RTEMS-6
Annotated Report
librfs
Sun Feb 28 23:05:05 2021
00107040 <rtems_rfs_bitmap_create_search>:
int
rtems_rfs_bitmap_create_search (rtems_rfs_bitmap_control* control)
{
107040: 55 push %ebp
107041: 89 e5 mov %esp,%ebp
107043: 57 push %edi
107044: 56 push %esi
107045: 53 push %ebx
107046: 83 ec 2c sub $0x2c,%esp
107049: 8b 5d 08 mov 0x8(%ebp),%ebx
if (!control->buffer)
10704c: 8b 03 mov (%ebx),%eax
10704e: 85 c0 test %eax,%eax
107050: 0f 84 0a 01 00 00 je 107160 <rtems_rfs_bitmap_create_search+0x120>
rc = rtems_rfs_buffer_handle_request (control->fs,
107056: ba 01 00 00 00 mov $0x1,%edx
10705b: 89 54 24 0c mov %edx,0xc(%esp)
10705f: 8b 53 08 mov 0x8(%ebx),%edx
107062: 89 44 24 04 mov %eax,0x4(%esp)
107066: 89 54 24 08 mov %edx,0x8(%esp)
10706a: 8b 43 04 mov 0x4(%ebx),%eax
10706d: 89 04 24 mov %eax,(%esp)
107070: e8 5b 05 00 00 call 1075d0 <rtems_rfs_buffer_handle_request>
if (rc)
107075: 85 c0 test %eax,%eax
107077: 0f 85 d3 00 00 00 jne 107150 <rtems_rfs_bitmap_create_search+0x110> <== NEVER TAKEN
*map = rtems_rfs_buffer_data (control->buffer);
10707d: 8b 03 mov (%ebx),%eax
10707f: 8b 40 08 mov 0x8(%eax),%eax
107082: 8b 40 1c mov 0x1c(%eax),%eax
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
control->free = 0;
107085: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx)
search_map = control->search_bits;
10708c: 8b 53 14 mov 0x14(%ebx),%edx
10708f: 89 55 dc mov %edx,-0x24(%ebp)
107092: 89 d6 mov %edx,%esi
size = control->size;
107094: 8b 53 0c mov 0xc(%ebx),%edx
bit = 0;
rtems_rfs_bitmap_check(control, search_map);
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
107097: c7 06 ff ff ff ff movl $0xffffffff,(%esi)
while (size)
10709d: 85 d2 test %edx,%edx
10709f: 74 35 je 1070d6 <rtems_rfs_bitmap_create_search+0x96> <== NEVER TAKEN
bit = 0;
1070a1: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
1070a8: 83 c0 04 add $0x4,%eax
{
rtems_rfs_bitmap_element bits;
int available;
if (size < rtems_rfs_bitmap_element_bits ())
1070ab: 83 fa 1f cmp $0x1f,%edx
1070ae: 89 45 e4 mov %eax,-0x1c(%ebp)
{
bits = rtems_rfs_bitmap_merge (*map,
1070b1: 8b 45 e4 mov -0x1c(%ebp),%eax
1070b4: 8b 40 fc mov -0x4(%eax),%eax
if (size < rtems_rfs_bitmap_element_bits ())
1070b7: 77 66 ja 10711f <rtems_rfs_bitmap_create_search+0xdf>
1070b9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
mask >>= (rtems_rfs_bitmap_element_bits () - size);
1070c0: b9 20 00 00 00 mov $0x20,%ecx
1070c5: be ff ff ff ff mov $0xffffffff,%esi
1070ca: 29 d1 sub %edx,%ecx
1070cc: d3 ee shr %cl,%esi
1070ce: 89 f1 mov %esi,%ecx
RTEMS_RFS_BITMAP_ELEMENT_SET,
rtems_rfs_bitmap_mask_section (0, size));
available = size;
1070d0: 89 d6 mov %edx,%esi
{
bits = *map;
available = rtems_rfs_bitmap_element_bits ();
}
if (rtems_rfs_bitmap_match (bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
1070d2: 21 c8 and %ecx,%eax
1070d4: 75 0a jne 1070e0 <rtems_rfs_bitmap_create_search+0xa0>
else
bit++;
map++;
}
return 0;
1070d6: 31 c0 xor %eax,%eax
}
1070d8: 83 c4 2c add $0x2c,%esp
1070db: 5b pop %ebx
1070dc: 5e pop %esi
1070dd: 5f pop %edi
1070de: 5d pop %ebp
1070df: c3 ret
if (rtems_rfs_bitmap_match (bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
1070e0: 31 d2 xor %edx,%edx
for (b = 0; b < available; b++)
1070e2: 31 c9 xor %ecx,%ecx
1070e4: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1070eb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
1070ef: 90 nop
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
1070f0: bf 01 00 00 00 mov $0x1,%edi
1070f5: d3 e7 shl %cl,%edi
if (!rtems_rfs_bitmap_test (bits, b))
1070f7: 85 c7 test %eax,%edi
1070f9: 74 03 je 1070fe <rtems_rfs_bitmap_create_search+0xbe>
control->free++;
1070fb: ff 43 10 incl 0x10(%ebx)
for (b = 0; b < available; b++)
1070fe: 41 inc %ecx
1070ff: 39 ce cmp %ecx,%esi
107101: 75 ed jne 1070f0 <rtems_rfs_bitmap_create_search+0xb0>
if (bit == (rtems_rfs_bitmap_element_bits () - 1))
107103: 83 7d e0 1f cmpl $0x1f,-0x20(%ebp)
107107: 74 27 je 107130 <rtems_rfs_bitmap_create_search+0xf0>
bit++;
107109: ff 45 e0 incl -0x20(%ebp)
while (size)
10710c: 85 d2 test %edx,%edx
10710e: 74 c6 je 1070d6 <rtems_rfs_bitmap_create_search+0x96>
if (size < rtems_rfs_bitmap_element_bits ())
107110: 83 45 e4 04 addl $0x4,-0x1c(%ebp)
107114: 83 fa 1f cmp $0x1f,%edx
bits = rtems_rfs_bitmap_merge (*map,
107117: 8b 45 e4 mov -0x1c(%ebp),%eax
10711a: 8b 40 fc mov -0x4(%eax),%eax
if (size < rtems_rfs_bitmap_element_bits ())
10711d: 76 a1 jbe 1070c0 <rtems_rfs_bitmap_create_search+0x80>
available = rtems_rfs_bitmap_element_bits ();
10711f: 83 ea 20 sub $0x20,%edx
if (rtems_rfs_bitmap_match (bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
107122: 85 c0 test %eax,%eax
107124: 74 dd je 107103 <rtems_rfs_bitmap_create_search+0xc3>
available = rtems_rfs_bitmap_element_bits ();
107126: be 20 00 00 00 mov $0x20,%esi
10712b: eb b5 jmp 1070e2 <rtems_rfs_bitmap_create_search+0xa2>
10712d: 8d 76 00 lea 0x0(%esi),%esi
if (size > 0)
107130: 85 d2 test %edx,%edx
107132: 74 a2 je 1070d6 <rtems_rfs_bitmap_create_search+0x96>
bit = 0;
107134: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
10713b: 8b 45 dc mov -0x24(%ebp),%eax
10713e: c7 40 04 ff ff ff ff movl $0xffffffff,0x4(%eax)
search_map++;
107145: 83 c0 04 add $0x4,%eax
107148: 89 45 dc mov %eax,-0x24(%ebp)
10714b: eb c3 jmp 107110 <rtems_rfs_bitmap_create_search+0xd0>
10714d: 8d 76 00 lea 0x0(%esi),%esi
if (rc > 0)
107150: 7f 86 jg 1070d8 <rtems_rfs_bitmap_create_search+0x98> <== NOT EXECUTED
*map = NULL;
107152: 31 c0 xor %eax,%eax <== NOT EXECUTED
107154: e9 2c ff ff ff jmp 107085 <rtems_rfs_bitmap_create_search+0x45> <== NOT EXECUTED
107159: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
}
107160: 83 c4 2c add $0x2c,%esp
return ENXIO;
107163: b8 06 00 00 00 mov $0x6,%eax
}
107168: 5b pop %ebx
107169: 5e pop %esi
10716a: 5f pop %edi
10716b: 5d pop %ebp
10716c: c3 ret
10716d: 90 nop
10716e: 90 nop
10716f: 90 nop
00106f70 <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)
{
106f70: 55 push %ebp
106f71: 89 e5 mov %esp,%ebp
106f73: 57 push %edi
106f74: 56 push %esi
106f75: 53 push %ebx
106f76: 83 ec 1c sub $0x1c,%esp
106f79: 8b 5d 0c mov 0xc(%ebp),%ebx
106f7c: 8b 4d 10 mov 0x10(%ebp),%ecx
106f7f: 8b 7d 08 mov 0x8(%ebp),%edi
106f82: 8b 55 14 mov 0x14(%ebp),%edx
* 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;
106f85: 89 de mov %ebx,%esi
*allocated = false;
106f87: c6 01 00 movb $0x0,(%ecx)
* 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))
106f8a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
106f90: 85 db test %ebx,%ebx
106f92: 78 4c js 106fe0 <rtems_rfs_bitmap_map_alloc+0x70>
106f94: 39 5f 0c cmp %ebx,0xc(%edi)
106f97: 76 47 jbe 106fe0 <rtems_rfs_bitmap_map_alloc+0x70>
/*
* Search up first so bits allocated in succession are grouped together.
*/
if (upper_seed < control->size)
{
*bit = upper_seed;
106f99: 89 1a mov %ebx,(%edx)
rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
106f9b: 89 f8 mov %edi,%eax
106f9d: c7 04 24 01 00 00 00 movl $0x1,(%esp)
106fa4: 89 4d 10 mov %ecx,0x10(%ebp)
106fa7: 89 55 14 mov %edx,0x14(%ebp)
106faa: e8 81 f5 ff ff call 106530 <rtems_rfs_search_map_for_clear_bit.constprop.0>
window, 1);
if ((rc > 0) || *allocated)
106faf: 85 c0 test %eax,%eax
106fb1: 7f 7d jg 107030 <rtems_rfs_bitmap_map_alloc+0xc0> <== NEVER TAKEN
106fb3: 8b 4d 10 mov 0x10(%ebp),%ecx
106fb6: 80 39 00 cmpb $0x0,(%ecx)
106fb9: 75 75 jne 107030 <rtems_rfs_bitmap_map_alloc+0xc0>
break;
}
if (lower_seed >= 0)
106fbb: 85 f6 test %esi,%esi
106fbd: 8b 55 14 mov 0x14(%ebp),%edx
106fc0: 79 2d jns 106fef <rtems_rfs_bitmap_map_alloc+0x7f>
/*
* 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)
106fc2: 3b 5f 0c cmp 0xc(%edi),%ebx
106fc5: 73 c9 jae 106f90 <rtems_rfs_bitmap_map_alloc+0x20> <== NEVER TAKEN
upper_seed += window;
106fc7: 81 c3 00 08 00 00 add $0x800,%ebx
while (((upper_seed >= 0) && (upper_seed < control->size))
106fcd: 85 db test %ebx,%ebx
106fcf: 79 c3 jns 106f94 <rtems_rfs_bitmap_map_alloc+0x24> <== ALWAYS TAKEN
106fd1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
106fd8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
106fdf: 90 nop
|| ((lower_seed >= 0) && (lower_seed < control->size)))
106fe0: 85 f6 test %esi,%esi
106fe2: 78 4c js 107030 <rtems_rfs_bitmap_map_alloc+0xc0>
106fe4: 8b 47 0c mov 0xc(%edi),%eax
106fe7: 39 f0 cmp %esi,%eax
106fe9: 76 45 jbe 107030 <rtems_rfs_bitmap_map_alloc+0xc0> <== NEVER TAKEN
if (upper_seed < control->size)
106feb: 39 c3 cmp %eax,%ebx
106fed: 72 aa jb 106f99 <rtems_rfs_bitmap_map_alloc+0x29> <== NEVER TAKEN
*bit = lower_seed;
106fef: 89 32 mov %esi,(%edx)
rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
106ff1: 89 f8 mov %edi,%eax
106ff3: c7 04 24 ff ff ff ff movl $0xffffffff,(%esp)
106ffa: 89 4d 10 mov %ecx,0x10(%ebp)
106ffd: 89 55 14 mov %edx,0x14(%ebp)
107000: e8 2b f5 ff ff call 106530 <rtems_rfs_search_map_for_clear_bit.constprop.0>
if ((rc > 0) || *allocated)
107005: 85 c0 test %eax,%eax
107007: 7f 27 jg 107030 <rtems_rfs_bitmap_map_alloc+0xc0> <== NEVER TAKEN
107009: 8b 4d 10 mov 0x10(%ebp),%ecx
10700c: 8b 55 14 mov 0x14(%ebp),%edx
10700f: 80 39 00 cmpb $0x0,(%ecx)
107012: 75 1c jne 107030 <rtems_rfs_bitmap_map_alloc+0xc0>
if (upper_seed < control->size)
107014: 3b 5f 0c cmp 0xc(%edi),%ebx
107017: 73 06 jae 10701f <rtems_rfs_bitmap_map_alloc+0xaf>
upper_seed += window;
107019: 81 c3 00 08 00 00 add $0x800,%ebx
if (lower_seed >= 0)
lower_seed -= window;
10701f: 81 ee 00 08 00 00 sub $0x800,%esi
107025: e9 66 ff ff ff jmp 106f90 <rtems_rfs_bitmap_map_alloc+0x20>
10702a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
}
return 0;
}
107030: 83 c4 1c add $0x1c,%esp
107033: 31 c0 xor %eax,%eax
107035: 5b pop %ebx
107036: 5e pop %esi
107037: 5f pop %edi
107038: 5d pop %ebp
107039: c3 ret
10703a: 90 nop
10703b: 90 nop
10703c: 90 nop
10703d: 90 nop
10703e: 90 nop
10703f: 90 nop
00106900 <rtems_rfs_bitmap_map_clear>:
{
106900: 55 push %ebp
106901: 89 e5 mov %esp,%ebp
106903: 83 ec 38 sub $0x38,%esp
106906: 89 5d f4 mov %ebx,-0xc(%ebp)
106909: 8b 5d 08 mov 0x8(%ebp),%ebx
10690c: 89 75 f8 mov %esi,-0x8(%ebp)
10690f: 89 7d fc mov %edi,-0x4(%ebp)
if (!control->buffer)
106912: 8b 03 mov (%ebx),%eax
106914: 85 c0 test %eax,%eax
106916: 0f 84 a4 00 00 00 je 1069c0 <rtems_rfs_bitmap_map_clear+0xc0>
rc = rtems_rfs_buffer_handle_request (control->fs,
10691c: ba 01 00 00 00 mov $0x1,%edx
106921: 89 54 24 0c mov %edx,0xc(%esp)
106925: 8b 53 08 mov 0x8(%ebx),%edx
106928: 89 44 24 04 mov %eax,0x4(%esp)
10692c: 89 54 24 08 mov %edx,0x8(%esp)
106930: 8b 43 04 mov 0x4(%ebx),%eax
106933: 89 04 24 mov %eax,(%esp)
106936: e8 95 0c 00 00 call 1075d0 <rtems_rfs_buffer_handle_request>
if (rc)
10693b: 85 c0 test %eax,%eax
10693d: 75 61 jne 1069a0 <rtems_rfs_bitmap_map_clear+0xa0> <== NEVER TAKEN
*map = rtems_rfs_buffer_data (control->buffer);
10693f: 8b 03 mov (%ebx),%eax
106941: 8b 40 08 mov 0x8(%eax),%eax
106944: 8b 50 1c mov 0x1c(%eax),%edx
if (bit >= control->size)
106947: 8b 45 0c mov 0xc(%ebp),%eax
10694a: 39 43 0c cmp %eax,0xc(%ebx)
10694d: 76 5d jbe 1069ac <rtems_rfs_bitmap_map_clear+0xac>
search_map = control->search_bits;
10694f: 8b 73 14 mov 0x14(%ebx),%esi
index = rtems_rfs_bitmap_map_index (bit);
106952: c1 f8 05 sar $0x5,%eax
element = map[index];
106955: 89 45 e0 mov %eax,-0x20(%ebp)
map[index] = rtems_rfs_bitmap_clear (element, 1 << offset);
106958: 0f b6 4d 0c movzbl 0xc(%ebp),%ecx
search_map = control->search_bits;
10695c: 89 75 e4 mov %esi,-0x1c(%ebp)
element = map[index];
10695f: 8d 34 82 lea (%edx,%eax,4),%esi
map[index] = rtems_rfs_bitmap_clear (element, 1 << offset);
106962: b8 01 00 00 00 mov $0x1,%eax
element = map[index];
106967: 8b 16 mov (%esi),%edx
map[index] = rtems_rfs_bitmap_clear (element, 1 << offset);
106969: 89 c7 mov %eax,%edi
10696b: d3 e7 shl %cl,%edi
10696d: 89 f9 mov %edi,%ecx
return RTEMS_RFS_BITMAP_CLEAR_BITS (target, bits);
10696f: 09 d1 or %edx,%ecx
map[index] = rtems_rfs_bitmap_clear (element, 1 << offset);
106971: 89 0e mov %ecx,(%esi)
if (rtems_rfs_bitmap_match(element, map[index]))
106973: 39 ca cmp %ecx,%edx
106975: 74 69 je 1069e0 <rtems_rfs_bitmap_map_clear+0xe0> <== NEVER TAKEN
index = rtems_rfs_bitmap_map_index (bit);
106977: 8b 55 0c mov 0xc(%ebp),%edx
search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset);
10697a: 0f b6 4d e0 movzbl -0x20(%ebp),%ecx
return RTEMS_RFS_BITMAP_CLEAR_BITS (target, bits);
10697e: 8b 75 e4 mov -0x1c(%ebp),%esi
index = rtems_rfs_bitmap_map_index (bit);
106981: c1 fa 0a sar $0xa,%edx
search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset);
106984: d3 e0 shl %cl,%eax
return RTEMS_RFS_BITMAP_CLEAR_BITS (target, bits);
106986: 09 04 96 or %eax,(%esi,%edx,4)
rtems_rfs_buffer_mark_dirty (control->buffer);
106989: 8b 03 mov (%ebx),%eax
10698b: c6 00 01 movb $0x1,(%eax)
return 0;
10698e: 31 c0 xor %eax,%eax
control->free++;
106990: ff 43 10 incl 0x10(%ebx)
}
106993: 8b 5d f4 mov -0xc(%ebp),%ebx
106996: 8b 75 f8 mov -0x8(%ebp),%esi
106999: 8b 7d fc mov -0x4(%ebp),%edi
10699c: 89 ec mov %ebp,%esp
10699e: 5d pop %ebp
10699f: c3 ret
if (rc > 0)
1069a0: 7f f1 jg 106993 <rtems_rfs_bitmap_map_clear+0x93> <== NOT EXECUTED
if (bit >= control->size)
1069a2: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
*map = NULL;
1069a5: 31 d2 xor %edx,%edx <== NOT EXECUTED
if (bit >= control->size)
1069a7: 39 43 0c cmp %eax,0xc(%ebx) <== NOT EXECUTED
1069aa: 77 a3 ja 10694f <rtems_rfs_bitmap_map_clear+0x4f> <== NOT EXECUTED
}
1069ac: 8b 5d f4 mov -0xc(%ebp),%ebx
return EINVAL;
1069af: b8 16 00 00 00 mov $0x16,%eax
}
1069b4: 8b 75 f8 mov -0x8(%ebp),%esi
1069b7: 8b 7d fc mov -0x4(%ebp),%edi
1069ba: 89 ec mov %ebp,%esp
1069bc: 5d pop %ebp
1069bd: c3 ret
1069be: 66 90 xchg %ax,%ax
1069c0: 8b 5d f4 mov -0xc(%ebp),%ebx
return ENXIO;
1069c3: b8 06 00 00 00 mov $0x6,%eax
}
1069c8: 8b 75 f8 mov -0x8(%ebp),%esi
1069cb: 8b 7d fc mov -0x4(%ebp),%edi
1069ce: 89 ec mov %ebp,%esp
1069d0: 5d pop %ebp
1069d1: c3 ret
1069d2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1069d9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
return 0;
1069e0: 31 c0 xor %eax,%eax
1069e2: eb af jmp 106993 <rtems_rfs_bitmap_map_clear+0x93> <== NOT EXECUTED
1069e4: 90 nop
1069e5: 90 nop
1069e6: 90 nop
1069e7: 90 nop
1069e8: 90 nop
1069e9: 90 nop
1069ea: 90 nop
1069eb: 90 nop
1069ec: 90 nop
1069ed: 90 nop
1069ee: 90 nop
1069ef: 90 nop
00106cc0 <rtems_rfs_bitmap_map_clear_all>:
{
106cc0: 55 push %ebp
106cc1: 89 e5 mov %esp,%ebp
106cc3: 57 push %edi
106cc4: 56 push %esi
106cc5: 53 push %ebx
106cc6: 83 ec 2c sub $0x2c,%esp
106cc9: 8b 5d 08 mov 0x8(%ebp),%ebx
if (!control->buffer)
106ccc: 8b 03 mov (%ebx),%eax
106cce: 85 c0 test %eax,%eax
106cd0: 0f 84 3a 02 00 00 je 106f10 <rtems_rfs_bitmap_map_clear_all+0x250>
rc = rtems_rfs_buffer_handle_request (control->fs,
106cd6: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED
106cdb: 89 54 24 0c mov %edx,0xc(%esp) <== NOT EXECUTED
106cdf: 8b 53 08 mov 0x8(%ebx),%edx <== NOT EXECUTED
106ce2: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
106ce6: 89 54 24 08 mov %edx,0x8(%esp) <== NOT EXECUTED
106cea: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED
106ced: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
106cf0: e8 db 08 00 00 call 1075d0 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc)
106cf5: 85 c0 test %eax,%eax
106cf7: 0f 85 f3 01 00 00 jne 106ef0 <rtems_rfs_bitmap_map_clear_all+0x230> <== NEVER TAKEN
*map = rtems_rfs_buffer_data (control->buffer);
106cfd: 8b 03 mov (%ebx),%eax
106cff: 89 45 e0 mov %eax,-0x20(%ebp)
106d02: 8b 40 08 mov 0x8(%eax),%eax
106d05: 8b 78 1c mov 0x1c(%eax),%edi
elements = rtems_rfs_bitmap_elements (control->size);
106d08: 8b 43 0c mov 0xc(%ebx),%eax
control->free = control->size;
106d0b: 89 43 10 mov %eax,0x10(%ebx)
elements = rtems_rfs_bitmap_elements (control->size);
106d0e: 8d 48 ff lea -0x1(%eax),%ecx
106d11: 89 4d dc mov %ecx,-0x24(%ebp)
106d14: 89 ce mov %ecx,%esi
106d16: c1 ee 05 shr $0x5,%esi
106d19: 46 inc %esi
map[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
106d1a: 8d 14 b5 00 00 00 00 lea 0x0(,%esi,4),%edx
106d21: 83 fa 08 cmp $0x8,%edx
106d24: 0f 83 36 01 00 00 jae 106e60 <rtems_rfs_bitmap_map_clear_all+0x1a0> <== ALWAYS TAKEN
106d2a: f6 c2 04 test $0x4,%dl <== NOT EXECUTED
106d2d: 0f 85 bd 00 00 00 jne 106df0 <rtems_rfs_bitmap_map_clear_all+0x130> <== NOT EXECUTED
106d33: f6 c2 02 test $0x2,%dl
106d36: 0f 85 94 00 00 00 jne 106dd0 <rtems_rfs_bitmap_map_clear_all+0x110> <== NEVER TAKEN
106d3c: f6 c2 01 test $0x1,%dl
106d3f: 90 nop
106d40: 75 6e jne 106db0 <rtems_rfs_bitmap_map_clear_all+0xf0> <== NEVER TAKEN
if (last_search_bit == 0)
106d42: b8 ff ff ff ff mov $0xffffffff,%eax
106d47: 83 e6 1f and $0x1f,%esi
106d4a: 89 45 e4 mov %eax,-0x1c(%ebp)
106d4d: 75 51 jne 106da0 <rtems_rfs_bitmap_map_clear_all+0xe0>
for (e = 0; e < (elements - 1); e++)
106d4f: 8b 75 dc mov -0x24(%ebp),%esi
control->search_bits[elements - 1] =
106d52: 8b 5b 14 mov 0x14(%ebx),%ebx
for (e = 0; e < (elements - 1); e++)
106d55: c1 ee 0a shr $0xa,%esi
106d58: 74 2d je 106d87 <rtems_rfs_bitmap_map_clear_all+0xc7>
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
106d5a: 8d 14 b5 00 00 00 00 lea 0x0(,%esi,4),%edx
106d61: 89 df mov %ebx,%edi
106d63: 83 fa 08 cmp $0x8,%edx
106d66: 0f 83 44 01 00 00 jae 106eb0 <rtems_rfs_bitmap_map_clear_all+0x1f0>
106d6c: f6 c2 04 test $0x4,%dl
106d6f: 0f 85 cb 00 00 00 jne 106e40 <rtems_rfs_bitmap_map_clear_all+0x180> <== ALWAYS TAKEN
106d75: f6 c2 02 test $0x2,%dl
106d78: 0f 85 a2 00 00 00 jne 106e20 <rtems_rfs_bitmap_map_clear_all+0x160> <== NEVER TAKEN
106d7e: f6 c2 01 test $0x1,%dl
106d81: 0f 85 89 00 00 00 jne 106e10 <rtems_rfs_bitmap_map_clear_all+0x150> <== NEVER TAKEN
control->search_bits[elements - 1] =
106d87: 8b 45 e4 mov -0x1c(%ebp),%eax
106d8a: 89 04 b3 mov %eax,(%ebx,%esi,4)
rtems_rfs_buffer_mark_dirty (control->buffer);
106d8d: 8b 45 e0 mov -0x20(%ebp),%eax
106d90: c6 00 01 movb $0x1,(%eax)
return 0;
106d93: 31 c0 xor %eax,%eax
}
106d95: 83 c4 2c add $0x2c,%esp
106d98: 5b pop %ebx
106d99: 5e pop %esi
106d9a: 5f pop %edi
106d9b: 5d pop %ebp
106d9c: c3 ret
106d9d: 8d 76 00 lea 0x0(%esi),%esi
mask >>= (rtems_rfs_bitmap_element_bits () - size);
106da0: b9 20 00 00 00 mov $0x20,%ecx
106da5: 29 f1 sub %esi,%ecx
106da7: d3 e8 shr %cl,%eax
106da9: 89 45 e4 mov %eax,-0x1c(%ebp)
106dac: eb a1 jmp 106d4f <rtems_rfs_bitmap_map_clear_all+0x8f>
106dae: 66 90 xchg %ax,%ax
map[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
106db0: c6 07 ff movb $0xff,(%edi) <== NOT EXECUTED
if (last_search_bit == 0)
106db3: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
106db8: 83 e6 1f and $0x1f,%esi <== NOT EXECUTED
106dbb: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED
106dbe: 74 8f je 106d4f <rtems_rfs_bitmap_map_clear_all+0x8f> <== NOT EXECUTED
106dc0: eb de jmp 106da0 <rtems_rfs_bitmap_map_clear_all+0xe0> <== NOT EXECUTED
106dc2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
106dc9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
map[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
106dd0: 66 c7 07 ff ff movw $0xffff,(%edi) <== NOT EXECUTED
106dd5: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
106dd8: f6 c2 01 test $0x1,%dl <== NOT EXECUTED
106ddb: 0f 84 61 ff ff ff je 106d42 <rtems_rfs_bitmap_map_clear_all+0x82> <== NOT EXECUTED
106de1: eb cd jmp 106db0 <rtems_rfs_bitmap_map_clear_all+0xf0> <== NOT EXECUTED
106de3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
106dea: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
106df0: c7 07 ff ff ff ff movl $0xffffffff,(%edi) <== NOT EXECUTED
106df6: 83 c7 04 add $0x4,%edi <== NOT EXECUTED
106df9: f6 c2 02 test $0x2,%dl <== NOT EXECUTED
106dfc: 0f 84 3a ff ff ff je 106d3c <rtems_rfs_bitmap_map_clear_all+0x7c> <== NOT EXECUTED
106e02: eb cc jmp 106dd0 <rtems_rfs_bitmap_map_clear_all+0x110> <== NOT EXECUTED
106e04: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
106e0b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
106e0f: 90 nop <== NOT EXECUTED
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
106e10: c6 07 ff movb $0xff,(%edi) <== NOT EXECUTED
106e13: e9 6f ff ff ff jmp 106d87 <rtems_rfs_bitmap_map_clear_all+0xc7> <== NOT EXECUTED
106e18: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
106e1f: 90 nop <== NOT EXECUTED
106e20: 66 c7 07 ff ff movw $0xffff,(%edi) <== NOT EXECUTED
106e25: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
106e28: f6 c2 01 test $0x1,%dl <== NOT EXECUTED
106e2b: 0f 84 56 ff ff ff je 106d87 <rtems_rfs_bitmap_map_clear_all+0xc7> <== NOT EXECUTED
106e31: eb dd jmp 106e10 <rtems_rfs_bitmap_map_clear_all+0x150> <== NOT EXECUTED
106e33: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
106e3a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
106e40: c7 07 ff ff ff ff movl $0xffffffff,(%edi)
106e46: 83 c7 04 add $0x4,%edi
106e49: f6 c2 02 test $0x2,%dl
106e4c: 0f 84 2c ff ff ff je 106d7e <rtems_rfs_bitmap_map_clear_all+0xbe> <== ALWAYS TAKEN
106e52: eb cc jmp 106e20 <rtems_rfs_bitmap_map_clear_all+0x160> <== NOT EXECUTED
106e54: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
106e5b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
106e5f: 90 nop <== NOT EXECUTED
map[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
106e60: f7 c7 01 00 00 00 test $0x1,%edi
106e66: 0f 85 f9 00 00 00 jne 106f65 <rtems_rfs_bitmap_map_clear_all+0x2a5> <== NEVER TAKEN
106e6c: f7 c7 02 00 00 00 test $0x2,%edi
106e72: 0f 85 cc 00 00 00 jne 106f44 <rtems_rfs_bitmap_map_clear_all+0x284> <== NEVER TAKEN
106e78: f7 c7 04 00 00 00 test $0x4,%edi
106e7e: 0f 85 d0 00 00 00 jne 106f54 <rtems_rfs_bitmap_map_clear_all+0x294> <== NEVER TAKEN
106e84: 89 d1 mov %edx,%ecx
106e86: 83 e2 03 and $0x3,%edx
106e89: c1 e9 02 shr $0x2,%ecx
106e8c: b8 ff ff ff ff mov $0xffffffff,%eax
106e91: f3 ab rep stos %eax,%es:(%edi)
106e93: f6 c2 04 test $0x4,%dl
106e96: 0f 84 97 fe ff ff je 106d33 <rtems_rfs_bitmap_map_clear_all+0x73> <== ALWAYS TAKEN
106e9c: e9 4f ff ff ff jmp 106df0 <rtems_rfs_bitmap_map_clear_all+0x130> <== NOT EXECUTED
106ea1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
106ea8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
106eaf: 90 nop <== NOT EXECUTED
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
106eb0: f6 c3 01 test $0x1,%bl
106eb3: 75 76 jne 106f2b <rtems_rfs_bitmap_map_clear_all+0x26b> <== NEVER TAKEN
106eb5: f7 c7 02 00 00 00 test $0x2,%edi
106ebb: 75 77 jne 106f34 <rtems_rfs_bitmap_map_clear_all+0x274> <== NEVER TAKEN
106ebd: f7 c7 04 00 00 00 test $0x4,%edi
106ec3: 75 58 jne 106f1d <rtems_rfs_bitmap_map_clear_all+0x25d> <== NEVER TAKEN
106ec5: 89 d1 mov %edx,%ecx
106ec7: 83 e2 03 and $0x3,%edx
106eca: c1 e9 02 shr $0x2,%ecx
106ecd: b8 ff ff ff ff mov $0xffffffff,%eax
106ed2: f3 ab rep stos %eax,%es:(%edi)
106ed4: f6 c2 04 test $0x4,%dl
106ed7: 0f 84 98 fe ff ff je 106d75 <rtems_rfs_bitmap_map_clear_all+0xb5> <== ALWAYS TAKEN
106edd: e9 5e ff ff ff jmp 106e40 <rtems_rfs_bitmap_map_clear_all+0x180> <== NOT EXECUTED
106ee2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
106ee9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
if (rc > 0)
106ef0: 0f 8f 9f fe ff ff jg 106d95 <rtems_rfs_bitmap_map_clear_all+0xd5> <== NOT EXECUTED
*map = rtems_rfs_buffer_data (control->buffer);
106ef6: 8b 03 mov (%ebx),%eax <== NOT EXECUTED
*map = NULL;
106ef8: 31 ff xor %edi,%edi <== NOT EXECUTED
*map = rtems_rfs_buffer_data (control->buffer);
106efa: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED
106efd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
106f00: e9 03 fe ff ff jmp 106d08 <rtems_rfs_bitmap_map_clear_all+0x48> <== NOT EXECUTED
106f05: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
106f0c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
}
106f10: 83 c4 2c add $0x2c,%esp
return ENXIO;
106f13: b8 06 00 00 00 mov $0x6,%eax
}
106f18: 5b pop %ebx
106f19: 5e pop %esi
106f1a: 5f pop %edi
106f1b: 5d pop %ebp
106f1c: c3 ret
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
106f1d: c7 07 ff ff ff ff movl $0xffffffff,(%edi) <== NOT EXECUTED
106f23: 83 ea 04 sub $0x4,%edx <== NOT EXECUTED
106f26: 83 c7 04 add $0x4,%edi <== NOT EXECUTED
106f29: eb 9a jmp 106ec5 <rtems_rfs_bitmap_map_clear_all+0x205> <== NOT EXECUTED
106f2b: c6 03 ff movb $0xff,(%ebx) <== NOT EXECUTED
106f2e: 8d 7b 01 lea 0x1(%ebx),%edi <== NOT EXECUTED
106f31: 4a dec %edx <== NOT EXECUTED
106f32: eb 81 jmp 106eb5 <rtems_rfs_bitmap_map_clear_all+0x1f5> <== NOT EXECUTED
106f34: 66 c7 07 ff ff movw $0xffff,(%edi) <== NOT EXECUTED
106f39: 83 ea 02 sub $0x2,%edx <== NOT EXECUTED
106f3c: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
106f3f: e9 79 ff ff ff jmp 106ebd <rtems_rfs_bitmap_map_clear_all+0x1fd> <== NOT EXECUTED
map[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
106f44: 66 c7 07 ff ff movw $0xffff,(%edi) <== NOT EXECUTED
106f49: 83 ea 02 sub $0x2,%edx <== NOT EXECUTED
106f4c: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
106f4f: e9 24 ff ff ff jmp 106e78 <rtems_rfs_bitmap_map_clear_all+0x1b8> <== NOT EXECUTED
106f54: c7 07 ff ff ff ff movl $0xffffffff,(%edi) <== NOT EXECUTED
106f5a: 83 ea 04 sub $0x4,%edx <== NOT EXECUTED
106f5d: 83 c7 04 add $0x4,%edi <== NOT EXECUTED
106f60: e9 1f ff ff ff jmp 106e84 <rtems_rfs_bitmap_map_clear_all+0x1c4> <== NOT EXECUTED
106f65: c6 07 ff movb $0xff,(%edi) <== NOT EXECUTED
106f68: 4a dec %edx <== NOT EXECUTED
106f69: 47 inc %edi <== NOT EXECUTED
106f6a: e9 fd fe ff ff jmp 106e6c <rtems_rfs_bitmap_map_clear_all+0x1ac> <== NOT EXECUTED
106f6f: 90 nop
00106800 <rtems_rfs_bitmap_map_set>:
{
106800: 55 push %ebp
106801: 89 e5 mov %esp,%ebp
106803: 83 ec 38 sub $0x38,%esp
106806: 89 5d f4 mov %ebx,-0xc(%ebp)
106809: 8b 5d 08 mov 0x8(%ebp),%ebx
10680c: 89 75 f8 mov %esi,-0x8(%ebp)
10680f: 89 7d fc mov %edi,-0x4(%ebp)
if (!control->buffer)
106812: 8b 03 mov (%ebx),%eax
106814: 85 c0 test %eax,%eax
106816: 0f 84 c4 00 00 00 je 1068e0 <rtems_rfs_bitmap_map_set+0xe0>
rc = rtems_rfs_buffer_handle_request (control->fs,
10681c: ba 01 00 00 00 mov $0x1,%edx
106821: 89 54 24 0c mov %edx,0xc(%esp)
106825: 8b 53 08 mov 0x8(%ebx),%edx
106828: 89 44 24 04 mov %eax,0x4(%esp)
10682c: 89 54 24 08 mov %edx,0x8(%esp)
106830: 8b 43 04 mov 0x4(%ebx),%eax
106833: 89 04 24 mov %eax,(%esp)
106836: e8 95 0d 00 00 call 1075d0 <rtems_rfs_buffer_handle_request>
if (rc)
10683b: 85 c0 test %eax,%eax
10683d: 75 61 jne 1068a0 <rtems_rfs_bitmap_map_set+0xa0> <== NEVER TAKEN
*map = rtems_rfs_buffer_data (control->buffer);
10683f: 8b 03 mov (%ebx),%eax
106841: 8b 40 08 mov 0x8(%eax),%eax
106844: 8b 50 1c mov 0x1c(%eax),%edx
if (bit >= control->size)
106847: 8b 45 0c mov 0xc(%ebp),%eax
10684a: 39 43 0c cmp %eax,0xc(%ebx)
10684d: 76 5d jbe 1068ac <rtems_rfs_bitmap_map_set+0xac>
search_map = control->search_bits;
10684f: 8b 43 14 mov 0x14(%ebx),%eax
map[index] = rtems_rfs_bitmap_set (element, 1 << offset);
106852: 0f b6 4d 0c movzbl 0xc(%ebp),%ecx
search_map = control->search_bits;
106856: 89 45 e4 mov %eax,-0x1c(%ebp)
index = rtems_rfs_bitmap_map_index (bit);
106859: 8b 45 0c mov 0xc(%ebp),%eax
10685c: c1 f8 05 sar $0x5,%eax
10685f: 89 45 e0 mov %eax,-0x20(%ebp)
element = map[index];
106862: 8d 3c 82 lea (%edx,%eax,4),%edi
map[index] = rtems_rfs_bitmap_set (element, 1 << offset);
106865: ba 01 00 00 00 mov $0x1,%edx
element = map[index];
10686a: 8b 37 mov (%edi),%esi
map[index] = rtems_rfs_bitmap_set (element, 1 << offset);
10686c: 89 d0 mov %edx,%eax
10686e: d3 e0 shl %cl,%eax
106870: 89 c1 mov %eax,%ecx
return RTEMS_RFS_BITMAP_SET_BITS (target, bits);
106872: f7 d1 not %ecx
106874: 21 f1 and %esi,%ecx
map[index] = rtems_rfs_bitmap_set (element, 1 << offset);
106876: 89 0f mov %ecx,(%edi)
if (rtems_rfs_bitmap_match(element, map[index]))
106878: 39 ce cmp %ecx,%esi
10687a: 74 0c je 106888 <rtems_rfs_bitmap_map_set+0x88>
control->free--;
10687c: ff 4b 10 decl 0x10(%ebx)
if (rtems_rfs_bitmap_match(map[index], RTEMS_RFS_BITMAP_ELEMENT_SET))
10687f: 85 c9 test %ecx,%ecx
rtems_rfs_buffer_mark_dirty (control->buffer);
106881: 8b 1b mov (%ebx),%ebx
106883: c6 03 01 movb $0x1,(%ebx)
if (rtems_rfs_bitmap_match(map[index], RTEMS_RFS_BITMAP_ELEMENT_SET))
106886: 74 38 je 1068c0 <rtems_rfs_bitmap_map_set+0xc0>
return 0;
106888: 31 c0 xor %eax,%eax
}
10688a: 8b 5d f4 mov -0xc(%ebp),%ebx
10688d: 8b 75 f8 mov -0x8(%ebp),%esi
106890: 8b 7d fc mov -0x4(%ebp),%edi
106893: 89 ec mov %ebp,%esp
106895: 5d pop %ebp
106896: c3 ret
106897: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10689e: 66 90 xchg %ax,%ax
if (rc > 0)
1068a0: 7f e8 jg 10688a <rtems_rfs_bitmap_map_set+0x8a> <== NOT EXECUTED
if (bit >= control->size)
1068a2: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
*map = NULL;
1068a5: 31 d2 xor %edx,%edx <== NOT EXECUTED
if (bit >= control->size)
1068a7: 39 43 0c cmp %eax,0xc(%ebx) <== NOT EXECUTED
1068aa: 77 a3 ja 10684f <rtems_rfs_bitmap_map_set+0x4f> <== NOT EXECUTED
}
1068ac: 8b 5d f4 mov -0xc(%ebp),%ebx
return EINVAL;
1068af: b8 16 00 00 00 mov $0x16,%eax
}
1068b4: 8b 75 f8 mov -0x8(%ebp),%esi
1068b7: 8b 7d fc mov -0x4(%ebp),%edi
1068ba: 89 ec mov %ebp,%esp
1068bc: 5d pop %ebp
1068bd: c3 ret
1068be: 66 90 xchg %ax,%ax
search_map[index] = rtems_rfs_bitmap_set (search_map[index], 1 << offset);
1068c0: 0f b6 4d e0 movzbl -0x20(%ebp),%ecx
index = rtems_rfs_bitmap_map_index (bit);
1068c4: 8b 5d 0c mov 0xc(%ebp),%ebx
return RTEMS_RFS_BITMAP_SET_BITS (target, bits);
1068c7: 8b 45 e4 mov -0x1c(%ebp),%eax
search_map[index] = rtems_rfs_bitmap_set (search_map[index], 1 << offset);
1068ca: d3 e2 shl %cl,%edx
index = rtems_rfs_bitmap_map_index (bit);
1068cc: c1 fb 0a sar $0xa,%ebx
return RTEMS_RFS_BITMAP_SET_BITS (target, bits);
1068cf: f7 d2 not %edx
1068d1: 21 14 98 and %edx,(%eax,%ebx,4)
1068d4: eb b2 jmp 106888 <rtems_rfs_bitmap_map_set+0x88>
1068d6: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1068dd: 8d 76 00 lea 0x0(%esi),%esi
}
1068e0: 8b 5d f4 mov -0xc(%ebp),%ebx
return ENXIO;
1068e3: b8 06 00 00 00 mov $0x6,%eax
}
1068e8: 8b 75 f8 mov -0x8(%ebp),%esi
1068eb: 8b 7d fc mov -0x4(%ebp),%edi
1068ee: 89 ec mov %ebp,%esp
1068f0: 5d pop %ebp
1068f1: c3 ret
1068f2: 90 nop
1068f3: 90 nop
1068f4: 90 nop
1068f5: 90 nop
1068f6: 90 nop
1068f7: 90 nop
1068f8: 90 nop
1068f9: 90 nop
1068fa: 90 nop
1068fb: 90 nop
1068fc: 90 nop
1068fd: 90 nop
1068fe: 90 nop
1068ff: 90 nop
00106a90 <rtems_rfs_bitmap_map_set_all>:
{
106a90: 55 push %ebp
106a91: 89 e5 mov %esp,%ebp
106a93: 57 push %edi
106a94: 56 push %esi
106a95: 53 push %ebx
106a96: 83 ec 2c sub $0x2c,%esp
106a99: 8b 5d 08 mov 0x8(%ebp),%ebx
if (!control->buffer)
106a9c: 8b 03 mov (%ebx),%eax
106a9e: 85 c0 test %eax,%eax
106aa0: 0f 84 ba 01 00 00 je 106c60 <rtems_rfs_bitmap_map_set_all+0x1d0>
rc = rtems_rfs_buffer_handle_request (control->fs,
106aa6: ba 01 00 00 00 mov $0x1,%edx
106aab: 89 54 24 0c mov %edx,0xc(%esp)
106aaf: 8b 53 08 mov 0x8(%ebx),%edx
106ab2: 89 44 24 04 mov %eax,0x4(%esp)
106ab6: 89 54 24 08 mov %edx,0x8(%esp)
106aba: 8b 43 04 mov 0x4(%ebx),%eax
106abd: 89 04 24 mov %eax,(%esp)
106ac0: e8 0b 0b 00 00 call 1075d0 <rtems_rfs_buffer_handle_request>
if (rc)
106ac5: 85 c0 test %eax,%eax
106ac7: 0f 85 73 01 00 00 jne 106c40 <rtems_rfs_bitmap_map_set_all+0x1b0> <== NEVER TAKEN
*map = rtems_rfs_buffer_data (control->buffer);
106acd: 8b 33 mov (%ebx),%esi
106acf: 8b 46 08 mov 0x8(%esi),%eax
106ad2: 8b 78 1c mov 0x1c(%eax),%edi
control->free = 0;
106ad5: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx)
elements = rtems_rfs_bitmap_elements (control->size);
106adc: 8b 43 0c mov 0xc(%ebx),%eax
106adf: 48 dec %eax
106ae0: 89 45 e4 mov %eax,-0x1c(%ebp)
106ae3: c1 e8 05 shr $0x5,%eax
map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
106ae6: 8d 14 85 04 00 00 00 lea 0x4(,%eax,4),%edx
106aed: 83 fa 08 cmp $0x8,%edx
106af0: 0f 83 0a 01 00 00 jae 106c00 <rtems_rfs_bitmap_map_set_all+0x170> <== ALWAYS TAKEN
106af6: f6 c2 04 test $0x4,%dl <== NOT EXECUTED
106af9: 0f 85 a1 00 00 00 jne 106ba0 <rtems_rfs_bitmap_map_set_all+0x110> <== NOT EXECUTED
106aff: f6 c2 02 test $0x2,%dl
106b02: 75 7c jne 106b80 <rtems_rfs_bitmap_map_set_all+0xf0> <== NEVER TAKEN
106b04: f6 c2 01 test $0x1,%dl
106b07: 75 67 jne 106b70 <rtems_rfs_bitmap_map_set_all+0xe0> <== NEVER TAKEN
elements = rtems_rfs_bitmap_elements (elements);
106b09: 8b 45 e4 mov -0x1c(%ebp),%eax
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
106b0c: 8b 7b 14 mov 0x14(%ebx),%edi
elements = rtems_rfs_bitmap_elements (elements);
106b0f: c1 e8 0a shr $0xa,%eax
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
106b12: 8d 14 85 04 00 00 00 lea 0x4(,%eax,4),%edx
106b19: 83 fa 08 cmp $0x8,%edx
106b1c: 0f 83 9e 00 00 00 jae 106bc0 <rtems_rfs_bitmap_map_set_all+0x130>
106b22: f6 c2 04 test $0x4,%dl
106b25: 75 39 jne 106b60 <rtems_rfs_bitmap_map_set_all+0xd0> <== ALWAYS TAKEN
106b27: f6 c2 02 test $0x2,%dl
106b2a: 75 24 jne 106b50 <rtems_rfs_bitmap_map_set_all+0xc0> <== NEVER TAKEN
106b2c: f6 c2 01 test $0x1,%dl
106b2f: 90 nop
106b30: 75 0e jne 106b40 <rtems_rfs_bitmap_map_set_all+0xb0> <== NEVER TAKEN
rtems_rfs_buffer_mark_dirty (control->buffer);
106b32: c6 06 01 movb $0x1,(%esi)
return 0;
106b35: 31 c0 xor %eax,%eax
}
106b37: 83 c4 2c add $0x2c,%esp
106b3a: 5b pop %ebx
106b3b: 5e pop %esi
106b3c: 5f pop %edi
106b3d: 5d pop %ebp
106b3e: c3 ret
106b3f: 90 nop
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
106b40: c6 07 00 movb $0x0,(%edi) <== NOT EXECUTED
106b43: eb ed jmp 106b32 <rtems_rfs_bitmap_map_set_all+0xa2> <== NOT EXECUTED
106b45: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
106b4c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
106b50: 66 c7 07 00 00 movw $0x0,(%edi) <== NOT EXECUTED
106b55: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
106b58: f6 c2 01 test $0x1,%dl <== NOT EXECUTED
106b5b: 74 d5 je 106b32 <rtems_rfs_bitmap_map_set_all+0xa2> <== NOT EXECUTED
106b5d: eb e1 jmp 106b40 <rtems_rfs_bitmap_map_set_all+0xb0> <== NOT EXECUTED
106b5f: 90 nop <== NOT EXECUTED
106b60: c7 07 00 00 00 00 movl $0x0,(%edi)
106b66: 83 c7 04 add $0x4,%edi
106b69: f6 c2 02 test $0x2,%dl
106b6c: 74 be je 106b2c <rtems_rfs_bitmap_map_set_all+0x9c> <== ALWAYS TAKEN
106b6e: eb e0 jmp 106b50 <rtems_rfs_bitmap_map_set_all+0xc0> <== NOT EXECUTED
map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
106b70: c6 07 00 movb $0x0,(%edi) <== NOT EXECUTED
106b73: eb 94 jmp 106b09 <rtems_rfs_bitmap_map_set_all+0x79> <== NOT EXECUTED
106b75: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
106b7c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
106b80: 66 c7 07 00 00 movw $0x0,(%edi) <== NOT EXECUTED
106b85: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
106b88: f6 c2 01 test $0x1,%dl <== NOT EXECUTED
106b8b: 0f 84 78 ff ff ff je 106b09 <rtems_rfs_bitmap_map_set_all+0x79> <== NOT EXECUTED
106b91: eb dd jmp 106b70 <rtems_rfs_bitmap_map_set_all+0xe0> <== NOT EXECUTED
106b93: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
106b9a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
106ba0: c7 07 00 00 00 00 movl $0x0,(%edi) <== NOT EXECUTED
106ba6: 83 c7 04 add $0x4,%edi <== NOT EXECUTED
106ba9: f6 c2 02 test $0x2,%dl <== NOT EXECUTED
106bac: 0f 84 52 ff ff ff je 106b04 <rtems_rfs_bitmap_map_set_all+0x74> <== NOT EXECUTED
106bb2: eb cc jmp 106b80 <rtems_rfs_bitmap_map_set_all+0xf0> <== NOT EXECUTED
106bb4: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
106bbb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
106bbf: 90 nop <== NOT EXECUTED
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
106bc0: f7 c7 01 00 00 00 test $0x1,%edi
106bc6: 0f 85 cf 00 00 00 jne 106c9b <rtems_rfs_bitmap_map_set_all+0x20b> <== NEVER TAKEN
106bcc: f7 c7 02 00 00 00 test $0x2,%edi
106bd2: 0f 85 a2 00 00 00 jne 106c7a <rtems_rfs_bitmap_map_set_all+0x1ea> <== NEVER TAKEN
106bd8: f7 c7 04 00 00 00 test $0x4,%edi
106bde: 0f 85 a6 00 00 00 jne 106c8a <rtems_rfs_bitmap_map_set_all+0x1fa> <== NEVER TAKEN
106be4: 89 d1 mov %edx,%ecx
106be6: 83 e2 03 and $0x3,%edx
106be9: c1 e9 02 shr $0x2,%ecx
106bec: 31 c0 xor %eax,%eax
106bee: f3 ab rep stos %eax,%es:(%edi)
106bf0: f6 c2 04 test $0x4,%dl
106bf3: 0f 84 2e ff ff ff je 106b27 <rtems_rfs_bitmap_map_set_all+0x97> <== ALWAYS TAKEN
106bf9: e9 62 ff ff ff jmp 106b60 <rtems_rfs_bitmap_map_set_all+0xd0> <== NOT EXECUTED
106bfe: 66 90 xchg %ax,%ax <== NOT EXECUTED
map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
106c00: f7 c7 01 00 00 00 test $0x1,%edi
106c06: 0f 85 aa 00 00 00 jne 106cb6 <rtems_rfs_bitmap_map_set_all+0x226> <== NEVER TAKEN
106c0c: f7 c7 02 00 00 00 test $0x2,%edi
106c12: 75 59 jne 106c6d <rtems_rfs_bitmap_map_set_all+0x1dd> <== NEVER TAKEN
106c14: f7 c7 04 00 00 00 test $0x4,%edi
106c1a: 0f 85 85 00 00 00 jne 106ca5 <rtems_rfs_bitmap_map_set_all+0x215> <== NEVER TAKEN
106c20: 89 d1 mov %edx,%ecx
106c22: 83 e2 03 and $0x3,%edx
106c25: c1 e9 02 shr $0x2,%ecx
106c28: 31 c0 xor %eax,%eax
106c2a: f3 ab rep stos %eax,%es:(%edi)
106c2c: f6 c2 04 test $0x4,%dl
106c2f: 0f 84 ca fe ff ff je 106aff <rtems_rfs_bitmap_map_set_all+0x6f> <== ALWAYS TAKEN
106c35: e9 66 ff ff ff jmp 106ba0 <rtems_rfs_bitmap_map_set_all+0x110> <== NOT EXECUTED
106c3a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
if (rc > 0)
106c40: 0f 8f f1 fe ff ff jg 106b37 <rtems_rfs_bitmap_map_set_all+0xa7> <== NOT EXECUTED
*map = rtems_rfs_buffer_data (control->buffer);
106c46: 8b 33 mov (%ebx),%esi <== NOT EXECUTED
*map = NULL;
106c48: 31 ff xor %edi,%edi <== NOT EXECUTED
106c4a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
106c50: e9 80 fe ff ff jmp 106ad5 <rtems_rfs_bitmap_map_set_all+0x45> <== NOT EXECUTED
106c55: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
106c5c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
}
106c60: 83 c4 2c add $0x2c,%esp
return ENXIO;
106c63: b8 06 00 00 00 mov $0x6,%eax
}
106c68: 5b pop %ebx
106c69: 5e pop %esi
106c6a: 5f pop %edi
106c6b: 5d pop %ebp
106c6c: c3 ret
map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
106c6d: 66 c7 07 00 00 movw $0x0,(%edi) <== NOT EXECUTED
106c72: 83 ea 02 sub $0x2,%edx <== NOT EXECUTED
106c75: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
106c78: eb 9a jmp 106c14 <rtems_rfs_bitmap_map_set_all+0x184> <== NOT EXECUTED
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
106c7a: 66 c7 07 00 00 movw $0x0,(%edi) <== NOT EXECUTED
106c7f: 83 ea 02 sub $0x2,%edx <== NOT EXECUTED
106c82: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
106c85: e9 4e ff ff ff jmp 106bd8 <rtems_rfs_bitmap_map_set_all+0x148> <== NOT EXECUTED
106c8a: c7 07 00 00 00 00 movl $0x0,(%edi) <== NOT EXECUTED
106c90: 83 ea 04 sub $0x4,%edx <== NOT EXECUTED
106c93: 83 c7 04 add $0x4,%edi <== NOT EXECUTED
106c96: e9 49 ff ff ff jmp 106be4 <rtems_rfs_bitmap_map_set_all+0x154> <== NOT EXECUTED
106c9b: c6 07 00 movb $0x0,(%edi) <== NOT EXECUTED
106c9e: 4a dec %edx <== NOT EXECUTED
106c9f: 47 inc %edi <== NOT EXECUTED
106ca0: e9 27 ff ff ff jmp 106bcc <rtems_rfs_bitmap_map_set_all+0x13c> <== NOT EXECUTED
map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
106ca5: c7 07 00 00 00 00 movl $0x0,(%edi) <== NOT EXECUTED
106cab: 83 ea 04 sub $0x4,%edx <== NOT EXECUTED
106cae: 83 c7 04 add $0x4,%edi <== NOT EXECUTED
106cb1: e9 6a ff ff ff jmp 106c20 <rtems_rfs_bitmap_map_set_all+0x190> <== NOT EXECUTED
106cb6: c6 07 00 movb $0x0,(%edi) <== NOT EXECUTED
106cb9: 4a dec %edx <== NOT EXECUTED
106cba: 47 inc %edi <== NOT EXECUTED
106cbb: e9 4c ff ff ff jmp 106c0c <rtems_rfs_bitmap_map_set_all+0x17c> <== NOT EXECUTED
001069f0 <rtems_rfs_bitmap_map_test>:
{
1069f0: 55 push %ebp
1069f1: 89 e5 mov %esp,%ebp
1069f3: 83 ec 18 sub $0x18,%esp
1069f6: 89 5d fc mov %ebx,-0x4(%ebp)
1069f9: 8b 5d 08 mov 0x8(%ebp),%ebx
if (!control->buffer)
1069fc: 8b 03 mov (%ebx),%eax
1069fe: 85 c0 test %eax,%eax
106a00: 74 7e je 106a80 <rtems_rfs_bitmap_map_test+0x90>
rc = rtems_rfs_buffer_handle_request (control->fs,
106a02: ba 01 00 00 00 mov $0x1,%edx
106a07: 89 54 24 0c mov %edx,0xc(%esp)
106a0b: 8b 53 08 mov 0x8(%ebx),%edx
106a0e: 89 44 24 04 mov %eax,0x4(%esp)
106a12: 89 54 24 08 mov %edx,0x8(%esp)
106a16: 8b 43 04 mov 0x4(%ebx),%eax
106a19: 89 04 24 mov %eax,(%esp)
106a1c: e8 af 0b 00 00 call 1075d0 <rtems_rfs_buffer_handle_request>
if (rc)
106a21: 85 c0 test %eax,%eax
106a23: 75 3b jne 106a60 <rtems_rfs_bitmap_map_test+0x70> <== NEVER TAKEN
*map = rtems_rfs_buffer_data (control->buffer);
106a25: 8b 03 mov (%ebx),%eax
106a27: 8b 40 08 mov 0x8(%eax),%eax
106a2a: 8b 50 1c mov 0x1c(%eax),%edx
if (bit >= control->size)
106a2d: 8b 45 0c mov 0xc(%ebp),%eax
106a30: 39 43 0c cmp %eax,0xc(%ebx)
106a33: 76 37 jbe 106a6c <rtems_rfs_bitmap_map_test+0x7c>
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
106a35: 0f b6 4d 0c movzbl 0xc(%ebp),%ecx
index = rtems_rfs_bitmap_map_index (bit);
106a39: 89 c3 mov %eax,%ebx
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
106a3b: b8 01 00 00 00 mov $0x1,%eax
index = rtems_rfs_bitmap_map_index (bit);
106a40: c1 fb 05 sar $0x5,%ebx
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
106a43: d3 e0 shl %cl,%eax
106a45: 23 04 9a and (%edx,%ebx,4),%eax
*state = rtems_rfs_bitmap_test (map[index], bit);
106a48: 8b 45 10 mov 0x10(%ebp),%eax
106a4b: 0f 94 00 sete (%eax)
return 0;
106a4e: 31 c0 xor %eax,%eax
}
106a50: 8b 5d fc mov -0x4(%ebp),%ebx
106a53: 89 ec mov %ebp,%esp
106a55: 5d pop %ebp
106a56: c3 ret
106a57: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
106a5e: 66 90 xchg %ax,%ax
if (rc > 0)
106a60: 7f ee jg 106a50 <rtems_rfs_bitmap_map_test+0x60> <== NOT EXECUTED
if (bit >= control->size)
106a62: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
*map = NULL;
106a65: 31 d2 xor %edx,%edx <== NOT EXECUTED
if (bit >= control->size)
106a67: 39 43 0c cmp %eax,0xc(%ebx) <== NOT EXECUTED
106a6a: 77 c9 ja 106a35 <rtems_rfs_bitmap_map_test+0x45> <== NOT EXECUTED
}
106a6c: 8b 5d fc mov -0x4(%ebp),%ebx
106a6f: 89 ec mov %ebp,%esp
return EINVAL;
106a71: b8 16 00 00 00 mov $0x16,%eax
}
106a76: 5d pop %ebp
106a77: c3 ret
106a78: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
106a7f: 90 nop
106a80: 8b 5d fc mov -0x4(%ebp),%ebx
106a83: 89 ec mov %ebp,%esp
return ENXIO;
106a85: b8 06 00 00 00 mov $0x6,%eax
}
106a8a: 5d pop %ebp
106a8b: c3 ret
106a8c: 90 nop
106a8d: 90 nop
106a8e: 90 nop
106a8f: 90 nop
00115a50 <rtems_rfs_block_map_close>:
{
115a50: 55 push %ebp
115a51: 89 e5 mov %esp,%ebp
115a53: 57 push %edi
115a54: 56 push %esi
int rc = 0;
115a55: 31 f6 xor %esi,%esi
{
115a57: 53 push %ebx
115a58: 83 ec 1c sub $0x1c,%esp
115a5b: 8b 5d 0c mov 0xc(%ebp),%ebx
115a5e: 8b 7d 08 mov 0x8(%ebp),%edi
if (map->dirty && map->inode)
115a61: 80 3b 00 cmpb $0x0,(%ebx)
115a64: 74 19 je 115a7f <rtems_rfs_block_map_close+0x2f>
115a66: 8b 43 04 mov 0x4(%ebx),%eax
115a69: 85 c0 test %eax,%eax
115a6b: 74 12 je 115a7f <rtems_rfs_block_map_close+0x2f> <== NEVER TAKEN
brc = rtems_rfs_inode_load (fs, map->inode);
115a6d: 89 44 24 04 mov %eax,0x4(%esp)
115a71: 89 3c 24 mov %edi,(%esp)
115a74: e8 07 3f ff ff call 109980 <rtems_rfs_inode_load>
if (brc > 0)
115a79: 85 c0 test %eax,%eax
brc = rtems_rfs_inode_load (fs, map->inode);
115a7b: 89 c6 mov %eax,%esi
if (brc > 0)
115a7d: 7e 61 jle 115ae0 <rtems_rfs_block_map_close+0x90> <== ALWAYS TAKEN
map->inode = NULL;
115a7f: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx)
brc = rtems_rfs_buffer_handle_close (fs, &map->singly_buffer);
115a86: 8d 43 38 lea 0x38(%ebx),%eax
rtems_rfs_buffer_handle_release (fs, handle);
115a89: 89 3c 24 mov %edi,(%esp)
115a8c: 89 44 24 04 mov %eax,0x4(%esp)
115a90: e8 1b 1e ff ff call 1078b0 <rtems_rfs_buffer_handle_release>
brc = rtems_rfs_buffer_handle_close (fs, &map->doubly_buffer);
115a95: 8d 43 44 lea 0x44(%ebx),%eax
handle->dirty = false;
115a98: c6 43 38 00 movb $0x0,0x38(%ebx)
handle->bnum = 0;
115a9c: c7 43 3c 00 00 00 00 movl $0x0,0x3c(%ebx)
handle->buffer = NULL;
115aa3: c7 43 40 00 00 00 00 movl $0x0,0x40(%ebx)
rtems_rfs_buffer_handle_release (fs, handle);
115aaa: 89 3c 24 mov %edi,(%esp)
115aad: 89 44 24 04 mov %eax,0x4(%esp)
115ab1: e8 fa 1d ff ff call 1078b0 <rtems_rfs_buffer_handle_release>
}
115ab6: 89 f0 mov %esi,%eax
handle->dirty = false;
115ab8: c6 43 44 00 movb $0x0,0x44(%ebx)
handle->bnum = 0;
115abc: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx)
handle->buffer = NULL;
115ac3: c7 43 4c 00 00 00 00 movl $0x0,0x4c(%ebx)
115aca: 83 c4 1c add $0x1c,%esp
115acd: 5b pop %ebx
115ace: 5e pop %esi
115acf: 5f pop %edi
115ad0: 5d pop %ebp
115ad1: c3 ret
115ad2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
115ad9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
115ae0: 89 7d 08 mov %edi,0x8(%ebp)
115ae3: b8 1c 00 00 00 mov $0x1c,%eax
115ae8: 89 de mov %ebx,%esi
rtems_rfs_inode_set_block (map->inode, b, map->blocks[b]);
115aea: 8b 56 04 mov 0x4(%esi),%edx
115aed: 8b 4c 06 08 mov 0x8(%esi,%eax,1),%ecx
rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);
115af1: 8b 7a 0c mov 0xc(%edx),%edi
115af4: 89 cb mov %ecx,%ebx
115af6: c1 eb 18 shr $0x18,%ebx
115af9: 88 1c 07 mov %bl,(%edi,%eax,1)
115afc: 89 cb mov %ecx,%ebx
115afe: 8b 7a 0c mov 0xc(%edx),%edi
115b01: c1 eb 10 shr $0x10,%ebx
115b04: 88 5c 07 01 mov %bl,0x1(%edi,%eax,1)
115b08: 8b 5a 0c mov 0xc(%edx),%ebx
115b0b: 88 6c 03 02 mov %ch,0x2(%ebx,%eax,1)
115b0f: 8b 5a 0c mov 0xc(%edx),%ebx
115b12: 88 4c 03 03 mov %cl,0x3(%ebx,%eax,1)
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
115b16: 83 c0 04 add $0x4,%eax
rtems_rfs_buffer_mark_dirty (&handle->buffer);
115b19: c6 42 10 01 movb $0x1,0x10(%edx)
115b1d: 83 f8 30 cmp $0x30,%eax
115b20: 75 c8 jne 115aea <rtems_rfs_block_map_close+0x9a>
rtems_rfs_inode_set_block_count (map->inode, map->size.count);
115b22: 8b 4e 04 mov 0x4(%esi),%ecx
115b25: 89 f3 mov %esi,%ebx
115b27: 8b 46 08 mov 0x8(%esi),%eax
115b2a: 8b 7d 08 mov 0x8(%ebp),%edi
rtems_rfs_write_u32 (&handle->node->block_count, block_count);
115b2d: 8b 71 0c mov 0xc(%ecx),%esi
115b30: 89 c2 mov %eax,%edx
115b32: c1 ea 18 shr $0x18,%edx
115b35: 88 56 0c mov %dl,0xc(%esi)
115b38: 89 c2 mov %eax,%edx
115b3a: 8b 71 0c mov 0xc(%ecx),%esi
115b3d: c1 ea 10 shr $0x10,%edx
115b40: 88 56 0d mov %dl,0xd(%esi)
115b43: 8b 51 0c mov 0xc(%ecx),%edx
115b46: 88 62 0e mov %ah,0xe(%edx)
115b49: 8b 51 0c mov 0xc(%ecx),%edx
115b4c: 88 42 0f mov %al,0xf(%edx)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
115b4f: c6 41 10 01 movb $0x1,0x10(%ecx)
rtems_rfs_inode_set_block_offset (map->inode, map->size.offset);
115b53: 8b 43 04 mov 0x4(%ebx),%eax
115b56: 8b 53 0c mov 0xc(%ebx),%edx
rtems_rfs_write_u16 (&handle->node->block_offset, block_offset);
115b59: 8b 48 0c mov 0xc(%eax),%ecx
115b5c: 88 71 0a mov %dh,0xa(%ecx)
115b5f: 8b 48 0c mov 0xc(%eax),%ecx
115b62: 88 51 0b mov %dl,0xb(%ecx)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
115b65: c6 40 10 01 movb $0x1,0x10(%eax)
rtems_rfs_inode_set_last_map_block (map->inode, map->last_map_block);
115b69: 8b 4b 04 mov 0x4(%ebx),%ecx
115b6c: 8b 43 1c mov 0x1c(%ebx),%eax
rtems_rfs_write_u32 (&handle->node->last_map_block, last_map_block);
115b6f: 8b 71 0c mov 0xc(%ecx),%esi
115b72: 89 c2 mov %eax,%edx
115b74: c1 ea 18 shr $0x18,%edx
115b77: 88 56 30 mov %dl,0x30(%esi)
115b7a: 89 c2 mov %eax,%edx
115b7c: 8b 71 0c mov 0xc(%ecx),%esi
115b7f: c1 ea 10 shr $0x10,%edx
115b82: 88 56 31 mov %dl,0x31(%esi)
115b85: 8b 51 0c mov 0xc(%ecx),%edx
115b88: 88 62 32 mov %ah,0x32(%edx)
115b8b: 8b 51 0c mov 0xc(%ecx),%edx
115b8e: 88 42 33 mov %al,0x33(%edx)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
115b91: c6 41 10 01 movb $0x1,0x10(%ecx)
rtems_rfs_inode_set_last_data_block (map->inode, map->last_data_block);
115b95: 8b 4b 04 mov 0x4(%ebx),%ecx
115b98: 8b 43 20 mov 0x20(%ebx),%eax
rtems_rfs_write_u32 (&handle->node->last_data_block, last_data_block);
115b9b: 8b 71 0c mov 0xc(%ecx),%esi
115b9e: 89 c2 mov %eax,%edx
115ba0: c1 ea 18 shr $0x18,%edx
115ba3: 88 56 34 mov %dl,0x34(%esi)
115ba6: 89 c2 mov %eax,%edx
115ba8: 8b 71 0c mov 0xc(%ecx),%esi
115bab: c1 ea 10 shr $0x10,%edx
115bae: 88 56 35 mov %dl,0x35(%esi)
115bb1: 8b 51 0c mov 0xc(%ecx),%edx
115bb4: 88 62 36 mov %ah,0x36(%edx)
115bb7: 8b 51 0c mov 0xc(%ecx),%edx
115bba: 88 42 37 mov %al,0x37(%edx)
brc = rtems_rfs_inode_unload (fs, map->inode, true);
115bbd: b8 01 00 00 00 mov $0x1,%eax
rtems_rfs_buffer_mark_dirty (&handle->buffer);
115bc2: c6 41 10 01 movb $0x1,0x10(%ecx)
115bc6: 89 44 24 08 mov %eax,0x8(%esp)
115bca: 8b 43 04 mov 0x4(%ebx),%eax
115bcd: 89 3c 24 mov %edi,(%esp)
115bd0: 89 44 24 04 mov %eax,0x4(%esp)
115bd4: e8 67 3f ff ff call 109b40 <rtems_rfs_inode_unload>
map->dirty = false;
115bd9: c6 03 00 movb $0x0,(%ebx)
brc = rtems_rfs_inode_unload (fs, map->inode, true);
115bdc: 89 c6 mov %eax,%esi
if (brc > 0)
115bde: f7 d0 not %eax
115be0: c1 f8 1f sar $0x1f,%eax
115be3: 21 c6 and %eax,%esi
map->dirty = false;
115be5: e9 95 fe ff ff jmp 115a7f <rtems_rfs_block_map_close+0x2f>
115bea: 90 nop
115beb: 90 nop
115bec: 90 nop
115bed: 90 nop
115bee: 90 nop
115bef: 90 nop
00115bf0 <rtems_rfs_block_map_find>:
{
115bf0: 55 push %ebp
115bf1: 89 e5 mov %esp,%ebp
115bf3: 83 ec 48 sub $0x48,%esp
115bf6: 89 7d fc mov %edi,-0x4(%ebp)
115bf9: 8b 7d 14 mov 0x14(%ebp),%edi
115bfc: 89 75 f8 mov %esi,-0x8(%ebp)
115bff: 8b 75 10 mov 0x10(%ebp),%esi
115c02: 89 5d f4 mov %ebx,-0xc(%ebp)
115c05: 8b 5d 0c mov 0xc(%ebp),%ebx
*block = 0;
115c08: c7 07 00 00 00 00 movl $0x0,(%edi)
if (rtems_rfs_block_pos_block_past_end (bpos, &map->size))
115c0e: 8b 06 mov (%esi),%eax
115c10: 8b 4b 08 mov 0x8(%ebx),%ecx
115c13: 85 c0 test %eax,%eax
115c15: 74 08 je 115c1f <rtems_rfs_block_map_find+0x2f>
115c17: 85 c9 test %ecx,%ecx
115c19: 0f 84 d1 00 00 00 je 115cf0 <rtems_rfs_block_map_find+0x100> <== NEVER TAKEN
115c1f: 39 c8 cmp %ecx,%eax
115c21: 0f 83 c9 00 00 00 jae 115cf0 <rtems_rfs_block_map_find+0x100>
if ((bpos->bno == map->bpos.bno) && (map->bpos.block != 0))
115c27: 3b 43 10 cmp 0x10(%ebx),%eax
115c2a: 0f 84 a0 00 00 00 je 115cd0 <rtems_rfs_block_map_find+0xe0>
if (map->size.count <= RTEMS_RFS_INODE_BLOCKS)
115c30: 83 f9 05 cmp $0x5,%ecx
115c33: 77 2b ja 115c60 <rtems_rfs_block_map_find+0x70>
*block = map->blocks[bpos->bno];
115c35: 8b 44 83 24 mov 0x24(%ebx,%eax,4),%eax
115c39: 89 07 mov %eax,(%edi)
rtems_rfs_block_copy_bpos (&map->bpos, bpos);
115c3b: 8b 06 mov (%esi),%eax
115c3d: 89 43 10 mov %eax,0x10(%ebx)
115c40: 8b 46 04 mov 0x4(%esi),%eax
115c43: 89 43 14 mov %eax,0x14(%ebx)
115c46: 8b 46 08 mov 0x8(%esi),%eax
115c49: 89 43 18 mov %eax,0x18(%ebx)
map->bpos.block = *block;
115c4c: 8b 07 mov (%edi),%eax
115c4e: 89 43 18 mov %eax,0x18(%ebx)
115c51: 31 c0 xor %eax,%eax
}
115c53: 8b 5d f4 mov -0xc(%ebp),%ebx
115c56: 8b 75 f8 mov -0x8(%ebp),%esi
115c59: 8b 7d fc mov -0x4(%ebp),%edi
115c5c: 89 ec mov %ebp,%esp
115c5e: 5d pop %ebp
115c5f: c3 ret
direct = bpos->bno % fs->blocks_per_block;
115c60: 8b 55 08 mov 0x8(%ebp),%edx
115c63: 8b 52 34 mov 0x34(%edx),%edx
115c66: 89 55 d4 mov %edx,-0x2c(%ebp)
115c69: 31 d2 xor %edx,%edx
115c6b: f7 75 d4 divl -0x2c(%ebp)
115c6e: 89 55 d0 mov %edx,-0x30(%ebp)
if (map->size.count <= fs->block_map_singly_blocks)
115c71: 8b 55 08 mov 0x8(%ebp),%edx
singly = bpos->bno / fs->blocks_per_block;
115c74: 89 45 e4 mov %eax,-0x1c(%ebp)
if (map->size.count <= fs->block_map_singly_blocks)
115c77: 39 4a 38 cmp %ecx,0x38(%edx)
115c7a: 0f 83 90 00 00 00 jae 115d10 <rtems_rfs_block_map_find+0x120>
singly %= fs->blocks_per_block;
115c80: 31 d2 xor %edx,%edx
115c82: f7 75 d4 divl -0x2c(%ebp)
115c85: 89 55 d4 mov %edx,-0x2c(%ebp)
115c88: 89 55 e4 mov %edx,-0x1c(%ebp)
if (map->size.count < fs->block_map_doubly_blocks)
115c8b: 8b 55 08 mov 0x8(%ebp),%edx
115c8e: 39 4a 3c cmp %ecx,0x3c(%edx)
115c91: 76 5d jbe 115cf0 <rtems_rfs_block_map_find+0x100> <== NEVER TAKEN
rc = rtems_rfs_block_find_indirect (fs,
115c93: 8b 4c 83 24 mov 0x24(%ebx,%eax,4),%ecx
115c97: 8d 43 44 lea 0x44(%ebx),%eax
115c9a: 89 c2 mov %eax,%edx
115c9c: 8d 45 e4 lea -0x1c(%ebp),%eax
115c9f: 89 44 24 04 mov %eax,0x4(%esp)
115ca3: 8b 45 d4 mov -0x2c(%ebp),%eax
115ca6: 89 04 24 mov %eax,(%esp)
115ca9: 8b 45 08 mov 0x8(%ebp),%eax
115cac: e8 bf fa ff ff call 115770 <rtems_rfs_block_find_indirect>
if (rc == 0)
115cb1: 85 c0 test %eax,%eax
115cb3: 75 9e jne 115c53 <rtems_rfs_block_map_find+0x63> <== NEVER TAKEN
rc = rtems_rfs_block_find_indirect (fs,
115cb5: 8b 45 d0 mov -0x30(%ebp),%eax
115cb8: 8d 53 38 lea 0x38(%ebx),%edx
115cbb: 89 7c 24 04 mov %edi,0x4(%esp)
115cbf: 8b 4d e4 mov -0x1c(%ebp),%ecx
115cc2: 89 04 24 mov %eax,(%esp)
115cc5: 8b 45 08 mov 0x8(%ebp),%eax
115cc8: e8 a3 fa ff ff call 115770 <rtems_rfs_block_find_indirect>
115ccd: eb 5a jmp 115d29 <rtems_rfs_block_map_find+0x139>
115ccf: 90 nop
if ((bpos->bno == map->bpos.bno) && (map->bpos.block != 0))
115cd0: 8b 53 18 mov 0x18(%ebx),%edx
115cd3: 85 d2 test %edx,%edx
115cd5: 0f 84 55 ff ff ff je 115c30 <rtems_rfs_block_map_find+0x40>
*block = map->bpos.block;
115cdb: 89 17 mov %edx,(%edi)
if (rc == 0)
115cdd: 8d 76 00 lea 0x0(%esi),%esi
115ce0: e9 56 ff ff ff jmp 115c3b <rtems_rfs_block_map_find+0x4b>
115ce5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
115cec: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
}
115cf0: 8b 5d f4 mov -0xc(%ebp),%ebx
return ENXIO;
115cf3: b8 06 00 00 00 mov $0x6,%eax
}
115cf8: 8b 75 f8 mov -0x8(%ebp),%esi
115cfb: 8b 7d fc mov -0x4(%ebp),%edi
115cfe: 89 ec mov %ebp,%esp
115d00: 5d pop %ebp
115d01: c3 ret
115d02: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
115d09: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
rc = rtems_rfs_block_find_indirect (fs,
115d10: 8b 4c 83 24 mov 0x24(%ebx,%eax,4),%ecx
115d14: 8d 53 38 lea 0x38(%ebx),%edx
115d17: 89 7c 24 04 mov %edi,0x4(%esp)
115d1b: 8b 45 d0 mov -0x30(%ebp),%eax
115d1e: 89 04 24 mov %eax,(%esp)
115d21: 8b 45 08 mov 0x8(%ebp),%eax
115d24: e8 47 fa ff ff call 115770 <rtems_rfs_block_find_indirect>
if (rc == 0)
115d29: 85 c0 test %eax,%eax
115d2b: 0f 84 0a ff ff ff je 115c3b <rtems_rfs_block_map_find+0x4b> <== ALWAYS TAKEN
115d31: e9 1d ff ff ff jmp 115c53 <rtems_rfs_block_map_find+0x63> <== NOT EXECUTED
115d36: 90 nop
115d37: 90 nop
115d38: 90 nop
115d39: 90 nop
115d3a: 90 nop
115d3b: 90 nop
115d3c: 90 nop
115d3d: 90 nop
115d3e: 90 nop
115d3f: 90 nop
00115e00 <rtems_rfs_block_map_grow>:
{
115e00: 55 push %ebp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
115e01: 31 c0 xor %eax,%eax
{
115e03: 89 e5 mov %esp,%ebp
115e05: 57 push %edi
115e06: 56 push %esi
115e07: 53 push %ebx
115e08: 83 ec 4c sub $0x4c,%esp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
115e0b: c7 04 24 00 20 00 00 movl $0x2000,(%esp)
{
115e12: 8b 75 08 mov 0x8(%ebp),%esi
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
115e15: 89 44 24 04 mov %eax,0x4(%esp)
{
115e19: 8b 7d 0c mov 0xc(%ebp),%edi
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
115e1c: e8 2f 5a ff ff call 10b850 <rtems_rfs_trace>
115e21: 84 c0 test %al,%al
115e23: 0f 85 27 03 00 00 jne 116150 <rtems_rfs_block_map_grow+0x350> <== NEVER TAKEN
if ((map->size.count + blocks) >= rtems_rfs_fs_max_block_map_blocks (fs))
115e29: 8b 45 10 mov 0x10(%ebp),%eax
115e2c: 8b 5f 08 mov 0x8(%edi),%ebx
115e2f: 01 d8 add %ebx,%eax
115e31: 3b 46 3c cmp 0x3c(%esi),%eax
115e34: 0f 83 41 03 00 00 jae 11617b <rtems_rfs_block_map_grow+0x37b> <== NEVER TAKEN
for (b = 0; b < blocks; b++)
115e3a: 8b 45 10 mov 0x10(%ebp),%eax
115e3d: 85 c0 test %eax,%eax
115e3f: 0f 84 4b 03 00 00 je 116190 <rtems_rfs_block_map_grow+0x390> <== NEVER TAKEN
rc = rtems_rfs_buffer_handle_request (fs,
115e45: 8d 57 44 lea 0x44(%edi),%edx
rc = rtems_rfs_group_bitmap_alloc (fs, map->last_data_block,
115e48: 8b 47 20 mov 0x20(%edi),%eax
for (b = 0; b < blocks; b++)
115e4b: 31 db xor %ebx,%ebx
rc = rtems_rfs_buffer_handle_request (fs,
115e4d: 89 55 bc mov %edx,-0x44(%ebp)
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
115e50: 8d 57 38 lea 0x38(%edi),%edx
115e53: 89 55 c4 mov %edx,-0x3c(%ebp)
115e56: eb 33 jmp 115e8b <rtems_rfs_block_map_grow+0x8b>
115e58: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
115e5f: 90 nop
map->blocks[map->size.count] = block;
115e60: 8b 45 e0 mov -0x20(%ebp),%eax
115e63: 89 44 8f 24 mov %eax,0x24(%edi,%ecx,4)
map->size.offset = 0;
115e67: c7 47 0c 00 00 00 00 movl $0x0,0xc(%edi)
map->size.count++;
115e6e: 41 inc %ecx
if (b == 0)
115e6f: 85 db test %ebx,%ebx
map->size.count++;
115e71: 89 4f 08 mov %ecx,0x8(%edi)
if (b == 0)
115e74: 75 05 jne 115e7b <rtems_rfs_block_map_grow+0x7b> <== NEVER TAKEN
*new_block = block;
115e76: 8b 4d 14 mov 0x14(%ebp),%ecx
115e79: 89 01 mov %eax,(%ecx)
map->last_data_block = block;
115e7b: 89 47 20 mov %eax,0x20(%edi)
for (b = 0; b < blocks; b++)
115e7e: 43 inc %ebx
115e7f: 3b 5d 10 cmp 0x10(%ebp),%ebx
map->dirty = true;
115e82: c6 07 01 movb $0x1,(%edi)
for (b = 0; b < blocks; b++)
115e85: 0f 84 05 03 00 00 je 116190 <rtems_rfs_block_map_grow+0x390> <== ALWAYS TAKEN
rc = rtems_rfs_group_bitmap_alloc (fs, map->last_data_block,
115e8b: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
115e8f: 8d 4d e0 lea -0x20(%ebp),%ecx <== NOT EXECUTED
115e92: 89 4c 24 0c mov %ecx,0xc(%esp) <== NOT EXECUTED
115e96: 31 c9 xor %ecx,%ecx <== NOT EXECUTED
115e98: 89 4c 24 08 mov %ecx,0x8(%esp) <== NOT EXECUTED
115e9c: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
115e9f: e8 bc 36 ff ff call 109560 <rtems_rfs_group_bitmap_alloc> <== NOT EXECUTED
if (rc > 0)
115ea4: 85 c0 test %eax,%eax
115ea6: 0f 8f f4 02 00 00 jg 1161a0 <rtems_rfs_block_map_grow+0x3a0>
if (map->size.count < RTEMS_RFS_INODE_BLOCKS)
115eac: 8b 4f 08 mov 0x8(%edi),%ecx
115eaf: 83 f9 04 cmp $0x4,%ecx
115eb2: 76 ac jbe 115e60 <rtems_rfs_block_map_grow+0x60>
direct = map->size.count % fs->blocks_per_block;
115eb4: 8b 46 34 mov 0x34(%esi),%eax
115eb7: 89 c2 mov %eax,%edx
115eb9: 89 c8 mov %ecx,%eax
115ebb: 89 55 d4 mov %edx,-0x2c(%ebp)
115ebe: 31 d2 xor %edx,%edx
115ec0: f7 75 d4 divl -0x2c(%ebp)
if (map->size.count < fs->block_map_singly_blocks)
115ec3: 3b 4e 38 cmp 0x38(%esi),%ecx
115ec6: 89 55 d0 mov %edx,-0x30(%ebp)
115ec9: 89 45 cc mov %eax,-0x34(%ebp)
115ecc: 0f 83 8e 00 00 00 jae 115f60 <rtems_rfs_block_map_grow+0x160>
if ((direct == 0) ||
115ed2: 85 d2 test %edx,%edx
115ed4: 74 12 je 115ee8 <rtems_rfs_block_map_grow+0xe8>
115ed6: 3b 4d d4 cmp -0x2c(%ebp),%ecx
115ed9: 0f 83 01 02 00 00 jae 1160e0 <rtems_rfs_block_map_grow+0x2e0>
115edf: 83 fa 05 cmp $0x5,%edx
115ee2: 0f 85 f8 01 00 00 jne 1160e0 <rtems_rfs_block_map_grow+0x2e0>
upping = map->size.count == RTEMS_RFS_INODE_BLOCKS;
115ee8: 31 c0 xor %eax,%eax
115eea: 83 f9 05 cmp $0x5,%ecx
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
115eed: 8b 4d c4 mov -0x3c(%ebp),%ecx
upping = map->size.count == RTEMS_RFS_INODE_BLOCKS;
115ef0: 0f 94 c0 sete %al
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
115ef3: 89 fa mov %edi,%edx
115ef5: 89 44 24 04 mov %eax,0x4(%esp)
&map->blocks[singly],
115ef9: 8b 45 cc mov -0x34(%ebp),%eax
115efc: 8d 44 87 24 lea 0x24(%edi,%eax,4),%eax
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
115f00: 89 04 24 mov %eax,(%esp)
115f03: 89 f0 mov %esi,%eax
115f05: e8 26 f6 ff ff call 115530 <rtems_rfs_block_map_indirect_alloc>
if (rc > 0)
115f0a: 85 c0 test %eax,%eax
115f0c: 0f 8f 9d 01 00 00 jg 1160af <rtems_rfs_block_map_grow+0x2af> <== NEVER TAKEN
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
115f12: 8b 57 40 mov 0x40(%edi),%edx
115f15: 8b 45 d0 mov -0x30(%ebp),%eax
115f18: 0f b6 4d e3 movzbl -0x1d(%ebp),%ecx
115f1c: 8b 52 1c mov 0x1c(%edx),%edx
115f1f: c1 e0 02 shl $0x2,%eax
115f22: 88 0c 02 mov %cl,(%edx,%eax,1)
115f25: 8b 57 40 mov 0x40(%edi),%edx
115f28: 0f b7 4d e2 movzwl -0x1e(%ebp),%ecx
115f2c: 8b 52 1c mov 0x1c(%edx),%edx
115f2f: 88 4c 02 01 mov %cl,0x1(%edx,%eax,1)
115f33: 8b 57 40 mov 0x40(%edi),%edx
115f36: 8b 4d e0 mov -0x20(%ebp),%ecx
115f39: 8b 52 1c mov 0x1c(%edx),%edx
115f3c: 88 6c 02 02 mov %ch,0x2(%edx,%eax,1)
115f40: 8b 57 40 mov 0x40(%edi),%edx
115f43: 0f b6 4d e0 movzbl -0x20(%ebp),%ecx
115f47: 8b 52 1c mov 0x1c(%edx),%edx
115f4a: 88 4c 02 03 mov %cl,0x3(%edx,%eax,1)
115f4e: c6 47 38 01 movb $0x1,0x38(%edi)
map->size.count++;
115f52: 8b 4f 08 mov 0x8(%edi),%ecx
*new_block = block;
115f55: 8b 45 e0 mov -0x20(%ebp),%eax
115f58: e9 0a ff ff ff jmp 115e67 <rtems_rfs_block_map_grow+0x67>
115f5d: 8d 76 00 lea 0x0(%esi),%esi
doubly = singly / fs->blocks_per_block;
115f60: 8b 45 cc mov -0x34(%ebp),%eax
115f63: 31 d2 xor %edx,%edx
115f65: f7 75 d4 divl -0x2c(%ebp)
115f68: 89 45 c0 mov %eax,-0x40(%ebp)
if (direct == 0)
115f6b: 8b 45 d0 mov -0x30(%ebp),%eax
115f6e: 89 55 c8 mov %edx,-0x38(%ebp)
115f71: 85 c0 test %eax,%eax
115f73: 0f 85 b7 00 00 00 jne 116030 <rtems_rfs_block_map_grow+0x230>
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
115f79: 8b 4d c4 mov -0x3c(%ebp),%ecx
115f7c: 31 c0 xor %eax,%eax
115f7e: 89 fa mov %edi,%edx
115f80: 89 44 24 04 mov %eax,0x4(%esp)
115f84: 8d 45 e4 lea -0x1c(%ebp),%eax
115f87: 89 04 24 mov %eax,(%esp)
115f8a: 89 f0 mov %esi,%eax
115f8c: e8 9f f5 ff ff call 115530 <rtems_rfs_block_map_indirect_alloc>
if (rc > 0)
115f91: 85 c0 test %eax,%eax
115f93: 0f 8f 16 01 00 00 jg 1160af <rtems_rfs_block_map_grow+0x2af> <== NEVER TAKEN
if ((singly == 0) ||
115f99: 8b 45 c8 mov -0x38(%ebp),%eax
115f9c: 85 c0 test %eax,%eax
115f9e: 74 15 je 115fb5 <rtems_rfs_block_map_grow+0x1b5> <== NEVER TAKEN
115fa0: 8b 4d cc mov -0x34(%ebp),%ecx
115fa3: 39 4d d4 cmp %ecx,-0x2c(%ebp)
115fa6: 0f 86 54 01 00 00 jbe 116100 <rtems_rfs_block_map_grow+0x300> <== NEVER TAKEN
115fac: 83 f8 05 cmp $0x5,%eax
115faf: 0f 85 4b 01 00 00 jne 116100 <rtems_rfs_block_map_grow+0x300>
upping = map->size.count == fs->block_map_singly_blocks;
115fb5: 8b 46 38 mov 0x38(%esi),%eax
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
115fb8: 89 fa mov %edi,%edx
upping = map->size.count == fs->block_map_singly_blocks;
115fba: 39 47 08 cmp %eax,0x8(%edi)
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
115fbd: 8b 4d bc mov -0x44(%ebp),%ecx
upping = map->size.count == fs->block_map_singly_blocks;
115fc0: 0f 94 c0 sete %al
115fc3: 0f b6 c0 movzbl %al,%eax
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
115fc6: 89 44 24 04 mov %eax,0x4(%esp)
&map->blocks[doubly],
115fca: 8b 45 c0 mov -0x40(%ebp),%eax
115fcd: 8d 44 87 24 lea 0x24(%edi,%eax,4),%eax
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
115fd1: 89 04 24 mov %eax,(%esp)
115fd4: 89 f0 mov %esi,%eax
115fd6: e8 55 f5 ff ff call 115530 <rtems_rfs_block_map_indirect_alloc>
if (rc > 0)
115fdb: 85 c0 test %eax,%eax
115fdd: 0f 8f 48 01 00 00 jg 11612b <rtems_rfs_block_map_grow+0x32b> <== NEVER TAKEN
rtems_rfs_block_set_number (&map->doubly_buffer,
115fe3: 8b 57 4c mov 0x4c(%edi),%edx
115fe6: 8b 45 c8 mov -0x38(%ebp),%eax
115fe9: 0f b6 4d e7 movzbl -0x19(%ebp),%ecx
115fed: 8b 52 1c mov 0x1c(%edx),%edx
115ff0: c1 e0 02 shl $0x2,%eax
115ff3: 88 0c 02 mov %cl,(%edx,%eax,1)
115ff6: 8b 57 4c mov 0x4c(%edi),%edx
115ff9: 0f b7 4d e6 movzwl -0x1a(%ebp),%ecx
115ffd: 8b 52 1c mov 0x1c(%edx),%edx
116000: 88 4c 02 01 mov %cl,0x1(%edx,%eax,1)
116004: 8b 57 4c mov 0x4c(%edi),%edx
116007: 8b 4d e4 mov -0x1c(%ebp),%ecx
11600a: 8b 52 1c mov 0x1c(%edx),%edx
11600d: 88 6c 02 02 mov %ch,0x2(%edx,%eax,1)
116011: 8b 57 4c mov 0x4c(%edi),%edx
116014: 0f b6 4d e4 movzbl -0x1c(%ebp),%ecx
116018: 8b 52 1c mov 0x1c(%edx),%edx
11601b: 88 4c 02 03 mov %cl,0x3(%edx,%eax,1)
11601f: c6 47 44 01 movb $0x1,0x44(%edi)
116023: e9 ea fe ff ff jmp 115f12 <rtems_rfs_block_map_grow+0x112>
116028: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11602f: 90 nop
rc = rtems_rfs_buffer_handle_request (fs,
116030: b8 01 00 00 00 mov $0x1,%eax
116035: 89 44 24 0c mov %eax,0xc(%esp)
116039: 8b 45 c0 mov -0x40(%ebp),%eax
11603c: 8b 44 87 24 mov 0x24(%edi,%eax,4),%eax
116040: 89 34 24 mov %esi,(%esp)
116043: 89 44 24 08 mov %eax,0x8(%esp)
116047: 8b 45 bc mov -0x44(%ebp),%eax
11604a: 89 44 24 04 mov %eax,0x4(%esp)
11604e: e8 7d 15 ff ff call 1075d0 <rtems_rfs_buffer_handle_request>
if (rc > 0)
116053: 85 c0 test %eax,%eax
116055: 7f 58 jg 1160af <rtems_rfs_block_map_grow+0x2af> <== NEVER TAKEN
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
116057: 8b 47 4c mov 0x4c(%edi),%eax
11605a: 8b 4d c8 mov -0x38(%ebp),%ecx
11605d: 8b 50 1c mov 0x1c(%eax),%edx
116060: 0f b6 04 8a movzbl (%edx,%ecx,4),%eax
116064: 0f b6 4c 8a 03 movzbl 0x3(%edx,%ecx,4),%ecx
116069: c1 e0 18 shl $0x18,%eax
11606c: 09 c8 or %ecx,%eax
11606e: 8b 4d c8 mov -0x38(%ebp),%ecx
116071: 0f b6 4c 8a 01 movzbl 0x1(%edx,%ecx,4),%ecx
116076: c1 e1 10 shl $0x10,%ecx
116079: 09 c8 or %ecx,%eax
11607b: 8b 4d c8 mov -0x38(%ebp),%ecx
11607e: 0f b6 54 8a 02 movzbl 0x2(%edx,%ecx,4),%edx
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
116083: b9 01 00 00 00 mov $0x1,%ecx
116088: 89 4c 24 0c mov %ecx,0xc(%esp)
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
11608c: c1 e2 08 shl $0x8,%edx
11608f: 09 d0 or %edx,%eax
116091: 89 45 e4 mov %eax,-0x1c(%ebp)
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
116094: 89 44 24 08 mov %eax,0x8(%esp)
116098: 8b 45 c4 mov -0x3c(%ebp),%eax
11609b: 89 34 24 mov %esi,(%esp)
11609e: 89 44 24 04 mov %eax,0x4(%esp)
1160a2: e8 29 15 ff ff call 1075d0 <rtems_rfs_buffer_handle_request>
if (rc > 0)
1160a7: 85 c0 test %eax,%eax
1160a9: 0f 8e 63 fe ff ff jle 115f12 <rtems_rfs_block_map_grow+0x112> <== ALWAYS TAKEN
rtems_rfs_group_bitmap_free (fs, false, block);
1160af: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED
1160b2: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
1160b5: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED
1160b8: 31 d2 xor %edx,%edx <== NOT EXECUTED
1160ba: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
1160be: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
1160c2: e8 39 37 ff ff call 109800 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
return rc;
1160c7: 8b 55 d4 mov -0x2c(%ebp),%edx <== NOT EXECUTED
}
1160ca: 83 c4 4c add $0x4c,%esp <== NOT EXECUTED
1160cd: 5b pop %ebx <== NOT EXECUTED
1160ce: 5e pop %esi <== NOT EXECUTED
1160cf: 89 d0 mov %edx,%eax <== NOT EXECUTED
1160d1: 5f pop %edi <== NOT EXECUTED
1160d2: 5d pop %ebp <== NOT EXECUTED
1160d3: c3 ret <== NOT EXECUTED
1160d4: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1160db: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1160df: 90 nop <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
1160e0: 8b 45 cc mov -0x34(%ebp),%eax
1160e3: ba 01 00 00 00 mov $0x1,%edx
1160e8: 89 54 24 0c mov %edx,0xc(%esp)
1160ec: 8b 44 87 24 mov 0x24(%edi,%eax,4),%eax
1160f0: eb a2 jmp 116094 <rtems_rfs_block_map_grow+0x294>
1160f2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1160f9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
116100: b8 01 00 00 00 mov $0x1,%eax
116105: 89 44 24 0c mov %eax,0xc(%esp)
116109: 8b 45 c0 mov -0x40(%ebp),%eax
11610c: 8b 44 87 24 mov 0x24(%edi,%eax,4),%eax
116110: 89 34 24 mov %esi,(%esp)
116113: 89 44 24 08 mov %eax,0x8(%esp)
116117: 8b 45 bc mov -0x44(%ebp),%eax
11611a: 89 44 24 04 mov %eax,0x4(%esp)
11611e: e8 ad 14 ff ff call 1075d0 <rtems_rfs_buffer_handle_request>
if (rc > 0)
116123: 85 c0 test %eax,%eax
116125: 0f 8e b8 fe ff ff jle 115fe3 <rtems_rfs_block_map_grow+0x1e3> <== ALWAYS TAKEN
rtems_rfs_group_bitmap_free (fs, false, singly_block);
11612b: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED
11612e: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED
116131: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
116134: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
116138: 31 c0 xor %eax,%eax <== NOT EXECUTED
11613a: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
11613e: e8 bd 36 ff ff call 109800 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
rtems_rfs_group_bitmap_free (fs, false, block);
116143: e9 6a ff ff ff jmp 1160b2 <rtems_rfs_block_map_grow+0x2b2> <== NOT EXECUTED
116148: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11614f: 90 nop <== NOT EXECUTED
printf ("rtems-rfs: block-map-grow: entry: blocks=%zd count=%" PRIu32 "\n",
116150: 8b 47 08 mov 0x8(%edi),%eax <== NOT EXECUTED
116153: c7 04 24 10 53 13 00 movl $0x135310,(%esp) <== NOT EXECUTED
11615a: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
11615e: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
116161: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
116165: e8 d6 bf fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
if ((map->size.count + blocks) >= rtems_rfs_fs_max_block_map_blocks (fs))
11616a: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
11616d: 8b 5f 08 mov 0x8(%edi),%ebx <== NOT EXECUTED
116170: 01 d8 add %ebx,%eax <== NOT EXECUTED
116172: 3b 46 3c cmp 0x3c(%esi),%eax <== NOT EXECUTED
116175: 0f 82 bf fc ff ff jb 115e3a <rtems_rfs_block_map_grow+0x3a> <== NOT EXECUTED
}
11617b: 83 c4 4c add $0x4c,%esp <== NOT EXECUTED
return EFBIG;
11617e: ba 1b 00 00 00 mov $0x1b,%edx <== NOT EXECUTED
}
116183: 5b pop %ebx <== NOT EXECUTED
116184: 89 d0 mov %edx,%eax <== NOT EXECUTED
116186: 5e pop %esi <== NOT EXECUTED
116187: 5f pop %edi <== NOT EXECUTED
116188: 5d pop %ebp <== NOT EXECUTED
116189: c3 ret <== NOT EXECUTED
11618a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
116190: 83 c4 4c add $0x4c,%esp
return 0;
116193: 31 d2 xor %edx,%edx
}
116195: 5b pop %ebx
116196: 89 d0 mov %edx,%eax
116198: 5e pop %esi
116199: 5f pop %edi
11619a: 5d pop %ebp
11619b: c3 ret
11619c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
1161a0: 83 c4 4c add $0x4c,%esp <== NOT EXECUTED
1161a3: 89 c2 mov %eax,%edx <== NOT EXECUTED
1161a5: 5b pop %ebx <== NOT EXECUTED
1161a6: 89 d0 mov %edx,%eax <== NOT EXECUTED
1161a8: 5e pop %esi <== NOT EXECUTED
1161a9: 5f pop %edi <== NOT EXECUTED
1161aa: 5d pop %ebp <== NOT EXECUTED
1161ab: c3 ret <== NOT EXECUTED
1161ac: 90 nop
1161ad: 90 nop
1161ae: 90 nop
1161af: 90 nop
00115920 <rtems_rfs_block_map_open>:
{
115920: 55 push %ebp <== NOT EXECUTED
115921: 89 e5 mov %esp,%ebp <== NOT EXECUTED
115923: 57 push %edi <== NOT EXECUTED
115924: 56 push %esi <== NOT EXECUTED
115925: 53 push %ebx <== NOT EXECUTED
115926: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED
115929: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED
11592c: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED
11592f: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED
map->dirty = false;
115932: c6 03 00 movb $0x0,(%ebx) <== NOT EXECUTED
map->inode = NULL;
115935: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) <== NOT EXECUTED
* @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;
11593c: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) <== NOT EXECUTED
size->offset = 0;
115943: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) <== NOT EXECUTED
bpos->bno = 0;
11594a: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) <== NOT EXECUTED
bpos->boff = 0;
115951: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx) <== NOT EXECUTED
bpos->block = 0;
115958: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) <== NOT EXECUTED
handle->dirty = false;
11595f: c6 43 38 00 movb $0x0,0x38(%ebx) <== NOT EXECUTED
handle->bnum = 0;
115963: c7 43 3c 00 00 00 00 movl $0x0,0x3c(%ebx) <== NOT EXECUTED
handle->buffer = NULL;
11596a: c7 43 40 00 00 00 00 movl $0x0,0x40(%ebx) <== NOT EXECUTED
handle->dirty = false;
115971: c6 43 44 00 movb $0x0,0x44(%ebx) <== NOT EXECUTED
handle->bnum = 0;
115975: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx) <== NOT EXECUTED
handle->buffer = NULL;
11597c: c7 43 4c 00 00 00 00 movl $0x0,0x4c(%ebx) <== NOT EXECUTED
rc = rtems_rfs_inode_load (fs, inode);
115983: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED
115987: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
11598a: e8 f1 3f ff ff call 109980 <rtems_rfs_inode_load> <== NOT EXECUTED
if (rc > 0)
11598f: 85 c0 test %eax,%eax
115991: 7f 5d jg 1159f0 <rtems_rfs_block_map_open+0xd0> <== NEVER TAKEN
map->inode = inode;
115993: 89 73 04 mov %esi,0x4(%ebx)
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
115996: 8b 4e 0c mov 0xc(%esi),%ecx
115999: 31 c0 xor %eax,%eax
return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);
11599b: 8b 54 81 1c mov 0x1c(%ecx,%eax,4),%edx
11599f: 0f ca bswap %edx
map->blocks[b] = rtems_rfs_inode_get_block (inode, b);
1159a1: 89 54 83 24 mov %edx,0x24(%ebx,%eax,4)
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
1159a5: 40 inc %eax
1159a6: 83 f8 05 cmp $0x5,%eax
1159a9: 75 f0 jne 11599b <rtems_rfs_block_map_open+0x7b>
return rtems_rfs_read_u32 (&handle->node->block_count);
1159ab: 8b 41 0c mov 0xc(%ecx),%eax <== NOT EXECUTED
1159ae: 0f c8 bswap %eax <== NOT EXECUTED
map->size.count = rtems_rfs_inode_get_block_count (inode);
1159b0: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED
map->size.offset = rtems_rfs_inode_get_block_offset (inode);
1159b3: 0f b7 51 0a movzwl 0xa(%ecx),%edx <== NOT EXECUTED
1159b7: 89 d0 mov %edx,%eax <== NOT EXECUTED
1159b9: 0f b6 d6 movzbl %dh,%edx <== NOT EXECUTED
1159bc: c1 e0 08 shl $0x8,%eax <== NOT EXECUTED
1159bf: 09 d0 or %edx,%eax <== NOT EXECUTED
1159c1: 0f b7 c0 movzwl %ax,%eax <== NOT EXECUTED
1159c4: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED
return rtems_rfs_read_u32 (&handle->node->last_map_block);
1159c7: 8b 41 30 mov 0x30(%ecx),%eax <== NOT EXECUTED
1159ca: 0f c8 bswap %eax <== NOT EXECUTED
map->last_map_block = rtems_rfs_inode_get_last_map_block (inode);
1159cc: 89 43 1c mov %eax,0x1c(%ebx) <== NOT EXECUTED
return rtems_rfs_read_u32 (&handle->node->last_data_block);
1159cf: 8b 41 34 mov 0x34(%ecx),%eax <== NOT EXECUTED
1159d2: 0f c8 bswap %eax <== NOT EXECUTED
map->last_data_block = rtems_rfs_inode_get_last_data_block (inode);
1159d4: 89 43 20 mov %eax,0x20(%ebx) <== NOT EXECUTED
rc = rtems_rfs_inode_unload (fs, inode, false);
1159d7: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED
1159da: 89 7d 08 mov %edi,0x8(%ebp) <== NOT EXECUTED
1159dd: c7 45 10 00 00 00 00 movl $0x0,0x10(%ebp) <== NOT EXECUTED
}
1159e4: 83 c4 2c add $0x2c,%esp <== NOT EXECUTED
1159e7: 5b pop %ebx <== NOT EXECUTED
1159e8: 5e pop %esi <== NOT EXECUTED
1159e9: 5f pop %edi <== NOT EXECUTED
1159ea: 5d pop %ebp <== NOT EXECUTED
rc = rtems_rfs_inode_unload (fs, inode, false);
1159eb: e9 50 41 ff ff jmp 109b40 <rtems_rfs_inode_unload> <== NOT EXECUTED
1159f0: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_open (fs, &map->singly_buffer);
1159f3: 8d 43 38 lea 0x38(%ebx),%eax <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
1159f6: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
1159f9: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1159fd: e8 ae 1e ff ff call 1078b0 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_open (fs, &map->doubly_buffer);
115a02: 8d 43 44 lea 0x44(%ebx),%eax <== NOT EXECUTED
handle->dirty = false;
115a05: c6 43 38 00 movb $0x0,0x38(%ebx) <== NOT EXECUTED
handle->bnum = 0;
115a09: c7 43 3c 00 00 00 00 movl $0x0,0x3c(%ebx) <== NOT EXECUTED
handle->buffer = NULL;
115a10: c7 43 40 00 00 00 00 movl $0x0,0x40(%ebx) <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
115a17: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
115a1a: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
115a1e: e8 8d 1e ff ff call 1078b0 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
return rc;
115a23: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED
handle->dirty = false;
115a26: c6 43 44 00 movb $0x0,0x44(%ebx) <== NOT EXECUTED
handle->bnum = 0;
115a2a: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx) <== NOT EXECUTED
handle->buffer = NULL;
115a31: c7 43 4c 00 00 00 00 movl $0x0,0x4c(%ebx) <== NOT EXECUTED
}
115a38: 83 c4 2c add $0x2c,%esp <== NOT EXECUTED
115a3b: 5b pop %ebx <== NOT EXECUTED
115a3c: 89 d0 mov %edx,%eax <== NOT EXECUTED
115a3e: 5e pop %esi <== NOT EXECUTED
115a3f: 5f pop %edi <== NOT EXECUTED
115a40: 5d pop %ebp <== NOT EXECUTED
115a41: c3 ret <== NOT EXECUTED
115a42: 90 nop
115a43: 90 nop
115a44: 90 nop
115a45: 90 nop
115a46: 90 nop
115a47: 90 nop
115a48: 90 nop
115a49: 90 nop
115a4a: 90 nop
115a4b: 90 nop
115a4c: 90 nop
115a4d: 90 nop
115a4e: 90 nop
115a4f: 90 nop
001161b0 <rtems_rfs_block_map_shrink>:
int
rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks)
{
1161b0: 55 push %ebp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))
1161b1: 31 c0 xor %eax,%eax
{
1161b3: 89 e5 mov %esp,%ebp
1161b5: 57 push %edi
1161b6: 56 push %esi
1161b7: 53 push %ebx
1161b8: 83 ec 3c sub $0x3c,%esp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))
1161bb: c7 04 24 00 40 00 00 movl $0x4000,(%esp)
{
1161c2: 8b 7d 0c mov 0xc(%ebp),%edi
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))
1161c5: 89 44 24 04 mov %eax,0x4(%esp)
{
1161c9: 8b 5d 10 mov 0x10(%ebp),%ebx
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))
1161cc: e8 7f 56 ff ff call 10b850 <rtems_rfs_trace>
1161d1: 84 c0 test %al,%al
1161d3: 0f 85 77 02 00 00 jne 116450 <rtems_rfs_block_map_shrink+0x2a0> <== NEVER TAKEN
printf ("rtems-rfs: block-map-shrink: entry: blocks=%zd count=%" PRIu32 "\n",
blocks, map->size.count);
if (map->size.count == 0)
1161d9: 8b 4f 08 mov 0x8(%edi),%ecx
1161dc: 85 c9 test %ecx,%ecx
1161de: 0f 84 4c 02 00 00 je 116430 <rtems_rfs_block_map_shrink+0x280>
return 0;
if (blocks > map->size.count)
1161e4: 89 4d dc mov %ecx,-0x24(%ebp)
1161e7: 39 d9 cmp %ebx,%ecx
1161e9: 0f 87 51 02 00 00 ja 116440 <rtems_rfs_block_map_shrink+0x290>
blocks = map->size.count;
while (blocks)
1161ef: 8b 45 dc mov -0x24(%ebp),%eax
1161f2: 85 c0 test %eax,%eax
1161f4: 0f 84 76 02 00 00 je 116470 <rtems_rfs_block_map_shrink+0x2c0> <== NEVER TAKEN
rtems_rfs_block_no doubly_singly;
doubly = singly / fs->blocks_per_block;
doubly_singly = singly % fs->blocks_per_block;
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
1161fa: 8d 47 44 lea 0x44(%edi),%eax
doubly_singly);
/*
* Read the singly indirect table and get the block number.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
1161fd: 8b 75 08 mov 0x8(%ebp),%esi
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
116200: 89 45 d0 mov %eax,-0x30(%ebp)
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
116203: 8d 47 38 lea 0x38(%edi),%eax
116206: 89 45 d4 mov %eax,-0x2c(%ebp)
116209: eb 4b jmp 116256 <rtems_rfs_block_map_shrink+0xa6>
11620b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
11620f: 90 nop
block_to_free = map->blocks[block];
116210: 83 c1 07 add $0x7,%ecx
map->blocks[block] = 0;
116213: 31 c0 xor %eax,%eax
block_to_free = map->blocks[block];
116215: 8b 5c 8f 04 mov 0x4(%edi,%ecx,4),%ebx
map->blocks[block] = 0;
116219: 89 44 8f 04 mov %eax,0x4(%edi,%ecx,4)
{
rc = EIO;
break;
}
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
11621d: 89 5c 24 08 mov %ebx,0x8(%esp)
116221: 31 c0 xor %eax,%eax
116223: 89 44 24 04 mov %eax,0x4(%esp)
116227: 89 34 24 mov %esi,(%esp)
11622a: e8 d1 35 ff ff call 109800 <rtems_rfs_group_bitmap_free>
if (rc > 0)
11622f: 85 c0 test %eax,%eax
116231: 0f 8f 45 01 00 00 jg 11637c <rtems_rfs_block_map_shrink+0x1cc> <== NEVER TAKEN
return rc;
map->size.count--;
map->size.offset = 0;
116237: c7 47 0c 00 00 00 00 movl $0x0,0xc(%edi)
map->size.count--;
11623e: 8b 47 08 mov 0x8(%edi),%eax
while (blocks)
116241: ff 4d dc decl -0x24(%ebp)
map->last_data_block = block_to_free;
116244: 89 5f 20 mov %ebx,0x20(%edi)
map->dirty = true;
116247: c6 07 01 movb $0x1,(%edi)
map->size.count--;
11624a: 8d 48 ff lea -0x1(%eax),%ecx
11624d: 89 4f 08 mov %ecx,0x8(%edi)
while (blocks)
116250: 0f 84 aa 01 00 00 je 116400 <rtems_rfs_block_map_shrink+0x250>
block = map->size.count - 1;
116256: 8d 59 ff lea -0x1(%ecx),%ebx
if (block < RTEMS_RFS_INODE_BLOCKS)
116259: 83 fb 04 cmp $0x4,%ebx
11625c: 76 b2 jbe 116210 <rtems_rfs_block_map_shrink+0x60>
direct = block % fs->blocks_per_block;
11625e: 8b 46 34 mov 0x34(%esi),%eax
116261: 89 c2 mov %eax,%edx
116263: 89 d8 mov %ebx,%eax
116265: 89 55 e4 mov %edx,-0x1c(%ebp)
116268: 31 d2 xor %edx,%edx
11626a: f7 75 e4 divl -0x1c(%ebp)
if (block < fs->block_map_singly_blocks)
11626d: 39 5e 38 cmp %ebx,0x38(%esi)
116270: 89 55 d8 mov %edx,-0x28(%ebp)
116273: 89 45 e0 mov %eax,-0x20(%ebp)
116276: 0f 87 14 01 00 00 ja 116390 <rtems_rfs_block_map_shrink+0x1e0> <== ALWAYS TAKEN
else if (block < fs->block_map_doubly_blocks)
11627c: 39 5e 3c cmp %ebx,0x3c(%esi) <== NOT EXECUTED
11627f: 0f 86 7b 01 00 00 jbe 116400 <rtems_rfs_block_map_shrink+0x250> <== NOT EXECUTED
doubly = singly / fs->blocks_per_block;
116285: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED
116288: 31 d2 xor %edx,%edx <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
11628a: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED
11628f: 89 5c 24 0c mov %ebx,0xc(%esp) <== NOT EXECUTED
116293: f7 75 e4 divl -0x1c(%ebp) <== NOT EXECUTED
116296: 89 45 cc mov %eax,-0x34(%ebp) <== NOT EXECUTED
116299: 8b 44 87 24 mov 0x24(%edi,%eax,4),%eax <== NOT EXECUTED
11629d: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
1162a0: 89 55 e4 mov %edx,-0x1c(%ebp) <== NOT EXECUTED
1162a3: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
1162a7: 8b 45 d0 mov -0x30(%ebp),%eax <== NOT EXECUTED
1162aa: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1162ae: e8 1d 13 ff ff call 1075d0 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
1162b3: 85 c0 test %eax,%eax <== NOT EXECUTED
1162b5: 0f 8f c1 00 00 00 jg 11637c <rtems_rfs_block_map_shrink+0x1cc> <== NOT EXECUTED
singly = rtems_rfs_block_get_number (&map->doubly_buffer,
1162bb: 8b 47 4c mov 0x4c(%edi),%eax <== NOT EXECUTED
1162be: 8b 5d e4 mov -0x1c(%ebp),%ebx <== NOT EXECUTED
1162c1: 8b 48 1c mov 0x1c(%eax),%ecx <== NOT EXECUTED
1162c4: 0f b6 14 99 movzbl (%ecx,%ebx,4),%edx <== NOT EXECUTED
1162c8: 0f b6 44 99 03 movzbl 0x3(%ecx,%ebx,4),%eax <== NOT EXECUTED
1162cd: c1 e2 18 shl $0x18,%edx <== NOT EXECUTED
1162d0: 09 c2 or %eax,%edx <== NOT EXECUTED
1162d2: 0f b6 44 99 01 movzbl 0x1(%ecx,%ebx,4),%eax <== NOT EXECUTED
1162d7: c1 e0 10 shl $0x10,%eax <== NOT EXECUTED
1162da: 09 d0 or %edx,%eax <== NOT EXECUTED
1162dc: 0f b6 54 99 02 movzbl 0x2(%ecx,%ebx,4),%edx <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
1162e1: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED
1162e6: 89 4c 24 0c mov %ecx,0xc(%esp) <== NOT EXECUTED
1162ea: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
singly = rtems_rfs_block_get_number (&map->doubly_buffer,
1162ed: c1 e2 08 shl $0x8,%edx <== NOT EXECUTED
1162f0: 09 d0 or %edx,%eax <== NOT EXECUTED
1162f2: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
1162f5: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
1162f9: 8b 45 d4 mov -0x2c(%ebp),%eax <== NOT EXECUTED
1162fc: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
116300: e8 cb 12 ff ff call 1075d0 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
116305: 85 c0 test %eax,%eax <== NOT EXECUTED
116307: 7f 73 jg 11637c <rtems_rfs_block_map_shrink+0x1cc> <== NOT EXECUTED
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
116309: 8b 47 40 mov 0x40(%edi),%eax <== NOT EXECUTED
11630c: 8b 4d d8 mov -0x28(%ebp),%ecx <== NOT EXECUTED
11630f: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED
116312: 0f b6 04 8a movzbl (%edx,%ecx,4),%eax <== NOT EXECUTED
116316: 0f b6 5c 8a 03 movzbl 0x3(%edx,%ecx,4),%ebx <== NOT EXECUTED
11631b: c1 e0 18 shl $0x18,%eax <== NOT EXECUTED
11631e: 09 d8 or %ebx,%eax <== NOT EXECUTED
116320: 0f b6 5c 8a 01 movzbl 0x1(%edx,%ecx,4),%ebx <== NOT EXECUTED
116325: c1 e3 10 shl $0x10,%ebx <== NOT EXECUTED
116328: 09 c3 or %eax,%ebx <== NOT EXECUTED
11632a: 0f b6 44 8a 02 movzbl 0x2(%edx,%ecx,4),%eax <== NOT EXECUTED
11632f: c1 e0 08 shl $0x8,%eax <== NOT EXECUTED
116332: 09 c3 or %eax,%ebx <== NOT EXECUTED
if (direct == 0)
116334: 85 c9 test %ecx,%ecx <== NOT EXECUTED
116336: 0f 85 e1 fe ff ff jne 11621d <rtems_rfs_block_map_shrink+0x6d> <== NOT EXECUTED
rc = rtems_rfs_group_bitmap_free (fs, false, singly);
11633c: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
11633f: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED
116342: 31 d2 xor %edx,%edx <== NOT EXECUTED
116344: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
116348: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
11634c: e8 af 34 ff ff call 109800 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
if (rc > 0)
116351: 85 c0 test %eax,%eax <== NOT EXECUTED
116353: 7f 27 jg 11637c <rtems_rfs_block_map_shrink+0x1cc> <== NOT EXECUTED
map->last_map_block = singly;
116355: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->doubly_buffer,
116358: 8b 4d d0 mov -0x30(%ebp),%ecx <== NOT EXECUTED
map->last_map_block = singly;
11635b: 89 47 1c mov %eax,0x1c(%edi) <== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->doubly_buffer,
11635e: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED
116361: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
116365: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED
116368: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
11636b: 89 fa mov %edi,%edx
11636d: 89 f0 mov %esi,%eax
11636f: e8 0c f1 ff ff call 115480 <rtems_rfs_block_map_indirect_shrink>
if (rc)
116374: 85 c0 test %eax,%eax
116376: 0f 84 a1 fe ff ff je 11621d <rtems_rfs_block_map_shrink+0x6d> <== ALWAYS TAKEN
*/
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
return 0;
}
11637c: 83 c4 3c add $0x3c,%esp <== NOT EXECUTED
11637f: 5b pop %ebx <== NOT EXECUTED
116380: 5e pop %esi <== NOT EXECUTED
116381: 5f pop %edi <== NOT EXECUTED
116382: 5d pop %ebp <== NOT EXECUTED
116383: c3 ret <== NOT EXECUTED
116384: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11638b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11638f: 90 nop <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
116390: ba 01 00 00 00 mov $0x1,%edx
116395: 89 54 24 0c mov %edx,0xc(%esp)
116399: 8b 55 d4 mov -0x2c(%ebp),%edx
11639c: 8b 44 87 24 mov 0x24(%edi,%eax,4),%eax
1163a0: 89 34 24 mov %esi,(%esp)
1163a3: 89 54 24 04 mov %edx,0x4(%esp)
1163a7: 89 44 24 08 mov %eax,0x8(%esp)
1163ab: e8 20 12 ff ff call 1075d0 <rtems_rfs_buffer_handle_request>
if (rc > 0)
1163b0: 85 c0 test %eax,%eax
1163b2: 7f c8 jg 11637c <rtems_rfs_block_map_shrink+0x1cc> <== NEVER TAKEN
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
1163b4: 8b 47 40 mov 0x40(%edi),%eax
1163b7: 8b 4d d8 mov -0x28(%ebp),%ecx
1163ba: 8b 50 1c mov 0x1c(%eax),%edx
1163bd: 0f b6 04 8a movzbl (%edx,%ecx,4),%eax
1163c1: 0f b6 5c 8a 03 movzbl 0x3(%edx,%ecx,4),%ebx
1163c6: c1 e0 18 shl $0x18,%eax
1163c9: 09 d8 or %ebx,%eax
1163cb: 0f b6 5c 8a 01 movzbl 0x1(%edx,%ecx,4),%ebx
1163d0: c1 e3 10 shl $0x10,%ebx
1163d3: 09 c3 or %eax,%ebx
1163d5: 0f b6 44 8a 02 movzbl 0x2(%edx,%ecx,4),%eax
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
1163da: 89 4c 24 04 mov %ecx,0x4(%esp)
1163de: 8b 4d d4 mov -0x2c(%ebp),%ecx
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
1163e1: c1 e0 08 shl $0x8,%eax
1163e4: 09 c3 or %eax,%ebx
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
1163e6: 8b 45 e0 mov -0x20(%ebp),%eax
1163e9: 89 04 24 mov %eax,(%esp)
1163ec: e9 7a ff ff ff jmp 11636b <rtems_rfs_block_map_shrink+0x1bb>
1163f1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1163f8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1163ff: 90 nop
if (map->size.count == 0)
116400: 85 c9 test %ecx,%ecx
116402: 75 6c jne 116470 <rtems_rfs_block_map_shrink+0x2c0>
map->last_map_block = 0;
116404: c7 47 1c 00 00 00 00 movl $0x0,0x1c(%edi)
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
11640b: 8b 47 0c mov 0xc(%edi),%eax
map->last_data_block = 0;
11640e: c7 47 20 00 00 00 00 movl $0x0,0x20(%edi)
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
116415: 89 4f 10 mov %ecx,0x10(%edi)
116418: 85 c0 test %eax,%eax
11641a: 89 47 14 mov %eax,0x14(%edi)
11641d: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi)
116424: 74 0a je 116430 <rtems_rfs_block_map_shrink+0x280> <== ALWAYS TAKEN
116426: 8d 41 ff lea -0x1(%ecx),%eax <== NOT EXECUTED
116429: 89 47 10 mov %eax,0x10(%edi) <== NOT EXECUTED
11642c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
return 0;
116430: 31 c0 xor %eax,%eax
}
116432: 83 c4 3c add $0x3c,%esp
116435: 5b pop %ebx
116436: 5e pop %esi
116437: 5f pop %edi
116438: 5d pop %ebp
116439: c3 ret
11643a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
116440: 89 5d dc mov %ebx,-0x24(%ebp)
116443: e9 a7 fd ff ff jmp 1161ef <rtems_rfs_block_map_shrink+0x3f>
116448: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11644f: 90 nop
printf ("rtems-rfs: block-map-shrink: entry: blocks=%zd count=%" PRIu32 "\n",
116450: 8b 47 08 mov 0x8(%edi),%eax <== NOT EXECUTED
116453: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
116457: c7 04 24 48 53 13 00 movl $0x135348,(%esp) <== NOT EXECUTED
11645e: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
116462: e8 d9 bc fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
116467: e9 6d fd ff ff jmp 1161d9 <rtems_rfs_block_map_shrink+0x29> <== NOT EXECUTED
11646c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
116470: 8b 47 10 mov 0x10(%edi),%eax
116473: 39 c8 cmp %ecx,%eax
116475: 73 13 jae 11648a <rtems_rfs_block_map_shrink+0x2da> <== NEVER TAKEN
116477: 8d 51 ff lea -0x1(%ecx),%edx
11647a: 39 d0 cmp %edx,%eax
11647c: 75 b2 jne 116430 <rtems_rfs_block_map_shrink+0x280> <== NEVER TAKEN
11647e: 8b 47 0c mov 0xc(%edi),%eax
116481: 39 47 14 cmp %eax,0x14(%edi)
116484: 77 8f ja 116415 <rtems_rfs_block_map_shrink+0x265> <== ALWAYS TAKEN
return 0;
116486: 31 c0 xor %eax,%eax
116488: eb a8 jmp 116432 <rtems_rfs_block_map_shrink+0x282> <== NOT EXECUTED
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
11648a: 8b 47 0c mov 0xc(%edi),%eax <== NOT EXECUTED
11648d: eb 86 jmp 116415 <rtems_rfs_block_map_shrink+0x265> <== NOT EXECUTED
11648f: 90 nop
00116520 <rtems_rfs_buffer_bdbuf_release>:
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
116520: 55 push %ebp
rtems_status_code sc;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
116521: 31 c0 xor %eax,%eax
{
116523: 89 e5 mov %esp,%ebp
116525: 56 push %esi
116526: 53 push %ebx
116527: 83 ec 10 sub $0x10,%esp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
11652a: c7 04 24 40 00 00 00 movl $0x40,(%esp)
{
116531: 8b 75 08 mov 0x8(%ebp),%esi
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
116534: 89 44 24 04 mov %eax,0x4(%esp)
{
116538: 0f b6 5d 0c movzbl 0xc(%ebp),%ebx
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
11653c: e8 0f 53 ff ff call 10b850 <rtems_rfs_trace>
116541: 84 c0 test %al,%al
116543: 74 27 je 11656c <rtems_rfs_buffer_bdbuf_release+0x4c> <== ALWAYS TAKEN
printf ("rtems-rfs: bdbuf-release: block=%" PRIuPTR " bdbuf=%" PRIu32 " %s\n",
116545: 84 db test %bl,%bl <== NOT EXECUTED
116547: b8 81 53 13 00 mov $0x135381,%eax <== NOT EXECUTED
11654c: 74 52 je 1165a0 <rtems_rfs_buffer_bdbuf_release+0x80> <== NOT EXECUTED
11654e: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
116552: 8b 46 18 mov 0x18(%esi),%eax <== NOT EXECUTED
116555: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
116559: 8b 46 34 mov 0x34(%esi),%eax <== NOT EXECUTED
11655c: c7 04 24 8c 53 13 00 movl $0x13538c,(%esp) <== NOT EXECUTED
116563: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
116567: e8 d4 bb fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
((intptr_t) buffer->user),
buffer->block, modified ? "(modified)" : "");
if (modified)
sc = rtems_bdbuf_release_modified (buffer);
11656c: 89 34 24 mov %esi,(%esp)
if (modified)
11656f: 84 db test %bl,%bl
116571: 74 1d je 116590 <rtems_rfs_buffer_bdbuf_release+0x70>
sc = rtems_bdbuf_release_modified (buffer);
116573: e8 a8 cb ff ff call 113120 <rtems_bdbuf_release_modified>
#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;
116578: 83 f8 01 cmp $0x1,%eax
11657b: 19 c0 sbb %eax,%eax
}
return rc;
}
11657d: 83 c4 10 add $0x10,%esp
116580: 5b pop %ebx
rc = EIO;
116581: f7 d0 not %eax
116583: 83 e0 05 and $0x5,%eax
}
116586: 5e pop %esi
116587: 5d pop %ebp
116588: c3 ret
116589: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
sc = rtems_bdbuf_release (buffer);
116590: e8 8b ca ff ff call 113020 <rtems_bdbuf_release>
116595: eb e1 jmp 116578 <rtems_rfs_buffer_bdbuf_release+0x58>
116597: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11659e: 66 90 xchg %ax,%ax
printf ("rtems-rfs: bdbuf-release: block=%" PRIuPTR " bdbuf=%" PRIu32 " %s\n",
1165a0: b8 b9 33 13 00 mov $0x1333b9,%eax <== NOT EXECUTED
1165a5: eb a7 jmp 11654e <rtems_rfs_buffer_bdbuf_release+0x2e> <== NOT EXECUTED
1165a7: 90 nop
1165a8: 90 nop
1165a9: 90 nop
1165aa: 90 nop
1165ab: 90 nop
1165ac: 90 nop
1165ad: 90 nop
1165ae: 90 nop
1165af: 90 nop
00107d40 <rtems_rfs_buffer_close>:
{
107d40: 55 push %ebp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
107d41: 31 c9 xor %ecx,%ecx
{
107d43: 89 e5 mov %esp,%ebp
107d45: 56 push %esi
107d46: 53 push %ebx
107d47: 83 ec 10 sub $0x10,%esp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
107d4a: c7 04 24 10 00 00 00 movl $0x10,(%esp)
{
107d51: 8b 75 08 mov 0x8(%ebp),%esi
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
107d54: 89 4c 24 04 mov %ecx,0x4(%esp)
107d58: e8 f3 3a 00 00 call 10b850 <rtems_rfs_trace>
107d5d: 84 c0 test %al,%al
107d5f: 0f 85 db 00 00 00 jne 107e40 <rtems_rfs_buffer_close+0x100> <== NEVER TAKEN
rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_media_block_size (fs));
107d65: 8b 46 10 mov 0x10(%esi),%eax
107d68: 8b 40 20 mov 0x20(%eax),%eax
107d6b: 89 34 24 mov %esi,(%esp)
107d6e: 89 44 24 04 mov %eax,0x4(%esp)
107d72: e8 a9 fe ff ff call 107c20 <rtems_rfs_buffer_setblksize>
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
107d77: 85 c0 test %eax,%eax
rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_media_block_size (fs));
107d79: 89 c3 mov %eax,%ebx
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
107d7b: 7f 23 jg 107da0 <rtems_rfs_buffer_close+0x60> <== NEVER TAKEN
if (close (fs->device) < 0)
107d7d: 8b 46 0c mov 0xc(%esi),%eax
107d80: 89 04 24 mov %eax,(%esp)
107d83: e8 88 c2 00 00 call 114010 <close>
107d88: 85 c0 test %eax,%eax
107d8a: 78 64 js 107df0 <rtems_rfs_buffer_close+0xb0> <== NEVER TAKEN
}
107d8c: 83 c4 10 add $0x10,%esp
107d8f: 89 d8 mov %ebx,%eax
107d91: 5b pop %ebx
107d92: 5e pop %esi
107d93: 5d pop %ebp
107d94: c3 ret
107d95: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
107d9c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
107da0: c7 04 24 10 00 00 00 movl $0x10,(%esp) <== NOT EXECUTED
107da7: 31 d2 xor %edx,%edx <== NOT EXECUTED
107da9: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
107dad: e8 9e 3a 00 00 call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
107db2: 84 c0 test %al,%al <== NOT EXECUTED
107db4: 74 c7 je 107d7d <rtems_rfs_buffer_close+0x3d> <== NOT EXECUTED
printf ("rtems-rfs: buffer-close: set media block size failed: %d: %s\n",
107db6: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
107db9: e8 62 36 02 00 call 12b420 <strerror> <== NOT EXECUTED
107dbe: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
107dc2: c7 04 24 f8 3b 13 00 movl $0x133bf8,(%esp) <== NOT EXECUTED
107dc9: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
107dcd: e8 6e a3 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
if (close (fs->device) < 0)
107dd2: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED
107dd5: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
107dd8: e8 33 c2 00 00 call 114010 <close> <== NOT EXECUTED
107ddd: 85 c0 test %eax,%eax <== NOT EXECUTED
107ddf: 79 ab jns 107d8c <rtems_rfs_buffer_close+0x4c> <== NOT EXECUTED
107de1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
107de8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
107def: 90 nop <== NOT EXECUTED
rc = errno;
107df0: e8 0b 27 02 00 call 12a500 <__errno> <== NOT EXECUTED
107df5: 8b 18 mov (%eax),%ebx <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
107df7: 31 c0 xor %eax,%eax <== NOT EXECUTED
107df9: c7 04 24 10 00 00 00 movl $0x10,(%esp) <== NOT EXECUTED
107e00: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
107e04: e8 47 3a 00 00 call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
107e09: 84 c0 test %al,%al <== NOT EXECUTED
107e0b: 0f 84 7b ff ff ff je 107d8c <rtems_rfs_buffer_close+0x4c> <== NOT EXECUTED
printf ("rtems-rfs: buffer-close: file close failed: %d: %s\n",
107e11: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
107e14: e8 07 36 02 00 call 12b420 <strerror> <== NOT EXECUTED
107e19: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
107e1d: c7 04 24 38 3c 13 00 movl $0x133c38,(%esp) <== NOT EXECUTED
107e24: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
107e28: e8 13 a3 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
return rc;
107e2d: e9 5a ff ff ff jmp 107d8c <rtems_rfs_buffer_close+0x4c> <== NOT EXECUTED
107e32: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
107e39: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
printf ("rtems-rfs: buffer-close: closing\n");
107e40: c7 04 24 d4 3b 13 00 movl $0x133bd4,(%esp) <== NOT EXECUTED
107e47: e8 24 a3 ff ff call 102170 <__wrap_puts> <== NOT EXECUTED
107e4c: e9 14 ff ff ff jmp 107d65 <rtems_rfs_buffer_close+0x25> <== NOT EXECUTED
107e51: 90 nop
107e52: 90 nop
107e53: 90 nop
107e54: 90 nop
107e55: 90 nop
107e56: 90 nop
107e57: 90 nop
107e58: 90 nop
107e59: 90 nop
107e5a: 90 nop
107e5b: 90 nop
107e5c: 90 nop
107e5d: 90 nop
107e5e: 90 nop
107e5f: 90 nop
001073c0 <rtems_rfs_buffer_handle_release.part.0>:
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
1073c0: 55 push %ebp <== NOT EXECUTED
1073c1: 89 e5 mov %esp,%ebp <== NOT EXECUTED
1073c3: 57 push %edi <== NOT EXECUTED
1073c4: 89 d7 mov %edx,%edi <== NOT EXECUTED
1073c6: 56 push %esi <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
1073c7: 31 f6 xor %esi,%esi
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
1073c9: 53 push %ebx
1073ca: 89 c3 mov %eax,%ebx
1073cc: 83 ec 3c sub $0x3c,%esp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
1073cf: c7 04 24 00 02 00 00 movl $0x200,(%esp)
1073d6: 89 74 24 04 mov %esi,0x4(%esp)
1073da: e8 71 44 00 00 call 10b850 <rtems_rfs_trace>
1073df: 84 c0 test %al,%al
1073e1: 74 40 je 107423 <rtems_rfs_buffer_handle_release.part.0+0x63>
rtems_rfs_buffer_refs (handle) == 0 ? "BAD REF COUNT" : "");
1073e3: 8b 47 08 mov 0x8(%edi),%eax
printf ("rtems-rfs: buffer-release: block=%" PRIu32 " %s refs=%d %s\n",
1073e6: b9 e8 37 13 00 mov $0x1337e8,%ecx
rtems_rfs_buffer_refs (handle) == 0 ? "BAD REF COUNT" : "");
1073eb: 8b 40 30 mov 0x30(%eax),%eax
printf ("rtems-rfs: buffer-release: block=%" PRIu32 " %s refs=%d %s\n",
1073ee: 85 c0 test %eax,%eax
1073f0: 0f 85 ba 00 00 00 jne 1074b0 <rtems_rfs_buffer_handle_release.part.0+0xf0>
1073f6: 80 3f 00 cmpb $0x0,(%edi)
1073f9: ba f6 37 13 00 mov $0x1337f6,%edx
1073fe: 0f 84 9c 00 00 00 je 1074a0 <rtems_rfs_buffer_handle_release.part.0+0xe0>
107404: 89 44 24 0c mov %eax,0xc(%esp)
107408: 8b 47 04 mov 0x4(%edi),%eax
10740b: 89 4c 24 10 mov %ecx,0x10(%esp)
10740f: 89 54 24 08 mov %edx,0x8(%esp)
107413: c7 04 24 00 38 13 00 movl $0x133800,(%esp)
10741a: 89 44 24 04 mov %eax,0x4(%esp)
10741e: e8 1d ad ff ff call 102140 <__wrap_printf>
if (rtems_rfs_buffer_refs (handle) > 0)
107423: 8b 47 08 mov 0x8(%edi),%eax
107426: 8b 70 30 mov 0x30(%eax),%esi
107429: 85 f6 test %esi,%esi
10742b: 7e 04 jle 107431 <rtems_rfs_buffer_handle_release.part.0+0x71>
rtems_rfs_buffer_refs_down (handle);
10742d: 4e dec %esi
10742e: 89 70 30 mov %esi,0x30(%eax)
if (rtems_rfs_buffer_refs (handle) == 0)
107431: 85 f6 test %esi,%esi
107433: 75 4b jne 107480 <rtems_rfs_buffer_handle_release.part.0+0xc0>
next = the_node->next;
107435: 8b 08 mov (%eax),%ecx
previous = the_node->previous;
107437: 8b 50 04 mov 0x4(%eax),%edx
next->previous = previous;
10743a: 89 51 04 mov %edx,0x4(%ecx)
previous->next = next;
10743d: 89 0a mov %ecx,(%edx)
fs->buffers_count--;
10743f: ff 4b 50 decl 0x50(%ebx)
if (rtems_rfs_fs_no_local_cache (fs))
107442: f6 03 02 testb $0x2,(%ebx)
107445: 0f 85 a5 00 00 00 jne 1074f0 <rtems_rfs_buffer_handle_release.part.0+0x130>
if ((fs->release_count +
10744b: 8b 53 70 mov 0x70(%ebx),%edx
10744e: 8b 4b 60 mov 0x60(%ebx),%ecx
107451: 01 ca add %ecx,%edx
107453: 3b 53 40 cmp 0x40(%ebx),%edx
107456: 0f 83 b4 00 00 00 jae 107510 <rtems_rfs_buffer_handle_release.part.0+0x150>
if (rtems_rfs_buffer_dirty (handle))
10745c: 80 3f 00 cmpb $0x0,(%edi)
10745f: 74 6f je 1074d0 <rtems_rfs_buffer_handle_release.part.0+0x110>
old_last = tail->previous;
107461: 8b 53 6c mov 0x6c(%ebx),%edx
return &the_chain->Tail.Node;
107464: 8d 4b 68 lea 0x68(%ebx),%ecx
107467: 89 08 mov %ecx,(%eax)
tail->previous = the_node;
107469: 89 43 6c mov %eax,0x6c(%ebx)
old_last->next = the_node;
10746c: 89 02 mov %eax,(%edx)
the_node->previous = old_last;
10746e: 89 50 04 mov %edx,0x4(%eax)
fs->release_modified_count++;
107471: ff 43 70 incl 0x70(%ebx)
107474: eb 0c jmp 107482 <rtems_rfs_buffer_handle_release.part.0+0xc2>
107476: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10747d: 8d 76 00 lea 0x0(%esi),%esi
int rc = 0;
107480: 31 f6 xor %esi,%esi
handle->buffer = NULL;
107482: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi)
}
107489: 83 c4 3c add $0x3c,%esp
10748c: 89 f0 mov %esi,%eax
10748e: 5b pop %ebx
10748f: 5e pop %esi
107490: 5f pop %edi
107491: 5d pop %ebp
107492: c3 ret
107493: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10749a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
printf ("rtems-rfs: buffer-release: block=%" PRIu32 " %s refs=%d %s\n",
1074a0: ba b9 33 13 00 mov $0x1333b9,%edx
1074a5: e9 5a ff ff ff jmp 107404 <rtems_rfs_buffer_handle_release.part.0+0x44>
1074aa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
1074b0: 80 3f 00 cmpb $0x0,(%edi)
1074b3: b9 b9 33 13 00 mov $0x1333b9,%ecx
1074b8: ba f6 37 13 00 mov $0x1337f6,%edx
1074bd: 0f 85 41 ff ff ff jne 107404 <rtems_rfs_buffer_handle_release.part.0+0x44>
1074c3: eb db jmp 1074a0 <rtems_rfs_buffer_handle_release.part.0+0xe0>
1074c5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1074cc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
old_last = tail->previous;
1074d0: 8b 53 5c mov 0x5c(%ebx),%edx
return &the_chain->Tail.Node;
1074d3: 8d 4b 58 lea 0x58(%ebx),%ecx
1074d6: 89 08 mov %ecx,(%eax)
tail->previous = the_node;
1074d8: 89 43 5c mov %eax,0x5c(%ebx)
old_last->next = the_node;
1074db: 89 02 mov %eax,(%edx)
the_node->previous = old_last;
1074dd: 89 50 04 mov %edx,0x4(%eax)
fs->release_count++;
1074e0: ff 43 60 incl 0x60(%ebx)
1074e3: eb 9d jmp 107482 <rtems_rfs_buffer_handle_release.part.0+0xc2>
1074e5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1074ec: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
handle->buffer->user = (void*) 0;
1074f0: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax)
rc = rtems_rfs_buffer_io_release (handle->buffer,
1074f7: 0f b6 17 movzbl (%edi),%edx
1074fa: 89 04 24 mov %eax,(%esp)
1074fd: 89 54 24 04 mov %edx,0x4(%esp)
107501: e8 1a f0 00 00 call 116520 <rtems_rfs_buffer_bdbuf_release>
107506: 89 c6 mov %eax,%esi
107508: e9 75 ff ff ff jmp 107482 <rtems_rfs_buffer_handle_release.part.0+0xc2>
10750d: 8d 76 00 lea 0x0(%esi),%esi
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
107510: c7 04 24 00 02 00 00 movl $0x200,(%esp)
107517: 31 c9 xor %ecx,%ecx
107519: 89 4c 24 04 mov %ecx,0x4(%esp)
10751d: e8 2e 43 00 00 call 10b850 <rtems_rfs_trace>
107522: 84 c0 test %al,%al
107524: 0f 85 86 00 00 00 jne 1075b0 <rtems_rfs_buffer_handle_release.part.0+0x1f0>
if (fs->release_count > fs->release_modified_count)
10752a: 8b 43 60 mov 0x60(%ebx),%eax
10752d: 8b 4b 70 mov 0x70(%ebx),%ecx
107530: 89 45 e4 mov %eax,-0x1c(%ebp)
107533: 39 c8 cmp %ecx,%eax
107535: 76 29 jbe 107560 <rtems_rfs_buffer_handle_release.part.0+0x1a0>
return _Chain_Immutable_head( the_chain )->next;
107537: 8b 43 54 mov 0x54(%ebx),%eax
return &the_chain->Tail.Node;
10753a: 8d 4b 54 lea 0x54(%ebx),%ecx
10753d: 89 ca mov %ecx,%edx
10753f: 8d 4b 58 lea 0x58(%ebx),%ecx
if ( !_Chain_Is_empty(the_chain))
107542: 39 c8 cmp %ecx,%eax
107544: 74 55 je 10759b <rtems_rfs_buffer_handle_release.part.0+0x1db>
new_first = old_first->next;
107546: 8b 08 mov (%eax),%ecx
head->next = new_first;
107548: 89 4b 54 mov %ecx,0x54(%ebx)
return &the_chain->Head.Node;
10754b: 89 51 04 mov %edx,0x4(%ecx)
fs->release_count--;
10754e: 8b 55 e4 mov -0x1c(%ebp),%edx
107551: 4a dec %edx
107552: 89 53 60 mov %edx,0x60(%ebx)
modified = false;
107555: eb 27 jmp 10757e <rtems_rfs_buffer_handle_release.part.0+0x1be>
107557: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10755e: 66 90 xchg %ax,%ax
return _Chain_Immutable_head( the_chain )->next;
107560: 8b 43 64 mov 0x64(%ebx),%eax
return &the_chain->Tail.Node;
107563: 8d 53 68 lea 0x68(%ebx),%edx
107566: 8d 73 64 lea 0x64(%ebx),%esi
if ( !_Chain_Is_empty(the_chain))
107569: 39 d0 cmp %edx,%eax
10756b: 74 32 je 10759f <rtems_rfs_buffer_handle_release.part.0+0x1df>
new_first = old_first->next;
10756d: 8b 10 mov (%eax),%edx
head->next = new_first;
10756f: 89 53 64 mov %edx,0x64(%ebx)
return &the_chain->Head.Node;
107572: 89 72 04 mov %esi,0x4(%edx)
fs->release_modified_count--;
107575: 49 dec %ecx
107576: be 01 00 00 00 mov $0x1,%esi
10757b: 89 4b 70 mov %ecx,0x70(%ebx)
buffer->user = (void*) 0;
10757e: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax)
rc = rtems_rfs_buffer_io_release (buffer, modified);
107585: 89 74 24 04 mov %esi,0x4(%esp)
107589: 89 04 24 mov %eax,(%esp)
10758c: e8 8f ef 00 00 call 116520 <rtems_rfs_buffer_bdbuf_release>
107591: 89 c6 mov %eax,%esi
rtems_rfs_buffer_link (handle));
107593: 8b 47 08 mov 0x8(%edi),%eax
107596: e9 c1 fe ff ff jmp 10745c <rtems_rfs_buffer_handle_release.part.0+0x9c>
return NULL;
10759b: 31 c0 xor %eax,%eax
10759d: eb af jmp 10754e <rtems_rfs_buffer_handle_release.part.0+0x18e>
10759f: 31 c0 xor %eax,%eax
1075a1: eb d2 jmp 107575 <rtems_rfs_buffer_handle_release.part.0+0x1b5>
1075a3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1075aa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
printf ("rtems-rfs: buffer-release: local cache overflow:"
1075b0: c7 04 24 34 38 13 00 movl $0x133834,(%esp)
1075b7: 8b 43 70 mov 0x70(%ebx),%eax
1075ba: 8b 53 60 mov 0x60(%ebx),%edx
1075bd: 01 d0 add %edx,%eax
1075bf: 89 44 24 04 mov %eax,0x4(%esp)
1075c3: e8 78 ab ff ff call 102140 <__wrap_printf>
1075c8: e9 5d ff ff ff jmp 10752a <rtems_rfs_buffer_handle_release.part.0+0x16a>
1075cd: 90 nop
1075ce: 90 nop
1075cf: 90 nop
001075d0 <rtems_rfs_buffer_handle_request>:
{
1075d0: 55 push %ebp
1075d1: 89 e5 mov %esp,%ebp
1075d3: 57 push %edi
1075d4: 56 push %esi
1075d5: 53 push %ebx
1075d6: 83 ec 3c sub $0x3c,%esp
1075d9: 8b 5d 0c mov 0xc(%ebp),%ebx
1075dc: 0f b6 45 14 movzbl 0x14(%ebp),%eax
1075e0: 8b 75 08 mov 0x8(%ebp),%esi
1075e3: 8b 7d 10 mov 0x10(%ebp),%edi
if (rtems_rfs_buffer_handle_has_block (handle))
1075e6: 8b 4b 08 mov 0x8(%ebx),%ecx
{
1075e9: 88 45 e4 mov %al,-0x1c(%ebp)
if (rtems_rfs_buffer_handle_has_block (handle))
1075ec: 85 c9 test %ecx,%ecx
1075ee: 74 4b je 10763b <rtems_rfs_buffer_handle_request+0x6b>
if (block && (rtems_rfs_buffer_bnum (handle) == block))
1075f0: 85 ff test %edi,%edi
1075f2: 74 09 je 1075fd <rtems_rfs_buffer_handle_request+0x2d> <== NEVER TAKEN
1075f4: 39 7b 04 cmp %edi,0x4(%ebx)
1075f7: 0f 84 dd 00 00 00 je 1076da <rtems_rfs_buffer_handle_request+0x10a>
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
1075fd: c7 04 24 00 01 00 00 movl $0x100,(%esp)
107604: 31 d2 xor %edx,%edx
107606: 89 54 24 04 mov %edx,0x4(%esp)
10760a: e8 41 42 00 00 call 10b850 <rtems_rfs_trace>
10760f: 84 c0 test %al,%al
107611: 0f 85 89 01 00 00 jne 1077a0 <rtems_rfs_buffer_handle_request+0x1d0> <== NEVER TAKEN
if (rtems_rfs_buffer_handle_has_block (handle))
107617: 8b 43 08 mov 0x8(%ebx),%eax
10761a: 85 c0 test %eax,%eax
10761c: 74 13 je 107631 <rtems_rfs_buffer_handle_request+0x61> <== NEVER TAKEN
10761e: 89 da mov %ebx,%edx
107620: 89 f0 mov %esi,%eax
107622: e8 99 fd ff ff call 1073c0 <rtems_rfs_buffer_handle_release.part.0>
if (rc > 0)
107627: 85 c0 test %eax,%eax
107629: 89 c2 mov %eax,%edx
10762b: 0f 8f ab 00 00 00 jg 1076dc <rtems_rfs_buffer_handle_request+0x10c> <== NEVER TAKEN
handle->dirty = false;
107631: c6 03 00 movb $0x0,(%ebx)
handle->bnum = 0;
107634: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx)
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
10763b: c7 04 24 00 01 00 00 movl $0x100,(%esp)
107642: 31 c0 xor %eax,%eax
107644: 89 44 24 04 mov %eax,0x4(%esp)
107648: e8 03 42 00 00 call 10b850 <rtems_rfs_trace>
10764d: 84 c0 test %al,%al
10764f: 0f 85 2b 01 00 00 jne 107780 <rtems_rfs_buffer_handle_request+0x1b0> <== NEVER TAKEN
if (fs->buffers_count)
107655: 8b 46 50 mov 0x50(%esi),%eax
107658: 85 c0 test %eax,%eax
10765a: 0f 85 d0 00 00 00 jne 107730 <rtems_rfs_buffer_handle_request+0x160>
if (!rtems_rfs_fs_no_local_cache (fs) &&
107660: f6 06 02 testb $0x2,(%esi)
!rtems_rfs_buffer_handle_has_block (handle))
107663: 8b 43 08 mov 0x8(%ebx),%eax
if (!rtems_rfs_fs_no_local_cache (fs) &&
107666: 0f 85 84 00 00 00 jne 1076f0 <rtems_rfs_buffer_handle_request+0x120>
10766c: 85 c0 test %eax,%eax
10766e: 0f 84 75 01 00 00 je 1077e9 <rtems_rfs_buffer_handle_request+0x219>
old_last = tail->previous;
107674: 8b 56 4c mov 0x4c(%esi),%edx
return &the_chain->Tail.Node;
107677: 8d 4e 48 lea 0x48(%esi),%ecx
rtems_rfs_buffer_refs_up (handle);
10767a: ff 40 30 incl 0x30(%eax)
10767d: 89 08 mov %ecx,(%eax)
tail->previous = the_node;
10767f: 89 46 4c mov %eax,0x4c(%esi)
old_last->next = the_node;
107682: 89 02 mov %eax,(%edx)
the_node->previous = old_last;
107684: 89 50 04 mov %edx,0x4(%eax)
fs->buffers_count++;
107687: ff 46 50 incl 0x50(%esi)
handle->buffer->user = (void*) ((intptr_t) block);
10768a: 89 78 34 mov %edi,0x34(%eax)
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
10768d: 31 c0 xor %eax,%eax
handle->bnum = block;
10768f: 89 7b 04 mov %edi,0x4(%ebx)
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
107692: c7 04 24 00 01 00 00 movl $0x100,(%esp)
107699: 89 44 24 04 mov %eax,0x4(%esp)
10769d: e8 ae 41 00 00 call 10b850 <rtems_rfs_trace>
1076a2: 84 c0 test %al,%al
1076a4: 74 34 je 1076da <rtems_rfs_buffer_handle_request+0x10a> <== ALWAYS TAKEN
handle->buffer->references);
1076a6: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED
printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
1076a9: 80 7d e4 00 cmpb $0x0,-0x1c(%ebp) <== NOT EXECUTED
1076ad: 8b 48 30 mov 0x30(%eax),%ecx <== NOT EXECUTED
1076b0: 8b 50 18 mov 0x18(%eax),%edx <== NOT EXECUTED
1076b3: b8 69 38 13 00 mov $0x133869,%eax <== NOT EXECUTED
1076b8: 0f 84 12 01 00 00 je 1077d0 <rtems_rfs_buffer_handle_request+0x200> <== NOT EXECUTED
1076be: 89 4c 24 10 mov %ecx,0x10(%esp) <== NOT EXECUTED
1076c2: 89 54 24 0c mov %edx,0xc(%esp) <== NOT EXECUTED
1076c6: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
1076ca: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED
1076ce: c7 04 24 3c 39 13 00 movl $0x13393c,(%esp) <== NOT EXECUTED
1076d5: e8 66 aa ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
return 0;
1076da: 31 d2 xor %edx,%edx
}
1076dc: 83 c4 3c add $0x3c,%esp
1076df: 89 d0 mov %edx,%eax
1076e1: 5b pop %ebx
1076e2: 5e pop %esi
1076e3: 5f pop %edi
1076e4: 5d pop %ebp
1076e5: c3 ret
1076e6: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1076ed: 8d 76 00 lea 0x0(%esi),%esi
if (!rtems_rfs_buffer_handle_has_block (handle))
1076f0: 85 c0 test %eax,%eax
1076f2: 0f 85 7c ff ff ff jne 107674 <rtems_rfs_buffer_handle_request+0xa4> <== NEVER TAKEN
rc = rtems_rfs_buffer_io_request (fs, block, read, &handle->buffer);
1076f8: 89 7c 24 04 mov %edi,0x4(%esp)
1076fc: 8d 43 08 lea 0x8(%ebx),%eax
1076ff: 89 44 24 0c mov %eax,0xc(%esp)
107703: 0f b6 45 e4 movzbl -0x1c(%ebp),%eax
107707: 89 34 24 mov %esi,(%esp)
10770a: 89 44 24 08 mov %eax,0x8(%esp)
10770e: e8 ad ed 00 00 call 1164c0 <rtems_rfs_buffer_bdbuf_request>
if (rc > 0)
107713: 85 c0 test %eax,%eax
rc = rtems_rfs_buffer_io_request (fs, block, read, &handle->buffer);
107715: 89 c2 mov %eax,%edx
if (rc > 0)
107717: 0f 8f 03 01 00 00 jg 107820 <rtems_rfs_buffer_handle_request+0x250> <== NEVER TAKEN
rtems_chain_set_off_chain (rtems_rfs_buffer_link(handle));
10771d: 8b 43 08 mov 0x8(%ebx),%eax
node->next = NULL;
107720: c7 00 00 00 00 00 movl $0x0,(%eax)
RTEMS_INLINE_ROUTINE void rtems_chain_set_off_chain(
rtems_chain_node *node
)
{
_Chain_Set_off_chain( node );
}
107726: e9 49 ff ff ff jmp 107674 <rtems_rfs_buffer_handle_request+0xa4>
10772b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10772f: 90 nop
handle->buffer = rtems_rfs_scan_chain (&fs->buffers,
107730: 8d 56 50 lea 0x50(%esi),%edx
107733: 89 f9 mov %edi,%ecx
107735: 8d 46 44 lea 0x44(%esi),%eax
107738: e8 b3 fa ff ff call 1071f0 <rtems_rfs_scan_chain>
10773d: 89 43 08 mov %eax,0x8(%ebx)
if (rtems_rfs_buffer_handle_has_block (handle) &&
107740: 85 c0 test %eax,%eax
107742: 0f 84 98 00 00 00 je 1077e0 <rtems_rfs_buffer_handle_request+0x210>
rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
107748: c7 04 24 00 01 00 00 movl $0x100,(%esp)
10774f: 31 c0 xor %eax,%eax
107751: 89 44 24 04 mov %eax,0x4(%esp)
107755: e8 f6 40 00 00 call 10b850 <rtems_rfs_trace>
if (rtems_rfs_buffer_handle_has_block (handle) &&
10775a: 84 c0 test %al,%al
10775c: 0f 84 fe fe ff ff je 107660 <rtems_rfs_buffer_handle_request+0x90> <== ALWAYS TAKEN
rtems_rfs_buffer_refs (handle) + 1);
107762: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED
printf ("rtems-rfs: buffer-request: buffer shared: refs: %d\n",
107765: 8b 40 30 mov 0x30(%eax),%eax <== NOT EXECUTED
107768: c7 04 24 d0 38 13 00 movl $0x1338d0,(%esp) <== NOT EXECUTED
10776f: 40 inc %eax <== NOT EXECUTED
107770: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
107774: e8 c7 a9 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
107779: e9 e2 fe ff ff jmp 107660 <rtems_rfs_buffer_handle_request+0x90> <== NOT EXECUTED
10777e: 66 90 xchg %ax,%ax <== NOT EXECUTED
printf ("rtems-rfs: buffer-request: block=%" PRIu32 "\n", block);
107780: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED
107784: c7 04 24 a8 38 13 00 movl $0x1338a8,(%esp) <== NOT EXECUTED
10778b: e8 b0 a9 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
if (fs->buffers_count)
107790: 8b 46 50 mov 0x50(%esi),%eax <== NOT EXECUTED
107793: 85 c0 test %eax,%eax <== NOT EXECUTED
107795: 0f 84 c5 fe ff ff je 107660 <rtems_rfs_buffer_handle_request+0x90> <== NOT EXECUTED
10779b: eb 93 jmp 107730 <rtems_rfs_buffer_handle_request+0x160> <== NOT EXECUTED
10779d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
printf ("rtems-rfs: buffer-request: handle has buffer: %" PRIu32 "\n",
1077a0: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED
1077a3: c7 04 24 74 38 13 00 movl $0x133874,(%esp) <== NOT EXECUTED
1077aa: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1077ae: e8 8d a9 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
if (rtems_rfs_buffer_handle_has_block (handle))
1077b3: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED
1077b6: 85 c0 test %eax,%eax <== NOT EXECUTED
1077b8: 0f 85 60 fe ff ff jne 10761e <rtems_rfs_buffer_handle_request+0x4e> <== NOT EXECUTED
1077be: e9 6e fe ff ff jmp 107631 <rtems_rfs_buffer_handle_request+0x61> <== NOT EXECUTED
1077c3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1077ca: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
1077d0: b8 6e 38 13 00 mov $0x13386e,%eax <== NOT EXECUTED
1077d5: e9 e4 fe ff ff jmp 1076be <rtems_rfs_buffer_handle_request+0xee> <== NOT EXECUTED
1077da: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
if (!rtems_rfs_fs_no_local_cache (fs) &&
1077e0: f6 06 02 testb $0x2,(%esi)
1077e3: 0f 85 0f ff ff ff jne 1076f8 <rtems_rfs_buffer_handle_request+0x128>
if (fs->release_count)
1077e9: 8b 46 60 mov 0x60(%esi),%eax
1077ec: 85 c0 test %eax,%eax
1077ee: 0f 85 9c 00 00 00 jne 107890 <rtems_rfs_buffer_handle_request+0x2c0>
if (!rtems_rfs_buffer_handle_has_block (handle) &&
1077f4: 8b 4e 70 mov 0x70(%esi),%ecx
1077f7: 85 c9 test %ecx,%ecx
1077f9: 0f 84 f9 fe ff ff je 1076f8 <rtems_rfs_buffer_handle_request+0x128>
handle->buffer = rtems_rfs_scan_chain (&fs->release_modified,
1077ff: 8d 56 70 lea 0x70(%esi),%edx
107802: 89 f9 mov %edi,%ecx
107804: 8d 46 64 lea 0x64(%esi),%eax
107807: e8 e4 f9 ff ff call 1071f0 <rtems_rfs_scan_chain>
10780c: 89 43 08 mov %eax,0x8(%ebx)
if (rtems_rfs_buffer_handle_has_block (handle))
10780f: 85 c0 test %eax,%eax
107811: 0f 84 e1 fe ff ff je 1076f8 <rtems_rfs_buffer_handle_request+0x128>
rtems_rfs_buffer_mark_dirty (handle);
107817: c6 03 01 movb $0x1,(%ebx)
10781a: e9 55 fe ff ff jmp 107674 <rtems_rfs_buffer_handle_request+0xa4>
10781f: 90 nop
107820: 89 55 e0 mov %edx,-0x20(%ebp) <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
107823: 31 d2 xor %edx,%edx <== NOT EXECUTED
107825: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
107829: c7 04 24 00 01 00 00 movl $0x100,(%esp) <== NOT EXECUTED
107830: e8 1b 40 00 00 call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
107835: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED
107838: 84 c0 test %al,%al <== NOT EXECUTED
10783a: 0f 84 9c fe ff ff je 1076dc <rtems_rfs_buffer_handle_request+0x10c> <== NOT EXECUTED
printf ("rtems-rfs: buffer-request: block=%" PRIu32 ": bdbuf-%s: %d: %s\n",
107840: 89 14 24 mov %edx,(%esp) <== NOT EXECUTED
107843: e8 d8 3b 02 00 call 12b420 <strerror> <== NOT EXECUTED
107848: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED
10784b: b9 69 38 13 00 mov $0x133869,%ecx <== NOT EXECUTED
107850: 80 7d e4 00 cmpb $0x0,-0x1c(%ebp) <== NOT EXECUTED
107854: 75 05 jne 10785b <rtems_rfs_buffer_handle_request+0x28b> <== NOT EXECUTED
107856: b9 6e 38 13 00 mov $0x13386e,%ecx <== NOT EXECUTED
10785b: 89 54 24 0c mov %edx,0xc(%esp) <== NOT EXECUTED
10785f: 89 44 24 10 mov %eax,0x10(%esp) <== NOT EXECUTED
107863: 89 4c 24 08 mov %ecx,0x8(%esp) <== NOT EXECUTED
107867: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED
10786b: c7 04 24 04 39 13 00 movl $0x133904,(%esp) <== NOT EXECUTED
107872: 89 55 e4 mov %edx,-0x1c(%ebp) <== NOT EXECUTED
107875: e8 c6 a8 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
10787a: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED
10787d: e9 5a fe ff ff jmp 1076dc <rtems_rfs_buffer_handle_request+0x10c> <== NOT EXECUTED
107882: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
107889: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
handle->buffer = rtems_rfs_scan_chain (&fs->release,
107890: 8d 56 60 lea 0x60(%esi),%edx
107893: 89 f9 mov %edi,%ecx
107895: 8d 46 54 lea 0x54(%esi),%eax
107898: e8 53 f9 ff ff call 1071f0 <rtems_rfs_scan_chain>
10789d: 89 43 08 mov %eax,0x8(%ebx)
if (!rtems_rfs_buffer_handle_has_block (handle) &&
1078a0: 85 c0 test %eax,%eax
1078a2: 0f 85 cc fd ff ff jne 107674 <rtems_rfs_buffer_handle_request+0xa4>
1078a8: e9 47 ff ff ff jmp 1077f4 <rtems_rfs_buffer_handle_request+0x224>
1078ad: 90 nop
1078ae: 90 nop
1078af: 90 nop
001078e0 <rtems_rfs_buffer_open>:
{
1078e0: 55 push %ebp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
1078e1: 31 c0 xor %eax,%eax
{
1078e3: 89 e5 mov %esp,%ebp
1078e5: 56 push %esi
1078e6: 53 push %ebx
1078e7: 83 ec 70 sub $0x70,%esp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
1078ea: c7 04 24 20 00 00 00 movl $0x20,(%esp)
{
1078f1: 8b 75 08 mov 0x8(%ebp),%esi
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
1078f4: 89 44 24 04 mov %eax,0x4(%esp)
{
1078f8: 8b 5d 0c mov 0xc(%ebp),%ebx
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
1078fb: e8 50 3f 00 00 call 10b850 <rtems_rfs_trace>
107900: 84 c0 test %al,%al
107902: 0f 85 c8 00 00 00 jne 1079d0 <rtems_rfs_buffer_open+0xf0> <== NEVER TAKEN
fs->device = open (name, O_RDWR);
107908: 89 34 24 mov %esi,(%esp)
10790b: b8 02 00 00 00 mov $0x2,%eax
107910: 89 44 24 04 mov %eax,0x4(%esp)
107914: e8 97 cd 00 00 call 1146b0 <open>
107919: 89 43 0c mov %eax,0xc(%ebx)
if (fs->device < 0)
10791c: 85 c0 test %eax,%eax
10791e: 0f 88 ec 00 00 00 js 107a10 <rtems_rfs_buffer_open+0x130> <== NEVER TAKEN
if (fstat (fs->device, &st) < 0)
107924: 89 04 24 mov %eax,(%esp)
107927: 8d 55 a0 lea -0x60(%ebp),%edx
10792a: 89 54 24 04 mov %edx,0x4(%esp)
10792e: e8 fd c7 00 00 call 114130 <fstat>
107933: 85 c0 test %eax,%eax
107935: 0f 88 65 01 00 00 js 107aa0 <rtems_rfs_buffer_open+0x1c0> <== NEVER TAKEN
if (!S_ISBLK (st.st_mode))
10793b: 8b 45 b0 mov -0x50(%ebp),%eax
10793e: 25 00 f0 00 00 and $0xf000,%eax
107943: 3d 00 60 00 00 cmp $0x6000,%eax
107948: 75 56 jne 1079a0 <rtems_rfs_buffer_open+0xc0> <== NEVER TAKEN
rv = rtems_disk_fd_get_disk_device (fs->device, &fs->disk);
10794a: 8d 43 10 lea 0x10(%ebx),%eax
static inline int rtems_disk_fd_get_disk_device(
int fd,
rtems_disk_device **dd_ptr
)
{
return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);
10794d: b9 09 42 04 40 mov $0x40044209,%ecx
107952: 89 44 24 08 mov %eax,0x8(%esp)
107956: 89 4c 24 04 mov %ecx,0x4(%esp)
10795a: 8b 43 0c mov 0xc(%ebx),%eax
10795d: 89 04 24 mov %eax,(%esp)
107960: e8 bb c9 00 00 call 114320 <ioctl>
if (rv != 0)
107965: 85 c0 test %eax,%eax
107967: 89 c6 mov %eax,%esi
107969: 0f 85 01 01 00 00 jne 107a70 <rtems_rfs_buffer_open+0x190> <== NEVER TAKEN
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
10796f: c7 04 24 20 00 00 00 movl $0x20,(%esp)
107976: 31 c0 xor %eax,%eax
107978: 89 44 24 04 mov %eax,0x4(%esp)
10797c: e8 cf 3e 00 00 call 10b850 <rtems_rfs_trace>
107981: 84 c0 test %al,%al
107983: 0f 85 b7 00 00 00 jne 107a40 <rtems_rfs_buffer_open+0x160> <== NEVER TAKEN
}
107989: 83 c4 70 add $0x70,%esp
10798c: 89 f0 mov %esi,%eax
10798e: 5b pop %ebx
10798f: 5e pop %esi
107990: 5d pop %ebp
107991: c3 ret
107992: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
107999: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
1079a0: c7 04 24 08 00 00 00 movl $0x8,(%esp) <== NOT EXECUTED
1079a7: 31 db xor %ebx,%ebx <== NOT EXECUTED
1079a9: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
1079ad: e8 9e 3e 00 00 call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
1079b2: 84 c0 test %al,%al <== NOT EXECUTED
1079b4: 75 3a jne 1079f0 <rtems_rfs_buffer_open+0x110> <== NOT EXECUTED
}
1079b6: 83 c4 70 add $0x70,%esp <== NOT EXECUTED
return ENXIO;
1079b9: be 06 00 00 00 mov $0x6,%esi <== NOT EXECUTED
}
1079be: 5b pop %ebx <== NOT EXECUTED
1079bf: 89 f0 mov %esi,%eax <== NOT EXECUTED
1079c1: 5e pop %esi <== NOT EXECUTED
1079c2: 5d pop %ebp <== NOT EXECUTED
1079c3: c3 ret <== NOT EXECUTED
1079c4: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1079cb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1079cf: 90 nop <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: opening: %s\n", name);
1079d0: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED
1079d4: c7 04 24 78 39 13 00 movl $0x133978,(%esp) <== NOT EXECUTED
1079db: e8 60 a7 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
1079e0: e9 23 ff ff ff jmp 107908 <rtems_rfs_buffer_open+0x28> <== NOT EXECUTED
1079e5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1079ec: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: '%s' is not a block device\n", name);
1079f0: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED
return ENXIO;
1079f4: be 06 00 00 00 mov $0x6,%esi <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: '%s' is not a block device\n", name);
1079f9: c7 04 24 fc 39 13 00 movl $0x1339fc,(%esp) <== NOT EXECUTED
107a00: e8 3b a7 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
107a05: eb 82 jmp 107989 <rtems_rfs_buffer_open+0xa9> <== NOT EXECUTED
107a07: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
107a0e: 66 90 xchg %ax,%ax <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
107a10: c7 04 24 08 00 00 00 movl $0x8,(%esp) <== NOT EXECUTED
107a17: 31 c0 xor %eax,%eax <== NOT EXECUTED
107a19: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
107a1d: e8 2e 3e 00 00 call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
107a22: 84 c0 test %al,%al <== NOT EXECUTED
107a24: 74 90 je 1079b6 <rtems_rfs_buffer_open+0xd6> <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: cannot open file\n");
107a26: c7 04 24 a0 39 13 00 movl $0x1339a0,(%esp) <== NOT EXECUTED
107a2d: e8 3e a7 ff ff call 102170 <__wrap_puts> <== NOT EXECUTED
107a32: eb 82 jmp 1079b6 <rtems_rfs_buffer_open+0xd6> <== NOT EXECUTED
107a34: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
107a3b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
107a3f: 90 nop <== NOT EXECUTED
rtems_rfs_fs_media_block_size (fs));
107a40: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: blks=%" PRId32 ", blk-size=%" PRId32 "\n",
107a43: 8b 50 20 mov 0x20(%eax),%edx <== NOT EXECUTED
107a46: 89 54 24 08 mov %edx,0x8(%esp) <== NOT EXECUTED
107a4a: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED
107a4d: c7 04 24 60 3a 13 00 movl $0x133a60,(%esp) <== NOT EXECUTED
107a54: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
107a58: e8 e3 a6 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
}
107a5d: 83 c4 70 add $0x70,%esp <== NOT EXECUTED
107a60: 89 f0 mov %esi,%eax <== NOT EXECUTED
107a62: 5b pop %ebx <== NOT EXECUTED
107a63: 5e pop %esi <== NOT EXECUTED
107a64: 5d pop %ebp <== NOT EXECUTED
107a65: c3 ret <== NOT EXECUTED
107a66: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
107a6d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
107a70: c7 04 24 08 00 00 00 movl $0x8,(%esp) <== NOT EXECUTED
107a77: 31 d2 xor %edx,%edx <== NOT EXECUTED
107a79: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
107a7d: e8 ce 3d 00 00 call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
107a82: 84 c0 test %al,%al <== NOT EXECUTED
107a84: 0f 84 2c ff ff ff je 1079b6 <rtems_rfs_buffer_open+0xd6> <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: cannot obtain the disk\n");
107a8a: c7 04 24 30 3a 13 00 movl $0x133a30,(%esp) <== NOT EXECUTED
return ENXIO;
107a91: be 06 00 00 00 mov $0x6,%esi <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: cannot obtain the disk\n");
107a96: e8 d5 a6 ff ff call 102170 <__wrap_puts> <== NOT EXECUTED
107a9b: e9 e9 fe ff ff jmp 107989 <rtems_rfs_buffer_open+0xa9> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
107aa0: c7 04 24 08 00 00 00 movl $0x8,(%esp) <== NOT EXECUTED
107aa7: 31 c0 xor %eax,%eax <== NOT EXECUTED
107aa9: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
107aad: e8 9e 3d 00 00 call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
107ab2: 84 c0 test %al,%al <== NOT EXECUTED
107ab4: 0f 84 fc fe ff ff je 1079b6 <rtems_rfs_buffer_open+0xd6> <== NOT EXECUTED
name, strerror (errno));
107aba: e8 41 2a 02 00 call 12a500 <__errno> <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n",
107abf: 8b 00 mov (%eax),%eax <== NOT EXECUTED
107ac1: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
107ac4: e8 57 39 02 00 call 12b420 <strerror> <== NOT EXECUTED
107ac9: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED
return ENXIO;
107acd: be 06 00 00 00 mov $0x6,%esi <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n",
107ad2: c7 04 24 cc 39 13 00 movl $0x1339cc,(%esp) <== NOT EXECUTED
107ad9: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
107add: e8 5e a6 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
107ae2: e9 a2 fe ff ff jmp 107989 <rtems_rfs_buffer_open+0xa9> <== NOT EXECUTED
107ae7: 90 nop
107ae8: 90 nop
107ae9: 90 nop
107aea: 90 nop
107aeb: 90 nop
107aec: 90 nop
107aed: 90 nop
107aee: 90 nop
107aef: 90 nop
00107c20 <rtems_rfs_buffer_setblksize>:
{
107c20: 55 push %ebp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
107c21: 31 c0 xor %eax,%eax
{
107c23: 89 e5 mov %esp,%ebp
107c25: 56 push %esi
107c26: 53 push %ebx
107c27: 83 ec 10 sub $0x10,%esp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
107c2a: c7 04 24 00 04 00 00 movl $0x400,(%esp)
{
107c31: 8b 75 08 mov 0x8(%ebp),%esi
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
107c34: 89 44 24 04 mov %eax,0x4(%esp)
107c38: e8 13 3c 00 00 call 10b850 <rtems_rfs_trace>
107c3d: 84 c0 test %al,%al
107c3f: 0f 85 cb 00 00 00 jne 107d10 <rtems_rfs_buffer_setblksize+0xf0> <== NEVER TAKEN
rc = rtems_rfs_buffers_release (fs);
107c45: 89 34 24 mov %esi,(%esp)
107c48: e8 43 ff ff ff call 107b90 <rtems_rfs_buffers_release>
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
107c4d: 85 c0 test %eax,%eax
rc = rtems_rfs_buffers_release (fs);
107c4f: 89 c3 mov %eax,%ebx
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
107c51: 7f 3d jg 107c90 <rtems_rfs_buffer_setblksize+0x70> <== NEVER TAKEN
rc = rtems_rfs_buffer_sync (fs);
107c53: 89 34 24 mov %esi,(%esp)
107c56: e8 95 fe ff ff call 107af0 <rtems_rfs_buffer_sync>
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
107c5b: 85 c0 test %eax,%eax
rc = rtems_rfs_buffer_sync (fs);
107c5d: 89 c3 mov %eax,%ebx
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
107c5f: 7f 6f jg 107cd0 <rtems_rfs_buffer_setblksize+0xb0> <== NEVER TAKEN
rc = fs->disk->ioctl (fs->disk, RTEMS_BLKIO_SETBLKSIZE, &size);
107c61: 8b 46 10 mov 0x10(%esi),%eax
107c64: 8d 55 0c lea 0xc(%ebp),%edx
107c67: 89 54 24 08 mov %edx,0x8(%esp)
107c6b: ba 04 42 04 80 mov $0x80044204,%edx
107c70: 89 54 24 04 mov %edx,0x4(%esp)
107c74: 89 04 24 mov %eax,(%esp)
107c77: ff 50 38 call *0x38(%eax)
if (rc < 0)
107c7a: 85 c0 test %eax,%eax
107c7c: 0f 88 ae 00 00 00 js 107d30 <rtems_rfs_buffer_setblksize+0x110> <== NEVER TAKEN
}
107c82: 83 c4 10 add $0x10,%esp
107c85: 5b pop %ebx
107c86: 5e pop %esi
107c87: 5d pop %ebp
107c88: c3 ret
107c89: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
107c90: c7 04 24 00 04 00 00 movl $0x400,(%esp) <== NOT EXECUTED
107c97: 31 c0 xor %eax,%eax <== NOT EXECUTED
107c99: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
107c9d: e8 ae 3b 00 00 call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
107ca2: 84 c0 test %al,%al <== NOT EXECUTED
107ca4: 74 ad je 107c53 <rtems_rfs_buffer_setblksize+0x33> <== NOT EXECUTED
printf ("rtems-rfs: buffer-setblksize: buffer release failed: %d: %s\n",
107ca6: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
107ca9: e8 72 37 02 00 call 12b420 <strerror> <== NOT EXECUTED
107cae: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
107cb2: c7 04 24 58 3b 13 00 movl $0x133b58,(%esp) <== NOT EXECUTED
107cb9: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
107cbd: e8 7e a4 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
rc = rtems_rfs_buffer_sync (fs);
107cc2: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
107cc5: e8 26 fe ff ff call 107af0 <rtems_rfs_buffer_sync> <== NOT EXECUTED
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
107cca: 85 c0 test %eax,%eax <== NOT EXECUTED
rc = rtems_rfs_buffer_sync (fs);
107ccc: 89 c3 mov %eax,%ebx <== NOT EXECUTED
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
107cce: 7e 91 jle 107c61 <rtems_rfs_buffer_setblksize+0x41> <== NOT EXECUTED
107cd0: c7 04 24 00 04 00 00 movl $0x400,(%esp) <== NOT EXECUTED
107cd7: 31 c9 xor %ecx,%ecx <== NOT EXECUTED
107cd9: 89 4c 24 04 mov %ecx,0x4(%esp) <== NOT EXECUTED
107cdd: e8 6e 3b 00 00 call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
107ce2: 84 c0 test %al,%al <== NOT EXECUTED
107ce4: 0f 84 77 ff ff ff je 107c61 <rtems_rfs_buffer_setblksize+0x41> <== NOT EXECUTED
printf ("rtems-rfs: buffer-setblksize: device sync failed: %d: %s\n",
107cea: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
107ced: e8 2e 37 02 00 call 12b420 <strerror> <== NOT EXECUTED
107cf2: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
107cf6: c7 04 24 98 3b 13 00 movl $0x133b98,(%esp) <== NOT EXECUTED
107cfd: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
107d01: e8 3a a4 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
107d06: e9 56 ff ff ff jmp 107c61 <rtems_rfs_buffer_setblksize+0x41> <== NOT EXECUTED
107d0b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
107d0f: 90 nop <== NOT EXECUTED
printf ("rtems-rfs: buffer-setblksize: block size: %" PRIu32 "\n", size);
107d10: c7 04 24 28 3b 13 00 movl $0x133b28,(%esp) <== NOT EXECUTED
107d17: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
107d1a: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
107d1e: e8 1d a4 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
107d23: e9 1d ff ff ff jmp 107c45 <rtems_rfs_buffer_setblksize+0x25> <== NOT EXECUTED
107d28: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
107d2f: 90 nop <== NOT EXECUTED
rc = errno;
107d30: e8 cb 27 02 00 call 12a500 <__errno> <== NOT EXECUTED
107d35: 8b 00 mov (%eax),%eax <== NOT EXECUTED
}
107d37: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107d3a: 5b pop %ebx <== NOT EXECUTED
107d3b: 5e pop %esi <== NOT EXECUTED
107d3c: 5d pop %ebp <== NOT EXECUTED
107d3d: c3 ret <== NOT EXECUTED
107d3e: 90 nop
107d3f: 90 nop
00107af0 <rtems_rfs_buffer_sync>:
{
107af0: 55 push %ebp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
107af1: 31 d2 xor %edx,%edx
{
107af3: 89 e5 mov %esp,%ebp
107af5: 83 ec 18 sub $0x18,%esp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
107af8: c7 04 24 20 00 00 00 movl $0x20,(%esp)
107aff: 89 54 24 04 mov %edx,0x4(%esp)
{
107b03: 89 5d f8 mov %ebx,-0x8(%ebp)
107b06: 89 75 fc mov %esi,-0x4(%ebp)
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
107b09: e8 42 3d 00 00 call 10b850 <rtems_rfs_trace>
107b0e: 84 c0 test %al,%al
107b10: 75 2e jne 107b40 <rtems_rfs_buffer_sync+0x50> <== NEVER TAKEN
sc = rtems_bdbuf_syncdev (rtems_rfs_fs_device (fs));
107b12: 8b 45 08 mov 0x8(%ebp),%eax
int result = 0;
107b15: 31 f6 xor %esi,%esi
sc = rtems_bdbuf_syncdev (rtems_rfs_fs_device (fs));
107b17: 8b 40 10 mov 0x10(%eax),%eax
107b1a: 89 04 24 mov %eax,(%esp)
107b1d: e8 7e b6 00 00 call 1131a0 <rtems_bdbuf_syncdev>
if (sc != RTEMS_SUCCESSFUL)
107b22: 85 c0 test %eax,%eax
sc = rtems_bdbuf_syncdev (rtems_rfs_fs_device (fs));
107b24: 89 c3 mov %eax,%ebx
if (sc != RTEMS_SUCCESSFUL)
107b26: 75 28 jne 107b50 <rtems_rfs_buffer_sync+0x60> <== NEVER TAKEN
}
107b28: 8b 5d f8 mov -0x8(%ebp),%ebx
107b2b: 89 f0 mov %esi,%eax
107b2d: 8b 75 fc mov -0x4(%ebp),%esi
107b30: 89 ec mov %ebp,%esp
107b32: 5d pop %ebp
107b33: c3 ret
107b34: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
107b3b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
107b3f: 90 nop
printf ("rtems-rfs: buffer-sync: syncing\n");
107b40: c7 04 24 90 3a 13 00 movl $0x133a90,(%esp) <== NOT EXECUTED
107b47: e8 24 a6 ff ff call 102170 <__wrap_puts> <== NOT EXECUTED
107b4c: eb c4 jmp 107b12 <rtems_rfs_buffer_sync+0x22> <== NOT EXECUTED
107b4e: 66 90 xchg %ax,%ax <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
107b50: c7 04 24 20 00 00 00 movl $0x20,(%esp) <== NOT EXECUTED
107b57: 31 c0 xor %eax,%eax <== NOT EXECUTED
result = EIO;
107b59: be 05 00 00 00 mov $0x5,%esi <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
107b5e: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
107b62: e8 e9 3c 00 00 call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
107b67: 84 c0 test %al,%al <== NOT EXECUTED
107b69: 74 bd je 107b28 <rtems_rfs_buffer_sync+0x38> <== NOT EXECUTED
printf ("rtems-rfs: buffer-sync: device sync failed: %s\n",
107b6b: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
107b6e: e8 fd 3c 00 00 call 10b870 <rtems_status_text> <== NOT EXECUTED
107b73: c7 04 24 b0 3a 13 00 movl $0x133ab0,(%esp) <== NOT EXECUTED
107b7a: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
107b7e: e8 bd a5 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
}
107b83: 8b 5d f8 mov -0x8(%ebp),%ebx <== NOT EXECUTED
107b86: 89 f0 mov %esi,%eax <== NOT EXECUTED
107b88: 8b 75 fc mov -0x4(%ebp),%esi <== NOT EXECUTED
107b8b: 89 ec mov %ebp,%esp <== NOT EXECUTED
107b8d: 5d pop %ebp <== NOT EXECUTED
107b8e: c3 ret <== NOT EXECUTED
107b8f: 90 nop
00107b90 <rtems_rfs_buffers_release>:
int
rtems_rfs_buffers_release (rtems_rfs_file_system* fs)
{
107b90: 55 push %ebp
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
107b91: 31 c0 xor %eax,%eax
{
107b93: 89 e5 mov %esp,%ebp
107b95: 56 push %esi
107b96: 53 push %ebx
107b97: 83 ec 10 sub $0x10,%esp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
107b9a: c7 04 24 40 00 00 00 movl $0x40,(%esp)
{
107ba1: 8b 5d 08 mov 0x8(%ebp),%ebx
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
107ba4: 89 44 24 04 mov %eax,0x4(%esp)
107ba8: e8 a3 3c 00 00 call 10b850 <rtems_rfs_trace>
107bad: 84 c0 test %al,%al
107baf: 75 3f jne 107bf0 <rtems_rfs_buffers_release+0x60> <== NEVER TAKEN
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,
107bb1: 8d 53 60 lea 0x60(%ebx),%edx
107bb4: 31 c9 xor %ecx,%ecx
107bb6: 8d 43 54 lea 0x54(%ebx),%eax
107bb9: e8 42 f7 ff ff call 107300 <rtems_rfs_release_chain>
&fs->release_count,
false);
if ((rc > 0) && (rrc == 0))
rrc = rc;
rc = rtems_rfs_release_chain (&fs->release_modified,
107bbe: 8d 53 70 lea 0x70(%ebx),%edx
107bc1: b9 01 00 00 00 mov $0x1,%ecx
rc = rtems_rfs_release_chain (&fs->release,
107bc6: 89 c6 mov %eax,%esi
rc = rtems_rfs_release_chain (&fs->release_modified,
107bc8: 8d 43 64 lea 0x64(%ebx),%eax
107bcb: e8 30 f7 ff ff call 107300 <rtems_rfs_release_chain>
&fs->release_modified_count,
true);
if ((rc > 0) && (rrc == 0))
107bd0: 85 c0 test %eax,%eax
107bd2: 7e 0c jle 107be0 <rtems_rfs_buffers_release+0x50> <== ALWAYS TAKEN
107bd4: 85 f6 test %esi,%esi <== NOT EXECUTED
107bd6: 7f 08 jg 107be0 <rtems_rfs_buffers_release+0x50> <== NOT EXECUTED
rrc = rc;
return rrc;
}
107bd8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107bdb: 5b pop %ebx <== NOT EXECUTED
107bdc: 5e pop %esi <== NOT EXECUTED
107bdd: 5d pop %ebp <== NOT EXECUTED
107bde: c3 ret <== NOT EXECUTED
107bdf: 90 nop <== NOT EXECUTED
107be0: 83 c4 10 add $0x10,%esp
107be3: 89 f0 mov %esi,%eax
107be5: 5b pop %ebx
107be6: f7 d0 not %eax
107be8: c1 f8 1f sar $0x1f,%eax
107beb: 21 f0 and %esi,%eax
107bed: 5e pop %esi
107bee: 5d pop %ebp
107bef: c3 ret
printf ("rtems-rfs: buffers-release: active:%" PRIu32 " "
107bf0: 8b 43 70 mov 0x70(%ebx),%eax <== NOT EXECUTED
107bf3: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
107bf7: 8b 43 60 mov 0x60(%ebx),%eax <== NOT EXECUTED
107bfa: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
107bfe: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED
107c01: c7 04 24 e0 3a 13 00 movl $0x133ae0,(%esp) <== NOT EXECUTED
107c08: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
107c0c: e8 2f a5 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
107c11: eb 9e jmp 107bb1 <rtems_rfs_buffers_release+0x21> <== NOT EXECUTED
107c13: 90 nop
107c14: 90 nop
107c15: 90 nop
107c16: 90 nop
107c17: 90 nop
107c18: 90 nop
107c19: 90 nop
107c1a: 90 nop
107c1b: 90 nop
107c1c: 90 nop
107c1d: 90 nop
107c1e: 90 nop
107c1f: 90 nop
00116bb0 <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)
{
116bb0: 55 push %ebp
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))
116bb1: 31 c0 xor %eax,%eax
{
116bb3: 89 e5 mov %esp,%ebp
116bb5: 57 push %edi
116bb6: 56 push %esi
116bb7: 53 push %ebx
116bb8: 81 ec ac 00 00 00 sub $0xac,%esp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
116bbe: c7 04 24 00 00 00 20 movl $0x20000000,(%esp)
116bc5: 89 44 24 04 mov %eax,0x4(%esp)
116bc9: e8 82 4c ff ff call 10b850 <rtems_rfs_trace>
116bce: 84 c0 test %al,%al
116bd0: 0f 85 3a 03 00 00 jne 116f10 <rtems_rfs_dir_add_entry+0x360> <== NEVER TAKEN
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf (", len=%zd\n", length);
}
rc = rtems_rfs_block_map_open (fs, dir, &map);
116bd6: 8d 45 98 lea -0x68(%ebp),%eax
116bd9: 89 44 24 08 mov %eax,0x8(%esp)
116bdd: 8b 45 0c mov 0xc(%ebp),%eax
116be0: 89 44 24 04 mov %eax,0x4(%esp)
116be4: 8b 45 08 mov 0x8(%ebp),%eax
116be7: 89 04 24 mov %eax,(%esp)
116bea: e8 31 ed ff ff call 115920 <rtems_rfs_block_map_open>
if (rc > 0)
116bef: 85 c0 test %eax,%eax
rc = rtems_rfs_block_map_open (fs, dir, &map);
116bf1: 89 c3 mov %eax,%ebx
if (rc > 0)
116bf3: 0f 8f 0f 01 00 00 jg 116d08 <rtems_rfs_dir_add_entry+0x158> <== NEVER TAKEN
handle->dirty = false;
116bf9: c6 45 8c 00 movb $0x0,-0x74(%ebp)
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
{
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
116bfd: 8b 45 14 mov 0x14(%ebp),%eax
handle->bnum = 0;
116c00: c7 45 90 00 00 00 00 movl $0x0,-0x70(%ebp)
handle->buffer = NULL;
116c07: c7 45 94 00 00 00 00 movl $0x0,-0x6c(%ebp)
bpos->bno = 0;
116c0e: c7 45 80 00 00 00 00 movl $0x0,-0x80(%ebp)
bpos->boff = 0;
116c15: c7 45 84 00 00 00 00 movl $0x0,-0x7c(%ebp)
116c1c: 83 c0 0a add $0xa,%eax
bpos->block = 0;
116c1f: c7 45 88 00 00 00 00 movl $0x0,-0x78(%ebp)
116c26: 89 85 68 ff ff ff mov %eax,-0x98(%ebp)
rc = rtems_rfs_block_map_find (fs, &map, &bpos, &block);
116c2c: 8d 85 7c ff ff ff lea -0x84(%ebp),%eax
116c32: 89 44 24 0c mov %eax,0xc(%esp)
116c36: 8d 45 80 lea -0x80(%ebp),%eax
116c39: 89 44 24 08 mov %eax,0x8(%esp)
116c3d: 8d 45 98 lea -0x68(%ebp),%eax
116c40: 89 44 24 04 mov %eax,0x4(%esp)
116c44: 8b 45 08 mov 0x8(%ebp),%eax
116c47: 89 04 24 mov %eax,(%esp)
116c4a: e8 a1 ef ff ff call 115bf0 <rtems_rfs_block_map_find>
if (rc > 0)
116c4f: 85 c0 test %eax,%eax
116c51: 0f 8e 19 03 00 00 jle 116f70 <rtems_rfs_dir_add_entry+0x3c0>
if (rc != ENXIO)
116c57: 83 f8 06 cmp $0x6,%eax
116c5a: 0f 85 07 04 00 00 jne 117067 <rtems_rfs_dir_add_entry+0x4b7> <== NEVER TAKEN
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
116c60: 8d 85 7c ff ff ff lea -0x84(%ebp),%eax
116c66: 89 44 24 0c mov %eax,0xc(%esp)
116c6a: b8 01 00 00 00 mov $0x1,%eax
116c6f: 89 44 24 08 mov %eax,0x8(%esp)
116c73: 8d 45 98 lea -0x68(%ebp),%eax
116c76: 89 44 24 04 mov %eax,0x4(%esp)
116c7a: 8b 45 08 mov 0x8(%ebp),%eax
116c7d: 89 04 24 mov %eax,(%esp)
116c80: e8 7b f1 ff ff call 115e00 <rtems_rfs_block_map_grow>
if (rc > 0)
116c85: 85 c0 test %eax,%eax
116c87: 0f 8f 21 04 00 00 jg 1170ae <rtems_rfs_dir_add_entry+0x4fe> <== NEVER TAKEN
bpos.bno++;
116c8d: ff 45 80 incl -0x80(%ebp)
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
116c90: 31 c0 xor %eax,%eax
116c92: 89 44 24 0c mov %eax,0xc(%esp)
116c96: 8b 85 7c ff ff ff mov -0x84(%ebp),%eax
116c9c: 89 44 24 08 mov %eax,0x8(%esp)
116ca0: 8d 45 8c lea -0x74(%ebp),%eax
116ca3: 89 44 24 04 mov %eax,0x4(%esp)
116ca7: 8b 45 08 mov 0x8(%ebp),%eax
116caa: 89 04 24 mov %eax,(%esp)
116cad: e8 1e 09 ff ff call 1075d0 <rtems_rfs_buffer_handle_request>
if (rc > 0)
116cb2: 85 c0 test %eax,%eax
116cb4: 7e 6a jle 116d20 <rtems_rfs_dir_add_entry+0x170> <== ALWAYS TAKEN
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
116cb6: c7 04 24 00 00 00 20 movl $0x20000000,(%esp) <== NOT EXECUTED
116cbd: 31 f6 xor %esi,%esi <== NOT EXECUTED
116cbf: 89 c3 mov %eax,%ebx <== NOT EXECUTED
116cc1: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED
116cc5: e8 86 4b ff ff call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
116cca: 84 c0 test %al,%al <== NOT EXECUTED
116ccc: 0f 85 5e 04 00 00 jne 117130 <rtems_rfs_dir_add_entry+0x580> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
116cd2: 8d 45 8c lea -0x74(%ebp),%eax <== NOT EXECUTED
116cd5: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
116cd9: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
116cdc: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
116cdf: e8 cc 0b ff ff call 1078b0 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
offset += elength;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
116ce4: 8d 45 98 lea -0x68(%ebp),%eax <== NOT EXECUTED
116ce7: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
116ceb: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
handle->dirty = false;
116cee: c6 45 8c 00 movb $0x0,-0x74(%ebp) <== NOT EXECUTED
handle->bnum = 0;
116cf2: c7 45 90 00 00 00 00 movl $0x0,-0x70(%ebp) <== NOT EXECUTED
handle->buffer = NULL;
116cf9: c7 45 94 00 00 00 00 movl $0x0,-0x6c(%ebp) <== NOT EXECUTED
116d00: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
116d03: e8 48 ed ff ff call 115a50 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
}
116d08: 81 c4 ac 00 00 00 add $0xac,%esp
116d0e: 89 d8 mov %ebx,%eax
116d10: 5b pop %ebx
116d11: 5e pop %esi
116d12: 5f pop %edi
116d13: 5d pop %ebp
116d14: c3 ret
116d15: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
116d1c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
entry = rtems_rfs_buffer_data (&buffer);
116d20: 8b 45 94 mov -0x6c(%ebp),%eax
116d23: 8b 50 1c mov 0x1c(%eax),%edx
memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
116d26: 8b 45 08 mov 0x8(%ebp),%eax
116d29: 89 d7 mov %edx,%edi
116d2b: 8b 58 08 mov 0x8(%eax),%ebx
116d2e: 83 fb 08 cmp $0x8,%ebx
116d31: 0f 83 c9 02 00 00 jae 117000 <rtems_rfs_dir_add_entry+0x450> <== ALWAYS TAKEN
116d37: f6 c3 04 test $0x4,%bl <== NOT EXECUTED
116d3a: 0f 85 a0 02 00 00 jne 116fe0 <rtems_rfs_dir_add_entry+0x430> <== NOT EXECUTED
116d40: f6 c3 02 test $0x2,%bl
116d43: 0f 85 77 02 00 00 jne 116fc0 <rtems_rfs_dir_add_entry+0x410> <== NEVER TAKEN
116d49: f6 c3 01 test $0x1,%bl
116d4c: 0f 85 5e 02 00 00 jne 116fb0 <rtems_rfs_dir_add_entry+0x400> <== NEVER TAKEN
116d52: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
116d59: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
116d60: 8b 45 08 mov 0x8(%ebp),%eax
116d63: 8b 40 08 mov 0x8(%eax),%eax
116d66: 89 85 6c ff ff ff mov %eax,-0x94(%ebp)
116d6c: 89 c1 mov %eax,%ecx
116d6e: 83 e9 0a sub $0xa,%ecx
116d71: 0f 84 b5 fe ff ff je 116c2c <rtems_rfs_dir_add_entry+0x7c> <== NEVER TAKEN
116d77: 89 8d 70 ff ff ff mov %ecx,-0x90(%ebp)
116d7d: 31 c0 xor %eax,%eax
116d7f: 8b 4d 08 mov 0x8(%ebp),%ecx
116d82: 89 85 74 ff ff ff mov %eax,-0x8c(%ebp)
offset = 0;
116d88: 31 ff xor %edi,%edi
116d8a: eb 40 jmp 116dcc <rtems_rfs_dir_add_entry+0x21c>
116d8c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
116d90: 83 fb 0a cmp $0xa,%ebx
116d93: 0f 8e 07 01 00 00 jle 116ea0 <rtems_rfs_dir_add_entry+0x2f0> <== NEVER TAKEN
116d99: 39 59 1c cmp %ebx,0x1c(%ecx)
116d9c: 0f 86 fe 00 00 00 jbe 116ea0 <rtems_rfs_dir_add_entry+0x2f0> <== NEVER TAKEN
116da2: 85 f6 test %esi,%esi
116da4: 0f 84 f6 00 00 00 je 116ea0 <rtems_rfs_dir_add_entry+0x2f0> <== NEVER TAKEN
116daa: 39 71 14 cmp %esi,0x14(%ecx)
116dad: 8d 76 00 lea 0x0(%esi),%esi
116db0: 0f 82 ea 00 00 00 jb 116ea0 <rtems_rfs_dir_add_entry+0x2f0> <== NEVER TAKEN
offset += elength;
116db6: 01 df add %ebx,%edi
entry += elength;
116db8: 01 da add %ebx,%edx
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
116dba: 39 bd 70 ff ff ff cmp %edi,-0x90(%ebp)
116dc0: 89 bd 74 ff ff ff mov %edi,-0x8c(%ebp)
116dc6: 0f 86 60 fe ff ff jbe 116c2c <rtems_rfs_dir_add_entry+0x7c> <== NEVER TAKEN
elength = rtems_rfs_dir_entry_length (entry);
116dcc: 0f b7 72 08 movzwl 0x8(%edx),%esi
116dd0: 89 f3 mov %esi,%ebx
116dd2: 89 f0 mov %esi,%eax
116dd4: c1 e3 08 shl $0x8,%ebx
116dd7: 0f b6 f4 movzbl %ah,%esi
116dda: 09 de or %ebx,%esi
116ddc: 0f b7 de movzwl %si,%ebx
eino = rtems_rfs_dir_entry_ino (entry);
116ddf: 8b 32 mov (%edx),%esi
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
116de1: 81 fb ff ff 00 00 cmp $0xffff,%ebx
116de7: 0f ce bswap %esi
116de9: 75 a5 jne 116d90 <rtems_rfs_dir_add_entry+0x1e0>
(rtems_rfs_fs_block_size (fs) - offset))
116deb: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax
116df1: 8b 8d 6c ff ff ff mov -0x94(%ebp),%ecx
116df7: 29 c1 sub %eax,%ecx
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
116df9: 39 8d 68 ff ff ff cmp %ecx,-0x98(%ebp)
116dff: 0f 83 27 fe ff ff jae 116c2c <rtems_rfs_dir_add_entry+0x7c> <== NEVER TAKEN
hash = rtems_rfs_dir_hash (name, length);
116e05: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp)
116e0b: 8b 45 14 mov 0x14(%ebp),%eax
116e0e: 89 44 24 04 mov %eax,0x4(%esp)
116e12: 8b 45 10 mov 0x10(%ebp),%eax
116e15: 89 04 24 mov %eax,(%esp)
116e18: e8 e3 10 00 00 call 117f00 <rtems_rfs_dir_hash>
rtems_rfs_dir_set_entry_hash (entry, hash);
116e1d: 8b 95 74 ff ff ff mov -0x8c(%ebp),%edx
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
116e23: 8b 4d 14 mov 0x14(%ebp),%ecx
116e26: 8b 75 10 mov 0x10(%ebp),%esi
116e29: 8d 7a 0a lea 0xa(%edx),%edi
116e2c: 0f c8 bswap %eax
rtems_rfs_dir_set_entry_hash (entry, hash);
116e2e: 89 42 04 mov %eax,0x4(%edx)
rtems_rfs_dir_set_entry_ino (entry, ino);
116e31: 8b 45 18 mov 0x18(%ebp),%eax
116e34: 0f c8 bswap %eax
116e36: 89 02 mov %eax,(%edx)
rtems_rfs_dir_set_entry_length (entry,
116e38: 8b 85 68 ff ff ff mov -0x98(%ebp),%eax
116e3e: 88 62 08 mov %ah,0x8(%edx)
116e41: 0f b6 45 14 movzbl 0x14(%ebp),%eax
116e45: 04 0a add $0xa,%al
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
116e47: 83 f9 08 cmp $0x8,%ecx
rtems_rfs_dir_set_entry_length (entry,
116e4a: 88 42 09 mov %al,0x9(%edx)
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
116e4d: 0f 83 08 03 00 00 jae 11715b <rtems_rfs_dir_add_entry+0x5ab>
116e53: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
rtems_rfs_buffer_handle_release (fs, handle);
116e55: 8d 45 8c lea -0x74(%ebp),%eax
return 0;
116e58: 31 db xor %ebx,%ebx
116e5a: 89 44 24 04 mov %eax,0x4(%esp)
rtems_rfs_buffer_mark_dirty (&buffer);
116e5e: c6 45 8c 01 movb $0x1,-0x74(%ebp)
116e62: 8b 45 08 mov 0x8(%ebp),%eax
116e65: 89 04 24 mov %eax,(%esp)
116e68: e8 43 0a ff ff call 1078b0 <rtems_rfs_buffer_handle_release>
rtems_rfs_block_map_close (fs, &map);
116e6d: 8d 45 98 lea -0x68(%ebp),%eax
116e70: 89 44 24 04 mov %eax,0x4(%esp)
116e74: 8b 45 08 mov 0x8(%ebp),%eax
handle->dirty = false;
116e77: c6 45 8c 00 movb $0x0,-0x74(%ebp)
handle->bnum = 0;
116e7b: c7 45 90 00 00 00 00 movl $0x0,-0x70(%ebp)
handle->buffer = NULL;
116e82: c7 45 94 00 00 00 00 movl $0x0,-0x6c(%ebp)
116e89: 89 04 24 mov %eax,(%esp)
116e8c: e8 bf eb ff ff call 115a50 <rtems_rfs_block_map_close>
return 0;
116e91: e9 72 fe ff ff jmp 116d08 <rtems_rfs_dir_add_entry+0x158>
116e96: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
116e9d: 8d 76 00 lea 0x0(%esi),%esi
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
116ea0: c7 04 24 00 00 00 20 movl $0x20000000,(%esp) <== NOT EXECUTED
116ea7: 31 c9 xor %ecx,%ecx <== NOT EXECUTED
116ea9: 89 4c 24 04 mov %ecx,0x4(%esp) <== NOT EXECUTED
116ead: e8 9e 49 ff ff call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
116eb2: 84 c0 test %al,%al <== NOT EXECUTED
116eb4: 0f 85 86 01 00 00 jne 117040 <rtems_rfs_dir_add_entry+0x490> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
116eba: 8d 45 8c lea -0x74(%ebp),%eax <== NOT EXECUTED
return EIO;
116ebd: bb 05 00 00 00 mov $0x5,%ebx <== NOT EXECUTED
116ec2: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
116ec6: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
116ec9: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
116ecc: e8 df 09 ff ff call 1078b0 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
116ed1: 8d 45 98 lea -0x68(%ebp),%eax <== NOT EXECUTED
116ed4: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
116ed8: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
handle->dirty = false;
116edb: c6 45 8c 00 movb $0x0,-0x74(%ebp) <== NOT EXECUTED
handle->bnum = 0;
116edf: c7 45 90 00 00 00 00 movl $0x0,-0x70(%ebp) <== NOT EXECUTED
handle->buffer = NULL;
116ee6: c7 45 94 00 00 00 00 movl $0x0,-0x6c(%ebp) <== NOT EXECUTED
116eed: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
116ef0: e8 5b eb ff ff call 115a50 <rtems_rfs_block_map_close> <== NOT EXECUTED
}
116ef5: 81 c4 ac 00 00 00 add $0xac,%esp <== NOT EXECUTED
116efb: 89 d8 mov %ebx,%eax <== NOT EXECUTED
116efd: 5b pop %ebx <== NOT EXECUTED
116efe: 5e pop %esi <== NOT EXECUTED
116eff: 5f pop %edi <== NOT EXECUTED
116f00: 5d pop %ebp <== NOT EXECUTED
116f01: c3 ret <== NOT EXECUTED
116f02: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
116f09: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: dir=%" PRId32 ", name=",
116f10: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
116f13: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED
116f16: c7 04 24 64 56 13 00 movl $0x135664,(%esp) <== NOT EXECUTED
116f1d: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
116f21: e8 1a b2 fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
for (c = 0; c < length; c++)
116f26: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED
116f29: 85 c0 test %eax,%eax <== NOT EXECUTED
116f2b: 74 23 je 116f50 <rtems_rfs_dir_add_entry+0x3a0> <== NOT EXECUTED
116f2d: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED
116f30: 8b 5d 14 mov 0x14(%ebp),%ebx <== NOT EXECUTED
116f33: 01 f3 add %esi,%ebx <== NOT EXECUTED
116f35: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
116f3c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
printf ("%c", name[c]);
116f40: 0f be 06 movsbl (%esi),%eax <== NOT EXECUTED
for (c = 0; c < length; c++)
116f43: 46 inc %esi <== NOT EXECUTED
printf ("%c", name[c]);
116f44: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
116f47: e8 44 3b 01 00 call 12aa90 <putchar> <== NOT EXECUTED
for (c = 0; c < length; c++)
116f4c: 39 de cmp %ebx,%esi <== NOT EXECUTED
116f4e: 75 f0 jne 116f40 <rtems_rfs_dir_add_entry+0x390> <== NOT EXECUTED
printf (", len=%zd\n", length);
116f50: c7 04 24 a2 57 13 00 movl $0x1357a2,(%esp) <== NOT EXECUTED
116f57: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED
116f5a: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
116f5e: e8 dd b1 fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
116f63: e9 6e fc ff ff jmp 116bd6 <rtems_rfs_dir_add_entry+0x26> <== NOT EXECUTED
116f68: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
116f6f: 90 nop <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
116f70: 8b 85 7c ff ff ff mov -0x84(%ebp),%eax
116f76: ba 01 00 00 00 mov $0x1,%edx
116f7b: 89 54 24 0c mov %edx,0xc(%esp)
bpos.bno++;
116f7f: ff 45 80 incl -0x80(%ebp)
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
116f82: 89 44 24 08 mov %eax,0x8(%esp)
116f86: 8d 45 8c lea -0x74(%ebp),%eax
116f89: 89 44 24 04 mov %eax,0x4(%esp)
116f8d: 8b 45 08 mov 0x8(%ebp),%eax
116f90: 89 04 24 mov %eax,(%esp)
116f93: e8 38 06 ff ff call 1075d0 <rtems_rfs_buffer_handle_request>
if (rc > 0)
116f98: 85 c0 test %eax,%eax
116f9a: 0f 8f 16 fd ff ff jg 116cb6 <rtems_rfs_dir_add_entry+0x106> <== NEVER TAKEN
entry = rtems_rfs_buffer_data (&buffer);
116fa0: 8b 45 94 mov -0x6c(%ebp),%eax
116fa3: 8b 50 1c mov 0x1c(%eax),%edx
if (!read)
116fa6: e9 b5 fd ff ff jmp 116d60 <rtems_rfs_dir_add_entry+0x1b0>
116fab: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
116faf: 90 nop
memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
116fb0: c6 07 ff movb $0xff,(%edi) <== NOT EXECUTED
116fb3: e9 a8 fd ff ff jmp 116d60 <rtems_rfs_dir_add_entry+0x1b0> <== NOT EXECUTED
116fb8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
116fbf: 90 nop <== NOT EXECUTED
116fc0: 66 c7 07 ff ff movw $0xffff,(%edi) <== NOT EXECUTED
116fc5: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
116fc8: f6 c3 01 test $0x1,%bl <== NOT EXECUTED
116fcb: 0f 84 8f fd ff ff je 116d60 <rtems_rfs_dir_add_entry+0x1b0> <== NOT EXECUTED
116fd1: eb dd jmp 116fb0 <rtems_rfs_dir_add_entry+0x400> <== NOT EXECUTED
116fd3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
116fda: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
116fe0: c7 07 ff ff ff ff movl $0xffffffff,(%edi) <== NOT EXECUTED
116fe6: 83 c7 04 add $0x4,%edi <== NOT EXECUTED
116fe9: f6 c3 02 test $0x2,%bl <== NOT EXECUTED
116fec: 0f 84 57 fd ff ff je 116d49 <rtems_rfs_dir_add_entry+0x199> <== NOT EXECUTED
116ff2: eb cc jmp 116fc0 <rtems_rfs_dir_add_entry+0x410> <== NOT EXECUTED
116ff4: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
116ffb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
116fff: 90 nop <== NOT EXECUTED
117000: f6 c2 01 test $0x1,%dl
117003: 0f 85 0d 01 00 00 jne 117116 <rtems_rfs_dir_add_entry+0x566> <== NEVER TAKEN
117009: f7 c7 02 00 00 00 test $0x2,%edi
11700f: 90 nop
117010: 0f 85 f0 00 00 00 jne 117106 <rtems_rfs_dir_add_entry+0x556> <== NEVER TAKEN
117016: f7 c7 04 00 00 00 test $0x4,%edi
11701c: 0f 85 d3 00 00 00 jne 1170f5 <rtems_rfs_dir_add_entry+0x545> <== NEVER TAKEN
117022: 89 d9 mov %ebx,%ecx
117024: 83 e3 03 and $0x3,%ebx
117027: c1 e9 02 shr $0x2,%ecx
11702a: b8 ff ff ff ff mov $0xffffffff,%eax
11702f: f3 ab rep stos %eax,%es:(%edi)
117031: f6 c3 04 test $0x4,%bl
117034: 0f 84 06 fd ff ff je 116d40 <rtems_rfs_dir_add_entry+0x190> <== ALWAYS TAKEN
11703a: eb a4 jmp 116fe0 <rtems_rfs_dir_add_entry+0x430> <== NOT EXECUTED
11703c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
117040: 89 7c 24 10 mov %edi,0x10(%esp) <== NOT EXECUTED
117044: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
117047: 89 74 24 0c mov %esi,0xc(%esp) <== NOT EXECUTED
11704b: 89 5c 24 08 mov %ebx,0x8(%esp) <== NOT EXECUTED
11704f: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED
117052: c7 04 24 5c 57 13 00 movl $0x13575c,(%esp) <== NOT EXECUTED
117059: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
11705d: e8 de b0 fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
117062: e9 53 fe ff ff jmp 116eba <rtems_rfs_dir_add_entry+0x30a> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
117067: c7 04 24 00 00 00 20 movl $0x20000000,(%esp) <== NOT EXECUTED
11706e: 89 c3 mov %eax,%ebx <== NOT EXECUTED
117070: 31 c0 xor %eax,%eax <== NOT EXECUTED
117072: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
117076: e8 d5 47 ff ff call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
11707b: 84 c0 test %al,%al <== NOT EXECUTED
11707d: 0f 84 4f fc ff ff je 116cd2 <rtems_rfs_dir_add_entry+0x122> <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
117083: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
117086: e8 95 43 01 00 call 12b420 <strerror> <== NOT EXECUTED
11708b: 89 5c 24 08 mov %ebx,0x8(%esp) <== NOT EXECUTED
11708f: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
117093: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
117096: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED
117099: c7 04 24 8c 56 13 00 movl $0x13568c,(%esp) <== NOT EXECUTED
1170a0: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1170a4: e8 97 b0 fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
1170a9: e9 24 fc ff ff jmp 116cd2 <rtems_rfs_dir_add_entry+0x122> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
1170ae: c7 04 24 00 00 00 20 movl $0x20000000,(%esp) <== NOT EXECUTED
1170b5: 31 ff xor %edi,%edi <== NOT EXECUTED
1170b7: 89 c3 mov %eax,%ebx <== NOT EXECUTED
1170b9: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED
1170bd: e8 8e 47 ff ff call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
1170c2: 84 c0 test %al,%al <== NOT EXECUTED
1170c4: 0f 84 08 fc ff ff je 116cd2 <rtems_rfs_dir_add_entry+0x122> <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
1170ca: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
1170cd: e8 4e 43 01 00 call 12b420 <strerror> <== NOT EXECUTED
1170d2: 89 5c 24 08 mov %ebx,0x8(%esp) <== NOT EXECUTED
1170d6: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
1170da: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
1170dd: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED
1170e0: c7 04 24 d0 56 13 00 movl $0x1356d0,(%esp) <== NOT EXECUTED
1170e7: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1170eb: e8 50 b0 fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
1170f0: e9 dd fb ff ff jmp 116cd2 <rtems_rfs_dir_add_entry+0x122> <== NOT EXECUTED
memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
1170f5: c7 07 ff ff ff ff movl $0xffffffff,(%edi) <== NOT EXECUTED
1170fb: 83 eb 04 sub $0x4,%ebx <== NOT EXECUTED
1170fe: 83 c7 04 add $0x4,%edi <== NOT EXECUTED
117101: e9 1c ff ff ff jmp 117022 <rtems_rfs_dir_add_entry+0x472> <== NOT EXECUTED
117106: 66 c7 07 ff ff movw $0xffff,(%edi) <== NOT EXECUTED
11710b: 83 eb 02 sub $0x2,%ebx <== NOT EXECUTED
11710e: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
117111: e9 00 ff ff ff jmp 117016 <rtems_rfs_dir_add_entry+0x466> <== NOT EXECUTED
117116: c6 02 ff movb $0xff,(%edx) <== NOT EXECUTED
117119: 8d 7a 01 lea 0x1(%edx),%edi <== NOT EXECUTED
11711c: 4b dec %ebx <== NOT EXECUTED
11711d: e9 e7 fe ff ff jmp 117009 <rtems_rfs_dir_add_entry+0x459> <== NOT EXECUTED
117122: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
117129: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
117130: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
117133: e8 e8 42 01 00 call 12b420 <strerror> <== NOT EXECUTED
117138: 89 5c 24 08 mov %ebx,0x8(%esp) <== NOT EXECUTED
11713c: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
117140: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
117143: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED
117146: c7 04 24 14 57 13 00 movl $0x135714,(%esp) <== NOT EXECUTED
11714d: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
117151: e8 ea af fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
117156: e9 77 fb ff ff jmp 116cd2 <rtems_rfs_dir_add_entry+0x122> <== NOT EXECUTED
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
11715b: f7 c7 01 00 00 00 test $0x1,%edi
117161: 75 27 jne 11718a <rtems_rfs_dir_add_entry+0x5da>
117163: f7 c7 02 00 00 00 test $0x2,%edi
117169: 75 2b jne 117196 <rtems_rfs_dir_add_entry+0x5e6>
11716b: f7 c7 04 00 00 00 test $0x4,%edi
117171: 0f 84 dc fc ff ff je 116e53 <rtems_rfs_dir_add_entry+0x2a3>
117177: 8b 06 mov (%esi),%eax
117179: 83 c7 04 add $0x4,%edi
11717c: 83 c6 04 add $0x4,%esi
11717f: 83 e9 04 sub $0x4,%ecx
117182: 89 47 fc mov %eax,-0x4(%edi)
117185: e9 c9 fc ff ff jmp 116e53 <rtems_rfs_dir_add_entry+0x2a3>
11718a: 0f b6 06 movzbl (%esi),%eax
11718d: 49 dec %ecx
11718e: 46 inc %esi
11718f: 88 07 mov %al,(%edi)
117191: 8d 7a 0b lea 0xb(%edx),%edi
117194: eb cd jmp 117163 <rtems_rfs_dir_add_entry+0x5b3>
117196: 0f b7 06 movzwl (%esi),%eax
117199: 83 c7 02 add $0x2,%edi
11719c: 83 c6 02 add $0x2,%esi
11719f: 83 e9 02 sub $0x2,%ecx
1171a2: 66 89 47 fe mov %ax,-0x2(%edi)
1171a6: eb c3 jmp 11716b <rtems_rfs_dir_add_entry+0x5bb>
1171a8: 90 nop
1171a9: 90 nop
1171aa: 90 nop
1171ab: 90 nop
1171ac: 90 nop
1171ad: 90 nop
1171ae: 90 nop
1171af: 90 nop
001171b0 <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)
{
1171b0: 55 push %ebp
rtems_rfs_block_no block;
rtems_rfs_buffer_handle buffer;
bool search;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
1171b1: 31 c9 xor %ecx,%ecx
{
1171b3: 89 e5 mov %esp,%ebp
1171b5: 57 push %edi
1171b6: 56 push %esi
1171b7: 53 push %ebx
1171b8: 81 ec 9c 00 00 00 sub $0x9c,%esp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
1171be: c7 04 24 00 00 00 40 movl $0x40000000,(%esp)
1171c5: 89 4c 24 04 mov %ecx,0x4(%esp)
1171c9: e8 82 46 ff ff call 10b850 <rtems_rfs_trace>
1171ce: 84 c0 test %al,%al
1171d0: 0f 85 0a 02 00 00 jne 1173e0 <rtems_rfs_dir_del_entry+0x230> <== NEVER TAKEN
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);
1171d6: 8d 45 98 lea -0x68(%ebp),%eax
1171d9: 89 44 24 08 mov %eax,0x8(%esp)
1171dd: 8b 45 0c mov 0xc(%ebp),%eax
1171e0: 89 44 24 04 mov %eax,0x4(%esp)
1171e4: 8b 45 08 mov 0x8(%ebp),%eax
1171e7: 89 04 24 mov %eax,(%esp)
1171ea: e8 31 e7 ff ff call 115920 <rtems_rfs_block_map_open>
1171ef: 89 45 84 mov %eax,-0x7c(%ebp)
if (rc > 0)
1171f2: 85 c0 test %eax,%eax
1171f4: 7e 1a jle 117210 <rtems_rfs_dir_del_entry+0x60> <== ALWAYS TAKEN
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
1171f6: 8b 45 84 mov -0x7c(%ebp),%eax <== NOT EXECUTED
1171f9: 81 c4 9c 00 00 00 add $0x9c,%esp <== NOT EXECUTED
1171ff: 5b pop %ebx <== NOT EXECUTED
117200: 5e pop %esi <== NOT EXECUTED
117201: 5f pop %edi <== NOT EXECUTED
117202: 5d pop %ebp <== NOT EXECUTED
117203: c3 ret <== NOT EXECUTED
117204: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11720b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11720f: 90 nop <== NOT EXECUTED
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
117210: 8d 45 88 lea -0x78(%ebp),%eax
117213: 31 d2 xor %edx,%edx
117215: 89 44 24 10 mov %eax,0x10(%esp)
117219: 8b 45 14 mov 0x14(%ebp),%eax
11721c: 89 54 24 0c mov %edx,0xc(%esp)
117220: 89 44 24 08 mov %eax,0x8(%esp)
117224: 8d 45 98 lea -0x68(%ebp),%eax
117227: 89 44 24 04 mov %eax,0x4(%esp)
11722b: 8b 45 08 mov 0x8(%ebp),%eax
11722e: 89 04 24 mov %eax,(%esp)
117231: e8 0a eb ff ff call 115d40 <rtems_rfs_block_map_seek>
117236: 89 45 84 mov %eax,-0x7c(%ebp)
if (rc > 0)
117239: 85 c0 test %eax,%eax
11723b: 0f 8f ff 01 00 00 jg 117440 <rtems_rfs_dir_del_entry+0x290> <== NEVER TAKEN
handle->dirty = false;
117241: c6 45 8c 00 movb $0x0,-0x74(%ebp)
handle->bnum = 0;
117245: 8b 4d 08 mov 0x8(%ebp),%ecx
117248: c7 45 90 00 00 00 00 movl $0x0,-0x70(%ebp)
handle->buffer = NULL;
11724f: c7 45 94 00 00 00 00 movl $0x0,-0x6c(%ebp)
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
117256: 89 0c 24 mov %ecx,(%esp)
117259: b8 01 00 00 00 mov $0x1,%eax
11725e: 89 44 24 0c mov %eax,0xc(%esp)
117262: 8b 45 88 mov -0x78(%ebp),%eax
117265: 89 4d 08 mov %ecx,0x8(%ebp)
117268: 89 44 24 08 mov %eax,0x8(%esp)
11726c: 8d 45 8c lea -0x74(%ebp),%eax
11726f: 89 44 24 04 mov %eax,0x4(%esp)
117273: e8 58 03 ff ff call 1075d0 <rtems_rfs_buffer_handle_request>
if (rc > 0)
117278: 8b 4d 08 mov 0x8(%ebp),%ecx
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
11727b: 89 45 84 mov %eax,-0x7c(%ebp)
if (rc > 0)
11727e: 85 c0 test %eax,%eax
117280: 0f 8f c6 03 00 00 jg 11764c <rtems_rfs_dir_del_entry+0x49c> <== NEVER TAKEN
if (search)
117286: 8b 45 14 mov 0x14(%ebp),%eax
eoffset = offset % rtems_rfs_fs_block_size (fs);
117289: 8b 51 08 mov 0x8(%ecx),%edx
if (search)
11728c: 85 c0 test %eax,%eax
eoffset = offset % rtems_rfs_fs_block_size (fs);
11728e: 89 55 80 mov %edx,-0x80(%ebp)
if (search)
117291: 0f 84 c9 00 00 00 je 117360 <rtems_rfs_dir_del_entry+0x1b0> <== NEVER TAKEN
eoffset = offset % rtems_rfs_fs_block_size (fs);
117297: 8b 45 14 mov 0x14(%ebp),%eax
11729a: 89 d6 mov %edx,%esi
11729c: 31 d2 xor %edx,%edx
11729e: f7 f6 div %esi
1172a0: 89 d3 mov %edx,%ebx
1172a2: 89 d0 mov %edx,%eax
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
1172a4: 8b 55 94 mov -0x6c(%ebp),%edx
1172a7: 8b 72 1c mov 0x1c(%edx),%esi
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
1172aa: 8b 55 80 mov -0x80(%ebp),%edx
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
1172ad: 01 de add %ebx,%esi
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
1172af: 83 ea 0a sub $0xa,%edx
1172b2: 39 da cmp %ebx,%edx
1172b4: 77 4d ja 117303 <rtems_rfs_dir_del_entry+0x153> <== ALWAYS TAKEN
1172b6: eb 68 jmp 117320 <rtems_rfs_dir_del_entry+0x170> <== NOT EXECUTED
1172b8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1172bf: 90 nop <== NOT EXECUTED
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
1172c0: 83 ff 0a cmp $0xa,%edi
1172c3: 0f 8e a7 00 00 00 jle 117370 <rtems_rfs_dir_del_entry+0x1c0> <== NEVER TAKEN
1172c9: 39 79 1c cmp %edi,0x1c(%ecx)
1172cc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
1172d0: 0f 86 9a 00 00 00 jbe 117370 <rtems_rfs_dir_del_entry+0x1c0> <== NEVER TAKEN
1172d6: 85 db test %ebx,%ebx
1172d8: 0f 84 92 00 00 00 je 117370 <rtems_rfs_dir_del_entry+0x1c0> <== NEVER TAKEN
1172de: 39 59 14 cmp %ebx,0x14(%ecx)
1172e1: 0f 82 89 00 00 00 jb 117370 <rtems_rfs_dir_del_entry+0x1c0> <== NEVER TAKEN
if (ino == rtems_rfs_dir_entry_ino (entry))
1172e7: 39 5d 10 cmp %ebx,0x10(%ebp)
1172ea: 0f 84 70 01 00 00 je 117460 <rtems_rfs_dir_del_entry+0x2b0> <== ALWAYS TAKEN
if (!search)
1172f0: 8b 5d 14 mov 0x14(%ebp),%ebx <== NOT EXECUTED
1172f3: 85 db test %ebx,%ebx <== NOT EXECUTED
1172f5: 0f 85 45 03 00 00 jne 117640 <rtems_rfs_dir_del_entry+0x490> <== NOT EXECUTED
eoffset += elength;
1172fb: 01 f8 add %edi,%eax <== NOT EXECUTED
entry += elength;
1172fd: 01 fe add %edi,%esi <== NOT EXECUTED
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
1172ff: 39 c2 cmp %eax,%edx <== NOT EXECUTED
117301: 76 1d jbe 117320 <rtems_rfs_dir_del_entry+0x170> <== NOT EXECUTED
elength = rtems_rfs_dir_entry_length (entry);
117303: 0f b7 5e 08 movzwl 0x8(%esi),%ebx
117307: 89 df mov %ebx,%edi
117309: 0f b6 df movzbl %bh,%ebx
11730c: c1 e7 08 shl $0x8,%edi
11730f: 09 fb or %edi,%ebx
117311: 0f b7 fb movzwl %bx,%edi
eino = rtems_rfs_dir_entry_ino (entry);
117314: 8b 1e mov (%esi),%ebx
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
117316: 81 ff ff ff 00 00 cmp $0xffff,%edi
11731c: 0f cb bswap %ebx
11731e: 75 a0 jne 1172c0 <rtems_rfs_dir_del_entry+0x110> <== ALWAYS TAKEN
if (rc == 0)
117320: 8b 45 84 mov -0x7c(%ebp),%eax <== NOT EXECUTED
117323: 85 c0 test %eax,%eax <== NOT EXECUTED
117325: 75 6c jne 117393 <rtems_rfs_dir_del_entry+0x1e3> <== NOT EXECUTED
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
117327: 89 0c 24 mov %ecx,(%esp) <== NOT EXECUTED
11732a: 8d 45 88 lea -0x78(%ebp),%eax <== NOT EXECUTED
11732d: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
117331: 8d 45 98 lea -0x68(%ebp),%eax <== NOT EXECUTED
117334: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
117338: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED
11733b: e8 80 ea ff ff call 115dc0 <rtems_rfs_block_map_next_block> <== NOT EXECUTED
117340: 89 45 84 mov %eax,-0x7c(%ebp) <== NOT EXECUTED
if (rc == ENXIO)
117343: 83 f8 06 cmp $0x6,%eax <== NOT EXECUTED
117346: 0f 84 77 03 00 00 je 1176c3 <rtems_rfs_dir_del_entry+0x513> <== NOT EXECUTED
while (rc == 0)
11734c: 85 c0 test %eax,%eax <== NOT EXECUTED
11734e: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED
117351: 0f 84 ff fe ff ff je 117256 <rtems_rfs_dir_del_entry+0xa6> <== NOT EXECUTED
117357: eb 3a jmp 117393 <rtems_rfs_dir_del_entry+0x1e3> <== NOT EXECUTED
117359: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
117360: 31 db xor %ebx,%ebx <== NOT EXECUTED
eoffset = 0;
117362: 31 c0 xor %eax,%eax <== NOT EXECUTED
117364: e9 3b ff ff ff jmp 1172a4 <rtems_rfs_dir_del_entry+0xf4> <== NOT EXECUTED
117369: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
117370: 89 45 80 mov %eax,-0x80(%ebp) <== NOT EXECUTED
117373: 31 c0 xor %eax,%eax <== NOT EXECUTED
117375: c7 04 24 00 00 00 40 movl $0x40000000,(%esp) <== NOT EXECUTED
11737c: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
117380: e8 cb 44 ff ff call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
117385: 8b 55 80 mov -0x80(%ebp),%edx <== NOT EXECUTED
rc = EIO;
117388: c7 45 84 05 00 00 00 movl $0x5,-0x7c(%ebp) <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
11738f: 84 c0 test %al,%al <== NOT EXECUTED
117391: 75 7d jne 117410 <rtems_rfs_dir_del_entry+0x260> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
117393: 8d 45 8c lea -0x74(%ebp),%eax <== NOT EXECUTED
117396: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
11739a: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
11739d: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
1173a0: e8 0b 05 ff ff call 1078b0 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
1173a5: c6 45 8c 00 movb $0x0,-0x74(%ebp) <== NOT EXECUTED
handle->bnum = 0;
1173a9: c7 45 90 00 00 00 00 movl $0x0,-0x70(%ebp) <== NOT EXECUTED
handle->buffer = NULL;
1173b0: c7 45 94 00 00 00 00 movl $0x0,-0x6c(%ebp) <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
1173b7: 8d 45 98 lea -0x68(%ebp),%eax <== NOT EXECUTED
1173ba: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1173be: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
1173c1: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
1173c4: e8 87 e6 ff ff call 115a50 <rtems_rfs_block_map_close> <== NOT EXECUTED
}
1173c9: 8b 45 84 mov -0x7c(%ebp),%eax <== NOT EXECUTED
1173cc: 81 c4 9c 00 00 00 add $0x9c,%esp <== NOT EXECUTED
1173d2: 5b pop %ebx <== NOT EXECUTED
1173d3: 5e pop %esi <== NOT EXECUTED
1173d4: 5f pop %edi <== NOT EXECUTED
1173d5: 5d pop %ebp <== NOT EXECUTED
1173d6: c3 ret <== NOT EXECUTED
1173d7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1173de: 66 90 xchg %ax,%ax <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: dir=%" PRId32 ", entry=%" PRId32 " offset=%" PRIu32 "\n",
1173e0: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED
1173e3: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
1173e7: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
1173ea: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
1173ee: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
1173f1: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED
1173f4: c7 04 24 b0 57 13 00 movl $0x1357b0,(%esp) <== NOT EXECUTED
1173fb: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1173ff: e8 3c ad fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
117404: e9 cd fd ff ff jmp 1171d6 <rtems_rfs_dir_del_entry+0x26> <== NOT EXECUTED
117409: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
117410: 89 54 24 14 mov %edx,0x14(%esp) <== NOT EXECUTED
117414: 8b 45 88 mov -0x78(%ebp),%eax <== NOT EXECUTED
117417: 89 5c 24 0c mov %ebx,0xc(%esp) <== NOT EXECUTED
11741b: 89 7c 24 08 mov %edi,0x8(%esp) <== NOT EXECUTED
11741f: 89 44 24 10 mov %eax,0x10(%esp) <== NOT EXECUTED
117423: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
117426: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED
117429: c7 04 24 30 58 13 00 movl $0x135830,(%esp) <== NOT EXECUTED
117430: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
117434: e8 07 ad fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
while (rc == 0)
117439: e9 55 ff ff ff jmp 117393 <rtems_rfs_dir_del_entry+0x1e3> <== NOT EXECUTED
11743e: 66 90 xchg %ax,%ax <== NOT EXECUTED
if (rc == ENXIO)
117440: 83 f8 06 cmp $0x6,%eax <== NOT EXECUTED
117443: 0f 85 6e ff ff ff jne 1173b7 <rtems_rfs_dir_del_entry+0x207> <== NOT EXECUTED
rc = ENOENT;
117449: c7 45 84 02 00 00 00 movl $0x2,-0x7c(%ebp) <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
117450: e9 62 ff ff ff jmp 1173b7 <rtems_rfs_dir_del_entry+0x207> <== NOT EXECUTED
117455: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11745c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
memmove (entry, entry + elength, remaining);
117460: 89 34 24 mov %esi,(%esp)
remaining = rtems_rfs_fs_block_size (fs) - (eoffset + elength);
117463: 8b 4d 80 mov -0x80(%ebp),%ecx
117466: 89 c2 mov %eax,%edx
117468: 89 95 7c ff ff ff mov %edx,-0x84(%ebp)
11746e: 01 f8 add %edi,%eax
117470: 29 c1 sub %eax,%ecx
memmove (entry, entry + elength, remaining);
117472: 89 4c 24 08 mov %ecx,0x8(%esp)
117476: 8d 04 3e lea (%esi,%edi,1),%eax
117479: 89 44 24 04 mov %eax,0x4(%esp)
11747d: 89 4d 80 mov %ecx,-0x80(%ebp)
117480: e8 eb 34 01 00 call 12a970 <memmove>
memset (entry + remaining, 0xff, elength);
117485: 8b 4d 80 mov -0x80(%ebp),%ecx
117488: 89 7d 84 mov %edi,-0x7c(%ebp)
11748b: 8b 95 7c ff ff ff mov -0x84(%ebp),%edx
117491: 8d 3c 0e lea (%esi,%ecx,1),%edi
117494: f7 c7 01 00 00 00 test $0x1,%edi
11749a: 0f 85 17 02 00 00 jne 1176b7 <rtems_rfs_dir_del_entry+0x507>
1174a0: f7 c7 02 00 00 00 test $0x2,%edi
1174a6: 0f 85 fa 01 00 00 jne 1176a6 <rtems_rfs_dir_del_entry+0x4f6>
1174ac: f7 c7 04 00 00 00 test $0x4,%edi
1174b2: 0f 85 dc 01 00 00 jne 117694 <rtems_rfs_dir_del_entry+0x4e4>
1174b8: 8b 4d 84 mov -0x7c(%ebp),%ecx
1174bb: b8 ff ff ff ff mov $0xffffffff,%eax
1174c0: c1 e9 02 shr $0x2,%ecx
1174c3: f3 ab rep stos %eax,%es:(%edi)
1174c5: f6 45 84 02 testb $0x2,-0x7c(%ebp)
1174c9: 74 08 je 1174d3 <rtems_rfs_dir_del_entry+0x323> <== ALWAYS TAKEN
1174cb: 66 c7 07 ff ff movw $0xffff,(%edi) <== NOT EXECUTED
1174d0: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
1174d3: f6 45 84 01 testb $0x1,-0x7c(%ebp)
1174d7: 74 03 je 1174dc <rtems_rfs_dir_del_entry+0x32c> <== ALWAYS TAKEN
1174d9: c6 07 ff movb $0xff,(%edi) <== NOT EXECUTED
1174dc: 89 55 84 mov %edx,-0x7c(%ebp)
elength = rtems_rfs_dir_entry_length (entry);
1174df: 0f b7 46 08 movzwl 0x8(%esi),%eax
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
1174e3: c7 04 24 00 00 00 40 movl $0x40000000,(%esp)
1174ea: 89 c7 mov %eax,%edi
1174ec: 0f b6 c4 movzbl %ah,%eax
1174ef: c1 e7 08 shl $0x8,%edi
1174f2: 09 f8 or %edi,%eax
1174f4: 0f b7 f8 movzwl %ax,%edi
1174f7: 31 c0 xor %eax,%eax
1174f9: 89 44 24 04 mov %eax,0x4(%esp)
1174fd: e8 4e 43 ff ff call 10b850 <rtems_rfs_trace>
117502: 8b 55 84 mov -0x7c(%ebp),%edx
117505: 84 c0 test %al,%al
117507: 74 43 je 11754c <rtems_rfs_dir_del_entry+0x39c> <== ALWAYS TAKEN
printf ("rtems-rfs: dir-del-entry: "
117509: c7 45 84 37 46 13 00 movl $0x134637,-0x7c(%ebp) <== NOT EXECUTED
rtems_rfs_block_map_last (&map) ? "yes" : "no");
117510: 8b 4d a8 mov -0x58(%ebp),%ecx <== NOT EXECUTED
117513: 8b 45 a0 mov -0x60(%ebp),%eax <== NOT EXECUTED
117516: 89 ce mov %ecx,%esi <== NOT EXECUTED
117518: 09 c6 or %eax,%esi <== NOT EXECUTED
11751a: 0f 85 fe 00 00 00 jne 11761e <rtems_rfs_dir_del_entry+0x46e> <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
117520: 89 54 24 10 mov %edx,0x10(%esp) <== NOT EXECUTED
117524: 8b 45 84 mov -0x7c(%ebp),%eax <== NOT EXECUTED
117527: 89 7c 24 08 mov %edi,0x8(%esp) <== NOT EXECUTED
11752b: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
11752f: c7 04 24 7c 58 13 00 movl $0x13587c,(%esp) <== NOT EXECUTED
117536: 89 44 24 14 mov %eax,0x14(%esp) <== NOT EXECUTED
11753a: 8b 45 88 mov -0x78(%ebp),%eax <== NOT EXECUTED
11753d: 89 55 84 mov %edx,-0x7c(%ebp) <== NOT EXECUTED
117540: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
117544: e8 f7 ab fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
117549: 8b 55 84 mov -0x7c(%ebp),%edx <== NOT EXECUTED
if ((elength == RTEMS_RFS_DIR_ENTRY_EMPTY) &&
11754c: 81 ff ff ff 00 00 cmp $0xffff,%edi
117552: 75 71 jne 1175c5 <rtems_rfs_dir_del_entry+0x415>
117554: 85 d2 test %edx,%edx
117556: 75 6d jne 1175c5 <rtems_rfs_dir_del_entry+0x415> <== ALWAYS TAKEN
(eoffset == 0) && rtems_rfs_block_map_last (&map))
117558: 8b 55 a8 mov -0x58(%ebp),%edx <== NOT EXECUTED
11755b: 8b 45 a0 mov -0x60(%ebp),%eax <== NOT EXECUTED
11755e: 89 d1 mov %edx,%ecx <== NOT EXECUTED
117560: 09 c1 or %eax,%ecx <== NOT EXECUTED
117562: 0f 85 ac 00 00 00 jne 117614 <rtems_rfs_dir_del_entry+0x464> <== NOT EXECUTED
rc = rtems_rfs_block_map_shrink (fs, &map, 1);
117568: 8d 45 98 lea -0x68(%ebp),%eax <== NOT EXECUTED
11756b: bf 01 00 00 00 mov $0x1,%edi <== NOT EXECUTED
117570: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
117574: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
117577: 89 7c 24 08 mov %edi,0x8(%esp) <== NOT EXECUTED
11757b: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
11757e: e8 2d ec ff ff call 1161b0 <rtems_rfs_block_map_shrink> <== NOT EXECUTED
if (rc > 0)
117583: 85 c0 test %eax,%eax <== NOT EXECUTED
rc = rtems_rfs_block_map_shrink (fs, &map, 1);
117585: 89 c3 mov %eax,%ebx <== NOT EXECUTED
if (rc > 0)
117587: 7e 3c jle 1175c5 <rtems_rfs_dir_del_entry+0x415> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
117589: c7 04 24 00 00 00 40 movl $0x40000000,(%esp) <== NOT EXECUTED
117590: 31 f6 xor %esi,%esi <== NOT EXECUTED
117592: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED
117596: e8 b5 42 ff ff call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
11759b: 84 c0 test %al,%al <== NOT EXECUTED
11759d: 74 26 je 1175c5 <rtems_rfs_dir_del_entry+0x415> <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
11759f: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
1175a2: e8 79 3e 01 00 call 12b420 <strerror> <== NOT EXECUTED
1175a7: 89 5c 24 08 mov %ebx,0x8(%esp) <== NOT EXECUTED
1175ab: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
1175af: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
1175b2: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED
1175b5: c7 04 24 dc 58 13 00 movl $0x1358dc,(%esp) <== NOT EXECUTED
1175bc: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1175c0: e8 7b ab fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&buffer);
1175c5: c6 45 8c 01 movb $0x1,-0x74(%ebp)
rtems_rfs_buffer_handle_release (fs, handle);
1175c9: 8d 45 8c lea -0x74(%ebp),%eax
1175cc: 89 44 24 04 mov %eax,0x4(%esp)
1175d0: 8b 45 08 mov 0x8(%ebp),%eax
1175d3: 89 04 24 mov %eax,(%esp)
1175d6: e8 d5 02 ff ff call 1078b0 <rtems_rfs_buffer_handle_release>
rtems_rfs_block_map_close (fs, &map);
1175db: 8d 45 98 lea -0x68(%ebp),%eax
1175de: 89 44 24 04 mov %eax,0x4(%esp)
1175e2: 8b 45 08 mov 0x8(%ebp),%eax
handle->dirty = false;
1175e5: c6 45 8c 00 movb $0x0,-0x74(%ebp)
handle->bnum = 0;
1175e9: c7 45 90 00 00 00 00 movl $0x0,-0x70(%ebp)
handle->buffer = NULL;
1175f0: c7 45 94 00 00 00 00 movl $0x0,-0x6c(%ebp)
1175f7: 89 04 24 mov %eax,(%esp)
1175fa: e8 51 e4 ff ff call 115a50 <rtems_rfs_block_map_close>
return 0;
1175ff: c7 45 84 00 00 00 00 movl $0x0,-0x7c(%ebp)
}
117606: 8b 45 84 mov -0x7c(%ebp),%eax
117609: 81 c4 9c 00 00 00 add $0x9c,%esp
11760f: 5b pop %ebx
117610: 5e pop %esi
117611: 5f pop %edi
117612: 5d pop %ebp
117613: c3 ret
(eoffset == 0) && rtems_rfs_block_map_last (&map))
117614: 48 dec %eax <== NOT EXECUTED
117615: 39 c2 cmp %eax,%edx <== NOT EXECUTED
117617: 75 ac jne 1175c5 <rtems_rfs_dir_del_entry+0x415> <== NOT EXECUTED
117619: e9 4a ff ff ff jmp 117568 <rtems_rfs_dir_del_entry+0x3b8> <== NOT EXECUTED
rtems_rfs_block_map_last (&map) ? "yes" : "no");
11761e: 48 dec %eax <== NOT EXECUTED
11761f: 39 c1 cmp %eax,%ecx <== NOT EXECUTED
117621: 0f 84 f9 fe ff ff je 117520 <rtems_rfs_dir_del_entry+0x370> <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
117627: c7 45 84 3b 46 13 00 movl $0x13463b,-0x7c(%ebp) <== NOT EXECUTED
11762e: e9 ed fe ff ff jmp 117520 <rtems_rfs_dir_del_entry+0x370> <== NOT EXECUTED
117633: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11763a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
rc = EIO;
117640: c7 45 84 05 00 00 00 movl $0x5,-0x7c(%ebp) <== NOT EXECUTED
while (rc == 0)
117647: e9 47 fd ff ff jmp 117393 <rtems_rfs_dir_del_entry+0x1e3> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
11764c: c7 04 24 00 00 00 40 movl $0x40000000,(%esp) <== NOT EXECUTED
117653: 31 c0 xor %eax,%eax <== NOT EXECUTED
117655: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
117659: e8 f2 41 ff ff call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
11765e: 84 c0 test %al,%al <== NOT EXECUTED
117660: 0f 84 2d fd ff ff je 117393 <rtems_rfs_dir_del_entry+0x1e3> <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
117666: 8b 75 84 mov -0x7c(%ebp),%esi <== NOT EXECUTED
117669: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
11766c: e8 af 3d 01 00 call 12b420 <strerror> <== NOT EXECUTED
117671: 89 74 24 08 mov %esi,0x8(%esp) <== NOT EXECUTED
117675: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
117679: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
11767c: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED
11767f: c7 04 24 e8 57 13 00 movl $0x1357e8,(%esp) <== NOT EXECUTED
117686: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
11768a: e8 b1 aa fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
11768f: e9 ff fc ff ff jmp 117393 <rtems_rfs_dir_del_entry+0x1e3> <== NOT EXECUTED
memset (entry + remaining, 0xff, elength);
117694: c7 07 ff ff ff ff movl $0xffffffff,(%edi)
11769a: 83 c7 04 add $0x4,%edi
11769d: 83 6d 84 04 subl $0x4,-0x7c(%ebp)
1176a1: e9 12 fe ff ff jmp 1174b8 <rtems_rfs_dir_del_entry+0x308>
1176a6: 66 c7 07 ff ff movw $0xffff,(%edi)
1176ab: 83 c7 02 add $0x2,%edi
1176ae: 83 6d 84 02 subl $0x2,-0x7c(%ebp)
1176b2: e9 f5 fd ff ff jmp 1174ac <rtems_rfs_dir_del_entry+0x2fc>
1176b7: c6 07 ff movb $0xff,(%edi)
1176ba: 47 inc %edi
1176bb: ff 4d 84 decl -0x7c(%ebp)
1176be: e9 dd fd ff ff jmp 1174a0 <rtems_rfs_dir_del_entry+0x2f0>
rc = ENOENT;
1176c3: c7 45 84 02 00 00 00 movl $0x2,-0x7c(%ebp) <== NOT EXECUTED
1176ca: e9 c4 fc ff ff jmp 117393 <rtems_rfs_dir_del_entry+0x1e3> <== NOT EXECUTED
1176cf: 90 nop
00117c80 <rtems_rfs_dir_empty>:
int
rtems_rfs_dir_empty (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir)
{
117c80: 55 push %ebp
rtems_rfs_buffer_handle buffer;
rtems_rfs_block_no block;
bool empty;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
117c81: 31 c0 xor %eax,%eax
{
117c83: 89 e5 mov %esp,%ebp
117c85: 57 push %edi
117c86: 56 push %esi
117c87: 53 push %ebx
117c88: 81 ec 9c 00 00 00 sub $0x9c,%esp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
117c8e: c7 04 24 00 00 00 80 movl $0x80000000,(%esp)
117c95: 89 44 24 04 mov %eax,0x4(%esp)
117c99: e8 b2 3b ff ff call 10b850 <rtems_rfs_trace>
117c9e: 8b 55 08 mov 0x8(%ebp),%edx
117ca1: 84 c0 test %al,%al
117ca3: 0f 85 17 02 00 00 jne 117ec0 <rtems_rfs_dir_empty+0x240> <== NEVER TAKEN
printf ("rtems-rfs: dir-empty: dir=%" PRId32 "\n", rtems_rfs_inode_ino (dir));
empty = true;
rc = rtems_rfs_block_map_open (fs, dir, &map);
117ca9: 89 14 24 mov %edx,(%esp)
117cac: 8d 45 98 lea -0x68(%ebp),%eax
117caf: 89 44 24 08 mov %eax,0x8(%esp)
117cb3: 8b 45 0c mov 0xc(%ebp),%eax
117cb6: 89 55 08 mov %edx,0x8(%ebp)
117cb9: 89 44 24 04 mov %eax,0x4(%esp)
117cbd: e8 5e dc ff ff call 115920 <rtems_rfs_block_map_open>
if (rc > 0)
117cc2: 8b 55 08 mov 0x8(%ebp),%edx
rc = rtems_rfs_block_map_open (fs, dir, &map);
117cc5: 89 45 80 mov %eax,-0x80(%ebp)
if (rc > 0)
117cc8: 85 c0 test %eax,%eax
117cca: 7e 14 jle 117ce0 <rtems_rfs_dir_empty+0x60> <== ALWAYS TAKEN
rc = ENOTEMPTY;
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
117ccc: 8b 45 80 mov -0x80(%ebp),%eax <== NOT EXECUTED
117ccf: 81 c4 9c 00 00 00 add $0x9c,%esp <== NOT EXECUTED
117cd5: 5b pop %ebx <== NOT EXECUTED
117cd6: 5e pop %esi <== NOT EXECUTED
117cd7: 5f pop %edi <== NOT EXECUTED
117cd8: 5d pop %ebp <== NOT EXECUTED
117cd9: c3 ret <== NOT EXECUTED
117cda: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
117ce0: 8d 45 88 lea -0x78(%ebp),%eax
117ce3: 31 f6 xor %esi,%esi
117ce5: 89 44 24 10 mov %eax,0x10(%esp)
117ce9: 8d 45 98 lea -0x68(%ebp),%eax
117cec: 31 ff xor %edi,%edi
117cee: 89 14 24 mov %edx,(%esp)
117cf1: 89 74 24 08 mov %esi,0x8(%esp)
117cf5: 89 7c 24 0c mov %edi,0xc(%esp)
117cf9: 89 44 24 04 mov %eax,0x4(%esp)
117cfd: e8 3e e0 ff ff call 115d40 <rtems_rfs_block_map_seek>
if (rc > 0)
117d02: 8b 55 08 mov 0x8(%ebp),%edx
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
117d05: 89 45 80 mov %eax,-0x80(%ebp)
if (rc > 0)
117d08: 85 c0 test %eax,%eax
117d0a: 0f 8f ce 01 00 00 jg 117ede <rtems_rfs_dir_empty+0x25e> <== NEVER TAKEN
handle->dirty = false;
117d10: c6 45 8c 00 movb $0x0,-0x74(%ebp)
handle->bnum = 0;
117d14: c7 45 90 00 00 00 00 movl $0x0,-0x70(%ebp)
handle->buffer = NULL;
117d1b: c7 45 94 00 00 00 00 movl $0x0,-0x6c(%ebp)
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
117d22: 89 14 24 mov %edx,(%esp)
117d25: 8b 45 88 mov -0x78(%ebp),%eax
117d28: bb 01 00 00 00 mov $0x1,%ebx
117d2d: 89 5c 24 0c mov %ebx,0xc(%esp)
117d31: 89 55 08 mov %edx,0x8(%ebp)
117d34: 89 44 24 08 mov %eax,0x8(%esp)
117d38: 8d 45 8c lea -0x74(%ebp),%eax
117d3b: 89 44 24 04 mov %eax,0x4(%esp)
117d3f: e8 8c f8 fe ff call 1075d0 <rtems_rfs_buffer_handle_request>
if (rc > 0)
117d44: 8b 55 08 mov 0x8(%ebp),%edx
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
117d47: 89 45 80 mov %eax,-0x80(%ebp)
if (rc > 0)
117d4a: 85 c0 test %eax,%eax
117d4c: 0f 8f 8e 00 00 00 jg 117de0 <rtems_rfs_dir_empty+0x160> <== NEVER TAKEN
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
117d52: 8b 4a 08 mov 0x8(%edx),%ecx
entry = rtems_rfs_buffer_data (&buffer);
117d55: 8b 45 94 mov -0x6c(%ebp),%eax
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
117d58: 83 e9 0a sub $0xa,%ecx
entry = rtems_rfs_buffer_data (&buffer);
117d5b: 8b 40 1c mov 0x1c(%eax),%eax
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
117d5e: 0f 84 13 01 00 00 je 117e77 <rtems_rfs_dir_empty+0x1f7> <== NEVER TAKEN
offset = 0;
117d64: 89 4d 84 mov %ecx,-0x7c(%ebp)
117d67: 31 ff xor %edi,%edi
117d69: eb 23 jmp 117d8e <rtems_rfs_dir_empty+0x10e>
117d6b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
117d6f: 90 nop
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.')) &&
117d70: 83 fb 0c cmp $0xc,%ebx
117d73: 75 5d jne 117dd2 <rtems_rfs_dir_empty+0x152>
((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 2)) ||
117d75: 80 78 0a 2e cmpb $0x2e,0xa(%eax)
117d79: 75 57 jne 117dd2 <rtems_rfs_dir_empty+0x152> <== NEVER TAKEN
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.') ||
117d7b: 80 78 0b 2e cmpb $0x2e,0xb(%eax)
117d7f: 75 51 jne 117dd2 <rtems_rfs_dir_empty+0x152> <== NEVER TAKEN
offset += elength;
117d81: 01 df add %ebx,%edi
entry += elength;
117d83: 01 d8 add %ebx,%eax
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
117d85: 3b 7d 84 cmp -0x7c(%ebp),%edi
117d88: 0f 83 e9 00 00 00 jae 117e77 <rtems_rfs_dir_empty+0x1f7> <== NEVER TAKEN
elength = rtems_rfs_dir_entry_length (entry);
117d8e: 0f b7 70 08 movzwl 0x8(%eax),%esi
117d92: 89 f3 mov %esi,%ebx
117d94: 89 f1 mov %esi,%ecx
117d96: c1 e3 08 shl $0x8,%ebx
117d99: 0f b6 f5 movzbl %ch,%esi
117d9c: 09 de or %ebx,%esi
117d9e: 0f b7 de movzwl %si,%ebx
eino = rtems_rfs_dir_entry_ino (entry);
117da1: 8b 30 mov (%eax),%esi
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
117da3: 81 fb ff ff 00 00 cmp $0xffff,%ebx
117da9: 0f ce bswap %esi
117dab: 0f 84 c6 00 00 00 je 117e77 <rtems_rfs_dir_empty+0x1f7>
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
117db1: 83 fb 0a cmp $0xa,%ebx
117db4: 7e 7a jle 117e30 <rtems_rfs_dir_empty+0x1b0> <== NEVER TAKEN
117db6: 39 5a 1c cmp %ebx,0x1c(%edx)
117db9: 76 75 jbe 117e30 <rtems_rfs_dir_empty+0x1b0> <== NEVER TAKEN
117dbb: 85 f6 test %esi,%esi
117dbd: 8d 76 00 lea 0x0(%esi),%esi
117dc0: 74 6e je 117e30 <rtems_rfs_dir_empty+0x1b0> <== NEVER TAKEN
117dc2: 39 72 14 cmp %esi,0x14(%edx)
117dc5: 72 69 jb 117e30 <rtems_rfs_dir_empty+0x1b0> <== NEVER TAKEN
if (((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 1)) ||
117dc7: 83 fb 0b cmp $0xb,%ebx
117dca: 75 a4 jne 117d70 <rtems_rfs_dir_empty+0xf0>
117dcc: 80 78 0a 2e cmpb $0x2e,0xa(%eax)
117dd0: 74 af je 117d81 <rtems_rfs_dir_empty+0x101> <== ALWAYS TAKEN
if ((rc == 0) && !empty)
117dd2: 8b 4d 80 mov -0x80(%ebp),%ecx
117dd5: 85 c9 test %ecx,%ecx
117dd7: 75 07 jne 117de0 <rtems_rfs_dir_empty+0x160> <== NEVER TAKEN
rc = ENOTEMPTY;
117dd9: c7 45 80 5a 00 00 00 movl $0x5a,-0x80(%ebp)
rtems_rfs_buffer_handle_release (fs, handle);
117de0: 89 14 24 mov %edx,(%esp)
117de3: 8d 45 8c lea -0x74(%ebp),%eax
117de6: 89 44 24 04 mov %eax,0x4(%esp)
117dea: 89 55 08 mov %edx,0x8(%ebp)
117ded: e8 be fa fe ff call 1078b0 <rtems_rfs_buffer_handle_release>
rtems_rfs_block_map_close (fs, &map);
117df2: 8b 55 08 mov 0x8(%ebp),%edx
117df5: 8d 45 98 lea -0x68(%ebp),%eax
117df8: 89 44 24 04 mov %eax,0x4(%esp)
handle->dirty = false;
117dfc: c6 45 8c 00 movb $0x0,-0x74(%ebp)
handle->bnum = 0;
117e00: c7 45 90 00 00 00 00 movl $0x0,-0x70(%ebp)
117e07: 89 14 24 mov %edx,(%esp)
handle->buffer = NULL;
117e0a: c7 45 94 00 00 00 00 movl $0x0,-0x6c(%ebp)
117e11: e8 3a dc ff ff call 115a50 <rtems_rfs_block_map_close>
}
117e16: 8b 45 80 mov -0x80(%ebp),%eax
117e19: 81 c4 9c 00 00 00 add $0x9c,%esp
117e1f: 5b pop %ebx
117e20: 5e pop %esi
117e21: 5f pop %edi
117e22: 5d pop %ebp
117e23: c3 ret
117e24: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
117e2b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
117e2f: 90 nop
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY))
117e30: c7 04 24 00 00 00 00 movl $0x0,(%esp) <== NOT EXECUTED
117e37: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
117e3c: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
117e40: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED
117e43: e8 08 3a ff ff call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
117e48: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
117e4b: 84 c0 test %al,%al <== NOT EXECUTED
117e4d: 74 28 je 117e77 <rtems_rfs_dir_empty+0x1f7> <== NOT EXECUTED
printf ("rtems-rfs: dir-empty: "
117e4f: 89 7c 24 10 mov %edi,0x10(%esp) <== NOT EXECUTED
117e53: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
117e56: 89 74 24 0c mov %esi,0xc(%esp) <== NOT EXECUTED
117e5a: 89 5c 24 08 mov %ebx,0x8(%esp) <== NOT EXECUTED
117e5e: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED
117e61: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED
117e64: c7 04 24 20 5a 13 00 movl $0x135a20,(%esp) <== NOT EXECUTED
117e6b: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
117e6f: e8 cc a2 fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
if (empty)
117e74: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
117e77: 89 14 24 mov %edx,(%esp)
117e7a: 8d 45 88 lea -0x78(%ebp),%eax
117e7d: 89 44 24 08 mov %eax,0x8(%esp)
117e81: 8d 45 98 lea -0x68(%ebp),%eax
117e84: 89 44 24 04 mov %eax,0x4(%esp)
117e88: 89 55 08 mov %edx,0x8(%ebp)
117e8b: e8 30 df ff ff call 115dc0 <rtems_rfs_block_map_next_block>
if (rc > 0)
117e90: 8b 55 08 mov 0x8(%ebp),%edx
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
117e93: 89 45 80 mov %eax,-0x80(%ebp)
if (rc > 0)
117e96: 85 c0 test %eax,%eax
117e98: 0f 8e 84 fe ff ff jle 117d22 <rtems_rfs_dir_empty+0xa2> <== NEVER TAKEN
if (rc == ENXIO)
117e9e: 83 f8 06 cmp $0x6,%eax
117ea1: 0f 85 39 ff ff ff jne 117de0 <rtems_rfs_dir_empty+0x160> <== NEVER TAKEN
rc = 0;
117ea7: c7 45 80 00 00 00 00 movl $0x0,-0x80(%ebp)
117eae: e9 2d ff ff ff jmp 117de0 <rtems_rfs_dir_empty+0x160>
117eb3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
117eba: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
printf ("rtems-rfs: dir-empty: dir=%" PRId32 "\n", rtems_rfs_inode_ino (dir));
117ec0: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
117ec3: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED
117ec6: c7 04 24 02 5a 13 00 movl $0x135a02,(%esp) <== NOT EXECUTED
117ecd: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
117ed1: e8 6a a2 fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
117ed6: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
117ed9: e9 cb fd ff ff jmp 117ca9 <rtems_rfs_dir_empty+0x29> <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
117ede: 89 14 24 mov %edx,(%esp) <== NOT EXECUTED
117ee1: 8d 45 98 lea -0x68(%ebp),%eax <== NOT EXECUTED
117ee4: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
117ee8: e8 63 db ff ff call 115a50 <rtems_rfs_block_map_close> <== NOT EXECUTED
}
117eed: 8b 45 80 mov -0x80(%ebp),%eax <== NOT EXECUTED
117ef0: 81 c4 9c 00 00 00 add $0x9c,%esp <== NOT EXECUTED
117ef6: 5b pop %ebx <== NOT EXECUTED
117ef7: 5e pop %esi <== NOT EXECUTED
117ef8: 5f pop %edi <== NOT EXECUTED
117ef9: 5d pop %ebp <== NOT EXECUTED
117efa: c3 ret <== NOT EXECUTED
117efb: 90 nop
117efc: 90 nop
117efd: 90 nop
117efe: 90 nop
117eff: 90 nop
00117f00 <rtems_rfs_dir_hash>:
*/
#define initval (20010928)
uint32_t
rtems_rfs_dir_hash (const void *key, size_t length)
{
117f00: 55 push %ebp
117f01: 89 e5 mov %esp,%ebp
117f03: 57 push %edi
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;
117f04: 8b 45 0c mov 0xc(%ebp),%eax
{
117f07: 56 push %esi
117f08: 53 push %ebx
117f09: 8b 5d 08 mov 0x8(%ebp),%ebx
a = b = c = 0xdeadbeef + ((uint32_t)length) + initval;
117f0c: 2d 61 e9 20 20 sub $0x2020e961,%eax
117f11: 89 c2 mov %eax,%edx
117f13: 89 c1 mov %eax,%ecx
u.ptr = key;
if (HASH_LITTLE_ENDIAN && ((u.i & 0x3) == 0)) {
117f15: f6 c3 03 test $0x3,%bl
117f18: 0f 85 22 01 00 00 jne 118040 <rtems_rfs_dir_hash+0x140>
const uint32_t *k = (const uint32_t *)key; /* read 32-bit chunks */
/*const uint8_t *k8;*/
/*------ all but last block: aligned reads and affect 32 bits of (a,b,c) */
while (length > 12)
117f1e: 83 7d 0c 0c cmpl $0xc,0xc(%ebp)
117f22: 76 6b jbe 117f8f <rtems_rfs_dir_hash+0x8f>
a = b = c = 0xdeadbeef + ((uint32_t)length) + initval;
117f24: 8b 75 0c mov 0xc(%ebp),%esi
117f27: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
117f2e: 66 90 xchg %ax,%ax
{
a += k[0];
b += k[1];
117f30: 8b 7b 04 mov 0x4(%ebx),%edi
c += k[2];
mix(a,b,c);
length -= 12;
117f33: 83 ee 0c sub $0xc,%esi
k += 3;
117f36: 83 c3 0c add $0xc,%ebx
b += k[1];
117f39: 01 f9 add %edi,%ecx
c += k[2];
117f3b: 8b 7b fc mov -0x4(%ebx),%edi
117f3e: 01 fa add %edi,%edx
mix(a,b,c);
117f40: 8b 7b f4 mov -0xc(%ebx),%edi
117f43: 29 d7 sub %edx,%edi
117f45: 01 f8 add %edi,%eax
117f47: 89 d7 mov %edx,%edi
117f49: c1 c7 04 rol $0x4,%edi
117f4c: 01 ca add %ecx,%edx
117f4e: 31 f8 xor %edi,%eax
117f50: 89 c7 mov %eax,%edi
117f52: 29 c1 sub %eax,%ecx
117f54: c1 c7 06 rol $0x6,%edi
117f57: 01 d0 add %edx,%eax
117f59: 31 f9 xor %edi,%ecx
117f5b: 89 cf mov %ecx,%edi
117f5d: 29 ca sub %ecx,%edx
117f5f: c1 c7 08 rol $0x8,%edi
117f62: 01 c1 add %eax,%ecx
117f64: 31 fa xor %edi,%edx
117f66: 89 d7 mov %edx,%edi
117f68: 29 d0 sub %edx,%eax
117f6a: c1 c7 10 rol $0x10,%edi
117f6d: 01 ca add %ecx,%edx
117f6f: 31 f8 xor %edi,%eax
117f71: 89 c7 mov %eax,%edi
117f73: 29 c1 sub %eax,%ecx
117f75: c1 cf 0d ror $0xd,%edi
117f78: 01 d0 add %edx,%eax
117f7a: 31 f9 xor %edi,%ecx
117f7c: 89 cf mov %ecx,%edi
117f7e: 29 ca sub %ecx,%edx
117f80: c1 c7 04 rol $0x4,%edi
117f83: 01 c1 add %eax,%ecx
117f85: 31 fa xor %edi,%edx
while (length > 12)
117f87: 83 fe 0c cmp $0xc,%esi
117f8a: 77 a4 ja 117f30 <rtems_rfs_dir_hash+0x30> <== NEVER TAKEN
117f8c: 89 75 0c mov %esi,0xc(%ebp)
117f8f: 8b 7d 0c mov 0xc(%ebp),%edi
117f92: ff 24 bd 64 5a 13 00 jmp *0x135a64(,%edi,4)
}
/*-------------------------------- last block: affect all 32 bits of (c) */
switch(length) /* all the case statements fall through */
{
case 12: c+=((uint32_t)k[11])<<24;
117f99: 0f b6 73 0b movzbl 0xb(%ebx),%esi <== NOT EXECUTED
117f9d: c1 e6 18 shl $0x18,%esi <== NOT EXECUTED
117fa0: 01 f2 add %esi,%edx <== NOT EXECUTED
case 11: c+=((uint32_t)k[10])<<16;
117fa2: 0f b6 73 0a movzbl 0xa(%ebx),%esi
117fa6: c1 e6 10 shl $0x10,%esi
117fa9: 01 f2 add %esi,%edx
case 10: c+=((uint32_t)k[9])<<8;
117fab: 0f b6 73 09 movzbl 0x9(%ebx),%esi
117faf: c1 e6 08 shl $0x8,%esi
117fb2: 01 f2 add %esi,%edx
case 9 : c+=k[8];
117fb4: 0f b6 73 08 movzbl 0x8(%ebx),%esi
117fb8: 01 f2 add %esi,%edx
case 8 : b+=((uint32_t)k[7])<<24;
117fba: 0f b6 73 07 movzbl 0x7(%ebx),%esi
117fbe: c1 e6 18 shl $0x18,%esi
117fc1: 01 f1 add %esi,%ecx
case 7 : b+=((uint32_t)k[6])<<16;
117fc3: 0f b6 73 06 movzbl 0x6(%ebx),%esi
117fc7: c1 e6 10 shl $0x10,%esi
117fca: 01 f1 add %esi,%ecx
case 6 : b+=((uint32_t)k[5])<<8;
117fcc: 0f b6 73 05 movzbl 0x5(%ebx),%esi
117fd0: c1 e6 08 shl $0x8,%esi
117fd3: 01 f1 add %esi,%ecx
case 5 : b+=k[4];
117fd5: 0f b6 73 04 movzbl 0x4(%ebx),%esi
117fd9: 01 f1 add %esi,%ecx
case 4 : a+=((uint32_t)k[3])<<24;
117fdb: 0f b6 73 03 movzbl 0x3(%ebx),%esi
117fdf: c1 e6 18 shl $0x18,%esi
117fe2: 01 f0 add %esi,%eax
case 3 : a+=((uint32_t)k[2])<<16;
117fe4: 0f b6 73 02 movzbl 0x2(%ebx),%esi
117fe8: c1 e6 10 shl $0x10,%esi
117feb: 01 f0 add %esi,%eax
case 2 : a+=((uint32_t)k[1])<<8;
117fed: 0f b6 73 01 movzbl 0x1(%ebx),%esi
117ff1: c1 e6 08 shl $0x8,%esi
117ff4: 01 f0 add %esi,%eax
case 1 : a+=k[0];
117ff6: 0f b6 1b movzbl (%ebx),%ebx
117ff9: 01 d8 add %ebx,%eax
break;
case 0 : return c;
}
}
final(a,b,c);
117ffb: 89 cb mov %ecx,%ebx
117ffd: 31 ca xor %ecx,%edx
117fff: c1 c3 0e rol $0xe,%ebx
118002: 29 da sub %ebx,%edx
118004: 89 d3 mov %edx,%ebx
118006: 31 d0 xor %edx,%eax
118008: c1 c3 0b rol $0xb,%ebx
11800b: 29 d8 sub %ebx,%eax
11800d: 89 c3 mov %eax,%ebx
11800f: 31 c1 xor %eax,%ecx
118011: c1 cb 07 ror $0x7,%ebx
118014: 29 d9 sub %ebx,%ecx
118016: 89 cb mov %ecx,%ebx
118018: 31 ca xor %ecx,%edx
11801a: c1 c3 10 rol $0x10,%ebx
11801d: 29 da sub %ebx,%edx
11801f: 89 d3 mov %edx,%ebx
118021: 31 d0 xor %edx,%eax
118023: c1 c3 04 rol $0x4,%ebx
118026: 29 d8 sub %ebx,%eax
118028: 31 c1 xor %eax,%ecx
11802a: c1 c0 0e rol $0xe,%eax
11802d: 29 c1 sub %eax,%ecx
11802f: 31 ca xor %ecx,%edx
118031: c1 c9 08 ror $0x8,%ecx
118034: 29 ca sub %ecx,%edx
return c;
}
118036: 5b pop %ebx
118037: 89 d0 mov %edx,%eax
118039: 5e pop %esi
11803a: 5f pop %edi
11803b: 5d pop %ebp
11803c: c3 ret
11803d: 8d 76 00 lea 0x0(%esi),%esi
} else if (HASH_LITTLE_ENDIAN && ((u.i & 0x1) == 0)) {
118040: f6 c3 01 test $0x1,%bl
118043: 0f 85 49 01 00 00 jne 118192 <rtems_rfs_dir_hash+0x292>
while (length > 12)
118049: 83 7d 0c 0c cmpl $0xc,0xc(%ebp)
11804d: 76 7c jbe 1180cb <rtems_rfs_dir_hash+0x1cb>
11804f: 90 nop
b += k[2] + (((uint32_t)k[3])<<16);
118050: 0f b7 73 06 movzwl 0x6(%ebx),%esi
118054: 0f b7 7b 04 movzwl 0x4(%ebx),%edi
118058: c1 e6 10 shl $0x10,%esi
11805b: 01 fe add %edi,%esi
c += k[4] + (((uint32_t)k[5])<<16);
11805d: 0f b7 7b 08 movzwl 0x8(%ebx),%edi
b += k[2] + (((uint32_t)k[3])<<16);
118061: 01 f1 add %esi,%ecx
c += k[4] + (((uint32_t)k[5])<<16);
118063: 0f b7 73 0a movzwl 0xa(%ebx),%esi
118067: c1 e6 10 shl $0x10,%esi
11806a: 01 fe add %edi,%esi
a += k[0] + (((uint32_t)k[1])<<16);
11806c: 0f b7 3b movzwl (%ebx),%edi
c += k[4] + (((uint32_t)k[5])<<16);
11806f: 01 f2 add %esi,%edx
a += k[0] + (((uint32_t)k[1])<<16);
118071: 0f b7 73 02 movzwl 0x2(%ebx),%esi
118075: c1 e6 10 shl $0x10,%esi
mix(a,b,c);
118078: 01 fe add %edi,%esi
11807a: 29 d6 sub %edx,%esi
11807c: 01 f0 add %esi,%eax
11807e: 89 d6 mov %edx,%esi
118080: c1 c6 04 rol $0x4,%esi
118083: 01 ca add %ecx,%edx
118085: 31 f0 xor %esi,%eax
118087: 89 c6 mov %eax,%esi
118089: 29 c1 sub %eax,%ecx
11808b: c1 c6 06 rol $0x6,%esi
11808e: 01 d0 add %edx,%eax
118090: 31 f1 xor %esi,%ecx
118092: 89 ce mov %ecx,%esi
118094: 29 ca sub %ecx,%edx
118096: c1 c6 08 rol $0x8,%esi
118099: 01 c1 add %eax,%ecx
11809b: 31 f2 xor %esi,%edx
11809d: 89 d6 mov %edx,%esi
11809f: 29 d0 sub %edx,%eax
1180a1: c1 c6 10 rol $0x10,%esi
1180a4: 01 ca add %ecx,%edx
1180a6: 31 f0 xor %esi,%eax
1180a8: 89 c6 mov %eax,%esi
1180aa: 29 c1 sub %eax,%ecx
1180ac: c1 ce 0d ror $0xd,%esi
1180af: 01 d0 add %edx,%eax
1180b1: 31 f1 xor %esi,%ecx
1180b3: 89 ce mov %ecx,%esi
1180b5: 29 ca sub %ecx,%edx
1180b7: c1 c6 04 rol $0x4,%esi
1180ba: 31 f2 xor %esi,%edx
1180bc: 01 c1 add %eax,%ecx
length -= 12;
1180be: 83 6d 0c 0c subl $0xc,0xc(%ebp)
k += 6;
1180c2: 83 c3 0c add $0xc,%ebx
while (length > 12)
1180c5: 83 7d 0c 0c cmpl $0xc,0xc(%ebp)
1180c9: 77 85 ja 118050 <rtems_rfs_dir_hash+0x150> <== NEVER TAKEN
1180cb: 8b 7d 0c mov 0xc(%ebp),%edi
1180ce: ff 24 bd 98 5a 13 00 jmp *0x135a98(,%edi,4)
1180d5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1180dc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
b += ((uint32_t)k[5])<<8;
1180e0: 0f b6 73 05 movzbl 0x5(%ebx),%esi
1180e4: 89 f7 mov %esi,%edi
b += ((uint32_t)k[6])<<16;
1180e6: 0f b6 73 06 movzbl 0x6(%ebx),%esi
b += ((uint32_t)k[5])<<8;
1180ea: c1 e7 08 shl $0x8,%edi
b += ((uint32_t)k[6])<<16;
1180ed: c1 e6 10 shl $0x10,%esi
b += ((uint32_t)k[7])<<24;
1180f0: 01 fe add %edi,%esi
b += k[4];
1180f2: 0f b6 7b 04 movzbl 0x4(%ebx),%edi
b += ((uint32_t)k[7])<<24;
1180f6: 01 fe add %edi,%esi
1180f8: 0f b6 7b 07 movzbl 0x7(%ebx),%edi
1180fc: c1 e7 18 shl $0x18,%edi
1180ff: 01 fe add %edi,%esi
118101: 01 f1 add %esi,%ecx
c += ((uint32_t)k[9])<<8;
118103: 0f b6 73 09 movzbl 0x9(%ebx),%esi
118107: 89 f7 mov %esi,%edi
c += ((uint32_t)k[10])<<16;
118109: 0f b6 73 0a movzbl 0xa(%ebx),%esi
c += ((uint32_t)k[9])<<8;
11810d: c1 e7 08 shl $0x8,%edi
c += ((uint32_t)k[10])<<16;
118110: c1 e6 10 shl $0x10,%esi
c += ((uint32_t)k[11])<<24;
118113: 01 fe add %edi,%esi
c += k[8];
118115: 0f b6 7b 08 movzbl 0x8(%ebx),%edi
c += ((uint32_t)k[11])<<24;
118119: 01 fe add %edi,%esi
11811b: 0f b6 7b 0b movzbl 0xb(%ebx),%edi
11811f: c1 e7 18 shl $0x18,%edi
118122: 01 fe add %edi,%esi
118124: 01 f2 add %esi,%edx
a += ((uint32_t)k[1])<<8;
118126: 0f b6 73 01 movzbl 0x1(%ebx),%esi
11812a: 89 f7 mov %esi,%edi
a += ((uint32_t)k[2])<<16;
11812c: 0f b6 73 02 movzbl 0x2(%ebx),%esi
a += ((uint32_t)k[1])<<8;
118130: c1 e7 08 shl $0x8,%edi
a += ((uint32_t)k[2])<<16;
118133: c1 e6 10 shl $0x10,%esi
mix(a,b,c);
118136: 01 fe add %edi,%esi
a += k[0];
118138: 0f b6 3b movzbl (%ebx),%edi
mix(a,b,c);
11813b: 01 fe add %edi,%esi
a += ((uint32_t)k[3])<<24;
11813d: 0f b6 7b 03 movzbl 0x3(%ebx),%edi
118141: c1 e7 18 shl $0x18,%edi
mix(a,b,c);
118144: 01 fe add %edi,%esi
118146: 29 d6 sub %edx,%esi
118148: 01 f0 add %esi,%eax
11814a: 89 d6 mov %edx,%esi
11814c: c1 c6 04 rol $0x4,%esi
11814f: 01 ca add %ecx,%edx
118151: 31 c6 xor %eax,%esi
118153: 89 f0 mov %esi,%eax
118155: 29 f1 sub %esi,%ecx
118157: c1 c0 06 rol $0x6,%eax
11815a: 01 d6 add %edx,%esi
11815c: 31 c1 xor %eax,%ecx
11815e: 89 c8 mov %ecx,%eax
118160: 29 ca sub %ecx,%edx
118162: c1 c0 08 rol $0x8,%eax
118165: 31 c2 xor %eax,%edx
118167: 01 f1 add %esi,%ecx
118169: 89 d0 mov %edx,%eax
11816b: 29 d6 sub %edx,%esi
11816d: c1 c0 10 rol $0x10,%eax
118170: 01 ca add %ecx,%edx
118172: 31 c6 xor %eax,%esi
k += 12;
118174: 83 c3 0c add $0xc,%ebx
mix(a,b,c);
118177: 89 f0 mov %esi,%eax
118179: 29 f1 sub %esi,%ecx
11817b: c1 c8 0d ror $0xd,%eax
length -= 12;
11817e: 83 6d 0c 0c subl $0xc,0xc(%ebp)
mix(a,b,c);
118182: 31 c1 xor %eax,%ecx
118184: 8d 04 16 lea (%esi,%edx,1),%eax
118187: 89 ce mov %ecx,%esi
118189: c1 c6 04 rol $0x4,%esi
11818c: 29 ca sub %ecx,%edx
11818e: 31 f2 xor %esi,%edx
118190: 01 c1 add %eax,%ecx
while (length > 12)
118192: 83 7d 0c 0c cmpl $0xc,0xc(%ebp)
118196: 0f 87 44 ff ff ff ja 1180e0 <rtems_rfs_dir_hash+0x1e0>
11819c: 8b 7d 0c mov 0xc(%ebp),%edi
11819f: ff 24 bd cc 5a 13 00 jmp *0x135acc(,%edi,4)
case 3 : a+=((uint32_t)k8[2])<<16; /* fall through */
1181a6: 0f b6 73 02 movzbl 0x2(%ebx),%esi
1181aa: c1 e6 10 shl $0x10,%esi
1181ad: 01 f0 add %esi,%eax
case 2 : a+=k[0];
1181af: 0f b7 1b movzwl (%ebx),%ebx
1181b2: 01 d8 add %ebx,%eax
break;
1181b4: e9 42 fe ff ff jmp 117ffb <rtems_rfs_dir_hash+0xfb>
case 11: c+=((uint32_t)k8[10])<<16; /* fall through */
1181b9: 0f b6 73 0a movzbl 0xa(%ebx),%esi <== NOT EXECUTED
1181bd: c1 e6 10 shl $0x10,%esi <== NOT EXECUTED
1181c0: 01 f2 add %esi,%edx <== NOT EXECUTED
case 10: c+=k[4];
1181c2: 0f b7 73 08 movzwl 0x8(%ebx),%esi
case 9 : c+=k8[8]; /* fall through */
1181c6: 01 f2 add %esi,%edx
case 8 : b+=k[2]+(((uint32_t)k[3])<<16);
1181c8: 0f b7 73 04 movzwl 0x4(%ebx),%esi
1181cc: 01 ce add %ecx,%esi
1181ce: 0f b7 4b 06 movzwl 0x6(%ebx),%ecx
1181d2: c1 e1 10 shl $0x10,%ecx
case 5 : b+=k8[4]; /* fall through */
1181d5: 01 f1 add %esi,%ecx
case 4 : a+=k[0]+(((uint32_t)k[1])<<16);
1181d7: 0f b7 33 movzwl (%ebx),%esi
1181da: 01 c6 add %eax,%esi
1181dc: 0f b7 43 02 movzwl 0x2(%ebx),%eax
1181e0: c1 e0 10 shl $0x10,%eax
1181e3: 01 f0 add %esi,%eax
break;
1181e5: e9 11 fe ff ff jmp 117ffb <rtems_rfs_dir_hash+0xfb>
case 5 : b+=k[1]&0xff; a+=k[0]; break;
1181ea: 0f b6 73 04 movzbl 0x4(%ebx),%esi
1181ee: 8b 3b mov (%ebx),%edi
1181f0: 01 f1 add %esi,%ecx
1181f2: 01 f8 add %edi,%eax
1181f4: e9 02 fe ff ff jmp 117ffb <rtems_rfs_dir_hash+0xfb>
case 4 : a+=k[0]; break;
1181f9: 8b 33 mov (%ebx),%esi
1181fb: 01 f0 add %esi,%eax
1181fd: e9 f9 fd ff ff jmp 117ffb <rtems_rfs_dir_hash+0xfb>
case 3 : a+=k[0]&0xffffff; break;
118202: 8b 1b mov (%ebx),%ebx
118204: 81 e3 ff ff ff 00 and $0xffffff,%ebx
11820a: 01 d8 add %ebx,%eax
11820c: e9 ea fd ff ff jmp 117ffb <rtems_rfs_dir_hash+0xfb>
case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
118211: 8b 73 08 mov 0x8(%ebx),%esi
118214: 8b 7b 04 mov 0x4(%ebx),%edi
118217: 01 f2 add %esi,%edx
118219: 8b 33 mov (%ebx),%esi
11821b: 01 f9 add %edi,%ecx
11821d: 01 f0 add %esi,%eax
11821f: e9 d7 fd ff ff jmp 117ffb <rtems_rfs_dir_hash+0xfb>
case 11: c+=k[2]&0xffffff; b+=k[1]; a+=k[0]; break;
118224: 8b 73 08 mov 0x8(%ebx),%esi
118227: 8b 3b mov (%ebx),%edi
118229: 81 e6 ff ff ff 00 and $0xffffff,%esi
11822f: 01 f2 add %esi,%edx
118231: 8b 73 04 mov 0x4(%ebx),%esi
118234: 01 f8 add %edi,%eax
118236: 01 f1 add %esi,%ecx
118238: e9 be fd ff ff jmp 117ffb <rtems_rfs_dir_hash+0xfb>
case 10: c+=k[2]&0xffff; b+=k[1]; a+=k[0]; break;
11823d: 0f b7 73 08 movzwl 0x8(%ebx),%esi
118241: 8b 3b mov (%ebx),%edi
118243: 01 f2 add %esi,%edx
118245: 8b 73 04 mov 0x4(%ebx),%esi
118248: 01 f8 add %edi,%eax
11824a: 01 f1 add %esi,%ecx
11824c: e9 aa fd ff ff jmp 117ffb <rtems_rfs_dir_hash+0xfb>
case 9 : c+=k[2]&0xff; b+=k[1]; a+=k[0]; break;
118251: 0f b6 73 08 movzbl 0x8(%ebx),%esi
118255: 8b 3b mov (%ebx),%edi
118257: 01 f2 add %esi,%edx
118259: 8b 73 04 mov 0x4(%ebx),%esi
11825c: 01 f8 add %edi,%eax
11825e: 01 f1 add %esi,%ecx
118260: e9 96 fd ff ff jmp 117ffb <rtems_rfs_dir_hash+0xfb>
case 8 : b+=k[1]; a+=k[0]; break;
118265: 8b 73 04 mov 0x4(%ebx),%esi
118268: 8b 3b mov (%ebx),%edi
11826a: 01 f1 add %esi,%ecx
11826c: 01 f8 add %edi,%eax
11826e: e9 88 fd ff ff jmp 117ffb <rtems_rfs_dir_hash+0xfb>
case 7 : b+=k[1]&0xffffff; a+=k[0]; break;
118273: 8b 73 04 mov 0x4(%ebx),%esi
118276: 8b 3b mov (%ebx),%edi
118278: 81 e6 ff ff ff 00 and $0xffffff,%esi
11827e: 01 f1 add %esi,%ecx
118280: 01 f8 add %edi,%eax
118282: e9 74 fd ff ff jmp 117ffb <rtems_rfs_dir_hash+0xfb>
case 6 : b+=k[1]&0xffff; a+=k[0]; break;
118287: 0f b7 73 04 movzwl 0x4(%ebx),%esi
11828b: 01 f1 add %esi,%ecx
11828d: 8b 33 mov (%ebx),%esi
11828f: 01 f0 add %esi,%eax
118291: e9 65 fd ff ff jmp 117ffb <rtems_rfs_dir_hash+0xfb>
case 7 : b+=((uint32_t)k8[6])<<16; /* fall through */
118296: 0f b6 73 06 movzbl 0x6(%ebx),%esi <== NOT EXECUTED
11829a: c1 e6 10 shl $0x10,%esi <== NOT EXECUTED
11829d: 01 f1 add %esi,%ecx <== NOT EXECUTED
case 6 : b+=k[2];
11829f: 0f b7 73 04 movzwl 0x4(%ebx),%esi
case 5 : b+=k8[4]; /* fall through */
1182a3: 01 f1 add %esi,%ecx
1182a5: e9 2d ff ff ff jmp 1181d7 <rtems_rfs_dir_hash+0x2d7>
case 9 : c+=k8[8]; /* fall through */
1182aa: 0f b6 73 08 movzbl 0x8(%ebx),%esi
1182ae: 01 f2 add %esi,%edx
1182b0: e9 13 ff ff ff jmp 1181c8 <rtems_rfs_dir_hash+0x2c8>
case 12: c+=k[4]+(((uint32_t)k[5])<<16);
1182b5: 0f b7 73 08 movzwl 0x8(%ebx),%esi <== NOT EXECUTED
1182b9: 01 d6 add %edx,%esi <== NOT EXECUTED
1182bb: 0f b7 53 0a movzwl 0xa(%ebx),%edx <== NOT EXECUTED
1182bf: c1 e2 10 shl $0x10,%edx <== NOT EXECUTED
1182c2: 01 f2 add %esi,%edx <== NOT EXECUTED
b+=k[2]+(((uint32_t)k[3])<<16);
1182c4: 0f b7 73 04 movzwl 0x4(%ebx),%esi <== NOT EXECUTED
1182c8: 01 f1 add %esi,%ecx <== NOT EXECUTED
1182ca: 0f b7 73 06 movzwl 0x6(%ebx),%esi <== NOT EXECUTED
1182ce: c1 e6 10 shl $0x10,%esi <== NOT EXECUTED
case 5 : b+=k8[4]; /* fall through */
1182d1: 01 f1 add %esi,%ecx <== NOT EXECUTED
1182d3: e9 ff fe ff ff jmp 1181d7 <rtems_rfs_dir_hash+0x2d7> <== NOT EXECUTED
1182d8: 0f b6 73 04 movzbl 0x4(%ebx),%esi
1182dc: 01 f1 add %esi,%ecx
1182de: e9 f4 fe ff ff jmp 1181d7 <rtems_rfs_dir_hash+0x2d7>
1182e3: 90 nop
1182e4: 90 nop
1182e5: 90 nop
1182e6: 90 nop
1182e7: 90 nop
1182e8: 90 nop
1182e9: 90 nop
1182ea: 90 nop
1182eb: 90 nop
1182ec: 90 nop
1182ed: 90 nop
1182ee: 90 nop
1182ef: 90 nop
001165b0 <rtems_rfs_dir_lookup_ino>:
rtems_rfs_inode_handle* inode,
const char* name,
int length,
rtems_rfs_ino* ino,
uint32_t* offset)
{
1165b0: 55 push %ebp
rtems_rfs_block_map map;
rtems_rfs_buffer_handle entries;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
1165b1: 31 c0 xor %eax,%eax
{
1165b3: 89 e5 mov %esp,%ebp
1165b5: 57 push %edi
1165b6: 56 push %esi
1165b7: 53 push %ebx
1165b8: 81 ec 9c 00 00 00 sub $0x9c,%esp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
1165be: c7 04 24 00 00 00 04 movl $0x4000000,(%esp)
{
1165c5: 8b 7d 08 mov 0x8(%ebp),%edi
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
1165c8: 89 44 24 04 mov %eax,0x4(%esp)
{
1165cc: 8b 75 18 mov 0x18(%ebp),%esi
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
1165cf: e8 7c 52 ff ff call 10b850 <rtems_rfs_trace>
1165d4: 84 c0 test %al,%al
1165d6: 0f 85 f5 03 00 00 jne 1169d1 <rtems_rfs_dir_lookup_ino+0x421> <== NEVER TAKEN
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf (", len=%d\n", length);
}
*ino = RTEMS_RFS_EMPTY_INO;
1165dc: c7 06 00 00 00 00 movl $0x0,(%esi)
*offset = 0;
1165e2: 8b 45 1c mov 0x1c(%ebp),%eax
1165e5: c7 00 00 00 00 00 movl $0x0,(%eax)
rc = rtems_rfs_block_map_open (fs, inode, &map);
1165eb: 8d 45 98 lea -0x68(%ebp),%eax
1165ee: 89 44 24 08 mov %eax,0x8(%esp)
1165f2: 8b 45 0c mov 0xc(%ebp),%eax
1165f5: 89 3c 24 mov %edi,(%esp)
1165f8: 89 44 24 04 mov %eax,0x4(%esp)
1165fc: e8 1f f3 ff ff call 115920 <rtems_rfs_block_map_open>
116601: 89 45 80 mov %eax,-0x80(%ebp)
if (rc > 0)
116604: 85 c0 test %eax,%eax
116606: 0f 8f 74 03 00 00 jg 116980 <rtems_rfs_dir_lookup_ino+0x3d0> <== NEVER TAKEN
handle->dirty = false;
11660c: c6 45 8c 00 movb $0x0,-0x74(%ebp)
uint32_t hash;
/*
* Calculate the hash of the look up string.
*/
hash = rtems_rfs_dir_hash (name, length);
116610: 8b 45 14 mov 0x14(%ebp),%eax
handle->bnum = 0;
116613: c7 45 90 00 00 00 00 movl $0x0,-0x70(%ebp)
handle->buffer = NULL;
11661a: c7 45 94 00 00 00 00 movl $0x0,-0x6c(%ebp)
116621: 89 44 24 04 mov %eax,0x4(%esp)
116625: 8b 45 10 mov 0x10(%ebp),%eax
116628: 89 04 24 mov %eax,(%esp)
11662b: e8 d0 18 00 00 call 117f00 <rtems_rfs_dir_hash>
/*
* Locate the first block. The map points to the start after open so just
* seek 0. If an error the block will be 0.
*/
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
116630: 89 3c 24 mov %edi,(%esp)
hash = rtems_rfs_dir_hash (name, length);
116633: 89 45 84 mov %eax,-0x7c(%ebp)
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
116636: 8d 45 88 lea -0x78(%ebp),%eax
116639: 89 44 24 10 mov %eax,0x10(%esp)
11663d: 31 c0 xor %eax,%eax
11663f: 89 44 24 08 mov %eax,0x8(%esp)
116643: 31 c0 xor %eax,%eax
116645: 89 44 24 0c mov %eax,0xc(%esp)
116649: 8d 45 98 lea -0x68(%ebp),%eax
11664c: 89 44 24 04 mov %eax,0x4(%esp)
116650: e8 eb f6 ff ff call 115d40 <rtems_rfs_block_map_seek>
116655: 89 45 80 mov %eax,-0x80(%ebp)
if (rc > 0)
116658: 85 c0 test %eax,%eax
11665a: 0f 8f cb 03 00 00 jg 116a2b <rtems_rfs_dir_lookup_ino+0x47b> <== NEVER TAKEN
116660: 89 75 18 mov %esi,0x18(%ebp)
116663: 89 fe mov %edi,%esi
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
while ((rc == 0) && block)
116665: 8b 5d 80 mov -0x80(%ebp),%ebx
116668: 85 db test %ebx,%ebx
11666a: 0f 85 87 02 00 00 jne 1168f7 <rtems_rfs_dir_lookup_ino+0x347> <== NEVER TAKEN
116670: 8b 4d 88 mov -0x78(%ebp),%ecx
116673: 85 c9 test %ecx,%ecx
116675: 0f 84 45 04 00 00 je 116ac0 <rtems_rfs_dir_lookup_ino+0x510> <== NEVER TAKEN
{
uint8_t* entry;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
11667b: c7 04 24 00 00 00 04 movl $0x4000000,(%esp)
116682: 31 c9 xor %ecx,%ecx
116684: 89 4c 24 04 mov %ecx,0x4(%esp)
116688: e8 c3 51 ff ff call 10b850 <rtems_rfs_trace>
11668d: 84 c0 test %al,%al
11668f: 0f 85 2b 02 00 00 jne 1168c0 <rtems_rfs_dir_lookup_ino+0x310> <== NEVER TAKEN
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n",
rtems_rfs_inode_ino (inode), map.bpos.bno);
rc = rtems_rfs_buffer_handle_request (fs, &entries, block, true);
116695: 89 34 24 mov %esi,(%esp)
116698: 8b 45 88 mov -0x78(%ebp),%eax
11669b: ba 01 00 00 00 mov $0x1,%edx
1166a0: 89 54 24 0c mov %edx,0xc(%esp)
1166a4: 89 44 24 08 mov %eax,0x8(%esp)
1166a8: 8d 45 8c lea -0x74(%ebp),%eax
1166ab: 89 44 24 04 mov %eax,0x4(%esp)
1166af: e8 1c 0f ff ff call 1075d0 <rtems_rfs_buffer_handle_request>
1166b4: 89 45 80 mov %eax,-0x80(%ebp)
if (rc > 0)
1166b7: 85 c0 test %eax,%eax
1166b9: 0f 8f 51 04 00 00 jg 116b10 <rtems_rfs_dir_lookup_ino+0x560> <== NEVER TAKEN
* means the entry is empty.
*/
entry = rtems_rfs_buffer_data (&entries);
map.bpos.boff = 0;
1166bf: c7 45 ac 00 00 00 00 movl $0x0,-0x54(%ebp)
entry = rtems_rfs_buffer_data (&entries);
1166c6: 8b 45 94 mov -0x6c(%ebp),%eax
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
1166c9: 83 7e 08 0a cmpl $0xa,0x8(%esi)
entry = rtems_rfs_buffer_data (&entries);
1166cd: 8b 78 1c mov 0x1c(%eax),%edi
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
1166d0: 0f 84 1a 02 00 00 je 1168f0 <rtems_rfs_dir_lookup_ino+0x340> <== NEVER TAKEN
1166d6: 8b 55 18 mov 0x18(%ebp),%edx
1166d9: eb 1d jmp 1166f8 <rtems_rfs_dir_lookup_ino+0x148>
1166db: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
1166df: 90 nop
rtems_rfs_block_map_close (fs, &map);
return 0;
}
}
map.bpos.boff += elength;
1166e0: 8b 45 ac mov -0x54(%ebp),%eax
entry += elength;
1166e3: 01 df add %ebx,%edi
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
1166e5: 8b 4e 08 mov 0x8(%esi),%ecx
map.bpos.boff += elength;
1166e8: 01 d8 add %ebx,%eax
1166ea: 89 45 ac mov %eax,-0x54(%ebp)
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
1166ed: 83 e9 0a sub $0xa,%ecx
1166f0: 39 c8 cmp %ecx,%eax
1166f2: 0f 83 f8 01 00 00 jae 1168f0 <rtems_rfs_dir_lookup_ino+0x340> <== NEVER TAKEN
ehash = rtems_rfs_dir_entry_hash (entry);
1166f8: 0f b7 47 08 movzwl 0x8(%edi),%eax
1166fc: 8b 4f 04 mov 0x4(%edi),%ecx
1166ff: 89 c3 mov %eax,%ebx
116701: 0f b6 c4 movzbl %ah,%eax
116704: c1 e3 08 shl $0x8,%ebx
116707: 0f c9 bswap %ecx
elength = rtems_rfs_dir_entry_length (entry);
116709: 09 d8 or %ebx,%eax
11670b: 0f b7 d8 movzwl %ax,%ebx
*ino = rtems_rfs_dir_entry_ino (entry);
11670e: 8b 07 mov (%edi),%eax
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
116710: 81 fb ff ff 00 00 cmp $0xffff,%ebx
116716: 0f c8 bswap %eax
*ino = rtems_rfs_dir_entry_ino (entry);
116718: 89 02 mov %eax,(%edx)
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
11671a: 0f 84 d0 01 00 00 je 1168f0 <rtems_rfs_dir_lookup_ino+0x340>
if (rtems_rfs_dir_entry_valid (fs, elength, *ino))
116720: 83 fb 0a cmp $0xa,%ebx
116723: 0f 8e e7 00 00 00 jle 116810 <rtems_rfs_dir_lookup_ino+0x260> <== NEVER TAKEN
116729: 39 5e 1c cmp %ebx,0x1c(%esi)
11672c: 0f 86 de 00 00 00 jbe 116810 <rtems_rfs_dir_lookup_ino+0x260> <== NEVER TAKEN
116732: 85 c0 test %eax,%eax
116734: 0f 84 d6 00 00 00 je 116810 <rtems_rfs_dir_lookup_ino+0x260> <== NEVER TAKEN
11673a: 3b 46 14 cmp 0x14(%esi),%eax
11673d: 8d 76 00 lea 0x0(%esi),%esi
116740: 0f 87 ca 00 00 00 ja 116810 <rtems_rfs_dir_lookup_ino+0x260> <== NEVER TAKEN
if (ehash == hash)
116746: 39 4d 84 cmp %ecx,-0x7c(%ebp)
116749: 75 95 jne 1166e0 <rtems_rfs_dir_lookup_ino+0x130>
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
11674b: c7 04 24 00 00 00 08 movl $0x8000000,(%esp)
116752: 31 c0 xor %eax,%eax
116754: 89 44 24 04 mov %eax,0x4(%esp)
116758: 89 55 18 mov %edx,0x18(%ebp)
11675b: e8 f0 50 ff ff call 10b850 <rtems_rfs_trace>
116760: 8b 55 18 mov 0x18(%ebp),%edx
116763: 84 c0 test %al,%al
116765: 0f 85 15 01 00 00 jne 116880 <rtems_rfs_dir_lookup_ino+0x2d0> <== NEVER TAKEN
11676b: 89 55 18 mov %edx,0x18(%ebp)
if (memcmp (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length) == 0)
11676e: 8b 45 14 mov 0x14(%ebp),%eax
116771: 89 44 24 08 mov %eax,0x8(%esp)
116775: 8b 45 10 mov 0x10(%ebp),%eax
116778: 89 44 24 04 mov %eax,0x4(%esp)
11677c: 8d 47 0a lea 0xa(%edi),%eax
11677f: 89 04 24 mov %eax,(%esp)
116782: e8 95 41 01 00 call 12a91c <memcmp>
116787: 8b 55 18 mov 0x18(%ebp),%edx
11678a: 85 c0 test %eax,%eax
11678c: 0f 85 4e ff ff ff jne 1166e0 <rtems_rfs_dir_lookup_ino+0x130> <== NEVER TAKEN
*offset = rtems_rfs_block_map_pos (fs, &map);
116792: 8d 45 a8 lea -0x58(%ebp),%eax
116795: 89 f7 mov %esi,%edi
116797: 89 44 24 04 mov %eax,0x4(%esp)
11679b: 89 d6 mov %edx,%esi
11679d: 89 3c 24 mov %edi,(%esp)
1167a0: e8 0b f1 ff ff call 1158b0 <rtems_rfs_block_get_pos>
1167a5: 8b 55 1c mov 0x1c(%ebp),%edx
1167a8: 89 02 mov %eax,(%edx)
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND))
1167aa: 31 c0 xor %eax,%eax
1167ac: c7 04 24 00 00 00 10 movl $0x10000000,(%esp)
1167b3: 89 44 24 04 mov %eax,0x4(%esp)
1167b7: e8 94 50 ff ff call 10b850 <rtems_rfs_trace>
1167bc: 84 c0 test %al,%al
1167be: 0f 85 c1 03 00 00 jne 116b85 <rtems_rfs_dir_lookup_ino+0x5d5> <== NEVER TAKEN
rtems_rfs_buffer_handle_release (fs, handle);
1167c4: 89 3c 24 mov %edi,(%esp)
1167c7: 8d 45 8c lea -0x74(%ebp),%eax
1167ca: 89 44 24 04 mov %eax,0x4(%esp)
1167ce: e8 dd 10 ff ff call 1078b0 <rtems_rfs_buffer_handle_release>
rtems_rfs_block_map_close (fs, &map);
1167d3: 8d 45 98 lea -0x68(%ebp),%eax
1167d6: 89 3c 24 mov %edi,(%esp)
1167d9: 89 44 24 04 mov %eax,0x4(%esp)
handle->dirty = false;
1167dd: c6 45 8c 00 movb $0x0,-0x74(%ebp)
handle->bnum = 0;
1167e1: c7 45 90 00 00 00 00 movl $0x0,-0x70(%ebp)
handle->buffer = NULL;
1167e8: c7 45 94 00 00 00 00 movl $0x0,-0x6c(%ebp)
1167ef: e8 5c f2 ff ff call 115a50 <rtems_rfs_block_map_close>
return 0;
1167f4: c7 45 80 00 00 00 00 movl $0x0,-0x80(%ebp) <== NOT EXECUTED
}
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
1167fb: 8b 45 80 mov -0x80(%ebp),%eax <== NOT EXECUTED
1167fe: 81 c4 9c 00 00 00 add $0x9c,%esp <== NOT EXECUTED
116804: 5b pop %ebx <== NOT EXECUTED
116805: 5e pop %esi <== NOT EXECUTED
116806: 5f pop %edi <== NOT EXECUTED
116807: 5d pop %ebp <== NOT EXECUTED
116808: c3 ret <== NOT EXECUTED
116809: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
116810: c7 04 24 00 00 00 04 movl $0x4000000,(%esp) <== NOT EXECUTED
116817: 31 c0 xor %eax,%eax <== NOT EXECUTED
116819: 89 f7 mov %esi,%edi <== NOT EXECUTED
11681b: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
11681f: 89 d6 mov %edx,%esi <== NOT EXECUTED
116821: e8 2a 50 ff ff call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
116826: 84 c0 test %al,%al <== NOT EXECUTED
116828: 0f 85 12 01 00 00 jne 116940 <rtems_rfs_dir_lookup_ino+0x390> <== NOT EXECUTED
rc = EIO;
11682e: c7 45 80 05 00 00 00 movl $0x5,-0x80(%ebp) <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
116835: 89 3c 24 mov %edi,(%esp)
116838: 8d 45 8c lea -0x74(%ebp),%eax
11683b: 89 44 24 04 mov %eax,0x4(%esp)
11683f: e8 6c 10 ff ff call 1078b0 <rtems_rfs_buffer_handle_release>
rtems_rfs_block_map_close (fs, &map);
116844: 8d 45 98 lea -0x68(%ebp),%eax <== NOT EXECUTED
116847: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
11684b: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
handle->dirty = false;
11684e: c6 45 8c 00 movb $0x0,-0x74(%ebp) <== NOT EXECUTED
handle->bnum = 0;
116852: c7 45 90 00 00 00 00 movl $0x0,-0x70(%ebp) <== NOT EXECUTED
handle->buffer = NULL;
116859: c7 45 94 00 00 00 00 movl $0x0,-0x6c(%ebp) <== NOT EXECUTED
116860: e8 eb f1 ff ff call 115a50 <rtems_rfs_block_map_close> <== NOT EXECUTED
}
116865: 8b 45 80 mov -0x80(%ebp),%eax
116868: 81 c4 9c 00 00 00 add $0x9c,%esp
11686e: 5b pop %ebx
11686f: 5e pop %esi
116870: 5f pop %edi
116871: 5d pop %ebp
116872: c3 ret
116873: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11687a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
printf ("rtems-rfs: dir-lookup-ino: "
116880: 8b 07 mov (%edi),%eax <== NOT EXECUTED
116882: 89 5c 24 10 mov %ebx,0x10(%esp) <== NOT EXECUTED
116886: 0f c8 bswap %eax <== NOT EXECUTED
116888: 89 44 24 14 mov %eax,0x14(%esp) <== NOT EXECUTED
11688c: 8b 45 ac mov -0x54(%ebp),%eax <== NOT EXECUTED
11688f: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
116893: 8b 45 a8 mov -0x58(%ebp),%eax <== NOT EXECUTED
116896: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
11689a: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
11689d: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED
1168a0: c7 04 24 34 55 13 00 movl $0x135534,(%esp) <== NOT EXECUTED
1168a7: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1168ab: e8 90 b8 fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
1168b0: 8b 55 18 mov 0x18(%ebp),%edx <== NOT EXECUTED
1168b3: e9 b3 fe ff ff jmp 11676b <rtems_rfs_dir_lookup_ino+0x1bb> <== NOT EXECUTED
1168b8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1168bf: 90 nop <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n",
1168c0: 8b 45 a8 mov -0x58(%ebp),%eax <== NOT EXECUTED
1168c3: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
1168c7: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
1168ca: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED
1168cd: c7 04 24 74 54 13 00 movl $0x135474,(%esp) <== NOT EXECUTED
1168d4: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1168d8: e8 63 b8 fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
1168dd: e9 b3 fd ff ff jmp 116695 <rtems_rfs_dir_lookup_ino+0xe5> <== NOT EXECUTED
1168e2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1168e9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
if (rc == 0)
1168f0: 8b 45 80 mov -0x80(%ebp),%eax
1168f3: 85 c0 test %eax,%eax
1168f5: 74 09 je 116900 <rtems_rfs_dir_lookup_ino+0x350> <== ALWAYS TAKEN
1168f7: 89 f7 mov %esi,%edi <== NOT EXECUTED
1168f9: e9 37 ff ff ff jmp 116835 <rtems_rfs_dir_lookup_ino+0x285> <== NOT EXECUTED
1168fe: 66 90 xchg %ax,%ax <== NOT EXECUTED
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
116900: 89 34 24 mov %esi,(%esp)
116903: 8d 45 88 lea -0x78(%ebp),%eax
116906: 89 44 24 08 mov %eax,0x8(%esp)
11690a: 8d 45 98 lea -0x68(%ebp),%eax
11690d: 89 44 24 04 mov %eax,0x4(%esp)
116911: e8 aa f4 ff ff call 115dc0 <rtems_rfs_block_map_next_block>
116916: 89 45 80 mov %eax,-0x80(%ebp)
if ((rc > 0) && (rc != ENXIO))
116919: 85 c0 test %eax,%eax
11691b: 0f 8e 82 01 00 00 jle 116aa3 <rtems_rfs_dir_lookup_ino+0x4f3> <== NEVER TAKEN
116921: 83 f8 06 cmp $0x6,%eax
116924: 0f 85 31 01 00 00 jne 116a5b <rtems_rfs_dir_lookup_ino+0x4ab> <== NEVER TAKEN
rc = ENOENT;
11692a: 89 f7 mov %esi,%edi
11692c: e9 1e 01 00 00 jmp 116a4f <rtems_rfs_dir_lookup_ino+0x49f>
116931: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
116938: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11693f: 90 nop
printf ("rtems-rfs: dir-lookup-ino: "
116940: 8b 45 ac mov -0x54(%ebp),%eax <== NOT EXECUTED
116943: 89 44 24 10 mov %eax,0x10(%esp) <== NOT EXECUTED
116947: 8b 06 mov (%esi),%eax <== NOT EXECUTED
116949: 89 5c 24 08 mov %ebx,0x8(%esp) <== NOT EXECUTED
11694d: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
116951: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
116954: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED
116957: c7 04 24 ec 54 13 00 movl $0x1354ec,(%esp) <== NOT EXECUTED
11695e: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
116962: e8 d9 b7 fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
rc = EIO;
116967: c7 45 80 05 00 00 00 movl $0x5,-0x80(%ebp) <== NOT EXECUTED
11696e: e9 c2 fe ff ff jmp 116835 <rtems_rfs_dir_lookup_ino+0x285> <== NOT EXECUTED
116973: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11697a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
116980: c7 04 24 00 00 00 04 movl $0x4000000,(%esp) <== NOT EXECUTED
116987: 31 c0 xor %eax,%eax <== NOT EXECUTED
116989: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
11698d: e8 be 4e ff ff call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
116992: 84 c0 test %al,%al <== NOT EXECUTED
116994: 0f 84 cb fe ff ff je 116865 <rtems_rfs_dir_lookup_ino+0x2b5> <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: map open failed for ino %" PRIu32 ": %d: %s",
11699a: 8b 75 80 mov -0x80(%ebp),%esi <== NOT EXECUTED
11699d: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
1169a0: e8 7b 4a 01 00 call 12b420 <strerror> <== NOT EXECUTED
1169a5: 89 74 24 08 mov %esi,0x8(%esp) <== NOT EXECUTED
1169a9: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
1169ad: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
1169b0: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED
1169b3: c7 04 24 f8 53 13 00 movl $0x1353f8,(%esp) <== NOT EXECUTED
1169ba: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1169be: e8 7d b7 fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
}
1169c3: 8b 45 80 mov -0x80(%ebp),%eax <== NOT EXECUTED
1169c6: 81 c4 9c 00 00 00 add $0x9c,%esp <== NOT EXECUTED
1169cc: 5b pop %ebx <== NOT EXECUTED
1169cd: 5e pop %esi <== NOT EXECUTED
1169ce: 5f pop %edi <== NOT EXECUTED
1169cf: 5d pop %ebp <== NOT EXECUTED
1169d0: c3 ret <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: lookup ino: root=%" PRId32 ", path=",
1169d1: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
1169d4: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED
1169d7: c7 04 24 c0 53 13 00 movl $0x1353c0,(%esp) <== NOT EXECUTED
1169de: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1169e2: e8 59 b7 fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
for (c = 0; c < length; c++)
1169e7: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED
1169ea: 85 c0 test %eax,%eax <== NOT EXECUTED
1169ec: 7e 25 jle 116a13 <rtems_rfs_dir_lookup_ino+0x463> <== NOT EXECUTED
1169ee: 89 75 18 mov %esi,0x18(%ebp) <== NOT EXECUTED
1169f1: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED
1169f4: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED
1169f7: 89 de mov %ebx,%esi <== NOT EXECUTED
1169f9: 01 d8 add %ebx,%eax <== NOT EXECUTED
1169fb: 89 c3 mov %eax,%ebx <== NOT EXECUTED
1169fd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
printf ("%c", name[c]);
116a00: 0f be 06 movsbl (%esi),%eax <== NOT EXECUTED
for (c = 0; c < length; c++)
116a03: 46 inc %esi <== NOT EXECUTED
printf ("%c", name[c]);
116a04: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
116a07: e8 84 40 01 00 call 12aa90 <putchar> <== NOT EXECUTED
for (c = 0; c < length; c++)
116a0c: 39 f3 cmp %esi,%ebx <== NOT EXECUTED
116a0e: 75 f0 jne 116a00 <rtems_rfs_dir_lookup_ino+0x450> <== NOT EXECUTED
116a10: 8b 75 18 mov 0x18(%ebp),%esi <== NOT EXECUTED
printf (", len=%d\n", length);
116a13: c7 04 24 59 56 13 00 movl $0x135659,(%esp) <== NOT EXECUTED
116a1a: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED
116a1d: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
116a21: e8 1a b7 fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
116a26: e9 b1 fb ff ff jmp 1165dc <rtems_rfs_dir_lookup_ino+0x2c> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
116a2b: c7 04 24 00 00 00 04 movl $0x4000000,(%esp) <== NOT EXECUTED
116a32: 31 db xor %ebx,%ebx <== NOT EXECUTED
116a34: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
116a38: e8 13 4e ff ff call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
116a3d: 84 c0 test %al,%al <== NOT EXECUTED
116a3f: 0f 85 1c 01 00 00 jne 116b61 <rtems_rfs_dir_lookup_ino+0x5b1> <== NOT EXECUTED
if (rc == ENXIO)
116a45: 83 7d 80 06 cmpl $0x6,-0x80(%ebp) <== NOT EXECUTED
116a49: 0f 85 e6 fd ff ff jne 116835 <rtems_rfs_dir_lookup_ino+0x285> <== NOT EXECUTED
rc = ENOENT;
116a4f: c7 45 80 02 00 00 00 movl $0x2,-0x80(%ebp)
116a56: e9 da fd ff ff jmp 116835 <rtems_rfs_dir_lookup_ino+0x285>
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
116a5b: c7 04 24 00 00 00 04 movl $0x4000000,(%esp) <== NOT EXECUTED
116a62: 31 ff xor %edi,%edi <== NOT EXECUTED
116a64: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED
116a68: e8 e3 4d ff ff call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
116a6d: 84 c0 test %al,%al <== NOT EXECUTED
116a6f: 0f 84 f0 fb ff ff je 116665 <rtems_rfs_dir_lookup_ino+0xb5> <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
116a75: 8b 7d 80 mov -0x80(%ebp),%edi <== NOT EXECUTED
116a78: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
116a7b: e8 a0 49 01 00 call 12b420 <strerror> <== NOT EXECUTED
116a80: 89 7c 24 08 mov %edi,0x8(%esp) <== NOT EXECUTED
116a84: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
116a88: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
116a8b: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED
116a8e: c7 04 24 d4 55 13 00 movl $0x1355d4,(%esp) <== NOT EXECUTED
116a95: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
116a99: e8 a2 b6 fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
116a9e: e9 c2 fb ff ff jmp 116665 <rtems_rfs_dir_lookup_ino+0xb5> <== NOT EXECUTED
if (rc == ENXIO)
116aa3: 83 7d 80 06 cmpl $0x6,-0x80(%ebp) <== NOT EXECUTED
116aa7: 0f 85 b8 fb ff ff jne 116665 <rtems_rfs_dir_lookup_ino+0xb5> <== NOT EXECUTED
rc = ENOENT;
116aad: 89 f7 mov %esi,%edi <== NOT EXECUTED
116aaf: 90 nop <== NOT EXECUTED
116ab0: eb 9d jmp 116a4f <rtems_rfs_dir_lookup_ino+0x49f> <== NOT EXECUTED
116ab2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
116ab9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
116ac0: c7 04 24 00 00 00 04 movl $0x4000000,(%esp) <== NOT EXECUTED
116ac7: 31 c0 xor %eax,%eax <== NOT EXECUTED
116ac9: 89 f7 mov %esi,%edi <== NOT EXECUTED
116acb: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
116acf: e8 7c 4d ff ff call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
116ad4: 84 c0 test %al,%al <== NOT EXECUTED
116ad6: 0f 84 52 fd ff ff je 11682e <rtems_rfs_dir_lookup_ino+0x27e> <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block is 0 in ino %" PRIu32 ": %d: %s\n",
116adc: c7 04 24 05 00 00 00 movl $0x5,(%esp) <== NOT EXECUTED
116ae3: e8 38 49 01 00 call 12b420 <strerror> <== NOT EXECUTED
116ae8: ba 05 00 00 00 mov $0x5,%edx <== NOT EXECUTED
116aed: 89 54 24 08 mov %edx,0x8(%esp) <== NOT EXECUTED
116af1: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
116af5: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
116af8: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED
116afb: c7 04 24 20 56 13 00 movl $0x135620,(%esp) <== NOT EXECUTED
116b02: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
116b06: e8 35 b6 fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
116b0b: e9 1e fd ff ff jmp 11682e <rtems_rfs_dir_lookup_ino+0x27e> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
116b10: c7 04 24 00 00 00 04 movl $0x4000000,(%esp) <== NOT EXECUTED
116b17: 31 c0 xor %eax,%eax <== NOT EXECUTED
116b19: 89 f7 mov %esi,%edi <== NOT EXECUTED
116b1b: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
116b1f: e8 2c 4d ff ff call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
116b24: 84 c0 test %al,%al <== NOT EXECUTED
116b26: 0f 84 09 fd ff ff je 116835 <rtems_rfs_dir_lookup_ino+0x285> <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " block=%" PRId32 ": %d: %s\n",
116b2c: 8b 75 80 mov -0x80(%ebp),%esi <== NOT EXECUTED
116b2f: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
116b32: e8 e9 48 01 00 call 12b420 <strerror> <== NOT EXECUTED
116b37: 89 74 24 0c mov %esi,0xc(%esp) <== NOT EXECUTED
116b3b: 89 44 24 10 mov %eax,0x10(%esp) <== NOT EXECUTED
116b3f: 8b 45 88 mov -0x78(%ebp),%eax <== NOT EXECUTED
116b42: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
116b46: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
116b49: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED
116b4c: c7 04 24 ac 54 13 00 movl $0x1354ac,(%esp) <== NOT EXECUTED
116b53: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
116b57: e8 e4 b5 fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
116b5c: e9 d4 fc ff ff jmp 116835 <rtems_rfs_dir_lookup_ino+0x285> <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block map find failed: %d: %s\n",
116b61: 8b 75 80 mov -0x80(%ebp),%esi <== NOT EXECUTED
116b64: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
116b67: e8 b4 48 01 00 call 12b420 <strerror> <== NOT EXECUTED
116b6c: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED
116b70: c7 04 24 38 54 13 00 movl $0x135438,(%esp) <== NOT EXECUTED
116b77: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
116b7b: e8 c0 b5 fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
116b80: e9 c0 fe ff ff jmp 116a45 <rtems_rfs_dir_lookup_ino+0x495> <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
116b85: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED
116b88: 8b 00 mov (%eax),%eax <== NOT EXECUTED
116b8a: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
116b8e: 8b 06 mov (%esi),%eax <== NOT EXECUTED
116b90: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
116b94: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
116b97: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED
116b9a: c7 04 24 90 55 13 00 movl $0x135590,(%esp) <== NOT EXECUTED
116ba1: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
116ba5: e8 96 b5 fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
116baa: e9 15 fc ff ff jmp 1167c4 <rtems_rfs_dir_lookup_ino+0x214> <== NOT EXECUTED
116baf: 90 nop
001176d0 <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)
{
1176d0: 55 push %ebp
1176d1: 89 e5 mov %esp,%ebp
1176d3: 57 push %edi
1176d4: 56 push %esi
1176d5: 53 push %ebx
1176d6: 81 ec bc 00 00 00 sub $0xbc,%esp
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))
1176dc: c7 04 24 00 00 00 80 movl $0x80000000,(%esp)
{
1176e3: 8b 45 10 mov 0x10(%ebp),%eax
1176e6: 8b 55 14 mov 0x14(%ebp),%edx
1176e9: 8b 75 08 mov 0x8(%ebp),%esi
1176ec: 8b 7d 1c mov 0x1c(%ebp),%edi
1176ef: 89 85 78 ff ff ff mov %eax,-0x88(%ebp)
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
1176f5: 31 c0 xor %eax,%eax
1176f7: 89 44 24 04 mov %eax,0x4(%esp)
{
1176fb: 89 95 7c ff ff ff mov %edx,-0x84(%ebp)
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
117701: e8 4a 41 ff ff call 10b850 <rtems_rfs_trace>
117706: 84 c0 test %al,%al
117708: 0f 85 42 02 00 00 jne 117950 <rtems_rfs_dir_read+0x280> <== NEVER TAKEN
printf ("rtems-rfs: dir-read: dir=%" PRId32 " offset=%" PRId64 "\n",
rtems_rfs_inode_ino (dir), offset);
*length = 0;
11770e: c7 07 00 00 00 00 movl $0x0,(%edi)
rc = rtems_rfs_block_map_open (fs, dir, &map);
117714: 8d 45 98 lea -0x68(%ebp),%eax
117717: 89 44 24 08 mov %eax,0x8(%esp)
11771b: 8b 45 0c mov 0xc(%ebp),%eax
11771e: 89 34 24 mov %esi,(%esp)
117721: 89 44 24 04 mov %eax,0x4(%esp)
117725: e8 f6 e1 ff ff call 115920 <rtems_rfs_block_map_open>
if (rc > 0)
11772a: 85 c0 test %eax,%eax
rc = rtems_rfs_block_map_open (fs, dir, &map);
11772c: 89 c3 mov %eax,%ebx
if (rc > 0)
11772e: 0f 8f fe 01 00 00 jg 117932 <rtems_rfs_dir_read+0x262> <== NEVER TAKEN
return rc;
if (((rtems_rfs_fs_block_size (fs) -
117734: 8b 46 08 mov 0x8(%esi),%eax
117737: 31 d2 xor %edx,%edx
117739: 89 d1 mov %edx,%ecx
11773b: 89 4c 24 0c mov %ecx,0xc(%esp)
11773f: 89 8d 74 ff ff ff mov %ecx,-0x8c(%ebp)
117745: 89 c2 mov %eax,%edx
117747: 89 95 70 ff ff ff mov %edx,-0x90(%ebp)
11774d: 8d 45 80 lea -0x80(%ebp),%eax
117750: 89 44 24 10 mov %eax,0x10(%esp)
117754: 8b 85 78 ff ff ff mov -0x88(%ebp),%eax
11775a: 89 54 24 08 mov %edx,0x8(%esp)
11775e: 8b 95 7c ff ff ff mov -0x84(%ebp),%edx
117764: 89 04 24 mov %eax,(%esp)
117767: 89 54 24 04 mov %edx,0x4(%esp)
11776b: e8 f0 18 01 00 call 129060 <__divmoddi4>
117770: 8b 8d 70 ff ff ff mov -0x90(%ebp),%ecx
117776: 2b 4d 80 sub -0x80(%ebp),%ecx
117779: 8b 9d 74 ff ff ff mov -0x8c(%ebp),%ebx
11777f: 1b 5d 84 sbb -0x7c(%ebp),%ebx
117782: 89 85 68 ff ff ff mov %eax,-0x98(%ebp)
117788: b8 00 00 00 00 mov $0x0,%eax
11778d: 89 95 6c ff ff ff mov %edx,-0x94(%ebp)
117793: 89 ca mov %ecx,%edx
117795: 89 d9 mov %ebx,%ecx
117797: bb 0a 00 00 00 mov $0xa,%ebx
11779c: 39 d3 cmp %edx,%ebx
11779e: 89 c3 mov %eax,%ebx
1177a0: 19 cb sbb %ecx,%ebx
1177a2: 7c 33 jl 1177d7 <rtems_rfs_dir_read+0x107> <== ALWAYS TAKEN
(offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
offset = (((offset / rtems_rfs_fs_block_size (fs)) + 1) *
1177a4: 8b 85 68 ff ff ff mov -0x98(%ebp),%eax <== NOT EXECUTED
1177aa: 8b 95 6c ff ff ff mov -0x94(%ebp),%edx <== NOT EXECUTED
1177b0: 8b 9d 70 ff ff ff mov -0x90(%ebp),%ebx <== NOT EXECUTED
1177b6: 83 c0 01 add $0x1,%eax <== NOT EXECUTED
1177b9: 83 d2 00 adc $0x0,%edx <== NOT EXECUTED
1177bc: 0f af da imul %edx,%ebx <== NOT EXECUTED
1177bf: f7 a5 70 ff ff ff mull -0x90(%ebp) <== NOT EXECUTED
1177c5: 89 95 7c ff ff ff mov %edx,-0x84(%ebp) <== NOT EXECUTED
1177cb: 01 9d 7c ff ff ff add %ebx,-0x84(%ebp) <== NOT EXECUTED
1177d1: 89 85 78 ff ff ff mov %eax,-0x88(%ebp) <== NOT EXECUTED
rtems_rfs_fs_block_size (fs));
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
1177d7: 89 34 24 mov %esi,(%esp)
1177da: 8d 45 88 lea -0x78(%ebp),%eax
1177dd: 8b 95 7c ff ff ff mov -0x84(%ebp),%edx
1177e3: 89 44 24 10 mov %eax,0x10(%esp)
1177e7: 8b 85 78 ff ff ff mov -0x88(%ebp),%eax
1177ed: 89 54 24 0c mov %edx,0xc(%esp)
1177f1: 89 44 24 08 mov %eax,0x8(%esp)
1177f5: 8d 45 98 lea -0x68(%ebp),%eax
1177f8: 89 44 24 04 mov %eax,0x4(%esp)
1177fc: e8 3f e5 ff ff call 115d40 <rtems_rfs_block_map_seek>
if (rc > 0)
117801: 85 c0 test %eax,%eax
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
117803: 89 c3 mov %eax,%ebx
if (rc > 0)
117805: 0f 8f 35 01 00 00 jg 117940 <rtems_rfs_dir_read+0x270> <== NEVER TAKEN
handle->dirty = false;
11780b: c6 45 8c 00 movb $0x0,-0x74(%ebp)
handle->bnum = 0;
11780f: c7 45 90 00 00 00 00 movl $0x0,-0x70(%ebp)
handle->buffer = NULL;
117816: c7 45 94 00 00 00 00 movl $0x0,-0x6c(%ebp)
/*
* Look for an empty entry and if this is the last block that is the end of
* the directory.
*/
while (rc == 0)
11781d: 89 7d 1c mov %edi,0x1c(%ebp)
117820: eb 35 jmp 117857 <rtems_rfs_dir_read+0x187>
117822: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
117829: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
offset, *length);
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
117830: 89 34 24 mov %esi,(%esp)
117833: 8d 45 88 lea -0x78(%ebp),%eax
117836: 89 44 24 08 mov %eax,0x8(%esp)
11783a: 8d 45 98 lea -0x68(%ebp),%eax
11783d: 89 44 24 04 mov %eax,0x4(%esp)
117841: e8 7a e5 ff ff call 115dc0 <rtems_rfs_block_map_next_block>
if (rc == ENXIO)
117846: 83 f8 06 cmp $0x6,%eax
117849: 0f 84 71 03 00 00 je 117bc0 <rtems_rfs_dir_read+0x4f0> <== ALWAYS TAKEN
while (rc == 0)
11784f: 85 c0 test %eax,%eax <== NOT EXECUTED
117851: 0f 85 a9 00 00 00 jne 117900 <rtems_rfs_dir_read+0x230> <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
117857: 89 34 24 mov %esi,(%esp)
11785a: 8b 45 88 mov -0x78(%ebp),%eax
11785d: bb 01 00 00 00 mov $0x1,%ebx
117862: 89 5c 24 0c mov %ebx,0xc(%esp)
117866: 89 44 24 08 mov %eax,0x8(%esp)
11786a: 8d 45 8c lea -0x74(%ebp),%eax
11786d: 89 44 24 04 mov %eax,0x4(%esp)
117871: e8 5a fd fe ff call 1075d0 <rtems_rfs_buffer_handle_request>
if (rc > 0)
117876: 85 c0 test %eax,%eax
117878: 0f 8f 82 00 00 00 jg 117900 <rtems_rfs_dir_read+0x230> <== NEVER TAKEN
entry += map.bpos.boff;
11787e: 8b 55 94 mov -0x6c(%ebp),%edx
117881: 8b 5d ac mov -0x54(%ebp),%ebx
117884: 8b 4a 1c mov 0x1c(%edx),%ecx
117887: 01 d9 add %ebx,%ecx
117889: 89 ca mov %ecx,%edx
elength = rtems_rfs_dir_entry_length (entry);
11788b: 0f b7 49 08 movzwl 0x8(%ecx),%ecx
11788f: 89 cf mov %ecx,%edi
117891: 0f b6 cd movzbl %ch,%ecx
117894: c1 e7 08 shl $0x8,%edi
117897: 09 f9 or %edi,%ecx
117899: 0f b7 c9 movzwl %cx,%ecx
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
11789c: 81 f9 ff ff 00 00 cmp $0xffff,%ecx
1178a2: 0f 85 d8 00 00 00 jne 117980 <rtems_rfs_dir_read+0x2b0>
*length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;
1178a8: 8b 46 08 mov 0x8(%esi),%eax
1178ab: 8b 7d 1c mov 0x1c(%ebp),%edi
1178ae: 29 d8 sub %ebx,%eax
1178b0: 01 07 add %eax,(%edi)
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
1178b2: 31 c0 xor %eax,%eax
1178b4: c7 04 24 00 00 00 80 movl $0x80000000,(%esp)
1178bb: 89 44 24 04 mov %eax,0x4(%esp)
1178bf: e8 8c 3f ff ff call 10b850 <rtems_rfs_trace>
1178c4: 84 c0 test %al,%al
1178c6: 0f 84 64 ff ff ff je 117830 <rtems_rfs_dir_read+0x160> <== ALWAYS TAKEN
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
1178cc: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED
1178cf: 8b 95 7c ff ff ff mov -0x84(%ebp),%edx <== NOT EXECUTED
1178d5: 8b 00 mov (%eax),%eax <== NOT EXECUTED
1178d7: 89 54 24 08 mov %edx,0x8(%esp) <== NOT EXECUTED
1178db: c7 04 24 cc 59 13 00 movl $0x1359cc,(%esp) <== NOT EXECUTED
1178e2: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
1178e6: 8b 85 78 ff ff ff mov -0x88(%ebp),%eax <== NOT EXECUTED
1178ec: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1178f0: e8 4b a8 fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
1178f5: e9 36 ff ff ff jmp 117830 <rtems_rfs_dir_read+0x160> <== NOT EXECUTED
1178fa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
117900: 89 c3 mov %eax,%ebx <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
117902: 89 34 24 mov %esi,(%esp)
117905: 8d 45 8c lea -0x74(%ebp),%eax
117908: 89 44 24 04 mov %eax,0x4(%esp)
11790c: e8 9f ff fe ff call 1078b0 <rtems_rfs_buffer_handle_release>
handle->dirty = false;
117911: c6 45 8c 00 movb $0x0,-0x74(%ebp)
handle->bnum = 0;
117915: c7 45 90 00 00 00 00 movl $0x0,-0x70(%ebp)
handle->buffer = NULL;
11791c: c7 45 94 00 00 00 00 movl $0x0,-0x6c(%ebp)
rc = ENOENT;
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
117923: 89 34 24 mov %esi,(%esp)
117926: 8d 45 98 lea -0x68(%ebp),%eax
117929: 89 44 24 04 mov %eax,0x4(%esp)
11792d: e8 1e e1 ff ff call 115a50 <rtems_rfs_block_map_close>
return rc;
}
117932: 81 c4 bc 00 00 00 add $0xbc,%esp
117938: 89 d8 mov %ebx,%eax
11793a: 5b pop %ebx
11793b: 5e pop %esi
11793c: 5f pop %edi
11793d: 5d pop %ebp
11793e: c3 ret
11793f: 90 nop
if (rc == ENXIO)
117940: 83 f8 06 cmp $0x6,%eax <== NOT EXECUTED
117943: 75 de jne 117923 <rtems_rfs_dir_read+0x253> <== NOT EXECUTED
rc = ENOENT;
117945: bb 02 00 00 00 mov $0x2,%ebx <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
11794a: eb d7 jmp 117923 <rtems_rfs_dir_read+0x253> <== NOT EXECUTED
11794c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
printf ("rtems-rfs: dir-read: dir=%" PRId32 " offset=%" PRId64 "\n",
117950: 8b 85 78 ff ff ff mov -0x88(%ebp),%eax <== NOT EXECUTED
117956: 8b 95 7c ff ff ff mov -0x84(%ebp),%edx <== NOT EXECUTED
11795c: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
117960: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
117963: 89 54 24 0c mov %edx,0xc(%esp) <== NOT EXECUTED
117967: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED
11796a: c7 04 24 24 59 13 00 movl $0x135924,(%esp) <== NOT EXECUTED
117971: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
117975: e8 c6 a7 fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
11797a: e9 8f fd ff ff jmp 11770e <rtems_rfs_dir_read+0x3e> <== NOT EXECUTED
11797f: 90 nop <== NOT EXECUTED
117980: 89 c3 mov %eax,%ebx
117982: 8b 02 mov (%edx),%eax
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
117984: 83 f9 0a cmp $0xa,%ecx
117987: 89 95 68 ff ff ff mov %edx,-0x98(%ebp)
11798d: 8b 7d 1c mov 0x1c(%ebp),%edi
117990: 89 8d 78 ff ff ff mov %ecx,-0x88(%ebp)
117996: 0f c8 bswap %eax
117998: 89 85 70 ff ff ff mov %eax,-0x90(%ebp)
11799e: 0f 8e bc 01 00 00 jle 117b60 <rtems_rfs_dir_read+0x490> <== NEVER TAKEN
1179a4: 39 4e 1c cmp %ecx,0x1c(%esi)
1179a7: 0f 86 b3 01 00 00 jbe 117b60 <rtems_rfs_dir_read+0x490> <== NEVER TAKEN
1179ad: 85 c0 test %eax,%eax
1179af: 0f 84 ab 01 00 00 je 117b60 <rtems_rfs_dir_read+0x490> <== NEVER TAKEN
1179b5: 39 46 14 cmp %eax,0x14(%esi)
1179b8: 0f 82 a2 01 00 00 jb 117b60 <rtems_rfs_dir_read+0x490> <== NEVER TAKEN
memset (dirent, 0, sizeof (struct dirent));
1179be: 8b 45 18 mov 0x18(%ebp),%eax
1179c1: ba 18 01 00 00 mov $0x118,%edx
1179c6: 31 c9 xor %ecx,%ecx
1179c8: 89 95 70 ff ff ff mov %edx,-0x90(%ebp)
1179ce: a8 01 test $0x1,%al
1179d0: 0f 85 8b 02 00 00 jne 117c61 <rtems_rfs_dir_read+0x591> <== NEVER TAKEN
1179d6: a8 02 test $0x2,%al
1179d8: 0f 85 6f 02 00 00 jne 117c4d <rtems_rfs_dir_read+0x57d> <== NEVER TAKEN
1179de: 8b 95 70 ff ff ff mov -0x90(%ebp),%edx
1179e4: 83 e2 f8 and $0xfffffff8,%edx
1179e7: 89 95 64 ff ff ff mov %edx,-0x9c(%ebp)
1179ed: 31 d2 xor %edx,%edx
1179ef: 89 0c 10 mov %ecx,(%eax,%edx,1)
1179f2: 89 4c 10 04 mov %ecx,0x4(%eax,%edx,1)
1179f6: 83 c2 08 add $0x8,%edx
1179f9: 3b 95 64 ff ff ff cmp -0x9c(%ebp),%edx
1179ff: 72 ee jb 1179ef <rtems_rfs_dir_read+0x31f>
117a01: 01 d0 add %edx,%eax
117a03: f6 85 70 ff ff ff 04 testb $0x4,-0x90(%ebp)
117a0a: 74 09 je 117a15 <rtems_rfs_dir_read+0x345> <== ALWAYS TAKEN
117a0c: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED
117a12: 83 c0 04 add $0x4,%eax <== NOT EXECUTED
117a15: f6 85 70 ff ff ff 02 testb $0x2,-0x90(%ebp)
117a1c: 74 08 je 117a26 <rtems_rfs_dir_read+0x356> <== ALWAYS TAKEN
117a1e: 66 c7 00 00 00 movw $0x0,(%eax) <== NOT EXECUTED
117a23: 83 c0 02 add $0x2,%eax <== NOT EXECUTED
117a26: f6 85 70 ff ff ff 01 testb $0x1,-0x90(%ebp)
117a2d: 74 03 je 117a32 <rtems_rfs_dir_read+0x362> <== ALWAYS TAKEN
117a2f: c6 00 00 movb $0x0,(%eax) <== NOT EXECUTED
dirent->d_off = rtems_rfs_block_get_pos (fs, &map.bpos);
117a32: 89 34 24 mov %esi,(%esp)
117a35: 8d 45 a8 lea -0x58(%ebp),%eax
117a38: 89 44 24 04 mov %eax,0x4(%esp)
117a3c: e8 6f de ff ff call 1158b0 <rtems_rfs_block_get_pos>
117a41: 8b 4d 18 mov 0x18(%ebp),%ecx
dirent->d_reclen = sizeof (struct dirent);
117a44: 66 c7 41 10 18 01 movw $0x118,0x10(%ecx)
dirent->d_off = rtems_rfs_block_get_pos (fs, &map.bpos);
117a4a: 89 41 08 mov %eax,0x8(%ecx)
*length += elength;
117a4d: 8b 07 mov (%edi),%eax
dirent->d_off = rtems_rfs_block_get_pos (fs, &map.bpos);
117a4f: 89 51 0c mov %edx,0xc(%ecx)
*length += elength;
117a52: 8b 8d 78 ff ff ff mov -0x88(%ebp),%ecx
117a58: 89 85 70 ff ff ff mov %eax,-0x90(%ebp)
117a5e: 8d 14 01 lea (%ecx,%eax,1),%edx
117a61: 89 17 mov %edx,(%edi)
remaining = rtems_rfs_fs_block_size (fs) - (map.bpos.boff + elength);
117a63: 8b 56 08 mov 0x8(%esi),%edx
117a66: 2b 55 ac sub -0x54(%ebp),%edx
117a69: 89 d0 mov %edx,%eax
117a6b: 29 c8 sub %ecx,%eax
if (remaining <= RTEMS_RFS_DIR_ENTRY_SIZE)
117a6d: 83 f8 0a cmp $0xa,%eax
117a70: 7f 0a jg 117a7c <rtems_rfs_dir_read+0x3ac> <== ALWAYS TAKEN
*length += remaining;
117a72: 8b 85 70 ff ff ff mov -0x90(%ebp),%eax <== NOT EXECUTED
117a78: 01 d0 add %edx,%eax <== NOT EXECUTED
117a7a: 89 07 mov %eax,(%edi) <== NOT EXECUTED
if (elength > NAME_MAX)
117a7c: 8b 85 78 ff ff ff mov -0x88(%ebp),%eax
117a82: 83 e8 0a sub $0xa,%eax
117a85: 89 85 78 ff ff ff mov %eax,-0x88(%ebp)
117a8b: 3d ff 00 00 00 cmp $0xff,%eax
117a90: 7e 0b jle 117a9d <rtems_rfs_dir_read+0x3cd> <== ALWAYS TAKEN
117a92: b9 ff 00 00 00 mov $0xff,%ecx <== NOT EXECUTED
117a97: 89 8d 78 ff ff ff mov %ecx,-0x88(%ebp) <== NOT EXECUTED
memcpy (dirent->d_name, entry + RTEMS_RFS_DIR_ENTRY_SIZE, elength);
117a9d: 8b 45 18 mov 0x18(%ebp),%eax
117aa0: 8b bd 78 ff ff ff mov -0x88(%ebp),%edi
117aa6: 8d 50 16 lea 0x16(%eax),%edx
117aa9: 8b 85 68 ff ff ff mov -0x98(%ebp),%eax
117aaf: 89 95 70 ff ff ff mov %edx,-0x90(%ebp)
117ab5: 89 d1 mov %edx,%ecx
117ab7: 83 c0 0a add $0xa,%eax
117aba: 83 ff 04 cmp $0x4,%edi
117abd: 0f 83 07 01 00 00 jae 117bca <rtems_rfs_dir_read+0x4fa>
117ac3: 31 d2 xor %edx,%edx
117ac5: f7 c7 02 00 00 00 test $0x2,%edi
117acb: 74 0b je 117ad8 <rtems_rfs_dir_read+0x408>
117acd: 0f b7 10 movzwl (%eax),%edx
117ad0: 66 89 11 mov %dx,(%ecx)
117ad3: ba 02 00 00 00 mov $0x2,%edx
117ad8: 83 e7 01 and $0x1,%edi
117adb: 74 07 je 117ae4 <rtems_rfs_dir_read+0x414>
117add: 0f b6 04 10 movzbl (%eax,%edx,1),%eax
117ae1: 88 04 11 mov %al,(%ecx,%edx,1)
dirent->d_ino = rtems_rfs_dir_entry_ino (entry);
117ae4: 8b 85 68 ff ff ff mov -0x98(%ebp),%eax
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
117aea: 31 d2 xor %edx,%edx
dirent->d_ino = rtems_rfs_dir_entry_ino (entry);
117aec: 8b 7d 18 mov 0x18(%ebp),%edi
117aef: 8b 00 mov (%eax),%eax
117af1: c7 47 04 00 00 00 00 movl $0x0,0x4(%edi)
dirent->d_namlen = elength;
117af8: 0f c8 bswap %eax
dirent->d_ino = rtems_rfs_dir_entry_ino (entry);
117afa: 89 07 mov %eax,(%edi)
dirent->d_namlen = elength;
117afc: 89 f8 mov %edi,%eax
117afe: 8b bd 78 ff ff ff mov -0x88(%ebp),%edi
117b04: 66 89 78 14 mov %di,0x14(%eax)
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
117b08: c7 04 24 00 00 00 80 movl $0x80000000,(%esp)
117b0f: 89 54 24 04 mov %edx,0x4(%esp)
117b13: e8 38 3d ff ff call 10b850 <rtems_rfs_trace>
117b18: 84 c0 test %al,%al
117b1a: 0f 84 e2 fd ff ff je 117902 <rtems_rfs_dir_read+0x232> <== ALWAYS TAKEN
printf ("rtems-rfs: dir-read: found off:%" PRIooff_t
117b20: 8b 85 70 ff ff ff mov -0x90(%ebp),%eax <== NOT EXECUTED
117b26: 89 44 24 14 mov %eax,0x14(%esp) <== NOT EXECUTED
117b2a: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED
117b2d: 8b 50 04 mov 0x4(%eax),%edx <== NOT EXECUTED
117b30: 8b 00 mov (%eax),%eax <== NOT EXECUTED
117b32: 89 54 24 10 mov %edx,0x10(%esp) <== NOT EXECUTED
117b36: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
117b3a: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED
117b3d: 8b 50 0c mov 0xc(%eax),%edx <== NOT EXECUTED
117b40: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED
117b43: c7 04 24 94 59 13 00 movl $0x135994,(%esp) <== NOT EXECUTED
117b4a: 89 54 24 08 mov %edx,0x8(%esp) <== NOT EXECUTED
117b4e: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
117b52: e8 e9 a5 fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
117b57: e9 a6 fd ff ff jmp 117902 <rtems_rfs_dir_read+0x232> <== NOT EXECUTED
117b5c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
117b60: c7 04 24 00 00 00 80 movl $0x80000000,(%esp) <== NOT EXECUTED
117b67: 31 c9 xor %ecx,%ecx <== NOT EXECUTED
rc = EIO;
117b69: bb 05 00 00 00 mov $0x5,%ebx <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
117b6e: 89 4c 24 04 mov %ecx,0x4(%esp) <== NOT EXECUTED
117b72: e8 d9 3c ff ff call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
117b77: 84 c0 test %al,%al <== NOT EXECUTED
117b79: 0f 84 83 fd ff ff je 117902 <rtems_rfs_dir_read+0x232> <== NOT EXECUTED
printf ("rtems-rfs: dir-read: "
117b7f: 8b 45 ac mov -0x54(%ebp),%eax <== NOT EXECUTED
117b82: 89 44 24 10 mov %eax,0x10(%esp) <== NOT EXECUTED
117b86: 8b 85 70 ff ff ff mov -0x90(%ebp),%eax <== NOT EXECUTED
117b8c: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
117b90: 8b 85 78 ff ff ff mov -0x88(%ebp),%eax <== NOT EXECUTED
117b96: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
117b9a: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
117b9d: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED
117ba0: c7 04 24 50 59 13 00 movl $0x135950,(%esp) <== NOT EXECUTED
117ba7: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
117bab: e8 90 a5 fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
117bb0: e9 4d fd ff ff jmp 117902 <rtems_rfs_dir_read+0x232> <== NOT EXECUTED
117bb5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
117bbc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
rc = ENOENT;
117bc0: bb 02 00 00 00 mov $0x2,%ebx
117bc5: e9 38 fd ff ff jmp 117902 <rtems_rfs_dir_read+0x232>
memcpy (dirent->d_name, entry + RTEMS_RFS_DIR_ENTRY_SIZE, elength);
117bca: f6 c2 01 test $0x1,%dl
117bcd: 8d 76 00 lea 0x0(%esi),%esi
117bd0: 75 53 jne 117c25 <rtems_rfs_dir_read+0x555> <== NEVER TAKEN
117bd2: f6 c1 02 test $0x2,%cl
117bd5: 75 3c jne 117c13 <rtems_rfs_dir_read+0x543> <== ALWAYS TAKEN
117bd7: 83 ff 04 cmp $0x4,%edi
117bda: 0f 82 e3 fe ff ff jb 117ac3 <rtems_rfs_dir_read+0x3f3>
117be0: 89 9d 60 ff ff ff mov %ebx,-0xa0(%ebp)
117be6: 89 fa mov %edi,%edx
117be8: 83 e2 fc and $0xfffffffc,%edx
117beb: 89 95 64 ff ff ff mov %edx,-0x9c(%ebp)
117bf1: 31 d2 xor %edx,%edx
117bf3: 8b 1c 10 mov (%eax,%edx,1),%ebx
117bf6: 89 1c 11 mov %ebx,(%ecx,%edx,1)
117bf9: 83 c2 04 add $0x4,%edx
117bfc: 3b 95 64 ff ff ff cmp -0x9c(%ebp),%edx
117c02: 72 ef jb 117bf3 <rtems_rfs_dir_read+0x523>
117c04: 8b 9d 60 ff ff ff mov -0xa0(%ebp),%ebx
117c0a: 01 d1 add %edx,%ecx
117c0c: 01 d0 add %edx,%eax
117c0e: e9 b0 fe ff ff jmp 117ac3 <rtems_rfs_dir_read+0x3f3>
117c13: 0f b7 10 movzwl (%eax),%edx
117c16: 83 c1 02 add $0x2,%ecx
117c19: 83 c0 02 add $0x2,%eax
117c1c: 83 ef 02 sub $0x2,%edi
117c1f: 66 89 51 fe mov %dx,-0x2(%ecx)
117c23: eb b2 jmp 117bd7 <rtems_rfs_dir_read+0x507>
117c25: 8b bd 68 ff ff ff mov -0x98(%ebp),%edi <== NOT EXECUTED
117c2b: 8b 55 18 mov 0x18(%ebp),%edx <== NOT EXECUTED
117c2e: 0f b6 47 0a movzbl 0xa(%edi),%eax <== NOT EXECUTED
117c32: 88 85 64 ff ff ff mov %al,-0x9c(%ebp) <== NOT EXECUTED
117c38: 88 42 16 mov %al,0x16(%edx) <== NOT EXECUTED
117c3b: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED
117c3e: 8d 48 17 lea 0x17(%eax),%ecx <== NOT EXECUTED
117c41: 8d 47 0b lea 0xb(%edi),%eax <== NOT EXECUTED
117c44: 8b bd 78 ff ff ff mov -0x88(%ebp),%edi <== NOT EXECUTED
117c4a: 4f dec %edi <== NOT EXECUTED
117c4b: eb 85 jmp 117bd2 <rtems_rfs_dir_read+0x502> <== NOT EXECUTED
memset (dirent, 0, sizeof (struct dirent));
117c4d: 66 c7 00 00 00 movw $0x0,(%eax) <== NOT EXECUTED
117c52: 83 c0 02 add $0x2,%eax <== NOT EXECUTED
117c55: 83 ad 70 ff ff ff 02 subl $0x2,-0x90(%ebp) <== NOT EXECUTED
117c5c: e9 7d fd ff ff jmp 1179de <rtems_rfs_dir_read+0x30e> <== NOT EXECUTED
117c61: c6 00 00 movb $0x0,(%eax) <== NOT EXECUTED
117c64: c7 85 70 ff ff ff 17 movl $0x117,-0x90(%ebp) <== NOT EXECUTED
117c6b: 01 00 00
117c6e: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED
117c71: 40 inc %eax <== NOT EXECUTED
117c72: e9 5f fd ff ff jmp 1179d6 <rtems_rfs_dir_read+0x306> <== NOT EXECUTED
117c77: 90 nop
117c78: 90 nop
117c79: 90 nop
117c7a: 90 nop
117c7b: 90 nop
117c7c: 90 nop
117c7d: 90 nop
117c7e: 90 nop
117c7f: 90 nop
001186a0 <rtems_rfs_file_close>:
{
1186a0: 55 push %ebp
1186a1: 89 e5 mov %esp,%ebp
1186a3: 57 push %edi
1186a4: 56 push %esi
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
1186a5: be 10 00 00 00 mov $0x10,%esi
{
1186aa: 53 push %ebx
1186ab: 83 ec 2c sub $0x2c,%esp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
1186ae: c7 04 24 00 00 00 00 movl $0x0,(%esp)
{
1186b5: 8b 5d 0c mov 0xc(%ebp),%ebx
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
1186b8: 89 74 24 04 mov %esi,0x4(%esp)
1186bc: e8 8f 31 ff ff call 10b850 <rtems_rfs_trace>
1186c1: 84 c0 test %al,%al
1186c3: 0f 85 b7 01 00 00 jne 118880 <rtems_rfs_file_close+0x1e0> <== NEVER TAKEN
if (handle->shared->references > 0)
1186c9: 8b 4b 1c mov 0x1c(%ebx),%ecx
1186cc: 8b 71 08 mov 0x8(%ecx),%esi
1186cf: 85 f6 test %esi,%esi
1186d1: 7e 04 jle 1186d7 <rtems_rfs_file_close+0x37> <== NEVER TAKEN
handle->shared->references--;
1186d3: 4e dec %esi
1186d4: 89 71 08 mov %esi,0x8(%ecx)
rc = rtems_rfs_buffer_handle_close (fs, &handle->buffer);
1186d7: 8d 43 04 lea 0x4(%ebx),%eax
if (handle->shared->references == 0)
1186da: 85 f6 test %esi,%esi
rc = rtems_rfs_buffer_handle_close (fs, &handle->buffer);
1186dc: 89 45 e4 mov %eax,-0x1c(%ebp)
if (handle->shared->references == 0)
1186df: 74 2f je 118710 <rtems_rfs_file_close+0x70> <== ALWAYS TAKEN
1186e1: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1186e5: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
rrc = 0;
1186e8: 31 f6 xor %esi,%esi <== NOT EXECUTED
1186ea: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
1186ed: e8 be f1 fe ff call 1078b0 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
free (handle);
1186f2: 89 1c 24 mov %ebx,(%esp)
1186f5: e8 e6 9d fe ff call 1024e0 <free>
}
1186fa: 83 c4 2c add $0x2c,%esp
1186fd: 89 f0 mov %esi,%eax
1186ff: 5b pop %ebx
118700: 5e pop %esi
118701: 5f pop %edi
118702: 5d pop %ebp
118703: c3 ret
118704: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11870b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
11870f: 90 nop
if (!rtems_rfs_inode_is_loaded (&handle->shared->inode))
118710: 8b 79 18 mov 0x18(%ecx),%edi
118713: 85 ff test %edi,%edi
118715: 0f 84 25 02 00 00 je 118940 <rtems_rfs_file_close+0x2a0> <== ALWAYS TAKEN
rtems_rfs_inode_set_atime (&handle->shared->inode,
11871b: 8b 81 8c 00 00 00 mov 0x8c(%ecx),%eax
rtems_rfs_write_u32 (&handle->node->atime, atime);
118721: 89 c2 mov %eax,%edx
118723: c1 ea 18 shr $0x18,%edx
118726: 88 57 10 mov %dl,0x10(%edi)
118729: 89 c2 mov %eax,%edx
11872b: 8b 79 18 mov 0x18(%ecx),%edi
11872e: c1 ea 10 shr $0x10,%edx
118731: 88 57 11 mov %dl,0x11(%edi)
118734: 8b 51 18 mov 0x18(%ecx),%edx
118737: 88 62 12 mov %ah,0x12(%edx)
11873a: 8b 51 18 mov 0x18(%ecx),%edx
11873d: 88 42 13 mov %al,0x13(%edx)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
118740: c6 41 1c 01 movb $0x1,0x1c(%ecx)
handle->shared->mtime);
118744: 8b 4b 1c mov 0x1c(%ebx),%ecx
rtems_rfs_inode_set_mtime (&handle->shared->inode,
118747: 8b 81 90 00 00 00 mov 0x90(%ecx),%eax
rtems_rfs_write_u32 (&handle->node->mtime, mtime);
11874d: 8b 79 18 mov 0x18(%ecx),%edi
118750: 89 c2 mov %eax,%edx
118752: c1 ea 18 shr $0x18,%edx
118755: 88 57 14 mov %dl,0x14(%edi)
118758: 89 c2 mov %eax,%edx
11875a: 8b 79 18 mov 0x18(%ecx),%edi
11875d: c1 ea 10 shr $0x10,%edx
118760: 88 57 15 mov %dl,0x15(%edi)
118763: 8b 51 18 mov 0x18(%ecx),%edx
118766: 88 62 16 mov %ah,0x16(%edx)
118769: 8b 51 18 mov 0x18(%ecx),%edx
11876c: 88 42 17 mov %al,0x17(%edx)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
11876f: c6 41 1c 01 movb $0x1,0x1c(%ecx)
handle->shared->ctime);
118773: 8b 4b 1c mov 0x1c(%ebx),%ecx
rtems_rfs_inode_set_ctime (&handle->shared->inode,
118776: 8b 81 94 00 00 00 mov 0x94(%ecx),%eax
rtems_rfs_write_u32 (&handle->node->ctime, ctime);
11877c: 8b 79 18 mov 0x18(%ecx),%edi
11877f: 89 c2 mov %eax,%edx
118781: c1 ea 18 shr $0x18,%edx
118784: 88 57 18 mov %dl,0x18(%edi)
118787: 89 c2 mov %eax,%edx
118789: 8b 79 18 mov 0x18(%ecx),%edi
11878c: c1 ea 10 shr $0x10,%edx
11878f: 88 57 19 mov %dl,0x19(%edi)
118792: 8b 51 18 mov 0x18(%ecx),%edx
118795: 88 62 1a mov %ah,0x1a(%edx)
118798: 8b 51 18 mov 0x18(%ecx),%edx
11879b: 88 42 1b mov %al,0x1b(%edx)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
11879e: c6 41 1c 01 movb $0x1,0x1c(%ecx)
if (!rtems_rfs_block_size_equal (&handle->shared->size,
1187a2: 8b 43 1c mov 0x1c(%ebx),%eax
1187a5: 8b 90 84 00 00 00 mov 0x84(%eax),%edx
1187ab: 3b 50 3c cmp 0x3c(%eax),%edx
1187ae: 8b 88 88 00 00 00 mov 0x88(%eax),%ecx
1187b4: 0f 84 16 02 00 00 je 1189d0 <rtems_rfs_file_close+0x330> <== ALWAYS TAKEN
*/
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);
1187ba: 89 50 3c mov %edx,0x3c(%eax) <== NOT EXECUTED
1187bd: 89 48 40 mov %ecx,0x40(%eax) <== NOT EXECUTED
map->dirty = true;
1187c0: c6 40 34 01 movb $0x1,0x34(%eax) <== NOT EXECUTED
rc = rtems_rfs_block_map_close (fs, &handle->shared->map);
1187c4: 83 c0 34 add $0x34,%eax
1187c7: 89 44 24 04 mov %eax,0x4(%esp)
1187cb: 8b 45 08 mov 0x8(%ebp),%eax
1187ce: 89 04 24 mov %eax,(%esp)
1187d1: e8 7a d2 ff ff call 115a50 <rtems_rfs_block_map_close>
if (rc > 0)
1187d6: 85 c0 test %eax,%eax
rc = rtems_rfs_block_map_close (fs, &handle->shared->map);
1187d8: 89 c7 mov %eax,%edi
if (rc > 0)
1187da: 0f 8f 30 01 00 00 jg 118910 <rtems_rfs_file_close+0x270> <== NEVER TAKEN
rc = rtems_rfs_inode_close (fs, &handle->shared->inode);
1187e0: 8b 43 1c mov 0x1c(%ebx),%eax
1187e3: 83 c0 0c add $0xc,%eax
1187e6: 89 44 24 04 mov %eax,0x4(%esp)
1187ea: 8b 45 08 mov 0x8(%ebp),%eax
1187ed: 89 04 24 mov %eax,(%esp)
1187f0: e8 4b 14 ff ff call 109c40 <rtems_rfs_inode_close>
if (rc > 0)
1187f5: 85 c0 test %eax,%eax
rc = rtems_rfs_inode_close (fs, &handle->shared->inode);
1187f7: 89 c7 mov %eax,%edi
if (rc > 0)
1187f9: 0f 8f a1 00 00 00 jg 1188a0 <rtems_rfs_file_close+0x200> <== NEVER TAKEN
rtems_chain_extract_unprotected (&handle->shared->link);
1187ff: 8b 43 1c mov 0x1c(%ebx),%eax
next = the_node->next;
118802: 8b 08 mov (%eax),%ecx
previous = the_node->previous;
118804: 8b 50 04 mov 0x4(%eax),%edx
next->previous = previous;
118807: 89 51 04 mov %edx,0x4(%ecx)
previous->next = next;
11880a: 89 0a mov %ecx,(%edx)
free (handle->shared);
11880c: 89 04 24 mov %eax,(%esp)
11880f: e8 cc 9c fe ff call 1024e0 <free>
118814: 8b 45 e4 mov -0x1c(%ebp),%eax
118817: 89 44 24 04 mov %eax,0x4(%esp)
11881b: 8b 45 08 mov 0x8(%ebp),%eax
11881e: 89 04 24 mov %eax,(%esp)
118821: e8 8a f0 fe ff call 1078b0 <rtems_rfs_buffer_handle_release>
if (rrc > 0)
118826: 85 f6 test %esi,%esi
handle->dirty = false;
118828: c6 43 04 00 movb $0x0,0x4(%ebx)
handle->bnum = 0;
11882c: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx)
handle->buffer = NULL;
118833: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
11883a: 0f 8e b2 fe ff ff jle 1186f2 <rtems_rfs_file_close+0x52> <== ALWAYS TAKEN
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
118840: c7 04 24 00 00 00 00 movl $0x0,(%esp) <== NOT EXECUTED
118847: b8 10 00 00 00 mov $0x10,%eax <== NOT EXECUTED
11884c: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
118850: e8 fb 2f ff ff call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
118855: 84 c0 test %al,%al <== NOT EXECUTED
118857: 0f 84 95 fe ff ff je 1186f2 <rtems_rfs_file_close+0x52> <== NOT EXECUTED
printf ("rtems-rfs: file-close: result: %d: %s\n", rrc, strerror (rrc));
11885d: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
118860: e8 bb 2b 01 00 call 12b420 <strerror> <== NOT EXECUTED
118865: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED
118869: c7 04 24 7c 5c 13 00 movl $0x135c7c,(%esp) <== NOT EXECUTED
118870: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
118874: e8 c7 98 fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
118879: e9 74 fe ff ff jmp 1186f2 <rtems_rfs_file_close+0x52> <== NOT EXECUTED
11887e: 66 90 xchg %ax,%ax <== NOT EXECUTED
printf ("rtems-rfs: file-close: entry: ino=%" PRId32 "\n",
118880: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED
118883: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED
118886: c7 04 24 e0 5b 13 00 movl $0x135be0,(%esp) <== NOT EXECUTED
11888d: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
118891: e8 aa 98 fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
118896: e9 2e fe ff ff jmp 1186c9 <rtems_rfs_file_close+0x29> <== NOT EXECUTED
11889b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11889f: 90 nop <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
1188a0: c7 04 24 00 00 00 00 movl $0x0,(%esp) <== NOT EXECUTED
1188a7: ba 10 00 00 00 mov $0x10,%edx <== NOT EXECUTED
1188ac: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
1188b0: e8 9b 2f ff ff call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
1188b5: 84 c0 test %al,%al <== NOT EXECUTED
1188b7: 0f 85 e3 00 00 00 jne 1189a0 <rtems_rfs_file_close+0x300> <== NOT EXECUTED
rtems_chain_extract_unprotected (&handle->shared->link);
1188bd: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED
if (rrc == 0)
1188c0: 85 f6 test %esi,%esi <== NOT EXECUTED
next = the_node->next;
1188c2: 8b 08 mov (%eax),%ecx <== NOT EXECUTED
previous = the_node->previous;
1188c4: 8b 50 04 mov 0x4(%eax),%edx <== NOT EXECUTED
1188c7: 0f 85 3a ff ff ff jne 118807 <rtems_rfs_file_close+0x167> <== NOT EXECUTED
next->previous = previous;
1188cd: 89 51 04 mov %edx,0x4(%ecx) <== NOT EXECUTED
1188d0: 89 fe mov %edi,%esi <== NOT EXECUTED
previous->next = next;
1188d2: 89 0a mov %ecx,(%edx) <== NOT EXECUTED
free (handle->shared);
1188d4: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
1188d7: e8 04 9c fe ff call 1024e0 <free> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
1188dc: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED
1188df: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1188e3: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
1188e6: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
1188e9: e8 c2 ef fe ff call 1078b0 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
1188ee: c6 43 04 00 movb $0x0,0x4(%ebx) <== NOT EXECUTED
handle->bnum = 0;
1188f2: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) <== NOT EXECUTED
handle->buffer = NULL;
1188f9: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) <== NOT EXECUTED
if (rrc > 0)
118900: e9 3b ff ff ff jmp 118840 <rtems_rfs_file_close+0x1a0> <== NOT EXECUTED
118905: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11890c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
118910: c7 04 24 00 00 00 00 movl $0x0,(%esp) <== NOT EXECUTED
118917: b9 10 00 00 00 mov $0x10,%ecx <== NOT EXECUTED
11891c: 89 4c 24 04 mov %ecx,0x4(%esp) <== NOT EXECUTED
118920: e8 2b 2f ff ff call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
118925: 84 c0 test %al,%al <== NOT EXECUTED
118927: 75 47 jne 118970 <rtems_rfs_file_close+0x2d0> <== NOT EXECUTED
if (rrc == 0)
118929: 85 f6 test %esi,%esi <== NOT EXECUTED
11892b: 0f 85 af fe ff ff jne 1187e0 <rtems_rfs_file_close+0x140> <== NOT EXECUTED
118931: 89 fe mov %edi,%esi <== NOT EXECUTED
118933: e9 a8 fe ff ff jmp 1187e0 <rtems_rfs_file_close+0x140> <== NOT EXECUTED
118938: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11893f: 90 nop <== NOT EXECUTED
rrc = rtems_rfs_inode_load (fs, &handle->shared->inode);
118940: 8b 45 08 mov 0x8(%ebp),%eax
118943: 83 c1 0c add $0xc,%ecx
118946: 89 4c 24 04 mov %ecx,0x4(%esp)
11894a: 89 04 24 mov %eax,(%esp)
11894d: e8 2e 10 ff ff call 109980 <rtems_rfs_inode_load>
if (rrc == 0)
118952: 85 c0 test %eax,%eax
rrc = rtems_rfs_inode_load (fs, &handle->shared->inode);
118954: 89 c2 mov %eax,%edx
if (rrc == 0)
118956: 0f 84 94 00 00 00 je 1189f0 <rtems_rfs_file_close+0x350> <== ALWAYS TAKEN
rc = rtems_rfs_block_map_close (fs, &handle->shared->map);
11895c: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED
11895f: 89 d6 mov %edx,%esi <== NOT EXECUTED
118961: e9 5e fe ff ff jmp 1187c4 <rtems_rfs_file_close+0x124> <== NOT EXECUTED
118966: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11896d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
printf ("rtems-rfs: file-close: map close error: ino=%" PRId32 ": %d: %s\n",
118970: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
118973: e8 a8 2a 01 00 call 12b420 <strerror> <== NOT EXECUTED
118978: 89 7c 24 08 mov %edi,0x8(%esp) <== NOT EXECUTED
11897c: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
118980: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED
118983: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED
118986: c7 04 24 08 5c 13 00 movl $0x135c08,(%esp) <== NOT EXECUTED
11898d: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
118991: e8 aa 97 fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
118996: eb 91 jmp 118929 <rtems_rfs_file_close+0x289> <== NOT EXECUTED
118998: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11899f: 90 nop <== NOT EXECUTED
printf ("rtems-rfs: file-close: inode close error: ino=%" PRId32 ": %d: %s\n",
1189a0: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
1189a3: e8 78 2a 01 00 call 12b420 <strerror> <== NOT EXECUTED
1189a8: 89 7c 24 08 mov %edi,0x8(%esp) <== NOT EXECUTED
1189ac: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
1189b0: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED
1189b3: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED
1189b6: c7 04 24 40 5c 13 00 movl $0x135c40,(%esp) <== NOT EXECUTED
1189bd: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1189c1: e8 7a 97 fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
1189c6: e9 f2 fe ff ff jmp 1188bd <rtems_rfs_file_close+0x21d> <== NOT EXECUTED
1189cb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1189cf: 90 nop <== NOT EXECUTED
if (!rtems_rfs_block_size_equal (&handle->shared->size,
1189d0: 3b 48 40 cmp 0x40(%eax),%ecx
1189d3: 0f 85 e1 fd ff ff jne 1187ba <rtems_rfs_file_close+0x11a> <== NEVER TAKEN
1189d9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1189e0: e9 df fd ff ff jmp 1187c4 <rtems_rfs_file_close+0x124>
1189e5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1189ec: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
handle->shared->atime);
1189f0: 8b 4b 1c mov 0x1c(%ebx),%ecx
rtems_rfs_write_u32 (&handle->node->atime, atime);
1189f3: 8b 79 18 mov 0x18(%ecx),%edi
1189f6: e9 20 fd ff ff jmp 11871b <rtems_rfs_file_close+0x7b>
1189fb: 90 nop
1189fc: 90 nop
1189fd: 90 nop
1189fe: 90 nop
1189ff: 90 nop
00119640 <rtems_rfs_file_get_shared>:
{
119640: 55 push %ebp
119641: 89 e5 mov %esp,%ebp
119643: 8b 55 08 mov 0x8(%ebp),%edx
119646: 8b 4d 0c mov 0xc(%ebp),%ecx
return _Chain_Immutable_head( the_chain )->next;
119649: 8b 42 74 mov 0x74(%edx),%eax
return &the_chain->Tail.Node;
11964c: 83 c2 78 add $0x78,%edx
while (!rtems_chain_is_tail (&fs->file_shares, node))
11964f: 39 d0 cmp %edx,%eax
119651: 75 13 jne 119666 <rtems_rfs_file_get_shared+0x26>
119653: eb 1b jmp 119670 <rtems_rfs_file_get_shared+0x30>
119655: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11965c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
return the_node->next;
119660: 8b 00 mov (%eax),%eax <== NOT EXECUTED
119662: 39 d0 cmp %edx,%eax <== NOT EXECUTED
119664: 74 0a je 119670 <rtems_rfs_file_get_shared+0x30> <== NOT EXECUTED
if (shared->inode.ino == ino)
119666: 39 48 14 cmp %ecx,0x14(%eax)
119669: 75 f5 jne 119660 <rtems_rfs_file_get_shared+0x20> <== NEVER TAKEN
return shared;
node = rtems_chain_next (node);
}
return NULL;
}
11966b: 5d pop %ebp <== NOT EXECUTED
11966c: c3 ret <== NOT EXECUTED
11966d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
119670: 5d pop %ebp
return NULL;
119671: 31 c0 xor %eax,%eax
}
119673: c3 ret
119674: 90 nop
119675: 90 nop
119676: 90 nop
119677: 90 nop
119678: 90 nop
119679: 90 nop
11967a: 90 nop
11967b: 90 nop
11967c: 90 nop
11967d: 90 nop
11967e: 90 nop
11967f: 90 nop
00118cb0 <rtems_rfs_file_io_end>:
{
118cb0: 55 push %ebp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
118cb1: b8 20 00 00 00 mov $0x20,%eax
{
118cb6: 89 e5 mov %esp,%ebp
118cb8: 57 push %edi
118cb9: 56 push %esi
118cba: 53 push %ebx
118cbb: 83 ec 4c sub $0x4c,%esp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
118cbe: c7 04 24 00 00 00 00 movl $0x0,(%esp)
{
118cc5: 8b 75 08 mov 0x8(%ebp),%esi
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
118cc8: 89 44 24 04 mov %eax,0x4(%esp)
{
118ccc: 8b 7d 0c mov 0xc(%ebp),%edi
118ccf: 0f b6 5d 10 movzbl 0x10(%ebp),%ebx
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
118cd3: e8 78 2b ff ff call 10b850 <rtems_rfs_trace>
118cd8: 84 c0 test %al,%al
118cda: 74 21 je 118cfd <rtems_rfs_file_io_end+0x4d> <== ALWAYS TAKEN
printf ("rtems-rfs: file-io: end: %s size=%zu\n",
118cdc: 84 db test %bl,%bl <== NOT EXECUTED
118cde: b8 69 38 13 00 mov $0x133869,%eax <== NOT EXECUTED
118ce3: 0f 84 17 02 00 00 je 118f00 <rtems_rfs_file_io_end+0x250> <== NOT EXECUTED
118ce9: 89 7c 24 08 mov %edi,0x8(%esp) <== NOT EXECUTED
118ced: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
118cf1: c7 04 24 60 5d 13 00 movl $0x135d60,(%esp) <== NOT EXECUTED
118cf8: e8 43 94 fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
118cfd: 8b 4e 0c mov 0xc(%esi),%ecx
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
118d00: 8b 46 1c mov 0x1c(%esi),%eax
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
118d03: 85 c9 test %ecx,%ecx
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
118d05: 8b 90 98 00 00 00 mov 0x98(%eax),%edx
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
118d0b: 0f 84 2f 02 00 00 je 118f40 <rtems_rfs_file_io_end+0x290> <== NEVER TAKEN
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
118d11: 8d 46 04 lea 0x4(%esi),%eax
if (!read)
118d14: 84 db test %bl,%bl
118d16: 0f 85 44 01 00 00 jne 118e60 <rtems_rfs_file_io_end+0x1b0>
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
118d1c: c6 46 04 01 movb $0x1,0x4(%esi)
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
118d20: 89 44 24 04 mov %eax,0x4(%esp)
118d24: 89 14 24 mov %edx,(%esp)
118d27: e8 84 eb fe ff call 1078b0 <rtems_rfs_buffer_handle_release>
118d2c: 89 45 e4 mov %eax,-0x1c(%ebp)
if (rc > 0)
118d2f: 85 c0 test %eax,%eax
118d31: 0f 8f b9 02 00 00 jg 118ff0 <rtems_rfs_file_io_end+0x340> <== NEVER TAKEN
if (handle->bpos.boff >=
118d37: c6 45 e3 01 movb $0x1,-0x1d(%ebp)
handle->bpos.boff += size;
118d3b: 8b 46 14 mov 0x14(%esi),%eax
118d3e: 01 c7 add %eax,%edi
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
118d40: 8b 46 1c mov 0x1c(%esi),%eax
handle->bpos.boff += size;
118d43: 89 7e 14 mov %edi,0x14(%esi)
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
118d46: 8b 90 98 00 00 00 mov 0x98(%eax),%edx
118d4c: 8b 52 08 mov 0x8(%edx),%edx
if (handle->bpos.boff >=
118d4f: 39 d7 cmp %edx,%edi
118d51: 72 10 jb 118d63 <rtems_rfs_file_io_end+0xb3>
handle->bpos.bno++;
118d53: ff 46 10 incl 0x10(%esi)
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
118d56: 29 d7 sub %edx,%edi
118d58: 89 7e 14 mov %edi,0x14(%esi)
if (!read &&
118d5b: 84 db test %bl,%bl
118d5d: 0f 85 38 01 00 00 jne 118e9b <rtems_rfs_file_io_end+0x1eb> <== NEVER TAKEN
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
118d63: 8b 4e 10 mov 0x10(%esi),%ecx
118d66: 8b 50 3c mov 0x3c(%eax),%edx
if (!read &&
118d69: 85 c9 test %ecx,%ecx
118d6b: 0f 84 9f 01 00 00 je 118f10 <rtems_rfs_file_io_end+0x260>
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
118d71: 85 d2 test %edx,%edx
118d73: 0f 85 97 01 00 00 jne 118f10 <rtems_rfs_file_io_end+0x260> <== ALWAYS TAKEN
118d79: 8b 56 14 mov 0x14(%esi),%edx
map->size.offset = offset;
118d7c: 89 50 40 mov %edx,0x40(%eax)
atime = rtems_rfs_file_update_atime (handle);
118d7f: 8b 0e mov (%esi),%ecx
map->dirty = true;
118d81: c6 40 34 01 movb $0x1,0x34(%eax)
118d85: 89 c8 mov %ecx,%eax
118d87: 83 e0 01 and $0x1,%eax
118d8a: 89 45 d8 mov %eax,-0x28(%ebp)
118d8d: 89 c2 mov %eax,%edx
118d8f: 83 f2 01 xor $0x1,%edx
118d92: 88 d0 mov %dl,%al
118d94: 24 01 and $0x1,%al
118d96: 88 45 e2 mov %al,-0x1e(%ebp)
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
118d99: 89 c8 mov %ecx,%eax
118d9b: d1 e8 shr %eax
118d9d: 83 f0 01 xor $0x1,%eax
118da0: 24 01 and $0x1,%al
118da2: 22 45 e3 and -0x1d(%ebp),%al
118da5: 88 45 e1 mov %al,-0x1f(%ebp)
118da8: 0f b6 f8 movzbl %al,%edi
length = rtems_rfs_file_update_length (handle) && length;
118dab: 09 fa or %edi,%edx
118dad: f6 c1 04 test $0x4,%cl
118db0: 89 55 dc mov %edx,-0x24(%ebp)
118db3: 0f 85 11 01 00 00 jne 118eca <rtems_rfs_file_io_end+0x21a> <== NEVER TAKEN
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
118db9: c7 04 24 00 00 00 00 movl $0x0,(%esp)
118dc0: b8 20 00 00 00 mov $0x20,%eax
118dc5: 89 44 24 04 mov %eax,0x4(%esp)
118dc9: e8 82 2a ff ff call 10b850 <rtems_rfs_trace>
118dce: 84 c0 test %al,%al
118dd0: 0f 84 6c 02 00 00 je 119042 <rtems_rfs_file_io_end+0x392> <== ALWAYS TAKEN
length = rtems_rfs_file_update_length (handle) && length;
118dd6: c7 45 d4 01 00 00 00 movl $0x1,-0x2c(%ebp) <== NOT EXECUTED
printf ("rtems-rfs: file-io: end: pos=%" PRIu32 ":%" PRIu32 " %c %c %c\n",
118ddd: b8 4c 00 00 00 mov $0x4c,%eax <== NOT EXECUTED
118de2: 89 44 24 14 mov %eax,0x14(%esp) <== NOT EXECUTED
118de6: 83 ff 01 cmp $0x1,%edi <== NOT EXECUTED
118de9: 19 d2 sbb %edx,%edx <== NOT EXECUTED
118deb: 83 e2 e0 and $0xffffffe0,%edx <== NOT EXECUTED
118dee: 83 c2 4d add $0x4d,%edx <== NOT EXECUTED
118df1: 83 7d d8 01 cmpl $0x1,-0x28(%ebp) <== NOT EXECUTED
118df5: 89 54 24 10 mov %edx,0x10(%esp) <== NOT EXECUTED
118df9: 19 c9 sbb %ecx,%ecx <== NOT EXECUTED
118dfb: 83 e1 14 and $0x14,%ecx <== NOT EXECUTED
118dfe: 83 c1 2d add $0x2d,%ecx <== NOT EXECUTED
118e01: 89 4c 24 0c mov %ecx,0xc(%esp) <== NOT EXECUTED
118e05: 8b 46 14 mov 0x14(%esi),%eax <== NOT EXECUTED
118e08: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
118e0c: 8b 46 10 mov 0x10(%esi),%eax <== NOT EXECUTED
118e0f: c7 04 24 cc 5d 13 00 movl $0x135dcc,(%esp) <== NOT EXECUTED
118e16: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
118e1a: e8 21 93 fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
if (atime || mtime)
118e1f: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED
118e22: 85 c0 test %eax,%eax <== NOT EXECUTED
118e24: 0f 85 4d 01 00 00 jne 118f77 <rtems_rfs_file_io_end+0x2c7> <== NOT EXECUTED
if (length)
118e2a: 8b 45 d4 mov -0x2c(%ebp),%eax
118e2d: 85 c0 test %eax,%eax
118e2f: 0f 84 bd 00 00 00 je 118ef2 <rtems_rfs_file_io_end+0x242>
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
118e35: 8b 46 1c mov 0x1c(%esi),%eax
handle->shared->size.count =
118e38: 8b 50 3c mov 0x3c(%eax),%edx
118e3b: 89 90 84 00 00 00 mov %edx,0x84(%eax)
handle->shared->size.offset =
118e41: 8b 50 40 mov 0x40(%eax),%edx
118e44: 89 90 88 00 00 00 mov %edx,0x88(%eax)
}
118e4a: 8b 45 e4 mov -0x1c(%ebp),%eax
118e4d: 83 c4 4c add $0x4c,%esp
118e50: 5b pop %ebx
118e51: 5e pop %esi
118e52: 5f pop %edi
118e53: 5d pop %ebp
118e54: c3 ret
118e55: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
118e5c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
118e60: 89 44 24 04 mov %eax,0x4(%esp)
118e64: 89 14 24 mov %edx,(%esp)
118e67: e8 44 ea fe ff call 1078b0 <rtems_rfs_buffer_handle_release>
118e6c: 89 45 e4 mov %eax,-0x1c(%ebp)
if (rc > 0)
118e6f: 85 c0 test %eax,%eax
118e71: 0f 8f b9 01 00 00 jg 119030 <rtems_rfs_file_io_end+0x380> <== NEVER TAKEN
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
118e77: 8b 46 1c mov 0x1c(%esi),%eax
handle->bpos.boff += size;
118e7a: 8b 4e 14 mov 0x14(%esi),%ecx
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
118e7d: 8b 90 98 00 00 00 mov 0x98(%eax),%edx
handle->bpos.boff += size;
118e83: 01 cf add %ecx,%edi
mtime = !read;
118e85: 88 d9 mov %bl,%cl
handle->bpos.boff += size;
118e87: 89 7e 14 mov %edi,0x14(%esi)
mtime = !read;
118e8a: 80 f1 01 xor $0x1,%cl
118e8d: 88 4d e3 mov %cl,-0x1d(%ebp)
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
118e90: 8b 52 08 mov 0x8(%edx),%edx
if (handle->bpos.boff >=
118e93: 39 fa cmp %edi,%edx
118e95: 0f 86 b8 fe ff ff jbe 118d53 <rtems_rfs_file_io_end+0xa3> <== NEVER TAKEN
atime = rtems_rfs_file_update_atime (handle);
118e9b: 8b 06 mov (%esi),%eax
118e9d: 89 c7 mov %eax,%edi
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
118e9f: d1 e8 shr %eax
atime = rtems_rfs_file_update_atime (handle);
118ea1: 83 e7 01 and $0x1,%edi
118ea4: 89 7d d8 mov %edi,-0x28(%ebp)
118ea7: 89 fa mov %edi,%edx
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
118ea9: 83 f0 01 xor $0x1,%eax
118eac: 83 f2 01 xor $0x1,%edx
118eaf: 24 01 and $0x1,%al
atime = rtems_rfs_file_update_atime (handle);
118eb1: 88 d1 mov %dl,%cl
118eb3: 80 e1 01 and $0x1,%cl
118eb6: 88 4d e2 mov %cl,-0x1e(%ebp)
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
118eb9: 0f b6 4d e3 movzbl -0x1d(%ebp),%ecx
118ebd: 20 c8 and %cl,%al
118ebf: 88 45 e1 mov %al,-0x1f(%ebp)
118ec2: 0f b6 f8 movzbl %al,%edi
length = rtems_rfs_file_update_length (handle) && length;
118ec5: 09 fa or %edi,%edx
118ec7: 89 55 dc mov %edx,-0x24(%ebp)
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
118eca: c7 04 24 00 00 00 00 movl $0x0,(%esp)
118ed1: b8 20 00 00 00 mov $0x20,%eax
118ed6: 89 44 24 04 mov %eax,0x4(%esp)
118eda: e8 71 29 ff ff call 10b850 <rtems_rfs_trace>
118edf: 84 c0 test %al,%al
118ee1: 0f 85 b9 00 00 00 jne 118fa0 <rtems_rfs_file_io_end+0x2f0> <== NEVER TAKEN
if (atime || mtime)
118ee7: 8b 7d dc mov -0x24(%ebp),%edi
118eea: 85 ff test %edi,%edi
118eec: 0f 85 7e 00 00 00 jne 118f70 <rtems_rfs_file_io_end+0x2c0> <== ALWAYS TAKEN
}
118ef2: 8b 45 e4 mov -0x1c(%ebp),%eax
118ef5: 83 c4 4c add $0x4c,%esp
118ef8: 5b pop %ebx
118ef9: 5e pop %esi
118efa: 5f pop %edi
118efb: 5d pop %ebp
118efc: c3 ret
118efd: 8d 76 00 lea 0x0(%esi),%esi
printf ("rtems-rfs: file-io: end: %s size=%zu\n",
118f00: b8 a3 5c 13 00 mov $0x135ca3,%eax <== NOT EXECUTED
118f05: e9 df fd ff ff jmp 118ce9 <rtems_rfs_file_io_end+0x39> <== NOT EXECUTED
118f0a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
118f10: 39 d1 cmp %edx,%ecx
118f12: 0f 83 61 fe ff ff jae 118d79 <rtems_rfs_file_io_end+0xc9>
118f18: 4a dec %edx
118f19: 39 d1 cmp %edx,%ecx
118f1b: 0f 85 7a ff ff ff jne 118e9b <rtems_rfs_file_io_end+0x1eb>
118f21: 8b 56 14 mov 0x14(%esi),%edx
118f24: 3b 50 40 cmp 0x40(%eax),%edx
118f27: 0f 86 6e ff ff ff jbe 118e9b <rtems_rfs_file_io_end+0x1eb>
118f2d: e9 4a fe ff ff jmp 118d7c <rtems_rfs_file_io_end+0xcc>
118f32: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
118f39: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
int rc = 0;
118f40: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) <== NOT EXECUTED
handle->bpos.boff += size;
118f47: 8b 4e 14 mov 0x14(%esi),%ecx <== NOT EXECUTED
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
118f4a: 8b 52 08 mov 0x8(%edx),%edx <== NOT EXECUTED
handle->bpos.boff += size;
118f4d: 01 cf add %ecx,%edi <== NOT EXECUTED
mtime = !read;
118f4f: 88 d9 mov %bl,%cl <== NOT EXECUTED
handle->bpos.boff += size;
118f51: 89 7e 14 mov %edi,0x14(%esi) <== NOT EXECUTED
mtime = !read;
118f54: 80 f1 01 xor $0x1,%cl <== NOT EXECUTED
if (handle->bpos.boff >=
118f57: 39 d7 cmp %edx,%edi <== NOT EXECUTED
mtime = !read;
118f59: 88 4d e3 mov %cl,-0x1d(%ebp) <== NOT EXECUTED
if (handle->bpos.boff >=
118f5c: 0f 82 f9 fd ff ff jb 118d5b <rtems_rfs_file_io_end+0xab> <== NOT EXECUTED
118f62: e9 ec fd ff ff jmp 118d53 <rtems_rfs_file_io_end+0xa3> <== NOT EXECUTED
118f67: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
118f6e: 66 90 xchg %ax,%ax <== NOT EXECUTED
length = rtems_rfs_file_update_length (handle) && length;
118f70: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) <== NOT EXECUTED
time_t now = time (NULL);
118f77: c7 04 24 00 00 00 00 movl $0x0,(%esp)
118f7e: e8 cd 5e 01 00 call 12ee50 <time>
if (read && atime)
118f83: 84 db test %bl,%bl
118f85: 74 39 je 118fc0 <rtems_rfs_file_io_end+0x310>
118f87: 80 7d e2 00 cmpb $0x0,-0x1e(%ebp)
118f8b: 74 33 je 118fc0 <rtems_rfs_file_io_end+0x310> <== NEVER TAKEN
handle->shared->atime = now;
118f8d: 8b 56 1c mov 0x1c(%esi),%edx
118f90: 89 82 8c 00 00 00 mov %eax,0x8c(%edx)
if (!read && mtime)
118f96: e9 8f fe ff ff jmp 118e2a <rtems_rfs_file_io_end+0x17a>
118f9b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
118f9f: 90 nop
length = rtems_rfs_file_update_length (handle) && length;
118fa0: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) <== NOT EXECUTED
printf ("rtems-rfs: file-io: end: pos=%" PRIu32 ":%" PRIu32 " %c %c %c\n",
118fa7: b8 2d 00 00 00 mov $0x2d,%eax <== NOT EXECUTED
118fac: e9 31 fe ff ff jmp 118de2 <rtems_rfs_file_io_end+0x132> <== NOT EXECUTED
118fb1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
118fb8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
118fbf: 90 nop <== NOT EXECUTED
if (!read && mtime)
118fc0: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp)
118fc4: 0f 84 60 fe ff ff je 118e2a <rtems_rfs_file_io_end+0x17a> <== NEVER TAKEN
118fca: 80 7d e1 00 cmpb $0x0,-0x1f(%ebp)
118fce: 0f 84 56 fe ff ff je 118e2a <rtems_rfs_file_io_end+0x17a> <== NEVER TAKEN
handle->shared->mtime = now;
118fd4: 8b 56 1c mov 0x1c(%esi),%edx
118fd7: 89 82 90 00 00 00 mov %eax,0x90(%edx)
118fdd: e9 48 fe ff ff jmp 118e2a <rtems_rfs_file_io_end+0x17a>
118fe2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
118fe9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
printf (
118ff0: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED
118ff3: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
118ff6: e8 25 24 01 00 call 12b420 <strerror> <== NOT EXECUTED
118ffb: ba a3 5c 13 00 mov $0x135ca3,%edx <== NOT EXECUTED
119000: 89 44 24 10 mov %eax,0x10(%esp) <== NOT EXECUTED
119004: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED
119007: 89 7c 24 08 mov %edi,0x8(%esp) <== NOT EXECUTED
11900b: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
11900f: c7 04 24 88 5d 13 00 movl $0x135d88,(%esp) <== NOT EXECUTED
119016: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
11901a: e8 21 91 fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
}
11901f: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED
119022: 83 c4 4c add $0x4c,%esp <== NOT EXECUTED
119025: 5b pop %ebx <== NOT EXECUTED
119026: 5e pop %esi <== NOT EXECUTED
119027: 5f pop %edi <== NOT EXECUTED
119028: 5d pop %ebp <== NOT EXECUTED
119029: c3 ret <== NOT EXECUTED
11902a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
printf (
119030: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED
119033: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
119036: e8 e5 23 01 00 call 12b420 <strerror> <== NOT EXECUTED
11903b: ba 69 38 13 00 mov $0x133869,%edx <== NOT EXECUTED
119040: eb be jmp 119000 <rtems_rfs_file_io_end+0x350> <== NOT EXECUTED
if (atime || mtime)
119042: 83 7d dc 00 cmpl $0x0,-0x24(%ebp)
119046: 0f 84 e9 fd ff ff je 118e35 <rtems_rfs_file_io_end+0x185> <== NEVER TAKEN
length = rtems_rfs_file_update_length (handle) && length;
11904c: 8b 45 dc mov -0x24(%ebp),%eax
11904f: 89 45 d4 mov %eax,-0x2c(%ebp)
119052: e9 20 ff ff ff jmp 118f77 <rtems_rfs_file_io_end+0x2c7>
119057: 90 nop
119058: 90 nop
119059: 90 nop
11905a: 90 nop
11905b: 90 nop
11905c: 90 nop
11905d: 90 nop
11905e: 90 nop
11905f: 90 nop
00118a00 <rtems_rfs_file_io_start>:
{
118a00: 55 push %ebp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
118a01: b8 20 00 00 00 mov $0x20,%eax
{
118a06: 89 e5 mov %esp,%ebp
118a08: 83 ec 38 sub $0x38,%esp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
118a0b: c7 04 24 00 00 00 00 movl $0x0,(%esp)
118a12: 89 44 24 04 mov %eax,0x4(%esp)
{
118a16: 89 5d f4 mov %ebx,-0xc(%ebp)
118a19: 0f b6 5d 10 movzbl 0x10(%ebp),%ebx
118a1d: 89 75 f8 mov %esi,-0x8(%ebp)
118a20: 8b 75 08 mov 0x8(%ebp),%esi
118a23: 89 7d fc mov %edi,-0x4(%ebp)
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
118a26: e8 25 2e ff ff call 10b850 <rtems_rfs_trace>
118a2b: 84 c0 test %al,%al
118a2d: 74 2b je 118a5a <rtems_rfs_file_io_start+0x5a> <== ALWAYS TAKEN
printf ("rtems-rfs: file-io: start: %s pos=%" PRIu32 ":%" PRIu32 "\n",
118a2f: 84 db test %bl,%bl <== NOT EXECUTED
118a31: 8b 7e 14 mov 0x14(%esi),%edi <== NOT EXECUTED
118a34: b8 69 38 13 00 mov $0x133869,%eax <== NOT EXECUTED
118a39: 8b 4e 10 mov 0x10(%esi),%ecx <== NOT EXECUTED
118a3c: 0f 84 8e 00 00 00 je 118ad0 <rtems_rfs_file_io_start+0xd0> <== NOT EXECUTED
118a42: 89 7c 24 0c mov %edi,0xc(%esp) <== NOT EXECUTED
118a46: 89 4c 24 08 mov %ecx,0x8(%esp) <== NOT EXECUTED
118a4a: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
118a4e: c7 04 24 ac 5c 13 00 movl $0x135cac,(%esp) <== NOT EXECUTED
118a55: e8 e6 96 fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
if (!rtems_rfs_buffer_handle_has_block (&handle->buffer))
118a5a: 8b 7e 0c mov 0xc(%esi),%edi
rtems_rfs_file_map (handle),
118a5d: 8b 46 1c mov 0x1c(%esi),%eax
if (!rtems_rfs_buffer_handle_has_block (&handle->buffer))
118a60: 85 ff test %edi,%edi
118a62: 0f 84 b8 00 00 00 je 118b20 <rtems_rfs_file_io_start+0x120>
if (read
118a68: 84 db test %bl,%bl
118a6a: 75 44 jne 118ab0 <rtems_rfs_file_io_start+0xb0>
size = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
118a6c: 8b 80 98 00 00 00 mov 0x98(%eax),%eax
118a72: 8b 58 08 mov 0x8(%eax),%ebx
*available = size - rtems_rfs_file_block_offset (handle);
118a75: 8b 56 14 mov 0x14(%esi),%edx
118a78: 89 d8 mov %ebx,%eax
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
118a7a: b9 20 00 00 00 mov $0x20,%ecx
return 0;
118a7f: 31 ff xor %edi,%edi
*available = size - rtems_rfs_file_block_offset (handle);
118a81: 29 d0 sub %edx,%eax
118a83: 8b 55 0c mov 0xc(%ebp),%edx
118a86: 89 02 mov %eax,(%edx)
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
118a88: c7 04 24 00 00 00 00 movl $0x0,(%esp)
118a8f: 89 4c 24 04 mov %ecx,0x4(%esp)
118a93: e8 b8 2d ff ff call 10b850 <rtems_rfs_trace>
118a98: 84 c0 test %al,%al
118a9a: 75 54 jne 118af0 <rtems_rfs_file_io_start+0xf0> <== NEVER TAKEN
}
118a9c: 8b 5d f4 mov -0xc(%ebp),%ebx
118a9f: 89 f8 mov %edi,%eax
118aa1: 8b 75 f8 mov -0x8(%ebp),%esi
118aa4: 8b 7d fc mov -0x4(%ebp),%edi
118aa7: 89 ec mov %ebp,%esp
118aa9: 5d pop %ebp
118aaa: c3 ret
118aab: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
118aaf: 90 nop
&& rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
118ab0: 8b 58 44 mov 0x44(%eax),%ebx
118ab3: 8b 48 3c mov 0x3c(%eax),%ecx
118ab6: 89 da mov %ebx,%edx
118ab8: 09 ca or %ecx,%edx
118aba: 75 24 jne 118ae0 <rtems_rfs_file_io_start+0xe0> <== ALWAYS TAKEN
&& rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle)))
118abc: 8b 58 40 mov 0x40(%eax),%ebx
118abf: 85 db test %ebx,%ebx
118ac1: 75 b2 jne 118a75 <rtems_rfs_file_io_start+0x75>
118ac3: eb a7 jmp 118a6c <rtems_rfs_file_io_start+0x6c>
118ac5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
118acc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
printf ("rtems-rfs: file-io: start: %s pos=%" PRIu32 ":%" PRIu32 "\n",
118ad0: b8 a3 5c 13 00 mov $0x135ca3,%eax <== NOT EXECUTED
118ad5: e9 68 ff ff ff jmp 118a42 <rtems_rfs_file_io_start+0x42> <== NOT EXECUTED
118ada: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
&& rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
118ae0: 49 dec %ecx
118ae1: 39 cb cmp %ecx,%ebx
118ae3: 75 87 jne 118a6c <rtems_rfs_file_io_start+0x6c>
118ae5: eb d5 jmp 118abc <rtems_rfs_file_io_start+0xbc>
118ae7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
118aee: 66 90 xchg %ax,%ax
printf ("rtems-rfs: file-io: start: available=%zu (%zu)\n",
118af0: 89 5c 24 08 mov %ebx,0x8(%esp) <== NOT EXECUTED
118af4: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
118af7: 8b 00 mov (%eax),%eax <== NOT EXECUTED
118af9: c7 04 24 30 5d 13 00 movl $0x135d30,(%esp) <== NOT EXECUTED
118b00: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
118b04: e8 37 96 fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
}
118b09: 8b 5d f4 mov -0xc(%ebp),%ebx <== NOT EXECUTED
118b0c: 89 f8 mov %edi,%eax <== NOT EXECUTED
118b0e: 8b 75 f8 mov -0x8(%ebp),%esi <== NOT EXECUTED
118b11: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED
118b14: 89 ec mov %ebp,%esp <== NOT EXECUTED
118b16: 5d pop %ebp <== NOT EXECUTED
118b17: c3 ret <== NOT EXECUTED
118b18: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
118b1f: 90 nop <== NOT EXECUTED
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
118b20: 8d 4e 10 lea 0x10(%esi),%ecx
118b23: 89 4c 24 08 mov %ecx,0x8(%esp)
118b27: 8d 55 e4 lea -0x1c(%ebp),%edx
118b2a: 89 54 24 0c mov %edx,0xc(%esp)
118b2e: 8d 48 34 lea 0x34(%eax),%ecx
118b31: 89 4c 24 04 mov %ecx,0x4(%esp)
118b35: 8b 80 98 00 00 00 mov 0x98(%eax),%eax
118b3b: 89 04 24 mov %eax,(%esp)
118b3e: e8 ad d0 ff ff call 115bf0 <rtems_rfs_block_map_find>
if (rc > 0)
118b43: 85 c0 test %eax,%eax
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
118b45: 89 c7 mov %eax,%edi
if (rc > 0)
118b47: 7e 27 jle 118b70 <rtems_rfs_file_io_start+0x170>
if (read && (rc == ENXIO))
118b49: 83 f8 06 cmp $0x6,%eax
118b4c: 0f 85 4a ff ff ff jne 118a9c <rtems_rfs_file_io_start+0x9c> <== NEVER TAKEN
118b52: 84 db test %bl,%bl
118b54: 0f 84 e6 00 00 00 je 118c40 <rtems_rfs_file_io_start+0x240> <== ALWAYS TAKEN
*available = 0;
118b5a: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
return 0;
118b5d: 31 ff xor %edi,%edi <== NOT EXECUTED
*available = 0;
118b5f: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED
return 0;
118b65: e9 32 ff ff ff jmp 118a9c <rtems_rfs_file_io_start+0x9c> <== NOT EXECUTED
118b6a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
if (!read &&
118b70: 84 db test %bl,%bl
118b72: 0f 85 98 00 00 00 jne 118c10 <rtems_rfs_file_io_start+0x210>
118b78: 8b 46 14 mov 0x14(%esi),%eax
118b7b: 85 c0 test %eax,%eax
118b7d: 0f 85 8d 00 00 00 jne 118c10 <rtems_rfs_file_io_start+0x210>
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
118b83: 8b 46 1c mov 0x1c(%esi),%eax
(rtems_rfs_file_block_offset (handle) ||
118b86: 8b 55 0c mov 0xc(%ebp),%edx
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
118b89: 8b 80 98 00 00 00 mov 0x98(%eax),%eax
(rtems_rfs_file_block_offset (handle) ||
118b8f: 8b 40 08 mov 0x8(%eax),%eax
118b92: 39 02 cmp %eax,(%edx)
118b94: 72 7a jb 118c10 <rtems_rfs_file_io_start+0x210> <== ALWAYS TAKEN
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
118b96: c7 04 24 00 00 00 00 movl $0x0,(%esp)
118b9d: b8 20 00 00 00 mov $0x20,%eax
printf ("rtems-rfs: file-io: start: %s pos=%" PRIu32 ":%" PRIu32 "\n",
118ba2: 31 ff xor %edi,%edi
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
118ba4: 89 44 24 04 mov %eax,0x4(%esp)
118ba8: e8 a3 2c ff ff call 10b850 <rtems_rfs_trace>
118bad: 84 c0 test %al,%al
118baf: 74 1c je 118bcd <rtems_rfs_file_io_start+0x1cd> <== ALWAYS TAKEN
printf ("rtems-rfs: file-io: start: block=%" PRIu32 " request-read=%s\n",
118bb1: b8 3b 46 13 00 mov $0x13463b,%eax <== NOT EXECUTED
118bb6: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
118bba: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED
118bbd: c7 04 24 f8 5c 13 00 movl $0x135cf8,(%esp) <== NOT EXECUTED
118bc4: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
118bc8: e8 73 95 fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
118bcd: 89 7c 24 0c mov %edi,0xc(%esp)
118bd1: 8b 45 e4 mov -0x1c(%ebp),%eax
118bd4: 89 44 24 08 mov %eax,0x8(%esp)
118bd8: 8d 46 04 lea 0x4(%esi),%eax
118bdb: 89 44 24 04 mov %eax,0x4(%esp)
118bdf: 8b 46 1c mov 0x1c(%esi),%eax
118be2: 8b 80 98 00 00 00 mov 0x98(%eax),%eax
118be8: 89 04 24 mov %eax,(%esp)
118beb: e8 e0 e9 fe ff call 1075d0 <rtems_rfs_buffer_handle_request>
if (rc > 0)
118bf0: 85 c0 test %eax,%eax
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
118bf2: 89 c7 mov %eax,%edi
if (rc > 0)
118bf4: 0f 8f a2 fe ff ff jg 118a9c <rtems_rfs_file_io_start+0x9c> <== NEVER TAKEN
&& rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
118bfa: 8b 46 1c mov 0x1c(%esi),%eax
118bfd: e9 66 fe ff ff jmp 118a68 <rtems_rfs_file_io_start+0x68>
118c02: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
118c09: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
118c10: c7 04 24 00 00 00 00 movl $0x0,(%esp)
118c17: bf 20 00 00 00 mov $0x20,%edi
118c1c: 89 7c 24 04 mov %edi,0x4(%esp)
118c20: bf 01 00 00 00 mov $0x1,%edi
118c25: e8 26 2c ff ff call 10b850 <rtems_rfs_trace>
118c2a: 84 c0 test %al,%al
118c2c: 74 9f je 118bcd <rtems_rfs_file_io_start+0x1cd> <== ALWAYS TAKEN
printf ("rtems-rfs: file-io: start: block=%" PRIu32 " request-read=%s\n",
118c2e: b8 37 46 13 00 mov $0x134637,%eax <== NOT EXECUTED
118c33: eb 81 jmp 118bb6 <rtems_rfs_file_io_start+0x1b6> <== NOT EXECUTED
118c35: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
118c3c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
if (rc != ENXIO)
118c40: 83 f8 06 cmp $0x6,%eax
118c43: 0f 85 53 fe ff ff jne 118a9c <rtems_rfs_file_io_start+0x9c> <== NEVER TAKEN
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
118c49: c7 04 24 00 00 00 00 movl $0x0,(%esp)
118c50: b9 20 00 00 00 mov $0x20,%ecx
118c55: 89 4c 24 04 mov %ecx,0x4(%esp)
118c59: e8 f2 2b ff ff call 10b850 <rtems_rfs_trace>
118c5e: 84 c0 test %al,%al
118c60: 75 37 jne 118c99 <rtems_rfs_file_io_start+0x299> <== NEVER TAKEN
rtems_rfs_file_map (handle),
118c62: 8b 46 1c mov 0x1c(%esi),%eax
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
118c65: 8d 55 e4 lea -0x1c(%ebp),%edx
118c68: 89 54 24 0c mov %edx,0xc(%esp)
118c6c: ba 01 00 00 00 mov $0x1,%edx
118c71: 89 54 24 08 mov %edx,0x8(%esp)
118c75: 8d 48 34 lea 0x34(%eax),%ecx
118c78: 89 4c 24 04 mov %ecx,0x4(%esp)
118c7c: 8b 80 98 00 00 00 mov 0x98(%eax),%eax
118c82: 89 04 24 mov %eax,(%esp)
118c85: e8 76 d1 ff ff call 115e00 <rtems_rfs_block_map_grow>
if (rc > 0)
118c8a: 85 c0 test %eax,%eax
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
118c8c: 89 c7 mov %eax,%edi
if (rc > 0)
118c8e: 0f 8e 02 ff ff ff jle 118b96 <rtems_rfs_file_io_start+0x196>
118c94: e9 03 fe ff ff jmp 118a9c <rtems_rfs_file_io_start+0x9c>
printf ("rtems-rfs: file-io: start: grow\n");
118c99: c7 04 24 d8 5c 13 00 movl $0x135cd8,(%esp) <== NOT EXECUTED
118ca0: e8 cb 94 fe ff call 102170 <__wrap_puts> <== NOT EXECUTED
118ca5: eb bb jmp 118c62 <rtems_rfs_file_io_start+0x262> <== NOT EXECUTED
118ca7: 90 nop
118ca8: 90 nop
118ca9: 90 nop
118caa: 90 nop
118cab: 90 nop
118cac: 90 nop
118cad: 90 nop
118cae: 90 nop
118caf: 90 nop
001182f0 <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)
{
1182f0: 55 push %ebp
1182f1: 89 e5 mov %esp,%ebp
1182f3: 57 push %edi
1182f4: 56 push %esi
1182f5: 53 push %ebx
rtems_rfs_file_handle* handle;
rtems_rfs_file_shared* shared;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
1182f6: bb 08 00 00 00 mov $0x8,%ebx
{
1182fb: 83 ec 2c sub $0x2c,%esp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
1182fe: c7 04 24 00 00 00 00 movl $0x0,(%esp)
{
118305: 8b 75 0c mov 0xc(%ebp),%esi
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
118308: 89 5c 24 04 mov %ebx,0x4(%esp)
11830c: e8 3f 35 ff ff call 10b850 <rtems_rfs_trace>
118311: 84 c0 test %al,%al
118313: 0f 85 b7 00 00 00 jne 1183d0 <rtems_rfs_file_open+0xe0> <== NEVER TAKEN
printf ("rtems-rfs: file-open: ino=%" PRId32 "\n", ino);
*file = NULL;
118319: 8b 45 14 mov 0x14(%ebp),%eax
/*
* 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));
11831c: b9 01 00 00 00 mov $0x1,%ecx
*file = NULL;
118321: c7 00 00 00 00 00 movl $0x0,(%eax)
handle = malloc (sizeof (rtems_rfs_file_handle));
118327: 89 4c 24 04 mov %ecx,0x4(%esp)
11832b: c7 04 24 20 00 00 00 movl $0x20,(%esp)
118332: e8 a9 bb ff ff call 113ee0 <calloc>
if (!handle)
118337: 85 c0 test %eax,%eax
handle = malloc (sizeof (rtems_rfs_file_handle));
118339: 89 c2 mov %eax,%edx
if (!handle)
11833b: 0f 84 1e 03 00 00 je 11865f <rtems_rfs_file_open+0x36f> <== NEVER TAKEN
return _Chain_Immutable_head( the_chain )->next;
118341: 8b 45 08 mov 0x8(%ebp),%eax
118344: 8b 58 74 mov 0x74(%eax),%ebx
return &the_chain->Tail.Node;
118347: 8d 78 78 lea 0x78(%eax),%edi
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))
11834a: 39 fb cmp %edi,%ebx
11834c: 75 1c jne 11836a <rtems_rfs_file_open+0x7a> <== NEVER TAKEN
11834e: e9 9d 00 00 00 jmp 1183f0 <rtems_rfs_file_open+0x100>
118353: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11835a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
return the_node->next;
118360: 8b 1b mov (%ebx),%ebx <== NOT EXECUTED
118362: 39 fb cmp %edi,%ebx <== NOT EXECUTED
118364: 0f 84 86 00 00 00 je 1183f0 <rtems_rfs_file_open+0x100> <== NOT EXECUTED
{
rtems_rfs_file_shared* shared;
shared = (rtems_rfs_file_shared*) node;
if (shared->inode.ino == ino)
11836a: 3b 73 14 cmp 0x14(%ebx),%esi <== NOT EXECUTED
11836d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
118370: 75 ee jne 118360 <rtems_rfs_file_open+0x70> <== NOT EXECUTED
shared->references++;
118372: ff 43 08 incl 0x8(%ebx) <== NOT EXECUTED
118375: 89 55 e4 mov %edx,-0x1c(%ebp) <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
118378: ba 08 00 00 00 mov $0x8,%edx <== NOT EXECUTED
11837d: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
118381: c7 04 24 00 00 00 00 movl $0x0,(%esp) <== NOT EXECUTED
118388: e8 c3 34 ff ff call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
11838d: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED
118390: 84 c0 test %al,%al <== NOT EXECUTED
118392: 75 1c jne 1183b0 <rtems_rfs_file_open+0xc0> <== NOT EXECUTED
handle->shared = shared;
118394: 89 5a 1c mov %ebx,0x1c(%edx)
handle->flags = oflag;
118397: 8b 45 10 mov 0x10(%ebp),%eax
return 0;
11839a: 31 c9 xor %ecx,%ecx
handle->flags = oflag;
11839c: 89 02 mov %eax,(%edx)
*file = handle;
11839e: 8b 45 14 mov 0x14(%ebp),%eax
1183a1: 89 10 mov %edx,(%eax)
}
1183a3: 83 c4 2c add $0x2c,%esp
1183a6: 89 c8 mov %ecx,%eax
1183a8: 5b pop %ebx
1183a9: 5e pop %esi
1183aa: 5f pop %edi
1183ab: 5d pop %ebp
1183ac: c3 ret
1183ad: 8d 76 00 lea 0x0(%esi),%esi
printf ("rtems-rfs: file-open: ino=%" PRId32 " shared\n", ino);
1183b0: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED
1183b4: c7 04 24 20 5b 13 00 movl $0x135b20,(%esp) <== NOT EXECUTED
1183bb: 89 55 e4 mov %edx,-0x1c(%ebp) <== NOT EXECUTED
1183be: e8 7d 9d fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
1183c3: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED
1183c6: eb cc jmp 118394 <rtems_rfs_file_open+0xa4> <== NOT EXECUTED
1183c8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1183cf: 90 nop <== NOT EXECUTED
printf ("rtems-rfs: file-open: ino=%" PRId32 "\n", ino);
1183d0: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED
1183d4: c7 04 24 00 5b 13 00 movl $0x135b00,(%esp) <== NOT EXECUTED
1183db: e8 60 9d fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
1183e0: e9 34 ff ff ff jmp 118319 <rtems_rfs_file_open+0x29> <== NOT EXECUTED
1183e5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1183ec: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
shared = malloc (sizeof (rtems_rfs_file_shared));
1183f0: c7 04 24 9c 00 00 00 movl $0x9c,(%esp)
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
1183f7: 8d 42 04 lea 0x4(%edx),%eax
1183fa: 89 45 dc mov %eax,-0x24(%ebp)
shared = malloc (sizeof (rtems_rfs_file_shared));
1183fd: b8 01 00 00 00 mov $0x1,%eax
118402: 89 44 24 04 mov %eax,0x4(%esp)
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
118406: 89 55 e4 mov %edx,-0x1c(%ebp)
shared = malloc (sizeof (rtems_rfs_file_shared));
118409: e8 d2 ba ff ff call 113ee0 <calloc>
if (!shared)
11840e: 8b 55 e4 mov -0x1c(%ebp),%edx
118411: 85 c0 test %eax,%eax
shared = malloc (sizeof (rtems_rfs_file_shared));
118413: 89 c3 mov %eax,%ebx
if (!shared)
118415: 0f 84 4e 02 00 00 je 118669 <rtems_rfs_file_open+0x379> <== NEVER TAKEN
11841b: 89 55 e0 mov %edx,-0x20(%ebp)
rc = rtems_rfs_inode_open (fs, ino, &shared->inode, true);
11841e: 8d 43 0c lea 0xc(%ebx),%eax
118421: ba 01 00 00 00 mov $0x1,%edx
118426: 89 45 e4 mov %eax,-0x1c(%ebp)
118429: 89 44 24 08 mov %eax,0x8(%esp)
11842d: 8b 45 08 mov 0x8(%ebp),%eax
118430: 89 54 24 0c mov %edx,0xc(%esp)
118434: 89 74 24 04 mov %esi,0x4(%esp)
118438: 89 04 24 mov %eax,(%esp)
11843b: e8 f0 15 ff ff call 109a30 <rtems_rfs_inode_open>
if (rc > 0)
118440: 8b 55 e0 mov -0x20(%ebp),%edx
118443: 89 45 d8 mov %eax,-0x28(%ebp)
118446: 85 c0 test %eax,%eax
118448: 0f 8f f2 00 00 00 jg 118540 <rtems_rfs_file_open+0x250> <== NEVER TAKEN
11844e: 89 55 e0 mov %edx,-0x20(%ebp)
rc = rtems_rfs_block_map_open (fs, &shared->inode, &shared->map);
118451: 8d 43 34 lea 0x34(%ebx),%eax
118454: 89 44 24 08 mov %eax,0x8(%esp)
118458: 8b 45 e4 mov -0x1c(%ebp),%eax
11845b: 89 44 24 04 mov %eax,0x4(%esp)
11845f: 8b 45 08 mov 0x8(%ebp),%eax
118462: 89 04 24 mov %eax,(%esp)
118465: e8 b6 d4 ff ff call 115920 <rtems_rfs_block_map_open>
if (rc > 0)
11846a: 8b 55 e0 mov -0x20(%ebp),%edx
11846d: 89 45 d8 mov %eax,-0x28(%ebp)
118470: 85 c0 test %eax,%eax
118472: 0f 8f 26 01 00 00 jg 11859e <rtems_rfs_file_open+0x2ae> <== NEVER TAKEN
shared->references = 1;
118478: c7 43 08 01 00 00 00 movl $0x1,0x8(%ebx)
11847f: 8b 4b 18 mov 0x18(%ebx),%ecx
118482: 89 55 e0 mov %edx,-0x20(%ebp)
return rtems_rfs_read_u32 (&handle->node->block_count);
118485: 8b 41 0c mov 0xc(%ecx),%eax
118488: 0f c8 bswap %eax
shared->size.count = rtems_rfs_inode_get_block_count (&shared->inode);
11848a: 89 83 84 00 00 00 mov %eax,0x84(%ebx)
shared->size.offset = rtems_rfs_inode_get_block_offset (&shared->inode);
118490: 0f b7 41 0a movzwl 0xa(%ecx),%eax
118494: 89 c2 mov %eax,%edx
118496: 0f b6 c4 movzbl %ah,%eax
118499: c1 e2 08 shl $0x8,%edx
11849c: 09 d0 or %edx,%eax
11849e: 0f b7 c0 movzwl %ax,%eax
1184a1: 89 83 88 00 00 00 mov %eax,0x88(%ebx)
return rtems_rfs_read_u32 (&handle->node->atime);
1184a7: 8b 41 10 mov 0x10(%ecx),%eax
1184aa: 0f c8 bswap %eax
shared->atime = rtems_rfs_inode_get_atime (&shared->inode);
1184ac: 89 83 8c 00 00 00 mov %eax,0x8c(%ebx)
return rtems_rfs_read_u32 (&handle->node->mtime);
1184b2: 8b 41 14 mov 0x14(%ecx),%eax
1184b5: 0f c8 bswap %eax
shared->mtime = rtems_rfs_inode_get_mtime (&shared->inode);
1184b7: 89 83 90 00 00 00 mov %eax,0x90(%ebx)
return rtems_rfs_read_u32 (&handle->node->ctime);
1184bd: 8b 41 18 mov 0x18(%ecx),%eax
the_node->next = tail;
1184c0: 89 3b mov %edi,(%ebx)
tail->previous = the_node;
1184c2: 8b 4d 08 mov 0x8(%ebp),%ecx
rtems_rfs_inode_unload (fs, &shared->inode, false);
1184c5: 31 ff xor %edi,%edi
1184c7: 0f c8 bswap %eax
shared->ctime = rtems_rfs_inode_get_ctime (&shared->inode);
1184c9: 89 83 94 00 00 00 mov %eax,0x94(%ebx)
shared->fs = fs;
1184cf: 8b 45 08 mov 0x8(%ebp),%eax
1184d2: 89 83 98 00 00 00 mov %eax,0x98(%ebx)
old_last = tail->previous;
1184d8: 8b 40 7c mov 0x7c(%eax),%eax
tail->previous = the_node;
1184db: 89 59 7c mov %ebx,0x7c(%ecx)
old_last->next = the_node;
1184de: 89 18 mov %ebx,(%eax)
the_node->previous = old_last;
1184e0: 89 43 04 mov %eax,0x4(%ebx)
rtems_rfs_inode_unload (fs, &shared->inode, false);
1184e3: 8b 45 e4 mov -0x1c(%ebp),%eax
1184e6: 89 0c 24 mov %ecx,(%esp)
1184e9: 89 7c 24 08 mov %edi,0x8(%esp)
1184ed: 89 44 24 04 mov %eax,0x4(%esp)
1184f1: e8 4a 16 ff ff call 109b40 <rtems_rfs_inode_unload>
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
1184f6: b8 08 00 00 00 mov $0x8,%eax
1184fb: c7 04 24 00 00 00 00 movl $0x0,(%esp)
118502: 89 44 24 04 mov %eax,0x4(%esp)
118506: e8 45 33 ff ff call 10b850 <rtems_rfs_trace>
11850b: 8b 55 e0 mov -0x20(%ebp),%edx
11850e: 84 c0 test %al,%al
118510: 0f 84 7e fe ff ff je 118394 <rtems_rfs_file_open+0xa4> <== ALWAYS TAKEN
printf ("rtems-rfs: file-open: ino=%" PRId32 " share created\n", ino);
118516: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED
11851a: c7 04 24 b4 5b 13 00 movl $0x135bb4,(%esp) <== NOT EXECUTED
118521: 89 55 e4 mov %edx,-0x1c(%ebp) <== NOT EXECUTED
118524: e8 17 9c fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
118529: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED
11852c: e9 63 fe ff ff jmp 118394 <rtems_rfs_file_open+0xa4> <== NOT EXECUTED
118531: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
118538: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11853f: 90 nop <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
118540: c7 04 24 00 00 00 00 movl $0x0,(%esp) <== NOT EXECUTED
118547: b8 08 00 00 00 mov $0x8,%eax <== NOT EXECUTED
11854c: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
118550: 89 55 e4 mov %edx,-0x1c(%ebp) <== NOT EXECUTED
118553: e8 f8 32 ff ff call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
118558: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED
11855b: 8b 4d d8 mov -0x28(%ebp),%ecx <== NOT EXECUTED
11855e: 84 c0 test %al,%al <== NOT EXECUTED
118560: 0f 85 c9 00 00 00 jne 11862f <rtems_rfs_file_open+0x33f> <== NOT EXECUTED
free (shared);
118566: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
118569: 89 4d e0 mov %ecx,-0x20(%ebp) <== NOT EXECUTED
11856c: 89 55 e4 mov %edx,-0x1c(%ebp) <== NOT EXECUTED
11856f: e8 6c 9f fe ff call 1024e0 <free> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
118574: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED
118577: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
11857b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
11857e: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
118581: e8 2a f3 fe ff call 1078b0 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
free (handle);
118586: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED
118589: 89 14 24 mov %edx,(%esp) <== NOT EXECUTED
11858c: e8 4f 9f fe ff call 1024e0 <free> <== NOT EXECUTED
return rc;
118591: 8b 4d e0 mov -0x20(%ebp),%ecx <== NOT EXECUTED
}
118594: 83 c4 2c add $0x2c,%esp <== NOT EXECUTED
118597: 5b pop %ebx <== NOT EXECUTED
118598: 5e pop %esi <== NOT EXECUTED
118599: 89 c8 mov %ecx,%eax <== NOT EXECUTED
11859b: 5f pop %edi <== NOT EXECUTED
11859c: 5d pop %ebp <== NOT EXECUTED
11859d: c3 ret <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
11859e: c7 04 24 00 00 00 00 movl $0x0,(%esp) <== NOT EXECUTED
1185a5: b8 08 00 00 00 mov $0x8,%eax <== NOT EXECUTED
1185aa: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1185ae: e8 9d 32 ff ff call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
1185b3: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED
1185b6: 8b 4d d8 mov -0x28(%ebp),%ecx <== NOT EXECUTED
1185b9: 84 c0 test %al,%al <== NOT EXECUTED
1185bb: 75 45 jne 118602 <rtems_rfs_file_open+0x312> <== NOT EXECUTED
1185bd: 89 4d d8 mov %ecx,-0x28(%ebp) <== NOT EXECUTED
rtems_rfs_inode_close (fs, &shared->inode);
1185c0: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED
1185c3: 89 55 e0 mov %edx,-0x20(%ebp) <== NOT EXECUTED
1185c6: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1185ca: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
1185cd: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
1185d0: e8 6b 16 ff ff call 109c40 <rtems_rfs_inode_close> <== NOT EXECUTED
free (shared);
1185d5: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
1185d8: e8 03 9f fe ff call 1024e0 <free> <== NOT EXECUTED
1185dd: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED
1185e0: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1185e4: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
1185e7: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
1185ea: e8 c1 f2 fe ff call 1078b0 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
free (handle);
1185ef: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED
1185f2: 89 14 24 mov %edx,(%esp) <== NOT EXECUTED
1185f5: e8 e6 9e fe ff call 1024e0 <free> <== NOT EXECUTED
return rc;
1185fa: 8b 4d d8 mov -0x28(%ebp),%ecx <== NOT EXECUTED
1185fd: e9 a1 fd ff ff jmp 1183a3 <rtems_rfs_file_open+0xb3> <== NOT EXECUTED
printf ("rtems-rfs: file-open: block map open failed: %d: %s\n",
118602: 89 0c 24 mov %ecx,(%esp) <== NOT EXECUTED
118605: 89 55 d8 mov %edx,-0x28(%ebp) <== NOT EXECUTED
118608: 89 4d e0 mov %ecx,-0x20(%ebp) <== NOT EXECUTED
11860b: e8 10 2e 01 00 call 12b420 <strerror> <== NOT EXECUTED
118610: 8b 4d e0 mov -0x20(%ebp),%ecx <== NOT EXECUTED
118613: c7 04 24 7c 5b 13 00 movl $0x135b7c,(%esp) <== NOT EXECUTED
11861a: 89 4c 24 04 mov %ecx,0x4(%esp) <== NOT EXECUTED
11861e: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
118622: e8 19 9b fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
118627: 8b 55 d8 mov -0x28(%ebp),%edx <== NOT EXECUTED
11862a: 8b 4d e0 mov -0x20(%ebp),%ecx <== NOT EXECUTED
11862d: eb 8e jmp 1185bd <rtems_rfs_file_open+0x2cd> <== NOT EXECUTED
printf ("rtems-rfs: file-open: inode open failed: %d: %s\n",
11862f: 89 0c 24 mov %ecx,(%esp) <== NOT EXECUTED
118632: 89 55 e0 mov %edx,-0x20(%ebp) <== NOT EXECUTED
118635: 89 4d e4 mov %ecx,-0x1c(%ebp) <== NOT EXECUTED
118638: e8 e3 2d 01 00 call 12b420 <strerror> <== NOT EXECUTED
11863d: 8b 4d e4 mov -0x1c(%ebp),%ecx <== NOT EXECUTED
118640: c7 04 24 48 5b 13 00 movl $0x135b48,(%esp) <== NOT EXECUTED
118647: 89 4c 24 04 mov %ecx,0x4(%esp) <== NOT EXECUTED
11864b: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
11864f: e8 ec 9a fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
118654: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED
118657: 8b 4d e4 mov -0x1c(%ebp),%ecx <== NOT EXECUTED
11865a: e9 07 ff ff ff jmp 118566 <rtems_rfs_file_open+0x276> <== NOT EXECUTED
return ENOMEM;
11865f: b9 0c 00 00 00 mov $0xc,%ecx <== NOT EXECUTED
118664: e9 3a fd ff ff jmp 1183a3 <rtems_rfs_file_open+0xb3> <== NOT EXECUTED
118669: 89 55 e4 mov %edx,-0x1c(%ebp) <== NOT EXECUTED
11866c: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED
11866f: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
118673: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
118676: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
118679: e8 32 f2 fe ff call 1078b0 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
free (handle);
11867e: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED
118681: 89 14 24 mov %edx,(%esp) <== NOT EXECUTED
118684: e8 57 9e fe ff call 1024e0 <free> <== NOT EXECUTED
return ENOMEM;
118689: b9 0c 00 00 00 mov $0xc,%ecx <== NOT EXECUTED
11868e: e9 10 fd ff ff jmp 1183a3 <rtems_rfs_file_open+0xb3> <== NOT EXECUTED
118693: 90 nop
118694: 90 nop
118695: 90 nop
118696: 90 nop
118697: 90 nop
118698: 90 nop
118699: 90 nop
11869a: 90 nop
11869b: 90 nop
11869c: 90 nop
11869d: 90 nop
11869e: 90 nop
11869f: 90 nop
00119060 <rtems_rfs_file_seek>:
{
119060: 55 push %ebp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
119061: b9 20 00 00 00 mov $0x20,%ecx
{
119066: 89 e5 mov %esp,%ebp
119068: 83 ec 48 sub $0x48,%esp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
11906b: c7 04 24 00 00 00 00 movl $0x0,(%esp)
119072: 89 4c 24 04 mov %ecx,0x4(%esp)
{
119076: 89 5d f4 mov %ebx,-0xc(%ebp)
119079: 8b 5d 10 mov 0x10(%ebp),%ebx
11907c: 89 75 f8 mov %esi,-0x8(%ebp)
11907f: 8b 75 0c mov 0xc(%ebp),%esi
119082: 89 7d fc mov %edi,-0x4(%ebp)
119085: 8b 7d 08 mov 0x8(%ebp),%edi
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
119088: e8 c3 27 ff ff call 10b850 <rtems_rfs_trace>
11908d: 84 c0 test %al,%al
11908f: 0f 85 cb 00 00 00 jne 119160 <rtems_rfs_file_seek+0x100> <== NEVER TAKEN
if (pos <= rtems_rfs_file_shared_get_size (rtems_rfs_file_fs (handle),
119095: 8b 47 1c mov 0x1c(%edi),%eax
119098: 8d 90 84 00 00 00 lea 0x84(%eax),%edx
11909e: 89 54 24 04 mov %edx,0x4(%esp)
1190a2: 8b 80 98 00 00 00 mov 0x98(%eax),%eax
1190a8: 89 04 24 mov %eax,(%esp)
1190ab: e8 20 c8 ff ff call 1158d0 <rtems_rfs_block_get_size>
1190b0: 39 f0 cmp %esi,%eax
1190b2: 19 da sbb %ebx,%edx
1190b4: 73 3a jae 1190f0 <rtems_rfs_file_seek+0x90>
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
1190b6: 8b 47 0c mov 0xc(%edi),%eax
1190b9: 85 c0 test %eax,%eax
1190bb: 74 1c je 1190d9 <rtems_rfs_file_seek+0x79> <== ALWAYS TAKEN
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
1190bd: 8d 47 04 lea 0x4(%edi),%eax <== NOT EXECUTED
1190c0: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1190c4: 8b 47 1c mov 0x1c(%edi),%eax <== NOT EXECUTED
1190c7: 8b 80 98 00 00 00 mov 0x98(%eax),%eax <== NOT EXECUTED
1190cd: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
1190d0: e8 db e7 fe ff call 1078b0 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
if (rc > 0)
1190d5: 85 c0 test %eax,%eax <== NOT EXECUTED
1190d7: 7f 0a jg 1190e3 <rtems_rfs_file_seek+0x83> <== NOT EXECUTED
*new_pos = pos;
1190d9: 8b 45 14 mov 0x14(%ebp),%eax
1190dc: 89 30 mov %esi,(%eax)
1190de: 89 58 04 mov %ebx,0x4(%eax)
return 0;
1190e1: 31 c0 xor %eax,%eax
}
1190e3: 8b 5d f4 mov -0xc(%ebp),%ebx
1190e6: 8b 75 f8 mov -0x8(%ebp),%esi
1190e9: 8b 7d fc mov -0x4(%ebp),%edi
1190ec: 89 ec mov %ebp,%esp
1190ee: 5d pop %ebp
1190ef: c3 ret
rtems_rfs_file_set_bpos (handle, pos);
1190f0: 89 74 24 04 mov %esi,0x4(%esp)
1190f4: 8d 47 10 lea 0x10(%edi),%eax
1190f7: 89 44 24 0c mov %eax,0xc(%esp)
1190fb: 89 5c 24 08 mov %ebx,0x8(%esp)
1190ff: 89 45 d4 mov %eax,-0x2c(%ebp)
119102: 8b 57 1c mov 0x1c(%edi),%edx
119105: 8b 92 98 00 00 00 mov 0x98(%edx),%edx
11910b: 89 14 24 mov %edx,(%esp)
11910e: e8 4d c7 ff ff call 115860 <rtems_rfs_block_get_bpos>
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
119113: 8b 57 0c mov 0xc(%edi),%edx
119116: 85 d2 test %edx,%edx
119118: 74 bf je 1190d9 <rtems_rfs_file_seek+0x79>
rtems_rfs_file_map (handle),
11911a: 8b 57 1c mov 0x1c(%edi),%edx
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
11911d: 8d 4d e4 lea -0x1c(%ebp),%ecx
119120: 89 4c 24 0c mov %ecx,0xc(%esp)
119124: 8b 45 d4 mov -0x2c(%ebp),%eax
119127: 89 44 24 08 mov %eax,0x8(%esp)
11912b: 8d 42 34 lea 0x34(%edx),%eax
11912e: 89 44 24 04 mov %eax,0x4(%esp)
119132: 8b 82 98 00 00 00 mov 0x98(%edx),%eax
119138: 89 04 24 mov %eax,(%esp)
11913b: e8 b0 ca ff ff call 115bf0 <rtems_rfs_block_map_find>
if (rc > 0)
119140: 85 c0 test %eax,%eax
119142: 7f 9f jg 1190e3 <rtems_rfs_file_seek+0x83> <== NEVER TAKEN
if (rtems_rfs_buffer_bnum (&handle->buffer) != block)
119144: 8b 45 e4 mov -0x1c(%ebp),%eax
119147: 39 47 08 cmp %eax,0x8(%edi)
11914a: 74 8d je 1190d9 <rtems_rfs_file_seek+0x79> <== ALWAYS TAKEN
11914c: e9 6c ff ff ff jmp 1190bd <rtems_rfs_file_seek+0x5d> <== NOT EXECUTED
119151: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
119158: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11915f: 90 nop <== NOT EXECUTED
printf ("rtems-rfs: file-seek: new=%" PRIu64 "\n", pos);
119160: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED
119164: 89 5c 24 08 mov %ebx,0x8(%esp) <== NOT EXECUTED
119168: c7 04 24 fc 5d 13 00 movl $0x135dfc,(%esp) <== NOT EXECUTED
11916f: e8 cc 8f fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
119174: e9 1c ff ff ff jmp 119095 <rtems_rfs_file_seek+0x35> <== NOT EXECUTED
119179: 90 nop
11917a: 90 nop
11917b: 90 nop
11917c: 90 nop
11917d: 90 nop
11917e: 90 nop
11917f: 90 nop
00119180 <rtems_rfs_file_set_size>:
{
119180: 55 push %ebp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
119181: b9 20 00 00 00 mov $0x20,%ecx
{
119186: 89 e5 mov %esp,%ebp
119188: 57 push %edi
119189: 56 push %esi
11918a: 53 push %ebx
11918b: 83 ec 5c sub $0x5c,%esp
11918e: 8b 45 0c mov 0xc(%ebp),%eax
119191: 8b 5d 08 mov 0x8(%ebp),%ebx
119194: 8b 55 10 mov 0x10(%ebp),%edx
119197: 89 45 d0 mov %eax,-0x30(%ebp)
rtems_rfs_block_map* map = rtems_rfs_file_map (handle);
11919a: 8b 43 1c mov 0x1c(%ebx),%eax
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
11919d: c7 04 24 00 00 00 00 movl $0x0,(%esp)
1191a4: 89 4c 24 04 mov %ecx,0x4(%esp)
{
1191a8: 89 55 d4 mov %edx,-0x2c(%ebp)
rtems_rfs_block_map* map = rtems_rfs_file_map (handle);
1191ab: 89 45 bc mov %eax,-0x44(%ebp)
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
1191ae: e8 9d 26 ff ff call 10b850 <rtems_rfs_trace>
1191b3: 84 c0 test %al,%al
1191b5: 0f 85 e5 02 00 00 jne 1194a0 <rtems_rfs_file_set_size+0x320> <== NEVER TAKEN
size = rtems_rfs_file_size (handle);
1191bb: 8b 43 1c mov 0x1c(%ebx),%eax
1191be: 8d 90 84 00 00 00 lea 0x84(%eax),%edx
1191c4: 89 54 24 04 mov %edx,0x4(%esp)
1191c8: 8b 80 98 00 00 00 mov 0x98(%eax),%eax
1191ce: 89 04 24 mov %eax,(%esp)
1191d1: e8 fa c6 ff ff call 1158d0 <rtems_rfs_block_get_size>
if (size != new_size)
1191d6: 8b 4d d4 mov -0x2c(%ebp),%ecx
1191d9: 89 d7 mov %edx,%edi
1191db: 8b 55 d0 mov -0x30(%ebp),%edx
1191de: 89 c6 mov %eax,%esi
1191e0: 89 75 c0 mov %esi,-0x40(%ebp)
1191e3: 89 7d c4 mov %edi,-0x3c(%ebp)
1191e6: 8b 75 c4 mov -0x3c(%ebp),%esi
1191e9: 89 d0 mov %edx,%eax
1191eb: 8b 55 c0 mov -0x40(%ebp),%edx
1191ee: 31 ce xor %ecx,%esi
1191f0: 31 d0 xor %edx,%eax
1191f2: 09 c6 or %eax,%esi
1191f4: 0f 84 1c 02 00 00 je 119416 <rtems_rfs_file_set_size+0x296>
rtems_rfs_block_map* map = rtems_rfs_file_map (handle);
1191fa: 8b 45 bc mov -0x44(%ebp),%eax
if (new_size == 0)
1191fd: 8b 7d d4 mov -0x2c(%ebp),%edi
119200: 8b 75 d0 mov -0x30(%ebp),%esi
rtems_rfs_block_map* map = rtems_rfs_file_map (handle);
119203: 83 c0 34 add $0x34,%eax
119206: 89 45 c8 mov %eax,-0x38(%ebp)
rc = rtems_rfs_block_map_free_all (rtems_rfs_file_fs (handle), map);
119209: 8b 43 1c mov 0x1c(%ebx),%eax
if (new_size == 0)
11920c: 89 fa mov %edi,%edx
11920e: 09 f2 or %esi,%edx
rc = rtems_rfs_block_map_free_all (rtems_rfs_file_fs (handle), map);
119210: 89 45 b4 mov %eax,-0x4c(%ebp)
119213: 8b 88 98 00 00 00 mov 0x98(%eax),%ecx
if (new_size == 0)
119219: 0f 84 c1 01 00 00 je 1193e0 <rtems_rfs_file_set_size+0x260>
rtems_rfs_block_map_count (map) -
11921f: 8b 7d bc mov -0x44(%ebp),%edi
if (size < new_size)
119222: 8b 55 d4 mov -0x2c(%ebp),%edx
119225: 8b 75 c4 mov -0x3c(%ebp),%esi
rtems_rfs_block_map_count (map) -
119228: 8b 47 3c mov 0x3c(%edi),%eax
11922b: 89 45 b8 mov %eax,-0x48(%ebp)
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
11922e: 8b 41 08 mov 0x8(%ecx),%eax
119231: 89 45 cc mov %eax,-0x34(%ebp)
if (size < new_size)
119234: 8b 45 d0 mov -0x30(%ebp),%eax
119237: 39 45 c0 cmp %eax,-0x40(%ebp)
11923a: 19 d6 sbb %edx,%esi
11923c: 0f 83 7e 02 00 00 jae 1194c0 <rtems_rfs_file_set_size+0x340>
count = new_size - size;
119242: 2b 45 c0 sub -0x40(%ebp),%eax
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
119245: 89 fe mov %edi,%esi
read_block = false;
119247: c6 45 bc 00 movb $0x0,-0x44(%ebp)
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
11924b: 8b 7d b8 mov -0x48(%ebp),%edi
count = new_size - size;
11924e: 1b 55 c4 sbb -0x3c(%ebp),%edx
119251: 89 45 d0 mov %eax,-0x30(%ebp)
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
119254: 8d 43 04 lea 0x4(%ebx),%eax
119257: 89 45 c0 mov %eax,-0x40(%ebp)
count = new_size - size;
11925a: 89 55 d4 mov %edx,-0x2c(%ebp)
while (count)
11925d: e9 dd 00 00 00 jmp 11933f <rtems_rfs_file_set_size+0x1bf>
119262: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
119269: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
119270: c6 46 34 01 movb $0x1,0x34(%esi)
length = count + bpos.boff;
119274: 8b 45 d0 mov -0x30(%ebp),%eax
read_block = true;
119277: c6 45 bc 01 movb $0x1,-0x44(%ebp)
length = count + bpos.boff;
11927b: 01 c7 add %eax,%edi
}
11927d: b8 01 00 00 00 mov $0x1,%eax
119282: 89 7d cc mov %edi,-0x34(%ebp)
map->size.offset = offset;
119285: 89 7e 40 mov %edi,0x40(%esi)
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
119288: 89 44 24 0c mov %eax,0xc(%esp)
11928c: 8b 45 d8 mov -0x28(%ebp),%eax
11928f: 89 44 24 08 mov %eax,0x8(%esp)
119293: 8b 45 c0 mov -0x40(%ebp),%eax
119296: 89 44 24 04 mov %eax,0x4(%esp)
11929a: 8b 43 1c mov 0x1c(%ebx),%eax
11929d: 8b 80 98 00 00 00 mov 0x98(%eax),%eax
1192a3: 89 04 24 mov %eax,(%esp)
1192a6: e8 25 e3 fe ff call 1075d0 <rtems_rfs_buffer_handle_request>
if (rc > 0)
1192ab: 85 c0 test %eax,%eax
1192ad: 0f 8f 1d 03 00 00 jg 1195d0 <rtems_rfs_file_set_size+0x450> <== NEVER TAKEN
dst = rtems_rfs_buffer_data (&handle->buffer);
1192b3: 8b 53 0c mov 0xc(%ebx),%edx
memset (dst + bpos.boff, 0, length - bpos.boff);
1192b6: 8b 45 e0 mov -0x20(%ebp),%eax
1192b9: 8b 4a 1c mov 0x1c(%edx),%ecx
1192bc: 8b 55 cc mov -0x34(%ebp),%edx
1192bf: 01 c1 add %eax,%ecx
1192c1: 29 c2 sub %eax,%edx
1192c3: 89 cf mov %ecx,%edi
1192c5: 83 fa 08 cmp $0x8,%edx
1192c8: 0f 83 92 01 00 00 jae 119460 <rtems_rfs_file_set_size+0x2e0>
1192ce: f6 c2 04 test $0x4,%dl
1192d1: 74 09 je 1192dc <rtems_rfs_file_set_size+0x15c> <== ALWAYS TAKEN
1192d3: c7 07 00 00 00 00 movl $0x0,(%edi) <== NOT EXECUTED
1192d9: 83 c7 04 add $0x4,%edi <== NOT EXECUTED
1192dc: f6 c2 02 test $0x2,%dl
1192df: 74 08 je 1192e9 <rtems_rfs_file_set_size+0x169>
1192e1: 66 c7 07 00 00 movw $0x0,(%edi)
1192e6: 83 c7 02 add $0x2,%edi
1192e9: f6 c2 01 test $0x1,%dl
1192ec: 74 03 je 1192f1 <rtems_rfs_file_set_size+0x171>
1192ee: c6 07 00 movb $0x0,(%edi)
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
1192f1: c6 43 04 01 movb $0x1,0x4(%ebx)
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
1192f5: 8b 45 c0 mov -0x40(%ebp),%eax
1192f8: 89 44 24 04 mov %eax,0x4(%esp)
1192fc: 8b 43 1c mov 0x1c(%ebx),%eax
1192ff: 8b 80 98 00 00 00 mov 0x98(%eax),%eax
119305: 89 04 24 mov %eax,(%esp)
119308: e8 a3 e5 fe ff call 1078b0 <rtems_rfs_buffer_handle_release>
if (rc > 0)
11930d: 85 c0 test %eax,%eax
11930f: 0f 8f bb 02 00 00 jg 1195d0 <rtems_rfs_file_set_size+0x450> <== NEVER TAKEN
count -= length - bpos.boff;
119315: 8b 7d e0 mov -0x20(%ebp),%edi
119318: 31 d2 xor %edx,%edx
11931a: 8b 45 cc mov -0x34(%ebp),%eax
11931d: 29 f8 sub %edi,%eax
handle->shared->size.count = rtems_rfs_block_map_count (map);
11931f: 8b 7e 3c mov 0x3c(%esi),%edi
count -= length - bpos.boff;
119322: 29 45 d0 sub %eax,-0x30(%ebp)
handle->shared->size.count = rtems_rfs_block_map_count (map);
119325: 8b 43 1c mov 0x1c(%ebx),%eax
count -= length - bpos.boff;
119328: 19 55 d4 sbb %edx,-0x2c(%ebp)
11932b: 8b 55 d0 mov -0x30(%ebp),%edx
while (count)
11932e: 8b 4d d4 mov -0x2c(%ebp),%ecx
119331: 09 d1 or %edx,%ecx
119333: 0f 84 e7 02 00 00 je 119620 <rtems_rfs_file_set_size+0x4a0>
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
119339: 8b 88 98 00 00 00 mov 0x98(%eax),%ecx
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map), &bpos);
11933f: 89 7d dc mov %edi,-0x24(%ebp)
119342: 8b 46 40 mov 0x40(%esi),%eax
119345: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
11934c: 89 45 e0 mov %eax,-0x20(%ebp)
11934f: 85 c0 test %eax,%eax
119351: 74 04 je 119357 <rtems_rfs_file_set_size+0x1d7>
119353: 4f dec %edi
119354: 89 7d dc mov %edi,-0x24(%ebp)
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
119357: 89 0c 24 mov %ecx,(%esp)
11935a: 8d 45 d8 lea -0x28(%ebp),%eax
11935d: 89 44 24 0c mov %eax,0xc(%esp)
119361: 8d 45 dc lea -0x24(%ebp),%eax
119364: 89 44 24 08 mov %eax,0x8(%esp)
119368: 8b 45 c8 mov -0x38(%ebp),%eax
11936b: 89 44 24 04 mov %eax,0x4(%esp)
11936f: e8 7c c8 ff ff call 115bf0 <rtems_rfs_block_map_find>
if (rc > 0)
119374: 85 c0 test %eax,%eax
119376: 7e 39 jle 1193b1 <rtems_rfs_file_set_size+0x231>
if (rc != ENXIO)
119378: 83 f8 06 cmp $0x6,%eax
11937b: 0f 85 4f 02 00 00 jne 1195d0 <rtems_rfs_file_set_size+0x450> <== NEVER TAKEN
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
119381: 8d 45 d8 lea -0x28(%ebp),%eax
119384: 89 44 24 0c mov %eax,0xc(%esp)
119388: b8 01 00 00 00 mov $0x1,%eax
11938d: 89 44 24 08 mov %eax,0x8(%esp)
119391: 8b 45 c8 mov -0x38(%ebp),%eax
119394: 89 44 24 04 mov %eax,0x4(%esp)
119398: 8b 43 1c mov 0x1c(%ebx),%eax
11939b: 8b 80 98 00 00 00 mov 0x98(%eax),%eax
1193a1: 89 04 24 mov %eax,(%esp)
1193a4: e8 57 ca ff ff call 115e00 <rtems_rfs_block_map_grow>
if (rc > 0)
1193a9: 85 c0 test %eax,%eax
1193ab: 0f 8f 1f 02 00 00 jg 1195d0 <rtems_rfs_file_set_size+0x450> <== NEVER TAKEN
if (count < (length - bpos.boff))
1193b1: 8b 7d e0 mov -0x20(%ebp),%edi
1193b4: 31 d2 xor %edx,%edx
1193b6: 8b 4d cc mov -0x34(%ebp),%ecx
1193b9: 29 f9 sub %edi,%ecx
1193bb: 39 4d d0 cmp %ecx,-0x30(%ebp)
1193be: 8b 4d d4 mov -0x2c(%ebp),%ecx
1193c1: 19 d1 sbb %edx,%ecx
1193c3: 0f 82 a7 fe ff ff jb 119270 <rtems_rfs_file_set_size+0xf0>
1193c9: c7 46 40 00 00 00 00 movl $0x0,0x40(%esi)
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
1193d0: 0f b6 45 bc movzbl -0x44(%ebp),%eax
map->dirty = true;
1193d4: c6 46 34 01 movb $0x1,0x34(%esi)
}
1193d8: e9 ab fe ff ff jmp 119288 <rtems_rfs_file_set_size+0x108>
1193dd: 8d 76 00 lea 0x0(%esi),%esi
rc = rtems_rfs_block_map_free_all (rtems_rfs_file_fs (handle), map);
1193e0: 89 0c 24 mov %ecx,(%esp)
1193e3: 8b 45 c8 mov -0x38(%ebp),%eax
1193e6: 89 44 24 04 mov %eax,0x4(%esp)
1193ea: e8 a1 d0 ff ff call 116490 <rtems_rfs_block_map_free_all>
if (rc > 0)
1193ef: 85 c0 test %eax,%eax
rc = rtems_rfs_block_map_free_all (rtems_rfs_file_fs (handle), map);
1193f1: 89 c7 mov %eax,%edi
if (rc > 0)
1193f3: 7f 2a jg 11941f <rtems_rfs_file_set_size+0x29f> <== NEVER TAKEN
handle->shared->size.count = rtems_rfs_block_map_count (map);
1193f5: 8b 75 bc mov -0x44(%ebp),%esi
1193f8: 8b 43 1c mov 0x1c(%ebx),%eax
1193fb: 8b 76 3c mov 0x3c(%esi),%esi
1193fe: 89 75 b8 mov %esi,-0x48(%ebp)
119401: 8b 75 b8 mov -0x48(%ebp),%esi
119404: 89 b0 84 00 00 00 mov %esi,0x84(%eax)
handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
11940a: 8b 75 bc mov -0x44(%ebp),%esi
11940d: 8b 56 40 mov 0x40(%esi),%edx
119410: 89 90 88 00 00 00 mov %edx,0x88(%eax)
if (rtems_rfs_file_update_mtime (handle))
119416: 8b 3b mov (%ebx),%edi
119418: 83 e7 02 and $0x2,%edi
11941b: 74 13 je 119430 <rtems_rfs_file_set_size+0x2b0> <== ALWAYS TAKEN
return 0;
11941d: 31 ff xor %edi,%edi <== NOT EXECUTED
}
11941f: 83 c4 5c add $0x5c,%esp <== NOT EXECUTED
119422: 89 f8 mov %edi,%eax <== NOT EXECUTED
119424: 5b pop %ebx <== NOT EXECUTED
119425: 5e pop %esi <== NOT EXECUTED
119426: 5f pop %edi <== NOT EXECUTED
119427: 5d pop %ebp <== NOT EXECUTED
119428: c3 ret <== NOT EXECUTED
119429: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
handle->shared->mtime = time (NULL);
119430: c7 04 24 00 00 00 00 movl $0x0,(%esp)
119437: e8 14 5a 01 00 call 12ee50 <time>
11943c: 89 c2 mov %eax,%edx
11943e: 8b 43 1c mov 0x1c(%ebx),%eax
119441: 89 90 90 00 00 00 mov %edx,0x90(%eax)
}
119447: 83 c4 5c add $0x5c,%esp
11944a: 89 f8 mov %edi,%eax
11944c: 5b pop %ebx
11944d: 5e pop %esi
11944e: 5f pop %edi
11944f: 5d pop %ebp
119450: c3 ret
119451: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
119458: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11945f: 90 nop
memset (dst + bpos.boff, 0, length - bpos.boff);
119460: f6 c1 01 test $0x1,%cl
119463: 0f 85 77 01 00 00 jne 1195e0 <rtems_rfs_file_set_size+0x460>
119469: f7 c7 02 00 00 00 test $0x2,%edi
11946f: 0f 85 9b 01 00 00 jne 119610 <rtems_rfs_file_set_size+0x490>
119475: f7 c7 04 00 00 00 test $0x4,%edi
11947b: 0f 85 6f 01 00 00 jne 1195f0 <rtems_rfs_file_set_size+0x470>
119481: 89 d1 mov %edx,%ecx
119483: 31 c0 xor %eax,%eax
119485: c1 e9 02 shr $0x2,%ecx
119488: 83 e2 03 and $0x3,%edx
11948b: f3 ab rep stos %eax,%es:(%edi)
11948d: e9 3c fe ff ff jmp 1192ce <rtems_rfs_file_set_size+0x14e>
119492: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
119499: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
printf ("rtems-rfs: file-set-size: size=%" PRIu64 "\n", new_size);
1194a0: c7 04 24 1c 5e 13 00 movl $0x135e1c,(%esp) <== NOT EXECUTED
1194a7: 8b 45 d0 mov -0x30(%ebp),%eax <== NOT EXECUTED
1194aa: 8b 55 d4 mov -0x2c(%ebp),%edx <== NOT EXECUTED
1194ad: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1194b1: 89 54 24 08 mov %edx,0x8(%esp) <== NOT EXECUTED
1194b5: e8 86 8c fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
1194ba: e9 fc fc ff ff jmp 1191bb <rtems_rfs_file_set_size+0x3b> <== NOT EXECUTED
1194bf: 90 nop <== NOT EXECUTED
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1);
1194c0: 8b 45 cc mov -0x34(%ebp),%eax
1194c3: 31 ff xor %edi,%edi
(((new_size - 1) /
1194c5: 89 7c 24 0c mov %edi,0xc(%esp)
1194c9: 8b 55 d4 mov -0x2c(%ebp),%edx
1194cc: 89 4d c8 mov %ecx,-0x38(%ebp)
1194cf: 89 7d c4 mov %edi,-0x3c(%ebp)
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1);
1194d2: 89 c6 mov %eax,%esi
blocks =
1194d4: 8b 45 b8 mov -0x48(%ebp),%eax
(((new_size - 1) /
1194d7: 89 74 24 08 mov %esi,0x8(%esp)
1194db: 89 75 c0 mov %esi,-0x40(%ebp)
blocks =
1194de: 48 dec %eax
1194df: 89 45 cc mov %eax,-0x34(%ebp)
(((new_size - 1) /
1194e2: 8b 45 d0 mov -0x30(%ebp),%eax
1194e5: 83 c0 ff add $0xffffffff,%eax
1194e8: 89 04 24 mov %eax,(%esp)
1194eb: 83 d2 ff adc $0xffffffff,%edx
1194ee: 89 54 24 04 mov %edx,0x4(%esp)
1194f2: e8 69 fd 00 00 call 129260 <__udivdi3>
blocks =
1194f7: 8b 7d cc mov -0x34(%ebp),%edi
new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
1194fa: 8b 75 c0 mov -0x40(%ebp),%esi
1194fd: 8b 55 d4 mov -0x2c(%ebp),%edx
119500: 89 74 24 08 mov %esi,0x8(%esp)
119504: 89 54 24 04 mov %edx,0x4(%esp)
blocks =
119508: 29 c7 sub %eax,%edi
new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
11950a: 8b 45 d0 mov -0x30(%ebp),%eax
blocks =
11950d: 89 7d cc mov %edi,-0x34(%ebp)
new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
119510: 8b 7d c4 mov -0x3c(%ebp),%edi
119513: 89 04 24 mov %eax,(%esp)
119516: 89 7c 24 0c mov %edi,0xc(%esp)
11951a: e8 61 fe 00 00 call 129380 <__umoddi3>
if (blocks)
11951f: 8b 75 cc mov -0x34(%ebp),%esi
119522: 8b 4d c8 mov -0x38(%ebp),%ecx
119525: 85 f6 test %esi,%esi
new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
119527: 89 c2 mov %eax,%edx
if (blocks)
119529: 75 45 jne 119570 <rtems_rfs_file_set_size+0x3f0>
map->size.offset = offset;
11952b: 8b 45 bc mov -0x44(%ebp),%eax
11952e: 89 50 40 mov %edx,0x40(%eax)
map->dirty = true;
119531: c6 40 34 01 movb $0x1,0x34(%eax)
if (rtems_rfs_block_pos_past_end (rtems_rfs_file_bpos (handle),
119535: 8b 43 10 mov 0x10(%ebx),%eax
119538: 85 c0 test %eax,%eax
11953a: 74 74 je 1195b0 <rtems_rfs_file_set_size+0x430>
11953c: 8b 4d b8 mov -0x48(%ebp),%ecx
11953f: 85 c9 test %ecx,%ecx
119541: 75 6d jne 1195b0 <rtems_rfs_file_set_size+0x430> <== ALWAYS TAKEN
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map),
119543: 8b 75 b8 mov -0x48(%ebp),%esi
119546: 85 d2 test %edx,%edx
119548: 89 53 14 mov %edx,0x14(%ebx)
handle->shared->size.count = rtems_rfs_block_map_count (map);
11954b: 8b 45 b4 mov -0x4c(%ebp),%eax
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map),
11954e: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx)
119555: 89 73 10 mov %esi,0x10(%ebx)
119558: 0f 84 a3 fe ff ff je 119401 <rtems_rfs_file_set_size+0x281> <== NEVER TAKEN
11955e: 8d 56 ff lea -0x1(%esi),%edx
119561: 89 53 10 mov %edx,0x10(%ebx)
119564: e9 98 fe ff ff jmp 119401 <rtems_rfs_file_set_size+0x281>
119569: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
119570: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED
rc = rtems_rfs_block_map_shrink (rtems_rfs_file_fs (handle),
119573: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED
119576: 89 0c 24 mov %ecx,(%esp) <== NOT EXECUTED
119579: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
11957d: 8b 45 b4 mov -0x4c(%ebp),%eax <== NOT EXECUTED
119580: 83 c0 34 add $0x34,%eax <== NOT EXECUTED
119583: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
119587: e8 24 cc ff ff call 1161b0 <rtems_rfs_block_map_shrink> <== NOT EXECUTED
if (rc > 0)
11958c: 85 c0 test %eax,%eax
rc = rtems_rfs_block_map_shrink (rtems_rfs_file_fs (handle),
11958e: 89 c7 mov %eax,%edi
if (rc > 0)
119590: 0f 8f 89 fe ff ff jg 11941f <rtems_rfs_file_set_size+0x29f> <== NEVER TAKEN
if (rtems_rfs_block_pos_past_end (rtems_rfs_file_bpos (handle),
119596: 8b 45 bc mov -0x44(%ebp),%eax
119599: 8b 55 d0 mov -0x30(%ebp),%edx
11959c: 8b 40 3c mov 0x3c(%eax),%eax
11959f: 89 45 b8 mov %eax,-0x48(%ebp)
1195a2: 8b 43 1c mov 0x1c(%ebx),%eax
1195a5: 89 45 b4 mov %eax,-0x4c(%ebp)
1195a8: eb 81 jmp 11952b <rtems_rfs_file_set_size+0x3ab>
1195aa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
1195b0: 8b 75 b8 mov -0x48(%ebp),%esi
1195b3: 39 f0 cmp %esi,%eax
1195b5: 73 8c jae 119543 <rtems_rfs_file_set_size+0x3c3> <== NEVER TAKEN
1195b7: 8d 4e ff lea -0x1(%esi),%ecx
1195ba: 39 c8 cmp %ecx,%eax
1195bc: 74 6d je 11962b <rtems_rfs_file_set_size+0x4ab> <== ALWAYS TAKEN
handle->shared->size.count = rtems_rfs_block_map_count (map);
1195be: 8b 45 b4 mov -0x4c(%ebp),%eax
1195c1: e9 3b fe ff ff jmp 119401 <rtems_rfs_file_set_size+0x281>
1195c6: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1195cd: 8d 76 00 lea 0x0(%esi),%esi
}
1195d0: 83 c4 5c add $0x5c,%esp <== NOT EXECUTED
1195d3: 89 c7 mov %eax,%edi <== NOT EXECUTED
1195d5: 5b pop %ebx <== NOT EXECUTED
1195d6: 89 f8 mov %edi,%eax <== NOT EXECUTED
1195d8: 5e pop %esi <== NOT EXECUTED
1195d9: 5f pop %edi <== NOT EXECUTED
1195da: 5d pop %ebp <== NOT EXECUTED
1195db: c3 ret <== NOT EXECUTED
1195dc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
memset (dst + bpos.boff, 0, length - bpos.boff);
1195e0: c6 01 00 movb $0x0,(%ecx)
1195e3: 47 inc %edi
1195e4: 4a dec %edx
1195e5: e9 7f fe ff ff jmp 119469 <rtems_rfs_file_set_size+0x2e9>
1195ea: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
1195f0: c7 07 00 00 00 00 movl $0x0,(%edi)
1195f6: 83 ea 04 sub $0x4,%edx
1195f9: 83 c7 04 add $0x4,%edi
1195fc: e9 80 fe ff ff jmp 119481 <rtems_rfs_file_set_size+0x301>
119601: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
119608: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11960f: 90 nop
119610: 66 c7 07 00 00 movw $0x0,(%edi)
119615: 83 ea 02 sub $0x2,%edx
119618: 83 c7 02 add $0x2,%edi
11961b: e9 55 fe ff ff jmp 119475 <rtems_rfs_file_set_size+0x2f5>
119620: 89 75 bc mov %esi,-0x44(%ebp)
119623: 89 7d b8 mov %edi,-0x48(%ebp)
119626: e9 d6 fd ff ff jmp 119401 <rtems_rfs_file_set_size+0x281>
if (rtems_rfs_block_pos_past_end (rtems_rfs_file_bpos (handle),
11962b: 39 53 14 cmp %edx,0x14(%ebx)
11962e: 0f 87 0f ff ff ff ja 119543 <rtems_rfs_file_set_size+0x3c3>
119634: eb 88 jmp 1195be <rtems_rfs_file_set_size+0x43e>
119636: 90 nop
119637: 90 nop
119638: 90 nop
119639: 90 nop
11963a: 90 nop
11963b: 90 nop
11963c: 90 nop
11963d: 90 nop
11963e: 90 nop
11963f: 90 nop
00107e60 <rtems_rfs_format>:
return 0;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
{
107e60: 55 push %ebp
107e61: 89 e5 mov %esp,%ebp
107e63: 57 push %edi
107e64: 56 push %esi
107e65: 53 push %ebx
107e66: 81 ec 0c 01 00 00 sub $0x10c,%esp
rtems_rfs_file_system fs;
int group;
int rc;
if (config->verbose)
107e6c: 8b 45 0c mov 0xc(%ebp),%eax
107e6f: 80 78 15 00 cmpb $0x0,0x15(%eax)
107e73: 0f 85 87 06 00 00 jne 108500 <rtems_rfs_format+0x6a0> <== NEVER TAKEN
printf ("rtems-rfs: format: %s\n", name);
memset (&fs, 0, sizeof (rtems_rfs_file_system));
107e79: 31 d2 xor %edx,%edx
107e7b: 31 c0 xor %eax,%eax
107e7d: 89 94 05 68 ff ff ff mov %edx,-0x98(%ebp,%eax,1)
107e84: 89 94 05 6c ff ff ff mov %edx,-0x94(%ebp,%eax,1)
107e8b: 83 c0 08 add $0x8,%eax
107e8e: 3d 80 00 00 00 cmp $0x80,%eax
107e93: 72 e8 jb 107e7d <rtems_rfs_format+0x1d>
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;
107e95: c7 45 a4 05 00 00 00 movl $0x5,-0x5c(%ebp)
head->next = tail;
107e9c: 8d 45 ac lea -0x54(%ebp),%eax
107e9f: 89 45 a8 mov %eax,-0x58(%ebp)
tail->previous = head;
107ea2: 8d 45 a8 lea -0x58(%ebp),%eax
107ea5: 89 45 b0 mov %eax,-0x50(%ebp)
head->next = tail;
107ea8: 8d 45 bc lea -0x44(%ebp),%eax
107eab: 89 45 b8 mov %eax,-0x48(%ebp)
tail->previous = head;
107eae: 8d 45 b8 lea -0x48(%ebp),%eax
107eb1: 89 45 c0 mov %eax,-0x40(%ebp)
head->next = tail;
107eb4: 8d 45 cc lea -0x34(%ebp),%eax
107eb7: 89 45 c8 mov %eax,-0x38(%ebp)
tail->previous = head;
107eba: 8d 45 c8 lea -0x38(%ebp),%eax
107ebd: 89 45 d0 mov %eax,-0x30(%ebp)
head->next = tail;
107ec0: 8d 45 dc lea -0x24(%ebp),%eax
107ec3: 89 45 d8 mov %eax,-0x28(%ebp)
tail->previous = head;
107ec6: 8d 45 d8 lea -0x28(%ebp),%eax
107ec9: 89 45 e0 mov %eax,-0x20(%ebp)
fs.release_count = 0;
fs.release_modified_count = 0;
fs.flags = RTEMS_RFS_FS_NO_LOCAL_CACHE;
107ecc: b8 02 00 00 00 mov $0x2,%eax
107ed1: 89 85 64 ff ff ff mov %eax,-0x9c(%ebp)
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
107ed7: 8d 85 64 ff ff ff lea -0x9c(%ebp),%eax
107edd: 89 44 24 04 mov %eax,0x4(%esp)
107ee1: 8b 45 08 mov 0x8(%ebp),%eax
107ee4: 89 04 24 mov %eax,(%esp)
107ee7: e8 f4 f9 ff ff call 1078e0 <rtems_rfs_buffer_open>
if (rc != 0)
107eec: 85 c0 test %eax,%eax
rc = rtems_rfs_buffer_open (name, &fs);
107eee: 89 c3 mov %eax,%ebx
if (rc != 0)
107ef0: 0f 85 aa 12 00 00 jne 1091a0 <rtems_rfs_format+0x1340> <== NEVER TAKEN
}
/*
* Check the media.
*/
if (rtems_rfs_fs_media_block_size (&fs) == 0)
107ef6: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax
107efc: 8b 48 20 mov 0x20(%eax),%ecx
107eff: 85 c9 test %ecx,%ecx
107f01: 0f 84 45 12 00 00 je 10914c <rtems_rfs_format+0x12ec> <== NEVER TAKEN
fs->block_size = config->block_size;
107f07: 8b 45 0c mov 0xc(%ebp),%eax
107f0a: 8b 18 mov (%eax),%ebx
107f0c: 89 9d 6c ff ff ff mov %ebx,-0x94(%ebp)
if (!fs->block_size)
107f12: 85 db test %ebx,%ebx
107f14: 0f 84 86 0d 00 00 je 108ca0 <rtems_rfs_format+0xe40> <== NEVER TAKEN
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
107f1a: 31 d2 xor %edx,%edx
107f1c: 89 d8 mov %ebx,%eax
107f1e: f7 f1 div %ecx
107f20: 85 d2 test %edx,%edx
107f22: 0f 85 ce 0d 00 00 jne 108cf6 <rtems_rfs_format+0xe96> <== NEVER TAKEN
fs->group_blocks = config->group_blocks;
107f28: 8b 45 0c mov 0xc(%ebp),%eax
fs->group_blocks = rtems_rfs_bitmap_numof_bits (fs->block_size);
107f2b: c1 e3 03 shl $0x3,%ebx
fs->group_blocks = config->group_blocks;
107f2e: 8b 40 04 mov 0x4(%eax),%eax
107f31: 89 45 8c mov %eax,-0x74(%ebp)
if (!fs->group_blocks)
107f34: 85 c0 test %eax,%eax
107f36: 0f 85 04 0b 00 00 jne 108a40 <rtems_rfs_format+0xbe0> <== NEVER TAKEN
fs->group_blocks = rtems_rfs_bitmap_numof_bits (fs->block_size);
107f3c: 89 5d 8c mov %ebx,-0x74(%ebp)
fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;
107f3f: 8d 85 64 ff ff ff lea -0x9c(%ebp),%eax
107f45: 31 ff xor %edi,%edi
107f47: 89 04 24 mov %eax,(%esp)
107f4a: e8 41 17 01 00 call 119690 <rtems_rfs_fs_media_size>
107f4f: 8b b5 6c ff ff ff mov -0x94(%ebp),%esi
107f55: 89 7c 24 0c mov %edi,0xc(%esp)
107f59: 89 74 24 08 mov %esi,0x8(%esp)
107f5d: 89 b5 24 ff ff ff mov %esi,-0xdc(%ebp)
return rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs));
107f63: c1 e6 03 shl $0x3,%esi
fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;
107f66: 89 04 24 mov %eax,(%esp)
107f69: 89 54 24 04 mov %edx,0x4(%esp)
107f6d: e8 ee 12 02 00 call 129260 <__udivdi3>
return rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs));
107f72: 89 b5 20 ff ff ff mov %esi,-0xe0(%ebp)
fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;
107f78: 89 85 68 ff ff ff mov %eax,-0x98(%ebp)
if (dividend == 0)
107f7e: 85 c0 test %eax,%eax
fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;
107f80: 89 c1 mov %eax,%ecx
if (dividend == 0)
107f82: 0f 84 fe 0d 00 00 je 108d86 <rtems_rfs_format+0xf26> <== NEVER TAKEN
return ((dividend - 1) / divisor) + 1;
107f88: 8d 40 ff lea -0x1(%eax),%eax
107f8b: 31 d2 xor %edx,%edx
107f8d: f7 f6 div %esi
107f8f: 40 inc %eax
107f90: 89 85 1c ff ff ff mov %eax,-0xe4(%ebp)
fs->group_count = rtems_rfs_rup_quotient (rtems_rfs_fs_blocks (fs),
107f96: 8b 85 1c ff ff ff mov -0xe4(%ebp),%eax
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
107f9c: bf 25 49 92 24 mov $0x24924925,%edi
fs->group_count = rtems_rfs_rup_quotient (rtems_rfs_fs_blocks (fs),
107fa1: 89 45 88 mov %eax,-0x78(%ebp)
fs->group_inodes = config->group_inodes;
107fa4: 8b 45 0c mov 0xc(%ebp),%eax
107fa7: 8b 58 08 mov 0x8(%eax),%ebx
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
107faa: 8b 85 24 ff ff ff mov -0xdc(%ebp),%eax
107fb0: c1 e8 03 shr $0x3,%eax
107fb3: f7 e7 mul %edi
if (!fs->group_inodes)
107fb5: 85 db test %ebx,%ebx
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
107fb7: 89 d7 mov %edx,%edi
107fb9: 89 d6 mov %edx,%esi
if (!fs->group_inodes)
107fbb: 0f 85 ef 0a 00 00 jne 108ab0 <rtems_rfs_format+0xc50> <== NEVER TAKEN
if (config->inode_overhead)
107fc1: 8b 45 0c mov 0xc(%ebp),%eax
107fc4: 8b 40 0c mov 0xc(%eax),%eax
107fc7: 85 c0 test %eax,%eax
107fc9: 75 05 jne 107fd0 <rtems_rfs_format+0x170> <== NEVER TAKEN
107fcb: b8 01 00 00 00 mov $0x1,%eax
blocks = ((rtems_rfs_fs_blocks (fs) -
107fd0: 49 dec %ecx
RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;
107fd1: 0f af c8 imul %eax,%ecx
if (dividend == 0)
107fd4: 83 f9 63 cmp $0x63,%ecx
107fd7: 0f 86 cd 0f 00 00 jbe 108faa <rtems_rfs_format+0x114a> <== NEVER TAKEN
RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;
107fdd: 89 c8 mov %ecx,%eax
107fdf: ba 1f 85 eb 51 mov $0x51eb851f,%edx
107fe4: f7 e2 mul %edx
107fe6: c1 ea 05 shr $0x5,%edx
return ((dividend - 1) / divisor) + 1;
107fe9: 8d 42 ff lea -0x1(%edx),%eax
107fec: 31 d2 xor %edx,%edx
107fee: f7 b5 1c ff ff ff divl -0xe4(%ebp)
107ff4: 8d 58 01 lea 0x1(%eax),%ebx
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
107ff7: 0f af df imul %edi,%ebx
fs->inodes_per_block = rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE;
107ffa: 89 7d 94 mov %edi,-0x6c(%ebp)
if (dividend == 0)
107ffd: 85 db test %ebx,%ebx
107fff: 0f 85 ae 0a 00 00 jne 108ab3 <rtems_rfs_format+0xc53> <== ALWAYS TAKEN
if (fs->group_inodes > rtems_rfs_bitmap_numof_bits (fs->block_size))
108005: 39 b5 20 ff ff ff cmp %esi,-0xe0(%ebp) <== NOT EXECUTED
10800b: 0f 82 bb 0a 00 00 jb 108acc <rtems_rfs_format+0xc6c> <== NOT EXECUTED
fs->group_inodes =
108011: 89 75 90 mov %esi,-0x70(%ebp)
fs->max_name_length = config->max_name_length;
108014: 8b 45 0c mov 0xc(%ebp),%eax
108017: 8b 40 10 mov 0x10(%eax),%eax
if (!fs->max_name_length)
10801a: 85 c0 test %eax,%eax
10801c: 0f 85 c1 0a 00 00 jne 108ae3 <rtems_rfs_format+0xc83> <== NEVER TAKEN
fs->max_name_length = 512;
108022: c7 45 80 00 02 00 00 movl $0x200,-0x80(%ebp)
{
errno = EINVAL;
return -1;
}
if (config->verbose)
108029: 8b 45 0c mov 0xc(%ebp),%eax
10802c: 80 78 15 00 cmpb $0x0,0x15(%eax)
108030: 0f 85 bd 0a 00 00 jne 108af3 <rtems_rfs_format+0xc93> <== NEVER TAKEN
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));
108036: 8b 85 24 ff ff ff mov -0xdc(%ebp),%eax
10803c: 89 44 24 04 mov %eax,0x4(%esp)
108040: 8d 85 64 ff ff ff lea -0x9c(%ebp),%eax
108046: 89 04 24 mov %eax,(%esp)
108049: e8 d2 fb ff ff call 107c20 <rtems_rfs_buffer_setblksize>
10804e: 89 85 24 ff ff ff mov %eax,-0xdc(%ebp)
if (rc != 0)
108054: 85 c0 test %eax,%eax
108056: 0f 85 c1 10 00 00 jne 10911d <rtems_rfs_format+0x12bd> <== NEVER TAKEN
handle->dirty = false;
10805c: c6 85 3c ff ff ff 00 movb $0x0,-0xc4(%ebp)
rc = rtems_rfs_buffer_handle_request (fs, &handle, 0, false);
108063: 8d b5 3c ff ff ff lea -0xc4(%ebp),%esi
handle->bnum = 0;
108069: 31 c0 xor %eax,%eax
10806b: 89 85 40 ff ff ff mov %eax,-0xc0(%ebp)
handle->buffer = NULL;
108071: 31 c0 xor %eax,%eax
108073: 89 85 44 ff ff ff mov %eax,-0xbc(%ebp)
108079: 31 c0 xor %eax,%eax
10807b: 89 44 24 0c mov %eax,0xc(%esp)
10807f: 31 c0 xor %eax,%eax
108081: 89 44 24 08 mov %eax,0x8(%esp)
108085: 8d 85 64 ff ff ff lea -0x9c(%ebp),%eax
10808b: 89 74 24 04 mov %esi,0x4(%esp)
10808f: 89 04 24 mov %eax,(%esp)
108092: e8 39 f5 ff ff call 1075d0 <rtems_rfs_buffer_handle_request>
if (rc > 0)
108097: 85 c0 test %eax,%eax
rc = rtems_rfs_buffer_handle_request (fs, &handle, 0, false);
108099: 89 c3 mov %eax,%ebx
if (rc > 0)
10809b: 0f 8f cf 08 00 00 jg 108970 <rtems_rfs_format+0xb10> <== NEVER TAKEN
sb = rtems_rfs_buffer_data (&handle);
1080a1: 8b 85 44 ff ff ff mov -0xbc(%ebp),%eax
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
1080a7: 8b 9d 6c ff ff ff mov -0x94(%ebp),%ebx
sb = rtems_rfs_buffer_data (&handle);
1080ad: 8b 50 1c mov 0x1c(%eax),%edx
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
1080b0: 83 fb 08 cmp $0x8,%ebx
1080b3: 89 d7 mov %edx,%edi
1080b5: 0f 83 95 0c 00 00 jae 108d50 <rtems_rfs_format+0xef0> <== ALWAYS TAKEN
1080bb: f6 c3 04 test $0x4,%bl
1080be: 74 09 je 1080c9 <rtems_rfs_format+0x269> <== ALWAYS TAKEN
1080c0: c7 07 ff ff ff ff movl $0xffffffff,(%edi) <== NOT EXECUTED
1080c6: 83 c7 04 add $0x4,%edi <== NOT EXECUTED
1080c9: f6 c3 02 test $0x2,%bl
1080cc: 74 08 je 1080d6 <rtems_rfs_format+0x276> <== ALWAYS TAKEN
1080ce: 66 c7 07 ff ff movw $0xffff,(%edi) <== NOT EXECUTED
1080d3: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
1080d6: f6 c3 01 test $0x1,%bl
1080d9: 74 03 je 1080de <rtems_rfs_format+0x27e> <== ALWAYS TAKEN
1080db: c6 07 ff movb $0xff,(%edi) <== NOT EXECUTED
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
1080de: c7 02 28 09 20 01 movl $0x1200928,(%edx)
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
1080e4: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx)
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
1080eb: 8b 85 68 ff ff ff mov -0x98(%ebp),%eax
1080f1: 0f c8 bswap %eax
1080f3: 89 42 0c mov %eax,0xc(%edx)
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
1080f6: 0f b6 85 6f ff ff ff movzbl -0x91(%ebp),%eax
1080fd: 88 42 08 mov %al,0x8(%edx)
108100: 0f b7 85 6e ff ff ff movzwl -0x92(%ebp),%eax
108107: 88 42 09 mov %al,0x9(%edx)
10810a: 8b 85 6c ff ff ff mov -0x94(%ebp),%eax
108110: 88 62 0a mov %ah,0xa(%edx)
108113: 0f b6 85 6c ff ff ff movzbl -0x94(%ebp),%eax
10811a: 88 42 0b mov %al,0xb(%edx)
write_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS, fs->bad_blocks);
10811d: 0f b6 85 7f ff ff ff movzbl -0x81(%ebp),%eax
108124: 88 42 10 mov %al,0x10(%edx)
108127: 0f b7 85 7e ff ff ff movzwl -0x82(%ebp),%eax
10812e: 88 42 11 mov %al,0x11(%edx)
108131: 8b 85 7c ff ff ff mov -0x84(%ebp),%eax
108137: 88 62 12 mov %ah,0x12(%edx)
10813a: 0f b6 85 7c ff ff ff movzbl -0x84(%ebp),%eax
108141: 88 42 13 mov %al,0x13(%edx)
write_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH, fs->max_name_length);
108144: 0f b6 45 83 movzbl -0x7d(%ebp),%eax
108148: 88 42 14 mov %al,0x14(%edx)
10814b: 0f b7 45 82 movzwl -0x7e(%ebp),%eax
10814f: 88 42 15 mov %al,0x15(%edx)
108152: 8b 45 80 mov -0x80(%ebp),%eax
108155: 88 62 16 mov %ah,0x16(%edx)
108158: 0f b6 45 80 movzbl -0x80(%ebp),%eax
10815c: 88 42 17 mov %al,0x17(%edx)
write_sb (RTEMS_RFS_SB_OFFSET_GROUPS, fs->group_count);
10815f: 0f b6 45 8b movzbl -0x75(%ebp),%eax
108163: 88 42 18 mov %al,0x18(%edx)
108166: 0f b7 45 8a movzwl -0x76(%ebp),%eax
10816a: 88 42 19 mov %al,0x19(%edx)
10816d: 8b 45 88 mov -0x78(%ebp),%eax
108170: 88 62 1a mov %ah,0x1a(%edx)
108173: 0f b6 45 88 movzbl -0x78(%ebp),%eax
108177: 88 42 1b mov %al,0x1b(%edx)
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS, fs->group_blocks);
10817a: 0f b6 45 8f movzbl -0x71(%ebp),%eax
10817e: 88 42 1c mov %al,0x1c(%edx)
108181: 0f b7 45 8e movzwl -0x72(%ebp),%eax
108185: 88 42 1d mov %al,0x1d(%edx)
108188: 8b 45 8c mov -0x74(%ebp),%eax
10818b: 88 62 1e mov %ah,0x1e(%edx)
10818e: 0f b6 45 8c movzbl -0x74(%ebp),%eax
108192: 88 42 1f mov %al,0x1f(%edx)
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);
108195: 0f b6 45 93 movzbl -0x6d(%ebp),%eax
108199: 88 42 20 mov %al,0x20(%edx)
10819c: 0f b7 45 92 movzwl -0x6e(%ebp),%eax
1081a0: 88 42 21 mov %al,0x21(%edx)
1081a3: 8b 45 90 mov -0x70(%ebp),%eax
1081a6: 88 62 22 mov %ah,0x22(%edx)
1081a9: 0f b6 45 90 movzbl -0x70(%ebp),%eax
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
1081ad: c7 42 24 00 00 00 38 movl $0x38000000,0x24(%edx)
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);
1081b4: 88 42 23 mov %al,0x23(%edx)
rc = rtems_rfs_buffer_handle_release (fs, &handle);
1081b7: 8d 85 64 ff ff ff lea -0x9c(%ebp),%eax
1081bd: 89 74 24 04 mov %esi,0x4(%esp)
1081c1: 89 04 24 mov %eax,(%esp)
rtems_rfs_buffer_mark_dirty (&handle);
1081c4: c6 85 3c ff ff ff 01 movb $0x1,-0xc4(%ebp)
rc = rtems_rfs_buffer_handle_release (fs, &handle);
1081cb: e8 e0 f6 ff ff call 1078b0 <rtems_rfs_buffer_handle_release>
*/
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);
1081d0: 89 74 24 04 mov %esi,0x4(%esp)
1081d4: 89 c3 mov %eax,%ebx
1081d6: 8d 85 64 ff ff ff lea -0x9c(%ebp),%eax
if (rc > 0)
1081dc: 85 db test %ebx,%ebx
1081de: 89 04 24 mov %eax,(%esp)
1081e1: 0f 8f 29 0b 00 00 jg 108d10 <rtems_rfs_format+0xeb0> <== NEVER TAKEN
1081e7: e8 c4 f6 ff ff call 1078b0 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
errno = EIO;
return -1;
}
for (group = 0; group < fs.group_count; group++)
1081ec: 8b 45 88 mov -0x78(%ebp),%eax
1081ef: 85 c0 test %eax,%eax
1081f1: 0f 8e 56 03 00 00 jle 10854d <rtems_rfs_format+0x6ed> <== NEVER TAKEN
1081f7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1081fe: 66 90 xchg %ax,%ax
group_base = rtems_rfs_fs_block (fs, group, 0);
108200: 8b 5d 8c mov -0x74(%ebp),%ebx
108203: 8b 85 24 ff ff ff mov -0xdc(%ebp),%eax
108209: 0f af c3 imul %ebx,%eax
10820c: 89 85 20 ff ff ff mov %eax,-0xe0(%ebp)
108212: 8d 78 01 lea 0x1(%eax),%edi
if (group_base > rtems_rfs_fs_blocks (fs))
108215: 8b 85 68 ff ff ff mov -0x98(%ebp),%eax
10821b: 39 c7 cmp %eax,%edi
10821d: 0f 87 6d 05 00 00 ja 108790 <rtems_rfs_format+0x930> <== NEVER TAKEN
if ((group_base + group_size) > rtems_rfs_fs_blocks (fs))
108223: 8d 14 3b lea (%ebx,%edi,1),%edx
108226: 39 d0 cmp %edx,%eax
108228: 73 04 jae 10822e <rtems_rfs_format+0x3ce> <== NEVER TAKEN
group_size = rtems_rfs_fs_blocks (fs) - group_base;
10822a: 29 f8 sub %edi,%eax
10822c: 89 c3 mov %eax,%ebx
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
10822e: 8b 45 0c mov 0xc(%ebp),%eax
108231: 8b 4d 0c mov 0xc(%ebp),%ecx
108234: 0f b6 40 15 movzbl 0x15(%eax),%eax
108238: 0f b6 49 14 movzbl 0x14(%ecx),%ecx
10823c: 88 85 1c ff ff ff mov %al,-0xe4(%ebp)
if (verbose)
108242: 84 c0 test %al,%al
config->initialise_inodes, config->verbose))
108244: 88 8d 1b ff ff ff mov %cl,-0xe5(%ebp)
if (verbose)
10824a: 0f 85 f0 04 00 00 jne 108740 <rtems_rfs_format+0x8e0> <== NEVER TAKEN
handle->dirty = false;
108250: c6 85 30 ff ff ff 00 movb $0x0,-0xd0(%ebp)
handle->bnum = 0;
108257: 31 c0 xor %eax,%eax
handle->buffer = NULL;
108259: 31 d2 xor %edx,%edx
handle->bnum = 0;
10825b: 89 85 34 ff ff ff mov %eax,-0xcc(%ebp)
handle->buffer = NULL;
108261: 89 95 38 ff ff ff mov %edx,-0xc8(%ebp)
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
108267: 89 7c 24 10 mov %edi,0x10(%esp)
10826b: 8d 85 30 ff ff ff lea -0xd0(%ebp),%eax
108271: 89 44 24 08 mov %eax,0x8(%esp)
108275: 8d 85 64 ff ff ff lea -0x9c(%ebp),%eax
10827b: 89 5c 24 0c mov %ebx,0xc(%esp)
10827f: 89 44 24 04 mov %eax,0x4(%esp)
108283: 89 34 24 mov %esi,(%esp)
108286: e8 e5 ee ff ff call 107170 <rtems_rfs_bitmap_open>
if (rc > 0)
10828b: 85 c0 test %eax,%eax
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
10828d: 89 c7 mov %eax,%edi
if (rc > 0)
10828f: 0f 8f 2b 04 00 00 jg 1086c0 <rtems_rfs_format+0x860> <== NEVER TAKEN
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
108295: 8b 85 38 ff ff ff mov -0xc8(%ebp),%eax
10829b: 8b 95 6c ff ff ff mov -0x94(%ebp),%edx
1082a1: 8b 40 1c mov 0x1c(%eax),%eax
1082a4: 83 fa 08 cmp $0x8,%edx
1082a7: 89 c7 mov %eax,%edi
1082a9: 0f 83 71 05 00 00 jae 108820 <rtems_rfs_format+0x9c0> <== ALWAYS TAKEN
1082af: f6 c2 04 test $0x4,%dl
1082b2: 74 09 je 1082bd <rtems_rfs_format+0x45d> <== ALWAYS TAKEN
1082b4: c7 07 ff ff ff ff movl $0xffffffff,(%edi) <== NOT EXECUTED
1082ba: 83 c7 04 add $0x4,%edi <== NOT EXECUTED
1082bd: f6 c2 02 test $0x2,%dl
1082c0: 74 08 je 1082ca <rtems_rfs_format+0x46a> <== ALWAYS TAKEN
1082c2: 66 c7 07 ff ff movw $0xffff,(%edi) <== NOT EXECUTED
1082c7: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
1082ca: f6 c2 01 test $0x1,%dl
1082cd: 74 03 je 1082d2 <rtems_rfs_format+0x472> <== ALWAYS TAKEN
1082cf: c6 07 ff movb $0xff,(%edi) <== NOT EXECUTED
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
1082d2: 89 34 24 mov %esi,(%esp)
1082d5: e8 e6 e9 ff ff call 106cc0 <rtems_rfs_bitmap_map_clear_all>
if (rc > 0)
1082da: 85 c0 test %eax,%eax
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
1082dc: 89 c7 mov %eax,%edi
if (rc > 0)
1082de: 0f 8f cc 04 00 00 jg 1087b0 <rtems_rfs_format+0x950> <== NEVER TAKEN
rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
1082e4: 89 34 24 mov %esi,(%esp)
1082e7: 31 d2 xor %edx,%edx
1082e9: 89 54 24 04 mov %edx,0x4(%esp)
1082ed: e8 0e e5 ff ff call 106800 <rtems_rfs_bitmap_map_set>
rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
1082f2: b9 01 00 00 00 mov $0x1,%ecx
1082f7: 89 4c 24 04 mov %ecx,0x4(%esp)
1082fb: 89 34 24 mov %esi,(%esp)
1082fe: e8 fd e4 ff ff call 106800 <rtems_rfs_bitmap_map_set>
blocks = rtems_rfs_rup_quotient (fs->group_inodes, fs->inodes_per_block);
108303: 8b 45 90 mov -0x70(%ebp),%eax
if (dividend == 0)
108306: 85 c0 test %eax,%eax
108308: 0f 84 52 05 00 00 je 108860 <rtems_rfs_format+0xa00> <== NEVER TAKEN
return ((dividend - 1) / divisor) + 1;
10830e: 48 dec %eax
10830f: 31 d2 xor %edx,%edx
108311: f7 75 94 divl -0x6c(%ebp)
108314: 8d 48 01 lea 0x1(%eax),%ecx
108317: 89 8d 14 ff ff ff mov %ecx,-0xec(%ebp)
for (b = 0; b < blocks; b++)
10831d: 85 c9 test %ecx,%ecx
10831f: 7e 36 jle 108357 <rtems_rfs_format+0x4f7> <== NEVER TAKEN
108321: 89 9d 10 ff ff ff mov %ebx,-0xf0(%ebp)
108327: bf 02 00 00 00 mov $0x2,%edi
10832c: 83 c0 03 add $0x3,%eax
10832f: 89 fb mov %edi,%ebx
108331: 89 c7 mov %eax,%edi
108333: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10833a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
108340: 89 5c 24 04 mov %ebx,0x4(%esp)
for (b = 0; b < blocks; b++)
108344: 43 inc %ebx
rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
108345: 89 34 24 mov %esi,(%esp)
108348: e8 b3 e4 ff ff call 106800 <rtems_rfs_bitmap_map_set>
for (b = 0; b < blocks; b++)
10834d: 39 df cmp %ebx,%edi
10834f: 75 ef jne 108340 <rtems_rfs_format+0x4e0>
108351: 8b 9d 10 ff ff ff mov -0xf0(%ebp),%ebx
rc = rtems_rfs_bitmap_close (&bitmap);
108357: 89 34 24 mov %esi,(%esp)
10835a: e8 71 ee ff ff call 1071d0 <rtems_rfs_bitmap_close>
if (rc > 0)
10835f: 85 c0 test %eax,%eax
rc = rtems_rfs_bitmap_close (&bitmap);
108361: 89 c7 mov %eax,%edi
if (rc > 0)
108363: 0f 8f 25 05 00 00 jg 10888e <rtems_rfs_format+0xa2e> <== NEVER TAKEN
if (verbose)
108369: 80 bd 1c ff ff ff 00 cmpb $0x0,-0xe4(%ebp)
rtems_rfs_buffer_mark_dirty (&handle);
108370: c6 85 30 ff ff ff 01 movb $0x1,-0xd0(%ebp)
if (verbose)
108377: 0f 85 d3 05 00 00 jne 108950 <rtems_rfs_format+0xaf0> <== NEVER TAKEN
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
10837d: 89 5c 24 0c mov %ebx,0xc(%esp)
108381: 8b 85 20 ff ff ff mov -0xe0(%ebp),%eax
108387: 89 34 24 mov %esi,(%esp)
10838a: 83 c0 02 add $0x2,%eax
10838d: 89 44 24 10 mov %eax,0x10(%esp)
108391: 8d 85 30 ff ff ff lea -0xd0(%ebp),%eax
108397: 89 44 24 08 mov %eax,0x8(%esp)
10839b: 8d 85 64 ff ff ff lea -0x9c(%ebp),%eax
1083a1: 89 44 24 04 mov %eax,0x4(%esp)
1083a5: e8 c6 ed ff ff call 107170 <rtems_rfs_bitmap_open>
if (rc > 0)
1083aa: 85 c0 test %eax,%eax
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
1083ac: 89 c3 mov %eax,%ebx
if (rc > 0)
1083ae: 0f 8f 3c 05 00 00 jg 1088f0 <rtems_rfs_format+0xa90> <== NEVER TAKEN
memset (rtems_rfs_buffer_data (&handle), 0x00, rtems_rfs_fs_block_size (fs));
1083b4: 8b 85 38 ff ff ff mov -0xc8(%ebp),%eax
1083ba: 8b 95 6c ff ff ff mov -0x94(%ebp),%edx
1083c0: 8b 40 1c mov 0x1c(%eax),%eax
1083c3: 83 fa 08 cmp $0x8,%edx
1083c6: 89 c7 mov %eax,%edi
1083c8: 0f 83 a2 06 00 00 jae 108a70 <rtems_rfs_format+0xc10> <== ALWAYS TAKEN
1083ce: f6 c2 04 test $0x4,%dl
1083d1: 74 09 je 1083dc <rtems_rfs_format+0x57c> <== ALWAYS TAKEN
1083d3: c7 07 00 00 00 00 movl $0x0,(%edi) <== NOT EXECUTED
1083d9: 83 c7 04 add $0x4,%edi <== NOT EXECUTED
1083dc: f6 c2 02 test $0x2,%dl
1083df: 74 08 je 1083e9 <rtems_rfs_format+0x589> <== ALWAYS TAKEN
1083e1: 66 c7 07 00 00 movw $0x0,(%edi) <== NOT EXECUTED
1083e6: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
1083e9: f6 c2 01 test $0x1,%dl
1083ec: 74 03 je 1083f1 <rtems_rfs_format+0x591> <== ALWAYS TAKEN
1083ee: c6 07 00 movb $0x0,(%edi) <== NOT EXECUTED
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
1083f1: 89 34 24 mov %esi,(%esp)
1083f4: e8 c7 e8 ff ff call 106cc0 <rtems_rfs_bitmap_map_clear_all>
rtems_rfs_bitmap_close (&bitmap);
1083f9: 89 34 24 mov %esi,(%esp)
if (rc > 0)
1083fc: 85 c0 test %eax,%eax
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
1083fe: 89 c3 mov %eax,%ebx
if (rc > 0)
108400: 0f 8f da 05 00 00 jg 1089e0 <rtems_rfs_format+0xb80> <== NEVER TAKEN
rc = rtems_rfs_bitmap_close (&bitmap);
108406: e8 c5 ed ff ff call 1071d0 <rtems_rfs_bitmap_close>
if (rc > 0)
10840b: 85 c0 test %eax,%eax
rc = rtems_rfs_bitmap_close (&bitmap);
10840d: 89 c3 mov %eax,%ebx
if (rc > 0)
10840f: 0f 8f 50 0a 00 00 jg 108e65 <rtems_rfs_format+0x1005> <== NEVER TAKEN
if (initialise_inodes)
108415: 80 bd 1b ff ff ff 00 cmpb $0x0,-0xe5(%ebp)
rtems_rfs_buffer_mark_dirty (&handle);
10841c: c6 85 30 ff ff ff 01 movb $0x1,-0xd0(%ebp)
if (initialise_inodes)
108423: 0f 84 f7 00 00 00 je 108520 <rtems_rfs_format+0x6c0> <== ALWAYS TAKEN
for (b = 0; b < blocks; b++)
108429: 8b 85 14 ff ff ff mov -0xec(%ebp),%eax <== NOT EXECUTED
10842f: 85 c0 test %eax,%eax <== NOT EXECUTED
108431: 0f 8e e9 00 00 00 jle 108520 <rtems_rfs_format+0x6c0> <== NOT EXECUTED
108437: 8b 8d 20 ff ff ff mov -0xe0(%ebp),%ecx <== NOT EXECUTED
10843d: 8d 44 08 03 lea 0x3(%eax,%ecx,1),%eax <== NOT EXECUTED
108441: 89 85 20 ff ff ff mov %eax,-0xe0(%ebp) <== NOT EXECUTED
108447: 8d 59 03 lea 0x3(%ecx),%ebx <== NOT EXECUTED
10844a: eb 3b jmp 108487 <rtems_rfs_format+0x627> <== NOT EXECUTED
10844c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
108450: f6 c2 04 test $0x4,%dl <== NOT EXECUTED
108453: 74 09 je 10845e <rtems_rfs_format+0x5fe> <== NOT EXECUTED
108455: c7 07 ff ff ff ff movl $0xffffffff,(%edi) <== NOT EXECUTED
10845b: 83 c7 04 add $0x4,%edi <== NOT EXECUTED
10845e: f6 c2 02 test $0x2,%dl <== NOT EXECUTED
108461: 74 08 je 10846b <rtems_rfs_format+0x60b> <== NOT EXECUTED
108463: 66 c7 07 ff ff movw $0xffff,(%edi) <== NOT EXECUTED
108468: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
10846b: f6 c2 01 test $0x1,%dl <== NOT EXECUTED
10846e: 74 03 je 108473 <rtems_rfs_format+0x613> <== NOT EXECUTED
108470: c6 07 ff movb $0xff,(%edi) <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle);
108473: c6 85 30 ff ff ff 01 movb $0x1,-0xd0(%ebp) <== NOT EXECUTED
for (b = 0; b < blocks; b++)
10847a: 43 inc %ebx <== NOT EXECUTED
10847b: 39 9d 20 ff ff ff cmp %ebx,-0xe0(%ebp) <== NOT EXECUTED
108481: 0f 84 99 00 00 00 je 108520 <rtems_rfs_format+0x6c0> <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &handle,
108487: 89 5c 24 08 mov %ebx,0x8(%esp) <== NOT EXECUTED
10848b: 31 c0 xor %eax,%eax <== NOT EXECUTED
10848d: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
108491: 8d 85 30 ff ff ff lea -0xd0(%ebp),%eax <== NOT EXECUTED
108497: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
10849b: 8d 85 64 ff ff ff lea -0x9c(%ebp),%eax <== NOT EXECUTED
1084a1: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
1084a4: e8 27 f1 ff ff call 1075d0 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
1084a9: 85 c0 test %eax,%eax <== NOT EXECUTED
1084ab: 0f 8f 0e 0a 00 00 jg 108ebf <rtems_rfs_format+0x105f> <== NOT EXECUTED
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
1084b1: 8b 85 38 ff ff ff mov -0xc8(%ebp),%eax <== NOT EXECUTED
1084b7: 8b 95 6c ff ff ff mov -0x94(%ebp),%edx <== NOT EXECUTED
1084bd: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED
1084c0: 83 fa 08 cmp $0x8,%edx <== NOT EXECUTED
1084c3: 89 c7 mov %eax,%edi <== NOT EXECUTED
1084c5: 72 89 jb 108450 <rtems_rfs_format+0x5f0> <== NOT EXECUTED
1084c7: a8 01 test $0x1,%al <== NOT EXECUTED
1084c9: 0f 85 d1 0a 00 00 jne 108fa0 <rtems_rfs_format+0x1140> <== NOT EXECUTED
1084cf: f7 c7 02 00 00 00 test $0x2,%edi <== NOT EXECUTED
1084d5: 0f 85 b5 0a 00 00 jne 108f90 <rtems_rfs_format+0x1130> <== NOT EXECUTED
1084db: f7 c7 04 00 00 00 test $0x4,%edi <== NOT EXECUTED
1084e1: 0f 85 42 0a 00 00 jne 108f29 <rtems_rfs_format+0x10c9> <== NOT EXECUTED
1084e7: 89 d1 mov %edx,%ecx <== NOT EXECUTED
1084e9: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
1084ee: c1 e9 02 shr $0x2,%ecx <== NOT EXECUTED
1084f1: 83 e2 03 and $0x3,%edx <== NOT EXECUTED
1084f4: f3 ab rep stos %eax,%es:(%edi) <== NOT EXECUTED
1084f6: e9 55 ff ff ff jmp 108450 <rtems_rfs_format+0x5f0> <== NOT EXECUTED
1084fb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1084ff: 90 nop <== NOT EXECUTED
printf ("rtems-rfs: format: %s\n", name);
108500: c7 04 24 6c 3c 13 00 movl $0x133c6c,(%esp) <== NOT EXECUTED
108507: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
10850a: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
10850e: e8 2d 9c ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
108513: e9 61 f9 ff ff jmp 107e79 <rtems_rfs_format+0x19> <== NOT EXECUTED
108518: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10851f: 90 nop <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
108520: 8d 85 30 ff ff ff lea -0xd0(%ebp),%eax
108526: 89 44 24 04 mov %eax,0x4(%esp)
10852a: 8d 85 64 ff ff ff lea -0x9c(%ebp),%eax
108530: 89 04 24 mov %eax,(%esp)
108533: e8 78 f3 ff ff call 1078b0 <rtems_rfs_buffer_handle_release>
for (group = 0; group < fs.group_count; group++)
108538: ff 85 24 ff ff ff incl -0xdc(%ebp)
10853e: 8b 85 24 ff ff ff mov -0xdc(%ebp),%eax
108544: 39 45 88 cmp %eax,-0x78(%ebp)
108547: 0f 8f b3 fc ff ff jg 108200 <rtems_rfs_format+0x3a0> <== NEVER TAKEN
{
errno = EIO;
return -1;
}
if (config->verbose)
10854d: 8b 45 0c mov 0xc(%ebp),%eax
108550: 80 78 15 00 cmpb $0x0,0x15(%eax)
108554: 0f 85 74 08 00 00 jne 108dce <rtems_rfs_format+0xf6e> <== NEVER TAKEN
printf ("\n");
rc = rtems_rfs_buffer_close (&fs);
10855a: 8d 85 64 ff ff ff lea -0x9c(%ebp),%eax
108560: 89 04 24 mov %eax,(%esp)
108563: e8 d8 f7 ff ff call 107d40 <rtems_rfs_buffer_close>
if (rc != 0)
108568: 85 c0 test %eax,%eax
rc = rtems_rfs_buffer_close (&fs);
10856a: 89 c3 mov %eax,%ebx
if (rc != 0)
10856c: 0f 85 01 0c 00 00 jne 109173 <rtems_rfs_format+0x1313> <== NEVER TAKEN
rc = rtems_rfs_fs_open (name, NULL,
108572: 8d 85 2c ff ff ff lea -0xd4(%ebp),%eax
108578: 31 db xor %ebx,%ebx
10857a: 89 44 24 10 mov %eax,0x10(%esp)
10857e: 31 c0 xor %eax,%eax
108580: bf 06 00 00 00 mov $0x6,%edi
108585: 89 44 24 04 mov %eax,0x4(%esp)
108589: 8b 45 08 mov 0x8(%ebp),%eax
10858c: 89 5c 24 0c mov %ebx,0xc(%esp)
108590: 89 7c 24 08 mov %edi,0x8(%esp)
108594: 89 04 24 mov %eax,(%esp)
108597: e8 14 11 01 00 call 1196b0 <rtems_rfs_fs_open>
if (rc != 0)
10859c: 85 c0 test %eax,%eax
10859e: 0f 85 f2 07 00 00 jne 108d96 <rtems_rfs_format+0xf36> <== NEVER TAKEN
rc = rtems_rfs_inode_alloc (fs, RTEMS_RFS_ROOT_INO, &ino);
1085a4: 8d 85 30 ff ff ff lea -0xd0(%ebp),%eax
1085aa: b9 01 00 00 00 mov $0x1,%ecx
1085af: 89 44 24 08 mov %eax,0x8(%esp)
1085b3: 8b 85 2c ff ff ff mov -0xd4(%ebp),%eax
1085b9: 89 4c 24 04 mov %ecx,0x4(%esp)
1085bd: 89 04 24 mov %eax,(%esp)
1085c0: e8 7b 13 00 00 call 109940 <rtems_rfs_inode_alloc>
if (rc != 0)
1085c5: 85 c0 test %eax,%eax
rc = rtems_rfs_inode_alloc (fs, RTEMS_RFS_ROOT_INO, &ino);
1085c7: 89 c3 mov %eax,%ebx
if (rc != 0)
1085c9: 0f 85 e2 09 00 00 jne 108fb1 <rtems_rfs_format+0x1151> <== NEVER TAKEN
if (ino != RTEMS_RFS_ROOT_INO)
1085cf: 8b 85 30 ff ff ff mov -0xd0(%ebp),%eax
1085d5: 83 f8 01 cmp $0x1,%eax
1085d8: 0f 85 5c 09 00 00 jne 108f3a <rtems_rfs_format+0x10da> <== NEVER TAKEN
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
1085de: 89 74 24 08 mov %esi,0x8(%esp)
1085e2: b8 01 00 00 00 mov $0x1,%eax
1085e7: ba 01 00 00 00 mov $0x1,%edx
1085ec: 89 44 24 0c mov %eax,0xc(%esp)
1085f0: 8b 85 2c ff ff ff mov -0xd4(%ebp),%eax
1085f6: 89 54 24 04 mov %edx,0x4(%esp)
1085fa: 89 04 24 mov %eax,(%esp)
1085fd: e8 2e 14 00 00 call 109a30 <rtems_rfs_inode_open>
if (rc != 0)
108602: 85 c0 test %eax,%eax
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
108604: 89 c3 mov %eax,%ebx
if (rc != 0)
108606: 0f 85 de 09 00 00 jne 108fea <rtems_rfs_format+0x118a> <== NEVER TAKEN
rc = rtems_rfs_inode_initialise (&inode, 0,
10860c: 89 34 24 mov %esi,(%esp)
10860f: 31 c0 xor %eax,%eax
108611: 31 ff xor %edi,%edi
108613: 89 44 24 0c mov %eax,0xc(%esp)
108617: b8 c9 41 00 00 mov $0x41c9,%eax
10861c: 89 44 24 08 mov %eax,0x8(%esp)
108620: 31 c0 xor %eax,%eax
108622: 89 7c 24 10 mov %edi,0x10(%esp)
108626: 89 44 24 04 mov %eax,0x4(%esp)
10862a: e8 e1 19 00 00 call 10a010 <rtems_rfs_inode_initialise>
if (rc != 0)
10862f: 85 c0 test %eax,%eax
rc = rtems_rfs_inode_initialise (&inode, 0,
108631: 89 c3 mov %eax,%ebx
if (rc != 0)
108633: 0f 85 6e 0a 00 00 jne 1090a7 <rtems_rfs_format+0x1247> <== NEVER TAKEN
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, ino);
108639: 8b 85 30 ff ff ff mov -0xd0(%ebp),%eax
10863f: b9 01 00 00 00 mov $0x1,%ecx
108644: bb 92 75 13 00 mov $0x137592,%ebx
108649: 89 5c 24 08 mov %ebx,0x8(%esp)
10864d: 89 4c 24 0c mov %ecx,0xc(%esp)
108651: 89 74 24 04 mov %esi,0x4(%esp)
108655: 89 44 24 10 mov %eax,0x10(%esp)
108659: 8b 85 2c ff ff ff mov -0xd4(%ebp),%eax
10865f: 89 04 24 mov %eax,(%esp)
108662: e8 49 e5 00 00 call 116bb0 <rtems_rfs_dir_add_entry>
if (rc != 0)
108667: 85 c0 test %eax,%eax
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, ino);
108669: 89 c3 mov %eax,%ebx
if (rc != 0)
10866b: 0f 85 15 0a 00 00 jne 109086 <rtems_rfs_format+0x1226> <== NEVER TAKEN
rc = rtems_rfs_inode_close (fs, &inode);
108671: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED
108675: 8b 85 2c ff ff ff mov -0xd4(%ebp),%eax <== NOT EXECUTED
10867b: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
10867e: e8 bd 15 00 00 call 109c40 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc != 0)
108683: 85 c0 test %eax,%eax
rc = rtems_rfs_inode_close (fs, &inode);
108685: 89 c3 mov %eax,%ebx
if (rc != 0)
108687: 0f 85 d8 09 00 00 jne 109065 <rtems_rfs_format+0x1205> <== NEVER TAKEN
rc = rtems_rfs_fs_close (fs);
10868d: 8b 85 2c ff ff ff mov -0xd4(%ebp),%eax
108693: 89 04 24 mov %eax,(%esp)
108696: e8 d5 17 01 00 call 119e70 <rtems_rfs_fs_close>
if (rc != 0)
10869b: 85 c0 test %eax,%eax
rc = rtems_rfs_fs_close (fs);
10869d: 89 c3 mov %eax,%ebx
if (rc != 0)
10869f: 0f 85 50 0a 00 00 jne 1090f5 <rtems_rfs_format+0x1295> <== NEVER TAKEN
errno = rc;
return -1;
}
return 0;
}
1086a5: 81 c4 0c 01 00 00 add $0x10c,%esp
1086ab: 89 d8 mov %ebx,%eax
1086ad: 5b pop %ebx
1086ae: 5e pop %esi
1086af: 5f pop %edi
1086b0: 5d pop %ebp
1086b1: c3 ret
1086b2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1086b9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1086c0: 8d 85 30 ff ff ff lea -0xd0(%ebp),%eax <== NOT EXECUTED
1086c6: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1086ca: 8d 85 64 ff ff ff lea -0x9c(%ebp),%eax <== NOT EXECUTED
1086d0: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
1086d3: e8 d8 f1 ff ff call 1078b0 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
handle->bnum = 0;
1086d8: 31 c0 xor %eax,%eax <== NOT EXECUTED
1086da: 89 85 34 ff ff ff mov %eax,-0xcc(%ebp) <== NOT EXECUTED
handle->buffer = NULL;
1086e0: 31 c0 xor %eax,%eax <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: open block bitmap failed: %d: %s\n",
1086e2: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
handle->dirty = false;
1086e5: c6 85 30 ff ff ff 00 movb $0x0,-0xd0(%ebp) <== NOT EXECUTED
handle->buffer = NULL;
1086ec: 89 85 38 ff ff ff mov %eax,-0xc8(%ebp) <== NOT EXECUTED
1086f2: e8 29 2d 02 00 call 12b420 <strerror> <== NOT EXECUTED
1086f7: 89 7c 24 08 mov %edi,0x8(%esp) <== NOT EXECUTED
1086fb: c7 04 24 80 40 13 00 movl $0x134080,(%esp) <== NOT EXECUTED
108702: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
108706: 8b 85 24 ff ff ff mov -0xdc(%ebp),%eax <== NOT EXECUTED
10870c: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
108710: e8 2b 9a ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
errno = EIO;
108715: e8 e6 1d 02 00 call 12a500 <__errno> <== NOT EXECUTED
return -1;
10871a: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED
errno = EIO;
10871f: c7 00 05 00 00 00 movl $0x5,(%eax) <== NOT EXECUTED
}
108725: 81 c4 0c 01 00 00 add $0x10c,%esp <== NOT EXECUTED
10872b: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10872d: 5b pop %ebx <== NOT EXECUTED
10872e: 5e pop %esi <== NOT EXECUTED
10872f: 5f pop %edi <== NOT EXECUTED
108730: 5d pop %ebp <== NOT EXECUTED
108731: c3 ret <== NOT EXECUTED
108732: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
108739: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
printf ("\rrtems-rfs: format: group %3d: base = %" PRId32 ", size = %zd",
108740: 89 5c 24 0c mov %ebx,0xc(%esp) <== NOT EXECUTED
108744: 8b 85 24 ff ff ff mov -0xdc(%ebp),%eax <== NOT EXECUTED
10874a: 89 7c 24 08 mov %edi,0x8(%esp) <== NOT EXECUTED
10874e: c7 04 24 48 40 13 00 movl $0x134048,(%esp) <== NOT EXECUTED
108755: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
108759: e8 e2 99 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
handle->bnum = 0;
10875e: 31 c0 xor %eax,%eax <== NOT EXECUTED
108760: 89 85 34 ff ff ff mov %eax,-0xcc(%ebp) <== NOT EXECUTED
handle->buffer = NULL;
108766: 31 c0 xor %eax,%eax <== NOT EXECUTED
printf (", blocks");
108768: c7 04 24 83 3c 13 00 movl $0x133c83,(%esp) <== NOT EXECUTED
handle->dirty = false;
10876f: c6 85 30 ff ff ff 00 movb $0x0,-0xd0(%ebp) <== NOT EXECUTED
handle->buffer = NULL;
108776: 89 85 38 ff ff ff mov %eax,-0xc8(%ebp) <== NOT EXECUTED
10877c: e8 bf 99 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
108781: e9 e1 fa ff ff jmp 108267 <rtems_rfs_format+0x407> <== NOT EXECUTED
108786: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10878d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
printf ("rtems-rfs: write-group: group %d base beyond disk limit\n",
108790: c7 04 24 0c 40 13 00 movl $0x13400c,(%esp) <== NOT EXECUTED
108797: 8b 85 24 ff ff ff mov -0xdc(%ebp),%eax <== NOT EXECUTED
10879d: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1087a1: e8 9a 99 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
return false;
1087a6: e9 6a ff ff ff jmp 108715 <rtems_rfs_format+0x8b5> <== NOT EXECUTED
1087ab: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1087af: 90 nop <== NOT EXECUTED
rtems_rfs_bitmap_close (&bitmap);
1087b0: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
handle->bnum = 0;
1087b3: 31 db xor %ebx,%ebx <== NOT EXECUTED
handle->buffer = NULL;
1087b5: 31 f6 xor %esi,%esi <== NOT EXECUTED
1087b7: e8 14 ea ff ff call 1071d0 <rtems_rfs_bitmap_close> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
1087bc: 8d 85 30 ff ff ff lea -0xd0(%ebp),%eax <== NOT EXECUTED
1087c2: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1087c6: 8d 85 64 ff ff ff lea -0x9c(%ebp),%eax <== NOT EXECUTED
1087cc: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
1087cf: e8 dc f0 ff ff call 1078b0 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: block bitmap clear all failed: %d: %s\n",
1087d4: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
handle->dirty = false;
1087d7: c6 85 30 ff ff ff 00 movb $0x0,-0xd0(%ebp) <== NOT EXECUTED
handle->bnum = 0;
1087de: 89 9d 34 ff ff ff mov %ebx,-0xcc(%ebp) <== NOT EXECUTED
handle->buffer = NULL;
1087e4: 89 b5 38 ff ff ff mov %esi,-0xc8(%ebp) <== NOT EXECUTED
1087ea: e8 31 2c 02 00 call 12b420 <strerror> <== NOT EXECUTED
1087ef: 89 7c 24 08 mov %edi,0x8(%esp) <== NOT EXECUTED
1087f3: c7 04 24 c8 40 13 00 movl $0x1340c8,(%esp) <== NOT EXECUTED
1087fa: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
1087fe: 8b 85 24 ff ff ff mov -0xdc(%ebp),%eax <== NOT EXECUTED
108804: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
108808: e8 33 99 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
return false;
10880d: e9 03 ff ff ff jmp 108715 <rtems_rfs_format+0x8b5> <== NOT EXECUTED
108812: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
108819: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
108820: a8 01 test $0x1,%al
108822: 0f 85 33 06 00 00 jne 108e5b <rtems_rfs_format+0xffb> <== NEVER TAKEN
108828: f7 c7 02 00 00 00 test $0x2,%edi
10882e: 66 90 xchg %ax,%ax
108830: 0f 85 15 06 00 00 jne 108e4b <rtems_rfs_format+0xfeb> <== NEVER TAKEN
108836: f7 c7 04 00 00 00 test $0x4,%edi
10883c: 0f 85 f8 05 00 00 jne 108e3a <rtems_rfs_format+0xfda> <== NEVER TAKEN
108842: 89 d1 mov %edx,%ecx
108844: b8 ff ff ff ff mov $0xffffffff,%eax
108849: c1 e9 02 shr $0x2,%ecx
10884c: 83 e2 03 and $0x3,%edx
10884f: f3 ab rep stos %eax,%es:(%edi)
108851: e9 59 fa ff ff jmp 1082af <rtems_rfs_format+0x44f>
108856: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10885d: 8d 76 00 lea 0x0(%esi),%esi
rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
108860: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
108863: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED
108868: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
10886c: e8 8f df ff ff call 106800 <rtems_rfs_bitmap_map_set> <== NOT EXECUTED
return 1;
108871: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
rc = rtems_rfs_bitmap_close (&bitmap);
108876: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
return 1;
108879: 89 85 14 ff ff ff mov %eax,-0xec(%ebp) <== NOT EXECUTED
rc = rtems_rfs_bitmap_close (&bitmap);
10887f: e8 4c e9 ff ff call 1071d0 <rtems_rfs_bitmap_close> <== NOT EXECUTED
if (rc > 0)
108884: 85 c0 test %eax,%eax <== NOT EXECUTED
rc = rtems_rfs_bitmap_close (&bitmap);
108886: 89 c7 mov %eax,%edi <== NOT EXECUTED
if (rc > 0)
108888: 0f 8e db fa ff ff jle 108369 <rtems_rfs_format+0x509> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
10888e: 8d 85 30 ff ff ff lea -0xd0(%ebp),%eax <== NOT EXECUTED
108894: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
108898: 8d 85 64 ff ff ff lea -0x9c(%ebp),%eax <== NOT EXECUTED
10889e: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
1088a1: e8 0a f0 ff ff call 1078b0 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->bnum = 0;
1088a6: 31 c0 xor %eax,%eax <== NOT EXECUTED
1088a8: 89 85 34 ff ff ff mov %eax,-0xcc(%ebp) <== NOT EXECUTED
handle->buffer = NULL;
1088ae: 31 c0 xor %eax,%eax <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: close block bitmap failed: %d: %s\n",
1088b0: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
handle->dirty = false;
1088b3: c6 85 30 ff ff ff 00 movb $0x0,-0xd0(%ebp) <== NOT EXECUTED
handle->buffer = NULL;
1088ba: 89 85 38 ff ff ff mov %eax,-0xc8(%ebp) <== NOT EXECUTED
1088c0: e8 5b 2b 02 00 call 12b420 <strerror> <== NOT EXECUTED
1088c5: 89 7c 24 08 mov %edi,0x8(%esp) <== NOT EXECUTED
1088c9: c7 04 24 14 41 13 00 movl $0x134114,(%esp) <== NOT EXECUTED
1088d0: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
1088d4: 8b 85 24 ff ff ff mov -0xdc(%ebp),%eax <== NOT EXECUTED
1088da: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1088de: e8 5d 98 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
return false;
1088e3: e9 2d fe ff ff jmp 108715 <rtems_rfs_format+0x8b5> <== NOT EXECUTED
1088e8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1088ef: 90 nop <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
1088f0: 8d 85 30 ff ff ff lea -0xd0(%ebp),%eax <== NOT EXECUTED
handle->bnum = 0;
1088f6: 31 ff xor %edi,%edi <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
1088f8: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1088fc: 8d 85 64 ff ff ff lea -0x9c(%ebp),%eax <== NOT EXECUTED
108902: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
108905: e8 a6 ef ff ff call 1078b0 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->buffer = NULL;
10890a: 31 c0 xor %eax,%eax <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: open inode bitmap failed: %d: %s\n",
10890c: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
handle->dirty = false;
10890f: c6 85 30 ff ff ff 00 movb $0x0,-0xd0(%ebp) <== NOT EXECUTED
handle->bnum = 0;
108916: 89 bd 34 ff ff ff mov %edi,-0xcc(%ebp) <== NOT EXECUTED
handle->buffer = NULL;
10891c: 89 85 38 ff ff ff mov %eax,-0xc8(%ebp) <== NOT EXECUTED
108922: e8 f9 2a 02 00 call 12b420 <strerror> <== NOT EXECUTED
108927: 89 5c 24 08 mov %ebx,0x8(%esp) <== NOT EXECUTED
10892b: c7 04 24 5c 41 13 00 movl $0x13415c,(%esp) <== NOT EXECUTED
108932: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
108936: 8b 85 24 ff ff ff mov -0xdc(%ebp),%eax <== NOT EXECUTED
10893c: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
108940: e8 fb 97 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
return false;
108945: e9 cb fd ff ff jmp 108715 <rtems_rfs_format+0x8b5> <== NOT EXECUTED
10894a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
printf (", inodes");
108950: c7 04 24 8c 3c 13 00 movl $0x133c8c,(%esp) <== NOT EXECUTED
108957: e8 e4 97 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
10895c: e9 1c fa ff ff jmp 10837d <rtems_rfs_format+0x51d> <== NOT EXECUTED
108961: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
108968: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10896f: 90 nop <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
108970: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED
108974: 8d 85 64 ff ff ff lea -0x9c(%ebp),%eax <== NOT EXECUTED
handle->bnum = 0;
10897a: 31 f6 xor %esi,%esi <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
10897c: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
handle->buffer = NULL;
10897f: 31 ff xor %edi,%edi <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
108981: e8 2a ef ff ff call 1078b0 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
printf ("rtems-rfs: write-superblock: request failed: %d: %s\n",
108986: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
handle->dirty = false;
108989: c6 85 3c ff ff ff 00 movb $0x0,-0xc4(%ebp) <== NOT EXECUTED
handle->bnum = 0;
108990: 89 b5 40 ff ff ff mov %esi,-0xc0(%ebp) <== NOT EXECUTED
handle->buffer = NULL;
108996: 89 bd 44 ff ff ff mov %edi,-0xbc(%ebp) <== NOT EXECUTED
10899c: e8 7f 2a 02 00 call 12b420 <strerror> <== NOT EXECUTED
1089a1: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
1089a5: c7 04 24 6c 3f 13 00 movl $0x133f6c,(%esp) <== NOT EXECUTED
1089ac: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
1089b0: e8 8b 97 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
printf ("rtems-rfs: format: superblock write failed\n");
1089b5: c7 04 24 e0 3f 13 00 movl $0x133fe0,(%esp) <== NOT EXECUTED
return -1;
1089bc: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED
printf ("rtems-rfs: format: superblock write failed\n");
1089c1: e8 aa 97 ff ff call 102170 <__wrap_puts> <== NOT EXECUTED
errno = EIO;
1089c6: e8 35 1b 02 00 call 12a500 <__errno> <== NOT EXECUTED
1089cb: c7 00 05 00 00 00 movl $0x5,(%eax) <== NOT EXECUTED
return -1;
1089d1: e9 cf fc ff ff jmp 1086a5 <rtems_rfs_format+0x845> <== NOT EXECUTED
1089d6: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1089dd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
rtems_rfs_bitmap_close (&bitmap);
1089e0: e8 eb e7 ff ff call 1071d0 <rtems_rfs_bitmap_close> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
1089e5: 8d 85 30 ff ff ff lea -0xd0(%ebp),%eax <== NOT EXECUTED
handle->buffer = NULL;
1089eb: 31 f6 xor %esi,%esi <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
1089ed: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1089f1: 8d 85 64 ff ff ff lea -0x9c(%ebp),%eax <== NOT EXECUTED
1089f7: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
1089fa: e8 b1 ee ff ff call 1078b0 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->bnum = 0;
1089ff: 31 c9 xor %ecx,%ecx <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: inode bitmap" \
108a01: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
handle->dirty = false;
108a04: c6 85 30 ff ff ff 00 movb $0x0,-0xd0(%ebp) <== NOT EXECUTED
handle->bnum = 0;
108a0b: 89 8d 34 ff ff ff mov %ecx,-0xcc(%ebp) <== NOT EXECUTED
handle->buffer = NULL;
108a11: 89 b5 38 ff ff ff mov %esi,-0xc8(%ebp) <== NOT EXECUTED
108a17: e8 04 2a 02 00 call 12b420 <strerror> <== NOT EXECUTED
108a1c: 89 5c 24 08 mov %ebx,0x8(%esp) <== NOT EXECUTED
108a20: c7 04 24 a4 41 13 00 movl $0x1341a4,(%esp) <== NOT EXECUTED
108a27: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
108a2b: 8b 85 24 ff ff ff mov -0xdc(%ebp),%eax <== NOT EXECUTED
108a31: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
108a35: e8 06 97 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
return false;
108a3a: e9 d6 fc ff ff jmp 108715 <rtems_rfs_format+0x8b5> <== NOT EXECUTED
108a3f: 90 nop <== NOT EXECUTED
if (fs->group_blocks > rtems_rfs_bitmap_numof_bits (fs->block_size))
108a40: 39 d8 cmp %ebx,%eax <== NOT EXECUTED
108a42: 0f 86 f7 f4 ff ff jbe 107f3f <rtems_rfs_format+0xdf> <== NOT EXECUTED
printf ("group block count is higher than bits in block\n");
108a48: c7 04 24 30 3d 13 00 movl $0x133d30,(%esp) <== NOT EXECUTED
108a4f: e8 1c 97 ff ff call 102170 <__wrap_puts> <== NOT EXECUTED
errno = EINVAL;
108a54: e8 a7 1a 02 00 call 12a500 <__errno> <== NOT EXECUTED
return -1;
108a59: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED
errno = EINVAL;
108a5e: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
return -1;
108a64: e9 3c fc ff ff jmp 1086a5 <rtems_rfs_format+0x845> <== NOT EXECUTED
108a69: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
memset (rtems_rfs_buffer_data (&handle), 0x00, rtems_rfs_fs_block_size (fs));
108a70: a8 01 test $0x1,%al
108a72: 0f 85 e3 05 00 00 jne 10905b <rtems_rfs_format+0x11fb> <== NEVER TAKEN
108a78: f7 c7 02 00 00 00 test $0x2,%edi
108a7e: 0f 85 c7 05 00 00 jne 10904b <rtems_rfs_format+0x11eb> <== NEVER TAKEN
108a84: f7 c7 04 00 00 00 test $0x4,%edi
108a8a: 0f 85 aa 05 00 00 jne 10903a <rtems_rfs_format+0x11da> <== NEVER TAKEN
108a90: 89 d1 mov %edx,%ecx
108a92: 31 c0 xor %eax,%eax
108a94: c1 e9 02 shr $0x2,%ecx
108a97: 83 e2 03 and $0x3,%edx
108a9a: f3 ab rep stos %eax,%es:(%edi)
108a9c: e9 2d f9 ff ff jmp 1083ce <rtems_rfs_format+0x56e>
108aa1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
108aa8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
108aaf: 90 nop
fs->inodes_per_block = rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE;
108ab0: 89 55 94 mov %edx,-0x6c(%ebp) <== NOT EXECUTED
return ((dividend - 1) / divisor) + 1;
108ab3: 31 d2 xor %edx,%edx
fs->inodes_per_block) * fs->inodes_per_block;
108ab5: 89 fe mov %edi,%esi
return ((dividend - 1) / divisor) + 1;
108ab7: 8d 43 ff lea -0x1(%ebx),%eax
108aba: f7 f7 div %edi
108abc: 40 inc %eax
fs->inodes_per_block) * fs->inodes_per_block;
108abd: 0f af f0 imul %eax,%esi
if (fs->group_inodes > rtems_rfs_bitmap_numof_bits (fs->block_size))
108ac0: 39 b5 20 ff ff ff cmp %esi,-0xe0(%ebp)
108ac6: 0f 83 45 f5 ff ff jae 108011 <rtems_rfs_format+0x1b1> <== ALWAYS TAKEN
fs->group_inodes = rtems_rfs_bitmap_numof_bits (fs->block_size);
108acc: 8b 85 20 ff ff ff mov -0xe0(%ebp),%eax <== NOT EXECUTED
108ad2: 89 45 90 mov %eax,-0x70(%ebp) <== NOT EXECUTED
fs->max_name_length = config->max_name_length;
108ad5: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
108ad8: 8b 40 10 mov 0x10(%eax),%eax <== NOT EXECUTED
if (!fs->max_name_length)
108adb: 85 c0 test %eax,%eax <== NOT EXECUTED
108add: 0f 84 3f f5 ff ff je 108022 <rtems_rfs_format+0x1c2> <== NOT EXECUTED
fs->max_name_length = config->max_name_length;
108ae3: 89 45 80 mov %eax,-0x80(%ebp) <== NOT EXECUTED
if (config->verbose)
108ae6: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
108ae9: 80 78 15 00 cmpb $0x0,0x15(%eax) <== NOT EXECUTED
108aed: 0f 84 43 f5 ff ff je 108036 <rtems_rfs_format+0x1d6> <== NOT EXECUTED
printf ("rtems-rfs: format: media size = %" PRIu64 "\n",
108af3: 8d 85 64 ff ff ff lea -0x9c(%ebp),%eax <== NOT EXECUTED
108af9: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
108afc: e8 8f 0b 01 00 call 119690 <rtems_rfs_fs_media_size> <== NOT EXECUTED
108b01: c7 04 24 60 3d 13 00 movl $0x133d60,(%esp) <== NOT EXECUTED
108b08: 89 54 24 08 mov %edx,0x8(%esp) <== NOT EXECUTED
108b0c: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
108b10: e8 2b 96 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
printf ("rtems-rfs: format: media blocks = %" PRIu32 "\n",
108b15: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax <== NOT EXECUTED
108b1b: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED
108b1e: c7 04 24 88 3d 13 00 movl $0x133d88,(%esp) <== NOT EXECUTED
108b25: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
108b29: e8 12 96 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
printf ("rtems-rfs: format: media block size = %" PRIu32 "\n",
108b2e: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax <== NOT EXECUTED
108b34: 8b 40 20 mov 0x20(%eax),%eax <== NOT EXECUTED
108b37: c7 04 24 b0 3d 13 00 movl $0x133db0,(%esp) <== NOT EXECUTED
108b3e: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
108b42: e8 f9 95 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
printf ("rtems-rfs: format: size = %" PRIu64 "\n",
108b47: 8d 85 64 ff ff ff lea -0x9c(%ebp),%eax <== NOT EXECUTED
108b4d: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
108b50: e8 2b 0b 01 00 call 119680 <rtems_rfs_fs_size> <== NOT EXECUTED
108b55: c7 04 24 dc 3d 13 00 movl $0x133ddc,(%esp) <== NOT EXECUTED
108b5c: 89 54 24 08 mov %edx,0x8(%esp) <== NOT EXECUTED
108b60: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
108b64: e8 d7 95 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
printf ("rtems-rfs: format: blocks = %zu\n",
108b69: 8b 85 68 ff ff ff mov -0x98(%ebp),%eax <== NOT EXECUTED
108b6f: c7 04 24 fc 3d 13 00 movl $0x133dfc,(%esp) <== NOT EXECUTED
108b76: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
108b7a: e8 c1 95 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
printf ("rtems-rfs: format: block size = %zu\n",
108b7f: 8b 85 6c ff ff ff mov -0x94(%ebp),%eax <== NOT EXECUTED
108b85: c7 04 24 20 3e 13 00 movl $0x133e20,(%esp) <== NOT EXECUTED
108b8c: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
108b90: e8 ab 95 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
return rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs));
108b95: 8b 85 6c ff ff ff mov -0x94(%ebp),%eax <== NOT EXECUTED
printf ("rtems-rfs: format: bits per block = %u\n",
108b9b: c7 04 24 48 3e 13 00 movl $0x133e48,(%esp) <== NOT EXECUTED
return rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs));
108ba2: c1 e0 03 shl $0x3,%eax <== NOT EXECUTED
printf ("rtems-rfs: format: bits per block = %u\n",
108ba5: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
108ba9: e8 92 95 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
108bae: ba 38 00 00 00 mov $0x38,%edx <== NOT EXECUTED
108bb3: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
108bb7: c7 04 24 70 3e 13 00 movl $0x133e70,(%esp) <== NOT EXECUTED
108bbe: e8 7d 95 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
blocks = rtems_rfs_rup_quotient(fs->group_inodes * RTEMS_RFS_INODE_SIZE,
108bc3: 8b 5d 90 mov -0x70(%ebp),%ebx <== NOT EXECUTED
rtems_rfs_fs_block_size (fs));
108bc6: 8b 8d 6c ff ff ff mov -0x94(%ebp),%ecx <== NOT EXECUTED
blocks = rtems_rfs_rup_quotient(fs->group_inodes * RTEMS_RFS_INODE_SIZE,
108bcc: 8d 04 dd 00 00 00 00 lea 0x0(,%ebx,8),%eax <== NOT EXECUTED
108bd3: 29 d8 sub %ebx,%eax <== NOT EXECUTED
if (dividend == 0)
108bd5: c1 e0 03 shl $0x3,%eax <== NOT EXECUTED
108bd8: 0f 84 41 03 00 00 je 108f1f <rtems_rfs_format+0x10bf> <== NOT EXECUTED
return ((dividend - 1) / divisor) + 1;
108bde: 48 dec %eax <== NOT EXECUTED
108bdf: 31 d2 xor %edx,%edx <== NOT EXECUTED
108be1: f7 f1 div %ecx <== NOT EXECUTED
return ((blocks + 1) * 100 * 10) / bits_per_block;
108be3: 83 c0 02 add $0x2,%eax <== NOT EXECUTED
108be6: 69 c0 e8 03 00 00 imul $0x3e8,%eax,%eax <== NOT EXECUTED
return rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs));
108bec: 8d 14 cd 00 00 00 00 lea 0x0(,%ecx,8),%edx <== NOT EXECUTED
return ((blocks + 1) * 100 * 10) / bits_per_block;
108bf3: 8b 8d 68 ff ff ff mov -0x98(%ebp),%ecx <== NOT EXECUTED
108bf9: 8d 79 ff lea -0x1(%ecx),%edi <== NOT EXECUTED
108bfc: 39 d7 cmp %edx,%edi <== NOT EXECUTED
108bfe: 76 02 jbe 108c02 <rtems_rfs_format+0xda2> <== NOT EXECUTED
108c00: 89 d7 mov %edx,%edi <== NOT EXECUTED
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
108c02: c7 04 24 98 3e 13 00 movl $0x133e98,(%esp) <== NOT EXECUTED
return ((blocks + 1) * 100 * 10) / bits_per_block;
108c09: 99 cltd <== NOT EXECUTED
108c0a: f7 ff idiv %edi <== NOT EXECUTED
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
108c0c: bf 67 66 66 66 mov $0x66666667,%edi <== NOT EXECUTED
return ((blocks + 1) * 100 * 10) / bits_per_block;
108c11: 89 c1 mov %eax,%ecx <== NOT EXECUTED
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
108c13: f7 ef imul %edi <== NOT EXECUTED
108c15: 89 ce mov %ecx,%esi <== NOT EXECUTED
108c17: c1 fe 1f sar $0x1f,%esi <== NOT EXECUTED
108c1a: 89 d0 mov %edx,%eax <== NOT EXECUTED
108c1c: 89 ca mov %ecx,%edx <== NOT EXECUTED
108c1e: c1 f8 02 sar $0x2,%eax <== NOT EXECUTED
108c21: 29 f0 sub %esi,%eax <== NOT EXECUTED
108c23: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED
108c26: 01 c0 add %eax,%eax <== NOT EXECUTED
108c28: 29 c2 sub %eax,%edx <== NOT EXECUTED
108c2a: 89 c8 mov %ecx,%eax <== NOT EXECUTED
108c2c: 89 54 24 0c mov %edx,0xc(%esp) <== NOT EXECUTED
108c30: f7 ef imul %edi <== NOT EXECUTED
108c32: 8b 45 88 mov -0x78(%ebp),%eax <== NOT EXECUTED
108c35: 0f af d8 imul %eax,%ebx <== NOT EXECUTED
108c38: 89 d7 mov %edx,%edi <== NOT EXECUTED
108c3a: c1 ff 02 sar $0x2,%edi <== NOT EXECUTED
108c3d: 29 f7 sub %esi,%edi <== NOT EXECUTED
108c3f: 89 7c 24 08 mov %edi,0x8(%esp) <== NOT EXECUTED
108c43: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
108c47: e8 f4 94 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
printf ("rtems-rfs: format: groups = %u\n", fs.group_count);
108c4c: 8b 45 88 mov -0x78(%ebp),%eax <== NOT EXECUTED
108c4f: c7 04 24 c4 3e 13 00 movl $0x133ec4,(%esp) <== NOT EXECUTED
108c56: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
108c5a: e8 e1 94 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
printf ("rtems-rfs: format: group blocks = %zu\n", fs.group_blocks);
108c5f: 8b 45 8c mov -0x74(%ebp),%eax <== NOT EXECUTED
108c62: c7 04 24 e4 3e 13 00 movl $0x133ee4,(%esp) <== NOT EXECUTED
108c69: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
108c6d: e8 ce 94 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
printf ("rtems-rfs: format: group inodes = %zu\n", fs.group_inodes);
108c72: 8b 45 90 mov -0x70(%ebp),%eax <== NOT EXECUTED
108c75: c7 04 24 0c 3f 13 00 movl $0x133f0c,(%esp) <== NOT EXECUTED
108c7c: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
108c80: e8 bb 94 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
rc = rtems_rfs_buffer_setblksize (&fs, rtems_rfs_fs_block_size (&fs));
108c85: 8b 85 6c ff ff ff mov -0x94(%ebp),%eax <== NOT EXECUTED
108c8b: 89 85 24 ff ff ff mov %eax,-0xdc(%ebp) <== NOT EXECUTED
108c91: e9 a0 f3 ff ff jmp 108036 <rtems_rfs_format+0x1d6> <== NOT EXECUTED
108c96: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
108c9d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
uint64_t total_size = rtems_rfs_fs_media_size (fs);
108ca0: 8d 85 64 ff ff ff lea -0x9c(%ebp),%eax
108ca6: 89 04 24 mov %eax,(%esp)
108ca9: e8 e2 09 01 00 call 119690 <rtems_rfs_fs_media_size>
if (total_size >= GIGS (1))
108cae: b9 ff ff 0f 00 mov $0xfffff,%ecx
108cb3: 39 c1 cmp %eax,%ecx
108cb5: 19 d3 sbb %edx,%ebx
108cb7: 0f 82 43 01 00 00 jb 108e00 <rtems_rfs_format+0xfa0> <== NEVER TAKEN
if (fs->block_size < 512)
108cbd: 8b 9d 6c ff ff ff mov -0x94(%ebp),%ebx
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
108cc3: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax
if (fs->block_size < 512)
108cc9: 81 fb ff 01 00 00 cmp $0x1ff,%ebx
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
108ccf: 8b 48 20 mov 0x20(%eax),%ecx
if (fs->block_size < 512)
108cd2: 0f 87 07 01 00 00 ja 108ddf <rtems_rfs_format+0xf7f> <== NEVER TAKEN
fs->block_size = 512;
108cd8: b8 00 02 00 00 mov $0x200,%eax
108cdd: bb 00 02 00 00 mov $0x200,%ebx
108ce2: 89 85 6c ff ff ff mov %eax,-0x94(%ebp)
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
108ce8: 31 d2 xor %edx,%edx
108cea: 89 d8 mov %ebx,%eax
108cec: f7 f1 div %ecx
108cee: 85 d2 test %edx,%edx
108cf0: 0f 84 32 f2 ff ff je 107f28 <rtems_rfs_format+0xc8>
printf ("block size (%zd) is not a multiple of media block size (%" PRId32 ")\n",
108cf6: 89 4c 24 08 mov %ecx,0x8(%esp) <== NOT EXECUTED
108cfa: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
108cfe: c7 04 24 f0 3c 13 00 movl $0x133cf0,(%esp) <== NOT EXECUTED
108d05: e8 36 94 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
return false;
108d0a: e9 45 fd ff ff jmp 108a54 <rtems_rfs_format+0xbf4> <== NOT EXECUTED
108d0f: 90 nop <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
108d10: e8 9b eb ff ff call 1078b0 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->bnum = 0;
108d15: 31 d2 xor %edx,%edx <== NOT EXECUTED
handle->buffer = NULL;
108d17: 31 c9 xor %ecx,%ecx <== NOT EXECUTED
printf ("rtems-rfs: write-superblock: buffer release failed: %d: %s\n",
108d19: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
handle->dirty = false;
108d1c: c6 85 3c ff ff ff 00 movb $0x0,-0xc4(%ebp) <== NOT EXECUTED
handle->bnum = 0;
108d23: 89 95 40 ff ff ff mov %edx,-0xc0(%ebp) <== NOT EXECUTED
handle->buffer = NULL;
108d29: 89 8d 44 ff ff ff mov %ecx,-0xbc(%ebp) <== NOT EXECUTED
108d2f: e8 ec 26 02 00 call 12b420 <strerror> <== NOT EXECUTED
108d34: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
108d38: c7 04 24 a4 3f 13 00 movl $0x133fa4,(%esp) <== NOT EXECUTED
108d3f: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
108d43: e8 f8 93 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
return false;
108d48: e9 68 fc ff ff jmp 1089b5 <rtems_rfs_format+0xb55> <== NOT EXECUTED
108d4d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
108d50: f6 c2 01 test $0x1,%dl
108d53: 0f 85 90 03 00 00 jne 1090e9 <rtems_rfs_format+0x1289> <== NEVER TAKEN
108d59: f7 c7 02 00 00 00 test $0x2,%edi
108d5f: 90 nop
108d60: 0f 85 73 03 00 00 jne 1090d9 <rtems_rfs_format+0x1279> <== NEVER TAKEN
108d66: f7 c7 04 00 00 00 test $0x4,%edi
108d6c: 0f 85 56 03 00 00 jne 1090c8 <rtems_rfs_format+0x1268> <== NEVER TAKEN
108d72: 89 d9 mov %ebx,%ecx
108d74: b8 ff ff ff ff mov $0xffffffff,%eax
108d79: c1 e9 02 shr $0x2,%ecx
108d7c: 83 e3 03 and $0x3,%ebx
108d7f: f3 ab rep stos %eax,%es:(%edi)
108d81: e9 35 f3 ff ff jmp 1080bb <rtems_rfs_format+0x25b>
return 1;
108d86: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED
108d8b: 89 9d 1c ff ff ff mov %ebx,-0xe4(%ebp) <== NOT EXECUTED
108d91: e9 00 f2 ff ff jmp 107f96 <rtems_rfs_format+0x136> <== NOT EXECUTED
rc = errno;
108d96: e8 65 17 02 00 call 12a500 <__errno> <== NOT EXECUTED
108d9b: 8b 18 mov (%eax),%ebx <== NOT EXECUTED
printf ("rtems-rfs: format: file system open failed: %d: %s\n",
108d9d: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
108da0: e8 7b 26 02 00 call 12b420 <strerror> <== NOT EXECUTED
108da5: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
108da9: c7 04 24 b0 42 13 00 movl $0x1342b0,(%esp) <== NOT EXECUTED
108db0: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
108db4: e8 87 93 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
if (rc != 0)
108db9: 85 db test %ebx,%ebx <== NOT EXECUTED
108dbb: 0f 85 9c 01 00 00 jne 108f5d <rtems_rfs_format+0x10fd> <== NOT EXECUTED
}
108dc1: 81 c4 0c 01 00 00 add $0x10c,%esp <== NOT EXECUTED
108dc7: 89 d8 mov %ebx,%eax <== NOT EXECUTED
108dc9: 5b pop %ebx <== NOT EXECUTED
108dca: 5e pop %esi <== NOT EXECUTED
108dcb: 5f pop %edi <== NOT EXECUTED
108dcc: 5d pop %ebp <== NOT EXECUTED
108dcd: c3 ret <== NOT EXECUTED
printf ("\n");
108dce: c7 04 24 0a 00 00 00 movl $0xa,(%esp) <== NOT EXECUTED
108dd5: e8 b6 1c 02 00 call 12aa90 <putchar> <== NOT EXECUTED
108dda: e9 7b f7 ff ff jmp 10855a <rtems_rfs_format+0x6fa> <== NOT EXECUTED
if (fs->block_size > (4 * 1024))
108ddf: 81 fb 00 10 00 00 cmp $0x1000,%ebx <== NOT EXECUTED
108de5: 0f 86 2f f1 ff ff jbe 107f1a <rtems_rfs_format+0xba> <== NOT EXECUTED
fs->block_size = (4 * 1024);
108deb: b8 00 10 00 00 mov $0x1000,%eax <== NOT EXECUTED
108df0: bb 00 10 00 00 mov $0x1000,%ebx <== NOT EXECUTED
108df5: 89 85 6c ff ff ff mov %eax,-0x94(%ebp) <== NOT EXECUTED
108dfb: e9 1a f1 ff ff jmp 107f1a <rtems_rfs_format+0xba> <== NOT EXECUTED
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
108e00: 05 00 00 10 00 add $0x100000,%eax <== NOT EXECUTED
for (b = 31; b > 0; b--)
108e05: b9 1f 00 00 00 mov $0x1f,%ecx <== NOT EXECUTED
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
108e0a: 83 d2 00 adc $0x0,%edx <== NOT EXECUTED
108e0d: 0f ac d0 14 shrd $0x14,%edx,%eax <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
108e11: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED
108e16: eb 0f jmp 108e27 <rtems_rfs_format+0xfc7> <== NOT EXECUTED
108e18: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
108e1f: 90 nop <== NOT EXECUTED
for (b = 31; b > 0; b--)
108e20: 49 dec %ecx <== NOT EXECUTED
108e21: 0f 84 b9 01 00 00 je 108fe0 <rtems_rfs_format+0x1180> <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
108e27: 89 d3 mov %edx,%ebx <== NOT EXECUTED
108e29: d3 e3 shl %cl,%ebx <== NOT EXECUTED
108e2b: 85 d8 test %ebx,%eax <== NOT EXECUTED
108e2d: 74 f1 je 108e20 <rtems_rfs_format+0xfc0> <== NOT EXECUTED
fs->block_size = 1 << b;
108e2f: 89 9d 6c ff ff ff mov %ebx,-0x94(%ebp) <== NOT EXECUTED
108e35: e9 89 fe ff ff jmp 108cc3 <rtems_rfs_format+0xe63> <== NOT EXECUTED
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
108e3a: c7 07 ff ff ff ff movl $0xffffffff,(%edi) <== NOT EXECUTED
108e40: 83 ea 04 sub $0x4,%edx <== NOT EXECUTED
108e43: 83 c7 04 add $0x4,%edi <== NOT EXECUTED
108e46: e9 f7 f9 ff ff jmp 108842 <rtems_rfs_format+0x9e2> <== NOT EXECUTED
108e4b: 66 c7 07 ff ff movw $0xffff,(%edi) <== NOT EXECUTED
108e50: 83 ea 02 sub $0x2,%edx <== NOT EXECUTED
108e53: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
108e56: e9 db f9 ff ff jmp 108836 <rtems_rfs_format+0x9d6> <== NOT EXECUTED
108e5b: c6 00 ff movb $0xff,(%eax) <== NOT EXECUTED
108e5e: 47 inc %edi <== NOT EXECUTED
108e5f: 4a dec %edx <== NOT EXECUTED
108e60: e9 c3 f9 ff ff jmp 108828 <rtems_rfs_format+0x9c8> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
108e65: 8d 85 30 ff ff ff lea -0xd0(%ebp),%eax <== NOT EXECUTED
108e6b: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
108e6f: 8d 85 64 ff ff ff lea -0x9c(%ebp),%eax <== NOT EXECUTED
108e75: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
108e78: e8 33 ea ff ff call 1078b0 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->bnum = 0;
108e7d: 31 c0 xor %eax,%eax <== NOT EXECUTED
handle->buffer = NULL;
108e7f: 31 d2 xor %edx,%edx <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: close inode" \
108e81: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
handle->dirty = false;
108e84: c6 85 30 ff ff ff 00 movb $0x0,-0xd0(%ebp) <== NOT EXECUTED
handle->bnum = 0;
108e8b: 89 85 34 ff ff ff mov %eax,-0xcc(%ebp) <== NOT EXECUTED
handle->buffer = NULL;
108e91: 89 95 38 ff ff ff mov %edx,-0xc8(%ebp) <== NOT EXECUTED
108e97: e8 84 25 02 00 call 12b420 <strerror> <== NOT EXECUTED
108e9c: 89 5c 24 08 mov %ebx,0x8(%esp) <== NOT EXECUTED
108ea0: c7 04 24 f0 41 13 00 movl $0x1341f0,(%esp) <== NOT EXECUTED
108ea7: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
108eab: 8b 85 24 ff ff ff mov -0xdc(%ebp),%eax <== NOT EXECUTED
108eb1: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
108eb5: e8 86 92 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
return false;
108eba: e9 56 f8 ff ff jmp 108715 <rtems_rfs_format+0x8b5> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
108ebf: 89 c7 mov %eax,%edi <== NOT EXECUTED
108ec1: 8d 85 30 ff ff ff lea -0xd0(%ebp),%eax <== NOT EXECUTED
108ec7: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
108ecb: 8d 85 64 ff ff ff lea -0x9c(%ebp),%eax <== NOT EXECUTED
108ed1: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
108ed4: e8 d7 e9 ff ff call 1078b0 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->bnum = 0;
108ed9: 31 c0 xor %eax,%eax <== NOT EXECUTED
108edb: 89 85 34 ff ff ff mov %eax,-0xcc(%ebp) <== NOT EXECUTED
handle->buffer = NULL;
108ee1: 31 c0 xor %eax,%eax <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: block %" PRId32 " request failed: %d: %s\n",
108ee3: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
handle->dirty = false;
108ee6: c6 85 30 ff ff ff 00 movb $0x0,-0xd0(%ebp) <== NOT EXECUTED
handle->buffer = NULL;
108eed: 89 85 38 ff ff ff mov %eax,-0xc8(%ebp) <== NOT EXECUTED
108ef3: e8 28 25 02 00 call 12b420 <strerror> <== NOT EXECUTED
108ef8: 89 7c 24 0c mov %edi,0xc(%esp) <== NOT EXECUTED
108efc: 89 5c 24 08 mov %ebx,0x8(%esp) <== NOT EXECUTED
108f00: c7 04 24 38 42 13 00 movl $0x134238,(%esp) <== NOT EXECUTED
108f07: 89 44 24 10 mov %eax,0x10(%esp) <== NOT EXECUTED
108f0b: 8b 85 24 ff ff ff mov -0xdc(%ebp),%eax <== NOT EXECUTED
108f11: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
108f15: e8 26 92 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
return false;
108f1a: e9 f6 f7 ff ff jmp 108715 <rtems_rfs_format+0x8b5> <== NOT EXECUTED
108f1f: b8 d0 07 00 00 mov $0x7d0,%eax <== NOT EXECUTED
108f24: e9 c3 fc ff ff jmp 108bec <rtems_rfs_format+0xd8c> <== NOT EXECUTED
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
108f29: c7 07 ff ff ff ff movl $0xffffffff,(%edi) <== NOT EXECUTED
108f2f: 83 ea 04 sub $0x4,%edx <== NOT EXECUTED
108f32: 83 c7 04 add $0x4,%edi <== NOT EXECUTED
108f35: e9 ad f5 ff ff jmp 1084e7 <rtems_rfs_format+0x687> <== NOT EXECUTED
printf ("rtems-rfs: format: allocated inode not root ino: %" PRId32 "\n", ino);
108f3a: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
return EINVAL;
108f3e: bb 16 00 00 00 mov $0x16,%ebx <== NOT EXECUTED
printf ("rtems-rfs: format: allocated inode not root ino: %" PRId32 "\n", ino);
108f43: c7 04 24 18 43 13 00 movl $0x134318,(%esp) <== NOT EXECUTED
108f4a: e8 f1 91 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
rtems_rfs_fs_close (fs);
108f4f: 8b 85 2c ff ff ff mov -0xd4(%ebp),%eax <== NOT EXECUTED
108f55: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
108f58: e8 13 0f 01 00 call 119e70 <rtems_rfs_fs_close> <== NOT EXECUTED
printf ("rtems-rfs: format: writing root dir failed: %d: %s\n",
108f5d: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
108f60: e8 bb 24 02 00 call 12b420 <strerror> <== NOT EXECUTED
108f65: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
108f69: c7 04 24 50 44 13 00 movl $0x134450,(%esp) <== NOT EXECUTED
108f70: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
108f74: e8 c7 91 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
errno = rc;
108f79: e8 82 15 02 00 call 12a500 <__errno> <== NOT EXECUTED
108f7e: 89 18 mov %ebx,(%eax) <== NOT EXECUTED
return -1;
108f80: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED
108f85: e9 1b f7 ff ff jmp 1086a5 <rtems_rfs_format+0x845> <== NOT EXECUTED
108f8a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
108f90: 66 c7 07 ff ff movw $0xffff,(%edi) <== NOT EXECUTED
108f95: 83 ea 02 sub $0x2,%edx <== NOT EXECUTED
108f98: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
108f9b: e9 3b f5 ff ff jmp 1084db <rtems_rfs_format+0x67b> <== NOT EXECUTED
108fa0: c6 00 ff movb $0xff,(%eax) <== NOT EXECUTED
108fa3: 47 inc %edi <== NOT EXECUTED
108fa4: 4a dec %edx <== NOT EXECUTED
108fa5: e9 25 f5 ff ff jmp 1084cf <rtems_rfs_format+0x66f> <== NOT EXECUTED
108faa: 89 fb mov %edi,%ebx
108fac: e9 49 f0 ff ff jmp 107ffa <rtems_rfs_format+0x19a>
printf ("rtems-rfs: format: inode allocation failed: %d: %s\n",
108fb1: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
108fb4: e8 67 24 02 00 call 12b420 <strerror> <== NOT EXECUTED
108fb9: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
108fbd: c7 04 24 e4 42 13 00 movl $0x1342e4,(%esp) <== NOT EXECUTED
108fc4: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
108fc8: e8 73 91 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
rtems_rfs_fs_close (fs);
108fcd: 8b 85 2c ff ff ff mov -0xd4(%ebp),%eax <== NOT EXECUTED
108fd3: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
108fd6: e8 95 0e 01 00 call 119e70 <rtems_rfs_fs_close> <== NOT EXECUTED
return rc;
108fdb: e9 7d ff ff ff jmp 108f5d <rtems_rfs_format+0x10fd> <== NOT EXECUTED
108fe0: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED
108fe5: e9 45 fe ff ff jmp 108e2f <rtems_rfs_format+0xfcf> <== NOT EXECUTED
printf ("rtems-rfs: format: inode open failed: %d: %s\n",
108fea: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
108fed: e8 2e 24 02 00 call 12b420 <strerror> <== NOT EXECUTED
108ff2: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
108ff6: c7 04 24 50 43 13 00 movl $0x134350,(%esp) <== NOT EXECUTED
108ffd: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
109001: e8 3a 91 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
rtems_rfs_group_bitmap_free (fs, true, ino);
109006: 8b 85 30 ff ff ff mov -0xd0(%ebp),%eax <== NOT EXECUTED
10900c: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
109010: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
109015: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
109019: 8b 85 2c ff ff ff mov -0xd4(%ebp),%eax <== NOT EXECUTED
10901f: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
109022: e8 d9 07 00 00 call 109800 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
rtems_rfs_fs_close (fs);
109027: 8b 85 2c ff ff ff mov -0xd4(%ebp),%eax <== NOT EXECUTED
10902d: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
109030: e8 3b 0e 01 00 call 119e70 <rtems_rfs_fs_close> <== NOT EXECUTED
return rc;
109035: e9 23 ff ff ff jmp 108f5d <rtems_rfs_format+0x10fd> <== NOT EXECUTED
memset (rtems_rfs_buffer_data (&handle), 0x00, rtems_rfs_fs_block_size (fs));
10903a: c7 07 00 00 00 00 movl $0x0,(%edi) <== NOT EXECUTED
109040: 83 ea 04 sub $0x4,%edx <== NOT EXECUTED
109043: 83 c7 04 add $0x4,%edi <== NOT EXECUTED
109046: e9 45 fa ff ff jmp 108a90 <rtems_rfs_format+0xc30> <== NOT EXECUTED
10904b: 66 c7 07 00 00 movw $0x0,(%edi) <== NOT EXECUTED
109050: 83 ea 02 sub $0x2,%edx <== NOT EXECUTED
109053: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
109056: e9 29 fa ff ff jmp 108a84 <rtems_rfs_format+0xc24> <== NOT EXECUTED
10905b: c6 00 00 movb $0x0,(%eax) <== NOT EXECUTED
10905e: 47 inc %edi <== NOT EXECUTED
10905f: 4a dec %edx <== NOT EXECUTED
109060: e9 13 fa ff ff jmp 108a78 <rtems_rfs_format+0xc18> <== NOT EXECUTED
printf ("rtems-rfs: format: inode close failed: %d: %s\n",
109065: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
109068: e8 b3 23 02 00 call 12b420 <strerror> <== NOT EXECUTED
10906d: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
109071: c7 04 24 e8 43 13 00 movl $0x1343e8,(%esp) <== NOT EXECUTED
109078: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
10907c: e8 bf 90 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
109081: e9 07 f6 ff ff jmp 10868d <rtems_rfs_format+0x82d> <== NOT EXECUTED
printf ("rtems-rfs: format: directory add failed: %d: %s\n",
109086: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
109089: e8 92 23 02 00 call 12b420 <strerror> <== NOT EXECUTED
10908e: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
109092: c7 04 24 b4 43 13 00 movl $0x1343b4,(%esp) <== NOT EXECUTED
109099: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
10909d: e8 9e 90 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
1090a2: e9 ca f5 ff ff jmp 108671 <rtems_rfs_format+0x811> <== NOT EXECUTED
printf ("rtems-rfs: format: inode initialise failed: %d: %s\n",
1090a7: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
1090aa: e8 71 23 02 00 call 12b420 <strerror> <== NOT EXECUTED
1090af: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
1090b3: c7 04 24 80 43 13 00 movl $0x134380,(%esp) <== NOT EXECUTED
1090ba: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
1090be: e8 7d 90 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
1090c3: e9 71 f5 ff ff jmp 108639 <rtems_rfs_format+0x7d9> <== NOT EXECUTED
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
1090c8: c7 07 ff ff ff ff movl $0xffffffff,(%edi) <== NOT EXECUTED
1090ce: 83 eb 04 sub $0x4,%ebx <== NOT EXECUTED
1090d1: 83 c7 04 add $0x4,%edi <== NOT EXECUTED
1090d4: e9 99 fc ff ff jmp 108d72 <rtems_rfs_format+0xf12> <== NOT EXECUTED
1090d9: 66 c7 07 ff ff movw $0xffff,(%edi) <== NOT EXECUTED
1090de: 83 eb 02 sub $0x2,%ebx <== NOT EXECUTED
1090e1: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
1090e4: e9 7d fc ff ff jmp 108d66 <rtems_rfs_format+0xf06> <== NOT EXECUTED
1090e9: c6 02 ff movb $0xff,(%edx) <== NOT EXECUTED
1090ec: 8d 7a 01 lea 0x1(%edx),%edi <== NOT EXECUTED
1090ef: 4b dec %ebx <== NOT EXECUTED
1090f0: e9 64 fc ff ff jmp 108d59 <rtems_rfs_format+0xef9> <== NOT EXECUTED
rc = errno;
1090f5: e8 06 14 02 00 call 12a500 <__errno> <== NOT EXECUTED
1090fa: 8b 18 mov (%eax),%ebx <== NOT EXECUTED
printf ("rtems-rfs: format: file system close failed: %d: %s\n",
1090fc: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
1090ff: e8 1c 23 02 00 call 12b420 <strerror> <== NOT EXECUTED
109104: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
109108: c7 04 24 18 44 13 00 movl $0x134418,(%esp) <== NOT EXECUTED
10910f: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
109113: e8 28 90 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
return rc;
109118: e9 9c fc ff ff jmp 108db9 <rtems_rfs_format+0xf59> <== NOT EXECUTED
printf ("rtems-rfs: format: setting block size failed: %d: %s\n",
10911d: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
109120: 89 c6 mov %eax,%esi <== NOT EXECUTED
return -1;
109122: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED
printf ("rtems-rfs: format: setting block size failed: %d: %s\n",
109127: e8 f4 22 02 00 call 12b420 <strerror> <== NOT EXECUTED
10912c: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED
109130: c7 04 24 34 3f 13 00 movl $0x133f34,(%esp) <== NOT EXECUTED
109137: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
10913b: e8 00 90 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
errno = rc;
109140: e8 bb 13 02 00 call 12a500 <__errno> <== NOT EXECUTED
109145: 89 30 mov %esi,(%eax) <== NOT EXECUTED
return -1;
109147: e9 59 f5 ff ff jmp 1086a5 <rtems_rfs_format+0x845> <== NOT EXECUTED
printf ("rtems-rfs: media block is invalid: %" PRIu32 "\n",
10914c: c7 04 24 c8 3c 13 00 movl $0x133cc8,(%esp) <== NOT EXECUTED
109153: 31 c0 xor %eax,%eax <== NOT EXECUTED
return -1;
109155: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED
printf ("rtems-rfs: media block is invalid: %" PRIu32 "\n",
10915a: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
10915e: e8 dd 8f ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
errno = EINVAL;
109163: e8 98 13 02 00 call 12a500 <__errno> <== NOT EXECUTED
109168: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
return -1;
10916e: e9 32 f5 ff ff jmp 1086a5 <rtems_rfs_format+0x845> <== NOT EXECUTED
printf ("rtems-rfs: format: buffer close failed: %d: %s\n",
109173: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
109176: e8 a5 22 02 00 call 12b420 <strerror> <== NOT EXECUTED
10917b: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
10917f: c7 04 24 80 42 13 00 movl $0x134280,(%esp) <== NOT EXECUTED
109186: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
10918a: e8 b1 8f ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
errno = rc;
10918f: e8 6c 13 02 00 call 12a500 <__errno> <== NOT EXECUTED
109194: 89 18 mov %ebx,(%eax) <== NOT EXECUTED
return -1;
109196: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED
10919b: e9 05 f5 ff ff jmp 1086a5 <rtems_rfs_format+0x845> <== NOT EXECUTED
printf ("rtems-rfs: format: buffer open failed: %d: %s\n",
1091a0: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
1091a3: e8 78 22 02 00 call 12b420 <strerror> <== NOT EXECUTED
1091a8: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
1091ac: c7 04 24 98 3c 13 00 movl $0x133c98,(%esp) <== NOT EXECUTED
1091b3: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
1091b7: e8 84 8f ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
errno = rc;
1091bc: e8 3f 13 02 00 call 12a500 <__errno> <== NOT EXECUTED
1091c1: 89 18 mov %ebx,(%eax) <== NOT EXECUTED
return -1;
1091c3: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED
1091c8: e9 d8 f4 ff ff jmp 1086a5 <rtems_rfs_format+0x845> <== NOT EXECUTED
1091cd: 90 nop
1091ce: 90 nop
1091cf: 90 nop
00119e70 <rtems_rfs_fs_close>:
int
rtems_rfs_fs_close (rtems_rfs_file_system* fs)
{
119e70: 55 push %ebp
119e71: 89 e5 mov %esp,%ebp
119e73: 56 push %esi
119e74: 53 push %ebx
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
119e75: 31 db xor %ebx,%ebx
{
119e77: 83 ec 10 sub $0x10,%esp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
119e7a: c7 04 24 02 00 00 00 movl $0x2,(%esp)
{
119e81: 8b 75 08 mov 0x8(%ebp),%esi
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
119e84: 89 5c 24 04 mov %ebx,0x4(%esp)
119e88: e8 c3 19 ff ff call 10b850 <rtems_rfs_trace>
119e8d: 84 c0 test %al,%al
119e8f: 75 4f jne 119ee0 <rtems_rfs_fs_close+0x70> <== NEVER TAKEN
printf ("rtems-rfs: close\n");
for (group = 0; group < fs->group_count; group++)
119e91: 8b 4e 24 mov 0x24(%esi),%ecx
119e94: 85 c9 test %ecx,%ecx
119e96: 7e 25 jle 119ebd <rtems_rfs_fs_close+0x4d> <== NEVER TAKEN
119e98: 31 db xor %ebx,%ebx
119e9a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
rtems_rfs_group_close (fs, &fs->groups[group]);
119ea0: 8b 56 20 mov 0x20(%esi),%edx
119ea3: 8d 04 9b lea (%ebx,%ebx,4),%eax
for (group = 0; group < fs->group_count; group++)
119ea6: 43 inc %ebx
rtems_rfs_group_close (fs, &fs->groups[group]);
119ea7: 89 34 24 mov %esi,(%esp)
119eaa: c1 e0 04 shl $0x4,%eax
119ead: 01 d0 add %edx,%eax
119eaf: 89 44 24 04 mov %eax,0x4(%esp)
119eb3: e8 d8 f5 fe ff call 109490 <rtems_rfs_group_close>
for (group = 0; group < fs->group_count; group++)
119eb8: 39 5e 24 cmp %ebx,0x24(%esi)
119ebb: 7f e3 jg 119ea0 <rtems_rfs_fs_close+0x30> <== NEVER TAKEN
rtems_rfs_buffer_close (fs);
119ebd: 89 34 24 mov %esi,(%esp)
119ec0: e8 7b de fe ff call 107d40 <rtems_rfs_buffer_close>
free (fs);
119ec5: 89 34 24 mov %esi,(%esp)
119ec8: e8 13 86 fe ff call 1024e0 <free>
return 0;
}
119ecd: 83 c4 10 add $0x10,%esp
119ed0: 31 c0 xor %eax,%eax
119ed2: 5b pop %ebx
119ed3: 5e pop %esi
119ed4: 5d pop %ebp
119ed5: c3 ret
119ed6: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
119edd: 8d 76 00 lea 0x0(%esi),%esi
printf ("rtems-rfs: close\n");
119ee0: c7 04 24 65 61 13 00 movl $0x136165,(%esp) <== NOT EXECUTED
119ee7: e8 84 82 fe ff call 102170 <__wrap_puts> <== NOT EXECUTED
119eec: eb a3 jmp 119e91 <rtems_rfs_fs_close+0x21> <== NOT EXECUTED
119eee: 90 nop
119eef: 90 nop
001196b0 <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)
{
1196b0: 55 push %ebp
#endif
rtems_rfs_inode_handle inode;
uint16_t mode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
1196b1: 31 d2 xor %edx,%edx
{
1196b3: 89 e5 mov %esp,%ebp
1196b5: 57 push %edi
1196b6: 56 push %esi
1196b7: 53 push %ebx
1196b8: 83 ec 6c sub $0x6c,%esp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
1196bb: c7 04 24 01 00 00 00 movl $0x1,(%esp)
1196c2: 89 54 24 04 mov %edx,0x4(%esp)
1196c6: e8 85 21 ff ff call 10b850 <rtems_rfs_trace>
1196cb: 84 c0 test %al,%al
1196cd: 0f 85 fd 02 00 00 jne 1199d0 <rtems_rfs_fs_open+0x320> <== NEVER TAKEN
printf ("rtems-rfs: open: %s\n", name);
*fs = malloc (sizeof (rtems_rfs_file_system));
1196d3: c7 04 24 84 00 00 00 movl $0x84,(%esp)
1196da: e8 e1 8e fe ff call 1025c0 <malloc>
1196df: 8b 75 18 mov 0x18(%ebp),%esi
1196e2: 89 06 mov %eax,(%esi)
if (!*fs)
1196e4: 85 c0 test %eax,%eax
1196e6: 0f 84 fb 06 00 00 je 119de7 <rtems_rfs_fs_open+0x737> <== NEVER TAKEN
printf ("rtems-rfs: open: no memory for file system data\n");
errno = ENOMEM;
return -1;
}
memset (*fs, 0, sizeof (rtems_rfs_file_system));
1196ec: 8d 58 04 lea 0x4(%eax),%ebx
1196ef: 31 c9 xor %ecx,%ecx
1196f1: 31 d2 xor %edx,%edx
1196f3: 89 0c 13 mov %ecx,(%ebx,%edx,1)
1196f6: 89 4c 13 04 mov %ecx,0x4(%ebx,%edx,1)
1196fa: 83 c2 08 add $0x8,%edx
1196fd: 81 fa 80 00 00 00 cmp $0x80,%edx
119703: 72 ee jb 1196f3 <rtems_rfs_fs_open+0x43>
(*fs)->user = user;
119705: 8b 55 0c mov 0xc(%ebp),%edx
return &the_chain->Tail.Node;
119708: 8d 48 48 lea 0x48(%eax),%ecx
11970b: 89 48 44 mov %ecx,0x44(%eax)
11970e: 8d 48 58 lea 0x58(%eax),%ecx
119711: 89 48 54 mov %ecx,0x54(%eax)
119714: 8d 48 68 lea 0x68(%eax),%ecx
119717: 89 48 64 mov %ecx,0x64(%eax)
11971a: 8d 48 78 lea 0x78(%eax),%ecx
11971d: 89 90 80 00 00 00 mov %edx,0x80(%eax)
119723: 8d 50 44 lea 0x44(%eax),%edx
return &the_chain->Head.Node;
119726: 89 50 4c mov %edx,0x4c(%eax)
return &the_chain->Tail.Node;
119729: 8d 50 54 lea 0x54(%eax),%edx
return &the_chain->Head.Node;
11972c: 89 50 5c mov %edx,0x5c(%eax)
return &the_chain->Tail.Node;
11972f: 8d 50 64 lea 0x64(%eax),%edx
return &the_chain->Head.Node;
119732: 89 50 6c mov %edx,0x6c(%eax)
return &the_chain->Tail.Node;
119735: 8d 50 74 lea 0x74(%eax),%edx
return &the_chain->Head.Node;
119738: 89 50 7c mov %edx,0x7c(%eax)
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 = max_held_buffers;
11973b: 8b 55 14 mov 0x14(%ebp),%edx
return &the_chain->Tail.Node;
11973e: 89 48 74 mov %ecx,0x74(%eax)
119741: 89 50 40 mov %edx,0x40(%eax)
(*fs)->buffers_count = 0;
(*fs)->release_count = 0;
(*fs)->release_modified_count = 0;
(*fs)->flags = flags;
119744: 8b 55 10 mov 0x10(%ebp),%edx
119747: 89 10 mov %edx,(%eax)
#endif
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, *fs);
119749: 89 44 24 04 mov %eax,0x4(%esp)
11974d: 8b 45 08 mov 0x8(%ebp),%eax
119750: 89 04 24 mov %eax,(%esp)
119753: e8 88 e1 fe ff call 1078e0 <rtems_rfs_buffer_open>
119758: 89 c3 mov %eax,%ebx
if (rc > 0)
{
free (*fs);
11975a: 8b 45 18 mov 0x18(%ebp),%eax
if (rc > 0)
11975d: 85 db test %ebx,%ebx
11975f: 0f 8f 1c 05 00 00 jg 119c81 <rtems_rfs_fs_open+0x5d1> <== NEVER TAKEN
handle->dirty = false;
119765: c6 45 c0 00 movb $0x0,-0x40(%ebp)
rc, strerror (rc));
errno = rc;
return -1;
}
rc = rtems_rfs_fs_read_superblock (*fs);
119769: 8b 18 mov (%eax),%ebx
rc = rtems_rfs_buffer_handle_request (fs, &handle, 0, true);
11976b: b8 01 00 00 00 mov $0x1,%eax
119770: 89 44 24 0c mov %eax,0xc(%esp)
119774: 8d 75 c0 lea -0x40(%ebp),%esi
119777: 31 c0 xor %eax,%eax
119779: 89 44 24 08 mov %eax,0x8(%esp)
11977d: 89 74 24 04 mov %esi,0x4(%esp)
119781: 89 1c 24 mov %ebx,(%esp)
handle->bnum = 0;
119784: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp)
handle->buffer = NULL;
11978b: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp)
119792: e8 39 de fe ff call 1075d0 <rtems_rfs_buffer_handle_request>
if (rc > 0)
119797: 85 c0 test %eax,%eax
rc = rtems_rfs_buffer_handle_request (fs, &handle, 0, true);
119799: 89 c7 mov %eax,%edi
if (rc > 0)
11979b: 0f 8f df 02 00 00 jg 119a80 <rtems_rfs_fs_open+0x3d0> <== NEVER TAKEN
sb = rtems_rfs_buffer_data (&handle);
1197a1: 8b 45 c8 mov -0x38(%ebp),%eax
1197a4: 8b 78 1c mov 0x1c(%eax),%edi
if (read_sb (RTEMS_RFS_SB_OFFSET_MAGIC) != RTEMS_RFS_SB_MAGIC)
1197a7: 81 3f 28 09 20 01 cmpl $0x1200928,(%edi)
1197ad: 0f 85 0d 03 00 00 jne 119ac0 <rtems_rfs_fs_open+0x410> <== NEVER TAKEN
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
1197b3: 8b 47 0c mov 0xc(%edi),%eax
uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
1197b6: 8b 4b 10 mov 0x10(%ebx),%ecx
1197b9: 0f c8 bswap %eax
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
1197bb: 89 43 04 mov %eax,0x4(%ebx)
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
1197be: 8b 57 08 mov 0x8(%edi),%edx
1197c1: 0f ca bswap %edx
1197c3: 89 55 b4 mov %edx,-0x4c(%ebp)
1197c6: 89 53 08 mov %edx,0x8(%ebx)
return blocks * block_size;
1197c9: f7 e2 mul %edx
1197cb: 89 45 a8 mov %eax,-0x58(%ebp)
return media_blocks * media_block_size;
1197ce: 8b 41 20 mov 0x20(%ecx),%eax
return blocks * block_size;
1197d1: 89 55 ac mov %edx,-0x54(%ebp)
return media_blocks * media_block_size;
1197d4: f7 61 1c mull 0x1c(%ecx)
if (rtems_rfs_fs_size(fs) > rtems_rfs_fs_media_size (fs))
1197d7: 3b 45 a8 cmp -0x58(%ebp),%eax
1197da: 89 d1 mov %edx,%ecx
1197dc: 1b 4d ac sbb -0x54(%ebp),%ecx
1197df: 0f 82 eb 03 00 00 jb 119bd0 <rtems_rfs_fs_open+0x520> <== NEVER TAKEN
if (read_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE) != RTEMS_RFS_INODE_SIZE)
1197e5: 81 7f 24 00 00 00 38 cmpl $0x38000000,0x24(%edi)
1197ec: 0f 85 5e 03 00 00 jne 119b50 <rtems_rfs_fs_open+0x4a0> <== NEVER TAKEN
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
1197f2: 8b 47 10 mov 0x10(%edi),%eax
1197f5: 0f c8 bswap %eax
1197f7: 89 43 18 mov %eax,0x18(%ebx)
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
1197fa: 8b 47 14 mov 0x14(%edi),%eax
1197fd: 0f c8 bswap %eax
1197ff: 89 43 1c mov %eax,0x1c(%ebx)
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
119802: 8b 47 18 mov 0x18(%edi),%eax
119805: 0f c8 bswap %eax
119807: 89 43 24 mov %eax,0x24(%ebx)
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
11980a: 89 c2 mov %eax,%edx
11980c: 8b 47 1c mov 0x1c(%edi),%eax
11980f: 0f c8 bswap %eax
119811: 89 43 28 mov %eax,0x28(%ebx)
119814: 89 45 a8 mov %eax,-0x58(%ebp)
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
119817: 8b 45 b4 mov -0x4c(%ebp),%eax
11981a: 8b 4f 20 mov 0x20(%edi),%ecx
11981d: c1 e8 02 shr $0x2,%eax
fs->blocks_per_block =
119820: 89 43 34 mov %eax,0x34(%ebx)
fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
119823: 8d 3c 80 lea (%eax,%eax,4),%edi
119826: 0f c9 bswap %ecx
fs->block_map_singly_blocks =
119828: 89 7b 38 mov %edi,0x38(%ebx)
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
11982b: 0f af c0 imul %eax,%eax
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
11982e: 8b 7d b4 mov -0x4c(%ebp),%edi
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
119831: 89 4b 2c mov %ecx,0x2c(%ebx)
fs->inodes = fs->group_count * fs->group_inodes;
119834: 0f af ca imul %edx,%ecx
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
119837: ba 25 49 92 24 mov $0x24924925,%edx
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
11983c: 8d 04 80 lea (%eax,%eax,4),%eax
fs->block_map_doubly_blocks =
11983f: 89 43 3c mov %eax,0x3c(%ebx)
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
119842: 89 f8 mov %edi,%eax
fs->inodes = fs->group_count * fs->group_inodes;
119844: 89 4b 14 mov %ecx,0x14(%ebx)
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
119847: c1 e8 03 shr $0x3,%eax
11984a: f7 e2 mul %edx
rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs)))
11984c: 89 f8 mov %edi,%eax
11984e: c1 e0 03 shl $0x3,%eax
if (fs->group_blocks >
119851: 39 45 a8 cmp %eax,-0x58(%ebp)
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
119854: 89 53 30 mov %edx,0x30(%ebx)
rtems_rfs_buffer_handle_release (fs, handle);
119857: 89 74 24 04 mov %esi,0x4(%esp)
11985b: 89 1c 24 mov %ebx,(%esp)
if (fs->group_blocks >
11985e: 0f 87 2c 03 00 00 ja 119b90 <rtems_rfs_fs_open+0x4e0> <== NEVER TAKEN
119864: e8 47 e0 fe ff call 1078b0 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_block_size (fs));
119869: 8b 43 08 mov 0x8(%ebx),%eax
11986c: 89 1c 24 mov %ebx,(%esp)
handle->dirty = false;
11986f: c6 45 c0 00 movb $0x0,-0x40(%ebp)
handle->bnum = 0;
119873: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp)
11987a: 89 44 24 04 mov %eax,0x4(%esp)
handle->buffer = NULL;
11987e: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp)
119885: e8 96 e3 fe ff call 107c20 <rtems_rfs_buffer_setblksize>
if (rc > 0)
11988a: 85 c0 test %eax,%eax
rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_block_size (fs));
11988c: 89 c7 mov %eax,%edi
if (rc > 0)
11988e: 0f 8f 5c 02 00 00 jg 119af0 <rtems_rfs_fs_open+0x440> <== NEVER TAKEN
fs->groups = calloc (fs->group_count, sizeof (rtems_rfs_group));
119894: 8b 7b 24 mov 0x24(%ebx),%edi
119897: b8 50 00 00 00 mov $0x50,%eax
11989c: 89 44 24 04 mov %eax,0x4(%esp)
1198a0: 89 3c 24 mov %edi,(%esp)
1198a3: e8 38 a6 ff ff call 113ee0 <calloc>
1198a8: 89 43 20 mov %eax,0x20(%ebx)
if (!fs->groups)
1198ab: 85 c0 test %eax,%eax
1198ad: 0f 84 6d 05 00 00 je 119e20 <rtems_rfs_fs_open+0x770> <== NEVER TAKEN
for (group = 0; group < fs->group_count; group++)
1198b3: 31 d2 xor %edx,%edx
1198b5: 85 ff test %edi,%edi
1198b7: 0f 8e 33 01 00 00 jle 1199f0 <rtems_rfs_fs_open+0x340> <== NEVER TAKEN
1198bd: 89 d7 mov %edx,%edi
1198bf: 89 c2 mov %eax,%edx
1198c1: eb 1a jmp 1198dd <rtems_rfs_fs_open+0x22d>
1198c3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1198ca: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
1198d0: 47 inc %edi
1198d1: 3b 7b 24 cmp 0x24(%ebx),%edi
1198d4: 0f 8d 16 01 00 00 jge 1199f0 <rtems_rfs_fs_open+0x340> <== ALWAYS TAKEN
&fs->groups[group]);
1198da: 8b 53 20 mov 0x20(%ebx),%edx <== NOT EXECUTED
rc = rtems_rfs_group_open (fs,
1198dd: 8b 4b 28 mov 0x28(%ebx),%ecx
1198e0: 8d 04 bf lea (%edi,%edi,4),%eax
1198e3: c1 e0 04 shl $0x4,%eax
1198e6: 01 d0 add %edx,%eax
1198e8: 89 44 24 10 mov %eax,0x10(%esp)
1198ec: 8b 43 2c mov 0x2c(%ebx),%eax
1198ef: 89 4c 24 08 mov %ecx,0x8(%esp)
rtems_rfs_fs_block (fs, group, 0),
1198f3: 0f af cf imul %edi,%ecx
rc = rtems_rfs_group_open (fs,
1198f6: 89 1c 24 mov %ebx,(%esp)
1198f9: 89 44 24 0c mov %eax,0xc(%esp)
rtems_rfs_fs_block (fs, group, 0),
1198fd: 41 inc %ecx
rc = rtems_rfs_group_open (fs,
1198fe: 89 4c 24 04 mov %ecx,0x4(%esp)
119902: e8 c9 f8 fe ff call 1091d0 <rtems_rfs_group_open>
if (rc > 0)
119907: 85 c0 test %eax,%eax
119909: 7e c5 jle 1198d0 <rtems_rfs_fs_open+0x220> <== ALWAYS TAKEN
for (g = 0; g < group; g++)
11990b: 89 fa mov %edi,%edx <== NOT EXECUTED
11990d: 31 c9 xor %ecx,%ecx <== NOT EXECUTED
11990f: 85 d2 test %edx,%edx <== NOT EXECUTED
119911: 89 c7 mov %eax,%edi <== NOT EXECUTED
119913: 74 2d je 119942 <rtems_rfs_fs_open+0x292> <== NOT EXECUTED
119915: 89 45 a8 mov %eax,-0x58(%ebp) <== NOT EXECUTED
119918: 89 df mov %ebx,%edi <== NOT EXECUTED
11991a: 89 cb mov %ecx,%ebx <== NOT EXECUTED
11991c: 89 55 b4 mov %edx,-0x4c(%ebp) <== NOT EXECUTED
11991f: 90 nop <== NOT EXECUTED
rtems_rfs_group_close (fs, &fs->groups[g]);
119920: 8b 57 20 mov 0x20(%edi),%edx <== NOT EXECUTED
119923: 8d 04 9b lea (%ebx,%ebx,4),%eax <== NOT EXECUTED
for (g = 0; g < group; g++)
119926: 43 inc %ebx <== NOT EXECUTED
rtems_rfs_group_close (fs, &fs->groups[g]);
119927: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
11992a: c1 e0 04 shl $0x4,%eax <== NOT EXECUTED
11992d: 01 d0 add %edx,%eax <== NOT EXECUTED
11992f: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
119933: e8 58 fb fe ff call 109490 <rtems_rfs_group_close> <== NOT EXECUTED
for (g = 0; g < group; g++)
119938: 3b 5d b4 cmp -0x4c(%ebp),%ebx <== NOT EXECUTED
11993b: 75 e3 jne 119920 <rtems_rfs_fs_open+0x270> <== NOT EXECUTED
11993d: 89 fb mov %edi,%ebx <== NOT EXECUTED
11993f: 8b 7d a8 mov -0x58(%ebp),%edi <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
119942: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED
119946: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
119949: e8 62 df fe ff call 1078b0 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
11994e: 31 c9 xor %ecx,%ecx <== NOT EXECUTED
119950: c7 04 24 01 00 00 00 movl $0x1,(%esp) <== NOT EXECUTED
119957: 89 4c 24 04 mov %ecx,0x4(%esp) <== NOT EXECUTED
handle->dirty = false;
11995b: c6 45 c0 00 movb $0x0,-0x40(%ebp) <== NOT EXECUTED
handle->bnum = 0;
11995f: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp) <== NOT EXECUTED
handle->buffer = NULL;
119966: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp) <== NOT EXECUTED
11996d: e8 de 1e ff ff call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
119972: 84 c0 test %al,%al <== NOT EXECUTED
119974: 0f 85 c6 02 00 00 jne 119c40 <rtems_rfs_fs_open+0x590> <== NOT EXECUTED
11997a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
if (rc > 0)
{
rtems_rfs_buffer_close (*fs);
119980: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED
119983: 8b 00 mov (%eax),%eax <== NOT EXECUTED
119985: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
119988: e8 b3 e3 fe ff call 107d40 <rtems_rfs_buffer_close> <== NOT EXECUTED
free (*fs);
11998d: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED
119990: 8b 00 mov (%eax),%eax <== NOT EXECUTED
119992: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
119995: e8 46 8b fe ff call 1024e0 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
11999a: 31 c0 xor %eax,%eax <== NOT EXECUTED
11999c: c7 04 24 01 00 00 00 movl $0x1,(%esp) <== NOT EXECUTED
1199a3: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1199a7: e8 a4 1e ff ff call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
1199ac: 84 c0 test %al,%al <== NOT EXECUTED
1199ae: 0f 85 47 02 00 00 jne 119bfb <rtems_rfs_fs_open+0x54b> <== NOT EXECUTED
printf ("rtems-rfs: open: reading superblock: %d: %s\n",
rc, strerror (rc));
errno = rc;
1199b4: e8 47 0b 01 00 call 12a500 <__errno> <== NOT EXECUTED
1199b9: 89 38 mov %edi,(%eax) <== NOT EXECUTED
return -1;
1199bb: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
1199c0: e9 a9 00 00 00 jmp 119a6e <rtems_rfs_fs_open+0x3be> <== NOT EXECUTED
1199c5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1199cc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
printf ("rtems-rfs: open: %s\n", name);
1199d0: c7 04 24 41 5e 13 00 movl $0x135e41,(%esp) <== NOT EXECUTED
1199d7: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
1199da: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1199de: e8 5d 87 fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
1199e3: e9 eb fc ff ff jmp 1196d3 <rtems_rfs_fs_open+0x23> <== NOT EXECUTED
1199e8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1199ef: 90 nop <== NOT EXECUTED
}
rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);
1199f0: 89 74 24 08 mov %esi,0x8(%esp)
1199f4: b8 01 00 00 00 mov $0x1,%eax
1199f9: ba 01 00 00 00 mov $0x1,%edx
1199fe: 89 44 24 0c mov %eax,0xc(%esp)
119a02: 8b 45 18 mov 0x18(%ebp),%eax
119a05: 89 54 24 04 mov %edx,0x4(%esp)
119a09: 8b 00 mov (%eax),%eax
119a0b: 89 04 24 mov %eax,(%esp)
119a0e: e8 1d 00 ff ff call 109a30 <rtems_rfs_inode_open>
if (rc > 0)
119a13: 85 c0 test %eax,%eax
rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);
119a15: 89 c3 mov %eax,%ebx
if (rc > 0)
119a17: 0f 8f ee 02 00 00 jg 119d0b <rtems_rfs_fs_open+0x65b> <== NEVER TAKEN
rc, strerror (rc));
errno = rc;
return -1;
}
if (((*fs)->flags & RTEMS_RFS_FS_FORCE_OPEN) == 0)
119a1d: 8b 45 18 mov 0x18(%ebp),%eax
119a20: 8b 10 mov (%eax),%edx
119a22: f6 02 04 testb $0x4,(%edx)
119a25: 75 2f jne 119a56 <rtems_rfs_fs_open+0x3a6>
return rtems_rfs_read_u16 (&handle->node->mode);
119a27: 8b 45 cc mov -0x34(%ebp),%eax
119a2a: 0f b7 48 02 movzwl 0x2(%eax),%ecx
119a2e: 89 c8 mov %ecx,%eax
119a30: 0f b6 cd movzbl %ch,%ecx
119a33: c1 e0 08 shl $0x8,%eax
119a36: 09 c8 or %ecx,%eax
119a38: 0f b7 c0 movzwl %ax,%eax
{
mode = rtems_rfs_inode_get_mode (&inode);
if ((mode == 0xffff) || !RTEMS_RFS_S_ISDIR (mode))
119a3b: 3d ff ff 00 00 cmp $0xffff,%eax
119a40: 0f 84 70 02 00 00 je 119cb6 <rtems_rfs_fs_open+0x606> <== NEVER TAKEN
119a46: 25 00 f0 00 00 and $0xf000,%eax
119a4b: 3d 00 40 00 00 cmp $0x4000,%eax
119a50: 0f 85 60 02 00 00 jne 119cb6 <rtems_rfs_fs_open+0x606> <== NEVER TAKEN
errno = EIO;
return -1;
}
}
rc = rtems_rfs_inode_close (*fs, &inode);
119a56: 89 74 24 04 mov %esi,0x4(%esp)
119a5a: 89 14 24 mov %edx,(%esp)
119a5d: e8 de 01 ff ff call 109c40 <rtems_rfs_inode_close>
if (rc > 0)
119a62: 85 c0 test %eax,%eax
rc = rtems_rfs_inode_close (*fs, &inode);
119a64: 89 c3 mov %eax,%ebx
if (rc > 0)
119a66: 0f 8f f4 02 00 00 jg 119d60 <rtems_rfs_fs_open+0x6b0> <== NEVER TAKEN
printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
errno = rc;
return -1;
}
return 0;
119a6c: 31 c0 xor %eax,%eax
}
119a6e: 83 c4 6c add $0x6c,%esp
119a71: 5b pop %ebx
119a72: 5e pop %esi
119a73: 5f pop %edi
119a74: 5d pop %ebp
119a75: c3 ret
119a76: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
119a7d: 8d 76 00 lea 0x0(%esi),%esi
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
119a80: c7 04 24 01 00 00 00 movl $0x1,(%esp) <== NOT EXECUTED
119a87: 31 c0 xor %eax,%eax <== NOT EXECUTED
119a89: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
119a8d: e8 be 1d ff ff call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
119a92: 84 c0 test %al,%al <== NOT EXECUTED
119a94: 0f 84 e6 fe ff ff je 119980 <rtems_rfs_fs_open+0x2d0> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: request failed%d: %s\n",
119a9a: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
119a9d: e8 7e 19 01 00 call 12b420 <strerror> <== NOT EXECUTED
119aa2: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED
119aa6: c7 04 24 b8 5e 13 00 movl $0x135eb8,(%esp) <== NOT EXECUTED
119aad: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
119ab1: e8 8a 86 fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
119ab6: e9 c5 fe ff ff jmp 119980 <rtems_rfs_fs_open+0x2d0> <== NOT EXECUTED
119abb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
119abf: 90 nop <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
119ac0: c7 04 24 01 00 00 00 movl $0x1,(%esp) <== NOT EXECUTED
119ac7: 31 c0 xor %eax,%eax <== NOT EXECUTED
119ac9: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
119acd: e8 7e 1d ff ff call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
119ad2: 84 c0 test %al,%al <== NOT EXECUTED
119ad4: 0f 85 46 01 00 00 jne 119c20 <rtems_rfs_fs_open+0x570> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
119ada: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED
return EIO;
119ade: bf 05 00 00 00 mov $0x5,%edi <== NOT EXECUTED
119ae3: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
119ae6: e8 c5 dd fe ff call 1078b0 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
if (rc > 0)
119aeb: e9 90 fe ff ff jmp 119980 <rtems_rfs_fs_open+0x2d0> <== NOT EXECUTED
119af0: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED
119af4: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
119af7: e8 b4 dd fe ff call 1078b0 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
119afc: 31 c0 xor %eax,%eax <== NOT EXECUTED
119afe: c7 04 24 01 00 00 00 movl $0x1,(%esp) <== NOT EXECUTED
119b05: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
handle->dirty = false;
119b09: c6 45 c0 00 movb $0x0,-0x40(%ebp) <== NOT EXECUTED
handle->bnum = 0;
119b0d: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp) <== NOT EXECUTED
handle->buffer = NULL;
119b14: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp) <== NOT EXECUTED
119b1b: e8 30 1d ff ff call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
119b20: 84 c0 test %al,%al <== NOT EXECUTED
119b22: 0f 84 58 fe ff ff je 119980 <rtems_rfs_fs_open+0x2d0> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block size%d: %s\n",
119b28: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
119b2b: e8 f0 18 01 00 call 12b420 <strerror> <== NOT EXECUTED
119b30: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED
119b34: c7 04 24 f0 5f 13 00 movl $0x135ff0,(%esp) <== NOT EXECUTED
119b3b: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
119b3f: e8 fc 85 fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
119b44: e9 37 fe ff ff jmp 119980 <rtems_rfs_fs_open+0x2d0> <== NOT EXECUTED
119b49: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
119b50: c7 04 24 01 00 00 00 movl $0x1,(%esp) <== NOT EXECUTED
119b57: 31 c9 xor %ecx,%ecx <== NOT EXECUTED
119b59: 89 4c 24 04 mov %ecx,0x4(%esp) <== NOT EXECUTED
119b5d: e8 ee 1c ff ff call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
119b62: 84 c0 test %al,%al <== NOT EXECUTED
119b64: 0f 84 70 ff ff ff je 119ada <rtems_rfs_fs_open+0x42a> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: inode size mismatch: fs:%" PRId32 " target:%" PRId32 "\n",
119b6a: 8b 47 04 mov 0x4(%edi),%eax <== NOT EXECUTED
119b6d: 31 d2 xor %edx,%edx <== NOT EXECUTED
119b6f: 89 54 24 08 mov %edx,0x8(%esp) <== NOT EXECUTED
119b73: c7 04 24 68 5f 13 00 movl $0x135f68,(%esp) <== NOT EXECUTED
119b7a: 0f c8 bswap %eax <== NOT EXECUTED
119b7c: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
119b80: e8 bb 85 fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
119b85: e9 50 ff ff ff jmp 119ada <rtems_rfs_fs_open+0x42a> <== NOT EXECUTED
119b8a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
119b90: e8 1b dd fe ff call 1078b0 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
119b95: 31 c0 xor %eax,%eax <== NOT EXECUTED
119b97: c7 04 24 01 00 00 00 movl $0x1,(%esp) <== NOT EXECUTED
119b9e: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
handle->dirty = false;
119ba2: c6 45 c0 00 movb $0x0,-0x40(%ebp) <== NOT EXECUTED
handle->bnum = 0;
119ba6: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp) <== NOT EXECUTED
handle->buffer = NULL;
119bad: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp) <== NOT EXECUTED
119bb4: e8 97 1c ff ff call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
119bb9: 84 c0 test %al,%al <== NOT EXECUTED
119bbb: 0f 85 af 00 00 00 jne 119c70 <rtems_rfs_fs_open+0x5c0> <== NOT EXECUTED
return EIO;
119bc1: bf 05 00 00 00 mov $0x5,%edi <== NOT EXECUTED
119bc6: e9 b5 fd ff ff jmp 119980 <rtems_rfs_fs_open+0x2d0> <== NOT EXECUTED
119bcb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
119bcf: 90 nop <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
119bd0: c7 04 24 01 00 00 00 movl $0x1,(%esp) <== NOT EXECUTED
119bd7: 31 ff xor %edi,%edi <== NOT EXECUTED
119bd9: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED
119bdd: e8 6e 1c ff ff call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
119be2: 84 c0 test %al,%al <== NOT EXECUTED
119be4: 0f 84 f0 fe ff ff je 119ada <rtems_rfs_fs_open+0x42a> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block/size count\n");
119bea: c7 04 24 28 5f 13 00 movl $0x135f28,(%esp) <== NOT EXECUTED
119bf1: e8 7a 85 fe ff call 102170 <__wrap_puts> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
119bf6: e9 df fe ff ff jmp 119ada <rtems_rfs_fs_open+0x42a> <== NOT EXECUTED
printf ("rtems-rfs: open: reading superblock: %d: %s\n",
119bfb: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
119bfe: e8 1d 18 01 00 call 12b420 <strerror> <== NOT EXECUTED
119c03: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED
119c07: c7 04 24 ac 60 13 00 movl $0x1360ac,(%esp) <== NOT EXECUTED
119c0e: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
119c12: e8 29 85 fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
119c17: e9 98 fd ff ff jmp 1199b4 <rtems_rfs_fs_open+0x304> <== NOT EXECUTED
119c1c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock, bad magic\n");
119c20: c7 04 24 ec 5e 13 00 movl $0x135eec,(%esp) <== NOT EXECUTED
119c27: e8 44 85 fe ff call 102170 <__wrap_puts> <== NOT EXECUTED
119c2c: e9 a9 fe ff ff jmp 119ada <rtems_rfs_fs_open+0x42a> <== NOT EXECUTED
119c31: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
119c38: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
119c3f: 90 nop <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table%d: %s\n",
119c40: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
119c43: e8 d8 17 01 00 call 12b420 <strerror> <== NOT EXECUTED
119c48: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED
119c4c: c7 04 24 6c 60 13 00 movl $0x13606c,(%esp) <== NOT EXECUTED
119c53: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
119c57: e8 e4 84 fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
119c5c: e9 1f fd ff ff jmp 119980 <rtems_rfs_fs_open+0x2d0> <== NOT EXECUTED
119c61: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
119c68: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
119c6f: 90 nop <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: groups blocks larger than block bits\n");
119c70: c7 04 24 ac 5f 13 00 movl $0x135fac,(%esp) <== NOT EXECUTED
119c77: e8 f4 84 fe ff call 102170 <__wrap_puts> <== NOT EXECUTED
119c7c: e9 40 ff ff ff jmp 119bc1 <rtems_rfs_fs_open+0x511> <== NOT EXECUTED
free (*fs);
119c81: 8b 00 mov (%eax),%eax <== NOT EXECUTED
119c83: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
119c86: e8 55 88 fe ff call 1024e0 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
119c8b: 31 c0 xor %eax,%eax <== NOT EXECUTED
119c8d: c7 04 24 01 00 00 00 movl $0x1,(%esp) <== NOT EXECUTED
119c94: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
119c98: e8 b3 1b ff ff call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
119c9d: 84 c0 test %al,%al <== NOT EXECUTED
119c9f: 0f 85 10 01 00 00 jne 119db5 <rtems_rfs_fs_open+0x705> <== NOT EXECUTED
errno = rc;
119ca5: e8 56 08 01 00 call 12a500 <__errno> <== NOT EXECUTED
119caa: 89 18 mov %ebx,(%eax) <== NOT EXECUTED
return -1;
119cac: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
119cb1: e9 b8 fd ff ff jmp 119a6e <rtems_rfs_fs_open+0x3be> <== NOT EXECUTED
rtems_rfs_inode_close (*fs, &inode);
119cb6: 89 14 24 mov %edx,(%esp) <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
119cb9: 31 db xor %ebx,%ebx <== NOT EXECUTED
rtems_rfs_inode_close (*fs, &inode);
119cbb: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED
119cbf: e8 7c ff fe ff call 109c40 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_buffer_close (*fs);
119cc4: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED
119cc7: 8b 00 mov (%eax),%eax <== NOT EXECUTED
119cc9: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
119ccc: e8 6f e0 fe ff call 107d40 <rtems_rfs_buffer_close> <== NOT EXECUTED
free (*fs);
119cd1: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED
119cd4: 8b 00 mov (%eax),%eax <== NOT EXECUTED
119cd6: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
119cd9: e8 02 88 fe ff call 1024e0 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
119cde: c7 04 24 01 00 00 00 movl $0x1,(%esp) <== NOT EXECUTED
119ce5: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
119ce9: e8 62 1b ff ff call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
119cee: 84 c0 test %al,%al <== NOT EXECUTED
119cf0: 0f 85 e0 00 00 00 jne 119dd6 <rtems_rfs_fs_open+0x726> <== NOT EXECUTED
errno = EIO;
119cf6: e8 05 08 01 00 call 12a500 <__errno> <== NOT EXECUTED
119cfb: c7 00 05 00 00 00 movl $0x5,(%eax) <== NOT EXECUTED
return -1;
119d01: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
119d06: e9 63 fd ff ff jmp 119a6e <rtems_rfs_fs_open+0x3be> <== NOT EXECUTED
rtems_rfs_buffer_close (*fs);
119d0b: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
119d0e: 31 f6 xor %esi,%esi <== NOT EXECUTED
rtems_rfs_buffer_close (*fs);
119d10: 8b 00 mov (%eax),%eax <== NOT EXECUTED
119d12: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
119d15: e8 26 e0 fe ff call 107d40 <rtems_rfs_buffer_close> <== NOT EXECUTED
free (*fs);
119d1a: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED
119d1d: 8b 00 mov (%eax),%eax <== NOT EXECUTED
119d1f: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
119d22: e8 b9 87 fe ff call 1024e0 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
119d27: c7 04 24 01 00 00 00 movl $0x1,(%esp) <== NOT EXECUTED
119d2e: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED
119d32: e8 19 1b ff ff call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
119d37: 84 c0 test %al,%al <== NOT EXECUTED
119d39: 0f 84 66 ff ff ff je 119ca5 <rtems_rfs_fs_open+0x5f5> <== NOT EXECUTED
printf ("rtems-rfs: open: reading root inode: %d: %s\n",
119d3f: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
119d42: e8 d9 16 01 00 call 12b420 <strerror> <== NOT EXECUTED
119d47: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
119d4b: c7 04 24 dc 60 13 00 movl $0x1360dc,(%esp) <== NOT EXECUTED
119d52: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
119d56: e8 e5 83 fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
errno = rc;
119d5b: e9 45 ff ff ff jmp 119ca5 <rtems_rfs_fs_open+0x5f5> <== NOT EXECUTED
rtems_rfs_buffer_close (*fs);
119d60: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED
119d63: 8b 00 mov (%eax),%eax <== NOT EXECUTED
119d65: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
119d68: e8 d3 df fe ff call 107d40 <rtems_rfs_buffer_close> <== NOT EXECUTED
free (*fs);
119d6d: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED
119d70: 8b 00 mov (%eax),%eax <== NOT EXECUTED
119d72: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
119d75: e8 66 87 fe ff call 1024e0 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
119d7a: 31 c9 xor %ecx,%ecx <== NOT EXECUTED
119d7c: c7 04 24 01 00 00 00 movl $0x1,(%esp) <== NOT EXECUTED
119d83: 89 4c 24 04 mov %ecx,0x4(%esp) <== NOT EXECUTED
119d87: e8 c4 1a ff ff call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
119d8c: 84 c0 test %al,%al <== NOT EXECUTED
119d8e: 0f 84 11 ff ff ff je 119ca5 <rtems_rfs_fs_open+0x5f5> <== NOT EXECUTED
printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
119d94: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
119d97: e8 84 16 01 00 call 12b420 <strerror> <== NOT EXECUTED
119d9c: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
119da0: c7 04 24 38 61 13 00 movl $0x136138,(%esp) <== NOT EXECUTED
119da7: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
119dab: e8 90 83 fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
119db0: e9 f0 fe ff ff jmp 119ca5 <rtems_rfs_fs_open+0x5f5> <== NOT EXECUTED
printf ("rtems-rfs: open: buffer open failed: %d: %s\n",
119db5: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
119db8: e8 63 16 01 00 call 12b420 <strerror> <== NOT EXECUTED
119dbd: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
119dc1: c7 04 24 88 5e 13 00 movl $0x135e88,(%esp) <== NOT EXECUTED
119dc8: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
119dcc: e8 6f 83 fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
errno = rc;
119dd1: e9 cf fe ff ff jmp 119ca5 <rtems_rfs_fs_open+0x5f5> <== NOT EXECUTED
printf ("rtems-rfs: open: invalid root inode mode\n");
119dd6: c7 04 24 0c 61 13 00 movl $0x13610c,(%esp) <== NOT EXECUTED
119ddd: e8 8e 83 fe ff call 102170 <__wrap_puts> <== NOT EXECUTED
119de2: e9 0f ff ff ff jmp 119cf6 <rtems_rfs_fs_open+0x646> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
119de7: c7 04 24 01 00 00 00 movl $0x1,(%esp) <== NOT EXECUTED
119dee: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp) <== NOT EXECUTED
119df5: 00
119df6: e8 55 1a ff ff call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
119dfb: 84 c0 test %al,%al <== NOT EXECUTED
119dfd: 75 13 jne 119e12 <rtems_rfs_fs_open+0x762> <== NOT EXECUTED
errno = ENOMEM;
119dff: e8 fc 06 01 00 call 12a500 <__errno> <== NOT EXECUTED
119e04: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED
return -1;
119e0a: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
119e0d: e9 5c fc ff ff jmp 119a6e <rtems_rfs_fs_open+0x3be> <== NOT EXECUTED
printf ("rtems-rfs: open: no memory for file system data\n");
119e12: c7 04 24 58 5e 13 00 movl $0x135e58,(%esp) <== NOT EXECUTED
119e19: e8 52 83 fe ff call 102170 <__wrap_puts> <== NOT EXECUTED
119e1e: eb df jmp 119dff <rtems_rfs_fs_open+0x74f> <== NOT EXECUTED
119e20: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED
119e24: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
119e27: e8 84 da fe ff call 1078b0 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
119e2c: c7 04 24 01 00 00 00 movl $0x1,(%esp) <== NOT EXECUTED
119e33: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp) <== NOT EXECUTED
119e3a: 00
handle->dirty = false;
119e3b: c6 45 c0 00 movb $0x0,-0x40(%ebp) <== NOT EXECUTED
handle->bnum = 0;
119e3f: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp) <== NOT EXECUTED
handle->buffer = NULL;
119e46: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp) <== NOT EXECUTED
119e4d: e8 fe 19 ff ff call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
119e52: 84 c0 test %al,%al <== NOT EXECUTED
119e54: 75 0a jne 119e60 <rtems_rfs_fs_open+0x7b0> <== NOT EXECUTED
return ENOMEM;
119e56: bf 0c 00 00 00 mov $0xc,%edi <== NOT EXECUTED
119e5b: e9 20 fb ff ff jmp 119980 <rtems_rfs_fs_open+0x2d0> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table\n");
119e60: c7 04 24 34 60 13 00 movl $0x136034,(%esp) <== NOT EXECUTED
119e67: e8 04 83 fe ff call 102170 <__wrap_puts> <== NOT EXECUTED
119e6c: eb e8 jmp 119e56 <rtems_rfs_fs_open+0x7a6> <== NOT EXECUTED
119e6e: 90 nop
119e6f: 90 nop
00119680 <rtems_rfs_fs_size>:
#include <rtems/rfs/rtems-rfs-inode.h>
#include <rtems/rfs/rtems-rfs-trace.h>
uint64_t
rtems_rfs_fs_size (rtems_rfs_file_system* fs)
{
119680: 55 push %ebp <== NOT EXECUTED
119681: 89 e5 mov %esp,%ebp <== NOT EXECUTED
119683: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
uint64_t blocks = rtems_rfs_fs_blocks (fs);
uint64_t block_size = rtems_rfs_fs_block_size (fs);
return blocks * block_size;
}
119686: 5d pop %ebp <== NOT EXECUTED
return blocks * block_size;
119687: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED
11968a: f7 62 04 mull 0x4(%edx) <== NOT EXECUTED
}
11968d: c3 ret <== NOT EXECUTED
11968e: 90 nop
11968f: 90 nop
00109560 <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)
{
109560: 55 push %ebp
109561: 89 e5 mov %esp,%ebp
109563: 57 push %edi
109564: 56 push %esi
109565: 53 push %ebx
109566: 83 ec 4c sub $0x4c,%esp
109569: 0f b6 5d 10 movzbl 0x10(%ebp),%ebx
10956d: 8b 75 08 mov 0x8(%ebp),%esi
109570: 8b 45 0c mov 0xc(%ebp),%eax
109573: 88 5d cb mov %bl,-0x35(%ebp)
rtems_rfs_bitmap_bit bit;
int offset;
bool updown;
int direction;
if (inode)
109576: 84 db test %bl,%bl
109578: 0f 84 22 01 00 00 je 1096a0 <rtems_rfs_group_bitmap_alloc+0x140>
{
size = fs->group_inodes;
10957e: 8b 7e 2c mov 0x2c(%esi),%edi
goal -= RTEMS_RFS_ROOT_INO;
109581: 48 dec %eax
size = fs->group_inodes;
109582: 89 7d cc mov %edi,-0x34(%ebp)
*/
while (true)
{
rtems_rfs_bitmap_control* bitmap;
int group;
bool allocated = false;
109585: c6 45 e3 00 movb $0x0,-0x1d(%ebp)
109589: 31 d2 xor %edx,%edx
direction = 1;
10958b: b9 01 00 00 00 mov $0x1,%ecx
109590: f7 75 cc divl -0x34(%ebp)
bool allocated = false;
109593: 31 ff xor %edi,%edi
bit = (rtems_rfs_bitmap_bit) (goal % size);
109595: 89 55 e4 mov %edx,-0x1c(%ebp)
/*
* 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);
109598: 89 c3 mov %eax,%ebx
updown = true;
10959a: b2 01 mov $0x1,%dl
10959c: 89 45 d0 mov %eax,-0x30(%ebp)
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
else
bitmap = &fs->groups[group].block_bitmap;
rc = rtems_rfs_bitmap_map_alloc (bitmap, bit, &allocated, &bit);
10959f: 89 7d d4 mov %edi,-0x2c(%ebp)
if ((group < 0) || (group >= fs->group_count))
1095a2: 85 db test %ebx,%ebx
1095a4: 0f 88 96 00 00 00 js 109640 <rtems_rfs_group_bitmap_alloc+0xe0>
1095aa: 39 5e 24 cmp %ebx,0x24(%esi)
1095ad: 0f 8e 8d 00 00 00 jle 109640 <rtems_rfs_group_bitmap_alloc+0xe0>
bitmap = &fs->groups[group].inode_bitmap;
1095b3: 8b 7e 20 mov 0x20(%esi),%edi
1095b6: 8d 04 9b lea (%ebx,%ebx,4),%eax
1095b9: c1 e0 04 shl $0x4,%eax
1095bc: 89 45 c0 mov %eax,-0x40(%ebp)
1095bf: 01 f8 add %edi,%eax
if (inode)
1095c1: 80 7d cb 00 cmpb $0x0,-0x35(%ebp)
bitmap = &fs->groups[group].block_bitmap;
1095c5: 8d 78 08 lea 0x8(%eax),%edi
if (inode)
1095c8: 0f 85 f2 00 00 00 jne 1096c0 <rtems_rfs_group_bitmap_alloc+0x160>
rc = rtems_rfs_bitmap_map_alloc (bitmap, bit, &allocated, &bit);
1095ce: 89 3c 24 mov %edi,(%esp)
1095d1: 8d 45 e4 lea -0x1c(%ebp),%eax
1095d4: 89 44 24 0c mov %eax,0xc(%esp)
1095d8: 8d 45 e3 lea -0x1d(%ebp),%eax
1095db: 89 44 24 08 mov %eax,0x8(%esp)
1095df: 8b 45 e4 mov -0x1c(%ebp),%eax
1095e2: 88 55 ca mov %dl,-0x36(%ebp)
1095e5: 89 4d c4 mov %ecx,-0x3c(%ebp)
1095e8: 89 44 24 04 mov %eax,0x4(%esp)
1095ec: e8 7f d9 ff ff call 106f70 <rtems_rfs_bitmap_map_alloc>
if (rc > 0)
1095f1: 85 c0 test %eax,%eax
1095f3: 0f 8f 96 00 00 00 jg 10968f <rtems_rfs_group_bitmap_alloc+0x12f> <== NEVER TAKEN
return rc;
if (rtems_rfs_fs_release_bitmaps (fs))
1095f9: f6 06 01 testb $0x1,(%esi)
1095fc: 8b 4d c4 mov -0x3c(%ebp),%ecx
1095ff: 0f b6 55 ca movzbl -0x36(%ebp),%edx
109603: 0f 84 27 01 00 00 je 109730 <rtems_rfs_group_bitmap_alloc+0x1d0> <== ALWAYS TAKEN
rtems_rfs_bitmap_release_buffer (fs, bitmap);
if (allocated)
109609: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp)
10960d: 0f 85 5d 01 00 00 jne 109770 <rtems_rfs_group_bitmap_alloc+0x210>
* 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)
109613: 84 d2 test %dl,%dl
109615: 0f 84 b5 00 00 00 je 1096d0 <rtems_rfs_group_bitmap_alloc+0x170> <== NEVER TAKEN
{
direction = direction > 0 ? -1 : 1;
10961b: 49 dec %ecx
10961c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
109620: 0f 85 2a 01 00 00 jne 109750 <rtems_rfs_group_bitmap_alloc+0x1f0> <== NEVER TAKEN
if ( direction == -1 )
offset++;
109626: 8b 7d d4 mov -0x2c(%ebp),%edi
direction = direction > 0 ? -1 : 1;
109629: b9 ff ff ff ff mov $0xffffffff,%ecx
10962e: 8b 5d d0 mov -0x30(%ebp),%ebx
offset++;
109631: 47 inc %edi
group = group_start + (direction * offset);
109632: 29 fb sub %edi,%ebx
bit = direction > 0 ? 0 : size - 1;
109634: 8b 45 cc mov -0x34(%ebp),%eax
109637: 48 dec %eax
109638: 89 45 e4 mov %eax,-0x1c(%ebp)
10963b: e9 5f ff ff ff jmp 10959f <rtems_rfs_group_bitmap_alloc+0x3f>
if (!updown)
109640: 84 d2 test %dl,%dl
109642: 8b 7d d4 mov -0x2c(%ebp),%edi
109645: 74 29 je 109670 <rtems_rfs_group_bitmap_alloc+0x110>
bool allocated = false;
109647: c6 45 e3 00 movb $0x0,-0x1d(%ebp)
direction = direction > 0 ? -1 : 1;
10964b: 49 dec %ecx
10964c: 0f 85 9e 00 00 00 jne 1096f0 <rtems_rfs_group_bitmap_alloc+0x190> <== ALWAYS TAKEN
group = group_start + (direction * offset);
109652: 8b 5d d0 mov -0x30(%ebp),%ebx <== NOT EXECUTED
if (offset)
109655: 31 d2 xor %edx,%edx <== NOT EXECUTED
direction = direction > 0 ? -1 : 1;
109657: b9 ff ff ff ff mov $0xffffffff,%ecx <== NOT EXECUTED
10965c: 29 fb sub %edi,%ebx <== NOT EXECUTED
if (offset)
10965e: 85 ff test %edi,%edi <== NOT EXECUTED
109660: 75 d2 jne 109634 <rtems_rfs_group_bitmap_alloc+0xd4> <== NOT EXECUTED
109662: e9 38 ff ff ff jmp 10959f <rtems_rfs_group_bitmap_alloc+0x3f> <== NOT EXECUTED
109667: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10966e: 66 90 xchg %ax,%ax <== NOT EXECUTED
offset++;
}
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
109670: c7 04 24 00 00 02 00 movl $0x20000,(%esp)
109677: 31 c0 xor %eax,%eax
109679: 89 44 24 04 mov %eax,0x4(%esp)
10967d: e8 ce 21 00 00 call 10b850 <rtems_rfs_trace>
109682: 84 c0 test %al,%al
109684: 0f 85 86 00 00 00 jne 109710 <rtems_rfs_group_bitmap_alloc+0x1b0> <== NEVER TAKEN
printf ("rtems-rfs: group-bitmap-alloc: no blocks available\n");
return ENOSPC;
10968a: b8 1c 00 00 00 mov $0x1c,%eax <== NOT EXECUTED
}
10968f: 83 c4 4c add $0x4c,%esp
109692: 5b pop %ebx
109693: 5e pop %esi
109694: 5f pop %edi
109695: 5d pop %ebp
109696: c3 ret
109697: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10969e: 66 90 xchg %ax,%ax
size = fs->group_blocks;
1096a0: 8b 7e 28 mov 0x28(%esi),%edi
goal -= RTEMS_RFS_ROOT_INO;
1096a3: 31 d2 xor %edx,%edx
1096a5: 85 c0 test %eax,%eax
1096a7: 0f 9f c2 setg %dl
1096aa: 29 d0 sub %edx,%eax
size = fs->group_blocks;
1096ac: 89 7d cc mov %edi,-0x34(%ebp)
if (goal >= RTEMS_RFS_ROOT_INO)
1096af: e9 d1 fe ff ff jmp 109585 <rtems_rfs_group_bitmap_alloc+0x25>
1096b4: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1096bb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
1096bf: 90 nop
bitmap = &fs->groups[group].inode_bitmap;
1096c0: 83 c0 2c add $0x2c,%eax
1096c3: 89 c7 mov %eax,%edi
1096c5: e9 04 ff ff ff jmp 1095ce <rtems_rfs_group_bitmap_alloc+0x6e>
1096ca: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
offset++;
1096d0: 8b 7d d4 mov -0x2c(%ebp),%edi <== NOT EXECUTED
group = group_start + (direction * offset);
1096d3: 8b 45 d0 mov -0x30(%ebp),%eax <== NOT EXECUTED
offset++;
1096d6: 47 inc %edi <== NOT EXECUTED
group = group_start + (direction * offset);
1096d7: 89 fb mov %edi,%ebx <== NOT EXECUTED
1096d9: 0f af d9 imul %ecx,%ebx <== NOT EXECUTED
1096dc: 01 c3 add %eax,%ebx <== NOT EXECUTED
bit = direction > 0 ? 0 : size - 1;
1096de: 83 f9 01 cmp $0x1,%ecx <== NOT EXECUTED
1096e1: 0f 85 4d ff ff ff jne 109634 <rtems_rfs_group_bitmap_alloc+0xd4> <== NOT EXECUTED
1096e7: 31 c0 xor %eax,%eax <== NOT EXECUTED
1096e9: e9 4a ff ff ff jmp 109638 <rtems_rfs_group_bitmap_alloc+0xd8> <== NOT EXECUTED
1096ee: 66 90 xchg %ax,%ax <== NOT EXECUTED
group = group_start + (direction * offset);
1096f0: 8b 45 d0 mov -0x30(%ebp),%eax
if (offset)
1096f3: 31 d2 xor %edx,%edx
1096f5: 85 ff test %edi,%edi
1096f7: b9 01 00 00 00 mov $0x1,%ecx
group = group_start + (direction * offset);
1096fc: 8d 1c 38 lea (%eax,%edi,1),%ebx
if (offset)
1096ff: 0f 84 9a fe ff ff je 10959f <rtems_rfs_group_bitmap_alloc+0x3f> <== NEVER TAKEN
bit = direction > 0 ? 0 : size - 1;
109705: 31 c0 xor %eax,%eax
109707: e9 2c ff ff ff jmp 109638 <rtems_rfs_group_bitmap_alloc+0xd8>
10970c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
printf ("rtems-rfs: group-bitmap-alloc: no blocks available\n");
109710: c7 04 24 d8 45 13 00 movl $0x1345d8,(%esp) <== NOT EXECUTED
109717: e8 54 8a ff ff call 102170 <__wrap_puts> <== NOT EXECUTED
10971c: e9 69 ff ff ff jmp 10968a <rtems_rfs_group_bitmap_alloc+0x12a> <== NOT EXECUTED
109721: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
109728: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10972f: 90 nop <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
109730: 8b 07 mov (%edi),%eax
109732: 89 34 24 mov %esi,(%esp)
109735: 89 44 24 04 mov %eax,0x4(%esp)
109739: e8 72 e1 ff ff call 1078b0 <rtems_rfs_buffer_handle_release>
10973e: 0f b6 55 ca movzbl -0x36(%ebp),%edx
109742: 8b 4d c4 mov -0x3c(%ebp),%ecx
109745: e9 bf fe ff ff jmp 109609 <rtems_rfs_group_bitmap_alloc+0xa9>
10974a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
group = group_start + (direction * offset);
109750: 8b 7d d4 mov -0x2c(%ebp),%edi <== NOT EXECUTED
109753: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED
109758: 8b 45 d0 mov -0x30(%ebp),%eax <== NOT EXECUTED
if (offset)
10975b: 85 ff test %edi,%edi <== NOT EXECUTED
group = group_start + (direction * offset);
10975d: 8d 1c 38 lea (%eax,%edi,1),%ebx <== NOT EXECUTED
if (offset)
109760: 0f 84 3c fe ff ff je 1095a2 <rtems_rfs_group_bitmap_alloc+0x42> <== NOT EXECUTED
bit = direction > 0 ? 0 : size - 1;
109766: 8b 7d d4 mov -0x2c(%ebp),%edi <== NOT EXECUTED
109769: 31 c0 xor %eax,%eax <== NOT EXECUTED
10976b: e9 c8 fe ff ff jmp 109638 <rtems_rfs_group_bitmap_alloc+0xd8> <== NOT EXECUTED
if (inode)
109770: 80 7d cb 00 cmpb $0x0,-0x35(%ebp)
*result = rtems_rfs_group_inode (fs, group, bit);
109774: 8b 45 e4 mov -0x1c(%ebp),%eax
if (inode)
109777: 74 4a je 1097c3 <rtems_rfs_group_bitmap_alloc+0x263>
*result = rtems_rfs_group_inode (fs, group, bit);
109779: 8b 7e 2c mov 0x2c(%esi),%edi
10977c: 0f af df imul %edi,%ebx
10977f: 8b 7d 14 mov 0x14(%ebp),%edi
109782: 8d 44 18 01 lea 0x1(%eax,%ebx,1),%eax
109786: 89 07 mov %eax,(%edi)
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
109788: 31 c0 xor %eax,%eax
10978a: c7 04 24 00 00 02 00 movl $0x20000,(%esp)
109791: 89 44 24 04 mov %eax,0x4(%esp)
109795: e8 b6 20 00 00 call 10b850 <rtems_rfs_trace>
10979a: 84 c0 test %al,%al
10979c: 74 1e je 1097bc <rtems_rfs_group_bitmap_alloc+0x25c> <== ALWAYS TAKEN
printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
10979e: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED
1097a1: 8b 10 mov (%eax),%edx <== NOT EXECUTED
1097a3: b8 95 45 13 00 mov $0x134595,%eax <== NOT EXECUTED
1097a8: 89 54 24 08 mov %edx,0x8(%esp) <== NOT EXECUTED
1097ac: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1097b0: c7 04 24 a4 45 13 00 movl $0x1345a4,(%esp) <== NOT EXECUTED
1097b7: e8 84 89 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
return 0;
1097bc: 31 c0 xor %eax,%eax
1097be: e9 cc fe ff ff jmp 10968f <rtems_rfs_group_bitmap_alloc+0x12f>
*result = rtems_rfs_group_block (&fs->groups[group], bit);
1097c3: 8b 56 20 mov 0x20(%esi),%edx
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
1097c6: 31 db xor %ebx,%ebx
*result = rtems_rfs_group_block (&fs->groups[group], bit);
1097c8: 8b 7d c0 mov -0x40(%ebp),%edi
1097cb: 8b 0c 3a mov (%edx,%edi,1),%ecx
1097ce: 8b 7d 14 mov 0x14(%ebp),%edi
1097d1: 01 c8 add %ecx,%eax
1097d3: 89 07 mov %eax,(%edi)
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
1097d5: c7 04 24 00 00 02 00 movl $0x20000,(%esp)
1097dc: 89 5c 24 04 mov %ebx,0x4(%esp)
1097e0: e8 6b 20 00 00 call 10b850 <rtems_rfs_trace>
1097e5: 84 c0 test %al,%al
1097e7: 74 d3 je 1097bc <rtems_rfs_group_bitmap_alloc+0x25c> <== ALWAYS TAKEN
printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
1097e9: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED
1097ec: 8b 10 mov (%eax),%edx <== NOT EXECUTED
1097ee: b8 9b 45 13 00 mov $0x13459b,%eax <== NOT EXECUTED
1097f3: eb b3 jmp 1097a8 <rtems_rfs_group_bitmap_alloc+0x248> <== NOT EXECUTED
1097f5: 90 nop
1097f6: 90 nop
1097f7: 90 nop
1097f8: 90 nop
1097f9: 90 nop
1097fa: 90 nop
1097fb: 90 nop
1097fc: 90 nop
1097fd: 90 nop
1097fe: 90 nop
1097ff: 90 nop
00109800 <rtems_rfs_group_bitmap_free>:
int
rtems_rfs_group_bitmap_free (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no)
{
109800: 55 push %ebp
unsigned int group;
rtems_rfs_bitmap_bit bit;
size_t size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
109801: 31 c0 xor %eax,%eax
{
109803: 89 e5 mov %esp,%ebp
109805: 83 ec 28 sub $0x28,%esp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
109808: c7 04 24 00 00 02 00 movl $0x20000,(%esp)
10980f: 89 44 24 04 mov %eax,0x4(%esp)
{
109813: 89 5d f4 mov %ebx,-0xc(%ebp)
109816: 0f b6 5d 0c movzbl 0xc(%ebp),%ebx
10981a: 89 75 f8 mov %esi,-0x8(%ebp)
10981d: 8b 75 10 mov 0x10(%ebp),%esi
109820: 89 7d fc mov %edi,-0x4(%ebp)
109823: 8b 7d 08 mov 0x8(%ebp),%edi
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
109826: e8 25 20 00 00 call 10b850 <rtems_rfs_trace>
10982b: 84 c0 test %al,%al
10982d: 74 1d je 10984c <rtems_rfs_group_bitmap_free+0x4c> <== ALWAYS TAKEN
printf ("rtems-rfs: group-bitmap-free: %s free: %" PRId32 "\n",
10982f: 84 db test %bl,%bl <== NOT EXECUTED
109831: b8 95 45 13 00 mov $0x134595,%eax <== NOT EXECUTED
109836: 74 68 je 1098a0 <rtems_rfs_group_bitmap_free+0xa0> <== NOT EXECUTED
109838: 89 74 24 08 mov %esi,0x8(%esp) <== NOT EXECUTED
10983c: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
109840: c7 04 24 0c 46 13 00 movl $0x13460c,(%esp) <== NOT EXECUTED
109847: e8 f4 88 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
10984c: 8b 4f 20 mov 0x20(%edi),%ecx
no -= RTEMS_RFS_ROOT_INO;
10984f: 8d 46 ff lea -0x1(%esi),%eax
bit = (rtems_rfs_bitmap_bit) (no % size);
109852: 31 d2 xor %edx,%edx
if (inode)
109854: 84 db test %bl,%bl
109856: 74 38 je 109890 <rtems_rfs_group_bitmap_free+0x90>
bit = (rtems_rfs_bitmap_bit) (no % size);
109858: f7 77 2c divl 0x2c(%edi)
bitmap = &fs->groups[group].inode_bitmap;
10985b: 8d 04 80 lea (%eax,%eax,4),%eax
10985e: c1 e0 04 shl $0x4,%eax
109861: 8d 74 01 2c lea 0x2c(%ecx,%eax,1),%esi
else
bitmap = &fs->groups[group].block_bitmap;
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
109865: 89 54 24 04 mov %edx,0x4(%esp)
109869: 89 34 24 mov %esi,(%esp)
10986c: e8 8f d0 ff ff call 106900 <rtems_rfs_bitmap_map_clear>
109871: 89 c3 mov %eax,%ebx
rtems_rfs_bitmap_release_buffer (fs, bitmap);
109873: 8b 06 mov (%esi),%eax
109875: 89 3c 24 mov %edi,(%esp)
109878: 89 44 24 04 mov %eax,0x4(%esp)
10987c: e8 2f e0 ff ff call 1078b0 <rtems_rfs_buffer_handle_release>
return rc;
}
109881: 8b 75 f8 mov -0x8(%ebp),%esi
109884: 89 d8 mov %ebx,%eax
109886: 8b 7d fc mov -0x4(%ebp),%edi
109889: 8b 5d f4 mov -0xc(%ebp),%ebx
10988c: 89 ec mov %ebp,%esp
10988e: 5d pop %ebp
10988f: c3 ret
bit = (rtems_rfs_bitmap_bit) (no % size);
109890: f7 77 28 divl 0x28(%edi)
bitmap = &fs->groups[group].block_bitmap;
109893: 8d 04 80 lea (%eax,%eax,4),%eax
109896: c1 e0 04 shl $0x4,%eax
109899: 8d 74 01 08 lea 0x8(%ecx,%eax,1),%esi
10989d: eb c6 jmp 109865 <rtems_rfs_group_bitmap_free+0x65>
10989f: 90 nop
printf ("rtems-rfs: group-bitmap-free: %s free: %" PRId32 "\n",
1098a0: b8 9b 45 13 00 mov $0x13459b,%eax <== NOT EXECUTED
1098a5: eb 91 jmp 109838 <rtems_rfs_group_bitmap_free+0x38> <== NOT EXECUTED
1098a7: 90 nop
1098a8: 90 nop
1098a9: 90 nop
1098aa: 90 nop
1098ab: 90 nop
1098ac: 90 nop
1098ad: 90 nop
1098ae: 90 nop
1098af: 90 nop
00147e60 <rtems_rfs_group_bitmap_test>:
int
rtems_rfs_group_bitmap_test (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no,
bool* state)
{
147e60: 55 push %ebp <== NOT EXECUTED
unsigned int group;
rtems_rfs_bitmap_bit bit;
size_t size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
147e61: 31 c0 xor %eax,%eax <== NOT EXECUTED
{
147e63: 89 e5 mov %esp,%ebp <== NOT EXECUTED
147e65: 83 ec 28 sub $0x28,%esp <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
147e68: c7 04 24 00 00 02 00 movl $0x20000,(%esp) <== NOT EXECUTED
147e6f: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
{
147e73: 89 5d f4 mov %ebx,-0xc(%ebp) <== NOT EXECUTED
147e76: 0f b6 5d 0c movzbl 0xc(%ebp),%ebx <== NOT EXECUTED
147e7a: 89 75 f8 mov %esi,-0x8(%ebp) <== NOT EXECUTED
147e7d: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED
147e80: 89 7d fc mov %edi,-0x4(%ebp) <== NOT EXECUTED
147e83: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
147e86: e8 55 3b 00 00 call 14b9e0 <rtems_rfs_trace> <== NOT EXECUTED
147e8b: 84 c0 test %al,%al <== NOT EXECUTED
147e8d: 74 1d je 147eac <rtems_rfs_group_bitmap_test+0x4c> <== NOT EXECUTED
printf ("rtems-rfs: group-bitmap-test: %s test: %" PRId32 "\n",
147e8f: 84 db test %bl,%bl <== NOT EXECUTED
147e91: b8 bd 62 19 00 mov $0x1962bd,%eax <== NOT EXECUTED
147e96: 74 78 je 147f10 <rtems_rfs_group_bitmap_test+0xb0> <== NOT EXECUTED
147e98: 89 74 24 08 mov %esi,0x8(%esp) <== NOT EXECUTED
147e9c: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
147ea0: c7 04 24 58 63 19 00 movl $0x196358,(%esp) <== NOT EXECUTED
147ea7: e8 34 3f 02 00 call 16bde0 <__wrap_printf> <== NOT EXECUTED
inode ? "inode" : "block", no);
if (inode)
147eac: 84 db test %bl,%bl <== NOT EXECUTED
147eae: 0f 84 8c 00 00 00 je 147f40 <rtems_rfs_group_bitmap_test+0xe0> <== NOT EXECUTED
{
if ((no < RTEMS_RFS_ROOT_INO) || (no > rtems_rfs_fs_inodes (fs)))
147eb4: 85 f6 test %esi,%esi <== NOT EXECUTED
147eb6: 7e 68 jle 147f20 <rtems_rfs_group_bitmap_test+0xc0> <== NOT EXECUTED
147eb8: 39 77 14 cmp %esi,0x14(%edi) <== NOT EXECUTED
147ebb: 72 63 jb 147f20 <rtems_rfs_group_bitmap_test+0xc0> <== NOT EXECUTED
return EINVAL;
no -= RTEMS_RFS_ROOT_INO;
147ebd: 8d 46 ff lea -0x1(%esi),%eax <== NOT EXECUTED
no -= RTEMS_RFS_ROOT_INO;
size = fs->group_blocks;
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
147ec0: 31 d2 xor %edx,%edx <== NOT EXECUTED
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
147ec2: 8b 5f 20 mov 0x20(%edi),%ebx <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (no % size);
147ec5: f7 77 2c divl 0x2c(%edi) <== NOT EXECUTED
bitmap = &fs->groups[group].inode_bitmap;
147ec8: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED
147ecb: c1 e0 04 shl $0x4,%eax <== NOT EXECUTED
147ece: 01 d8 add %ebx,%eax <== NOT EXECUTED
147ed0: 8d 70 2c lea 0x2c(%eax),%esi <== NOT EXECUTED
else
bitmap = &fs->groups[group].block_bitmap;
rc = rtems_rfs_bitmap_map_test (bitmap, bit, state);
147ed3: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
147ed7: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED
147eda: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
147edd: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
147ee1: e8 fa 1b 01 00 call 159ae0 <rtems_rfs_bitmap_map_test> <== NOT EXECUTED
147ee6: 89 c3 mov %eax,%ebx <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
147ee8: 8b 06 mov (%esi),%eax <== NOT EXECUTED
147eea: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
147eed: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
147ef1: e8 9a b9 ff ff call 143890 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
return rc;
}
147ef6: 8b 75 f8 mov -0x8(%ebp),%esi <== NOT EXECUTED
147ef9: 89 d8 mov %ebx,%eax <== NOT EXECUTED
147efb: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED
147efe: 8b 5d f4 mov -0xc(%ebp),%ebx <== NOT EXECUTED
147f01: 89 ec mov %ebp,%esp <== NOT EXECUTED
147f03: 5d pop %ebp <== NOT EXECUTED
147f04: c3 ret <== NOT EXECUTED
147f05: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
147f0c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
printf ("rtems-rfs: group-bitmap-test: %s test: %" PRId32 "\n",
147f10: b8 cb 7e 19 00 mov $0x197ecb,%eax <== NOT EXECUTED
147f15: eb 81 jmp 147e98 <rtems_rfs_group_bitmap_test+0x38> <== NOT EXECUTED
147f17: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
147f1e: 66 90 xchg %ax,%ax <== NOT EXECUTED
return EINVAL;
147f20: bb 16 00 00 00 mov $0x16,%ebx <== NOT EXECUTED
}
147f25: 8b 75 f8 mov -0x8(%ebp),%esi <== NOT EXECUTED
147f28: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED
147f2b: 89 d8 mov %ebx,%eax <== NOT EXECUTED
147f2d: 8b 5d f4 mov -0xc(%ebp),%ebx <== NOT EXECUTED
147f30: 89 ec mov %ebp,%esp <== NOT EXECUTED
147f32: 5d pop %ebp <== NOT EXECUTED
147f33: c3 ret <== NOT EXECUTED
147f34: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
147f3b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
147f3f: 90 nop <== NOT EXECUTED
if ((no < RTEMS_RFS_ROOT_INO) || (no >= rtems_rfs_fs_blocks (fs)))
147f40: 85 f6 test %esi,%esi <== NOT EXECUTED
147f42: 7e dc jle 147f20 <rtems_rfs_group_bitmap_test+0xc0> <== NOT EXECUTED
147f44: 39 77 04 cmp %esi,0x4(%edi) <== NOT EXECUTED
147f47: 76 d7 jbe 147f20 <rtems_rfs_group_bitmap_test+0xc0> <== NOT EXECUTED
no -= RTEMS_RFS_ROOT_INO;
147f49: 8d 46 ff lea -0x1(%esi),%eax <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (no % size);
147f4c: 31 d2 xor %edx,%edx <== NOT EXECUTED
bitmap = &fs->groups[group].block_bitmap;
147f4e: 8b 4f 20 mov 0x20(%edi),%ecx <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (no % size);
147f51: f7 77 28 divl 0x28(%edi) <== NOT EXECUTED
bitmap = &fs->groups[group].block_bitmap;
147f54: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED
147f57: c1 e0 04 shl $0x4,%eax <== NOT EXECUTED
147f5a: 01 c8 add %ecx,%eax <== NOT EXECUTED
147f5c: 8d 70 08 lea 0x8(%eax),%esi <== NOT EXECUTED
147f5f: e9 6f ff ff ff jmp 147ed3 <rtems_rfs_group_bitmap_test+0x73> <== NOT EXECUTED
147f64: 90 nop
147f65: 90 nop
147f66: 90 nop
147f67: 90 nop
147f68: 90 nop
147f69: 90 nop
147f6a: 90 nop
147f6b: 90 nop
147f6c: 90 nop
147f6d: 90 nop
147f6e: 90 nop
147f6f: 90 nop
00109490 <rtems_rfs_group_close>:
int
rtems_rfs_group_close (rtems_rfs_file_system* fs, rtems_rfs_group* group)
{
109490: 55 push %ebp
int result = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_CLOSE))
109491: 31 c0 xor %eax,%eax
{
109493: 89 e5 mov %esp,%ebp
109495: 83 ec 28 sub $0x28,%esp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_CLOSE))
109498: c7 04 24 00 00 01 00 movl $0x10000,(%esp)
10949f: 89 44 24 04 mov %eax,0x4(%esp)
{
1094a3: 89 5d f4 mov %ebx,-0xc(%ebp)
1094a6: 8b 5d 0c mov 0xc(%ebp),%ebx
1094a9: 89 75 f8 mov %esi,-0x8(%ebp)
1094ac: 89 7d fc mov %edi,-0x4(%ebp)
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_CLOSE))
1094af: e8 9c 23 00 00 call 10b850 <rtems_rfs_trace>
1094b4: 84 c0 test %al,%al
1094b6: 0f 85 84 00 00 00 jne 109540 <rtems_rfs_group_close+0xb0> <== NEVER TAKEN
/*
* 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);
1094bc: 8d 43 2c lea 0x2c(%ebx),%eax
1094bf: 89 04 24 mov %eax,(%esp)
1094c2: e8 09 dd ff ff call 1071d0 <rtems_rfs_bitmap_close>
1094c7: 89 c6 mov %eax,%esi
if (rc > 0)
result = rc;
rc = rtems_rfs_buffer_handle_close (fs, &group->inode_bitmap_buffer);
1094c9: 8d 43 44 lea 0x44(%ebx),%eax
1094cc: 89 44 24 04 mov %eax,0x4(%esp)
rtems_rfs_buffer_handle_release (fs, handle);
1094d0: 8b 45 08 mov 0x8(%ebp),%eax
1094d3: 89 04 24 mov %eax,(%esp)
1094d6: e8 d5 e3 ff ff call 1078b0 <rtems_rfs_buffer_handle_release>
if (rc > 0)
result = rc;
rc = rtems_rfs_bitmap_close (&group->block_bitmap);
1094db: 8d 43 08 lea 0x8(%ebx),%eax
handle->dirty = false;
1094de: c6 43 44 00 movb $0x0,0x44(%ebx)
handle->bnum = 0;
1094e2: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx)
handle->buffer = NULL;
1094e9: c7 43 4c 00 00 00 00 movl $0x0,0x4c(%ebx)
1094f0: 89 04 24 mov %eax,(%esp)
1094f3: e8 d8 dc ff ff call 1071d0 <rtems_rfs_bitmap_close>
if (rc > 0)
1094f8: 85 c0 test %eax,%eax
rc = rtems_rfs_bitmap_close (&group->block_bitmap);
1094fa: 89 c7 mov %eax,%edi
if (rc > 0)
1094fc: 7f 0b jg 109509 <rtems_rfs_group_close+0x79> <== NEVER TAKEN
1094fe: 89 f2 mov %esi,%edx
109500: f7 d2 not %edx
109502: c1 fa 1f sar $0x1f,%edx
109505: 21 d6 and %edx,%esi
109507: 89 f7 mov %esi,%edi
result = rc;
rc = rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);
109509: 8d 43 20 lea 0x20(%ebx),%eax
10950c: 89 44 24 04 mov %eax,0x4(%esp)
rtems_rfs_buffer_handle_release (fs, handle);
109510: 8b 45 08 mov 0x8(%ebp),%eax
109513: 89 04 24 mov %eax,(%esp)
109516: e8 95 e3 ff ff call 1078b0 <rtems_rfs_buffer_handle_release>
if (rc > 0)
result = rc;
return result;
}
10951b: 8b 75 f8 mov -0x8(%ebp),%esi
10951e: 89 f8 mov %edi,%eax
handle->dirty = false;
109520: c6 43 20 00 movb $0x0,0x20(%ebx)
109524: 8b 7d fc mov -0x4(%ebp),%edi
handle->bnum = 0;
109527: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
handle->buffer = NULL;
10952e: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx)
109535: 8b 5d f4 mov -0xc(%ebp),%ebx
109538: 89 ec mov %ebp,%esp
10953a: 5d pop %ebp
10953b: c3 ret
10953c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
printf ("rtems-rfs: group-close: base=%" PRId32 "\n", group->base);
109540: 8b 03 mov (%ebx),%eax <== NOT EXECUTED
109542: c7 04 24 74 45 13 00 movl $0x134574,(%esp) <== NOT EXECUTED
109549: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
10954d: e8 ee 8b ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
109552: e9 65 ff ff ff jmp 1094bc <rtems_rfs_group_close+0x2c> <== NOT EXECUTED
109557: 90 nop
109558: 90 nop
109559: 90 nop
10955a: 90 nop
10955b: 90 nop
10955c: 90 nop
10955d: 90 nop
10955e: 90 nop
10955f: 90 nop
001091d0 <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)
{
1091d0: 55 push %ebp
1091d1: 89 e5 mov %esp,%ebp
1091d3: 57 push %edi
1091d4: 56 push %esi
1091d5: 53 push %ebx
1091d6: 83 ec 3c sub $0x3c,%esp
1091d9: 8b 75 08 mov 0x8(%ebp),%esi
1091dc: 8b 4d 0c mov 0xc(%ebp),%ecx
1091df: 8b 55 10 mov 0x10(%ebp),%edx
1091e2: 8b 5d 18 mov 0x18(%ebp),%ebx
int rc;
if (base >= rtems_rfs_fs_blocks (fs))
1091e5: 8b 46 04 mov 0x4(%esi),%eax
1091e8: 39 c8 cmp %ecx,%eax
1091ea: 0f 86 50 02 00 00 jbe 109440 <rtems_rfs_group_open+0x270> <== NEVER TAKEN
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))
1091f0: 8d 3c 11 lea (%ecx,%edx,1),%edi
1091f3: 39 f8 cmp %edi,%eax
1091f5: 77 04 ja 1091fb <rtems_rfs_group_open+0x2b> <== NEVER TAKEN
size = rtems_rfs_fs_blocks (fs) - base;
1091f7: 29 c8 sub %ecx,%eax
1091f9: 89 c2 mov %eax,%edx
* Limit the inodes to the same size as the blocks. This is what the
* format does and if this is not done the accounting of inodes does
* not work. If we are so pushed for inodes that this makes a difference
* the format configuration needs reviewing.
*/
if (inodes > size)
1091fb: 3b 55 14 cmp 0x14(%ebp),%edx
1091fe: 89 55 e4 mov %edx,-0x1c(%ebp)
109201: 0f 87 c9 00 00 00 ja 1092d0 <rtems_rfs_group_open+0x100> <== ALWAYS TAKEN
109207: 89 4d 0c mov %ecx,0xc(%ebp)
inodes = size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
10920a: 31 c9 xor %ecx,%ecx
10920c: 89 4c 24 04 mov %ecx,0x4(%esp)
109210: c7 04 24 00 80 00 00 movl $0x8000,(%esp)
109217: 89 55 10 mov %edx,0x10(%ebp)
10921a: e8 31 26 00 00 call 10b850 <rtems_rfs_trace>
10921f: 8b 4d 0c mov 0xc(%ebp),%ecx
109222: 8b 55 10 mov 0x10(%ebp),%edx
109225: 84 c0 test %al,%al
109227: 0f 85 23 01 00 00 jne 109350 <rtems_rfs_group_open+0x180> <== NEVER TAKEN
printf ("rtems-rfs: group-open: base=%" PRId32 ", blocks=%zd inodes=%zd\n",
base, size, inodes);
group->base = base;
10922d: 89 0b mov %ecx,(%ebx)
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,
10922f: 8d 43 08 lea 0x8(%ebx),%eax
group->size = size;
109232: 89 53 04 mov %edx,0x4(%ebx)
rc = rtems_rfs_buffer_handle_open (fs, &group->block_bitmap_buffer);
109235: 8d 7b 20 lea 0x20(%ebx),%edi
handle->dirty = false;
109238: c6 43 20 00 movb $0x0,0x20(%ebx)
handle->bnum = 0;
10923c: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
handle->buffer = NULL;
109243: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx)
rc = rtems_rfs_bitmap_open (&group->block_bitmap, fs,
10924a: 89 4c 24 10 mov %ecx,0x10(%esp)
10924e: 89 54 24 0c mov %edx,0xc(%esp)
109252: 89 7c 24 08 mov %edi,0x8(%esp)
109256: 89 74 24 04 mov %esi,0x4(%esp)
10925a: 89 04 24 mov %eax,(%esp)
10925d: 89 45 dc mov %eax,-0x24(%ebp)
109260: e8 0b df ff ff call 107170 <rtems_rfs_bitmap_open>
&group->block_bitmap_buffer, size,
group->base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
109265: 89 45 e0 mov %eax,-0x20(%ebp)
109268: 85 c0 test %eax,%eax
10926a: 7f 74 jg 1092e0 <rtems_rfs_group_open+0x110> <== NEVER TAKEN
handle->dirty = false;
10926c: c6 43 44 00 movb $0x0,0x44(%ebx)
printf ("rtems-rfs: group-open: could not open inode bitmap handle: %d: %s\n",
rc, strerror (rc));
return rc;
}
rc = rtems_rfs_bitmap_open (&group->inode_bitmap, fs,
109270: 8b 03 mov (%ebx),%eax
rc = rtems_rfs_buffer_handle_open (fs, &group->inode_bitmap_buffer);
109272: 8d 4b 44 lea 0x44(%ebx),%ecx
handle->bnum = 0;
109275: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx)
handle->buffer = NULL;
10927c: c7 43 4c 00 00 00 00 movl $0x0,0x4c(%ebx)
rc = rtems_rfs_bitmap_open (&group->inode_bitmap, fs,
109283: 89 4c 24 08 mov %ecx,0x8(%esp)
109287: 89 74 24 04 mov %esi,0x4(%esp)
10928b: 40 inc %eax
10928c: 89 44 24 10 mov %eax,0x10(%esp)
109290: 8b 45 e4 mov -0x1c(%ebp),%eax
109293: 89 4d e4 mov %ecx,-0x1c(%ebp)
109296: 89 44 24 0c mov %eax,0xc(%esp)
10929a: 8d 43 2c lea 0x2c(%ebx),%eax
10929d: 89 04 24 mov %eax,(%esp)
1092a0: e8 cb de ff ff call 107170 <rtems_rfs_bitmap_open>
&group->inode_bitmap_buffer, inodes,
group->base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
1092a5: 8b 4d e4 mov -0x1c(%ebp),%ecx
1092a8: 85 c0 test %eax,%eax
1092aa: 0f 8f d0 00 00 00 jg 109380 <rtems_rfs_group_open+0x1b0> <== NEVER TAKEN
{
rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);
rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);
}
return 0;
1092b0: 31 d2 xor %edx,%edx
if (rtems_rfs_fs_release_bitmaps (fs))
1092b2: f6 06 01 testb $0x1,(%esi)
1092b5: 0f 84 55 01 00 00 je 109410 <rtems_rfs_group_open+0x240> <== ALWAYS TAKEN
}
1092bb: 83 c4 3c add $0x3c,%esp <== NOT EXECUTED
1092be: 89 d0 mov %edx,%eax <== NOT EXECUTED
1092c0: 5b pop %ebx <== NOT EXECUTED
1092c1: 5e pop %esi <== NOT EXECUTED
1092c2: 5f pop %edi <== NOT EXECUTED
1092c3: 5d pop %ebp <== NOT EXECUTED
1092c4: c3 ret <== NOT EXECUTED
1092c5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1092cc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1092d0: 8b 45 14 mov 0x14(%ebp),%eax
1092d3: 89 45 e4 mov %eax,-0x1c(%ebp)
1092d6: e9 2c ff ff ff jmp 109207 <rtems_rfs_group_open+0x37>
1092db: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
1092df: 90 nop
rtems_rfs_buffer_handle_release (fs, handle);
1092e0: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED
1092e4: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
1092e7: e8 c4 e5 ff ff call 1078b0 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
1092ec: 31 d2 xor %edx,%edx <== NOT EXECUTED
handle->dirty = false;
1092ee: c6 43 20 00 movb $0x0,0x20(%ebx) <== NOT EXECUTED
handle->bnum = 0;
1092f2: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) <== NOT EXECUTED
handle->buffer = NULL;
1092f9: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx) <== NOT EXECUTED
109300: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
109304: c7 04 24 00 80 00 00 movl $0x8000,(%esp) <== NOT EXECUTED
10930b: e8 40 25 00 00 call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
109310: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED
109313: 84 c0 test %al,%al <== NOT EXECUTED
109315: 74 a4 je 1092bb <rtems_rfs_group_open+0xeb> <== NOT EXECUTED
printf ("rtems-rfs: group-open: could not open block bitmap: %d: %s\n",
109317: 89 14 24 mov %edx,(%esp) <== NOT EXECUTED
10931a: 89 55 e4 mov %edx,-0x1c(%ebp) <== NOT EXECUTED
10931d: e8 fe 20 02 00 call 12b420 <strerror> <== NOT EXECUTED
109322: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED
109325: c7 04 24 fc 44 13 00 movl $0x1344fc,(%esp) <== NOT EXECUTED
10932c: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
109330: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
109334: e8 07 8e ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
109339: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED
}
10933c: 83 c4 3c add $0x3c,%esp <== NOT EXECUTED
10933f: 5b pop %ebx <== NOT EXECUTED
109340: 5e pop %esi <== NOT EXECUTED
109341: 89 d0 mov %edx,%eax <== NOT EXECUTED
109343: 5f pop %edi <== NOT EXECUTED
109344: 5d pop %ebp <== NOT EXECUTED
109345: c3 ret <== NOT EXECUTED
109346: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10934d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
printf ("rtems-rfs: group-open: base=%" PRId32 ", blocks=%zd inodes=%zd\n",
109350: 89 54 24 08 mov %edx,0x8(%esp) <== NOT EXECUTED
109354: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED
109357: 89 4c 24 04 mov %ecx,0x4(%esp) <== NOT EXECUTED
10935b: c7 04 24 c4 44 13 00 movl $0x1344c4,(%esp) <== NOT EXECUTED
109362: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
109366: e8 d5 8d ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
10936b: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED
10936e: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED
109371: e9 b7 fe ff ff jmp 10922d <rtems_rfs_group_open+0x5d> <== NOT EXECUTED
109376: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10937d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
109380: 89 4c 24 04 mov %ecx,0x4(%esp) <== NOT EXECUTED
109384: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
109387: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED
10938a: e8 21 e5 ff ff call 1078b0 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
rtems_rfs_bitmap_close (&group->block_bitmap);
10938f: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED
handle->dirty = false;
109392: c6 43 44 00 movb $0x0,0x44(%ebx) <== NOT EXECUTED
handle->bnum = 0;
109396: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx) <== NOT EXECUTED
handle->buffer = NULL;
10939d: c7 43 4c 00 00 00 00 movl $0x0,0x4c(%ebx) <== NOT EXECUTED
1093a4: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
1093a7: e8 24 de ff ff call 1071d0 <rtems_rfs_bitmap_close> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
1093ac: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED
1093b0: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
1093b3: e8 f8 e4 ff ff call 1078b0 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
1093b8: 31 c0 xor %eax,%eax <== NOT EXECUTED
handle->dirty = false;
1093ba: c6 43 20 00 movb $0x0,0x20(%ebx) <== NOT EXECUTED
handle->bnum = 0;
1093be: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) <== NOT EXECUTED
handle->buffer = NULL;
1093c5: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx) <== NOT EXECUTED
1093cc: c7 04 24 00 80 00 00 movl $0x8000,(%esp) <== NOT EXECUTED
1093d3: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1093d7: e8 74 24 00 00 call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
1093dc: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED
1093df: 84 c0 test %al,%al <== NOT EXECUTED
1093e1: 0f 84 d4 fe ff ff je 1092bb <rtems_rfs_group_open+0xeb> <== NOT EXECUTED
printf ("rtems-rfs: group-open: could not open inode bitmap: %d: %s\n",
1093e7: 89 14 24 mov %edx,(%esp) <== NOT EXECUTED
1093ea: e8 31 20 02 00 call 12b420 <strerror> <== NOT EXECUTED
1093ef: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED
1093f2: c7 04 24 38 45 13 00 movl $0x134538,(%esp) <== NOT EXECUTED
1093f9: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
1093fd: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
109401: e8 3a 8d ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
109406: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED
109409: e9 ad fe ff ff jmp 1092bb <rtems_rfs_group_open+0xeb> <== NOT EXECUTED
10940e: 66 90 xchg %ax,%ax <== NOT EXECUTED
109410: 89 55 e4 mov %edx,-0x1c(%ebp)
rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);
109413: 8b 43 08 mov 0x8(%ebx),%eax
109416: 89 34 24 mov %esi,(%esp)
109419: 89 44 24 04 mov %eax,0x4(%esp)
10941d: e8 8e e4 ff ff call 1078b0 <rtems_rfs_buffer_handle_release>
rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);
109422: 8b 43 2c mov 0x2c(%ebx),%eax
109425: 89 34 24 mov %esi,(%esp)
109428: 89 44 24 04 mov %eax,0x4(%esp)
10942c: e8 7f e4 ff ff call 1078b0 <rtems_rfs_buffer_handle_release>
109431: 8b 55 e4 mov -0x1c(%ebp),%edx
}
109434: 83 c4 3c add $0x3c,%esp
109437: 5b pop %ebx
109438: 5e pop %esi
109439: 89 d0 mov %edx,%eax
10943b: 5f pop %edi
10943c: 5d pop %ebp
10943d: c3 ret
10943e: 66 90 xchg %ax,%ax
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
109440: c7 04 24 00 80 00 00 movl $0x8000,(%esp) <== NOT EXECUTED
109447: 31 f6 xor %esi,%esi <== NOT EXECUTED
109449: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED
10944d: e8 fe 23 00 00 call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
return EIO;
109452: ba 05 00 00 00 mov $0x5,%edx <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
109457: 84 c0 test %al,%al <== NOT EXECUTED
109459: 0f 84 5c fe ff ff je 1092bb <rtems_rfs_group_open+0xeb> <== NOT EXECUTED
printf ("rtems-rfs: group-open: base outside file system range: %d: %s\n",
10945f: c7 04 24 05 00 00 00 movl $0x5,(%esp) <== NOT EXECUTED
109466: bb 05 00 00 00 mov $0x5,%ebx <== NOT EXECUTED
10946b: 89 55 e4 mov %edx,-0x1c(%ebp) <== NOT EXECUTED
10946e: e8 ad 1f 02 00 call 12b420 <strerror> <== NOT EXECUTED
109473: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
109477: c7 04 24 84 44 13 00 movl $0x134484,(%esp) <== NOT EXECUTED
10947e: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
109482: e8 b9 8c ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
109487: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED
10948a: e9 2c fe ff ff jmp 1092bb <rtems_rfs_group_open+0xeb> <== NOT EXECUTED
10948f: 90 nop
001098b0 <rtems_rfs_group_usage>:
int
rtems_rfs_group_usage (rtems_rfs_file_system* fs,
size_t* blocks,
size_t* inodes)
{
1098b0: 55 push %ebp <== NOT EXECUTED
1098b1: 89 e5 mov %esp,%ebp <== NOT EXECUTED
1098b3: 57 push %edi <== NOT EXECUTED
1098b4: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED
1098b7: 56 push %esi <== NOT EXECUTED
1098b8: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED
1098bb: 53 push %ebx <== NOT EXECUTED
1098bc: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED
int g;
*blocks = 0;
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
1098bf: 8b 57 24 mov 0x24(%edi),%edx <== NOT EXECUTED
*blocks = 0;
1098c2: c7 01 00 00 00 00 movl $0x0,(%ecx) <== NOT EXECUTED
*inodes = 0;
1098c8: c7 03 00 00 00 00 movl $0x0,(%ebx) <== NOT EXECUTED
for (g = 0; g < fs->group_count; g++)
1098ce: 85 d2 test %edx,%edx <== NOT EXECUTED
1098d0: 7e 48 jle 10991a <rtems_rfs_group_usage+0x6a> <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
1098d2: 8b 77 20 mov 0x20(%edi),%esi <== NOT EXECUTED
1098d5: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED
1098d8: c1 e2 04 shl $0x4,%edx <== NOT EXECUTED
1098db: 8d 46 14 lea 0x14(%esi),%eax <== NOT EXECUTED
1098de: 8d 74 16 14 lea 0x14(%esi,%edx,1),%esi <== NOT EXECUTED
1098e2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1098e9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
*blocks +=
1098f0: 8b 10 mov (%eax),%edx <== NOT EXECUTED
for (g = 0; g < fs->group_count; g++)
1098f2: 83 c0 50 add $0x50,%eax <== NOT EXECUTED
*blocks +=
1098f5: 03 11 add (%ecx),%edx <== NOT EXECUTED
1098f7: 2b 50 b4 sub -0x4c(%eax),%edx <== NOT EXECUTED
1098fa: 89 11 mov %edx,(%ecx) <== NOT EXECUTED
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
rtems_rfs_bitmap_map_free (&group->block_bitmap);
*inodes +=
1098fc: 8b 50 d4 mov -0x2c(%eax),%edx <== NOT EXECUTED
1098ff: 03 13 add (%ebx),%edx <== NOT EXECUTED
109901: 2b 50 d8 sub -0x28(%eax),%edx <== NOT EXECUTED
for (g = 0; g < fs->group_count; g++)
109904: 39 c6 cmp %eax,%esi <== NOT EXECUTED
*inodes +=
109906: 89 13 mov %edx,(%ebx) <== NOT EXECUTED
for (g = 0; g < fs->group_count; g++)
109908: 75 e6 jne 1098f0 <rtems_rfs_group_usage+0x40> <== 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))
10990a: 8b 47 04 mov 0x4(%edi),%eax <== NOT EXECUTED
10990d: 39 01 cmp %eax,(%ecx) <== NOT EXECUTED
10990f: 77 1f ja 109930 <rtems_rfs_group_usage+0x80> <== NOT EXECUTED
*blocks = rtems_rfs_fs_blocks (fs);
if (*inodes > rtems_rfs_fs_inodes (fs))
109911: 8b 47 14 mov 0x14(%edi),%eax <== NOT EXECUTED
109914: 39 d0 cmp %edx,%eax <== NOT EXECUTED
109916: 73 02 jae 10991a <rtems_rfs_group_usage+0x6a> <== NOT EXECUTED
*inodes = rtems_rfs_fs_inodes (fs);
109918: 89 03 mov %eax,(%ebx) <== NOT EXECUTED
return 0;
}
10991a: 5b pop %ebx <== NOT EXECUTED
10991b: 31 c0 xor %eax,%eax <== NOT EXECUTED
10991d: 5e pop %esi <== NOT EXECUTED
10991e: 5f pop %edi <== NOT EXECUTED
10991f: 5d pop %ebp <== NOT EXECUTED
109920: c3 ret <== NOT EXECUTED
109921: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
109928: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10992f: 90 nop <== NOT EXECUTED
*blocks = rtems_rfs_fs_blocks (fs);
109930: 89 01 mov %eax,(%ecx) <== NOT EXECUTED
if (*inodes > rtems_rfs_fs_inodes (fs))
109932: 8b 13 mov (%ebx),%edx <== NOT EXECUTED
109934: eb db jmp 109911 <rtems_rfs_group_usage+0x61> <== NOT EXECUTED
109936: 90 nop
109937: 90 nop
109938: 90 nop
109939: 90 nop
10993a: 90 nop
10993b: 90 nop
10993c: 90 nop
10993d: 90 nop
10993e: 90 nop
10993f: 90 nop
00109c40 <rtems_rfs_inode_close>:
{
109c40: 55 push %ebp
109c41: 89 e5 mov %esp,%ebp
109c43: 56 push %esi
109c44: 53 push %ebx
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
109c45: 31 db xor %ebx,%ebx
{
109c47: 83 ec 10 sub $0x10,%esp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
109c4a: c7 04 24 00 00 08 00 movl $0x80000,(%esp)
{
109c51: 8b 75 0c mov 0xc(%ebp),%esi
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
109c54: 89 5c 24 04 mov %ebx,0x4(%esp)
109c58: e8 f3 1b 00 00 call 10b850 <rtems_rfs_trace>
109c5d: 84 c0 test %al,%al
109c5f: 75 6f jne 109cd0 <rtems_rfs_inode_close+0x90> <== NEVER TAKEN
rc = rtems_rfs_inode_unload (fs, handle, true);
109c61: 89 74 24 04 mov %esi,0x4(%esp)
109c65: 8b 45 08 mov 0x8(%ebp),%eax
109c68: b9 01 00 00 00 mov $0x1,%ecx
109c6d: 89 4c 24 08 mov %ecx,0x8(%esp)
109c71: 89 04 24 mov %eax,(%esp)
109c74: e8 c7 fe ff ff call 109b40 <rtems_rfs_inode_unload>
if ((rc == 0) && (handle->loads > 0))
109c79: 85 c0 test %eax,%eax
rc = rtems_rfs_inode_unload (fs, handle, true);
109c7b: 89 c3 mov %eax,%ebx
if ((rc == 0) && (handle->loads > 0))
109c7d: 75 07 jne 109c86 <rtems_rfs_inode_close+0x46> <== NEVER TAKEN
109c7f: 8b 56 24 mov 0x24(%esi),%edx
109c82: 85 d2 test %edx,%edx
109c84: 7f 1a jg 109ca0 <rtems_rfs_inode_close+0x60> <== NEVER TAKEN
handle->ino = 0;
109c86: c7 46 08 00 00 00 00 movl $0x0,0x8(%esi)
}
109c8d: 83 c4 10 add $0x10,%esp
109c90: 89 d8 mov %ebx,%eax
109c92: 5b pop %ebx
109c93: 5e pop %esi
109c94: 5d pop %ebp
109c95: c3 ret
109c96: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
109c9d: 8d 76 00 lea 0x0(%esi),%esi
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
109ca0: c7 04 24 00 00 08 00 movl $0x80000,(%esp) <== NOT EXECUTED
109ca7: 31 c0 xor %eax,%eax <== NOT EXECUTED
rc = EIO;
109ca9: bb 05 00 00 00 mov $0x5,%ebx <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
109cae: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
109cb2: e8 99 1b 00 00 call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
109cb7: 84 c0 test %al,%al <== NOT EXECUTED
109cb9: 74 cb je 109c86 <rtems_rfs_inode_close+0x46> <== NOT EXECUTED
printf ("rtems-rfs: inode-close: bad loads number: %d\n",
109cbb: 8b 46 24 mov 0x24(%esi),%eax <== NOT EXECUTED
109cbe: c7 04 24 ec 46 13 00 movl $0x1346ec,(%esp) <== NOT EXECUTED
109cc5: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
109cc9: e8 72 84 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
109cce: eb b6 jmp 109c86 <rtems_rfs_inode_close+0x46> <== NOT EXECUTED
printf ("rtems-rfs: inode-close: ino: %" PRIu32 "\n", handle->ino);
109cd0: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED
109cd3: c7 04 24 c8 46 13 00 movl $0x1346c8,(%esp) <== NOT EXECUTED
109cda: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
109cde: e8 5d 84 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
109ce3: e9 79 ff ff ff jmp 109c61 <rtems_rfs_inode_close+0x21> <== NOT EXECUTED
109ce8: 90 nop
109ce9: 90 nop
109cea: 90 nop
109ceb: 90 nop
109cec: 90 nop
109ced: 90 nop
109cee: 90 nop
109cef: 90 nop
0010a120 <rtems_rfs_inode_create>:
{
10a120: 55 push %ebp
10a121: 89 e5 mov %esp,%ebp
10a123: 57 push %edi
10a124: 56 push %esi
10a125: 53 push %ebx
10a126: 81 ec 9c 00 00 00 sub $0x9c,%esp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
10a12c: c7 04 24 00 00 40 00 movl $0x400000,(%esp)
{
10a133: 0f b7 45 1c movzwl 0x1c(%ebp),%eax
10a137: 0f b7 75 18 movzwl 0x18(%ebp),%esi
10a13b: 89 45 90 mov %eax,-0x70(%ebp)
10a13e: 0f b7 45 20 movzwl 0x20(%ebp),%eax
10a142: 89 75 94 mov %esi,-0x6c(%ebp)
10a145: 81 e6 00 f0 00 00 and $0xf000,%esi
10a14b: 89 45 8c mov %eax,-0x74(%ebp)
10a14e: 0f b7 45 24 movzwl 0x24(%ebp),%eax
10a152: 89 45 88 mov %eax,-0x78(%ebp)
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
10a155: 31 c0 xor %eax,%eax
10a157: 89 44 24 04 mov %eax,0x4(%esp)
10a15b: e8 f0 16 00 00 call 10b850 <rtems_rfs_trace>
10a160: 84 c0 test %al,%al
10a162: 0f 84 ad 00 00 00 je 10a215 <rtems_rfs_inode_create+0xf5> <== ALWAYS TAKEN
if (RTEMS_RFS_S_ISDIR (mode))
10a168: 81 fe 00 40 00 00 cmp $0x4000,%esi <== NOT EXECUTED
10a16e: 74 40 je 10a1b0 <rtems_rfs_inode_create+0x90> <== NOT EXECUTED
else if (RTEMS_RFS_S_ISCHR (mode))
10a170: 81 fe 00 20 00 00 cmp $0x2000,%esi <== NOT EXECUTED
10a176: 0f 84 b4 02 00 00 je 10a430 <rtems_rfs_inode_create+0x310> <== NOT EXECUTED
else if (RTEMS_RFS_S_ISBLK (mode))
10a17c: 81 fe 00 60 00 00 cmp $0x6000,%esi <== NOT EXECUTED
10a182: 0f 84 28 02 00 00 je 10a3b0 <rtems_rfs_inode_create+0x290> <== NOT EXECUTED
else if (RTEMS_RFS_S_ISREG (mode))
10a188: 81 fe 00 80 00 00 cmp $0x8000,%esi <== NOT EXECUTED
10a18e: 0f 84 dc 02 00 00 je 10a470 <rtems_rfs_inode_create+0x350> <== NOT EXECUTED
else if (RTEMS_RFS_S_ISLNK (mode))
10a194: 81 fe 00 a0 00 00 cmp $0xa000,%esi <== NOT EXECUTED
10a19a: 0f 84 dc 02 00 00 je 10a47c <rtems_rfs_inode_create+0x35c> <== NOT EXECUTED
const char* type = "unknown";
10a1a0: c7 45 84 55 47 13 00 movl $0x134755,-0x7c(%ebp) <== NOT EXECUTED
10a1a7: eb 0e jmp 10a1b7 <rtems_rfs_inode_create+0x97> <== NOT EXECUTED
10a1a9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
type = "dir";
10a1b0: c7 45 84 47 47 13 00 movl $0x134747,-0x7c(%ebp) <== NOT EXECUTED
printf("rtems-rfs: inode-create: parent:%" PRIu32 " name:", parent);
10a1b7: c7 04 24 78 47 13 00 movl $0x134778,(%esp) <== NOT EXECUTED
10a1be: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
10a1c1: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
10a1c5: e8 76 7f ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
for (c = 0; c < length; c++)
10a1ca: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED
10a1cd: 8b 5d 14 mov 0x14(%ebp),%ebx <== NOT EXECUTED
10a1d0: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED
10a1d3: 01 fb add %edi,%ebx <== NOT EXECUTED
10a1d5: 85 c0 test %eax,%eax <== NOT EXECUTED
10a1d7: 74 17 je 10a1f0 <rtems_rfs_inode_create+0xd0> <== NOT EXECUTED
10a1d9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
printf ("%c", name[c]);
10a1e0: 0f be 07 movsbl (%edi),%eax <== NOT EXECUTED
for (c = 0; c < length; c++)
10a1e3: 47 inc %edi <== NOT EXECUTED
printf ("%c", name[c]);
10a1e4: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
10a1e7: e8 a4 08 02 00 call 12aa90 <putchar> <== NOT EXECUTED
for (c = 0; c < length; c++)
10a1ec: 39 fb cmp %edi,%ebx <== NOT EXECUTED
10a1ee: 75 f0 jne 10a1e0 <rtems_rfs_inode_create+0xc0> <== NOT EXECUTED
printf (" type:%s mode:%04x (%03o)\n", type, mode, mode & ((1 << 10) - 1));
10a1f0: c7 04 24 5d 47 13 00 movl $0x13475d,(%esp) <== NOT EXECUTED
10a1f7: 8b 4d 94 mov -0x6c(%ebp),%ecx <== NOT EXECUTED
10a1fa: 89 4c 24 08 mov %ecx,0x8(%esp) <== NOT EXECUTED
10a1fe: 89 c8 mov %ecx,%eax <== NOT EXECUTED
10a200: 25 ff 03 00 00 and $0x3ff,%eax <== NOT EXECUTED
10a205: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
10a209: 8b 45 84 mov -0x7c(%ebp),%eax <== NOT EXECUTED
10a20c: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
10a210: e8 2b 7f ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
switch (mode & RTEMS_RFS_S_IFMT)
10a215: 81 fe 00 60 00 00 cmp $0x6000,%esi
10a21b: 74 43 je 10a260 <rtems_rfs_inode_create+0x140> <== NEVER TAKEN
10a21d: 76 21 jbe 10a240 <rtems_rfs_inode_create+0x120>
10a21f: 8b 45 94 mov -0x6c(%ebp),%eax
10a222: ba 16 00 00 00 mov $0x16,%edx
10a227: 25 00 d0 00 00 and $0xd000,%eax
10a22c: 3d 00 80 00 00 cmp $0x8000,%eax
10a231: 74 2d je 10a260 <rtems_rfs_inode_create+0x140> <== ALWAYS TAKEN
}
10a233: 81 c4 9c 00 00 00 add $0x9c,%esp
10a239: 89 d0 mov %edx,%eax
10a23b: 5b pop %ebx
10a23c: 5e pop %esi
10a23d: 5f pop %edi
10a23e: 5d pop %ebp
10a23f: c3 ret
switch (mode & RTEMS_RFS_S_IFMT)
10a240: 8d 86 00 e0 ff ff lea -0x2000(%esi),%eax
10a246: f6 c4 d0 test $0xd0,%ah
10a249: 74 15 je 10a260 <rtems_rfs_inode_create+0x140> <== ALWAYS TAKEN
}
10a24b: 81 c4 9c 00 00 00 add $0x9c,%esp <== NOT EXECUTED
switch (mode & RTEMS_RFS_S_IFMT)
10a251: ba 16 00 00 00 mov $0x16,%edx <== NOT EXECUTED
}
10a256: 5b pop %ebx <== NOT EXECUTED
10a257: 89 d0 mov %edx,%eax <== NOT EXECUTED
10a259: 5e pop %esi <== NOT EXECUTED
10a25a: 5f pop %edi <== NOT EXECUTED
10a25b: 5d pop %ebp <== NOT EXECUTED
10a25c: c3 ret <== NOT EXECUTED
10a25d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
rc = rtems_rfs_group_bitmap_alloc (fs, goal, true, &bit);
10a260: 8b 45 0c mov 0xc(%ebp),%eax
10a263: 8d 5d c0 lea -0x40(%ebp),%ebx
10a266: b9 01 00 00 00 mov $0x1,%ecx
10a26b: 89 4c 24 08 mov %ecx,0x8(%esp)
10a26f: 89 5c 24 0c mov %ebx,0xc(%esp)
10a273: 89 44 24 04 mov %eax,0x4(%esp)
10a277: 8b 45 08 mov 0x8(%ebp),%eax
10a27a: 89 04 24 mov %eax,(%esp)
10a27d: e8 de f2 ff ff call 109560 <rtems_rfs_group_bitmap_alloc>
*ino = bit;
10a282: 8b 4d 28 mov 0x28(%ebp),%ecx
rc = rtems_rfs_group_bitmap_alloc (fs, goal, true, &bit);
10a285: 89 c2 mov %eax,%edx
*ino = bit;
10a287: 8b 45 c0 mov -0x40(%ebp),%eax
if (rc > 0)
10a28a: 85 d2 test %edx,%edx
*ino = bit;
10a28c: 89 01 mov %eax,(%ecx)
if (rc > 0)
10a28e: 7f a3 jg 10a233 <rtems_rfs_inode_create+0x113>
rc = rtems_rfs_inode_open (fs, *ino, &inode, true);
10a290: 89 44 24 04 mov %eax,0x4(%esp)
10a294: 8b 45 08 mov 0x8(%ebp),%eax
10a297: ba 01 00 00 00 mov $0x1,%edx
10a29c: 89 54 24 0c mov %edx,0xc(%esp)
10a2a0: 89 5c 24 08 mov %ebx,0x8(%esp)
10a2a4: 89 04 24 mov %eax,(%esp)
10a2a7: e8 84 f7 ff ff call 109a30 <rtems_rfs_inode_open>
if (rc > 0)
10a2ac: 89 45 84 mov %eax,-0x7c(%ebp)
10a2af: 85 c0 test %eax,%eax
10a2b1: 0f 8f 89 01 00 00 jg 10a440 <rtems_rfs_inode_create+0x320> <== NEVER TAKEN
rc = rtems_rfs_inode_initialise (&inode, links, mode, uid, gid);
10a2b7: 89 1c 24 mov %ebx,(%esp)
10a2ba: 8b 45 88 mov -0x78(%ebp),%eax
10a2bd: 89 44 24 10 mov %eax,0x10(%esp)
10a2c1: 8b 45 8c mov -0x74(%ebp),%eax
10a2c4: 89 44 24 0c mov %eax,0xc(%esp)
10a2c8: 8b 45 94 mov -0x6c(%ebp),%eax
10a2cb: 89 44 24 08 mov %eax,0x8(%esp)
10a2cf: 8b 45 90 mov -0x70(%ebp),%eax
10a2d2: 89 44 24 04 mov %eax,0x4(%esp)
10a2d6: e8 35 fd ff ff call 10a010 <rtems_rfs_inode_initialise>
if (rc > 0)
10a2db: 85 c0 test %eax,%eax
10a2dd: 0f 8f a5 01 00 00 jg 10a488 <rtems_rfs_inode_create+0x368> <== NEVER TAKEN
if (RTEMS_RFS_S_ISDIR (mode))
10a2e3: 81 fe 00 40 00 00 cmp $0x4000,%esi
10a2e9: 0f 84 cd 00 00 00 je 10a3bc <rtems_rfs_inode_create+0x29c>
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
10a2ef: 8b 45 0c mov 0xc(%ebp),%eax
10a2f2: bf 01 00 00 00 mov $0x1,%edi
10a2f7: 89 7c 24 0c mov %edi,0xc(%esp)
10a2fb: 8d 7d 98 lea -0x68(%ebp),%edi
10a2fe: 89 7c 24 08 mov %edi,0x8(%esp)
10a302: 89 44 24 04 mov %eax,0x4(%esp)
10a306: 8b 45 08 mov 0x8(%ebp),%eax
10a309: 89 04 24 mov %eax,(%esp)
10a30c: e8 1f f7 ff ff call 109a30 <rtems_rfs_inode_open>
if (rc > 0)
10a311: 89 45 94 mov %eax,-0x6c(%ebp)
10a314: 85 c0 test %eax,%eax
10a316: 0f 8f e4 00 00 00 jg 10a400 <rtems_rfs_inode_create+0x2e0> <== NEVER TAKEN
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, *ino);
10a31c: 8b 45 28 mov 0x28(%ebp),%eax
10a31f: 8b 00 mov (%eax),%eax
10a321: 89 7c 24 04 mov %edi,0x4(%esp)
10a325: 89 44 24 10 mov %eax,0x10(%esp)
10a329: 8b 45 14 mov 0x14(%ebp),%eax
10a32c: 89 44 24 0c mov %eax,0xc(%esp)
10a330: 8b 45 10 mov 0x10(%ebp),%eax
10a333: 89 44 24 08 mov %eax,0x8(%esp)
10a337: 8b 45 08 mov 0x8(%ebp),%eax
10a33a: 89 04 24 mov %eax,(%esp)
10a33d: e8 6e c8 00 00 call 116bb0 <rtems_rfs_dir_add_entry>
if (rc > 0)
10a342: 85 c0 test %eax,%eax
10a344: 0f 8f 75 01 00 00 jg 10a4bf <rtems_rfs_inode_create+0x39f> <== NEVER TAKEN
if (RTEMS_RFS_S_ISDIR (mode))
10a34a: 81 fe 00 40 00 00 cmp $0x4000,%esi
10a350: 0f 84 a1 01 00 00 je 10a4f7 <rtems_rfs_inode_create+0x3d7>
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
10a356: 89 3c 24 mov %edi,(%esp)
10a359: ba 01 00 00 00 mov $0x1,%edx
10a35e: b9 01 00 00 00 mov $0x1,%ecx
10a363: 89 54 24 08 mov %edx,0x8(%esp)
10a367: 89 4c 24 04 mov %ecx,0x4(%esp)
10a36b: e8 e0 fb ff ff call 109f50 <rtems_rfs_inode_time_stamp_now>
if (rc > 0)
10a370: 89 45 94 mov %eax,-0x6c(%ebp)
10a373: 85 c0 test %eax,%eax
10a375: 0f 8f 85 00 00 00 jg 10a400 <rtems_rfs_inode_create+0x2e0> <== NEVER TAKEN
rc = rtems_rfs_inode_close (fs, &parent_inode);
10a37b: 89 7c 24 04 mov %edi,0x4(%esp)
10a37f: 8b 45 08 mov 0x8(%ebp),%eax
10a382: 89 04 24 mov %eax,(%esp)
10a385: e8 b6 f8 ff ff call 109c40 <rtems_rfs_inode_close>
rtems_rfs_inode_delete (fs, &inode);
10a38a: 89 5c 24 04 mov %ebx,0x4(%esp)
if (rc > 0)
10a38e: 89 45 94 mov %eax,-0x6c(%ebp)
10a391: 85 c0 test %eax,%eax
rtems_rfs_inode_delete (fs, &inode);
10a393: 8b 45 08 mov 0x8(%ebp),%eax
10a396: 89 04 24 mov %eax,(%esp)
if (rc > 0)
10a399: 7f 6f jg 10a40a <rtems_rfs_inode_create+0x2ea> <== NEVER TAKEN
rc = rtems_rfs_inode_close (fs, &inode);
10a39b: e8 a0 f8 ff ff call 109c40 <rtems_rfs_inode_close>
if (rc > 0)
10a3a0: 85 c0 test %eax,%eax
10a3a2: 0f 8f b3 01 00 00 jg 10a55b <rtems_rfs_inode_create+0x43b> <== NEVER TAKEN
return 0;
10a3a8: 31 d2 xor %edx,%edx
10a3aa: e9 84 fe ff ff jmp 10a233 <rtems_rfs_inode_create+0x113>
10a3af: 90 nop
type = "block";
10a3b0: c7 45 84 9b 45 13 00 movl $0x13459b,-0x7c(%ebp) <== NOT EXECUTED
10a3b7: e9 fb fd ff ff jmp 10a1b7 <rtems_rfs_inode_create+0x97> <== NOT EXECUTED
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, *ino);
10a3bc: 8b 45 28 mov 0x28(%ebp),%eax
10a3bf: 8b 00 mov (%eax),%eax
10a3c1: 89 5c 24 04 mov %ebx,0x4(%esp)
10a3c5: 89 44 24 10 mov %eax,0x10(%esp)
10a3c9: b8 01 00 00 00 mov $0x1,%eax
10a3ce: 89 44 24 0c mov %eax,0xc(%esp)
10a3d2: b8 92 75 13 00 mov $0x137592,%eax
10a3d7: 89 44 24 08 mov %eax,0x8(%esp)
10a3db: 8b 45 08 mov 0x8(%ebp),%eax
10a3de: 89 04 24 mov %eax,(%esp)
10a3e1: e8 ca c7 00 00 call 116bb0 <rtems_rfs_dir_add_entry>
if (rc == 0)
10a3e6: 85 c0 test %eax,%eax
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, *ino);
10a3e8: 89 c2 mov %eax,%edx
if (rc == 0)
10a3ea: 0f 84 36 01 00 00 je 10a526 <rtems_rfs_inode_create+0x406> <== ALWAYS TAKEN
if (rc > 0)
10a3f0: 85 d2 test %edx,%edx
10a3f2: 0f 8e f7 fe ff ff jle 10a2ef <rtems_rfs_inode_create+0x1cf> <== ALWAYS TAKEN
10a3f8: 89 55 94 mov %edx,-0x6c(%ebp) <== NOT EXECUTED
rtems_rfs_inode_delete (fs, &inode);
10a3fb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10a3ff: 90 nop <== NOT EXECUTED
rtems_rfs_inode_delete (fs, &inode);
10a400: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
10a404: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
10a407: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
rtems_rfs_inode_delete (fs, &inode);
10a40a: e8 e1 f8 ff ff call 109cf0 <rtems_rfs_inode_delete> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
10a40f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
10a412: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
10a416: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
10a419: e8 22 f8 ff ff call 109c40 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
10a41e: 8b 55 94 mov -0x6c(%ebp),%edx <== NOT EXECUTED
10a421: e9 0d fe ff ff jmp 10a233 <rtems_rfs_inode_create+0x113> <== NOT EXECUTED
10a426: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10a42d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
type = "char";
10a430: c7 45 84 50 47 13 00 movl $0x134750,-0x7c(%ebp) <== NOT EXECUTED
10a437: e9 7b fd ff ff jmp 10a1b7 <rtems_rfs_inode_create+0x97> <== NOT EXECUTED
10a43c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
return rtems_rfs_group_bitmap_free (fs, true, bit);
10a440: 8b 45 28 mov 0x28(%ebp),%eax <== NOT EXECUTED
10a443: 8b 00 mov (%eax),%eax <== NOT EXECUTED
10a445: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
10a449: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
10a44e: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
10a452: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
10a455: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
10a458: e8 a3 f3 ff ff call 109800 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
return rc;
10a45d: 8b 55 84 mov -0x7c(%ebp),%edx <== NOT EXECUTED
10a460: e9 ce fd ff ff jmp 10a233 <rtems_rfs_inode_create+0x113> <== NOT EXECUTED
10a465: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10a46c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
type = "file";
10a470: c7 45 84 4b 47 13 00 movl $0x13474b,-0x7c(%ebp) <== NOT EXECUTED
10a477: e9 3b fd ff ff jmp 10a1b7 <rtems_rfs_inode_create+0x97> <== NOT EXECUTED
type = "link";
10a47c: c7 45 84 9c 98 13 00 movl $0x13989c,-0x7c(%ebp) <== NOT EXECUTED
10a483: e9 2f fd ff ff jmp 10a1b7 <rtems_rfs_inode_create+0x97> <== NOT EXECUTED
10a488: 89 45 94 mov %eax,-0x6c(%ebp) <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
10a48b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
10a48e: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
10a492: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
10a495: e8 a6 f7 ff ff call 109c40 <rtems_rfs_inode_close> <== NOT EXECUTED
return rtems_rfs_group_bitmap_free (fs, true, bit);
10a49a: 8b 45 28 mov 0x28(%ebp),%eax <== NOT EXECUTED
10a49d: 8b 00 mov (%eax),%eax <== NOT EXECUTED
10a49f: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
10a4a3: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
10a4a8: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
10a4ac: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
10a4af: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
10a4b2: e8 49 f3 ff ff call 109800 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
return rc;
10a4b7: 8b 55 94 mov -0x6c(%ebp),%edx <== NOT EXECUTED
10a4ba: e9 74 fd ff ff jmp 10a233 <rtems_rfs_inode_create+0x113> <== NOT EXECUTED
10a4bf: 89 45 94 mov %eax,-0x6c(%ebp) <== NOT EXECUTED
rtems_rfs_inode_delete (fs, &inode);
10a4c2: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
10a4c5: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
10a4c9: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
10a4cc: e8 1f f8 ff ff call 109cf0 <rtems_rfs_inode_delete> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
10a4d1: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
10a4d4: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
10a4d8: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
10a4db: e8 60 f7 ff ff call 109c40 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
10a4e0: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
10a4e3: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED
10a4e7: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
10a4ea: e8 51 f7 ff ff call 109c40 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
10a4ef: 8b 55 94 mov -0x6c(%ebp),%edx <== NOT EXECUTED
10a4f2: e9 3c fd ff ff jmp 10a233 <rtems_rfs_inode_create+0x113> <== NOT EXECUTED
links = rtems_rfs_read_u16 (&handle->node->links);
10a4f7: 8b 55 a4 mov -0x5c(%ebp),%edx
10a4fa: 0f b7 0a movzwl (%edx),%ecx
10a4fd: 89 c8 mov %ecx,%eax
10a4ff: 0f b6 cd movzbl %ch,%ecx
10a502: c1 e0 08 shl $0x8,%eax
10a505: 09 c8 or %ecx,%eax
10a507: 0f b7 c0 movzwl %ax,%eax
if (links == 0xffff)
10a50a: 3d ff ff 00 00 cmp $0xffff,%eax
10a50f: 74 44 je 10a555 <rtems_rfs_inode_create+0x435> <== NEVER TAKEN
rtems_rfs_inode_get_links (&parent_inode) + 1);
10a511: 40 inc %eax
rtems_rfs_write_u16 (&handle->node->links, links);
10a512: 0f b6 cc movzbl %ah,%ecx
10a515: 88 0a mov %cl,(%edx)
10a517: 8b 55 a4 mov -0x5c(%ebp),%edx
10a51a: 88 42 01 mov %al,0x1(%edx)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
10a51d: c6 45 a8 01 movb $0x1,-0x58(%ebp)
}
10a521: e9 30 fe ff ff jmp 10a356 <rtems_rfs_inode_create+0x236>
rc = rtems_rfs_dir_add_entry (fs, &inode, "..", 2, parent);
10a526: 89 5c 24 04 mov %ebx,0x4(%esp)
10a52a: 8b 45 0c mov 0xc(%ebp),%eax
10a52d: 89 44 24 10 mov %eax,0x10(%esp)
10a531: b8 02 00 00 00 mov $0x2,%eax
10a536: 89 44 24 0c mov %eax,0xc(%esp)
10a53a: b8 91 75 13 00 mov $0x137591,%eax
10a53f: 89 44 24 08 mov %eax,0x8(%esp)
10a543: 8b 45 08 mov 0x8(%ebp),%eax
10a546: 89 04 24 mov %eax,(%esp)
10a549: e8 62 c6 00 00 call 116bb0 <rtems_rfs_dir_add_entry>
10a54e: 89 c2 mov %eax,%edx
10a550: e9 9b fe ff ff jmp 10a3f0 <rtems_rfs_inode_create+0x2d0>
10a555: b0 01 mov $0x1,%al <== NOT EXECUTED
10a557: 31 c9 xor %ecx,%ecx <== NOT EXECUTED
10a559: eb ba jmp 10a515 <rtems_rfs_inode_create+0x3f5> <== NOT EXECUTED
10a55b: 89 45 94 mov %eax,-0x6c(%ebp) <== NOT EXECUTED
10a55e: 66 90 xchg %ax,%ax <== NOT EXECUTED
10a560: e9 35 ff ff ff jmp 10a49a <rtems_rfs_inode_create+0x37a> <== NOT EXECUTED
10a565: 90 nop
10a566: 90 nop
10a567: 90 nop
10a568: 90 nop
10a569: 90 nop
10a56a: 90 nop
10a56b: 90 nop
10a56c: 90 nop
10a56d: 90 nop
10a56e: 90 nop
10a56f: 90 nop
00109cf0 <rtems_rfs_inode_delete>:
}
int
rtems_rfs_inode_delete (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
109cf0: 55 push %ebp
109cf1: 89 e5 mov %esp,%ebp
109cf3: 81 ec 88 00 00 00 sub $0x88,%esp
109cf9: 89 7d fc mov %edi,-0x4(%ebp)
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_DELETE))
109cfc: 31 ff xor %edi,%edi
109cfe: c7 04 24 00 00 80 00 movl $0x800000,(%esp)
109d05: 89 7c 24 04 mov %edi,0x4(%esp)
{
109d09: 89 75 f8 mov %esi,-0x8(%ebp)
109d0c: 8b 75 0c mov 0xc(%ebp),%esi
109d0f: 89 5d f4 mov %ebx,-0xc(%ebp)
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_DELETE))
109d12: e8 39 1b 00 00 call 10b850 <rtems_rfs_trace>
109d17: 84 c0 test %al,%al
109d19: 74 27 je 109d42 <rtems_rfs_inode_delete+0x52> <== ALWAYS TAKEN
printf("rtems-rfs: inode-delete: ino:%" PRIu32 " loaded:%s\n",
109d1b: 8b 5e 0c mov 0xc(%esi),%ebx <== NOT EXECUTED
109d1e: b8 37 46 13 00 mov $0x134637,%eax <== NOT EXECUTED
109d23: 85 db test %ebx,%ebx <== NOT EXECUTED
109d25: 0f 84 35 01 00 00 je 109e60 <rtems_rfs_inode_delete+0x170> <== NOT EXECUTED
109d2b: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
109d2f: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED
109d32: c7 04 24 1c 47 13 00 movl $0x13471c,(%esp) <== NOT EXECUTED
109d39: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
109d3d: e8 fe 83 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
rtems_rfs_inode_ino (handle),
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
109d42: 8b 4e 0c mov 0xc(%esi),%ecx
int rc = 0;
109d45: 31 db xor %ebx,%ebx
if (rtems_rfs_inode_is_loaded (handle))
109d47: 85 c9 test %ecx,%ecx
109d49: 74 21 je 109d6c <rtems_rfs_inode_delete+0x7c> <== NEVER TAKEN
return rtems_rfs_group_bitmap_free (fs, true, bit);
109d4b: 8b 46 08 mov 0x8(%esi),%eax
109d4e: ba 01 00 00 00 mov $0x1,%edx
109d53: 89 54 24 04 mov %edx,0x4(%esp)
109d57: 89 44 24 08 mov %eax,0x8(%esp)
109d5b: 8b 45 08 mov 0x8(%ebp),%eax
109d5e: 89 04 24 mov %eax,(%esp)
109d61: e8 9a fa ff ff call 109800 <rtems_rfs_group_bitmap_free>
/*
* Free the ino number.
*/
rc = rtems_rfs_inode_free (fs, handle->ino);
if (rc > 0)
109d66: 85 c0 test %eax,%eax
return rtems_rfs_group_bitmap_free (fs, true, bit);
109d68: 89 c3 mov %eax,%ebx
if (rc > 0)
109d6a: 7e 14 jle 109d80 <rtems_rfs_inode_delete+0x90> <== ALWAYS TAKEN
if (rrc > 0)
rc = rrc;
}
}
return rc;
}
109d6c: 8b 75 f8 mov -0x8(%ebp),%esi
109d6f: 89 d8 mov %ebx,%eax
109d71: 8b 5d f4 mov -0xc(%ebp),%ebx
109d74: 8b 7d fc mov -0x4(%ebp),%edi
109d77: 89 ec mov %ebp,%esp
109d79: 5d pop %ebp
109d7a: c3 ret
109d7b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
109d7f: 90 nop
rc = rtems_rfs_block_map_open (fs, handle, &map);
109d80: 89 74 24 04 mov %esi,0x4(%esp)
109d84: 8b 45 08 mov 0x8(%ebp),%eax
109d87: 8d 7d 98 lea -0x68(%ebp),%edi
109d8a: 89 7c 24 08 mov %edi,0x8(%esp)
109d8e: 89 04 24 mov %eax,(%esp)
109d91: e8 8a bb 00 00 call 115920 <rtems_rfs_block_map_open>
if (rc == 0)
109d96: 85 c0 test %eax,%eax
rc = rtems_rfs_block_map_open (fs, handle, &map);
109d98: 89 c3 mov %eax,%ebx
if (rc == 0)
109d9a: 75 d0 jne 109d6c <rtems_rfs_inode_delete+0x7c> <== NEVER TAKEN
rrc = rtems_rfs_block_map_free_all (fs, &map);
109d9c: 89 7c 24 04 mov %edi,0x4(%esp)
109da0: 8b 45 08 mov 0x8(%ebp),%eax
109da3: 89 04 24 mov %eax,(%esp)
109da6: e8 e5 c6 00 00 call 116490 <rtems_rfs_block_map_free_all>
rc = rtems_rfs_block_map_close (fs, &map);
109dab: 89 7c 24 04 mov %edi,0x4(%esp)
rrc = rtems_rfs_block_map_free_all (fs, &map);
109daf: 89 45 94 mov %eax,-0x6c(%ebp)
rc = rtems_rfs_block_map_close (fs, &map);
109db2: 8b 45 08 mov 0x8(%ebp),%eax
109db5: 89 04 24 mov %eax,(%esp)
109db8: e8 93 bc 00 00 call 115a50 <rtems_rfs_block_map_close>
memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE);
109dbd: 8b 56 0c mov 0xc(%esi),%edx
rc = rtems_rfs_block_map_close (fs, &map);
109dc0: 89 c3 mov %eax,%ebx
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
109dc2: 8d 46 10 lea 0x10(%esi),%eax
if (rc > 0)
109dc5: 85 db test %ebx,%ebx
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
109dc7: 89 45 90 mov %eax,-0x70(%ebp)
if (rc > 0)
109dca: 0f 8e a0 00 00 00 jle 109e70 <rtems_rfs_inode_delete+0x180> <== ALWAYS TAKEN
memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE);
109dd0: c7 45 94 38 00 00 00 movl $0x38,-0x6c(%ebp) <== NOT EXECUTED
109dd7: f6 c2 01 test $0x1,%dl <== NOT EXECUTED
109dda: b9 ff ff ff ff mov $0xffffffff,%ecx <== NOT EXECUTED
109ddf: 0f 85 3c 01 00 00 jne 109f21 <rtems_rfs_inode_delete+0x231> <== NOT EXECUTED
109de5: f6 c2 02 test $0x2,%dl <== NOT EXECUTED
109de8: 0f 85 22 01 00 00 jne 109f10 <rtems_rfs_inode_delete+0x220> <== NOT EXECUTED
109dee: 8b 7d 94 mov -0x6c(%ebp),%edi <== NOT EXECUTED
109df1: 31 c0 xor %eax,%eax <== NOT EXECUTED
109df3: 83 e7 f8 and $0xfffffff8,%edi <== NOT EXECUTED
109df6: 89 0c 02 mov %ecx,(%edx,%eax,1) <== NOT EXECUTED
109df9: 89 4c 02 04 mov %ecx,0x4(%edx,%eax,1) <== NOT EXECUTED
109dfd: 83 c0 08 add $0x8,%eax <== NOT EXECUTED
109e00: 39 f8 cmp %edi,%eax <== NOT EXECUTED
109e02: 72 f2 jb 109df6 <rtems_rfs_inode_delete+0x106> <== NOT EXECUTED
109e04: 01 c2 add %eax,%edx <== NOT EXECUTED
109e06: f6 45 94 04 testb $0x4,-0x6c(%ebp) <== NOT EXECUTED
109e0a: 74 09 je 109e15 <rtems_rfs_inode_delete+0x125> <== NOT EXECUTED
109e0c: c7 02 ff ff ff ff movl $0xffffffff,(%edx) <== NOT EXECUTED
109e12: 83 c2 04 add $0x4,%edx <== NOT EXECUTED
109e15: f6 45 94 02 testb $0x2,-0x6c(%ebp) <== NOT EXECUTED
109e19: 74 08 je 109e23 <rtems_rfs_inode_delete+0x133> <== NOT EXECUTED
109e1b: 66 c7 02 ff ff movw $0xffff,(%edx) <== NOT EXECUTED
109e20: 83 c2 02 add $0x2,%edx <== NOT EXECUTED
109e23: f6 45 94 01 testb $0x1,-0x6c(%ebp) <== NOT EXECUTED
109e27: 74 03 je 109e2c <rtems_rfs_inode_delete+0x13c> <== NOT EXECUTED
109e29: c6 02 ff movb $0xff,(%edx) <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
109e2c: c6 46 10 01 movb $0x1,0x10(%esi) <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
109e30: 8b 45 90 mov -0x70(%ebp),%eax <== NOT EXECUTED
109e33: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
109e37: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
109e3a: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
109e3d: e8 6e da ff ff call 1078b0 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->loads = 0;
109e42: c7 46 24 00 00 00 00 movl $0x0,0x24(%esi) <== NOT EXECUTED
handle->node = NULL;
109e49: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi) <== NOT EXECUTED
if (rrc > 0)
109e50: e9 17 ff ff ff jmp 109d6c <rtems_rfs_inode_delete+0x7c> <== NOT EXECUTED
109e55: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
109e5c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
printf("rtems-rfs: inode-delete: ino:%" PRIu32 " loaded:%s\n",
109e60: b8 3b 46 13 00 mov $0x13463b,%eax <== NOT EXECUTED
109e65: e9 c1 fe ff ff jmp 109d2b <rtems_rfs_inode_delete+0x3b> <== NOT EXECUTED
109e6a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE);
109e70: f6 c2 01 test $0x1,%dl
109e73: bf 38 00 00 00 mov $0x38,%edi
109e78: b9 ff ff ff ff mov $0xffffffff,%ecx
109e7d: 0f 85 be 00 00 00 jne 109f41 <rtems_rfs_inode_delete+0x251> <== NEVER TAKEN
109e83: f6 c2 02 test $0x2,%dl
109e86: 0f 85 a5 00 00 00 jne 109f31 <rtems_rfs_inode_delete+0x241> <== NEVER TAKEN
109e8c: 89 fb mov %edi,%ebx
109e8e: 31 c0 xor %eax,%eax
109e90: 83 e3 f8 and $0xfffffff8,%ebx
109e93: 89 0c 02 mov %ecx,(%edx,%eax,1)
109e96: 89 4c 02 04 mov %ecx,0x4(%edx,%eax,1)
109e9a: 83 c0 08 add $0x8,%eax
109e9d: 39 d8 cmp %ebx,%eax
109e9f: 72 f2 jb 109e93 <rtems_rfs_inode_delete+0x1a3>
109ea1: 01 c2 add %eax,%edx
109ea3: f7 c7 04 00 00 00 test $0x4,%edi
109ea9: 74 09 je 109eb4 <rtems_rfs_inode_delete+0x1c4> <== ALWAYS TAKEN
109eab: c7 02 ff ff ff ff movl $0xffffffff,(%edx) <== NOT EXECUTED
109eb1: 83 c2 04 add $0x4,%edx <== NOT EXECUTED
109eb4: f7 c7 02 00 00 00 test $0x2,%edi
109eba: 74 08 je 109ec4 <rtems_rfs_inode_delete+0x1d4> <== ALWAYS TAKEN
109ebc: 66 c7 02 ff ff movw $0xffff,(%edx) <== NOT EXECUTED
109ec1: 83 c2 02 add $0x2,%edx <== NOT EXECUTED
109ec4: 83 e7 01 and $0x1,%edi
109ec7: 74 03 je 109ecc <rtems_rfs_inode_delete+0x1dc> <== ALWAYS TAKEN
109ec9: c6 02 ff movb $0xff,(%edx) <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
109ecc: c6 46 10 01 movb $0x1,0x10(%esi)
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
109ed0: 8b 45 90 mov -0x70(%ebp),%eax
109ed3: 89 44 24 04 mov %eax,0x4(%esp)
109ed7: 8b 45 08 mov 0x8(%ebp),%eax
109eda: 89 04 24 mov %eax,(%esp)
109edd: e8 ce d9 ff ff call 1078b0 <rtems_rfs_buffer_handle_release>
handle->loads = 0;
109ee2: c7 46 24 00 00 00 00 movl $0x0,0x24(%esi)
handle->node = NULL;
109ee9: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi)
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
109ef0: 89 c3 mov %eax,%ebx
if (rrc > 0)
109ef2: 8b 45 94 mov -0x6c(%ebp),%eax
109ef5: 85 c0 test %eax,%eax
109ef7: 0f 8e 6f fe ff ff jle 109d6c <rtems_rfs_inode_delete+0x7c> <== ALWAYS TAKEN
109efd: 8b 5d 94 mov -0x6c(%ebp),%ebx <== NOT EXECUTED
109f00: e9 67 fe ff ff jmp 109d6c <rtems_rfs_inode_delete+0x7c> <== NOT EXECUTED
109f05: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
109f0c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE);
109f10: 66 c7 02 ff ff movw $0xffff,(%edx) <== NOT EXECUTED
109f15: 83 c2 02 add $0x2,%edx <== NOT EXECUTED
109f18: 83 6d 94 02 subl $0x2,-0x6c(%ebp) <== NOT EXECUTED
109f1c: e9 cd fe ff ff jmp 109dee <rtems_rfs_inode_delete+0xfe> <== NOT EXECUTED
109f21: c6 02 ff movb $0xff,(%edx) <== NOT EXECUTED
109f24: 42 inc %edx <== NOT EXECUTED
109f25: c7 45 94 37 00 00 00 movl $0x37,-0x6c(%ebp) <== NOT EXECUTED
109f2c: e9 b4 fe ff ff jmp 109de5 <rtems_rfs_inode_delete+0xf5> <== NOT EXECUTED
109f31: 66 c7 02 ff ff movw $0xffff,(%edx) <== NOT EXECUTED
109f36: 83 ef 02 sub $0x2,%edi <== NOT EXECUTED
109f39: 83 c2 02 add $0x2,%edx <== NOT EXECUTED
109f3c: e9 4b ff ff ff jmp 109e8c <rtems_rfs_inode_delete+0x19c> <== NOT EXECUTED
109f41: c6 02 ff movb $0xff,(%edx) <== NOT EXECUTED
109f44: bf 37 00 00 00 mov $0x37,%edi <== NOT EXECUTED
109f49: 42 inc %edx <== NOT EXECUTED
109f4a: e9 34 ff ff ff jmp 109e83 <rtems_rfs_inode_delete+0x193> <== NOT EXECUTED
109f4f: 90 nop
00109980 <rtems_rfs_inode_load>:
}
int
rtems_rfs_inode_load (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
109980: 55 push %ebp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_LOAD))
109981: 31 c0 xor %eax,%eax
{
109983: 89 e5 mov %esp,%ebp
109985: 83 ec 18 sub $0x18,%esp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_LOAD))
109988: c7 04 24 00 00 10 00 movl $0x100000,(%esp)
10998f: 89 44 24 04 mov %eax,0x4(%esp)
{
109993: 89 5d fc mov %ebx,-0x4(%ebp)
109996: 8b 5d 0c mov 0xc(%ebp),%ebx
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_LOAD))
109999: e8 b2 1e 00 00 call 10b850 <rtems_rfs_trace>
10999e: 84 c0 test %al,%al
1099a0: 74 2a je 1099cc <rtems_rfs_inode_load+0x4c> <== ALWAYS TAKEN
printf ("rtems-rfs: inode-load: ino=%" PRIu32 " loads=%i loaded=%s\n",
1099a2: 8b 4b 0c mov 0xc(%ebx),%ecx <== NOT EXECUTED
1099a5: b8 37 46 13 00 mov $0x134637,%eax <== NOT EXECUTED
1099aa: 85 c9 test %ecx,%ecx <== NOT EXECUTED
1099ac: 74 32 je 1099e0 <rtems_rfs_inode_load+0x60> <== NOT EXECUTED
1099ae: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
1099b2: 8b 43 24 mov 0x24(%ebx),%eax <== NOT EXECUTED
1099b5: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
1099b9: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED
1099bc: c7 04 24 40 46 13 00 movl $0x134640,(%esp) <== NOT EXECUTED
1099c3: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1099c7: e8 74 87 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
/*
* An inode does not move so once loaded no need to do again.
*/
if (!rtems_rfs_inode_is_loaded (handle))
1099cc: 8b 53 0c mov 0xc(%ebx),%edx
1099cf: 85 d2 test %edx,%edx
1099d1: 74 1d je 1099f0 <rtems_rfs_inode_load+0x70>
handle->node = rtems_rfs_buffer_data (&handle->buffer);
handle->node += handle->offset;
}
handle->loads++;
1099d3: ff 43 24 incl 0x24(%ebx)
return 0;
1099d6: 31 c0 xor %eax,%eax
}
1099d8: 8b 5d fc mov -0x4(%ebp),%ebx
1099db: 89 ec mov %ebp,%esp
1099dd: 5d pop %ebp
1099de: c3 ret
1099df: 90 nop
printf ("rtems-rfs: inode-load: ino=%" PRIu32 " loads=%i loaded=%s\n",
1099e0: b8 3b 46 13 00 mov $0x13463b,%eax <== NOT EXECUTED
1099e5: eb c7 jmp 1099ae <rtems_rfs_inode_load+0x2e> <== NOT EXECUTED
1099e7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1099ee: 66 90 xchg %ax,%ax <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs,&handle->buffer,
1099f0: b8 01 00 00 00 mov $0x1,%eax
1099f5: 89 44 24 0c mov %eax,0xc(%esp)
1099f9: 8b 43 1c mov 0x1c(%ebx),%eax
1099fc: 89 44 24 08 mov %eax,0x8(%esp)
109a00: 8d 43 10 lea 0x10(%ebx),%eax
109a03: 89 44 24 04 mov %eax,0x4(%esp)
109a07: 8b 45 08 mov 0x8(%ebp),%eax
109a0a: 89 04 24 mov %eax,(%esp)
109a0d: e8 be db ff ff call 1075d0 <rtems_rfs_buffer_handle_request>
if (rc > 0)
109a12: 85 c0 test %eax,%eax
109a14: 7f c2 jg 1099d8 <rtems_rfs_inode_load+0x58> <== NEVER TAKEN
handle->node += handle->offset;
109a16: 8b 53 20 mov 0x20(%ebx),%edx
handle->node = rtems_rfs_buffer_data (&handle->buffer);
109a19: 8b 4b 18 mov 0x18(%ebx),%ecx
handle->node += handle->offset;
109a1c: 8d 04 d5 00 00 00 00 lea 0x0(,%edx,8),%eax
109a23: 29 d0 sub %edx,%eax
109a25: 8b 51 1c mov 0x1c(%ecx),%edx
109a28: 8d 04 c2 lea (%edx,%eax,8),%eax
109a2b: 89 43 0c mov %eax,0xc(%ebx)
109a2e: eb a3 jmp 1099d3 <rtems_rfs_inode_load+0x53>
00109a30 <rtems_rfs_inode_open>:
{
109a30: 55 push %ebp
109a31: 89 e5 mov %esp,%ebp
109a33: 83 ec 38 sub $0x38,%esp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_OPEN))
109a36: c7 04 24 00 00 04 00 movl $0x40000,(%esp)
{
109a3d: 0f b6 45 14 movzbl 0x14(%ebp),%eax
109a41: 89 5d f4 mov %ebx,-0xc(%ebp)
109a44: 8b 5d 0c mov 0xc(%ebp),%ebx
109a47: 89 75 f8 mov %esi,-0x8(%ebp)
109a4a: 8b 75 10 mov 0x10(%ebp),%esi
109a4d: 89 7d fc mov %edi,-0x4(%ebp)
109a50: 8b 7d 08 mov 0x8(%ebp),%edi
109a53: 88 45 e7 mov %al,-0x19(%ebp)
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_OPEN))
109a56: 31 c0 xor %eax,%eax
109a58: 89 44 24 04 mov %eax,0x4(%esp)
109a5c: e8 ef 1d 00 00 call 10b850 <rtems_rfs_trace>
109a61: 84 c0 test %al,%al
109a63: 0f 85 b7 00 00 00 jne 109b20 <rtems_rfs_inode_open+0xf0> <== NEVER TAKEN
if (ino == RTEMS_RFS_EMPTY_INO)
109a69: 85 db test %ebx,%ebx
109a6b: 0f 84 8f 00 00 00 je 109b00 <rtems_rfs_inode_open+0xd0> <== NEVER TAKEN
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
109a71: 8d 43 ff lea -0x1(%ebx),%eax
109a74: 3b 47 14 cmp 0x14(%edi),%eax
109a77: 0f 87 83 00 00 00 ja 109b00 <rtems_rfs_inode_open+0xd0> <== NEVER TAKEN
handle->ino = ino;
109a7d: 89 5e 08 mov %ebx,0x8(%esi)
handle->node = NULL;
109a80: 31 d2 xor %edx,%edx
109a82: f7 77 2c divl 0x2c(%edi)
109a85: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi)
handle->loads = 0;
109a8c: c7 46 24 00 00 00 00 movl $0x0,0x24(%esi)
group = gino / fs->group_inodes;
109a93: 89 c1 mov %eax,%ecx
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
109a95: 89 d0 mov %edx,%eax
109a97: 31 d2 xor %edx,%edx
109a99: f7 77 30 divl 0x30(%edi)
handle->offset = gino % fs->inodes_per_block;
109a9c: 89 56 20 mov %edx,0x20(%esi)
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
109a9f: 8d 14 89 lea (%ecx,%ecx,4),%edx
109aa2: 8b 4f 20 mov 0x20(%edi),%ecx
109aa5: c1 e2 04 shl $0x4,%edx
109aa8: 01 ca add %ecx,%edx
109aaa: 8b 12 mov (%edx),%edx
handle->dirty = false;
109aac: c6 46 10 00 movb $0x0,0x10(%esi)
handle->bnum = 0;
109ab0: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi)
handle->buffer = NULL;
109ab7: c7 46 18 00 00 00 00 movl $0x0,0x18(%esi)
109abe: 8d 44 10 02 lea 0x2(%eax,%edx,1),%eax
109ac2: 89 46 1c mov %eax,0x1c(%esi)
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
109ac5: 31 c0 xor %eax,%eax
if ((rc == 0) && load)
109ac7: 80 7d e7 00 cmpb $0x0,-0x19(%ebp)
109acb: 75 13 jne 109ae0 <rtems_rfs_inode_open+0xb0> <== ALWAYS TAKEN
}
109acd: 8b 5d f4 mov -0xc(%ebp),%ebx <== NOT EXECUTED
109ad0: 8b 75 f8 mov -0x8(%ebp),%esi <== NOT EXECUTED
109ad3: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED
109ad6: 89 ec mov %ebp,%esp <== NOT EXECUTED
109ad8: 5d pop %ebp <== NOT EXECUTED
109ad9: c3 ret <== NOT EXECUTED
109ada: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
rc = rtems_rfs_inode_load (fs, handle);
109ae0: 89 75 0c mov %esi,0xc(%ebp)
}
109ae3: 8b 5d f4 mov -0xc(%ebp),%ebx
rc = rtems_rfs_inode_load (fs, handle);
109ae6: 89 7d 08 mov %edi,0x8(%ebp)
}
109ae9: 8b 75 f8 mov -0x8(%ebp),%esi
109aec: 8b 7d fc mov -0x4(%ebp),%edi
109aef: 89 ec mov %ebp,%esp
109af1: 5d pop %ebp
rc = rtems_rfs_inode_load (fs, handle);
109af2: e9 89 fe ff ff jmp 109980 <rtems_rfs_inode_load>
109af7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
109afe: 66 90 xchg %ax,%ax
}
109b00: 8b 5d f4 mov -0xc(%ebp),%ebx <== NOT EXECUTED
return EINVAL;
109b03: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED
}
109b08: 8b 75 f8 mov -0x8(%ebp),%esi <== NOT EXECUTED
109b0b: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED
109b0e: 89 ec mov %ebp,%esp <== NOT EXECUTED
109b10: 5d pop %ebp <== NOT EXECUTED
109b11: c3 ret <== NOT EXECUTED
109b12: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
109b19: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
printf ("rtems-rfs: inode-open: ino: %" PRIu32 "\n", ino);
109b20: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
109b24: c7 04 24 74 46 13 00 movl $0x134674,(%esp) <== NOT EXECUTED
109b2b: e8 10 86 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
109b30: e9 34 ff ff ff jmp 109a69 <rtems_rfs_inode_open+0x39> <== NOT EXECUTED
109b35: 90 nop
109b36: 90 nop
109b37: 90 nop
109b38: 90 nop
109b39: 90 nop
109b3a: 90 nop
109b3b: 90 nop
109b3c: 90 nop
109b3d: 90 nop
109b3e: 90 nop
109b3f: 90 nop
00109f50 <rtems_rfs_inode_time_stamp_now>:
int
rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,
bool atime,
bool mtime)
{
109f50: 55 push %ebp
109f51: 89 e5 mov %esp,%ebp
109f53: 56 push %esi
109f54: 53 push %ebx
109f55: 83 ec 20 sub $0x20,%esp
109f58: 8b 75 08 mov 0x8(%ebp),%esi
109f5b: 0f b6 4d 0c movzbl 0xc(%ebp),%ecx
109f5f: 0f b6 5d 10 movzbl 0x10(%ebp),%ebx
time_t now;
if (!rtems_rfs_inode_is_loaded (handle))
109f63: 8b 46 0c mov 0xc(%esi),%eax
{
109f66: 88 4d f7 mov %cl,-0x9(%ebp)
if (!rtems_rfs_inode_is_loaded (handle))
109f69: 85 c0 test %eax,%eax
109f6b: 0f 84 8f 00 00 00 je 10a000 <rtems_rfs_inode_time_stamp_now+0xb0> <== NEVER TAKEN
return ENXIO;
now = time (NULL);
109f71: c7 04 24 00 00 00 00 movl $0x0,(%esp)
109f78: e8 d3 4e 02 00 call 12ee50 <time>
if (atime)
109f7d: 0f b6 4d f7 movzbl -0x9(%ebp),%ecx
109f81: 84 c9 test %cl,%cl
109f83: 75 1b jne 109fa0 <rtems_rfs_inode_time_stamp_now+0x50> <== ALWAYS TAKEN
rtems_rfs_inode_set_atime (handle, now);
if (mtime)
rtems_rfs_inode_set_mtime (handle, now);
return 0;
109f85: 31 d2 xor %edx,%edx <== NOT EXECUTED
if (mtime)
109f87: 84 db test %bl,%bl <== NOT EXECUTED
109f89: 75 41 jne 109fcc <rtems_rfs_inode_time_stamp_now+0x7c> <== NOT EXECUTED
}
109f8b: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
109f8e: 89 d0 mov %edx,%eax <== NOT EXECUTED
109f90: 5b pop %ebx <== NOT EXECUTED
109f91: 5e pop %esi <== NOT EXECUTED
109f92: 5d pop %ebp <== NOT EXECUTED
109f93: c3 ret <== NOT EXECUTED
109f94: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
109f9b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
109f9f: 90 nop <== NOT EXECUTED
rtems_rfs_write_u32 (&handle->node->atime, atime);
109fa0: 8b 4e 0c mov 0xc(%esi),%ecx
109fa3: 89 c2 mov %eax,%edx
109fa5: c1 ea 18 shr $0x18,%edx
109fa8: 88 51 10 mov %dl,0x10(%ecx)
109fab: 89 c2 mov %eax,%edx
109fad: 8b 4e 0c mov 0xc(%esi),%ecx
109fb0: c1 ea 10 shr $0x10,%edx
109fb3: 88 51 11 mov %dl,0x11(%ecx)
109fb6: 8b 56 0c mov 0xc(%esi),%edx
109fb9: 88 62 12 mov %ah,0x12(%edx)
109fbc: 8b 56 0c mov 0xc(%esi),%edx
109fbf: 88 42 13 mov %al,0x13(%edx)
return 0;
109fc2: 31 d2 xor %edx,%edx
if (mtime)
109fc4: 84 db test %bl,%bl
rtems_rfs_buffer_mark_dirty (&handle->buffer);
109fc6: c6 46 10 01 movb $0x1,0x10(%esi)
109fca: 74 bf je 109f8b <rtems_rfs_inode_time_stamp_now+0x3b> <== NEVER TAKEN
rtems_rfs_write_u32 (&handle->node->mtime, mtime);
109fcc: 8b 5e 0c mov 0xc(%esi),%ebx
109fcf: 89 c1 mov %eax,%ecx
109fd1: c1 e9 18 shr $0x18,%ecx
109fd4: 88 4b 14 mov %cl,0x14(%ebx)
109fd7: 89 c1 mov %eax,%ecx
109fd9: 8b 5e 0c mov 0xc(%esi),%ebx
109fdc: c1 e9 10 shr $0x10,%ecx
109fdf: 88 4b 15 mov %cl,0x15(%ebx)
109fe2: 8b 4e 0c mov 0xc(%esi),%ecx
109fe5: 88 61 16 mov %ah,0x16(%ecx)
109fe8: 8b 4e 0c mov 0xc(%esi),%ecx
109feb: 88 41 17 mov %al,0x17(%ecx)
}
109fee: 89 d0 mov %edx,%eax
rtems_rfs_buffer_mark_dirty (&handle->buffer);
109ff0: c6 46 10 01 movb $0x1,0x10(%esi)
109ff4: 83 c4 20 add $0x20,%esp
109ff7: 5b pop %ebx
109ff8: 5e pop %esi
109ff9: 5d pop %ebp
109ffa: c3 ret
109ffb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
109fff: 90 nop
10a000: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
return ENXIO;
10a003: ba 06 00 00 00 mov $0x6,%edx <== NOT EXECUTED
}
10a008: 5b pop %ebx <== NOT EXECUTED
10a009: 89 d0 mov %edx,%eax <== NOT EXECUTED
10a00b: 5e pop %esi <== NOT EXECUTED
10a00c: 5d pop %ebp <== NOT EXECUTED
10a00d: c3 ret <== NOT EXECUTED
10a00e: 90 nop
10a00f: 90 nop
00109b40 <rtems_rfs_inode_unload>:
int
rtems_rfs_inode_unload (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle,
bool update_ctime)
{
109b40: 55 push %ebp
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD))
109b41: 31 c9 xor %ecx,%ecx
{
109b43: 89 e5 mov %esp,%ebp
109b45: 56 push %esi
109b46: 53 push %ebx
109b47: 83 ec 10 sub $0x10,%esp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD))
109b4a: c7 04 24 00 00 20 00 movl $0x200000,(%esp)
{
109b51: 8b 75 0c mov 0xc(%ebp),%esi
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD))
109b54: 89 4c 24 04 mov %ecx,0x4(%esp)
{
109b58: 0f b6 5d 10 movzbl 0x10(%ebp),%ebx
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD))
109b5c: e8 ef 1c 00 00 call 10b850 <rtems_rfs_trace>
109b61: 84 c0 test %al,%al
109b63: 74 2a je 109b8f <rtems_rfs_inode_unload+0x4f> <== ALWAYS TAKEN
printf ("rtems-rfs: inode-unload: ino=%" PRIu32 " loads=%i loaded=%s\n",
109b65: 8b 56 0c mov 0xc(%esi),%edx <== NOT EXECUTED
109b68: b8 37 46 13 00 mov $0x134637,%eax <== NOT EXECUTED
109b6d: 85 d2 test %edx,%edx <== NOT EXECUTED
109b6f: 74 6f je 109be0 <rtems_rfs_inode_unload+0xa0> <== NOT EXECUTED
109b71: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
109b75: 8b 46 24 mov 0x24(%esi),%eax <== NOT EXECUTED
109b78: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
109b7c: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED
109b7f: c7 04 24 94 46 13 00 movl $0x134694,(%esp) <== NOT EXECUTED
109b86: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
109b8a: e8 b1 85 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
handle->ino, handle->loads,
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
109b8f: 8b 46 0c mov 0xc(%esi),%eax
109b92: 85 c0 test %eax,%eax
109b94: 74 0d je 109ba3 <rtems_rfs_inode_unload+0x63>
{
if (handle->loads == 0)
109b96: 8b 46 24 mov 0x24(%esi),%eax
109b99: 85 c0 test %eax,%eax
109b9b: 74 53 je 109bf0 <rtems_rfs_inode_unload+0xb0> <== NEVER TAKEN
return EIO;
handle->loads--;
109b9d: 48 dec %eax
109b9e: 89 46 24 mov %eax,0x24(%esi)
if (handle->loads == 0)
109ba1: 74 0d je 109bb0 <rtems_rfs_inode_unload+0x70>
handle->node = NULL;
}
}
return rc;
}
109ba3: 83 c4 10 add $0x10,%esp
int rc = 0;
109ba6: 31 c0 xor %eax,%eax
}
109ba8: 5b pop %ebx
109ba9: 5e pop %esi
109baa: 5d pop %ebp
109bab: c3 ret
109bac: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
if (rtems_rfs_buffer_dirty (&handle->buffer) && update_ctime)
109bb0: 80 7e 10 00 cmpb $0x0,0x10(%esi)
109bb4: 74 04 je 109bba <rtems_rfs_inode_unload+0x7a>
109bb6: 84 db test %bl,%bl
109bb8: 75 46 jne 109c00 <rtems_rfs_inode_unload+0xc0> <== ALWAYS TAKEN
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
109bba: 8d 46 10 lea 0x10(%esi),%eax
109bbd: 89 44 24 04 mov %eax,0x4(%esp)
109bc1: 8b 45 08 mov 0x8(%ebp),%eax
109bc4: 89 04 24 mov %eax,(%esp)
109bc7: e8 e4 dc ff ff call 1078b0 <rtems_rfs_buffer_handle_release>
handle->node = NULL;
109bcc: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi)
}
109bd3: 83 c4 10 add $0x10,%esp
109bd6: 5b pop %ebx
109bd7: 5e pop %esi
109bd8: 5d pop %ebp
109bd9: c3 ret
109bda: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
printf ("rtems-rfs: inode-unload: ino=%" PRIu32 " loads=%i loaded=%s\n",
109be0: b8 3b 46 13 00 mov $0x13463b,%eax <== NOT EXECUTED
109be5: eb 8a jmp 109b71 <rtems_rfs_inode_unload+0x31> <== NOT EXECUTED
109be7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
109bee: 66 90 xchg %ax,%ax <== NOT EXECUTED
}
109bf0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
return EIO;
109bf3: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED
}
109bf8: 5b pop %ebx <== NOT EXECUTED
109bf9: 5e pop %esi <== NOT EXECUTED
109bfa: 5d pop %ebp <== NOT EXECUTED
109bfb: c3 ret <== NOT EXECUTED
109bfc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
rtems_rfs_inode_set_ctime (handle, time (NULL));
109c00: c7 04 24 00 00 00 00 movl $0x0,(%esp)
109c07: e8 44 52 02 00 call 12ee50 <time>
*/
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);
109c0c: 8b 56 0c mov 0xc(%esi),%edx
109c0f: 89 c1 mov %eax,%ecx
109c11: c1 e9 18 shr $0x18,%ecx
109c14: 88 4a 18 mov %cl,0x18(%edx)
109c17: 89 c1 mov %eax,%ecx
109c19: 8b 56 0c mov 0xc(%esi),%edx
109c1c: c1 e9 10 shr $0x10,%ecx
109c1f: 88 4a 19 mov %cl,0x19(%edx)
109c22: 8b 56 0c mov 0xc(%esi),%edx
109c25: 88 62 1a mov %ah,0x1a(%edx)
109c28: 8b 56 0c mov 0xc(%esi),%edx
109c2b: 88 42 1b mov %al,0x1b(%edx)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
109c2e: c6 46 10 01 movb $0x1,0x10(%esi)
}
109c32: eb 86 jmp 109bba <rtems_rfs_inode_unload+0x7a>
109c34: 90 nop
109c35: 90 nop
109c36: 90 nop
109c37: 90 nop
109c38: 90 nop
109c39: 90 nop
109c3a: 90 nop
109c3b: 90 nop
109c3c: 90 nop
109c3d: 90 nop
109c3e: 90 nop
109c3f: 90 nop
00119ef0 <rtems_rfs_link>:
const char* name,
int length,
rtems_rfs_ino parent,
rtems_rfs_ino target,
bool link_dir)
{
119ef0: 55 push %ebp
119ef1: 89 e5 mov %esp,%ebp
119ef3: 57 push %edi
119ef4: 56 push %esi
119ef5: 53 push %ebx
119ef6: 81 ec 8c 00 00 00 sub $0x8c,%esp
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))
119efc: c7 04 24 00 00 00 01 movl $0x1000000,(%esp)
{
119f03: 0f b6 45 1c movzbl 0x1c(%ebp),%eax
119f07: 8b 75 08 mov 0x8(%ebp),%esi
119f0a: 88 45 94 mov %al,-0x6c(%ebp)
if (rtems_rfs_trace (RTEMS_RFS_TRACE_LINK))
119f0d: 31 c0 xor %eax,%eax
119f0f: 89 44 24 04 mov %eax,0x4(%esp)
119f13: e8 38 19 ff ff call 10b850 <rtems_rfs_trace>
119f18: 84 c0 test %al,%al
119f1a: 0f 85 70 01 00 00 jne 11a090 <rtems_rfs_link+0x1a0> <== NEVER TAKEN
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf ("(%" PRIu32 ")\n", target);
}
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
119f20: 8b 45 18 mov 0x18(%ebp),%eax
119f23: 8d 7d c0 lea -0x40(%ebp),%edi
119f26: bb 01 00 00 00 mov $0x1,%ebx
119f2b: 89 5c 24 0c mov %ebx,0xc(%esp)
119f2f: 89 7c 24 08 mov %edi,0x8(%esp)
119f33: 89 34 24 mov %esi,(%esp)
119f36: 89 44 24 04 mov %eax,0x4(%esp)
119f3a: e8 f1 fa fe ff call 109a30 <rtems_rfs_inode_open>
if (rc)
119f3f: 85 c0 test %eax,%eax
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
119f41: 89 c2 mov %eax,%edx
if (rc)
119f43: 0f 85 e4 00 00 00 jne 11a02d <rtems_rfs_link+0x13d> <== NEVER TAKEN
/*
* 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)))
119f49: 80 7d 94 00 cmpb $0x0,-0x6c(%ebp)
119f4d: 75 1a jne 119f69 <rtems_rfs_link+0x79>
119f4f: 8b 45 cc mov -0x34(%ebp),%eax
119f52: 0f b7 40 02 movzwl 0x2(%eax),%eax
119f56: c1 e0 08 shl $0x8,%eax
119f59: 25 00 f0 00 00 and $0xf000,%eax
119f5e: 3d 00 40 00 00 cmp $0x4000,%eax
119f63: 0f 84 a4 01 00 00 je 11a10d <rtems_rfs_link+0x21d> <== NEVER TAKEN
{
rtems_rfs_inode_close (fs, &target_inode);
return ENOTSUP;
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
119f69: 8b 45 14 mov 0x14(%ebp),%eax
119f6c: 8d 5d 98 lea -0x68(%ebp),%ebx
119f6f: b9 01 00 00 00 mov $0x1,%ecx
119f74: 89 4c 24 0c mov %ecx,0xc(%esp)
119f78: 89 5c 24 08 mov %ebx,0x8(%esp)
119f7c: 89 34 24 mov %esi,(%esp)
119f7f: 89 44 24 04 mov %eax,0x4(%esp)
119f83: e8 a8 fa fe ff call 109a30 <rtems_rfs_inode_open>
if (rc)
119f88: 85 c0 test %eax,%eax
119f8a: 0f 85 b0 00 00 00 jne 11a040 <rtems_rfs_link+0x150> <== NEVER TAKEN
{
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, target);
119f90: 89 5c 24 04 mov %ebx,0x4(%esp)
119f94: 8b 45 18 mov 0x18(%ebp),%eax
119f97: 89 34 24 mov %esi,(%esp)
119f9a: 89 44 24 10 mov %eax,0x10(%esp)
119f9e: 8b 45 10 mov 0x10(%ebp),%eax
119fa1: 89 44 24 0c mov %eax,0xc(%esp)
119fa5: 8b 45 0c mov 0xc(%ebp),%eax
119fa8: 89 44 24 08 mov %eax,0x8(%esp)
119fac: e8 ff cb ff ff call 116bb0 <rtems_rfs_dir_add_entry>
if (rc > 0)
119fb1: 85 c0 test %eax,%eax
119fb3: 0f 8f a7 00 00 00 jg 11a060 <rtems_rfs_link+0x170> <== NEVER TAKEN
links = rtems_rfs_read_u16 (&handle->node->links);
119fb9: 8b 4d cc mov -0x34(%ebp),%ecx
119fbc: 0f b7 11 movzwl (%ecx),%edx
119fbf: 89 d0 mov %edx,%eax
119fc1: 0f b6 d6 movzbl %dh,%edx
119fc4: c1 e0 08 shl $0x8,%eax
119fc7: 09 d0 or %edx,%eax
119fc9: 0f b7 c0 movzwl %ax,%eax
if (links == 0xffff)
119fcc: 3d ff ff 00 00 cmp $0xffff,%eax
119fd1: 0f 84 19 01 00 00 je 11a0f0 <rtems_rfs_link+0x200> <== NEVER TAKEN
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
links = rtems_rfs_inode_get_links (&target_inode) + 1;
119fd7: 40 inc %eax
rtems_rfs_write_u16 (&handle->node->links, links);
119fd8: 0f b6 d4 movzbl %ah,%edx
119fdb: 88 11 mov %dl,(%ecx)
119fdd: 8b 55 cc mov -0x34(%ebp),%edx
119fe0: 88 42 01 mov %al,0x1(%edx)
rtems_rfs_inode_set_links (&target_inode, links);
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
119fe3: b8 01 00 00 00 mov $0x1,%eax
119fe8: ba 01 00 00 00 mov $0x1,%edx
119fed: 89 44 24 08 mov %eax,0x8(%esp)
119ff1: 89 54 24 04 mov %edx,0x4(%esp)
119ff5: 89 1c 24 mov %ebx,(%esp)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
119ff8: c6 45 d0 01 movb $0x1,-0x30(%ebp)
119ffc: e8 4f ff fe ff call 109f50 <rtems_rfs_inode_time_stamp_now>
if (rc > 0)
{
rtems_rfs_inode_close (fs, &parent_inode);
11a001: 89 5c 24 04 mov %ebx,0x4(%esp)
11a005: 89 34 24 mov %esi,(%esp)
if (rc > 0)
11a008: 89 45 94 mov %eax,-0x6c(%ebp)
11a00b: 85 c0 test %eax,%eax
11a00d: 7f 5b jg 11a06a <rtems_rfs_link+0x17a> <== NEVER TAKEN
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &parent_inode);
11a00f: e8 2c fc fe ff call 109c40 <rtems_rfs_inode_close>
if (rc > 0)
{
rtems_rfs_inode_close (fs, &target_inode);
11a014: 89 7c 24 04 mov %edi,0x4(%esp)
11a018: 89 34 24 mov %esi,(%esp)
if (rc > 0)
11a01b: 89 45 94 mov %eax,-0x6c(%ebp)
11a01e: 85 c0 test %eax,%eax
11a020: 0f 8f da 00 00 00 jg 11a100 <rtems_rfs_link+0x210> <== NEVER TAKEN
return rc;
}
rc = rtems_rfs_inode_close (fs, &target_inode);
11a026: e8 15 fc fe ff call 109c40 <rtems_rfs_inode_close>
11a02b: 89 c2 mov %eax,%edx
return rc;
}
11a02d: 81 c4 8c 00 00 00 add $0x8c,%esp
11a033: 89 d0 mov %edx,%eax
11a035: 5b pop %ebx
11a036: 5e pop %esi
11a037: 5f pop %edi
11a038: 5d pop %ebp
11a039: c3 ret
11a03a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
rtems_rfs_inode_close (fs, &target_inode);
11a040: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED
11a044: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
11a047: 89 45 94 mov %eax,-0x6c(%ebp) <== NOT EXECUTED
11a04a: e8 f1 fb fe ff call 109c40 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
11a04f: 8b 55 94 mov -0x6c(%ebp),%edx <== NOT EXECUTED
}
11a052: 81 c4 8c 00 00 00 add $0x8c,%esp <== NOT EXECUTED
11a058: 5b pop %ebx <== NOT EXECUTED
11a059: 5e pop %esi <== NOT EXECUTED
11a05a: 89 d0 mov %edx,%eax <== NOT EXECUTED
11a05c: 5f pop %edi <== NOT EXECUTED
11a05d: 5d pop %ebp <== NOT EXECUTED
11a05e: c3 ret <== NOT EXECUTED
11a05f: 90 nop <== NOT EXECUTED
11a060: 89 45 94 mov %eax,-0x6c(%ebp) <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
11a063: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
11a067: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
11a06a: e8 d1 fb fe ff call 109c40 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
11a06f: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED
11a073: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
11a076: e8 c5 fb fe ff call 109c40 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
11a07b: 8b 55 94 mov -0x6c(%ebp),%edx <== NOT EXECUTED
}
11a07e: 81 c4 8c 00 00 00 add $0x8c,%esp <== NOT EXECUTED
11a084: 5b pop %ebx <== NOT EXECUTED
11a085: 5e pop %esi <== NOT EXECUTED
11a086: 89 d0 mov %edx,%eax <== NOT EXECUTED
11a088: 5f pop %edi <== NOT EXECUTED
11a089: 5d pop %ebp <== NOT EXECUTED
11a08a: c3 ret <== NOT EXECUTED
11a08b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11a08f: 90 nop <== NOT EXECUTED
printf ("rtems-rfs: link: parent(%" PRIu32 ") -> ", parent);
11a090: c7 04 24 78 61 13 00 movl $0x136178,(%esp) <== NOT EXECUTED
11a097: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED
11a09a: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
11a09e: e8 9d 80 fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
for (c = 0; c < length; c++)
11a0a3: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED
11a0a6: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED
11a0a9: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
11a0ac: 01 df add %ebx,%edi <== NOT EXECUTED
11a0ae: 85 c0 test %eax,%eax <== NOT EXECUTED
11a0b0: 7e 1e jle 11a0d0 <rtems_rfs_link+0x1e0> <== NOT EXECUTED
11a0b2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11a0b9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
printf ("%c", name[c]);
11a0c0: 0f be 03 movsbl (%ebx),%eax <== NOT EXECUTED
for (c = 0; c < length; c++)
11a0c3: 43 inc %ebx <== NOT EXECUTED
printf ("%c", name[c]);
11a0c4: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
11a0c7: e8 c4 09 01 00 call 12aa90 <putchar> <== NOT EXECUTED
for (c = 0; c < length; c++)
11a0cc: 39 df cmp %ebx,%edi <== NOT EXECUTED
11a0ce: 75 f0 jne 11a0c0 <rtems_rfs_link+0x1d0> <== NOT EXECUTED
printf ("(%" PRIu32 ")\n", target);
11a0d0: c7 04 24 98 61 13 00 movl $0x136198,(%esp) <== NOT EXECUTED
11a0d7: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED
11a0da: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
11a0de: e8 5d 80 fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
11a0e3: e9 38 fe ff ff jmp 119f20 <rtems_rfs_link+0x30> <== NOT EXECUTED
11a0e8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11a0ef: 90 nop <== NOT EXECUTED
11a0f0: b0 01 mov $0x1,%al <== NOT EXECUTED
11a0f2: 31 d2 xor %edx,%edx <== NOT EXECUTED
11a0f4: e9 e2 fe ff ff jmp 119fdb <rtems_rfs_link+0xeb> <== NOT EXECUTED
11a0f9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
11a100: e8 3b fb fe ff call 109c40 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
11a105: 8b 55 94 mov -0x6c(%ebp),%edx <== NOT EXECUTED
11a108: e9 20 ff ff ff jmp 11a02d <rtems_rfs_link+0x13d> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
11a10d: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED
11a111: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
11a114: e8 27 fb fe ff call 109c40 <rtems_rfs_inode_close> <== NOT EXECUTED
return ENOTSUP;
11a119: ba 86 00 00 00 mov $0x86,%edx <== NOT EXECUTED
11a11e: e9 0a ff ff ff jmp 11a02d <rtems_rfs_link+0x13d> <== NOT EXECUTED
11a123: 90 nop
11a124: 90 nop
11a125: 90 nop
11a126: 90 nop
11a127: 90 nop
11a128: 90 nop
11a129: 90 nop
11a12a: 90 nop
11a12b: 90 nop
11a12c: 90 nop
11a12d: 90 nop
11a12e: 90 nop
11a12f: 90 nop
0010b2b0 <rtems_rfs_rtems_fdatasync>:
{
10b2b0: 55 push %ebp <== NOT EXECUTED
10b2b1: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10b2b3: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED
10b2b6: 89 5d fc mov %ebx,-0x4(%ebp) <== NOT EXECUTED
rc = rtems_rfs_buffer_sync (rtems_rfs_rtems_pathloc_dev (&iop->pathinfo));
10b2b9: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
10b2bc: 8b 40 20 mov 0x20(%eax),%eax <== NOT EXECUTED
10b2bf: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED
10b2c2: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
10b2c5: e8 26 c8 ff ff call 107af0 <rtems_rfs_buffer_sync> <== NOT EXECUTED
if (rc)
10b2ca: 85 c0 test %eax,%eax <== NOT EXECUTED
rc = rtems_rfs_buffer_sync (rtems_rfs_rtems_pathloc_dev (&iop->pathinfo));
10b2cc: 89 c3 mov %eax,%ebx <== NOT EXECUTED
if (rc)
10b2ce: 75 09 jne 10b2d9 <rtems_rfs_rtems_fdatasync+0x29> <== NOT EXECUTED
}
10b2d0: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10b2d2: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10b2d5: 89 ec mov %ebp,%esp <== NOT EXECUTED
10b2d7: 5d pop %ebp <== NOT EXECUTED
10b2d8: c3 ret <== NOT EXECUTED
return rtems_rfs_rtems_error ("fdatasync: sync", rc);
10b2d9: e8 22 f2 01 00 call 12a500 <__errno> <== NOT EXECUTED
10b2de: 89 18 mov %ebx,(%eax) <== NOT EXECUTED
10b2e0: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED
10b2e5: eb e9 jmp 10b2d0 <rtems_rfs_rtems_fdatasync+0x20> <== NOT EXECUTED
10b2e7: 90 nop
10b2e8: 90 nop
10b2e9: 90 nop
10b2ea: 90 nop
10b2eb: 90 nop
10b2ec: 90 nop
10b2ed: 90 nop
10b2ee: 90 nop
10b2ef: 90 nop
0010ad80 <rtems_rfs_rtems_fstat>:
{
10ad80: 55 push %ebp
10ad81: 89 e5 mov %esp,%ebp
10ad83: 57 push %edi
10ad84: 56 push %esi
10ad85: 53 push %ebx
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
10ad86: 8d 75 c0 lea -0x40(%ebp),%esi
{
10ad89: 83 ec 5c sub $0x5c,%esp
10ad8c: 8b 45 08 mov 0x8(%ebp),%eax
10ad8f: 8b 5d 0c mov 0xc(%ebp),%ebx
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
10ad92: 8b 50 14 mov 0x14(%eax),%edx
10ad95: 8b 7a 08 mov 0x8(%edx),%edi
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
10ad98: ba 01 00 00 00 mov $0x1,%edx
10ad9d: 89 54 24 0c mov %edx,0xc(%esp)
10ada1: 89 74 24 08 mov %esi,0x8(%esp)
10ada5: 8b 40 08 mov 0x8(%eax),%eax
10ada8: 89 3c 24 mov %edi,(%esp)
10adab: 89 44 24 04 mov %eax,0x4(%esp)
10adaf: e8 7c ec ff ff call 109a30 <rtems_rfs_inode_open>
10adb4: 89 45 b4 mov %eax,-0x4c(%ebp)
if (rc)
10adb7: 85 c0 test %eax,%eax
10adb9: 0f 85 fb 01 00 00 jne 10afba <rtems_rfs_rtems_fstat+0x23a> <== NEVER TAKEN
return rtems_rfs_read_u16 (&handle->node->mode);
10adbf: 8b 4d cc mov -0x34(%ebp),%ecx
10adc2: 0f b7 51 02 movzwl 0x2(%ecx),%edx
10adc6: 89 d0 mov %edx,%eax
10adc8: 0f b6 d6 movzbl %dh,%edx
10adcb: c1 e0 08 shl $0x8,%eax
10adce: 09 d0 or %edx,%eax
10add0: 0f b7 d0 movzwl %ax,%edx
if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK (mode))
10add3: 25 00 b0 00 00 and $0xb000,%eax
10add8: 3d 00 20 00 00 cmp $0x2000,%eax
10addd: 0f 84 fd 00 00 00 je 10aee0 <rtems_rfs_rtems_fstat+0x160> <== NEVER TAKEN
buf->st_dev = (dev_t) (uintptr_t)rtems_rfs_fs_device (fs);
10ade3: 8b 47 10 mov 0x10(%edi),%eax
10ade6: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx)
buf->st_ino = rtems_rfs_inode_ino (&inode);
10aded: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
buf->st_dev = (dev_t) (uintptr_t)rtems_rfs_fs_device (fs);
10adf4: 89 03 mov %eax,(%ebx)
buf->st_ino = rtems_rfs_inode_ino (&inode);
10adf6: 8b 45 c8 mov -0x38(%ebp),%eax
10adf9: 89 43 08 mov %eax,0x8(%ebx)
buf->st_mode = rtems_rfs_rtems_mode (mode);
10adfc: 89 14 24 mov %edx,(%esp)
10adff: e8 3c 0a 00 00 call 10b840 <rtems_rfs_rtems_mode>
links = rtems_rfs_read_u16 (&handle->node->links);
10ae04: 8b 55 cc mov -0x34(%ebp),%edx
10ae07: 89 43 10 mov %eax,0x10(%ebx)
10ae0a: 0f b7 0a movzwl (%edx),%ecx
10ae0d: 89 c8 mov %ecx,%eax
10ae0f: 0f b6 cd movzbl %ch,%ecx
10ae12: c1 e0 08 shl $0x8,%eax
10ae15: 09 c1 or %eax,%ecx
10ae17: 0f b7 c9 movzwl %cx,%ecx
if (links == 0xffff)
10ae1a: 81 f9 ff ff 00 00 cmp $0xffff,%ecx
10ae20: 75 02 jne 10ae24 <rtems_rfs_rtems_fstat+0xa4> <== ALWAYS TAKEN
links = 0;
10ae22: 31 c9 xor %ecx,%ecx <== NOT EXECUTED
buf->st_nlink = rtems_rfs_inode_get_links (&inode);
10ae24: 66 89 4b 14 mov %cx,0x14(%ebx)
buf->st_uid = rtems_rfs_inode_get_uid (&inode);
10ae28: 0f b7 42 06 movzwl 0x6(%edx),%eax
10ae2c: 89 c1 mov %eax,%ecx
10ae2e: 0f b6 c4 movzbl %ah,%eax
10ae31: c1 e1 08 shl $0x8,%ecx
10ae34: 09 c8 or %ecx,%eax
10ae36: 66 89 43 16 mov %ax,0x16(%ebx)
return (rtems_rfs_read_u32 (&handle->node->owner) >> 16) & 0xffff;
10ae3a: 8b 42 04 mov 0x4(%edx),%eax
10ae3d: 0f c8 bswap %eax
10ae3f: c1 e8 10 shr $0x10,%eax
10ae42: 66 89 43 18 mov %ax,0x18(%ebx)
shared = rtems_rfs_file_get_shared (fs, rtems_rfs_inode_ino (&inode));
10ae46: 8b 45 c8 mov -0x38(%ebp),%eax
10ae49: 89 3c 24 mov %edi,(%esp)
10ae4c: 89 44 24 04 mov %eax,0x4(%esp)
10ae50: e8 eb e7 00 00 call 119640 <rtems_rfs_file_get_shared>
if (shared)
10ae55: 85 c0 test %eax,%eax
10ae57: 0f 84 c3 00 00 00 je 10af20 <rtems_rfs_rtems_fstat+0x1a0>
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
10ae5d: 8b 88 8c 00 00 00 mov 0x8c(%eax),%ecx
10ae63: c7 43 30 00 00 00 00 movl $0x0,0x30(%ebx)
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
10ae6a: 8b 90 84 00 00 00 mov 0x84(%eax),%edx
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
10ae70: 89 4b 2c mov %ecx,0x2c(%ebx)
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
10ae73: 8b 88 90 00 00 00 mov 0x90(%eax),%ecx
10ae79: c7 43 3c 00 00 00 00 movl $0x0,0x3c(%ebx)
10ae80: 89 4b 38 mov %ecx,0x38(%ebx)
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
10ae83: 8b 88 94 00 00 00 mov 0x94(%eax),%ecx
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
10ae89: 89 53 54 mov %edx,0x54(%ebx)
if (S_ISLNK (buf->st_mode))
10ae8c: 8b 53 10 mov 0x10(%ebx),%edx
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
10ae8f: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx)
10ae96: 89 4b 44 mov %ecx,0x44(%ebx)
if (S_ISLNK (buf->st_mode))
10ae99: 81 e2 00 f0 00 00 and $0xf000,%edx
10ae9f: 81 fa 00 a0 00 00 cmp $0xa000,%edx
10aea5: 75 59 jne 10af00 <rtems_rfs_rtems_fstat+0x180> <== ALWAYS TAKEN
buf->st_size = rtems_rfs_file_shared_get_block_offset (shared);
10aea7: 0f b7 80 88 00 00 00 movzwl 0x88(%eax),%eax <== NOT EXECUTED
10aeae: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx) <== NOT EXECUTED
10aeb5: 89 43 24 mov %eax,0x24(%ebx) <== NOT EXECUTED
buf->st_blksize = rtems_rfs_fs_block_size (fs);
10aeb8: 8b 47 08 mov 0x8(%edi),%eax
10aebb: 89 43 50 mov %eax,0x50(%ebx)
rc = rtems_rfs_inode_close (fs, &inode);
10aebe: 89 74 24 04 mov %esi,0x4(%esp)
10aec2: 89 3c 24 mov %edi,(%esp)
10aec5: e8 76 ed ff ff call 109c40 <rtems_rfs_inode_close>
if (rc > 0)
10aeca: 85 c0 test %eax,%eax
rc = rtems_rfs_inode_close (fs, &inode);
10aecc: 89 c3 mov %eax,%ebx
if (rc > 0)
10aece: 0f 8f d3 00 00 00 jg 10afa7 <rtems_rfs_rtems_fstat+0x227> <== NEVER TAKEN
}
10aed4: 8b 45 b4 mov -0x4c(%ebp),%eax
10aed7: 83 c4 5c add $0x5c,%esp
10aeda: 5b pop %ebx
10aedb: 5e pop %esi
10aedc: 5f pop %edi
10aedd: 5d pop %ebp
10aede: c3 ret
10aedf: 90 nop
return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);
10aee0: 8b 41 20 mov 0x20(%ecx),%eax <== NOT EXECUTED
10aee3: 8b 49 1c mov 0x1c(%ecx),%ecx <== NOT EXECUTED
10aee6: 0f c8 bswap %eax <== NOT EXECUTED
buf->st_rdev =
10aee8: 89 43 20 mov %eax,0x20(%ebx) <== NOT EXECUTED
10aeeb: 0f c9 bswap %ecx <== NOT EXECUTED
10aeed: 89 4b 1c mov %ecx,0x1c(%ebx) <== NOT EXECUTED
10aef0: e9 ee fe ff ff jmp 10ade3 <rtems_rfs_rtems_fstat+0x63> <== NOT EXECUTED
10aef5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10aefc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== 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);
10af00: 89 3c 24 mov %edi,(%esp)
10af03: 05 84 00 00 00 add $0x84,%eax
10af08: 89 44 24 04 mov %eax,0x4(%esp)
10af0c: e8 bf a9 00 00 call 1158d0 <rtems_rfs_block_get_size>
buf->st_size = rtems_rfs_file_shared_get_size (fs, shared);
10af11: 89 43 24 mov %eax,0x24(%ebx)
10af14: 89 53 28 mov %edx,0x28(%ebx)
10af17: eb 9f jmp 10aeb8 <rtems_rfs_rtems_fstat+0x138>
10af19: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
buf->st_atime = rtems_rfs_inode_get_atime (&inode);
10af20: 8b 45 cc mov -0x34(%ebp),%eax
return rtems_rfs_read_u32 (&handle->node->atime);
10af23: 8b 50 10 mov 0x10(%eax),%edx
10af26: c7 43 30 00 00 00 00 movl $0x0,0x30(%ebx)
10af2d: 0f ca bswap %edx
10af2f: 89 53 2c mov %edx,0x2c(%ebx)
10af32: 8b 50 14 mov 0x14(%eax),%edx
buf->st_mtime = rtems_rfs_inode_get_mtime (&inode);
10af35: c7 43 3c 00 00 00 00 movl $0x0,0x3c(%ebx)
10af3c: 0f ca bswap %edx
10af3e: 89 53 38 mov %edx,0x38(%ebx)
10af41: 8b 50 18 mov 0x18(%eax),%edx
buf->st_ctime = rtems_rfs_inode_get_ctime (&inode);
10af44: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx)
10af4b: 0f ca bswap %edx
10af4d: 89 53 44 mov %edx,0x44(%ebx)
10af50: 8b 50 0c mov 0xc(%eax),%edx
10af53: 0f ca bswap %edx
buf->st_blocks = rtems_rfs_inode_get_block_count (&inode);
10af55: 89 53 54 mov %edx,0x54(%ebx)
if (S_ISLNK (buf->st_mode))
10af58: 8b 53 10 mov 0x10(%ebx),%edx
10af5b: 81 e2 00 f0 00 00 and $0xf000,%edx
10af61: 81 fa 00 a0 00 00 cmp $0xa000,%edx
10af67: 75 27 jne 10af90 <rtems_rfs_rtems_fstat+0x210>
buf->st_size = rtems_rfs_inode_get_block_offset (&inode);
10af69: 0f b7 50 0a movzwl 0xa(%eax),%edx
10af6d: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx)
10af74: 89 d0 mov %edx,%eax
10af76: 0f b6 d6 movzbl %dh,%edx
10af79: c1 e0 08 shl $0x8,%eax
10af7c: 09 d0 or %edx,%eax
10af7e: 0f b7 c0 movzwl %ax,%eax
10af81: 89 43 24 mov %eax,0x24(%ebx)
10af84: e9 2f ff ff ff jmp 10aeb8 <rtems_rfs_rtems_fstat+0x138>
10af89: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
buf->st_size = rtems_rfs_inode_get_size (fs, &inode);
10af90: 89 74 24 04 mov %esi,0x4(%esp)
10af94: 89 3c 24 mov %edi,(%esp)
10af97: e8 d4 f5 ff ff call 10a570 <rtems_rfs_inode_get_size>
10af9c: 89 43 24 mov %eax,0x24(%ebx)
10af9f: 89 53 28 mov %edx,0x28(%ebx)
10afa2: e9 11 ff ff ff jmp 10aeb8 <rtems_rfs_rtems_fstat+0x138>
return rtems_rfs_rtems_error ("stat: closing inode", rc);
10afa7: e8 54 f5 01 00 call 12a500 <__errno> <== NOT EXECUTED
10afac: c7 45 b4 ff ff ff ff movl $0xffffffff,-0x4c(%ebp) <== NOT EXECUTED
10afb3: 89 18 mov %ebx,(%eax) <== NOT EXECUTED
10afb5: e9 1a ff ff ff jmp 10aed4 <rtems_rfs_rtems_fstat+0x154> <== NOT EXECUTED
return rtems_rfs_rtems_error ("stat: opening inode", rc);
10afba: e8 41 f5 01 00 call 12a500 <__errno> <== NOT EXECUTED
10afbf: 8b 75 b4 mov -0x4c(%ebp),%esi <== NOT EXECUTED
10afc2: c7 45 b4 ff ff ff ff movl $0xffffffff,-0x4c(%ebp) <== NOT EXECUTED
10afc9: 89 30 mov %esi,(%eax) <== NOT EXECUTED
10afcb: e9 04 ff ff ff jmp 10aed4 <rtems_rfs_rtems_fstat+0x154> <== NOT EXECUTED
0010b2f0 <rtems_rfs_rtems_initialise>:
{
10b2f0: 55 push %ebp
10b2f1: 89 e5 mov %esp,%ebp
10b2f3: 57 push %edi
10b2f4: 56 push %esi
10b2f5: 53 push %ebx
10b2f6: 83 ec 4c sub $0x4c,%esp
uint32_t max_held_buffers = RTEMS_RFS_FS_MAX_HELD_BUFFERS;
10b2f9: c7 45 d0 05 00 00 00 movl $0x5,-0x30(%ebp)
{
10b300: 8b 5d 0c mov 0xc(%ebp),%ebx
uint32_t flags = 0;
10b303: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
while (options)
10b30a: 85 db test %ebx,%ebx
10b30c: 74 4f je 10b35d <rtems_rfs_rtems_initialise+0x6d> <== ALWAYS TAKEN
10b30e: 66 90 xchg %ax,%ax
printf ("options=%s\n", options);
10b310: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
if (strncmp (options, "hold-bitmaps",
10b314: 89 de mov %ebx,%esi <== NOT EXECUTED
10b316: bf ad 47 13 00 mov $0x1347ad,%edi <== NOT EXECUTED
printf ("options=%s\n", options);
10b31b: c7 04 24 a1 47 13 00 movl $0x1347a1,(%esp) <== NOT EXECUTED
10b322: e8 19 6e ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
if (strncmp (options, "hold-bitmaps",
10b327: b9 0c 00 00 00 mov $0xc,%ecx <== NOT EXECUTED
10b32c: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) <== NOT EXECUTED
10b32e: 0f 97 c0 seta %al <== NOT EXECUTED
10b331: 1c 00 sbb $0x0,%al <== NOT EXECUTED
10b333: 84 c0 test %al,%al <== NOT EXECUTED
10b335: 0f 85 d5 00 00 00 jne 10b410 <rtems_rfs_rtems_initialise+0x120> <== NOT EXECUTED
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
10b33b: 83 4d d4 01 orl $0x1,-0x2c(%ebp) <== NOT EXECUTED
options = strchr (options, ',');
10b33f: ba 2c 00 00 00 mov $0x2c,%edx <== NOT EXECUTED
10b344: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
10b348: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
10b34b: e8 00 fb 01 00 call 12ae50 <strchr> <== NOT EXECUTED
if (options)
10b350: 85 c0 test %eax,%eax <== NOT EXECUTED
10b352: 74 09 je 10b35d <rtems_rfs_rtems_initialise+0x6d> <== NOT EXECUTED
if (*options == '\0')
10b354: 80 78 01 00 cmpb $0x0,0x1(%eax) <== NOT EXECUTED
++options;
10b358: 8d 58 01 lea 0x1(%eax),%ebx <== NOT EXECUTED
if (*options == '\0')
10b35b: 75 b3 jne 10b310 <rtems_rfs_rtems_initialise+0x20> <== NOT EXECUTED
rtems = malloc (sizeof (rtems_rfs_rtems_private));
10b35d: c7 04 24 18 00 00 00 movl $0x18,(%esp)
10b364: b8 01 00 00 00 mov $0x1,%eax
10b369: 89 44 24 04 mov %eax,0x4(%esp)
10b36d: e8 6e 8b 00 00 call 113ee0 <calloc>
if (!rtems)
10b372: 85 c0 test %eax,%eax
rtems = malloc (sizeof (rtems_rfs_rtems_private));
10b374: 89 c3 mov %eax,%ebx
if (!rtems)
10b376: 0f 84 64 01 00 00 je 10b4e0 <rtems_rfs_rtems_initialise+0x1f0> <== NEVER TAKEN
rc = rtems_rfs_mutex_create (&rtems->access);
10b37c: 89 04 24 mov %eax,(%esp)
10b37f: e8 9c fa 00 00 call 11ae20 <rtems_rfs_mutex_create>
free (rtems);
10b384: 89 1c 24 mov %ebx,(%esp)
if (rc > 0)
10b387: 85 c0 test %eax,%eax
rc = rtems_rfs_mutex_create (&rtems->access);
10b389: 89 c6 mov %eax,%esi
if (rc > 0)
10b38b: 0f 8f 39 01 00 00 jg 10b4ca <rtems_rfs_rtems_initialise+0x1da> <== NEVER TAKEN
_Mutex_recursive_Acquire( mutex );
10b391: e8 ea 24 00 00 call 10d880 <_Mutex_recursive_Acquire>
rc = rtems_rfs_fs_open (mt_entry->dev, rtems, flags, max_held_buffers, &fs);
10b396: 8d 45 e4 lea -0x1c(%ebp),%eax
10b399: 89 44 24 10 mov %eax,0x10(%esp)
10b39d: 8b 45 d0 mov -0x30(%ebp),%eax
10b3a0: 89 5c 24 04 mov %ebx,0x4(%esp)
10b3a4: 89 44 24 0c mov %eax,0xc(%esp)
10b3a8: 8b 45 d4 mov -0x2c(%ebp),%eax
10b3ab: 89 44 24 08 mov %eax,0x8(%esp)
10b3af: 8b 45 08 mov 0x8(%ebp),%eax
10b3b2: 8b 40 38 mov 0x38(%eax),%eax
10b3b5: 89 04 24 mov %eax,(%esp)
10b3b8: e8 f3 e2 00 00 call 1196b0 <rtems_rfs_fs_open>
if (rc)
10b3bd: 85 c0 test %eax,%eax
rc = rtems_rfs_fs_open (mt_entry->dev, rtems, flags, max_held_buffers, &fs);
10b3bf: 89 c6 mov %eax,%esi
if (rc)
10b3c1: 0f 85 a9 00 00 00 jne 10b470 <rtems_rfs_rtems_initialise+0x180> <== NEVER TAKEN
mt_entry->fs_info = fs;
10b3c7: 8b 45 e4 mov -0x1c(%ebp),%eax
10b3ca: 8b 55 08 mov 0x8(%ebp),%edx
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
10b3cd: 8b 98 80 00 00 00 mov 0x80(%eax),%ebx
10b3d3: 89 42 08 mov %eax,0x8(%edx)
mt_entry->ops = &rtems_rfs_ops;
10b3d6: c7 42 0c e0 47 13 00 movl $0x1347e0,0xc(%edx)
mt_entry->mt_fs_root->location.node_access = (void*) RTEMS_RFS_ROOT_INO;
10b3dd: 8b 52 24 mov 0x24(%edx),%edx
10b3e0: c7 42 08 01 00 00 00 movl $0x1,0x8(%edx)
mt_entry->mt_fs_root->location.handlers = &rtems_rfs_rtems_dir_handlers;
10b3e7: c7 42 10 a0 48 13 00 movl $0x1348a0,0x10(%edx)
rtems_rfs_buffers_release (fs);
10b3ee: 89 04 24 mov %eax,(%esp)
10b3f1: e8 9a c7 ff ff call 107b90 <rtems_rfs_buffers_release>
_Mutex_recursive_Release( mutex );
10b3f6: 89 1c 24 mov %ebx,(%esp)
10b3f9: e8 02 25 00 00 call 10d900 <_Mutex_recursive_Release>
}
10b3fe: 83 c4 4c add $0x4c,%esp
10b401: 89 f0 mov %esi,%eax
10b403: 5b pop %ebx
10b404: 5e pop %esi
10b405: 5f pop %edi
10b406: 5d pop %ebp
10b407: c3 ret
10b408: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10b40f: 90 nop
else if (strncmp (options, "no-local-cache",
10b410: bf ba 47 13 00 mov $0x1347ba,%edi <== NOT EXECUTED
10b415: b9 0e 00 00 00 mov $0xe,%ecx <== NOT EXECUTED
10b41a: 89 de mov %ebx,%esi <== NOT EXECUTED
10b41c: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) <== NOT EXECUTED
10b41e: 0f 97 c0 seta %al <== NOT EXECUTED
10b421: 1c 00 sbb $0x0,%al <== NOT EXECUTED
10b423: 84 c0 test %al,%al <== NOT EXECUTED
10b425: 75 09 jne 10b430 <rtems_rfs_rtems_initialise+0x140> <== NOT EXECUTED
flags |= RTEMS_RFS_FS_NO_LOCAL_CACHE;
10b427: 83 4d d4 02 orl $0x2,-0x2c(%ebp) <== NOT EXECUTED
10b42b: e9 0f ff ff ff jmp 10b33f <rtems_rfs_rtems_initialise+0x4f> <== NOT EXECUTED
else if (strncmp (options, "max-held-bufs",
10b430: bf c9 47 13 00 mov $0x1347c9,%edi <== NOT EXECUTED
10b435: b9 0d 00 00 00 mov $0xd,%ecx <== NOT EXECUTED
10b43a: 89 de mov %ebx,%esi <== NOT EXECUTED
10b43c: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) <== NOT EXECUTED
10b43e: 0f 97 c0 seta %al <== NOT EXECUTED
10b441: 1c 00 sbb $0x0,%al <== NOT EXECUTED
10b443: 84 c0 test %al,%al <== NOT EXECUTED
10b445: 75 69 jne 10b4b0 <rtems_rfs_rtems_initialise+0x1c0> <== NOT EXECUTED
max_held_buffers = strtoul (options + sizeof ("max-held-bufs"), 0, 0);
10b447: 31 c9 xor %ecx,%ecx <== NOT EXECUTED
10b449: 31 f6 xor %esi,%esi <== NOT EXECUTED
10b44b: 89 4c 24 08 mov %ecx,0x8(%esp) <== NOT EXECUTED
10b44f: 8d 43 0e lea 0xe(%ebx),%eax <== NOT EXECUTED
10b452: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED
10b456: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
10b459: e8 82 0d 02 00 call 12c1e0 <strtoul> <== NOT EXECUTED
10b45e: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED
10b461: e9 d9 fe ff ff jmp 10b33f <rtems_rfs_rtems_initialise+0x4f> <== NOT EXECUTED
10b466: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10b46d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
10b470: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
10b473: e8 88 24 00 00 call 10d900 <_Mutex_recursive_Release> <== NOT EXECUTED
rtems_rfs_mutex_destroy (&rtems->access);
10b478: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
10b47b: e8 e0 f9 00 00 call 11ae60 <rtems_rfs_mutex_destroy> <== NOT EXECUTED
free (rtems);
10b480: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
10b483: e8 58 70 ff ff call 1024e0 <free> <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: open", errno);
10b488: e8 73 f0 01 00 call 12a500 <__errno> <== NOT EXECUTED
10b48d: 89 c3 mov %eax,%ebx <== NOT EXECUTED
10b48f: e8 6c f0 01 00 call 12a500 <__errno> <== NOT EXECUTED
10b494: 89 c2 mov %eax,%edx <== NOT EXECUTED
10b496: 8b 03 mov (%ebx),%eax <== NOT EXECUTED
10b498: 89 02 mov %eax,(%edx) <== NOT EXECUTED
10b49a: 85 c0 test %eax,%eax <== NOT EXECUTED
10b49c: 0f 95 c0 setne %al <== NOT EXECUTED
}
10b49f: 83 c4 4c add $0x4c,%esp <== NOT EXECUTED
10b4a2: 5b pop %ebx <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: open", errno);
10b4a3: 0f b6 f0 movzbl %al,%esi <== NOT EXECUTED
10b4a6: f7 de neg %esi <== NOT EXECUTED
}
10b4a8: 89 f0 mov %esi,%eax <== NOT EXECUTED
10b4aa: 5e pop %esi <== NOT EXECUTED
10b4ab: 5f pop %edi <== NOT EXECUTED
10b4ac: 5d pop %ebp <== NOT EXECUTED
10b4ad: c3 ret <== NOT EXECUTED
10b4ae: 66 90 xchg %ax,%ax <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: invalid option", EINVAL);
10b4b0: e8 4b f0 01 00 call 12a500 <__errno> <== NOT EXECUTED
10b4b5: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED
10b4ba: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
}
10b4c0: 83 c4 4c add $0x4c,%esp <== NOT EXECUTED
10b4c3: 89 f0 mov %esi,%eax <== NOT EXECUTED
10b4c5: 5b pop %ebx <== NOT EXECUTED
10b4c6: 5e pop %esi <== NOT EXECUTED
10b4c7: 5f pop %edi <== NOT EXECUTED
10b4c8: 5d pop %ebp <== NOT EXECUTED
10b4c9: c3 ret <== NOT EXECUTED
free (rtems);
10b4ca: e8 11 70 ff ff call 1024e0 <free> <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: cannot create mutex", rc);
10b4cf: e8 2c f0 01 00 call 12a500 <__errno> <== NOT EXECUTED
10b4d4: 89 30 mov %esi,(%eax) <== NOT EXECUTED
10b4d6: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED
10b4db: e9 1e ff ff ff jmp 10b3fe <rtems_rfs_rtems_initialise+0x10e> <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: local data", ENOMEM);
10b4e0: e8 1b f0 01 00 call 12a500 <__errno> <== NOT EXECUTED
10b4e5: 83 ce ff or $0xffffffff,%esi <== NOT EXECUTED
10b4e8: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED
10b4ee: e9 0b ff ff ff jmp 10b3fe <rtems_rfs_rtems_initialise+0x10e> <== NOT EXECUTED
10b4f3: 90 nop
10b4f4: 90 nop
10b4f5: 90 nop
10b4f6: 90 nop
10b4f7: 90 nop
10b4f8: 90 nop
10b4f9: 90 nop
10b4fa: 90 nop
10b4fb: 90 nop
10b4fc: 90 nop
10b4fd: 90 nop
10b4fe: 90 nop
10b4ff: 90 nop
0010b770 <rtems_rfs_rtems_set_handlers>:
*/
bool
rtems_rfs_rtems_set_handlers (rtems_filesystem_location_info_t* loc,
rtems_rfs_inode_handle* inode)
{
10b770: 55 push %ebp
10b771: 89 e5 mov %esp,%ebp
10b773: 83 ec 18 sub $0x18,%esp
10b776: 89 5d fc mov %ebx,-0x4(%ebp)
10b779: 8b 45 0c mov 0xc(%ebp),%eax
10b77c: 8b 4d 08 mov 0x8(%ebp),%ecx
10b77f: 8b 40 0c mov 0xc(%eax),%eax
10b782: 0f b7 50 02 movzwl 0x2(%eax),%edx
uint16_t mode = rtems_rfs_inode_get_mode (inode);
loc->handlers = NULL;
10b786: c7 41 10 00 00 00 00 movl $0x0,0x10(%ecx)
10b78d: 89 d0 mov %edx,%eax
10b78f: 0f b6 d6 movzbl %dh,%edx
10b792: c1 e0 08 shl $0x8,%eax
10b795: 09 d0 or %edx,%eax
10b797: 0f b7 d0 movzwl %ax,%edx
if (RTEMS_RFS_S_ISDIR (mode))
10b79a: 25 00 f0 00 00 and $0xf000,%eax
10b79f: 3d 00 40 00 00 cmp $0x4000,%eax
10b7a4: 74 4a je 10b7f0 <rtems_rfs_rtems_set_handlers+0x80>
loc->handlers = rtems_rfs_rtems_handlers (dir);
else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))
10b7a6: 89 d3 mov %edx,%ebx
10b7a8: 81 e3 00 b0 00 00 and $0xb000,%ebx
10b7ae: 81 fb 00 20 00 00 cmp $0x2000,%ebx
10b7b4: 75 1a jne 10b7d0 <rtems_rfs_rtems_set_handlers+0x60> <== ALWAYS TAKEN
loc->handlers = rtems_rfs_rtems_handlers (device);
10b7b6: c7 41 10 c0 63 13 00 movl $0x1363c0,0x10(%ecx) <== NOT EXECUTED
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
return false;
}
return true;
10b7bd: b0 01 mov $0x1,%al <== NOT EXECUTED
}
10b7bf: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10b7c2: 89 ec mov %ebp,%esp <== NOT EXECUTED
10b7c4: 5d pop %ebp <== NOT EXECUTED
10b7c5: c3 ret <== NOT EXECUTED
10b7c6: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10b7cd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
else if (RTEMS_RFS_S_ISLNK (mode))
10b7d0: 3d 00 a0 00 00 cmp $0xa000,%eax
10b7d5: 74 49 je 10b820 <rtems_rfs_rtems_set_handlers+0xb0>
else if (RTEMS_RFS_S_ISREG (mode))
10b7d7: 3d 00 80 00 00 cmp $0x8000,%eax
10b7dc: 75 22 jne 10b800 <rtems_rfs_rtems_set_handlers+0x90> <== NEVER TAKEN
loc->handlers = rtems_rfs_rtems_handlers (file);
10b7de: c7 41 10 00 64 13 00 movl $0x136400,0x10(%ecx)
}
10b7e5: 8b 5d fc mov -0x4(%ebp),%ebx
10b7e8: 89 ec mov %ebp,%esp
10b7ea: 5d pop %ebp
return true;
10b7eb: b0 01 mov $0x1,%al
}
10b7ed: c3 ret
10b7ee: 66 90 xchg %ax,%ax
loc->handlers = rtems_rfs_rtems_handlers (dir);
10b7f0: c7 41 10 a0 48 13 00 movl $0x1348a0,0x10(%ecx)
}
10b7f7: 8b 5d fc mov -0x4(%ebp),%ebx
10b7fa: 89 ec mov %ebp,%esp
10b7fc: 5d pop %ebp
return true;
10b7fd: b0 01 mov $0x1,%al
}
10b7ff: c3 ret
if (RTEMS_RFS_S_ISDIR (mode))
10b800: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
10b804: c7 04 24 e0 48 13 00 movl $0x1348e0,(%esp) <== NOT EXECUTED
10b80b: e8 30 69 ff ff call 102140 <__wrap_printf> <== NOT EXECUTED
return false;
10b810: 31 c0 xor %eax,%eax <== NOT EXECUTED
10b812: eb ab jmp 10b7bf <rtems_rfs_rtems_set_handlers+0x4f> <== NOT EXECUTED
10b814: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10b81b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10b81f: 90 nop <== NOT EXECUTED
loc->handlers = rtems_rfs_rtems_handlers (link);
10b820: c7 41 10 40 48 13 00 movl $0x134840,0x10(%ecx)
}
10b827: 8b 5d fc mov -0x4(%ebp),%ebx
10b82a: 89 ec mov %ebp,%esp
10b82c: 5d pop %ebp
return true;
10b82d: b0 01 mov $0x1,%al
}
10b82f: c3 ret
0011a620 <rtems_rfs_symlink>:
const char* link,
int link_length,
uid_t uid,
gid_t gid,
rtems_rfs_ino parent)
{
11a620: 55 push %ebp
11a621: 89 e5 mov %esp,%ebp
11a623: 57 push %edi
11a624: 56 push %esi
11a625: 53 push %ebx
11a626: 81 ec dc 00 00 00 sub $0xdc,%esp
rtems_rfs_inode_handle inode;
rtems_rfs_ino ino;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
11a62c: c7 04 24 00 00 00 00 movl $0x0,(%esp)
{
11a633: 0f b7 45 1c movzwl 0x1c(%ebp),%eax
11a637: 0f b7 7d 20 movzwl 0x20(%ebp),%edi
11a63b: 89 85 54 ff ff ff mov %eax,-0xac(%ebp)
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
11a641: b8 02 00 00 00 mov $0x2,%eax
11a646: 89 44 24 04 mov %eax,0x4(%esp)
11a64a: e8 01 12 ff ff call 10b850 <rtems_rfs_trace>
11a64f: 84 c0 test %al,%al
11a651: 0f 85 69 01 00 00 jne 11a7c0 <rtems_rfs_symlink+0x1a0> <== NEVER TAKEN
printf (" link:");
for (c = 0; c < link_length; c++)
printf ("%c", link[c]);
}
if (link_length >= rtems_rfs_fs_block_size (fs))
11a657: 8b 45 08 mov 0x8(%ebp),%eax
11a65a: 8b 4d 18 mov 0x18(%ebp),%ecx
11a65d: 39 48 08 cmp %ecx,0x8(%eax)
11a660: 0f 86 3a 01 00 00 jbe 11a7a0 <rtems_rfs_symlink+0x180> <== NEVER TAKEN
return ENAMETOOLONG;
rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),
11a666: 8b 45 0c mov 0xc(%ebp),%eax
11a669: 89 04 24 mov %eax,(%esp)
11a66c: e8 2f 0e 01 00 call 12b4a0 <strlen>
11a671: 8d 95 5c ff ff ff lea -0xa4(%ebp),%edx
11a677: b9 ff a1 00 00 mov $0xa1ff,%ecx
11a67c: 89 54 24 20 mov %edx,0x20(%esp)
11a680: 8b 95 54 ff ff ff mov -0xac(%ebp),%edx
11a686: 89 7c 24 1c mov %edi,0x1c(%esp)
11a68a: 89 4c 24 10 mov %ecx,0x10(%esp)
11a68e: 89 54 24 18 mov %edx,0x18(%esp)
11a692: ba 01 00 00 00 mov $0x1,%edx
11a697: 89 44 24 0c mov %eax,0xc(%esp)
11a69b: 8b 45 0c mov 0xc(%ebp),%eax
11a69e: 89 54 24 14 mov %edx,0x14(%esp)
11a6a2: 89 44 24 08 mov %eax,0x8(%esp)
11a6a6: 8b 45 24 mov 0x24(%ebp),%eax
11a6a9: 89 44 24 04 mov %eax,0x4(%esp)
11a6ad: 8b 45 08 mov 0x8(%ebp),%eax
11a6b0: 89 04 24 mov %eax,(%esp)
11a6b3: e8 68 fa fe ff call 10a120 <rtems_rfs_inode_create>
RTEMS_RFS_S_SYMLINK,
1, uid, gid, &ino);
if (rc > 0)
11a6b8: 85 c0 test %eax,%eax
rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),
11a6ba: 89 c6 mov %eax,%esi
if (rc > 0)
11a6bc: 7e 12 jle 11a6d0 <rtems_rfs_symlink+0xb0> <== ALWAYS TAKEN
rtems_rfs_inode_set_block_offset (&inode, link_length);
rc = rtems_rfs_inode_close (fs, &inode);
return rc;
}
11a6be: 81 c4 dc 00 00 00 add $0xdc,%esp
11a6c4: 89 f0 mov %esi,%eax
11a6c6: 5b pop %ebx
11a6c7: 5e pop %esi
11a6c8: 5f pop %edi
11a6c9: 5d pop %ebp
11a6ca: c3 ret
11a6cb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
11a6cf: 90 nop
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
11a6d0: 8d 9d 70 ff ff ff lea -0x90(%ebp),%ebx
11a6d6: b8 01 00 00 00 mov $0x1,%eax
11a6db: 89 44 24 0c mov %eax,0xc(%esp)
11a6df: 8b 85 5c ff ff ff mov -0xa4(%ebp),%eax
11a6e5: 89 5c 24 08 mov %ebx,0x8(%esp)
11a6e9: 89 44 24 04 mov %eax,0x4(%esp)
11a6ed: 8b 45 08 mov 0x8(%ebp),%eax
11a6f0: 89 04 24 mov %eax,(%esp)
11a6f3: e8 38 f3 fe ff call 109a30 <rtems_rfs_inode_open>
if (rc > 0)
11a6f8: 85 c0 test %eax,%eax
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
11a6fa: 89 c6 mov %eax,%esi
if (rc > 0)
11a6fc: 7f c0 jg 11a6be <rtems_rfs_symlink+0x9e> <== NEVER TAKEN
if (link_length < RTEMS_RFS_INODE_DATA_NAME_SIZE)
11a6fe: 83 7d 18 13 cmpl $0x13,0x18(%ebp)
11a702: 0f 87 38 01 00 00 ja 11a840 <rtems_rfs_symlink+0x220> <== NEVER TAKEN
memset (inode.node->data.name, 0, RTEMS_RFS_INODE_DATA_NAME_SIZE);
11a708: 8b 85 7c ff ff ff mov -0x84(%ebp),%eax
memcpy (inode.node->data.name, link, link_length);
11a70e: 8b 4d 18 mov 0x18(%ebp),%ecx
11a711: 8b 75 14 mov 0x14(%ebp),%esi
memset (inode.node->data.name, 0, RTEMS_RFS_INODE_DATA_NAME_SIZE);
11a714: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax)
11a71b: 8d 78 1c lea 0x1c(%eax),%edi
11a71e: c7 47 04 00 00 00 00 movl $0x0,0x4(%edi)
memcpy (inode.node->data.name, link, link_length);
11a725: 83 f9 08 cmp $0x8,%ecx
memset (inode.node->data.name, 0, RTEMS_RFS_INODE_DATA_NAME_SIZE);
11a728: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi)
11a72f: c7 47 0c 00 00 00 00 movl $0x0,0xc(%edi)
11a736: c7 47 10 00 00 00 00 movl $0x0,0x10(%edi)
memcpy (inode.node->data.name, link, link_length);
11a73d: 0f 83 41 02 00 00 jae 11a984 <rtems_rfs_symlink+0x364> <== NEVER TAKEN
11a743: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
rtems_rfs_write_u32 (&handle->node->block_count, block_count);
11a745: c6 40 0c 00 movb $0x0,0xc(%eax)
11a749: 8b 85 7c ff ff ff mov -0x84(%ebp),%eax
11a74f: c6 40 0d 00 movb $0x0,0xd(%eax)
11a753: 8b 85 7c ff ff ff mov -0x84(%ebp),%eax
11a759: c6 40 0e 00 movb $0x0,0xe(%eax)
11a75d: 8b 85 7c ff ff ff mov -0x84(%ebp),%eax
11a763: c6 40 0f 00 movb $0x0,0xf(%eax)
rtems_rfs_write_u16 (&handle->node->block_offset, block_offset);
11a767: 8b 85 7c ff ff ff mov -0x84(%ebp),%eax
11a76d: 8b 4d 18 mov 0x18(%ebp),%ecx
11a770: 88 68 0a mov %ch,0xa(%eax)
11a773: 0f b6 4d 18 movzbl 0x18(%ebp),%ecx
11a777: 8b 85 7c ff ff ff mov -0x84(%ebp),%eax
11a77d: 88 48 0b mov %cl,0xb(%eax)
rc = rtems_rfs_inode_close (fs, &inode);
11a780: 8b 45 08 mov 0x8(%ebp),%eax
11a783: 89 5c 24 04 mov %ebx,0x4(%esp)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
11a787: c6 45 80 01 movb $0x1,-0x80(%ebp)
11a78b: 89 04 24 mov %eax,(%esp)
11a78e: e8 ad f4 fe ff call 109c40 <rtems_rfs_inode_close>
11a793: 89 c6 mov %eax,%esi
return rc;
11a795: e9 24 ff ff ff jmp 11a6be <rtems_rfs_symlink+0x9e>
11a79a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
}
11a7a0: 81 c4 dc 00 00 00 add $0xdc,%esp <== NOT EXECUTED
return ENAMETOOLONG;
11a7a6: be 5b 00 00 00 mov $0x5b,%esi <== NOT EXECUTED
}
11a7ab: 5b pop %ebx <== NOT EXECUTED
11a7ac: 89 f0 mov %esi,%eax <== NOT EXECUTED
11a7ae: 5e pop %esi <== NOT EXECUTED
11a7af: 5f pop %edi <== NOT EXECUTED
11a7b0: 5d pop %ebp <== NOT EXECUTED
11a7b1: c3 ret <== NOT EXECUTED
11a7b2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11a7b9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
printf ("rtems-rfs: symlink: parent:%" PRIu32 " name:", parent);
11a7c0: c7 04 24 58 63 13 00 movl $0x136358,(%esp) <== NOT EXECUTED
11a7c7: 8b 45 24 mov 0x24(%ebp),%eax <== NOT EXECUTED
11a7ca: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
11a7ce: e8 6d 79 fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
for (c = 0; c < length; c++)
11a7d3: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED
11a7d6: 85 f6 test %esi,%esi <== NOT EXECUTED
11a7d8: 7e 26 jle 11a800 <rtems_rfs_symlink+0x1e0> <== NOT EXECUTED
11a7da: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED
11a7dd: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED
11a7e0: 01 f3 add %esi,%ebx <== NOT EXECUTED
11a7e2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11a7e9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
printf ("%c", name[c]);
11a7f0: 0f be 06 movsbl (%esi),%eax <== NOT EXECUTED
for (c = 0; c < length; c++)
11a7f3: 46 inc %esi <== NOT EXECUTED
printf ("%c", name[c]);
11a7f4: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
11a7f7: e8 94 02 01 00 call 12aa90 <putchar> <== NOT EXECUTED
for (c = 0; c < length; c++)
11a7fc: 39 de cmp %ebx,%esi <== NOT EXECUTED
11a7fe: 75 f0 jne 11a7f0 <rtems_rfs_symlink+0x1d0> <== NOT EXECUTED
printf (" link:");
11a800: c7 04 24 7c 63 13 00 movl $0x13637c,(%esp) <== NOT EXECUTED
11a807: e8 34 79 fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
for (c = 0; c < link_length; c++)
11a80c: 8b 5d 18 mov 0x18(%ebp),%ebx <== NOT EXECUTED
11a80f: 85 db test %ebx,%ebx <== NOT EXECUTED
11a811: 0f 8e 40 fe ff ff jle 11a657 <rtems_rfs_symlink+0x37> <== NOT EXECUTED
11a817: 8b 75 14 mov 0x14(%ebp),%esi <== NOT EXECUTED
11a81a: 8b 5d 18 mov 0x18(%ebp),%ebx <== NOT EXECUTED
11a81d: 01 f3 add %esi,%ebx <== NOT EXECUTED
11a81f: 90 nop <== NOT EXECUTED
printf ("%c", link[c]);
11a820: 0f be 06 movsbl (%esi),%eax <== NOT EXECUTED
for (c = 0; c < link_length; c++)
11a823: 46 inc %esi <== NOT EXECUTED
printf ("%c", link[c]);
11a824: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
11a827: e8 64 02 01 00 call 12aa90 <putchar> <== NOT EXECUTED
for (c = 0; c < link_length; c++)
11a82c: 39 f3 cmp %esi,%ebx <== NOT EXECUTED
11a82e: 75 f0 jne 11a820 <rtems_rfs_symlink+0x200> <== NOT EXECUTED
11a830: e9 22 fe ff ff jmp 11a657 <rtems_rfs_symlink+0x37> <== NOT EXECUTED
11a835: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11a83c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, &inode, &map);
11a840: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
11a844: 8d 45 98 lea -0x68(%ebp),%eax <== NOT EXECUTED
11a847: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
11a84b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
11a84e: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
11a851: e8 ca b0 ff ff call 115920 <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc > 0)
11a856: 85 c0 test %eax,%eax <== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, &inode, &map);
11a858: 89 c6 mov %eax,%esi <== NOT EXECUTED
if (rc > 0)
11a85a: 0f 8f 10 01 00 00 jg 11a970 <rtems_rfs_symlink+0x350> <== NOT EXECUTED
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
11a860: 8d 85 60 ff ff ff lea -0xa0(%ebp),%eax <== NOT EXECUTED
11a866: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
11a86a: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
11a86f: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
11a873: 8d 45 98 lea -0x68(%ebp),%eax <== NOT EXECUTED
11a876: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
11a87a: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
11a87d: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
11a880: e8 7b b5 ff ff call 115e00 <rtems_rfs_block_map_grow> <== NOT EXECUTED
if (rc > 0)
11a885: 85 c0 test %eax,%eax <== NOT EXECUTED
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
11a887: 89 c6 mov %eax,%esi <== NOT EXECUTED
if (rc > 0)
11a889: 0f 8f 2c 01 00 00 jg 11a9bb <rtems_rfs_symlink+0x39b> <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false);
11a88f: 8b 85 60 ff ff ff mov -0xa0(%ebp),%eax <== NOT EXECUTED
11a895: 31 ff xor %edi,%edi <== NOT EXECUTED
handle->bnum = 0;
11a897: 31 c9 xor %ecx,%ecx <== NOT EXECUTED
11a899: 89 7c 24 0c mov %edi,0xc(%esp) <== NOT EXECUTED
handle->buffer = NULL;
11a89d: 31 f6 xor %esi,%esi <== NOT EXECUTED
11a89f: 89 b5 6c ff ff ff mov %esi,-0x94(%ebp) <== NOT EXECUTED
handle->dirty = false;
11a8a5: c6 85 64 ff ff ff 00 movb $0x0,-0x9c(%ebp) <== NOT EXECUTED
11a8ac: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
11a8b0: 8d 85 64 ff ff ff lea -0x9c(%ebp),%eax <== NOT EXECUTED
11a8b6: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
11a8ba: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
handle->bnum = 0;
11a8bd: 89 8d 68 ff ff ff mov %ecx,-0x98(%ebp) <== NOT EXECUTED
11a8c3: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
11a8c6: e8 05 cd fe ff call 1075d0 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
11a8cb: 85 c0 test %eax,%eax <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false);
11a8cd: 89 c6 mov %eax,%esi <== NOT EXECUTED
if (rc > 0)
11a8cf: 0f 8f e6 00 00 00 jg 11a9bb <rtems_rfs_symlink+0x39b> <== NOT EXECUTED
data = rtems_rfs_buffer_data (&buffer);
11a8d5: 8b 85 6c ff ff ff mov -0x94(%ebp),%eax <== NOT EXECUTED
11a8db: 8b 70 1c mov 0x1c(%eax),%esi <== NOT EXECUTED
memset (data, 0xff, rtems_rfs_fs_block_size (fs));
11a8de: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
11a8e1: 89 f7 mov %esi,%edi <== NOT EXECUTED
11a8e3: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED
11a8e6: 83 fa 08 cmp $0x8,%edx <== NOT EXECUTED
11a8e9: 0f 83 31 01 00 00 jae 11aa20 <rtems_rfs_symlink+0x400> <== NOT EXECUTED
11a8ef: f6 c2 04 test $0x4,%dl <== NOT EXECUTED
11a8f2: 74 09 je 11a8fd <rtems_rfs_symlink+0x2dd> <== NOT EXECUTED
11a8f4: c7 07 ff ff ff ff movl $0xffffffff,(%edi) <== NOT EXECUTED
11a8fa: 83 c7 04 add $0x4,%edi <== NOT EXECUTED
11a8fd: f6 c2 02 test $0x2,%dl <== NOT EXECUTED
11a900: 74 08 je 11a90a <rtems_rfs_symlink+0x2ea> <== NOT EXECUTED
11a902: 66 c7 07 ff ff movw $0xffff,(%edi) <== NOT EXECUTED
11a907: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
11a90a: f6 c2 01 test $0x1,%dl <== NOT EXECUTED
11a90d: 74 03 je 11a912 <rtems_rfs_symlink+0x2f2> <== NOT EXECUTED
11a90f: c6 07 ff movb $0xff,(%edi) <== NOT EXECUTED
memcpy (data, link, link_length);
11a912: 8b 4d 18 mov 0x18(%ebp),%ecx <== NOT EXECUTED
11a915: 89 f7 mov %esi,%edi <== NOT EXECUTED
11a917: 8b 75 14 mov 0x14(%ebp),%esi <== NOT EXECUTED
11a91a: 83 f9 08 cmp $0x8,%ecx <== NOT EXECUTED
11a91d: 0f 83 be 00 00 00 jae 11a9e1 <rtems_rfs_symlink+0x3c1> <== NOT EXECUTED
11a923: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
11a925: 8d 85 64 ff ff ff lea -0x9c(%ebp),%eax <== NOT EXECUTED
11a92b: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
11a92f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
11a932: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
11a935: e8 76 cf fe ff call 1078b0 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->bnum = 0;
11a93a: 31 c0 xor %eax,%eax <== NOT EXECUTED
handle->buffer = NULL;
11a93c: 31 d2 xor %edx,%edx <== NOT EXECUTED
handle->bnum = 0;
11a93e: 89 85 68 ff ff ff mov %eax,-0x98(%ebp) <== NOT EXECUTED
rc = rtems_rfs_block_map_close (fs, &map);
11a944: 8d 45 98 lea -0x68(%ebp),%eax <== NOT EXECUTED
11a947: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
11a94b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
handle->dirty = false;
11a94e: c6 85 64 ff ff ff 00 movb $0x0,-0x9c(%ebp) <== NOT EXECUTED
handle->buffer = NULL;
11a955: 89 95 6c ff ff ff mov %edx,-0x94(%ebp) <== NOT EXECUTED
11a95b: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
11a95e: e8 ed b0 ff ff call 115a50 <rtems_rfs_block_map_close> <== NOT EXECUTED
if (rc > 0)
11a963: 85 c0 test %eax,%eax <== NOT EXECUTED
rc = rtems_rfs_block_map_close (fs, &map);
11a965: 89 c6 mov %eax,%esi <== NOT EXECUTED
if (rc > 0)
11a967: 0f 8e fa fd ff ff jle 11a767 <rtems_rfs_symlink+0x147> <== NOT EXECUTED
11a96d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
11a970: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
11a974: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
11a977: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
11a97a: e8 c1 f2 fe ff call 109c40 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
11a97f: e9 3a fd ff ff jmp 11a6be <rtems_rfs_symlink+0x9e> <== NOT EXECUTED
memcpy (inode.node->data.name, link, link_length);
11a984: f7 c7 01 00 00 00 test $0x1,%edi <== NOT EXECUTED
11a98a: 0f 85 d5 00 00 00 jne 11aa65 <rtems_rfs_symlink+0x445> <== NOT EXECUTED
11a990: f7 c7 02 00 00 00 test $0x2,%edi <== NOT EXECUTED
11a996: 0f 85 b4 00 00 00 jne 11aa50 <rtems_rfs_symlink+0x430> <== NOT EXECUTED
11a99c: f7 c7 04 00 00 00 test $0x4,%edi <== NOT EXECUTED
11a9a2: 0f 84 9b fd ff ff je 11a743 <rtems_rfs_symlink+0x123> <== NOT EXECUTED
11a9a8: 8b 16 mov (%esi),%edx <== NOT EXECUTED
11a9aa: 83 c7 04 add $0x4,%edi <== NOT EXECUTED
11a9ad: 83 c6 04 add $0x4,%esi <== NOT EXECUTED
11a9b0: 83 e9 04 sub $0x4,%ecx <== NOT EXECUTED
11a9b3: 89 57 fc mov %edx,-0x4(%edi) <== NOT EXECUTED
11a9b6: e9 88 fd ff ff jmp 11a743 <rtems_rfs_symlink+0x123> <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
11a9bb: 8d 45 98 lea -0x68(%ebp),%eax <== NOT EXECUTED
11a9be: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
11a9c2: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
11a9c5: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
11a9c8: e8 83 b0 ff ff call 115a50 <rtems_rfs_block_map_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
11a9cd: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
11a9d0: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
11a9d4: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
11a9d7: e8 64 f2 fe ff call 109c40 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
11a9dc: e9 dd fc ff ff jmp 11a6be <rtems_rfs_symlink+0x9e> <== NOT EXECUTED
memcpy (data, link, link_length);
11a9e1: f7 c7 01 00 00 00 test $0x1,%edi <== NOT EXECUTED
11a9e7: 0f 85 ae 00 00 00 jne 11aa9b <rtems_rfs_symlink+0x47b> <== NOT EXECUTED
11a9ed: f7 c7 02 00 00 00 test $0x2,%edi <== NOT EXECUTED
11a9f3: 0f 85 8d 00 00 00 jne 11aa86 <rtems_rfs_symlink+0x466> <== NOT EXECUTED
11a9f9: f7 c7 04 00 00 00 test $0x4,%edi <== NOT EXECUTED
11a9ff: 0f 84 1e ff ff ff je 11a923 <rtems_rfs_symlink+0x303> <== NOT EXECUTED
11aa05: 8b 06 mov (%esi),%eax <== NOT EXECUTED
11aa07: 83 c7 04 add $0x4,%edi <== NOT EXECUTED
11aa0a: 83 c6 04 add $0x4,%esi <== NOT EXECUTED
11aa0d: 83 e9 04 sub $0x4,%ecx <== NOT EXECUTED
11aa10: 89 47 fc mov %eax,-0x4(%edi) <== NOT EXECUTED
11aa13: e9 0b ff ff ff jmp 11a923 <rtems_rfs_symlink+0x303> <== NOT EXECUTED
11aa18: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11aa1f: 90 nop <== NOT EXECUTED
memset (data, 0xff, rtems_rfs_fs_block_size (fs));
11aa20: f7 c6 01 00 00 00 test $0x1,%esi <== NOT EXECUTED
11aa26: 0f 85 92 00 00 00 jne 11aabe <rtems_rfs_symlink+0x49e> <== NOT EXECUTED
11aa2c: f7 c7 02 00 00 00 test $0x2,%edi <== NOT EXECUTED
11aa32: 75 7a jne 11aaae <rtems_rfs_symlink+0x48e> <== NOT EXECUTED
11aa34: f7 c7 04 00 00 00 test $0x4,%edi <== NOT EXECUTED
11aa3a: 75 3c jne 11aa78 <rtems_rfs_symlink+0x458> <== NOT EXECUTED
11aa3c: 89 d1 mov %edx,%ecx <== NOT EXECUTED
11aa3e: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
11aa43: c1 e9 02 shr $0x2,%ecx <== NOT EXECUTED
11aa46: 83 e2 03 and $0x3,%edx <== NOT EXECUTED
11aa49: f3 ab rep stos %eax,%es:(%edi) <== NOT EXECUTED
11aa4b: e9 9f fe ff ff jmp 11a8ef <rtems_rfs_symlink+0x2cf> <== NOT EXECUTED
memcpy (inode.node->data.name, link, link_length);
11aa50: 0f b7 16 movzwl (%esi),%edx <== NOT EXECUTED
11aa53: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
11aa56: 83 c6 02 add $0x2,%esi <== NOT EXECUTED
11aa59: 83 e9 02 sub $0x2,%ecx <== NOT EXECUTED
11aa5c: 66 89 57 fe mov %dx,-0x2(%edi) <== NOT EXECUTED
11aa60: e9 37 ff ff ff jmp 11a99c <rtems_rfs_symlink+0x37c> <== NOT EXECUTED
11aa65: 0f b6 0e movzbl (%esi),%ecx <== NOT EXECUTED
11aa68: 8d 78 1d lea 0x1d(%eax),%edi <== NOT EXECUTED
11aa6b: 46 inc %esi <== NOT EXECUTED
11aa6c: 88 48 1c mov %cl,0x1c(%eax) <== NOT EXECUTED
11aa6f: 8b 4d 18 mov 0x18(%ebp),%ecx <== NOT EXECUTED
11aa72: 49 dec %ecx <== NOT EXECUTED
11aa73: e9 18 ff ff ff jmp 11a990 <rtems_rfs_symlink+0x370> <== NOT EXECUTED
memset (data, 0xff, rtems_rfs_fs_block_size (fs));
11aa78: c7 07 ff ff ff ff movl $0xffffffff,(%edi) <== NOT EXECUTED
11aa7e: 83 ea 04 sub $0x4,%edx <== NOT EXECUTED
11aa81: 83 c7 04 add $0x4,%edi <== NOT EXECUTED
11aa84: eb b6 jmp 11aa3c <rtems_rfs_symlink+0x41c> <== NOT EXECUTED
memcpy (data, link, link_length);
11aa86: 0f b7 06 movzwl (%esi),%eax <== NOT EXECUTED
11aa89: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
11aa8c: 83 c6 02 add $0x2,%esi <== NOT EXECUTED
11aa8f: 83 e9 02 sub $0x2,%ecx <== NOT EXECUTED
11aa92: 66 89 47 fe mov %ax,-0x2(%edi) <== NOT EXECUTED
11aa96: e9 5e ff ff ff jmp 11a9f9 <rtems_rfs_symlink+0x3d9> <== NOT EXECUTED
11aa9b: 0f b6 06 movzbl (%esi),%eax <== NOT EXECUTED
11aa9e: 47 inc %edi <== NOT EXECUTED
11aa9f: 46 inc %esi <== NOT EXECUTED
11aaa0: 88 47 ff mov %al,-0x1(%edi) <== NOT EXECUTED
11aaa3: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED
11aaa6: 8d 48 ff lea -0x1(%eax),%ecx <== NOT EXECUTED
11aaa9: e9 3f ff ff ff jmp 11a9ed <rtems_rfs_symlink+0x3cd> <== NOT EXECUTED
memset (data, 0xff, rtems_rfs_fs_block_size (fs));
11aaae: 66 c7 07 ff ff movw $0xffff,(%edi) <== NOT EXECUTED
11aab3: 83 ea 02 sub $0x2,%edx <== NOT EXECUTED
11aab6: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
11aab9: e9 76 ff ff ff jmp 11aa34 <rtems_rfs_symlink+0x414> <== NOT EXECUTED
11aabe: c6 06 ff movb $0xff,(%esi) <== NOT EXECUTED
11aac1: 8d 7e 01 lea 0x1(%esi),%edi <== NOT EXECUTED
11aac4: 4a dec %edx <== NOT EXECUTED
11aac5: e9 62 ff ff ff jmp 11aa2c <rtems_rfs_symlink+0x40c> <== NOT EXECUTED
11aaca: 90 nop
11aacb: 90 nop
11aacc: 90 nop
11aacd: 90 nop
11aace: 90 nop
11aacf: 90 nop
0011aad0 <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)
{
11aad0: 55 push %ebp
11aad1: 89 e5 mov %esp,%ebp
11aad3: 57 push %edi
11aad4: 56 push %esi
11aad5: 53 push %ebx
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))
11aad6: bb 04 00 00 00 mov $0x4,%ebx
{
11aadb: 81 ec bc 00 00 00 sub $0xbc,%esp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))
11aae1: c7 04 24 00 00 00 00 movl $0x0,(%esp)
{
11aae8: 8b 75 0c mov 0xc(%ebp),%esi
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))
11aaeb: 89 5c 24 04 mov %ebx,0x4(%esp)
11aaef: e8 5c 0d ff ff call 10b850 <rtems_rfs_trace>
11aaf4: 84 c0 test %al,%al
11aaf6: 0f 85 e4 01 00 00 jne 11ace0 <rtems_rfs_symlink_read+0x210> <== NEVER TAKEN
printf ("rtems-rfs: symlink-read: link:%" PRIu32 "\n", link);
rc = rtems_rfs_inode_open (fs, link, &inode, true);
11aafc: 8b 45 08 mov 0x8(%ebp),%eax
11aaff: 8d 9d 70 ff ff ff lea -0x90(%ebp),%ebx
11ab05: b9 01 00 00 00 mov $0x1,%ecx
11ab0a: 89 74 24 04 mov %esi,0x4(%esp)
11ab0e: 89 4c 24 0c mov %ecx,0xc(%esp)
11ab12: 89 5c 24 08 mov %ebx,0x8(%esp)
11ab16: 89 04 24 mov %eax,(%esp)
11ab19: e8 12 ef fe ff call 109a30 <rtems_rfs_inode_open>
if (rc)
11ab1e: 85 c0 test %eax,%eax
rc = rtems_rfs_inode_open (fs, link, &inode, true);
11ab20: 89 c6 mov %eax,%esi
if (rc)
11ab22: 75 67 jne 11ab8b <rtems_rfs_symlink_read+0xbb> <== NEVER TAKEN
return rtems_rfs_read_u16 (&handle->node->mode);
11ab24: 8b 85 7c ff ff ff mov -0x84(%ebp),%eax
return rc;
if (!RTEMS_RFS_S_ISLNK (rtems_rfs_inode_get_mode (&inode)))
11ab2a: 0f b7 50 02 movzwl 0x2(%eax),%edx
11ab2e: c1 e2 08 shl $0x8,%edx
11ab31: 81 e2 00 f0 00 00 and $0xf000,%edx
11ab37: 81 fa 00 a0 00 00 cmp $0xa000,%edx
11ab3d: 0f 85 2d 02 00 00 jne 11ad70 <rtems_rfs_symlink_read+0x2a0> <== NEVER TAKEN
{
rtems_rfs_inode_close (fs, &inode);
return EINVAL;
}
*length = rtems_rfs_inode_get_block_offset (&inode);
11ab43: 0f b7 50 0a movzwl 0xa(%eax),%edx
11ab47: 89 d1 mov %edx,%ecx
11ab49: 0f b6 d6 movzbl %dh,%edx
11ab4c: c1 e1 08 shl $0x8,%ecx
11ab4f: 09 d1 or %edx,%ecx
11ab51: 0f b7 c9 movzwl %cx,%ecx
11ab54: 3b 4d 14 cmp 0x14(%ebp),%ecx
11ab57: 0f 87 63 01 00 00 ja 11acc0 <rtems_rfs_symlink_read+0x1f0>
11ab5d: 8b 7d 18 mov 0x18(%ebp),%edi
11ab60: 89 0f mov %ecx,(%edi)
if (size < *length)
{
*length = size;
}
if (rtems_rfs_inode_get_block_count (&inode) == 0)
11ab62: 8b 50 0c mov 0xc(%eax),%edx
11ab65: 85 d2 test %edx,%edx
11ab67: 75 37 jne 11aba0 <rtems_rfs_symlink_read+0xd0> <== NEVER TAKEN
{
memcpy (path, inode.node->data.name, *length);
11ab69: 8b 7d 10 mov 0x10(%ebp),%edi
11ab6c: 8d 70 1c lea 0x1c(%eax),%esi
11ab6f: 83 f9 08 cmp $0x8,%ecx
11ab72: 0f 83 88 01 00 00 jae 11ad00 <rtems_rfs_symlink_read+0x230> <== NEVER TAKEN
11ab78: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
rtems_rfs_inode_close (fs, &inode);
return rc;
}
}
rc = rtems_rfs_inode_close (fs, &inode);
11ab7a: 89 5c 24 04 mov %ebx,0x4(%esp)
11ab7e: 8b 45 08 mov 0x8(%ebp),%eax
11ab81: 89 04 24 mov %eax,(%esp)
11ab84: e8 b7 f0 fe ff call 109c40 <rtems_rfs_inode_close>
11ab89: 89 c6 mov %eax,%esi
return rc;
}
11ab8b: 81 c4 bc 00 00 00 add $0xbc,%esp
11ab91: 89 f0 mov %esi,%eax
11ab93: 5b pop %ebx
11ab94: 5e pop %esi
11ab95: 5f pop %edi
11ab96: 5d pop %ebp
11ab97: c3 ret
11ab98: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11ab9f: 90 nop
rc = rtems_rfs_block_map_open (fs, &inode, &map);
11aba0: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
11aba4: 8d 45 98 lea -0x68(%ebp),%eax <== NOT EXECUTED
11aba7: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
11abab: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
11abae: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
11abb1: e8 6a ad ff ff call 115920 <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc > 0)
11abb6: 85 c0 test %eax,%eax <== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, &inode, &map);
11abb8: 89 c6 mov %eax,%esi <== NOT EXECUTED
if (rc > 0)
11abba: 0f 8f e0 00 00 00 jg 11aca0 <rtems_rfs_symlink_read+0x1d0> <== NOT EXECUTED
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
11abc0: 8d 85 60 ff ff ff lea -0xa0(%ebp),%eax <== NOT EXECUTED
11abc6: 89 44 24 10 mov %eax,0x10(%esp) <== NOT EXECUTED
11abca: 31 c0 xor %eax,%eax <== NOT EXECUTED
11abcc: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
11abd0: 31 c0 xor %eax,%eax <== NOT EXECUTED
11abd2: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
11abd6: 8d 45 98 lea -0x68(%ebp),%eax <== NOT EXECUTED
11abd9: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
11abdd: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
11abe0: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
11abe3: e8 58 b1 ff ff call 115d40 <rtems_rfs_block_map_seek> <== NOT EXECUTED
if (rc > 0)
11abe8: 85 c0 test %eax,%eax <== NOT EXECUTED
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
11abea: 89 c6 mov %eax,%esi <== NOT EXECUTED
if (rc > 0)
11abec: 0f 8f 4e 01 00 00 jg 11ad40 <rtems_rfs_symlink_read+0x270> <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false);
11abf2: 8b 85 60 ff ff ff mov -0xa0(%ebp),%eax <== NOT EXECUTED
11abf8: 8d 95 64 ff ff ff lea -0x9c(%ebp),%edx <== NOT EXECUTED
11abfe: 31 ff xor %edi,%edi <== NOT EXECUTED
11ac00: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
handle->bnum = 0;
11ac04: 31 c9 xor %ecx,%ecx <== NOT EXECUTED
handle->buffer = NULL;
11ac06: 31 f6 xor %esi,%esi <== NOT EXECUTED
11ac08: 89 7c 24 0c mov %edi,0xc(%esp) <== NOT EXECUTED
11ac0c: 89 b5 6c ff ff ff mov %esi,-0x94(%ebp) <== NOT EXECUTED
11ac12: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
11ac16: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
handle->dirty = false;
11ac19: c6 85 64 ff ff ff 00 movb $0x0,-0x9c(%ebp) <== NOT EXECUTED
handle->bnum = 0;
11ac20: 89 8d 68 ff ff ff mov %ecx,-0x98(%ebp) <== NOT EXECUTED
11ac26: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
11ac29: e8 a2 c9 fe ff call 1075d0 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
11ac2e: 8d 95 64 ff ff ff lea -0x9c(%ebp),%edx <== NOT EXECUTED
11ac34: 85 c0 test %eax,%eax <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false);
11ac36: 89 c6 mov %eax,%esi <== NOT EXECUTED
if (rc > 0)
11ac38: 0f 8f 02 01 00 00 jg 11ad40 <rtems_rfs_symlink_read+0x270> <== NOT EXECUTED
memcpy (path, data, *length);
11ac3e: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED
11ac41: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED
11ac44: 8b 08 mov (%eax),%ecx <== NOT EXECUTED
11ac46: 8b 85 6c ff ff ff mov -0x94(%ebp),%eax <== NOT EXECUTED
11ac4c: 83 f9 08 cmp $0x8,%ecx <== NOT EXECUTED
11ac4f: 8b 70 1c mov 0x1c(%eax),%esi <== NOT EXECUTED
11ac52: 0f 83 48 01 00 00 jae 11ada0 <rtems_rfs_symlink_read+0x2d0> <== NOT EXECUTED
11ac58: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
11ac5a: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
11ac5e: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
11ac61: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
11ac64: e8 47 cc fe ff call 1078b0 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->bnum = 0;
11ac69: 31 c0 xor %eax,%eax <== NOT EXECUTED
handle->buffer = NULL;
11ac6b: 31 d2 xor %edx,%edx <== NOT EXECUTED
handle->bnum = 0;
11ac6d: 89 85 68 ff ff ff mov %eax,-0x98(%ebp) <== NOT EXECUTED
rc = rtems_rfs_block_map_close (fs, &map);
11ac73: 8d 45 98 lea -0x68(%ebp),%eax <== NOT EXECUTED
11ac76: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
11ac7a: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
handle->dirty = false;
11ac7d: c6 85 64 ff ff ff 00 movb $0x0,-0x9c(%ebp) <== NOT EXECUTED
handle->buffer = NULL;
11ac84: 89 95 6c ff ff ff mov %edx,-0x94(%ebp) <== NOT EXECUTED
11ac8a: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
11ac8d: e8 be ad ff ff call 115a50 <rtems_rfs_block_map_close> <== NOT EXECUTED
if (rc > 0)
11ac92: 85 c0 test %eax,%eax <== NOT EXECUTED
rc = rtems_rfs_block_map_close (fs, &map);
11ac94: 89 c6 mov %eax,%esi <== NOT EXECUTED
if (rc > 0)
11ac96: 0f 8e de fe ff ff jle 11ab7a <rtems_rfs_symlink_read+0xaa> <== NOT EXECUTED
11ac9c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
11aca0: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
11aca4: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
11aca7: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
11acaa: e8 91 ef fe ff call 109c40 <rtems_rfs_inode_close> <== NOT EXECUTED
}
11acaf: 81 c4 bc 00 00 00 add $0xbc,%esp <== NOT EXECUTED
11acb5: 89 f0 mov %esi,%eax <== NOT EXECUTED
11acb7: 5b pop %ebx <== NOT EXECUTED
11acb8: 5e pop %esi <== NOT EXECUTED
11acb9: 5f pop %edi <== NOT EXECUTED
11acba: 5d pop %ebp <== NOT EXECUTED
11acbb: c3 ret <== NOT EXECUTED
11acbc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11acc0: 8b 4d 14 mov 0x14(%ebp),%ecx
11acc3: 8b 7d 18 mov 0x18(%ebp),%edi
11acc6: 89 0f mov %ecx,(%edi)
if (rtems_rfs_inode_get_block_count (&inode) == 0)
11acc8: 8b 50 0c mov 0xc(%eax),%edx
11accb: 85 d2 test %edx,%edx
11accd: 0f 85 cd fe ff ff jne 11aba0 <rtems_rfs_symlink_read+0xd0> <== NEVER TAKEN
11acd3: e9 91 fe ff ff jmp 11ab69 <rtems_rfs_symlink_read+0x99>
11acd8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11acdf: 90 nop
printf ("rtems-rfs: symlink-read: link:%" PRIu32 "\n", link);
11ace0: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED
11ace4: c7 04 24 84 63 13 00 movl $0x136384,(%esp) <== NOT EXECUTED
11aceb: e8 50 74 fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
11acf0: e9 07 fe ff ff jmp 11aafc <rtems_rfs_symlink_read+0x2c> <== NOT EXECUTED
11acf5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11acfc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
memcpy (path, inode.node->data.name, *length);
11ad00: f7 c7 01 00 00 00 test $0x1,%edi <== NOT EXECUTED
11ad06: 0f 85 e4 00 00 00 jne 11adf0 <rtems_rfs_symlink_read+0x320> <== NOT EXECUTED
11ad0c: f7 c7 02 00 00 00 test $0x2,%edi <== NOT EXECUTED
11ad12: 0f 85 b8 00 00 00 jne 11add0 <rtems_rfs_symlink_read+0x300> <== NOT EXECUTED
11ad18: f7 c7 04 00 00 00 test $0x4,%edi <== NOT EXECUTED
11ad1e: 0f 84 54 fe ff ff je 11ab78 <rtems_rfs_symlink_read+0xa8> <== NOT EXECUTED
11ad24: 8b 06 mov (%esi),%eax <== NOT EXECUTED
11ad26: 83 c7 04 add $0x4,%edi <== NOT EXECUTED
11ad29: 83 c6 04 add $0x4,%esi <== NOT EXECUTED
11ad2c: 83 e9 04 sub $0x4,%ecx <== NOT EXECUTED
11ad2f: 89 47 fc mov %eax,-0x4(%edi) <== NOT EXECUTED
11ad32: e9 41 fe ff ff jmp 11ab78 <rtems_rfs_symlink_read+0xa8> <== NOT EXECUTED
11ad37: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11ad3e: 66 90 xchg %ax,%ax <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
11ad40: 8d 45 98 lea -0x68(%ebp),%eax <== NOT EXECUTED
11ad43: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
11ad47: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
11ad4a: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
11ad4d: e8 fe ac ff ff call 115a50 <rtems_rfs_block_map_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
11ad52: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
11ad55: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
11ad59: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
11ad5c: e8 df ee fe ff call 109c40 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
11ad61: e9 49 ff ff ff jmp 11acaf <rtems_rfs_symlink_read+0x1df> <== NOT EXECUTED
11ad66: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11ad6d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
11ad70: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
11ad74: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
return EINVAL;
11ad77: be 16 00 00 00 mov $0x16,%esi <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
11ad7c: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
11ad7f: e8 bc ee fe ff call 109c40 <rtems_rfs_inode_close> <== NOT EXECUTED
}
11ad84: 81 c4 bc 00 00 00 add $0xbc,%esp <== NOT EXECUTED
11ad8a: 89 f0 mov %esi,%eax <== NOT EXECUTED
11ad8c: 5b pop %ebx <== NOT EXECUTED
11ad8d: 5e pop %esi <== NOT EXECUTED
11ad8e: 5f pop %edi <== NOT EXECUTED
11ad8f: 5d pop %ebp <== NOT EXECUTED
11ad90: c3 ret <== NOT EXECUTED
11ad91: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11ad98: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11ad9f: 90 nop <== NOT EXECUTED
memcpy (path, data, *length);
11ada0: f7 c7 01 00 00 00 test $0x1,%edi <== NOT EXECUTED
11ada6: 75 6b jne 11ae13 <rtems_rfs_symlink_read+0x343> <== NOT EXECUTED
11ada8: f7 c7 02 00 00 00 test $0x2,%edi <== NOT EXECUTED
11adae: 75 51 jne 11ae01 <rtems_rfs_symlink_read+0x331> <== NOT EXECUTED
11adb0: f7 c7 04 00 00 00 test $0x4,%edi <== NOT EXECUTED
11adb6: 0f 84 9c fe ff ff je 11ac58 <rtems_rfs_symlink_read+0x188> <== NOT EXECUTED
11adbc: 8b 06 mov (%esi),%eax <== NOT EXECUTED
11adbe: 83 c7 04 add $0x4,%edi <== NOT EXECUTED
11adc1: 83 c6 04 add $0x4,%esi <== NOT EXECUTED
11adc4: 83 e9 04 sub $0x4,%ecx <== NOT EXECUTED
11adc7: 89 47 fc mov %eax,-0x4(%edi) <== NOT EXECUTED
11adca: e9 89 fe ff ff jmp 11ac58 <rtems_rfs_symlink_read+0x188> <== NOT EXECUTED
11adcf: 90 nop <== NOT EXECUTED
memcpy (path, inode.node->data.name, *length);
11add0: 0f b7 06 movzwl (%esi),%eax <== NOT EXECUTED
11add3: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
11add6: 83 c6 02 add $0x2,%esi <== NOT EXECUTED
11add9: 83 e9 02 sub $0x2,%ecx <== NOT EXECUTED
11addc: 66 89 47 fe mov %ax,-0x2(%edi) <== NOT EXECUTED
11ade0: e9 33 ff ff ff jmp 11ad18 <rtems_rfs_symlink_read+0x248> <== NOT EXECUTED
11ade5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11adec: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11adf0: 0f b6 50 1c movzbl 0x1c(%eax),%edx <== NOT EXECUTED
11adf4: 47 inc %edi <== NOT EXECUTED
11adf5: 49 dec %ecx <== NOT EXECUTED
11adf6: 8d 70 1d lea 0x1d(%eax),%esi <== NOT EXECUTED
11adf9: 88 57 ff mov %dl,-0x1(%edi) <== NOT EXECUTED
11adfc: e9 0b ff ff ff jmp 11ad0c <rtems_rfs_symlink_read+0x23c> <== NOT EXECUTED
memcpy (path, data, *length);
11ae01: 0f b7 06 movzwl (%esi),%eax <== NOT EXECUTED
11ae04: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
11ae07: 83 c6 02 add $0x2,%esi <== NOT EXECUTED
11ae0a: 83 e9 02 sub $0x2,%ecx <== NOT EXECUTED
11ae0d: 66 89 47 fe mov %ax,-0x2(%edi) <== NOT EXECUTED
11ae11: eb 9d jmp 11adb0 <rtems_rfs_symlink_read+0x2e0> <== NOT EXECUTED
11ae13: 0f b6 06 movzbl (%esi),%eax <== NOT EXECUTED
11ae16: 47 inc %edi <== NOT EXECUTED
11ae17: 46 inc %esi <== NOT EXECUTED
11ae18: 49 dec %ecx <== NOT EXECUTED
11ae19: 88 47 ff mov %al,-0x1(%edi) <== NOT EXECUTED
11ae1c: eb 8a jmp 11ada8 <rtems_rfs_symlink_read+0x2d8> <== NOT EXECUTED
11ae1e: 90 nop
11ae1f: 90 nop
0011a130 <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)
{
11a130: 55 push %ebp
rtems_rfs_inode_handle target_inode;
uint16_t links;
bool dir;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
11a131: 31 c0 xor %eax,%eax
{
11a133: 89 e5 mov %esp,%ebp
11a135: 57 push %edi
11a136: 56 push %esi
11a137: 53 push %ebx
11a138: 83 ec 7c sub $0x7c,%esp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
11a13b: c7 04 24 00 00 00 02 movl $0x2000000,(%esp)
{
11a142: 8b 5d 08 mov 0x8(%ebp),%ebx
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
11a145: 89 44 24 04 mov %eax,0x4(%esp)
11a149: e8 02 17 ff ff call 10b850 <rtems_rfs_trace>
11a14e: 84 c0 test %al,%al
11a150: 0f 85 6a 01 00 00 jne 11a2c0 <rtems_rfs_unlink+0x190> <== NEVER TAKEN
printf ("rtems-rfs: unlink: parent(%" PRIu32 ") -X-> (%" PRIu32 ")\n", parent, target);
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
11a156: 89 1c 24 mov %ebx,(%esp)
11a159: 8d 75 c0 lea -0x40(%ebp),%esi
11a15c: b8 01 00 00 00 mov $0x1,%eax
11a161: 89 44 24 0c mov %eax,0xc(%esp)
11a165: 8b 45 10 mov 0x10(%ebp),%eax
11a168: 89 74 24 08 mov %esi,0x8(%esp)
11a16c: 89 44 24 04 mov %eax,0x4(%esp)
11a170: e8 bb f8 fe ff call 109a30 <rtems_rfs_inode_open>
if (rc)
11a175: 85 c0 test %eax,%eax
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
11a177: 89 c7 mov %eax,%edi
if (rc)
11a179: 0f 85 28 01 00 00 jne 11a2a7 <rtems_rfs_unlink+0x177> <== NEVER TAKEN
return rtems_rfs_read_u16 (&handle->node->mode);
11a17f: 8b 45 cc mov -0x34(%ebp),%eax
11a182: 0f b7 40 02 movzwl 0x2(%eax),%eax
11a186: c1 e0 08 shl $0x8,%eax
11a189: 25 00 f0 00 00 and $0xf000,%eax
11a18e: 89 45 94 mov %eax,-0x6c(%ebp)
/*
* If a directory process the unlink mode.
*/
dir = RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&target_inode));
if (dir)
11a191: 3d 00 40 00 00 cmp $0x4000,%eax
11a196: 75 15 jne 11a1ad <rtems_rfs_unlink+0x7d>
{
switch (dir_mode)
11a198: 8b 45 18 mov 0x18(%ebp),%eax
11a19b: 85 c0 test %eax,%eax
11a19d: 0f 84 2d 02 00 00 je 11a3d0 <rtems_rfs_unlink+0x2a0> <== NEVER TAKEN
11a1a3: 83 7d 18 01 cmpl $0x1,0x18(%ebp)
11a1a7: 0f 84 63 01 00 00 je 11a310 <rtems_rfs_unlink+0x1e0>
default:
break;
}
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
11a1ad: 89 1c 24 mov %ebx,(%esp)
11a1b0: 8d 45 98 lea -0x68(%ebp),%eax
11a1b3: bf 01 00 00 00 mov $0x1,%edi
11a1b8: 89 44 24 08 mov %eax,0x8(%esp)
11a1bc: 8b 45 0c mov 0xc(%ebp),%eax
11a1bf: 89 7c 24 0c mov %edi,0xc(%esp)
11a1c3: 89 44 24 04 mov %eax,0x4(%esp)
11a1c7: e8 64 f8 fe ff call 109a30 <rtems_rfs_inode_open>
if (rc)
11a1cc: 85 c0 test %eax,%eax
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
11a1ce: 89 c7 mov %eax,%edi
if (rc)
11a1d0: 0f 85 0a 01 00 00 jne 11a2e0 <rtems_rfs_unlink+0x1b0> <== NEVER TAKEN
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_dir_del_entry (fs, &parent_inode, target, doff);
11a1d6: 89 1c 24 mov %ebx,(%esp)
11a1d9: 8b 45 14 mov 0x14(%ebp),%eax
11a1dc: 89 44 24 0c mov %eax,0xc(%esp)
11a1e0: 8b 45 10 mov 0x10(%ebp),%eax
11a1e3: 89 44 24 08 mov %eax,0x8(%esp)
11a1e7: 8d 45 98 lea -0x68(%ebp),%eax
11a1ea: 89 44 24 04 mov %eax,0x4(%esp)
11a1ee: e8 bd cf ff ff call 1171b0 <rtems_rfs_dir_del_entry>
if (rc > 0)
11a1f3: 85 c0 test %eax,%eax
rc = rtems_rfs_dir_del_entry (fs, &parent_inode, target, doff);
11a1f5: 89 c7 mov %eax,%edi
if (rc > 0)
11a1f7: 0f 8f 53 02 00 00 jg 11a450 <rtems_rfs_unlink+0x320> <== NEVER TAKEN
links = rtems_rfs_read_u16 (&handle->node->links);
11a1fd: 8b 45 cc mov -0x34(%ebp),%eax
11a200: 0f b7 00 movzwl (%eax),%eax
return rc;
}
links = rtems_rfs_inode_get_links (&target_inode);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
11a203: c7 04 24 00 00 00 02 movl $0x2000000,(%esp)
11a20a: 89 c2 mov %eax,%edx
11a20c: 0f b6 c4 movzbl %ah,%eax
11a20f: c1 e2 08 shl $0x8,%edx
11a212: 09 c2 or %eax,%edx
11a214: 31 c0 xor %eax,%eax
11a216: 89 44 24 04 mov %eax,0x4(%esp)
11a21a: 0f b7 fa movzwl %dx,%edi
if (links == 0xffff)
11a21d: 81 ff ff ff 00 00 cmp $0xffff,%edi
11a223: 0f 84 37 01 00 00 je 11a360 <rtems_rfs_unlink+0x230> <== NEVER TAKEN
11a229: e8 22 16 ff ff call 10b850 <rtems_rfs_trace>
11a22e: 84 c0 test %al,%al
11a230: 0f 85 ca 02 00 00 jne 11a500 <rtems_rfs_unlink+0x3d0> <== NEVER TAKEN
printf ("rtems-rfs: unlink: target:%" PRIu32 " links:%u\n", target, links);
if (links > 1)
11a236: 83 ff 01 cmp $0x1,%edi
11a239: 0f 86 2e 01 00 00 jbe 11a36d <rtems_rfs_unlink+0x23d>
rtems_rfs_write_u16 (&handle->node->links, links);
11a23f: 8b 45 cc mov -0x34(%ebp),%eax
{
links--;
11a242: 8d 57 ff lea -0x1(%edi),%edx
11a245: 88 30 mov %dh,(%eax)
11a247: 8b 45 cc mov -0x34(%ebp),%eax
11a24a: 88 50 01 mov %dl,0x1(%eax)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
11a24d: c6 45 d0 01 movb $0x1,-0x30(%ebp)
links--;
rtems_rfs_inode_set_links (&parent_inode, links);
}
}
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
11a251: b8 01 00 00 00 mov $0x1,%eax
11a256: 89 44 24 08 mov %eax,0x8(%esp)
11a25a: b8 01 00 00 00 mov $0x1,%eax
11a25f: 89 44 24 04 mov %eax,0x4(%esp)
11a263: 8d 45 98 lea -0x68(%ebp),%eax
11a266: 89 04 24 mov %eax,(%esp)
11a269: e8 e2 fc fe ff call 109f50 <rtems_rfs_inode_time_stamp_now>
if (rc > 0)
11a26e: 85 c0 test %eax,%eax
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
11a270: 89 c7 mov %eax,%edi
if (rc > 0)
11a272: 0f 8f 98 01 00 00 jg 11a410 <rtems_rfs_unlink+0x2e0> <== NEVER TAKEN
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &parent_inode);
11a278: 89 1c 24 mov %ebx,(%esp)
11a27b: 8d 45 98 lea -0x68(%ebp),%eax
11a27e: 89 44 24 04 mov %eax,0x4(%esp)
11a282: e8 b9 f9 fe ff call 109c40 <rtems_rfs_inode_close>
if (rc > 0)
11a287: 85 c0 test %eax,%eax
rc = rtems_rfs_inode_close (fs, &parent_inode);
11a289: 89 c7 mov %eax,%edi
if (rc > 0)
11a28b: 0f 8f 2f 02 00 00 jg 11a4c0 <rtems_rfs_unlink+0x390> <== NEVER TAKEN
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &target_inode);
11a291: 89 74 24 04 mov %esi,0x4(%esp)
11a295: 89 1c 24 mov %ebx,(%esp)
11a298: e8 a3 f9 fe ff call 109c40 <rtems_rfs_inode_close>
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
11a29d: 85 c0 test %eax,%eax
rc = rtems_rfs_inode_close (fs, &target_inode);
11a29f: 89 c7 mov %eax,%edi
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
11a2a1: 0f 8f 79 02 00 00 jg 11a520 <rtems_rfs_unlink+0x3f0> <== NEVER TAKEN
printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",
rc, strerror (rc));
return rc;
}
11a2a7: 83 c4 7c add $0x7c,%esp
11a2aa: 89 f8 mov %edi,%eax
11a2ac: 5b pop %ebx
11a2ad: 5e pop %esi
11a2ae: 5f pop %edi
11a2af: 5d pop %ebp
11a2b0: c3 ret
11a2b1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11a2b8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11a2bf: 90 nop
printf ("rtems-rfs: unlink: parent(%" PRIu32 ") -X-> (%" PRIu32 ")\n", parent, target);
11a2c0: c7 04 24 a0 61 13 00 movl $0x1361a0,(%esp) <== NOT EXECUTED
11a2c7: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
11a2ca: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
11a2ce: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
11a2d1: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
11a2d5: e8 66 7e fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
11a2da: e9 77 fe ff ff jmp 11a156 <rtems_rfs_unlink+0x26> <== NOT EXECUTED
11a2df: 90 nop <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
11a2e0: c7 04 24 00 00 00 02 movl $0x2000000,(%esp) <== NOT EXECUTED
11a2e7: 31 c9 xor %ecx,%ecx <== NOT EXECUTED
11a2e9: 89 4c 24 04 mov %ecx,0x4(%esp) <== NOT EXECUTED
11a2ed: e8 5e 15 ff ff call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
11a2f2: 84 c0 test %al,%al <== NOT EXECUTED
11a2f4: 0f 85 96 01 00 00 jne 11a490 <rtems_rfs_unlink+0x360> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
11a2fa: 89 74 24 04 mov %esi,0x4(%esp)
11a2fe: 89 1c 24 mov %ebx,(%esp)
11a301: e8 3a f9 fe ff call 109c40 <rtems_rfs_inode_close>
}
11a306: 83 c4 7c add $0x7c,%esp
11a309: 89 f8 mov %edi,%eax
11a30b: 5b pop %ebx
11a30c: 5e pop %esi
11a30d: 5f pop %edi
11a30e: 5d pop %ebp
11a30f: c3 ret
rc = rtems_rfs_dir_empty (fs, &target_inode);
11a310: 89 74 24 04 mov %esi,0x4(%esp)
11a314: 89 1c 24 mov %ebx,(%esp)
11a317: e8 64 d9 ff ff call 117c80 <rtems_rfs_dir_empty>
if (rc > 0)
11a31c: 85 c0 test %eax,%eax
rc = rtems_rfs_dir_empty (fs, &target_inode);
11a31e: 89 c7 mov %eax,%edi
if (rc > 0)
11a320: 0f 8e 87 fe ff ff jle 11a1ad <rtems_rfs_unlink+0x7d>
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
11a326: c7 04 24 00 00 00 02 movl $0x2000000,(%esp)
11a32d: 31 c0 xor %eax,%eax
11a32f: 89 44 24 04 mov %eax,0x4(%esp)
11a333: e8 18 15 ff ff call 10b850 <rtems_rfs_trace>
11a338: 84 c0 test %al,%al
11a33a: 74 be je 11a2fa <rtems_rfs_unlink+0x1ca> <== ALWAYS TAKEN
printf ("rtems-rfs: dir-empty: %d: %s\n", rc, strerror (rc));
11a33c: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
11a33f: e8 dc 10 01 00 call 12b420 <strerror> <== NOT EXECUTED
11a344: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED
11a348: c7 04 24 38 63 13 00 movl $0x136338,(%esp) <== NOT EXECUTED
11a34f: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
11a353: e8 e8 7d fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
11a358: eb a0 jmp 11a2fa <rtems_rfs_unlink+0x1ca> <== NOT EXECUTED
11a35a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
11a360: e8 eb 14 ff ff call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
11a365: 84 c0 test %al,%al <== NOT EXECUTED
11a367: 0f 85 83 02 00 00 jne 11a5f0 <rtems_rfs_unlink+0x4c0> <== NOT EXECUTED
rc = rtems_rfs_inode_delete (fs, &target_inode);
11a36d: 89 74 24 04 mov %esi,0x4(%esp)
11a371: 89 1c 24 mov %ebx,(%esp)
11a374: e8 77 f9 fe ff call 109cf0 <rtems_rfs_inode_delete>
if (rc > 0)
11a379: 85 c0 test %eax,%eax
rc = rtems_rfs_inode_delete (fs, &target_inode);
11a37b: 89 c7 mov %eax,%edi
if (rc > 0)
11a37d: 0f 8f dd 01 00 00 jg 11a560 <rtems_rfs_unlink+0x430> <== NEVER TAKEN
if (dir)
11a383: 81 7d 94 00 40 00 00 cmpl $0x4000,-0x6c(%ebp)
11a38a: 0f 85 c1 fe ff ff jne 11a251 <rtems_rfs_unlink+0x121>
links = rtems_rfs_read_u16 (&handle->node->links);
11a390: 8b 55 a4 mov -0x5c(%ebp),%edx
11a393: 0f b7 0a movzwl (%edx),%ecx
11a396: 89 c8 mov %ecx,%eax
11a398: 0f b6 cd movzbl %ch,%ecx
11a39b: c1 e0 08 shl $0x8,%eax
11a39e: 09 c8 or %ecx,%eax
11a3a0: 0f b7 c0 movzwl %ax,%eax
if (links == 0xffff)
11a3a3: 3d ff ff 00 00 cmp $0xffff,%eax
11a3a8: 0f 84 60 02 00 00 je 11a60e <rtems_rfs_unlink+0x4de> <== NEVER TAKEN
if (links > 1)
11a3ae: 83 f8 01 cmp $0x1,%eax
11a3b1: 0f 86 59 02 00 00 jbe 11a610 <rtems_rfs_unlink+0x4e0>
links--;
11a3b7: 48 dec %eax
rtems_rfs_write_u16 (&handle->node->links, links);
11a3b8: 0f b6 cc movzbl %ah,%ecx
11a3bb: 88 0a mov %cl,(%edx)
11a3bd: 8b 55 a4 mov -0x5c(%ebp),%edx
11a3c0: 88 42 01 mov %al,0x1(%edx)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
11a3c3: c6 45 a8 01 movb $0x1,-0x58(%ebp)
}
11a3c7: e9 85 fe ff ff jmp 11a251 <rtems_rfs_unlink+0x121>
11a3cc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
11a3d0: c7 04 24 00 00 00 02 movl $0x2000000,(%esp) <== NOT EXECUTED
11a3d7: 31 c0 xor %eax,%eax <== NOT EXECUTED
11a3d9: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
11a3dd: e8 6e 14 ff ff call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
11a3e2: 84 c0 test %al,%al <== NOT EXECUTED
11a3e4: 0f 85 b6 01 00 00 jne 11a5a0 <rtems_rfs_unlink+0x470> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
11a3ea: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED
return EISDIR;
11a3ee: bf 15 00 00 00 mov $0x15,%edi <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
11a3f3: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
11a3f6: e8 45 f8 fe ff call 109c40 <rtems_rfs_inode_close> <== NOT EXECUTED
}
11a3fb: 83 c4 7c add $0x7c,%esp <== NOT EXECUTED
11a3fe: 89 f8 mov %edi,%eax <== NOT EXECUTED
11a400: 5b pop %ebx <== NOT EXECUTED
11a401: 5e pop %esi <== NOT EXECUTED
11a402: 5f pop %edi <== NOT EXECUTED
11a403: 5d pop %ebp <== NOT EXECUTED
11a404: c3 ret <== NOT EXECUTED
11a405: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11a40c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
11a410: c7 04 24 00 00 00 02 movl $0x2000000,(%esp) <== NOT EXECUTED
11a417: 31 c0 xor %eax,%eax <== NOT EXECUTED
11a419: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
11a41d: e8 2e 14 ff ff call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
11a422: 84 c0 test %al,%al <== NOT EXECUTED
11a424: 0f 85 96 01 00 00 jne 11a5c0 <rtems_rfs_unlink+0x490> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
11a42a: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
11a42d: 8d 45 98 lea -0x68(%ebp),%eax <== NOT EXECUTED
11a430: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
11a434: e8 07 f8 fe ff call 109c40 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
11a439: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED
11a43d: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
11a440: e8 fb f7 fe ff call 109c40 <rtems_rfs_inode_close> <== NOT EXECUTED
}
11a445: 83 c4 7c add $0x7c,%esp <== NOT EXECUTED
11a448: 89 f8 mov %edi,%eax <== NOT EXECUTED
11a44a: 5b pop %ebx <== NOT EXECUTED
11a44b: 5e pop %esi <== NOT EXECUTED
11a44c: 5f pop %edi <== NOT EXECUTED
11a44d: 5d pop %ebp <== NOT EXECUTED
11a44e: c3 ret <== NOT EXECUTED
11a44f: 90 nop <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
11a450: c7 04 24 00 00 00 02 movl $0x2000000,(%esp) <== NOT EXECUTED
11a457: 31 d2 xor %edx,%edx <== NOT EXECUTED
11a459: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
11a45d: e8 ee 13 ff ff call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
11a462: 84 c0 test %al,%al <== NOT EXECUTED
11a464: 74 c4 je 11a42a <rtems_rfs_unlink+0x2fa> <== NOT EXECUTED
printf ("rtems-rfs: unlink: dir-del failed: %d: %s\n",
11a466: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
11a469: e8 b2 0f 01 00 call 12b420 <strerror> <== NOT EXECUTED
11a46e: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED
11a472: c7 04 24 18 62 13 00 movl $0x136218,(%esp) <== NOT EXECUTED
11a479: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
11a47d: e8 be 7c fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
11a482: eb a6 jmp 11a42a <rtems_rfs_unlink+0x2fa> <== NOT EXECUTED
11a484: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11a48b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11a48f: 90 nop <== NOT EXECUTED
printf ("rtems-rfs: link: inode-open failed: %d: %s\n",
11a490: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
11a493: e8 88 0f 01 00 call 12b420 <strerror> <== NOT EXECUTED
11a498: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED
11a49c: c7 04 24 ec 61 13 00 movl $0x1361ec,(%esp) <== NOT EXECUTED
11a4a3: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
11a4a7: e8 94 7c fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
11a4ac: e9 49 fe ff ff jmp 11a2fa <rtems_rfs_unlink+0x1ca> <== NOT EXECUTED
11a4b1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11a4b8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11a4bf: 90 nop <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
11a4c0: c7 04 24 00 00 00 02 movl $0x2000000,(%esp) <== NOT EXECUTED
11a4c7: 31 c9 xor %ecx,%ecx <== NOT EXECUTED
11a4c9: 89 4c 24 04 mov %ecx,0x4(%esp) <== NOT EXECUTED
11a4cd: e8 7e 13 ff ff call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
11a4d2: 84 c0 test %al,%al <== NOT EXECUTED
11a4d4: 0f 84 20 fe ff ff je 11a2fa <rtems_rfs_unlink+0x1ca> <== NOT EXECUTED
printf ("rtems-rfs: link: parent inode-close failed: %d: %s\n",
11a4da: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
11a4dd: e8 3e 0f 01 00 call 12b420 <strerror> <== NOT EXECUTED
11a4e2: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED
11a4e6: c7 04 24 d0 62 13 00 movl $0x1362d0,(%esp) <== NOT EXECUTED
11a4ed: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
11a4f1: e8 4a 7c fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
11a4f6: e9 ff fd ff ff jmp 11a2fa <rtems_rfs_unlink+0x1ca> <== NOT EXECUTED
11a4fb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11a4ff: 90 nop <== NOT EXECUTED
printf ("rtems-rfs: unlink: target:%" PRIu32 " links:%u\n", target, links);
11a500: 89 7c 24 08 mov %edi,0x8(%esp) <== NOT EXECUTED
11a504: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
11a507: c7 04 24 44 62 13 00 movl $0x136244,(%esp) <== NOT EXECUTED
11a50e: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
11a512: e8 29 7c fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
11a517: e9 1a fd ff ff jmp 11a236 <rtems_rfs_unlink+0x106> <== NOT EXECUTED
11a51c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
11a520: c7 04 24 00 00 00 02 movl $0x2000000,(%esp) <== NOT EXECUTED
11a527: 31 d2 xor %edx,%edx <== NOT EXECUTED
11a529: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
11a52d: e8 1e 13 ff ff call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
11a532: 84 c0 test %al,%al <== NOT EXECUTED
11a534: 0f 84 6d fd ff ff je 11a2a7 <rtems_rfs_unlink+0x177> <== NOT EXECUTED
printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",
11a53a: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
11a53d: e8 de 0e 01 00 call 12b420 <strerror> <== NOT EXECUTED
11a542: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED
11a546: c7 04 24 04 63 13 00 movl $0x136304,(%esp) <== NOT EXECUTED
11a54d: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
11a551: e8 ea 7b fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
11a556: e9 4c fd ff ff jmp 11a2a7 <rtems_rfs_unlink+0x177> <== NOT EXECUTED
11a55b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11a55f: 90 nop <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
11a560: c7 04 24 00 00 00 02 movl $0x2000000,(%esp) <== NOT EXECUTED
11a567: 31 c0 xor %eax,%eax <== NOT EXECUTED
11a569: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
11a56d: e8 de 12 ff ff call 10b850 <rtems_rfs_trace> <== NOT EXECUTED
11a572: 84 c0 test %al,%al <== NOT EXECUTED
11a574: 0f 84 b0 fe ff ff je 11a42a <rtems_rfs_unlink+0x2fa> <== NOT EXECUTED
printf ("rtems-rfs: unlink: inode-del failed: %d: %s\n",
11a57a: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
11a57d: e8 9e 0e 01 00 call 12b420 <strerror> <== NOT EXECUTED
11a582: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED
11a586: c7 04 24 6c 62 13 00 movl $0x13626c,(%esp) <== NOT EXECUTED
11a58d: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
11a591: e8 aa 7b fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
11a596: e9 8f fe ff ff jmp 11a42a <rtems_rfs_unlink+0x2fa> <== NOT EXECUTED
11a59b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11a59f: 90 nop <== NOT EXECUTED
printf ("rtems-rfs: link is a directory\n");
11a5a0: c7 04 24 cc 61 13 00 movl $0x1361cc,(%esp) <== NOT EXECUTED
11a5a7: e8 c4 7b fe ff call 102170 <__wrap_puts> <== NOT EXECUTED
11a5ac: e9 39 fe ff ff jmp 11a3ea <rtems_rfs_unlink+0x2ba> <== NOT EXECUTED
11a5b1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11a5b8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11a5bf: 90 nop <== NOT EXECUTED
printf ("rtems-rfs: link: inode-time-stamp failed: %d: %s\n",
11a5c0: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
11a5c3: e8 58 0e 01 00 call 12b420 <strerror> <== NOT EXECUTED
11a5c8: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED
11a5cc: c7 04 24 9c 62 13 00 movl $0x13629c,(%esp) <== NOT EXECUTED
11a5d3: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
11a5d7: e8 64 7b fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
11a5dc: e9 49 fe ff ff jmp 11a42a <rtems_rfs_unlink+0x2fa> <== NOT EXECUTED
11a5e1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11a5e8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11a5ef: 90 nop <== NOT EXECUTED
printf ("rtems-rfs: unlink: target:%" PRIu32 " links:%u\n", target, links);
11a5f0: c7 04 24 44 62 13 00 movl $0x136244,(%esp) <== NOT EXECUTED
11a5f7: 31 c0 xor %eax,%eax <== NOT EXECUTED
11a5f9: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
11a5fd: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
11a600: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
11a604: e8 37 7b fe ff call 102140 <__wrap_printf> <== NOT EXECUTED
if (links > 1)
11a609: e9 5f fd ff ff jmp 11a36d <rtems_rfs_unlink+0x23d> <== NOT EXECUTED
11a60e: 31 c0 xor %eax,%eax <== NOT EXECUTED
11a610: 31 c9 xor %ecx,%ecx
11a612: e9 a4 fd ff ff jmp 11a3bb <rtems_rfs_unlink+0x28b>
11a617: 90 nop
11a618: 90 nop
11a619: 90 nop
11a61a: 90 nop
11a61b: 90 nop
11a61c: 90 nop
11a61d: 90 nop
11a61e: 90 nop
11a61f: 90 nop
0014b510 <rtems_shell_debugrfs>:
printf (" -l: The debugger command list.\n");
}
int
rtems_shell_debugrfs (int argc, char *argv[])
{
14b510: 55 push %ebp <== NOT EXECUTED
const rtems_rfs_shell_cmd table[] =
14b511: 31 c0 xor %eax,%eax <== NOT EXECUTED
{
14b513: 89 e5 mov %esp,%ebp <== NOT EXECUTED
14b515: 57 push %edi <== NOT EXECUTED
14b516: 56 push %esi <== NOT EXECUTED
14b517: 53 push %ebx <== NOT EXECUTED
14b518: 81 ec dc 00 00 00 sub $0xdc,%esp <== NOT EXECUTED
const rtems_rfs_shell_cmd table[] =
14b51e: 8b 90 60 6f 19 00 mov 0x196f60(%eax),%edx <== NOT EXECUTED
14b524: 89 54 05 ac mov %edx,-0x54(%ebp,%eax,1) <== NOT EXECUTED
14b528: 83 c0 04 add $0x4,%eax <== NOT EXECUTED
14b52b: 83 f8 3c cmp $0x3c,%eax <== NOT EXECUTED
14b52e: 72 ee jb 14b51e <rtems_shell_debugrfs+0xe> <== NOT EXECUTED
};
int arg;
int t;
for (arg = 1; arg < argc; arg++)
14b530: 83 7d 08 01 cmpl $0x1,0x8(%ebp) <== NOT EXECUTED
14b534: 0f 8e c6 00 00 00 jle 14b600 <rtems_shell_debugrfs+0xf0> <== NOT EXECUTED
{
if (argv[arg][0] != '-')
14b53a: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
14b53d: 8b 70 04 mov 0x4(%eax),%esi <== NOT EXECUTED
14b540: 80 3e 2d cmpb $0x2d,(%esi) <== NOT EXECUTED
14b543: 0f 84 e7 00 00 00 je 14b630 <rtems_shell_debugrfs+0x120> <== NOT EXECUTED
printf ("error: unknown option: %s\n", argv[arg]);
return 1;
}
}
if ((argc - arg) < 2)
14b549: 83 7d 08 02 cmpl $0x2,0x8(%ebp) <== NOT EXECUTED
14b54d: 0f 84 ad 00 00 00 je 14b600 <rtems_shell_debugrfs+0xf0> <== NOT EXECUTED
rc = statvfs (path, &sb);
14b553: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
14b556: 8d 85 3c ff ff ff lea -0xc4(%ebp),%eax <== NOT EXECUTED
14b55c: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
14b560: e8 4b f1 fe ff call 13a6b0 <statvfs> <== NOT EXECUTED
if (rc < 0)
14b565: 85 c0 test %eax,%eax <== NOT EXECUTED
rc = statvfs (path, &sb);
14b567: 89 c7 mov %eax,%edi <== NOT EXECUTED
if (rc < 0)
14b569: 0f 88 f4 01 00 00 js 14b763 <rtems_shell_debugrfs+0x253> <== NOT EXECUTED
if (sb.f_fsid != RTEMS_RFS_SB_MAGIC)
14b56f: 81 bd 68 ff ff ff 01 cmpl $0x28092001,-0x98(%ebp) <== NOT EXECUTED
14b576: 20 09 28
14b579: 0f 85 ca 01 00 00 jne 14b749 <rtems_shell_debugrfs+0x239> <== NOT EXECUTED
rtems_filesystem_eval_path_start (&ctx, path, eval_flags);
14b57f: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED
14b583: 8d b5 74 ff ff ff lea -0x8c(%ebp),%esi <== NOT EXECUTED
14b589: b8 18 00 00 00 mov $0x18,%eax <== NOT EXECUTED
14b58e: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
14b592: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
14b595: e8 46 dd fb ff call 1092e0 <rtems_filesystem_eval_path_start> <== NOT EXECUTED
*fs = rtems_rfs_rtems_pathloc_dev (currentloc);
14b59a: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED
14b59d: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED
rtems_filesystem_eval_path_cleanup (&ctx);
14b5a0: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
*fs = rtems_rfs_rtems_pathloc_dev (currentloc);
14b5a3: 89 85 34 ff ff ff mov %eax,-0xcc(%ebp) <== NOT EXECUTED
rtems_filesystem_eval_path_cleanup (&ctx);
14b5a9: e8 e2 de fb ff call 109490 <rtems_filesystem_eval_path_cleanup> <== NOT EXECUTED
printf ("error: you need at least a path and command, try %s -h\n", argv[0]);
else
{
rtems_rfs_file_system* fs;
if (rtems_rfs_get_fs (argv[arg], &fs) == 0)
14b5ae: 85 ff test %edi,%edi <== NOT EXECUTED
return table[t].handler (fs, argc - 2, argv + 2);
printf ("error: command not found: %s\n", argv[arg + 1]);
}
}
return 1;
14b5b0: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
if (rtems_rfs_get_fs (argv[arg], &fs) == 0)
14b5b5: 75 3d jne 14b5f4 <rtems_shell_debugrfs+0xe4> <== NOT EXECUTED
if (strcmp (argv[arg + 1], table[t].name) == 0)
14b5b7: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
14b5ba: 8d 5d ac lea -0x54(%ebp),%ebx <== NOT EXECUTED
14b5bd: 8b 70 08 mov 0x8(%eax),%esi <== NOT EXECUTED
14b5c0: 8b 03 mov (%ebx),%eax <== NOT EXECUTED
14b5c2: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
14b5c5: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
14b5c9: e8 22 c1 02 00 call 1776f0 <strcmp> <== NOT EXECUTED
14b5ce: 85 c0 test %eax,%eax <== NOT EXECUTED
14b5d0: 0f 84 4a 01 00 00 je 14b720 <rtems_shell_debugrfs+0x210> <== NOT EXECUTED
for (t = 0; t < (sizeof (table) / sizeof (const rtems_rfs_shell_cmd)); t++)
14b5d6: 47 inc %edi <== NOT EXECUTED
14b5d7: 83 c3 0c add $0xc,%ebx <== NOT EXECUTED
14b5da: 83 ff 05 cmp $0x5,%edi <== NOT EXECUTED
14b5dd: 75 e1 jne 14b5c0 <rtems_shell_debugrfs+0xb0> <== NOT EXECUTED
printf ("error: command not found: %s\n", argv[arg + 1]);
14b5df: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED
14b5e3: c7 04 24 fb 6d 19 00 movl $0x196dfb,(%esp) <== NOT EXECUTED
14b5ea: e8 f1 07 02 00 call 16bde0 <__wrap_printf> <== NOT EXECUTED
return 1;
14b5ef: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
}
14b5f4: 81 c4 dc 00 00 00 add $0xdc,%esp <== NOT EXECUTED
14b5fa: 5b pop %ebx <== NOT EXECUTED
14b5fb: 5e pop %esi <== NOT EXECUTED
14b5fc: 5f pop %edi <== NOT EXECUTED
14b5fd: 5d pop %ebp <== NOT EXECUTED
14b5fe: c3 ret <== NOT EXECUTED
14b5ff: 90 nop <== NOT EXECUTED
printf ("error: you need at least a path and command, try %s -h\n", argv[0]);
14b600: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
14b603: 8b 00 mov (%eax),%eax <== NOT EXECUTED
14b605: c7 04 24 bc 6e 19 00 movl $0x196ebc,(%esp) <== NOT EXECUTED
14b60c: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
14b610: e8 cb 07 02 00 call 16bde0 <__wrap_printf> <== NOT EXECUTED
}
14b615: 81 c4 dc 00 00 00 add $0xdc,%esp <== NOT EXECUTED
return 1;
14b61b: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
}
14b620: 5b pop %ebx <== NOT EXECUTED
14b621: 5e pop %esi <== NOT EXECUTED
14b622: 5f pop %edi <== NOT EXECUTED
14b623: 5d pop %ebp <== NOT EXECUTED
14b624: c3 ret <== NOT EXECUTED
14b625: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
14b62c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
switch (argv[arg][1])
14b630: 0f b6 46 01 movzbl 0x1(%esi),%eax <== NOT EXECUTED
14b634: 3c 68 cmp $0x68,%al <== NOT EXECUTED
14b636: 74 78 je 14b6b0 <rtems_shell_debugrfs+0x1a0> <== NOT EXECUTED
14b638: 3c 6c cmp $0x6c,%al <== NOT EXECUTED
14b63a: 75 54 jne 14b690 <rtems_shell_debugrfs+0x180> <== NOT EXECUTED
printf ("%s: commands are:\n", argv[0]);
14b63c: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
14b63f: 8d 5d ac lea -0x54(%ebp),%ebx <== NOT EXECUTED
14b642: 8d 75 e8 lea -0x18(%ebp),%esi <== NOT EXECUTED
14b645: 8b 00 mov (%eax),%eax <== NOT EXECUTED
14b647: c7 04 24 65 29 19 00 movl $0x192965,(%esp) <== NOT EXECUTED
14b64e: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
14b652: e8 89 07 02 00 call 16bde0 <__wrap_printf> <== NOT EXECUTED
for (t = 0; t < (sizeof (table) / sizeof (const rtems_rfs_shell_cmd)); t++)
14b657: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
14b65e: 66 90 xchg %ax,%ax <== NOT EXECUTED
printf (" %s\t\t%s\n", table[t].name, table[t].help);
14b660: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED
for (t = 0; t < (sizeof (table) / sizeof (const rtems_rfs_shell_cmd)); t++)
14b663: 83 c3 0c add $0xc,%ebx <== NOT EXECUTED
printf (" %s\t\t%s\n", table[t].name, table[t].help);
14b666: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
14b66a: 8b 43 f4 mov -0xc(%ebx),%eax <== NOT EXECUTED
14b66d: c7 04 24 f1 6d 19 00 movl $0x196df1,(%esp) <== NOT EXECUTED
14b674: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
14b678: e8 63 07 02 00 call 16bde0 <__wrap_printf> <== NOT EXECUTED
for (t = 0; t < (sizeof (table) / sizeof (const rtems_rfs_shell_cmd)); t++)
14b67d: 39 de cmp %ebx,%esi <== NOT EXECUTED
14b67f: 75 df jne 14b660 <rtems_shell_debugrfs+0x150> <== NOT EXECUTED
return 0;
14b681: 31 c0 xor %eax,%eax <== NOT EXECUTED
14b683: e9 6c ff ff ff jmp 14b5f4 <rtems_shell_debugrfs+0xe4> <== NOT EXECUTED
14b688: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
14b68f: 90 nop <== NOT EXECUTED
printf ("error: unknown option: %s\n", argv[arg]);
14b690: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED
14b694: c7 04 24 83 29 19 00 movl $0x192983,(%esp) <== NOT EXECUTED
14b69b: e8 40 07 02 00 call 16bde0 <__wrap_printf> <== NOT EXECUTED
return 1;
14b6a0: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
14b6a5: e9 4a ff ff ff jmp 14b5f4 <rtems_shell_debugrfs+0xe4> <== NOT EXECUTED
14b6aa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
rtems_rfs_shell_usage (argv[0]);
14b6b0: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
14b6b3: 8b 18 mov (%eax),%ebx <== NOT EXECUTED
printf ("%s: RFS debugger\n", arg);
14b6b5: c7 04 24 c2 6d 19 00 movl $0x196dc2,(%esp) <== NOT EXECUTED
14b6bc: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
14b6c0: e8 1b 07 02 00 call 16bde0 <__wrap_printf> <== NOT EXECUTED
printf (" %s [-hl] <path> <command>\n", arg);
14b6c5: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
14b6c9: c7 04 24 d4 6d 19 00 movl $0x196dd4,(%esp) <== NOT EXECUTED
14b6d0: e8 0b 07 02 00 call 16bde0 <__wrap_printf> <== NOT EXECUTED
printf (" where:\n");
14b6d5: c7 04 24 43 29 19 00 movl $0x192943,(%esp) <== NOT EXECUTED
14b6dc: e8 2f 07 02 00 call 16be10 <__wrap_puts> <== NOT EXECUTED
printf (" path: Path to the mounted RFS file system\n");
14b6e1: c7 04 24 1c 6e 19 00 movl $0x196e1c,(%esp) <== NOT EXECUTED
14b6e8: e8 23 07 02 00 call 16be10 <__wrap_puts> <== NOT EXECUTED
printf (" command: A debugger command. See -l for a list plus help.\n");
14b6ed: c7 04 24 50 6e 19 00 movl $0x196e50,(%esp) <== NOT EXECUTED
14b6f4: e8 17 07 02 00 call 16be10 <__wrap_puts> <== NOT EXECUTED
printf (" -h: This help\n");
14b6f9: c7 04 24 4d 29 19 00 movl $0x19294d,(%esp) <== NOT EXECUTED
14b700: e8 0b 07 02 00 call 16be10 <__wrap_puts> <== NOT EXECUTED
printf (" -l: The debugger command list.\n");
14b705: c7 04 24 90 6e 19 00 movl $0x196e90,(%esp) <== NOT EXECUTED
14b70c: e8 ff 06 02 00 call 16be10 <__wrap_puts> <== NOT EXECUTED
return 0;
14b711: 31 c0 xor %eax,%eax <== NOT EXECUTED
}
14b713: e9 dc fe ff ff jmp 14b5f4 <rtems_shell_debugrfs+0xe4> <== NOT EXECUTED
14b718: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
14b71f: 90 nop <== NOT EXECUTED
return table[t].handler (fs, argc - 2, argv + 2);
14b720: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
14b723: 8d 14 7f lea (%edi,%edi,2),%edx <== NOT EXECUTED
14b726: 8d 58 08 lea 0x8(%eax),%ebx <== NOT EXECUTED
14b729: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
14b72c: 89 5c 24 08 mov %ebx,0x8(%esp) <== NOT EXECUTED
14b730: 83 e8 02 sub $0x2,%eax <== NOT EXECUTED
14b733: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
14b737: 8b 85 34 ff ff ff mov -0xcc(%ebp),%eax <== NOT EXECUTED
14b73d: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
14b740: ff 54 95 b0 call *-0x50(%ebp,%edx,4) <== NOT EXECUTED
14b744: e9 ab fe ff ff jmp 14b5f4 <rtems_shell_debugrfs+0xe4> <== NOT EXECUTED
printf ("error: path '%s' is not on an RFS file system\n", path);
14b749: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED
14b74d: c7 04 24 20 6f 19 00 movl $0x196f20,(%esp) <== NOT EXECUTED
14b754: e8 87 06 02 00 call 16bde0 <__wrap_printf> <== NOT EXECUTED
return 1;
14b759: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
14b75e: e9 91 fe ff ff jmp 14b5f4 <rtems_shell_debugrfs+0xe4> <== NOT EXECUTED
path, errno, strerror (errno));
14b763: e8 78 54 02 00 call 170be0 <__errno> <== NOT EXECUTED
printf ("error: cannot statvfs path: %s: (%d) %s\n",
14b768: 8b 00 mov (%eax),%eax <== NOT EXECUTED
14b76a: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
14b76d: e8 be c4 02 00 call 177c30 <strerror> <== NOT EXECUTED
14b772: 89 c3 mov %eax,%ebx <== NOT EXECUTED
path, errno, strerror (errno));
14b774: e8 67 54 02 00 call 170be0 <__errno> <== NOT EXECUTED
printf ("error: cannot statvfs path: %s: (%d) %s\n",
14b779: 89 5c 24 0c mov %ebx,0xc(%esp) <== NOT EXECUTED
14b77d: 8b 00 mov (%eax),%eax <== NOT EXECUTED
14b77f: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED
14b783: c7 04 24 f4 6e 19 00 movl $0x196ef4,(%esp) <== NOT EXECUTED
14b78a: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
14b78e: e8 4d 06 02 00 call 16bde0 <__wrap_printf> <== NOT EXECUTED
return 1;
14b793: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
14b798: e9 57 fe ff ff jmp 14b5f4 <rtems_shell_debugrfs+0xe4> <== NOT EXECUTED
14b79d: 90 nop
14b79e: 90 nop
14b79f: 90 nop
0014b7a0 <rtems_shell_rfs_format>:
int
rtems_shell_rfs_format (int argc, char* argv[])
{
14b7a0: 55 push %ebp <== NOT EXECUTED
rtems_rfs_format_config config;
const char* driver = NULL;
int arg;
memset (&config, 0, sizeof (rtems_rfs_format_config));
14b7a1: 31 d2 xor %edx,%edx <== NOT EXECUTED
{
14b7a3: 89 e5 mov %esp,%ebp <== NOT EXECUTED
memset (&config, 0, sizeof (rtems_rfs_format_config));
14b7a5: 31 c0 xor %eax,%eax <== NOT EXECUTED
{
14b7a7: 57 push %edi <== NOT EXECUTED
14b7a8: 56 push %esi <== NOT EXECUTED
14b7a9: 53 push %ebx <== NOT EXECUTED
14b7aa: 83 ec 3c sub $0x3c,%esp <== NOT EXECUTED
14b7ad: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED
memset (&config, 0, sizeof (rtems_rfs_format_config));
14b7b0: 89 54 05 d0 mov %edx,-0x30(%ebp,%eax,1) <== NOT EXECUTED
14b7b4: 89 54 05 d4 mov %edx,-0x2c(%ebp,%eax,1) <== NOT EXECUTED
14b7b8: 83 c0 08 add $0x8,%eax <== NOT EXECUTED
14b7bb: 83 f8 18 cmp $0x18,%eax <== NOT EXECUTED
14b7be: 72 f0 jb 14b7b0 <rtems_shell_rfs_format+0x10> <== NOT EXECUTED
for (arg = 1; arg < argc; arg++)
14b7c0: 83 7d 08 01 cmpl $0x1,0x8(%ebp) <== NOT EXECUTED
14b7c4: 0f 8e a3 01 00 00 jle 14b96d <rtems_shell_rfs_format+0x1cd> <== NOT EXECUTED
14b7ca: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED
const char* driver = NULL;
14b7cf: 31 f6 xor %esi,%esi <== NOT EXECUTED
14b7d1: eb 1d jmp 14b7f0 <rtems_shell_rfs_format+0x50> <== NOT EXECUTED
14b7d3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
14b7da: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
return 1;
}
}
else
{
if (!driver)
14b7e0: 85 f6 test %esi,%esi <== NOT EXECUTED
14b7e2: 0f 85 68 01 00 00 jne 14b950 <rtems_shell_rfs_format+0x1b0> <== NOT EXECUTED
14b7e8: 89 c6 mov %eax,%esi <== NOT EXECUTED
for (arg = 1; arg < argc; arg++)
14b7ea: 43 inc %ebx <== NOT EXECUTED
14b7eb: 39 5d 08 cmp %ebx,0x8(%ebp) <== NOT EXECUTED
14b7ee: 7e 60 jle 14b850 <rtems_shell_rfs_format+0xb0> <== NOT EXECUTED
if (argv[arg][0] == '-')
14b7f0: 8d 0c 9d 00 00 00 00 lea 0x0(,%ebx,4),%ecx <== NOT EXECUTED
14b7f7: 8b 04 0f mov (%edi,%ecx,1),%eax <== NOT EXECUTED
14b7fa: 80 38 2d cmpb $0x2d,(%eax) <== NOT EXECUTED
14b7fd: 75 e1 jne 14b7e0 <rtems_shell_rfs_format+0x40> <== NOT EXECUTED
switch (argv[arg][1])
14b7ff: 0f b6 50 01 movzbl 0x1(%eax),%edx <== NOT EXECUTED
14b803: 80 ea 49 sub $0x49,%dl <== NOT EXECUTED
14b806: 80 fa 2d cmp $0x2d,%dl <== NOT EXECUTED
14b809: 77 15 ja 14b820 <rtems_shell_rfs_format+0x80> <== NOT EXECUTED
14b80b: 0f b6 d2 movzbl %dl,%edx <== NOT EXECUTED
14b80e: ff 24 95 8c 70 19 00 jmp *0x19708c(,%edx,4) <== NOT EXECUTED
14b815: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
14b81c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
printf ("error: invalid option: %s\n", argv[arg]);
14b820: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
14b824: c7 04 24 44 d0 18 00 movl $0x18d044,(%esp) <== NOT EXECUTED
14b82b: e8 b0 05 02 00 call 16bde0 <__wrap_printf> <== NOT EXECUTED
return 1;
14b830: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
driver, strerror (errno));
return 1;
}
return 0;
}
14b835: 83 c4 3c add $0x3c,%esp <== NOT EXECUTED
14b838: 5b pop %ebx <== NOT EXECUTED
14b839: 5e pop %esi <== NOT EXECUTED
14b83a: 5f pop %edi <== NOT EXECUTED
14b83b: 5d pop %ebp <== NOT EXECUTED
14b83c: c3 ret <== NOT EXECUTED
config.verbose = true;
14b83d: c6 45 e5 01 movb $0x1,-0x1b(%ebp) <== NOT EXECUTED
for (arg = 1; arg < argc; arg++)
14b841: 43 inc %ebx <== NOT EXECUTED
14b842: 39 5d 08 cmp %ebx,0x8(%ebp) <== NOT EXECUTED
14b845: 7f a9 jg 14b7f0 <rtems_shell_rfs_format+0x50> <== NOT EXECUTED
14b847: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
14b84e: 66 90 xchg %ax,%ax <== NOT EXECUTED
if (!driver) {
14b850: 85 f6 test %esi,%esi <== NOT EXECUTED
14b852: 0f 84 15 01 00 00 je 14b96d <rtems_shell_rfs_format+0x1cd> <== NOT EXECUTED
if (rtems_rfs_format (driver, &config) < 0)
14b858: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
14b85b: 8d 45 d0 lea -0x30(%ebp),%eax <== NOT EXECUTED
14b85e: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
14b862: e8 39 e9 00 00 call 15a1a0 <rtems_rfs_format> <== NOT EXECUTED
14b867: 89 c2 mov %eax,%edx <== NOT EXECUTED
return 0;
14b869: 31 c0 xor %eax,%eax <== NOT EXECUTED
if (rtems_rfs_format (driver, &config) < 0)
14b86b: 85 d2 test %edx,%edx <== NOT EXECUTED
14b86d: 79 c6 jns 14b835 <rtems_shell_rfs_format+0x95> <== NOT EXECUTED
driver, strerror (errno));
14b86f: e8 6c 53 02 00 call 170be0 <__errno> <== NOT EXECUTED
printf ("error: format of %s failed: %s\n",
14b874: 8b 00 mov (%eax),%eax <== NOT EXECUTED
14b876: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
14b879: e8 b2 c3 02 00 call 177c30 <strerror> <== NOT EXECUTED
14b87e: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED
14b882: c7 04 24 6c 70 19 00 movl $0x19706c,(%esp) <== NOT EXECUTED
14b889: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
14b88d: e8 4e 05 02 00 call 16bde0 <__wrap_printf> <== NOT EXECUTED
return 1;
14b892: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
14b897: eb 9c jmp 14b835 <rtems_shell_rfs_format+0x95> <== NOT EXECUTED
14b899: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
arg++;
14b8a0: 43 inc %ebx <== NOT EXECUTED
if (arg >= argc)
14b8a1: 39 5d 08 cmp %ebx,0x8(%ebp) <== NOT EXECUTED
14b8a4: 0f 8e ef 00 00 00 jle 14b999 <rtems_shell_rfs_format+0x1f9> <== NOT EXECUTED
config.block_size = strtoul (argv[arg], 0, 0);
14b8aa: 31 c0 xor %eax,%eax <== NOT EXECUTED
14b8ac: 31 d2 xor %edx,%edx <== NOT EXECUTED
14b8ae: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
14b8b2: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
14b8b6: 8b 44 0f 04 mov 0x4(%edi,%ecx,1),%eax <== NOT EXECUTED
14b8ba: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
14b8bd: e8 5e e4 02 00 call 179d20 <strtoul> <== NOT EXECUTED
14b8c2: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED
break;
14b8c5: e9 20 ff ff ff jmp 14b7ea <rtems_shell_rfs_format+0x4a> <== NOT EXECUTED
arg++;
14b8ca: 43 inc %ebx <== NOT EXECUTED
if (arg >= argc)
14b8cb: 39 5d 08 cmp %ebx,0x8(%ebp) <== NOT EXECUTED
14b8ce: 0f 8e f1 00 00 00 jle 14b9c5 <rtems_shell_rfs_format+0x225> <== NOT EXECUTED
config.inode_overhead = strtoul (argv[arg], 0, 0);
14b8d4: 31 c0 xor %eax,%eax <== NOT EXECUTED
14b8d6: 31 d2 xor %edx,%edx <== NOT EXECUTED
14b8d8: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
14b8dc: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
14b8e0: 8b 44 0f 04 mov 0x4(%edi,%ecx,1),%eax <== NOT EXECUTED
14b8e4: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
14b8e7: e8 34 e4 02 00 call 179d20 <strtoul> <== NOT EXECUTED
14b8ec: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED
break;
14b8ef: e9 f6 fe ff ff jmp 14b7ea <rtems_shell_rfs_format+0x4a> <== NOT EXECUTED
arg++;
14b8f4: 43 inc %ebx <== NOT EXECUTED
if (arg >= argc)
14b8f5: 39 5d 08 cmp %ebx,0x8(%ebp) <== NOT EXECUTED
14b8f8: 0f 8e b1 00 00 00 jle 14b9af <rtems_shell_rfs_format+0x20f> <== NOT EXECUTED
config.group_inodes = strtoul (argv[arg], 0, 0);
14b8fe: 31 c0 xor %eax,%eax <== NOT EXECUTED
14b900: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
14b904: 31 c0 xor %eax,%eax <== NOT EXECUTED
14b906: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
14b90a: 8b 44 0f 04 mov 0x4(%edi,%ecx,1),%eax <== NOT EXECUTED
14b90e: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
14b911: e8 0a e4 02 00 call 179d20 <strtoul> <== NOT EXECUTED
14b916: 89 45 d8 mov %eax,-0x28(%ebp) <== NOT EXECUTED
break;
14b919: e9 cc fe ff ff jmp 14b7ea <rtems_shell_rfs_format+0x4a> <== NOT EXECUTED
arg++;
14b91e: 43 inc %ebx <== NOT EXECUTED
if (arg >= argc)
14b91f: 39 5d 08 cmp %ebx,0x8(%ebp) <== NOT EXECUTED
14b922: 7e 5f jle 14b983 <rtems_shell_rfs_format+0x1e3> <== NOT EXECUTED
config.group_blocks = strtoul (argv[arg], 0, 0);
14b924: 31 c0 xor %eax,%eax <== NOT EXECUTED
14b926: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
14b92a: 31 c0 xor %eax,%eax <== NOT EXECUTED
14b92c: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
14b930: 8b 44 0f 04 mov 0x4(%edi,%ecx,1),%eax <== NOT EXECUTED
14b934: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
14b937: e8 e4 e3 02 00 call 179d20 <strtoul> <== NOT EXECUTED
14b93c: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED
break;
14b93f: e9 a6 fe ff ff jmp 14b7ea <rtems_shell_rfs_format+0x4a> <== NOT EXECUTED
config.initialise_inodes = true;
14b944: c6 45 e4 01 movb $0x1,-0x1c(%ebp) <== NOT EXECUTED
break;
14b948: e9 9d fe ff ff jmp 14b7ea <rtems_shell_rfs_format+0x4a> <== NOT EXECUTED
14b94d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
printf ("error: only one driver name allowed: %s\n", argv[arg]);
14b950: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
14b954: c7 04 24 8c d0 18 00 movl $0x18d08c,(%esp) <== NOT EXECUTED
14b95b: e8 80 04 02 00 call 16bde0 <__wrap_printf> <== NOT EXECUTED
}
14b960: 83 c4 3c add $0x3c,%esp <== NOT EXECUTED
return 1;
14b963: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
}
14b968: 5b pop %ebx <== NOT EXECUTED
14b969: 5e pop %esi <== NOT EXECUTED
14b96a: 5f pop %edi <== NOT EXECUTED
14b96b: 5d pop %ebp <== NOT EXECUTED
14b96c: c3 ret <== NOT EXECUTED
printf ("error: no driver name provided\n");
14b96d: c7 04 24 4c 70 19 00 movl $0x19704c,(%esp) <== NOT EXECUTED
14b974: e8 97 04 02 00 call 16be10 <__wrap_puts> <== NOT EXECUTED
return 1;
14b979: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
14b97e: e9 b2 fe ff ff jmp 14b835 <rtems_shell_rfs_format+0x95> <== NOT EXECUTED
printf ("error: group block count needs an argument\n");
14b983: c7 04 24 c0 6f 19 00 movl $0x196fc0,(%esp) <== NOT EXECUTED
14b98a: e8 81 04 02 00 call 16be10 <__wrap_puts> <== NOT EXECUTED
return 1;
14b98f: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
14b994: e9 9c fe ff ff jmp 14b835 <rtems_shell_rfs_format+0x95> <== NOT EXECUTED
printf ("error: block size needs an argument\n");
14b999: c7 04 24 9c 6f 19 00 movl $0x196f9c,(%esp) <== NOT EXECUTED
14b9a0: e8 6b 04 02 00 call 16be10 <__wrap_puts> <== NOT EXECUTED
return 1;
14b9a5: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
14b9aa: e9 86 fe ff ff jmp 14b835 <rtems_shell_rfs_format+0x95> <== NOT EXECUTED
printf ("error: group inode count needs an argument\n");
14b9af: c7 04 24 ec 6f 19 00 movl $0x196fec,(%esp) <== NOT EXECUTED
14b9b6: e8 55 04 02 00 call 16be10 <__wrap_puts> <== NOT EXECUTED
return 1;
14b9bb: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
14b9c0: e9 70 fe ff ff jmp 14b835 <rtems_shell_rfs_format+0x95> <== NOT EXECUTED
printf ("error: inode percentage overhead needs an argument\n");
14b9c5: c7 04 24 18 70 19 00 movl $0x197018,(%esp) <== NOT EXECUTED
14b9cc: e8 3f 04 02 00 call 16be10 <__wrap_puts> <== NOT EXECUTED
return 1;
14b9d1: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
14b9d6: e9 5a fe ff ff jmp 14b835 <rtems_shell_rfs_format+0x95> <== NOT EXECUTED
14b9db: 90 nop
14b9dc: 90 nop
14b9dd: 90 nop
14b9de: 90 nop
14b9df: 90 nop