=============================================================================== 00107040 : 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 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 if (rc) 107075: 85 c0 test %eax,%eax 107077: 0f 85 d3 00 00 00 jne 107150 <== 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 <== 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 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 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 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 if (bit == (rtems_rfs_bitmap_element_bits () - 1)) 107103: 83 7d e0 1f cmpl $0x1f,-0x20(%ebp) 107107: 74 27 je 107130 bit++; 107109: ff 45 e0 incl -0x20(%ebp) while (size) 10710c: 85 d2 test %edx,%edx 10710e: 74 c6 je 1070d6 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 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 available = rtems_rfs_bitmap_element_bits (); 107126: be 20 00 00 00 mov $0x20,%esi 10712b: eb b5 jmp 1070e2 10712d: 8d 76 00 lea 0x0(%esi),%esi if (size > 0) 107130: 85 d2 test %edx,%edx 107132: 74 a2 je 1070d6 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 10714d: 8d 76 00 lea 0x0(%esi),%esi if (rc > 0) 107150: 7f 86 jg 1070d8 <== NOT EXECUTED *map = NULL; 107152: 31 c0 xor %eax,%eax <== NOT EXECUTED 107154: e9 2c ff ff ff jmp 107085 <== 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 : 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 106f94: 39 5f 0c cmp %ebx,0xc(%edi) 106f97: 76 47 jbe 106fe0 /* * 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 window, 1); if ((rc > 0) || *allocated) 106faf: 85 c0 test %eax,%eax 106fb1: 7f 7d jg 107030 <== NEVER TAKEN 106fb3: 8b 4d 10 mov 0x10(%ebp),%ecx 106fb6: 80 39 00 cmpb $0x0,(%ecx) 106fb9: 75 75 jne 107030 break; } if (lower_seed >= 0) 106fbb: 85 f6 test %esi,%esi 106fbd: 8b 55 14 mov 0x14(%ebp),%edx 106fc0: 79 2d jns 106fef /* * 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 <== 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 <== 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 106fe4: 8b 47 0c mov 0xc(%edi),%eax 106fe7: 39 f0 cmp %esi,%eax 106fe9: 76 45 jbe 107030 <== NEVER TAKEN if (upper_seed < control->size) 106feb: 39 c3 cmp %eax,%ebx 106fed: 72 aa jb 106f99 <== 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 if ((rc > 0) || *allocated) 107005: 85 c0 test %eax,%eax 107007: 7f 27 jg 107030 <== 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 if (upper_seed < control->size) 107014: 3b 5f 0c cmp 0xc(%edi),%ebx 107017: 73 06 jae 10701f 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 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 : { 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 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 if (rc) 10693b: 85 c0 test %eax,%eax 10693d: 75 61 jne 1069a0 <== 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 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 <== 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 <== 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 <== 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 <== 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 : { 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 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 <== NOT EXECUTED if (rc) 106cf5: 85 c0 test %eax,%eax 106cf7: 0f 85 f3 01 00 00 jne 106ef0 <== 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 <== ALWAYS TAKEN 106d2a: f6 c2 04 test $0x4,%dl <== NOT EXECUTED 106d2d: 0f 85 bd 00 00 00 jne 106df0 <== NOT EXECUTED 106d33: f6 c2 02 test $0x2,%dl 106d36: 0f 85 94 00 00 00 jne 106dd0 <== NEVER TAKEN 106d3c: f6 c2 01 test $0x1,%dl 106d3f: 90 nop 106d40: 75 6e jne 106db0 <== 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 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 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 106d6c: f6 c2 04 test $0x4,%dl 106d6f: 0f 85 cb 00 00 00 jne 106e40 <== ALWAYS TAKEN 106d75: f6 c2 02 test $0x2,%dl 106d78: 0f 85 a2 00 00 00 jne 106e20 <== NEVER TAKEN 106d7e: f6 c2 01 test $0x1,%dl 106d81: 0f 85 89 00 00 00 jne 106e10 <== 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 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 <== NOT EXECUTED 106dc0: eb de jmp 106da0 <== 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 <== NOT EXECUTED 106de1: eb cd jmp 106db0 <== 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 <== NOT EXECUTED 106e02: eb cc jmp 106dd0 <== 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 <== 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 <== NOT EXECUTED 106e31: eb dd jmp 106e10 <== 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 <== ALWAYS TAKEN 106e52: eb cc jmp 106e20 <== 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 <== NEVER TAKEN 106e6c: f7 c7 02 00 00 00 test $0x2,%edi 106e72: 0f 85 cc 00 00 00 jne 106f44 <== NEVER TAKEN 106e78: f7 c7 04 00 00 00 test $0x4,%edi 106e7e: 0f 85 d0 00 00 00 jne 106f54 <== 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 <== ALWAYS TAKEN 106e9c: e9 4f ff ff ff jmp 106df0 <== 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 <== NEVER TAKEN 106eb5: f7 c7 02 00 00 00 test $0x2,%edi 106ebb: 75 77 jne 106f34 <== NEVER TAKEN 106ebd: f7 c7 04 00 00 00 test $0x4,%edi 106ec3: 75 58 jne 106f1d <== 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 <== ALWAYS TAKEN 106edd: e9 5e ff ff ff jmp 106e40 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== NOT EXECUTED 106f6f: 90 nop =============================================================================== 00106800 : { 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 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 if (rc) 10683b: 85 c0 test %eax,%eax 10683d: 75 61 jne 1068a0 <== 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 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 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 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 <== 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 <== 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 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 : { 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 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 if (rc) 106ac5: 85 c0 test %eax,%eax 106ac7: 0f 85 73 01 00 00 jne 106c40 <== 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 <== ALWAYS TAKEN 106af6: f6 c2 04 test $0x4,%dl <== NOT EXECUTED 106af9: 0f 85 a1 00 00 00 jne 106ba0 <== NOT EXECUTED 106aff: f6 c2 02 test $0x2,%dl 106b02: 75 7c jne 106b80 <== NEVER TAKEN 106b04: f6 c2 01 test $0x1,%dl 106b07: 75 67 jne 106b70 <== 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 106b22: f6 c2 04 test $0x4,%dl 106b25: 75 39 jne 106b60 <== ALWAYS TAKEN 106b27: f6 c2 02 test $0x2,%dl 106b2a: 75 24 jne 106b50 <== NEVER TAKEN 106b2c: f6 c2 01 test $0x1,%dl 106b2f: 90 nop 106b30: 75 0e jne 106b40 <== 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 <== 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 <== NOT EXECUTED 106b5d: eb e1 jmp 106b40 <== 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 <== ALWAYS TAKEN 106b6e: eb e0 jmp 106b50 <== NOT EXECUTED map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET; 106b70: c6 07 00 movb $0x0,(%edi) <== NOT EXECUTED 106b73: eb 94 jmp 106b09 <== 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 <== NOT EXECUTED 106b91: eb dd jmp 106b70 <== 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 <== NOT EXECUTED 106bb2: eb cc jmp 106b80 <== 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 <== NEVER TAKEN 106bcc: f7 c7 02 00 00 00 test $0x2,%edi 106bd2: 0f 85 a2 00 00 00 jne 106c7a <== NEVER TAKEN 106bd8: f7 c7 04 00 00 00 test $0x4,%edi 106bde: 0f 85 a6 00 00 00 jne 106c8a <== 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 <== ALWAYS TAKEN 106bf9: e9 62 ff ff ff jmp 106b60 <== 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 <== NEVER TAKEN 106c0c: f7 c7 02 00 00 00 test $0x2,%edi 106c12: 75 59 jne 106c6d <== NEVER TAKEN 106c14: f7 c7 04 00 00 00 test $0x4,%edi 106c1a: 0f 85 85 00 00 00 jne 106ca5 <== 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 <== ALWAYS TAKEN 106c35: e9 66 ff ff ff jmp 106ba0 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== NOT EXECUTED =============================================================================== 001069f0 : { 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 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 if (rc) 106a21: 85 c0 test %eax,%eax 106a23: 75 3b jne 106a60 <== 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 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 <== 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 <== 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 : { 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 115a66: 8b 43 04 mov 0x4(%ebx),%eax 115a69: 85 c0 test %eax,%eax 115a6b: 74 12 je 115a7f <== 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 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 <== 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 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 } 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_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 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 115bea: 90 nop 115beb: 90 nop 115bec: 90 nop 115bed: 90 nop 115bee: 90 nop 115bef: 90 nop =============================================================================== 00115bf0 : { 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 115c17: 85 c9 test %ecx,%ecx 115c19: 0f 84 d1 00 00 00 je 115cf0 <== NEVER TAKEN 115c1f: 39 c8 cmp %ecx,%eax 115c21: 0f 83 c9 00 00 00 jae 115cf0 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 if (map->size.count <= RTEMS_RFS_INODE_BLOCKS) 115c30: 83 f9 05 cmp $0x5,%ecx 115c33: 77 2b ja 115c60 *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 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 <== 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 if (rc == 0) 115cb1: 85 c0 test %eax,%eax 115cb3: 75 9e jne 115c53 <== 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 115ccd: eb 5a jmp 115d29 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 *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 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 if (rc == 0) 115d29: 85 c0 test %eax,%eax 115d2b: 0f 84 0a ff ff ff je 115c3b <== ALWAYS TAKEN 115d31: e9 1d ff ff ff jmp 115c53 <== 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 : { 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 115e21: 84 c0 test %al,%al 115e23: 0f 85 27 03 00 00 jne 116150 <== 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 <== 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 <== 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 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 <== 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 <== 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 <== NOT EXECUTED if (rc > 0) 115ea4: 85 c0 test %eax,%eax 115ea6: 0f 8f f4 02 00 00 jg 1161a0 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 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 if ((direct == 0) || 115ed2: 85 d2 test %edx,%edx 115ed4: 74 12 je 115ee8 115ed6: 3b 4d d4 cmp -0x2c(%ebp),%ecx 115ed9: 0f 83 01 02 00 00 jae 1160e0 115edf: 83 fa 05 cmp $0x5,%edx 115ee2: 0f 85 f8 01 00 00 jne 1160e0 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 if (rc > 0) 115f0a: 85 c0 test %eax,%eax 115f0c: 0f 8f 9d 01 00 00 jg 1160af <== 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 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 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 if (rc > 0) 115f91: 85 c0 test %eax,%eax 115f93: 0f 8f 16 01 00 00 jg 1160af <== NEVER TAKEN if ((singly == 0) || 115f99: 8b 45 c8 mov -0x38(%ebp),%eax 115f9c: 85 c0 test %eax,%eax 115f9e: 74 15 je 115fb5 <== 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 <== NEVER TAKEN 115fac: 83 f8 05 cmp $0x5,%eax 115faf: 0f 85 4b 01 00 00 jne 116100 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 if (rc > 0) 115fdb: 85 c0 test %eax,%eax 115fdd: 0f 8f 48 01 00 00 jg 11612b <== 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 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 if (rc > 0) 116053: 85 c0 test %eax,%eax 116055: 7f 58 jg 1160af <== 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 if (rc > 0) 1160a7: 85 c0 test %eax,%eax 1160a9: 0f 8e 63 fe ff ff jle 115f12 <== 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 <== 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 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 if (rc > 0) 116123: 85 c0 test %eax,%eax 116125: 0f 8e b8 fe ff ff jle 115fe3 <== 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 <== NOT EXECUTED rtems_rfs_group_bitmap_free (fs, false, block); 116143: e9 6a ff ff ff jmp 1160b2 <== 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 <== 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 : { 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 <== NOT EXECUTED if (rc > 0) 11598f: 85 c0 test %eax,%eax 115991: 7f 5d jg 1159f0 <== 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 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 <== 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 <== 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 <== 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 : 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 1161d1: 84 c0 test %al,%al 1161d3: 0f 85 77 02 00 00 jne 116450 <== 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 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 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 <== 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 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 if (rc > 0) 11622f: 85 c0 test %eax,%eax 116231: 0f 8f 45 01 00 00 jg 11637c <== 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 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 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 <== 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 <== 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 <== NOT EXECUTED if (rc > 0) 1162b3: 85 c0 test %eax,%eax <== NOT EXECUTED 1162b5: 0f 8f c1 00 00 00 jg 11637c <== 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 <== NOT EXECUTED if (rc > 0) 116305: 85 c0 test %eax,%eax <== NOT EXECUTED 116307: 7f 73 jg 11637c <== 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 <== 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 <== NOT EXECUTED if (rc > 0) 116351: 85 c0 test %eax,%eax <== NOT EXECUTED 116353: 7f 27 jg 11637c <== 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 if (rc) 116374: 85 c0 test %eax,%eax 116376: 0f 84 a1 fe ff ff je 11621d <== 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 if (rc > 0) 1163b0: 85 c0 test %eax,%eax 1163b2: 7f c8 jg 11637c <== 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 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 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 <== 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 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 <== 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 <== NEVER TAKEN 116477: 8d 51 ff lea -0x1(%ecx),%edx 11647a: 39 d0 cmp %edx,%eax 11647c: 75 b2 jne 116430 <== NEVER TAKEN 11647e: 8b 47 0c mov 0xc(%edi),%eax 116481: 39 47 14 cmp %eax,0x14(%edi) 116484: 77 8f ja 116415 <== ALWAYS TAKEN return 0; 116486: 31 c0 xor %eax,%eax 116488: eb a8 jmp 116432 <== 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 <== NOT EXECUTED 11648f: 90 nop =============================================================================== 00116520 : 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 116541: 84 c0 test %al,%al 116543: 74 27 je 11656c <== 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 <== 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 sc = rtems_bdbuf_release_modified (buffer); 116573: e8 a8 cb ff ff call 113120 #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 116595: eb e1 jmp 116578 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 <== 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 : { 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 107d5d: 84 c0 test %al,%al 107d5f: 0f 85 db 00 00 00 jne 107e40 <== 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 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 <== 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 107d88: 85 c0 test %eax,%eax 107d8a: 78 64 js 107df0 <== 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 <== NOT EXECUTED 107db2: 84 c0 test %al,%al <== NOT EXECUTED 107db4: 74 c7 je 107d7d <== 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 <== 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 <== NOT EXECUTED 107ddd: 85 c0 test %eax,%eax <== NOT EXECUTED 107ddf: 79 ab jns 107d8c <== 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 <== NOT EXECUTED 107e09: 84 c0 test %al,%al <== NOT EXECUTED 107e0b: 0f 84 7b ff ff ff je 107d8c <== 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 <== 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 <== 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 <== 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 (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 1073df: 84 c0 test %al,%al 1073e1: 74 40 je 107423 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 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 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_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 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 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 if (rtems_rfs_buffer_dirty (handle)) 10745c: 80 3f 00 cmpb $0x0,(%edi) 10745f: 74 6f je 1074d0 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 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 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 1074c3: eb db jmp 1074a0 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 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 107506: 89 c6 mov %eax,%esi 107508: e9 75 ff ff ff jmp 107482 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 107522: 84 c0 test %al,%al 107524: 0f 85 86 00 00 00 jne 1075b0 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 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 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 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 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 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 return NULL; 10759b: 31 c0 xor %eax,%eax 10759d: eb af jmp 10754e 10759f: 31 c0 xor %eax,%eax 1075a1: eb d2 jmp 107575 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 1075cd: 90 nop 1075ce: 90 nop 1075cf: 90 nop =============================================================================== 001075d0 : { 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 if (block && (rtems_rfs_buffer_bnum (handle) == block)) 1075f0: 85 ff test %edi,%edi 1075f2: 74 09 je 1075fd <== NEVER TAKEN 1075f4: 39 7b 04 cmp %edi,0x4(%ebx) 1075f7: 0f 84 dd 00 00 00 je 1076da 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 10760f: 84 c0 test %al,%al 107611: 0f 85 89 01 00 00 jne 1077a0 <== 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 <== NEVER TAKEN 10761e: 89 da mov %ebx,%edx 107620: 89 f0 mov %esi,%eax 107622: e8 99 fd ff ff call 1073c0 if (rc > 0) 107627: 85 c0 test %eax,%eax 107629: 89 c2 mov %eax,%edx 10762b: 0f 8f ab 00 00 00 jg 1076dc <== 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 10764d: 84 c0 test %al,%al 10764f: 0f 85 2b 01 00 00 jne 107780 <== 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 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 10766c: 85 c0 test %eax,%eax 10766e: 0f 84 75 01 00 00 je 1077e9 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 1076a2: 84 c0 test %al,%al 1076a4: 74 34 je 1076da <== 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 <== 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 <== 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 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 <== 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 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 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_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 if (rtems_rfs_buffer_handle_has_block (handle) && 10775a: 84 c0 test %al,%al 10775c: 0f 84 fe fe ff ff je 107660 <== 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 <== 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 <== NOT EXECUTED 10779b: eb 93 jmp 107730 <== 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 <== NOT EXECUTED 1077be: e9 6e fe ff ff jmp 107631 <== 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 <== 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 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 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 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 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_mark_dirty (handle); 107817: c6 03 01 movb $0x1,(%ebx) 10781a: e9 55 fe ff ff jmp 107674 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 <== 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 <== 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 <== 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 <== 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 <== 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 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 1078a8: e9 47 ff ff ff jmp 1077f4 1078ad: 90 nop 1078ae: 90 nop 1078af: 90 nop =============================================================================== 001078e0 : { 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 107900: 84 c0 test %al,%al 107902: 0f 85 c8 00 00 00 jne 1079d0 <== 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 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 <== 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 107933: 85 c0 test %eax,%eax 107935: 0f 88 65 01 00 00 js 107aa0 <== 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 <== 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 if (rv != 0) 107965: 85 c0 test %eax,%eax 107967: 89 c6 mov %eax,%esi 107969: 0f 85 01 01 00 00 jne 107a70 <== 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 107981: 84 c0 test %al,%al 107983: 0f 85 b7 00 00 00 jne 107a40 <== 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 <== NOT EXECUTED 1079b2: 84 c0 test %al,%al <== NOT EXECUTED 1079b4: 75 3a jne 1079f0 <== 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 <== 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 <== 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 <== NOT EXECUTED 107a22: 84 c0 test %al,%al <== NOT EXECUTED 107a24: 74 90 je 1079b6 <== 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 <== 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 <== NOT EXECUTED 107a82: 84 c0 test %al,%al <== NOT EXECUTED 107a84: 0f 84 2c ff ff ff je 1079b6 <== 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 <== 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 <== NOT EXECUTED 107ab2: 84 c0 test %al,%al <== NOT EXECUTED 107ab4: 0f 84 fc fe ff ff je 1079b6 <== 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 <== 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 <== 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 : { 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 107c3d: 84 c0 test %al,%al 107c3f: 0f 85 cb 00 00 00 jne 107d10 <== NEVER TAKEN rc = rtems_rfs_buffers_release (fs); 107c45: 89 34 24 mov %esi,(%esp) 107c48: e8 43 ff ff ff call 107b90 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 <== NEVER TAKEN rc = rtems_rfs_buffer_sync (fs); 107c53: 89 34 24 mov %esi,(%esp) 107c56: e8 95 fe ff ff call 107af0 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 <== 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 <== 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 <== NOT EXECUTED 107ca2: 84 c0 test %al,%al <== NOT EXECUTED 107ca4: 74 ad je 107c53 <== 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 <== 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 <== 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 <== 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 <== NOT EXECUTED 107ce2: 84 c0 test %al,%al <== NOT EXECUTED 107ce4: 0f 84 77 ff ff ff je 107c61 <== 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 <== 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 <== 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 <== 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 : { 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 107b0e: 84 c0 test %al,%al 107b10: 75 2e jne 107b40 <== 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 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 <== 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 <== 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 <== NOT EXECUTED 107b67: 84 c0 test %al,%al <== NOT EXECUTED 107b69: 74 bd je 107b28 <== 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 <== 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 : 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 107bad: 84 c0 test %al,%al 107baf: 75 3f jne 107bf0 <== 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 &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 &fs->release_modified_count, true); if ((rc > 0) && (rrc == 0)) 107bd0: 85 c0 test %eax,%eax 107bd2: 7e 0c jle 107be0 <== ALWAYS TAKEN 107bd4: 85 f6 test %esi,%esi <== NOT EXECUTED 107bd6: 7f 08 jg 107be0 <== 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 <== 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_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 116bce: 84 c0 test %al,%al 116bd0: 0f 85 3a 03 00 00 jne 116f10 <== 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 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 <== 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 if (rc > 0) 116c4f: 85 c0 test %eax,%eax 116c51: 0f 8e 19 03 00 00 jle 116f70 if (rc != ENXIO) 116c57: 83 f8 06 cmp $0x6,%eax 116c5a: 0f 85 07 04 00 00 jne 117067 <== 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 if (rc > 0) 116c85: 85 c0 test %eax,%eax 116c87: 0f 8f 21 04 00 00 jg 1170ae <== 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 if (rc > 0) 116cb2: 85 c0 test %eax,%eax 116cb4: 7e 6a jle 116d20 <== 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 <== NOT EXECUTED 116cca: 84 c0 test %al,%al <== NOT EXECUTED 116ccc: 0f 85 5e 04 00 00 jne 117130 <== 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 <== 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 <== 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 <== ALWAYS TAKEN 116d37: f6 c3 04 test $0x4,%bl <== NOT EXECUTED 116d3a: 0f 85 a0 02 00 00 jne 116fe0 <== NOT EXECUTED 116d40: f6 c3 02 test $0x2,%bl 116d43: 0f 85 77 02 00 00 jne 116fc0 <== NEVER TAKEN 116d49: f6 c3 01 test $0x1,%bl 116d4c: 0f 85 5e 02 00 00 jne 116fb0 <== 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 <== 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 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 <== NEVER TAKEN 116d99: 39 59 1c cmp %ebx,0x1c(%ecx) 116d9c: 0f 86 fe 00 00 00 jbe 116ea0 <== NEVER TAKEN 116da2: 85 f6 test %esi,%esi 116da4: 0f 84 f6 00 00 00 je 116ea0 <== 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 <== 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 <== 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_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 <== 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_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 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_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 return 0; 116e91: e9 72 fe ff ff jmp 116d08 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 <== NOT EXECUTED 116eb2: 84 c0 test %al,%al <== NOT EXECUTED 116eb4: 0f 85 86 01 00 00 jne 117040 <== 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 <== 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 <== 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 <== 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 <== NOT EXECUTED for (c = 0; c < length; c++) 116f4c: 39 de cmp %ebx,%esi <== NOT EXECUTED 116f4e: 75 f0 jne 116f40 <== 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 <== 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 if (rc > 0) 116f98: 85 c0 test %eax,%eax 116f9a: 0f 8f 16 fd ff ff jg 116cb6 <== 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 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 <== 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 <== NOT EXECUTED 116fd1: eb dd jmp 116fb0 <== 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 <== NOT EXECUTED 116ff2: eb cc jmp 116fc0 <== 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 <== NEVER TAKEN 117009: f7 c7 02 00 00 00 test $0x2,%edi 11700f: 90 nop 117010: 0f 85 f0 00 00 00 jne 117106 <== NEVER TAKEN 117016: f7 c7 04 00 00 00 test $0x4,%edi 11701c: 0f 85 d3 00 00 00 jne 1170f5 <== 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 <== ALWAYS TAKEN 11703a: eb a4 jmp 116fe0 <== 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 <== 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 <== NOT EXECUTED 11707b: 84 c0 test %al,%al <== NOT EXECUTED 11707d: 0f 84 4f fc ff ff je 116cd2 <== 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 <== 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 <== 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 <== NOT EXECUTED 1170c2: 84 c0 test %al,%al <== NOT EXECUTED 1170c4: 0f 84 08 fc ff ff je 116cd2 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 117163: f7 c7 02 00 00 00 test $0x2,%edi 117169: 75 2b jne 117196 11716b: f7 c7 04 00 00 00 test $0x4,%edi 117171: 0f 84 dc fc ff ff je 116e53 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 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 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 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 : 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 1171ce: 84 c0 test %al,%al 1171d0: 0f 85 0a 02 00 00 jne 1173e0 <== 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 1171ef: 89 45 84 mov %eax,-0x7c(%ebp) if (rc > 0) 1171f2: 85 c0 test %eax,%eax 1171f4: 7e 1a jle 117210 <== 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 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 <== 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 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 <== 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 <== 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 <== ALWAYS TAKEN 1172b6: eb 68 jmp 117320 <== 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 <== 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 <== NEVER TAKEN 1172d6: 85 db test %ebx,%ebx 1172d8: 0f 84 92 00 00 00 je 117370 <== NEVER TAKEN 1172de: 39 59 14 cmp %ebx,0x14(%ecx) 1172e1: 0f 82 89 00 00 00 jb 117370 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== NOT EXECUTED 117357: eb 3a jmp 117393 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 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 1174a0: f7 c7 02 00 00 00 test $0x2,%edi 1174a6: 0f 85 fa 01 00 00 jne 1176a6 1174ac: f7 c7 04 00 00 00 test $0x4,%edi 1174b2: 0f 85 dc 01 00 00 jne 117694 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 <== 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 <== 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 117502: 8b 55 84 mov -0x7c(%ebp),%edx 117505: 84 c0 test %al,%al 117507: 74 43 je 11754c <== 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 <== 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 117554: 85 d2 test %edx,%edx 117556: 75 6d jne 1175c5 <== 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 <== 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 <== 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 <== 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 <== NOT EXECUTED 11759b: 84 c0 test %al,%al <== NOT EXECUTED 11759d: 74 26 je 1175c5 <== 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 <== 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_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 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 <== NOT EXECUTED 117619: e9 4a ff ff ff jmp 117568 <== 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 <== 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 <== 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 <== 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 <== NOT EXECUTED 11765e: 84 c0 test %al,%al <== NOT EXECUTED 117660: 0f 84 2d fd ff ff je 117393 <== 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 <== 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 <== 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 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 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 rc = ENOENT; 1176c3: c7 45 84 02 00 00 00 movl $0x2,-0x7c(%ebp) <== NOT EXECUTED 1176ca: e9 c4 fc ff ff jmp 117393 <== NOT EXECUTED 1176cf: 90 nop =============================================================================== 00117c80 : 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 117c9e: 8b 55 08 mov 0x8(%ebp),%edx 117ca1: 84 c0 test %al,%al 117ca3: 0f 85 17 02 00 00 jne 117ec0 <== 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 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 <== 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 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 <== 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 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 <== 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 <== NEVER TAKEN offset = 0; 117d64: 89 4d 84 mov %ecx,-0x7c(%ebp) 117d67: 31 ff xor %edi,%edi 117d69: eb 23 jmp 117d8e 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 ((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 2)) || 117d75: 80 78 0a 2e cmpb $0x2e,0xa(%eax) 117d79: 75 57 jne 117dd2 <== NEVER TAKEN (entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.') || 117d7b: 80 78 0b 2e cmpb $0x2e,0xb(%eax) 117d7f: 75 51 jne 117dd2 <== 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 <== 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 if (rtems_rfs_dir_entry_valid (fs, elength, eino)) 117db1: 83 fb 0a cmp $0xa,%ebx 117db4: 7e 7a jle 117e30 <== NEVER TAKEN 117db6: 39 5a 1c cmp %ebx,0x1c(%edx) 117db9: 76 75 jbe 117e30 <== NEVER TAKEN 117dbb: 85 f6 test %esi,%esi 117dbd: 8d 76 00 lea 0x0(%esi),%esi 117dc0: 74 6e je 117e30 <== NEVER TAKEN 117dc2: 39 72 14 cmp %esi,0x14(%edx) 117dc5: 72 69 jb 117e30 <== NEVER TAKEN if (((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 1)) || 117dc7: 83 fb 0b cmp $0xb,%ebx 117dca: 75 a4 jne 117d70 117dcc: 80 78 0a 2e cmpb $0x2e,0xa(%eax) 117dd0: 74 af je 117d81 <== 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 <== 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_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 } 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 <== 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 <== 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 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 <== NEVER TAKEN if (rc == ENXIO) 117e9e: 83 f8 06 cmp $0x6,%eax 117ea1: 0f 85 39 ff ff ff jne 117de0 <== NEVER TAKEN rc = 0; 117ea7: c7 45 80 00 00 00 00 movl $0x0,-0x80(%ebp) 117eae: e9 2d ff ff ff jmp 117de0 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 <== 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 <== 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 : */ #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 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 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 <== 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 while (length > 12) 118049: 83 7d 0c 0c cmpl $0xc,0xc(%ebp) 11804d: 76 7c jbe 1180cb 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 <== 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 <== 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 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_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 1165d4: 84 c0 test %al,%al 1165d6: 0f 85 f5 03 00 00 jne 1169d1 <== 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 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 <== 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 /* * 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 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 <== 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 <== 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 <== 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 11668d: 84 c0 test %al,%al 11668f: 0f 85 2b 02 00 00 jne 1168c0 <== 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 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 <== 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 <== NEVER TAKEN 1166d6: 8b 55 18 mov 0x18(%ebp),%edx 1166d9: eb 1d jmp 1166f8 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 <== 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 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 <== NEVER TAKEN 116729: 39 5e 1c cmp %ebx,0x1c(%esi) 11672c: 0f 86 de 00 00 00 jbe 116810 <== NEVER TAKEN 116732: 85 c0 test %eax,%eax 116734: 0f 84 d6 00 00 00 je 116810 <== 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 <== NEVER TAKEN if (ehash == hash) 116746: 39 4d 84 cmp %ecx,-0x7c(%ebp) 116749: 75 95 jne 1166e0 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 116760: 8b 55 18 mov 0x18(%ebp),%edx 116763: 84 c0 test %al,%al 116765: 0f 85 15 01 00 00 jne 116880 <== 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 116787: 8b 55 18 mov 0x18(%ebp),%edx 11678a: 85 c0 test %eax,%eax 11678c: 0f 85 4e ff ff ff jne 1166e0 <== 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 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 1167bc: 84 c0 test %al,%al 1167be: 0f 85 c1 03 00 00 jne 116b85 <== 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_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 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 <== NOT EXECUTED 116826: 84 c0 test %al,%al <== NOT EXECUTED 116828: 0f 85 12 01 00 00 jne 116940 <== 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_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 <== 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 <== 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 <== 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 <== ALWAYS TAKEN 1168f7: 89 f7 mov %esi,%edi <== NOT EXECUTED 1168f9: e9 37 ff ff ff jmp 116835 <== 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 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 <== NEVER TAKEN 116921: 83 f8 06 cmp $0x6,%eax 116924: 0f 85 31 01 00 00 jne 116a5b <== NEVER TAKEN rc = ENOENT; 11692a: 89 f7 mov %esi,%edi 11692c: e9 1e 01 00 00 jmp 116a4f 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 <== 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 <== NOT EXECUTED 116992: 84 c0 test %al,%al <== NOT EXECUTED 116994: 0f 84 cb fe ff ff je 116865 <== 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 <== 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 <== 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 <== NOT EXECUTED for (c = 0; c < length; c++) 116a0c: 39 f3 cmp %esi,%ebx <== NOT EXECUTED 116a0e: 75 f0 jne 116a00 <== 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 <== 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 <== NOT EXECUTED 116a3d: 84 c0 test %al,%al <== NOT EXECUTED 116a3f: 0f 85 1c 01 00 00 jne 116b61 <== 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 <== NOT EXECUTED rc = ENOENT; 116a4f: c7 45 80 02 00 00 00 movl $0x2,-0x80(%ebp) 116a56: e9 da fd ff ff jmp 116835 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 <== NOT EXECUTED 116a6d: 84 c0 test %al,%al <== NOT EXECUTED 116a6f: 0f 84 f0 fb ff ff je 116665 <== 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 <== 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 <== 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 <== NOT EXECUTED rc = ENOENT; 116aad: 89 f7 mov %esi,%edi <== NOT EXECUTED 116aaf: 90 nop <== NOT EXECUTED 116ab0: eb 9d jmp 116a4f <== 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 <== NOT EXECUTED 116ad4: 84 c0 test %al,%al <== NOT EXECUTED 116ad6: 0f 84 52 fd ff ff je 11682e <== 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 <== 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 <== 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 <== NOT EXECUTED 116b24: 84 c0 test %al,%al <== NOT EXECUTED 116b26: 0f 84 09 fd ff ff je 116835 <== 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 <== 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 <== 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 <== 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 <== 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 <== NOT EXECUTED 116baf: 90 nop =============================================================================== 001176d0 : 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 117706: 84 c0 test %al,%al 117708: 0f 85 42 02 00 00 jne 117950 <== 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 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 <== 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 <== 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 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 <== 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 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 if (rc == ENXIO) 117846: 83 f8 06 cmp $0x6,%eax 117849: 0f 84 71 03 00 00 je 117bc0 <== ALWAYS TAKEN while (rc == 0) 11784f: 85 c0 test %eax,%eax <== NOT EXECUTED 117851: 0f 85 a9 00 00 00 jne 117900 <== 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 if (rc > 0) 117876: 85 c0 test %eax,%eax 117878: 0f 8f 82 00 00 00 jg 117900 <== 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 *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 1178c4: 84 c0 test %al,%al 1178c6: 0f 84 64 ff ff ff je 117830 <== 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 <== 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 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 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 <== 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 <== 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 <== 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 <== NEVER TAKEN 1179a4: 39 4e 1c cmp %ecx,0x1c(%esi) 1179a7: 0f 86 b3 01 00 00 jbe 117b60 <== NEVER TAKEN 1179ad: 85 c0 test %eax,%eax 1179af: 0f 84 ab 01 00 00 je 117b60 <== NEVER TAKEN 1179b5: 39 46 14 cmp %eax,0x14(%esi) 1179b8: 0f 82 a2 01 00 00 jb 117b60 <== 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 <== NEVER TAKEN 1179d6: a8 02 test $0x2,%al 1179d8: 0f 85 6f 02 00 00 jne 117c4d <== 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 117a01: 01 d0 add %edx,%eax 117a03: f6 85 70 ff ff ff 04 testb $0x4,-0x90(%ebp) 117a0a: 74 09 je 117a15 <== 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 <== 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 <== 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 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 <== 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 <== 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 117ac3: 31 d2 xor %edx,%edx 117ac5: f7 c7 02 00 00 00 test $0x2,%edi 117acb: 74 0b je 117ad8 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 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 117b18: 84 c0 test %al,%al 117b1a: 0f 84 e2 fd ff ff je 117902 <== 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 <== 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 <== NOT EXECUTED 117b77: 84 c0 test %al,%al <== NOT EXECUTED 117b79: 0f 84 83 fd ff ff je 117902 <== 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 <== 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 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 <== NEVER TAKEN 117bd2: f6 c1 02 test $0x2,%cl 117bd5: 75 3c jne 117c13 <== ALWAYS TAKEN 117bd7: 83 ff 04 cmp $0x4,%edi 117bda: 0f 82 e3 fe ff ff jb 117ac3 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 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 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 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 <== 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 <== 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 <== 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 : { 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 1186c1: 84 c0 test %al,%al 1186c3: 0f 85 b7 01 00 00 jne 118880 <== 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 <== 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 <== 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 <== NOT EXECUTED free (handle); 1186f2: 89 1c 24 mov %ebx,(%esp) 1186f5: e8 e6 9d fe ff call 1024e0 } 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 <== 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 <== 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 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 <== 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 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 <== 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 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 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 <== 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 <== NOT EXECUTED 118855: 84 c0 test %al,%al <== NOT EXECUTED 118857: 0f 84 95 fe ff ff je 1186f2 <== 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 <== 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 <== 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 <== 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 <== NOT EXECUTED 1188b5: 84 c0 test %al,%al <== NOT EXECUTED 1188b7: 0f 85 e3 00 00 00 jne 1189a0 <== 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 <== 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 <== 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 <== 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 <== 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 <== NOT EXECUTED 118925: 84 c0 test %al,%al <== NOT EXECUTED 118927: 75 47 jne 118970 <== NOT EXECUTED if (rrc == 0) 118929: 85 f6 test %esi,%esi <== NOT EXECUTED 11892b: 0f 85 af fe ff ff jne 1187e0 <== NOT EXECUTED 118931: 89 fe mov %edi,%esi <== NOT EXECUTED 118933: e9 a8 fe ff ff jmp 1187e0 <== 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 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== NEVER TAKEN 1189d9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 1189e0: e9 df fd ff ff jmp 1187c4 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 1189fb: 90 nop 1189fc: 90 nop 1189fd: 90 nop 1189fe: 90 nop 1189ff: 90 nop =============================================================================== 00119640 : { 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 119653: eb 1b jmp 119670 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 <== NOT EXECUTED if (shared->inode.ino == ino) 119666: 39 48 14 cmp %ecx,0x14(%eax) 119669: 75 f5 jne 119660 <== 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 : { 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 118cd8: 84 c0 test %al,%al 118cda: 74 21 je 118cfd <== 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 <== 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 <== 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_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 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 <== 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 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 <== 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_block_map_past_end (rtems_rfs_file_map (handle), 118d71: 85 d2 test %edx,%edx 118d73: 0f 85 97 01 00 00 jne 118f10 <== 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 <== 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 118dce: 84 c0 test %al,%al 118dd0: 0f 84 6c 02 00 00 je 119042 <== 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 <== 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_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 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 <== 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 <== 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 118edf: 84 c0 test %al,%al 118ee1: 0f 85 b9 00 00 00 jne 118fa0 <== 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 <== 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 <== 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 118f18: 4a dec %edx 118f19: 39 d1 cmp %edx,%ecx 118f1b: 0f 85 7a ff ff ff jne 118e9b 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 118f2d: e9 4a fe ff ff jmp 118d7c 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 <== NOT EXECUTED 118f62: e9 ec fd ff ff jmp 118d53 <== 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