=============================================================================== 0010e920 <_fat_block_read>: uint32_t start, uint32_t offset, uint32_t count, void *buff ) { 10e920: 55 push %ebp 10e921: 89 e5 mov %esp,%ebp 10e923: 57 push %edi 10e924: 56 push %esi 10e925: 53 push %ebx 10e926: 83 ec 2c sub $0x2c,%esp uint32_t sec_num = start; uint32_t ofs = offset; uint8_t *sec_buf; uint32_t c = 0; while (count > 0) 10e929: 8b 45 14 mov 0x14(%ebp),%eax ssize_t cmpltd = 0; 10e92c: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) { 10e933: 8b 5d 08 mov 0x8(%ebp),%ebx 10e936: 8b 7d 10 mov 0x10(%ebp),%edi while (count > 0) 10e939: 85 c0 test %eax,%eax 10e93b: 0f 84 05 01 00 00 je 10ea46 <_fat_block_read+0x126> <== NEVER TAKEN sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &fs_info->c.buf); 10e941: 8d 83 9c 00 00 00 lea 0x9c(%ebx),%eax 10e947: 89 45 d8 mov %eax,-0x28(%ebp) 10e94a: eb 17 jmp 10e963 <_fat_block_read+0x43> 10e94c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf); if (rc != RC_OK) return -1; c = MIN(count, (fs_info->vol.bps - ofs)); memcpy((buff + cmpltd), (sec_buf + ofs), c); 10e950: f3 a4 rep movsb %ds:(%esi),%es:(%edi) count -= c; cmpltd += c; sec_num++; ofs = 0; 10e952: 31 ff xor %edi,%edi cmpltd += c; 10e954: 01 45 e4 add %eax,-0x1c(%ebp) sec_num++; 10e957: ff 45 0c incl 0xc(%ebp) while (count > 0) 10e95a: 29 45 14 sub %eax,0x14(%ebp) 10e95d: 0f 84 e3 00 00 00 je 10ea46 <_fat_block_read+0x126> return sector_number >> (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2); 10e963: 0f b6 43 02 movzbl 0x2(%ebx),%eax 10e967: 0f b6 4b 14 movzbl 0x14(%ebx),%ecx 10e96b: 8b 75 0c mov 0xc(%ebp),%esi 10e96e: 29 c1 sub %eax,%ecx 10e970: d3 ee shr %cl,%esi return block_number << (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2); 10e972: 89 f2 mov %esi,%edx 10e974: d3 e2 shl %cl,%edx 10e976: 89 d1 mov %edx,%ecx ((sector - 10e978: 8b 55 0c mov 0xc(%ebp),%edx 10e97b: 29 ca sub %ecx,%edx << fs_info->vol.sec_log2); 10e97d: 88 c1 mov %al,%cl 10e97f: d3 e2 shl %cl,%edx if (fs_info->c.state == FAT_CACHE_EMPTY || fs_info->c.blk_num != sec_num) 10e981: 80 bb 99 00 00 00 00 cmpb $0x0,0x99(%ebx) 10e988: 89 55 e0 mov %edx,-0x20(%ebp) 10e98b: 74 12 je 10e99f <_fat_block_read+0x7f> 10e98d: 8b 45 0c mov 0xc(%ebp),%eax 10e990: 39 83 94 00 00 00 cmp %eax,0x94(%ebx) 10e996: 74 3a je 10e9d2 <_fat_block_read+0xb2> if (fs_info->c.state == FAT_CACHE_EMPTY) 10e998: 89 d8 mov %ebx,%eax 10e99a: e8 f1 fb ff ff call 10e590 sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &fs_info->c.buf); 10e99f: 89 74 24 04 mov %esi,0x4(%esp) 10e9a3: 8b 45 d8 mov -0x28(%ebp),%eax 10e9a6: 89 44 24 08 mov %eax,0x8(%esp) 10e9aa: 8b 43 6c mov 0x6c(%ebx),%eax 10e9ad: 89 04 24 mov %eax,(%esp) 10e9b0: e8 7b 96 00 00 call 118030 if (sc != RTEMS_SUCCESSFUL) 10e9b5: 85 c0 test %eax,%eax 10e9b7: 0f 85 d3 00 00 00 jne 10ea90 <_fat_block_read+0x170> <== NEVER TAKEN fs_info->c.blk_num = sec_num; 10e9bd: 8b 45 0c mov 0xc(%ebp),%eax 10e9c0: 89 83 94 00 00 00 mov %eax,0x94(%ebx) fs_info->c.modified = 0; 10e9c6: b8 00 01 00 00 mov $0x100,%eax 10e9cb: 66 89 83 98 00 00 00 mov %ax,0x98(%ebx) c = MIN(count, (fs_info->vol.bps - ofs)); 10e9d2: 0f b7 03 movzwl (%ebx),%eax 10e9d5: 29 f8 sub %edi,%eax 10e9d7: 3b 45 14 cmp 0x14(%ebp),%eax 10e9da: 76 03 jbe 10e9df <_fat_block_read+0xbf> 10e9dc: 8b 45 14 mov 0x14(%ebp),%eax memcpy((buff + cmpltd), (sec_buf + ofs), c); 10e9df: 8b 55 18 mov 0x18(%ebp),%edx 10e9e2: 8b 75 e4 mov -0x1c(%ebp),%esi *sec_buf = &fs_info->c.buf->buffer[blk_ofs]; 10e9e5: 8b 8b 9c 00 00 00 mov 0x9c(%ebx),%ecx memcpy((buff + cmpltd), (sec_buf + ofs), c); 10e9eb: 01 d6 add %edx,%esi 10e9ed: 8b 55 e0 mov -0x20(%ebp),%edx 10e9f0: 89 75 dc mov %esi,-0x24(%ebp) 10e9f3: 01 fa add %edi,%edx 10e9f5: 8b 79 1c mov 0x1c(%ecx),%edi 10e9f8: 89 c1 mov %eax,%ecx 10e9fa: 01 fa add %edi,%edx 10e9fc: 83 f8 08 cmp $0x8,%eax 10e9ff: 89 f7 mov %esi,%edi 10ea01: 89 d6 mov %edx,%esi 10ea03: 0f 82 47 ff ff ff jb 10e950 <_fat_block_read+0x30> 10ea09: f7 c7 01 00 00 00 test $0x1,%edi 10ea0f: 75 6f jne 10ea80 <_fat_block_read+0x160> <== NEVER TAKEN 10ea11: f7 c7 02 00 00 00 test $0x2,%edi 10ea17: 75 47 jne 10ea60 <_fat_block_read+0x140> 10ea19: f7 c7 04 00 00 00 test $0x4,%edi 10ea1f: 0f 84 2b ff ff ff je 10e950 <_fat_block_read+0x30> 10ea25: 8b 16 mov (%esi),%edx 10ea27: 83 c7 04 add $0x4,%edi 10ea2a: 83 c6 04 add $0x4,%esi 10ea2d: 83 e9 04 sub $0x4,%ecx 10ea30: 89 57 fc mov %edx,-0x4(%edi) 10ea33: f3 a4 rep movsb %ds:(%esi),%es:(%edi) ofs = 0; 10ea35: 31 ff xor %edi,%edi cmpltd += c; 10ea37: 01 45 e4 add %eax,-0x1c(%ebp) sec_num++; 10ea3a: ff 45 0c incl 0xc(%ebp) while (count > 0) 10ea3d: 29 45 14 sub %eax,0x14(%ebp) 10ea40: 0f 85 1d ff ff ff jne 10e963 <_fat_block_read+0x43> } return cmpltd; } 10ea46: 8b 45 e4 mov -0x1c(%ebp),%eax 10ea49: 83 c4 2c add $0x2c,%esp 10ea4c: 5b pop %ebx 10ea4d: 5e pop %esi 10ea4e: 5f pop %edi 10ea4f: 5d pop %ebp 10ea50: c3 ret 10ea51: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10ea58: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10ea5f: 90 nop memcpy((buff + cmpltd), (sec_buf + ofs), c); 10ea60: 0f b7 16 movzwl (%esi),%edx 10ea63: 83 c7 02 add $0x2,%edi 10ea66: 83 c6 02 add $0x2,%esi 10ea69: 83 e9 02 sub $0x2,%ecx 10ea6c: 66 89 57 fe mov %dx,-0x2(%edi) 10ea70: eb a7 jmp 10ea19 <_fat_block_read+0xf9> 10ea72: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10ea79: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10ea80: 0f b6 12 movzbl (%edx),%edx <== NOT EXECUTED 10ea83: 47 inc %edi <== NOT EXECUTED 10ea84: 46 inc %esi <== NOT EXECUTED 10ea85: 8d 48 ff lea -0x1(%eax),%ecx <== NOT EXECUTED 10ea88: 88 55 e0 mov %dl,-0x20(%ebp) <== NOT EXECUTED 10ea8b: 88 57 ff mov %dl,-0x1(%edi) <== NOT EXECUTED 10ea8e: eb 81 jmp 10ea11 <_fat_block_read+0xf1> <== NOT EXECUTED rtems_set_errno_and_return_minus_one(EIO); 10ea90: e8 0b 7e 01 00 call 1268a0 <__errno> <== NOT EXECUTED return -1; 10ea95: c7 45 e4 ff ff ff ff movl $0xffffffff,-0x1c(%ebp) <== NOT EXECUTED rtems_set_errno_and_return_minus_one(EIO); 10ea9c: c7 00 05 00 00 00 movl $0x5,(%eax) <== NOT EXECUTED if (rc != RC_OK) 10eaa2: eb a2 jmp 10ea46 <_fat_block_read+0x126> <== NOT EXECUTED 10eaa4: 90 nop 10eaa5: 90 nop 10eaa6: 90 nop 10eaa7: 90 nop 10eaa8: 90 nop 10eaa9: 90 nop 10eaaa: 90 nop 10eaab: 90 nop 10eaac: 90 nop 10eaad: 90 nop 10eaae: 90 nop 10eaaf: 90 nop =============================================================================== 0010e820 : { 10e820: 55 push %ebp 10e821: 89 e5 mov %esp,%ebp 10e823: 83 ec 38 sub $0x38,%esp 10e826: 89 5d f4 mov %ebx,-0xc(%ebp) 10e829: 8b 5d 08 mov 0x8(%ebp),%ebx 10e82c: 89 75 f8 mov %esi,-0x8(%ebp) 10e82f: 89 7d fc mov %edi,-0x4(%ebp) 10e832: 8b 7d 0c mov 0xc(%ebp),%edi return sector_number >> (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2); 10e835: 0f b6 43 02 movzbl 0x2(%ebx),%eax 10e839: 0f b6 4b 14 movzbl 0x14(%ebx),%ecx 10e83d: 89 fa mov %edi,%edx 10e83f: 29 c1 sub %eax,%ecx 10e841: d3 ea shr %cl,%edx return block_number << (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2); 10e843: 89 d6 mov %edx,%esi 10e845: d3 e6 shl %cl,%esi 10e847: 89 f1 mov %esi,%ecx ((sector - 10e849: 89 fe mov %edi,%esi 10e84b: 29 ce sub %ecx,%esi << fs_info->vol.sec_log2); 10e84d: 88 c1 mov %al,%cl 10e84f: d3 e6 shl %cl,%esi if (fs_info->c.state == FAT_CACHE_EMPTY || fs_info->c.blk_num != sec_num) 10e851: 80 bb 99 00 00 00 00 cmpb $0x0,0x99(%ebx) 10e858: 74 15 je 10e86f 10e85a: 39 bb 94 00 00 00 cmp %edi,0x94(%ebx) 10e860: 89 55 e4 mov %edx,-0x1c(%ebp) 10e863: 74 3f je 10e8a4 if (fs_info->c.state == FAT_CACHE_EMPTY) 10e865: 89 d8 mov %ebx,%eax 10e867: e8 24 fd ff ff call 10e590 10e86c: 8b 55 e4 mov -0x1c(%ebp),%edx sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &fs_info->c.buf); 10e86f: 8b 43 6c mov 0x6c(%ebx),%eax 10e872: 8d 8b 9c 00 00 00 lea 0x9c(%ebx),%ecx if (op_type == FAT_OP_TYPE_READ) 10e878: 83 7d 10 01 cmpl $0x1,0x10(%ebp) sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &fs_info->c.buf); 10e87c: 89 4c 24 08 mov %ecx,0x8(%esp) 10e880: 89 54 24 04 mov %edx,0x4(%esp) 10e884: 89 04 24 mov %eax,(%esp) if (op_type == FAT_OP_TYPE_READ) 10e887: 74 47 je 10e8d0 sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &fs_info->c.buf); 10e889: e8 c2 96 00 00 call 117f50 if (sc != RTEMS_SUCCESSFUL) 10e88e: 85 c0 test %eax,%eax 10e890: 75 45 jne 10e8d7 <== NEVER TAKEN fs_info->c.blk_num = sec_num; 10e892: 89 bb 94 00 00 00 mov %edi,0x94(%ebx) fs_info->c.modified = 0; 10e898: b9 00 01 00 00 mov $0x100,%ecx 10e89d: 66 89 8b 98 00 00 00 mov %cx,0x98(%ebx) *sec_buf = &fs_info->c.buf->buffer[blk_ofs]; 10e8a4: 8b 83 9c 00 00 00 mov 0x9c(%ebx),%eax 10e8aa: 8b 50 1c mov 0x1c(%eax),%edx 10e8ad: 8b 45 14 mov 0x14(%ebp),%eax 10e8b0: 01 d6 add %edx,%esi 10e8b2: 89 30 mov %esi,(%eax) return RC_OK; 10e8b4: 31 c0 xor %eax,%eax } 10e8b6: 8b 5d f4 mov -0xc(%ebp),%ebx 10e8b9: 8b 75 f8 mov -0x8(%ebp),%esi 10e8bc: 8b 7d fc mov -0x4(%ebp),%edi 10e8bf: 89 ec mov %ebp,%esp 10e8c1: 5d pop %ebp 10e8c2: c3 ret 10e8c3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10e8ca: 8d b6 00 00 00 00 lea 0x0(%esi),%esi sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &fs_info->c.buf); 10e8d0: e8 5b 97 00 00 call 118030 10e8d5: eb b7 jmp 10e88e rtems_set_errno_and_return_minus_one(EIO); 10e8d7: e8 c4 7f 01 00 call 1268a0 <__errno> <== NOT EXECUTED 10e8dc: c7 00 05 00 00 00 movl $0x5,(%eax) <== NOT EXECUTED 10e8e2: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10e8e7: eb cd jmp 10e8b6 <== NOT EXECUTED 10e8e9: 90 nop 10e8ea: 90 nop 10e8eb: 90 nop 10e8ec: 90 nop 10e8ed: 90 nop 10e8ee: 90 nop 10e8ef: 90 nop =============================================================================== 0010e590 : *sec_buf = &fs_info->c.buf->buffer[blk_ofs]; return RC_OK; } int fat_buf_release(fat_fs_info_t *fs_info) 10e590: 55 push %ebp <== NOT EXECUTED 10e591: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e593: 57 push %edi <== NOT EXECUTED 10e594: 56 push %esi <== NOT EXECUTED 10e595: 53 push %ebx <== NOT EXECUTED 10e596: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10e598: 83 ec 3c sub $0x3c,%esp <== NOT EXECUTED rtems_status_code sc = RTEMS_SUCCESSFUL; if (fs_info->c.state == FAT_CACHE_EMPTY) return RC_OK; if (fs_info->c.modified) 10e59b: 80 b8 98 00 00 00 00 cmpb $0x0,0x98(%eax) <== NOT EXECUTED sec_num, 0); if (sec_of_fat && !fs_info->vol.mirror) memcpy(fs_info->sec_buf, fs_info->c.buf->buffer + blk_ofs, 10e5a2: 8b 90 9c 00 00 00 mov 0x9c(%eax),%edx <== NOT EXECUTED if (fs_info->c.modified) 10e5a8: 0f 84 52 01 00 00 je 10e700 <== NOT EXECUTED uint32_t sec_num = fs_info->c.blk_num; 10e5ae: 8b b0 94 00 00 00 mov 0x94(%eax),%esi <== NOT EXECUTED bool sec_of_fat = ((sec_num >= fs_info->vol.fat_loc) && 10e5b4: 0f b7 40 20 movzwl 0x20(%eax),%eax <== NOT EXECUTED 10e5b8: 39 c6 cmp %eax,%esi <== NOT EXECUTED 10e5ba: 73 34 jae 10e5f0 <== NOT EXECUTED fs_info->vol.bps); sc = rtems_bdbuf_release_modified(fs_info->c.buf); 10e5bc: 89 14 24 mov %edx,(%esp) <== NOT EXECUTED 10e5bf: e8 5c 9d 00 00 call 118320 <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) 10e5c4: 85 c0 test %eax,%eax <== NOT EXECUTED 10e5c6: 0f 85 44 01 00 00 jne 10e710 <== NOT EXECUTED rtems_set_errno_and_return_minus_one(EIO); fs_info->c.modified = 0; 10e5cc: c6 83 98 00 00 00 00 movb $0x0,0x98(%ebx) <== NOT EXECUTED { sc = rtems_bdbuf_release(fs_info->c.buf); if (sc != RTEMS_SUCCESSFUL) rtems_set_errno_and_return_minus_one(EIO); } fs_info->c.state = FAT_CACHE_EMPTY; 10e5d3: c6 83 99 00 00 00 00 movb $0x0,0x99(%ebx) <== NOT EXECUTED return RC_OK; } 10e5da: 83 c4 3c add $0x3c,%esp <== NOT EXECUTED return RC_OK; 10e5dd: 31 c0 xor %eax,%eax } 10e5df: 5b pop %ebx 10e5e0: 5e pop %esi 10e5e1: 5f pop %edi 10e5e2: 5d pop %ebp 10e5e3: c3 ret 10e5e4: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10e5eb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 10e5ef: 90 nop bool sec_of_fat = ((sec_num >= fs_info->vol.fat_loc) && 10e5f0: 3b 73 28 cmp 0x28(%ebx),%esi 10e5f3: 73 c7 jae 10e5bc if (sec_of_fat && !fs_info->vol.mirror) 10e5f5: 80 7b 5c 00 cmpb $0x0,0x5c(%ebx) 10e5f9: 0f 84 41 01 00 00 je 10e740 sc = rtems_bdbuf_release_modified(fs_info->c.buf); 10e5ff: 89 14 24 mov %edx,(%esp) 10e602: e8 19 9d 00 00 call 118320 if (sc != RTEMS_SUCCESSFUL) 10e607: 85 c0 test %eax,%eax 10e609: 0f 85 01 01 00 00 jne 10e710 if (sec_of_fat && !fs_info->vol.mirror) 10e60f: 80 7b 5c 00 cmpb $0x0,0x5c(%ebx) fs_info->c.modified = 0; 10e613: c6 83 98 00 00 00 00 movb $0x0,0x98(%ebx) if (sec_of_fat && !fs_info->vol.mirror) 10e61a: 75 b7 jne 10e5d3 for (i = 1; i < fs_info->vol.fats; i++) 10e61c: 80 7b 15 01 cmpb $0x1,0x15(%ebx) 10e620: c6 45 d7 01 movb $0x1,-0x29(%ebp) 10e624: 77 2b ja 10e651 10e626: eb ab jmp 10e5d3 10e628: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10e62f: 90 nop memcpy(bd->buffer + blk_ofs, fs_info->sec_buf, fs_info->vol.bps); 10e630: f3 a4 rep movsb %ds:(%esi),%es:(%edi) sc = rtems_bdbuf_release_modified(bd); 10e632: 8b 45 e4 mov -0x1c(%ebp),%eax 10e635: 89 04 24 mov %eax,(%esp) 10e638: e8 e3 9c 00 00 call 118320 if ( sc != RTEMS_SUCCESSFUL) 10e63d: 85 c0 test %eax,%eax 10e63f: 0f 85 3b 01 00 00 jne 10e780 for (i = 1; i < fs_info->vol.fats; i++) 10e645: fe 45 d7 incb -0x29(%ebp) 10e648: 0f b6 45 d7 movzbl -0x29(%ebp),%eax 10e64c: 3a 43 15 cmp 0x15(%ebx),%al 10e64f: 73 82 jae 10e5d3 sec_num = fs_info->c.blk_num + fs_info->vol.fat_length * i, 10e651: 8b 43 24 mov 0x24(%ebx),%eax 10e654: 0f b6 75 d7 movzbl -0x29(%ebp),%esi 10e658: 8b 93 94 00 00 00 mov 0x94(%ebx),%edx static inline uint32_t fat_sector_num_to_block_num (const fat_fs_info_t *fs_info, const uint32_t sector_number) { return sector_number >> (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2); 10e65e: 0f b6 4b 14 movzbl 0x14(%ebx),%ecx 10e662: 0f af f0 imul %eax,%esi 10e665: 0f b6 43 02 movzbl 0x2(%ebx),%eax 10e669: 01 d6 add %edx,%esi 10e66b: 29 c1 sub %eax,%ecx 10e66d: 89 f7 mov %esi,%edi 10e66f: d3 ef shr %cl,%edi return block_number << (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2); 10e671: 89 fa mov %edi,%edx 10e673: d3 e2 shl %cl,%edx { return sector_offset + ((sector - fat_block_num_to_sector_num (fs_info, fat_sector_num_to_block_num (fs_info, sector))) << fs_info->vol.sec_log2); 10e675: 88 c1 mov %al,%cl sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &bd); 10e677: 8b 43 6c mov 0x6c(%ebx),%eax ((sector - 10e67a: 29 d6 sub %edx,%esi << fs_info->vol.sec_log2); 10e67c: d3 e6 shl %cl,%esi 10e67e: 8d 55 e4 lea -0x1c(%ebp),%edx if (blk_ofs == 0 10e681: 85 f6 test %esi,%esi 10e683: 75 0c jne 10e691 && fs_info->vol.bps == fs_info->vol.bytes_per_block) 10e685: 0f b7 0b movzwl (%ebx),%ecx 10e688: 3b 4b 10 cmp 0x10(%ebx),%ecx 10e68b: 0f 84 8f 00 00 00 je 10e720 sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &bd); 10e691: 89 54 24 08 mov %edx,0x8(%esp) 10e695: 89 7c 24 04 mov %edi,0x4(%esp) 10e699: 89 04 24 mov %eax,(%esp) 10e69c: e8 8f 99 00 00 call 118030 if ( sc != RTEMS_SUCCESSFUL) 10e6a1: 85 c0 test %eax,%eax 10e6a3: 0f 85 d7 00 00 00 jne 10e780 memcpy(bd->buffer + blk_ofs, fs_info->sec_buf, fs_info->vol.bps); 10e6a9: 8b 45 e4 mov -0x1c(%ebp),%eax 10e6ac: 0f b7 0b movzwl (%ebx),%ecx 10e6af: 8b 50 1c mov 0x1c(%eax),%edx 10e6b2: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax 10e6b8: 01 f2 add %esi,%edx 10e6ba: 83 f9 08 cmp $0x8,%ecx 10e6bd: 89 d7 mov %edx,%edi 10e6bf: 89 c6 mov %eax,%esi 10e6c1: 0f 82 69 ff ff ff jb 10e630 10e6c7: f6 c2 01 test $0x1,%dl 10e6ca: 0f 85 f0 00 00 00 jne 10e7c0 10e6d0: f7 c7 02 00 00 00 test $0x2,%edi 10e6d6: 0f 85 c4 00 00 00 jne 10e7a0 10e6dc: f7 c7 04 00 00 00 test $0x4,%edi 10e6e2: 0f 84 48 ff ff ff je 10e630 10e6e8: 8b 06 mov (%esi),%eax 10e6ea: 83 c7 04 add $0x4,%edi 10e6ed: 83 c6 04 add $0x4,%esi 10e6f0: 83 e9 04 sub $0x4,%ecx 10e6f3: 89 47 fc mov %eax,-0x4(%edi) 10e6f6: e9 35 ff ff ff jmp 10e630 10e6fb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 10e6ff: 90 nop sc = rtems_bdbuf_release(fs_info->c.buf); 10e700: 89 14 24 mov %edx,(%esp) 10e703: e8 18 9b 00 00 call 118220 if (sc != RTEMS_SUCCESSFUL) 10e708: 85 c0 test %eax,%eax 10e70a: 0f 84 c3 fe ff ff je 10e5d3 rtems_set_errno_and_return_minus_one(EIO); 10e710: e8 8b 81 01 00 call 1268a0 <__errno> 10e715: c7 00 05 00 00 00 movl $0x5,(%eax) 10e71b: eb 6e jmp 10e78b 10e71d: 8d 76 00 lea 0x0(%esi),%esi sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &bd); 10e720: 89 54 24 08 mov %edx,0x8(%esp) 10e724: 89 7c 24 04 mov %edi,0x4(%esp) 10e728: 89 04 24 mov %eax,(%esp) 10e72b: e8 20 98 00 00 call 117f50 10e730: e9 6c ff ff ff jmp 10e6a1 10e735: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10e73c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi return sector_number >> (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2); 10e740: 0f b6 43 02 movzbl 0x2(%ebx),%eax 10e744: 89 f7 mov %esi,%edi 10e746: 0f b6 4b 14 movzbl 0x14(%ebx),%ecx 10e74a: 29 c1 sub %eax,%ecx 10e74c: d3 ef shr %cl,%edi return block_number << (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2); 10e74e: d3 e7 shl %cl,%edi << fs_info->vol.sec_log2); 10e750: 88 c1 mov %al,%cl memcpy(fs_info->sec_buf, 10e752: 8b 42 1c mov 0x1c(%edx),%eax ((sector - 10e755: 29 fe sub %edi,%esi 10e757: 8b bb a0 00 00 00 mov 0xa0(%ebx),%edi << fs_info->vol.sec_log2); 10e75d: d3 e6 shl %cl,%esi 10e75f: 0f b7 0b movzwl (%ebx),%ecx 10e762: 01 c6 add %eax,%esi 10e764: 83 f9 08 cmp $0x8,%ecx 10e767: 73 67 jae 10e7d0 10e769: f3 a4 rep movsb %ds:(%esi),%es:(%edi) sc = rtems_bdbuf_release_modified(fs_info->c.buf); 10e76b: 8b 93 9c 00 00 00 mov 0x9c(%ebx),%edx 10e771: e9 89 fe ff ff jmp 10e5ff 10e776: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10e77d: 8d 76 00 lea 0x0(%esi),%esi rtems_set_errno_and_return_minus_one(ENOMEM); 10e780: e8 1b 81 01 00 call 1268a0 <__errno> 10e785: c7 00 0c 00 00 00 movl $0xc,(%eax) } 10e78b: 83 c4 3c add $0x3c,%esp rtems_set_errno_and_return_minus_one(EIO); 10e78e: b8 ff ff ff ff mov $0xffffffff,%eax } 10e793: 5b pop %ebx 10e794: 5e pop %esi 10e795: 5f pop %edi 10e796: 5d pop %ebp 10e797: c3 ret 10e798: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10e79f: 90 nop memcpy(bd->buffer + blk_ofs, fs_info->sec_buf, fs_info->vol.bps); 10e7a0: 0f b7 06 movzwl (%esi),%eax 10e7a3: 83 c7 02 add $0x2,%edi 10e7a6: 83 c6 02 add $0x2,%esi 10e7a9: 83 e9 02 sub $0x2,%ecx 10e7ac: 66 89 47 fe mov %ax,-0x2(%edi) 10e7b0: e9 27 ff ff ff jmp 10e6dc 10e7b5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10e7bc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 10e7c0: 0f b6 00 movzbl (%eax),%eax 10e7c3: 47 inc %edi 10e7c4: 46 inc %esi 10e7c5: 49 dec %ecx 10e7c6: 88 02 mov %al,(%edx) 10e7c8: e9 03 ff ff ff jmp 10e6d0 10e7cd: 8d 76 00 lea 0x0(%esi),%esi memcpy(fs_info->sec_buf, 10e7d0: f7 c7 01 00 00 00 test $0x1,%edi 10e7d6: 75 23 jne 10e7fb 10e7d8: f7 c7 02 00 00 00 test $0x2,%edi 10e7de: 75 26 jne 10e806 10e7e0: f7 c7 04 00 00 00 test $0x4,%edi 10e7e6: 74 81 je 10e769 10e7e8: 8b 06 mov (%esi),%eax 10e7ea: 83 c7 04 add $0x4,%edi 10e7ed: 83 c6 04 add $0x4,%esi 10e7f0: 83 e9 04 sub $0x4,%ecx 10e7f3: 89 47 fc mov %eax,-0x4(%edi) 10e7f6: e9 6e ff ff ff jmp 10e769 10e7fb: 0f b6 06 movzbl (%esi),%eax 10e7fe: 47 inc %edi 10e7ff: 46 inc %esi 10e800: 49 dec %ecx 10e801: 88 47 ff mov %al,-0x1(%edi) 10e804: eb d2 jmp 10e7d8 10e806: 0f b7 06 movzwl (%esi),%eax 10e809: 83 c7 02 add $0x2,%edi 10e80c: 83 c6 02 add $0x2,%esi 10e80f: 83 e9 02 sub $0x2,%ecx 10e812: 66 89 47 fe mov %ax,-0x2(%edi) 10e816: eb c8 jmp 10e7e0 10e818: 90 nop 10e819: 90 nop 10e81a: 90 nop 10e81b: 90 nop 10e81c: 90 nop 10e81d: 90 nop 10e81e: 90 nop 10e81f: 90 nop =============================================================================== 0010ebf0 : fat_fs_info_t *fs_info, const uint32_t start_cln, const uint32_t offset, const uint32_t count, const uint8_t pattern) { 10ebf0: 55 push %ebp 10ebf1: 89 e5 mov %esp,%ebp 10ebf3: 57 push %edi 10ebf4: 56 push %esi 10ebf5: 53 push %ebx 10ebf6: 83 ec 4c sub $0x4c,%esp 10ebf9: 8b 75 08 mov 0x8(%ebp),%esi 10ebfc: 8b 7d 10 mov 0x10(%ebp),%edi 10ebff: 8b 45 14 mov 0x14(%ebp),%eax 10ec02: 0f b6 55 18 movzbl 0x18(%ebp),%edx ssize_t rc = RC_OK; uint32_t bytes_to_write = MIN(count, (fs_info->vol.bpc - offset)); 10ec06: 8b 4e 08 mov 0x8(%esi),%ecx { 10ec09: 8b 5d 0c mov 0xc(%ebp),%ebx 10ec0c: 88 55 cc mov %dl,-0x34(%ebp) uint32_t bytes_to_write = MIN(count, (fs_info->vol.bpc - offset)); 10ec0f: 29 f9 sub %edi,%ecx 10ec11: 89 4d d0 mov %ecx,-0x30(%ebp) 10ec14: 39 c1 cmp %eax,%ecx 10ec16: 76 03 jbe 10ec1b <== ALWAYS TAKEN 10ec18: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) ) 10ec1b: 0f b6 46 14 movzbl 0x14(%esi),%eax 10ec1f: 0f b6 4e 02 movzbl 0x2(%esi),%ecx 10ec23: 88 45 c6 mov %al,-0x3a(%ebp) return sector_number >> (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2); 10ec26: 89 45 d4 mov %eax,-0x2c(%ebp) 10ec29: 29 c8 sub %ecx,%eax 10ec2b: 85 db test %ebx,%ebx 10ec2d: 88 4d c7 mov %cl,-0x39(%ebp) 10ec30: 75 0a jne 10ec3c <== ALWAYS TAKEN 10ec32: f6 46 16 03 testb $0x3,0x16(%esi) <== NOT EXECUTED 10ec36: 0f 85 74 01 00 00 jne 10edb0 <== NOT EXECUTED blk = cln << (fs_info->vol.bpc_log2 - fs_info->vol.bytes_per_block_log2); 10ec3c: 8b 55 d4 mov -0x2c(%ebp),%edx cln -= FAT_RSRVD_CLN; 10ec3f: 83 eb 02 sub $0x2,%ebx blk = cln << (fs_info->vol.bpc_log2 - fs_info->vol.bytes_per_block_log2); 10ec42: 0f b6 4e 0c movzbl 0xc(%esi),%ecx 10ec46: 29 d1 sub %edx,%ecx 10ec48: 8b 56 3c mov 0x3c(%esi),%edx 10ec4b: d3 e3 shl %cl,%ebx 10ec4d: 88 c1 mov %al,%cl 10ec4f: d3 ea shr %cl,%edx blk += fat_sector_num_to_block_num(fs_info, fs_info->vol.data_fsec); 10ec51: 01 d3 add %edx,%ebx uint32_t cur_blk = fat_cluster_num_to_block_num(fs_info, start_cln); uint32_t blocks_in_offset = offset >> fs_info->vol.bytes_per_block_log2; 10ec53: 0f b6 4d d4 movzbl -0x2c(%ebp),%ecx 10ec57: 89 f8 mov %edi,%eax 10ec59: d3 e8 shr %cl,%eax uint32_t ofs_blk = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2); 10ec5b: 89 c2 mov %eax,%edx ssize_t bytes_written = 0; ssize_t ret; cur_blk += blocks_in_offset; 10ec5d: 01 d8 add %ebx,%eax 10ec5f: 89 45 c8 mov %eax,-0x38(%ebp) uint32_t ofs_blk = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2); 10ec62: d3 e2 shl %cl,%edx while ( (RC_OK == rc) 10ec64: 8b 4d d0 mov -0x30(%ebp),%ecx uint32_t ofs_blk = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2); 10ec67: 29 d7 sub %edx,%edi while ( (RC_OK == rc) 10ec69: 85 c9 test %ecx,%ecx 10ec6b: 0f 84 4f 01 00 00 je 10edc0 <== NEVER TAKEN && (0 < bytes_to_write)) { uint32_t c = MIN(bytes_to_write, (fs_info->vol.bytes_per_block - ofs_blk)); ret = fat_block_set( 10ec71: 0f b6 4d cc movzbl -0x34(%ebp),%ecx ssize_t bytes_written = 0; 10ec75: c7 45 cc 00 00 00 00 movl $0x0,-0x34(%ebp) ret = fat_block_set( 10ec7c: 89 4d c0 mov %ecx,-0x40(%ebp) memset(blk_buf + offset, pattern, bytes_to_write); 10ec7f: 69 c1 01 01 01 01 imul $0x1010101,%ecx,%eax 10ec85: 0f b6 4d c6 movzbl -0x3a(%ebp),%ecx 10ec89: 89 45 bc mov %eax,-0x44(%ebp) 10ec8c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi uint32_t c = MIN(bytes_to_write, (fs_info->vol.bytes_per_block - ofs_blk)); 10ec90: 8b 46 10 mov 0x10(%esi),%eax 10ec93: 8b 55 d0 mov -0x30(%ebp),%edx 10ec96: 89 c3 mov %eax,%ebx 10ec98: 29 fb sub %edi,%ebx 10ec9a: 89 5d d4 mov %ebx,-0x2c(%ebp) 10ec9d: 39 d3 cmp %edx,%ebx 10ec9f: 76 03 jbe 10eca4 <== ALWAYS TAKEN 10eca1: 89 55 d4 mov %edx,-0x2c(%ebp) <== NOT EXECUTED uint32_t bytes_to_write = MIN(count, (fs_info->vol.bytes_per_block - offset)); 10eca4: 8b 55 d4 mov -0x2c(%ebp),%edx 10eca7: 39 d3 cmp %edx,%ebx 10eca9: 76 02 jbe 10ecad <== ALWAYS TAKEN 10ecab: 89 d3 mov %edx,%ebx <== NOT EXECUTED if (0 < bytes_to_write) 10ecad: 85 db test %ebx,%ebx 10ecaf: 0f 84 a2 00 00 00 je 10ed57 <== NEVER TAKEN return block_number << (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2); 10ecb5: 0f b6 55 c7 movzbl -0x39(%ebp),%edx 10ecb9: 28 d1 sub %dl,%cl 10ecbb: 8b 55 c8 mov -0x38(%ebp),%edx 10ecbe: d3 e2 shl %cl,%edx if (bytes_to_write == fs_info->vol.bytes_per_block) 10ecc0: 39 d8 cmp %ebx,%eax rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &blk_buf); 10ecc2: 8d 45 e4 lea -0x1c(%ebp),%eax 10ecc5: 89 44 24 0c mov %eax,0xc(%esp) if (bytes_to_write == fs_info->vol.bytes_per_block) 10ecc9: 0f 84 91 00 00 00 je 10ed60 rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &blk_buf); 10eccf: 89 54 24 04 mov %edx,0x4(%esp) 10ecd3: b8 01 00 00 00 mov $0x1,%eax 10ecd8: 89 44 24 08 mov %eax,0x8(%esp) 10ecdc: 89 34 24 mov %esi,(%esp) 10ecdf: e8 3c fb ff ff call 10e820 if (RC_OK == rc) 10ece4: 85 c0 test %eax,%eax 10ece6: 74 48 je 10ed30 <== ALWAYS TAKEN fs_info, cur_blk, ofs_blk, c, pattern); if (c != ret) 10ece8: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10ecea: 39 5d d4 cmp %ebx,-0x2c(%ebp) 10eced: 74 21 je 10ed10 <== ALWAYS TAKEN 10ecef: c7 45 cc ff ff ff ff movl $0xffffffff,-0x34(%ebp) <== NOT EXECUTED } if (RC_OK != rc) return rc; else return bytes_written; } 10ecf6: 8b 45 cc mov -0x34(%ebp),%eax 10ecf9: 83 c4 4c add $0x4c,%esp 10ecfc: 5b pop %ebx 10ecfd: 5e pop %esi 10ecfe: 5f pop %edi 10ecff: 5d pop %ebp 10ed00: c3 ret 10ed01: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10ed08: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10ed0f: 90 nop while ( (RC_OK == rc) 10ed10: 8b 7d d4 mov -0x2c(%ebp),%edi bytes_written += ret; 10ed13: 01 45 cc add %eax,-0x34(%ebp) ++cur_blk; 10ed16: ff 45 c8 incl -0x38(%ebp) while ( (RC_OK == rc) 10ed19: 29 7d d0 sub %edi,-0x30(%ebp) 10ed1c: 74 d8 je 10ecf6 10ed1e: 0f b6 46 02 movzbl 0x2(%esi),%eax 10ed22: 31 ff xor %edi,%edi 10ed24: 0f b6 4e 14 movzbl 0x14(%esi),%ecx 10ed28: 88 45 c7 mov %al,-0x39(%ebp) 10ed2b: e9 60 ff ff ff jmp 10ec90 memset(blk_buf + offset, pattern, bytes_to_write); 10ed30: 8b 45 e4 mov -0x1c(%ebp),%eax 10ed33: 89 da mov %ebx,%edx 10ed35: 01 f8 add %edi,%eax 10ed37: 83 fb 08 cmp $0x8,%ebx 10ed3a: 89 c7 mov %eax,%edi 10ed3c: 73 42 jae 10ed80 <== ALWAYS TAKEN 10ed3e: 83 e2 07 and $0x7,%edx 10ed41: 74 0d je 10ed50 <== ALWAYS TAKEN 10ed43: 8b 4d c0 mov -0x40(%ebp),%ecx <== NOT EXECUTED 10ed46: 31 c0 xor %eax,%eax <== NOT EXECUTED 10ed48: 88 0c 07 mov %cl,(%edi,%eax,1) <== NOT EXECUTED 10ed4b: 40 inc %eax <== NOT EXECUTED 10ed4c: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10ed4e: 72 f8 jb 10ed48 <== NOT EXECUTED fs_info->c.modified = true; 10ed50: c6 86 98 00 00 00 01 movb $0x1,0x98(%esi) return bytes_to_write; 10ed57: 89 d8 mov %ebx,%eax 10ed59: eb 8f jmp 10ecea 10ed5b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 10ed5f: 90 nop rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &blk_buf); 10ed60: 89 54 24 04 mov %edx,0x4(%esp) 10ed64: b9 02 00 00 00 mov $0x2,%ecx 10ed69: 89 4c 24 08 mov %ecx,0x8(%esp) 10ed6d: 89 34 24 mov %esi,(%esp) 10ed70: e8 ab fa ff ff call 10e820 10ed75: e9 6a ff ff ff jmp 10ece4 10ed7a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi memset(blk_buf + offset, pattern, bytes_to_write); 10ed80: a8 01 test $0x1,%al 10ed82: 75 6b jne 10edef 10ed84: f7 c7 02 00 00 00 test $0x2,%edi 10ed8a: 75 46 jne 10edd2 10ed8c: f7 c7 04 00 00 00 test $0x4,%edi 10ed92: 75 4d jne 10ede1 10ed94: 8b 45 bc mov -0x44(%ebp),%eax 10ed97: 89 d1 mov %edx,%ecx 10ed99: 83 e2 03 and $0x3,%edx 10ed9c: c1 e9 02 shr $0x2,%ecx 10ed9f: f3 ab rep stos %eax,%es:(%edi) 10eda1: eb 9b jmp 10ed3e 10eda3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10edaa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi return sector_number >> (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2); 10edb0: 8b 5e 28 mov 0x28(%esi),%ebx <== NOT EXECUTED 10edb3: 88 c1 mov %al,%cl <== NOT EXECUTED 10edb5: d3 eb shr %cl,%ebx <== NOT EXECUTED return blk; 10edb7: e9 97 fe ff ff jmp 10ec53 <== NOT EXECUTED 10edbc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED ssize_t bytes_written = 0; 10edc0: c7 45 cc 00 00 00 00 movl $0x0,-0x34(%ebp) <== NOT EXECUTED } 10edc7: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED 10edca: 83 c4 4c add $0x4c,%esp <== NOT EXECUTED 10edcd: 5b pop %ebx <== NOT EXECUTED 10edce: 5e pop %esi <== NOT EXECUTED 10edcf: 5f pop %edi <== NOT EXECUTED 10edd0: 5d pop %ebp <== NOT EXECUTED 10edd1: c3 ret <== NOT EXECUTED memset(blk_buf + offset, pattern, bytes_to_write); 10edd2: 8b 45 bc mov -0x44(%ebp),%eax 10edd5: 83 c7 02 add $0x2,%edi 10edd8: 83 ea 02 sub $0x2,%edx 10eddb: 66 89 47 fe mov %ax,-0x2(%edi) 10eddf: eb ab jmp 10ed8c 10ede1: 8b 45 bc mov -0x44(%ebp),%eax 10ede4: 83 c7 04 add $0x4,%edi 10ede7: 83 ea 04 sub $0x4,%edx 10edea: 89 47 fc mov %eax,-0x4(%edi) 10eded: eb a5 jmp 10ed94 10edef: 0f b6 55 bc movzbl -0x44(%ebp),%edx 10edf3: 47 inc %edi 10edf4: 88 10 mov %dl,(%eax) 10edf6: 8d 53 ff lea -0x1(%ebx),%edx 10edf9: eb 89 jmp 10ed84 10edfb: 90 nop 10edfc: 90 nop 10edfd: 90 nop 10edfe: 90 nop 10edff: 90 nop =============================================================================== 0010ee00 : fat_fs_info_t *fs_info, const uint32_t start_cln, const uint32_t offset, const uint32_t count, const void *buff) { 10ee00: 55 push %ebp 10ee01: 89 e5 mov %esp,%ebp 10ee03: 57 push %edi 10ee04: 56 push %esi 10ee05: 53 push %ebx 10ee06: 83 ec 4c sub $0x4c,%esp 10ee09: 8b 55 08 mov 0x8(%ebp),%edx 10ee0c: 8b 75 10 mov 0x10(%ebp),%esi 10ee0f: 8b 45 14 mov 0x14(%ebp),%eax 10ee12: 8b 5d 0c mov 0xc(%ebp),%ebx ssize_t rc = RC_OK; uint32_t bytes_to_write = MIN(count, (fs_info->vol.bpc - offset)); 10ee15: 8b 4a 08 mov 0x8(%edx),%ecx 10ee18: 29 f1 sub %esi,%ecx 10ee1a: 89 4d d0 mov %ecx,-0x30(%ebp) 10ee1d: 39 c1 cmp %eax,%ecx 10ee1f: 76 03 jbe 10ee24 10ee21: 89 45 d0 mov %eax,-0x30(%ebp) if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) ) 10ee24: 0f b6 7a 14 movzbl 0x14(%edx),%edi 10ee28: 0f b6 4a 02 movzbl 0x2(%edx),%ecx 10ee2c: 89 7d d4 mov %edi,-0x2c(%ebp) 10ee2f: 89 f8 mov %edi,%eax 10ee31: 88 4d c4 mov %cl,-0x3c(%ebp) 10ee34: 29 cf sub %ecx,%edi 10ee36: 85 db test %ebx,%ebx 10ee38: 88 45 c3 mov %al,-0x3d(%ebp) 10ee3b: 89 f9 mov %edi,%ecx 10ee3d: 89 7d cc mov %edi,-0x34(%ebp) 10ee40: 75 0a jne 10ee4c 10ee42: f6 42 16 03 testb $0x3,0x16(%edx) 10ee46: 0f 85 54 01 00 00 jne 10efa0 <== ALWAYS TAKEN blk = cln << (fs_info->vol.bpc_log2 - fs_info->vol.bytes_per_block_log2); 10ee4c: 8b 45 d4 mov -0x2c(%ebp),%eax cln -= FAT_RSRVD_CLN; 10ee4f: 83 eb 02 sub $0x2,%ebx blk = cln << (fs_info->vol.bpc_log2 - fs_info->vol.bytes_per_block_log2); 10ee52: 0f b6 4a 0c movzbl 0xc(%edx),%ecx 10ee56: 29 c1 sub %eax,%ecx 10ee58: 8b 42 3c mov 0x3c(%edx),%eax 10ee5b: d3 e3 shl %cl,%ebx 10ee5d: 0f b6 4d cc movzbl -0x34(%ebp),%ecx 10ee61: d3 e8 shr %cl,%eax blk += fat_sector_num_to_block_num(fs_info, fs_info->vol.data_fsec); 10ee63: 01 c3 add %eax,%ebx uint32_t cur_blk = fat_cluster_num_to_block_num(fs_info, start_cln); uint32_t blocks_in_offset = (offset >> fs_info->vol.bytes_per_block_log2); uint32_t ofs_blk = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2); ssize_t bytes_written = 0; 10ee65: c7 45 cc 00 00 00 00 movl $0x0,-0x34(%ebp) uint32_t blocks_in_offset = (offset >> fs_info->vol.bytes_per_block_log2); 10ee6c: 0f b6 4d d4 movzbl -0x2c(%ebp),%ecx 10ee70: 89 f7 mov %esi,%edi 10ee72: d3 ef shr %cl,%edi uint32_t ofs_blk = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2); 10ee74: 89 f8 mov %edi,%eax 10ee76: d3 e0 shl %cl,%eax 10ee78: 29 c6 sub %eax,%esi uint8_t *buffer = (uint8_t*)buff; ssize_t ret; uint32_t c; cur_blk += blocks_in_offset; 10ee7a: 8d 04 1f lea (%edi,%ebx,1),%eax 10ee7d: 89 45 c8 mov %eax,-0x38(%ebp) while ( (RC_OK == rc) 10ee80: 8b 45 d0 mov -0x30(%ebp),%eax 10ee83: 85 c0 test %eax,%eax 10ee85: 74 75 je 10eefc <== NEVER TAKEN rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &blk_buf); 10ee87: 0f b6 4d c3 movzbl -0x3d(%ebp),%ecx 10ee8b: 89 f7 mov %esi,%edi 10ee8d: 8d 76 00 lea 0x0(%esi),%esi && (0 < bytes_to_write)) { c = MIN(bytes_to_write, (fs_info->vol.bytes_per_block - ofs_blk)); 10ee90: 8b 72 10 mov 0x10(%edx),%esi 10ee93: 8b 45 d0 mov -0x30(%ebp),%eax 10ee96: 89 f3 mov %esi,%ebx 10ee98: 29 fb sub %edi,%ebx 10ee9a: 89 5d d4 mov %ebx,-0x2c(%ebp) 10ee9d: 39 c3 cmp %eax,%ebx 10ee9f: 76 03 jbe 10eea4 10eea1: 89 45 d4 mov %eax,-0x2c(%ebp) uint32_t bytes_to_write = MIN(count, (fs_info->vol.bytes_per_block - offset)); 10eea4: 8b 45 d4 mov -0x2c(%ebp),%eax 10eea7: 39 c3 cmp %eax,%ebx 10eea9: 76 02 jbe 10eead 10eeab: 89 c3 mov %eax,%ebx if (0 < bytes_to_write) 10eead: 85 db test %ebx,%ebx 10eeaf: 0f 84 9d 00 00 00 je 10ef52 <== NEVER TAKEN return block_number << (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2); 10eeb5: 0f b6 45 c4 movzbl -0x3c(%ebp),%eax 10eeb9: 28 c1 sub %al,%cl 10eebb: 8b 45 c8 mov -0x38(%ebp),%eax 10eebe: d3 e0 shl %cl,%eax if (bytes_to_write == fs_info->vol.bytes_per_block) 10eec0: 39 de cmp %ebx,%esi rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &blk_buf); 10eec2: 8d 75 e4 lea -0x1c(%ebp),%esi 10eec5: 89 74 24 0c mov %esi,0xc(%esp) if (bytes_to_write == fs_info->vol.bytes_per_block) 10eec9: 0f 84 91 00 00 00 je 10ef60 rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &blk_buf); 10eecf: be 01 00 00 00 mov $0x1,%esi 10eed4: 89 74 24 08 mov %esi,0x8(%esp) 10eed8: 89 14 24 mov %edx,(%esp) 10eedb: 89 44 24 04 mov %eax,0x4(%esp) 10eedf: 89 55 08 mov %edx,0x8(%ebp) 10eee2: e8 39 f9 ff ff call 10e820 10eee7: 8b 55 08 mov 0x8(%ebp),%edx if (RC_OK == rc) 10eeea: 85 c0 test %eax,%eax 10eeec: 74 42 je 10ef30 <== ALWAYS TAKEN fs_info, cur_blk, ofs_blk, c, &buffer[bytes_written]); if (c != ret) 10eeee: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10eef0: 39 5d d4 cmp %ebx,-0x2c(%ebp) 10eef3: 74 1b je 10ef10 <== ALWAYS TAKEN 10eef5: c7 45 cc ff ff ff ff movl $0xffffffff,-0x34(%ebp) <== NOT EXECUTED } if (RC_OK != rc) return rc; else return bytes_written; } 10eefc: 8b 45 cc mov -0x34(%ebp),%eax 10eeff: 83 c4 4c add $0x4c,%esp 10ef02: 5b pop %ebx 10ef03: 5e pop %esi 10ef04: 5f pop %edi 10ef05: 5d pop %ebp 10ef06: c3 ret 10ef07: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10ef0e: 66 90 xchg %ax,%ax while ( (RC_OK == rc) 10ef10: 8b 4d d4 mov -0x2c(%ebp),%ecx bytes_written += ret; 10ef13: 01 45 cc add %eax,-0x34(%ebp) ++cur_blk; 10ef16: ff 45 c8 incl -0x38(%ebp) while ( (RC_OK == rc) 10ef19: 29 4d d0 sub %ecx,-0x30(%ebp) 10ef1c: 74 de je 10eefc <== ALWAYS TAKEN 10ef1e: 0f b6 42 02 movzbl 0x2(%edx),%eax <== NOT EXECUTED 10ef22: 31 ff xor %edi,%edi <== NOT EXECUTED 10ef24: 0f b6 4a 14 movzbl 0x14(%edx),%ecx <== NOT EXECUTED 10ef28: 88 45 c4 mov %al,-0x3c(%ebp) <== NOT EXECUTED 10ef2b: e9 60 ff ff ff jmp 10ee90 <== NOT EXECUTED memcpy(blk_buf + offset, buf, bytes_to_write); 10ef30: 8b 45 e4 mov -0x1c(%ebp),%eax &buffer[bytes_written]); 10ef33: 8b 4d 18 mov 0x18(%ebp),%ecx memcpy(blk_buf + offset, buf, bytes_to_write); 10ef36: 01 c7 add %eax,%edi &buffer[bytes_written]); 10ef38: 8b 45 cc mov -0x34(%ebp),%eax memcpy(blk_buf + offset, buf, bytes_to_write); 10ef3b: 89 7d c4 mov %edi,-0x3c(%ebp) &buffer[bytes_written]); 10ef3e: 01 c8 add %ecx,%eax memcpy(blk_buf + offset, buf, bytes_to_write); 10ef40: 83 fb 08 cmp $0x8,%ebx 10ef43: 89 d9 mov %ebx,%ecx 10ef45: 89 c6 mov %eax,%esi 10ef47: 73 27 jae 10ef70 10ef49: f3 a4 rep movsb %ds:(%esi),%es:(%edi) fs_info->c.modified = true; 10ef4b: c6 82 98 00 00 00 01 movb $0x1,0x98(%edx) return bytes_to_write; 10ef52: 89 d8 mov %ebx,%eax 10ef54: eb 9a jmp 10eef0 10ef56: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10ef5d: 8d 76 00 lea 0x0(%esi),%esi rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &blk_buf); 10ef60: b9 02 00 00 00 mov $0x2,%ecx 10ef65: 89 4c 24 08 mov %ecx,0x8(%esp) 10ef69: e9 6a ff ff ff jmp 10eed8 10ef6e: 66 90 xchg %ax,%ax memcpy(blk_buf + offset, buf, bytes_to_write); 10ef70: f7 c7 01 00 00 00 test $0x1,%edi 10ef76: 75 32 jne 10efaa 10ef78: f7 c7 02 00 00 00 test $0x2,%edi 10ef7e: 75 3a jne 10efba 10ef80: f7 c7 04 00 00 00 test $0x4,%edi 10ef86: 74 c1 je 10ef49 10ef88: 8b 06 mov (%esi),%eax 10ef8a: 83 c7 04 add $0x4,%edi 10ef8d: 83 c6 04 add $0x4,%esi 10ef90: 83 e9 04 sub $0x4,%ecx 10ef93: 89 47 fc mov %eax,-0x4(%edi) 10ef96: eb b1 jmp 10ef49 10ef98: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10ef9f: 90 nop return sector_number >> (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2); 10efa0: 8b 5a 28 mov 0x28(%edx),%ebx 10efa3: d3 eb shr %cl,%ebx return blk; 10efa5: e9 bb fe ff ff jmp 10ee65 memcpy(blk_buf + offset, buf, bytes_to_write); 10efaa: 0f b6 00 movzbl (%eax),%eax 10efad: 47 inc %edi 10efae: 46 inc %esi 10efaf: 8d 4b ff lea -0x1(%ebx),%ecx 10efb2: 88 45 c3 mov %al,-0x3d(%ebp) 10efb5: 88 47 ff mov %al,-0x1(%edi) 10efb8: eb be jmp 10ef78 10efba: 0f b7 06 movzwl (%esi),%eax 10efbd: 83 c7 02 add $0x2,%edi 10efc0: 83 c6 02 add $0x2,%esi 10efc3: 83 e9 02 sub $0x2,%ecx 10efc6: 66 89 47 fe mov %ax,-0x2(%edi) 10efca: eb b4 jmp 10ef80 10efcc: 90 nop 10efcd: 90 nop 10efce: 90 nop 10efcf: 90 nop =============================================================================== 00110950 : { 110950: 55 push %ebp 110951: 89 e5 mov %esp,%ebp 110953: 83 ec 18 sub $0x18,%esp 110956: 89 5d f8 mov %ebx,-0x8(%ebp) 110959: 8b 5d 0c mov 0xc(%ebp),%ebx 11095c: 89 75 fc mov %esi,-0x4(%ebp) 11095f: 8b 75 08 mov 0x8(%ebp),%esi if (fat_fd->links_num > 1) 110962: 8b 43 08 mov 0x8(%ebx),%eax 110965: 83 f8 01 cmp $0x1,%eax 110968: 76 16 jbe 110980 fat_fd->links_num--; 11096a: 48 dec %eax 11096b: 89 43 08 mov %eax,0x8(%ebx) rc = fat_buf_release(fs_info); 11096e: 89 75 08 mov %esi,0x8(%ebp) } 110971: 8b 5d f8 mov -0x8(%ebp),%ebx 110974: 8b 75 fc mov -0x4(%ebp),%esi 110977: 89 ec mov %ebp,%esp 110979: 5d pop %ebp rc = fat_buf_release(fs_info); 11097a: e9 71 df ff ff jmp 10e8f0 11097f: 90 nop fat_file_update(fs_info, fat_fd); 110980: 89 5c 24 04 mov %ebx,0x4(%esp) 110984: 89 34 24 mov %esi,(%esp) 110987: e8 54 fc ff ff call 1105e0 if (fat_fd->flags & FAT_FILE_REMOVED) 11098c: f6 43 30 01 testb $0x1,0x30(%ebx) 110990: 75 1e jne 1109b0 if (fat_ino_is_unique(fs_info, fat_fd->ino)) 110992: 8b 43 0c mov 0xc(%ebx),%eax 110995: 89 34 24 mov %esi,(%esp) 110998: 89 44 24 04 mov %eax,0x4(%esp) 11099c: e8 8f f1 ff ff call 10fb30 1109a1: 84 c0 test %al,%al 1109a3: 74 4b je 1109f0 fat_fd->links_num = 0; 1109a5: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) 1109ac: eb c0 jmp 11096e 1109ae: 66 90 xchg %ax,%ax rc = fat_file_truncate(fs_info, fat_fd, 0); 1109b0: 89 5c 24 04 mov %ebx,0x4(%esp) 1109b4: 31 c0 xor %eax,%eax 1109b6: 89 44 24 08 mov %eax,0x8(%esp) 1109ba: 89 34 24 mov %esi,(%esp) 1109bd: e8 8e fe ff ff call 110850 if (rc == RC_OK) 1109c2: 85 c0 test %eax,%eax 1109c4: 75 a8 jne 11096e <== NEVER TAKEN _hash_delete(fs_info->rhash, key, fat_fd->ino, fat_fd); 1109c6: 8b 4b 0c mov 0xc(%ebx),%ecx next = the_node->next; 1109c9: 8b 13 mov (%ebx),%edx previous = the_node->previous; 1109cb: 8b 43 04 mov 0x4(%ebx),%eax next->previous = previous; 1109ce: 89 42 04 mov %eax,0x4(%edx) previous->next = next; 1109d1: 89 10 mov %edx,(%eax) if (fat_ino_is_unique(fs_info, fat_fd->ino)) 1109d3: 89 4c 24 04 mov %ecx,0x4(%esp) 1109d7: 89 34 24 mov %esi,(%esp) 1109da: e8 51 f1 ff ff call 10fb30 1109df: 84 c0 test %al,%al 1109e1: 75 1d jne 110a00 <== NEVER TAKEN free(fat_fd); 1109e3: 89 1c 24 mov %ebx,(%esp) 1109e6: e8 65 12 ff ff call 101c50 1109eb: eb 81 jmp 11096e 1109ed: 8d 76 00 lea 0x0(%esi),%esi next = the_node->next; 1109f0: 8b 13 mov (%ebx),%edx previous = the_node->previous; 1109f2: 8b 43 04 mov 0x4(%ebx),%eax next->previous = previous; 1109f5: 89 42 04 mov %eax,0x4(%edx) previous->next = next; 1109f8: 89 10 mov %edx,(%eax) 1109fa: eb e7 jmp 1109e3 1109fc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi fat_free_unique_ino(fs_info, fat_fd->ino); 110a00: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 110a03: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 110a06: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 110a0a: e8 f1 f0 ff ff call 10fb00 <== NOT EXECUTED free(fat_fd); 110a0f: eb d2 jmp 1109e3 <== NOT EXECUTED 110a11: 90 nop 110a12: 90 nop 110a13: 90 nop 110a14: 90 nop 110a15: 90 nop 110a16: 90 nop 110a17: 90 nop 110a18: 90 nop 110a19: 90 nop 110a1a: 90 nop 110a1b: 90 nop 110a1c: 90 nop 110a1d: 90 nop 110a1e: 90 nop 110a1f: 90 nop =============================================================================== 00110ad0 : { 110ad0: 55 push %ebp 110ad1: 89 e5 mov %esp,%ebp 110ad3: 83 ec 58 sub $0x58,%esp 110ad6: 89 75 f8 mov %esi,-0x8(%ebp) *a_length = new_length; 110ad9: 8b 45 18 mov 0x18(%ebp),%eax { 110adc: 89 7d fc mov %edi,-0x4(%ebp) *a_length = new_length; 110adf: 8b 75 14 mov 0x14(%ebp),%esi { 110ae2: 89 5d f4 mov %ebx,-0xc(%ebp) 110ae5: 8b 7d 0c mov 0xc(%ebp),%edi uint32_t chain = 0; 110ae8: c7 45 d8 00 00 00 00 movl $0x0,-0x28(%ebp) { 110aef: 0f b6 5d 10 movzbl 0x10(%ebp),%ebx uint32_t last_cl = 0; 110af3: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) *a_length = new_length; 110afa: 89 30 mov %esi,(%eax) if (new_length <= fat_fd->fat_file_size) 110afc: 8b 47 18 mov 0x18(%edi),%eax 110aff: 39 f0 cmp %esi,%eax 110b01: 0f 83 5d 01 00 00 jae 110c64 if ((FAT_FD_OF_ROOT_DIR(fat_fd)) && 110b07: 83 7f 20 01 cmpl $0x1,0x20(%edi) 110b0b: 0f 84 6f 01 00 00 je 110c80 bytes_remain = (fs_info->vol.bpc - 110b11: 8b 4d 08 mov 0x8(%ebp),%ecx 110b14: 8b 71 08 mov 0x8(%ecx),%esi (fat_fd->fat_file_size & (fs_info->vol.bpc - 1))) & 110b17: 89 c1 mov %eax,%ecx 110b19: 8d 56 ff lea -0x1(%esi),%edx 110b1c: 21 d1 and %edx,%ecx 110b1e: 89 4d d0 mov %ecx,-0x30(%ebp) bytes_remain = (fs_info->vol.bpc - 110b21: 29 ce sub %ecx,%esi 110b23: 21 d6 and %edx,%esi bytes2add = new_length - fat_fd->fat_file_size; 110b25: 8b 55 14 mov 0x14(%ebp),%edx 110b28: 29 c2 sub %eax,%edx if (bytes2add > bytes_remain) 110b2a: 39 d6 cmp %edx,%esi 110b2c: 0f 83 2e 01 00 00 jae 110c60 bytes2add -= bytes_remain; 110b32: 29 f2 sub %esi,%edx if (zero_fill && bytes_remain > 0) { 110b34: 85 f6 test %esi,%esi bytes2add -= bytes_remain; 110b36: 89 55 d4 mov %edx,-0x2c(%ebp) if (zero_fill && bytes_remain > 0) { 110b39: 74 08 je 110b43 110b3b: 84 db test %bl,%bl 110b3d: 0f 85 74 01 00 00 jne 110cb7 <== NEVER TAKEN if (bytes2add == 0) 110b43: 8b 45 d4 mov -0x2c(%ebp),%eax 110b46: 85 c0 test %eax,%eax 110b48: 0f 84 16 01 00 00 je 110c64 cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1; 110b4e: 8b 4d 08 mov 0x8(%ebp),%ecx 110b51: 48 dec %eax 110b52: 0f b6 49 0c movzbl 0xc(%ecx),%ecx rc = fat_scan_fat_for_free_clusters(fs_info, &chain, cls2add, 110b56: 89 5c 24 14 mov %ebx,0x14(%esp) cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1; 110b5a: d3 e8 shr %cl,%eax 110b5c: 8d 48 01 lea 0x1(%eax),%ecx rc = fat_scan_fat_for_free_clusters(fs_info, &chain, cls2add, 110b5f: 89 4c 24 08 mov %ecx,0x8(%esp) 110b63: 8d 45 e0 lea -0x20(%ebp),%eax 110b66: 89 44 24 10 mov %eax,0x10(%esp) 110b6a: 8d 45 e4 lea -0x1c(%ebp),%eax 110b6d: 89 44 24 0c mov %eax,0xc(%esp) 110b71: 8d 45 d8 lea -0x28(%ebp),%eax 110b74: 89 44 24 04 mov %eax,0x4(%esp) 110b78: 8b 45 08 mov 0x8(%ebp),%eax 110b7b: 89 4d d0 mov %ecx,-0x30(%ebp) 110b7e: 89 04 24 mov %eax,(%esp) 110b81: e8 ba f4 ff ff call 110040 if (rc != RC_OK) 110b86: 85 c0 test %eax,%eax rc = fat_scan_fat_for_free_clusters(fs_info, &chain, cls2add, 110b88: 89 c2 mov %eax,%edx if (rc != RC_OK) 110b8a: 0f 85 d6 00 00 00 jne 110c66 <== NEVER TAKEN if ((cls_added == 0) && (bytes_remain == 0)) 110b90: 8b 45 e4 mov -0x1c(%ebp),%eax 110b93: 8b 4d d0 mov -0x30(%ebp),%ecx 110b96: 09 c6 or %eax,%esi 110b98: 0f 84 fa 00 00 00 je 110c98 <== NEVER TAKEN if (cls2add != cls_added) 110b9e: 39 c8 cmp %ecx,%eax 110ba0: 74 19 je 110bbb uint32_t missing = (cls2add - cls_added) << fs_info->vol.bpc_log2; 110ba2: 8b 75 08 mov 0x8(%ebp),%esi 110ba5: 89 cb mov %ecx,%ebx 110ba7: 29 c3 sub %eax,%ebx 110ba9: 0f b6 4e 0c movzbl 0xc(%esi),%ecx new_length -= bytes2add < missing ? bytes2add : missing; 110bad: 8b 75 d4 mov -0x2c(%ebp),%esi 110bb0: d3 e3 shl %cl,%ebx 110bb2: 39 f3 cmp %esi,%ebx 110bb4: 76 02 jbe 110bb8 <== NEVER TAKEN 110bb6: 89 f3 mov %esi,%ebx <== NOT EXECUTED 110bb8: 29 5d 14 sub %ebx,0x14(%ebp) <== NOT EXECUTED if (cls_added > 0) 110bbb: 85 c0 test %eax,%eax 110bbd: 0f 84 4d 01 00 00 je 110d10 <== NEVER TAKEN if ( fat_fd->fat_file_size == 0 ) 110bc3: 8b 47 18 mov 0x18(%edi),%eax 110bc6: 85 c0 test %eax,%eax 110bc8: 0f 84 62 01 00 00 je 110d30 if (fat_fd->map.last_cln != FAT_UNDEFINED_VALUE) 110bce: 8b 4f 3c mov 0x3c(%edi),%ecx 110bd1: 83 f9 ff cmp $0xffffffff,%ecx 110bd4: 0f 84 6f 01 00 00 je 110d49 <== NEVER TAKEN old_last_cl = fat_fd->map.last_cln; 110bda: 89 4d dc mov %ecx,-0x24(%ebp) rc = fat_set_fat_cluster(fs_info, old_last_cl, chain); 110bdd: 89 4c 24 04 mov %ecx,0x4(%esp) 110be1: 8b 45 d8 mov -0x28(%ebp),%eax 110be4: 89 55 d4 mov %edx,-0x2c(%ebp) 110be7: 89 44 24 08 mov %eax,0x8(%esp) 110beb: 8b 45 08 mov 0x8(%ebp),%eax 110bee: 89 04 24 mov %eax,(%esp) 110bf1: e8 1a f1 ff ff call 10fd10 if ( rc != RC_OK ) 110bf6: 8b 55 d4 mov -0x2c(%ebp),%edx 110bf9: 85 c0 test %eax,%eax rc = fat_set_fat_cluster(fs_info, old_last_cl, chain); 110bfb: 89 c3 mov %eax,%ebx if ( rc != RC_OK ) 110bfd: 75 44 jne 110c43 <== NEVER TAKEN 110bff: 89 55 d4 mov %edx,-0x2c(%ebp) fat_buf_release(fs_info); 110c02: 8b 45 08 mov 0x8(%ebp),%eax 110c05: 89 04 24 mov %eax,(%esp) 110c08: e8 e3 dc ff ff call 10e8f0 110c0d: 8b 55 d4 mov -0x2c(%ebp),%edx fat_fd->map.last_cln = last_cl; 110c10: 8b 45 e0 mov -0x20(%ebp),%eax 110c13: 89 47 3c mov %eax,0x3c(%edi) if (fat_fd->fat_file_type == FAT_DIRECTORY) 110c16: 8b 47 10 mov 0x10(%edi),%eax 110c19: 85 c0 test %eax,%eax 110c1b: 0f 85 ef 00 00 00 jne 110d10 110c21: 89 55 d4 mov %edx,-0x2c(%ebp) rc = fat_init_clusters_chain(fs_info, chain); 110c24: 8b 45 d8 mov -0x28(%ebp),%eax 110c27: 89 44 24 04 mov %eax,0x4(%esp) 110c2b: 8b 45 08 mov 0x8(%ebp),%eax 110c2e: 89 04 24 mov %eax,(%esp) 110c31: e8 4a ed ff ff call 10f980 if ( rc != RC_OK ) 110c36: 8b 55 d4 mov -0x2c(%ebp),%edx 110c39: 85 c0 test %eax,%eax rc = fat_init_clusters_chain(fs_info, chain); 110c3b: 89 c3 mov %eax,%ebx if ( rc != RC_OK ) 110c3d: 0f 84 cd 00 00 00 je 110d10 <== ALWAYS TAKEN fat_free_fat_clusters_chain(fs_info, chain); 110c43: 8b 45 d8 mov -0x28(%ebp),%eax <== NOT EXECUTED 110c46: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 110c4a: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 110c4d: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 110c50: e8 1b f3 ff ff call 10ff70 <== NOT EXECUTED return rc; 110c55: 89 da mov %ebx,%edx <== NOT EXECUTED 110c57: eb 0d jmp 110c66 <== NOT EXECUTED 110c59: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED if (zero_fill && bytes_remain > 0) { 110c60: 84 db test %bl,%bl 110c62: 75 4c jne 110cb0 return RC_OK; 110c64: 31 d2 xor %edx,%edx } 110c66: 8b 5d f4 mov -0xc(%ebp),%ebx 110c69: 89 d0 mov %edx,%eax 110c6b: 8b 75 f8 mov -0x8(%ebp),%esi 110c6e: 8b 7d fc mov -0x4(%ebp),%edi 110c71: 89 ec mov %ebp,%esp 110c73: 5d pop %ebp 110c74: c3 ret 110c75: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 110c7c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi if ((FAT_FD_OF_ROOT_DIR(fat_fd)) && 110c80: 8b 77 24 mov 0x24(%edi),%esi 110c83: 85 f6 test %esi,%esi 110c85: 0f 85 86 fe ff ff jne 110b11 <== NEVER TAKEN 110c8b: 8b 75 08 mov 0x8(%ebp),%esi 110c8e: f6 46 16 03 testb $0x3,0x16(%esi) 110c92: 0f 84 79 fe ff ff je 110b11 <== NEVER TAKEN rtems_set_errno_and_return_minus_one(ENOSPC); 110c98: e8 03 5c 01 00 call 1268a0 <__errno> 110c9d: ba ff ff ff ff mov $0xffffffff,%edx 110ca2: c7 00 1c 00 00 00 movl $0x1c,(%eax) 110ca8: eb bc jmp 110c66 110caa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi bytes2add = 0; 110cb0: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) uint32_t cl_start = start >> fs_info->vol.bpc_log2; 110cb7: 8b 4d 08 mov 0x8(%ebp),%ecx rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln); 110cba: 89 fa mov %edi,%edx uint32_t cl_start = start >> fs_info->vol.bpc_log2; 110cbc: 0f b6 49 0c movzbl 0xc(%ecx),%ecx 110cc0: d3 e8 shr %cl,%eax 110cc2: 89 c1 mov %eax,%ecx rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln); 110cc4: 8d 45 e4 lea -0x1c(%ebp),%eax 110cc7: 89 04 24 mov %eax,(%esp) 110cca: 8b 45 08 mov 0x8(%ebp),%eax 110ccd: e8 7e f5 ff ff call 110250 if (rc != RC_OK) 110cd2: 85 c0 test %eax,%eax rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln); 110cd4: 89 c2 mov %eax,%edx if (rc != RC_OK) 110cd6: 75 8e jne 110c66 <== NEVER TAKEN bytes_written = fat_cluster_set (fs_info, cur_cln, ofs, bytes_remain, 0); 110cd8: 89 74 24 0c mov %esi,0xc(%esp) <== NOT EXECUTED 110cdc: 8b 45 d0 mov -0x30(%ebp),%eax <== NOT EXECUTED 110cdf: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 110ce1: 89 4c 24 10 mov %ecx,0x10(%esp) <== NOT EXECUTED 110ce5: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED 110ce9: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 110cec: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 110cf0: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 110cf3: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 110cf6: e8 f5 de ff ff call 10ebf0 <== NOT EXECUTED return -1; 110cfb: ba ff ff ff ff mov $0xffffffff,%edx if (bytes_remain != bytes_written) 110d00: 39 f0 cmp %esi,%eax 110d02: 0f 85 5e ff ff ff jne 110c66 <== NEVER TAKEN 110d08: e9 36 fe ff ff jmp 110b43 110d0d: 8d 76 00 lea 0x0(%esi),%esi *a_length = new_length; 110d10: 8b 5d 14 mov 0x14(%ebp),%ebx 110d13: 8b 45 18 mov 0x18(%ebp),%eax 110d16: 89 18 mov %ebx,(%eax) } 110d18: 89 d0 mov %edx,%eax fat_fd->flags |= FAT_FILE_META_DATA_CHANGED; 110d1a: 80 4f 30 02 orb $0x2,0x30(%edi) fat_fd->fat_file_size = s; 110d1e: 89 5f 18 mov %ebx,0x18(%edi) 110d21: 8b 75 f8 mov -0x8(%ebp),%esi 110d24: 8b 5d f4 mov -0xc(%ebp),%ebx 110d27: 8b 7d fc mov -0x4(%ebp),%edi 110d2a: 89 ec mov %ebp,%esp 110d2c: 5d pop %ebp 110d2d: c3 ret 110d2e: 66 90 xchg %ax,%ax fat_fd->map.file_cln = 0; 110d30: c7 47 34 00 00 00 00 movl $0x0,0x34(%edi) fat_fd->map.disk_cln = chain; 110d37: 8b 45 d8 mov -0x28(%ebp),%eax fat_fd->flags |= FAT_FILE_META_DATA_CHANGED; 110d3a: 80 4f 30 02 orb $0x2,0x30(%edi) 110d3e: 89 47 38 mov %eax,0x38(%edi) fat_fd->cln = cln; 110d41: 89 47 1c mov %eax,0x1c(%edi) } 110d44: e9 c7 fe ff ff jmp 110c10 110d49: 89 55 d4 mov %edx,-0x2c(%ebp) <== NOT EXECUTED rc = fat_file_ioctl(fs_info, fat_fd, F_CLU_NUM, 110d4c: 48 dec %eax <== NOT EXECUTED 110d4d: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 110d52: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED 110d56: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 110d59: 8d 4d dc lea -0x24(%ebp),%ecx <== NOT EXECUTED 110d5c: 89 54 24 08 mov %edx,0x8(%esp) <== NOT EXECUTED 110d60: 89 4c 24 10 mov %ecx,0x10(%esp) <== NOT EXECUTED 110d64: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED 110d68: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 110d6b: e8 b0 fc ff ff call 110a20 <== NOT EXECUTED if ( rc != RC_OK ) 110d70: 8b 55 d4 mov -0x2c(%ebp),%edx <== NOT EXECUTED 110d73: 85 c0 test %eax,%eax <== NOT EXECUTED rc = fat_file_ioctl(fs_info, fat_fd, F_CLU_NUM, 110d75: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( rc != RC_OK ) 110d77: 0f 85 c6 fe ff ff jne 110c43 <== NOT EXECUTED rc = fat_set_fat_cluster(fs_info, old_last_cl, chain); 110d7d: 8b 4d dc mov -0x24(%ebp),%ecx <== NOT EXECUTED 110d80: e9 58 fe ff ff jmp 110bdd <== NOT EXECUTED 110d85: 90 nop 110d86: 90 nop 110d87: 90 nop 110d88: 90 nop 110d89: 90 nop 110d8a: 90 nop 110d8b: 90 nop 110d8c: 90 nop 110d8d: 90 nop 110d8e: 90 nop 110d8f: 90 nop =============================================================================== 00110a20 : { 110a20: 55 push %ebp 110a21: 89 e5 mov %esp,%ebp 110a23: 83 ec 28 sub $0x28,%esp switch (cmd) 110a26: 83 7d 10 01 cmpl $0x1,0x10(%ebp) { 110a2a: 89 75 fc mov %esi,-0x4(%ebp) 110a2d: 8b 55 0c mov 0xc(%ebp),%edx 110a30: 89 5d f8 mov %ebx,-0x8(%ebp) 110a33: 8b 75 08 mov 0x8(%ebp),%esi uint32_t cur_cln = 0; 110a36: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) switch (cmd) 110a3d: 75 41 jne 110a80 <== NEVER TAKEN pos = va_arg(ap, uint32_t); 110a3f: 8b 45 14 mov 0x14(%ebp),%eax if ( pos >= fat_fd->fat_file_size ) { 110a42: 39 42 18 cmp %eax,0x18(%edx) ret = va_arg(ap, uint32_t *); 110a45: 8b 5d 18 mov 0x18(%ebp),%ebx if ( pos >= fat_fd->fat_file_size ) { 110a48: 76 66 jbe 110ab0 <== NEVER TAKEN if ((FAT_FD_OF_ROOT_DIR(fat_fd)) && 110a4a: 83 7a 20 01 cmpl $0x1,0x20(%edx) 110a4e: 75 07 jne 110a57 110a50: 8b 4a 24 mov 0x24(%edx),%ecx 110a53: 85 c9 test %ecx,%ecx 110a55: 74 49 je 110aa0 <== ALWAYS TAKEN cl_start = pos >> fs_info->vol.bpc_log2; 110a57: 0f b6 4e 0c movzbl 0xc(%esi),%ecx 110a5b: d3 e8 shr %cl,%eax 110a5d: 89 c1 mov %eax,%ecx rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln); 110a5f: 8d 45 f4 lea -0xc(%ebp),%eax 110a62: 89 04 24 mov %eax,(%esp) 110a65: 89 f0 mov %esi,%eax 110a67: e8 e4 f7 ff ff call 110250 if ( rc != RC_OK ) 110a6c: 85 c0 test %eax,%eax 110a6e: 75 05 jne 110a75 <== NEVER TAKEN *ret = cur_cln; 110a70: 8b 55 f4 mov -0xc(%ebp),%edx 110a73: 89 13 mov %edx,(%ebx) } 110a75: 8b 5d f8 mov -0x8(%ebp),%ebx 110a78: 8b 75 fc mov -0x4(%ebp),%esi 110a7b: 89 ec mov %ebp,%esp 110a7d: 5d pop %ebp 110a7e: c3 ret 110a7f: 90 nop errno = EINVAL; 110a80: e8 1b 5e 01 00 call 1268a0 <__errno> <== NOT EXECUTED } 110a85: 8b 5d f8 mov -0x8(%ebp),%ebx <== NOT EXECUTED 110a88: 8b 75 fc mov -0x4(%ebp),%esi <== NOT EXECUTED errno = EINVAL; 110a8b: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED } 110a91: 89 ec mov %ebp,%esp <== NOT EXECUTED rc = -1; 110a93: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED } 110a98: 5d pop %ebp <== NOT EXECUTED 110a99: c3 ret <== NOT EXECUTED 110a9a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED if ((FAT_FD_OF_ROOT_DIR(fat_fd)) && 110aa0: f6 46 16 03 testb $0x3,0x16(%esi) 110aa4: 74 b1 je 110a57 *ret = 0; 110aa6: c7 03 00 00 00 00 movl $0x0,(%ebx) rc = RC_OK; 110aac: 31 c0 xor %eax,%eax break; 110aae: eb c5 jmp 110a75 rtems_set_errno_and_return_minus_one( EIO ); 110ab0: e8 eb 5d 01 00 call 1268a0 <__errno> <== NOT EXECUTED 110ab5: c7 00 05 00 00 00 movl $0x5,(%eax) <== NOT EXECUTED 110abb: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 110ac0: eb b3 jmp 110a75 <== NOT EXECUTED 110ac2: 90 nop 110ac3: 90 nop 110ac4: 90 nop 110ac5: 90 nop 110ac6: 90 nop 110ac7: 90 nop 110ac8: 90 nop 110ac9: 90 nop 110aca: 90 nop 110acb: 90 nop 110acc: 90 nop 110acd: 90 nop 110ace: 90 nop 110acf: 90 nop =============================================================================== 00111010 : { 111010: 55 push %ebp 111011: 89 e5 mov %esp,%ebp 111013: 56 push %esi 111014: 8b 45 0c mov 0xc(%ebp),%eax 111017: 53 push %ebx 111018: 8b 5d 08 mov 0x8(%ebp),%ebx 11101b: 8b 48 20 mov 0x20(%eax),%ecx 11101e: 8b 50 24 mov 0x24(%eax),%edx if (cln == 1) 111021: 83 f9 01 cmp $0x1,%ecx 111024: 74 00 je 111026 <== NEVER TAKEN next = the_node->next; 111026: 8b 30 mov (%eax),%esi ((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) ); 111028: c1 ea 05 shr $0x5,%edx previous = the_node->previous; 11102b: 8b 48 04 mov 0x4(%eax),%ecx rtems_chain_append_unprotected((hash) + ((key1) % FAT_HASH_MODULE), &(el)->link); 11102e: 83 e2 01 and $0x1,%edx next->previous = previous; 111031: 89 4e 04 mov %ecx,0x4(%esi) previous->next = next; 111034: 89 31 mov %esi,(%ecx) 111036: 8d 0c 52 lea (%edx,%edx,2),%ecx 111039: 8b 93 80 00 00 00 mov 0x80(%ebx),%edx 11103f: 8d 14 8a lea (%edx,%ecx,4),%edx old_last = tail->previous; 111042: 8b 4a 08 mov 0x8(%edx),%ecx return &the_chain->Tail.Node; 111045: 8d 5a 04 lea 0x4(%edx),%ebx 111048: 89 18 mov %ebx,(%eax) tail->previous = the_node; 11104a: 89 42 08 mov %eax,0x8(%edx) old_last->next = the_node; 11104d: 89 01 mov %eax,(%ecx) fat_fd->flags |= FAT_FILE_REMOVED; 11104f: 80 48 30 01 orb $0x1,0x30(%eax) the_node->previous = old_last; 111053: 89 48 04 mov %ecx,0x4(%eax) } 111056: 5b pop %ebx 111057: 5e pop %esi 111058: 5d pop %ebp 111059: c3 ret 11105a: 90 nop 11105b: 90 nop 11105c: 90 nop 11105d: 90 nop 11105e: 90 nop 11105f: 90 nop =============================================================================== 00110310 : { 110310: 55 push %ebp 110311: 89 e5 mov %esp,%ebp 110313: 57 push %edi 110314: 56 push %esi 110315: 53 push %ebx 110316: 83 ec 2c sub $0x2c,%esp 110319: 8b 45 0c mov 0xc(%ebp),%eax 11031c: 8b 5d 08 mov 0x8(%ebp),%ebx 11031f: 8b 10 mov (%eax),%edx 110321: 8b 40 04 mov 0x4(%eax),%eax if (cln == 1) 110324: 83 fa 01 cmp $0x1,%edx 110327: 74 1c je 110345 if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) ) 110329: 85 d2 test %edx,%edx 11032b: 0f 84 bf 01 00 00 je 1104f0 return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) + 110331: 0f b6 4b 05 movzbl 0x5(%ebx),%ecx 110335: 83 ea 02 sub $0x2,%edx 110338: d3 e2 shl %cl,%edx 11033a: 8b 4b 3c mov 0x3c(%ebx),%ecx 11033d: 01 ca add %ecx,%edx fs_info->vol.sec_mul); 11033f: 0f b6 4b 03 movzbl 0x3(%ebx),%ecx return (fat_cluster_num_to_sector_num(fs_info, cln) << 110343: d3 e2 shl %cl,%edx (pos->ofs >> FAT_SECTOR512_BITS)) << 4) + 110345: 89 c1 mov %eax,%ecx rtems_chain_node *the_node = rtems_chain_first(hash + mod); 110347: 8b 7b 7c mov 0x7c(%ebx),%edi 11034a: c1 e9 09 shr $0x9,%ecx ((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) ); 11034d: c1 e8 05 shr $0x5,%eax return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) + 110350: 01 ca add %ecx,%edx (pos->ofs >> FAT_SECTOR512_BITS)) << 4) + 110352: c1 e2 04 shl $0x4,%edx ((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) ); 110355: 83 e0 0f and $0xf,%eax (pos->ofs >> FAT_SECTOR512_BITS)) << 4) + 110358: 8d 34 02 lea (%edx,%eax,1),%esi uint32_t mod = (key1) % FAT_HASH_MODULE; 11035b: 83 e0 01 and $0x1,%eax rtems_chain_node *the_node = rtems_chain_first(hash + mod); 11035e: 8d 04 40 lea (%eax,%eax,2),%eax 110361: c1 e0 02 shl $0x2,%eax 110364: 89 45 d8 mov %eax,-0x28(%ebp) 110367: 01 f8 add %edi,%eax 110369: 89 45 dc mov %eax,-0x24(%ebp) return _Chain_Immutable_head( the_chain )->next; 11036c: 8b 38 mov (%eax),%edi return &the_chain->Tail.Node; 11036e: 83 c0 04 add $0x4,%eax 110371: 89 45 e0 mov %eax,-0x20(%ebp) for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; ) 110374: 39 c7 cmp %eax,%edi 110376: 74 4e je 1103c6 uint32_t ck = fat_construct_key(fs_info, &ffd->dir_pos.sname); 110378: 8b 47 20 mov 0x20(%edi),%eax 11037b: 8b 57 24 mov 0x24(%edi),%edx if (cln == 1) 11037e: 83 f8 01 cmp $0x1,%eax 110381: 74 22 je 1103a5 if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) ) 110383: 85 c0 test %eax,%eax 110385: 75 0a jne 110391 110387: f6 43 16 03 testb $0x3,0x16(%ebx) 11038b: 0f 85 8f 01 00 00 jne 110520 <== ALWAYS TAKEN return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) + 110391: 0f b6 4b 05 movzbl 0x5(%ebx),%ecx 110395: 83 e8 02 sub $0x2,%eax 110398: d3 e0 shl %cl,%eax 11039a: 8b 4b 3c mov 0x3c(%ebx),%ecx 11039d: 01 c8 add %ecx,%eax fs_info->vol.sec_mul); 11039f: 0f b6 4b 03 movzbl 0x3(%ebx),%ecx return (fat_cluster_num_to_sector_num(fs_info, cln) << 1103a3: d3 e0 shl %cl,%eax 1103a5: 89 d1 mov %edx,%ecx 1103a7: c1 e9 09 shr $0x9,%ecx ((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) ); 1103aa: c1 ea 05 shr $0x5,%edx return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) + 1103ad: 01 c1 add %eax,%ecx (pos->ofs >> FAT_SECTOR512_BITS)) << 4) + 1103af: c1 e1 04 shl $0x4,%ecx ((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) ); 1103b2: 83 e2 0f and $0xf,%edx (pos->ofs >> FAT_SECTOR512_BITS)) << 4) + 1103b5: 01 d1 add %edx,%ecx if ( (key1) == ck) 1103b7: 39 ce cmp %ecx,%esi 1103b9: 0f 84 11 01 00 00 je 1104d0 the_node = the_node->next; 1103bf: 8b 3f mov (%edi),%edi for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; ) 1103c1: 3b 7d e0 cmp -0x20(%ebp),%edi 1103c4: 75 b2 jne 110378 rtems_chain_node *the_node = rtems_chain_first(hash + mod); 1103c6: 8b 45 d8 mov -0x28(%ebp),%eax 1103c9: 8b 93 80 00 00 00 mov 0x80(%ebx),%edx 1103cf: 01 d0 add %edx,%eax return _Chain_Immutable_head( the_chain )->next; 1103d1: 8b 38 mov (%eax),%edi return &the_chain->Tail.Node; 1103d3: 83 c0 04 add $0x4,%eax 1103d6: 89 45 e4 mov %eax,-0x1c(%ebp) for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; ) 1103d9: 39 c7 cmp %eax,%edi 1103db: 75 1e jne 1103fb <== NEVER TAKEN 1103dd: e9 4e 01 00 00 jmp 110530 1103e2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 1103e9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi the_node = the_node->next; 1103f0: 8b 3f mov (%edi),%edi <== NOT EXECUTED for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; ) 1103f2: 3b 7d e4 cmp -0x1c(%ebp),%edi <== NOT EXECUTED 1103f5: 0f 84 35 01 00 00 je 110530 <== NOT EXECUTED uint32_t ck = fat_construct_key(fs_info, &ffd->dir_pos.sname); 1103fb: 8b 47 20 mov 0x20(%edi),%eax <== NOT EXECUTED 1103fe: 8b 57 24 mov 0x24(%edi),%edx <== NOT EXECUTED if (cln == 1) 110401: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 110404: 74 22 je 110428 <== NOT EXECUTED if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) ) 110406: 85 c0 test %eax,%eax <== NOT EXECUTED 110408: 75 0a jne 110414 <== NOT EXECUTED 11040a: f6 43 16 03 testb $0x3,0x16(%ebx) <== NOT EXECUTED 11040e: 0f 85 fc 00 00 00 jne 110510 <== NOT EXECUTED return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) + 110414: 0f b6 4b 05 movzbl 0x5(%ebx),%ecx <== NOT EXECUTED 110418: 83 e8 02 sub $0x2,%eax <== NOT EXECUTED 11041b: d3 e0 shl %cl,%eax <== NOT EXECUTED 11041d: 8b 4b 3c mov 0x3c(%ebx),%ecx <== NOT EXECUTED 110420: 01 c8 add %ecx,%eax <== NOT EXECUTED fs_info->vol.sec_mul); 110422: 0f b6 4b 03 movzbl 0x3(%ebx),%ecx <== NOT EXECUTED return (fat_cluster_num_to_sector_num(fs_info, cln) << 110426: d3 e0 shl %cl,%eax <== NOT EXECUTED 110428: 89 d1 mov %edx,%ecx <== NOT EXECUTED 11042a: c1 e9 09 shr $0x9,%ecx <== NOT EXECUTED ((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) ); 11042d: c1 ea 05 shr $0x5,%edx <== NOT EXECUTED return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) + 110430: 01 c1 add %eax,%ecx <== NOT EXECUTED (pos->ofs >> FAT_SECTOR512_BITS)) << 4) + 110432: c1 e1 04 shl $0x4,%ecx <== NOT EXECUTED ((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) ); 110435: 83 e2 0f and $0xf,%edx <== NOT EXECUTED (pos->ofs >> FAT_SECTOR512_BITS)) << 4) + 110438: 01 d1 add %edx,%ecx <== NOT EXECUTED if ( (key1) == ck) 11043a: 39 ce cmp %ecx,%esi <== NOT EXECUTED 11043c: 75 b2 jne 1103f0 <== NOT EXECUTED if ( ((key2) == 0) || ((key2) == ffd->ino) ) 11043e: 85 f6 test %esi,%esi <== NOT EXECUTED 110440: 74 05 je 110447 <== NOT EXECUTED 110442: 3b 77 0c cmp 0xc(%edi),%esi <== NOT EXECUTED 110445: 75 a9 jne 1103f0 <== NOT EXECUTED lfat_fd = (*fat_fd) = (fat_file_fd_t*)calloc(1, sizeof(fat_file_fd_t)); 110447: c7 04 24 01 00 00 00 movl $0x1,(%esp) <== NOT EXECUTED 11044e: b9 50 00 00 00 mov $0x50,%ecx <== NOT EXECUTED 110453: 89 4c 24 04 mov %ecx,0x4(%esp) <== NOT EXECUTED 110457: e8 64 d4 ff ff call 10d8c0 <== NOT EXECUTED 11045c: 89 c7 mov %eax,%edi <== NOT EXECUTED 11045e: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED if ( lfat_fd == NULL ) 110461: 85 ff test %edi,%edi <== NOT EXECUTED lfat_fd = (*fat_fd) = (fat_file_fd_t*)calloc(1, sizeof(fat_file_fd_t)); 110463: 89 38 mov %edi,(%eax) <== NOT EXECUTED if ( lfat_fd == NULL ) 110465: 0f 84 47 01 00 00 je 1105b2 <== NOT EXECUTED lfat_fd->links_num = 1; 11046b: c7 47 08 01 00 00 00 movl $0x1,0x8(%edi) <== NOT EXECUTED lfat_fd->dir_pos = *dir_pos; 110472: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED lfat_fd->flags &= ~FAT_FILE_REMOVED; 110475: 80 67 30 fe andb $0xfe,0x30(%edi) <== NOT EXECUTED lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE; 110479: c7 47 3c ff ff ff ff movl $0xffffffff,0x3c(%edi) <== NOT EXECUTED lfat_fd->dir_pos = *dir_pos; 110480: 8b 00 mov (%eax),%eax <== NOT EXECUTED 110482: 89 47 20 mov %eax,0x20(%edi) <== NOT EXECUTED 110485: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 110488: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 11048b: 89 47 24 mov %eax,0x24(%edi) <== NOT EXECUTED 11048e: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 110491: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 110494: 89 47 28 mov %eax,0x28(%edi) <== NOT EXECUTED 110497: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 11049a: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED 11049d: 89 47 2c mov %eax,0x2c(%edi) <== NOT EXECUTED lfat_fd->ino = fat_get_unique_ino(fs_info); 1104a0: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 1104a3: e8 68 f5 ff ff call 10fa10 <== NOT EXECUTED 1104a8: 89 47 0c mov %eax,0xc(%edi) <== NOT EXECUTED if ( lfat_fd->ino == 0 ) 1104ab: 85 c0 test %eax,%eax <== NOT EXECUTED 1104ad: 0f 84 f2 00 00 00 je 1105a5 <== NOT EXECUTED rtems_chain_append_unprotected((hash) + ((key1) % FAT_HASH_MODULE), &(el)->link); 1104b3: 8b 45 d8 mov -0x28(%ebp),%eax <== NOT EXECUTED 1104b6: 8b 73 7c mov 0x7c(%ebx),%esi <== NOT EXECUTED 1104b9: 01 f0 add %esi,%eax <== NOT EXECUTED 1104bb: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED return &the_chain->Tail.Node; 1104be: 83 c0 04 add $0x4,%eax <== NOT EXECUTED 1104c1: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED 1104c4: e9 bf 00 00 00 jmp 110588 <== NOT EXECUTED 1104c9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED (*fat_fd) = lfat_fd; 1104d0: 8b 45 10 mov 0x10(%ebp),%eax 1104d3: 89 38 mov %edi,(%eax) return rc; 1104d5: 31 c0 xor %eax,%eax lfat_fd->links_num++; 1104d7: ff 47 08 incl 0x8(%edi) } 1104da: 83 c4 2c add $0x2c,%esp 1104dd: 5b pop %ebx 1104de: 5e pop %esi 1104df: 5f pop %edi 1104e0: 5d pop %ebp 1104e1: c3 ret 1104e2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 1104e9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) ) 1104f0: f6 43 16 03 testb $0x3,0x16(%ebx) 1104f4: 0f 84 37 fe ff ff je 110331 <== NEVER TAKEN return fs_info->vol.rdir_loc; 1104fa: 8b 53 28 mov 0x28(%ebx),%edx 1104fd: e9 3d fe ff ff jmp 11033f 110502: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 110509: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 110510: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 110513: e9 0a ff ff ff jmp 110422 <== NOT EXECUTED 110518: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 11051f: 90 nop <== NOT EXECUTED 110520: 8b 43 28 mov 0x28(%ebx),%eax 110523: e9 77 fe ff ff jmp 11039f 110528: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 11052f: 90 nop lfat_fd = (*fat_fd) = (fat_file_fd_t*)calloc(1, sizeof(fat_file_fd_t)); 110530: c7 04 24 01 00 00 00 movl $0x1,(%esp) 110537: bb 50 00 00 00 mov $0x50,%ebx 11053c: 89 5c 24 04 mov %ebx,0x4(%esp) 110540: e8 7b d3 ff ff call 10d8c0 110545: 89 c7 mov %eax,%edi 110547: 8b 45 10 mov 0x10(%ebp),%eax if ( lfat_fd == NULL ) 11054a: 85 ff test %edi,%edi lfat_fd = (*fat_fd) = (fat_file_fd_t*)calloc(1, sizeof(fat_file_fd_t)); 11054c: 89 38 mov %edi,(%eax) if ( lfat_fd == NULL ) 11054e: 74 62 je 1105b2 <== NEVER TAKEN lfat_fd->links_num = 1; 110550: c7 47 08 01 00 00 00 movl $0x1,0x8(%edi) lfat_fd->dir_pos = *dir_pos; 110557: 8b 45 0c mov 0xc(%ebp),%eax lfat_fd->flags &= ~FAT_FILE_REMOVED; 11055a: 80 67 30 fe andb $0xfe,0x30(%edi) lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE; 11055e: c7 47 3c ff ff ff ff movl $0xffffffff,0x3c(%edi) lfat_fd->ino = key; 110565: 89 77 0c mov %esi,0xc(%edi) lfat_fd->dir_pos = *dir_pos; 110568: 8b 00 mov (%eax),%eax 11056a: 89 47 20 mov %eax,0x20(%edi) 11056d: 8b 45 0c mov 0xc(%ebp),%eax 110570: 8b 40 04 mov 0x4(%eax),%eax 110573: 89 47 24 mov %eax,0x24(%edi) 110576: 8b 45 0c mov 0xc(%ebp),%eax 110579: 8b 40 08 mov 0x8(%eax),%eax 11057c: 89 47 28 mov %eax,0x28(%edi) 11057f: 8b 45 0c mov 0xc(%ebp),%eax 110582: 8b 40 0c mov 0xc(%eax),%eax 110585: 89 47 2c mov %eax,0x2c(%edi) old_last = tail->previous; 110588: 8b 75 dc mov -0x24(%ebp),%esi the_node->next = tail; 11058b: 8b 5d e0 mov -0x20(%ebp),%ebx old_last = tail->previous; 11058e: 8b 46 08 mov 0x8(%esi),%eax the_node->next = tail; 110591: 89 1f mov %ebx,(%edi) tail->previous = the_node; 110593: 89 7e 08 mov %edi,0x8(%esi) old_last->next = the_node; 110596: 89 38 mov %edi,(%eax) the_node->previous = old_last; 110598: 89 47 04 mov %eax,0x4(%edi) } 11059b: 83 c4 2c add $0x2c,%esp return RC_OK; 11059e: 31 c0 xor %eax,%eax } 1105a0: 5b pop %ebx 1105a1: 5e pop %esi 1105a2: 5f pop %edi 1105a3: 5d pop %ebp 1105a4: c3 ret free((*fat_fd)); 1105a5: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 1105a8: 8b 00 mov (%eax),%eax <== NOT EXECUTED 1105aa: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 1105ad: e8 9e 16 ff ff call 101c50 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOMEM ); 1105b2: e8 e9 62 01 00 call 1268a0 <__errno> <== NOT EXECUTED 1105b7: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 1105bd: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 1105c2: e9 13 ff ff ff jmp 1104da <== NOT EXECUTED 1105c7: 90 nop 1105c8: 90 nop 1105c9: 90 nop 1105ca: 90 nop 1105cb: 90 nop 1105cc: 90 nop 1105cd: 90 nop 1105ce: 90 nop 1105cf: 90 nop =============================================================================== 00110660 : { 110660: 55 push %ebp 110661: 89 e5 mov %esp,%ebp 110663: 57 push %edi 110664: 56 push %esi 110665: 53 push %ebx 110666: 83 ec 4c sub $0x4c,%esp 110669: 8b 75 14 mov 0x14(%ebp),%esi uint32_t cur_cln = 0; 11066c: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) { 110673: 8b 5d 08 mov 0x8(%ebp),%ebx 110676: 8b 7d 10 mov 0x10(%ebp),%edi if (count == 0) 110679: 85 f6 test %esi,%esi 11067b: 0f 84 0f 01 00 00 je 110790 <== NEVER TAKEN if ( start >= fat_fd->fat_file_size ) 110681: 8b 45 0c mov 0xc(%ebp),%eax 110684: 8b 40 18 mov 0x18(%eax),%eax 110687: 39 f8 cmp %edi,%eax 110689: 0f 86 01 01 00 00 jbe 110790 if ((count > fat_fd->fat_file_size) || 11068f: 39 f0 cmp %esi,%eax 110691: 0f 82 09 01 00 00 jb 1107a0 (start > fat_fd->fat_file_size - count)) 110697: 89 c2 mov %eax,%edx 110699: 29 f2 sub %esi,%edx if ((count > fat_fd->fat_file_size) || 11069b: 39 fa cmp %edi,%edx 11069d: 0f 82 fd 00 00 00 jb 1107a0 if ((FAT_FD_OF_ROOT_DIR(fat_fd)) && 1106a3: 8b 45 0c mov 0xc(%ebp),%eax 1106a6: 83 78 20 01 cmpl $0x1,0x20(%eax) 1106aa: 75 0b jne 1106b7 1106ac: 8b 48 24 mov 0x24(%eax),%ecx 1106af: 85 c9 test %ecx,%ecx 1106b1: 0f 84 f9 00 00 00 je 1107b0 <== ALWAYS TAKEN cl_start = start >> fs_info->vol.bpc_log2; 1106b7: 0f b6 4b 0c movzbl 0xc(%ebx),%ecx rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln); 1106bb: 8d 55 e4 lea -0x1c(%ebp),%edx cl_start = start >> fs_info->vol.bpc_log2; 1106be: 89 f8 mov %edi,%eax 1106c0: d3 e8 shr %cl,%eax 1106c2: 89 45 d0 mov %eax,-0x30(%ebp) 1106c5: 89 c1 mov %eax,%ecx save_ofs = ofs = start & (fs_info->vol.bpc - 1); 1106c7: 8b 43 08 mov 0x8(%ebx),%eax rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln); 1106ca: 89 14 24 mov %edx,(%esp) 1106cd: 8b 55 0c mov 0xc(%ebp),%edx save_ofs = ofs = start & (fs_info->vol.bpc - 1); 1106d0: 89 45 d4 mov %eax,-0x2c(%ebp) rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln); 1106d3: 89 d8 mov %ebx,%eax 1106d5: e8 76 fb ff ff call 110250 if (rc != RC_OK) 1106da: 85 c0 test %eax,%eax 1106dc: 0f 85 b0 00 00 00 jne 110792 <== NEVER TAKEN save_ofs = ofs = start & (fs_info->vol.bpc - 1); 1106e2: 8b 45 d4 mov -0x2c(%ebp),%eax uint32_t cmpltd = 0; 1106e5: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) save_ofs = ofs = start & (fs_info->vol.bpc - 1); 1106ec: 48 dec %eax 1106ed: 21 f8 and %edi,%eax 1106ef: 89 45 cc mov %eax,-0x34(%ebp) 1106f2: 89 c2 mov %eax,%edx 1106f4: eb 75 jmp 11076b 1106f6: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 1106fd: 8d 76 00 lea 0x0(%esi),%esi return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) + 110700: 0f b6 4b 05 movzbl 0x5(%ebx),%ecx 110704: 83 e8 02 sub $0x2,%eax 110707: d3 e0 shl %cl,%eax 110709: 8b 4b 3c mov 0x3c(%ebx),%ecx 11070c: 01 c8 add %ecx,%eax ret = _fat_block_read(fs_info, sec, byte, c, buf + cmpltd); 11070e: 89 7c 24 0c mov %edi,0xc(%esp) 110712: 8b 4d d4 mov -0x2c(%ebp),%ecx 110715: 03 4d 18 add 0x18(%ebp),%ecx 110718: 89 4c 24 10 mov %ecx,0x10(%esp) byte = ofs & (fs_info->vol.bps - 1); 11071c: 0f b7 0b movzwl (%ebx),%ecx 11071f: 49 dec %ecx 110720: 21 d1 and %edx,%ecx ret = _fat_block_read(fs_info, sec, byte, c, buf + cmpltd); 110722: 89 4c 24 08 mov %ecx,0x8(%esp) sec += (ofs >> fs_info->vol.sec_log2); 110726: 0f b6 4b 02 movzbl 0x2(%ebx),%ecx ret = _fat_block_read(fs_info, sec, byte, c, buf + cmpltd); 11072a: 89 1c 24 mov %ebx,(%esp) sec += (ofs >> fs_info->vol.sec_log2); 11072d: d3 ea shr %cl,%edx 11072f: 01 d0 add %edx,%eax ret = _fat_block_read(fs_info, sec, byte, c, buf + cmpltd); 110731: 89 44 24 04 mov %eax,0x4(%esp) 110735: e8 e6 e1 ff ff call 10e920 <_fat_block_read> if ( ret < 0 ) 11073a: 85 c0 test %eax,%eax 11073c: 0f 88 ba 00 00 00 js 1107fc <== NEVER TAKEN cmpltd += c; 110742: 01 7d d4 add %edi,-0x2c(%ebp) count -= c; 110745: 29 fe sub %edi,%esi save_cln = cur_cln; 110747: 8b 7d e4 mov -0x1c(%ebp),%edi rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln); 11074a: 8d 45 e4 lea -0x1c(%ebp),%eax 11074d: 89 44 24 08 mov %eax,0x8(%esp) 110751: 89 1c 24 mov %ebx,(%esp) 110754: 89 7c 24 04 mov %edi,0x4(%esp) 110758: e8 f3 f3 ff ff call 10fb50 if ( rc != RC_OK ) 11075d: 85 c0 test %eax,%eax 11075f: 75 31 jne 110792 <== NEVER TAKEN ofs = 0; 110761: 31 d2 xor %edx,%edx while (count > 0) 110763: 85 f6 test %esi,%esi 110765: 0f 84 a5 00 00 00 je 110810 c = MIN(count, (fs_info->vol.bpc - ofs)); 11076b: 8b 7b 08 mov 0x8(%ebx),%edi 11076e: 29 d7 sub %edx,%edi 110770: 39 f7 cmp %esi,%edi 110772: 76 02 jbe 110776 110774: 89 f7 mov %esi,%edi sec = fat_cluster_num_to_sector_num(fs_info, cur_cln); 110776: 8b 45 e4 mov -0x1c(%ebp),%eax if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) ) 110779: 85 c0 test %eax,%eax 11077b: 75 83 jne 110700 <== ALWAYS TAKEN 11077d: f6 43 16 03 testb $0x3,0x16(%ebx) <== NOT EXECUTED 110781: 0f 84 79 ff ff ff je 110700 <== NOT EXECUTED return fs_info->vol.rdir_loc; 110787: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 11078a: eb 82 jmp 11070e <== NOT EXECUTED 11078c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED return cmpltd; 110790: 31 c0 xor %eax,%eax } 110792: 83 c4 4c add $0x4c,%esp 110795: 5b pop %ebx 110796: 5e pop %esi 110797: 5f pop %edi 110798: 5d pop %ebp 110799: c3 ret 11079a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi count = fat_fd->fat_file_size - start; 1107a0: 29 f8 sub %edi,%eax 1107a2: 89 c6 mov %eax,%esi 1107a4: e9 fa fe ff ff jmp 1106a3 1107a9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi if ((FAT_FD_OF_ROOT_DIR(fat_fd)) && 1107b0: f6 43 16 03 testb $0x3,0x16(%ebx) 1107b4: 0f 84 fd fe ff ff je 1106b7 sec = fat_cluster_num_to_sector_num(fs_info, fat_fd->cln); 1107ba: 8b 40 1c mov 0x1c(%eax),%eax if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) ) 1107bd: 85 c0 test %eax,%eax 1107bf: 74 7f je 110840 <== ALWAYS TAKEN return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) + 1107c1: 0f b6 4b 05 movzbl 0x5(%ebx),%ecx <== NOT EXECUTED 1107c5: 83 e8 02 sub $0x2,%eax <== NOT EXECUTED 1107c8: 8b 53 3c mov 0x3c(%ebx),%edx <== NOT EXECUTED 1107cb: d3 e0 shl %cl,%eax <== NOT EXECUTED 1107cd: 01 d0 add %edx,%eax <== NOT EXECUTED ret = _fat_block_read(fs_info, sec, byte, count, buf); 1107cf: 89 74 24 0c mov %esi,0xc(%esp) 1107d3: 8b 55 18 mov 0x18(%ebp),%edx 1107d6: 89 54 24 10 mov %edx,0x10(%esp) byte = start & (fs_info->vol.bps - 1); 1107da: 0f b7 13 movzwl (%ebx),%edx 1107dd: 4a dec %edx 1107de: 21 fa and %edi,%edx ret = _fat_block_read(fs_info, sec, byte, count, buf); 1107e0: 89 54 24 08 mov %edx,0x8(%esp) sec += (start >> fs_info->vol.sec_log2); 1107e4: 0f b6 4b 02 movzbl 0x2(%ebx),%ecx ret = _fat_block_read(fs_info, sec, byte, count, buf); 1107e8: 89 1c 24 mov %ebx,(%esp) sec += (start >> fs_info->vol.sec_log2); 1107eb: d3 ef shr %cl,%edi 1107ed: 01 f8 add %edi,%eax ret = _fat_block_read(fs_info, sec, byte, count, buf); 1107ef: 89 44 24 04 mov %eax,0x4(%esp) 1107f3: e8 28 e1 ff ff call 10e920 <_fat_block_read> if ( ret < 0 ) 1107f8: 85 c0 test %eax,%eax 1107fa: 79 96 jns 110792 <== ALWAYS TAKEN } 1107fc: 83 c4 4c add $0x4c,%esp <== NOT EXECUTED return -1; 1107ff: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED } 110804: 5b pop %ebx <== NOT EXECUTED 110805: 5e pop %esi <== NOT EXECUTED 110806: 5f pop %edi <== NOT EXECUTED 110807: 5d pop %ebp <== NOT EXECUTED 110808: c3 ret <== NOT EXECUTED 110809: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED ((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2); 110810: 8b 75 d4 mov -0x2c(%ebp),%esi 110813: 8b 45 cc mov -0x34(%ebp),%eax 110816: 0f b6 4b 0c movzbl 0xc(%ebx),%ecx fat_fd->map.file_cln = cl_start + 11081a: 8b 55 d0 mov -0x30(%ebp),%edx ((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2); 11081d: 8d 44 30 ff lea -0x1(%eax,%esi,1),%eax 110821: d3 e8 shr %cl,%eax fat_fd->map.file_cln = cl_start + 110823: 01 d0 add %edx,%eax 110825: 8b 55 0c mov 0xc(%ebp),%edx 110828: 89 42 34 mov %eax,0x34(%edx) return cmpltd; 11082b: 89 f0 mov %esi,%eax fat_fd->map.disk_cln = save_cln; 11082d: 89 7a 38 mov %edi,0x38(%edx) return cmpltd; 110830: e9 5d ff ff ff jmp 110792 110835: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 11083c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi return fs_info->vol.rdir_loc; 110840: 8b 43 28 mov 0x28(%ebx),%eax 110843: eb 8a jmp 1107cf 110845: 90 nop 110846: 90 nop 110847: 90 nop 110848: 90 nop 110849: 90 nop 11084a: 90 nop 11084b: 90 nop 11084c: 90 nop 11084d: 90 nop 11084e: 90 nop 11084f: 90 nop =============================================================================== 00111060 : { 111060: 55 push %ebp 111061: 89 e5 mov %esp,%ebp 111063: 57 push %edi 111064: 56 push %esi 111065: 53 push %ebx 111066: 83 ec 2c sub $0x2c,%esp 111069: 8b 7d 0c mov 0xc(%ebp),%edi 11106c: 8b 5d 08 mov 0x8(%ebp),%ebx uint32_t cur_cln = fat_fd->cln; 11106f: 8b 77 1c mov 0x1c(%edi),%esi if ((FAT_FD_OF_ROOT_DIR(fat_fd)) && 111072: 83 7f 20 01 cmpl $0x1,0x20(%edi) uint32_t cur_cln = fat_fd->cln; 111076: 89 75 e4 mov %esi,-0x1c(%ebp) if ((FAT_FD_OF_ROOT_DIR(fat_fd)) && 111079: 74 65 je 1110e0 fat_fd->fat_file_size = 0; 11107b: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi) while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val) 111082: 8b 43 18 mov 0x18(%ebx),%eax 111085: 21 f0 and %esi,%eax 111087: 39 43 1c cmp %eax,0x1c(%ebx) 11108a: 77 19 ja 1110a5 <== ALWAYS TAKEN 11108c: eb 36 jmp 1110c4 <== NOT EXECUTED 11108e: 66 90 xchg %ax,%ax <== NOT EXECUTED fat_fd->fat_file_size += fs_info->vol.bpc; 111090: 8b 43 08 mov 0x8(%ebx),%eax 111093: 01 47 18 add %eax,0x18(%edi) while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val) 111096: 8b 4b 18 mov 0x18(%ebx),%ecx 111099: 8b 45 e4 mov -0x1c(%ebp),%eax 11109c: 21 c1 and %eax,%ecx 11109e: 3b 4b 1c cmp 0x1c(%ebx),%ecx 1110a1: 73 23 jae 1110c6 1110a3: 89 c6 mov %eax,%esi <== NOT EXECUTED rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln); 1110a5: 89 74 24 04 mov %esi,0x4(%esp) 1110a9: 8d 45 e4 lea -0x1c(%ebp),%eax 1110ac: 89 44 24 08 mov %eax,0x8(%esp) 1110b0: 89 1c 24 mov %ebx,(%esp) 1110b3: e8 98 ea ff ff call 10fb50 if ( rc != RC_OK ) 1110b8: 85 c0 test %eax,%eax 1110ba: 74 d4 je 111090 <== ALWAYS TAKEN } 1110bc: 83 c4 2c add $0x2c,%esp 1110bf: 5b pop %ebx 1110c0: 5e pop %esi 1110c1: 5f pop %edi 1110c2: 5d pop %ebp 1110c3: c3 ret uint32_t save_cln = 0; 1110c4: 31 f6 xor %esi,%esi fat_fd->map.last_cln = save_cln; 1110c6: 89 77 3c mov %esi,0x3c(%edi) } 1110c9: 83 c4 2c add $0x2c,%esp return rc; 1110cc: 31 c0 xor %eax,%eax } 1110ce: 5b pop %ebx 1110cf: 5e pop %esi 1110d0: 5f pop %edi 1110d1: 5d pop %ebp 1110d2: c3 ret 1110d3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 1110da: 8d b6 00 00 00 00 lea 0x0(%esi),%esi if ((FAT_FD_OF_ROOT_DIR(fat_fd)) && 1110e0: 8b 47 24 mov 0x24(%edi),%eax 1110e3: 85 c0 test %eax,%eax 1110e5: 75 94 jne 11107b <== NEVER TAKEN 1110e7: f6 43 16 03 testb $0x3,0x16(%ebx) 1110eb: 74 8e je 11107b fat_fd->fat_file_size = fs_info->vol.rdir_size; 1110ed: 8b 43 34 mov 0x34(%ebx),%eax 1110f0: 89 47 18 mov %eax,0x18(%edi) return rc; 1110f3: 31 c0 xor %eax,%eax 1110f5: eb c5 jmp 1110bc 1110f7: 90 nop 1110f8: 90 nop 1110f9: 90 nop 1110fa: 90 nop 1110fb: 90 nop 1110fc: 90 nop 1110fd: 90 nop 1110fe: 90 nop 1110ff: 90 nop =============================================================================== 00110850 : { 110850: 55 push %ebp 110851: 89 e5 mov %esp,%ebp 110853: 83 ec 38 sub $0x38,%esp 110856: 89 75 f8 mov %esi,-0x8(%ebp) 110859: 8b 75 0c mov 0xc(%ebp),%esi 11085c: 89 5d f4 mov %ebx,-0xc(%ebp) 11085f: 8b 45 10 mov 0x10(%ebp),%eax 110862: 89 7d fc mov %edi,-0x4(%ebp) 110865: 8b 5d 08 mov 0x8(%ebp),%ebx uint32_t cur_cln = 0; 110868: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) uint32_t new_last_cln = FAT_UNDEFINED_VALUE; 11086f: c7 45 e4 ff ff ff ff movl $0xffffffff,-0x1c(%ebp) if ( new_length >= fat_fd->fat_file_size ) 110876: 8b 56 18 mov 0x18(%esi),%edx 110879: 39 c2 cmp %eax,%edx 11087b: 76 73 jbe 1108f0 assert(fat_fd->fat_file_size); 11087d: 85 d2 test %edx,%edx 11087f: 0f 84 a6 00 00 00 je 11092b <== NEVER TAKEN cl_start = (new_length + fs_info->vol.bpc - 1) >> fs_info->vol.bpc_log2; 110885: 8b 7b 08 mov 0x8(%ebx),%edi 110888: 0f b6 4b 0c movzbl 0xc(%ebx),%ecx 11088c: 01 f8 add %edi,%eax 11088e: 8d 78 ff lea -0x1(%eax),%edi 110891: d3 ef shr %cl,%edi if ((cl_start << fs_info->vol.bpc_log2) >= fat_fd->fat_file_size) 110893: 89 f8 mov %edi,%eax 110895: d3 e0 shl %cl,%eax 110897: 39 c2 cmp %eax,%edx 110899: 76 55 jbe 1108f0 if (cl_start != 0) 11089b: 85 ff test %edi,%edi 11089d: 74 16 je 1108b5 rc = fat_file_lseek(fs_info, fat_fd, cl_start - 1, &new_last_cln); 11089f: 8d 45 e4 lea -0x1c(%ebp),%eax 1108a2: 89 f2 mov %esi,%edx 1108a4: 89 04 24 mov %eax,(%esp) 1108a7: 8d 4f ff lea -0x1(%edi),%ecx 1108aa: 89 d8 mov %ebx,%eax 1108ac: e8 9f f9 ff ff call 110250 if (rc != RC_OK) 1108b1: 85 c0 test %eax,%eax 1108b3: 75 3d jne 1108f2 <== NEVER TAKEN rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln); 1108b5: 8d 45 e0 lea -0x20(%ebp),%eax 1108b8: 89 f9 mov %edi,%ecx 1108ba: 89 04 24 mov %eax,(%esp) 1108bd: 89 f2 mov %esi,%edx 1108bf: 89 d8 mov %ebx,%eax 1108c1: e8 8a f9 ff ff call 110250 if (rc != RC_OK) 1108c6: 85 c0 test %eax,%eax 1108c8: 75 28 jne 1108f2 <== NEVER TAKEN rc = fat_free_fat_clusters_chain(fs_info, cur_cln); 1108ca: 89 1c 24 mov %ebx,(%esp) 1108cd: 8b 45 e0 mov -0x20(%ebp),%eax 1108d0: 89 44 24 04 mov %eax,0x4(%esp) 1108d4: e8 97 f6 ff ff call 10ff70 if (rc != RC_OK) 1108d9: 85 c0 test %eax,%eax 1108db: 75 15 jne 1108f2 <== NEVER TAKEN if (cl_start != 0) 1108dd: 85 ff test %edi,%edi 1108df: 75 1f jne 110900 1108e1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 1108e8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 1108ef: 90 nop return rc; 1108f0: 31 c0 xor %eax,%eax } 1108f2: 8b 5d f4 mov -0xc(%ebp),%ebx 1108f5: 8b 75 f8 mov -0x8(%ebp),%esi 1108f8: 8b 7d fc mov -0x4(%ebp),%edi 1108fb: 89 ec mov %ebp,%esp 1108fd: 5d pop %ebp 1108fe: c3 ret 1108ff: 90 nop rc = fat_set_fat_cluster(fs_info, new_last_cln, FAT_GENFAT_EOC); 110900: 89 1c 24 mov %ebx,(%esp) 110903: b8 ff ff ff ff mov $0xffffffff,%eax 110908: 89 44 24 08 mov %eax,0x8(%esp) 11090c: 8b 45 e4 mov -0x1c(%ebp),%eax 11090f: 89 44 24 04 mov %eax,0x4(%esp) 110913: e8 f8 f3 ff ff call 10fd10 if ( rc != RC_OK ) 110918: 85 c0 test %eax,%eax 11091a: 75 d6 jne 1108f2 <== NEVER TAKEN fat_fd->map.disk_cln = new_last_cln; 11091c: 8b 55 e4 mov -0x1c(%ebp),%edx fat_fd->map.file_cln = cl_start - 1; 11091f: 4f dec %edi 110920: 89 7e 34 mov %edi,0x34(%esi) fat_fd->map.disk_cln = new_last_cln; 110923: 89 56 38 mov %edx,0x38(%esi) fat_fd->map.last_cln = new_last_cln; 110926: 89 56 3c mov %edx,0x3c(%esi) 110929: eb c7 jmp 1108f2 assert(fat_fd->fat_file_size); 11092b: c7 44 24 0c 72 35 13 movl $0x133572,0xc(%esp) <== NOT EXECUTED 110932: 00 110933: c7 44 24 08 b4 35 13 movl $0x1335b4,0x8(%esp) <== NOT EXECUTED 11093a: 00 11093b: c7 44 24 04 e4 02 00 movl $0x2e4,0x4(%esp) <== NOT EXECUTED 110942: 00 110943: c7 04 24 88 35 13 00 movl $0x133588,(%esp) <== NOT EXECUTED 11094a: e8 61 7d 00 00 call 1186b0 <__assert_func> <== NOT EXECUTED 11094f: 90 nop =============================================================================== 001105e0 : { 1105e0: 55 push %ebp 1105e1: 89 e5 mov %esp,%ebp 1105e3: 83 ec 18 sub $0x18,%esp 1105e6: 89 5d f8 mov %ebx,-0x8(%ebp) 1105e9: 8b 5d 0c mov 0xc(%ebp),%ebx 1105ec: 89 75 fc mov %esi,-0x4(%ebp) int ret_rc = RC_OK; 1105ef: be 00 00 00 00 mov $0x0,%esi return (fat_fd->flags & FAT_FILE_REMOVED) != 0; 1105f4: 0f b6 43 30 movzbl 0x30(%ebx),%eax 1105f8: 88 c2 mov %al,%dl 1105fa: 80 e2 01 and $0x1,%dl if (!FAT_FILE_IS_REMOVED(fat_fd) && 1105fd: 75 4c jne 11064b 1105ff: 24 02 and $0x2,%al 110601: 74 48 je 11064b FAT_FILE_HAS_META_DATA_CHANGED(fat_fd) && 110603: 83 7b 20 01 cmpl $0x1,0x20(%ebx) 110607: 75 07 jne 110610 !FAT_FD_OF_ROOT_DIR(fat_fd)) 110609: 8b 43 24 mov 0x24(%ebx),%eax 11060c: 85 c0 test %eax,%eax 11060e: 74 3b je 11064b <== ALWAYS TAKEN rc = fat_file_write_first_cluster_num(fs_info, fat_fd); 110610: 89 5c 24 04 mov %ebx,0x4(%esp) 110614: 8b 45 08 mov 0x8(%ebp),%eax 110617: 89 04 24 mov %eax,(%esp) 11061a: e8 91 1b 00 00 call 1121b0 rc = fat_file_write_file_size(fs_info, fat_fd); 11061f: 89 5c 24 04 mov %ebx,0x4(%esp) rc = fat_file_write_first_cluster_num(fs_info, fat_fd); 110623: 89 c6 mov %eax,%esi rc = fat_file_write_file_size(fs_info, fat_fd); 110625: 8b 45 08 mov 0x8(%ebp),%eax 110628: 89 04 24 mov %eax,(%esp) 11062b: e8 50 1c 00 00 call 112280 if (rc != RC_OK) 110630: 85 c0 test %eax,%eax 110632: 74 02 je 110636 <== ALWAYS TAKEN 110634: 89 c6 mov %eax,%esi <== NOT EXECUTED rc = fat_file_write_time_and_date(fs_info, fat_fd); 110636: 89 5c 24 04 mov %ebx,0x4(%esp) 11063a: 8b 45 08 mov 0x8(%ebp),%eax 11063d: 89 04 24 mov %eax,(%esp) 110640: e8 db 19 00 00 call 112020 if (rc != RC_OK) 110645: 85 c0 test %eax,%eax 110647: 74 02 je 11064b <== ALWAYS TAKEN 110649: 89 c6 mov %eax,%esi <== NOT EXECUTED } 11064b: 8b 5d f8 mov -0x8(%ebp),%ebx 11064e: 89 f0 mov %esi,%eax 110650: 8b 75 fc mov -0x4(%ebp),%esi 110653: 89 ec mov %ebp,%esp 110655: 5d pop %ebp 110656: c3 ret 110657: 90 nop 110658: 90 nop 110659: 90 nop 11065a: 90 nop 11065b: 90 nop 11065c: 90 nop 11065d: 90 nop 11065e: 90 nop 11065f: 90 nop =============================================================================== 00110d90 : { 110d90: 55 push %ebp 110d91: 89 e5 mov %esp,%ebp 110d93: 57 push %edi 110d94: 56 push %esi 110d95: 53 push %ebx 110d96: 83 ec 4c sub $0x4c,%esp 110d99: 8b 45 14 mov 0x14(%ebp),%eax uint32_t c = 0; 110d9c: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) { 110da3: 8b 7d 08 mov 0x8(%ebp),%edi 110da6: 8b 75 10 mov 0x10(%ebp),%esi if ( count == 0 ) 110da9: 85 c0 test %eax,%eax 110dab: 0f 84 4f 01 00 00 je 110f00 <== NEVER TAKEN if (start >= fat_fd->size_limit) 110db1: 8b 4d 0c mov 0xc(%ebp),%ecx 110db4: 8b 59 14 mov 0x14(%ecx),%ebx 110db7: 39 f3 cmp %esi,%ebx 110db9: 0f 86 2f 02 00 00 jbe 110fee <== NEVER TAKEN if (count > fat_fd->size_limit - start) 110dbf: 29 f3 sub %esi,%ebx 110dc1: 39 c3 cmp %eax,%ebx 110dc3: 0f 87 27 01 00 00 ja 110ef0 <== ALWAYS TAKEN rc = fat_file_extend(fs_info, fat_fd, zero_fill, start + count, &c); 110dc9: 8d 45 e0 lea -0x20(%ebp),%eax 110dcc: 89 44 24 10 mov %eax,0x10(%esp) bool zero_fill = start > fat_fd->fat_file_size; 110dd0: 8b 45 0c mov 0xc(%ebp),%eax rc = fat_file_extend(fs_info, fat_fd, zero_fill, start + count, &c); 110dd3: 8d 14 33 lea (%ebx,%esi,1),%edx 110dd6: 89 54 24 0c mov %edx,0xc(%esp) 110dda: 89 55 d4 mov %edx,-0x2c(%ebp) bool zero_fill = start > fat_fd->fat_file_size; 110ddd: 39 70 18 cmp %esi,0x18(%eax) rc = fat_file_extend(fs_info, fat_fd, zero_fill, start + count, &c); 110de0: 89 3c 24 mov %edi,(%esp) bool zero_fill = start > fat_fd->fat_file_size; 110de3: 0f 92 c0 setb %al 110de6: 0f b6 c0 movzbl %al,%eax rc = fat_file_extend(fs_info, fat_fd, zero_fill, start + count, &c); 110de9: 89 44 24 08 mov %eax,0x8(%esp) 110ded: 8b 45 0c mov 0xc(%ebp),%eax 110df0: 89 44 24 04 mov %eax,0x4(%esp) 110df4: e8 d7 fc ff ff call 110ad0 if (RC_OK == rc) 110df9: 85 c0 test %eax,%eax 110dfb: 0f 85 e6 00 00 00 jne 110ee7 if (c != (start + count)) 110e01: 8b 45 e0 mov -0x20(%ebp),%eax 110e04: 8b 55 d4 mov -0x2c(%ebp),%edx 110e07: 39 c2 cmp %eax,%edx 110e09: 74 04 je 110e0f count = c - start; 110e0b: 29 f0 sub %esi,%eax 110e0d: 89 c3 mov %eax,%ebx cln += (start >> fs_info->vol.bpc_log2); 110e0f: 0f b6 47 0c movzbl 0xc(%edi),%eax 110e13: 89 f2 mov %esi,%edx 110e15: 89 45 d4 mov %eax,-0x2c(%ebp) 110e18: 88 c1 mov %al,%cl return (FAT_FD_OF_ROOT_DIR(fat_fd)) && (volume_type & (FAT_FAT12 | FAT_FAT16)); 110e1a: 8b 45 0c mov 0xc(%ebp),%eax cln += (start >> fs_info->vol.bpc_log2); 110e1d: d3 ea shr %cl,%edx 110e1f: 89 55 d0 mov %edx,-0x30(%ebp) return (FAT_FD_OF_ROOT_DIR(fat_fd)) && (volume_type & (FAT_FAT12 | FAT_FAT16)); 110e22: 83 78 20 01 cmpl $0x1,0x20(%eax) 110e26: 0f 84 24 01 00 00 je 110f50 rc = fat_file_lseek(fs_info, fat_fd, start_cln, &cur_cln); 110e2c: 8b 4d d0 mov -0x30(%ebp),%ecx 110e2f: 8d 45 e4 lea -0x1c(%ebp),%eax 110e32: 89 04 24 mov %eax,(%esp) 110e35: 8b 55 0c mov 0xc(%ebp),%edx 110e38: 89 f8 mov %edi,%eax uint32_t cur_cln = 0; 110e3a: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) rc = fat_file_lseek(fs_info, fat_fd, start_cln, &cur_cln); 110e41: e8 0a f4 ff ff call 110250 if (RC_OK == rc) 110e46: 85 c0 test %eax,%eax 110e48: 0f 85 91 00 00 00 jne 110edf <== NEVER TAKEN uint32_t ofs_cln = start - (start_cln << fs_info->vol.bpc_log2); 110e4e: 0f b6 4d d4 movzbl -0x2c(%ebp),%ecx uint32_t save_cln = 0; /* FIXME: This might be incorrect, cf. below */ 110e52: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) uint32_t ofs_cln = start - (start_cln << fs_info->vol.bpc_log2); 110e59: 8b 55 d0 mov -0x30(%ebp),%edx 110e5c: d3 e2 shl %cl,%edx 110e5e: 89 d1 mov %edx,%ecx 110e60: 89 f2 mov %esi,%edx 110e62: 29 ca sub %ecx,%edx uint32_t cmpltd = 0; 110e64: 31 f6 xor %esi,%esi ((ofs_cln_save + cmpltd - 1) >> fs_info->vol.bpc_log2); 110e66: 8d 4a ff lea -0x1(%edx),%ecx while ( (RC_OK == rc) 110e69: 85 db test %ebx,%ebx ((ofs_cln_save + cmpltd - 1) >> fs_info->vol.bpc_log2); 110e6b: 89 4d cc mov %ecx,-0x34(%ebp) while ( (RC_OK == rc) 110e6e: 0f 84 5a 01 00 00 je 110fce <== NEVER TAKEN 110e74: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 110e7b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 110e7f: 90 nop &buf[cmpltd]); 110e80: 8b 45 18 mov 0x18(%ebp),%eax 110e83: 01 f0 add %esi,%eax ret = fat_cluster_write(fs_info, 110e85: 89 44 24 10 mov %eax,0x10(%esp) c = MIN(bytes_to_write, (fs_info->vol.bpc - ofs_cln)); 110e89: 8b 47 08 mov 0x8(%edi),%eax 110e8c: 29 d0 sub %edx,%eax 110e8e: 39 d8 cmp %ebx,%eax 110e90: 76 02 jbe 110e94 110e92: 89 d8 mov %ebx,%eax ret = fat_cluster_write(fs_info, 110e94: 89 44 24 0c mov %eax,0xc(%esp) 110e98: 8b 45 e4 mov -0x1c(%ebp),%eax 110e9b: 89 54 24 08 mov %edx,0x8(%esp) 110e9f: 89 3c 24 mov %edi,(%esp) 110ea2: 89 44 24 04 mov %eax,0x4(%esp) 110ea6: e8 55 df ff ff call 10ee00 if (0 > ret) 110eab: 85 c0 test %eax,%eax 110ead: 0f 88 fd 00 00 00 js 110fb0 <== NEVER TAKEN save_cln = cur_cln; 110eb3: 8b 4d e4 mov -0x1c(%ebp),%ecx cmpltd += ret; 110eb6: 01 c6 add %eax,%esi if (0 < bytes_to_write) 110eb8: 29 c3 sub %eax,%ebx save_cln = cur_cln; 110eba: 89 4d d4 mov %ecx,-0x2c(%ebp) if (0 < bytes_to_write) 110ebd: 75 51 jne 110f10 ((ofs_cln_save + cmpltd - 1) >> fs_info->vol.bpc_log2); 110ebf: 8b 45 cc mov -0x34(%ebp),%eax 110ec2: 0f b6 4f 0c movzbl 0xc(%edi),%ecx 110ec6: 01 f0 add %esi,%eax 110ec8: d3 e8 shr %cl,%eax fat_fd->map.file_cln = start_cln + 110eca: 8b 4d d0 mov -0x30(%ebp),%ecx 110ecd: 01 c8 add %ecx,%eax 110ecf: 8b 4d 0c mov 0xc(%ebp),%ecx 110ed2: 89 41 34 mov %eax,0x34(%ecx) fat_fd->map.disk_cln = save_cln; 110ed5: 89 c8 mov %ecx,%eax 110ed7: 8b 4d d4 mov -0x2c(%ebp),%ecx 110eda: 89 48 38 mov %ecx,0x38(%eax) return cmpltd; 110edd: 89 f0 mov %esi,%eax if (0 > ret) 110edf: 85 c0 test %eax,%eax 110ee1: 0f 88 b2 00 00 00 js 110f99 <== NEVER TAKEN } 110ee7: 83 c4 4c add $0x4c,%esp 110eea: 5b pop %ebx 110eeb: 5e pop %esi 110eec: 5f pop %edi 110eed: 5d pop %ebp 110eee: c3 ret 110eef: 90 nop 110ef0: 89 c3 mov %eax,%ebx 110ef2: e9 d2 fe ff ff jmp 110dc9 110ef7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 110efe: 66 90 xchg %ax,%ax 110f00: 83 c4 4c add $0x4c,%esp <== NOT EXECUTED return cmpltd; 110f03: 31 c0 xor %eax,%eax <== NOT EXECUTED } 110f05: 5b pop %ebx <== NOT EXECUTED 110f06: 5e pop %esi <== NOT EXECUTED 110f07: 5f pop %edi <== NOT EXECUTED 110f08: 5d pop %ebp <== NOT EXECUTED 110f09: c3 ret <== NOT EXECUTED 110f0a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln); 110f10: 89 4c 24 04 mov %ecx,0x4(%esp) 110f14: 8d 45 e4 lea -0x1c(%ebp),%eax 110f17: 89 44 24 08 mov %eax,0x8(%esp) 110f1b: 89 3c 24 mov %edi,(%esp) 110f1e: e8 2d ec ff ff call 10fb50 ofs_cln = 0; 110f23: 31 d2 xor %edx,%edx while ( (RC_OK == rc) 110f25: 85 c0 test %eax,%eax 110f27: 0f 84 53 ff ff ff je 110e80 <== ALWAYS TAKEN ((ofs_cln_save + cmpltd - 1) >> fs_info->vol.bpc_log2); 110f2d: 0f b6 4f 0c movzbl 0xc(%edi),%ecx <== NOT EXECUTED 110f31: 03 75 cc add -0x34(%ebp),%esi <== NOT EXECUTED fat_fd->map.file_cln = start_cln + 110f34: 8b 55 d0 mov -0x30(%ebp),%edx <== NOT EXECUTED fat_fd->map.disk_cln = save_cln; 110f37: 8b 7d d4 mov -0x2c(%ebp),%edi <== NOT EXECUTED ((ofs_cln_save + cmpltd - 1) >> fs_info->vol.bpc_log2); 110f3a: d3 ee shr %cl,%esi <== NOT EXECUTED fat_fd->map.file_cln = start_cln + 110f3c: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 110f3f: 01 f2 add %esi,%edx <== NOT EXECUTED 110f41: 89 51 34 mov %edx,0x34(%ecx) <== NOT EXECUTED fat_fd->map.disk_cln = save_cln; 110f44: 89 79 38 mov %edi,0x38(%ecx) <== NOT EXECUTED if (RC_OK != rc) 110f47: eb 96 jmp 110edf <== NOT EXECUTED 110f49: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED return (FAT_FD_OF_ROOT_DIR(fat_fd)) && (volume_type & (FAT_FAT12 | FAT_FAT16)); 110f50: 8b 40 24 mov 0x24(%eax),%eax 110f53: 85 c0 test %eax,%eax 110f55: 0f 85 d1 fe ff ff jne 110e2c <== NEVER TAKEN 110f5b: f6 47 16 03 testb $0x3,0x16(%edi) 110f5f: 0f 84 c7 fe ff ff je 110e2c ret = fat_cluster_write(fs_info, 110f65: 89 5c 24 0c mov %ebx,0xc(%esp) 110f69: 8b 45 18 mov 0x18(%ebp),%eax cln += (start >> fs_info->vol.bpc_log2); 110f6c: 8b 4d 0c mov 0xc(%ebp),%ecx ret = fat_cluster_write(fs_info, 110f6f: 89 44 24 10 mov %eax,0x10(%esp) byte = start & (fs_info->vol.bpc -1); 110f73: 8b 47 08 mov 0x8(%edi),%eax 110f76: 48 dec %eax 110f77: 21 c6 and %eax,%esi cln += (start >> fs_info->vol.bpc_log2); 110f79: 8b 45 d0 mov -0x30(%ebp),%eax ret = fat_cluster_write(fs_info, 110f7c: 89 74 24 08 mov %esi,0x8(%esp) cln += (start >> fs_info->vol.bpc_log2); 110f80: 8b 71 1c mov 0x1c(%ecx),%esi ret = fat_cluster_write(fs_info, 110f83: 89 3c 24 mov %edi,(%esp) cln += (start >> fs_info->vol.bpc_log2); 110f86: 01 f0 add %esi,%eax ret = fat_cluster_write(fs_info, 110f88: 89 44 24 04 mov %eax,0x4(%esp) 110f8c: e8 6f de ff ff call 10ee00 if (0 > ret) 110f91: 85 c0 test %eax,%eax 110f93: 0f 89 4e ff ff ff jns 110ee7 <== ALWAYS TAKEN rc = -1; 110f99: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 110f9e: e9 44 ff ff ff jmp 110ee7 <== NOT EXECUTED 110fa3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 110faa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED ((ofs_cln_save + cmpltd - 1) >> fs_info->vol.bpc_log2); 110fb0: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED 110fb3: 0f b6 4f 0c movzbl 0xc(%edi),%ecx <== NOT EXECUTED fat_fd->map.file_cln = start_cln + 110fb7: 8b 55 d0 mov -0x30(%ebp),%edx <== NOT EXECUTED ((ofs_cln_save + cmpltd - 1) >> fs_info->vol.bpc_log2); 110fba: 01 c6 add %eax,%esi <== NOT EXECUTED fat_fd->map.file_cln = start_cln + 110fbc: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED ((ofs_cln_save + cmpltd - 1) >> fs_info->vol.bpc_log2); 110fbf: d3 ee shr %cl,%esi <== NOT EXECUTED fat_fd->map.disk_cln = save_cln; 110fc1: 8b 4d d4 mov -0x2c(%ebp),%ecx <== NOT EXECUTED fat_fd->map.file_cln = start_cln + 110fc4: 01 d6 add %edx,%esi <== NOT EXECUTED 110fc6: 89 70 34 mov %esi,0x34(%eax) <== NOT EXECUTED fat_fd->map.disk_cln = save_cln; 110fc9: 89 48 38 mov %ecx,0x38(%eax) <== NOT EXECUTED if (0 > ret) 110fcc: eb cb jmp 110f99 <== NOT EXECUTED ((ofs_cln_save + cmpltd - 1) >> fs_info->vol.bpc_log2); 110fce: 0f b6 4f 0c movzbl 0xc(%edi),%ecx <== NOT EXECUTED 110fd2: 8b 55 cc mov -0x34(%ebp),%edx <== NOT EXECUTED fat_fd->map.file_cln = start_cln + 110fd5: 8b 5d d0 mov -0x30(%ebp),%ebx <== NOT EXECUTED ((ofs_cln_save + cmpltd - 1) >> fs_info->vol.bpc_log2); 110fd8: d3 ea shr %cl,%edx <== NOT EXECUTED fat_fd->map.file_cln = start_cln + 110fda: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 110fdd: 01 da add %ebx,%edx <== NOT EXECUTED 110fdf: 89 51 34 mov %edx,0x34(%ecx) <== NOT EXECUTED fat_fd->map.disk_cln = save_cln; 110fe2: c7 41 38 00 00 00 00 movl $0x0,0x38(%ecx) <== NOT EXECUTED if (0 > ret) 110fe9: e9 f9 fe ff ff jmp 110ee7 <== NOT EXECUTED rtems_set_errno_and_return_minus_one(EFBIG); 110fee: e8 ad 58 01 00 call 1268a0 <__errno> <== NOT EXECUTED 110ff3: c7 00 1b 00 00 00 movl $0x1b,(%eax) <== NOT EXECUTED 110ff9: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 110ffe: e9 e4 fe ff ff jmp 110ee7 <== NOT EXECUTED 111003: 90 nop 111004: 90 nop 111005: 90 nop 111006: 90 nop 111007: 90 nop 111008: 90 nop 111009: 90 nop 11100a: 90 nop 11100b: 90 nop 11100c: 90 nop 11100d: 90 nop 11100e: 90 nop 11100f: 90 nop =============================================================================== 00112280 : { 112280: 55 push %ebp 112281: 89 e5 mov %esp,%ebp 112283: 83 ec 48 sub $0x48,%esp 112286: 89 5d f4 mov %ebx,-0xc(%ebp) 112289: 8b 5d 0c mov 0xc(%ebp),%ebx 11228c: 89 75 f8 mov %esi,-0x8(%ebp) 11228f: 8b 55 08 mov 0x8(%ebp),%edx 112292: 89 7d fc mov %edi,-0x4(%ebp) uint32_t le_new_length = 0; 112295: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) sec = fat_cluster_num_to_sector_num(fs_info, fat_fd->dir_pos.sname.cln); 11229c: 8b 4b 20 mov 0x20(%ebx),%ecx if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) ) 11229f: 85 c9 test %ecx,%ecx 1122a1: 75 06 jne 1122a9 1122a3: f6 42 16 03 testb $0x3,0x16(%edx) 1122a7: 75 67 jne 112310 <== ALWAYS TAKEN return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) + 1122a9: 8d 41 fe lea -0x2(%ecx),%eax 1122ac: 0f b6 4a 05 movzbl 0x5(%edx),%ecx 1122b0: 8b 7a 3c mov 0x3c(%edx),%edi 1122b3: d3 e0 shl %cl,%eax 1122b5: 01 f8 add %edi,%eax sec += (fat_fd->dir_pos.sname.ofs >> fs_info->vol.sec_log2); 1122b7: 8b 73 24 mov 0x24(%ebx),%esi 1122ba: 0f b6 4a 02 movzbl 0x2(%edx),%ecx 1122be: 89 f7 mov %esi,%edi 1122c0: d3 ef shr %cl,%edi 1122c2: 89 f9 mov %edi,%ecx 1122c4: 01 c1 add %eax,%ecx byte = (fat_fd->dir_pos.sname.ofs & (fs_info->vol.bps - 1)); 1122c6: 0f b7 02 movzwl (%edx),%eax 1122c9: 48 dec %eax 1122ca: 21 f0 and %esi,%eax if (fat_fd->fat_file_type == FAT_DIRECTORY) { 1122cc: 8b 73 10 mov 0x10(%ebx),%esi 1122cf: 85 f6 test %esi,%esi 1122d1: 74 06 je 1122d9 le_new_length = CT_LE_L(fat_fd->fat_file_size); 1122d3: 8b 5b 18 mov 0x18(%ebx),%ebx 1122d6: 89 5d e4 mov %ebx,-0x1c(%ebp) ret = fat_sector_write(fs_info, sec, byte + MSDOS_FILE_SIZE_OFFSET, 4, 1122d9: 89 4c 24 04 mov %ecx,0x4(%esp) 1122dd: 8d 5d e4 lea -0x1c(%ebp),%ebx 1122e0: 83 c0 1c add $0x1c,%eax 1122e3: 89 5c 24 10 mov %ebx,0x10(%esp) 1122e7: bb 04 00 00 00 mov $0x4,%ebx 1122ec: 89 5c 24 0c mov %ebx,0xc(%esp) 1122f0: 89 44 24 08 mov %eax,0x8(%esp) 1122f4: 89 14 24 mov %edx,(%esp) 1122f7: e8 b4 c7 ff ff call 10eab0 } 1122fc: 8b 5d f4 mov -0xc(%ebp),%ebx 1122ff: 8b 75 f8 mov -0x8(%ebp),%esi 112302: 8b 7d fc mov -0x4(%ebp),%edi 112305: 89 ec mov %ebp,%esp 112307: 5d pop %ebp if ( ret < 0 ) 112308: c1 f8 1f sar $0x1f,%eax } 11230b: c3 ret 11230c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi return fs_info->vol.rdir_loc; 112310: 8b 42 28 mov 0x28(%edx),%eax 112313: eb a2 jmp 1122b7 112315: 90 nop 112316: 90 nop 112317: 90 nop 112318: 90 nop 112319: 90 nop 11231a: 90 nop 11231b: 90 nop 11231c: 90 nop 11231d: 90 nop 11231e: 90 nop 11231f: 90 nop =============================================================================== 001121b0 : { 1121b0: 55 push %ebp 1121b1: 89 e5 mov %esp,%ebp 1121b3: 57 push %edi 1121b4: 56 push %esi 1121b5: 53 push %ebx 1121b6: 83 ec 4c sub $0x4c,%esp uint16_t le_cl_hi = 0; 1121b9: 66 c7 45 e6 00 00 movw $0x0,-0x1a(%ebp) { 1121bf: 8b 5d 0c mov 0xc(%ebp),%ebx 1121c2: 8b 75 08 mov 0x8(%ebp),%esi sec = fat_cluster_num_to_sector_num(fs_info, fat_fd->dir_pos.sname.cln); 1121c5: 8b 43 20 mov 0x20(%ebx),%eax uint32_t new_cln = fat_fd->cln; 1121c8: 8b 53 1c mov 0x1c(%ebx),%edx if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) ) 1121cb: 85 c0 test %eax,%eax 1121cd: 75 0a jne 1121d9 1121cf: f6 46 16 03 testb $0x3,0x16(%esi) 1121d3: 0f 85 97 00 00 00 jne 112270 <== ALWAYS TAKEN return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) + 1121d9: 0f b6 4e 05 movzbl 0x5(%esi),%ecx 1121dd: 83 e8 02 sub $0x2,%eax 1121e0: d3 e0 shl %cl,%eax 1121e2: 8b 4e 3c mov 0x3c(%esi),%ecx 1121e5: 01 c8 add %ecx,%eax le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF)); 1121e7: 66 89 55 e4 mov %dx,-0x1c(%ebp) sec += (fat_fd->dir_pos.sname.ofs >> fs_info->vol.sec_log2); 1121eb: 8b 7b 24 mov 0x24(%ebx),%edi le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF)); 1121ee: 89 55 d0 mov %edx,-0x30(%ebp) sec += (fat_fd->dir_pos.sname.ofs >> fs_info->vol.sec_log2); 1121f1: 0f b6 4e 02 movzbl 0x2(%esi),%ecx 1121f5: 89 fb mov %edi,%ebx 1121f7: d3 eb shr %cl,%ebx 1121f9: 89 d9 mov %ebx,%ecx byte = fat_fd->dir_pos.sname.ofs & (fs_info->vol.bps - 1); 1121fb: 0f b7 1e movzwl (%esi),%ebx ret1 = fat_sector_write(fs_info, sec, 1121fe: 89 34 24 mov %esi,(%esp) sec += (fat_fd->dir_pos.sname.ofs >> fs_info->vol.sec_log2); 112201: 01 c1 add %eax,%ecx ret1 = fat_sector_write(fs_info, sec, 112203: 89 4c 24 04 mov %ecx,0x4(%esp) 112207: 8d 45 e4 lea -0x1c(%ebp),%eax 11220a: 89 44 24 10 mov %eax,0x10(%esp) 11220e: b8 02 00 00 00 mov $0x2,%eax 112213: 89 44 24 0c mov %eax,0xc(%esp) byte = fat_fd->dir_pos.sname.ofs & (fs_info->vol.bps - 1); 112217: 4b dec %ebx ret1 = fat_sector_write(fs_info, sec, 112218: 89 4d d4 mov %ecx,-0x2c(%ebp) byte = fat_fd->dir_pos.sname.ofs & (fs_info->vol.bps - 1); 11221b: 21 fb and %edi,%ebx ret1 = fat_sector_write(fs_info, sec, 11221d: 8d 43 1a lea 0x1a(%ebx),%eax ret2 = fat_sector_write(fs_info, sec, 112220: 83 c3 14 add $0x14,%ebx ret1 = fat_sector_write(fs_info, sec, 112223: 89 44 24 08 mov %eax,0x8(%esp) 112227: e8 84 c8 ff ff call 10eab0 le_cl_hi = CT_LE_W((uint16_t )((new_cln & 0xFFFF0000) >> 16)); 11222c: 8b 55 d0 mov -0x30(%ebp),%edx ret2 = fat_sector_write(fs_info, sec, 11222f: 89 5c 24 08 mov %ebx,0x8(%esp) 112233: 8b 4d d4 mov -0x2c(%ebp),%ecx 112236: 89 34 24 mov %esi,(%esp) le_cl_hi = CT_LE_W((uint16_t )((new_cln & 0xFFFF0000) >> 16)); 112239: c1 ea 10 shr $0x10,%edx 11223c: 66 89 55 e6 mov %dx,-0x1a(%ebp) ret2 = fat_sector_write(fs_info, sec, 112240: ba 02 00 00 00 mov $0x2,%edx 112245: 89 54 24 0c mov %edx,0xc(%esp) ret1 = fat_sector_write(fs_info, sec, 112249: 89 c7 mov %eax,%edi ret2 = fat_sector_write(fs_info, sec, 11224b: 89 4c 24 04 mov %ecx,0x4(%esp) 11224f: 8d 45 e6 lea -0x1a(%ebp),%eax 112252: 89 44 24 10 mov %eax,0x10(%esp) 112256: e8 55 c8 ff ff call 10eab0 } 11225b: 83 c4 4c add $0x4c,%esp 11225e: 5b pop %ebx 11225f: 5e pop %esi if ( (ret1 < 0) || (ret2 < 0) ) 112260: 09 f8 or %edi,%eax } 112262: 5f pop %edi if ( (ret1 < 0) || (ret2 < 0) ) 112263: c1 f8 1f sar $0x1f,%eax } 112266: 5d pop %ebp 112267: c3 ret 112268: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 11226f: 90 nop return fs_info->vol.rdir_loc; 112270: 8b 46 28 mov 0x28(%esi),%eax 112273: e9 6f ff ff ff jmp 1121e7 112278: 90 nop 112279: 90 nop 11227a: 90 nop 11227b: 90 nop 11227c: 90 nop 11227d: 90 nop 11227e: 90 nop 11227f: 90 nop =============================================================================== 00112020 : { 112020: 55 push %ebp 112021: 89 e5 mov %esp,%ebp 112023: 57 push %edi 112024: 56 push %esi 112025: 53 push %ebx 112026: 83 ec 4c sub $0x4c,%esp 112029: 8b 55 0c mov 0xc(%ebp),%edx 11202c: 8b 5d 08 mov 0x8(%ebp),%ebx sec = fat_cluster_num_to_sector_num(fs_info, fat_fd->dir_pos.sname.cln); 11202f: 8b 72 20 mov 0x20(%edx),%esi if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) ) 112032: 85 f6 test %esi,%esi 112034: 75 0a jne 112040 112036: f6 43 16 03 testb $0x3,0x16(%ebx) 11203a: 0f 85 50 01 00 00 jne 112190 <== ALWAYS TAKEN return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) + 112040: 0f b6 4b 05 movzbl 0x5(%ebx),%ecx 112044: 83 ee 02 sub $0x2,%esi 112047: 8b 43 3c mov 0x3c(%ebx),%eax 11204a: d3 e6 shl %cl,%esi 11204c: 01 c6 add %eax,%esi msdos_date_unix2dos(fat_fd->mtime, &date, &time_val); 11204e: 89 55 0c mov %edx,0xc(%ebp) sec += (fat_fd->dir_pos.sname.ofs >> fs_info->vol.sec_log2); 112051: 8b 42 24 mov 0x24(%edx),%eax 112054: 0f b6 4b 02 movzbl 0x2(%ebx),%ecx 112058: 89 c7 mov %eax,%edi 11205a: d3 ef shr %cl,%edi byte = fat_fd->dir_pos.sname.ofs & (fs_info->vol.bps - 1); 11205c: 0f b7 0b movzwl (%ebx),%ecx sec += (fat_fd->dir_pos.sname.ofs >> fs_info->vol.sec_log2); 11205f: 01 fe add %edi,%esi msdos_date_unix2dos(fat_fd->mtime, &date, &time_val); 112061: 8d 7d e6 lea -0x1a(%ebp),%edi 112064: 89 7c 24 04 mov %edi,0x4(%esp) byte = fat_fd->dir_pos.sname.ofs & (fs_info->vol.bps - 1); 112068: 49 dec %ecx 112069: 21 c1 and %eax,%ecx 11206b: 89 4d d4 mov %ecx,-0x2c(%ebp) msdos_date_unix2dos(fat_fd->mtime, &date, &time_val); 11206e: 8d 45 e4 lea -0x1c(%ebp),%eax 112071: 89 44 24 08 mov %eax,0x8(%esp) 112075: 8b 42 48 mov 0x48(%edx),%eax 112078: 89 04 24 mov %eax,(%esp) 11207b: e8 40 6a 00 00 call 118ac0 ret = fat_sector_write(fs_info, sec, byte + MSDOS_FILE_WTIME_OFFSET, 112080: 8b 4d d4 mov -0x2c(%ebp),%ecx 112083: 8d 45 e4 lea -0x1c(%ebp),%eax 112086: 89 44 24 10 mov %eax,0x10(%esp) 11208a: b8 02 00 00 00 mov $0x2,%eax 11208f: 89 44 24 0c mov %eax,0xc(%esp) 112093: 89 74 24 04 mov %esi,0x4(%esp) 112097: 89 1c 24 mov %ebx,(%esp) 11209a: 8d 41 16 lea 0x16(%ecx),%eax 11209d: 89 44 24 08 mov %eax,0x8(%esp) 1120a1: e8 0a ca ff ff call 10eab0 ret = fat_sector_write(fs_info, sec, byte + MSDOS_FILE_WDATE_OFFSET, 1120a6: 8b 4d d4 mov -0x2c(%ebp),%ecx 1120a9: 89 7c 24 10 mov %edi,0x10(%esp) 1120ad: 89 74 24 04 mov %esi,0x4(%esp) 1120b1: 89 1c 24 mov %ebx,(%esp) ret = fat_sector_write(fs_info, sec, byte + MSDOS_FILE_WTIME_OFFSET, 1120b4: 89 45 cc mov %eax,-0x34(%ebp) ret = fat_sector_write(fs_info, sec, byte + MSDOS_FILE_WDATE_OFFSET, 1120b7: b8 02 00 00 00 mov $0x2,%eax 1120bc: 89 44 24 0c mov %eax,0xc(%esp) 1120c0: 8d 41 18 lea 0x18(%ecx),%eax 1120c3: 89 44 24 08 mov %eax,0x8(%esp) 1120c7: e8 e4 c9 ff ff call 10eab0 if ( ret < 0 ) 1120cc: 8b 55 0c mov 0xc(%ebp),%edx rc = -1; 1120cf: c7 45 d0 ff ff ff ff movl $0xffffffff,-0x30(%ebp) if ( ret < 0 ) 1120d6: 85 c0 test %eax,%eax 1120d8: 78 09 js 1120e3 <== NEVER TAKEN if ( ret < 0 ) 1120da: 8b 45 cc mov -0x34(%ebp),%eax 1120dd: c1 f8 1f sar $0x1f,%eax 1120e0: 89 45 d0 mov %eax,-0x30(%ebp) ret = fat_sector_write(fs_info, sec, byte + MSDOS_FILE_ADATE_OFFSET, 1120e3: 89 7c 24 10 mov %edi,0x10(%esp) 1120e7: 8b 45 d4 mov -0x2c(%ebp),%eax 1120ea: b9 02 00 00 00 mov $0x2,%ecx 1120ef: 89 4c 24 0c mov %ecx,0xc(%esp) 1120f3: 89 74 24 04 mov %esi,0x4(%esp) 1120f7: 89 1c 24 mov %ebx,(%esp) 1120fa: 89 55 0c mov %edx,0xc(%ebp) 1120fd: 83 c0 12 add $0x12,%eax 112100: 89 44 24 08 mov %eax,0x8(%esp) 112104: e8 a7 c9 ff ff call 10eab0 if ( ret < 0 ) 112109: 8b 55 0c mov 0xc(%ebp),%edx 11210c: 85 c0 test %eax,%eax 11210e: 79 07 jns 112117 <== ALWAYS TAKEN rc = -1; 112110: c7 45 d0 ff ff ff ff movl $0xffffffff,-0x30(%ebp) <== NOT EXECUTED msdos_date_unix2dos(fat_fd->ctime, &date, &time_val); 112117: 89 7c 24 04 mov %edi,0x4(%esp) 11211b: 8d 45 e4 lea -0x1c(%ebp),%eax 11211e: 89 44 24 08 mov %eax,0x8(%esp) 112122: 8b 42 40 mov 0x40(%edx),%eax 112125: 89 04 24 mov %eax,(%esp) 112128: e8 93 69 00 00 call 118ac0 ret = fat_sector_write(fs_info, sec, byte + MSDOS_FILE_CTIME_OFFSET, 11212d: 8d 45 e4 lea -0x1c(%ebp),%eax 112130: ba 02 00 00 00 mov $0x2,%edx 112135: 89 44 24 10 mov %eax,0x10(%esp) 112139: 8b 45 d4 mov -0x2c(%ebp),%eax 11213c: 89 54 24 0c mov %edx,0xc(%esp) 112140: 89 74 24 04 mov %esi,0x4(%esp) 112144: 89 1c 24 mov %ebx,(%esp) 112147: 83 c0 0e add $0xe,%eax 11214a: 89 44 24 08 mov %eax,0x8(%esp) 11214e: e8 5d c9 ff ff call 10eab0 if ( ret < 0 ) 112153: 85 c0 test %eax,%eax 112155: 79 07 jns 11215e <== ALWAYS TAKEN rc = -1; 112157: c7 45 d0 ff ff ff ff movl $0xffffffff,-0x30(%ebp) <== NOT EXECUTED ret = fat_sector_write(fs_info, sec, byte + MSDOS_FILE_CDATE_OFFSET, 11215e: 89 7c 24 10 mov %edi,0x10(%esp) 112162: b8 02 00 00 00 mov $0x2,%eax 112167: 89 44 24 0c mov %eax,0xc(%esp) 11216b: 8b 45 d4 mov -0x2c(%ebp),%eax 11216e: 89 74 24 04 mov %esi,0x4(%esp) 112172: 89 1c 24 mov %ebx,(%esp) 112175: 83 c0 10 add $0x10,%eax 112178: 89 44 24 08 mov %eax,0x8(%esp) 11217c: e8 2f c9 ff ff call 10eab0 if ( ret < 0 ) 112181: 85 c0 test %eax,%eax 112183: 78 1b js 1121a0 <== NEVER TAKEN } 112185: 8b 45 d0 mov -0x30(%ebp),%eax 112188: 83 c4 4c add $0x4c,%esp 11218b: 5b pop %ebx 11218c: 5e pop %esi 11218d: 5f pop %edi 11218e: 5d pop %ebp 11218f: c3 ret return fs_info->vol.rdir_loc; 112190: 8b 73 28 mov 0x28(%ebx),%esi 112193: e9 b6 fe ff ff jmp 11204e 112198: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 11219f: 90 nop rc = -1; 1121a0: c7 45 d0 ff ff ff ff movl $0xffffffff,-0x30(%ebp) <== NOT EXECUTED return rc; 1121a7: eb dc jmp 112185 <== NOT EXECUTED 1121a9: 90 nop 1121aa: 90 nop 1121ab: 90 nop 1121ac: 90 nop 1121ad: 90 nop 1121ae: 90 nop 1121af: 90 nop =============================================================================== 0010ff70 : { 10ff70: 55 push %ebp 10ff71: 89 e5 mov %esp,%ebp 10ff73: 57 push %edi 10ff74: 56 push %esi 10ff75: 53 push %ebx 10ff76: 83 ec 3c sub $0x3c,%esp uint32_t next_cln = 0; 10ff79: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) { 10ff80: 8b 5d 08 mov 0x8(%ebp),%ebx while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val) 10ff83: 8b 45 0c mov 0xc(%ebp),%eax 10ff86: 8b 53 18 mov 0x18(%ebx),%edx 10ff89: 21 d0 and %edx,%eax 10ff8b: 39 43 1c cmp %eax,0x1c(%ebx) 10ff8e: 76 73 jbe 110003 <== NEVER TAKEN int rc = RC_OK, rc1 = RC_OK; 10ff90: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) uint32_t cur_cln = chain; 10ff97: 8b 7d 0c mov 0xc(%ebp),%edi uint32_t freed_cls_cnt = 0; 10ff9a: 31 f6 xor %esi,%esi 10ff9c: eb 29 jmp 10ffc7 10ff9e: 66 90 xchg %ax,%ax rc = fat_set_fat_cluster(fs_info, cur_cln, FAT_GENFAT_FREE); 10ffa0: 89 7c 24 04 mov %edi,0x4(%esp) 10ffa4: 31 c0 xor %eax,%eax 10ffa6: 89 44 24 08 mov %eax,0x8(%esp) 10ffaa: 89 1c 24 mov %ebx,(%esp) 10ffad: e8 5e fd ff ff call 10fd10 if ( rc != RC_OK ) 10ffb2: 85 c0 test %eax,%eax 10ffb4: 74 03 je 10ffb9 <== ALWAYS TAKEN 10ffb6: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED cur_cln = next_cln; 10ffb9: 8b 7d e4 mov -0x1c(%ebp),%edi freed_cls_cnt++; 10ffbc: 46 inc %esi while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val) 10ffbd: 8b 43 18 mov 0x18(%ebx),%eax 10ffc0: 21 f8 and %edi,%eax 10ffc2: 3b 43 1c cmp 0x1c(%ebx),%eax 10ffc5: 73 49 jae 110010 rc = fat_get_fat_cluster(fs_info, cur_cln, &next_cln); 10ffc7: 89 7c 24 04 mov %edi,0x4(%esp) 10ffcb: 8d 45 e4 lea -0x1c(%ebp),%eax 10ffce: 89 44 24 08 mov %eax,0x8(%esp) 10ffd2: 89 1c 24 mov %ebx,(%esp) 10ffd5: e8 76 fb ff ff call 10fb50 if ( rc != RC_OK ) 10ffda: 85 c0 test %eax,%eax 10ffdc: 74 c2 je 10ffa0 <== ALWAYS TAKEN if(fs_info->vol.free_cls != FAT_UNDEFINED_VALUE) 10ffde: 89 c2 mov %eax,%edx <== NOT EXECUTED 10ffe0: 8b 43 4c mov 0x4c(%ebx),%eax <== NOT EXECUTED 10ffe3: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 10ffe6: 74 05 je 10ffed <== NOT EXECUTED fs_info->vol.free_cls += freed_cls_cnt; 10ffe8: 01 f0 add %esi,%eax <== NOT EXECUTED 10ffea: 89 43 4c mov %eax,0x4c(%ebx) <== NOT EXECUTED fat_buf_release(fs_info); 10ffed: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10fff0: 89 55 d4 mov %edx,-0x2c(%ebp) <== NOT EXECUTED 10fff3: e8 f8 e8 ff ff call 10e8f0 <== NOT EXECUTED } 10fff8: 8b 45 d4 mov -0x2c(%ebp),%eax <== NOT EXECUTED 10fffb: 83 c4 3c add $0x3c,%esp <== NOT EXECUTED 10fffe: 5b pop %ebx <== NOT EXECUTED 10ffff: 5e pop %esi <== NOT EXECUTED 110000: 5f pop %edi <== NOT EXECUTED 110001: 5d pop %ebp <== NOT EXECUTED 110002: c3 ret <== NOT EXECUTED int rc = RC_OK, rc1 = RC_OK; 110003: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) <== NOT EXECUTED uint32_t freed_cls_cnt = 0; 11000a: 31 f6 xor %esi,%esi <== NOT EXECUTED 11000c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED fs_info->vol.next_cl = chain; 110010: 8b 45 0c mov 0xc(%ebp),%eax 110013: 89 43 54 mov %eax,0x54(%ebx) if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE) 110016: 8b 43 4c mov 0x4c(%ebx),%eax 110019: 83 f8 ff cmp $0xffffffff,%eax 11001c: 74 05 je 110023 <== ALWAYS TAKEN fs_info->vol.free_cls += freed_cls_cnt; 11001e: 01 f0 add %esi,%eax <== NOT EXECUTED 110020: 89 43 4c mov %eax,0x4c(%ebx) <== NOT EXECUTED fat_buf_release(fs_info); 110023: 89 1c 24 mov %ebx,(%esp) 110026: e8 c5 e8 ff ff call 10e8f0 } 11002b: 8b 45 d4 mov -0x2c(%ebp),%eax 11002e: 83 c4 3c add $0x3c,%esp 110031: 5b pop %ebx 110032: 5e pop %esi 110033: 5f pop %edi 110034: 5d pop %ebp 110035: c3 ret 110036: 90 nop 110037: 90 nop 110038: 90 nop 110039: 90 nop 11003a: 90 nop 11003b: 90 nop 11003c: 90 nop 11003d: 90 nop 11003e: 90 nop 11003f: 90 nop =============================================================================== 0010fb00 : void fat_free_unique_ino( fat_fs_info_t *fs_info, uint32_t ino ) { 10fb00: 55 push %ebp <== NOT EXECUTED 10fb01: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fb03: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED FAT_SET_UNIQ_INO_FREE((ino - fs_info->uino_base), fs_info->uino); 10fb06: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10fb09: 8b 90 90 00 00 00 mov 0x90(%eax),%edx <== NOT EXECUTED 10fb0f: 29 d1 sub %edx,%ecx <== NOT EXECUTED 10fb11: 89 ca mov %ecx,%edx <== NOT EXECUTED 10fb13: 83 e1 07 and $0x7,%ecx <== NOT EXECUTED 10fb16: c1 ea 03 shr $0x3,%edx <== NOT EXECUTED 10fb19: 03 90 84 00 00 00 add 0x84(%eax),%edx <== NOT EXECUTED 10fb1f: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10fb24: d3 e0 shl %cl,%eax <== NOT EXECUTED 10fb26: f6 d0 not %al <== NOT EXECUTED 10fb28: 20 02 and %al,(%edx) <== NOT EXECUTED } 10fb2a: 5d pop %ebp <== NOT EXECUTED 10fb2b: c3 ret <== NOT EXECUTED 10fb2c: 90 nop 10fb2d: 90 nop 10fb2e: 90 nop 10fb2f: 90 nop =============================================================================== 0010fb50 : fat_get_fat_cluster( fat_fs_info_t *fs_info, uint32_t cln, uint32_t *ret_val ) { 10fb50: 55 push %ebp 10fb51: 89 e5 mov %esp,%ebp 10fb53: 57 push %edi 10fb54: 56 push %esi 10fb55: 53 push %ebx 10fb56: 83 ec 3c sub $0x3c,%esp uint8_t *sec_buf; uint32_t sec = 0; uint32_t ofs = 0; /* sanity check */ if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) ) 10fb59: 83 7d 0c 01 cmpl $0x1,0xc(%ebp) { 10fb5d: 8b 5d 08 mov 0x8(%ebp),%ebx if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) ) 10fb60: 76 71 jbe 10fbd3 <== NEVER TAKEN 10fb62: 8b 43 40 mov 0x40(%ebx),%eax 10fb65: 40 inc %eax 10fb66: 3b 45 0c cmp 0xc(%ebp),%eax 10fb69: 72 68 jb 10fbd3 <== NEVER TAKEN rtems_set_errno_and_return_minus_one(EIO); sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) + 10fb6b: 0f b6 43 16 movzbl 0x16(%ebx),%eax fs_info->vol.afat_loc; 10fb6f: 8b 73 60 mov 0x60(%ebx),%esi sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) + 10fb72: 0f b6 4b 02 movzbl 0x2(%ebx),%ecx 10fb76: 88 c2 mov %al,%dl 10fb78: 80 e2 01 and $0x1,%dl 10fb7b: 75 73 jne 10fbf0 10fb7d: 24 02 and $0x2,%al 10fb7f: 8b 45 0c mov 0xc(%ebp),%eax 10fb82: 0f 84 88 00 00 00 je 10fc10 10fb88: 8d 3c 00 lea (%eax,%eax,1),%edi 10fb8b: 89 f8 mov %edi,%eax 10fb8d: d3 e8 shr %cl,%eax 10fb8f: 01 f0 add %esi,%eax 10fb91: 89 45 d4 mov %eax,-0x2c(%ebp) ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1); rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf); 10fb94: 8d 45 e4 lea -0x1c(%ebp),%eax ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1); 10fb97: 0f b7 33 movzwl (%ebx),%esi rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf); 10fb9a: 89 44 24 0c mov %eax,0xc(%esp) 10fb9e: b8 01 00 00 00 mov $0x1,%eax 10fba3: 89 44 24 08 mov %eax,0x8(%esp) 10fba7: 8b 45 d4 mov -0x2c(%ebp),%eax 10fbaa: 89 1c 24 mov %ebx,(%esp) 10fbad: 89 44 24 04 mov %eax,0x4(%esp) 10fbb1: e8 6a ec ff ff call 10e820 if (rc != RC_OK) 10fbb6: 85 c0 test %eax,%eax rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf); 10fbb8: 89 c2 mov %eax,%edx if (rc != RC_OK) 10fbba: 75 27 jne 10fbe3 <== NEVER TAKEN return rc; switch ( fs_info->vol.type ) 10fbbc: 0f b6 43 16 movzbl 0x16(%ebx),%eax ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1); 10fbc0: 4e dec %esi 10fbc1: 21 f7 and %esi,%edi switch ( fs_info->vol.type ) 10fbc3: 3c 02 cmp $0x2,%al 10fbc5: 74 69 je 10fc30 10fbc7: 3c 04 cmp $0x4,%al 10fbc9: 0f 84 c1 00 00 00 je 10fc90 10fbcf: fe c8 dec %al 10fbd1: 74 7d je 10fc50 <== ALWAYS TAKEN *ret_val = *((uint32_t *)(sec_buf + ofs)); *ret_val = CF_LE_L(*ret_val); break; default: rtems_set_errno_and_return_minus_one(EIO); 10fbd3: e8 c8 6c 01 00 call 1268a0 <__errno> <== NOT EXECUTED 10fbd8: ba ff ff ff ff mov $0xffffffff,%edx <== NOT EXECUTED 10fbdd: c7 00 05 00 00 00 movl $0x5,(%eax) <== NOT EXECUTED break; } return RC_OK; } 10fbe3: 83 c4 3c add $0x3c,%esp 10fbe6: 89 d0 mov %edx,%eax 10fbe8: 5b pop %ebx 10fbe9: 5e pop %esi 10fbea: 5f pop %edi 10fbeb: 5d pop %ebp 10fbec: c3 ret 10fbed: 8d 76 00 lea 0x0(%esi),%esi sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) + 10fbf0: 8b 7d 0c mov 0xc(%ebp),%edi 10fbf3: 8b 45 0c mov 0xc(%ebp),%eax 10fbf6: d1 ef shr %edi 10fbf8: 01 c7 add %eax,%edi 10fbfa: 89 f8 mov %edi,%eax 10fbfc: d3 e8 shr %cl,%eax 10fbfe: 01 f0 add %esi,%eax 10fc00: 89 45 d4 mov %eax,-0x2c(%ebp) ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1); 10fc03: eb 8f jmp 10fb94 10fc05: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10fc0c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) + 10fc10: 8d 3c 85 00 00 00 00 lea 0x0(,%eax,4),%edi 10fc17: 89 f8 mov %edi,%eax 10fc19: d3 e8 shr %cl,%eax 10fc1b: 01 f0 add %esi,%eax 10fc1d: 89 45 d4 mov %eax,-0x2c(%ebp) ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1); 10fc20: e9 6f ff ff ff jmp 10fb94 10fc25: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10fc2c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi *ret_val = *((uint16_t *)(sec_buf + ofs)); 10fc30: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 10fc33: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 10fc36: 0f b7 04 38 movzwl (%eax,%edi,1),%eax <== NOT EXECUTED 10fc3a: 89 01 mov %eax,(%ecx) <== NOT EXECUTED } 10fc3c: 83 c4 3c add $0x3c,%esp <== NOT EXECUTED 10fc3f: 89 d0 mov %edx,%eax <== NOT EXECUTED 10fc41: 5b pop %ebx <== NOT EXECUTED 10fc42: 5e pop %esi <== NOT EXECUTED 10fc43: 5f pop %edi <== NOT EXECUTED 10fc44: 5d pop %ebp <== NOT EXECUTED 10fc45: c3 ret <== NOT EXECUTED 10fc46: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10fc4d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED *ret_val = (*(sec_buf + ofs)); 10fc50: 8b 4d e4 mov -0x1c(%ebp),%ecx 10fc53: 8b 45 10 mov 0x10(%ebp),%eax 10fc56: 0f b6 34 39 movzbl (%ecx,%edi,1),%esi 10fc5a: 89 30 mov %esi,(%eax) if ( ofs == (fs_info->vol.bps - 1) ) 10fc5c: 0f b7 03 movzwl (%ebx),%eax 10fc5f: 48 dec %eax 10fc60: 39 f8 cmp %edi,%eax 10fc62: 74 5c je 10fcc0 *ret_val |= *(sec_buf + ofs + 1) << 8; 10fc64: 0f b6 44 39 01 movzbl 0x1(%ecx,%edi,1),%eax 10fc69: c1 e0 08 shl $0x8,%eax 10fc6c: 09 c6 or %eax,%esi if ( FAT_CLUSTER_IS_ODD(cln) ) 10fc6e: f6 45 0c 01 testb $0x1,0xc(%ebp) 10fc72: 74 3c je 10fcb0 *ret_val = (*ret_val) >> FAT12_SHIFT; 10fc74: 8b 45 10 mov 0x10(%ebp),%eax 10fc77: c1 ee 04 shr $0x4,%esi 10fc7a: 89 30 mov %esi,(%eax) 10fc7c: e9 62 ff ff ff jmp 10fbe3 10fc81: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10fc88: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10fc8f: 90 nop *ret_val = *((uint32_t *)(sec_buf + ofs)); 10fc90: 8b 45 e4 mov -0x1c(%ebp),%eax 10fc93: 8b 4d 10 mov 0x10(%ebp),%ecx 10fc96: 8b 04 38 mov (%eax,%edi,1),%eax 10fc99: 89 01 mov %eax,(%ecx) } 10fc9b: 83 c4 3c add $0x3c,%esp 10fc9e: 89 d0 mov %edx,%eax 10fca0: 5b pop %ebx 10fca1: 5e pop %esi 10fca2: 5f pop %edi 10fca3: 5d pop %ebp 10fca4: c3 ret 10fca5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10fcac: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi *ret_val = (*ret_val) & FAT_FAT12_MASK; 10fcb0: 8b 45 10 mov 0x10(%ebp),%eax 10fcb3: 81 e6 ff 0f 00 00 and $0xfff,%esi 10fcb9: 89 30 mov %esi,(%eax) 10fcbb: e9 23 ff ff ff jmp 10fbe3 rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ, 10fcc0: 8b 75 d4 mov -0x2c(%ebp),%esi 10fcc3: 8d 45 e4 lea -0x1c(%ebp),%eax 10fcc6: b9 01 00 00 00 mov $0x1,%ecx 10fccb: 89 44 24 0c mov %eax,0xc(%esp) 10fccf: 89 4c 24 08 mov %ecx,0x8(%esp) 10fcd3: 89 1c 24 mov %ebx,(%esp) 10fcd6: 89 55 d0 mov %edx,-0x30(%ebp) 10fcd9: 46 inc %esi 10fcda: 89 74 24 04 mov %esi,0x4(%esp) 10fcde: e8 3d eb ff ff call 10e820 if (rc != RC_OK) 10fce3: 85 c0 test %eax,%eax 10fce5: 75 19 jne 10fd00 <== NEVER TAKEN *ret_val |= *sec_buf << 8; 10fce7: 8b 45 e4 mov -0x1c(%ebp),%eax 10fcea: 0f b6 30 movzbl (%eax),%esi 10fced: 8b 45 10 mov 0x10(%ebp),%eax 10fcf0: c1 e6 08 shl $0x8,%esi 10fcf3: 8b 10 mov (%eax),%edx 10fcf5: 09 d6 or %edx,%esi 10fcf7: 8b 55 d0 mov -0x30(%ebp),%edx 10fcfa: e9 6f ff ff ff jmp 10fc6e 10fcff: 90 nop 10fd00: 89 c2 mov %eax,%edx <== NOT EXECUTED 10fd02: e9 dc fe ff ff jmp 10fbe3 <== NOT EXECUTED 10fd07: 90 nop 10fd08: 90 nop 10fd09: 90 nop 10fd0a: 90 nop 10fd0b: 90 nop 10fd0c: 90 nop 10fd0d: 90 nop 10fd0e: 90 nop 10fd0f: 90 nop =============================================================================== 0010fa10 : * 0 means FAILED !!! * */ uint32_t fat_get_unique_ino(fat_fs_info_t *fs_info) { 10fa10: 55 push %ebp <== NOT EXECUTED 10fa11: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fa13: 57 push %edi <== NOT EXECUTED 10fa14: 56 push %esi <== NOT EXECUTED 10fa15: 53 push %ebx <== NOT EXECUTED 10fa16: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 10fa19: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED uint32_t j = 0; bool resrc_unsuff = false; while (!resrc_unsuff) { for (j = 0; j < fs_info->uino_pool_size; j++) 10fa1c: 8b be 8c 00 00 00 mov 0x8c(%esi),%edi <== NOT EXECUTED 10fa22: 85 ff test %edi,%edi <== NOT EXECUTED 10fa24: 74 5e je 10fa84 <== NOT EXECUTED { if (!FAT_UNIQ_INO_IS_BUSY(fs_info->index, fs_info->uino)) 10fa26: 8b 86 84 00 00 00 mov 0x84(%esi),%eax <== NOT EXECUTED for (j = 0; j < fs_info->uino_pool_size; j++) 10fa2c: 31 db xor %ebx,%ebx <== NOT EXECUTED if (!FAT_UNIQ_INO_IS_BUSY(fs_info->index, fs_info->uino)) 10fa2e: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED 10fa31: eb 18 jmp 10fa4b <== NOT EXECUTED 10fa33: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10fa3a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED { FAT_SET_UNIQ_INO_BUSY(fs_info->index, fs_info->uino); return (fs_info->uino_base + fs_info->index); } fs_info->index++; 10fa40: 89 86 88 00 00 00 mov %eax,0x88(%esi) <== NOT EXECUTED for (j = 0; j < fs_info->uino_pool_size; j++) 10fa46: 43 inc %ebx <== NOT EXECUTED 10fa47: 39 fb cmp %edi,%ebx <== NOT EXECUTED 10fa49: 74 37 je 10fa82 <== NOT EXECUTED if (!FAT_UNIQ_INO_IS_BUSY(fs_info->index, fs_info->uino)) 10fa4b: 8b 86 88 00 00 00 mov 0x88(%esi),%eax <== NOT EXECUTED 10fa51: 8b 4d e4 mov -0x1c(%ebp),%ecx <== NOT EXECUTED 10fa54: 89 c2 mov %eax,%edx <== NOT EXECUTED 10fa56: c1 ea 03 shr $0x3,%edx <== NOT EXECUTED 10fa59: 01 ca add %ecx,%edx <== NOT EXECUTED 10fa5b: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10fa5d: 89 55 e0 mov %edx,-0x20(%ebp) <== NOT EXECUTED 10fa60: 0f be 12 movsbl (%edx),%edx <== NOT EXECUTED 10fa63: 83 e1 07 and $0x7,%ecx <== NOT EXECUTED 10fa66: 88 55 df mov %dl,-0x21(%ebp) <== NOT EXECUTED 10fa69: d3 fa sar %cl,%edx <== NOT EXECUTED 10fa6b: f6 c2 01 test $0x1,%dl <== NOT EXECUTED 10fa6e: 74 60 je 10fad0 <== NOT EXECUTED fs_info->index++; 10fa70: 40 inc %eax <== NOT EXECUTED if (fs_info->index >= fs_info->uino_pool_size) 10fa71: 39 f8 cmp %edi,%eax <== NOT EXECUTED 10fa73: 72 cb jb 10fa40 <== NOT EXECUTED for (j = 0; j < fs_info->uino_pool_size; j++) 10fa75: 43 inc %ebx <== NOT EXECUTED fs_info->index = 0; 10fa76: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 10fa78: 89 8e 88 00 00 00 mov %ecx,0x88(%esi) <== NOT EXECUTED for (j = 0; j < fs_info->uino_pool_size; j++) 10fa7e: 39 fb cmp %edi,%ebx <== NOT EXECUTED 10fa80: 75 c9 jne 10fa4b <== NOT EXECUTED } if ((fs_info->uino_pool_size << 1) < (0x0FFFFFFF - fs_info->uino_base)) 10fa82: 01 ff add %edi,%edi <== NOT EXECUTED 10fa84: 8b 96 90 00 00 00 mov 0x90(%esi),%edx <== NOT EXECUTED 10fa8a: b8 ff ff ff 0f mov $0xfffffff,%eax <== NOT EXECUTED 10fa8f: 29 d0 sub %edx,%eax <== NOT EXECUTED 10fa91: 39 f8 cmp %edi,%eax <== NOT EXECUTED 10fa93: 76 63 jbe 10faf8 <== NOT EXECUTED { fs_info->uino_pool_size <<= 1; 10fa95: 89 be 8c 00 00 00 mov %edi,0x8c(%esi) <== NOT EXECUTED fs_info->uino = realloc(fs_info->uino, fs_info->uino_pool_size); 10fa9b: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED 10fa9f: 8b 86 84 00 00 00 mov 0x84(%esi),%eax <== NOT EXECUTED 10faa5: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10faa8: e8 b3 8c 00 00 call 118760 <== NOT EXECUTED 10faad: 89 86 84 00 00 00 mov %eax,0x84(%esi) <== NOT EXECUTED if (fs_info->uino != NULL) 10fab3: 85 c0 test %eax,%eax <== NOT EXECUTED 10fab5: 74 41 je 10faf8 <== NOT EXECUTED fs_info->index = fs_info->uino_pool_size; 10fab7: 8b be 8c 00 00 00 mov 0x8c(%esi),%edi <== NOT EXECUTED 10fabd: 89 be 88 00 00 00 mov %edi,0x88(%esi) <== NOT EXECUTED 10fac3: e9 5a ff ff ff jmp 10fa22 <== NOT EXECUTED 10fac8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10facf: 90 nop <== NOT EXECUTED FAT_SET_UNIQ_INO_BUSY(fs_info->index, fs_info->uino); 10fad0: 0f b6 5d df movzbl -0x21(%ebp),%ebx <== NOT EXECUTED 10fad4: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10fad9: d3 e0 shl %cl,%eax <== NOT EXECUTED 10fadb: 08 d8 or %bl,%al <== NOT EXECUTED 10fadd: 8b 5d e0 mov -0x20(%ebp),%ebx <== NOT EXECUTED 10fae0: 88 03 mov %al,(%ebx) <== NOT EXECUTED return (fs_info->uino_base + fs_info->index); 10fae2: 8b 86 88 00 00 00 mov 0x88(%esi),%eax <== NOT EXECUTED 10fae8: 8b be 90 00 00 00 mov 0x90(%esi),%edi <== NOT EXECUTED 10faee: 01 f8 add %edi,%eax <== NOT EXECUTED } else resrc_unsuff = true; } return 0; } 10faf0: 83 c4 2c add $0x2c,%esp <== NOT EXECUTED 10faf3: 5b pop %ebx <== NOT EXECUTED 10faf4: 5e pop %esi <== NOT EXECUTED 10faf5: 5f pop %edi <== NOT EXECUTED 10faf6: 5d pop %ebp <== NOT EXECUTED 10faf7: c3 ret <== NOT EXECUTED return 0; 10faf8: 31 c0 xor %eax,%eax <== NOT EXECUTED 10fafa: eb f4 jmp 10faf0 <== NOT EXECUTED 10fafc: 90 nop 10fafd: 90 nop 10fafe: 90 nop 10faff: 90 nop =============================================================================== 0010f980 : int fat_init_clusters_chain( fat_fs_info_t *fs_info, uint32_t start_cln ) { 10f980: 55 push %ebp 10f981: 89 e5 mov %esp,%ebp 10f983: 56 push %esi 10f984: 53 push %ebx if ( ret != fs_info->vol.bpc ) { return -1; } rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln); 10f985: 8d 75 f4 lea -0xc(%ebp),%esi { 10f988: 83 ec 30 sub $0x30,%esp 10f98b: 8b 45 0c mov 0xc(%ebp),%eax 10f98e: 8b 5d 08 mov 0x8(%ebp),%ebx uint32_t cur_cln = start_cln; 10f991: 89 45 f4 mov %eax,-0xc(%ebp) while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val) 10f994: eb 48 jmp 10f9de 10f996: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10f99d: 8d 76 00 lea 0x0(%esi),%esi ret = fat_cluster_set(fs_info, cur_cln, 0, fs_info->vol.bpc, 0); 10f9a0: 31 d2 xor %edx,%edx <== NOT EXECUTED 10f9a2: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 10f9a4: 89 54 24 10 mov %edx,0x10(%esp) <== NOT EXECUTED 10f9a8: 8b 53 08 mov 0x8(%ebx),%edx <== NOT EXECUTED 10f9ab: 89 4c 24 08 mov %ecx,0x8(%esp) <== NOT EXECUTED 10f9af: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 10f9b3: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10f9b6: 89 54 24 0c mov %edx,0xc(%esp) <== NOT EXECUTED 10f9ba: e8 31 f2 ff ff call 10ebf0 <== NOT EXECUTED if ( ret != fs_info->vol.bpc ) 10f9bf: 39 43 08 cmp %eax,0x8(%ebx) 10f9c2: 75 3c jne 10fa00 <== NEVER TAKEN rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln); 10f9c4: 89 74 24 08 mov %esi,0x8(%esp) 10f9c8: 8b 45 f4 mov -0xc(%ebp),%eax 10f9cb: 89 1c 24 mov %ebx,(%esp) 10f9ce: 89 44 24 04 mov %eax,0x4(%esp) 10f9d2: e8 79 01 00 00 call 10fb50 if ( rc != RC_OK ) 10f9d7: 85 c0 test %eax,%eax 10f9d9: 75 0f jne 10f9ea <== NEVER TAKEN while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val) 10f9db: 8b 45 f4 mov -0xc(%ebp),%eax 10f9de: 8b 53 18 mov 0x18(%ebx),%edx 10f9e1: 21 c2 and %eax,%edx 10f9e3: 3b 53 1c cmp 0x1c(%ebx),%edx 10f9e6: 72 b8 jb 10f9a0 return rc; } } return rc; 10f9e8: 31 c0 xor %eax,%eax } 10f9ea: 83 c4 30 add $0x30,%esp 10f9ed: 5b pop %ebx 10f9ee: 5e pop %esi 10f9ef: 5d pop %ebp 10f9f0: c3 ret 10f9f1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10f9f8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10f9ff: 90 nop 10fa00: 83 c4 30 add $0x30,%esp <== NOT EXECUTED return -1; 10fa03: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED } 10fa08: 5b pop %ebx <== NOT EXECUTED 10fa09: 5e pop %esi <== NOT EXECUTED 10fa0a: 5d pop %ebp <== NOT EXECUTED 10fa0b: c3 ret <== NOT EXECUTED 10fa0c: 90 nop 10fa0d: 90 nop 10fa0e: 90 nop 10fa0f: 90 nop =============================================================================== 0010efd0 : * RC_OK on success, or -1 if error occured * and errno set appropriately */ int fat_init_volume_info(fat_fs_info_t *fs_info, const char *device) { 10efd0: 55 push %ebp ssize_t ret = 0; struct stat stat_buf; int i = 0; rtems_bdbuf_buffer *block = NULL; vol->fd = open(device, O_RDWR); 10efd1: ba 02 00 00 00 mov $0x2,%edx { 10efd6: 89 e5 mov %esp,%ebp 10efd8: 57 push %edi 10efd9: 56 push %esi 10efda: 53 push %ebx 10efdb: 81 ec cc 00 00 00 sub $0xcc,%esp vol->fd = open(device, O_RDWR); 10efe1: 89 54 24 04 mov %edx,0x4(%esp) 10efe5: 8b 45 0c mov 0xc(%ebp),%eax rtems_bdbuf_buffer *block = NULL; 10efe8: c7 45 80 00 00 00 00 movl $0x0,-0x80(%ebp) { 10efef: 8b 5d 08 mov 0x8(%ebp),%ebx vol->fd = open(device, O_RDWR); 10eff2: 89 04 24 mov %eax,(%esp) 10eff5: e8 46 3b ff ff call 102b40 10effa: 89 43 68 mov %eax,0x68(%ebx) if (vol->fd < 0) 10effd: 85 c0 test %eax,%eax 10efff: 0f 88 e8 05 00 00 js 10f5ed <== NEVER TAKEN { rtems_set_errno_and_return_minus_one(ENXIO); } rc = fstat(vol->fd, &stat_buf); 10f005: 89 04 24 mov %eax,(%esp) 10f008: 8d 55 90 lea -0x70(%ebp),%edx 10f00b: 89 54 24 04 mov %edx,0x4(%esp) 10f00f: e8 fc 2c ff ff call 101d10 if (rc != 0) 10f014: 85 c0 test %eax,%eax 10f016: 0f 85 c6 05 00 00 jne 10f5e2 <== NEVER TAKEN close(vol->fd); rtems_set_errno_and_return_minus_one(ENXIO); } /* Must be a block device. */ if (!S_ISBLK(stat_buf.st_mode)) 10f01c: 8b 45 a0 mov -0x60(%ebp),%eax close(vol->fd); 10f01f: 8b 53 68 mov 0x68(%ebx),%edx if (!S_ISBLK(stat_buf.st_mode)) 10f022: 25 00 f0 00 00 and $0xf000,%eax 10f027: 3d 00 60 00 00 cmp $0x6000,%eax 10f02c: 0f 85 d6 05 00 00 jne 10f608 <== NEVER TAKEN return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr); 10f032: 89 14 24 mov %edx,(%esp) close(vol->fd); rtems_set_errno_and_return_minus_one(ENXIO); } /* check that device is registred as block device and lock it */ rc = rtems_disk_fd_get_disk_device(vol->fd, &vol->dd); 10f035: 8d 43 6c lea 0x6c(%ebx),%eax 10f038: 89 44 24 08 mov %eax,0x8(%esp) 10f03c: b8 09 42 04 40 mov $0x40044209,%eax 10f041: 89 44 24 04 mov %eax,0x4(%esp) 10f045: e8 06 eb ff ff call 10db50 10f04a: 89 85 64 ff ff ff mov %eax,-0x9c(%ebp) if (rc != 0) { 10f050: 85 c0 test %eax,%eax 10f052: 0f 85 8a 05 00 00 jne 10f5e2 <== NEVER TAKEN close(vol->fd); rtems_set_errno_and_return_minus_one(ENXIO); } vol->dev = stat_buf.st_rdev; 10f058: 8b 45 ac mov -0x54(%ebp),%eax 10f05b: 8b 55 b0 mov -0x50(%ebp),%edx 10f05e: 89 43 70 mov %eax,0x70(%ebx) /* Read boot record */ /* FIXME: Asserts FAT_MAX_BPB_SIZE < bdbuf block size */ sc = rtems_bdbuf_read( vol->dd, 0, &block); 10f061: 8d 45 80 lea -0x80(%ebp),%eax vol->dev = stat_buf.st_rdev; 10f064: 89 53 74 mov %edx,0x74(%ebx) sc = rtems_bdbuf_read( vol->dd, 0, &block); 10f067: 89 44 24 08 mov %eax,0x8(%esp) 10f06b: 31 c0 xor %eax,%eax 10f06d: 89 44 24 04 mov %eax,0x4(%esp) 10f071: 8b 43 6c mov 0x6c(%ebx),%eax 10f074: 89 04 24 mov %eax,(%esp) 10f077: e8 b4 8f 00 00 call 118030 if (sc != RTEMS_SUCCESSFUL) 10f07c: 85 c0 test %eax,%eax 10f07e: 0f 85 a7 05 00 00 jne 10f62b <== NEVER TAKEN { close(vol->fd); rtems_set_errno_and_return_minus_one( EIO); } memcpy( boot_rec, block->buffer, FAT_MAX_BPB_SIZE); 10f084: 8b 55 80 mov -0x80(%ebp),%edx 10f087: 8b 42 1c mov 0x1c(%edx),%eax 10f08a: 0f b7 78 0e movzwl 0xe(%eax),%edi 10f08e: 0f b6 48 0d movzbl 0xd(%eax),%ecx 10f092: 0f b7 70 0b movzwl 0xb(%eax),%esi 10f096: 89 bd 74 ff ff ff mov %edi,-0x8c(%ebp) 10f09c: 0f b7 78 11 movzwl 0x11(%eax),%edi 10f0a0: 88 8d 72 ff ff ff mov %cl,-0x8e(%ebp) 10f0a6: 0f b6 48 10 movzbl 0x10(%eax),%ecx 10f0aa: 89 bd 60 ff ff ff mov %edi,-0xa0(%ebp) 10f0b0: 0f b7 78 13 movzwl 0x13(%eax),%edi 10f0b4: 88 8d 73 ff ff ff mov %cl,-0x8d(%ebp) 10f0ba: 0f b6 48 28 movzbl 0x28(%eax),%ecx 10f0be: 89 bd 5c ff ff ff mov %edi,-0xa4(%ebp) 10f0c4: 0f b7 78 16 movzwl 0x16(%eax),%edi 10f0c8: 88 8d 71 ff ff ff mov %cl,-0x8f(%ebp) 10f0ce: 89 bd 58 ff ff ff mov %edi,-0xa8(%ebp) vol->rdir_loc = vol->fat_loc + vol->fats * vol->fat_length; if ( (FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec)) != 0) vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec); else vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM32(boot_rec); 10f0d4: 8b 78 20 mov 0x20(%eax),%edi 10f0d7: 89 bd 68 ff ff ff mov %edi,-0x98(%ebp) vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT32(boot_rec); 10f0dd: 8b 78 24 mov 0x24(%eax),%edi 10f0e0: 89 bd 6c ff ff ff mov %edi,-0x94(%ebp) } } if (vol->type == FAT_FAT32) { vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec); 10f0e6: 8b 78 2c mov 0x2c(%eax),%edi 10f0e9: 0f b7 40 30 movzwl 0x30(%eax),%eax sc = rtems_bdbuf_release( block); 10f0ed: 89 14 24 mov %edx,(%esp) vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec); 10f0f0: 89 bd 50 ff ff ff mov %edi,-0xb0(%ebp) 10f0f6: 89 85 54 ff ff ff mov %eax,-0xac(%ebp) sc = rtems_bdbuf_release( block); 10f0fc: e8 1f 91 00 00 call 118220 if (sc != RTEMS_SUCCESSFUL) 10f101: 0f b6 8d 72 ff ff ff movzbl -0x8e(%ebp),%ecx 10f108: 85 c0 test %eax,%eax 10f10a: 0f 85 1b 05 00 00 jne 10f62b <== NEVER TAKEN vol->bps = FAT_GET_BR_BYTES_PER_SECTOR(boot_rec); 10f110: 66 89 33 mov %si,(%ebx) (vol->bps != 1024) && 10f113: 8d 86 00 f8 ff ff lea -0x800(%esi),%eax (vol->bps != 2048) && 10f119: a9 ff f7 00 00 test $0xf7ff,%eax 10f11e: 74 11 je 10f131 <== NEVER TAKEN if ( (vol->bps != 512) && 10f120: 8d 86 00 fe ff ff lea -0x200(%esi),%eax (vol->bps != 2048) && 10f126: a9 ff fd 00 00 test $0xfdff,%eax 10f12b: 0f 85 8b 04 00 00 jne 10f5bc <== NEVER TAKEN for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0; 10f131: c6 43 03 00 movb $0x0,0x3(%ebx) 10f135: 89 f7 mov %esi,%edi 10f137: c1 ef 09 shr $0x9,%edi 10f13a: f7 c6 00 02 00 00 test $0x200,%esi 10f140: 75 1f jne 10f161 <== ALWAYS TAKEN 10f142: b0 01 mov $0x1,%al <== NOT EXECUTED 10f144: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10f14b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10f14f: 90 nop <== NOT EXECUTED i >>= 1, vol->sec_mul++); 10f150: d1 ff sar %edi <== NOT EXECUTED for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0; 10f152: 88 c2 mov %al,%dl <== NOT EXECUTED 10f154: fe c0 inc %al <== NOT EXECUTED 10f156: f7 c7 01 00 00 00 test $0x1,%edi <== NOT EXECUTED 10f15c: 74 f2 je 10f150 <== NOT EXECUTED 10f15e: 88 53 03 mov %dl,0x3(%ebx) <== NOT EXECUTED for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0; 10f161: c6 43 02 00 movb $0x0,0x2(%ebx) 10f165: f7 c6 01 00 00 00 test $0x1,%esi 10f16b: 89 f7 mov %esi,%edi 10f16d: 75 22 jne 10f191 <== NEVER TAKEN 10f16f: b0 01 mov $0x1,%al 10f171: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10f178: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10f17f: 90 nop i >>= 1, vol->sec_log2++); 10f180: d1 ff sar %edi for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0; 10f182: 88 c2 mov %al,%dl 10f184: fe c0 inc %al 10f186: f7 c7 01 00 00 00 test $0x1,%edi 10f18c: 74 f2 je 10f180 10f18e: 88 53 02 mov %dl,0x2(%ebx) sc = rtems_bdbuf_set_block_size (vol->dd, vol->bps, true); 10f191: 89 74 24 04 mov %esi,0x4(%esp) 10f195: bf 01 00 00 00 mov $0x1,%edi 10f19a: 89 7c 24 08 mov %edi,0x8(%esp) 10f19e: 88 8d 72 ff ff ff mov %cl,-0x8e(%ebp) 10f1a4: 8b 43 6c mov 0x6c(%ebx),%eax 10f1a7: 89 04 24 mov %eax,(%esp) 10f1aa: e8 e1 92 00 00 call 118490 if (sc != RTEMS_SUCCESSFUL) 10f1af: 0f b6 8d 72 ff ff ff movzbl -0x8e(%ebp),%ecx 10f1b6: 85 c0 test %eax,%eax 10f1b8: 0f 85 fe 03 00 00 jne 10f5bc <== NEVER TAKEN vol->bytes_per_block_log2 = vol->sec_log2; 10f1be: 0f b6 43 02 movzbl 0x2(%ebx),%eax if (vol->spc == 0) 10f1c2: 84 c9 test %cl,%cl vol->sectors_per_block = 1; 10f1c4: c6 43 0d 01 movb $0x1,0xd(%ebx) vol->bytes_per_block = vol->bps; 10f1c8: 0f b7 33 movzwl (%ebx),%esi vol->spc = FAT_GET_BR_SECTORS_PER_CLUSTER(boot_rec); 10f1cb: 88 4b 04 mov %cl,0x4(%ebx) vol->bytes_per_block_log2 = vol->sec_log2; 10f1ce: 88 85 72 ff ff ff mov %al,-0x8e(%ebp) vol->bytes_per_block = vol->bps; 10f1d4: 89 73 10 mov %esi,0x10(%ebx) vol->bytes_per_block_log2 = vol->sec_log2; 10f1d7: 88 43 14 mov %al,0x14(%ebx) if (vol->spc == 0) 10f1da: 0f 84 dc 03 00 00 je 10f5bc <== NEVER TAKEN for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0; 10f1e0: c6 43 05 00 movb $0x0,0x5(%ebx) 10f1e4: 0f b6 f9 movzbl %cl,%edi 10f1e7: 80 e1 01 and $0x1,%cl 10f1ea: 89 fa mov %edi,%edx 10f1ec: 0f 85 ae 03 00 00 jne 10f5a0 10f1f2: b0 01 mov $0x1,%al 10f1f4: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10f1fb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 10f1ff: 90 nop i >>= 1, vol->spc_log2++); 10f200: d1 fa sar %edx for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0; 10f202: 88 c1 mov %al,%cl 10f204: fe c0 inc %al 10f206: f6 c2 01 test $0x1,%dl 10f209: 74 f5 je 10f200 10f20b: 88 4b 05 mov %cl,0x5(%ebx) if (vol->spc != UINT32_C(1) << vol->spc_log2) 10f20e: ba 01 00 00 00 mov $0x1,%edx 10f213: 0f b6 c1 movzbl %cl,%eax 10f216: d3 e2 shl %cl,%edx 10f218: 39 d7 cmp %edx,%edi 10f21a: 0f 85 9c 03 00 00 jne 10f5bc <== NEVER TAKEN for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0; 10f220: c6 43 0c 00 movb $0x0,0xc(%ebx) vol->bpc = ((uint32_t) vol->bps) << vol->spc_log2; 10f224: 88 c1 mov %al,%cl 10f226: 89 f2 mov %esi,%edx 10f228: d3 e2 shl %cl,%edx 10f22a: 89 53 08 mov %edx,0x8(%ebx) for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0; 10f22d: f6 c2 01 test $0x1,%dl vol->bpc = ((uint32_t) vol->bps) << vol->spc_log2; 10f230: 89 d1 mov %edx,%ecx for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0; 10f232: 75 1a jne 10f24e <== NEVER TAKEN 10f234: b0 01 mov $0x1,%al 10f236: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10f23d: 8d 76 00 lea 0x0(%esi),%esi i >>= 1, vol->bpc_log2++); 10f240: d1 f9 sar %ecx for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0; 10f242: 88 c2 mov %al,%dl 10f244: fe c0 inc %al 10f246: f6 c1 01 test $0x1,%cl 10f249: 74 f5 je 10f240 10f24b: 88 53 0c mov %dl,0xc(%ebx) vol->fats = FAT_GET_BR_FAT_NUM(boot_rec); 10f24e: 0f b6 85 73 ff ff ff movzbl -0x8d(%ebp),%eax vol->rdir_size = vol->rdir_secs << vol->sec_log2; 10f255: 0f b6 8d 72 ff ff ff movzbl -0x8e(%ebp),%ecx vol->fats = FAT_GET_BR_FAT_NUM(boot_rec); 10f25c: 88 43 15 mov %al,0x15(%ebx) vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec); 10f25f: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax 10f265: 66 89 43 20 mov %ax,0x20(%ebx) vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec); 10f269: 8b 85 60 ff ff ff mov -0xa0(%ebp),%eax 10f26f: 66 89 43 2c mov %ax,0x2c(%ebx) vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) / 10f273: c1 e0 05 shl $0x5,%eax 10f276: 8d 44 06 ff lea -0x1(%esi,%eax,1),%eax 10f27a: 99 cltd 10f27b: f7 fe idiv %esi if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0) 10f27d: 8b b5 58 ff ff ff mov -0xa8(%ebp),%esi vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) / 10f283: 89 43 30 mov %eax,0x30(%ebx) vol->rdir_size = vol->rdir_secs << vol->sec_log2; 10f286: 89 c2 mov %eax,%edx 10f288: d3 e2 shl %cl,%edx if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0) 10f28a: 85 f6 test %esi,%esi vol->rdir_size = vol->rdir_secs << vol->sec_log2; 10f28c: 89 53 34 mov %edx,0x34(%ebx) if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0) 10f28f: 74 06 je 10f297 vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT(boot_rec); 10f291: 89 b5 6c ff ff ff mov %esi,-0x94(%ebp) 10f297: 8b b5 6c ff ff ff mov -0x94(%ebp),%esi vol->data_fsec = vol->fat_loc + vol->fats * vol->fat_length + 10f29d: 0f b6 95 73 ff ff ff movzbl -0x8d(%ebp),%edx 10f2a4: 8b 8d 74 ff ff ff mov -0x8c(%ebp),%ecx 10f2aa: 89 73 24 mov %esi,0x24(%ebx) 10f2ad: 0f af d6 imul %esi,%edx 10f2b0: 01 ca add %ecx,%edx vol->rdir_loc = vol->fat_loc + vol->fats * vol->fat_length; 10f2b2: 89 53 28 mov %edx,0x28(%ebx) vol->data_fsec = vol->fat_loc + vol->fats * vol->fat_length + 10f2b5: 8d 0c 10 lea (%eax,%edx,1),%ecx if ( (FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec)) != 0) 10f2b8: 8b 85 5c ff ff ff mov -0xa4(%ebp),%eax vol->data_fsec = vol->fat_loc + vol->fats * vol->fat_length + 10f2be: 89 4b 3c mov %ecx,0x3c(%ebx) if ( (FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec)) != 0) 10f2c1: 85 c0 test %eax,%eax 10f2c3: 74 06 je 10f2cb vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec); 10f2c5: 89 85 68 ff ff ff mov %eax,-0x98(%ebp) 10f2cb: 8b 85 68 ff ff ff mov -0x98(%ebp),%eax vol->data_cls = data_secs / vol->spc; 10f2d1: 31 d2 xor %edx,%edx 10f2d3: 89 43 38 mov %eax,0x38(%ebx) data_secs = vol->tot_secs - vol->data_fsec; 10f2d6: 29 c8 sub %ecx,%eax vol->data_cls = data_secs / vol->spc; 10f2d8: f7 f7 div %edi 10f2da: 89 43 40 mov %eax,0x40(%ebx) if ( vol->data_cls < FAT_FAT12_MAX_CLN) 10f2dd: 3d f4 0f 00 00 cmp $0xff4,%eax 10f2e2: 0f 86 b8 01 00 00 jbe 10f4a0 if ( vol->data_cls < FAT_FAT16_MAX_CLN) 10f2e8: 3d f4 ff 00 00 cmp $0xfff4,%eax 10f2ed: 0f 87 cd 01 00 00 ja 10f4c0 vol->type = FAT_FAT16; 10f2f3: c6 43 16 02 movb $0x2,0x16(%ebx) vol->mask = FAT_FAT16_MASK; 10f2f7: c7 43 18 ff ff 00 00 movl $0xffff,0x18(%ebx) vol->eoc_val = FAT_FAT16_EOC; 10f2fe: c7 43 1c f8 ff 00 00 movl $0xfff8,0x1c(%ebx) } } } else { vol->rdir_cl = 0; 10f305: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) vol->mirror = 0; 10f30c: c6 43 5c 00 movb $0x0,0x5c(%ebx) vol->afat = 0; 10f310: c6 43 64 00 movb $0x0,0x64(%ebx) vol->free_cls = FAT_UNDEFINED_VALUE; 10f314: c7 43 4c ff ff ff ff movl $0xffffffff,0x4c(%ebx) vol->next_cl = FAT_UNDEFINED_VALUE; 10f31b: c7 43 54 ff ff ff ff movl $0xffffffff,0x54(%ebx) if (fs_info->c.state == FAT_CACHE_EMPTY) 10f322: 80 bb 99 00 00 00 00 cmpb $0x0,0x99(%ebx) 10f329: 74 07 je 10f332 10f32b: 89 d8 mov %ebx,%eax 10f32d: e8 5e f2 ff ff call 10e590 } _fat_block_release(fs_info); vol->afat_loc = vol->fat_loc + vol->fat_length * vol->afat; 10f332: 8b 53 24 mov 0x24(%ebx),%edx /* set up collection of fat-files fd */ fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control)); 10f335: b9 0c 00 00 00 mov $0xc,%ecx vol->afat_loc = vol->fat_loc + vol->fat_length * vol->afat; 10f33a: 0f b6 43 64 movzbl 0x64(%ebx),%eax 10f33e: 0f af c2 imul %edx,%eax 10f341: 0f b7 53 20 movzwl 0x20(%ebx),%edx 10f345: 01 d0 add %edx,%eax 10f347: 89 43 60 mov %eax,0x60(%ebx) fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control)); 10f34a: 89 4c 24 04 mov %ecx,0x4(%esp) 10f34e: c7 04 24 02 00 00 00 movl $0x2,(%esp) 10f355: e8 66 e5 ff ff call 10d8c0 10f35a: 89 43 7c mov %eax,0x7c(%ebx) if ( fs_info->vhash == NULL ) 10f35d: 85 c0 test %eax,%eax 10f35f: 0f 84 92 03 00 00 je 10f6f7 <== NEVER TAKEN head->previous = NULL; 10f365: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) return &the_chain->Tail.Node; 10f36c: 8d 50 04 lea 0x4(%eax),%edx 10f36f: 89 10 mov %edx,(%eax) 10f371: 8d 48 10 lea 0x10(%eax),%ecx tail->previous = head; 10f374: 89 40 08 mov %eax,0x8(%eax) return &the_chain->Tail.Node; 10f377: 8d 50 0c lea 0xc(%eax),%edx 10f37a: 89 48 0c mov %ecx,0xc(%eax) head->previous = NULL; 10f37d: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax) return &the_chain->Head.Node; 10f384: 89 50 14 mov %edx,0x14(%eax) } for (i = 0; i < FAT_HASH_SIZE; i++) rtems_chain_initialize_empty(fs_info->vhash + i); fs_info->rhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control)); 10f387: b8 0c 00 00 00 mov $0xc,%eax 10f38c: 89 44 24 04 mov %eax,0x4(%esp) 10f390: c7 04 24 02 00 00 00 movl $0x2,(%esp) 10f397: e8 24 e5 ff ff call 10d8c0 10f39c: 89 83 80 00 00 00 mov %eax,0x80(%ebx) if ( fs_info->rhash == NULL ) 10f3a2: 85 c0 test %eax,%eax 10f3a4: 0f 84 d2 02 00 00 je 10f67c <== NEVER TAKEN head->previous = NULL; 10f3aa: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) return &the_chain->Tail.Node; 10f3b1: 8d 50 04 lea 0x4(%eax),%edx for (i = 0; i < FAT_HASH_SIZE; i++) rtems_chain_initialize_empty(fs_info->rhash + i); fs_info->uino_pool_size = FAT_UINO_POOL_INIT_SIZE; fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4; fs_info->index = 0; 10f3b4: 31 ff xor %edi,%edi 10f3b6: 89 10 mov %edx,(%eax) 10f3b8: 8d 48 10 lea 0x10(%eax),%ecx fs_info->uino_pool_size = FAT_UINO_POOL_INIT_SIZE; 10f3bb: be 00 01 00 00 mov $0x100,%esi 10f3c0: 89 48 0c mov %ecx,0xc(%eax) 10f3c3: 8d 50 0c lea 0xc(%eax),%edx fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4; 10f3c6: 0f b6 4b 03 movzbl 0x3(%ebx),%ecx tail->previous = head; 10f3ca: 89 40 08 mov %eax,0x8(%eax) head->previous = NULL; 10f3cd: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax) return &the_chain->Head.Node; 10f3d4: 89 50 14 mov %edx,0x14(%eax) 10f3d7: 8b 43 38 mov 0x38(%ebx),%eax fs_info->uino_pool_size = FAT_UINO_POOL_INIT_SIZE; 10f3da: 89 b3 8c 00 00 00 mov %esi,0x8c(%ebx) fs_info->index = 0; 10f3e0: 89 bb 88 00 00 00 mov %edi,0x88(%ebx) fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4; 10f3e6: d3 e0 shl %cl,%eax 10f3e8: c1 e0 04 shl $0x4,%eax 10f3eb: 89 83 90 00 00 00 mov %eax,0x90(%ebx) fs_info->uino = (char *)calloc(fs_info->uino_pool_size, sizeof(char)); 10f3f1: b8 01 00 00 00 mov $0x1,%eax 10f3f6: 89 44 24 04 mov %eax,0x4(%esp) 10f3fa: c7 04 24 00 01 00 00 movl $0x100,(%esp) 10f401: e8 ba e4 ff ff call 10d8c0 10f406: 89 83 84 00 00 00 mov %eax,0x84(%ebx) if ( fs_info->uino == NULL ) 10f40c: 85 c0 test %eax,%eax 10f40e: 0f 84 c5 02 00 00 je 10f6d9 <== NEVER TAKEN close(vol->fd); free(fs_info->vhash); free(fs_info->rhash); rtems_set_errno_and_return_minus_one( ENOMEM ); } fs_info->sec_buf = (uint8_t *)calloc(vol->bps, sizeof(uint8_t)); 10f414: b9 01 00 00 00 mov $0x1,%ecx 10f419: 89 4c 24 04 mov %ecx,0x4(%esp) 10f41d: 0f b7 03 movzwl (%ebx),%eax 10f420: 89 04 24 mov %eax,(%esp) 10f423: e8 98 e4 ff ff call 10d8c0 10f428: 89 83 a0 00 00 00 mov %eax,0xa0(%ebx) if (fs_info->sec_buf == NULL) 10f42e: 85 c0 test %eax,%eax 10f430: 0f 84 77 02 00 00 je 10f6ad <== NEVER TAKEN return (sec_num & (vol->spc - 1)) == 0; 10f436: 0f b6 43 04 movzbl 0x4(%ebx),%eax 10f43a: 48 dec %eax 10f43b: 89 c2 mov %eax,%edx 10f43d: 23 53 3c and 0x3c(%ebx),%edx /* * If possible we will use the cluster size as bdbuf block size for faster * file access. This requires that certain sectors are aligned to cluster * borders. */ if (is_cluster_aligned(vol, vol->data_fsec) 10f440: 75 3e jne 10f480 <== NEVER TAKEN && (FAT_FAT32 == vol->type || is_cluster_aligned(vol, vol->rdir_loc))) 10f442: 80 7b 16 04 cmpb $0x4,0x16(%ebx) 10f446: 74 05 je 10f44d return (sec_num & (vol->spc - 1)) == 0; 10f448: 23 43 28 and 0x28(%ebx),%eax && (FAT_FAT32 == vol->type || is_cluster_aligned(vol, vol->rdir_loc))) 10f44b: 75 33 jne 10f480 <== NEVER TAKEN { sc = rtems_bdbuf_set_block_size (vol->dd, vol->bpc, true); 10f44d: b8 01 00 00 00 mov $0x1,%eax 10f452: 89 44 24 08 mov %eax,0x8(%esp) 10f456: 8b 43 08 mov 0x8(%ebx),%eax 10f459: 89 44 24 04 mov %eax,0x4(%esp) 10f45d: 8b 43 6c mov 0x6c(%ebx),%eax 10f460: 89 04 24 mov %eax,(%esp) 10f463: e8 28 90 00 00 call 118490 if (sc == RTEMS_SUCCESSFUL) 10f468: 85 c0 test %eax,%eax 10f46a: 75 14 jne 10f480 { vol->bytes_per_block = vol->bpc; 10f46c: 8b 43 08 mov 0x8(%ebx),%eax 10f46f: 89 43 10 mov %eax,0x10(%ebx) vol->bytes_per_block_log2 = vol->bpc_log2; 10f472: 0f b6 43 0c movzbl 0xc(%ebx),%eax 10f476: 88 43 14 mov %al,0x14(%ebx) vol->sectors_per_block = vol->spc; 10f479: 0f b6 43 04 movzbl 0x4(%ebx),%eax 10f47d: 88 43 0d mov %al,0xd(%ebx) } } return RC_OK; } 10f480: 8b 85 64 ff ff ff mov -0x9c(%ebp),%eax 10f486: 81 c4 cc 00 00 00 add $0xcc,%esp 10f48c: 5b pop %ebx 10f48d: 5e pop %esi 10f48e: 5f pop %edi 10f48f: 5d pop %ebp 10f490: c3 ret 10f491: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10f498: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10f49f: 90 nop vol->type = FAT_FAT12; 10f4a0: c6 43 16 01 movb $0x1,0x16(%ebx) vol->mask = FAT_FAT12_MASK; 10f4a4: c7 43 18 ff 0f 00 00 movl $0xfff,0x18(%ebx) vol->eoc_val = FAT_FAT12_EOC; 10f4ab: c7 43 1c f8 0f 00 00 movl $0xff8,0x1c(%ebx) 10f4b2: e9 4e fe ff ff jmp 10f305 10f4b7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10f4be: 66 90 xchg %ax,%ax else if ( vol->data_cls < FAT_FAT32_MASK - 1 ) 10f4c0: 3d fd ff ff 0f cmp $0xffffffd,%eax 10f4c5: 0f 87 f1 00 00 00 ja 10f5bc <== NEVER TAKEN vol->type = FAT_FAT32; 10f4cb: c6 43 16 04 movb $0x4,0x16(%ebx) vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR; 10f4cf: 0f b6 8d 71 ff ff ff movzbl -0x8f(%ebp),%ecx vol->mask = FAT_FAT32_MASK; 10f4d6: c7 43 18 ff ff ff 0f movl $0xfffffff,0x18(%ebx) vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec); 10f4dd: 8b 85 50 ff ff ff mov -0xb0(%ebp),%eax vol->eoc_val = FAT_FAT32_EOC; 10f4e3: c7 43 1c f8 ff ff 0f movl $0xffffff8,0x1c(%ebx) vol->afat = 0; 10f4ea: 88 ca mov %cl,%dl vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec); 10f4ec: 89 43 44 mov %eax,0x44(%ebx) vol->afat = 0; 10f4ef: c0 fa 07 sar $0x7,%dl vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR; 10f4f2: 88 c8 mov %cl,%al 10f4f4: 24 80 and $0x80,%al 10f4f6: 88 43 5c mov %al,0x5c(%ebx) vol->afat = 0; 10f4f9: 88 c8 mov %cl,%al 10f4fb: 24 0f and $0xf,%al 10f4fd: 20 d0 and %dl,%al 10f4ff: 88 43 64 mov %al,0x64(%ebx) vol->info_sec = FAT_GET_BR_FAT32_FS_INFO_SECTOR(boot_rec); 10f502: 8b 85 54 ff ff ff mov -0xac(%ebp),%eax 10f508: 66 89 43 48 mov %ax,0x48(%ebx) if( vol->info_sec == 0 ) 10f50c: 85 c0 test %eax,%eax 10f50e: 0f 84 a8 00 00 00 je 10f5bc <== NEVER TAKEN ret = _fat_block_read(fs_info, vol->info_sec , 0, 10f514: 89 1c 24 mov %ebx,(%esp) 10f517: 8d 75 84 lea -0x7c(%ebp),%esi 10f51a: b8 04 00 00 00 mov $0x4,%eax 10f51f: 89 44 24 0c mov %eax,0xc(%esp) 10f523: 31 c0 xor %eax,%eax 10f525: 89 44 24 08 mov %eax,0x8(%esp) 10f529: 8b 85 54 ff ff ff mov -0xac(%ebp),%eax 10f52f: 89 74 24 10 mov %esi,0x10(%esp) 10f533: 89 44 24 04 mov %eax,0x4(%esp) 10f537: e8 e4 f3 ff ff call 10e920 <_fat_block_read> if ( ret < 0 ) 10f53c: 85 c0 test %eax,%eax 10f53e: 0f 88 1d 01 00 00 js 10f661 <== NEVER TAKEN if (FAT_GET_FSINFO_LEAD_SIGNATURE(fs_info_sector) != 10f544: 81 7d 84 52 52 61 41 cmpl $0x41615252,-0x7c(%ebp) 10f54b: 75 5f jne 10f5ac <== NEVER TAKEN ret = _fat_block_read(fs_info, vol->info_sec , FAT_FSI_INFO, 10f54d: 89 74 24 10 mov %esi,0x10(%esp) <== NOT EXECUTED 10f551: bf e4 01 00 00 mov $0x1e4,%edi <== NOT EXECUTED 10f556: be 0c 00 00 00 mov $0xc,%esi <== NOT EXECUTED 10f55b: 89 74 24 0c mov %esi,0xc(%esp) <== NOT EXECUTED 10f55f: 89 7c 24 08 mov %edi,0x8(%esp) <== NOT EXECUTED 10f563: 0f b7 43 48 movzwl 0x48(%ebx),%eax <== NOT EXECUTED 10f567: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10f56a: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 10f56e: e8 ad f3 ff ff call 10e920 <_fat_block_read> <== NOT EXECUTED if ( ret < 0 ) 10f573: 85 c0 test %eax,%eax 10f575: 0f 88 d6 00 00 00 js 10f651 <== NEVER TAKEN FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector); 10f57b: 8b 45 88 mov -0x78(%ebp),%eax vol->free_cls_in_fs_info = 10f57e: 89 43 50 mov %eax,0x50(%ebx) vol->free_cls = vol->free_cls_in_fs_info; 10f581: 89 43 4c mov %eax,0x4c(%ebx) FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector); 10f584: 8b 45 8c mov -0x74(%ebp),%eax vol->next_cl_in_fs_info = 10f587: 89 43 58 mov %eax,0x58(%ebx) vol->next_cl = vol->next_cl_in_fs_info; 10f58a: 89 43 54 mov %eax,0x54(%ebx) 10f58d: e9 90 fd ff ff jmp 10f322 10f592: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10f599: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0; 10f5a0: 31 c0 xor %eax,%eax 10f5a2: ba 01 00 00 00 mov $0x1,%edx 10f5a7: e9 6c fc ff ff jmp 10f218 if (fs_info->c.state == FAT_CACHE_EMPTY) 10f5ac: 80 bb 99 00 00 00 00 cmpb $0x0,0x99(%ebx) <== NOT EXECUTED 10f5b3: 74 07 je 10f5bc <== NOT EXECUTED 10f5b5: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10f5b7: e8 d4 ef ff ff call 10e590 <== NOT EXECUTED close(vol->fd); 10f5bc: 8b 43 68 mov 0x68(%ebx),%eax <== NOT EXECUTED 10f5bf: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10f5c2: e8 e9 24 ff ff call 101ab0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 10f5c7: e8 d4 72 01 00 call 1268a0 <__errno> <== NOT EXECUTED 10f5cc: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10f5d2: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10f5d7: 89 85 64 ff ff ff mov %eax,-0x9c(%ebp) <== NOT EXECUTED 10f5dd: e9 9e fe ff ff jmp 10f480 <== NOT EXECUTED close(vol->fd); 10f5e2: 8b 43 68 mov 0x68(%ebx),%eax <== NOT EXECUTED 10f5e5: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10f5e8: e8 c3 24 ff ff call 101ab0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one(ENXIO); 10f5ed: e8 ae 72 01 00 call 1268a0 <__errno> <== NOT EXECUTED 10f5f2: c7 00 06 00 00 00 movl $0x6,(%eax) <== NOT EXECUTED 10f5f8: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10f5fd: 89 85 64 ff ff ff mov %eax,-0x9c(%ebp) <== NOT EXECUTED 10f603: e9 78 fe ff ff jmp 10f480 <== NOT EXECUTED close(vol->fd); 10f608: 89 14 24 mov %edx,(%esp) <== NOT EXECUTED 10f60b: e8 a0 24 ff ff call 101ab0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one(ENXIO); 10f610: e8 8b 72 01 00 call 1268a0 <__errno> <== NOT EXECUTED 10f615: c7 00 06 00 00 00 movl $0x6,(%eax) <== NOT EXECUTED 10f61b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10f620: 89 85 64 ff ff ff mov %eax,-0x9c(%ebp) <== NOT EXECUTED 10f626: e9 55 fe ff ff jmp 10f480 <== NOT EXECUTED close(vol->fd); 10f62b: 8b 43 68 mov 0x68(%ebx),%eax <== NOT EXECUTED 10f62e: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10f631: e8 7a 24 ff ff call 101ab0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EIO ); 10f636: e8 65 72 01 00 call 1268a0 <__errno> <== NOT EXECUTED 10f63b: c7 00 05 00 00 00 movl $0x5,(%eax) <== NOT EXECUTED 10f641: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10f646: 89 85 64 ff ff ff mov %eax,-0x9c(%ebp) <== NOT EXECUTED 10f64c: e9 2f fe ff ff jmp 10f480 <== NOT EXECUTED if (fs_info->c.state == FAT_CACHE_EMPTY) 10f651: 80 bb 99 00 00 00 00 cmpb $0x0,0x99(%ebx) <== NOT EXECUTED 10f658: 74 07 je 10f661 <== NOT EXECUTED 10f65a: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10f65c: e8 2f ef ff ff call 10e590 <== NOT EXECUTED close(vol->fd); 10f661: 8b 43 68 mov 0x68(%ebx),%eax <== NOT EXECUTED return -1; 10f664: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED close(vol->fd); 10f669: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10f66c: e8 3f 24 ff ff call 101ab0 <== NOT EXECUTED return -1; 10f671: 89 9d 64 ff ff ff mov %ebx,-0x9c(%ebp) <== NOT EXECUTED 10f677: e9 04 fe ff ff jmp 10f480 <== NOT EXECUTED close(vol->fd); 10f67c: 8b 43 68 mov 0x68(%ebx),%eax <== NOT EXECUTED 10f67f: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10f682: e8 29 24 ff ff call 101ab0 <== NOT EXECUTED free(fs_info->vhash); 10f687: 8b 43 7c mov 0x7c(%ebx),%eax <== NOT EXECUTED free(fs_info->uino); 10f68a: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10f68d: e8 be 25 ff ff call 101c50 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOMEM ); 10f692: e8 09 72 01 00 call 1268a0 <__errno> <== NOT EXECUTED 10f697: ba ff ff ff ff mov $0xffffffff,%edx <== NOT EXECUTED 10f69c: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 10f6a2: 89 95 64 ff ff ff mov %edx,-0x9c(%ebp) <== NOT EXECUTED 10f6a8: e9 d3 fd ff ff jmp 10f480 <== NOT EXECUTED close(vol->fd); 10f6ad: 8b 43 68 mov 0x68(%ebx),%eax <== NOT EXECUTED 10f6b0: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10f6b3: e8 f8 23 ff ff call 101ab0 <== NOT EXECUTED free(fs_info->vhash); 10f6b8: 8b 43 7c mov 0x7c(%ebx),%eax <== NOT EXECUTED 10f6bb: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10f6be: e8 8d 25 ff ff call 101c50 <== NOT EXECUTED free(fs_info->rhash); 10f6c3: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax <== NOT EXECUTED 10f6c9: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10f6cc: e8 7f 25 ff ff call 101c50 <== NOT EXECUTED free(fs_info->uino); 10f6d1: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax <== NOT EXECUTED 10f6d7: eb b1 jmp 10f68a <== NOT EXECUTED close(vol->fd); 10f6d9: 8b 43 68 mov 0x68(%ebx),%eax <== NOT EXECUTED 10f6dc: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10f6df: e8 cc 23 ff ff call 101ab0 <== NOT EXECUTED free(fs_info->vhash); 10f6e4: 8b 43 7c mov 0x7c(%ebx),%eax <== NOT EXECUTED 10f6e7: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10f6ea: e8 61 25 ff ff call 101c50 <== NOT EXECUTED free(fs_info->rhash); 10f6ef: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax <== NOT EXECUTED 10f6f5: eb 93 jmp 10f68a <== NOT EXECUTED close(vol->fd); 10f6f7: 8b 43 68 mov 0x68(%ebx),%eax <== NOT EXECUTED 10f6fa: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10f6fd: e8 ae 23 ff ff call 101ab0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOMEM ); 10f702: e8 99 71 01 00 call 1268a0 <__errno> <== NOT EXECUTED 10f707: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 10f70d: c7 85 64 ff ff ff ff movl $0xffffffff,-0x9c(%ebp) <== NOT EXECUTED 10f714: ff ff ff 10f717: e9 64 fd ff ff jmp 10f480 <== NOT EXECUTED 10f71c: 90 nop 10f71d: 90 nop 10f71e: 90 nop 10f71f: 90 nop =============================================================================== 00110040 : { 110040: 55 push %ebp 110041: 89 e5 mov %esp,%ebp 110043: 57 push %edi 110044: 56 push %esi 110045: 53 push %ebx 110046: 83 ec 4c sub $0x4c,%esp 110049: 8b 75 08 mov 0x8(%ebp),%esi 11004c: 0f b6 45 1c movzbl 0x1c(%ebp),%eax 110050: 8b 7d 14 mov 0x14(%ebp),%edi if (fs_info->vol.next_cl - 2 < fs_info->vol.data_cls) 110053: 8b 5e 54 mov 0x54(%esi),%ebx { 110056: 88 45 cb mov %al,-0x35(%ebp) uint32_t data_cls_val = fs_info->vol.data_cls + 2; 110059: 8b 46 40 mov 0x40(%esi),%eax 11005c: 8d 50 02 lea 0x2(%eax),%edx 11005f: 89 55 d4 mov %edx,-0x2c(%ebp) if (fs_info->vol.next_cl - 2 < fs_info->vol.data_cls) 110062: 8d 53 fe lea -0x2(%ebx),%edx 110065: 39 d0 cmp %edx,%eax 110067: 77 05 ja 11006e uint32_t cl4find = 2; 110069: bb 02 00 00 00 mov $0x2,%ebx while (*cls_added != count && i < data_cls_val) 11006e: 83 7d d4 02 cmpl $0x2,-0x2c(%ebp) *cls_added = 0; 110072: c7 07 00 00 00 00 movl $0x0,(%edi) while (*cls_added != count && i < data_cls_val) 110078: 0f 86 51 01 00 00 jbe 1101cf <== NEVER TAKEN 11007e: 8b 45 10 mov 0x10(%ebp),%eax 110081: 85 c0 test %eax,%eax 110083: 0f 84 46 01 00 00 je 1101cf <== NEVER TAKEN uint32_t i = 2; 110089: c7 45 d0 02 00 00 00 movl $0x2,-0x30(%ebp) uint32_t save_cln = FAT_UNDEFINED_VALUE; 110090: c7 45 cc ff ff ff ff movl $0xffffffff,-0x34(%ebp) 110097: eb 5e jmp 1100f7 110099: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi *chain = cl4find; 1100a0: 8b 45 0c mov 0xc(%ebp),%eax 1100a3: 89 18 mov %ebx,(%eax) rc = fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_EOC); 1100a5: b8 ff ff ff ff mov $0xffffffff,%eax 1100aa: 89 44 24 08 mov %eax,0x8(%esp) 1100ae: 89 5c 24 04 mov %ebx,0x4(%esp) 1100b2: 89 34 24 mov %esi,(%esp) 1100b5: e8 56 fc ff ff call 10fd10 if ( rc != RC_OK ) 1100ba: 85 c0 test %eax,%eax 1100bc: 0f 85 77 01 00 00 jne 110239 <== NEVER TAKEN if (zero_fill) 1100c2: 80 7d cb 00 cmpb $0x0,-0x35(%ebp) 1100c6: 0f 85 d4 00 00 00 jne 1101a0 (*cls_added)++; 1100cc: 89 5d cc mov %ebx,-0x34(%ebp) 1100cf: 8b 07 mov (%edi),%eax 1100d1: 40 inc %eax 1100d2: 89 07 mov %eax,(%edi) i++; 1100d4: ff 45 d0 incl -0x30(%ebp) cl4find++; 1100d7: 43 inc %ebx if (cl4find >= data_cls_val) 1100d8: 39 5d d4 cmp %ebx,-0x2c(%ebp) 1100db: 77 05 ja 1100e2 cl4find = 2; 1100dd: bb 02 00 00 00 mov $0x2,%ebx while (*cls_added != count && i < data_cls_val) 1100e2: 8b 4d d0 mov -0x30(%ebp),%ecx 1100e5: 39 4d d4 cmp %ecx,-0x2c(%ebp) 1100e8: 0f 86 f2 00 00 00 jbe 1101e0 1100ee: 39 45 10 cmp %eax,0x10(%ebp) 1100f1: 0f 84 e9 00 00 00 je 1101e0 rc = fat_get_fat_cluster(fs_info, cl4find, &next_cln); 1100f7: 89 5c 24 04 mov %ebx,0x4(%esp) 1100fb: 8d 45 e4 lea -0x1c(%ebp),%eax 1100fe: 89 44 24 08 mov %eax,0x8(%esp) 110102: 89 34 24 mov %esi,(%esp) uint32_t next_cln = 0; 110105: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) rc = fat_get_fat_cluster(fs_info, cl4find, &next_cln); 11010c: e8 3f fa ff ff call 10fb50 if ( rc != RC_OK ) 110111: 85 c0 test %eax,%eax 110113: 0f 85 f7 00 00 00 jne 110210 <== NEVER TAKEN if (next_cln == FAT_GENFAT_FREE) 110119: 8b 55 e4 mov -0x1c(%ebp),%edx if (*cls_added != 0) 11011c: 8b 07 mov (%edi),%eax if (next_cln == FAT_GENFAT_FREE) 11011e: 85 d2 test %edx,%edx 110120: 75 b2 jne 1100d4 if (*cls_added == 0) 110122: 85 c0 test %eax,%eax 110124: 0f 84 76 ff ff ff je 1100a0 rc = fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_EOC); 11012a: 89 5c 24 04 mov %ebx,0x4(%esp) 11012e: b8 ff ff ff ff mov $0xffffffff,%eax 110133: 89 44 24 08 mov %eax,0x8(%esp) 110137: 89 34 24 mov %esi,(%esp) 11013a: e8 d1 fb ff ff call 10fd10 if ( rc != RC_OK ) 11013f: 85 c0 test %eax,%eax 110141: 0f 85 f6 00 00 00 jne 11023d <== NEVER TAKEN rc = fat_set_fat_cluster(fs_info, save_cln, cl4find); 110147: 89 5c 24 08 mov %ebx,0x8(%esp) 11014b: 8b 45 cc mov -0x34(%ebp),%eax 11014e: 89 34 24 mov %esi,(%esp) 110151: 89 44 24 04 mov %eax,0x4(%esp) 110155: e8 b6 fb ff ff call 10fd10 if ( rc != RC_OK ) 11015a: 85 c0 test %eax,%eax 11015c: 0f 84 60 ff ff ff je 1100c2 <== ALWAYS TAKEN 110162: 89 c2 mov %eax,%edx <== NOT EXECUTED 110164: 89 55 d4 mov %edx,-0x2c(%ebp) <== NOT EXECUTED fat_free_fat_clusters_chain(fs_info, (*chain)); 110167: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 11016a: 8b 00 mov (%eax),%eax <== NOT EXECUTED 11016c: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 11016f: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 110173: e8 f8 fd ff ff call 10ff70 <== NOT EXECUTED (void) fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_FREE); 110178: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 11017a: 89 4c 24 08 mov %ecx,0x8(%esp) <== NOT EXECUTED 11017e: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED 110182: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 110185: e8 86 fb ff ff call 10fd10 <== NOT EXECUTED fat_buf_release(fs_info); 11018a: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 11018d: e8 5e e7 ff ff call 10e8f0 <== NOT EXECUTED return rc; 110192: 8b 55 d4 mov -0x2c(%ebp),%edx <== NOT EXECUTED } 110195: 83 c4 4c add $0x4c,%esp <== NOT EXECUTED 110198: 5b pop %ebx <== NOT EXECUTED 110199: 5e pop %esi <== NOT EXECUTED 11019a: 89 d0 mov %edx,%eax <== NOT EXECUTED 11019c: 5f pop %edi <== NOT EXECUTED 11019d: 5d pop %ebp <== NOT EXECUTED 11019e: c3 ret <== NOT EXECUTED 11019f: 90 nop <== NOT EXECUTED fat_cluster_set(fs_info, cl4find, 0, fs_info->vol.bpc, 0); 1101a0: 31 c0 xor %eax,%eax 1101a2: 89 44 24 10 mov %eax,0x10(%esp) 1101a6: 8b 46 08 mov 0x8(%esi),%eax 1101a9: 89 5c 24 04 mov %ebx,0x4(%esp) 1101ad: 89 34 24 mov %esi,(%esp) 1101b0: 89 44 24 0c mov %eax,0xc(%esp) 1101b4: 31 c0 xor %eax,%eax 1101b6: 89 44 24 08 mov %eax,0x8(%esp) 1101ba: e8 31 ea ff ff call 10ebf0 if (fs_info->vol.bpc != bytes_written) 1101bf: 39 46 08 cmp %eax,0x8(%esi) 1101c2: 0f 84 04 ff ff ff je 1100cc <== ALWAYS TAKEN rc = -1; 1101c8: ba ff ff ff ff mov $0xffffffff,%edx <== NOT EXECUTED 1101cd: eb 95 jmp 110164 <== NOT EXECUTED uint32_t save_cln = FAT_UNDEFINED_VALUE; 1101cf: c7 45 cc ff ff ff ff movl $0xffffffff,-0x34(%ebp) <== NOT EXECUTED 1101d6: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 1101dd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED *last_cl = save_cln; 1101e0: 8b 45 18 mov 0x18(%ebp),%eax 1101e3: 8b 55 cc mov -0x34(%ebp),%edx 1101e6: 89 10 mov %edx,(%eax) fs_info->vol.next_cl = save_cln; 1101e8: 89 56 54 mov %edx,0x54(%esi) if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE) 1101eb: 8b 46 4c mov 0x4c(%esi),%eax 1101ee: 83 f8 ff cmp $0xffffffff,%eax 1101f1: 74 07 je 1101fa <== ALWAYS TAKEN fs_info->vol.free_cls -= (*cls_added); 1101f3: 8b 17 mov (%edi),%edx <== NOT EXECUTED 1101f5: 29 d0 sub %edx,%eax <== NOT EXECUTED 1101f7: 89 46 4c mov %eax,0x4c(%esi) <== NOT EXECUTED fat_buf_release(fs_info); 1101fa: 89 34 24 mov %esi,(%esp) 1101fd: e8 ee e6 ff ff call 10e8f0 return RC_OK; 110202: 31 d2 xor %edx,%edx } 110204: 83 c4 4c add $0x4c,%esp 110207: 89 d0 mov %edx,%eax 110209: 5b pop %ebx 11020a: 5e pop %esi 11020b: 5f pop %edi 11020c: 5d pop %ebp 11020d: c3 ret 11020e: 66 90 xchg %ax,%ax if (*cls_added != 0) 110210: 8b 0f mov (%edi),%ecx <== NOT EXECUTED 110212: 89 c2 mov %eax,%edx <== NOT EXECUTED 110214: 85 c9 test %ecx,%ecx <== NOT EXECUTED 110216: 74 ec je 110204 <== NOT EXECUTED fat_free_fat_clusters_chain(fs_info, (*chain)); 110218: 89 55 d4 mov %edx,-0x2c(%ebp) <== NOT EXECUTED 11021b: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 11021e: 8b 00 mov (%eax),%eax <== NOT EXECUTED 110220: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 110223: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 110227: e8 44 fd ff ff call 10ff70 <== NOT EXECUTED return rc; 11022c: 8b 55 d4 mov -0x2c(%ebp),%edx <== NOT EXECUTED } 11022f: 83 c4 4c add $0x4c,%esp <== NOT EXECUTED 110232: 5b pop %ebx <== NOT EXECUTED 110233: 5e pop %esi <== NOT EXECUTED 110234: 89 d0 mov %edx,%eax <== NOT EXECUTED 110236: 5f pop %edi <== NOT EXECUTED 110237: 5d pop %ebp <== NOT EXECUTED 110238: c3 ret <== NOT EXECUTED 110239: 89 c2 mov %eax,%edx <== NOT EXECUTED 11023b: eb c7 jmp 110204 <== NOT EXECUTED fat_free_fat_clusters_chain(fs_info, (*chain)); 11023d: 89 c2 mov %eax,%edx <== NOT EXECUTED 11023f: eb d7 jmp 110218 <== NOT EXECUTED 110241: 90 nop 110242: 90 nop 110243: 90 nop 110244: 90 nop 110245: 90 nop 110246: 90 nop 110247: 90 nop 110248: 90 nop 110249: 90 nop 11024a: 90 nop 11024b: 90 nop 11024c: 90 nop 11024d: 90 nop 11024e: 90 nop 11024f: 90 nop =============================================================================== 0010eab0 : fat_fs_info_t *fs_info, uint32_t start, uint32_t offset, uint32_t count, const void *buff) { 10eab0: 55 push %ebp 10eab1: 89 e5 mov %esp,%ebp 10eab3: 57 push %edi 10eab4: 56 push %esi 10eab5: 53 push %ebx 10eab6: 83 ec 3c sub $0x3c,%esp uint32_t sec_num = start; uint32_t ofs = offset; uint8_t *sec_buf; uint32_t c = 0; while(count > 0) 10eab9: 8b 45 14 mov 0x14(%ebp),%eax ssize_t cmpltd = 0; 10eabc: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) { 10eac3: 8b 55 08 mov 0x8(%ebp),%edx 10eac6: 8b 75 10 mov 0x10(%ebp),%esi while(count > 0) 10eac9: 85 c0 test %eax,%eax 10eacb: 75 2d jne 10eafa <== ALWAYS TAKEN 10eacd: e9 c5 00 00 00 jmp 10eb97 <== NOT EXECUTED 10ead2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10ead9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED else rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf); if (rc != RC_OK) return -1; memcpy((sec_buf + ofs), (buff + cmpltd), c); 10eae0: f3 a4 rep movsb %ds:(%esi),%es:(%edi) fat_buf_mark_modified(fs_info); count -= c; cmpltd +=c; sec_num++; ofs = 0; 10eae2: 31 f6 xor %esi,%esi } static inline void fat_buf_mark_modified(fat_fs_info_t *fs_info) { fs_info->c.modified = true; 10eae4: c6 82 98 00 00 00 01 movb $0x1,0x98(%edx) cmpltd +=c; 10eaeb: 01 5d d4 add %ebx,-0x2c(%ebp) sec_num++; 10eaee: ff 45 0c incl 0xc(%ebp) while(count > 0) 10eaf1: 29 5d 14 sub %ebx,0x14(%ebp) 10eaf4: 0f 84 9d 00 00 00 je 10eb97 <== ALWAYS TAKEN c = MIN(count, (fs_info->vol.bps - ofs)); 10eafa: 0f b7 1a movzwl (%edx),%ebx 10eafd: 29 f3 sub %esi,%ebx 10eaff: 3b 5d 14 cmp 0x14(%ebp),%ebx 10eb02: 76 03 jbe 10eb07 10eb04: 8b 5d 14 mov 0x14(%ebp),%ebx if (c == fs_info->vol.bytes_per_block) 10eb07: 39 5a 10 cmp %ebx,0x10(%edx) rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &sec_buf); 10eb0a: 8d 45 e4 lea -0x1c(%ebp),%eax 10eb0d: 89 44 24 0c mov %eax,0xc(%esp) if (c == fs_info->vol.bytes_per_block) 10eb11: 74 6d je 10eb80 <== NEVER TAKEN rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf); 10eb13: bf 01 00 00 00 mov $0x1,%edi 10eb18: 89 7c 24 08 mov %edi,0x8(%esp) 10eb1c: 89 14 24 mov %edx,(%esp) 10eb1f: 8b 45 0c mov 0xc(%ebp),%eax 10eb22: 89 55 08 mov %edx,0x8(%ebp) 10eb25: 89 44 24 04 mov %eax,0x4(%esp) 10eb29: e8 f2 fc ff ff call 10e820 10eb2e: 8b 55 08 mov 0x8(%ebp),%edx if (rc != RC_OK) 10eb31: 85 c0 test %eax,%eax 10eb33: 75 5b jne 10eb90 <== NEVER TAKEN memcpy((sec_buf + ofs), (buff + cmpltd), c); 10eb35: 8b 45 e4 mov -0x1c(%ebp),%eax 10eb38: 8b 4d 18 mov 0x18(%ebp),%ecx 10eb3b: 01 c6 add %eax,%esi 10eb3d: 8b 45 d4 mov -0x2c(%ebp),%eax 10eb40: 89 75 d0 mov %esi,-0x30(%ebp) 10eb43: 89 f7 mov %esi,%edi 10eb45: 01 c8 add %ecx,%eax 10eb47: 83 fb 08 cmp $0x8,%ebx 10eb4a: 89 d9 mov %ebx,%ecx 10eb4c: 89 c6 mov %eax,%esi 10eb4e: 72 90 jb 10eae0 <== ALWAYS TAKEN 10eb50: f7 c7 01 00 00 00 test $0x1,%edi <== NOT EXECUTED 10eb56: 75 78 jne 10ebd0 <== NOT EXECUTED 10eb58: f7 c7 02 00 00 00 test $0x2,%edi <== NOT EXECUTED 10eb5e: 75 50 jne 10ebb0 <== NOT EXECUTED 10eb60: f7 c7 04 00 00 00 test $0x4,%edi <== NOT EXECUTED 10eb66: 0f 84 74 ff ff ff je 10eae0 <== NOT EXECUTED 10eb6c: 8b 06 mov (%esi),%eax <== NOT EXECUTED 10eb6e: 83 c7 04 add $0x4,%edi <== NOT EXECUTED 10eb71: 83 c6 04 add $0x4,%esi <== NOT EXECUTED 10eb74: 83 e9 04 sub $0x4,%ecx <== NOT EXECUTED 10eb77: 89 47 fc mov %eax,-0x4(%edi) <== NOT EXECUTED 10eb7a: e9 61 ff ff ff jmp 10eae0 <== NOT EXECUTED 10eb7f: 90 nop <== NOT EXECUTED rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &sec_buf); 10eb80: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED 10eb85: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED 10eb89: eb 91 jmp 10eb1c <== NOT EXECUTED 10eb8b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10eb8f: 90 nop <== NOT EXECUTED return -1; 10eb90: c7 45 d4 ff ff ff ff movl $0xffffffff,-0x2c(%ebp) <== NOT EXECUTED } return cmpltd; } 10eb97: 8b 45 d4 mov -0x2c(%ebp),%eax 10eb9a: 83 c4 3c add $0x3c,%esp 10eb9d: 5b pop %ebx 10eb9e: 5e pop %esi 10eb9f: 5f pop %edi 10eba0: 5d pop %ebp 10eba1: c3 ret 10eba2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10eba9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi memcpy((sec_buf + ofs), (buff + cmpltd), c); 10ebb0: 0f b7 06 movzwl (%esi),%eax <== NOT EXECUTED 10ebb3: 83 c7 02 add $0x2,%edi <== NOT EXECUTED 10ebb6: 83 c6 02 add $0x2,%esi <== NOT EXECUTED 10ebb9: 83 e9 02 sub $0x2,%ecx <== NOT EXECUTED 10ebbc: 66 89 47 fe mov %ax,-0x2(%edi) <== NOT EXECUTED 10ebc0: eb 9e jmp 10eb60 <== NOT EXECUTED 10ebc2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10ebc9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10ebd0: 0f b6 00 movzbl (%eax),%eax <== NOT EXECUTED 10ebd3: 47 inc %edi <== NOT EXECUTED 10ebd4: 46 inc %esi <== NOT EXECUTED 10ebd5: 8d 4b ff lea -0x1(%ebx),%ecx <== NOT EXECUTED 10ebd8: 88 45 cf mov %al,-0x31(%ebp) <== NOT EXECUTED 10ebdb: 88 47 ff mov %al,-0x1(%edi) <== NOT EXECUTED 10ebde: e9 75 ff ff ff jmp 10eb58 <== NOT EXECUTED 10ebe3: 90 nop 10ebe4: 90 nop 10ebe5: 90 nop 10ebe6: 90 nop 10ebe7: 90 nop 10ebe8: 90 nop 10ebe9: 90 nop 10ebea: 90 nop 10ebeb: 90 nop 10ebec: 90 nop 10ebed: 90 nop 10ebee: 90 nop 10ebef: 90 nop =============================================================================== 0010fd10 : fat_set_fat_cluster( fat_fs_info_t *fs_info, uint32_t cln, uint32_t in_val ) { 10fd10: 55 push %ebp 10fd11: 89 e5 mov %esp,%ebp 10fd13: 57 push %edi 10fd14: 56 push %esi 10fd15: 53 push %ebx 10fd16: 83 ec 3c sub $0x3c,%esp uint16_t fat16_clv = 0; uint32_t fat32_clv = 0; uint8_t *sec_buf = NULL; /* sanity check */ if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) ) 10fd19: 83 7d 0c 01 cmpl $0x1,0xc(%ebp) uint8_t *sec_buf = NULL; 10fd1d: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) { 10fd24: 8b 5d 08 mov 0x8(%ebp),%ebx if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) ) 10fd27: 76 75 jbe 10fd9e <== NEVER TAKEN 10fd29: 8b 43 40 mov 0x40(%ebx),%eax 10fd2c: 40 inc %eax 10fd2d: 3b 45 0c cmp 0xc(%ebp),%eax 10fd30: 72 6c jb 10fd9e <== NEVER TAKEN rtems_set_errno_and_return_minus_one(EIO); sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) + 10fd32: 0f b6 43 16 movzbl 0x16(%ebx),%eax fs_info->vol.afat_loc; 10fd36: 8b 73 60 mov 0x60(%ebx),%esi sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) + 10fd39: 0f b6 4b 02 movzbl 0x2(%ebx),%ecx 10fd3d: 88 c2 mov %al,%dl 10fd3f: 80 e2 01 and $0x1,%dl 10fd42: 75 7c jne 10fdc0 10fd44: 24 02 and $0x2,%al 10fd46: 8b 45 0c mov 0xc(%ebp),%eax 10fd49: 0f 84 91 00 00 00 je 10fde0 10fd4f: 8d 3c 00 lea (%eax,%eax,1),%edi <== NOT EXECUTED 10fd52: 89 f8 mov %edi,%eax <== NOT EXECUTED 10fd54: d3 e8 shr %cl,%eax <== NOT EXECUTED 10fd56: 01 f0 add %esi,%eax <== NOT EXECUTED 10fd58: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1); rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf); 10fd5b: 8d 45 e4 lea -0x1c(%ebp),%eax ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1); 10fd5e: 0f b7 33 movzwl (%ebx),%esi rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf); 10fd61: 89 44 24 0c mov %eax,0xc(%esp) 10fd65: b8 01 00 00 00 mov $0x1,%eax 10fd6a: 89 44 24 08 mov %eax,0x8(%esp) 10fd6e: 8b 45 d4 mov -0x2c(%ebp),%eax 10fd71: 89 1c 24 mov %ebx,(%esp) 10fd74: 89 44 24 04 mov %eax,0x4(%esp) 10fd78: e8 a3 ea ff ff call 10e820 if (rc != RC_OK) 10fd7d: 85 c0 test %eax,%eax 10fd7f: 75 2f jne 10fdb0 <== NEVER TAKEN return rc; switch ( fs_info->vol.type ) 10fd81: 0f b6 53 16 movzbl 0x16(%ebx),%edx ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1); 10fd85: 4e dec %esi 10fd86: 21 f7 and %esi,%edi switch ( fs_info->vol.type ) 10fd88: 80 fa 02 cmp $0x2,%dl 10fd8b: 74 73 je 10fe00 10fd8d: 80 fa 04 cmp $0x4,%dl 10fd90: 0f 84 ea 00 00 00 je 10fe80 10fd96: fe ca dec %dl 10fd98: 0f 84 82 00 00 00 je 10fe20 <== ALWAYS TAKEN fat_buf_mark_modified(fs_info); break; default: rtems_set_errno_and_return_minus_one(EIO); 10fd9e: 66 90 xchg %ax,%ax 10fda0: e8 fb 6a 01 00 call 1268a0 <__errno> <== NOT EXECUTED 10fda5: c7 00 05 00 00 00 movl $0x5,(%eax) <== NOT EXECUTED 10fdab: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED break; } return RC_OK; } 10fdb0: 83 c4 3c add $0x3c,%esp 10fdb3: 5b pop %ebx 10fdb4: 5e pop %esi 10fdb5: 5f pop %edi 10fdb6: 5d pop %ebp 10fdb7: c3 ret 10fdb8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10fdbf: 90 nop sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) + 10fdc0: 8b 7d 0c mov 0xc(%ebp),%edi 10fdc3: 8b 45 0c mov 0xc(%ebp),%eax 10fdc6: d1 ef shr %edi 10fdc8: 01 c7 add %eax,%edi 10fdca: 89 f8 mov %edi,%eax 10fdcc: d3 e8 shr %cl,%eax 10fdce: 01 f0 add %esi,%eax 10fdd0: 89 45 d4 mov %eax,-0x2c(%ebp) ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1); 10fdd3: eb 86 jmp 10fd5b 10fdd5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10fddc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) + 10fde0: 8d 3c 85 00 00 00 00 lea 0x0(,%eax,4),%edi 10fde7: 89 f8 mov %edi,%eax 10fde9: d3 e8 shr %cl,%eax 10fdeb: 01 f0 add %esi,%eax 10fded: 89 45 d4 mov %eax,-0x2c(%ebp) ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1); 10fdf0: e9 66 ff ff ff jmp 10fd5b 10fdf5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10fdfc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi *((uint16_t *)(sec_buf + ofs)) = 10fe00: 8b 55 e4 mov -0x1c(%ebp),%edx (uint16_t )(CT_LE_W(in_val)); 10fe03: 8b 4d 10 mov 0x10(%ebp),%ecx 10fe06: 66 89 0c 3a mov %cx,(%edx,%edi,1) fs_info->c.modified = true; 10fe0a: c6 83 98 00 00 00 01 movb $0x1,0x98(%ebx) } 10fe11: 83 c4 3c add $0x3c,%esp 10fe14: 5b pop %ebx 10fe15: 5e pop %esi 10fe16: 5f pop %edi 10fe17: 5d pop %ebp 10fe18: c3 ret 10fe19: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi *(sec_buf + ofs) &= 0x0F; 10fe20: 8b 75 e4 mov -0x1c(%ebp),%esi fat16_clv = ((uint16_t )in_val) << FAT_FAT12_SHIFT; 10fe23: 0f b7 55 10 movzwl 0x10(%ebp),%edx *(sec_buf + ofs) &= 0x0F; 10fe27: 01 fe add %edi,%esi if ( FAT_CLUSTER_IS_ODD(cln) ) 10fe29: f6 45 0c 01 testb $0x1,0xc(%ebp) fat16_clv = ((uint16_t )in_val) << FAT_FAT12_SHIFT; 10fe2d: 89 d1 mov %edx,%ecx if ( FAT_CLUSTER_IS_ODD(cln) ) 10fe2f: 74 7f je 10feb0 *(sec_buf + ofs) &= 0x0F; 10fe31: 80 26 0f andb $0xf,(%esi) fat16_clv = ((uint16_t )in_val) << FAT_FAT12_SHIFT; 10fe34: c1 e1 04 shl $0x4,%ecx 10fe37: 0f b7 d1 movzwl %cx,%edx 10fe3a: 89 55 d0 mov %edx,-0x30(%ebp) *(sec_buf + ofs) |= (uint8_t)(fat16_clv & 0x00F0); 10fe3d: 8b 55 e4 mov -0x1c(%ebp),%edx 10fe40: 01 fa add %edi,%edx 10fe42: 08 0a or %cl,(%edx) 10fe44: c6 83 98 00 00 00 01 movb $0x1,0x98(%ebx) if ( ofs == (fs_info->vol.bps - 1) ) 10fe4b: 0f b7 13 movzwl (%ebx),%edx 10fe4e: 4a dec %edx 10fe4f: 39 fa cmp %edi,%edx 10fe51: 0f 84 99 00 00 00 je 10fef0 *(sec_buf + ofs + 1) &= 0x00; 10fe57: 8b 55 e4 mov -0x1c(%ebp),%edx *(sec_buf + ofs + 1) |= (uint8_t )((fat16_clv & 0xFF00)>>8); 10fe5a: 8b 4d d0 mov -0x30(%ebp),%ecx *(sec_buf + ofs + 1) &= 0x00; 10fe5d: c6 44 3a 01 00 movb $0x0,0x1(%edx,%edi,1) 10fe62: 47 inc %edi *(sec_buf + ofs + 1) |= (uint8_t )((fat16_clv & 0xFF00)>>8); 10fe63: 8b 5d e4 mov -0x1c(%ebp),%ebx 10fe66: 0f b6 d5 movzbl %ch,%edx 10fe69: 01 df add %ebx,%edi 10fe6b: 08 17 or %dl,(%edi) 10fe6d: e9 3e ff ff ff jmp 10fdb0 10fe72: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10fe79: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi *((uint32_t *)(sec_buf + ofs)) &= CT_LE_L(0xF0000000); 10fe80: 8b 55 e4 mov -0x1c(%ebp),%edx 10fe83: 01 d7 add %edx,%edi fat32_clv = CT_LE_L((in_val & FAT_FAT32_MASK)); 10fe85: 8b 55 10 mov 0x10(%ebp),%edx *((uint32_t *)(sec_buf + ofs)) &= CT_LE_L(0xF0000000); 10fe88: 8b 0f mov (%edi),%ecx fat32_clv = CT_LE_L((in_val & FAT_FAT32_MASK)); 10fe8a: 81 e2 ff ff ff 0f and $0xfffffff,%edx *((uint32_t *)(sec_buf + ofs)) &= CT_LE_L(0xF0000000); 10fe90: 81 e1 00 00 00 f0 and $0xf0000000,%ecx *((uint32_t *)(sec_buf + ofs)) |= fat32_clv; 10fe96: 09 ca or %ecx,%edx 10fe98: 89 17 mov %edx,(%edi) 10fe9a: c6 83 98 00 00 00 01 movb $0x1,0x98(%ebx) } 10fea1: 83 c4 3c add $0x3c,%esp 10fea4: 5b pop %ebx 10fea5: 5e pop %esi 10fea6: 5f pop %edi 10fea7: 5d pop %ebp 10fea8: c3 ret 10fea9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi *(sec_buf + ofs) &= 0x00; 10feb0: c6 06 00 movb $0x0,(%esi) fat16_clv = ((uint16_t )in_val) & FAT_FAT12_MASK; 10feb3: 81 e1 ff 0f 00 00 and $0xfff,%ecx 10feb9: 89 4d d0 mov %ecx,-0x30(%ebp) *(sec_buf + ofs) |= (uint8_t)(fat16_clv & 0x00FF); 10febc: 8b 75 e4 mov -0x1c(%ebp),%esi 10febf: 01 fe add %edi,%esi 10fec1: 08 16 or %dl,(%esi) 10fec3: c6 83 98 00 00 00 01 movb $0x1,0x98(%ebx) if ( ofs == (fs_info->vol.bps - 1) ) 10feca: 0f b7 13 movzwl (%ebx),%edx 10fecd: 4a dec %edx 10fece: 39 fa cmp %edi,%edx 10fed0: 74 6e je 10ff40 <== NEVER TAKEN *(sec_buf + ofs + 1) &= 0xF0; 10fed2: 8b 55 e4 mov -0x1c(%ebp),%edx *(sec_buf + ofs+1) |= (uint8_t)((fat16_clv & 0xFF00)>>8); 10fed5: 8b 5d d0 mov -0x30(%ebp),%ebx *(sec_buf + ofs + 1) &= 0xF0; 10fed8: 80 64 3a 01 f0 andb $0xf0,0x1(%edx,%edi,1) *(sec_buf + ofs+1) |= (uint8_t)((fat16_clv & 0xFF00)>>8); 10fedd: 0f b6 d7 movzbl %bh,%edx 10fee0: 8b 4d e4 mov -0x1c(%ebp),%ecx 10fee3: 08 54 39 01 or %dl,0x1(%ecx,%edi,1) 10fee7: e9 c4 fe ff ff jmp 10fdb0 10feec: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ, 10fef0: 89 1c 24 mov %ebx,(%esp) 10fef3: 8d 45 e4 lea -0x1c(%ebp),%eax 10fef6: be 01 00 00 00 mov $0x1,%esi 10fefb: 89 74 24 08 mov %esi,0x8(%esp) 10feff: 8b 75 d4 mov -0x2c(%ebp),%esi 10ff02: 89 44 24 0c mov %eax,0xc(%esp) 10ff06: 46 inc %esi 10ff07: 89 74 24 04 mov %esi,0x4(%esp) 10ff0b: e8 10 e9 ff ff call 10e820 if (rc != RC_OK) 10ff10: 85 c0 test %eax,%eax 10ff12: 0f 85 98 fe ff ff jne 10fdb0 <== NEVER TAKEN *sec_buf &= 0x00; 10ff18: 8b 55 e4 mov -0x1c(%ebp),%edx 10ff1b: c6 02 00 movb $0x0,(%edx) *sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8); 10ff1e: 8b 4d d0 mov -0x30(%ebp),%ecx 10ff21: 8b 55 e4 mov -0x1c(%ebp),%edx 10ff24: 0f b6 cd movzbl %ch,%ecx 10ff27: 08 0a or %cl,(%edx) 10ff29: c6 83 98 00 00 00 01 movb $0x1,0x98(%ebx) } 10ff30: e9 7b fe ff ff jmp 10fdb0 10ff35: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10ff3c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ, 10ff40: 8b 75 d4 mov -0x2c(%ebp),%esi <== NOT EXECUTED 10ff43: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 10ff46: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED 10ff4b: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED 10ff4f: 89 4c 24 08 mov %ecx,0x8(%esp) <== NOT EXECUTED 10ff53: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10ff56: 46 inc %esi <== NOT EXECUTED 10ff57: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED 10ff5b: e8 c0 e8 ff ff call 10e820 <== NOT EXECUTED if (rc != RC_OK) 10ff60: 85 c0 test %eax,%eax <== NOT EXECUTED 10ff62: 0f 85 48 fe ff ff jne 10fdb0 <== NOT EXECUTED *sec_buf &= 0xF0; 10ff68: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED 10ff6b: 80 22 f0 andb $0xf0,(%edx) <== NOT EXECUTED 10ff6e: eb ae jmp 10ff1e <== NOT EXECUTED =============================================================================== 0010f820 : * RC_OK on success, or -1 if error occured * and errno set appropriately */ int fat_shutdown_drive(fat_fs_info_t *fs_info) { 10f820: 55 push %ebp 10f821: 89 e5 mov %esp,%ebp 10f823: 57 push %edi 10f824: 56 push %esi 10f825: 53 push %ebx 10f826: 83 ec 2c sub $0x2c,%esp 10f829: 8b 5d 08 mov 0x8(%ebp),%ebx int rc = RC_OK; int i = 0; rc = fat_sync(fs_info); 10f82c: 89 1c 24 mov %ebx,(%esp) 10f82f: e8 ec fe ff ff call 10f720 rc = -1; for (i = 0; i < FAT_HASH_SIZE; i++) { rtems_chain_node *node = NULL; rtems_chain_control *the_chain = fs_info->vhash + i; 10f834: 8b 7b 7c mov 0x7c(%ebx),%edi return _Chain_Immutable_head( the_chain )->next; 10f837: 8b 17 mov (%edi),%edx return &the_chain->Tail.Node; 10f839: 8d 77 04 lea 0x4(%edi),%esi rc = fat_sync(fs_info); 10f83c: 89 45 e4 mov %eax,-0x1c(%ebp) if ( rc != RC_OK ) 10f83f: 85 c0 test %eax,%eax 10f841: 0f 95 c0 setne %al 10f844: 0f b6 c0 movzbl %al,%eax 10f847: f7 d8 neg %eax if ( !_Chain_Is_empty(the_chain)) 10f849: 39 d6 cmp %edx,%esi 10f84b: 89 45 e0 mov %eax,-0x20(%ebp) 10f84e: 74 18 je 10f868 new_first = old_first->next; 10f850: 8b 02 mov (%edx),%eax <== NOT EXECUTED head->next = new_first; 10f852: 89 07 mov %eax,(%edi) <== NOT EXECUTED new_first->previous = head; 10f854: 89 78 04 mov %edi,0x4(%eax) <== NOT EXECUTED while ( (node = rtems_chain_get_unprotected(the_chain)) != NULL ) free(node); 10f857: 89 14 24 mov %edx,(%esp) <== NOT EXECUTED 10f85a: e8 f1 23 ff ff call 101c50 <== NOT EXECUTED return _Chain_Immutable_head( the_chain )->next; 10f85f: 8b 17 mov (%edi),%edx if ( !_Chain_Is_empty(the_chain)) 10f861: 39 d6 cmp %edx,%esi 10f863: 75 eb jne 10f850 rtems_chain_control *the_chain = fs_info->vhash + i; 10f865: 8b 7b 7c mov 0x7c(%ebx),%edi return _Chain_Immutable_head( the_chain )->next; 10f868: 8b 57 0c mov 0xc(%edi),%edx return &the_chain->Tail.Node; 10f86b: 8d 47 10 lea 0x10(%edi),%eax 10f86e: 8d 77 0c lea 0xc(%edi),%esi if ( !_Chain_Is_empty(the_chain)) 10f871: 39 c2 cmp %eax,%edx 10f873: 74 25 je 10f89a <== ALWAYS TAKEN 10f875: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED 10f878: 89 fb mov %edi,%ebx <== NOT EXECUTED 10f87a: 89 f7 mov %esi,%edi <== NOT EXECUTED 10f87c: 89 c6 mov %eax,%esi <== NOT EXECUTED 10f87e: 66 90 xchg %ax,%ax <== NOT EXECUTED new_first = old_first->next; 10f880: 8b 02 mov (%edx),%eax <== NOT EXECUTED head->next = new_first; 10f882: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED new_first->previous = head; 10f885: 89 78 04 mov %edi,0x4(%eax) <== NOT EXECUTED free(node); 10f888: 89 14 24 mov %edx,(%esp) <== NOT EXECUTED 10f88b: e8 c0 23 ff ff call 101c50 <== NOT EXECUTED return _Chain_Immutable_head( the_chain )->next; 10f890: 8b 53 0c mov 0xc(%ebx),%edx <== NOT EXECUTED if ( !_Chain_Is_empty(the_chain)) 10f893: 39 d6 cmp %edx,%esi <== NOT EXECUTED 10f895: 75 e9 jne 10f880 <== NOT EXECUTED 10f897: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED } for (i = 0; i < FAT_HASH_SIZE; i++) { rtems_chain_node *node = NULL; rtems_chain_control *the_chain = fs_info->rhash + i; 10f89a: 8b bb 80 00 00 00 mov 0x80(%ebx),%edi return _Chain_Immutable_head( the_chain )->next; 10f8a0: 8b 17 mov (%edi),%edx return &the_chain->Tail.Node; 10f8a2: 8d 77 04 lea 0x4(%edi),%esi if ( !_Chain_Is_empty(the_chain)) 10f8a5: 39 d6 cmp %edx,%esi 10f8a7: 74 22 je 10f8cb <== ALWAYS TAKEN 10f8a9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi new_first = old_first->next; 10f8b0: 8b 02 mov (%edx),%eax <== NOT EXECUTED head->next = new_first; 10f8b2: 89 07 mov %eax,(%edi) <== NOT EXECUTED new_first->previous = head; 10f8b4: 89 78 04 mov %edi,0x4(%eax) <== NOT EXECUTED while ( (node = rtems_chain_get_unprotected(the_chain)) != NULL ) free(node); 10f8b7: 89 14 24 mov %edx,(%esp) <== NOT EXECUTED 10f8ba: e8 91 23 ff ff call 101c50 <== NOT EXECUTED return _Chain_Immutable_head( the_chain )->next; 10f8bf: 8b 17 mov (%edi),%edx <== NOT EXECUTED if ( !_Chain_Is_empty(the_chain)) 10f8c1: 39 f2 cmp %esi,%edx <== NOT EXECUTED 10f8c3: 75 eb jne 10f8b0 <== NOT EXECUTED rtems_chain_control *the_chain = fs_info->rhash + i; 10f8c5: 8b bb 80 00 00 00 mov 0x80(%ebx),%edi <== NOT EXECUTED return _Chain_Immutable_head( the_chain )->next; 10f8cb: 8b 57 0c mov 0xc(%edi),%edx return &the_chain->Tail.Node; 10f8ce: 8d 47 10 lea 0x10(%edi),%eax 10f8d1: 8d 77 0c lea 0xc(%edi),%esi if ( !_Chain_Is_empty(the_chain)) 10f8d4: 39 d0 cmp %edx,%eax 10f8d6: 74 32 je 10f90a <== ALWAYS TAKEN 10f8d8: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED 10f8db: 89 fb mov %edi,%ebx <== NOT EXECUTED 10f8dd: 89 f7 mov %esi,%edi <== NOT EXECUTED 10f8df: 89 c6 mov %eax,%esi <== NOT EXECUTED 10f8e1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10f8e8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10f8ef: 90 nop <== NOT EXECUTED new_first = old_first->next; 10f8f0: 8b 02 mov (%edx),%eax <== NOT EXECUTED head->next = new_first; 10f8f2: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED new_first->previous = head; 10f8f5: 89 78 04 mov %edi,0x4(%eax) <== NOT EXECUTED free(node); 10f8f8: 89 14 24 mov %edx,(%esp) <== NOT EXECUTED 10f8fb: e8 50 23 ff ff call 101c50 <== NOT EXECUTED return _Chain_Immutable_head( the_chain )->next; 10f900: 8b 53 0c mov 0xc(%ebx),%edx <== NOT EXECUTED if ( !_Chain_Is_empty(the_chain)) 10f903: 39 d6 cmp %edx,%esi <== NOT EXECUTED 10f905: 75 e9 jne 10f8f0 <== NOT EXECUTED 10f907: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED } free(fs_info->vhash); 10f90a: 8b 43 7c mov 0x7c(%ebx),%eax 10f90d: 89 04 24 mov %eax,(%esp) 10f910: e8 3b 23 ff ff call 101c50 free(fs_info->rhash); 10f915: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax 10f91b: 89 04 24 mov %eax,(%esp) 10f91e: e8 2d 23 ff ff call 101c50 free(fs_info->uino); 10f923: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax 10f929: 89 04 24 mov %eax,(%esp) 10f92c: e8 1f 23 ff ff call 101c50 free(fs_info->sec_buf); 10f931: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax 10f937: 89 04 24 mov %eax,(%esp) 10f93a: e8 11 23 ff ff call 101c50 close(fs_info->vol.fd); 10f93f: 8b 43 68 mov 0x68(%ebx),%eax 10f942: 89 04 24 mov %eax,(%esp) 10f945: e8 66 21 ff ff call 101ab0 if (rc) 10f94a: 8b 45 e4 mov -0x1c(%ebp),%eax 10f94d: 85 c0 test %eax,%eax 10f94f: 75 0f jne 10f960 <== NEVER TAKEN errno = EIO; return rc; } 10f951: 8b 45 e0 mov -0x20(%ebp),%eax 10f954: 83 c4 2c add $0x2c,%esp 10f957: 5b pop %ebx 10f958: 5e pop %esi 10f959: 5f pop %edi 10f95a: 5d pop %ebp 10f95b: c3 ret 10f95c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi errno = EIO; 10f960: e8 3b 6f 01 00 call 1268a0 <__errno> <== NOT EXECUTED 10f965: c7 00 05 00 00 00 movl $0x5,(%eax) <== NOT EXECUTED } 10f96b: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 10f96e: 83 c4 2c add $0x2c,%esp <== NOT EXECUTED 10f971: 5b pop %ebx <== NOT EXECUTED 10f972: 5e pop %esi <== NOT EXECUTED 10f973: 5f pop %edi <== NOT EXECUTED 10f974: 5d pop %ebp <== NOT EXECUTED 10f975: c3 ret <== NOT EXECUTED 10f976: 90 nop 10f977: 90 nop 10f978: 90 nop 10f979: 90 nop 10f97a: 90 nop 10f97b: 90 nop 10f97c: 90 nop 10f97d: 90 nop 10f97e: 90 nop 10f97f: 90 nop =============================================================================== 0010f720 : return RC_OK; } int fat_sync(fat_fs_info_t *fs_info) { 10f720: 55 push %ebp 10f721: 89 e5 mov %esp,%ebp 10f723: 83 ec 58 sub $0x58,%esp 10f726: 89 75 f8 mov %esi,-0x8(%ebp) 10f729: 8b 75 08 mov 0x8(%ebp),%esi 10f72c: 89 5d f4 mov %ebx,-0xc(%ebp) return RC_OK; 10f72f: 31 db xor %ebx,%ebx { 10f731: 89 7d fc mov %edi,-0x4(%ebp) if (fs_info->vol.type == FAT_FAT32) 10f734: 80 7e 16 04 cmpb $0x4,0x16(%esi) 10f738: 74 36 je 10f770 if (fs_info->c.state == FAT_CACHE_EMPTY) 10f73a: 80 be 99 00 00 00 00 cmpb $0x0,0x99(%esi) 10f741: 74 07 je 10f74a 10f743: 89 f0 mov %esi,%eax 10f745: e8 46 ee ff ff call 10e590 if ( rc != RC_OK ) rc = -1; fat_buf_release(fs_info); if (rtems_bdbuf_syncdev(fs_info->vol.dd) != RTEMS_SUCCESSFUL) 10f74a: 8b 46 6c mov 0x6c(%esi),%eax 10f74d: 89 04 24 mov %eax,(%esp) 10f750: e8 4b 8c 00 00 call 1183a0 10f755: 85 c0 test %eax,%eax 10f757: 0f 85 b3 00 00 00 jne 10f810 <== NEVER TAKEN rc = -1; return rc; } 10f75d: 8b 75 f8 mov -0x8(%ebp),%esi 10f760: 89 d8 mov %ebx,%eax 10f762: 8b 5d f4 mov -0xc(%ebp),%ebx 10f765: 8b 7d fc mov -0x4(%ebp),%edi 10f768: 89 ec mov %ebp,%esp 10f76a: 5d pop %ebp 10f76b: c3 ret 10f76c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi uint32_t free_count = fs_info->vol.free_cls; 10f770: 8b 46 4c mov 0x4c(%esi),%eax if (free_count != fs_info->vol.free_cls_in_fs_info) 10f773: 3b 46 50 cmp 0x50(%esi),%eax uint32_t next_free = fs_info->vol.next_cl; 10f776: 8b 7e 54 mov 0x54(%esi),%edi if (free_count != fs_info->vol.free_cls_in_fs_info) 10f779: 75 45 jne 10f7c0 <== NEVER TAKEN if (next_free != fs_info->vol.next_cl_in_fs_info) 10f77b: 3b 7e 58 cmp 0x58(%esi),%edi 10f77e: 74 ba je 10f73a 10f780: 8d 55 e4 lea -0x1c(%ebp),%edx 10f783: 31 db xor %ebx,%ebx fs_info->vol.next_cl_in_fs_info = next_free; 10f785: 89 7e 58 mov %edi,0x58(%esi) ret2 = fat_sector_write(fs_info, 10f788: b8 04 00 00 00 mov $0x4,%eax 10f78d: 89 54 24 10 mov %edx,0x10(%esp) 10f791: ba ec 01 00 00 mov $0x1ec,%edx 10f796: 89 44 24 0c mov %eax,0xc(%esp) 10f79a: 89 54 24 08 mov %edx,0x8(%esp) uint32_t le_next_free = CT_LE_L(next_free); 10f79e: 89 7d e4 mov %edi,-0x1c(%ebp) ret2 = fat_sector_write(fs_info, 10f7a1: 0f b7 46 48 movzwl 0x48(%esi),%eax 10f7a5: 89 34 24 mov %esi,(%esp) 10f7a8: 89 44 24 04 mov %eax,0x4(%esp) 10f7ac: e8 ff f2 ff ff call 10eab0 if ( (ret1 < 0) || (ret2 < 0) ) 10f7b1: c1 e8 1f shr $0x1f,%eax 10f7b4: 08 c3 or %al,%bl 10f7b6: 0f b6 db movzbl %bl,%ebx 10f7b9: f7 db neg %ebx 10f7bb: e9 7a ff ff ff jmp 10f73a ret1 = fat_sector_write(fs_info, 10f7c0: 8d 55 e4 lea -0x1c(%ebp),%edx <== NOT EXECUTED 10f7c3: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED fs_info->vol.free_cls_in_fs_info = free_count; 10f7c8: 89 46 50 mov %eax,0x50(%esi) <== NOT EXECUTED ret1 = fat_sector_write(fs_info, 10f7cb: bb e8 01 00 00 mov $0x1e8,%ebx <== NOT EXECUTED 10f7d0: 89 54 24 10 mov %edx,0x10(%esp) <== NOT EXECUTED 10f7d4: 89 5c 24 08 mov %ebx,0x8(%esp) <== NOT EXECUTED 10f7d8: 89 4c 24 0c mov %ecx,0xc(%esp) <== NOT EXECUTED uint32_t le_free_count = CT_LE_L(free_count); 10f7dc: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED ret1 = fat_sector_write(fs_info, 10f7df: 0f b7 46 48 movzwl 0x48(%esi),%eax <== NOT EXECUTED 10f7e3: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10f7e6: 89 55 d4 mov %edx,-0x2c(%ebp) <== NOT EXECUTED 10f7e9: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 10f7ed: e8 be f2 ff ff call 10eab0 <== NOT EXECUTED if (next_free != fs_info->vol.next_cl_in_fs_info) 10f7f2: 8b 55 d4 mov -0x2c(%ebp),%edx <== NOT EXECUTED ret1 = fat_sector_write(fs_info, 10f7f5: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( (ret1 < 0) || (ret2 < 0) ) 10f7f7: c1 eb 1f shr $0x1f,%ebx <== NOT EXECUTED if (next_free != fs_info->vol.next_cl_in_fs_info) 10f7fa: 3b 7e 58 cmp 0x58(%esi),%edi <== NOT EXECUTED 10f7fd: 74 b7 je 10f7b6 <== NOT EXECUTED 10f7ff: eb 84 jmp 10f785 <== NOT EXECUTED 10f801: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10f808: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10f80f: 90 nop <== NOT EXECUTED rc = -1; 10f810: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED return rc; 10f815: e9 43 ff ff ff jmp 10f75d <== NOT EXECUTED 10f81a: 90 nop 10f81b: 90 nop 10f81c: 90 nop 10f81d: 90 nop 10f81e: 90 nop 10f81f: 90 nop =============================================================================== 00111380 : fat_file_type_t type, const char *name, int name_len, mode_t mode, const fat_file_fd_t *link_fd) { 111380: 55 push %ebp msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info; fat_file_fd_t *parent_fat_fd = parent_loc->node_access; fat_file_fd_t *fat_fd = NULL; time_t now; uint16_t time_val = 0; uint16_t date = 0; 111381: 31 d2 xor %edx,%edx { 111383: 89 e5 mov %esp,%ebp dir_pos->sname.cln = 0; 111385: 31 c9 xor %ecx,%ecx 111387: 57 push %edi dir_pos->sname.ofs = 0; 111388: 31 ff xor %edi,%edi 11138a: 56 push %esi 11138b: 53 push %ebx 11138c: 81 ec dc 00 00 00 sub $0xdc,%esp uint16_t date = 0; 111392: 66 89 95 52 ff ff ff mov %dx,-0xae(%ebp) msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info; 111399: 8b 45 08 mov 0x8(%ebp),%eax uint32_t sec = 0; uint32_t byte = 0; fat_dir_pos_init(&dir_pos); memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE); 11139c: 31 d2 xor %edx,%edx 11139e: 89 bd 5c ff ff ff mov %edi,-0xa4(%ebp) 1113a4: 8d bd 68 ff ff ff lea -0x98(%ebp),%edi dir_pos->sname.cln = 0; 1113aa: 89 8d 58 ff ff ff mov %ecx,-0xa8(%ebp) msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info; 1113b0: 8b 40 14 mov 0x14(%eax),%eax 1113b3: 8b 70 08 mov 0x8(%eax),%esi fat_file_fd_t *parent_fat_fd = parent_loc->node_access; 1113b6: 8b 45 08 mov 0x8(%ebp),%eax 1113b9: 8b 58 08 mov 0x8(%eax),%ebx fat_file_fd_t *fat_fd = NULL; 1113bc: 31 c0 xor %eax,%eax 1113be: 89 85 54 ff ff ff mov %eax,-0xac(%ebp) uint16_t time_val = 0; 1113c4: 31 c0 xor %eax,%eax 1113c6: 66 89 85 50 ff ff ff mov %ax,-0xb0(%ebp) dir_pos->lname.cln = FAT_FILE_SHORT_NAME; 1113cd: b8 ff ff ff ff mov $0xffffffff,%eax 1113d2: 89 85 60 ff ff ff mov %eax,-0xa0(%ebp) dir_pos->lname.ofs = FAT_FILE_SHORT_NAME; 1113d8: b8 ff ff ff ff mov $0xffffffff,%eax 1113dd: 89 85 64 ff ff ff mov %eax,-0x9c(%ebp) memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE); 1113e3: 31 c0 xor %eax,%eax 1113e5: 89 14 07 mov %edx,(%edi,%eax,1) 1113e8: 89 54 07 04 mov %edx,0x4(%edi,%eax,1) 1113ec: 83 c0 08 add $0x8,%eax 1113ef: 83 f8 20 cmp $0x20,%eax 1113f2: 72 f1 jb 1113e5 memset(dot_dotdot, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2); 1113f4: 31 d2 xor %edx,%edx 1113f6: 31 c0 xor %eax,%eax 1113f8: 89 54 05 a8 mov %edx,-0x58(%ebp,%eax,1) 1113fc: 89 54 05 ac mov %edx,-0x54(%ebp,%eax,1) 111400: 83 c0 08 add $0x8,%eax 111403: 83 f8 40 cmp $0x40,%eax 111406: 72 f0 jb 1113f8 if (name_len > MSDOS_NAME_MAX_LFN_WITH_DOT) { 111408: 81 7d 14 04 01 00 00 cmpl $0x104,0x14(%ebp) 11140f: 0f 8f 39 04 00 00 jg 11184e <== NEVER TAKEN rtems_set_errno_and_return_minus_one(ENAMETOOLONG); } name_type = msdos_long_to_short (fs_info->converter, 111415: 89 7c 24 0c mov %edi,0xc(%esp) 111419: b8 0b 00 00 00 mov $0xb,%eax 11141e: 89 44 24 10 mov %eax,0x10(%esp) 111422: 8b 45 14 mov 0x14(%ebp),%eax 111425: 89 44 24 08 mov %eax,0x8(%esp) 111429: 8b 45 10 mov 0x10(%ebp),%eax 11142c: 89 44 24 04 mov %eax,0x4(%esp) 111430: 8b 86 c8 00 00 00 mov 0xc8(%esi),%eax 111436: 89 04 24 mov %eax,(%esp) 111439: e8 f2 08 00 00 call 111d30 11143e: 89 85 44 ff ff ff mov %eax,-0xbc(%ebp) name, name_len, MSDOS_DIR_NAME(short_node), MSDOS_NAME_MAX); if (name_type == MSDOS_NAME_INVALID) { 111444: 85 c0 test %eax,%eax 111446: 0f 84 24 04 00 00 je 111870 <== NEVER TAKEN /* fill reserved field */ *MSDOS_DIR_NT_RES(short_node) = MSDOS_RES_NT_VALUE; /* set up last write date and time */ now = time(NULL); 11144c: c7 04 24 00 00 00 00 movl $0x0,(%esp) *MSDOS_DIR_NT_RES(short_node) = MSDOS_RES_NT_VALUE; 111453: c6 85 74 ff ff ff 00 movb $0x0,-0x8c(%ebp) now = time(NULL); 11145a: e8 21 a8 01 00 call 12bc80