RTEMS-6
Annotated Report
libdosfs
Sun Feb 28 23:08:24 2021
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 <fat_buf_release.part.0>
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 <rtems_bdbuf_read>
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 <fat_buf_access>:
{
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 <fat_buf_access+0x4f>
10e85a: 39 bb 94 00 00 00 cmp %edi,0x94(%ebx)
10e860: 89 55 e4 mov %edx,-0x1c(%ebp)
10e863: 74 3f je 10e8a4 <fat_buf_access+0x84>
if (fs_info->c.state == FAT_CACHE_EMPTY)
10e865: 89 d8 mov %ebx,%eax
10e867: e8 24 fd ff ff call 10e590 <fat_buf_release.part.0>
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 <fat_buf_access+0xb0>
sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &fs_info->c.buf);
10e889: e8 c2 96 00 00 call 117f50 <rtems_bdbuf_get>
if (sc != RTEMS_SUCCESSFUL)
10e88e: 85 c0 test %eax,%eax
10e890: 75 45 jne 10e8d7 <fat_buf_access+0xb7> <== 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 <rtems_bdbuf_read>
10e8d5: eb b7 jmp 10e88e <fat_buf_access+0x6e>
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 <fat_buf_access+0x96> <== NOT EXECUTED
10e8e9: 90 nop
10e8ea: 90 nop
10e8eb: 90 nop
10e8ec: 90 nop
10e8ed: 90 nop
10e8ee: 90 nop
10e8ef: 90 nop
0010e590 <fat_buf_release.part.0>:
*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 <fat_buf_release.part.0+0x170> <== 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 <fat_buf_release.part.0+0x60> <== 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 <rtems_bdbuf_release_modified> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
10e5c4: 85 c0 test %eax,%eax <== NOT EXECUTED
10e5c6: 0f 85 44 01 00 00 jne 10e710 <fat_buf_release.part.0+0x180> <== 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 <fat_buf_release.part.0+0x2c>
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 <fat_buf_release.part.0+0x1b0>
sc = rtems_bdbuf_release_modified(fs_info->c.buf);
10e5ff: 89 14 24 mov %edx,(%esp)
10e602: e8 19 9d 00 00 call 118320 <rtems_bdbuf_release_modified>
if (sc != RTEMS_SUCCESSFUL)
10e607: 85 c0 test %eax,%eax
10e609: 0f 85 01 01 00 00 jne 10e710 <fat_buf_release.part.0+0x180>
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 <fat_buf_release.part.0+0x43>
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 <fat_buf_release.part.0+0xc1>
10e626: eb ab jmp 10e5d3 <fat_buf_release.part.0+0x43>
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 <rtems_bdbuf_release_modified>
if ( sc != RTEMS_SUCCESSFUL)
10e63d: 85 c0 test %eax,%eax
10e63f: 0f 85 3b 01 00 00 jne 10e780 <fat_buf_release.part.0+0x1f0>
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 <fat_buf_release.part.0+0x43>
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 <fat_buf_release.part.0+0x101>
&& 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 <fat_buf_release.part.0+0x190>
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 <rtems_bdbuf_read>
if ( sc != RTEMS_SUCCESSFUL)
10e6a1: 85 c0 test %eax,%eax
10e6a3: 0f 85 d7 00 00 00 jne 10e780 <fat_buf_release.part.0+0x1f0>
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 <fat_buf_release.part.0+0xa0>
10e6c7: f6 c2 01 test $0x1,%dl
10e6ca: 0f 85 f0 00 00 00 jne 10e7c0 <fat_buf_release.part.0+0x230>
10e6d0: f7 c7 02 00 00 00 test $0x2,%edi
10e6d6: 0f 85 c4 00 00 00 jne 10e7a0 <fat_buf_release.part.0+0x210>
10e6dc: f7 c7 04 00 00 00 test $0x4,%edi
10e6e2: 0f 84 48 ff ff ff je 10e630 <fat_buf_release.part.0+0xa0>
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 <fat_buf_release.part.0+0xa0>
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 <rtems_bdbuf_release>
if (sc != RTEMS_SUCCESSFUL)
10e708: 85 c0 test %eax,%eax
10e70a: 0f 84 c3 fe ff ff je 10e5d3 <fat_buf_release.part.0+0x43>
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 <fat_buf_release.part.0+0x1fb>
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 <rtems_bdbuf_get>
10e730: e9 6c ff ff ff jmp 10e6a1 <fat_buf_release.part.0+0x111>
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 <fat_buf_release.part.0+0x240>
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 <fat_buf_release.part.0+0x6f>
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 <fat_buf_release.part.0+0x14c>
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 <fat_buf_release.part.0+0x140>
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 <fat_buf_release.part.0+0x26b>
10e7d8: f7 c7 02 00 00 00 test $0x2,%edi
10e7de: 75 26 jne 10e806 <fat_buf_release.part.0+0x276>
10e7e0: f7 c7 04 00 00 00 test $0x4,%edi
10e7e6: 74 81 je 10e769 <fat_buf_release.part.0+0x1d9>
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 <fat_buf_release.part.0+0x1d9>
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 <fat_buf_release.part.0+0x248>
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 <fat_buf_release.part.0+0x250>
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_cluster_set>:
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 <fat_cluster_set+0x2b> <== 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 <fat_cluster_set+0x4c> <== ALWAYS TAKEN
10ec32: f6 46 16 03 testb $0x3,0x16(%esi) <== NOT EXECUTED
10ec36: 0f 85 74 01 00 00 jne 10edb0 <fat_cluster_set+0x1c0> <== 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 <fat_cluster_set+0x1d0> <== 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 <fat_cluster_set+0xb4> <== 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 <fat_cluster_set+0xbd> <== 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 <fat_cluster_set+0x167> <== 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 <fat_cluster_set+0x170>
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 <fat_buf_access>
if (RC_OK == rc)
10ece4: 85 c0 test %eax,%eax
10ece6: 74 48 je 10ed30 <fat_cluster_set+0x140> <== 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 <fat_cluster_set+0x120> <== 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 <fat_cluster_set+0x106>
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 <fat_cluster_set+0xa0>
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 <fat_cluster_set+0x190> <== ALWAYS TAKEN
10ed3e: 83 e2 07 and $0x7,%edx
10ed41: 74 0d je 10ed50 <fat_cluster_set+0x160> <== 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 <fat_cluster_set+0x158> <== 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 <fat_cluster_set+0xfa>
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 <fat_buf_access>
10ed75: e9 6a ff ff ff jmp 10ece4 <fat_cluster_set+0xf4>
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 <fat_cluster_set+0x1ff>
10ed84: f7 c7 02 00 00 00 test $0x2,%edi
10ed8a: 75 46 jne 10edd2 <fat_cluster_set+0x1e2>
10ed8c: f7 c7 04 00 00 00 test $0x4,%edi
10ed92: 75 4d jne 10ede1 <fat_cluster_set+0x1f1>
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 <fat_cluster_set+0x14e>
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 <fat_cluster_set+0x63> <== 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 <fat_cluster_set+0x19c>
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 <fat_cluster_set+0x1a4>
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 <fat_cluster_set+0x194>
10edfb: 90 nop
10edfc: 90 nop
10edfd: 90 nop
10edfe: 90 nop
10edff: 90 nop
0010ee00 <fat_cluster_write>:
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 <fat_cluster_write+0x24>
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 <fat_cluster_write+0x4c>
10ee42: f6 42 16 03 testb $0x3,0x16(%edx)
10ee46: 0f 85 54 01 00 00 jne 10efa0 <fat_cluster_write+0x1a0> <== 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 <fat_cluster_write+0xfc> <== 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 <fat_cluster_write+0xa4>
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 <fat_cluster_write+0xad>
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 <fat_cluster_write+0x152> <== 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 <fat_cluster_write+0x160>
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 <fat_buf_access>
10eee7: 8b 55 08 mov 0x8(%ebp),%edx
if (RC_OK == rc)
10eeea: 85 c0 test %eax,%eax
10eeec: 74 42 je 10ef30 <fat_cluster_write+0x130> <== 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 <fat_cluster_write+0x110> <== 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 <fat_cluster_write+0xfc> <== 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 <fat_cluster_write+0x90> <== 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 <fat_cluster_write+0x170>
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 <fat_cluster_write+0xf0>
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 <fat_cluster_write+0xd8>
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 <fat_cluster_write+0x1aa>
10ef78: f7 c7 02 00 00 00 test $0x2,%edi
10ef7e: 75 3a jne 10efba <fat_cluster_write+0x1ba>
10ef80: f7 c7 04 00 00 00 test $0x4,%edi
10ef86: 74 c1 je 10ef49 <fat_cluster_write+0x149>
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 <fat_cluster_write+0x149>
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 <fat_cluster_write+0x65>
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 <fat_cluster_write+0x178>
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 <fat_cluster_write+0x180>
10efcc: 90 nop
10efcd: 90 nop
10efce: 90 nop
10efcf: 90 nop
00110950 <fat_file_close>:
{
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_file_close+0x30>
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 <fat_buf_release>
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 <fat_file_update>
if (fat_fd->flags & FAT_FILE_REMOVED)
11098c: f6 43 30 01 testb $0x1,0x30(%ebx)
110990: 75 1e jne 1109b0 <fat_file_close+0x60>
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 <fat_ino_is_unique>
1109a1: 84 c0 test %al,%al
1109a3: 74 4b je 1109f0 <fat_file_close+0xa0>
fat_fd->links_num = 0;
1109a5: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx)
1109ac: eb c0 jmp 11096e <fat_file_close+0x1e>
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 <fat_file_truncate>
if (rc == RC_OK)
1109c2: 85 c0 test %eax,%eax
1109c4: 75 a8 jne 11096e <fat_file_close+0x1e> <== 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 <fat_ino_is_unique>
1109df: 84 c0 test %al,%al
1109e1: 75 1d jne 110a00 <fat_file_close+0xb0> <== NEVER TAKEN
free(fat_fd);
1109e3: 89 1c 24 mov %ebx,(%esp)
1109e6: e8 65 12 ff ff call 101c50 <free>
1109eb: eb 81 jmp 11096e <fat_file_close+0x1e>
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 <fat_file_close+0x93>
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 <fat_free_unique_ino> <== NOT EXECUTED
free(fat_fd);
110a0f: eb d2 jmp 1109e3 <fat_file_close+0x93> <== 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 <fat_file_extend>:
{
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 <fat_file_extend+0x194>
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 <fat_file_extend+0x1b0>
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 <fat_file_extend+0x190>
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 <fat_file_extend+0x73>
110b3b: 84 db test %bl,%bl
110b3d: 0f 85 74 01 00 00 jne 110cb7 <fat_file_extend+0x1e7> <== 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 <fat_file_extend+0x194>
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 <fat_scan_fat_for_free_clusters>
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 <fat_file_extend+0x196> <== 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 <fat_file_extend+0x1c8> <== NEVER TAKEN
if (cls2add != cls_added)
110b9e: 39 c8 cmp %ecx,%eax
110ba0: 74 19 je 110bbb <fat_file_extend+0xeb>
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 <fat_file_extend+0xe8> <== 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 <fat_file_extend+0x240> <== 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 <fat_file_extend+0x260>
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 <fat_file_extend+0x279> <== 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 <fat_set_fat_cluster>
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 <fat_file_extend+0x173> <== 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 <fat_buf_release>
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 <fat_file_extend+0x240>
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 <fat_init_clusters_chain>
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 <fat_file_extend+0x240> <== 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 <fat_free_fat_clusters_chain> <== NOT EXECUTED
return rc;
110c55: 89 da mov %ebx,%edx <== NOT EXECUTED
110c57: eb 0d jmp 110c66 <fat_file_extend+0x196> <== 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 <fat_file_extend+0x1e0>
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 <fat_file_extend+0x41> <== 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 <fat_file_extend+0x41> <== 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 <fat_file_extend+0x196>
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 <fat_file_lseek>
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 <fat_file_extend+0x196> <== 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 <fat_cluster_set> <== 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 <fat_file_extend+0x196> <== NEVER TAKEN
110d08: e9 36 fe ff ff jmp 110b43 <fat_file_extend+0x73>
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 <fat_file_extend+0x140>
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 <fat_file_ioctl> <== 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 <fat_file_extend+0x173> <== 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 <fat_file_extend+0x10d> <== 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 <fat_file_ioctl>:
{
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 <fat_file_ioctl+0x60> <== 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 <fat_file_ioctl+0x90> <== NEVER TAKEN
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
110a4a: 83 7a 20 01 cmpl $0x1,0x20(%edx)
110a4e: 75 07 jne 110a57 <fat_file_ioctl+0x37>
110a50: 8b 4a 24 mov 0x24(%edx),%ecx
110a53: 85 c9 test %ecx,%ecx
110a55: 74 49 je 110aa0 <fat_file_ioctl+0x80> <== 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 <fat_file_lseek>
if ( rc != RC_OK )
110a6c: 85 c0 test %eax,%eax
110a6e: 75 05 jne 110a75 <fat_file_ioctl+0x55> <== 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 <fat_file_ioctl+0x37>
*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 <fat_file_ioctl+0x55>
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 <fat_file_ioctl+0x55> <== 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 <fat_file_mark_removed>:
{
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 <fat_file_mark_removed+0x16> <== 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 <fat_file_open>:
{
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 <fat_file_open+0x35>
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 <fat_file_open+0x1e0>
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 <fat_file_open+0xb6>
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 <fat_file_open+0x95>
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
110383: 85 c0 test %eax,%eax
110385: 75 0a jne 110391 <fat_file_open+0x81>
110387: f6 43 16 03 testb $0x3,0x16(%ebx)
11038b: 0f 85 8f 01 00 00 jne 110520 <fat_file_open+0x210> <== 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 <fat_file_open+0x1c0>
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 <fat_file_open+0x68>
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 <fat_file_open+0xeb> <== NEVER TAKEN
1103dd: e9 4e 01 00 00 jmp 110530 <fat_file_open+0x220>
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 <fat_file_open+0x220> <== 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 <fat_file_open+0x118> <== 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 <fat_file_open+0x104> <== NOT EXECUTED
11040a: f6 43 16 03 testb $0x3,0x16(%ebx) <== NOT EXECUTED
11040e: 0f 85 fc 00 00 00 jne 110510 <fat_file_open+0x200> <== 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 <fat_file_open+0xe0> <== NOT EXECUTED
if ( ((key2) == 0) || ((key2) == ffd->ino) )
11043e: 85 f6 test %esi,%esi <== NOT EXECUTED
110440: 74 05 je 110447 <fat_file_open+0x137> <== NOT EXECUTED
110442: 3b 77 0c cmp 0xc(%edi),%esi <== NOT EXECUTED
110445: 75 a9 jne 1103f0 <fat_file_open+0xe0> <== 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 <calloc> <== 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 <fat_file_open+0x2a2> <== 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 <fat_get_unique_ino> <== 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 <fat_file_open+0x295> <== 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 <fat_file_open+0x278> <== 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 <fat_file_open+0x21> <== NEVER TAKEN
return fs_info->vol.rdir_loc;
1104fa: 8b 53 28 mov 0x28(%ebx),%edx
1104fd: e9 3d fe ff ff jmp 11033f <fat_file_open+0x2f>
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 <fat_file_open+0x112> <== 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 <fat_file_open+0x8f>
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 <calloc>
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 <fat_file_open+0x2a2> <== 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 <free> <== 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 <fat_file_open+0x1ca> <== 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 <fat_file_read>:
{
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 <fat_file_read+0x130> <== 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 <fat_file_read+0x130>
if ((count > fat_fd->fat_file_size) ||
11068f: 39 f0 cmp %esi,%eax
110691: 0f 82 09 01 00 00 jb 1107a0 <fat_file_read+0x140>
(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 <fat_file_read+0x140>
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 <fat_file_read+0x57>
1106ac: 8b 48 24 mov 0x24(%eax),%ecx
1106af: 85 c9 test %ecx,%ecx
1106b1: 0f 84 f9 00 00 00 je 1107b0 <fat_file_read+0x150> <== 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 <fat_file_lseek>
if (rc != RC_OK)
1106da: 85 c0 test %eax,%eax
1106dc: 0f 85 b0 00 00 00 jne 110792 <fat_file_read+0x132> <== 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 <fat_file_read+0x10b>
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 <fat_file_read+0x19c> <== 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 <fat_get_fat_cluster>
if ( rc != RC_OK )
11075d: 85 c0 test %eax,%eax
11075f: 75 31 jne 110792 <fat_file_read+0x132> <== 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 <fat_file_read+0x1b0>
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 <fat_file_read+0x116>
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 <fat_file_read+0xa0> <== ALWAYS TAKEN
11077d: f6 43 16 03 testb $0x3,0x16(%ebx) <== NOT EXECUTED
110781: 0f 84 79 ff ff ff je 110700 <fat_file_read+0xa0> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
110787: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED
11078a: eb 82 jmp 11070e <fat_file_read+0xae> <== 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 <fat_file_read+0x43>
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 <fat_file_read+0x57>
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 <fat_file_read+0x1e0> <== 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 <fat_file_read+0x132> <== 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 <fat_file_read+0x132>
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 <fat_file_read+0x16f>
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 <fat_file_size>:
{
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_file_size+0x80>
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 <fat_file_size+0x45> <== ALWAYS TAKEN
11108c: eb 36 jmp 1110c4 <fat_file_size+0x64> <== 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 <fat_file_size+0x66>
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 <fat_get_fat_cluster>
if ( rc != RC_OK )
1110b8: 85 c0 test %eax,%eax
1110ba: 74 d4 je 111090 <fat_file_size+0x30> <== 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 <fat_file_size+0x1b> <== NEVER TAKEN
1110e7: f6 43 16 03 testb $0x3,0x16(%ebx)
1110eb: 74 8e je 11107b <fat_file_size+0x1b>
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 <fat_file_size+0x5c>
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 <fat_file_truncate>:
{
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 <fat_file_truncate+0xa0>
assert(fat_fd->fat_file_size);
11087d: 85 d2 test %edx,%edx
11087f: 0f 84 a6 00 00 00 je 11092b <fat_file_truncate+0xdb> <== 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 <fat_file_truncate+0xa0>
if (cl_start != 0)
11089b: 85 ff test %edi,%edi
11089d: 74 16 je 1108b5 <fat_file_truncate+0x65>
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 <fat_file_lseek>
if (rc != RC_OK)
1108b1: 85 c0 test %eax,%eax
1108b3: 75 3d jne 1108f2 <fat_file_truncate+0xa2> <== 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 <fat_file_lseek>
if (rc != RC_OK)
1108c6: 85 c0 test %eax,%eax
1108c8: 75 28 jne 1108f2 <fat_file_truncate+0xa2> <== 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 <fat_free_fat_clusters_chain>
if (rc != RC_OK)
1108d9: 85 c0 test %eax,%eax
1108db: 75 15 jne 1108f2 <fat_file_truncate+0xa2> <== NEVER TAKEN
if (cl_start != 0)
1108dd: 85 ff test %edi,%edi
1108df: 75 1f jne 110900 <fat_file_truncate+0xb0>
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 <fat_set_fat_cluster>
if ( rc != RC_OK )
110918: 85 c0 test %eax,%eax
11091a: 75 d6 jne 1108f2 <fat_file_truncate+0xa2> <== 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 <fat_file_truncate+0xa2>
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 <fat_file_update>:
{
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 <fat_file_update+0x6b>
1105ff: 24 02 and $0x2,%al
110601: 74 48 je 11064b <fat_file_update+0x6b>
FAT_FILE_HAS_META_DATA_CHANGED(fat_fd) &&
110603: 83 7b 20 01 cmpl $0x1,0x20(%ebx)
110607: 75 07 jne 110610 <fat_file_update+0x30>
!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 <fat_file_update+0x6b> <== 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 <fat_file_write_first_cluster_num>
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 <fat_file_write_file_size>
if (rc != RC_OK)
110630: 85 c0 test %eax,%eax
110632: 74 02 je 110636 <fat_file_update+0x56> <== 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 <fat_file_write_time_and_date>
if (rc != RC_OK)
110645: 85 c0 test %eax,%eax
110647: 74 02 je 11064b <fat_file_update+0x6b> <== 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 <fat_file_write>:
{
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 <fat_file_write+0x170> <== 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 <fat_file_write+0x25e> <== 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 <fat_file_write+0x160> <== 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 <fat_file_extend>
if (RC_OK == rc)
110df9: 85 c0 test %eax,%eax
110dfb: 0f 85 e6 00 00 00 jne 110ee7 <fat_file_write+0x157>
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 <fat_file_write+0x7f>
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 <fat_file_write+0x1c0>
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 <fat_file_lseek>
if (RC_OK == rc)
110e46: 85 c0 test %eax,%eax
110e48: 0f 85 91 00 00 00 jne 110edf <fat_file_write+0x14f> <== 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 <fat_file_write+0x23e> <== 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 <fat_file_write+0x104>
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 <fat_cluster_write>
if (0 > ret)
110eab: 85 c0 test %eax,%eax
110ead: 0f 88 fd 00 00 00 js 110fb0 <fat_file_write+0x220> <== 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 <fat_file_write+0x180>
((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 <fat_file_write+0x209> <== 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 <fat_file_write+0x39>
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 <fat_get_fat_cluster>
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 <fat_file_write+0xf0> <== 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 <fat_file_write+0x14f> <== 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 <fat_file_write+0x9c> <== NEVER TAKEN
110f5b: f6 47 16 03 testb $0x3,0x16(%edi)
110f5f: 0f 84 c7 fe ff ff je 110e2c <fat_file_write+0x9c>
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 <fat_cluster_write>
if (0 > ret)
110f91: 85 c0 test %eax,%eax
110f93: 0f 89 4e ff ff ff jns 110ee7 <fat_file_write+0x157> <== ALWAYS TAKEN
rc = -1;
110f99: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
110f9e: e9 44 ff ff ff jmp 110ee7 <fat_file_write+0x157> <== 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 <fat_file_write+0x209> <== 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 <fat_file_write+0x157> <== 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 <fat_file_write+0x157> <== 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 <fat_file_write_file_size>:
{
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 <fat_file_write_file_size+0x29>
1122a3: f6 42 16 03 testb $0x3,0x16(%edx)
1122a7: 75 67 jne 112310 <fat_file_write_file_size+0x90> <== 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 <fat_file_write_file_size+0x59>
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 <fat_sector_write>
}
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 <fat_file_write_file_size+0x37>
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 <fat_file_write_first_cluster_num>:
{
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 <fat_file_write_first_cluster_num+0x29>
1121cf: f6 46 16 03 testb $0x3,0x16(%esi)
1121d3: 0f 85 97 00 00 00 jne 112270 <fat_file_write_first_cluster_num+0xc0> <== 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 <fat_sector_write>
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 <fat_sector_write>
}
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 <fat_file_write_first_cluster_num+0x37>
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 <fat_file_write_time_and_date>:
{
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 <fat_file_write_time_and_date+0x20>
112036: f6 43 16 03 testb $0x3,0x16(%ebx)
11203a: 0f 85 50 01 00 00 jne 112190 <fat_file_write_time_and_date+0x170> <== 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 <msdos_date_unix2dos>
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 <fat_sector_write>
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 <fat_sector_write>
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 <fat_file_write_time_and_date+0xc3> <== 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 <fat_sector_write>
if ( ret < 0 )
112109: 8b 55 0c mov 0xc(%ebp),%edx
11210c: 85 c0 test %eax,%eax
11210e: 79 07 jns 112117 <fat_file_write_time_and_date+0xf7> <== 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 <msdos_date_unix2dos>
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 <fat_sector_write>
if ( ret < 0 )
112153: 85 c0 test %eax,%eax
112155: 79 07 jns 11215e <fat_file_write_time_and_date+0x13e> <== 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 <fat_sector_write>
if ( ret < 0 )
112181: 85 c0 test %eax,%eax
112183: 78 1b js 1121a0 <fat_file_write_time_and_date+0x180> <== 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 <fat_file_write_time_and_date+0x2e>
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 <fat_file_write_time_and_date+0x165> <== NOT EXECUTED
1121a9: 90 nop
1121aa: 90 nop
1121ab: 90 nop
1121ac: 90 nop
1121ad: 90 nop
1121ae: 90 nop
1121af: 90 nop
0010ff70 <fat_free_fat_clusters_chain>:
{
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 <fat_free_fat_clusters_chain+0x93> <== 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 <fat_free_fat_clusters_chain+0x57>
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 <fat_set_fat_cluster>
if ( rc != RC_OK )
10ffb2: 85 c0 test %eax,%eax
10ffb4: 74 03 je 10ffb9 <fat_free_fat_clusters_chain+0x49> <== 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 <fat_free_fat_clusters_chain+0xa0>
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 <fat_get_fat_cluster>
if ( rc != RC_OK )
10ffda: 85 c0 test %eax,%eax
10ffdc: 74 c2 je 10ffa0 <fat_free_fat_clusters_chain+0x30> <== 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 <fat_free_fat_clusters_chain+0x7d> <== 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 <fat_buf_release> <== 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 <fat_free_fat_clusters_chain+0xb3> <== 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 <fat_buf_release>
}
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 <fat_free_unique_ino>:
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_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 <fat_get_fat_cluster+0x83> <== 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 <fat_get_fat_cluster+0x83> <== 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 <fat_get_fat_cluster+0xa0>
10fb7d: 24 02 and $0x2,%al
10fb7f: 8b 45 0c mov 0xc(%ebp),%eax
10fb82: 0f 84 88 00 00 00 je 10fc10 <fat_get_fat_cluster+0xc0>
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 <fat_buf_access>
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 <fat_get_fat_cluster+0x93> <== 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 <fat_get_fat_cluster+0xe0>
10fbc7: 3c 04 cmp $0x4,%al
10fbc9: 0f 84 c1 00 00 00 je 10fc90 <fat_get_fat_cluster+0x140>
10fbcf: fe c8 dec %al
10fbd1: 74 7d je 10fc50 <fat_get_fat_cluster+0x100> <== 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 <fat_get_fat_cluster+0x44>
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 <fat_get_fat_cluster+0x44>
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 <fat_get_fat_cluster+0x170>
*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 <fat_get_fat_cluster+0x160>
*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 <fat_get_fat_cluster+0x93>
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 <fat_get_fat_cluster+0x93>
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 <fat_buf_access>
if (rc != RC_OK)
10fce3: 85 c0 test %eax,%eax
10fce5: 75 19 jne 10fd00 <fat_get_fat_cluster+0x1b0> <== 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 <fat_get_fat_cluster+0x11e>
10fcff: 90 nop
10fd00: 89 c2 mov %eax,%edx <== NOT EXECUTED
10fd02: e9 dc fe ff ff jmp 10fbe3 <fat_get_fat_cluster+0x93> <== 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 <fat_get_unique_ino>:
* 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 <fat_get_unique_ino+0x74> <== 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 <fat_get_unique_ino+0x3b> <== 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 <fat_get_unique_ino+0x72> <== 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 <fat_get_unique_ino+0xc0> <== 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 <fat_get_unique_ino+0x30> <== 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 <fat_get_unique_ino+0x3b> <== 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 <fat_get_unique_ino+0xe8> <== 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 <realloc> <== 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 <fat_get_unique_ino+0xe8> <== 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 <fat_get_unique_ino+0x12> <== 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 <fat_get_unique_ino+0xe0> <== NOT EXECUTED
10fafc: 90 nop
10fafd: 90 nop
10fafe: 90 nop
10faff: 90 nop
0010f980 <fat_init_clusters_chain>:
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 <fat_init_clusters_chain+0x5e>
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 <fat_cluster_set> <== NOT EXECUTED
if ( ret != fs_info->vol.bpc )
10f9bf: 39 43 08 cmp %eax,0x8(%ebx)
10f9c2: 75 3c jne 10fa00 <fat_init_clusters_chain+0x80> <== 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 <fat_get_fat_cluster>
if ( rc != RC_OK )
10f9d7: 85 c0 test %eax,%eax
10f9d9: 75 0f jne 10f9ea <fat_init_clusters_chain+0x6a> <== 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 <fat_init_clusters_chain+0x20>
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 <fat_init_volume_info>:
* 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 <open>
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 <fat_init_volume_info+0x61d> <== 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 <fstat>
if (rc != 0)
10f014: 85 c0 test %eax,%eax
10f016: 0f 85 c6 05 00 00 jne 10f5e2 <fat_init_volume_info+0x612> <== 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 <fat_init_volume_info+0x638> <== 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 <ioctl>
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 <fat_init_volume_info+0x612> <== 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 <rtems_bdbuf_read>
if (sc != RTEMS_SUCCESSFUL)
10f07c: 85 c0 test %eax,%eax
10f07e: 0f 85 a7 05 00 00 jne 10f62b <fat_init_volume_info+0x65b> <== 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 <rtems_bdbuf_release>
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 <fat_init_volume_info+0x65b> <== 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 <fat_init_volume_info+0x161> <== 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 <fat_init_volume_info+0x5ec> <== 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 <fat_init_volume_info+0x191> <== 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 <fat_init_volume_info+0x180> <== 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 <fat_init_volume_info+0x1c1> <== 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 <fat_init_volume_info+0x1b0>
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 <rtems_bdbuf_set_block_size>
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 <fat_init_volume_info+0x5ec> <== 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 <fat_init_volume_info+0x5ec> <== 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 <fat_init_volume_info+0x5d0>
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 <fat_init_volume_info+0x230>
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 <fat_init_volume_info+0x5ec> <== 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 <fat_init_volume_info+0x27e> <== 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 <fat_init_volume_info+0x270>
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 <fat_init_volume_info+0x2c7>
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 <fat_init_volume_info+0x2fb>
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 <fat_init_volume_info+0x4d0>
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 <fat_init_volume_info+0x4f0>
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 <fat_init_volume_info+0x362>
10f32b: 89 d8 mov %ebx,%eax
10f32d: e8 5e f2 ff ff call 10e590 <fat_buf_release.part.0>
}
_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 <calloc>
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 <fat_init_volume_info+0x727> <== 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 <calloc>
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 <fat_init_volume_info+0x6ac> <== 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 <calloc>
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 <fat_init_volume_info+0x709> <== 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 <calloc>
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 <fat_init_volume_info+0x6dd> <== 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 <fat_init_volume_info+0x4b0> <== 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 <fat_init_volume_info+0x47d>
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 <fat_init_volume_info+0x4b0> <== 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 <rtems_bdbuf_set_block_size>
if (sc == RTEMS_SUCCESSFUL)
10f468: 85 c0 test %eax,%eax
10f46a: 75 14 jne 10f480 <fat_init_volume_info+0x4b0>
{
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 <fat_init_volume_info+0x335>
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 <fat_init_volume_info+0x5ec> <== 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 <fat_init_volume_info+0x5ec> <== 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 <fat_init_volume_info+0x691> <== 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 <fat_init_volume_info+0x5dc> <== 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 <fat_init_volume_info+0x681> <== 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 <fat_init_volume_info+0x352>
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 <fat_init_volume_info+0x248>
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 <fat_init_volume_info+0x5ec> <== NOT EXECUTED
10f5b5: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10f5b7: e8 d4 ef ff ff call 10e590 <fat_buf_release.part.0> <== 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 <close> <== 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 <fat_init_volume_info+0x4b0> <== 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 <close> <== 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 <fat_init_volume_info+0x4b0> <== NOT EXECUTED
close(vol->fd);
10f608: 89 14 24 mov %edx,(%esp) <== NOT EXECUTED
10f60b: e8 a0 24 ff ff call 101ab0 <close> <== 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 <fat_init_volume_info+0x4b0> <== 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 <close> <== 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 <fat_init_volume_info+0x4b0> <== 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 <fat_init_volume_info+0x691> <== NOT EXECUTED
10f65a: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10f65c: e8 2f ef ff ff call 10e590 <fat_buf_release.part.0> <== 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 <close> <== 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 <fat_init_volume_info+0x4b0> <== 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 <close> <== 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 <free> <== 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 <fat_init_volume_info+0x4b0> <== 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 <close> <== 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 <free> <== 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 <free> <== NOT EXECUTED
free(fs_info->uino);
10f6d1: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax <== NOT EXECUTED
10f6d7: eb b1 jmp 10f68a <fat_init_volume_info+0x6ba> <== 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 <close> <== 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 <free> <== NOT EXECUTED
free(fs_info->rhash);
10f6ef: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax <== NOT EXECUTED
10f6f5: eb 93 jmp 10f68a <fat_init_volume_info+0x6ba> <== 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 <close> <== 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 <fat_init_volume_info+0x4b0> <== NOT EXECUTED
10f71c: 90 nop
10f71d: 90 nop
10f71e: 90 nop
10f71f: 90 nop
00110040 <fat_scan_fat_for_free_clusters>:
{
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 <fat_scan_fat_for_free_clusters+0x2e>
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 <fat_scan_fat_for_free_clusters+0x18f> <== 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 <fat_scan_fat_for_free_clusters+0x18f> <== 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 <fat_scan_fat_for_free_clusters+0xb7>
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 <fat_set_fat_cluster>
if ( rc != RC_OK )
1100ba: 85 c0 test %eax,%eax
1100bc: 0f 85 77 01 00 00 jne 110239 <fat_scan_fat_for_free_clusters+0x1f9> <== NEVER TAKEN
if (zero_fill)
1100c2: 80 7d cb 00 cmpb $0x0,-0x35(%ebp)
1100c6: 0f 85 d4 00 00 00 jne 1101a0 <fat_scan_fat_for_free_clusters+0x160>
(*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 <fat_scan_fat_for_free_clusters+0xa2>
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 <fat_scan_fat_for_free_clusters+0x1a0>
1100ee: 39 45 10 cmp %eax,0x10(%ebp)
1100f1: 0f 84 e9 00 00 00 je 1101e0 <fat_scan_fat_for_free_clusters+0x1a0>
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 <fat_get_fat_cluster>
if ( rc != RC_OK )
110111: 85 c0 test %eax,%eax
110113: 0f 85 f7 00 00 00 jne 110210 <fat_scan_fat_for_free_clusters+0x1d0> <== 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 <fat_scan_fat_for_free_clusters+0x94>
if (*cls_added == 0)
110122: 85 c0 test %eax,%eax
110124: 0f 84 76 ff ff ff je 1100a0 <fat_scan_fat_for_free_clusters+0x60>
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 <fat_set_fat_cluster>
if ( rc != RC_OK )
11013f: 85 c0 test %eax,%eax
110141: 0f 85 f6 00 00 00 jne 11023d <fat_scan_fat_for_free_clusters+0x1fd> <== 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 <fat_set_fat_cluster>
if ( rc != RC_OK )
11015a: 85 c0 test %eax,%eax
11015c: 0f 84 60 ff ff ff je 1100c2 <fat_scan_fat_for_free_clusters+0x82> <== 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 <fat_free_fat_clusters_chain> <== 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 <fat_set_fat_cluster> <== NOT EXECUTED
fat_buf_release(fs_info);
11018a: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
11018d: e8 5e e7 ff ff call 10e8f0 <fat_buf_release> <== 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 <fat_cluster_set>
if (fs_info->vol.bpc != bytes_written)
1101bf: 39 46 08 cmp %eax,0x8(%esi)
1101c2: 0f 84 04 ff ff ff je 1100cc <fat_scan_fat_for_free_clusters+0x8c> <== ALWAYS TAKEN
rc = -1;
1101c8: ba ff ff ff ff mov $0xffffffff,%edx <== NOT EXECUTED
1101cd: eb 95 jmp 110164 <fat_scan_fat_for_free_clusters+0x124> <== 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 <fat_scan_fat_for_free_clusters+0x1ba> <== 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 <fat_buf_release>
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 <fat_scan_fat_for_free_clusters+0x1c4> <== 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 <fat_free_fat_clusters_chain> <== 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 <fat_scan_fat_for_free_clusters+0x1c4> <== NOT EXECUTED
fat_free_fat_clusters_chain(fs_info, (*chain));
11023d: 89 c2 mov %eax,%edx <== NOT EXECUTED
11023f: eb d7 jmp 110218 <fat_scan_fat_for_free_clusters+0x1d8> <== 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_sector_write>:
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 <fat_sector_write+0x4a> <== ALWAYS TAKEN
10eacd: e9 c5 00 00 00 jmp 10eb97 <fat_sector_write+0xe7> <== 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 <fat_sector_write+0xe7> <== 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 <fat_sector_write+0x57>
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 <fat_sector_write+0xd0> <== 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 <fat_buf_access>
10eb2e: 8b 55 08 mov 0x8(%ebp),%edx
if (rc != RC_OK)
10eb31: 85 c0 test %eax,%eax
10eb33: 75 5b jne 10eb90 <fat_sector_write+0xe0> <== 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 <fat_sector_write+0x30> <== ALWAYS TAKEN
10eb50: f7 c7 01 00 00 00 test $0x1,%edi <== NOT EXECUTED
10eb56: 75 78 jne 10ebd0 <fat_sector_write+0x120> <== NOT EXECUTED
10eb58: f7 c7 02 00 00 00 test $0x2,%edi <== NOT EXECUTED
10eb5e: 75 50 jne 10ebb0 <fat_sector_write+0x100> <== NOT EXECUTED
10eb60: f7 c7 04 00 00 00 test $0x4,%edi <== NOT EXECUTED
10eb66: 0f 84 74 ff ff ff je 10eae0 <fat_sector_write+0x30> <== 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 <fat_sector_write+0x30> <== 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 <fat_sector_write+0x6c> <== 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 <fat_sector_write+0xb0> <== 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 <fat_sector_write+0xa8> <== 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_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 <fat_set_fat_cluster+0x8e> <== 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 <fat_set_fat_cluster+0x8e> <== 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 <fat_set_fat_cluster+0xb0>
10fd44: 24 02 and $0x2,%al
10fd46: 8b 45 0c mov 0xc(%ebp),%eax
10fd49: 0f 84 91 00 00 00 je 10fde0 <fat_set_fat_cluster+0xd0>
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 <fat_buf_access>
if (rc != RC_OK)
10fd7d: 85 c0 test %eax,%eax
10fd7f: 75 2f jne 10fdb0 <fat_set_fat_cluster+0xa0> <== 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 <fat_set_fat_cluster+0xf0>
10fd8d: 80 fa 04 cmp $0x4,%dl
10fd90: 0f 84 ea 00 00 00 je 10fe80 <fat_set_fat_cluster+0x170>
10fd96: fe ca dec %dl
10fd98: 0f 84 82 00 00 00 je 10fe20 <fat_set_fat_cluster+0x110> <== 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 <fat_set_fat_cluster+0x4b>
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 <fat_set_fat_cluster+0x4b>
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 <fat_set_fat_cluster+0x1a0>
*(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 <fat_set_fat_cluster+0x1e0>
*(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 <fat_set_fat_cluster+0xa0>
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 <fat_set_fat_cluster+0x230> <== 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 <fat_set_fat_cluster+0xa0>
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 <fat_buf_access>
if (rc != RC_OK)
10ff10: 85 c0 test %eax,%eax
10ff12: 0f 85 98 fe ff ff jne 10fdb0 <fat_set_fat_cluster+0xa0> <== 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 <fat_set_fat_cluster+0xa0>
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 <fat_buf_access> <== NOT EXECUTED
if (rc != RC_OK)
10ff60: 85 c0 test %eax,%eax <== NOT EXECUTED
10ff62: 0f 85 48 fe ff ff jne 10fdb0 <fat_set_fat_cluster+0xa0> <== 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 <fat_set_fat_cluster+0x20e> <== NOT EXECUTED
0010f820 <fat_shutdown_drive>:
* 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 <fat_sync>
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 <fat_shutdown_drive+0x48>
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 <free> <== 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 <fat_shutdown_drive+0x30>
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 <fat_shutdown_drive+0x7a> <== 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 <free> <== 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 <fat_shutdown_drive+0x60> <== 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 <fat_shutdown_drive+0xab> <== 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 <free> <== 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 <fat_shutdown_drive+0x90> <== 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 <fat_shutdown_drive+0xea> <== 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 <free> <== 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 <fat_shutdown_drive+0xd0> <== 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>
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>
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>
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 <free>
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 <close>
if (rc)
10f94a: 8b 45 e4 mov -0x1c(%ebp),%eax
10f94d: 85 c0 test %eax,%eax
10f94f: 75 0f jne 10f960 <fat_shutdown_drive+0x140> <== 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 <fat_sync>:
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 <fat_sync+0x50>
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 <fat_sync+0x2a>
10f743: 89 f0 mov %esi,%eax
10f745: e8 46 ee ff ff call 10e590 <fat_buf_release.part.0>
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 <rtems_bdbuf_syncdev>
10f755: 85 c0 test %eax,%eax
10f757: 0f 85 b3 00 00 00 jne 10f810 <fat_sync+0xf0> <== 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 <fat_sync+0xa0> <== 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 <fat_sync+0x1a>
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 <fat_sector_write>
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 <fat_sync+0x1a>
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 <fat_sector_write> <== 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 <fat_sync+0x96> <== NOT EXECUTED
10f7ff: eb 84 jmp 10f785 <fat_sync+0x65> <== 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 <fat_sync+0x3d> <== NOT EXECUTED
10f81a: 90 nop
10f81b: 90 nop
10f81c: 90 nop
10f81d: 90 nop
10f81e: 90 nop
10f81f: 90 nop
00111380 <msdos_creat_node>:
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 <msdos_creat_node+0x65>
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 <msdos_creat_node+0x78>
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 <msdos_creat_node+0x4ce> <== 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 <msdos_long_to_short>
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 <msdos_creat_node+0x4f0> <== 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 <time>
static inline void fat_file_set_ctime_mtime(fat_file_fd_t *fat_fd, time_t t)
{
fat_fd->ctime = t;
fat_fd->mtime = t;
fat_fd->flags |= FAT_FILE_META_DATA_CHANGED;
11145f: 80 4b 30 02 orb $0x2,0x30(%ebx)
fat_fd->ctime = t;
111463: 89 43 40 mov %eax,0x40(%ebx)
111466: 89 c1 mov %eax,%ecx
fat_fd->mtime = t;
111468: 89 43 48 mov %eax,0x48(%ebx)
11146b: 89 85 3c ff ff ff mov %eax,-0xc4(%ebp)
fat_file_set_ctime_mtime(parent_fat_fd, now);
msdos_date_unix2dos(now, &date, &time_val);
111471: 8d 85 50 ff ff ff lea -0xb0(%ebp),%eax
fat_fd->ctime = t;
111477: 89 53 44 mov %edx,0x44(%ebx)
fat_fd->mtime = t;
11147a: 89 53 4c mov %edx,0x4c(%ebx)
11147d: 89 44 24 08 mov %eax,0x8(%esp)
111481: 8d 85 52 ff ff ff lea -0xae(%ebp),%eax
111487: 89 44 24 04 mov %eax,0x4(%esp)
11148b: 89 0c 24 mov %ecx,(%esp)
11148e: 89 95 40 ff ff ff mov %edx,-0xc0(%ebp)
111494: e8 27 76 00 00 call 118ac0 <msdos_date_unix2dos>
*MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
111499: 0f b7 85 52 ff ff ff movzwl -0xae(%ebp),%eax
*MSDOS_DIR_WRITE_TIME(short_node) = CT_LE_W(time_val);
*MSDOS_DIR_WRITE_DATE(short_node) = CT_LE_W(date);
*MSDOS_DIR_LAST_ACCESS_DATE(short_node) = CT_LE_W(date);
/* initialize directory/file size */
*MSDOS_DIR_FILE_SIZE(short_node) = MSDOS_INIT_DIR_SIZE;
1114a0: c7 45 84 00 00 00 00 movl $0x0,-0x7c(%ebp)
*MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);
1114a7: 0f b7 8d 50 ff ff ff movzwl -0xb0(%ebp),%ecx
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
1114ae: 66 89 85 78 ff ff ff mov %ax,-0x88(%ebp)
*MSDOS_DIR_WRITE_DATE(short_node) = CT_LE_W(date);
1114b5: 66 89 45 80 mov %ax,-0x80(%ebp)
*MSDOS_DIR_LAST_ACCESS_DATE(short_node) = CT_LE_W(date);
1114b9: 66 89 85 7a ff ff ff mov %ax,-0x86(%ebp)
if (type == FAT_DIRECTORY) {
1114c0: 8b 45 0c mov 0xc(%ebp),%eax
*MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);
1114c3: 66 89 8d 76 ff ff ff mov %cx,-0x8a(%ebp)
*MSDOS_DIR_WRITE_TIME(short_node) = CT_LE_W(time_val);
1114ca: 66 89 8d 7e ff ff ff mov %cx,-0x82(%ebp)
if (type == FAT_DIRECTORY) {
1114d1: 85 c0 test %eax,%eax
1114d3: 75 5b jne 111530 <msdos_creat_node+0x1b0>
/*
* find free space in the parent directory and write new initialized
* FAT 32 Bytes Directory Entry Structure to the disk
*/
rc = msdos_get_name_node(parent_loc, true, name, name_len,
1114d5: 89 7c 24 18 mov %edi,0x18(%esp)
1114d9: 8b 85 44 ff ff ff mov -0xbc(%ebp),%eax
1114df: 8d bd 58 ff ff ff lea -0xa8(%ebp),%edi
1114e5: 89 7c 24 14 mov %edi,0x14(%esp)
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_DIRECTORY;
1114e9: 80 8d 73 ff ff ff 10 orb $0x10,-0x8d(%ebp)
rc = msdos_get_name_node(parent_loc, true, name, name_len,
1114f0: 89 44 24 10 mov %eax,0x10(%esp)
1114f4: 8b 45 14 mov 0x14(%ebp),%eax
1114f7: 89 44 24 0c mov %eax,0xc(%esp)
1114fb: 8b 45 10 mov 0x10(%ebp),%eax
1114fe: 89 44 24 08 mov %eax,0x8(%esp)
111502: b8 01 00 00 00 mov $0x1,%eax
111507: 89 44 24 04 mov %eax,0x4(%esp)
11150b: 8b 45 08 mov 0x8(%ebp),%eax
11150e: 89 04 24 mov %eax,(%esp)
111511: e8 6a 24 00 00 call 113980 <msdos_get_name_node>
name_type, &dir_pos, short_node);
if ( rc != RC_OK )
111516: 85 c0 test %eax,%eax
rc = msdos_get_name_node(parent_loc, true, name, name_len,
111518: 89 c1 mov %eax,%ecx
if ( rc != RC_OK )
11151a: 74 74 je 111590 <msdos_creat_node+0x210> <== ALWAYS TAKEN
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
return rc;
}
11151c: 81 c4 dc 00 00 00 add $0xdc,%esp
111522: 89 c8 mov %ecx,%eax
111524: 5b pop %ebx
111525: 5e pop %esi
111526: 5f pop %edi
111527: 5d pop %ebp
111528: c3 ret
111529: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
else if (type == FAT_HARD_LINK) {
111530: 83 7d 0c 02 cmpl $0x2,0xc(%ebp)
111534: 0f 84 16 02 00 00 je 111750 <msdos_creat_node+0x3d0> <== NEVER TAKEN
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
11153a: 80 8d 73 ff ff ff 20 orb $0x20,-0x8d(%ebp)
rc = msdos_get_name_node(parent_loc, true, name, name_len,
111541: 8d 85 58 ff ff ff lea -0xa8(%ebp),%eax
111547: 89 44 24 14 mov %eax,0x14(%esp)
11154b: 8b 85 44 ff ff ff mov -0xbc(%ebp),%eax
111551: 89 7c 24 18 mov %edi,0x18(%esp)
111555: 89 44 24 10 mov %eax,0x10(%esp)
111559: 8b 45 14 mov 0x14(%ebp),%eax
11155c: 89 44 24 0c mov %eax,0xc(%esp)
111560: 8b 45 10 mov 0x10(%ebp),%eax
111563: 89 44 24 08 mov %eax,0x8(%esp)
111567: b8 01 00 00 00 mov $0x1,%eax
11156c: 89 44 24 04 mov %eax,0x4(%esp)
111570: 8b 45 08 mov 0x8(%ebp),%eax
111573: 89 04 24 mov %eax,(%esp)
111576: e8 05 24 00 00 call 113980 <msdos_get_name_node>
}
11157b: 81 c4 dc 00 00 00 add $0xdc,%esp
111581: 5b pop %ebx
111582: 5e pop %esi
rc = msdos_get_name_node(parent_loc, true, name, name_len,
111583: 89 c1 mov %eax,%ecx
}
111585: 5f pop %edi
111586: 89 c8 mov %ecx,%eax
111588: 5d pop %ebp
111589: c3 ret
11158a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
rc = fat_file_open(&fs_info->fat, &dir_pos, &fat_fd);
111590: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED
111594: 8b 95 40 ff ff ff mov -0xc0(%ebp),%edx <== NOT EXECUTED
11159a: 8d 85 54 ff ff ff lea -0xac(%ebp),%eax <== NOT EXECUTED
1115a0: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
1115a4: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
1115a7: 89 95 44 ff ff ff mov %edx,-0xbc(%ebp) <== NOT EXECUTED
1115ad: e8 5e ed ff ff call 110310 <fat_file_open> <== NOT EXECUTED
if (rc != RC_OK)
1115b2: 85 c0 test %eax,%eax
rc = fat_file_open(&fs_info->fat, &dir_pos, &fat_fd);
1115b4: 89 c1 mov %eax,%ecx
if (rc != RC_OK)
1115b6: 74 38 je 1115f0 <msdos_creat_node+0x270> <== ALWAYS TAKEN
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
1115b8: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED
1115bc: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
1115bf: ba e5 00 00 00 mov $0xe5,%edx <== NOT EXECUTED
1115c4: 89 54 24 08 mov %edx,0x8(%esp) <== NOT EXECUTED
1115c8: 89 8d 44 ff ff ff mov %ecx,-0xbc(%ebp) <== NOT EXECUTED
1115ce: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED
1115d1: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
1115d4: e8 47 0d 00 00 call 112320 <msdos_set_first_char4file_name> <== NOT EXECUTED
return rc;
1115d9: 8b 8d 44 ff ff ff mov -0xbc(%ebp),%ecx <== NOT EXECUTED
}
1115df: 81 c4 dc 00 00 00 add $0xdc,%esp <== NOT EXECUTED
1115e5: 5b pop %ebx <== NOT EXECUTED
1115e6: 5e pop %esi <== NOT EXECUTED
1115e7: 89 c8 mov %ecx,%eax <== NOT EXECUTED
1115e9: 5f pop %edi <== NOT EXECUTED
1115ea: 5d pop %ebp <== NOT EXECUTED
1115eb: c3 ret <== NOT EXECUTED
1115ec: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
fat_fd->fat_file_type = FAT_DIRECTORY;
1115f0: 8b 85 54 ff ff ff mov -0xac(%ebp),%eax
fat_fd->ctime = t;
1115f6: 8b 95 44 ff ff ff mov -0xbc(%ebp),%edx
1115fc: 8b 8d 3c ff ff ff mov -0xc4(%ebp),%ecx
fat_fd->flags |= FAT_FILE_META_DATA_CHANGED;
111602: 80 48 30 02 orb $0x2,0x30(%eax)
fat_fd->ctime = t;
111606: 89 50 44 mov %edx,0x44(%eax)
fat_fd->mtime = t;
111609: 89 50 4c mov %edx,0x4c(%eax)
rc = fat_file_extend(&fs_info->fat,
11160c: 8d 55 88 lea -0x78(%ebp),%edx
fat_fd->ctime = t;
11160f: 89 48 40 mov %ecx,0x40(%eax)
fat_fd->mtime = t;
111612: 89 48 48 mov %ecx,0x48(%eax)
fat_fd->fat_file_type = FAT_DIRECTORY;
111615: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax)
fat_fd->size_limit = MSDOS_MAX_DIR_LENGTH;
11161c: c7 40 14 00 00 20 00 movl $0x200000,0x14(%eax)
rc = fat_file_extend(&fs_info->fat,
111623: 89 54 24 10 mov %edx,0x10(%esp)
111627: 8b 56 08 mov 0x8(%esi),%edx
11162a: 89 44 24 04 mov %eax,0x4(%esp)
11162e: 89 34 24 mov %esi,(%esp)
111631: 89 54 24 0c mov %edx,0xc(%esp)
111635: ba 01 00 00 00 mov $0x1,%edx
11163a: 89 54 24 08 mov %edx,0x8(%esp)
11163e: e8 8d f4 ff ff call 110ad0 <fat_file_extend>
if (rc != RC_OK)
111643: 85 c0 test %eax,%eax
rc = fat_file_extend(&fs_info->fat,
111645: 89 c1 mov %eax,%ecx
if (rc != RC_OK)
111647: 0f 85 6b ff ff ff jne 1115b8 <msdos_creat_node+0x238> <== NEVER TAKEN
memcpy(DOT_NODE_P(dot_dotdot), short_node,
11164d: 31 c0 xor %eax,%eax
11164f: 8b 94 05 68 ff ff ff mov -0x98(%ebp,%eax,1),%edx
111656: 89 54 05 a8 mov %edx,-0x58(%ebp,%eax,1)
11165a: 83 c0 04 add $0x4,%eax
11165d: 83 f8 20 cmp $0x20,%eax
111660: 72 ed jb 11164f <msdos_creat_node+0x2cf>
memcpy(DOTDOT_NODE_P(dot_dotdot), short_node,
111662: 31 c0 xor %eax,%eax
111664: 8b 94 05 68 ff ff ff mov -0x98(%ebp,%eax,1),%edx
11166b: 89 54 05 c8 mov %edx,-0x38(%ebp,%eax,1)
11166f: 83 c0 04 add $0x4,%eax
111672: 83 f8 20 cmp $0x20,%eax
111675: 72 ed jb 111664 <msdos_creat_node+0x2e4>
memcpy(MSDOS_DIR_NAME(DOT_NODE_P(dot_dotdot)), MSDOS_DOT_NAME,
111677: a1 e0 37 13 00 mov 0x1337e0,%eax
11167c: 8b 10 mov (%eax),%edx
11167e: 89 55 a8 mov %edx,-0x58(%ebp)
111681: 8b 50 04 mov 0x4(%eax),%edx
111684: 89 55 ac mov %edx,-0x54(%ebp)
111687: 0f b7 50 08 movzwl 0x8(%eax),%edx
11168b: 66 89 55 b0 mov %dx,-0x50(%ebp)
11168f: 0f b6 40 0a movzbl 0xa(%eax),%eax
111693: 88 45 b2 mov %al,-0x4e(%ebp)
memcpy(MSDOS_DIR_NAME(DOTDOT_NODE_P(dot_dotdot)), MSDOS_DOTDOT_NAME,
111696: a1 dc 37 13 00 mov 0x1337dc,%eax
11169b: 8b 10 mov (%eax),%edx
11169d: 89 55 c8 mov %edx,-0x38(%ebp)
1116a0: 8b 50 04 mov 0x4(%eax),%edx
1116a3: 89 55 cc mov %edx,-0x34(%ebp)
1116a6: 0f b7 50 08 movzwl 0x8(%eax),%edx
1116aa: 66 89 55 d0 mov %dx,-0x30(%ebp)
1116ae: 0f b6 40 0a movzbl 0xa(%eax),%eax
1116b2: 88 45 d2 mov %al,-0x2e(%ebp)
if ((FAT_FD_OF_ROOT_DIR(parent_fat_fd)) &&
1116b5: 83 7b 20 01 cmpl $0x1,0x20(%ebx)
1116b9: 0f 84 69 01 00 00 je 111828 <msdos_creat_node+0x4a8>
CT_LE_W((uint16_t )((parent_fat_fd->cln) & 0x0000FFFF));
1116bf: 8b 43 1c mov 0x1c(%ebx),%eax
1116c2: 66 89 45 e2 mov %ax,-0x1e(%ebp)
CT_LE_W((uint16_t )(((parent_fat_fd->cln) & 0xFFFF0000)>>16));
1116c6: c1 e8 10 shr $0x10,%eax
1116c9: 66 89 45 dc mov %ax,-0x24(%ebp)
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
1116cd: 8b 95 54 ff ff ff mov -0xac(%ebp),%edx
ret = fat_file_write(&fs_info->fat, fat_fd, 0,
1116d3: b9 40 00 00 00 mov $0x40,%ecx
1116d8: 31 db xor %ebx,%ebx
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
1116da: 8b 42 1c mov 0x1c(%edx),%eax
ret = fat_file_write(&fs_info->fat, fat_fd, 0,
1116dd: 89 4c 24 0c mov %ecx,0xc(%esp)
1116e1: 89 5c 24 08 mov %ebx,0x8(%esp)
1116e5: 89 54 24 04 mov %edx,0x4(%esp)
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
1116e9: 66 89 45 c2 mov %ax,-0x3e(%ebp)
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
1116ed: c1 e8 10 shr $0x10,%eax
1116f0: 66 89 45 bc mov %ax,-0x44(%ebp)
ret = fat_file_write(&fs_info->fat, fat_fd, 0,
1116f4: 8d 45 a8 lea -0x58(%ebp),%eax
1116f7: 89 44 24 10 mov %eax,0x10(%esp)
1116fb: 89 34 24 mov %esi,(%esp)
1116fe: e8 8d f6 ff ff call 110d90 <fat_file_write>
if (ret < 0)
111703: 85 c0 test %eax,%eax
111705: 0f 88 e5 00 00 00 js 1117f0 <msdos_creat_node+0x470> <== NEVER TAKEN
rc = fat_file_write_first_cluster_num(&fs_info->fat, fat_fd);
11170b: 89 34 24 mov %esi,(%esp)
11170e: 8b 85 54 ff ff ff mov -0xac(%ebp),%eax
111714: 89 44 24 04 mov %eax,0x4(%esp)
111718: e8 93 0a 00 00 call 1121b0 <fat_file_write_first_cluster_num>
if (rc != RC_OK)
11171d: 85 c0 test %eax,%eax
rc = fat_file_write_first_cluster_num(&fs_info->fat, fat_fd);
11171f: 89 c1 mov %eax,%ecx
if (rc != RC_OK)
111721: 0f 85 ce 00 00 00 jne 1117f5 <msdos_creat_node+0x475> <== NEVER TAKEN
111727: 89 85 44 ff ff ff mov %eax,-0xbc(%ebp)
fat_file_close(&fs_info->fat, fat_fd);
11172d: 8b 85 54 ff ff ff mov -0xac(%ebp),%eax
111733: 89 34 24 mov %esi,(%esp)
111736: 89 44 24 04 mov %eax,0x4(%esp)
11173a: e8 11 f2 ff ff call 110950 <fat_file_close>
11173f: 8b 8d 44 ff ff ff mov -0xbc(%ebp),%ecx
111745: e9 d2 fd ff ff jmp 11151c <msdos_creat_node+0x19c>
11174a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
sec = fat_cluster_num_to_sector_num(&fs_info->fat,
111750: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED
111753: 8b 40 20 mov 0x20(%eax),%eax <== NOT EXECUTED
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
111756: 85 c0 test %eax,%eax <== NOT EXECUTED
111758: 75 0a jne 111764 <msdos_creat_node+0x3e4> <== NOT EXECUTED
11175a: f6 46 16 03 testb $0x3,0x16(%esi) <== NOT EXECUTED
11175e: 0f 85 bc 00 00 00 jne 111820 <msdos_creat_node+0x4a0> <== NOT EXECUTED
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
111764: 0f b6 4e 05 movzbl 0x5(%esi),%ecx <== NOT EXECUTED
111768: 83 e8 02 sub $0x2,%eax <== NOT EXECUTED
11176b: 8b 5e 3c mov 0x3c(%esi),%ebx <== NOT EXECUTED
11176e: d3 e0 shl %cl,%eax <== NOT EXECUTED
111770: 01 d8 add %ebx,%eax <== NOT EXECUTED
sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
111772: 8b 5d 1c mov 0x1c(%ebp),%ebx <== NOT EXECUTED
ret = _fat_block_read(&fs_info->fat,
111775: 8d 4d 88 lea -0x78(%ebp),%ecx <== NOT EXECUTED
sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
111778: 8b 53 24 mov 0x24(%ebx),%edx <== NOT EXECUTED
ret = _fat_block_read(&fs_info->fat,
11177b: 89 4c 24 10 mov %ecx,0x10(%esp) <== NOT EXECUTED
11177f: b9 20 00 00 00 mov $0x20,%ecx <== NOT EXECUTED
111784: 89 4c 24 0c mov %ecx,0xc(%esp) <== NOT EXECUTED
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
111788: 0f b7 0e movzwl (%esi),%ecx <== NOT EXECUTED
11178b: 49 dec %ecx <== NOT EXECUTED
11178c: 21 d1 and %edx,%ecx <== NOT EXECUTED
ret = _fat_block_read(&fs_info->fat,
11178e: 89 4c 24 08 mov %ecx,0x8(%esp) <== NOT EXECUTED
sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
111792: 0f b6 4e 02 movzbl 0x2(%esi),%ecx <== NOT EXECUTED
ret = _fat_block_read(&fs_info->fat,
111796: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
111799: d3 ea shr %cl,%edx <== NOT EXECUTED
11179b: 01 d0 add %edx,%eax <== NOT EXECUTED
ret = _fat_block_read(&fs_info->fat,
11179d: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1117a1: e8 7a d1 ff ff call 10e920 <_fat_block_read> <== NOT EXECUTED
if (ret < 0) {
1117a6: 85 c0 test %eax,%eax <== NOT EXECUTED
1117a8: 0f 88 d7 00 00 00 js 111885 <msdos_creat_node+0x505> <== NOT EXECUTED
*MSDOS_DIR_CRT_TIME_TENTH(short_node)=*MSDOS_DIR_CRT_TIME_TENTH(link_node);
1117ae: 8b 45 95 mov -0x6b(%ebp),%eax <== NOT EXECUTED
1117b1: 89 85 75 ff ff ff mov %eax,-0x8b(%ebp) <== NOT EXECUTED
*MSDOS_DIR_CRT_DATE(short_node) =*MSDOS_DIR_CRT_DATE(link_node);
1117b7: 0f b6 45 99 movzbl -0x67(%ebp),%eax <== NOT EXECUTED
1117bb: 88 85 79 ff ff ff mov %al,-0x87(%ebp) <== NOT EXECUTED
*MSDOS_DIR_FILE_SIZE(short_node) =*MSDOS_DIR_FILE_SIZE(link_node);
1117c1: 8b 45 a4 mov -0x5c(%ebp),%eax <== NOT EXECUTED
1117c4: 89 45 84 mov %eax,-0x7c(%ebp) <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_LOW(short_node) =
1117c7: 0f b7 45 a2 movzwl -0x5e(%ebp),%eax <== NOT EXECUTED
1117cb: 66 89 45 82 mov %ax,-0x7e(%ebp) <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_HI(short_node) =
1117cf: 8b 45 9c mov -0x64(%ebp),%eax <== NOT EXECUTED
1117d2: 66 89 85 7c ff ff ff mov %ax,-0x84(%ebp) <== NOT EXECUTED
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
1117d9: 0f b6 45 93 movzbl -0x6d(%ebp),%eax <== NOT EXECUTED
1117dd: 0c 20 or $0x20,%al <== NOT EXECUTED
1117df: 88 85 73 ff ff ff mov %al,-0x8d(%ebp) <== NOT EXECUTED
1117e5: e9 57 fd ff ff jmp 111541 <msdos_creat_node+0x1c1> <== NOT EXECUTED
1117ea: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
rc = -1;
1117f0: b9 ff ff ff ff mov $0xffffffff,%ecx <== NOT EXECUTED
fat_file_close(&fs_info->fat, fat_fd);
1117f5: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
1117f8: 8b 85 54 ff ff ff mov -0xac(%ebp),%eax <== NOT EXECUTED
1117fe: 89 8d 44 ff ff ff mov %ecx,-0xbc(%ebp) <== NOT EXECUTED
111804: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
111808: e8 43 f1 ff ff call 110950 <fat_file_close> <== NOT EXECUTED
11180d: 8b 8d 44 ff ff ff mov -0xbc(%ebp),%ecx <== NOT EXECUTED
111813: e9 a0 fd ff ff jmp 1115b8 <msdos_creat_node+0x238> <== NOT EXECUTED
111818: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11181f: 90 nop <== NOT EXECUTED
return fs_info->vol.rdir_loc;
111820: 8b 46 28 mov 0x28(%esi),%eax <== NOT EXECUTED
111823: e9 4a ff ff ff jmp 111772 <msdos_creat_node+0x3f2> <== NOT EXECUTED
if ((FAT_FD_OF_ROOT_DIR(parent_fat_fd)) &&
111828: 8b 43 24 mov 0x24(%ebx),%eax
11182b: 85 c0 test %eax,%eax
11182d: 0f 85 8c fe ff ff jne 1116bf <msdos_creat_node+0x33f> <== NEVER TAKEN
111833: f6 46 16 04 testb $0x4,0x16(%esi)
111837: 0f 84 82 fe ff ff je 1116bf <msdos_creat_node+0x33f> <== ALWAYS TAKEN
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
11183d: 66 c7 45 e2 00 00 movw $0x0,-0x1e(%ebp) <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
111843: 66 c7 45 dc 00 00 movw $0x0,-0x24(%ebp) <== NOT EXECUTED
111849: e9 7f fe ff ff jmp 1116cd <msdos_creat_node+0x34d> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENAMETOOLONG);
11184e: e8 4d 50 01 00 call 1268a0 <__errno> <== NOT EXECUTED
111853: b9 ff ff ff ff mov $0xffffffff,%ecx <== NOT EXECUTED
111858: c7 00 5b 00 00 00 movl $0x5b,(%eax) <== NOT EXECUTED
11185e: e9 b9 fc ff ff jmp 11151c <msdos_creat_node+0x19c> <== NOT EXECUTED
111863: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11186a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EINVAL);
111870: e8 2b 50 01 00 call 1268a0 <__errno> <== NOT EXECUTED
111875: b9 ff ff ff ff mov $0xffffffff,%ecx <== NOT EXECUTED
11187a: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
111880: e9 97 fc ff ff jmp 11151c <msdos_creat_node+0x19c> <== NOT EXECUTED
return -1;
111885: b9 ff ff ff ff mov $0xffffffff,%ecx <== NOT EXECUTED
11188a: e9 8d fc ff ff jmp 11151c <msdos_creat_node+0x19c> <== NOT EXECUTED
11188f: 90 nop
00118c20 <msdos_date_dos2unix>:
* called from the stat(), and fstat() system calls and so probably need
* not be too efficient.
*/
unsigned int
msdos_date_dos2unix(unsigned int dd, unsigned int dt)
{
118c20: 55 push %ebp
118c21: 89 e5 mov %esp,%ebp
118c23: 57 push %edi
118c24: 56 push %esi
118c25: 53 push %ebx
118c26: 83 ec 04 sub $0x4,%esp
118c29: 8b 45 0c mov 0xc(%ebp),%eax
118c2c: 8b 75 08 mov 0x8(%ebp),%esi
uint32_t days;
uint16_t *months;
seconds = 2 * ((dt & MSDOS_DT_2SECONDS_MASK) >> MSDOS_DT_2SECONDS_SHIFT)
+ ((dt & MSDOS_DT_MINUTES_MASK) >> MSDOS_DT_MINUTES_SHIFT) * 60
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
118c2f: 89 c2 mov %eax,%edx
+ ((dt & MSDOS_DT_MINUTES_MASK) >> MSDOS_DT_MINUTES_SHIFT) * 60
118c31: 89 c1 mov %eax,%ecx
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
118c33: c1 ea 0b shr $0xb,%edx
seconds = 2 * ((dt & MSDOS_DT_2SECONDS_MASK) >> MSDOS_DT_2SECONDS_SHIFT)
118c36: 83 e0 1f and $0x1f,%eax
+ ((dt & MSDOS_DT_MINUTES_MASK) >> MSDOS_DT_MINUTES_SHIFT) * 60
118c39: c1 e9 05 shr $0x5,%ecx
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
118c3c: 83 e2 1f and $0x1f,%edx
118c3f: 69 d2 08 07 00 00 imul $0x708,%edx,%edx
+ ((dt & MSDOS_DT_MINUTES_MASK) >> MSDOS_DT_MINUTES_SHIFT) * 60
118c45: 83 e1 3f and $0x3f,%ecx
118c48: 89 cb mov %ecx,%ebx
118c4a: c1 e3 04 shl $0x4,%ebx
118c4d: 29 cb sub %ecx,%ebx
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
118c4f: 8d 14 5a lea (%edx,%ebx,2),%edx
118c52: 01 d0 add %edx,%eax
seconds = 2 * ((dt & MSDOS_DT_2SECONDS_MASK) >> MSDOS_DT_2SECONDS_SHIFT)
118c54: 01 c0 add %eax,%eax
118c56: 89 45 f0 mov %eax,-0x10(%ebp)
/*
* If the year, month, and day from the last conversion are the
* same then use the saved value.
*/
if (lastdosdate != dd) {
118c59: 0f b7 05 1c c2 13 00 movzwl 0x13c21c,%eax
118c60: 39 f0 cmp %esi,%eax
118c62: 0f 84 c8 00 00 00 je 118d30 <msdos_date_dos2unix+0x110>
lastdosdate = dd;
118c68: 66 89 35 1c c2 13 00 mov %si,0x13c21c
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
118c6f: 89 f7 mov %esi,%edi
days = 0;
118c71: 31 d2 xor %edx,%edx
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
118c73: c1 ef 09 shr $0x9,%edi
for (y = 0; y < year; y++)
118c76: 89 fb mov %edi,%ebx
118c78: 83 e3 7f and $0x7f,%ebx
118c7b: 74 2a je 118ca7 <msdos_date_dos2unix+0x87> <== NEVER TAKEN
118c7d: 31 c9 xor %ecx,%ecx
days += y & 0x03 ? 365 : 366;
118c7f: b8 6e 01 00 00 mov $0x16e,%eax
118c84: eb 1a jmp 118ca0 <msdos_date_dos2unix+0x80>
118c86: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
118c8d: 8d 76 00 lea 0x0(%esi),%esi
118c90: 89 c8 mov %ecx,%eax
118c92: 83 e0 03 and $0x3,%eax
118c95: 83 f8 01 cmp $0x1,%eax
118c98: b8 6d 01 00 00 mov $0x16d,%eax
118c9d: 83 d0 00 adc $0x0,%eax
for (y = 0; y < year; y++)
118ca0: 41 inc %ecx
days += y & 0x03 ? 365 : 366;
118ca1: 01 c2 add %eax,%edx
for (y = 0; y < year; y++)
118ca3: 39 cb cmp %ecx,%ebx
118ca5: 75 e9 jne 118c90 <msdos_date_dos2unix+0x70>
months = year & 0x03 ? regyear : leapyear;
118ca7: 83 e7 03 and $0x3,%edi
118caa: b8 4c 84 13 00 mov $0x13844c,%eax
118caf: 74 5f je 118d10 <msdos_date_dos2unix+0xf0>
/*
* Prevent going from 0 to 0xffffffff in the following
* loop.
*/
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
118cb1: 89 f3 mov %esi,%ebx
118cb3: c1 eb 05 shr $0x5,%ebx
if (month == 0) {
118cb6: 89 d9 mov %ebx,%ecx
118cb8: 83 e1 0f and $0xf,%ecx
118cbb: 74 43 je 118d00 <msdos_date_dos2unix+0xe0> <== NEVER TAKEN
month = 1;
}
for (m = 0; m < month - 1; m++)
118cbd: f6 c3 0e test $0xe,%bl
118cc0: 74 1a je 118cdc <msdos_date_dos2unix+0xbc>
118cc2: 8d 5c 48 fe lea -0x2(%eax,%ecx,2),%ebx
118cc6: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
118ccd: 8d 76 00 lea 0x0(%esi),%esi
days += months[m];
118cd0: 0f b7 08 movzwl (%eax),%ecx
for (m = 0; m < month - 1; m++)
118cd3: 83 c0 02 add $0x2,%eax
days += months[m];
118cd6: 01 ca add %ecx,%edx
for (m = 0; m < month - 1; m++)
118cd8: 39 c3 cmp %eax,%ebx
118cda: 75 f4 jne 118cd0 <msdos_date_dos2unix+0xb0> <== NEVER TAKEN
days += ((dd & MSDOS_DD_DAY_MASK) >> MSDOS_DD_DAY_SHIFT) - 1;
118cdc: 83 e6 1f and $0x1f,%esi
118cdf: 8d 44 32 ff lea -0x1(%edx,%esi,1),%eax
lastseconds = (days + DAYSTO1980) * SECONDSPERDAY;
}
return seconds + lastseconds;
118ce3: 8b 55 f0 mov -0x10(%ebp),%edx
lastseconds = (days + DAYSTO1980) * SECONDSPERDAY;
118ce6: 69 c0 80 51 01 00 imul $0x15180,%eax,%eax
118cec: 05 00 a6 ce 12 add $0x12cea600,%eax
118cf1: a3 18 c2 13 00 mov %eax,0x13c218
return seconds + lastseconds;
118cf6: 01 d0 add %edx,%eax
}
118cf8: 59 pop %ecx
118cf9: 5b pop %ebx
118cfa: 5e pop %esi
118cfb: 5f pop %edi
118cfc: 5d pop %ebp
118cfd: c3 ret
118cfe: 66 90 xchg %ax,%ax
118d00: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED
118d05: eb b6 jmp 118cbd <msdos_date_dos2unix+0x9d> <== NOT EXECUTED
118d07: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
118d0e: 66 90 xchg %ax,%ax <== NOT EXECUTED
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
118d10: 89 f3 mov %esi,%ebx
months = year & 0x03 ? regyear : leapyear;
118d12: b8 34 84 13 00 mov $0x138434,%eax
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
118d17: c1 eb 05 shr $0x5,%ebx
if (month == 0) {
118d1a: 89 d9 mov %ebx,%ecx
118d1c: 83 e1 0f and $0xf,%ecx
118d1f: 75 9c jne 118cbd <msdos_date_dos2unix+0x9d> <== ALWAYS TAKEN
118d21: eb dd jmp 118d00 <msdos_date_dos2unix+0xe0> <== NOT EXECUTED
118d23: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
118d2a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
return seconds + lastseconds;
118d30: 8b 55 f0 mov -0x10(%ebp),%edx
118d33: a1 18 c2 13 00 mov 0x13c218,%eax
}
118d38: 59 pop %ecx
118d39: 5b pop %ebx
return seconds + lastseconds;
118d3a: 01 d0 add %edx,%eax
}
118d3c: 5e pop %esi
118d3d: 5f pop %edi
118d3e: 5d pop %ebp
118d3f: c3 ret
00118ac0 <msdos_date_unix2dos>:
* file timestamps. The passed in unix time is assumed to be in GMT.
*/
void
msdos_date_unix2dos(unsigned int t, uint16_t *ddp,
uint16_t *dtp)
{
118ac0: 55 push %ebp
118ac1: 89 e5 mov %esp,%ebp
118ac3: 57 push %edi
118ac4: 56 push %esi
118ac5: 53 push %ebx
118ac6: 8b 5d 08 mov 0x8(%ebp),%ebx
/*
* If the time from the last conversion is the same as now, then
* skip the computations and use the saved result.
*/
if (lasttime != t) {
118ac9: 39 1d 28 c2 13 00 cmp %ebx,0x13c228
118acf: 0f 84 2b 01 00 00 je 118c00 <msdos_date_unix2dos+0x140>
lasttime = t;
118ad5: 89 1d 28 c2 13 00 mov %ebx,0x13c228
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
118adb: b9 89 88 88 88 mov $0x88888889,%ecx
118ae0: 89 d8 mov %ebx,%eax
118ae2: f7 e1 mul %ecx
118ae4: 89 d6 mov %edx,%esi
118ae6: c1 ee 05 shr $0x5,%esi
118ae9: 89 f0 mov %esi,%eax
118aeb: 89 f7 mov %esi,%edi
118aed: f7 e1 mul %ecx
118aef: c1 ea 05 shr $0x5,%edx
118af2: 89 d0 mov %edx,%eax
118af4: c1 e0 04 shl $0x4,%eax
118af7: 29 d0 sub %edx,%eax
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
118af9: ba c5 b3 a2 91 mov $0x91a2b3c5,%edx
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
118afe: c1 e0 02 shl $0x2,%eax
118b01: 29 c7 sub %eax,%edi
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
118b03: 89 d8 mov %ebx,%eax
118b05: f7 e2 mul %edx
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
118b07: c1 e7 05 shl $0x5,%edi
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
118b0a: 89 d1 mov %edx,%ecx
118b0c: ba ab aa aa aa mov $0xaaaaaaab,%edx
118b11: c1 e9 0b shr $0xb,%ecx
118b14: 89 c8 mov %ecx,%eax
118b16: f7 e2 mul %edx
118b18: c1 ea 04 shr $0x4,%edx
118b1b: 8d 04 52 lea (%edx,%edx,2),%eax
/*
* If the number of days since 1970 is the same as the last
* time we did the computation then skip all this leap year
* and month stuff.
*/
days = t / (SECONDSPERDAY);
118b1e: ba 07 45 2e c2 mov $0xc22e4507,%edx
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
118b23: c1 e0 03 shl $0x3,%eax
118b26: 29 c1 sub %eax,%ecx
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
118b28: 89 f0 mov %esi,%eax
118b2a: c1 e0 04 shl $0x4,%eax
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
118b2d: c1 e1 0b shl $0xb,%ecx
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
118b30: 29 f0 sub %esi,%eax
118b32: c1 e0 02 shl $0x2,%eax
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
118b35: 01 cf add %ecx,%edi
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
118b37: 89 d9 mov %ebx,%ecx
118b39: 29 c1 sub %eax,%ecx
days = t / (SECONDSPERDAY);
118b3b: 89 d8 mov %ebx,%eax
118b3d: f7 e2 mul %edx
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
118b3f: d1 e9 shr %ecx
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
118b41: 01 f9 add %edi,%ecx
118b43: 0f b7 c9 movzwl %cx,%ecx
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
118b46: 66 89 0d 1e c2 13 00 mov %cx,0x13c21e
days = t / (SECONDSPERDAY);
118b4d: c1 ea 10 shr $0x10,%edx
if (days != lastday) {
118b50: 39 15 24 c2 13 00 cmp %edx,0x13c224
118b56: 0f 84 84 00 00 00 je 118be0 <msdos_date_unix2dos+0x120>
lastday = days;
118b5c: 89 15 24 c2 13 00 mov %edx,0x13c224
for (year = 1970;; year++) {
118b62: bb b2 07 00 00 mov $0x7b2,%ebx
118b67: eb 0a jmp 118b73 <msdos_date_unix2dos+0xb3>
118b69: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
inc = year & 0x03 ? 365 : 366;
if (days < inc)
break;
days -= inc;
118b70: 29 c2 sub %eax,%edx
for (year = 1970;; year++) {
118b72: 43 inc %ebx
inc = year & 0x03 ? 365 : 366;
118b73: 89 de mov %ebx,%esi
118b75: 31 c0 xor %eax,%eax
118b77: 83 e6 03 and $0x3,%esi
118b7a: 0f 94 c0 sete %al
118b7d: 05 6d 01 00 00 add $0x16d,%eax
if (days < inc)
118b82: 39 c2 cmp %eax,%edx
118b84: 73 ea jae 118b70 <msdos_date_unix2dos+0xb0>
}
months = year & 0x03 ? regyear : leapyear;
118b86: 85 f6 test %esi,%esi
118b88: bf 4c 84 13 00 mov $0x13844c,%edi
118b8d: 75 05 jne 118b94 <msdos_date_unix2dos+0xd4> <== NEVER TAKEN
118b8f: bf 34 84 13 00 mov $0x138434,%edi
for (month = 0; month < 12; month++) {
118b94: 31 c0 xor %eax,%eax
118b96: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
118b9d: 8d 76 00 lea 0x0(%esi),%esi
if (days < months[month])
118ba0: 0f b7 34 47 movzwl (%edi,%eax,2),%esi
118ba4: 39 d6 cmp %edx,%esi
118ba6: 77 68 ja 118c10 <msdos_date_unix2dos+0x150> <== ALWAYS TAKEN
for (month = 0; month < 12; month++) {
118ba8: 40 inc %eax <== NOT EXECUTED
break;
days -= months[month];
118ba9: 29 f2 sub %esi,%edx <== NOT EXECUTED
for (month = 0; month < 12; month++) {
118bab: 83 f8 0c cmp $0xc,%eax <== NOT EXECUTED
118bae: 75 f0 jne 118ba0 <msdos_date_unix2dos+0xe0> <== NOT EXECUTED
118bb0: b8 a0 01 00 00 mov $0x1a0,%eax <== NOT EXECUTED
}
lastddate = ((days + 1) << MSDOS_DD_DAY_SHIFT)
+ ((month + 1) << MSDOS_DD_MONTH_SHIFT);
118bb5: 8d 44 02 01 lea 0x1(%edx,%eax,1),%eax
* Remember dos's idea of time is relative to 1980.
* unix's is relative to 1970. If somehow we get a
* time before 1980 then don't give totally crazy
* results.
*/
if (year > 1980)
118bb9: 81 fb bc 07 00 00 cmp $0x7bc,%ebx
+ ((month + 1) << MSDOS_DD_MONTH_SHIFT);
118bbf: 0f b7 c0 movzwl %ax,%eax
if (year > 1980)
118bc2: 76 0e jbe 118bd2 <msdos_date_unix2dos+0x112> <== NEVER TAKEN
lastddate += (year - 1980) <<
118bc4: 81 eb bc 07 00 00 sub $0x7bc,%ebx
118bca: c1 e3 09 shl $0x9,%ebx
118bcd: 01 d8 add %ebx,%eax
118bcf: 0f b7 c0 movzwl %ax,%eax
118bd2: 66 a3 20 c2 13 00 mov %ax,0x13c220
118bd8: eb 0d jmp 118be7 <msdos_date_unix2dos+0x127>
118bda: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
MSDOS_DD_YEAR_SHIFT;
}
}
*dtp = lastdtime;
*ddp = lastddate;
118be0: 0f b7 05 20 c2 13 00 movzwl 0x13c220,%eax <== NOT EXECUTED
*dtp = lastdtime;
118be7: 8b 55 10 mov 0x10(%ebp),%edx
118bea: 66 89 0a mov %cx,(%edx)
*ddp = lastddate;
118bed: 8b 55 0c mov 0xc(%ebp),%edx
118bf0: 66 89 02 mov %ax,(%edx)
}
118bf3: 5b pop %ebx
118bf4: 5e pop %esi
118bf5: 5f pop %edi
118bf6: 5d pop %ebp
118bf7: c3 ret
118bf8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
118bff: 90 nop
*dtp = lastdtime;
118c00: 0f b7 0d 1e c2 13 00 movzwl 0x13c21e,%ecx
*ddp = lastddate;
118c07: 0f b7 05 20 c2 13 00 movzwl 0x13c220,%eax
118c0e: eb d7 jmp 118be7 <msdos_date_unix2dos+0x127>
+ ((month + 1) << MSDOS_DD_MONTH_SHIFT);
118c10: 40 inc %eax
118c11: c1 e0 05 shl $0x5,%eax
118c14: 0f b7 c0 movzwl %ax,%eax
118c17: eb 9c jmp 118bb5 <msdos_date_unix2dos+0xf5>
118c19: 90 nop
118c1a: 90 nop
118c1b: 90 nop
118c1c: 90 nop
118c1d: 90 nop
118c1e: 90 nop
118c1f: 90 nop
00112460 <msdos_dir_is_empty>:
{
112460: 55 push %ebp <== NOT EXECUTED
112461: 89 e5 mov %esp,%ebp <== NOT EXECUTED
112463: 57 push %edi <== NOT EXECUTED
112464: 56 push %esi <== NOT EXECUTED
112465: 53 push %ebx <== NOT EXECUTED
112466: 83 ec 3c sub $0x3c,%esp <== NOT EXECUTED
uint32_t j = 0, i = 0;
112469: c7 45 d8 00 00 00 00 movl $0x0,-0x28(%ebp) <== NOT EXECUTED
msdos_fs_info_t *fs_info = mt_entry->fs_info;
112470: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
*ret_val = false;
112473: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED
msdos_fs_info_t *fs_info = mt_entry->fs_info;
112476: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED
*ret_val = false;
112479: c6 07 00 movb $0x0,(%edi) <== NOT EXECUTED
msdos_fs_info_t *fs_info = mt_entry->fs_info;
11247c: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED
fs_info->fat.vol.bps,
11247f: 0f b7 18 movzwl (%eax),%ebx <== NOT EXECUTED
while ((ret = fat_file_read(&fs_info->fat, fat_fd, j * fs_info->fat.vol.bps,
112482: 8b 80 c4 00 00 00 mov 0xc4(%eax),%eax <== NOT EXECUTED
112488: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED
11248b: 89 5c 24 0c mov %ebx,0xc(%esp)
11248f: 8b 45 dc mov -0x24(%ebp),%eax
112492: 89 44 24 10 mov %eax,0x10(%esp)
112496: 8b 45 d8 mov -0x28(%ebp),%eax
112499: 0f af d8 imul %eax,%ebx
11249c: 8b 45 0c mov 0xc(%ebp),%eax
11249f: 89 44 24 04 mov %eax,0x4(%esp)
1124a3: 8b 45 e4 mov -0x1c(%ebp),%eax
1124a6: 89 5c 24 08 mov %ebx,0x8(%esp)
1124aa: 89 04 24 mov %eax,(%esp)
1124ad: e8 ae e1 ff ff call 110660 <fat_file_read>
1124b2: 85 c0 test %eax,%eax
1124b4: 0f 84 a6 00 00 00 je 112560 <msdos_dir_is_empty+0x100> <== NEVER TAKEN
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
1124ba: 83 f8 1f cmp $0x1f,%eax
1124bd: 0f 8e ad 00 00 00 jle 112570 <msdos_dir_is_empty+0x110> <== NEVER TAKEN
assert(ret == fs_info->fat.vol.bps);
1124c3: 8b 7d e4 mov -0x1c(%ebp),%edi
1124c6: 0f b7 1f movzwl (%edi),%ebx
1124c9: 39 c3 cmp %eax,%ebx
1124cb: 0f 85 a6 00 00 00 jne 112577 <msdos_dir_is_empty+0x117> <== NEVER TAKEN
char* entry = (char*) fs_info->cl_buf + i;
1124d1: 8b 45 e4 mov -0x1c(%ebp),%eax
for (i = 0;
1124d4: 31 d2 xor %edx,%edx
1124d6: 85 db test %ebx,%ebx
char* entry = (char*) fs_info->cl_buf + i;
1124d8: 8b 80 c4 00 00 00 mov 0xc4(%eax),%eax
1124de: 89 45 dc mov %eax,-0x24(%ebp)
for (i = 0;
1124e1: 74 6b je 11254e <msdos_dir_is_empty+0xee> <== NEVER TAKEN
1124e3: 89 5d e0 mov %ebx,-0x20(%ebp)
1124e6: 89 d3 mov %edx,%ebx
if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
1124e8: 0f b6 10 movzbl (%eax),%edx
1124eb: 80 fa e5 cmp $0xe5,%dl
1124ee: 74 50 je 112540 <msdos_dir_is_empty+0xe0>
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
1124f0: 0f b6 48 0b movzbl 0xb(%eax),%ecx
1124f4: 80 e1 3f and $0x3f,%cl
1124f7: 80 f9 0f cmp $0xf,%cl
1124fa: 74 44 je 112540 <msdos_dir_is_empty+0xe0>
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
1124fc: b9 0b 00 00 00 mov $0xb,%ecx
112501: bf b5 36 13 00 mov $0x1336b5,%edi
112506: 89 c6 mov %eax,%esi
112508: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi)
11250a: 0f 97 c1 seta %cl
11250d: 80 d9 00 sbb $0x0,%cl
MSDOS_ATTR_LFN) ||
112510: 84 c9 test %cl,%cl
112512: 74 2c je 112540 <msdos_dir_is_empty+0xe0>
(strncmp(MSDOS_DIR_NAME((entry)),
112514: b9 0b 00 00 00 mov $0xb,%ecx
112519: bf c1 36 13 00 mov $0x1336c1,%edi
11251e: 89 c6 mov %eax,%esi
112520: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi)
112522: 0f 97 c1 seta %cl
112525: 80 d9 00 sbb $0x0,%cl
MSDOS_SHORT_NAME_LEN) == 0) ||
112528: 84 c9 test %cl,%cl
11252a: 74 14 je 112540 <msdos_dir_is_empty+0xe0>
return RC_OK;
11252c: 31 c0 xor %eax,%eax
if ((*MSDOS_DIR_NAME(entry)) ==
11252e: 84 d2 test %dl,%dl
112530: 74 2e je 112560 <msdos_dir_is_empty+0x100>
}
112532: 83 c4 3c add $0x3c,%esp
112535: 5b pop %ebx
112536: 5e pop %esi
112537: 5f pop %edi
112538: 5d pop %ebp
112539: c3 ret
11253a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
112540: 83 c3 20 add $0x20,%ebx
for (i = 0;
112543: 83 c0 20 add $0x20,%eax
112546: 3b 5d e0 cmp -0x20(%ebp),%ebx
112549: 72 9d jb 1124e8 <msdos_dir_is_empty+0x88>
11254b: 8b 5d e0 mov -0x20(%ebp),%ebx
j++;
11254e: ff 45 d8 incl -0x28(%ebp)
112551: e9 35 ff ff ff jmp 11248b <msdos_dir_is_empty+0x2b>
112556: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11255d: 8d 76 00 lea 0x0(%esi),%esi
*ret_val = true;
112560: 8b 45 10 mov 0x10(%ebp),%eax
112563: c6 00 01 movb $0x1,(%eax)
}
112566: 83 c4 3c add $0x3c,%esp
return RC_OK;
112569: 31 c0 xor %eax,%eax
}
11256b: 5b pop %ebx
11256c: 5e pop %esi
11256d: 5f pop %edi
11256e: 5d pop %ebp
11256f: c3 ret
return -1;
112570: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
112575: eb bb jmp 112532 <msdos_dir_is_empty+0xd2> <== NOT EXECUTED
assert(ret == fs_info->fat.vol.bps);
112577: c7 44 24 0c 99 36 13 movl $0x133699,0xc(%esp) <== NOT EXECUTED
11257e: 00
11257f: c7 44 24 08 c8 37 13 movl $0x1337c8,0x8(%esp) <== NOT EXECUTED
112586: 00
112587: c7 44 24 04 c6 03 00 movl $0x3c6,0x4(%esp) <== NOT EXECUTED
11258e: 00
11258f: c7 04 24 d0 36 13 00 movl $0x1336d0,(%esp) <== NOT EXECUTED
112596: e8 15 61 00 00 call 1186b0 <__assert_func> <== NOT EXECUTED
11259b: 90 nop
11259c: 90 nop
11259d: 90 nop
11259e: 90 nop
11259f: 90 nop
00119420 <msdos_dir_read>:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
{
119420: 55 push %ebp
int eno = 0;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
rtems_dosfs_convert_control *converter = fs_info->converter;
const rtems_dosfs_convert_handler *convert_handler = converter->handler;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
fat_file_fd_t *tmp_fat_fd = NULL;
119421: 31 c9 xor %ecx,%ecx
{
119423: 89 e5 mov %esp,%ebp
119425: 57 push %edi
119426: 56 push %esi
119427: 53 push %ebx
uint32_t start = 0;
ssize_t ret = 0;
ssize_t cmpltd = 0;
uint32_t j = 0, i = 0;
uint32_t bts2rd = 0;
uint32_t cur_cln = 0;
119428: 31 db xor %ebx,%ebx
{
11942a: 81 ec bc 01 00 00 sub $0x1bc,%esp
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
119430: 8b 45 08 mov 0x8(%ebp),%eax
119433: 8b 40 20 mov 0x20(%eax),%eax
119436: 8b 78 08 mov 0x8(%eax),%edi
rtems_dosfs_convert_control *converter = fs_info->converter;
119439: 8b 87 c8 00 00 00 mov 0xc8(%edi),%eax
11943f: 89 85 78 fe ff ff mov %eax,-0x188(%ebp)
const rtems_dosfs_convert_handler *convert_handler = converter->handler;
119445: 8b 30 mov (%eax),%esi
fat_file_fd_t *tmp_fat_fd = NULL;
119447: 89 8d b4 fe ff ff mov %ecx,-0x14c(%ebp)
uint16_t *lfn_buf = converter->buffer.data;
11944d: 8b 48 04 mov 0x4(%eax),%ecx
uint32_t cur_cln = 0;
119450: 89 9d b8 fe ff ff mov %ebx,-0x148(%ebp)
const size_t buf_size = converter->buffer.size;
119456: 8b 40 08 mov 0x8(%eax),%eax
/*
* cast start and count - protect against using sizes that are not exact
* multiples of the -dirent- size. These could result in unexpected
* results
*/
start = iop->offset / sizeof(struct dirent);
119459: 31 db xor %ebx,%ebx
const rtems_dosfs_convert_handler *convert_handler = converter->handler;
11945b: 89 b5 74 fe ff ff mov %esi,-0x18c(%ebp)
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
119461: 8b 75 08 mov 0x8(%ebp),%esi
uint16_t *lfn_buf = converter->buffer.data;
119464: 89 8d 7c fe ff ff mov %ecx,-0x184(%ebp)
const size_t buf_size = converter->buffer.size;
11946a: 89 85 60 fe ff ff mov %eax,-0x1a0(%ebp)
119470: 8d 87 ac 00 00 00 lea 0xac(%edi),%eax
119476: 89 85 64 fe ff ff mov %eax,-0x19c(%ebp)
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
11947c: 8b 76 14 mov 0x14(%esi),%esi
_Mutex_recursive_Acquire( mutex );
11947f: 89 04 24 mov %eax,(%esp)
119482: 89 b5 84 fe ff ff mov %esi,-0x17c(%ebp)
119488: e8 73 08 ff ff call 109d00 <_Mutex_recursive_Acquire>
start = iop->offset / sizeof(struct dirent);
11948d: 8b 45 08 mov 0x8(%ebp),%eax
119490: b9 18 01 00 00 mov $0x118,%ecx
119495: 8b 50 08 mov 0x8(%eax),%edx
119498: 8b 40 04 mov 0x4(%eax),%eax
11949b: 89 4c 24 08 mov %ecx,0x8(%esp)
11949f: 89 5c 24 0c mov %ebx,0xc(%esp)
1194a3: 89 54 24 04 mov %edx,0x4(%esp)
1194a7: 89 04 24 mov %eax,(%esp)
1194aa: e8 e1 c1 00 00 call 125690 <__divdi3>
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
1194af: ba 0f ea a0 0e mov $0xea0ea0f,%edx
start = iop->offset / sizeof(struct dirent);
1194b4: 89 85 90 fe ff ff mov %eax,-0x170(%ebp)
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
1194ba: 8b 45 10 mov 0x10(%ebp),%eax
1194bd: c1 e8 03 shr $0x3,%eax
1194c0: f7 e2 mul %edx
1194c2: d1 ea shr %edx
1194c4: 69 c2 18 01 00 00 imul $0x118,%edx,%eax
* too, so read such set of sectors is quick operation for low-level IO
* layer.
*/
bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
fat_fd->fat_file_size :
1194ca: 83 7e 20 01 cmpl $0x1,0x20(%esi)
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
1194ce: 89 85 80 fe ff ff mov %eax,-0x180(%ebp)
fat_fd->fat_file_size :
1194d4: 0f 84 76 06 00 00 je 119b50 <msdos_dir_read+0x730>
1194da: 8b 47 08 mov 0x8(%edi),%eax
1194dd: 89 85 6c fe ff ff mov %eax,-0x194(%ebp)
fs_info->fat.vol.bpc;
while (count > 0 && cmpltd >= 0)
1194e3: 8b 85 80 fe ff ff mov -0x180(%ebp),%eax
1194e9: 85 c0 test %eax,%eax
1194eb: 0f 84 03 07 00 00 je 119bf4 <msdos_dir_read+0x7d4> <== NEVER TAKEN
* fat-file is already opened by open call, so read it
* Always read directory fat-file from the beggining because of MSDOS
* directories feature :( - we should count elements currently
* present in the directory because there may be holes :)
*/
ret = fat_file_read(&fs_info->fat, fat_fd, (j * bts2rd),
1194f1: 31 c0 xor %eax,%eax
int lfn_entries = 0;
1194f3: 31 d2 xor %edx,%edx
uint32_t lfn_start = FAT_FILE_SHORT_NAME;
1194f5: b9 ff ff ff ff mov $0xffffffff,%ecx
ssize_t cmpltd = 0;
1194fa: 31 db xor %ebx,%ebx
ret = fat_file_read(&fs_info->fat, fat_fd, (j * bts2rd),
1194fc: 89 85 88 fe ff ff mov %eax,-0x178(%ebp)
size_t lfn_len = 0;
119502: 31 f6 xor %esi,%esi
int lfn_entries = 0;
119504: 89 95 8c fe ff ff mov %edx,-0x174(%ebp)
uint8_t lfn_checksum = 0;
11950a: c6 85 73 fe ff ff 00 movb $0x0,-0x18d(%ebp)
uint32_t lfn_start = FAT_FILE_SHORT_NAME;
119511: 89 8d 94 fe ff ff mov %ecx,-0x16c(%ebp)
ssize_t cmpltd = 0;
119517: 89 9d a0 fe ff ff mov %ebx,-0x160(%ebp)
size_t lfn_len = 0;
11951d: 89 b5 68 fe ff ff mov %esi,-0x198(%ebp)
*/
lfn_entries = (*MSDOS_DIR_ENTRY_TYPE(entry) &
MSDOS_LAST_LONG_ENTRY_MASK);
lfn_len = 0;
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
memset (tmp_dirent.d_name, 0, sizeof(tmp_dirent.d_name));
119523: 89 bd a4 fe ff ff mov %edi,-0x15c(%ebp)
ret = fat_file_read(&fs_info->fat, fat_fd, (j * bts2rd),
119529: 8b bd a4 fe ff ff mov -0x15c(%ebp),%edi
11952f: 8b 87 c4 00 00 00 mov 0xc4(%edi),%eax
119535: 89 3c 24 mov %edi,(%esp)
119538: 89 44 24 10 mov %eax,0x10(%esp)
11953c: 8b 85 6c fe ff ff mov -0x194(%ebp),%eax
119542: 89 44 24 0c mov %eax,0xc(%esp)
119546: 8b 85 88 fe ff ff mov -0x178(%ebp),%eax
11954c: 89 44 24 08 mov %eax,0x8(%esp)
119550: 8b 85 84 fe ff ff mov -0x17c(%ebp),%eax
119556: 89 44 24 04 mov %eax,0x4(%esp)
11955a: e8 01 71 ff ff call 110660 <fat_file_read>
11955f: 89 85 98 fe ff ff mov %eax,-0x168(%ebp)
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
119565: 83 f8 1f cmp $0x1f,%eax
119568: 0f 8e 42 06 00 00 jle 119bb0 <msdos_dir_read+0x790> <== NEVER TAKEN
for (i = 0; i < ret && cmpltd >= 0; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
11956e: 8b 85 a0 fe ff ff mov -0x160(%ebp),%eax
119574: 85 c0 test %eax,%eax
119576: 0f 88 48 04 00 00 js 1199c4 <msdos_dir_read+0x5a4> <== NEVER TAKEN
11957c: bf 20 00 00 00 mov $0x20,%edi
119581: 89 fe mov %edi,%esi
119583: eb 76 jmp 1195fb <msdos_dir_read+0x1db>
119585: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11958c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
119590: 8b 95 a0 fe ff ff mov -0x160(%ebp),%edx
119596: f7 d2 not %edx
119598: c1 ea 1f shr $0x1f,%edx
11959b: 3b b5 98 fe ff ff cmp -0x168(%ebp),%esi
1195a1: 0f 92 c3 setb %bl
1195a4: 20 d3 and %dl,%bl
if (((*MSDOS_DIR_ATTR(entry)) & MSDOS_ATTR_VOLUME_ID) &&
1195a6: 80 f9 0f cmp $0xf,%cl
1195a9: 75 45 jne 1195f0 <msdos_dir_read+0x1d0>
}
else
is_first_entry = false;
1195ab: 31 c9 xor %ecx,%ecx
if (lfn_start == FAT_FILE_SHORT_NAME)
1195ad: 83 bd 94 fe ff ff ff cmpl $0xffffffff,-0x16c(%ebp)
1195b4: 0f 84 36 03 00 00 je 1198f0 <msdos_dir_read+0x4d0> <== NEVER TAKEN
* If the entry number or the check sum do not match
* forget this series of long directory entries. These could
* be orphaned entries depending on the history of the
* disk.
*/
if ((lfn_entries != (*MSDOS_DIR_ENTRY_TYPE(entry) &
1195ba: 24 3f and $0x3f,%al
1195bc: 0f b6 c0 movzbl %al,%eax
1195bf: 3b 85 8c fe ff ff cmp -0x174(%ebp),%eax
1195c5: 75 10 jne 1195d7 <msdos_dir_read+0x1b7>
MSDOS_LAST_LONG_ENTRY_MASK)) ||
1195c7: 0f b6 85 73 fe ff ff movzbl -0x18d(%ebp),%eax
1195ce: 38 47 0d cmp %al,0xd(%edi)
1195d1: 0f 84 99 04 00 00 je 119a70 <msdos_dir_read+0x650>
(lfn_checksum != *MSDOS_DIR_LFN_CHECKSUM(entry)))
{
lfn_start = FAT_FILE_SHORT_NAME;
1195d7: b9 ff ff ff ff mov $0xffffffff,%ecx
1195dc: 89 8d 94 fe ff ff mov %ecx,-0x16c(%ebp)
1195e2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1195e9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
for (i = 0; i < ret && cmpltd >= 0; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
1195f0: 83 c6 20 add $0x20,%esi
1195f3: 84 db test %bl,%bl
1195f5: 0f 84 c7 04 00 00 je 119ac2 <msdos_dir_read+0x6a2> <== NEVER TAKEN
1195fb: 8d 46 e0 lea -0x20(%esi),%eax
1195fe: 89 85 9c fe ff ff mov %eax,-0x164(%ebp)
char* entry = (char*) fs_info->cl_buf + i;
119604: 8b 85 a4 fe ff ff mov -0x15c(%ebp),%eax
11960a: 8b 80 c4 00 00 00 mov 0xc4(%eax),%eax
119610: 8d 7c 30 e0 lea -0x20(%eax,%esi,1),%edi
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
119614: 0f b6 07 movzbl (%edi),%eax
119617: 84 c0 test %al,%al
119619: 0f 84 a5 03 00 00 je 1199c4 <msdos_dir_read+0x5a4>
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) == MSDOS_THIS_DIR_ENTRY_EMPTY)
11961f: 3c e5 cmp $0xe5,%al
119621: 0f 84 73 02 00 00 je 11989a <msdos_dir_read+0x47a> <== NEVER TAKEN
if (((*MSDOS_DIR_ATTR(entry)) & MSDOS_ATTR_VOLUME_ID) &&
119627: 0f b6 57 0b movzbl 0xb(%edi),%edx
11962b: 88 d1 mov %dl,%cl
11962d: 88 d3 mov %dl,%bl
11962f: 80 e1 3f and $0x3f,%cl
119632: 80 e3 08 and $0x8,%bl
119635: 0f 85 55 ff ff ff jne 119590 <msdos_dir_read+0x170>
if ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
11963b: 80 f9 0f cmp $0xf,%cl
11963e: 0f 84 95 05 00 00 je 119bd9 <msdos_dir_read+0x7b9> <== NEVER TAKEN
fat_dir_pos_t dir_pos;
/*
* Skip active entries until get the entry to start from.
*/
if (start)
119644: 8b 9d 90 fe ff ff mov -0x170(%ebp),%ebx
11964a: 85 db test %ebx,%ebx
11964c: 0f 85 6e 02 00 00 jne 1198c0 <msdos_dir_read+0x4a0>
start--;
continue;
}
#ifdef DT_DIR
if ((*MSDOS_DIR_ATTR(entry)) & MSDOS_ATTR_DIRECTORY)
119652: 80 e2 10 and $0x10,%dl
{
tmp_dirent.d_type = DT_DIR;
}
else
{
tmp_dirent.d_type = DT_REG;
119655: 80 fa 01 cmp $0x1,%dl
* unfortunately there is no method to extract ino except to
* open fat-file descriptor :( ... so, open it
*/
/* get number of cluster we are working with */
rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
119658: ba 01 00 00 00 mov $0x1,%edx
11965d: 89 54 24 08 mov %edx,0x8(%esp)
tmp_dirent.d_type = DT_REG;
119661: 19 c0 sbb %eax,%eax
119663: 24 04 and $0x4,%al
119665: 04 04 add $0x4,%al
119667: 88 85 e2 fe ff ff mov %al,-0x11e(%ebp)
rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
11966d: 8d 85 b8 fe ff ff lea -0x148(%ebp),%eax
119673: 89 44 24 10 mov %eax,0x10(%esp)
119677: 8b 85 88 fe ff ff mov -0x178(%ebp),%eax
11967d: 89 44 24 0c mov %eax,0xc(%esp)
119681: 8b 85 84 fe ff ff mov -0x17c(%ebp),%eax
119687: 89 44 24 04 mov %eax,0x4(%esp)
11968b: 8b 85 a4 fe ff ff mov -0x15c(%ebp),%eax
119691: 89 04 24 mov %eax,(%esp)
119694: e8 87 73 ff ff call 110a20 <fat_file_ioctl>
j * bts2rd, &cur_cln);
if (rc != RC_OK)
119699: 85 c0 test %eax,%eax
11969b: 0f 85 7f 04 00 00 jne 119b20 <msdos_dir_read+0x700> <== NEVER TAKEN
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
1196a1: b8 ff ff ff ff mov $0xffffffff,%eax
1196a6: 89 85 c8 fe ff ff mov %eax,-0x138(%ebp)
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
1196ac: b8 ff ff ff ff mov $0xffffffff,%eax
1196b1: 89 85 cc fe ff ff mov %eax,-0x134(%ebp)
msdos_fs_unlock(fs_info);
return rc;
}
fat_dir_pos_init(&dir_pos);
dir_pos.sname.cln = cur_cln;
1196b7: 8b 85 b8 fe ff ff mov -0x148(%ebp),%eax
1196bd: 89 85 c0 fe ff ff mov %eax,-0x140(%ebp)
dir_pos.sname.ofs = i;
1196c3: 8d 46 e0 lea -0x20(%esi),%eax
1196c6: 89 85 c4 fe ff ff mov %eax,-0x13c(%ebp)
rc = fat_file_open(&fs_info->fat, &dir_pos, &tmp_fat_fd);
1196cc: 8d 85 b4 fe ff ff lea -0x14c(%ebp),%eax
1196d2: 89 44 24 08 mov %eax,0x8(%esp)
1196d6: 8d 85 c0 fe ff ff lea -0x140(%ebp),%eax
1196dc: 89 44 24 04 mov %eax,0x4(%esp)
1196e0: 8b 85 a4 fe ff ff mov -0x15c(%ebp),%eax
1196e6: 89 04 24 mov %eax,(%esp)
1196e9: e8 22 6c ff ff call 110310 <fat_file_open>
if (rc != RC_OK)
1196ee: 85 c0 test %eax,%eax
1196f0: 0f 85 2a 04 00 00 jne 119b20 <msdos_dir_read+0x700> <== NEVER TAKEN
return rc;
}
/* fill in dirent structure */
/* XXX: from what and in what d_off should be computed ?! */
tmp_dirent.d_off = start + cmpltd;
1196f6: 8b 85 a0 fe ff ff mov -0x160(%ebp),%eax
1196fc: 8d 9d bc fe ff ff lea -0x144(%ebp),%ebx
119702: 89 85 d8 fe ff ff mov %eax,-0x128(%ebp)
119708: c1 f8 1f sar $0x1f,%eax
11970b: 89 85 dc fe ff ff mov %eax,-0x124(%ebp)
tmp_dirent.d_reclen = sizeof(struct dirent);
119711: b8 18 01 00 00 mov $0x118,%eax
119716: 66 89 85 e0 fe ff ff mov %ax,-0x120(%ebp)
tmp_dirent.d_ino = tmp_fat_fd->ino;
11971d: 8b 85 b4 fe ff ff mov -0x14c(%ebp),%eax
119723: 8b 40 0c mov 0xc(%eax),%eax
119726: 89 85 d0 fe ff ff mov %eax,-0x130(%ebp)
11972c: 31 c0 xor %eax,%eax
* convertable to utf8 string. If not return the short file
* name.
*/
if (lfn_start != FAT_FILE_SHORT_NAME)
{
if (lfn_entries == 0 &&
11972e: 83 bd 94 fe ff ff ff cmpl $0xffffffff,-0x16c(%ebp)
tmp_dirent.d_ino = tmp_fat_fd->ino;
119735: 89 85 d4 fe ff ff mov %eax,-0x12c(%ebp)
if (lfn_entries == 0 &&
11973b: 74 0e je 11974b <msdos_dir_read+0x32b>
11973d: 8b 85 8c fe ff ff mov -0x174(%ebp),%eax
119743: 85 c0 test %eax,%eax
119745: 0f 84 a5 02 00 00 je 1199f0 <msdos_dir_read+0x5d0>
/*
* convert dir entry from fixed 8+3 format (without dot)
* to 0..8 + 1dot + 0..3 format
*/
tmp_dirent.d_namlen = msdos_format_dirent_with_dot(
11974b: 89 7c 24 04 mov %edi,0x4(%esp)
11974f: 8b bd 7c fe ff ff mov -0x184(%ebp),%edi
size_t len = sizeof(tmp_dirent.d_name) - 1;
119755: b8 ff 00 00 00 mov $0xff,%eax
11975a: 89 85 bc fe ff ff mov %eax,-0x144(%ebp)
tmp_dirent.d_namlen = msdos_format_dirent_with_dot(
119760: 89 3c 24 mov %edi,(%esp)
119763: e8 68 8e ff ff call 1125d0 <msdos_format_dirent_with_dot>
sfn_buf, entry); /* src text */
eno = (*convert_handler->codepage_to_utf8) (
119768: 8d 8d e6 fe ff ff lea -0x11a(%ebp),%ecx
11976e: 89 5c 24 10 mov %ebx,0x10(%esp)
119772: 89 4c 24 0c mov %ecx,0xc(%esp)
119776: 89 7c 24 04 mov %edi,0x4(%esp)
tmp_dirent.d_namlen = msdos_format_dirent_with_dot(
11977a: 66 89 85 e4 fe ff ff mov %ax,-0x11c(%ebp)
eno = (*convert_handler->codepage_to_utf8) (
119781: 0f b7 c0 movzwl %ax,%eax
119784: 89 44 24 08 mov %eax,0x8(%esp)
119788: 8b 85 78 fe ff ff mov -0x188(%ebp),%eax
11978e: 89 04 24 mov %eax,(%esp)
119791: 8b 85 74 fe ff ff mov -0x18c(%ebp),%eax
119797: ff 50 04 call *0x4(%eax)
converter,
sfn_buf,
tmp_dirent.d_namlen,
(uint8_t *) &tmp_dirent.d_name[0],
&len);
if ( 0 == eno ) {
11979a: 85 c0 test %eax,%eax
11979c: 0f 85 0e 02 00 00 jne 1199b0 <msdos_dir_read+0x590> <== NEVER TAKEN
tmp_dirent.d_namlen = len;
1197a2: 8b 85 bc fe ff ff mov -0x144(%ebp),%eax
tmp_dirent.d_name[len] = '\0';
1197a8: 31 d2 xor %edx,%edx
1197aa: b9 ff ff ff ff mov $0xffffffff,%ecx
1197af: 89 8d 94 fe ff ff mov %ecx,-0x16c(%ebp)
tmp_dirent.d_namlen = len;
1197b5: 66 89 85 e4 fe ff ff mov %ax,-0x11c(%ebp)
tmp_dirent.d_name[len] = '\0';
1197bc: 88 94 05 e6 fe ff ff mov %dl,-0x11a(%ebp,%eax,1)
errno = eno;
}
}
if ( cmpltd >= 0 ) {
memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
1197c3: 8b 7d 0c mov 0xc(%ebp),%edi
1197c6: 8d 8d d0 fe ff ff lea -0x130(%ebp),%ecx
1197cc: 8b 85 a0 fe ff ff mov -0x160(%ebp),%eax
1197d2: 01 f8 add %edi,%eax
1197d4: bf 18 01 00 00 mov $0x118,%edi
1197d9: a8 01 test $0x1,%al
1197db: 89 c2 mov %eax,%edx
1197dd: 0f 85 fd 02 00 00 jne 119ae0 <msdos_dir_read+0x6c0> <== NEVER TAKEN
1197e3: f6 c2 02 test $0x2,%dl
1197e6: 0f 85 14 03 00 00 jne 119b00 <msdos_dir_read+0x6e0> <== NEVER TAKEN
1197ec: 89 b5 9c fe ff ff mov %esi,-0x164(%ebp)
1197f2: 89 fb mov %edi,%ebx
1197f4: 31 c0 xor %eax,%eax
1197f6: 83 e3 f8 and $0xfffffff8,%ebx
1197f9: 8b 34 01 mov (%ecx,%eax,1),%esi
1197fc: 89 34 02 mov %esi,(%edx,%eax,1)
1197ff: 8b 74 01 04 mov 0x4(%ecx,%eax,1),%esi
119803: 89 74 02 04 mov %esi,0x4(%edx,%eax,1)
119807: 83 c0 08 add $0x8,%eax
11980a: 39 d8 cmp %ebx,%eax
11980c: 72 eb jb 1197f9 <msdos_dir_read+0x3d9>
11980e: 01 c2 add %eax,%edx
119810: 01 c1 add %eax,%ecx
119812: 8b b5 9c fe ff ff mov -0x164(%ebp),%esi
119818: 31 c0 xor %eax,%eax
11981a: f7 c7 04 00 00 00 test $0x4,%edi
119820: 74 09 je 11982b <msdos_dir_read+0x40b> <== ALWAYS TAKEN
119822: 8b 01 mov (%ecx),%eax <== NOT EXECUTED
119824: 89 02 mov %eax,(%edx) <== NOT EXECUTED
119826: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED
11982b: f7 c7 02 00 00 00 test $0x2,%edi
119831: 74 0b je 11983e <msdos_dir_read+0x41e> <== ALWAYS TAKEN
119833: 0f b7 1c 01 movzwl (%ecx,%eax,1),%ebx <== NOT EXECUTED
119837: 66 89 1c 02 mov %bx,(%edx,%eax,1) <== NOT EXECUTED
11983b: 83 c0 02 add $0x2,%eax <== NOT EXECUTED
11983e: 83 e7 01 and $0x1,%edi
119841: 74 07 je 11984a <msdos_dir_read+0x42a> <== ALWAYS TAKEN
119843: 0f b6 0c 01 movzbl (%ecx,%eax,1),%ecx <== NOT EXECUTED
119847: 88 0c 02 mov %cl,(%edx,%eax,1) <== NOT EXECUTED
iop->offset = iop->offset + sizeof(struct dirent);
11984a: 8b 45 08 mov 0x8(%ebp),%eax
11984d: 81 40 04 18 01 00 00 addl $0x118,0x4(%eax)
119854: 83 50 08 00 adcl $0x0,0x8(%eax)
cmpltd += (sizeof(struct dirent));
count -= (sizeof(struct dirent));
/* inode number extracted, close fat-file */
rc = fat_file_close(&fs_info->fat, tmp_fat_fd);
119858: 8b 85 b4 fe ff ff mov -0x14c(%ebp),%eax
cmpltd += (sizeof(struct dirent));
11985e: 81 85 a0 fe ff ff 18 addl $0x118,-0x160(%ebp)
119865: 01 00 00
count -= (sizeof(struct dirent));
119868: 81 ad 80 fe ff ff 18 subl $0x118,-0x180(%ebp)
11986f: 01 00 00
rc = fat_file_close(&fs_info->fat, tmp_fat_fd);
119872: 89 44 24 04 mov %eax,0x4(%esp)
119876: 8b 85 a4 fe ff ff mov -0x15c(%ebp),%eax
11987c: 89 04 24 mov %eax,(%esp)
11987f: e8 cc 70 ff ff call 110950 <fat_file_close>
if (rc != RC_OK)
119884: 85 c0 test %eax,%eax
119886: 0f 85 94 02 00 00 jne 119b20 <msdos_dir_read+0x700> <== NEVER TAKEN
return rc;
}
}
}
if (count <= 0)
11988c: 8b 9d 80 fe ff ff mov -0x180(%ebp),%ebx
119892: 85 db test %ebx,%ebx
119894: 0f 84 2a 01 00 00 je 1199c4 <msdos_dir_read+0x5a4> <== ALWAYS TAKEN
for (i = 0; i < ret && cmpltd >= 0; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
11989a: 8b 85 a0 fe ff ff mov -0x160(%ebp),%eax <== NOT EXECUTED
1198a0: f7 d0 not %eax <== NOT EXECUTED
1198a2: c1 e8 1f shr $0x1f,%eax <== NOT EXECUTED
1198a5: 3b b5 98 fe ff ff cmp -0x168(%ebp),%esi <== NOT EXECUTED
1198ab: 89 c2 mov %eax,%edx <== NOT EXECUTED
1198ad: 0f 92 c3 setb %bl <== NOT EXECUTED
1198b0: 20 c3 and %al,%bl <== NOT EXECUTED
1198b2: e9 39 fd ff ff jmp 1195f0 <msdos_dir_read+0x1d0> <== NOT EXECUTED
1198b7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1198be: 66 90 xchg %ax,%ax <== NOT EXECUTED
1198c0: 8b 85 a0 fe ff ff mov -0x160(%ebp),%eax
lfn_start = FAT_FILE_SHORT_NAME;
1198c6: b9 ff ff ff ff mov $0xffffffff,%ecx
start--;
1198cb: ff 8d 90 fe ff ff decl -0x170(%ebp)
lfn_start = FAT_FILE_SHORT_NAME;
1198d1: 89 8d 94 fe ff ff mov %ecx,-0x16c(%ebp)
for (i = 0; i < ret && cmpltd >= 0; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
1198d7: f7 d0 not %eax
1198d9: c1 e8 1f shr $0x1f,%eax
1198dc: 3b b5 98 fe ff ff cmp -0x168(%ebp),%esi
1198e2: 89 c2 mov %eax,%edx
1198e4: 0f 92 c3 setb %bl
1198e7: 20 c3 and %al,%bl
1198e9: e9 02 fd ff ff jmp 1195f0 <msdos_dir_read+0x1d0>
1198ee: 66 90 xchg %ax,%ax
if ((*MSDOS_DIR_ENTRY_TYPE(entry) &
1198f0: 88 c1 mov %al,%cl
1198f2: 80 e1 40 and $0x40,%cl
1198f5: 0f 84 f5 fc ff ff je 1195f0 <msdos_dir_read+0x1d0> <== NEVER TAKEN
lfn_entries = (*MSDOS_DIR_ENTRY_TYPE(entry) &
1198fb: 24 3f and $0x3f,%al
lfn_start =
1198fd: 8b 8d 88 fe ff ff mov -0x178(%ebp),%ecx
lfn_entries = (*MSDOS_DIR_ENTRY_TYPE(entry) &
119903: 0f b6 c0 movzbl %al,%eax
119906: 89 85 8c fe ff ff mov %eax,-0x174(%ebp)
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
11990c: 0f b6 47 0d movzbl 0xd(%edi),%eax
lfn_start =
119910: 8d 4c 0e e0 lea -0x20(%esi,%ecx,1),%ecx
119914: c1 e9 05 shr $0x5,%ecx
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
119917: 88 85 73 fe ff ff mov %al,-0x18d(%ebp)
memset (tmp_dirent.d_name, 0, sizeof(tmp_dirent.d_name));
11991d: b8 00 01 00 00 mov $0x100,%eax
119922: 89 85 9c fe ff ff mov %eax,-0x164(%ebp)
119928: b8 02 00 00 00 mov $0x2,%eax
lfn_start =
11992d: 89 8d 94 fe ff ff mov %ecx,-0x16c(%ebp)
memset (tmp_dirent.d_name, 0, sizeof(tmp_dirent.d_name));
119933: 8d 8d e6 fe ff ff lea -0x11a(%ebp),%ecx
119939: 85 c0 test %eax,%eax
11993b: 0f 85 38 02 00 00 jne 119b79 <msdos_dir_read+0x759> <== ALWAYS TAKEN
119941: 88 95 72 fe ff ff mov %dl,-0x18e(%ebp)
119947: 8b 85 9c fe ff ff mov -0x164(%ebp),%eax
11994d: 83 e0 f8 and $0xfffffff8,%eax
119950: 89 85 68 fe ff ff mov %eax,-0x198(%ebp)
119956: 31 c0 xor %eax,%eax
119958: 8b 95 68 fe ff ff mov -0x198(%ebp),%edx
11995e: c7 04 01 00 00 00 00 movl $0x0,(%ecx,%eax,1)
119965: c7 44 01 04 00 00 00 movl $0x0,0x4(%ecx,%eax,1)
11996c: 00
11996d: 83 c0 08 add $0x8,%eax
119970: 39 d0 cmp %edx,%eax
119972: 72 ea jb 11995e <msdos_dir_read+0x53e>
119974: 01 c1 add %eax,%ecx
119976: 0f b6 95 72 fe ff ff movzbl -0x18e(%ebp),%edx
11997d: f6 85 9c fe ff ff 04 testb $0x4,-0x164(%ebp)
119984: 0f 85 18 02 00 00 jne 119ba2 <msdos_dir_read+0x782> <== ALWAYS TAKEN
11998a: f6 85 9c fe ff ff 02 testb $0x2,-0x164(%ebp)
119991: 0f 85 01 02 00 00 jne 119b98 <msdos_dir_read+0x778> <== ALWAYS TAKEN
lfn_len = 0;
119997: c7 85 68 fe ff ff 00 movl $0x0,-0x198(%ebp)
11999e: 00 00 00
if ((lfn_entries != (*MSDOS_DIR_ENTRY_TYPE(entry) &
1199a1: 0f b6 07 movzbl (%edi),%eax
is_first_entry = true;
1199a4: b1 01 mov $0x1,%cl
1199a6: e9 0f fc ff ff jmp 1195ba <msdos_dir_read+0x19a>
1199ab: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
1199af: 90 nop
errno = eno;
1199b0: 89 c6 mov %eax,%esi <== NOT EXECUTED
1199b2: e8 e9 ce 00 00 call 1268a0 <__errno> <== NOT EXECUTED
1199b7: 89 30 mov %esi,(%eax) <== NOT EXECUTED
cmpltd = -1;
1199b9: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
1199be: 89 85 a0 fe ff ff mov %eax,-0x160(%ebp) <== NOT EXECUTED
_Mutex_recursive_Release( mutex );
1199c4: 8b 85 64 fe ff ff mov -0x19c(%ebp),%eax
1199ca: 89 04 24 mov %eax,(%esp)
1199cd: e8 ae 03 ff ff call 109d80 <_Mutex_recursive_Release>
j++;
}
msdos_fs_unlock(fs_info);
return cmpltd;
}
1199d2: 8b 85 a0 fe ff ff mov -0x160(%ebp),%eax
1199d8: 81 c4 bc 01 00 00 add $0x1bc,%esp
1199de: 5b pop %ebx
1199df: 5e pop %esi
1199e0: 5f pop %edi
1199e1: 5d pop %ebp
1199e2: c3 ret
1199e3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1199ea: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
lfn_checksum == msdos_lfn_checksum(entry)) {
1199f0: 89 3c 24 mov %edi,(%esp)
1199f3: e8 08 83 ff ff call 111d00 <msdos_lfn_checksum>
if (lfn_entries == 0 &&
1199f8: 3a 85 73 fe ff ff cmp -0x18d(%ebp),%al
1199fe: 0f 85 47 fd ff ff jne 11974b <msdos_dir_read+0x32b> <== NEVER TAKEN
eno = (*convert_handler->utf16_to_utf8) (
119a04: 89 5c 24 10 mov %ebx,0x10(%esp)
119a08: 8d 85 e6 fe ff ff lea -0x11a(%ebp),%eax
size_t len = sizeof(tmp_dirent.d_name) - 1;
119a0e: b9 ff 00 00 00 mov $0xff,%ecx
eno = (*convert_handler->utf16_to_utf8) (
119a13: 89 44 24 0c mov %eax,0xc(%esp)
119a17: 8b 85 68 fe ff ff mov -0x198(%ebp),%eax
size_t len = sizeof(tmp_dirent.d_name) - 1;
119a1d: 89 8d bc fe ff ff mov %ecx,-0x144(%ebp)
eno = (*convert_handler->utf16_to_utf8) (
119a23: 89 44 24 08 mov %eax,0x8(%esp)
119a27: 8b 85 7c fe ff ff mov -0x184(%ebp),%eax
119a2d: 89 44 24 04 mov %eax,0x4(%esp)
119a31: 8b 85 78 fe ff ff mov -0x188(%ebp),%eax
119a37: 89 04 24 mov %eax,(%esp)
119a3a: 8b 85 74 fe ff ff mov -0x18c(%ebp),%eax
119a40: ff 50 0c call *0xc(%eax)
if (eno == 0) {
119a43: 85 c0 test %eax,%eax
119a45: 0f 85 00 fd ff ff jne 11974b <msdos_dir_read+0x32b> <== NEVER TAKEN
tmp_dirent.d_namlen = len;
119a4b: 8b 85 bc fe ff ff mov -0x144(%ebp),%eax
tmp_dirent.d_name[len] = '\0';
119a51: 31 d2 xor %edx,%edx
tmp_dirent.d_namlen = len;
119a53: 66 89 85 e4 fe ff ff mov %ax,-0x11c(%ebp)
tmp_dirent.d_name[len] = '\0';
119a5a: 88 94 05 e6 fe ff ff mov %dl,-0x11a(%ebp,%eax,1)
if (lfn_start == FAT_FILE_SHORT_NAME) {
119a61: e9 5d fd ff ff jmp 1197c3 <msdos_dir_read+0x3a3>
119a66: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
119a6d: 8d 76 00 lea 0x0(%esi),%esi
lfn_entries--;
119a70: ff 8d 8c fe ff ff decl -0x174(%ebp)
119a76: 88 95 9c fe ff ff mov %dl,-0x164(%ebp)
lfn_len += msdos_get_utf16_string_from_long_entry (
119a7c: 89 3c 24 mov %edi,(%esp)
lfn_entries--;
119a7f: 8b 95 8c fe ff ff mov -0x174(%ebp),%edx
offset_lfn = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
119a85: 8d 04 52 lea (%edx,%edx,2),%eax
119a88: 8d 14 82 lea (%edx,%eax,4),%edx
lfn_len += msdos_get_utf16_string_from_long_entry (
119a8b: 0f b6 c1 movzbl %cl,%eax
119a8e: 89 44 24 0c mov %eax,0xc(%esp)
119a92: 8b 85 60 fe ff ff mov -0x1a0(%ebp),%eax
119a98: 29 d0 sub %edx,%eax
119a9a: 89 44 24 08 mov %eax,0x8(%esp)
119a9e: 8b 85 7c fe ff ff mov -0x184(%ebp),%eax
119aa4: 8d 04 50 lea (%eax,%edx,2),%eax
119aa7: 89 44 24 04 mov %eax,0x4(%esp)
119aab: e8 f0 8a ff ff call 1125a0 <msdos_get_utf16_string_from_long_entry>
if (count <= 0)
119ab0: 0f b6 95 9c fe ff ff movzbl -0x164(%ebp),%edx
lfn_len += msdos_get_utf16_string_from_long_entry (
119ab7: 01 85 68 fe ff ff add %eax,-0x198(%ebp)
119abd: e9 2e fb ff ff jmp 1195f0 <msdos_dir_read+0x1d0>
while (count > 0 && cmpltd >= 0)
119ac2: 8b bd 6c fe ff ff mov -0x194(%ebp),%edi
119ac8: 01 bd 88 fe ff ff add %edi,-0x178(%ebp)
119ace: 84 d2 test %dl,%dl
119ad0: 0f 85 53 fa ff ff jne 119529 <msdos_dir_read+0x109>
119ad6: e9 e9 fe ff ff jmp 1199c4 <msdos_dir_read+0x5a4> <== NOT EXECUTED
119adb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
119adf: 90 nop <== NOT EXECUTED
memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
119ae0: 0f b6 8d d0 fe ff ff movzbl -0x130(%ebp),%ecx <== NOT EXECUTED
119ae7: 42 inc %edx <== NOT EXECUTED
119ae8: bf 17 01 00 00 mov $0x117,%edi <== NOT EXECUTED
119aed: f6 c2 02 test $0x2,%dl <== NOT EXECUTED
119af0: 88 08 mov %cl,(%eax) <== NOT EXECUTED
119af2: 8d 8d d1 fe ff ff lea -0x12f(%ebp),%ecx <== NOT EXECUTED
119af8: 0f 84 ee fc ff ff je 1197ec <msdos_dir_read+0x3cc> <== NOT EXECUTED
119afe: 66 90 xchg %ax,%ax <== NOT EXECUTED
119b00: 0f b7 01 movzwl (%ecx),%eax <== NOT EXECUTED
119b03: 83 c2 02 add $0x2,%edx <== NOT EXECUTED
119b06: 83 c1 02 add $0x2,%ecx <== NOT EXECUTED
119b09: 83 ef 02 sub $0x2,%edi <== NOT EXECUTED
119b0c: 66 89 42 fe mov %ax,-0x2(%edx) <== NOT EXECUTED
119b10: e9 d7 fc ff ff jmp 1197ec <msdos_dir_read+0x3cc> <== NOT EXECUTED
119b15: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
119b1c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
119b20: 89 85 a4 fe ff ff mov %eax,-0x15c(%ebp) <== NOT EXECUTED
119b26: 8b 85 64 fe ff ff mov -0x19c(%ebp),%eax <== NOT EXECUTED
119b2c: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
119b2f: e8 4c 02 ff ff call 109d80 <_Mutex_recursive_Release> <== NOT EXECUTED
rc = fat_file_close(&fs_info->fat, tmp_fat_fd);
119b34: 8b 85 a4 fe ff ff mov -0x15c(%ebp),%eax <== NOT EXECUTED
119b3a: 89 85 a0 fe ff ff mov %eax,-0x160(%ebp) <== NOT EXECUTED
return rc;
119b40: e9 8d fe ff ff jmp 1199d2 <msdos_dir_read+0x5b2> <== NOT EXECUTED
119b45: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
119b4c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&
119b50: 8b 85 84 fe ff ff mov -0x17c(%ebp),%eax
119b56: 8b 50 24 mov 0x24(%eax),%edx
119b59: 85 d2 test %edx,%edx
119b5b: 0f 85 79 f9 ff ff jne 1194da <msdos_dir_read+0xba> <== NEVER TAKEN
119b61: f6 47 16 03 testb $0x3,0x16(%edi)
119b65: 0f 84 6f f9 ff ff je 1194da <msdos_dir_read+0xba> <== NEVER TAKEN
fat_fd->fat_file_size :
119b6b: 8b 40 18 mov 0x18(%eax),%eax
119b6e: 89 85 6c fe ff ff mov %eax,-0x194(%ebp)
119b74: e9 6a f9 ff ff jmp 1194e3 <msdos_dir_read+0xc3>
memset (tmp_dirent.d_name, 0, sizeof(tmp_dirent.d_name));
119b79: 8d 8d e8 fe ff ff lea -0x118(%ebp),%ecx
119b7f: 31 c0 xor %eax,%eax
119b81: 66 89 85 e6 fe ff ff mov %ax,-0x11a(%ebp)
119b88: b8 fe 00 00 00 mov $0xfe,%eax
119b8d: 89 85 9c fe ff ff mov %eax,-0x164(%ebp)
119b93: e9 a9 fd ff ff jmp 119941 <msdos_dir_read+0x521>
119b98: 66 c7 01 00 00 movw $0x0,(%ecx)
119b9d: e9 f5 fd ff ff jmp 119997 <msdos_dir_read+0x577>
119ba2: c7 01 00 00 00 00 movl $0x0,(%ecx)
119ba8: 83 c1 04 add $0x4,%ecx
119bab: e9 da fd ff ff jmp 11998a <msdos_dir_read+0x56a>
119bb0: 8b 85 64 fe ff ff mov -0x19c(%ebp),%eax <== NOT EXECUTED
119bb6: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
119bb9: e8 c2 01 ff ff call 109d80 <_Mutex_recursive_Release> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
119bbe: e8 dd cc 00 00 call 1268a0 <__errno> <== NOT EXECUTED
119bc3: c7 00 05 00 00 00 movl $0x5,(%eax) <== NOT EXECUTED
119bc9: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
119bce: 89 85 a0 fe ff ff mov %eax,-0x160(%ebp) <== NOT EXECUTED
119bd4: e9 f9 fd ff ff jmp 1199d2 <msdos_dir_read+0x5b2> <== NOT EXECUTED
for (i = 0; i < ret && cmpltd >= 0; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
119bd9: 8b 95 a0 fe ff ff mov -0x160(%ebp),%edx <== NOT EXECUTED
119bdf: f7 d2 not %edx <== NOT EXECUTED
119be1: c1 ea 1f shr $0x1f,%edx <== NOT EXECUTED
119be4: 3b b5 98 fe ff ff cmp -0x168(%ebp),%esi <== NOT EXECUTED
119bea: 0f 92 c3 setb %bl <== NOT EXECUTED
119bed: 20 d3 and %dl,%bl <== NOT EXECUTED
119bef: e9 b7 f9 ff ff jmp 1195ab <msdos_dir_read+0x18b> <== NOT EXECUTED
ssize_t cmpltd = 0;
119bf4: 31 c0 xor %eax,%eax <== NOT EXECUTED
119bf6: 89 85 a0 fe ff ff mov %eax,-0x160(%ebp) <== NOT EXECUTED
119bfc: e9 c3 fd ff ff jmp 1199c4 <msdos_dir_read+0x5a4> <== NOT EXECUTED
119c01: 90 nop
119c02: 90 nop
119c03: 90 nop
119c04: 90 nop
119c05: 90 nop
119c06: 90 nop
119c07: 90 nop
119c08: 90 nop
119c09: 90 nop
119c0a: 90 nop
119c0b: 90 nop
119c0c: 90 nop
119c0d: 90 nop
119c0e: 90 nop
119c0f: 90 nop
00119ef0 <msdos_file_ftruncate>:
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately).
*/
int
msdos_file_ftruncate(rtems_libio_t *iop, off_t length)
{
119ef0: 55 push %ebp
119ef1: 89 e5 mov %esp,%ebp
119ef3: 83 ec 58 sub $0x58,%esp
119ef6: 89 5d f4 mov %ebx,-0xc(%ebp)
119ef9: 8b 45 08 mov 0x8(%ebp),%eax
119efc: 89 7d fc mov %edi,-0x4(%ebp)
119eff: 8b 5d 10 mov 0x10(%ebp),%ebx
119f02: 89 75 f8 mov %esi,-0x8(%ebp)
119f05: 8b 75 0c mov 0xc(%ebp),%esi
int rc = RC_OK;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
119f08: 8b 50 20 mov 0x20(%eax),%edx
{
119f0b: 89 5d d4 mov %ebx,-0x2c(%ebp)
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
119f0e: 8b 58 14 mov 0x14(%eax),%ebx
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
119f11: 8b 7a 08 mov 0x8(%edx),%edi
119f14: 89 7d d0 mov %edi,-0x30(%ebp)
119f17: 81 c7 ac 00 00 00 add $0xac,%edi
_Mutex_recursive_Acquire( mutex );
119f1d: 89 3c 24 mov %edi,(%esp)
119f20: e8 db fd fe ff call 109d00 <_Mutex_recursive_Acquire>
uint32_t old_length;
msdos_fs_lock(fs_info);
old_length = fat_fd->fat_file_size;
119f25: 8b 53 18 mov 0x18(%ebx),%edx
if (length < old_length) {
119f28: 8b 4d d4 mov -0x2c(%ebp),%ecx
119f2b: 39 d6 cmp %edx,%esi
119f2d: 83 d9 00 sbb $0x0,%ecx
119f30: 7d 3e jge 119f70 <msdos_file_ftruncate+0x80>
rc = fat_file_truncate(&fs_info->fat, fat_fd, length);
119f32: 89 74 24 08 mov %esi,0x8(%esp)
119f36: 8b 45 d0 mov -0x30(%ebp),%eax
119f39: 89 5c 24 04 mov %ebx,0x4(%esp)
119f3d: 89 04 24 mov %eax,(%esp)
119f40: e8 0b 69 ff ff call 110850 <fat_file_truncate>
errno = ENOSPC;
rc = -1;
}
}
if (rc == RC_OK)
119f45: 85 c0 test %eax,%eax
rc = fat_file_truncate(&fs_info->fat, fat_fd, length);
119f47: 89 c1 mov %eax,%ecx
if (rc == RC_OK)
119f49: 74 60 je 119fab <msdos_file_ftruncate+0xbb> <== ALWAYS TAKEN
_Mutex_recursive_Release( mutex );
119f4b: 89 3c 24 mov %edi,(%esp)
119f4e: 89 4d d4 mov %ecx,-0x2c(%ebp)
119f51: e8 2a fe fe ff call 109d80 <_Mutex_recursive_Release>
}
msdos_fs_unlock(fs_info);
return rc;
}
119f56: 8b 4d d4 mov -0x2c(%ebp),%ecx
119f59: 8b 5d f4 mov -0xc(%ebp),%ebx
119f5c: 8b 75 f8 mov -0x8(%ebp),%esi
119f5f: 8b 7d fc mov -0x4(%ebp),%edi
119f62: 89 ec mov %ebp,%esp
119f64: 5d pop %ebp
119f65: 89 c8 mov %ecx,%eax
119f67: c3 ret
119f68: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
119f6f: 90 nop
rc = fat_file_extend(&fs_info->fat,
119f70: 89 74 24 0c mov %esi,0xc(%esp)
119f74: 8d 45 e4 lea -0x1c(%ebp),%eax
119f77: 89 44 24 10 mov %eax,0x10(%esp)
119f7b: b8 01 00 00 00 mov $0x1,%eax
119f80: 89 44 24 08 mov %eax,0x8(%esp)
119f84: 8b 45 d0 mov -0x30(%ebp),%eax
119f87: 89 5c 24 04 mov %ebx,0x4(%esp)
119f8b: 89 55 cc mov %edx,-0x34(%ebp)
119f8e: 89 04 24 mov %eax,(%esp)
119f91: e8 3a 6b ff ff call 110ad0 <fat_file_extend>
if (rc == RC_OK && length != new_length) {
119f96: 85 c0 test %eax,%eax
rc = fat_file_extend(&fs_info->fat,
119f98: 89 c1 mov %eax,%ecx
if (rc == RC_OK && length != new_length) {
119f9a: 75 af jne 119f4b <msdos_file_ftruncate+0x5b> <== NEVER TAKEN
119f9c: 8b 45 e4 mov -0x1c(%ebp),%eax
119f9f: 8b 55 d4 mov -0x2c(%ebp),%edx
119fa2: 31 f0 xor %esi,%eax
119fa4: 09 c2 or %eax,%edx
119fa6: 8b 55 cc mov -0x34(%ebp),%edx
119fa9: 75 2e jne 119fd9 <msdos_file_ftruncate+0xe9> <== NEVER TAKEN
fat_fd->flags |= FAT_FILE_META_DATA_CHANGED;
119fab: 80 4b 30 02 orb $0x2,0x30(%ebx)
fat_fd->fat_file_size = s;
119faf: 89 73 18 mov %esi,0x18(%ebx)
fat_file_set_ctime_mtime(fat_fd, time(NULL));
119fb2: c7 04 24 00 00 00 00 movl $0x0,(%esp)
119fb9: 89 4d d4 mov %ecx,-0x2c(%ebp)
119fbc: e8 bf 1c 01 00 call 12bc80 <time>
fat_fd->flags |= FAT_FILE_META_DATA_CHANGED;
119fc1: 8b 4d d4 mov -0x2c(%ebp),%ecx
119fc4: 80 4b 30 02 orb $0x2,0x30(%ebx)
fat_fd->ctime = t;
119fc8: 89 43 40 mov %eax,0x40(%ebx)
119fcb: 89 53 44 mov %edx,0x44(%ebx)
fat_fd->mtime = t;
119fce: 89 43 48 mov %eax,0x48(%ebx)
119fd1: 89 53 4c mov %edx,0x4c(%ebx)
}
119fd4: e9 72 ff ff ff jmp 119f4b <msdos_file_ftruncate+0x5b>
fat_file_truncate(&fs_info->fat, fat_fd, old_length);
119fd9: 89 54 24 08 mov %edx,0x8(%esp) <== NOT EXECUTED
119fdd: 8b 45 d0 mov -0x30(%ebp),%eax <== NOT EXECUTED
119fe0: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
119fe4: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
119fe7: e8 64 68 ff ff call 110850 <fat_file_truncate> <== NOT EXECUTED
errno = ENOSPC;
119fec: e8 af c8 00 00 call 1268a0 <__errno> <== NOT EXECUTED
rc = -1;
119ff1: b9 ff ff ff ff mov $0xffffffff,%ecx <== NOT EXECUTED
errno = ENOSPC;
119ff6: c7 00 1c 00 00 00 movl $0x1c,(%eax) <== NOT EXECUTED
if (rc == RC_OK)
119ffc: e9 4a ff ff ff jmp 119f4b <msdos_file_ftruncate+0x5b> <== NOT EXECUTED
11a001: 90 nop
11a002: 90 nop
11a003: 90 nop
11a004: 90 nop
11a005: 90 nop
11a006: 90 nop
11a007: 90 nop
11a008: 90 nop
11a009: 90 nop
11a00a: 90 nop
11a00b: 90 nop
11a00c: 90 nop
11a00d: 90 nop
11a00e: 90 nop
11a00f: 90 nop
00119cc0 <msdos_file_read>:
* the number of bytes read on success, or -1 if error occured (errno set
* appropriately)
*/
ssize_t
msdos_file_read(rtems_libio_t *iop, void *buffer, size_t count)
{
119cc0: 55 push %ebp
119cc1: 89 e5 mov %esp,%ebp
119cc3: 83 ec 48 sub $0x48,%esp
119cc6: 89 75 f8 mov %esi,-0x8(%ebp)
119cc9: 8b 75 08 mov 0x8(%ebp),%esi
119ccc: 89 5d f4 mov %ebx,-0xc(%ebp)
119ccf: 89 7d fc mov %edi,-0x4(%ebp)
ssize_t ret = 0;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
119cd2: 8b 46 20 mov 0x20(%esi),%eax
119cd5: 8b 58 08 mov 0x8(%eax),%ebx
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
119cd8: 8b 46 14 mov 0x14(%esi),%eax
119cdb: 8d bb ac 00 00 00 lea 0xac(%ebx),%edi
_Mutex_recursive_Acquire( mutex );
119ce1: 89 3c 24 mov %edi,(%esp)
119ce4: 89 45 e4 mov %eax,-0x1c(%ebp)
119ce7: e8 14 00 ff ff call 109d00 <_Mutex_recursive_Acquire>
msdos_fs_lock(fs_info);
ret = fat_file_read(&fs_info->fat, fat_fd, iop->offset, count,
119cec: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED
119cef: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED
119cf2: 89 54 24 10 mov %edx,0x10(%esp) <== NOT EXECUTED
119cf6: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED
119cf9: 89 54 24 0c mov %edx,0xc(%esp) <== NOT EXECUTED
119cfd: 8b 56 04 mov 0x4(%esi),%edx <== NOT EXECUTED
119d00: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
119d03: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
119d07: 89 54 24 08 mov %edx,0x8(%esp) <== NOT EXECUTED
119d0b: e8 50 69 ff ff call 110660 <fat_file_read> <== NOT EXECUTED
buffer);
if (ret > 0)
119d10: 85 c0 test %eax,%eax
ret = fat_file_read(&fs_info->fat, fat_fd, iop->offset, count,
119d12: 89 c3 mov %eax,%ebx
if (ret > 0)
119d14: 7e 07 jle 119d1d <msdos_file_read+0x5d>
iop->offset += ret;
119d16: 99 cltd
119d17: 01 46 04 add %eax,0x4(%esi)
119d1a: 11 56 08 adc %edx,0x8(%esi)
_Mutex_recursive_Release( mutex );
119d1d: 89 3c 24 mov %edi,(%esp)
119d20: e8 5b 00 ff ff call 109d80 <_Mutex_recursive_Release>
msdos_fs_unlock(fs_info);
return ret;
}
119d25: 8b 75 f8 mov -0x8(%ebp),%esi
119d28: 89 d8 mov %ebx,%eax
119d2a: 8b 7d fc mov -0x4(%ebp),%edi
119d2d: 8b 5d f4 mov -0xc(%ebp),%ebx
119d30: 89 ec mov %ebp,%esp
119d32: 5d pop %ebp
119d33: c3 ret
119d34: 90 nop
119d35: 90 nop
119d36: 90 nop
119d37: 90 nop
119d38: 90 nop
119d39: 90 nop
119d3a: 90 nop
119d3b: 90 nop
119d3c: 90 nop
119d3d: 90 nop
119d3e: 90 nop
119d3f: 90 nop
0011a010 <msdos_file_sync>:
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
int
msdos_file_sync(rtems_libio_t *iop)
{
11a010: 55 push %ebp
11a011: 89 e5 mov %esp,%ebp
11a013: 83 ec 28 sub $0x28,%esp
11a016: 89 75 f8 mov %esi,-0x8(%ebp)
11a019: 8b 45 08 mov 0x8(%ebp),%eax
11a01c: 89 5d f4 mov %ebx,-0xc(%ebp)
11a01f: 89 7d fc mov %edi,-0x4(%ebp)
int rc = RC_OK;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
11a022: 8b 50 20 mov 0x20(%eax),%edx
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
11a025: 8b 58 14 mov 0x14(%eax),%ebx
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
11a028: 8b 72 08 mov 0x8(%edx),%esi
11a02b: 8d be ac 00 00 00 lea 0xac(%esi),%edi
_Mutex_recursive_Acquire( mutex );
11a031: 89 3c 24 mov %edi,(%esp)
11a034: e8 c7 fc fe ff call 109d00 <_Mutex_recursive_Acquire>
msdos_fs_lock(fs_info);
rc = fat_file_update(&fs_info->fat, fat_fd);
11a039: 89 5c 24 04 mov %ebx,0x4(%esp)
11a03d: 89 34 24 mov %esi,(%esp)
11a040: e8 9b 65 ff ff call 1105e0 <fat_file_update>
if (rc != RC_OK)
11a045: 85 c0 test %eax,%eax
rc = fat_file_update(&fs_info->fat, fat_fd);
11a047: 89 c3 mov %eax,%ebx
if (rc != RC_OK)
11a049: 75 08 jne 11a053 <msdos_file_sync+0x43> <== NEVER TAKEN
{
msdos_fs_unlock(fs_info);
return rc;
}
rc = fat_sync(&fs_info->fat);
11a04b: 89 34 24 mov %esi,(%esp)
11a04e: e8 cd 56 ff ff call 10f720 <fat_sync>
_Mutex_recursive_Release( mutex );
11a053: 89 3c 24 mov %edi,(%esp)
11a056: e8 25 fd fe ff call 109d80 <_Mutex_recursive_Release>
msdos_fs_unlock(fs_info);
return RC_OK;
}
11a05b: 8b 75 f8 mov -0x8(%ebp),%esi
11a05e: 89 d8 mov %ebx,%eax
11a060: 8b 7d fc mov -0x4(%ebp),%edi
11a063: 8b 5d f4 mov -0xc(%ebp),%ebx
11a066: 89 ec mov %ebp,%esp
11a068: 5d pop %ebp
11a069: c3 ret
11a06a: 90 nop
11a06b: 90 nop
11a06c: 90 nop
11a06d: 90 nop
11a06e: 90 nop
11a06f: 90 nop
00119d40 <msdos_file_write>:
* the number of bytes written on success, or -1 if error occured
* and errno set appropriately
*/
ssize_t
msdos_file_write(rtems_libio_t *iop,const void *buffer, size_t count)
{
119d40: 55 push %ebp
119d41: 89 e5 mov %esp,%ebp
119d43: 57 push %edi
119d44: 56 push %esi
119d45: 53 push %ebx
119d46: 83 ec 3c sub $0x3c,%esp
119d49: 8b 7d 08 mov 0x8(%ebp),%edi
ssize_t ret = 0;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
119d4c: 8b 47 20 mov 0x20(%edi),%eax
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
119d4f: 8b 5f 14 mov 0x14(%edi),%ebx
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
119d52: 8b 70 08 mov 0x8(%eax),%esi
119d55: 8d 86 ac 00 00 00 lea 0xac(%esi),%eax
_Mutex_recursive_Acquire( mutex );
119d5b: 89 04 24 mov %eax,(%esp)
119d5e: 89 45 dc mov %eax,-0x24(%ebp)
119d61: e8 9a ff fe ff call 109d00 <_Mutex_recursive_Acquire>
119d66: 8b 07 mov (%edi),%eax
msdos_fs_lock(fs_info);
if (rtems_libio_iop_is_append(iop))
119d68: f6 c4 02 test $0x2,%ah
119d6b: 75 73 jne 119de0 <msdos_file_write+0xa0>
iop->offset = fat_fd->fat_file_size;
ret = fat_file_write(&fs_info->fat, fat_fd, iop->offset, count,
119d6d: 8b 47 04 mov 0x4(%edi),%eax <== NOT EXECUTED
119d70: 89 34 24 mov %esi,(%esp)
119d73: 8b 55 0c mov 0xc(%ebp),%edx
119d76: 89 44 24 08 mov %eax,0x8(%esp)
119d7a: 89 5c 24 04 mov %ebx,0x4(%esp)
119d7e: 89 54 24 10 mov %edx,0x10(%esp)
119d82: 8b 55 10 mov 0x10(%ebp),%edx
119d85: 89 54 24 0c mov %edx,0xc(%esp)
119d89: e8 02 70 ff ff call 110d90 <fat_file_write>
buffer);
if (ret < 0)
119d8e: 85 c0 test %eax,%eax
ret = fat_file_write(&fs_info->fat, fat_fd, iop->offset, count,
119d90: 89 c6 mov %eax,%esi
if (ret < 0)
119d92: 0f 88 81 00 00 00 js 119e19 <msdos_file_write+0xd9>
/*
* update file size in both fat-file descriptor and file control block if
* file was extended
*/
iop->offset += ret;
119d98: 99 cltd
119d99: 03 47 04 add 0x4(%edi),%eax
119d9c: 13 57 08 adc 0x8(%edi),%edx
119d9f: 89 45 e0 mov %eax,-0x20(%ebp)
119da2: 89 47 04 mov %eax,0x4(%edi)
if (iop->offset > fat_fd->fat_file_size)
119da5: 8b 4d e0 mov -0x20(%ebp),%ecx
iop->offset += ret;
119da8: 89 55 e4 mov %edx,-0x1c(%ebp)
119dab: 89 57 08 mov %edx,0x8(%edi)
if (iop->offset > fat_fd->fat_file_size)
119dae: 31 d2 xor %edx,%edx
119db0: 39 4b 18 cmp %ecx,0x18(%ebx)
119db3: 89 d0 mov %edx,%eax
119db5: 8b 4d e4 mov -0x1c(%ebp),%ecx
119db8: 8b 55 e0 mov -0x20(%ebp),%edx
119dbb: 19 c8 sbb %ecx,%eax
119dbd: 7c 31 jl 119df0 <msdos_file_write+0xb0>
fat_file_set_file_size(fat_fd, (uint32_t) iop->offset);
if (ret > 0)
119dbf: 85 f6 test %esi,%esi
119dc1: 75 38 jne 119dfb <msdos_file_write+0xbb> <== ALWAYS TAKEN
_Mutex_recursive_Release( mutex );
119dc3: 8b 45 dc mov -0x24(%ebp),%eax
119dc6: 89 04 24 mov %eax,(%esp)
119dc9: e8 b2 ff fe ff call 109d80 <_Mutex_recursive_Release>
fat_file_set_ctime_mtime(fat_fd, time(NULL));
msdos_fs_unlock(fs_info);
return ret;
}
119dce: 83 c4 3c add $0x3c,%esp
119dd1: 89 f0 mov %esi,%eax
119dd3: 5b pop %ebx
119dd4: 5e pop %esi
119dd5: 5f pop %edi
119dd6: 5d pop %ebp
119dd7: c3 ret
119dd8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
119ddf: 90 nop
iop->offset = fat_fd->fat_file_size;
119de0: 8b 43 18 mov 0x18(%ebx),%eax
119de3: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi)
119dea: 89 47 04 mov %eax,0x4(%edi)
119ded: eb 81 jmp 119d70 <msdos_file_write+0x30>
119def: 90 nop
fat_fd->flags |= FAT_FILE_META_DATA_CHANGED;
119df0: 80 4b 30 02 orb $0x2,0x30(%ebx)
if (ret > 0)
119df4: 85 f6 test %esi,%esi
fat_file_set_file_size(fat_fd, (uint32_t) iop->offset);
119df6: 89 53 18 mov %edx,0x18(%ebx)
if (ret > 0)
119df9: 74 c8 je 119dc3 <msdos_file_write+0x83> <== NEVER TAKEN
fat_file_set_ctime_mtime(fat_fd, time(NULL));
119dfb: c7 04 24 00 00 00 00 movl $0x0,(%esp)
119e02: e8 79 1e 01 00 call 12bc80 <time>
fat_fd->flags |= FAT_FILE_META_DATA_CHANGED;
119e07: 80 4b 30 02 orb $0x2,0x30(%ebx)
fat_fd->ctime = t;
119e0b: 89 43 40 mov %eax,0x40(%ebx)
119e0e: 89 53 44 mov %edx,0x44(%ebx)
fat_fd->mtime = t;
119e11: 89 43 48 mov %eax,0x48(%ebx)
119e14: 89 53 4c mov %edx,0x4c(%ebx)
}
119e17: eb aa jmp 119dc3 <msdos_file_write+0x83>
119e19: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED
return -1;
119e1c: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED
119e21: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
119e24: e8 57 ff fe ff call 109d80 <_Mutex_recursive_Release> <== NOT EXECUTED
119e29: eb a3 jmp 119dce <msdos_file_write+0x8e>
119e2b: 90 nop
119e2c: 90 nop
119e2d: 90 nop
119e2e: 90 nop
119e2f: 90 nop
00118d40 <msdos_filename_utf8_to_long_name_for_compare>:
rtems_dosfs_convert_control *converter,
const uint8_t *utf8_name,
const size_t utf8_name_size,
uint8_t *long_name,
const size_t long_name_size)
{
118d40: 55 push %ebp
118d41: 89 e5 mov %esp,%ebp
118d43: 83 ec 38 sub $0x38,%esp
118d46: 89 5d fc mov %ebx,-0x4(%ebp)
118d49: 8b 4d 0c mov 0xc(%ebp),%ecx
118d4c: 8b 45 18 mov 0x18(%ebp),%eax
118d4f: 8b 55 10 mov 0x10(%ebp),%edx
if ( src_name[0] == UTF8_FULL_STOP
118d52: 80 39 2e cmpb $0x2e,(%ecx)
ssize_t returned_size = 0;
int eno = 0;
size_t name_size;
size_t dest_size = long_name_size;
118d55: 89 45 f4 mov %eax,-0xc(%ebp)
if ( src_name[0] == UTF8_FULL_STOP
118d58: 74 66 je 118dc0 <msdos_filename_utf8_to_long_name_for_compare+0x80><== NEVER TAKEN
for ( i = size_returned - UTF8_FULL_STOP_SIZE;
118d5a: 85 d2 test %edx,%edx
ssize_t size_returned = filename_size;
118d5c: 89 d0 mov %edx,%eax
for ( i = size_returned - UTF8_FULL_STOP_SIZE;
118d5e: 7f 53 jg 118db3 <msdos_filename_utf8_to_long_name_for_compare+0x73><== ALWAYS TAKEN
if (returned_size == 0) {
name_size = msdos_filename_delete_trailing_dots (
&utf8_name[0],
utf8_name_size);
if (name_size > 0) {
118d60: 0f 84 9a 00 00 00 je 118e00 <msdos_filename_utf8_to_long_name_for_compare+0xc0><== NOT EXECUTED
eno = (*converter->handler->utf8_normalize_and_fold) (
118d66: 8b 45 08 mov 0x8(%ebp),%eax
118d69: 8d 5d f4 lea -0xc(%ebp),%ebx
118d6c: 8b 00 mov (%eax),%eax
118d6e: 89 5c 24 10 mov %ebx,0x10(%esp)
118d72: 8b 5d 14 mov 0x14(%ebp),%ebx
118d75: 89 54 24 08 mov %edx,0x8(%esp)
118d79: 89 4c 24 04 mov %ecx,0x4(%esp)
118d7d: 89 5c 24 0c mov %ebx,0xc(%esp)
118d81: 8b 5d 08 mov 0x8(%ebp),%ebx
118d84: 89 1c 24 mov %ebx,(%esp)
118d87: ff 50 10 call *0x10(%eax)
converter,
utf8_name,
name_size,
long_name,
&dest_size);
if (eno == 0) {
118d8a: 85 c0 test %eax,%eax
eno = (*converter->handler->utf8_normalize_and_fold) (
118d8c: 89 c3 mov %eax,%ebx
if (eno == 0) {
118d8e: 74 60 je 118df0 <msdos_filename_utf8_to_long_name_for_compare+0xb0><== ALWAYS TAKEN
eno = EINVAL;
}
}
if ( eno != 0 ) {
errno = eno;
118d90: e8 0b db 00 00 call 1268a0 <__errno> <== NOT EXECUTED
118d95: 89 18 mov %ebx,(%eax) <== NOT EXECUTED
returned_size = -1;
118d97: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
}
return returned_size;
}
118d9c: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
118d9f: 89 ec mov %ebp,%esp <== NOT EXECUTED
118da1: 5d pop %ebp <== NOT EXECUTED
118da2: c3 ret <== NOT EXECUTED
118da3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
118daa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
for ( i = size_returned - UTF8_FULL_STOP_SIZE;
118db0: 48 dec %eax
118db1: 74 4d je 118e00 <msdos_filename_utf8_to_long_name_for_compare+0xc0><== NEVER TAKEN
&& filename_utf8[i] == UTF8_FULL_STOP;) {
118db3: 80 7c 01 ff 2e cmpb $0x2e,-0x1(%ecx,%eax,1)
118db8: 89 c2 mov %eax,%edx
118dba: 74 f4 je 118db0 <msdos_filename_utf8_to_long_name_for_compare+0x70>
118dbc: eb a8 jmp 118d66 <msdos_filename_utf8_to_long_name_for_compare+0x26>
118dbe: 66 90 xchg %ax,%ax
&& src_size == UTF8_FULL_STOP_SIZE) {
118dc0: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED
118dc3: 74 4b je 118e10 <msdos_filename_utf8_to_long_name_for_compare+0xd0><== NOT EXECUTED
&& src_size == ( 2 * UTF8_FULL_STOP_SIZE ) ) {
118dc5: 80 79 01 2e cmpb $0x2e,0x1(%ecx) <== NOT EXECUTED
118dc9: 75 8f jne 118d5a <msdos_filename_utf8_to_long_name_for_compare+0x1a><== NOT EXECUTED
118dcb: 83 fa 02 cmp $0x2,%edx <== NOT EXECUTED
118dce: 75 8a jne 118d5a <msdos_filename_utf8_to_long_name_for_compare+0x1a><== NOT EXECUTED
if (dest_size >= 2 * UTF8_FULL_STOP_SIZE) {
118dd0: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED
118dd3: 76 51 jbe 118e26 <msdos_filename_utf8_to_long_name_for_compare+0xe6><== NOT EXECUTED
dest_name[0] = UTF8_FULL_STOP;
118dd5: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED
118dd8: 66 c7 00 2e 2e movw $0x2e2e,(%eax) <== NOT EXECUTED
returned_size = 2 * UTF8_FULL_STOP_SIZE;
118ddd: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED
118de2: eb b8 jmp 118d9c <msdos_filename_utf8_to_long_name_for_compare+0x5c><== NOT EXECUTED
118de4: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
118deb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
118def: 90 nop <== NOT EXECUTED
returned_size = (ssize_t)dest_size;
118df0: 8b 45 f4 mov -0xc(%ebp),%eax
}
118df3: 8b 5d fc mov -0x4(%ebp),%ebx
118df6: 89 ec mov %ebp,%esp
118df8: 5d pop %ebp
118df9: c3 ret
118dfa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
eno = EINVAL;
118e00: bb 16 00 00 00 mov $0x16,%ebx <== NOT EXECUTED
118e05: eb 89 jmp 118d90 <msdos_filename_utf8_to_long_name_for_compare+0x50><== NOT EXECUTED
118e07: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
118e0e: 66 90 xchg %ax,%ax <== NOT EXECUTED
if (dest_size >= UTF8_FULL_STOP_SIZE) {
118e10: 85 c0 test %eax,%eax <== NOT EXECUTED
118e12: 74 12 je 118e26 <msdos_filename_utf8_to_long_name_for_compare+0xe6><== NOT EXECUTED
dest_name[0] = UTF8_FULL_STOP;
118e14: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED
118e17: c6 00 2e movb $0x2e,(%eax) <== NOT EXECUTED
returned_size = UTF8_FULL_STOP_SIZE;
118e1a: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
}
118e1f: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
118e22: 89 ec mov %ebp,%esp <== NOT EXECUTED
118e24: 5d pop %ebp <== NOT EXECUTED
118e25: c3 ret <== NOT EXECUTED
errno = eno;
118e26: e8 75 da 00 00 call 1268a0 <__errno> <== NOT EXECUTED
118e2b: c7 00 5b 00 00 00 movl $0x5b,(%eax) <== NOT EXECUTED
118e31: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
118e36: e9 61 ff ff ff jmp 118d9c <msdos_filename_utf8_to_long_name_for_compare+0x5c><== NOT EXECUTED
118e3b: 90 nop
118e3c: 90 nop
118e3d: 90 nop
118e3e: 90 nop
118e3f: 90 nop
00118e40 <msdos_filename_utf8_to_long_name_for_save>:
rtems_dosfs_convert_control *converter,
const uint8_t *utf8_name,
const size_t utf8_name_size,
uint16_t *long_name,
const size_t long_name_size)
{
118e40: 55 push %ebp
118e41: 89 e5 mov %esp,%ebp
118e43: 57 push %edi
118e44: 56 push %esi
118e45: 53 push %ebx
118e46: 83 ec 3c sub $0x3c,%esp
118e49: 8b 45 10 mov 0x10(%ebp),%eax
size_t name_size_tmp;
int i;
uint16_t c;
unsigned int chars_written;
name_size_tmp = long_name_size;
118e4c: 8b 7d 18 mov 0x18(%ebp),%edi
{
118e4f: 8b 4d 08 mov 0x8(%ebp),%ecx
118e52: 8b 55 0c mov 0xc(%ebp),%edx
for ( i = size_returned - UTF8_FULL_STOP_SIZE;
118e55: 85 c0 test %eax,%eax
118e57: 89 c3 mov %eax,%ebx
name_size_tmp = long_name_size;
118e59: 89 7d e4 mov %edi,-0x1c(%ebp)
for ( i = size_returned - UTF8_FULL_STOP_SIZE;
118e5c: 7f 19 jg 118e77 <msdos_filename_utf8_to_long_name_for_save+0x37><== ALWAYS TAKEN
118e5e: e9 94 00 00 00 jmp 118ef7 <msdos_filename_utf8_to_long_name_for_save+0xb7><== NOT EXECUTED
118e63: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
118e6a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
118e70: 4b dec %ebx
118e71: 0f 84 29 01 00 00 je 118fa0 <msdos_filename_utf8_to_long_name_for_save+0x160><== NEVER TAKEN
&& filename_utf8[i] == UTF8_FULL_STOP;) {
118e77: 80 7c 1a ff 2e cmpb $0x2e,-0x1(%edx,%ebx,1)
118e7c: 89 d8 mov %ebx,%eax
118e7e: 66 90 xchg %ax,%ax
118e80: 74 ee je 118e70 <msdos_filename_utf8_to_long_name_for_save+0x30>
utf8_name_size);
if (name_size > 0) {
/*
* Finally convert from UTF-8 to UTF-16
*/
eno = (*converter->handler->utf8_to_utf16) (
118e82: 8b 7d 14 mov 0x14(%ebp),%edi
118e85: 8d 75 e4 lea -0x1c(%ebp),%esi
118e88: 8b 19 mov (%ecx),%ebx
118e8a: 89 74 24 10 mov %esi,0x10(%esp)
118e8e: 89 44 24 08 mov %eax,0x8(%esp)
118e92: 89 7c 24 0c mov %edi,0xc(%esp)
118e96: 89 54 24 04 mov %edx,0x4(%esp)
118e9a: 89 0c 24 mov %ecx,(%esp)
118e9d: ff 53 08 call *0x8(%ebx)
converter,
utf8_name,
name_size,
&long_name[0],
&name_size_tmp);
if (eno == 0) {
118ea0: 85 c0 test %eax,%eax
eno = (*converter->handler->utf8_to_utf16) (
118ea2: 89 c3 mov %eax,%ebx
if (eno == 0) {
118ea4: 0f 85 bb 00 00 00 jne 118f65 <msdos_filename_utf8_to_long_name_for_save+0x125><== NEVER TAKEN
if (name_size_tmp <= (MSDOS_NAME_MAX_LNF_LEN * MSDOS_NAME_LFN_BYTES_PER_CHAR))
118eaa: 8b 4d e4 mov -0x1c(%ebp),%ecx
118ead: 81 f9 fe 01 00 00 cmp $0x1fe,%ecx
118eb3: 0f 87 a7 00 00 00 ja 118f60 <msdos_filename_utf8_to_long_name_for_save+0x120>
if ( eno == 0 )
{
/*
* Validate the characters and assign them to the UTF-16 file name
*/
for ( i = 0;
118eb9: 85 c9 test %ecx,%ecx
118ebb: 8b 55 14 mov 0x14(%ebp),%edx
118ebe: b8 fe ff ff ff mov $0xfffffffe,%eax
118ec3: 74 75 je 118f3a <msdos_filename_utf8_to_long_name_for_save+0xfa><== NEVER TAKEN
118ec5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
118ecc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
name_size
&& (c = msdos_get_valid_utf16_filename_character ( long_name[i]) );
118ed0: 0f b7 02 movzwl (%edx),%eax
if ( char_num <= 0x00ff ) {
118ed3: 3d ff 00 00 00 cmp $0xff,%eax
118ed8: 77 4a ja 118f24 <msdos_filename_utf8_to_long_name_for_save+0xe4>
switch ( char_num )
118eda: 83 f8 5d cmp $0x5d,%eax
118edd: 77 31 ja 118f10 <msdos_filename_utf8_to_long_name_for_save+0xd0>
118edf: 83 f8 2a cmp $0x2a,%eax
118ee2: 76 35 jbe 118f19 <msdos_filename_utf8_to_long_name_for_save+0xd9>
118ee4: 8d 70 d5 lea -0x2b(%eax),%esi
118ee7: 66 83 fe 32 cmp $0x32,%si
118eeb: 0f b7 fe movzwl %si,%edi
118eee: 77 29 ja 118f19 <msdos_filename_utf8_to_long_name_for_save+0xd9><== NEVER TAKEN
118ef0: ff 24 bd 48 39 13 00 jmp *0x133948(,%edi,4)
if (name_size > 0) {
118ef7: 75 89 jne 118e82 <msdos_filename_utf8_to_long_name_for_save+0x42><== NOT EXECUTED
118ef9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
118f00: e9 9b 00 00 00 jmp 118fa0 <msdos_filename_utf8_to_long_name_for_save+0x160><== NOT EXECUTED
118f05: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
118f0c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
switch ( char_num )
118f10: 8d 70 9f lea -0x61(%eax),%esi
118f13: 66 83 fe 19 cmp $0x19,%si
118f17: 76 0b jbe 118f24 <msdos_filename_utf8_to_long_name_for_save+0xe4>
retval = codepage_valid_char_map[char_num];
118f19: 0f b6 80 20 3a 13 00 movzbl 0x133a20(%eax),%eax
&& (c = msdos_get_valid_utf16_filename_character ( long_name[i]) );
118f20: 85 c0 test %eax,%eax
118f22: 74 2c je 118f50 <msdos_filename_utf8_to_long_name_for_save+0x110>
++i ) {
long_name[i] = c;
118f24: 66 89 02 mov %ax,(%edx)
returned_size += MSDOS_NAME_LFN_BYTES_PER_CHAR;
118f27: 83 c3 02 add $0x2,%ebx
for ( i = 0;
118f2a: 83 c2 02 add $0x2,%edx
118f2d: 83 e9 02 sub $0x2,%ecx
118f30: 75 9e jne 118ed0 <msdos_filename_utf8_to_long_name_for_save+0x90>
long_name[i] = c;
returned_size += MSDOS_NAME_LFN_BYTES_PER_CHAR;
}
else if ( name_size != 0 )
eno = EINVAL;
chars_written = returned_size / MSDOS_NAME_LFN_BYTES_PER_CHAR;
118f32: 89 d9 mov %ebx,%ecx
118f34: d1 f9 sar %ecx
if ( long_name [chars_written - 1] != UTF16_NULL
118f36: 8d 44 09 fe lea -0x2(%ecx,%ecx,1),%eax
118f3a: 8b 7d 14 mov 0x14(%ebp),%edi
118f3d: 66 83 3c 07 00 cmpw $0x0,(%edi,%eax,1)
118f42: 75 63 jne 118fa7 <msdos_filename_utf8_to_long_name_for_save+0x167><== ALWAYS TAKEN
errno = eno;
returned_size = -1;
}
return returned_size;
}
118f44: 83 c4 3c add $0x3c,%esp
118f47: 89 d8 mov %ebx,%eax
118f49: 5b pop %ebx
118f4a: 5e pop %esi
118f4b: 5f pop %edi
118f4c: 5d pop %ebp
118f4d: c3 ret
118f4e: 66 90 xchg %ax,%ax
if ( name_size == UTF16_NULL_SIZE && c == UTF16_NULL ) {
118f50: 83 f9 02 cmp $0x2,%ecx
118f53: 75 1e jne 118f73 <msdos_filename_utf8_to_long_name_for_save+0x133><== ALWAYS TAKEN
long_name[i] = c;
118f55: 66 c7 02 00 00 movw $0x0,(%edx) <== NOT EXECUTED
returned_size += MSDOS_NAME_LFN_BYTES_PER_CHAR;
118f5a: 83 c3 02 add $0x2,%ebx <== NOT EXECUTED
118f5d: eb d3 jmp 118f32 <msdos_filename_utf8_to_long_name_for_save+0xf2><== NOT EXECUTED
118f5f: 90 nop <== NOT EXECUTED
eno = ENAMETOOLONG;
118f60: bb 5b 00 00 00 mov $0x5b,%ebx
errno = eno;
118f65: e8 36 d9 00 00 call 1268a0 <__errno>
118f6a: 89 18 mov %ebx,(%eax)
returned_size = -1;
118f6c: bb ff ff ff ff mov $0xffffffff,%ebx
return returned_size;
118f71: eb d1 jmp 118f44 <msdos_filename_utf8_to_long_name_for_save+0x104>
if ( long_name [chars_written - 1] != UTF16_NULL
118f73: 8b 7d 14 mov 0x14(%ebp),%edi
chars_written = returned_size / MSDOS_NAME_LFN_BYTES_PER_CHAR;
118f76: 89 d8 mov %ebx,%eax
118f78: d1 f8 sar %eax
if ( long_name [chars_written - 1] != UTF16_NULL
118f7a: 66 83 7c 47 fe 00 cmpw $0x0,-0x2(%edi,%eax,2)
118f80: 74 1e je 118fa0 <msdos_filename_utf8_to_long_name_for_save+0x160><== NEVER TAKEN
&& (returned_size + UTF16_NULL_SIZE ) <= long_name_size ) {
118f82: 83 c3 02 add $0x2,%ebx
118f85: 3b 5d 18 cmp 0x18(%ebp),%ebx
118f88: 77 16 ja 118fa0 <msdos_filename_utf8_to_long_name_for_save+0x160><== NEVER TAKEN
long_name[chars_written] = UTF16_NULL;
118f8a: 8b 7d 14 mov 0x14(%ebp),%edi
118f8d: 66 c7 04 47 00 00 movw $0x0,(%edi,%eax,2)
118f93: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
118f9a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
eno = EINVAL;
118fa0: bb 16 00 00 00 mov $0x16,%ebx
118fa5: eb be jmp 118f65 <msdos_filename_utf8_to_long_name_for_save+0x125>
&& (returned_size + UTF16_NULL_SIZE ) <= long_name_size ) {
118fa7: 8d 43 02 lea 0x2(%ebx),%eax
118faa: 3b 45 18 cmp 0x18(%ebp),%eax
118fad: 77 95 ja 118f44 <msdos_filename_utf8_to_long_name_for_save+0x104><== NEVER TAKEN
long_name[chars_written] = UTF16_NULL;
118faf: 8b 45 14 mov 0x14(%ebp),%eax
118fb2: 66 c7 04 48 00 00 movw $0x0,(%eax,%ecx,2)
if ( eno != 0 ) {
118fb8: eb 8a jmp 118f44 <msdos_filename_utf8_to_long_name_for_save+0x104>
118fba: 90 nop
118fbb: 90 nop
118fbc: 90 nop
118fbd: 90 nop
118fbe: 90 nop
118fbf: 90 nop
00118fc0 <msdos_filename_utf8_to_short_name_for_compare>:
rtems_dosfs_convert_control *converter,
const uint8_t *utf8_name,
const size_t utf8_name_size,
void *short_name,
const size_t short_name_size)
{
118fc0: 55 push %ebp
118fc1: 89 e5 mov %esp,%ebp
118fc3: 57 push %edi
118fc4: 56 push %esi
118fc5: 83 ec 60 sub $0x60,%esp
int eno = 0;
const uint8_t *name_ptr = utf8_name;
char *dest_ptr = (char*)short_name;
size_t name_size = utf8_name_size;
uint8_t name_normalized_buf[(MSDOS_SHORT_NAME_LEN +1) * MSDOS_NAME_MAX_UTF8_BYTES_PER_CHAR];
size_t name_size_tmp = sizeof(name_normalized_buf);
118fc8: c7 45 c4 30 00 00 00 movl $0x30,-0x3c(%ebp)
{
118fcf: 8b 55 0c mov 0xc(%ebp),%edx
118fd2: 8b 45 10 mov 0x10(%ebp),%eax
if ( src_name[0] == UTF8_FULL_STOP
118fd5: 80 3a 2e cmpb $0x2e,(%edx)
118fd8: 74 76 je 119050 <msdos_filename_utf8_to_short_name_for_compare+0x90>
while ( *name_size >= UTF8_FULL_STOP_SIZE
118fda: 85 c0 test %eax,%eax
118fdc: 75 22 jne 119000 <msdos_filename_utf8_to_short_name_for_compare+0x40><== ALWAYS TAKEN
if ( eno == 0 ) {
memcpy (&dest_ptr[0], &name_ptr[0], name_size);
returned_size = name_size;
}
} else
eno = EINVAL;
118fde: bf 16 00 00 00 mov $0x16,%edi <== NOT EXECUTED
}
if ( eno != 0 ) {
errno = eno;
118fe3: e8 b8 d8 00 00 call 1268a0 <__errno> <== NOT EXECUTED
118fe8: 89 38 mov %edi,(%eax) <== NOT EXECUTED
returned_size = -1;
118fea: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
}
return returned_size;
}
118fef: 83 c4 60 add $0x60,%esp
118ff2: 5e pop %esi
118ff3: 5f pop %edi
118ff4: 5d pop %ebp
118ff5: c3 ret
118ff6: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
118ffd: 8d 76 00 lea 0x0(%esi),%esi
eno = (*converter->handler->utf8_normalize_and_fold) (
119000: 8b 4d 08 mov 0x8(%ebp),%ecx
119003: 8d 75 c4 lea -0x3c(%ebp),%esi
119006: 8b 09 mov (%ecx),%ecx
119008: 89 44 24 08 mov %eax,0x8(%esp)
11900c: 8b 45 08 mov 0x8(%ebp),%eax
11900f: 89 74 24 10 mov %esi,0x10(%esp)
119013: 8d 75 c8 lea -0x38(%ebp),%esi
119016: 89 74 24 0c mov %esi,0xc(%esp)
11901a: 89 54 24 04 mov %edx,0x4(%esp)
11901e: 89 04 24 mov %eax,(%esp)
119021: ff 51 10 call *0x10(%ecx)
119024: 89 c7 mov %eax,%edi
name_size = name_size_tmp;
119026: 8b 45 c4 mov -0x3c(%ebp),%eax
if ( eno == ENOMEM ) {
119029: 83 ff 0c cmp $0xc,%edi
11902c: 74 04 je 119032 <msdos_filename_utf8_to_short_name_for_compare+0x72><== NEVER TAKEN
if ( eno == 0 ) {
11902e: 85 ff test %edi,%edi
119030: 75 b1 jne 118fe3 <msdos_filename_utf8_to_short_name_for_compare+0x23><== NEVER TAKEN
memcpy (&dest_ptr[0], &name_ptr[0], name_size);
119032: 83 f8 08 cmp $0x8,%eax
119035: 8b 7d 14 mov 0x14(%ebp),%edi
119038: 89 c1 mov %eax,%ecx
11903a: 73 44 jae 119080 <msdos_filename_utf8_to_short_name_for_compare+0xc0>
11903c: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
}
11903e: 83 c4 60 add $0x60,%esp
119041: 5e pop %esi
119042: 5f pop %edi
119043: 5d pop %ebp
119044: c3 ret
119045: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11904c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
&& src_size == UTF8_FULL_STOP_SIZE) {
119050: 83 f8 01 cmp $0x1,%eax
119053: 74 5b je 1190b0 <msdos_filename_utf8_to_short_name_for_compare+0xf0>
&& src_size == ( 2 * UTF8_FULL_STOP_SIZE ) ) {
119055: 80 7a 01 2e cmpb $0x2e,0x1(%edx)
119059: 75 05 jne 119060 <msdos_filename_utf8_to_short_name_for_compare+0xa0><== NEVER TAKEN
11905b: 83 f8 02 cmp $0x2,%eax
11905e: 74 69 je 1190c9 <msdos_filename_utf8_to_short_name_for_compare+0x109><== ALWAYS TAKEN
while ( *name_size >= UTF8_FULL_STOP_SIZE
119060: 85 c0 test %eax,%eax <== NOT EXECUTED
119062: 75 11 jne 119075 <msdos_filename_utf8_to_short_name_for_compare+0xb5><== NOT EXECUTED
119064: e9 75 ff ff ff jmp 118fde <msdos_filename_utf8_to_short_name_for_compare+0x1e><== NOT EXECUTED
119069: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
&& **name_utf8 == UTF8_FULL_STOP) {
119070: 80 3a 2e cmpb $0x2e,(%edx) <== NOT EXECUTED
119073: 75 8b jne 119000 <msdos_filename_utf8_to_short_name_for_compare+0x40><== NOT EXECUTED
*name_utf8 += UTF8_FULL_STOP_SIZE;
119075: 42 inc %edx <== NOT EXECUTED
while ( *name_size >= UTF8_FULL_STOP_SIZE
119076: 48 dec %eax <== NOT EXECUTED
119077: 75 f7 jne 119070 <msdos_filename_utf8_to_short_name_for_compare+0xb0><== NOT EXECUTED
119079: e9 60 ff ff ff jmp 118fde <msdos_filename_utf8_to_short_name_for_compare+0x1e><== NOT EXECUTED
11907e: 66 90 xchg %ax,%ax <== NOT EXECUTED
memcpy (&dest_ptr[0], &name_ptr[0], name_size);
119080: f7 c7 01 00 00 00 test $0x1,%edi
119086: 75 6b jne 1190f3 <msdos_filename_utf8_to_short_name_for_compare+0x133><== NEVER TAKEN
119088: f7 c7 02 00 00 00 test $0x2,%edi
11908e: 75 51 jne 1190e1 <msdos_filename_utf8_to_short_name_for_compare+0x121><== NEVER TAKEN
119090: f7 c7 04 00 00 00 test $0x4,%edi
119096: 74 a4 je 11903c <msdos_filename_utf8_to_short_name_for_compare+0x7c>
119098: 8b 16 mov (%esi),%edx
11909a: 83 c7 04 add $0x4,%edi
11909d: 83 c6 04 add $0x4,%esi
1190a0: 83 e9 04 sub $0x4,%ecx
1190a3: 89 57 fc mov %edx,-0x4(%edi)
1190a6: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
if ( eno != 0 ) {
1190a8: eb 94 jmp 11903e <msdos_filename_utf8_to_short_name_for_compare+0x7e>
1190aa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
if (dest_size >= UTF8_FULL_STOP_SIZE) {
1190b0: 8b 45 18 mov 0x18(%ebp),%eax
1190b3: 85 c0 test %eax,%eax
1190b5: 74 4b je 119102 <msdos_filename_utf8_to_short_name_for_compare+0x142><== NEVER TAKEN
dest_name[0] = UTF8_FULL_STOP;
1190b7: 8b 45 14 mov 0x14(%ebp),%eax
1190ba: c6 00 2e movb $0x2e,(%eax)
}
1190bd: 83 c4 60 add $0x60,%esp
returned_size = UTF8_FULL_STOP_SIZE;
1190c0: b8 01 00 00 00 mov $0x1,%eax
}
1190c5: 5e pop %esi
1190c6: 5f pop %edi
1190c7: 5d pop %ebp
1190c8: c3 ret
if (dest_size >= 2 * UTF8_FULL_STOP_SIZE) {
1190c9: 83 7d 18 01 cmpl $0x1,0x18(%ebp)
1190cd: 76 33 jbe 119102 <msdos_filename_utf8_to_short_name_for_compare+0x142><== NEVER TAKEN
dest_name[0] = UTF8_FULL_STOP;
1190cf: 8b 45 14 mov 0x14(%ebp),%eax
1190d2: 66 c7 00 2e 2e movw $0x2e2e,(%eax)
returned_size = 2 * UTF8_FULL_STOP_SIZE;
1190d7: b8 02 00 00 00 mov $0x2,%eax
1190dc: e9 0e ff ff ff jmp 118fef <msdos_filename_utf8_to_short_name_for_compare+0x2f>
memcpy (&dest_ptr[0], &name_ptr[0], name_size);
1190e1: 0f b7 16 movzwl (%esi),%edx <== NOT EXECUTED
1190e4: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
1190e7: 83 c6 02 add $0x2,%esi <== NOT EXECUTED
1190ea: 83 e9 02 sub $0x2,%ecx <== NOT EXECUTED
1190ed: 66 89 57 fe mov %dx,-0x2(%edi) <== NOT EXECUTED
1190f1: eb 9d jmp 119090 <msdos_filename_utf8_to_short_name_for_compare+0xd0><== NOT EXECUTED
1190f3: 0f b6 0e movzbl (%esi),%ecx <== NOT EXECUTED
1190f6: 8d 75 c9 lea -0x37(%ebp),%esi <== NOT EXECUTED
1190f9: 47 inc %edi <== NOT EXECUTED
1190fa: 88 4f ff mov %cl,-0x1(%edi) <== NOT EXECUTED
1190fd: 8d 48 ff lea -0x1(%eax),%ecx <== NOT EXECUTED
119100: eb 86 jmp 119088 <msdos_filename_utf8_to_short_name_for_compare+0xc8><== NOT EXECUTED
errno = eno;
119102: e8 99 d7 00 00 call 1268a0 <__errno> <== NOT EXECUTED
119107: c7 00 5b 00 00 00 movl $0x5b,(%eax) <== NOT EXECUTED
11910d: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
119112: e9 d8 fe ff ff jmp 118fef <msdos_filename_utf8_to_short_name_for_compare+0x2f><== NOT EXECUTED
119117: 90 nop
119118: 90 nop
119119: 90 nop
11911a: 90 nop
11911b: 90 nop
11911c: 90 nop
11911d: 90 nop
11911e: 90 nop
11911f: 90 nop
00119120 <msdos_filename_utf8_to_short_name_for_save>:
rtems_dosfs_convert_control *converter,
const uint8_t *utf8_name,
const size_t utf8_name_size,
void *short_name,
const size_t short_name_size)
{
119120: 55 push %ebp
119121: 89 e5 mov %esp,%ebp
119123: 57 push %edi
119124: 56 push %esi
119125: 53 push %ebx
119126: 83 ec 4c sub $0x4c,%esp
119129: 8b 55 0c mov 0xc(%ebp),%edx
11912c: 8b 45 10 mov 0x10(%ebp),%eax
11912f: 8b 7d 14 mov 0x14(%ebp),%edi
if ( src_name[0] == UTF8_FULL_STOP
119132: 80 3a 2e cmpb $0x2e,(%edx)
119135: 0f 84 a5 00 00 00 je 1191e0 <msdos_filename_utf8_to_short_name_for_save+0xc0><== NEVER TAKEN
while ( *name_size >= UTF8_FULL_STOP_SIZE
11913b: 85 c0 test %eax,%eax
11913d: 75 21 jne 119160 <msdos_filename_utf8_to_short_name_for_save+0x40><== ALWAYS TAKEN
else
eno = EINVAL;
}
if ( eno != 0 ) {
errno = eno;
11913f: e8 5c d7 00 00 call 1268a0 <__errno> <== NOT EXECUTED
return -1;
119144: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED
errno = eno;
119149: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
return -1;
11914f: e9 bd 01 00 00 jmp 119311 <msdos_filename_utf8_to_short_name_for_save+0x1f1><== NOT EXECUTED
119154: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11915b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11915f: 90 nop <== NOT EXECUTED
name_size_tmp = sizeof ( name_to_format_buf );
119160: c7 45 d8 0c 00 00 00 movl $0xc,-0x28(%ebp)
eno = (*converter->handler->utf8_to_codepage) (
119167: 8b 75 08 mov 0x8(%ebp),%esi
11916a: 8d 5d d8 lea -0x28(%ebp),%ebx
11916d: 8b 0e mov (%esi),%ecx
11916f: 89 5c 24 10 mov %ebx,0x10(%esp)
119173: 8d 5d dc lea -0x24(%ebp),%ebx
119176: 89 34 24 mov %esi,(%esp)
119179: 89 5c 24 0c mov %ebx,0xc(%esp)
11917d: 89 44 24 08 mov %eax,0x8(%esp)
119181: 89 54 24 04 mov %edx,0x4(%esp)
119185: ff 11 call *(%ecx)
name_size = name_size_tmp;
119187: 8b 45 d8 mov -0x28(%ebp),%eax
11918a: 89 45 d4 mov %eax,-0x2c(%ebp)
for (i = 0; i < name_size; ++i)
11918d: 8d 34 03 lea (%ebx,%eax,1),%esi
119190: 85 c0 test %eax,%eax
119192: 0f 84 18 02 00 00 je 1193b0 <msdos_filename_utf8_to_short_name_for_save+0x290><== NEVER TAKEN
119198: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11919f: 90 nop
name_to_format_buf[i] = toupper ( (unsigned char)(name_to_format_buf[i]) );
1191a0: 0f b6 0b movzbl (%ebx),%ecx
1191a3: 0f b6 81 e1 6a 13 00 movzbl 0x136ae1(%ecx),%eax
1191aa: 89 ca mov %ecx,%edx
1191ac: 24 03 and $0x3,%al
1191ae: 3c 02 cmp $0x2,%al
1191b0: 75 03 jne 1191b5 <msdos_filename_utf8_to_short_name_for_save+0x95>
1191b2: 80 ea 20 sub $0x20,%dl
1191b5: 88 13 mov %dl,(%ebx)
for (i = 0; i < name_size; ++i)
1191b7: 43 inc %ebx
1191b8: 39 f3 cmp %esi,%ebx
1191ba: 75 e4 jne 1191a0 <msdos_filename_utf8_to_short_name_for_save+0x80>
if ( 0x20 == *name_ptr )
1191bc: 0f b6 45 dc movzbl -0x24(%ebp),%eax
1191c0: 3c 20 cmp $0x20,%al
1191c2: 74 7c je 119240 <msdos_filename_utf8_to_short_name_for_save+0x120>
else if ( 0xE5 == *name_ptr )
1191c4: 3c e5 cmp $0xe5,%al
1191c6: 0f 84 d4 01 00 00 je 1193a0 <msdos_filename_utf8_to_short_name_for_save+0x280><== NEVER TAKEN
char c = codepage_valid_char_map[character];
1191cc: 0f b6 80 20 3a 13 00 movzbl 0x133a20(%eax),%eax
if (c == 0) {
1191d3: 84 c0 test %al,%al
1191d5: 0f 84 dc 01 00 00 je 1193b7 <msdos_filename_utf8_to_short_name_for_save+0x297>
dest_ptr[0] = msdos_get_valid_codepage_filename_character(*name_ptr);
1191db: 88 07 mov %al,(%edi)
1191dd: eb 64 jmp 119243 <msdos_filename_utf8_to_short_name_for_save+0x123>
1191df: 90 nop
&& src_size == UTF8_FULL_STOP_SIZE) {
1191e0: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED
1191e3: 0f 84 47 01 00 00 je 119330 <msdos_filename_utf8_to_short_name_for_save+0x210><== NOT EXECUTED
&& src_size == ( 2 * UTF8_FULL_STOP_SIZE ) ) {
1191e9: 80 7a 01 2e cmpb $0x2e,0x1(%edx) <== NOT EXECUTED
1191ed: 75 09 jne 1191f8 <msdos_filename_utf8_to_short_name_for_save+0xd8><== NOT EXECUTED
1191ef: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED
1191f2: 0f 84 c8 01 00 00 je 1193c0 <msdos_filename_utf8_to_short_name_for_save+0x2a0><== NOT EXECUTED
while ( *name_size >= UTF8_FULL_STOP_SIZE
1191f8: 85 c0 test %eax,%eax <== NOT EXECUTED
1191fa: 75 1d jne 119219 <msdos_filename_utf8_to_short_name_for_save+0xf9><== NOT EXECUTED
1191fc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
119200: e9 3a ff ff ff jmp 11913f <msdos_filename_utf8_to_short_name_for_save+0x1f><== NOT EXECUTED
119205: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11920c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
&& **name_utf8 == UTF8_FULL_STOP) {
119210: 80 3a 2e cmpb $0x2e,(%edx) <== NOT EXECUTED
119213: 0f 85 47 ff ff ff jne 119160 <msdos_filename_utf8_to_short_name_for_save+0x40><== NOT EXECUTED
*name_utf8 += UTF8_FULL_STOP_SIZE;
119219: 42 inc %edx <== NOT EXECUTED
while ( *name_size >= UTF8_FULL_STOP_SIZE
11921a: 48 dec %eax <== NOT EXECUTED
11921b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11921f: 90 nop <== NOT EXECUTED
119220: 75 ee jne 119210 <msdos_filename_utf8_to_short_name_for_save+0xf0><== NOT EXECUTED
errno = eno;
119222: e8 79 d6 00 00 call 1268a0 <__errno> <== NOT EXECUTED
return -1;
119227: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED
errno = eno;
11922c: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
return -1;
119232: e9 da 00 00 00 jmp 119311 <msdos_filename_utf8_to_short_name_for_save+0x1f1><== NOT EXECUTED
119237: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11923e: 66 90 xchg %ax,%ax <== NOT EXECUTED
dest_ptr[0] = '_';
119240: c6 07 5f movb $0x5f,(%edi)
--name_size;
119243: 8b 4d d4 mov -0x2c(%ebp),%ecx
++name_ptr;
119246: 8d 75 dd lea -0x23(%ebp),%esi
++returned_size;
119249: bb 01 00 00 00 mov $0x1,%ebx
--name_size;
11924e: 49 dec %ecx
for (i = 1; i <= 7 && name_size && *name_ptr != '.'; ++i) {
11924f: 85 c9 test %ecx,%ecx
119251: 74 33 je 119286 <msdos_filename_utf8_to_short_name_for_save+0x166>
119253: 0f b6 06 movzbl (%esi),%eax
119256: 3c 2e cmp $0x2e,%al
119258: 0f 84 b4 01 00 00 je 119412 <msdos_filename_utf8_to_short_name_for_save+0x2f2>
char c = codepage_valid_char_map[character];
11925e: 0f b6 80 20 3a 13 00 movzbl 0x133a20(%eax),%eax
if (c == 0) {
119265: 84 c0 test %al,%al
119267: 75 02 jne 11926b <msdos_filename_utf8_to_short_name_for_save+0x14b>
c = '_';
119269: b0 5f mov $0x5f,%al
dest_ptr[i] = msdos_get_valid_codepage_filename_character(*name_ptr);
11926b: 88 04 1f mov %al,(%edi,%ebx,1)
++name_ptr;
11926e: 8d 56 01 lea 0x1(%esi),%edx
++returned_size;
119271: 43 inc %ebx
--name_size;
119272: 8d 41 ff lea -0x1(%ecx),%eax
for (i = 1; i <= 7 && name_size && *name_ptr != '.'; ++i) {
119275: 83 fb 08 cmp $0x8,%ebx
119278: 0f 84 a2 00 00 00 je 119320 <msdos_filename_utf8_to_short_name_for_save+0x200>
--name_size;
11927e: 89 c1 mov %eax,%ecx
++name_ptr;
119280: 89 d6 mov %edx,%esi
for (i = 1; i <= 7 && name_size && *name_ptr != '.'; ++i) {
119282: 85 c9 test %ecx,%ecx
119284: 75 cd jne 119253 <msdos_filename_utf8_to_short_name_for_save+0x133>
dest_ptr[i] = ' ';
119286: 8d 14 1f lea (%edi,%ebx,1),%edx
119289: b8 08 00 00 00 mov $0x8,%eax
11928e: 29 d8 sub %ebx,%eax
119290: 74 0b je 11929d <msdos_filename_utf8_to_short_name_for_save+0x17d><== NEVER TAKEN
119292: 31 db xor %ebx,%ebx
119294: c6 04 1a 20 movb $0x20,(%edx,%ebx,1)
119298: 43 inc %ebx
119299: 39 c3 cmp %eax,%ebx
11929b: 72 f7 jb 119294 <msdos_filename_utf8_to_short_name_for_save+0x174>
11929d: 83 c1 08 add $0x8,%ecx
if ( name_size > 0 && *name_ptr == '.' ) {
1192a0: ba 08 00 00 00 mov $0x8,%edx
1192a5: bb 08 00 00 00 mov $0x8,%ebx
1192aa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
for (; i <= 10 && name_size ; i++) {
1192b0: 39 d1 cmp %edx,%ecx
1192b2: 74 1c je 1192d0 <msdos_filename_utf8_to_short_name_for_save+0x1b0>
dest_ptr[i] = msdos_get_valid_codepage_filename_character(*name_ptr);
1192b4: 0f b6 44 16 f8 movzbl -0x8(%esi,%edx,1),%eax
char c = codepage_valid_char_map[character];
1192b9: 0f b6 80 20 3a 13 00 movzbl 0x133a20(%eax),%eax
if (c == 0) {
1192c0: 84 c0 test %al,%al
1192c2: 75 02 jne 1192c6 <msdos_filename_utf8_to_short_name_for_save+0x1a6>
c = '_';
1192c4: b0 5f mov $0x5f,%al
dest_ptr[i] = msdos_get_valid_codepage_filename_character(*name_ptr);
1192c6: 88 04 17 mov %al,(%edi,%edx,1)
for (; i <= 10 && name_size ; i++) {
1192c9: 42 inc %edx
++returned_size;
1192ca: 43 inc %ebx
for (; i <= 10 && name_size ; i++) {
1192cb: 83 fa 0b cmp $0xb,%edx
1192ce: 75 e0 jne 1192b0 <msdos_filename_utf8_to_short_name_for_save+0x190>
for ( ; i < short_name_size; ++i ) {
1192d0: 39 55 18 cmp %edx,0x18(%ebp)
1192d3: 76 3c jbe 119311 <msdos_filename_utf8_to_short_name_for_save+0x1f1>
dest_ptr[i] = ' ';
1192d5: 8b 75 18 mov 0x18(%ebp),%esi
1192d8: 01 d7 add %edx,%edi
1192da: 29 d6 sub %edx,%esi
1192dc: 83 fe 08 cmp $0x8,%esi
1192df: 73 6f jae 119350 <msdos_filename_utf8_to_short_name_for_save+0x230><== NEVER TAKEN
1192e1: f7 c6 04 00 00 00 test $0x4,%esi
1192e7: 74 09 je 1192f2 <msdos_filename_utf8_to_short_name_for_save+0x1d2><== ALWAYS TAKEN
1192e9: c7 07 20 20 20 20 movl $0x20202020,(%edi) <== NOT EXECUTED
1192ef: 83 c7 04 add $0x4,%edi <== NOT EXECUTED
1192f2: f7 c6 02 00 00 00 test $0x2,%esi
1192f8: 74 08 je 119302 <msdos_filename_utf8_to_short_name_for_save+0x1e2>
1192fa: 66 c7 07 20 20 movw $0x2020,(%edi)
1192ff: 83 c7 02 add $0x2,%edi
119302: 83 e6 01 and $0x1,%esi
119305: 74 03 je 11930a <msdos_filename_utf8_to_short_name_for_save+0x1ea>
119307: c6 07 20 movb $0x20,(%edi)
++returned_size;
11930a: 8b 45 18 mov 0x18(%ebp),%eax
11930d: 29 d3 sub %edx,%ebx
11930f: 01 c3 add %eax,%ebx
}
return returned_size;
}
119311: 83 c4 4c add $0x4c,%esp
119314: 89 d8 mov %ebx,%eax
119316: 5b pop %ebx
119317: 5e pop %esi
119318: 5f pop %edi
119319: 5d pop %ebp
11931a: c3 ret
11931b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
11931f: 90 nop
if ( name_size > 0 && *name_ptr == '.' ) {
119320: 85 c0 test %eax,%eax
119322: 75 5c jne 119380 <msdos_filename_utf8_to_short_name_for_save+0x260>
119324: ba 08 00 00 00 mov $0x8,%edx
119329: eb a5 jmp 1192d0 <msdos_filename_utf8_to_short_name_for_save+0x1b0>
11932b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
11932f: 90 nop
if (dest_size >= UTF8_FULL_STOP_SIZE) {
119330: 8b 55 18 mov 0x18(%ebp),%edx <== NOT EXECUTED
119333: 85 d2 test %edx,%edx <== NOT EXECUTED
119335: 0f 84 c2 00 00 00 je 1193fd <msdos_filename_utf8_to_short_name_for_save+0x2dd><== NOT EXECUTED
dest_name[0] = UTF8_FULL_STOP;
11933b: c6 07 2e movb $0x2e,(%edi) <== NOT EXECUTED
returned_size = UTF8_FULL_STOP_SIZE;
11933e: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED
}
119343: 83 c4 4c add $0x4c,%esp <== NOT EXECUTED
119346: 89 d8 mov %ebx,%eax <== NOT EXECUTED
119348: 5b pop %ebx <== NOT EXECUTED
119349: 5e pop %esi <== NOT EXECUTED
11934a: 5f pop %edi <== NOT EXECUTED
11934b: 5d pop %ebp <== NOT EXECUTED
11934c: c3 ret <== NOT EXECUTED
11934d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
dest_ptr[i] = ' ';
119350: f7 c7 01 00 00 00 test $0x1,%edi <== NOT EXECUTED
119356: 0f 85 97 00 00 00 jne 1193f3 <msdos_filename_utf8_to_short_name_for_save+0x2d3><== NOT EXECUTED
11935c: f7 c7 02 00 00 00 test $0x2,%edi <== NOT EXECUTED
119362: 75 7f jne 1193e3 <msdos_filename_utf8_to_short_name_for_save+0x2c3><== NOT EXECUTED
119364: f7 c7 04 00 00 00 test $0x4,%edi <== NOT EXECUTED
11936a: 75 69 jne 1193d5 <msdos_filename_utf8_to_short_name_for_save+0x2b5><== NOT EXECUTED
11936c: 89 f1 mov %esi,%ecx <== NOT EXECUTED
11936e: b8 20 20 20 20 mov $0x20202020,%eax <== NOT EXECUTED
119373: c1 e9 02 shr $0x2,%ecx <== NOT EXECUTED
119376: 83 e6 03 and $0x3,%esi <== NOT EXECUTED
119379: f3 ab rep stos %eax,%es:(%edi) <== NOT EXECUTED
11937b: e9 61 ff ff ff jmp 1192e1 <msdos_filename_utf8_to_short_name_for_save+0x1c1><== NOT EXECUTED
++name_ptr;
119380: 83 c6 02 add $0x2,%esi
--name_size;
119383: 83 e9 02 sub $0x2,%ecx
if ( name_size > 0 && *name_ptr == '.' ) {
119386: 80 3a 2e cmpb $0x2e,(%edx)
119389: 0f 84 0e ff ff ff je 11929d <msdos_filename_utf8_to_short_name_for_save+0x17d>
11938f: 89 c1 mov %eax,%ecx
119391: 89 d6 mov %edx,%esi
119393: e9 05 ff ff ff jmp 11929d <msdos_filename_utf8_to_short_name_for_save+0x17d>
119398: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11939f: 90 nop
dest_ptr[0] = 0x05;
1193a0: c6 07 05 movb $0x5,(%edi) <== NOT EXECUTED
1193a3: e9 9b fe ff ff jmp 119243 <msdos_filename_utf8_to_short_name_for_save+0x123><== NOT EXECUTED
1193a8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1193af: 90 nop <== NOT EXECUTED
returned_size = msdos_filename_process_dot_names (
1193b0: 31 db xor %ebx,%ebx <== NOT EXECUTED
1193b2: e9 5a ff ff ff jmp 119311 <msdos_filename_utf8_to_short_name_for_save+0x1f1><== NOT EXECUTED
c = '_';
1193b7: b0 5f mov $0x5f,%al
dest_ptr[0] = msdos_get_valid_codepage_filename_character(*name_ptr);
1193b9: 88 07 mov %al,(%edi)
1193bb: e9 83 fe ff ff jmp 119243 <msdos_filename_utf8_to_short_name_for_save+0x123>
if (dest_size >= 2 * UTF8_FULL_STOP_SIZE) {
1193c0: 83 7d 18 01 cmpl $0x1,0x18(%ebp) <== NOT EXECUTED
1193c4: 76 37 jbe 1193fd <msdos_filename_utf8_to_short_name_for_save+0x2dd><== NOT EXECUTED
dest_name[0] = UTF8_FULL_STOP;
1193c6: 66 c7 07 2e 2e movw $0x2e2e,(%edi) <== NOT EXECUTED
returned_size = 2 * UTF8_FULL_STOP_SIZE;
1193cb: bb 02 00 00 00 mov $0x2,%ebx <== NOT EXECUTED
1193d0: e9 3c ff ff ff jmp 119311 <msdos_filename_utf8_to_short_name_for_save+0x1f1><== NOT EXECUTED
dest_ptr[i] = ' ';
1193d5: c7 07 20 20 20 20 movl $0x20202020,(%edi) <== NOT EXECUTED
1193db: 83 ee 04 sub $0x4,%esi <== NOT EXECUTED
1193de: 83 c7 04 add $0x4,%edi <== NOT EXECUTED
1193e1: eb 89 jmp 11936c <msdos_filename_utf8_to_short_name_for_save+0x24c><== NOT EXECUTED
1193e3: 66 c7 07 20 20 movw $0x2020,(%edi) <== NOT EXECUTED
1193e8: 83 ee 02 sub $0x2,%esi <== NOT EXECUTED
1193eb: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
1193ee: e9 71 ff ff ff jmp 119364 <msdos_filename_utf8_to_short_name_for_save+0x244><== NOT EXECUTED
1193f3: c6 07 20 movb $0x20,(%edi) <== NOT EXECUTED
1193f6: 4e dec %esi <== NOT EXECUTED
1193f7: 47 inc %edi <== NOT EXECUTED
1193f8: e9 5f ff ff ff jmp 11935c <msdos_filename_utf8_to_short_name_for_save+0x23c><== NOT EXECUTED
errno = eno;
1193fd: e8 9e d4 00 00 call 1268a0 <__errno> <== NOT EXECUTED
119402: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED
119407: c7 00 5b 00 00 00 movl $0x5b,(%eax) <== NOT EXECUTED
if (returned_size == 0) {
11940d: e9 ff fe ff ff jmp 119311 <msdos_filename_utf8_to_short_name_for_save+0x1f1><== NOT EXECUTED
++name_ptr;
119412: 46 inc %esi
--name_size;
119413: 49 dec %ecx
119414: e9 6d fe ff ff jmp 119286 <msdos_filename_utf8_to_short_name_for_save+0x166>
119419: 90 nop
11941a: 90 nop
11941b: 90 nop
11941c: 90 nop
11941d: 90 nop
11941e: 90 nop
11941f: 90 nop
00113a80 <msdos_find_name>:
{
113a80: 55 push %ebp
memset(node_entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
113a81: 31 d2 xor %edx,%edx
{
113a83: 89 e5 mov %esp,%ebp
113a85: 57 push %edi
113a86: 56 push %esi
113a87: 53 push %ebx
memset(node_entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
113a88: 8d 7d c8 lea -0x38(%ebp),%edi
{
113a8b: 83 ec 7c sub $0x7c,%esp
fat_file_fd_t *fat_fd = NULL;
113a8e: c7 45 b4 00 00 00 00 movl $0x0,-0x4c(%ebp)
{
113a95: 8b 5d 08 mov 0x8(%ebp),%ebx
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
113a98: 8b 43 14 mov 0x14(%ebx),%eax
113a9b: 8b 70 08 mov 0x8(%eax),%esi
memset(node_entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
113a9e: 31 c0 xor %eax,%eax
113aa0: 89 14 07 mov %edx,(%edi,%eax,1)
113aa3: 89 54 07 04 mov %edx,0x4(%edi,%eax,1)
113aa7: 83 c0 08 add $0x8,%eax
113aaa: 83 f8 20 cmp $0x20,%eax
113aad: 72 f1 jb 113aa0 <msdos_find_name+0x20>
name_type = msdos_long_to_short (
113aaf: 89 7c 24 0c mov %edi,0xc(%esp)
113ab3: b8 0b 00 00 00 mov $0xb,%eax
113ab8: 89 44 24 10 mov %eax,0x10(%esp)
113abc: 8b 45 10 mov 0x10(%ebp),%eax
113abf: 89 44 24 08 mov %eax,0x8(%esp)
113ac3: 8b 45 0c mov 0xc(%ebp),%eax
113ac6: 89 44 24 04 mov %eax,0x4(%esp)
113aca: 8b 86 c8 00 00 00 mov 0xc8(%esi),%eax
113ad0: 89 04 24 mov %eax,(%esp)
113ad3: e8 58 e2 ff ff call 111d30 <msdos_long_to_short>
rc = msdos_get_name_node(parent_loc, false, name, name_len, name_type,
113ad8: 31 d2 xor %edx,%edx
113ada: 89 7c 24 18 mov %edi,0x18(%esp)
113ade: 8d 7d b8 lea -0x48(%ebp),%edi
113ae1: 89 54 24 04 mov %edx,0x4(%esp)
113ae5: 89 7c 24 14 mov %edi,0x14(%esp)
113ae9: 89 1c 24 mov %ebx,(%esp)
113aec: 89 44 24 10 mov %eax,0x10(%esp)
113af0: 8b 45 10 mov 0x10(%ebp),%eax
113af3: 89 44 24 0c mov %eax,0xc(%esp)
113af7: 8b 45 0c mov 0xc(%ebp),%eax
113afa: 89 44 24 08 mov %eax,0x8(%esp)
113afe: e8 7d fe ff ff call 113980 <msdos_get_name_node>
if (rc != RC_OK)
113b03: 85 c0 test %eax,%eax
rc = msdos_get_name_node(parent_loc, false, name, name_len, name_type,
113b05: 89 c2 mov %eax,%edx
if (rc != RC_OK)
113b07: 75 6a jne 113b73 <msdos_find_name+0xf3>
if (((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_VOLUME_ID) ||
113b09: 0f b6 45 d3 movzbl -0x2d(%ebp),%eax
113b0d: 88 c2 mov %al,%dl
113b0f: 80 e2 08 and $0x8,%dl
113b12: 75 6c jne 113b80 <msdos_find_name+0x100> <== NEVER TAKEN
113b14: 24 3f and $0x3f,%al
113b16: 3c 0f cmp $0xf,%al
113b18: 74 66 je 113b80 <msdos_find_name+0x100> <== NEVER TAKEN
rc = fat_file_open(&fs_info->fat, &dir_pos, &fat_fd);
113b1a: 89 7c 24 04 mov %edi,0x4(%esp)
113b1e: 8d 45 b4 lea -0x4c(%ebp),%eax
113b21: 89 44 24 08 mov %eax,0x8(%esp)
113b25: 89 34 24 mov %esi,(%esp)
113b28: e8 e3 c7 ff ff call 110310 <fat_file_open>
if (rc != RC_OK)
113b2d: 85 c0 test %eax,%eax
rc = fat_file_open(&fs_info->fat, &dir_pos, &fat_fd);
113b2f: 89 c2 mov %eax,%edx
if (rc != RC_OK)
113b31: 75 40 jne 113b73 <msdos_find_name+0xf3> <== NEVER TAKEN
fat_fd->dir_pos = dir_pos;
113b33: 8b 45 b4 mov -0x4c(%ebp),%eax
113b36: 8b 55 b8 mov -0x48(%ebp),%edx
if (fat_fd->links_num == 1)
113b39: 83 78 08 01 cmpl $0x1,0x8(%eax)
fat_fd->dir_pos = dir_pos;
113b3d: 89 50 20 mov %edx,0x20(%eax)
113b40: 8b 55 bc mov -0x44(%ebp),%edx
113b43: 89 50 24 mov %edx,0x24(%eax)
113b46: 8b 55 c0 mov -0x40(%ebp),%edx
113b49: 89 50 28 mov %edx,0x28(%eax)
113b4c: 8b 55 c4 mov -0x3c(%ebp),%edx
113b4f: 89 50 2c mov %edx,0x2c(%eax)
if (fat_fd->links_num == 1)
113b52: 74 3c je 113b90 <msdos_find_name+0x110>
rc = fat_file_close(&fs_info->fat, parent_loc->node_access);
113b54: 8b 43 08 mov 0x8(%ebx),%eax
113b57: 89 34 24 mov %esi,(%esp)
113b5a: 89 44 24 04 mov %eax,0x4(%esp)
113b5e: e8 ed cd ff ff call 110950 <fat_file_close>
if (rc != RC_OK)
113b63: 85 c0 test %eax,%eax
rc = fat_file_close(&fs_info->fat, parent_loc->node_access);
113b65: 89 c2 mov %eax,%edx
if (rc != RC_OK)
113b67: 0f 85 c3 00 00 00 jne 113c30 <msdos_find_name+0x1b0> <== NEVER TAKEN
parent_loc->node_access = fat_fd;
113b6d: 8b 45 b4 mov -0x4c(%ebp),%eax <== NOT EXECUTED
113b70: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED
}
113b73: 83 c4 7c add $0x7c,%esp
113b76: 89 d0 mov %edx,%eax
113b78: 5b pop %ebx
113b79: 5e pop %esi
113b7a: 5f pop %edi
113b7b: 5d pop %ebp
113b7c: c3 ret
113b7d: 8d 76 00 lea 0x0(%esi),%esi
113b80: 83 c4 7c add $0x7c,%esp <== NOT EXECUTED
return MSDOS_NAME_NOT_FOUND_ERR;
113b83: ba 01 7d 00 00 mov $0x7d01,%edx <== NOT EXECUTED
}
113b88: 5b pop %ebx <== NOT EXECUTED
113b89: 89 d0 mov %edx,%eax <== NOT EXECUTED
113b8b: 5e pop %esi <== NOT EXECUTED
113b8c: 5f pop %edi <== NOT EXECUTED
113b8d: 5d pop %ebp <== NOT EXECUTED
113b8e: c3 ret <== NOT EXECUTED
113b8f: 90 nop <== NOT EXECUTED
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);
113b90: 0f b7 55 dc movzwl -0x24(%ebp),%edx
113b94: 0f b7 4d e2 movzwl -0x1e(%ebp),%ecx
113b98: c1 e2 10 shl $0x10,%edx
113b9b: 09 ca or %ecx,%edx
113b9d: 89 50 1c mov %edx,0x1c(%eax)
fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
113ba0: 0f b7 45 de movzwl -0x22(%ebp),%eax
113ba4: 89 44 24 04 mov %eax,0x4(%esp)
113ba8: 0f b7 45 e0 movzwl -0x20(%ebp),%eax
113bac: 89 04 24 mov %eax,(%esp)
113baf: e8 6c 50 00 00 call 118c20 <msdos_date_dos2unix>
113bb4: 8b 55 b4 mov -0x4c(%ebp),%edx <== NOT EXECUTED
113bb7: c7 42 4c 00 00 00 00 movl $0x0,0x4c(%edx) <== NOT EXECUTED
113bbe: 89 42 48 mov %eax,0x48(%edx) <== NOT EXECUTED
fat_fd->ctime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
113bc1: 0f b7 45 d6 movzwl -0x2a(%ebp),%eax <== NOT EXECUTED
113bc5: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
113bc9: 0f b7 45 d8 movzwl -0x28(%ebp),%eax <== NOT EXECUTED
113bcd: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
113bd0: e8 4b 50 00 00 call 118c20 <msdos_date_dos2unix> <== NOT EXECUTED
if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
113bd5: f6 45 d3 10 testb $0x10,-0x2d(%ebp)
fat_fd->ctime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
113bd9: 89 c2 mov %eax,%edx
113bdb: 8b 45 b4 mov -0x4c(%ebp),%eax
113bde: 89 50 40 mov %edx,0x40(%eax)
113be1: c7 40 44 00 00 00 00 movl $0x0,0x44(%eax)
if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
113be8: 75 66 jne 113c50 <msdos_find_name+0x1d0>
fat_fd->fat_file_size = CF_LE_L(*MSDOS_DIR_FILE_SIZE(node_entry));
113bea: 8b 55 e4 mov -0x1c(%ebp),%edx
fat_fd->fat_file_type = FAT_FILE;
113bed: c7 40 10 04 00 00 00 movl $0x4,0x10(%eax)
fat_fd->size_limit = MSDOS_MAX_FILE_SIZE;
113bf4: c7 40 14 ff ff ff ff movl $0xffffffff,0x14(%eax)
fat_fd->fat_file_size = CF_LE_L(*MSDOS_DIR_FILE_SIZE(node_entry));
113bfb: 89 50 18 mov %edx,0x18(%eax)
fat_fd->map.file_cln = 0;
113bfe: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax)
fat_fd->map.disk_cln = fat_fd->cln;
113c05: 8b 48 1c mov 0x1c(%eax),%ecx
if ((fat_fd->fat_file_size != 0) &&
113c08: 85 d2 test %edx,%edx
fat_fd->map.disk_cln = fat_fd->cln;
113c0a: 89 48 38 mov %ecx,0x38(%eax)
if ((fat_fd->fat_file_size != 0) &&
113c0d: 74 11 je 113c20 <msdos_find_name+0x1a0>
113c0f: 39 56 08 cmp %edx,0x8(%esi)
113c12: 72 0c jb 113c20 <msdos_find_name+0x1a0>
fat_fd->map.last_cln = fat_fd->cln;
113c14: 89 48 3c mov %ecx,0x3c(%eax)
113c17: e9 38 ff ff ff jmp 113b54 <msdos_find_name+0xd4>
113c1c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
fat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
113c20: c7 40 3c ff ff ff ff movl $0xffffffff,0x3c(%eax)
113c27: e9 28 ff ff ff jmp 113b54 <msdos_find_name+0xd4>
113c2c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
fat_file_close(&fs_info->fat, fat_fd);
113c30: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
113c33: 8b 45 b4 mov -0x4c(%ebp),%eax <== NOT EXECUTED
113c36: 89 55 a4 mov %edx,-0x5c(%ebp) <== NOT EXECUTED
113c39: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
113c3d: e8 0e cd ff ff call 110950 <fat_file_close> <== NOT EXECUTED
return rc;
113c42: 8b 55 a4 mov -0x5c(%ebp),%edx <== NOT EXECUTED
113c45: e9 29 ff ff ff jmp 113b73 <msdos_find_name+0xf3> <== NOT EXECUTED
113c4a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
fat_fd->fat_file_type = FAT_DIRECTORY;
113c50: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax)
fat_fd->size_limit = MSDOS_MAX_DIR_LENGTH;
113c57: c7 40 14 00 00 20 00 movl $0x200000,0x14(%eax)
rc = fat_file_size(&fs_info->fat, fat_fd);
113c5e: 89 44 24 04 mov %eax,0x4(%esp)
113c62: 89 34 24 mov %esi,(%esp)
113c65: e8 f6 d3 ff ff call 111060 <fat_file_size>
if (rc != RC_OK)
113c6a: 85 c0 test %eax,%eax
rc = fat_file_size(&fs_info->fat, fat_fd);
113c6c: 89 c2 mov %eax,%edx
if (rc != RC_OK)
113c6e: 75 c0 jne 113c30 <msdos_find_name+0x1b0> <== NEVER TAKEN
fat_fd->map.file_cln = 0;
113c70: 8b 45 b4 mov -0x4c(%ebp),%eax
if ((fat_fd->fat_file_size != 0) &&
113c73: 8b 50 18 mov 0x18(%eax),%edx
113c76: eb 86 jmp 113bfe <msdos_find_name+0x17e>
113c78: 90 nop
113c79: 90 nop
113c7a: 90 nop
113c7b: 90 nop
113c7c: 90 nop
113c7d: 90 nop
113c7e: 90 nop
113c7f: 90 nop
00112720 <msdos_find_name_in_fat_file>:
const uint8_t *name_utf8,
int name_utf8_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry)
{
112720: 55 push %ebp
112721: 89 e5 mov %esp,%ebp
112723: 57 push %edi
112724: 56 push %esi
112725: 53 push %ebx
112726: 81 ec 1c 01 00 00 sub $0x11c,%esp
11272c: 0f b6 45 10 movzbl 0x10(%ebp),%eax
unsigned int lfn_entries;
rtems_dosfs_convert_control *converter = fs_info->converter;
void *buffer = converter->buffer.data;
size_t buffer_size = converter->buffer.size;
assert(name_utf8_len > 0);
112730: 8b 5d 18 mov 0x18(%ebp),%ebx
{
112733: 88 85 38 ff ff ff mov %al,-0xc8(%ebp)
msdos_fs_info_t *fs_info = mt_entry->fs_info;
112739: 8b 45 08 mov 0x8(%ebp),%eax
assert(name_utf8_len > 0);
11273c: 85 db test %ebx,%ebx
msdos_fs_info_t *fs_info = mt_entry->fs_info;
11273e: 8b 40 08 mov 0x8(%eax),%eax
112741: 89 85 24 ff ff ff mov %eax,-0xdc(%ebp)
rtems_dosfs_convert_control *converter = fs_info->converter;
112747: 8b 80 c8 00 00 00 mov 0xc8(%eax),%eax
11274d: 89 85 08 ff ff ff mov %eax,-0xf8(%ebp)
void *buffer = converter->buffer.data;
112753: 8b 78 04 mov 0x4(%eax),%edi
size_t buffer_size = converter->buffer.size;
112756: 8b 40 08 mov 0x8(%eax),%eax
void *buffer = converter->buffer.data;
112759: 89 bd 0c ff ff ff mov %edi,-0xf4(%ebp)
size_t buffer_size = converter->buffer.size;
11275f: 89 85 04 ff ff ff mov %eax,-0xfc(%ebp)
assert(name_utf8_len > 0);
112765: 0f 8e ec 0c 00 00 jle 113457 <msdos_find_name_in_fat_file+0xd37> <== NEVER TAKEN
dir_pos->sname.cln = 0;
11276b: 8b 45 20 mov 0x20(%ebp),%eax
11276e: c7 00 00 00 00 00 movl $0x0,(%eax)
dir_pos->sname.ofs = 0;
112774: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
11277b: c7 40 08 ff ff ff ff movl $0xffffffff,0x8(%eax)
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
112782: c7 40 0c ff ff ff ff movl $0xffffffff,0xc(%eax)
fat_dir_pos_init(dir_pos);
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
112789: 8b 45 0c mov 0xc(%ebp),%eax
11278c: 83 78 20 01 cmpl $0x1,0x20(%eax)
112790: 0f 84 84 00 00 00 je 11281a <msdos_find_name_in_fat_file+0xfa>
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
else
bts2rd = fs_info->fat.vol.bpc;
112796: 8b 85 24 ff ff ff mov -0xdc(%ebp),%eax
11279c: 8b 40 08 mov 0x8(%eax),%eax
11279f: 89 85 44 ff ff ff mov %eax,-0xbc(%ebp)
switch ( name_type ) {
1127a5: 83 7d 1c 01 cmpl $0x1,0x1c(%ebp)
1127a9: 0f 84 97 00 00 00 je 112846 <msdos_find_name_in_fat_file+0x126>
1127af: 83 7d 1c 02 cmpl $0x2,0x1c(%ebp)
1127b3: 74 1b je 1127d0 <msdos_find_name_in_fat_file+0xb0>
}
else
retval = -1;
break;
default:
errno = EINVAL;
1127b5: e8 e6 40 01 00 call 1268a0 <__errno>
1127ba: c7 00 16 00 00 00 movl $0x16,(%eax)
retval = -1;
1127c0: b8 ff ff ff ff mov $0xffffffff,%eax
empty_entry_count
);
}
return retval;
}
1127c5: 81 c4 1c 01 00 00 add $0x11c,%esp
1127cb: 5b pop %ebx
1127cc: 5e pop %esi
1127cd: 5f pop %edi
1127ce: 5d pop %ebp
1127cf: c3 ret
name_len_for_save = msdos_filename_utf8_to_long_name_for_save (
1127d0: 8b 45 18 mov 0x18(%ebp),%eax
1127d3: 8b bd 04 ff ff ff mov -0xfc(%ebp),%edi
1127d9: 8b b5 0c ff ff ff mov -0xf4(%ebp),%esi
1127df: 89 44 24 08 mov %eax,0x8(%esp)
1127e3: 8b 45 14 mov 0x14(%ebp),%eax
1127e6: 89 7c 24 10 mov %edi,0x10(%esp)
1127ea: 89 74 24 0c mov %esi,0xc(%esp)
1127ee: 89 44 24 04 mov %eax,0x4(%esp)
1127f2: 8b 85 08 ff ff ff mov -0xf8(%ebp),%eax
1127f8: 89 04 24 mov %eax,(%esp)
1127fb: e8 40 66 00 00 call 118e40 <msdos_filename_utf8_to_long_name_for_save>
if (name_len_for_save > 0) {
112800: 85 c0 test %eax,%eax
name_len_for_save = msdos_filename_utf8_to_long_name_for_save (
112802: 89 c3 mov %eax,%ebx
if (name_len_for_save > 0) {
112804: 0f 8f 7e 0a 00 00 jg 113288 <msdos_find_name_in_fat_file+0xb68>
rtems_set_errno_and_return_minus_one(EIO);
11280a: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
}
11280f: 81 c4 1c 01 00 00 add $0x11c,%esp <== NOT EXECUTED
112815: 5b pop %ebx <== NOT EXECUTED
112816: 5e pop %esi <== NOT EXECUTED
112817: 5f pop %edi <== NOT EXECUTED
112818: 5d pop %ebp <== NOT EXECUTED
112819: c3 ret <== NOT EXECUTED
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
11281a: 8b 48 24 mov 0x24(%eax),%ecx
11281d: 85 c9 test %ecx,%ecx
11281f: 0f 85 71 ff ff ff jne 112796 <msdos_find_name_in_fat_file+0x76> <== NEVER TAKEN
112825: 8b 85 24 ff ff ff mov -0xdc(%ebp),%eax
11282b: f6 40 16 03 testb $0x3,0x16(%eax)
11282f: 0f 84 61 ff ff ff je 112796 <msdos_find_name_in_fat_file+0x76>
bts2rd = fat_fd->fat_file_size;
112835: 8b 45 0c mov 0xc(%ebp),%eax
112838: 8b 40 18 mov 0x18(%eax),%eax
11283b: 89 85 44 ff ff ff mov %eax,-0xbc(%ebp)
112841: e9 5f ff ff ff jmp 1127a5 <msdos_find_name_in_fat_file+0x85>
name_len_for_compare = msdos_filename_utf8_to_short_name_for_compare (
112846: b8 0b 00 00 00 mov $0xb,%eax
11284b: 89 44 24 10 mov %eax,0x10(%esp)
11284f: 8b 85 0c ff ff ff mov -0xf4(%ebp),%eax
112855: 89 44 24 0c mov %eax,0xc(%esp)
112859: 8b 45 18 mov 0x18(%ebp),%eax
11285c: 89 44 24 08 mov %eax,0x8(%esp)
112860: 8b 45 14 mov 0x14(%ebp),%eax
112863: 89 44 24 04 mov %eax,0x4(%esp)
112867: 8b 85 08 ff ff ff mov -0xf8(%ebp),%eax
11286d: 89 04 24 mov %eax,(%esp)
112870: e8 4b 67 00 00 call 118fc0 <msdos_filename_utf8_to_short_name_for_compare>
lfn_entries = 0;
112875: 31 d2 xor %edx,%edx
112877: 89 95 18 ff ff ff mov %edx,-0xe8(%ebp)
name_len_for_compare = msdos_filename_utf8_to_short_name_for_compare (
11287d: 89 85 30 ff ff ff mov %eax,-0xd0(%ebp)
if (name_len_for_compare > 0) {
112883: 85 c0 test %eax,%eax
112885: 7e 83 jle 11280a <msdos_find_name_in_fat_file+0xea> <== NEVER TAKEN
uint32_t entries_per_block = bts2rd / MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
112887: 8b 85 44 ff ff ff mov -0xbc(%ebp),%eax
}
11288d: 31 d2 xor %edx,%edx
uint32_t empty_file_offset = 0;
11288f: 31 c9 xor %ecx,%ecx
*entry_matched = false;
112891: c6 85 4f ff ff ff 00 movb $0x0,-0xb1(%ebp)
uint32_t dir_offset = 0;
112898: 31 db xor %ebx,%ebx
uint32_t empty_entry_count = 0;
11289a: 31 f6 xor %esi,%esi
}
11289c: 89 95 2c ff ff ff mov %edx,-0xd4(%ebp)
uint32_t empty_file_offset = 0;
1128a2: 89 8d 34 ff ff ff mov %ecx,-0xcc(%ebp)
uint32_t dir_offset = 0;
1128a8: 89 9d 14 ff ff ff mov %ebx,-0xec(%ebp)
uint32_t entries_per_block = bts2rd / MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
1128ae: c1 e8 05 shr $0x5,%eax
1128b1: 89 85 fc fe ff ff mov %eax,-0x104(%ebp)
rtems_dosfs_convert_control *converter = fs_info->converter;
1128b7: 8b 85 24 ff ff ff mov -0xdc(%ebp),%eax
bool empty_space_found = false;
1128bd: c6 85 28 ff ff ff 00 movb $0x0,-0xd8(%ebp)
uint8_t lfn_checksum = 0;
1128c4: c6 85 13 ff ff ff 00 movb $0x0,-0xed(%ebp)
rtems_dosfs_convert_control *converter = fs_info->converter;
1128cb: 8b b8 c8 00 00 00 mov 0xc8(%eax),%edi
1128d1: 8b 80 c4 00 00 00 mov 0xc4(%eax),%eax
1128d7: 89 bd 1c ff ff ff mov %edi,-0xe4(%ebp)
lfn_start->cln = FAT_FILE_SHORT_NAME;
1128dd: bf ff ff ff ff mov $0xffffffff,%edi
1128e2: 89 bd 54 ff ff ff mov %edi,-0xac(%ebp)
}
1128e8: 8b bd 30 ff ff ff mov -0xd0(%ebp),%edi
1128ee: 89 85 40 ff ff ff mov %eax,-0xc0(%ebp)
1128f4: 89 bd 3c ff ff ff mov %edi,-0xc4(%ebp)
int lfn_entry = 0;
1128fa: 31 ff xor %edi,%edi
1128fc: 89 bd 20 ff ff ff mov %edi,-0xe0(%ebp)
112902: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
112909: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
while ( (bytes_read = fat_file_read (&fs_info->fat, fat_fd, (dir_offset * bts2rd),
112910: 8b 85 40 ff ff ff mov -0xc0(%ebp),%eax
112916: 89 44 24 10 mov %eax,0x10(%esp)
11291a: 8b 85 44 ff ff ff mov -0xbc(%ebp),%eax
112920: 89 44 24 0c mov %eax,0xc(%esp)
112924: 8b 85 2c ff ff ff mov -0xd4(%ebp),%eax
11292a: 89 44 24 08 mov %eax,0x8(%esp)
11292e: 8b 45 0c mov 0xc(%ebp),%eax
112931: 89 44 24 04 mov %eax,0x4(%esp)
112935: 8b 85 24 ff ff ff mov -0xdc(%ebp),%eax
11293b: 89 04 24 mov %eax,(%esp)
11293e: e8 1d dd ff ff call 110660 <fat_file_read>
&& rc == RC_OK)
112943: 85 c0 test %eax,%eax
112945: 0f 84 a0 09 00 00 je 1132eb <msdos_find_name_in_fat_file+0xbcb> <== NEVER TAKEN
if (bytes_read < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
11294b: 83 f8 1f cmp $0x1f,%eax
11294e: 0f 8e 1f 09 00 00 jle 113273 <msdos_find_name_in_fat_file+0xb53> <== NEVER TAKEN
assert(bytes_read == bts2rd);
112954: 8b 9d 44 ff ff ff mov -0xbc(%ebp),%ebx
11295a: 39 d8 cmp %ebx,%eax
11295c: 0f 85 be 0a 00 00 jne 113420 <msdos_find_name_in_fat_file+0xd00> <== NEVER TAKEN
for (dir_entry = 0;
112962: 85 db test %ebx,%ebx
112964: 0f 84 6a 09 00 00 je 1132d4 <msdos_find_name_in_fat_file+0xbb4> <== NEVER TAKEN
11296a: 8b 85 24 ff ff ff mov -0xdc(%ebp),%eax
112970: 31 ff xor %edi,%edi
112972: 8b 80 c4 00 00 00 mov 0xc4(%eax),%eax
112978: 89 85 40 ff ff ff mov %eax,-0xc0(%ebp)
11297e: e9 9a 00 00 00 jmp 112a1d <msdos_find_name_in_fat_file+0x2fd>
112983: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11298a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
if (create_node && !empty_space_found)
112990: 80 bd 28 ff ff ff 01 cmpb $0x1,-0xd8(%ebp)
112997: 74 13 je 1129ac <msdos_find_name_in_fat_file+0x28c> <== NEVER TAKEN
112999: 80 bd 38 ff ff ff 00 cmpb $0x0,-0xc8(%ebp)
1129a0: 74 0a je 1129ac <msdos_find_name_in_fat_file+0x28c>
*empty_file_offset = 0;
1129a2: 31 d2 xor %edx,%edx
*empty_entry_count = 0;
1129a4: 31 f6 xor %esi,%esi
*empty_file_offset = 0;
1129a6: 89 95 34 ff ff ff mov %edx,-0xcc(%ebp)
if ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
1129ac: 0f b6 53 0b movzbl 0xb(%ebx),%edx
1129b0: 88 d1 mov %dl,%cl
1129b2: 80 e1 3f and $0x3f,%cl
1129b5: 80 f9 0f cmp $0xf,%cl
1129b8: 0f 84 c2 00 00 00 je 112a80 <msdos_find_name_in_fat_file+0x360>
if (entry_matched)
1129be: 80 bd 4f ff ff ff 00 cmpb $0x0,-0xb1(%ebp)
1129c5: 0f 84 f5 00 00 00 je 112ac0 <msdos_find_name_in_fat_file+0x3a0>
if (lfn_entry ||
1129cb: 8b 8d 3c ff ff ff mov -0xc4(%ebp),%ecx
1129d1: 85 c9 test %ecx,%ecx
1129d3: 7f 1b jg 1129f0 <msdos_find_name_in_fat_file+0x2d0>
1129d5: 8b 95 20 ff ff ff mov -0xe0(%ebp),%edx
1129db: 85 d2 test %edx,%edx
1129dd: 0f 84 9d 06 00 00 je 113080 <msdos_find_name_in_fat_file+0x960> <== ALWAYS TAKEN
1129e3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1129ea: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
*entry_matched = false;
1129f0: c6 85 4f ff ff ff 00 movb $0x0,-0xb1(%ebp)
}
1129f7: 8b 85 30 ff ff ff mov -0xd0(%ebp),%eax
lfn_start->cln = FAT_FILE_SHORT_NAME;
1129fd: b9 ff ff ff ff mov $0xffffffff,%ecx
112a02: 89 8d 54 ff ff ff mov %ecx,-0xac(%ebp)
}
112a08: 89 85 3c ff ff ff mov %eax,-0xc4(%ebp)
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
112a0e: 83 c7 20 add $0x20,%edi
for (dir_entry = 0;
112a11: 39 bd 44 ff ff ff cmp %edi,-0xbc(%ebp)
112a17: 0f 86 d3 01 00 00 jbe 112bf0 <msdos_find_name_in_fat_file+0x4d0>
char* entry = (char*) fs_info->cl_buf + dir_entry;
112a1d: 8b 85 40 ff ff ff mov -0xc0(%ebp),%eax
if (*empty_entry_count == 0)
112a23: 85 f6 test %esi,%esi
char* entry = (char*) fs_info->cl_buf + dir_entry;
112a25: 8d 1c 38 lea (%eax,%edi,1),%ebx
bool entry_empty = (*MSDOS_DIR_ENTRY_TYPE(entry) ==
112a28: 0f b6 03 movzbl (%ebx),%eax
if (*empty_entry_count == 0)
112a2b: 75 0f jne 112a3c <msdos_find_name_in_fat_file+0x31c>
*empty_file_offset = dir_offset * bts2rd + dir_entry;
112a2d: 8b 8d 2c ff ff ff mov -0xd4(%ebp),%ecx
112a33: 8d 14 39 lea (%ecx,%edi,1),%edx
112a36: 89 95 34 ff ff ff mov %edx,-0xcc(%ebp)
if (remainder_empty)
112a3c: 84 c0 test %al,%al
112a3e: 0f 84 0c 03 00 00 je 112d50 <msdos_find_name_in_fat_file+0x630>
else if (entry_empty)
112a44: 3c e5 cmp $0xe5,%al
112a46: 0f 85 44 ff ff ff jne 112990 <msdos_find_name_in_fat_file+0x270>
if (create_node)
112a4c: 80 bd 38 ff ff ff 00 cmpb $0x0,-0xc8(%ebp)
112a53: 74 9b je 1129f0 <msdos_find_name_in_fat_file+0x2d0>
if (*empty_entry_count == (lfn_entries + 1))
112a55: 3b b5 18 ff ff ff cmp -0xe8(%ebp),%esi
(*empty_entry_count)++;
112a5b: 8d 46 01 lea 0x1(%esi),%eax
112a5e: 89 c6 mov %eax,%esi
if (*empty_entry_count == (lfn_entries + 1))
112a60: 75 8e jne 1129f0 <msdos_find_name_in_fat_file+0x2d0>
empty_space_found = true;
112a62: 0f b6 85 38 ff ff ff movzbl -0xc8(%ebp),%eax
112a69: 88 85 28 ff ff ff mov %al,-0xd8(%ebp)
112a6f: e9 7c ff ff ff jmp 1129f0 <msdos_find_name_in_fat_file+0x2d0>
112a74: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
112a7b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
112a7f: 90 nop
(lfn_start.cln == FAT_FILE_SHORT_NAME);
112a80: 8b 95 54 ff ff ff mov -0xac(%ebp),%edx
if (is_first_lfn_entry)
112a86: 83 fa ff cmp $0xffffffff,%edx
112a89: 0f 84 81 01 00 00 je 112c10 <msdos_find_name_in_fat_file+0x4f0>
if ((lfn_entry != (*MSDOS_DIR_ENTRY_TYPE(entry) &
112a8f: 24 3f and $0x3f,%al
112a91: 0f b6 c0 movzbl %al,%eax
112a94: 3b 85 20 ff ff ff cmp -0xe0(%ebp),%eax
112a9a: 0f 85 50 ff ff ff jne 1129f0 <msdos_find_name_in_fat_file+0x2d0> <== NEVER TAKEN
MSDOS_LAST_LONG_ENTRY_MASK)) ||
112aa0: 0f b6 85 13 ff ff ff movzbl -0xed(%ebp),%eax
112aa7: 38 43 0d cmp %al,0xd(%ebx)
112aaa: 0f 85 40 ff ff ff jne 1129f0 <msdos_find_name_in_fat_file+0x2d0> <== NEVER TAKEN
112ab0: e9 93 01 00 00 jmp 112c48 <msdos_find_name_in_fat_file+0x528>
112ab5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
112abc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
} else if ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_VOLUME_ID)
112ac0: 80 e2 08 and $0x8,%dl
112ac3: 0f 85 45 ff ff ff jne 112a0e <msdos_find_name_in_fat_file+0x2ee>
ssize_t bytes_written = msdos_format_dirent_with_dot(char_buf, entry);
112ac9: 89 5c 24 04 mov %ebx,0x4(%esp)
112acd: 8d 85 5e ff ff ff lea -0xa2(%ebp),%eax
size_t bytes_converted = buf_size;
112ad3: ba 0c 00 00 00 mov $0xc,%edx
ssize_t bytes_written = msdos_format_dirent_with_dot(char_buf, entry);
112ad8: 89 04 24 mov %eax,(%esp)
size_t bytes_converted = buf_size;
112adb: 89 95 50 ff ff ff mov %edx,-0xb0(%ebp)
ssize_t bytes_written = msdos_format_dirent_with_dot(char_buf, entry);
112ae1: e8 ea fa ff ff call 1125d0 <msdos_format_dirent_with_dot>
if (bytes_written > 0) {
112ae6: 85 c0 test %eax,%eax
112ae8: 0f 8e ce 08 00 00 jle 1133bc <msdos_find_name_in_fat_file+0xc9c> <== NEVER TAKEN
if (char_buf[0] == 0x05)
112aee: 80 bd 5e ff ff ff 05 cmpb $0x5,-0xa2(%ebp)
112af5: 75 07 jne 112afe <msdos_find_name_in_fat_file+0x3de> <== ALWAYS TAKEN
char_buf[0] = 0xE5;
112af7: c6 85 5e ff ff ff e5 movb $0xe5,-0xa2(%ebp) <== NOT EXECUTED
eno = (*converter->handler->codepage_to_utf8) (
112afe: 8b 95 1c ff ff ff mov -0xe4(%ebp),%edx
112b04: 8b 0a mov (%edx),%ecx
112b06: 8d 95 50 ff ff ff lea -0xb0(%ebp),%edx
112b0c: 89 54 24 10 mov %edx,0x10(%esp)
112b10: 8d 95 78 ff ff ff lea -0x88(%ebp),%edx
112b16: 89 54 24 0c mov %edx,0xc(%esp)
112b1a: 89 95 40 ff ff ff mov %edx,-0xc0(%ebp)
112b20: 8b 95 1c ff ff ff mov -0xe4(%ebp),%edx
112b26: 89 44 24 08 mov %eax,0x8(%esp)
112b2a: 8d 85 5e ff ff ff lea -0xa2(%ebp),%eax
112b30: 89 44 24 04 mov %eax,0x4(%esp)
112b34: 89 14 24 mov %edx,(%esp)
112b37: ff 51 04 call *0x4(%ecx)
if (eno == 0)
112b3a: 8b 95 40 ff ff ff mov -0xc0(%ebp),%edx
112b40: 85 c0 test %eax,%eax
eno = (*converter->handler->codepage_to_utf8) (
112b42: 89 c1 mov %eax,%ecx
if (eno == 0)
112b44: 0f 84 e6 01 00 00 je 112d30 <msdos_find_name_in_fat_file+0x610> <== ALWAYS TAKEN
112b4a: 89 95 3c ff ff ff mov %edx,-0xc4(%ebp) <== NOT EXECUTED
112b50: 89 8d 40 ff ff ff mov %ecx,-0xc0(%ebp) <== NOT EXECUTED
errno = eno;
112b56: e8 45 3d 01 00 call 1268a0 <__errno> <== NOT EXECUTED
112b5b: 8b 8d 40 ff ff ff mov -0xc0(%ebp),%ecx <== NOT EXECUTED
bytes_in_entry = msdos_short_entry_to_utf8_name (
112b61: 8b 95 3c ff ff ff mov -0xc4(%ebp),%edx <== NOT EXECUTED
errno = eno;
112b67: 89 08 mov %ecx,(%eax) <== NOT EXECUTED
bytes_in_entry = msdos_short_entry_to_utf8_name (
112b69: b9 ff ff ff ff mov $0xffffffff,%ecx <== NOT EXECUTED
112b6e: 66 90 xchg %ax,%ax <== NOT EXECUTED
name_len_remaining = msdos_compare_entry_against_filename (
112b70: 8d 85 4f ff ff ff lea -0xb1(%ebp),%eax
112b76: 89 44 24 08 mov %eax,0x8(%esp)
112b7a: 8b 85 30 ff ff ff mov -0xd0(%ebp),%eax
112b80: 89 44 24 04 mov %eax,0x4(%esp)
112b84: 8b 85 0c ff ff ff mov -0xf4(%ebp),%eax
112b8a: 89 04 24 mov %eax,(%esp)
112b8d: 8b 85 1c ff ff ff mov -0xe4(%ebp),%eax
112b93: e8 b8 ee ff ff call 111a50 <msdos_compare_entry_against_filename>
if (entry_matched && name_len_remaining == 0) {
112b98: 80 bd 4f ff ff ff 00 cmpb $0x0,-0xb1(%ebp)
112b9f: 74 0f je 112bb0 <msdos_find_name_in_fat_file+0x490>
112ba1: 85 c0 test %eax,%eax
112ba3: 0f 84 15 05 00 00 je 1130be <msdos_find_name_in_fat_file+0x99e>
112ba9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
*entry_matched = false;
112bb0: c6 85 4f ff ff ff 00 movb $0x0,-0xb1(%ebp)
}
112bb7: 8b 85 30 ff ff ff mov -0xd0(%ebp),%eax
lfn_start->cln = FAT_FILE_SHORT_NAME;
112bbd: bb ff ff ff ff mov $0xffffffff,%ebx
112bc2: 89 9d 54 ff ff ff mov %ebx,-0xac(%ebp)
}
112bc8: 89 85 3c ff ff ff mov %eax,-0xc4(%ebp)
112bce: 8b 85 24 ff ff ff mov -0xdc(%ebp),%eax
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
112bd4: 83 c7 20 add $0x20,%edi
for (dir_entry = 0;
112bd7: 39 bd 44 ff ff ff cmp %edi,-0xbc(%ebp)
112bdd: 8b 80 c4 00 00 00 mov 0xc4(%eax),%eax
112be3: 89 85 40 ff ff ff mov %eax,-0xc0(%ebp)
112be9: 0f 87 2e fe ff ff ja 112a1d <msdos_find_name_in_fat_file+0x2fd>
112bef: 90 nop
dir_offset++;
112bf0: 8b bd 44 ff ff ff mov -0xbc(%ebp),%edi
112bf6: ff 85 14 ff ff ff incl -0xec(%ebp)
112bfc: 01 bd 2c ff ff ff add %edi,-0xd4(%ebp)
112c02: e9 09 fd ff ff jmp 112910 <msdos_find_name_in_fat_file+0x1f0>
112c07: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
112c0e: 66 90 xchg %ax,%ax
entry_matched = false;
112c10: c6 85 4f ff ff ff 00 movb $0x0,-0xb1(%ebp)
if ((*MSDOS_DIR_ENTRY_TYPE(entry) &
112c17: f6 03 40 testb $0x40,(%ebx)
112c1a: 0f 84 ee fd ff ff je 112a0e <msdos_find_name_in_fat_file+0x2ee>
lfn_start.ofs = dir_entry;
112c20: 89 bd 58 ff ff ff mov %edi,-0xa8(%ebp)
lfn_start.cln = dir_offset;
112c26: 8b 85 14 ff ff ff mov -0xec(%ebp),%eax
112c2c: 89 85 54 ff ff ff mov %eax,-0xac(%ebp)
lfn_entry = (*MSDOS_DIR_ENTRY_TYPE(entry)
112c32: 0f b6 03 movzbl (%ebx),%eax
112c35: 83 e0 3f and $0x3f,%eax
112c38: 89 85 20 ff ff ff mov %eax,-0xe0(%ebp)
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
112c3e: 0f b6 43 0d movzbl 0xd(%ebx),%eax
112c42: 88 85 13 ff ff ff mov %al,-0xed(%ebp)
lfn_entry--;
112c48: ff 8d 20 ff ff ff decl -0xe0(%ebp)
size_t bytes_in_utf8 = buf_size;
112c4e: b8 70 00 00 00 mov $0x70,%eax
bool is_first_lfn_entry =
112c53: 31 c9 xor %ecx,%ecx
112c55: 42 inc %edx
size_t bytes_in_utf8 = buf_size;
112c56: 89 85 50 ff ff ff mov %eax,-0xb0(%ebp)
bool is_first_lfn_entry =
112c5c: 0f 94 c1 sete %cl
112c5f: 89 d8 mov %ebx,%eax
112c61: 8d 95 5e ff ff ff lea -0xa2(%ebp),%edx
112c67: e8 24 f0 ff ff call 111c90 <msdos_get_utf16_string_from_long_entry.part.0>
112c6c: 8d 95 78 ff ff ff lea -0x88(%ebp),%edx
if (retval >= 0) {
112c72: 85 c0 test %eax,%eax
112c74: 89 c1 mov %eax,%ecx
112c76: 78 68 js 112ce0 <msdos_find_name_in_fat_file+0x5c0> <== NEVER TAKEN
eno = (*converter->handler->utf16_to_utf8) (
112c78: 8b 9d 1c ff ff ff mov -0xe4(%ebp),%ebx
112c7e: 8d 95 50 ff ff ff lea -0xb0(%ebp),%edx
112c84: 8b 03 mov (%ebx),%eax
112c86: 89 54 24 10 mov %edx,0x10(%esp)
112c8a: 8d 95 78 ff ff ff lea -0x88(%ebp),%edx
112c90: 89 54 24 0c mov %edx,0xc(%esp)
112c94: 89 95 40 ff ff ff mov %edx,-0xc0(%ebp)
112c9a: 8d 95 5e ff ff ff lea -0xa2(%ebp),%edx
112ca0: 89 54 24 04 mov %edx,0x4(%esp)
112ca4: 89 1c 24 mov %ebx,(%esp)
112ca7: 89 4c 24 08 mov %ecx,0x8(%esp)
112cab: ff 50 0c call *0xc(%eax)
if ( eno == 0 ) {
112cae: 8b 95 40 ff ff ff mov -0xc0(%ebp),%edx
112cb4: 85 c0 test %eax,%eax
eno = (*converter->handler->utf16_to_utf8) (
112cb6: 89 c3 mov %eax,%ebx
if ( eno == 0 ) {
112cb8: 0f 84 a0 03 00 00 je 11305e <msdos_find_name_in_fat_file+0x93e>
112cbe: 89 95 40 ff ff ff mov %edx,-0xc0(%ebp)
errno = eno;
112cc4: e8 d7 3b 01 00 call 1268a0 <__errno>
112cc9: 8b 95 40 ff ff ff mov -0xc0(%ebp),%edx <== NOT EXECUTED
bytes_in_entry = msdos_long_entry_to_utf8_name (
112ccf: b9 ff ff ff ff mov $0xffffffff,%ecx <== NOT EXECUTED
errno = eno;
112cd4: 89 18 mov %ebx,(%eax) <== NOT EXECUTED
if (bytes_in_entry > 0) {
112cd6: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
112cdd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
name_len_remaining = msdos_compare_entry_against_filename (
112ce0: 8d 85 4f ff ff ff lea -0xb1(%ebp),%eax
112ce6: 89 44 24 08 mov %eax,0x8(%esp)
112cea: 8b 85 3c ff ff ff mov -0xc4(%ebp),%eax
112cf0: 89 44 24 04 mov %eax,0x4(%esp)
112cf4: 8b 85 0c ff ff ff mov -0xf4(%ebp),%eax
112cfa: 89 04 24 mov %eax,(%esp)
112cfd: 8b 85 1c ff ff ff mov -0xe4(%ebp),%eax
112d03: e8 48 ed ff ff call 111a50 <msdos_compare_entry_against_filename>
112d08: 89 85 3c ff ff ff mov %eax,-0xc4(%ebp)
if (name_len_remaining < 0 || !entry_matched) {
112d0e: 85 c0 test %eax,%eax
112d10: 0f 88 9a fe ff ff js 112bb0 <msdos_find_name_in_fat_file+0x490> <== NEVER TAKEN
112d16: 80 bd 4f ff ff ff 00 cmpb $0x0,-0xb1(%ebp)
112d1d: 0f 84 8d fe ff ff je 112bb0 <msdos_find_name_in_fat_file+0x490>
112d23: e9 a6 fe ff ff jmp 112bce <msdos_find_name_in_fat_file+0x4ae>
112d28: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
112d2f: 90 nop
bytes_written = bytes_converted;
112d30: 8b 8d 50 ff ff ff mov -0xb0(%ebp),%ecx
if (bytes_in_entry > 0) {
112d36: 85 c9 test %ecx,%ecx
112d38: 0f 84 72 fe ff ff je 112bb0 <msdos_find_name_in_fat_file+0x490> <== NEVER TAKEN
112d3e: 66 90 xchg %ax,%ax
112d40: e9 2b fe ff ff jmp 112b70 <msdos_find_name_in_fat_file+0x450>
112d45: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
112d4c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
if (!create_node)
112d50: 80 bd 38 ff ff ff 00 cmpb $0x0,-0xc8(%ebp)
rc = MSDOS_NAME_NOT_FOUND_ERR;
112d57: b8 01 7d 00 00 mov $0x7d01,%eax
if (!create_node)
112d5c: 0f 84 63 fa ff ff je 1127c5 <msdos_find_name_in_fat_file+0xa5>
if ( !empty_space_found
112d62: 80 bd 28 ff ff ff 00 cmpb $0x0,-0xd8(%ebp)
112d69: 75 0f jne 112d7a <msdos_find_name_in_fat_file+0x65a>
*empty_entry_count +=
112d6b: 8b 85 fc fe ff ff mov -0x104(%ebp),%eax
entries_per_block - (dir_entry / MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
112d71: c1 ef 05 shr $0x5,%edi
*empty_entry_count +=
112d74: 01 f0 add %esi,%eax
112d76: 29 f8 sub %edi,%eax
112d78: 89 c6 mov %eax,%esi
switch (name_type) {
112d7a: 83 7d 1c 01 cmpl $0x1,0x1c(%ebp)
112d7e: 0f 84 a5 03 00 00 je 113129 <msdos_find_name_in_fat_file+0xa09>
112d84: 83 7d 1c 02 cmpl $0x2,0x1c(%ebp)
112d88: 0f 85 27 fa ff ff jne 1127b5 <msdos_find_name_in_fat_file+0x95> <== NEVER TAKEN
name_len_for_save = msdos_filename_utf8_to_long_name_for_save (
112d8e: 8b 85 04 ff ff ff mov -0xfc(%ebp),%eax
112d94: 89 44 24 10 mov %eax,0x10(%esp)
112d98: 8b 85 0c ff ff ff mov -0xf4(%ebp),%eax
112d9e: 89 44 24 0c mov %eax,0xc(%esp)
112da2: 8b 45 18 mov 0x18(%ebp),%eax
112da5: 89 44 24 08 mov %eax,0x8(%esp)
112da9: 8b 45 14 mov 0x14(%ebp),%eax
112dac: 89 44 24 04 mov %eax,0x4(%esp)
112db0: 8b 85 08 ff ff ff mov -0xf8(%ebp),%eax
112db6: 89 04 24 mov %eax,(%esp)
112db9: e8 82 60 00 00 call 118e40 <msdos_filename_utf8_to_long_name_for_save>
if (name_len_for_save > 0) {
112dbe: 85 c0 test %eax,%eax
112dc0: 0f 8e 44 fa ff ff jle 11280a <msdos_find_name_in_fat_file+0xea> <== NEVER TAKEN
lfn_entries = (name_len_for_save + MSDOS_LFN_ENTRY_SIZE - 1)
112dc6: 83 c0 19 add $0x19,%eax
/ MSDOS_LFN_ENTRY_SIZE;
112dc9: ba 4f ec c4 4e mov $0x4ec4ec4f,%edx
112dce: f7 e2 mul %edx
112dd0: 89 d0 mov %edx,%eax
112dd2: c1 e8 03 shr $0x3,%eax
112dd5: 89 85 40 ff ff ff mov %eax,-0xc0(%ebp)
if (empty_entry_count < lfn_entries + 1)
112ddb: 8d 78 01 lea 0x1(%eax),%edi
112dde: 39 f7 cmp %esi,%edi
112de0: 76 4c jbe 112e2e <msdos_find_name_in_fat_file+0x70e>
empty_file_offset = fat_fd->fat_file_size -
112de2: 8b 45 0c mov 0xc(%ebp),%eax
ret = fat_file_extend(&fs_info->fat,
112de5: b9 01 00 00 00 mov $0x1,%ecx
112dea: 8b 95 24 ff ff ff mov -0xdc(%ebp),%edx
empty_file_offset = fat_fd->fat_file_size -
112df0: 8b 58 18 mov 0x18(%eax),%ebx
ret = fat_file_extend(&fs_info->fat,
112df3: 8d 85 78 ff ff ff lea -0x88(%ebp),%eax
112df9: 89 44 24 10 mov %eax,0x10(%esp)
112dfd: 8b 42 08 mov 0x8(%edx),%eax
112e00: 89 4c 24 08 mov %ecx,0x8(%esp)
112e04: 89 14 24 mov %edx,(%esp)
112e07: 01 d8 add %ebx,%eax
112e09: 89 44 24 0c mov %eax,0xc(%esp)
112e0d: 8b 45 0c mov 0xc(%ebp),%eax
112e10: 89 44 24 04 mov %eax,0x4(%esp)
112e14: e8 b7 dc ff ff call 110ad0 <fat_file_extend>
if (ret != RC_OK)
112e19: 85 c0 test %eax,%eax
112e1b: 0f 85 a4 f9 ff ff jne 1127c5 <msdos_find_name_in_fat_file+0xa5> <== NEVER TAKEN
empty_entry_count * MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
112e21: 89 f0 mov %esi,%eax
112e23: c1 e0 05 shl $0x5,%eax
empty_file_offset = fat_fd->fat_file_size -
112e26: 29 c3 sub %eax,%ebx
112e28: 89 9d 34 ff ff ff mov %ebx,-0xcc(%ebp)
if ((*c == ' ') || (*c == '.'))
112e2e: 8b 45 24 mov 0x24(%ebp),%eax
slot = (empty_file_offset /
112e31: 8b 9d 34 ff ff ff mov -0xcc(%ebp),%ebx
if ((*c == ' ') || (*c == '.'))
112e37: 0f b6 00 movzbl (%eax),%eax
slot = (empty_file_offset /
112e3a: c1 eb 05 shr $0x5,%ebx
112e3d: 01 fb add %edi,%ebx
if ((*c == ' ') || (*c == '.'))
112e3f: 3c 20 cmp $0x20,%al
112e41: 0f 84 0a 05 00 00 je 113351 <msdos_find_name_in_fat_file+0xc31> <== NEVER TAKEN
112e47: 3c 2e cmp $0x2e,%al
112e49: 0f 84 02 05 00 00 je 113351 <msdos_find_name_in_fat_file+0xc31> <== NEVER TAKEN
112e4f: 8b 45 24 mov 0x24(%ebp),%eax
112e52: 0f b6 40 01 movzbl 0x1(%eax),%eax
112e56: 3c 20 cmp $0x20,%al
112e58: 0f 84 2b 05 00 00 je 113389 <msdos_find_name_in_fat_file+0xc69>
112e5e: 3c 2e cmp $0x2e,%al
112e60: 0f 84 23 05 00 00 je 113389 <msdos_find_name_in_fat_file+0xc69> <== NEVER TAKEN
for (i = 0; i < 2; i++, c++)
112e66: 8b 45 24 mov 0x24(%ebp),%eax
112e69: b9 0c 00 00 00 mov $0xc,%ecx
112e6e: 83 c0 02 add $0x2,%eax
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
112e71: 89 da mov %ebx,%edx
for (i = 0; i < 4; i++, c++)
112e73: 40 inc %eax
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
112e74: d3 ea shr %cl,%edx
for (i = 0; i < 4; i++, c++)
112e76: 83 e9 04 sub $0x4,%ecx
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
112e79: 83 e2 0f and $0xf,%edx
112e7c: 0f b6 92 24 37 13 00 movzbl 0x133724(%edx),%edx
112e83: 88 50 ff mov %dl,-0x1(%eax)
for (i = 0; i < 4; i++, c++)
112e86: 83 f9 fc cmp $0xfffffffc,%ecx
112e89: 75 e6 jne 112e71 <msdos_find_name_in_fat_file+0x751>
*c++ = '~';
112e8b: 8b 45 24 mov 0x24(%ebp),%eax
cs = 0;
112e8e: 31 d2 xor %edx,%edx
*c++ = '~';
112e90: 66 c7 40 06 7e 31 movw $0x317e,0x6(%eax)
for (i = 0; i < MSDOS_SHORT_NAME_LEN; ++i) {
112e96: 8d 58 0b lea 0xb(%eax),%ebx
112e99: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + name[i];
112ea0: 88 d1 mov %dl,%cl
for (i = 0; i < MSDOS_SHORT_NAME_LEN; ++i) {
112ea2: 40 inc %eax
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + name[i];
112ea3: d0 ea shr %dl
112ea5: 02 50 ff add -0x1(%eax),%dl
112ea8: c0 e1 07 shl $0x7,%cl
112eab: 00 ca add %cl,%dl
for (i = 0; i < MSDOS_SHORT_NAME_LEN; ++i) {
112ead: 39 c3 cmp %eax,%ebx
112eaf: 75 ef jne 112ea0 <msdos_find_name_in_fat_file+0x780>
pos->ofs = file_offset & (bts2rd - 1);
112eb1: 88 95 30 ff ff ff mov %dl,-0xd0(%ebp)
112eb7: 8b 9d 34 ff ff ff mov -0xcc(%ebp),%ebx
112ebd: 8b b5 44 ff ff ff mov -0xbc(%ebp),%esi
112ec3: 8b 55 20 mov 0x20(%ebp),%edx
112ec6: 89 d8 mov %ebx,%eax
112ec8: 4e dec %esi
112ec9: 21 f0 and %esi,%eax
112ecb: 89 42 0c mov %eax,0xc(%edx)
return fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
112ece: 89 d0 mov %edx,%eax
112ed0: 89 5c 24 0c mov %ebx,0xc(%esp)
112ed4: 83 c0 08 add $0x8,%eax
112ed7: 89 44 24 10 mov %eax,0x10(%esp)
112edb: b8 01 00 00 00 mov $0x1,%eax
112ee0: 89 44 24 08 mov %eax,0x8(%esp)
112ee4: 8b 45 0c mov 0xc(%ebp),%eax
112ee7: 89 44 24 04 mov %eax,0x4(%esp)
112eeb: 8b 85 24 ff ff ff mov -0xdc(%ebp),%eax
112ef1: 89 04 24 mov %eax,(%esp)
112ef4: e8 27 db ff ff call 110a20 <fat_file_ioctl>
if (ret != RC_OK)
112ef9: 85 c0 test %eax,%eax
112efb: 0f 85 c4 f8 ff ff jne 1127c5 <msdos_find_name_in_fat_file+0xa5> <== NEVER TAKEN
* MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
112f01: 8b 9d 40 ff ff ff mov -0xc0(%ebp),%ebx
length = (lfn_entries + 1) * MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
112f07: c1 e7 05 shl $0x5,%edi
pos->ofs = file_offset & (bts2rd - 1);
112f0a: 89 f0 mov %esi,%eax
length = (lfn_entries + 1) * MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
112f0c: 89 bd 28 ff ff ff mov %edi,-0xd8(%ebp)
short_file_offset = empty_file_offset + lfn_entries
112f12: 8b 8d 34 ff ff ff mov -0xcc(%ebp),%ecx
if (bytes_written == (ssize_t) length)
112f18: 89 bd 2c ff ff ff mov %edi,-0xd4(%ebp)
pos->ofs = file_offset & (bts2rd - 1);
112f1e: 8b 75 20 mov 0x20(%ebp),%esi
return fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
112f21: 8b bd 24 ff ff ff mov -0xdc(%ebp),%edi
* MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
112f27: c1 e3 05 shl $0x5,%ebx
short_file_offset = empty_file_offset + lfn_entries
112f2a: 8d 14 0b lea (%ebx,%ecx,1),%edx
pos->ofs = file_offset & (bts2rd - 1);
112f2d: 21 d0 and %edx,%eax
112f2f: 89 46 04 mov %eax,0x4(%esi)
return fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
112f32: 89 74 24 10 mov %esi,0x10(%esp)
112f36: be 01 00 00 00 mov $0x1,%esi
112f3b: 89 74 24 08 mov %esi,0x8(%esp)
112f3f: 8b 75 0c mov 0xc(%ebp),%esi
112f42: 89 54 24 0c mov %edx,0xc(%esp)
112f46: 89 3c 24 mov %edi,(%esp)
112f49: 89 74 24 04 mov %esi,0x4(%esp)
112f4d: e8 ce da ff ff call 110a20 <fat_file_ioctl>
*MSDOS_DIR_ENTRY_TYPE(entry) = lfn_entries - lfn_entry;
112f52: 8b 95 40 ff ff ff mov -0xc0(%ebp),%edx
112f58: 8b b5 0c ff ff ff mov -0xf4(%ebp),%esi
entry = fs_info->cl_buf;
112f5e: 8b bf c4 00 00 00 mov 0xc4(%edi),%edi
*MSDOS_DIR_ENTRY_TYPE(entry) = lfn_entries - lfn_entry;
112f64: 88 95 40 ff ff ff mov %dl,-0xc0(%ebp)
112f6a: 8d 04 52 lea (%edx,%edx,2),%eax
112f6d: 8d 04 82 lea (%edx,%eax,4),%eax
112f70: 8d 44 46 e6 lea -0x1a(%esi,%eax,2),%eax
112f74: 89 85 3c ff ff ff mov %eax,-0xc4(%ebp)
112f7a: 8d 04 1f lea (%edi,%ebx,1),%eax
112f7d: 89 85 38 ff ff ff mov %eax,-0xc8(%ebp)
for (lfn_entry = 0; lfn_entry < lfn_entries; ++lfn_entry) {
112f83: 31 c0 xor %eax,%eax
112f85: 89 85 44 ff ff ff mov %eax,-0xbc(%ebp)
112f8b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
112f8f: 90 nop
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
112f90: f7 c7 01 00 00 00 test $0x1,%edi
112f96: 89 f9 mov %edi,%ecx
112f98: 8d 47 01 lea 0x1(%edi),%eax
112f9b: bb 20 00 00 00 mov $0x20,%ebx
112fa0: 0f 85 d4 03 00 00 jne 11337a <msdos_find_name_in_fat_file+0xc5a> <== NEVER TAKEN
112fa6: f6 c1 02 test $0x2,%cl
112fa9: 0f 85 bb 03 00 00 jne 11336a <msdos_find_name_in_fat_file+0xc4a> <== NEVER TAKEN
112faf: 89 de mov %ebx,%esi
112fb1: 31 d2 xor %edx,%edx
112fb3: 83 e6 f8 and $0xfffffff8,%esi
112fb6: c7 04 11 00 00 00 00 movl $0x0,(%ecx,%edx,1)
112fbd: c7 44 11 04 00 00 00 movl $0x0,0x4(%ecx,%edx,1)
112fc4: 00
112fc5: 83 c2 08 add $0x8,%edx
112fc8: 39 f2 cmp %esi,%edx
112fca: 72 ea jb 112fb6 <msdos_find_name_in_fat_file+0x896>
112fcc: 01 d1 add %edx,%ecx
112fce: f6 c3 04 test $0x4,%bl
112fd1: 74 09 je 112fdc <msdos_find_name_in_fat_file+0x8bc> <== ALWAYS TAKEN
112fd3: c7 01 00 00 00 00 movl $0x0,(%ecx) <== NOT EXECUTED
112fd9: 83 c1 04 add $0x4,%ecx <== NOT EXECUTED
112fdc: f6 c3 02 test $0x2,%bl
112fdf: 74 08 je 112fe9 <msdos_find_name_in_fat_file+0x8c9> <== ALWAYS TAKEN
112fe1: 66 c7 01 00 00 movw $0x0,(%ecx) <== NOT EXECUTED
112fe6: 83 c1 02 add $0x2,%ecx <== NOT EXECUTED
112fe9: f6 c3 01 test $0x1,%bl
112fec: 74 03 je 112ff1 <msdos_find_name_in_fat_file+0x8d1> <== ALWAYS TAKEN
112fee: c6 01 00 movb $0x0,(%ecx) <== NOT EXECUTED
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
112ff1: 0f b6 9d 30 ff ff ff movzbl -0xd0(%ebp),%ebx
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; ++i)
112ff8: 31 d2 xor %edx,%edx
n = (const uint8_t *) name_converted +
112ffa: 8b b5 3c ff ff ff mov -0xc4(%ebp),%esi
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
113000: 88 5f 0d mov %bl,0xd(%edi)
uint8_t fill = 0;
113003: 31 db xor %ebx,%ebx
if (*n != 0 || *(n + 1) != 0)
113005: 0f b6 0e movzbl (%esi),%ecx
113008: 84 c9 test %cl,%cl
11300a: 75 37 jne 113043 <msdos_find_name_in_fat_file+0x923> <== ALWAYS TAKEN
11300c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
113010: 80 7e 01 00 cmpb $0x0,0x1(%esi)
113014: 75 2d jne 113043 <msdos_find_name_in_fat_file+0x923>
p [0] = fill;
113016: 88 18 mov %bl,(%eax)
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; ++i)
113018: 8d 4a 01 lea 0x1(%edx),%ecx
switch (i)
11301b: 83 fa 04 cmp $0x4,%edx
p [1] = fill;
11301e: 88 58 01 mov %bl,0x1(%eax)
fill = 0xff;
113021: b3 ff mov $0xff,%bl
switch (i)
113023: 74 32 je 113057 <msdos_find_name_in_fat_file+0x937>
113025: 83 fa 0a cmp $0xa,%edx
113028: 0f 84 32 03 00 00 je 113360 <msdos_find_name_in_fat_file+0xc40>
p += 2;
11302e: 83 c0 02 add $0x2,%eax
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; ++i)
113031: 83 f9 0d cmp $0xd,%ecx
113034: 0f 84 d6 02 00 00 je 113310 <msdos_find_name_in_fat_file+0xbf0>
11303a: 89 ca mov %ecx,%edx
if (*n != 0 || *(n + 1) != 0)
11303c: 0f b6 0e movzbl (%esi),%ecx
11303f: 84 c9 test %cl,%cl
113041: 74 cd je 113010 <msdos_find_name_in_fat_file+0x8f0>
*p = *n;
113043: 88 08 mov %cl,(%eax)
n += MSDOS_NAME_LFN_BYTES_PER_CHAR;
113045: 83 c6 02 add $0x2,%esi
*(p + 1) = *(n + 1);
113048: 0f b6 4e ff movzbl -0x1(%esi),%ecx
switch (i)
11304c: 83 fa 04 cmp $0x4,%edx
*(p + 1) = *(n + 1);
11304f: 88 48 01 mov %cl,0x1(%eax)
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; ++i)
113052: 8d 4a 01 lea 0x1(%edx),%ecx
switch (i)
113055: 75 ce jne 113025 <msdos_find_name_in_fat_file+0x905>
p += 5;
113057: 83 c0 05 add $0x5,%eax
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; ++i)
11305a: 89 ca mov %ecx,%edx
11305c: eb de jmp 11303c <msdos_find_name_in_fat_file+0x91c>
retval = bytes_in_utf8;
11305e: 8b 8d 50 ff ff ff mov -0xb0(%ebp),%ecx
if (bytes_in_entry > 0) {
113064: 85 c9 test %ecx,%ecx
113066: 0f 84 44 fb ff ff je 112bb0 <msdos_find_name_in_fat_file+0x490> <== NEVER TAKEN
11306c: e9 6f fc ff ff jmp 112ce0 <msdos_find_name_in_fat_file+0x5c0>
113071: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
113078: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11307f: 90 nop
cs = 0;
113080: 89 9d 00 ff ff ff mov %ebx,-0x100(%ebp)
113086: 8d 4b 0b lea 0xb(%ebx),%ecx
113089: 89 8d 3c ff ff ff mov %ecx,-0xc4(%ebp)
11308f: 8d 53 01 lea 0x1(%ebx),%edx
113092: 31 c9 xor %ecx,%ecx
113094: 8b 9d 3c ff ff ff mov -0xc4(%ebp),%ebx
11309a: eb 08 jmp 1130a4 <msdos_find_name_in_fat_file+0x984>
11309c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + name[i];
1130a0: 0f b6 02 movzbl (%edx),%eax
1130a3: 42 inc %edx
1130a4: d0 c9 ror %cl
1130a6: 00 c1 add %al,%cl
for (i = 0; i < MSDOS_SHORT_NAME_LEN; ++i) {
1130a8: 39 d3 cmp %edx,%ebx
1130aa: 75 f4 jne 1130a0 <msdos_find_name_in_fat_file+0x980>
name_len_remaining > 0 ||
1130ac: 3a 8d 13 ff ff ff cmp -0xed(%ebp),%cl
1130b2: 8b 9d 00 ff ff ff mov -0x100(%ebp),%ebx
1130b8: 0f 85 32 f9 ff ff jne 1129f0 <msdos_find_name_in_fat_file+0x2d0> <== NEVER TAKEN
rc = msdos_on_entry_found (
1130be: 8d 85 54 ff ff ff lea -0xac(%ebp),%eax
1130c4: 8b 8d 44 ff ff ff mov -0xbc(%ebp),%ecx
1130ca: 89 44 24 14 mov %eax,0x14(%esp)
1130ce: 8b 85 14 ff ff ff mov -0xec(%ebp),%eax
1130d4: 89 7c 24 10 mov %edi,0x10(%esp)
1130d8: 8b 55 0c mov 0xc(%ebp),%edx
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
1130db: 83 c7 20 add $0x20,%edi
rc = msdos_on_entry_found (
1130de: 89 5c 24 04 mov %ebx,0x4(%esp)
1130e2: 89 44 24 0c mov %eax,0xc(%esp)
1130e6: 8b 45 20 mov 0x20(%ebp),%eax
1130e9: 89 44 24 08 mov %eax,0x8(%esp)
1130ed: 8b 45 24 mov 0x24(%ebp),%eax
1130f0: 89 04 24 mov %eax,(%esp)
1130f3: 8b 85 24 ff ff ff mov -0xdc(%ebp),%eax
1130f9: e8 22 ea ff ff call 111b20 <msdos_on_entry_found>
for (dir_entry = 0;
1130fe: 39 bd 44 ff ff ff cmp %edi,-0xbc(%ebp)
113104: 0f 86 3d 03 00 00 jbe 113447 <msdos_find_name_in_fat_file+0xd27>
11310a: 85 c0 test %eax,%eax
11310c: 0f 85 35 03 00 00 jne 113447 <msdos_find_name_in_fat_file+0xd27> <== NEVER TAKEN
if ( retval == RC_OK
113112: 80 bd 38 ff ff ff 00 cmpb $0x0,-0xc8(%ebp)
113119: 0f 84 a6 f6 ff ff je 1127c5 <msdos_find_name_in_fat_file+0xa5> <== ALWAYS TAKEN
switch (name_type) {
11311f: 83 7d 1c 01 cmpl $0x1,0x1c(%ebp) <== NOT EXECUTED
113123: 0f 85 5b fc ff ff jne 112d84 <msdos_find_name_in_fat_file+0x664> <== NOT EXECUTED
name_len_for_save = msdos_filename_utf8_to_short_name_for_save (
113129: b8 0b 00 00 00 mov $0xb,%eax
11312e: 89 44 24 10 mov %eax,0x10(%esp)
113132: 8b 85 0c ff ff ff mov -0xf4(%ebp),%eax
113138: 89 44 24 0c mov %eax,0xc(%esp)
11313c: 8b 45 18 mov 0x18(%ebp),%eax
11313f: 89 44 24 08 mov %eax,0x8(%esp)
113143: 8b 45 14 mov 0x14(%ebp),%eax
113146: 89 44 24 04 mov %eax,0x4(%esp)
11314a: 8b 85 08 ff ff ff mov -0xf8(%ebp),%eax
113150: 89 04 24 mov %eax,(%esp)
113153: e8 c8 5f 00 00 call 119120 <msdos_filename_utf8_to_short_name_for_save>
if (name_len_for_save > 0 ) {
113158: 85 c0 test %eax,%eax
11315a: 0f 8e aa f6 ff ff jle 11280a <msdos_find_name_in_fat_file+0xea> <== NEVER TAKEN
if (empty_entry_count < lfn_entries + 1)
113160: 85 f6 test %esi,%esi
113162: 0f 84 64 02 00 00 je 1133cc <msdos_find_name_in_fat_file+0xcac>
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
113168: 8b 45 20 mov 0x20(%ebp),%eax
pos->ofs = file_offset & (bts2rd - 1);
11316b: 8b bd 34 ff ff ff mov -0xcc(%ebp),%edi
113171: 8b 75 20 mov 0x20(%ebp),%esi
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
113174: c7 40 08 ff ff ff ff movl $0xffffffff,0x8(%eax)
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
11317b: c7 40 0c ff ff ff ff movl $0xffffffff,0xc(%eax)
pos->ofs = file_offset & (bts2rd - 1);
113182: 8b 85 44 ff ff ff mov -0xbc(%ebp),%eax
113188: 48 dec %eax
113189: 21 f8 and %edi,%eax
11318b: 89 46 04 mov %eax,0x4(%esi)
return fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
11318e: b8 01 00 00 00 mov $0x1,%eax
113193: 89 7c 24 0c mov %edi,0xc(%esp)
113197: 8b bd 24 ff ff ff mov -0xdc(%ebp),%edi
11319d: 89 44 24 08 mov %eax,0x8(%esp)
1131a1: 8b 45 0c mov 0xc(%ebp),%eax
1131a4: 89 74 24 10 mov %esi,0x10(%esp)
1131a8: 89 3c 24 mov %edi,(%esp)
1131ab: 89 44 24 04 mov %eax,0x4(%esp)
1131af: e8 6c d8 ff ff call 110a20 <fat_file_ioctl>
entry = fs_info->cl_buf;
1131b4: 8b 87 c4 00 00 00 mov 0xc4(%edi),%eax
1131ba: ba 20 00 00 00 mov $0x20,%edx
1131bf: 89 95 2c ff ff ff mov %edx,-0xd4(%ebp)
1131c5: b9 20 00 00 00 mov $0x20,%ecx
1131ca: 89 8d 28 ff ff ff mov %ecx,-0xd8(%ebp)
1131d0: 89 85 38 ff ff ff mov %eax,-0xc8(%ebp)
memcpy(entry, name_dir_entry, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
1131d6: 8b 85 38 ff ff ff mov -0xc8(%ebp),%eax
1131dc: be 20 00 00 00 mov $0x20,%esi
1131e1: 8b 4d 24 mov 0x24(%ebp),%ecx
1131e4: a8 01 test $0x1,%al
1131e6: 0f 85 be 01 00 00 jne 1133aa <msdos_find_name_in_fat_file+0xc8a> <== NEVER TAKEN
1131ec: a8 02 test $0x2,%al
1131ee: 0f 85 a1 01 00 00 jne 113395 <msdos_find_name_in_fat_file+0xc75> <== NEVER TAKEN
1131f4: 89 f3 mov %esi,%ebx
1131f6: 31 d2 xor %edx,%edx
1131f8: 83 e3 fc and $0xfffffffc,%ebx
1131fb: 8b 3c 11 mov (%ecx,%edx,1),%edi
1131fe: 89 3c 10 mov %edi,(%eax,%edx,1)
113201: 83 c2 04 add $0x4,%edx
113204: 39 da cmp %ebx,%edx
113206: 72 f3 jb 1131fb <msdos_find_name_in_fat_file+0xadb>
113208: 01 d0 add %edx,%eax
11320a: 01 d1 add %edx,%ecx
11320c: 31 d2 xor %edx,%edx
11320e: f7 c6 02 00 00 00 test $0x2,%esi
113214: 74 0b je 113221 <msdos_find_name_in_fat_file+0xb01> <== ALWAYS TAKEN
113216: 0f b7 11 movzwl (%ecx),%edx <== NOT EXECUTED
113219: 66 89 10 mov %dx,(%eax) <== NOT EXECUTED
11321c: ba 02 00 00 00 mov $0x2,%edx <== NOT EXECUTED
113221: 83 e6 01 and $0x1,%esi
113224: 74 07 je 11322d <msdos_find_name_in_fat_file+0xb0d> <== ALWAYS TAKEN
113226: 0f b6 1c 11 movzbl (%ecx,%edx,1),%ebx <== NOT EXECUTED
11322a: 88 1c 10 mov %bl,(%eax,%edx,1) <== NOT EXECUTED
bytes_written = fat_file_write(&fs_info->fat, fat_fd,
11322d: 8b bd 24 ff ff ff mov -0xdc(%ebp),%edi
113233: 8b 87 c4 00 00 00 mov 0xc4(%edi),%eax
113239: 89 3c 24 mov %edi,(%esp)
11323c: 89 44 24 10 mov %eax,0x10(%esp)
113240: 8b 85 28 ff ff ff mov -0xd8(%ebp),%eax
113246: 89 44 24 0c mov %eax,0xc(%esp)
11324a: 8b 85 34 ff ff ff mov -0xcc(%ebp),%eax
113250: 89 44 24 08 mov %eax,0x8(%esp)
113254: 8b 45 0c mov 0xc(%ebp),%eax
113257: 89 44 24 04 mov %eax,0x4(%esp)
11325b: e8 30 db ff ff call 110d90 <fat_file_write>
if (bytes_written == (ssize_t) length)
113260: 3b 85 2c ff ff ff cmp -0xd4(%ebp),%eax
113266: 0f 84 96 00 00 00 je 113302 <msdos_find_name_in_fat_file+0xbe2> <== ALWAYS TAKEN
else if (bytes_written == -1)
11326c: 40 inc %eax <== NOT EXECUTED
11326d: 0f 84 97 f5 ff ff je 11280a <msdos_find_name_in_fat_file+0xea> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
113273: e8 28 36 01 00 call 1268a0 <__errno> <== NOT EXECUTED
113278: c7 00 05 00 00 00 movl $0x5,(%eax) <== NOT EXECUTED
11327e: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
113283: e9 87 f5 ff ff jmp 11280f <msdos_find_name_in_fat_file+0xef> <== NOT EXECUTED
name_len_for_compare = msdos_filename_utf8_to_long_name_for_compare (
113288: 89 7c 24 10 mov %edi,0x10(%esp)
11328c: 8b 7d 18 mov 0x18(%ebp),%edi
11328f: 89 74 24 0c mov %esi,0xc(%esp)
113293: 8b 85 08 ff ff ff mov -0xf8(%ebp),%eax
113299: 89 7c 24 08 mov %edi,0x8(%esp)
11329d: 8b 7d 14 mov 0x14(%ebp),%edi
1132a0: 89 04 24 mov %eax,(%esp)
1132a3: 89 7c 24 04 mov %edi,0x4(%esp)
1132a7: e8 94 5a 00 00 call 118d40 <msdos_filename_utf8_to_long_name_for_compare>
1132ac: 89 85 30 ff ff ff mov %eax,-0xd0(%ebp)
if (0 >= name_len_for_compare) {
1132b2: 85 c0 test %eax,%eax
1132b4: 0f 8e 50 f5 ff ff jle 11280a <msdos_find_name_in_fat_file+0xea> <== NEVER TAKEN
lfn_entries = (name_len_for_save + MSDOS_LFN_ENTRY_SIZE - 1)
1132ba: 8d 53 19 lea 0x19(%ebx),%edx
/ MSDOS_LFN_ENTRY_SIZE;
1132bd: b9 4f ec c4 4e mov $0x4ec4ec4f,%ecx
1132c2: 89 d0 mov %edx,%eax
1132c4: f7 e1 mul %ecx
1132c6: c1 ea 03 shr $0x3,%edx
1132c9: 89 95 18 ff ff ff mov %edx,-0xe8(%ebp)
1132cf: e9 b3 f5 ff ff jmp 112887 <msdos_find_name_in_fat_file+0x167>
1132d4: 8b 85 24 ff ff ff mov -0xdc(%ebp),%eax <== NOT EXECUTED
1132da: 8b 80 c4 00 00 00 mov 0xc4(%eax),%eax <== NOT EXECUTED
1132e0: 89 85 40 ff ff ff mov %eax,-0xc0(%ebp) <== NOT EXECUTED
1132e6: e9 05 f9 ff ff jmp 112bf0 <msdos_find_name_in_fat_file+0x4d0> <== NOT EXECUTED
if (!create_node)
1132eb: 80 bd 38 ff ff ff 00 cmpb $0x0,-0xc8(%ebp)
1132f2: 0f 85 82 fa ff ff jne 112d7a <msdos_find_name_in_fat_file+0x65a> <== NEVER TAKEN
rc = MSDOS_NAME_NOT_FOUND_ERR;
1132f8: b8 01 7d 00 00 mov $0x7d01,%eax
if ( retval == RC_OK
1132fd: e9 c3 f4 ff ff jmp 1127c5 <msdos_find_name_in_fat_file+0xa5>
return 0;
113302: 31 c0 xor %eax,%eax
return retval;
113304: e9 bc f4 ff ff jmp 1127c5 <msdos_find_name_in_fat_file+0xa5>
113309: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
if (lfn_entry == 0)
113310: 8b b5 44 ff ff ff mov -0xbc(%ebp),%esi
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
113316: 0f b6 85 40 ff ff ff movzbl -0xc0(%ebp),%eax
if (lfn_entry == 0)
11331d: 85 f6 test %esi,%esi
11331f: 75 02 jne 113323 <msdos_find_name_in_fat_file+0xc03>
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
113321: 0c 40 or $0x40,%al
*MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;
113323: 80 4f 0b 0f orb $0xf,0xb(%edi)
entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
113327: 83 c7 20 add $0x20,%edi
for (lfn_entry = 0; lfn_entry < lfn_entries; ++lfn_entry) {
11332a: ff 85 44 ff ff ff incl -0xbc(%ebp)
113330: fe 8d 40 ff ff ff decb -0xc0(%ebp)
113336: 83 ad 3c ff ff ff 1a subl $0x1a,-0xc4(%ebp)
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
11333d: 88 47 e0 mov %al,-0x20(%edi)
for (lfn_entry = 0; lfn_entry < lfn_entries; ++lfn_entry) {
113340: 3b bd 38 ff ff ff cmp -0xc8(%ebp),%edi
113346: 0f 85 44 fc ff ff jne 112f90 <msdos_find_name_in_fat_file+0x870>
11334c: e9 85 fe ff ff jmp 1131d6 <msdos_find_name_in_fat_file+0xab6>
*c = '_';
113351: 8b 45 24 mov 0x24(%ebp),%eax <== NOT EXECUTED
113354: c6 00 5f movb $0x5f,(%eax) <== NOT EXECUTED
113357: e9 f3 fa ff ff jmp 112e4f <msdos_find_name_in_fat_file+0x72f> <== NOT EXECUTED
11335c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
p += 4;
113360: 83 c0 04 add $0x4,%eax
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; ++i)
113363: 89 ca mov %ecx,%edx
113365: e9 d2 fc ff ff jmp 11303c <msdos_find_name_in_fat_file+0x91c>
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
11336a: 66 c7 01 00 00 movw $0x0,(%ecx) <== NOT EXECUTED
11336f: 83 eb 02 sub $0x2,%ebx <== NOT EXECUTED
113372: 83 c1 02 add $0x2,%ecx <== NOT EXECUTED
113375: e9 35 fc ff ff jmp 112faf <msdos_find_name_in_fat_file+0x88f> <== NOT EXECUTED
11337a: c6 07 00 movb $0x0,(%edi) <== NOT EXECUTED
11337d: 89 c1 mov %eax,%ecx <== NOT EXECUTED
11337f: bb 1f 00 00 00 mov $0x1f,%ebx <== NOT EXECUTED
113384: e9 1d fc ff ff jmp 112fa6 <msdos_find_name_in_fat_file+0x886> <== NOT EXECUTED
*c = '_';
113389: 8b 45 24 mov 0x24(%ebp),%eax
11338c: c6 40 01 5f movb $0x5f,0x1(%eax)
113390: e9 d1 fa ff ff jmp 112e66 <msdos_find_name_in_fat_file+0x746>
memcpy(entry, name_dir_entry, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
113395: 0f b7 11 movzwl (%ecx),%edx <== NOT EXECUTED
113398: 83 c0 02 add $0x2,%eax <== NOT EXECUTED
11339b: 83 c1 02 add $0x2,%ecx <== NOT EXECUTED
11339e: 83 ee 02 sub $0x2,%esi <== NOT EXECUTED
1133a1: 66 89 50 fe mov %dx,-0x2(%eax) <== NOT EXECUTED
1133a5: e9 4a fe ff ff jmp 1131f4 <msdos_find_name_in_fat_file+0xad4> <== NOT EXECUTED
1133aa: 0f b6 19 movzbl (%ecx),%ebx <== NOT EXECUTED
1133ad: 40 inc %eax <== NOT EXECUTED
1133ae: 41 inc %ecx <== NOT EXECUTED
1133af: be 1f 00 00 00 mov $0x1f,%esi <== NOT EXECUTED
1133b4: 88 58 ff mov %bl,-0x1(%eax) <== NOT EXECUTED
1133b7: e9 30 fe ff ff jmp 1131ec <msdos_find_name_in_fat_file+0xacc> <== NOT EXECUTED
1133bc: 8d 95 78 ff ff ff lea -0x88(%ebp),%edx <== NOT EXECUTED
eno = EINVAL;
1133c2: b9 16 00 00 00 mov $0x16,%ecx <== NOT EXECUTED
1133c7: e9 7e f7 ff ff jmp 112b4a <msdos_find_name_in_fat_file+0x42a> <== NOT EXECUTED
empty_file_offset = fat_fd->fat_file_size -
1133cc: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
ret = fat_file_extend(&fs_info->fat,
1133cf: 8b b5 24 ff ff ff mov -0xdc(%ebp),%esi <== NOT EXECUTED
empty_file_offset = fat_fd->fat_file_size -
1133d5: 8b 78 18 mov 0x18(%eax),%edi <== NOT EXECUTED
ret = fat_file_extend(&fs_info->fat,
1133d8: 8d 85 78 ff ff ff lea -0x88(%ebp),%eax <== NOT EXECUTED
1133de: 89 44 24 10 mov %eax,0x10(%esp) <== NOT EXECUTED
1133e2: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED
1133e5: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
empty_file_offset = fat_fd->fat_file_size -
1133e8: 89 bd 34 ff ff ff mov %edi,-0xcc(%ebp) <== NOT EXECUTED
ret = fat_file_extend(&fs_info->fat,
1133ee: 01 f8 add %edi,%eax <== NOT EXECUTED
1133f0: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
1133f4: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
1133f9: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
1133fd: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
113400: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
113404: e8 c7 d6 ff ff call 110ad0 <fat_file_extend> <== NOT EXECUTED
if (ret != RC_OK)
113409: 85 c0 test %eax,%eax
11340b: 0f 84 57 fd ff ff je 113168 <msdos_find_name_in_fat_file+0xa48> <== NEVER TAKEN
113411: e9 af f3 ff ff jmp 1127c5 <msdos_find_name_in_fat_file+0xa5> <== NOT EXECUTED
113416: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11341d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
assert(bytes_read == bts2rd);
113420: b9 0f 37 13 00 mov $0x13370f,%ecx <== NOT EXECUTED
113425: bb 8c 37 13 00 mov $0x13378c,%ebx <== NOT EXECUTED
11342a: 89 4c 24 0c mov %ecx,0xc(%esp) <== NOT EXECUTED
11342e: be 4d 05 00 00 mov $0x54d,%esi <== NOT EXECUTED
113433: 89 5c 24 08 mov %ebx,0x8(%esp) <== NOT EXECUTED
113437: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED
11343b: c7 04 24 d0 36 13 00 movl $0x1336d0,(%esp) <== NOT EXECUTED
113442: e8 69 52 00 00 call 1186b0 <__assert_func> <== NOT EXECUTED
if ( retval == RC_OK
113447: 85 c0 test %eax,%eax
113449: 0f 94 c2 sete %dl
&& create_node) {
11344c: 20 95 38 ff ff ff and %dl,-0xc8(%ebp)
113452: e9 bb fc ff ff jmp 113112 <msdos_find_name_in_fat_file+0x9f2>
assert(name_utf8_len > 0);
113457: c7 44 24 0c fd 36 13 movl $0x1336fd,0xc(%esp) <== NOT EXECUTED
11345e: 00
11345f: c7 44 24 08 ac 37 13 movl $0x1337ac,0x8(%esp) <== NOT EXECUTED
113466: 00
113467: c7 44 24 04 46 07 00 movl $0x746,0x4(%esp) <== NOT EXECUTED
11346e: 00
11346f: c7 04 24 d0 36 13 00 movl $0x1336d0,(%esp) <== NOT EXECUTED
113476: e8 35 52 00 00 call 1186b0 <__assert_func> <== NOT EXECUTED
11347b: 90 nop
11347c: 90 nop
11347d: 90 nop
11347e: 90 nop
11347f: 90 nop
00113480 <msdos_find_node_by_cluster_num_in_fat_file>:
fat_file_fd_t *fat_fd,
uint32_t cl4find,
fat_dir_pos_t *dir_pos,
char *dir_entry
)
{
113480: 55 push %ebp
113481: 89 e5 mov %esp,%ebp
113483: 57 push %edi
113484: 56 push %esi
113485: 53 push %ebx
113486: 83 ec 3c sub $0x3c,%esp
int rc = RC_OK;
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
113489: 8b 45 08 mov 0x8(%ebp),%eax
{
11348c: 8b 55 10 mov 0x10(%ebp),%edx
msdos_fs_info_t *fs_info = mt_entry->fs_info;
11348f: 8b 40 08 mov 0x8(%eax),%eax
113492: 89 45 e4 mov %eax,-0x1c(%ebp)
uint32_t bts2rd = 0;
uint32_t i = 0, j = 0;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
113495: 8b 45 0c mov 0xc(%ebp),%eax
113498: 83 78 20 01 cmpl $0x1,0x20(%eax)
11349c: 0f 84 5e 01 00 00 je 113600 <msdos_find_node_by_cluster_num_in_fat_file+0x180>
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
else
bts2rd = fs_info->fat.vol.bpc;
1134a2: 8b 45 e4 mov -0x1c(%ebp),%eax
1134a5: 8b 78 08 mov 0x8(%eax),%edi
while ((ret = fat_file_read(&fs_info->fat, fat_fd, j * bts2rd, bts2rd,
1134a8: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp)
1134af: 8b 45 e4 mov -0x1c(%ebp),%eax
1134b2: 89 d6 mov %edx,%esi
1134b4: 8b 80 c4 00 00 00 mov 0xc4(%eax),%eax
1134ba: 89 45 e0 mov %eax,-0x20(%ebp)
1134bd: 89 7c 24 0c mov %edi,0xc(%esp)
1134c1: 8b 45 e0 mov -0x20(%ebp),%eax
1134c4: 89 44 24 10 mov %eax,0x10(%esp)
1134c8: 8b 45 dc mov -0x24(%ebp),%eax
1134cb: 89 44 24 08 mov %eax,0x8(%esp)
1134cf: 8b 45 0c mov 0xc(%ebp),%eax
1134d2: 89 44 24 04 mov %eax,0x4(%esp)
1134d6: 8b 45 e4 mov -0x1c(%ebp),%eax
1134d9: 89 04 24 mov %eax,(%esp)
1134dc: e8 7f d1 ff ff call 110660 <fat_file_read>
1134e1: 85 c0 test %eax,%eax
1134e3: 74 51 je 113536 <msdos_find_node_by_cluster_num_in_fat_file+0xb6><== NEVER TAKEN
fs_info->cl_buf)) != FAT_EOF)
{
if ( ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE )
1134e5: 83 f8 1f cmp $0x1f,%eax
1134e8: 0f 8e 42 01 00 00 jle 113630 <msdos_find_node_by_cluster_num_in_fat_file+0x1b0><== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EIO );
assert(ret == bts2rd);
1134ee: 39 c7 cmp %eax,%edi
1134f0: 0f 85 76 01 00 00 jne 11366c <msdos_find_node_by_cluster_num_in_fat_file+0x1ec><== NEVER TAKEN
for (i = 0; i < bts2rd; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + i;
1134f6: 8b 45 e4 mov -0x1c(%ebp),%eax
for (i = 0; i < bts2rd; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
1134f9: 31 d2 xor %edx,%edx
1134fb: 85 ff test %edi,%edi
char* entry = (char*) fs_info->cl_buf + i;
1134fd: 8b 80 c4 00 00 00 mov 0xc4(%eax),%eax
113503: 89 45 e0 mov %eax,-0x20(%ebp)
113506: 89 c3 mov %eax,%ebx
for (i = 0; i < bts2rd; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
113508: 75 25 jne 11352f <msdos_find_node_by_cluster_num_in_fat_file+0xaf><== ALWAYS TAKEN
11350a: eb 44 jmp 113550 <msdos_find_node_by_cluster_num_in_fat_file+0xd0><== NOT EXECUTED
11350c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)
return MSDOS_NAME_NOT_FOUND_ERR;
/* if this entry is empty - skip it */
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
113510: 3c e5 cmp $0xe5,%al
113512: 74 11 je 113525 <msdos_find_node_by_cluster_num_in_fat_file+0xa5><== NEVER TAKEN
MSDOS_THIS_DIR_ENTRY_EMPTY)
continue;
/* if get a non-empty entry - compare clusters num */
if (MSDOS_EXTRACT_CLUSTER_NUM(entry) == cl4find)
113514: 0f b7 43 14 movzwl 0x14(%ebx),%eax
113518: 0f b7 4b 1a movzwl 0x1a(%ebx),%ecx
11351c: c1 e0 10 shl $0x10,%eax
11351f: 09 c8 or %ecx,%eax
113521: 39 f0 cmp %esi,%eax
113523: 74 3b je 113560 <msdos_find_node_by_cluster_num_in_fat_file+0xe0>
for (i = 0; i < bts2rd; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
113525: 83 c2 20 add $0x20,%edx
113528: 83 c3 20 add $0x20,%ebx
11352b: 39 fa cmp %edi,%edx
11352d: 73 21 jae 113550 <msdos_find_node_by_cluster_num_in_fat_file+0xd0><== NEVER TAKEN
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
11352f: 0f b6 03 movzbl (%ebx),%eax
113532: 84 c0 test %al,%al
113534: 75 da jne 113510 <msdos_find_node_by_cluster_num_in_fat_file+0x90><== ALWAYS TAKEN
return MSDOS_NAME_NOT_FOUND_ERR;
113536: b8 01 7d 00 00 mov $0x7d01,%eax <== NOT EXECUTED
}
}
j++;
}
return MSDOS_NAME_NOT_FOUND_ERR;
}
11353b: 83 c4 3c add $0x3c,%esp
11353e: 5b pop %ebx
11353f: 5e pop %esi
113540: 5f pop %edi
113541: 5d pop %ebp
113542: c3 ret
113543: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11354a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
j++;
113550: 01 7d dc add %edi,-0x24(%ebp) <== NOT EXECUTED
113553: e9 65 ff ff ff jmp 1134bd <msdos_find_node_by_cluster_num_in_fat_file+0x3d><== NOT EXECUTED
113558: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11355f: 90 nop <== NOT EXECUTED
rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM, j * bts2rd,
113560: 8b 45 14 mov 0x14(%ebp),%eax
113563: 89 d6 mov %edx,%esi
113565: 89 44 24 10 mov %eax,0x10(%esp)
113569: 8b 45 dc mov -0x24(%ebp),%eax
11356c: 89 44 24 0c mov %eax,0xc(%esp)
113570: b8 01 00 00 00 mov $0x1,%eax
113575: 89 44 24 08 mov %eax,0x8(%esp)
113579: 8b 45 0c mov 0xc(%ebp),%eax
11357c: 89 44 24 04 mov %eax,0x4(%esp)
113580: 8b 45 e4 mov -0x1c(%ebp),%eax
113583: 89 04 24 mov %eax,(%esp)
113586: e8 95 d4 ff ff call 110a20 <fat_file_ioctl>
if (rc != RC_OK)
11358b: 85 c0 test %eax,%eax
11358d: 75 ac jne 11353b <msdos_find_node_by_cluster_num_in_fat_file+0xbb><== NEVER TAKEN
dir_pos->sname.ofs = i;
11358f: 8b 4d 14 mov 0x14(%ebp),%ecx
memcpy(dir_entry, entry,
113592: bf 20 00 00 00 mov $0x20,%edi
dir_pos->sname.ofs = i;
113597: 89 71 04 mov %esi,0x4(%ecx)
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
11359a: c7 41 08 ff ff ff ff movl $0xffffffff,0x8(%ecx)
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
1135a1: c7 41 0c ff ff ff ff movl $0xffffffff,0xc(%ecx)
memcpy(dir_entry, entry,
1135a8: 8b 4d 18 mov 0x18(%ebp),%ecx
1135ab: f6 c1 01 test $0x1,%cl
1135ae: 0f 85 a6 00 00 00 jne 11365a <msdos_find_node_by_cluster_num_in_fat_file+0x1da><== NEVER TAKEN
1135b4: f6 c1 02 test $0x2,%cl
1135b7: 0f 85 88 00 00 00 jne 113645 <msdos_find_node_by_cluster_num_in_fat_file+0x1c5><== NEVER TAKEN
1135bd: 89 45 e4 mov %eax,-0x1c(%ebp)
1135c0: 89 fe mov %edi,%esi
1135c2: 31 d2 xor %edx,%edx
1135c4: 83 e6 fc and $0xfffffffc,%esi
1135c7: 8b 04 13 mov (%ebx,%edx,1),%eax
1135ca: 89 04 11 mov %eax,(%ecx,%edx,1)
1135cd: 83 c2 04 add $0x4,%edx
1135d0: 39 f2 cmp %esi,%edx
1135d2: 72 f3 jb 1135c7 <msdos_find_node_by_cluster_num_in_fat_file+0x147>
1135d4: 01 d1 add %edx,%ecx
1135d6: 01 d3 add %edx,%ebx
1135d8: 8b 45 e4 mov -0x1c(%ebp),%eax
1135db: 31 d2 xor %edx,%edx
1135dd: f7 c7 02 00 00 00 test $0x2,%edi
1135e3: 75 3e jne 113623 <msdos_find_node_by_cluster_num_in_fat_file+0x1a3><== NEVER TAKEN
1135e5: 83 e7 01 and $0x1,%edi
1135e8: 0f 84 4d ff ff ff je 11353b <msdos_find_node_by_cluster_num_in_fat_file+0xbb><== ALWAYS TAKEN
1135ee: 0f b6 1c 13 movzbl (%ebx,%edx,1),%ebx <== NOT EXECUTED
1135f2: 88 1c 11 mov %bl,(%ecx,%edx,1) <== NOT EXECUTED
return RC_OK;
1135f5: e9 41 ff ff ff jmp 11353b <msdos_find_node_by_cluster_num_in_fat_file+0xbb><== NOT EXECUTED
1135fa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
113600: 8b 48 24 mov 0x24(%eax),%ecx
113603: 85 c9 test %ecx,%ecx
113605: 0f 85 97 fe ff ff jne 1134a2 <msdos_find_node_by_cluster_num_in_fat_file+0x22><== NEVER TAKEN
11360b: 8b 45 e4 mov -0x1c(%ebp),%eax
11360e: f6 40 16 03 testb $0x3,0x16(%eax)
113612: 0f 84 8a fe ff ff je 1134a2 <msdos_find_node_by_cluster_num_in_fat_file+0x22><== NEVER TAKEN
bts2rd = fat_fd->fat_file_size;
113618: 8b 45 0c mov 0xc(%ebp),%eax
11361b: 8b 78 18 mov 0x18(%eax),%edi
11361e: e9 85 fe ff ff jmp 1134a8 <msdos_find_node_by_cluster_num_in_fat_file+0x28>
memcpy(dir_entry, entry,
113623: 0f b7 13 movzwl (%ebx),%edx <== NOT EXECUTED
113626: 66 89 11 mov %dx,(%ecx) <== NOT EXECUTED
113629: ba 02 00 00 00 mov $0x2,%edx <== NOT EXECUTED
11362e: eb b5 jmp 1135e5 <msdos_find_node_by_cluster_num_in_fat_file+0x165><== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
113630: e8 6b 32 01 00 call 1268a0 <__errno> <== NOT EXECUTED
113635: c7 00 05 00 00 00 movl $0x5,(%eax) <== NOT EXECUTED
11363b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
113640: e9 f6 fe ff ff jmp 11353b <msdos_find_node_by_cluster_num_in_fat_file+0xbb><== NOT EXECUTED
memcpy(dir_entry, entry,
113645: 0f b7 13 movzwl (%ebx),%edx <== NOT EXECUTED
113648: 83 c1 02 add $0x2,%ecx <== NOT EXECUTED
11364b: 83 c3 02 add $0x2,%ebx <== NOT EXECUTED
11364e: 83 ef 02 sub $0x2,%edi <== NOT EXECUTED
113651: 66 89 51 fe mov %dx,-0x2(%ecx) <== NOT EXECUTED
113655: e9 63 ff ff ff jmp 1135bd <msdos_find_node_by_cluster_num_in_fat_file+0x13d><== NOT EXECUTED
11365a: 0f b6 13 movzbl (%ebx),%edx <== NOT EXECUTED
11365d: 41 inc %ecx <== NOT EXECUTED
11365e: 43 inc %ebx <== NOT EXECUTED
11365f: bf 1f 00 00 00 mov $0x1f,%edi <== NOT EXECUTED
113664: 88 51 ff mov %dl,-0x1(%ecx) <== NOT EXECUTED
113667: e9 48 ff ff ff jmp 1135b4 <msdos_find_node_by_cluster_num_in_fat_file+0x134><== NOT EXECUTED
assert(ret == bts2rd);
11366c: c7 44 24 0c 35 37 13 movl $0x133735,0xc(%esp) <== NOT EXECUTED
113673: 00
113674: c7 44 24 08 60 37 13 movl $0x133760,0x8(%esp) <== NOT EXECUTED
11367b: 00
11367c: c7 44 24 04 f1 07 00 movl $0x7f1,0x4(%esp) <== NOT EXECUTED
113683: 00
113684: c7 04 24 d0 36 13 00 movl $0x1336d0,(%esp) <== NOT EXECUTED
11368b: e8 20 50 00 00 call 1186b0 <__assert_func> <== NOT EXECUTED
00104600 <msdos_format>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
104600: 55 push %ebp
int ret_val = 0;
int fd = -1;
int i;
msdos_format_param_t fmt_params;
memset(&fmt_params, 0, sizeof(fmt_params));
104601: 31 d2 xor %edx,%edx
{
104603: 89 e5 mov %esp,%ebp
memset(&fmt_params, 0, sizeof(fmt_params));
104605: 31 c0 xor %eax,%eax
{
104607: 57 push %edi
104608: 56 push %esi
104609: 53 push %ebx
10460a: 81 ec 1c 01 00 00 sub $0x11c,%esp
104610: 8b 5d 08 mov 0x8(%ebp),%ebx
memset(&fmt_params, 0, sizeof(fmt_params));
104613: 89 54 05 90 mov %edx,-0x70(%ebp,%eax,1)
104617: 89 54 05 94 mov %edx,-0x6c(%ebp,%eax,1)
10461b: 83 c0 08 add $0x8,%eax
10461e: 83 f8 58 cmp $0x58,%eax
104621: 72 f0 jb 104613 <msdos_format+0x13>
/*
* open device for writing
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "open device\n");
104623: b8 4e 2d 13 00 mov $0x132d4e,%eax
104628: 89 44 24 08 mov %eax,0x8(%esp)
10462c: b8 02 00 00 00 mov $0x2,%eax
104631: 89 44 24 04 mov %eax,0x4(%esp)
104635: 8b 45 0c mov 0xc(%ebp),%eax
104638: 89 04 24 mov %eax,(%esp)
10463b: e8 e0 fc ff ff call 104320 <msdos_format_printf>
fd = open(devname, O_RDWR);
104640: b8 02 00 00 00 mov $0x2,%eax
104645: 89 44 24 04 mov %eax,0x4(%esp)
104649: 89 1c 24 mov %ebx,(%esp)
10464c: e8 ef e4 ff ff call 102b40 <open>
}
/*
* sanity check on device
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
104651: ba 02 00 00 00 mov $0x2,%edx
104656: 89 5c 24 0c mov %ebx,0xc(%esp)
10465a: 89 54 24 04 mov %edx,0x4(%esp)
fd = open(devname, O_RDWR);
10465e: 89 85 fc fe ff ff mov %eax,-0x104(%ebp)
104664: 89 c7 mov %eax,%edi
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
104666: b8 5b 2d 13 00 mov $0x132d5b,%eax
10466b: 89 44 24 08 mov %eax,0x8(%esp)
10466f: 8b 45 0c mov 0xc(%ebp),%eax
if (fd == -1) {
104672: 83 ff ff cmp $0xffffffff,%edi
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
104675: 89 04 24 mov %eax,(%esp)
if (fd == -1) {
104678: 0f 84 9c 00 00 00 je 10471a <msdos_format+0x11a> <== NEVER TAKEN
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
10467e: e8 9d fc ff ff call 104320 <msdos_format_printf>
"stat check: %s\n", devname);
if (ret_val == 0) {
ret_val = fstat(fd, &stat_buf);
104683: 8d 85 38 ff ff ff lea -0xc8(%ebp),%eax
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
104689: be 6b 2d 13 00 mov $0x132d6b,%esi
ret_val = fstat(fd, &stat_buf);
10468e: 89 3c 24 mov %edi,(%esp)
104691: 89 44 24 04 mov %eax,0x4(%esp)
104695: e8 76 d6 ff ff call 101d10 <fstat>
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
10469a: 89 5c 24 0c mov %ebx,0xc(%esp)
10469e: 89 74 24 08 mov %esi,0x8(%esp)
ret_val = fstat(fd, &stat_buf);
1046a2: 89 85 00 ff ff ff mov %eax,-0x100(%ebp)
1046a8: 89 c7 mov %eax,%edi
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
1046aa: b8 01 00 00 00 mov $0x1,%eax
1046af: 89 44 24 04 mov %eax,0x4(%esp)
1046b3: 8b 45 0c mov 0xc(%ebp),%eax
1046b6: 89 04 24 mov %eax,(%esp)
1046b9: e8 62 fc ff ff call 104320 <msdos_format_printf>
"formating: %s\n", devname);
/* rtems feature: no block devices, all are character devices */
if ((ret_val == 0) && (!S_ISBLK(stat_buf.st_mode))) {
1046be: 85 ff test %edi,%edi
1046c0: 75 2e jne 1046f0 <msdos_format+0xf0> <== NEVER TAKEN
1046c2: 8b 85 48 ff ff ff mov -0xb8(%ebp),%eax
1046c8: 25 00 f0 00 00 and $0xf000,%eax
1046cd: 3d 00 60 00 00 cmp $0x6000,%eax
1046d2: 74 7c je 104750 <msdos_format+0x150> <== ALWAYS TAKEN
errno = ENOTTY;
1046d4: e8 c7 21 02 00 call 1268a0 <__errno> <== NOT EXECUTED
1046d9: c7 00 19 00 00 00 movl $0x19,(%eax) <== NOT EXECUTED
ret_val = -1;
1046df: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
1046e4: 89 85 00 ff ff ff mov %eax,-0x100(%ebp) <== NOT EXECUTED
1046ea: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
* cleanup:
* sync and unlock disk
* free any data structures (not needed now)
*/
if (fd != -1) {
close(fd);
1046f0: 8b 85 fc fe ff ff mov -0x104(%ebp),%eax
1046f6: 89 04 24 mov %eax,(%esp)
1046f9: e8 b2 d3 ff ff call 101ab0 <close>
}
free(fmt_params.sec);
1046fe: 8b 45 e4 mov -0x1c(%ebp),%eax
104701: 89 04 24 mov %eax,(%esp)
104704: e8 47 d5 ff ff call 101c50 <free>
return ret_val;
}
104709: 8b 85 00 ff ff ff mov -0x100(%ebp),%eax
10470f: 81 c4 1c 01 00 00 add $0x11c,%esp
104715: 5b pop %ebx
104716: 5e pop %esi
104717: 5f pop %edi
104718: 5d pop %ebp
104719: c3 ret
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
10471a: e8 01 fc ff ff call 104320 <msdos_format_printf> <== NOT EXECUTED
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
10471f: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
104722: ba 6b 2d 13 00 mov $0x132d6b,%edx <== NOT EXECUTED
104727: 89 5c 24 0c mov %ebx,0xc(%esp) <== NOT EXECUTED
10472b: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED
ret_val= -1;
104730: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
104735: 89 54 24 08 mov %edx,0x8(%esp) <== NOT EXECUTED
104739: 89 4c 24 04 mov %ecx,0x4(%esp) <== NOT EXECUTED
10473d: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
104740: e8 db fb ff ff call 104320 <msdos_format_printf> <== NOT EXECUTED
ret_val= -1;
104745: 89 9d 00 ff ff ff mov %ebx,-0x100(%ebp) <== NOT EXECUTED
10474b: eb b1 jmp 1046fe <msdos_format+0xfe> <== NOT EXECUTED
10474d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
memset(fmt_params,0,sizeof(*fmt_params));
104750: 31 d2 xor %edx,%edx
104752: 31 c0 xor %eax,%eax
104754: 89 54 05 90 mov %edx,-0x70(%ebp,%eax,1)
104758: 89 54 05 94 mov %edx,-0x6c(%ebp,%eax,1)
10475c: 83 c0 08 add $0x8,%eax
10475f: 83 f8 58 cmp $0x58,%eax
104762: 72 f0 jb 104754 <msdos_format+0x154>
static inline int rtems_disk_fd_get_media_block_size(
int fd,
uint32_t *media_block_size
)
{
return ioctl(fd, RTEMS_BLKIO_GETMEDIABLKSIZE, media_block_size);
104764: 8d 45 90 lea -0x70(%ebp),%eax
104767: 89 44 24 08 mov %eax,0x8(%esp)
10476b: b8 02 42 04 40 mov $0x40044202,%eax
104770: 89 44 24 04 mov %eax,0x4(%esp)
104774: 8b 85 fc fe ff ff mov -0x104(%ebp),%eax
10477a: 89 04 24 mov %eax,(%esp)
10477d: e8 ce 93 00 00 call 10db50 <ioctl>
104782: 89 85 00 ff ff ff mov %eax,-0x100(%ebp)
if (ret_val == 0) {
104788: 85 c0 test %eax,%eax
10478a: 0f 84 1d 06 00 00 je 104dad <msdos_format+0x7ad> <== ALWAYS TAKEN
if ( fmt_params->totl_sector_cnt == 0 )
104790: 8b 45 94 mov -0x6c(%ebp),%eax
104793: 85 c0 test %eax,%eax
104795: 0f 85 80 09 00 00 jne 10511b <msdos_format+0xb1b>
errno = EINVAL;
10479b: e8 00 21 02 00 call 1268a0 <__errno>
ret_val = -1;
1047a0: bb ff ff ff ff mov $0xffffffff,%ebx
errno = EINVAL;
1047a5: c7 00 16 00 00 00 movl $0x16,(%eax)
ret_val = -1;
1047ab: 89 9d 00 ff ff ff mov %ebx,-0x100(%ebp)
fmt_params->rsvd_sector_cnt
1047b1: 8b 75 98 mov -0x68(%ebp),%esi
+ (fmt_params-> fat_num*fmt_params->sectors_per_fat);
1047b4: 0f b6 45 c0 movzbl -0x40(%ebp),%eax
1047b8: 8b 4d a0 mov -0x60(%ebp),%ecx
if (fmt_params->root_dir_sectors > 0) {
1047bb: 8b 55 ac mov -0x54(%ebp),%edx
+ (fmt_params-> fat_num*fmt_params->sectors_per_fat);
1047be: 0f af c1 imul %ecx,%eax
1047c1: 01 f0 add %esi,%eax
if (fmt_params->root_dir_sectors > 0) {
1047c3: 85 d2 test %edx,%edx
fmt_params->root_dir_start_sec =
1047c5: 89 45 b0 mov %eax,-0x50(%ebp)
if (fmt_params->root_dir_sectors > 0) {
1047c8: 0f 84 42 09 00 00 je 105110 <msdos_format+0xb10> <== NEVER TAKEN
fmt_params->root_dir_fmt_sec_cnt = fmt_params->root_dir_sectors;
1047ce: 89 55 b4 mov %edx,-0x4c(%ebp)
if (ret_val == 0) {
1047d1: 8b 85 00 ff ff ff mov -0x100(%ebp),%eax
1047d7: 85 c0 test %eax,%eax
1047d9: 0f 85 11 ff ff ff jne 1046f0 <msdos_format+0xf0>
if ((rqdata != NULL) && (rqdata->OEMName != NULL)) {
1047df: 8b 45 0c mov 0xc(%ebp),%eax
1047e2: 85 c0 test %eax,%eax
1047e4: 0f 84 c2 0a 00 00 je 1052ac <msdos_format+0xcac> <== NEVER TAKEN
1047ea: 8b 45 0c mov 0xc(%ebp),%eax
1047ed: 8b 08 mov (%eax),%ecx
1047ef: 85 c9 test %ecx,%ecx
1047f1: 0f 84 b5 0a 00 00 je 1052ac <msdos_format+0xcac> <== NEVER TAKEN
if (isprint((unsigned char)*from)) {
1047f7: 0f b6 11 movzbl (%ecx),%edx
from = "RTEMS"; /* default: make "from" point to OS Name */
1047fa: 8d 45 c3 lea -0x3d(%ebp),%eax
1047fd: 8d 75 cb lea -0x35(%ebp),%esi
104800: eb 1c jmp 10481e <msdos_format+0x21e>
104802: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
104809: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
*to++ = *from++;
104810: 88 50 ff mov %dl,-0x1(%eax)
104813: 41 inc %ecx
for (cnt = 0; cnt < (sizeof(fmt_params->OEMName)-1); cnt++) {
104814: 39 f0 cmp %esi,%eax
*to = '\0';
104816: c6 00 00 movb $0x0,(%eax)
for (cnt = 0; cnt < (sizeof(fmt_params->OEMName)-1); cnt++) {
104819: 74 1f je 10483a <msdos_format+0x23a> <== NEVER TAKEN
if (isprint((unsigned char)*from)) {
10481b: 0f b6 11 movzbl (%ecx),%edx
10481e: 0f b6 da movzbl %dl,%ebx
*to++ = *from++;
104821: 40 inc %eax
if (isprint((unsigned char)*from)) {
104822: 0f be 9b e1 6a 13 00 movsbl 0x136ae1(%ebx),%ebx
104829: f6 c3 97 test $0x97,%bl
10482c: 75 e2 jne 104810 <msdos_format+0x210>
*to = '\0';
10482e: c6 00 00 movb $0x0,(%eax)
*to++=' ';
104831: b2 20 mov $0x20,%dl
for (cnt = 0; cnt < (sizeof(fmt_params->OEMName)-1); cnt++) {
104833: 39 f0 cmp %esi,%eax
104835: 88 50 ff mov %dl,-0x1(%eax)
104838: 75 e1 jne 10481b <msdos_format+0x21b>
if ((rqdata != NULL) &&
10483a: 8b 45 0c mov 0xc(%ebp),%eax
10483d: 85 c0 test %eax,%eax
10483f: 0f 84 5b 0a 00 00 je 1052a0 <msdos_format+0xca0>
(rqdata->VolLabel != NULL)) {
104845: 8b 45 0c mov 0xc(%ebp),%eax
104848: 8b 48 04 mov 0x4(%eax),%ecx
if ((rqdata != NULL) &&
10484b: 85 c9 test %ecx,%ecx
10484d: 0f 84 4d 0a 00 00 je 1052a0 <msdos_format+0xca0> <== NEVER TAKEN
fmt_params->VolLabel_present = true;
104853: c6 45 d8 01 movb $0x1,-0x28(%ebp)
if (isprint((unsigned char)*from)) {
104857: 0f b6 11 movzbl (%ecx),%edx
from = ""; /* default: make "from" point to empty string */
10485a: 8d 45 cc lea -0x34(%ebp),%eax
10485d: 8d 75 d7 lea -0x29(%ebp),%esi
104860: eb 1c jmp 10487e <msdos_format+0x27e>
104862: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
104869: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
*to++ = *from++;
104870: 88 50 ff mov %dl,-0x1(%eax)
104873: 41 inc %ecx
for (cnt = 0; cnt < (sizeof(fmt_params->VolLabel)-1); cnt++) {
104874: 39 f0 cmp %esi,%eax
*to = '\0';
104876: c6 00 00 movb $0x0,(%eax)
for (cnt = 0; cnt < (sizeof(fmt_params->VolLabel)-1); cnt++) {
104879: 74 1f je 10489a <msdos_format+0x29a> <== NEVER TAKEN
if (isprint((unsigned char)*from)) {
10487b: 0f b6 11 movzbl (%ecx),%edx
10487e: 0f b6 da movzbl %dl,%ebx
*to++ = *from++;
104881: 40 inc %eax
if (isprint((unsigned char)*from)) {
104882: 0f be 9b e1 6a 13 00 movsbl 0x136ae1(%ebx),%ebx
104889: f6 c3 97 test $0x97,%bl
10488c: 75 e2 jne 104870 <msdos_format+0x270>
*to = '\0';
10488e: c6 00 00 movb $0x0,(%eax)
*to++=' ';
104891: b2 20 mov $0x20,%dl
for (cnt = 0; cnt < (sizeof(fmt_params->VolLabel)-1); cnt++) {
104893: 39 f0 cmp %esi,%eax
104895: 88 50 ff mov %dl,-0x1(%eax)
104898: 75 e1 jne 10487b <msdos_format+0x27b>
rc = rtems_clock_get_tod_timeval(&time_value);
10489a: 8d 85 2c ff ff ff lea -0xd4(%ebp),%eax
1048a0: 89 04 24 mov %eax,(%esp)
1048a3: e8 88 35 00 00 call 107e30 <rtems_clock_get_tod_timeval>
if (rc == RTEMS_SUCCESSFUL) {
1048a8: 85 c0 test %eax,%eax
1048aa: 0f 85 37 10 00 00 jne 1058e7 <msdos_format+0x12e7>
*volid_ptr = time_value.tv_sec + time_value.tv_sec;
1048b0: 8b 85 2c ff ff ff mov -0xd4(%ebp),%eax <== NOT EXECUTED
1048b6: 01 c0 add %eax,%eax <== NOT EXECUTED
1048b8: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED
fmt_params.sec = malloc(fmt_params.bytes_per_sector);
1048bb: 8b 45 90 mov -0x70(%ebp),%eax
1048be: 89 04 24 mov %eax,(%esp)
1048c1: e8 5a d8 ff ff call 102120 <malloc>
1048c6: 89 45 e4 mov %eax,-0x1c(%ebp)
if (fmt_params.sec == NULL) {
1048c9: 85 c0 test %eax,%eax
1048cb: 0f 84 8f 09 00 00 je 105260 <msdos_format+0xc60> <== NEVER TAKEN
if ((ret_val == 0) &&
1048d1: 8b 45 0c mov 0xc(%ebp),%eax
1048d4: 85 c0 test %eax,%eax
1048d6: 0f 85 54 08 00 00 jne 105130 <msdos_format+0xb30>
(rqdata != NULL) &&
1048dc: c6 85 1c ff ff ff 00 movb $0x0,-0xe4(%ebp)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
1048e3: b8 a7 2d 13 00 mov $0x132da7,%eax
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
1048e8: 31 ff xor %edi,%edi
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
1048ea: 89 44 24 08 mov %eax,0x8(%esp)
1048ee: b8 02 00 00 00 mov $0x2,%eax
1048f3: 89 44 24 04 mov %eax,0x4(%esp)
1048f7: 8b 45 0c mov 0xc(%ebp),%eax
1048fa: 89 04 24 mov %eax,(%esp)
1048fd: e8 1e fa ff ff call 104320 <msdos_format_printf>
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
104902: 31 d2 xor %edx,%edx
104904: 31 c9 xor %ecx,%ecx
104906: 89 7c 24 08 mov %edi,0x8(%esp)
10490a: 8b bd fc fe ff ff mov -0x104(%ebp),%edi
104910: 89 54 24 0c mov %edx,0xc(%esp)
ret_val = msdos_format_read_sec(fd,
104914: 8b 5d e4 mov -0x1c(%ebp),%ebx
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
104917: 89 4c 24 04 mov %ecx,0x4(%esp)
ret_val = msdos_format_read_sec(fd,
10491b: 8b 75 90 mov -0x70(%ebp),%esi
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
10491e: 89 3c 24 mov %edi,(%esp)
104921: e8 ea 92 00 00 call 10dc10 <lseek>
104926: 85 d2 test %edx,%edx
104928: 0f 88 32 09 00 00 js 105260 <msdos_format+0xc60> <== NEVER TAKEN
if (0 > read(fd,buffer,sector_size)) {
10492e: 89 74 24 08 mov %esi,0x8(%esp)
104932: 89 5c 24 04 mov %ebx,0x4(%esp)
104936: 89 3c 24 mov %edi,(%esp)
104939: e8 02 95 00 00 call 10de40 <read>
10493e: 85 c0 test %eax,%eax
104940: 0f 88 1a 09 00 00 js 105260 <msdos_format+0xc60> <== NEVER TAKEN
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
104946: b8 b8 2d 13 00 mov $0x132db8,%eax
10494b: 89 44 24 08 mov %eax,0x8(%esp)
10494f: b8 02 00 00 00 mov $0x2,%eax
104954: 89 44 24 04 mov %eax,0x4(%esp)
104958: 8b 45 0c mov 0xc(%ebp),%eax
10495b: 89 04 24 mov %eax,(%esp)
10495e: e8 bd f9 ff ff call 104320 <msdos_format_printf>
if (fmt_params->totl_sector_cnt < 0x10000) {
104963: 8b 45 94 mov -0x6c(%ebp),%eax
104966: 3d ff ff 00 00 cmp $0xffff,%eax
10496b: 0f 86 ff 08 00 00 jbe 105270 <msdos_format+0xc70>
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
104971: 88 85 0c ff ff ff mov %al,-0xf4(%ebp)
104977: 89 c2 mov %eax,%edx
104979: 0f b6 dc movzbl %ah,%ebx
10497c: 89 9d 10 ff ff ff mov %ebx,-0xf0(%ebp)
104982: c1 ea 10 shr $0x10,%edx
104985: 88 95 14 ff ff ff mov %dl,-0xec(%ebp)
10498b: c1 e8 18 shr $0x18,%eax
10498e: 89 85 24 ff ff ff mov %eax,-0xdc(%ebp)
104994: c6 85 20 ff ff ff 00 movb $0x0,-0xe0(%ebp)
10499b: c6 85 18 ff ff ff 00 movb $0x0,-0xe8(%ebp)
ret_val = msdos_format_gen_mbr(fmt_params.sec,&fmt_params);
1049a2: 8b 4d e4 mov -0x1c(%ebp),%ecx
memset(mbr,0,RTEMS_IDE_PARTITION_TABLE_OFFSET);
1049a5: 31 d2 xor %edx,%edx
1049a7: bf be 01 00 00 mov $0x1be,%edi
1049ac: f6 c1 01 test $0x1,%cl
1049af: 89 ce mov %ecx,%esi
1049b1: 0f 85 ae 0f 00 00 jne 105965 <msdos_format+0x1365> <== NEVER TAKEN
1049b7: f7 c6 02 00 00 00 test $0x2,%esi
1049bd: 0f 85 b2 0f 00 00 jne 105975 <msdos_format+0x1375> <== NEVER TAKEN
1049c3: 89 fb mov %edi,%ebx
1049c5: 31 c0 xor %eax,%eax
1049c7: 83 e3 f8 and $0xfffffff8,%ebx
1049ca: 89 14 06 mov %edx,(%esi,%eax,1)
1049cd: 89 54 06 04 mov %edx,0x4(%esi,%eax,1)
1049d1: 83 c0 08 add $0x8,%eax
1049d4: 39 d8 cmp %ebx,%eax
1049d6: 72 f2 jb 1049ca <msdos_format+0x3ca>
1049d8: 01 c6 add %eax,%esi
1049da: f7 c7 04 00 00 00 test $0x4,%edi
1049e0: 74 09 je 1049eb <msdos_format+0x3eb> <== NEVER TAKEN
1049e2: c7 06 00 00 00 00 movl $0x0,(%esi)
1049e8: 83 c6 04 add $0x4,%esi
1049eb: f7 c7 02 00 00 00 test $0x2,%edi
1049f1: 74 08 je 1049fb <msdos_format+0x3fb> <== NEVER TAKEN
1049f3: 66 c7 06 00 00 movw $0x0,(%esi)
1049f8: 83 c6 02 add $0x2,%esi
1049fb: 83 e7 01 and $0x1,%edi
1049fe: 74 03 je 104a03 <msdos_format+0x403> <== ALWAYS TAKEN
104a00: c6 06 00 movb $0x0,(%esi) <== NOT EXECUTED
memset(mbr + RTEMS_IDE_PARTITION_TABLE_OFFSET + RTEMS_IDE_PARTITION_TABLE_SIZE,
104a03: 31 c0 xor %eax,%eax
104a05: 66 89 81 fe 01 00 00 mov %ax,0x1fe(%ecx)
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
104a0c: 8b 45 c3 mov -0x3d(%ebp),%eax
104a0f: 8b 55 c7 mov -0x39(%ebp),%edx
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
104a12: c6 41 10 02 movb $0x2,0x10(%ecx)
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
104a16: 89 41 03 mov %eax,0x3(%ecx)
FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector);
104a19: 8b 45 90 mov -0x70(%ebp),%eax
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
104a1c: 89 51 07 mov %edx,0x7(%ecx)
FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector);
104a1f: 66 89 41 0b mov %ax,0xb(%ecx)
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
104a23: 0f b6 45 9c movzbl -0x64(%ebp),%eax
104a27: 88 41 0d mov %al,0xd(%ecx)
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
104a2a: 8b 45 98 mov -0x68(%ebp),%eax
104a2d: 66 89 41 0e mov %ax,0xe(%ecx)
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
104a31: 0f b6 45 a8 movzbl -0x58(%ebp),%eax
104a35: 88 41 11 mov %al,0x11(%ecx)
104a38: 8b 45 a8 mov -0x58(%ebp),%eax
104a3b: 88 61 12 mov %ah,0x12(%ecx)
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
104a3e: 0f b6 85 18 ff ff ff movzbl -0xe8(%ebp),%eax
104a45: 88 41 13 mov %al,0x13(%ecx)
104a48: 0f b6 85 20 ff ff ff movzbl -0xe0(%ebp),%eax
104a4f: 88 41 14 mov %al,0x14(%ecx)
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
104a52: 0f b6 45 c1 movzbl -0x3f(%ebp),%eax
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
104a56: c6 41 18 ff movb $0xff,0x18(%ecx)
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
104a5a: c6 41 1a 06 movb $0x6,0x1a(%ecx)
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
104a5e: c6 41 1c 01 movb $0x1,0x1c(%ecx)
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
104a62: 88 41 15 mov %al,0x15(%ecx)
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
104a65: 0f b6 85 0c ff ff ff movzbl -0xf4(%ebp),%eax
104a6c: 88 41 20 mov %al,0x20(%ecx)
104a6f: 0f b6 85 10 ff ff ff movzbl -0xf0(%ebp),%eax
104a76: 88 41 21 mov %al,0x21(%ecx)
104a79: 0f b6 85 14 ff ff ff movzbl -0xec(%ebp),%eax
104a80: 88 41 22 mov %al,0x22(%ecx)
104a83: 0f b6 85 24 ff ff ff movzbl -0xdc(%ebp),%eax
104a8a: 88 41 23 mov %al,0x23(%ecx)
if (fmt_params->fattype != FAT_FAT32) {
104a8d: 80 7d c2 04 cmpb $0x4,-0x3e(%ebp)
104a91: 0f 84 c0 0d 00 00 je 105857 <msdos_format+0x1257> <== NEVER TAKEN
FAT_SET_BR_BOOTSIG(mbr , FAT_BR_BOOTSIG_VAL);
104a97: c6 41 26 29 movb $0x29,0x26(%ecx)
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
104a9b: 8b 45 a0 mov -0x60(%ebp),%eax
104a9e: 66 89 41 16 mov %ax,0x16(%ecx)
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
104aa2: 8b 45 dc mov -0x24(%ebp),%eax
104aa5: 89 41 27 mov %eax,0x27(%ecx)
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
104aa8: b8 46 41 54 31 mov $0x31544146,%eax
104aad: 8b 55 cc mov -0x34(%ebp),%edx
104ab0: 89 51 2b mov %edx,0x2b(%ecx)
104ab3: 8b 55 d0 mov -0x30(%ebp),%edx
104ab6: 89 51 2f mov %edx,0x2f(%ecx)
104ab9: 8b 55 d4 mov -0x2c(%ebp),%edx
104abc: 66 89 51 33 mov %dx,0x33(%ecx)
104ac0: 0f b6 5d d6 movzbl -0x2a(%ebp),%ebx
104ac4: 88 59 35 mov %bl,0x35(%ecx)
memcpy(FAT_GET_ADDR_BR_FILSYSTYPE(mbr),
104ac7: 80 7d c2 01 cmpb $0x1,-0x3e(%ebp)
104acb: 0f 84 24 0e 00 00 je 1058f5 <msdos_format+0x12f5>
104ad1: ba 36 20 20 20 mov $0x20202036,%edx
104ad6: 89 41 36 mov %eax,0x36(%ecx)
104ad9: 89 51 3a mov %edx,0x3a(%ecx)
FAT_SET_VAL8(mbr,0,0xeb);
104adc: 66 c7 01 eb 3c movw $0x3ceb,(%ecx)
FAT_SET_BR_SIGNATURE(mbr, FAT_BR_SIGNATURE_VAL);
104ae1: b8 55 aa ff ff mov $0xffffaa55,%eax
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
104ae6: 31 ff xor %edi,%edi
FAT_SET_BR_SIGNATURE(mbr, FAT_BR_SIGNATURE_VAL);
104ae8: 66 89 81 fe 01 00 00 mov %ax,0x1fe(%ecx)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
104aef: b8 cd 2d 13 00 mov $0x132dcd,%eax
FAT_SET_VAL8(mbr,2,0x90);
104af4: c6 41 02 90 movb $0x90,0x2(%ecx)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
104af8: 89 44 24 08 mov %eax,0x8(%esp)
104afc: b8 02 00 00 00 mov $0x2,%eax
104b01: 89 44 24 04 mov %eax,0x4(%esp)
104b05: 8b 45 0c mov 0xc(%ebp),%eax
104b08: 89 04 24 mov %eax,(%esp)
104b0b: e8 10 f8 ff ff call 104320 <msdos_format_printf>
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
104b10: 31 d2 xor %edx,%edx
104b12: 31 c9 xor %ecx,%ecx
104b14: 89 7c 24 08 mov %edi,0x8(%esp)
104b18: 8b bd fc fe ff ff mov -0x104(%ebp),%edi
104b1e: 89 54 24 0c mov %edx,0xc(%esp)
fmt_params.sec);
104b22: 8b 5d e4 mov -0x1c(%ebp),%ebx
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
104b25: 89 4c 24 04 mov %ecx,0x4(%esp)
ret_val = msdos_format_write_sec(fd,
104b29: 8b 75 90 mov -0x70(%ebp),%esi
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
104b2c: 89 3c 24 mov %edi,(%esp)
104b2f: e8 dc 90 00 00 call 10dc10 <lseek>
104b34: 85 d2 test %edx,%edx
104b36: 0f 88 24 07 00 00 js 105260 <msdos_format+0xc60> <== NEVER TAKEN
if (0 > write(fd,buffer,sector_size)) {
104b3c: 89 74 24 08 mov %esi,0x8(%esp)
104b40: 89 5c 24 04 mov %ebx,0x4(%esp)
104b44: 89 3c 24 mov %edi,(%esp)
104b47: e8 34 f4 ff ff call 103f80 <write>
104b4c: 85 c0 test %eax,%eax
104b4e: 0f 88 0c 07 00 00 js 105260 <msdos_format+0xc60> <== NEVER TAKEN
if ((ret_val == 0) &&
104b54: 8b 45 b8 mov -0x48(%ebp),%eax
104b57: 85 c0 test %eax,%eax
104b59: 74 64 je 104bbf <msdos_format+0x5bf>
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
104b5b: 8b 45 0c mov 0xc(%ebp),%eax
104b5e: b9 df 2d 13 00 mov $0x132ddf,%ecx
104b63: bb 02 00 00 00 mov $0x2,%ebx
104b68: 89 4c 24 08 mov %ecx,0x8(%esp)
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
104b6c: 31 ff xor %edi,%edi
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
104b6e: 89 5c 24 04 mov %ebx,0x4(%esp)
104b72: 89 04 24 mov %eax,(%esp)
104b75: e8 a6 f7 ff ff call 104320 <msdos_format_printf>
ret_val = msdos_format_write_sec(fd,
104b7a: 8b 5d 90 mov -0x70(%ebp),%ebx
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
104b7d: 89 7c 24 0c mov %edi,0xc(%esp)
104b81: 8b bd fc fe ff ff mov -0x104(%ebp),%edi
fmt_params.sec);
104b87: 8b 75 e4 mov -0x1c(%ebp),%esi
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
104b8a: 89 d8 mov %ebx,%eax
104b8c: f7 65 b8 mull -0x48(%ebp)
104b8f: 89 3c 24 mov %edi,(%esp)
104b92: 89 44 24 04 mov %eax,0x4(%esp)
104b96: 89 54 24 08 mov %edx,0x8(%esp)
104b9a: e8 71 90 00 00 call 10dc10 <lseek>
104b9f: 85 d2 test %edx,%edx
104ba1: 0f 88 b9 06 00 00 js 105260 <msdos_format+0xc60> <== NEVER TAKEN
if (0 > write(fd,buffer,sector_size)) {
104ba7: 89 5c 24 08 mov %ebx,0x8(%esp)
104bab: 89 74 24 04 mov %esi,0x4(%esp)
104baf: 89 3c 24 mov %edi,(%esp)
104bb2: e8 c9 f3 ff ff call 103f80 <write>
104bb7: 85 c0 test %eax,%eax
104bb9: 0f 88 a1 06 00 00 js 105260 <msdos_format+0xc60> <== NEVER TAKEN
if ((ret_val == 0) &&
104bbf: 8b 45 bc mov -0x44(%ebp),%eax
104bc2: 85 c0 test %eax,%eax
104bc4: 0f 85 b6 05 00 00 jne 105180 <msdos_format+0xb80> <== NEVER TAKEN
ret_val = msdos_format_fill_sectors
104bca: 31 c0 xor %eax,%eax
104bcc: 8b 55 a0 mov -0x60(%ebp),%edx
104bcf: 89 44 24 08 mov %eax,0x8(%esp)
fmt_params.fat_num*fmt_params.sectors_per_fat,/* sector count */
104bd3: 0f b6 45 c0 movzbl -0x40(%ebp),%eax
ret_val = msdos_format_fill_sectors
104bd7: 8b 8d fc fe ff ff mov -0x104(%ebp),%ecx
104bdd: 0f af c2 imul %edx,%eax
104be0: 8b 55 0c mov 0xc(%ebp),%edx
104be3: 89 44 24 04 mov %eax,0x4(%esp)
104be7: 8b 45 98 mov -0x68(%ebp),%eax
104bea: 89 04 24 mov %eax,(%esp)
104bed: 8d 45 90 lea -0x70(%ebp),%eax
104bf0: e8 0b f8 ff ff call 104400 <msdos_format_fill_sectors>
104bf5: 89 85 00 ff ff ff mov %eax,-0x100(%ebp)
if (ret_val == 0) {
104bfb: 85 c0 test %eax,%eax
104bfd: 0f 85 ed fa ff ff jne 1046f0 <msdos_format+0xf0> <== NEVER TAKEN
ret_val = msdos_format_fill_sectors
104c03: 31 c0 xor %eax,%eax
104c05: 8b 8d fc fe ff ff mov -0x104(%ebp),%ecx
104c0b: 89 44 24 08 mov %eax,0x8(%esp)
104c0f: 8b 45 b4 mov -0x4c(%ebp),%eax
104c12: 8b 55 0c mov 0xc(%ebp),%edx
104c15: 89 44 24 04 mov %eax,0x4(%esp)
104c19: 8b 45 b0 mov -0x50(%ebp),%eax
104c1c: 89 04 24 mov %eax,(%esp)
104c1f: 8d 45 90 lea -0x70(%ebp),%eax
104c22: e8 d9 f7 ff ff call 104400 <msdos_format_fill_sectors>
104c27: 89 85 00 ff ff ff mov %eax,-0x100(%ebp)
if ((ret_val == 0) && fmt_params.VolLabel_present) {
104c2d: 85 c0 test %eax,%eax
104c2f: 0f 85 bb fa ff ff jne 1046f0 <msdos_format+0xf0> <== NEVER TAKEN
104c35: 80 7d d8 00 cmpb $0x0,-0x28(%ebp)
memset(fmt_params.sec,0,fmt_params.bytes_per_sector);
104c39: 8b 55 90 mov -0x70(%ebp),%edx
104c3c: 8b 7d e4 mov -0x1c(%ebp),%edi
if ((ret_val == 0) && fmt_params.VolLabel_present) {
104c3f: 0f 85 db 08 00 00 jne 105520 <msdos_format+0xf20>
memset(fmt_params.sec,0,fmt_params.bytes_per_sector);
104c45: 83 fa 08 cmp $0x8,%edx
104c48: 0f 83 77 09 00 00 jae 1055c5 <msdos_format+0xfc5> <== ALWAYS TAKEN
104c4e: f6 c2 04 test $0x4,%dl
104c51: 74 09 je 104c5c <msdos_format+0x65c> <== ALWAYS TAKEN
104c53: c7 07 00 00 00 00 movl $0x0,(%edi) <== NOT EXECUTED
104c59: 83 c7 04 add $0x4,%edi <== NOT EXECUTED
104c5c: f6 c2 02 test $0x2,%dl
104c5f: 74 08 je 104c69 <msdos_format+0x669> <== ALWAYS TAKEN
104c61: 66 c7 07 00 00 movw $0x0,(%edi) <== NOT EXECUTED
104c66: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
104c69: f6 c2 01 test $0x1,%dl
104c6c: 74 03 je 104c71 <msdos_format+0x671> <== ALWAYS TAKEN
104c6e: c6 07 00 movb $0x0,(%edi) <== NOT EXECUTED
switch(fmt_params.fattype) {
104c71: 0f b6 45 c2 movzbl -0x3e(%ebp),%eax
104c75: 3c 02 cmp $0x2,%al
104c77: 0f 84 45 0a 00 00 je 1056c2 <msdos_format+0x10c2> <== NEVER TAKEN
104c7d: 3c 04 cmp $0x4,%al
104c7f: 0f 84 f6 09 00 00 je 10567b <msdos_format+0x107b> <== NEVER TAKEN
104c85: fe c8 dec %al
104c87: 0f 84 ca 09 00 00 je 105657 <msdos_format+0x1057> <== ALWAYS TAKEN
errno = EINVAL;
104c8d: 8d 76 00 lea 0x0(%esi),%esi
104c90: e8 0b 1c 02 00 call 1268a0 <__errno> <== NOT EXECUTED
ret_val = -1;
104c95: b9 ff ff ff ff mov $0xffffffff,%ecx <== NOT EXECUTED
104c9a: 89 8d 18 ff ff ff mov %ecx,-0xe8(%ebp) <== NOT EXECUTED
errno = EINVAL;
104ca0: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
if (fmt_params.fattype == FAT_FAT32) {
104ca6: 80 7d c2 04 cmpb $0x4,-0x3e(%ebp)
104caa: 75 1c jne 104cc8 <msdos_format+0x6c8>
FAT_SET_VAL32(fmt_params.sec,8,FAT_FAT32_EOC);
104cac: 8b 45 e4 mov -0x1c(%ebp),%eax
104caf: c6 40 08 f8 movb $0xf8,0x8(%eax)
104cb3: 8b 45 e4 mov -0x1c(%ebp),%eax
104cb6: c6 40 09 ff movb $0xff,0x9(%eax)
104cba: 8b 45 e4 mov -0x1c(%ebp),%eax
104cbd: c6 40 0a ff movb $0xff,0xa(%eax)
104cc1: 8b 45 e4 mov -0x1c(%ebp),%eax
104cc4: c6 40 0b 0f movb $0xf,0xb(%eax)
start_sector = loc_align_object (fmt_params.rsvd_sector_cnt,
104cc8: 8b 5d 98 mov -0x68(%ebp),%ebx
if (! skip_alignment)
104ccb: 80 7d e0 00 cmpb $0x0,-0x20(%ebp)
start_sector = loc_align_object (fmt_params.rsvd_sector_cnt,
104ccf: 8b 45 9c mov -0x64(%ebp),%eax
104cd2: 89 9d 20 ff ff ff mov %ebx,-0xe0(%ebp)
if (! skip_alignment)
104cd8: 75 0e jne 104ce8 <msdos_format+0x6e8>
return (sectors + clustersize - 1) & ~(clustersize - 1);
104cda: 8d 7c 18 ff lea -0x1(%eax,%ebx,1),%edi
104cde: f7 d8 neg %eax
104ce0: 21 c7 and %eax,%edi
104ce2: 89 bd 20 ff ff ff mov %edi,-0xe0(%ebp)
for (i = 0;
104ce8: 80 7d c0 00 cmpb $0x0,-0x40(%ebp)
104cec: 0f 84 0d 0c 00 00 je 1058ff <msdos_format+0x12ff> <== NEVER TAKEN
(i < fmt_params.fat_num) && (ret_val == 0);
104cf2: 8b bd 18 ff ff ff mov -0xe8(%ebp),%edi
for (i = 0;
104cf8: 31 db xor %ebx,%ebx
104cfa: 8b b5 fc fe ff ff mov -0x104(%ebp),%esi
(i < fmt_params.fat_num) && (ret_val == 0);
104d00: 85 ff test %edi,%edi
104d02: 0f 85 58 05 00 00 jne 105260 <msdos_format+0xc60> <== NEVER TAKEN
104d08: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
104d0f: 90 nop
fmt_params.sec);
104d10: 8b 45 e4 mov -0x1c(%ebp),%eax
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
104d13: 89 34 24 mov %esi,(%esp)
ret_val = msdos_format_write_sec
104d16: 8b 95 20 ff ff ff mov -0xe0(%ebp),%edx
104d1c: 8b 7d 90 mov -0x70(%ebp),%edi
fmt_params.sec);
104d1f: 89 85 24 ff ff ff mov %eax,-0xdc(%ebp)
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
104d25: 31 c0 xor %eax,%eax
104d27: 89 44 24 0c mov %eax,0xc(%esp)
+ (i * fmt_params.sectors_per_fat),
104d2b: 8b 45 a0 mov -0x60(%ebp),%eax
104d2e: 0f af c3 imul %ebx,%eax
ret_val = msdos_format_write_sec
104d31: 01 d0 add %edx,%eax
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
104d33: f7 e7 mul %edi
104d35: 89 44 24 04 mov %eax,0x4(%esp)
104d39: 89 54 24 08 mov %edx,0x8(%esp)
104d3d: e8 ce 8e 00 00 call 10dc10 <lseek>
104d42: 85 d2 test %edx,%edx
104d44: 0f 88 16 05 00 00 js 105260 <msdos_format+0xc60> <== NEVER TAKEN
if (0 > write(fd,buffer,sector_size)) {
104d4a: 89 7c 24 08 mov %edi,0x8(%esp)
104d4e: 8b 85 24 ff ff ff mov -0xdc(%ebp),%eax
104d54: 89 34 24 mov %esi,(%esp)
104d57: 89 44 24 04 mov %eax,0x4(%esp)
104d5b: e8 20 f2 ff ff call 103f80 <write>
104d60: 85 c0 test %eax,%eax
104d62: 0f 88 f8 04 00 00 js 105260 <msdos_format+0xc60> <== NEVER TAKEN
(i < fmt_params.fat_num) && (ret_val == 0);
104d68: 0f b6 45 c0 movzbl -0x40(%ebp),%eax
i++) {
104d6c: 43 inc %ebx
for (i = 0;
104d6d: 39 c3 cmp %eax,%ebx
104d6f: 7c 9f jl 104d10 <msdos_format+0x710>
if (ret_val == 0 && rqdata != NULL && rqdata->sync_device) {
104d71: 80 bd 1c ff ff ff 00 cmpb $0x0,-0xe4(%ebp)
104d78: 0f 84 32 0c 00 00 je 1059b0 <msdos_format+0x13b0> <== NEVER TAKEN
104d7e: 8b 45 0c mov 0xc(%ebp),%eax
104d81: 80 78 17 00 cmpb $0x0,0x17(%eax)
104d85: 0f 84 65 f9 ff ff je 1046f0 <msdos_format+0xf0>
return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);
}
static inline int rtems_disk_fd_sync(int fd)
{
return ioctl(fd, RTEMS_BLKIO_SYNCDEV);
104d8b: 8b 85 fc fe ff ff mov -0x104(%ebp),%eax
104d91: bb 06 42 00 20 mov $0x20004206,%ebx
104d96: 89 5c 24 04 mov %ebx,0x4(%esp)
104d9a: 89 04 24 mov %eax,(%esp)
104d9d: e8 ae 8d 00 00 call 10db50 <ioctl>
104da2: 89 85 00 ff ff ff mov %eax,-0x100(%ebp)
104da8: e9 43 f9 ff ff jmp 1046f0 <msdos_format+0xf0>
return ioctl(fd, RTEMS_BLKIO_GETSIZE, block_count);
104dad: 8d 45 94 lea -0x6c(%ebp),%eax
104db0: 89 44 24 08 mov %eax,0x8(%esp)
104db4: b8 05 42 04 40 mov $0x40044205,%eax
104db9: 89 44 24 04 mov %eax,0x4(%esp)
104dbd: 8b 85 fc fe ff ff mov -0x104(%ebp),%eax
104dc3: 89 04 24 mov %eax,(%esp)
104dc6: e8 85 8d 00 00 call 10db50 <ioctl>
104dcb: 89 85 00 ff ff ff mov %eax,-0x100(%ebp)
if (ret_val == 0) {
104dd1: 85 c0 test %eax,%eax
104dd3: 0f 85 b7 f9 ff ff jne 104790 <msdos_format+0x190> <== NEVER TAKEN
total_size = (uint64_t)fmt_params->bytes_per_sector * fmt_params->totl_sector_cnt;
104dd9: 8b 4d 90 mov -0x70(%ebp),%ecx
104ddc: 8b 5d 94 mov -0x6c(%ebp),%ebx
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
104ddf: 89 4c 24 0c mov %ecx,0xc(%esp)
total_size = (uint64_t)fmt_params->bytes_per_sector * fmt_params->totl_sector_cnt;
104de3: 89 c8 mov %ecx,%eax
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
104de5: 89 5c 24 10 mov %ebx,0x10(%esp)
total_size = (uint64_t)fmt_params->bytes_per_sector * fmt_params->totl_sector_cnt;
104de9: f7 e3 mul %ebx
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
104deb: bb fc 2d 13 00 mov $0x132dfc,%ebx
104df0: 89 5c 24 08 mov %ebx,0x8(%esp)
104df4: 89 44 24 14 mov %eax,0x14(%esp)
total_size = (uint64_t)fmt_params->bytes_per_sector * fmt_params->totl_sector_cnt;
104df8: 89 c6 mov %eax,%esi
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
104dfa: b8 02 00 00 00 mov $0x2,%eax
104dff: 89 44 24 04 mov %eax,0x4(%esp)
104e03: 8b 45 0c mov 0xc(%ebp),%eax
total_size = (uint64_t)fmt_params->bytes_per_sector * fmt_params->totl_sector_cnt;
104e06: 89 d7 mov %edx,%edi
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
104e08: 89 54 24 18 mov %edx,0x18(%esp)
104e0c: 89 04 24 mov %eax,(%esp)
104e0f: e8 0c f5 ff ff call 104320 <msdos_format_printf>
if ((rqdata == NULL) || (rqdata->fat_num == 0)) {
104e14: 8b 45 0c mov 0xc(%ebp),%eax
104e17: 85 c0 test %eax,%eax
104e19: 0f 84 ce 08 00 00 je 1056ed <msdos_format+0x10ed>
104e1f: 8b 45 0c mov 0xc(%ebp),%eax
104e22: 8b 40 0c mov 0xc(%eax),%eax
104e25: 85 c0 test %eax,%eax
104e27: 0f 84 8b 04 00 00 je 1052b8 <msdos_format+0xcb8>
else if (rqdata->fat_num <= 6) {
104e2d: 83 f8 06 cmp $0x6,%eax
104e30: 0f 87 df 0a 00 00 ja 105915 <msdos_format+0x1315> <== NEVER TAKEN
fmt_params->fat_num = rqdata->fat_num;
104e36: 88 45 c0 mov %al,-0x40(%ebp)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
104e39: 89 44 24 0c mov %eax,0xc(%esp)
104e3d: b8 02 00 00 00 mov $0x2,%eax
104e42: bb 7a 2d 13 00 mov $0x132d7a,%ebx
104e47: 89 44 24 04 mov %eax,0x4(%esp)
104e4b: 8b 45 0c mov 0xc(%ebp),%eax
104e4e: 89 5c 24 08 mov %ebx,0x8(%esp)
104e52: 89 04 24 mov %eax,(%esp)
104e55: e8 c6 f4 ff ff call 104320 <msdos_format_printf>
if (rqdata != NULL && rqdata->sectors_per_cluster != 0) {
104e5a: 8b 45 0c mov 0xc(%ebp),%eax
104e5d: 8b 40 08 mov 0x8(%eax),%eax
104e60: 85 c0 test %eax,%eax
104e62: 0f 84 b0 08 00 00 je 105718 <msdos_format+0x1118>
if (fmt_params->totl_sector_cnt < FAT_FAT12_MAX_CLN * fat12_sect_per_clust) {
104e68: 69 c8 f5 0f 00 00 imul $0xff5,%eax,%ecx
104e6e: 8b 55 94 mov -0x6c(%ebp),%edx
104e71: 39 d1 cmp %edx,%ecx
104e73: 0f 86 e3 08 00 00 jbe 10575c <msdos_format+0x115c> <== NEVER TAKEN
fmt_params->fattype = FAT_FAT12;
104e79: c6 45 c2 01 movb $0x1,-0x3e(%ebp)
fmt_params->sectors_per_cluster = 2;
104e7d: c7 45 9c 02 00 00 00 movl $0x2,-0x64(%ebp)
ret_val = msdos_set_sectors_per_cluster_from_request( rqdata, fmt_params );
104e84: 8b 45 0c mov 0xc(%ebp),%eax
104e87: 8d 55 90 lea -0x70(%ebp),%edx
104e8a: e8 f1 f4 ff ff call 104380 <msdos_set_sectors_per_cluster_from_request>
104e8f: 89 85 00 ff ff ff mov %eax,-0x100(%ebp)
if (ret_val == 0) {
104e95: 85 c0 test %eax,%eax
104e97: 0f 85 f3 f8 ff ff jne 104790 <msdos_format+0x190> <== NEVER TAKEN
&& fmt_params->totl_sector_cnt > 0 ) {
104e9d: c6 85 07 ff ff ff ff movb $0xff,-0xf9(%ebp)
104ea4: 8b 45 94 mov -0x6c(%ebp),%eax
uint32_t gigs = ( total_size + ONE_GB ) / ONE_GB;
104ea7: 81 c6 00 00 00 40 add $0x40000000,%esi
&& fmt_params->totl_sector_cnt > 0 ) {
104ead: c6 85 06 ff ff ff 00 movb $0x0,-0xfa(%ebp)
uint32_t gigs = ( total_size + ONE_GB ) / ONE_GB;
104eb4: 83 d7 00 adc $0x0,%edi
104eb7: 0f ac fe 1e shrd $0x1e,%edi,%esi
104ebb: 89 b5 f8 fe ff ff mov %esi,-0x108(%ebp)
&& fmt_params->totl_sector_cnt > 0 ) {
104ec1: 89 85 14 ff ff ff mov %eax,-0xec(%ebp)
104ec7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
104ece: 66 90 xchg %ax,%ax
&& fmt_params->fattype != fat_type
104ed0: 0f b6 85 07 ff ff ff movzbl -0xf9(%ebp),%eax
104ed7: 38 45 c2 cmp %al,-0x3e(%ebp)
104eda: 0f 84 a4 08 00 00 je 105784 <msdos_format+0x1184>
&& fmt_params->totl_sector_cnt > 0 ) {
104ee0: 8b 85 14 ff ff ff mov -0xec(%ebp),%eax
104ee6: 85 c0 test %eax,%eax
104ee8: 0f 84 ad f8 ff ff je 10479b <msdos_format+0x19b> <== NEVER TAKEN
if (ret_val == 0 && rqdata != NULL)
104eee: 8b 55 0c mov 0xc(%ebp),%edx
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
104ef1: 8b 45 9c mov -0x64(%ebp),%eax
if (ret_val == 0 && rqdata != NULL)
104ef4: 85 d2 test %edx,%edx
104ef6: 0f 84 64 05 00 00 je 105460 <msdos_format+0xe60>
fmt_params->skip_alignment = rqdata->skip_alignment;
104efc: 8b 5d 0c mov 0xc(%ebp),%ebx
104eff: 0f b6 5b 16 movzbl 0x16(%ebx),%ebx
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
104f03: 89 44 24 0c mov %eax,0xc(%esp)
104f07: b8 8e 2d 13 00 mov $0x132d8e,%eax
104f0c: 89 44 24 08 mov %eax,0x8(%esp)
104f10: b8 02 00 00 00 mov $0x2,%eax
104f15: 89 44 24 04 mov %eax,0x4(%esp)
104f19: 8b 45 0c mov 0xc(%ebp),%eax
fmt_params->skip_alignment = rqdata->skip_alignment;
104f1c: 88 9d 24 ff ff ff mov %bl,-0xdc(%ebp)
104f22: 88 5d e0 mov %bl,-0x20(%ebp)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
104f25: 89 04 24 mov %eax,(%esp)
104f28: e8 f3 f3 ff ff call 104320 <msdos_format_printf>
if (fmt_params->fattype == FAT_FAT32) {
104f2d: 0f b6 45 c2 movzbl -0x3e(%ebp),%eax
104f31: 88 85 07 ff ff ff mov %al,-0xf9(%ebp)
104f37: 3c 04 cmp $0x4,%al
104f39: 0f 84 51 05 00 00 je 105490 <msdos_format+0xe90> <== NEVER TAKEN
fmt_params->rsvd_sector_cnt = 1;
104f3f: c7 45 98 01 00 00 00 movl $0x1,-0x68(%ebp)
(rqdata->files_per_root_dir > 0)) {
104f46: 8b 45 0c mov 0xc(%ebp),%eax
104f49: 8b 48 10 mov 0x10(%eax),%ecx
if ((rqdata != NULL) &&
104f4c: 85 c9 test %ecx,%ecx
104f4e: 0f 84 93 05 00 00 je 1054e7 <msdos_format+0xee7>
ret_val = msdos_format_eval_sectors_per_cluster(fmt_params->fattype,
104f54: 0f b6 9d 07 ff ff ff movzbl -0xf9(%ebp),%ebx
fmt_params->files_per_root_dir = rqdata->files_per_root_dir;
104f5b: b8 01 00 00 00 mov $0x1,%eax
104f60: 49 dec %ecx
104f61: 89 85 10 ff ff ff mov %eax,-0xf0(%ebp)
(2*fmt_params->bytes_per_sector/
104f67: 8b 45 90 mov -0x70(%ebp),%eax
fmt_params->files_per_root_dir -= (fmt_params->files_per_root_dir %
104f6a: 31 d2 xor %edx,%edx
(2*fmt_params->bytes_per_sector/
104f6c: 89 85 20 ff ff ff mov %eax,-0xe0(%ebp)
104f72: 01 c0 add %eax,%eax
104f74: c1 e8 05 shr $0x5,%eax
fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
104f77: 01 c1 add %eax,%ecx
(2*fmt_params->bytes_per_sector/
104f79: 89 c6 mov %eax,%esi
fmt_params->files_per_root_dir -= (fmt_params->files_per_root_dir %
104f7b: 89 c8 mov %ecx,%eax
104f7d: f7 f6 div %esi
104f7f: 29 d1 sub %edx,%ecx
104f81: 89 4d a8 mov %ecx,-0x58(%ebp)
(((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)
104f84: c1 e1 05 shl $0x5,%ecx
fmt_params->root_dir_sectors =
104f87: 8b bd 20 ff ff ff mov -0xe0(%ebp),%edi
/ fmt_params->bytes_per_sector);
104f8d: 31 d2 xor %edx,%edx
ret_val = msdos_format_eval_sectors_per_cluster(fmt_params->fattype,
104f8f: 8b 75 9c mov -0x64(%ebp),%esi
104f92: 8d 47 ff lea -0x1(%edi),%eax
104f95: 89 85 18 ff ff ff mov %eax,-0xe8(%ebp)
+ fmt_params->bytes_per_sector - 1)
104f9b: 8d 44 0f ff lea -0x1(%edi,%ecx,1),%eax
fmt_params->fat_num,
104f9f: 0f b6 4d c0 movzbl -0x40(%ebp),%ecx
/ fmt_params->bytes_per_sector);
104fa3: f7 f7 div %edi
while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
104fa5: 31 d2 xor %edx,%edx
/ fmt_params->bytes_per_sector);
104fa7: 89 85 0c ff ff ff mov %eax,-0xf4(%ebp)
fmt_params->root_dir_sectors =
104fad: 89 45 ac mov %eax,-0x54(%ebp)
fmt_params->skip_alignment,
104fb0: 0f b6 45 e0 movzbl -0x20(%ebp),%eax
104fb4: 88 85 24 ff ff ff mov %al,-0xdc(%ebp)
ret_val = msdos_format_eval_sectors_per_cluster(fmt_params->fattype,
104fba: 8b 45 94 mov -0x6c(%ebp),%eax
104fbd: 89 85 14 ff ff ff mov %eax,-0xec(%ebp)
while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
104fc3: b8 00 00 01 00 mov $0x10000,%eax
104fc8: f7 f7 div %edi
104fca: 39 c6 cmp %eax,%esi
104fcc: 76 08 jbe 104fd6 <msdos_format+0x9d6> <== ALWAYS TAKEN
104fce: 66 90 xchg %ax,%ax
sectors_per_cluster /= 2;
104fd0: d1 ee shr %esi <== NOT EXECUTED
while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
104fd2: 39 c6 cmp %eax,%esi <== NOT EXECUTED
104fd4: 77 fa ja 104fd0 <msdos_format+0x9d0> <== NOT EXECUTED
fat_sectors_cnt = loc_align_object (sectors_per_fat * fat_num,
104fd6: 0f b6 c1 movzbl %cl,%eax
fatdata_sect_cnt = total_sector_cnt
104fd9: 8b bd 10 ff ff ff mov -0xf0(%ebp),%edi
fat_sectors_cnt = loc_align_object (sectors_per_fat * fat_num,
104fdf: 89 85 1c ff ff ff mov %eax,-0xe4(%ebp)
fatdata_sect_cnt = total_sector_cnt
104fe5: 8b 85 14 ff ff ff mov -0xec(%ebp),%eax
104feb: 29 f8 sub %edi,%eax
104fed: 89 85 08 ff ff ff mov %eax,-0xf8(%ebp)
104ff3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
104ffa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
if (! skip_alignment)
105000: 80 bd 24 ff ff ff 00 cmpb $0x0,-0xdc(%ebp)
105007: 0f 85 c3 02 00 00 jne 1052d0 <msdos_format+0xcd0>
return (sectors + clustersize - 1) & ~(clustersize - 1);
10500d: 8b 85 10 ff ff ff mov -0xf0(%ebp),%eax
105013: 89 f1 mov %esi,%ecx
105015: f7 d9 neg %ecx
105017: 8d 54 06 ff lea -0x1(%esi,%eax,1),%edx
fatdata_sect_cnt = total_sector_cnt
10501b: 8b 85 14 ff ff ff mov -0xec(%ebp),%eax
return (sectors + clustersize - 1) & ~(clustersize - 1);
105021: 21 ca and %ecx,%edx
fatdata_sect_cnt = total_sector_cnt
105023: 29 d0 sub %edx,%eax
if (fattype == FAT_FAT12) {
105025: 83 fb 01 cmp $0x1,%ebx
105028: 0f 84 02 04 00 00 je 105430 <msdos_format+0xe30>
else if (fattype == FAT_FAT16) {
10502e: 83 fb 02 cmp $0x2,%ebx
105031: 0f 84 09 04 00 00 je 105440 <msdos_format+0xe40>
fatdata_cluster_cnt = fatdata_sect_cnt/sectors_per_cluster;
105037: 31 d2 xor %edx,%edx
105039: f7 f6 div %esi
10503b: 89 c7 mov %eax,%edi
fat_capacity = fatdata_cluster_cnt * 4;
10503d: 8d 04 85 00 00 00 00 lea 0x0(,%eax,4),%eax
+ (bytes_per_sector - 1))
105044: 8b 95 18 ff ff ff mov -0xe8(%ebp),%edx
fat_sectors_cnt = loc_align_object (sectors_per_fat * fat_num,
10504a: 8b 8d 1c ff ff ff mov -0xe4(%ebp),%ecx
+ (bytes_per_sector - 1))
105050: 01 d0 add %edx,%eax
sectors_per_fat = ((fat_capacity
105052: 31 d2 xor %edx,%edx
105054: f7 b5 20 ff ff ff divl -0xe0(%ebp)
10505a: 8d 56 ff lea -0x1(%esi),%edx
fat_sectors_cnt = loc_align_object (sectors_per_fat * fat_num,
10505d: 0f af c1 imul %ecx,%eax
if (! skip_alignment)
105060: 80 bd 24 ff ff ff 00 cmpb $0x0,-0xdc(%ebp)
fat_sectors_cnt = loc_align_object (sectors_per_fat * fat_num,
105067: 89 c1 mov %eax,%ecx
return (sectors + clustersize - 1) & ~(clustersize - 1);
105069: 8d 44 06 ff lea -0x1(%esi,%eax,1),%eax
if (! skip_alignment)
10506d: 75 09 jne 105078 <msdos_format+0xa78>
return (sectors + clustersize - 1) & ~(clustersize - 1);
10506f: 89 f1 mov %esi,%ecx
105071: f7 d9 neg %ecx
105073: 21 c1 and %eax,%ecx
+ (sectors_per_cluster - 1))
105075: 8d 04 11 lea (%ecx,%edx,1),%eax
/ sectors_per_cluster));
105078: 31 d2 xor %edx,%edx
10507a: f7 f6 div %esi
*data_cluster_cnt = (fatdata_cluster_cnt -
10507c: 29 c7 sub %eax,%edi
if (((fattype == FAT_FAT12) && (*data_cluster_cnt > FAT_FAT12_MAX_CLN)) ||
10507e: 83 fb 01 cmp $0x1,%ebx
105081: 0f 84 79 02 00 00 je 105300 <msdos_format+0xd00>
105087: 83 fb 02 cmp $0x2,%ebx
10508a: 0f 85 78 02 00 00 jne 105308 <msdos_format+0xd08>
((fattype == FAT_FAT16) && (*data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
105090: 81 ff f5 ff 00 00 cmp $0xfff5,%edi
105096: 0f 86 d4 02 00 00 jbe 105370 <msdos_format+0xd70>
} else if ((sectors_per_cluster * bytes_per_sector)
10509c: 8b 85 20 ff ff ff mov -0xe0(%ebp),%eax
sectors_per_cluster *= 2;
1050a2: 01 f6 add %esi,%esi
} else if ((sectors_per_cluster * bytes_per_sector)
1050a4: 0f af c6 imul %esi,%eax
1050a7: 3d 00 00 01 00 cmp $0x10000,%eax
1050ac: 0f 86 4e ff ff ff jbe 105000 <msdos_format+0xa00> <== ALWAYS TAKEN
fmt_params->sectors_per_cluster = sectors_per_cluster_adj;
1050b2: 89 75 9c mov %esi,-0x64(%ebp) <== NOT EXECUTED
*sectors_per_fat_ptr = fat_sectors_cnt / fat_num;
1050b5: 89 c8 mov %ecx,%eax <== NOT EXECUTED
1050b7: 31 d2 xor %edx,%edx <== NOT EXECUTED
1050b9: f7 b5 1c ff ff ff divl -0xe4(%ebp) <== NOT EXECUTED
uint32_t ms_sectors_per_cluster_limit_FAT16 =
1050bf: 31 d2 xor %edx,%edx <== NOT EXECUTED
*sectors_per_fat_ptr = fat_sectors_cnt / fat_num;
1050c1: 89 45 a0 mov %eax,-0x60(%ebp) <== NOT EXECUTED
uint32_t ms_sectors_per_cluster_limit_FAT16 =
1050c4: b8 01 80 00 00 mov $0x8001,%eax <== NOT EXECUTED
1050c9: f7 b5 20 ff ff ff divl -0xe0(%ebp) <== NOT EXECUTED
1050cf: 89 c1 mov %eax,%ecx <== NOT EXECUTED
if ( number_of_clusters < FAT_FAT12_MAX_CLN
1050d1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1050d8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1050df: 90 nop <== NOT EXECUTED
else if ( number_of_clusters < FAT_FAT16_MAX_CLN
1050e0: 81 ff f4 ff 00 00 cmp $0xfff4,%edi
1050e6: 0f 87 23 05 00 00 ja 10560f <msdos_format+0x100f>
1050ec: 39 ce cmp %ecx,%esi
fattype = FAT_FAT16;
1050ee: b0 02 mov $0x2,%al
else if ( number_of_clusters < FAT_FAT16_MAX_CLN
1050f0: 0f 87 19 05 00 00 ja 10560f <msdos_format+0x100f>
if (fat_type != fmt_params->fattype) {
1050f6: 3a 85 07 ff ff ff cmp -0xf9(%ebp),%al
fmt_params->fattype = msdos_get_fat_type(
1050fc: 88 45 c2 mov %al,-0x3e(%ebp)
if (fat_type != fmt_params->fattype) {
1050ff: 0f 85 ad 02 00 00 jne 1053b2 <msdos_format+0xdb2>
++iteration_cnt;
105105: fe 85 06 ff ff ff incb -0xfa(%ebp)
10510b: e9 c0 fd ff ff jmp 104ed0 <msdos_format+0x8d0>
fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
105110: 8b 45 9c mov -0x64(%ebp),%eax
105113: 89 45 b4 mov %eax,-0x4c(%ebp)
105116: e9 b6 f6 ff ff jmp 1047d1 <msdos_format+0x1d1>
fmt_params->rsvd_sector_cnt
10511b: 8b 75 98 mov -0x68(%ebp),%esi
10511e: e9 91 f6 ff ff jmp 1047b4 <msdos_format+0x1b4>
105123: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10512a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
(rqdata != NULL) &&
105130: 8b 45 0c mov 0xc(%ebp),%eax
105133: 80 78 15 00 cmpb $0x0,0x15(%eax)
105137: 75 36 jne 10516f <msdos_format+0xb6f> <== ALWAYS TAKEN
ret_val = msdos_format_fill_sectors
105139: b8 e5 ff ff ff mov $0xffffffe5,%eax <== NOT EXECUTED
10513e: 8b 8d fc fe ff ff mov -0x104(%ebp),%ecx <== NOT EXECUTED
105144: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
105148: 8b 45 94 mov -0x6c(%ebp),%eax <== NOT EXECUTED
10514b: c7 04 24 00 00 00 00 movl $0x0,(%esp) <== NOT EXECUTED
105152: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED
105155: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
105159: 8d 45 90 lea -0x70(%ebp),%eax <== NOT EXECUTED
10515c: e8 9f f2 ff ff call 104400 <msdos_format_fill_sectors> <== NOT EXECUTED
105161: 89 85 00 ff ff ff mov %eax,-0x100(%ebp) <== NOT EXECUTED
if (ret_val == 0) {
105167: 85 c0 test %eax,%eax <== NOT EXECUTED
105169: 0f 85 81 f5 ff ff jne 1046f0 <msdos_format+0xf0> <== NOT EXECUTED
*to++=' ';
10516f: c6 85 1c ff ff ff 01 movb $0x1,-0xe4(%ebp)
105176: e9 68 f7 ff ff jmp 1048e3 <msdos_format+0x2e3>
10517b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10517f: 90 nop
ret_val = msdos_format_gen_fsinfo(fmt_params.sec);
105180: 8b 75 e4 mov -0x1c(%ebp),%esi
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
105183: 31 c9 xor %ecx,%ecx
105185: bf 00 02 00 00 mov $0x200,%edi
10518a: f7 c6 01 00 00 00 test $0x1,%esi
105190: 89 f2 mov %esi,%edx
105192: 0f 85 af 06 00 00 jne 105847 <msdos_format+0x1247> <== NEVER TAKEN
105198: f6 c2 02 test $0x2,%dl
10519b: 0f 85 96 06 00 00 jne 105837 <msdos_format+0x1237> <== NEVER TAKEN
1051a1: 89 fb mov %edi,%ebx
1051a3: 31 c0 xor %eax,%eax
1051a5: 83 e3 f8 and $0xfffffff8,%ebx
1051a8: 89 0c 02 mov %ecx,(%edx,%eax,1)
1051ab: 89 4c 02 04 mov %ecx,0x4(%edx,%eax,1)
1051af: 83 c0 08 add $0x8,%eax
1051b2: 39 d8 cmp %ebx,%eax
1051b4: 72 f2 jb 1051a8 <msdos_format+0xba8>
1051b6: 01 c2 add %eax,%edx
1051b8: f7 c7 04 00 00 00 test $0x4,%edi
1051be: 74 09 je 1051c9 <msdos_format+0xbc9> <== ALWAYS TAKEN
1051c0: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED
1051c6: 83 c2 04 add $0x4,%edx <== NOT EXECUTED
1051c9: f7 c7 02 00 00 00 test $0x2,%edi
1051cf: 74 08 je 1051d9 <msdos_format+0xbd9> <== ALWAYS TAKEN
1051d1: 66 c7 02 00 00 movw $0x0,(%edx) <== NOT EXECUTED
1051d6: 83 c2 02 add $0x2,%edx <== NOT EXECUTED
1051d9: 83 e7 01 and $0x1,%edi
1051dc: 74 03 je 1051e1 <msdos_format+0xbe1> <== ALWAYS TAKEN
1051de: c6 02 00 movb $0x0,(%edx) <== NOT EXECUTED
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
1051e1: c7 06 52 52 61 41 movl $0x41615252,(%esi)
FAT_SET_FSINFO_NEXT_FREE_CLUSTER (fsinfo+FAT_FSI_INFO, 0xffffffff);
1051e7: b8 ff ff ff ff mov $0xffffffff,%eax
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
1051ec: b9 55 aa ff ff mov $0xffffaa55,%ecx
FAT_SET_FSINFO_NEXT_FREE_CLUSTER (fsinfo+FAT_FSI_INFO, 0xffffffff);
1051f1: 89 86 ec 01 00 00 mov %eax,0x1ec(%esi)
(fmt_params.fsinfo_sec != 0)) {
1051f7: 8b 45 bc mov -0x44(%ebp),%eax
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
1051fa: bb 72 72 41 61 mov $0x61417272,%ebx
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
1051ff: 66 89 8e fe 01 00 00 mov %cx,0x1fe(%esi)
FAT_SET_FSINFO_FREE_CLUSTER_COUNT(fsinfo+FAT_FSI_INFO, 0xffffffff);
105206: bf ff ff ff ff mov $0xffffffff,%edi
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
10520b: 89 9e e4 01 00 00 mov %ebx,0x1e4(%esi)
FAT_SET_FSINFO_FREE_CLUSTER_COUNT(fsinfo+FAT_FSI_INFO, 0xffffffff);
105211: 89 be e8 01 00 00 mov %edi,0x1e8(%esi)
if ((ret_val == 0) &&
105217: 85 c0 test %eax,%eax
105219: 0f 84 ab f9 ff ff je 104bca <msdos_format+0x5ca> <== NEVER TAKEN
ret_val = msdos_format_write_sec(fd,
10521f: 8b 75 90 mov -0x70(%ebp),%esi
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
105222: 31 d2 xor %edx,%edx
105224: 89 54 24 0c mov %edx,0xc(%esp)
105228: 8b bd fc fe ff ff mov -0x104(%ebp),%edi
fmt_params.sec);
10522e: 8b 5d e4 mov -0x1c(%ebp),%ebx
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
105231: f7 e6 mul %esi
105233: 89 3c 24 mov %edi,(%esp)
105236: 89 44 24 04 mov %eax,0x4(%esp)
10523a: 89 54 24 08 mov %edx,0x8(%esp)
10523e: e8 cd 89 00 00 call 10dc10 <lseek>
105243: 85 d2 test %edx,%edx
105245: 78 19 js 105260 <msdos_format+0xc60> <== NEVER TAKEN
if (0 > write(fd,buffer,sector_size)) {
105247: 89 74 24 08 mov %esi,0x8(%esp)
10524b: 89 5c 24 04 mov %ebx,0x4(%esp)
10524f: 89 3c 24 mov %edi,(%esp)
105252: e8 29 ed ff ff call 103f80 <write>
105257: 85 c0 test %eax,%eax
105259: 0f 89 6b f9 ff ff jns 104bca <msdos_format+0x5ca>
10525f: 90 nop
ret_val = -1;
105260: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
105265: 89 85 00 ff ff ff mov %eax,-0x100(%ebp) <== NOT EXECUTED
10526b: e9 80 f4 ff ff jmp 1046f0 <msdos_format+0xf0> <== NOT EXECUTED
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
105270: 88 85 18 ff ff ff mov %al,-0xe8(%ebp)
105276: 0f b6 c4 movzbl %ah,%eax
105279: 89 85 20 ff ff ff mov %eax,-0xe0(%ebp)
10527f: c6 85 24 ff ff ff 00 movb $0x0,-0xdc(%ebp)
105286: c6 85 14 ff ff ff 00 movb $0x0,-0xec(%ebp)
10528d: c6 85 10 ff ff ff 00 movb $0x0,-0xf0(%ebp)
105294: c6 85 0c ff ff ff 00 movb $0x0,-0xf4(%ebp)
10529b: e9 02 f7 ff ff jmp 1049a2 <msdos_format+0x3a2>
1052a0: 31 d2 xor %edx,%edx
from = ""; /* default: make "from" point to empty string */
1052a2: b9 cd 2a 13 00 mov $0x132acd,%ecx
1052a7: e9 ae f5 ff ff jmp 10485a <msdos_format+0x25a>
1052ac: b2 52 mov $0x52,%dl
from = "RTEMS"; /* default: make "from" point to OS Name */
1052ae: b9 48 2d 13 00 mov $0x132d48,%ecx
1052b3: e9 42 f5 ff ff jmp 1047fa <msdos_format+0x1fa>
fmt_params->fat_num = 2;
1052b8: c6 45 c0 02 movb $0x2,-0x40(%ebp)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
1052bc: b8 02 00 00 00 mov $0x2,%eax
1052c1: 89 44 24 0c mov %eax,0xc(%esp)
1052c5: e9 73 fb ff ff jmp 104e3d <msdos_format+0x83d>
1052ca: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
if (fattype == FAT_FAT12) {
1052d0: 83 fb 01 cmp $0x1,%ebx
fatdata_sect_cnt = total_sector_cnt
1052d3: 8b 85 08 ff ff ff mov -0xf8(%ebp),%eax
if (fattype == FAT_FAT12) {
1052d9: 0f 84 31 01 00 00 je 105410 <msdos_format+0xe10>
else if (fattype == FAT_FAT16) {
1052df: 83 fb 02 cmp $0x2,%ebx
1052e2: 0f 85 4f fd ff ff jne 105037 <msdos_format+0xa37> <== NEVER TAKEN
return sectors;
1052e8: 8b 95 0c ff ff ff mov -0xf4(%ebp),%edx
fatdata_sect_cnt = fatdata_sect_cnt
1052ee: 29 d0 sub %edx,%eax
fatdata_cluster_cnt = fatdata_sect_cnt/sectors_per_cluster;
1052f0: 31 d2 xor %edx,%edx
1052f2: f7 f6 div %esi
1052f4: 89 c7 mov %eax,%edi
fat_capacity = fatdata_cluster_cnt * 2;
1052f6: 01 c0 add %eax,%eax
1052f8: e9 47 fd ff ff jmp 105044 <msdos_format+0xa44>
1052fd: 8d 76 00 lea 0x0(%esi),%esi
if (((fattype == FAT_FAT12) && (*data_cluster_cnt > FAT_FAT12_MAX_CLN)) ||
105300: 81 ff f5 0f 00 00 cmp $0xff5,%edi
105306: 77 48 ja 105350 <msdos_format+0xd50>
*sectors_per_fat_ptr = fat_sectors_cnt / fat_num;
105308: 89 c8 mov %ecx,%eax
10530a: 31 d2 xor %edx,%edx
uint32_t ms_sectors_per_cluster_limit_FAT16 =
10530c: 8b 9d 20 ff ff ff mov -0xe0(%ebp),%ebx
*sectors_per_fat_ptr = fat_sectors_cnt / fat_num;
105312: f7 b5 1c ff ff ff divl -0xe4(%ebp)
uint32_t ms_sectors_per_cluster_limit_FAT16 =
105318: 31 d2 xor %edx,%edx
fmt_params->sectors_per_cluster = sectors_per_cluster_adj;
10531a: 89 75 9c mov %esi,-0x64(%ebp)
*sectors_per_fat_ptr = fat_sectors_cnt / fat_num;
10531d: 89 45 a0 mov %eax,-0x60(%ebp)
uint32_t ms_sectors_per_cluster_limit_FAT16 =
105320: b8 01 80 00 00 mov $0x8001,%eax
105325: f7 f3 div %ebx
uint32_t ms_sectors_per_cluster_limit_FAT12 =
105327: 31 d2 xor %edx,%edx
uint32_t ms_sectors_per_cluster_limit_FAT16 =
105329: 89 c1 mov %eax,%ecx
uint32_t ms_sectors_per_cluster_limit_FAT12 =
10532b: b8 01 10 00 00 mov $0x1001,%eax
105330: f7 f3 div %ebx
if ( number_of_clusters < FAT_FAT12_MAX_CLN
105332: 39 c6 cmp %eax,%esi
105334: 0f 87 a6 fd ff ff ja 1050e0 <msdos_format+0xae0>
10533a: 81 ff f4 0f 00 00 cmp $0xff4,%edi
fattype = FAT_FAT12;
105340: b0 01 mov $0x1,%al
if ( number_of_clusters < FAT_FAT12_MAX_CLN
105342: 0f 86 ae fd ff ff jbe 1050f6 <msdos_format+0xaf6>
105348: e9 93 fd ff ff jmp 1050e0 <msdos_format+0xae0>
10534d: 8d 76 00 lea 0x0(%esi),%esi
if (MS_BYTES_PER_CLUSTER_LIMIT_FAT12 < (sectors_per_cluster * bytes_per_sector)) {
105350: 8b 85 20 ff ff ff mov -0xe0(%ebp),%eax
sectors_per_cluster *= 2;
105356: 01 f6 add %esi,%esi
if (MS_BYTES_PER_CLUSTER_LIMIT_FAT12 < (sectors_per_cluster * bytes_per_sector)) {
105358: 0f af c6 imul %esi,%eax
10535b: 3d 00 10 00 00 cmp $0x1000,%eax
105360: 0f 86 9a fc ff ff jbe 105000 <msdos_format+0xa00> <== ALWAYS TAKEN
105366: e9 47 fd ff ff jmp 1050b2 <msdos_format+0xab2> <== NOT EXECUTED
10536b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10536f: 90 nop <== NOT EXECUTED
*sectors_per_fat_ptr = fat_sectors_cnt / fat_num;
105370: 89 c8 mov %ecx,%eax
105372: 31 d2 xor %edx,%edx
uint32_t ms_sectors_per_cluster_limit_FAT16 =
105374: 8b 9d 20 ff ff ff mov -0xe0(%ebp),%ebx
*sectors_per_fat_ptr = fat_sectors_cnt / fat_num;
10537a: f7 b5 1c ff ff ff divl -0xe4(%ebp)
uint32_t ms_sectors_per_cluster_limit_FAT16 =
105380: 31 d2 xor %edx,%edx
fmt_params->sectors_per_cluster = sectors_per_cluster_adj;
105382: 89 75 9c mov %esi,-0x64(%ebp)
*sectors_per_fat_ptr = fat_sectors_cnt / fat_num;
105385: 89 45 a0 mov %eax,-0x60(%ebp)
uint32_t ms_sectors_per_cluster_limit_FAT16 =
105388: b8 01 80 00 00 mov $0x8001,%eax
10538d: f7 f3 div %ebx
uint32_t ms_sectors_per_cluster_limit_FAT12 =
10538f: 31 d2 xor %edx,%edx
uint32_t ms_sectors_per_cluster_limit_FAT16 =
105391: 89 c1 mov %eax,%ecx
uint32_t ms_sectors_per_cluster_limit_FAT12 =
105393: b8 01 10 00 00 mov $0x1001,%eax
105398: f7 f3 div %ebx
if ( number_of_clusters < FAT_FAT12_MAX_CLN
10539a: 39 f0 cmp %esi,%eax
10539c: 0f 82 3e fd ff ff jb 1050e0 <msdos_format+0xae0>
1053a2: 81 ff f4 0f 00 00 cmp $0xff4,%edi
1053a8: 0f 87 32 fd ff ff ja 1050e0 <msdos_format+0xae0> <== ALWAYS TAKEN
fmt_params->fattype = msdos_get_fat_type(
1053ae: c6 45 c2 01 movb $0x1,-0x3e(%ebp) <== NOT EXECUTED
fmt_params->sectors_per_cluster = 2;
1053b2: c7 45 9c 02 00 00 00 movl $0x2,-0x64(%ebp)
ret_val = msdos_set_sectors_per_cluster_from_request( rqdata,
1053b9: 8b 45 0c mov 0xc(%ebp),%eax
1053bc: 8d 55 90 lea -0x70(%ebp),%edx
1053bf: e8 bc ef ff ff call 104380 <msdos_set_sectors_per_cluster_from_request>
if (fat_type != fmt_params->fattype && 1 < iteration_cnt) {
1053c4: 0f b6 9d 07 ff ff ff movzbl -0xf9(%ebp),%ebx
1053cb: 38 5d c2 cmp %bl,-0x3e(%ebp)
--fmt_params->totl_sector_cnt;
1053ce: 8b 5d 94 mov -0x6c(%ebp),%ebx
if (fat_type != fmt_params->fattype && 1 < iteration_cnt) {
1053d1: 0f 84 39 01 00 00 je 105510 <msdos_format+0xf10> <== NEVER TAKEN
1053d7: 80 bd 06 ff ff ff 01 cmpb $0x1,-0xfa(%ebp)
1053de: 0f 86 2c 01 00 00 jbe 105510 <msdos_format+0xf10>
--fmt_params->totl_sector_cnt;
1053e4: 4b dec %ebx <== NOT EXECUTED
1053e5: 89 9d 14 ff ff ff mov %ebx,-0xec(%ebp) <== NOT EXECUTED
1053eb: 89 5d 94 mov %ebx,-0x6c(%ebp) <== NOT EXECUTED
++iteration_cnt;
1053ee: fe 85 06 ff ff ff incb -0xfa(%ebp) <== NOT EXECUTED
while( ret_val == 0
1053f4: 85 c0 test %eax,%eax <== NOT EXECUTED
1053f6: 0f 84 d4 fa ff ff je 104ed0 <msdos_format+0x8d0> <== NOT EXECUTED
1053fc: 89 85 00 ff ff ff mov %eax,-0x100(%ebp) <== NOT EXECUTED
105402: e9 89 f3 ff ff jmp 104790 <msdos_format+0x190> <== NOT EXECUTED
105407: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10540e: 66 90 xchg %ax,%ax <== NOT EXECUTED
return sectors;
105410: 8b 95 0c ff ff ff mov -0xf4(%ebp),%edx
fatdata_sect_cnt = fatdata_sect_cnt
105416: 29 d0 sub %edx,%eax
fatdata_cluster_cnt = fatdata_sect_cnt/sectors_per_cluster;
105418: 31 d2 xor %edx,%edx
10541a: f7 f6 div %esi
10541c: 89 c7 mov %eax,%edi
fat_capacity = fatdata_cluster_cnt * 3 / 2;
10541e: 8d 04 40 lea (%eax,%eax,2),%eax
105421: d1 e8 shr %eax
105423: e9 1c fc ff ff jmp 105044 <msdos_format+0xa44>
105428: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10542f: 90 nop
return (sectors + clustersize - 1) & ~(clustersize - 1);
105430: 8b bd 0c ff ff ff mov -0xf4(%ebp),%edi
105436: 8d 54 3e ff lea -0x1(%esi,%edi,1),%edx
10543a: 21 ca and %ecx,%edx
10543c: eb d8 jmp 105416 <msdos_format+0xe16>
10543e: 66 90 xchg %ax,%ax
105440: 8b bd 0c ff ff ff mov -0xf4(%ebp),%edi
105446: 8d 54 3e ff lea -0x1(%esi,%edi,1),%edx
10544a: 21 ca and %ecx,%edx
10544c: e9 9d fe ff ff jmp 1052ee <msdos_format+0xcee>
105451: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
105458: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10545f: 90 nop
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
105460: 89 44 24 0c mov %eax,0xc(%esp)
105464: ba 8e 2d 13 00 mov $0x132d8e,%edx
105469: b9 02 00 00 00 mov $0x2,%ecx
10546e: 89 54 24 08 mov %edx,0x8(%esp)
105472: 89 4c 24 04 mov %ecx,0x4(%esp)
105476: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10547d: e8 9e ee ff ff call 104320 <msdos_format_printf>
if (fmt_params->fattype == FAT_FAT32) {
105482: 0f b6 45 c2 movzbl -0x3e(%ebp),%eax
105486: 88 85 07 ff ff ff mov %al,-0xf9(%ebp)
10548c: 3c 04 cmp $0x4,%al
10548e: 75 50 jne 1054e0 <msdos_format+0xee0>
+ fmt_params->bytes_per_sector - 1)
105490: 8b 45 90 mov -0x70(%ebp),%eax
105493: bb 04 00 00 00 mov $0x4,%ebx
105498: 31 c9 xor %ecx,%ecx
fmt_params->rsvd_sector_cnt = 32;
10549a: c7 45 98 20 00 00 00 movl $0x20,-0x68(%ebp)
fmt_params->files_per_root_dir = 0;
1054a1: c7 45 a8 00 00 00 00 movl $0x0,-0x58(%ebp)
fmt_params->mbr_copy_sec = 6;
1054a8: c7 45 b8 06 00 00 00 movl $0x6,-0x48(%ebp)
+ fmt_params->bytes_per_sector - 1)
1054af: 89 85 20 ff ff ff mov %eax,-0xe0(%ebp)
1054b5: b8 20 00 00 00 mov $0x20,%eax
fmt_params->fsinfo_sec = 1;
1054ba: c7 45 bc 01 00 00 00 movl $0x1,-0x44(%ebp)
1054c1: 89 85 10 ff ff ff mov %eax,-0xf0(%ebp)
1054c7: c6 85 07 ff ff ff 04 movb $0x4,-0xf9(%ebp)
1054ce: e9 b4 fa ff ff jmp 104f87 <msdos_format+0x987>
1054d3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1054da: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
fmt_params->rsvd_sector_cnt = 1;
1054e0: c7 45 98 01 00 00 00 movl $0x1,-0x68(%ebp)
ret_val = msdos_format_eval_sectors_per_cluster(fmt_params->fattype,
1054e7: 8b 45 98 mov -0x68(%ebp),%eax
if (fmt_params->fattype == FAT_FAT16) {
1054ea: 80 bd 07 ff ff ff 02 cmpb $0x2,-0xf9(%ebp)
ret_val = msdos_format_eval_sectors_per_cluster(fmt_params->fattype,
1054f1: 89 85 10 ff ff ff mov %eax,-0xf0(%ebp)
if (fmt_params->fattype == FAT_FAT16) {
1054f7: 0f 84 03 01 00 00 je 105600 <msdos_format+0x1000>
ret_val = msdos_format_eval_sectors_per_cluster(fmt_params->fattype,
1054fd: 0f b6 9d 07 ff ff ff movzbl -0xf9(%ebp),%ebx
105504: b9 3f 00 00 00 mov $0x3f,%ecx
105509: e9 59 fa ff ff jmp 104f67 <msdos_format+0x967>
10550e: 66 90 xchg %ax,%ax
if ( fmt_params->totl_sector_cnt == 0 )
105510: 89 9d 14 ff ff ff mov %ebx,-0xec(%ebp)
105516: e9 d3 fe ff ff jmp 1053ee <msdos_format+0xdee>
10551b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10551f: 90 nop
memset(fmt_params.sec,0,fmt_params.bytes_per_sector);
105520: 83 fa 08 cmp $0x8,%edx
105523: 0f 83 fe 01 00 00 jae 105727 <msdos_format+0x1127> <== ALWAYS TAKEN
105529: f6 c2 04 test $0x4,%dl
10552c: 74 09 je 105537 <msdos_format+0xf37> <== ALWAYS TAKEN
10552e: c7 07 00 00 00 00 movl $0x0,(%edi) <== NOT EXECUTED
105534: 83 c7 04 add $0x4,%edi <== NOT EXECUTED
105537: f6 c2 02 test $0x2,%dl
10553a: 74 08 je 105544 <msdos_format+0xf44> <== ALWAYS TAKEN
10553c: 66 c7 07 00 00 movw $0x0,(%edi) <== NOT EXECUTED
105541: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
105544: f6 c2 01 test $0x1,%dl
105547: 74 03 je 10554c <msdos_format+0xf4c> <== ALWAYS TAKEN
105549: c6 07 00 movb $0x0,(%edi) <== NOT EXECUTED
memcpy(MSDOS_DIR_NAME(fmt_params.sec),fmt_params.VolLabel,MSDOS_SHORT_NAME_LEN);
10554c: 8b 45 e4 mov -0x1c(%ebp),%eax
10554f: 8b 55 cc mov -0x34(%ebp),%edx
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
105552: 8b bd fc fe ff ff mov -0x104(%ebp),%edi
memcpy(MSDOS_DIR_NAME(fmt_params.sec),fmt_params.VolLabel,MSDOS_SHORT_NAME_LEN);
105558: 89 10 mov %edx,(%eax)
10555a: 8b 55 d0 mov -0x30(%ebp),%edx
ret_val = msdos_format_write_sec
10555d: 8b 75 90 mov -0x70(%ebp),%esi
memcpy(MSDOS_DIR_NAME(fmt_params.sec),fmt_params.VolLabel,MSDOS_SHORT_NAME_LEN);
105560: 89 50 04 mov %edx,0x4(%eax)
105563: 8b 55 d4 mov -0x2c(%ebp),%edx
105566: 66 89 50 08 mov %dx,0x8(%eax)
10556a: 0f b6 5d d6 movzbl -0x2a(%ebp),%ebx
10556e: 88 58 0a mov %bl,0xa(%eax)
*MSDOS_DIR_ATTR(fmt_params.sec) = MSDOS_ATTR_VOLUME_ID;
105571: 8b 45 e4 mov -0x1c(%ebp),%eax
105574: c6 40 0b 08 movb $0x8,0xb(%eax)
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
105578: 31 c0 xor %eax,%eax
10557a: 89 44 24 0c mov %eax,0xc(%esp)
10557e: 89 f0 mov %esi,%eax
fmt_params.sec);
105580: 8b 5d e4 mov -0x1c(%ebp),%ebx
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
105583: f7 65 b0 mull -0x50(%ebp)
105586: 89 3c 24 mov %edi,(%esp)
105589: 89 44 24 04 mov %eax,0x4(%esp)
10558d: 89 54 24 08 mov %edx,0x8(%esp)
105591: e8 7a 86 00 00 call 10dc10 <lseek>
105596: 85 d2 test %edx,%edx
105598: 0f 88 c2 fc ff ff js 105260 <msdos_format+0xc60> <== NEVER TAKEN
if (0 > write(fd,buffer,sector_size)) {
10559e: 89 74 24 08 mov %esi,0x8(%esp)
1055a2: 89 5c 24 04 mov %ebx,0x4(%esp)
1055a6: 89 3c 24 mov %edi,(%esp)
1055a9: e8 d2 e9 ff ff call 103f80 <write>
1055ae: 85 c0 test %eax,%eax
1055b0: 0f 88 aa fc ff ff js 105260 <msdos_format+0xc60> <== NEVER TAKEN
memset(fmt_params.sec,0,fmt_params.bytes_per_sector);
1055b6: 8b 55 90 mov -0x70(%ebp),%edx
1055b9: 8b 7d e4 mov -0x1c(%ebp),%edi
1055bc: 83 fa 08 cmp $0x8,%edx
1055bf: 0f 82 89 f6 ff ff jb 104c4e <msdos_format+0x64e> <== NEVER TAKEN
1055c5: f7 c7 01 00 00 00 test $0x1,%edi
1055cb: 0f 85 80 03 00 00 jne 105951 <msdos_format+0x1351> <== NEVER TAKEN
1055d1: f7 c7 02 00 00 00 test $0x2,%edi
1055d7: 0f 85 64 03 00 00 jne 105941 <msdos_format+0x1341> <== NEVER TAKEN
1055dd: f7 c7 04 00 00 00 test $0x4,%edi
1055e3: 0f 85 47 03 00 00 jne 105930 <msdos_format+0x1330>
1055e9: 89 d1 mov %edx,%ecx
1055eb: 31 c0 xor %eax,%eax
1055ed: c1 e9 02 shr $0x2,%ecx
1055f0: 83 e2 03 and $0x3,%edx
1055f3: f3 ab rep stos %eax,%es:(%edi)
1055f5: e9 54 f6 ff ff jmp 104c4e <msdos_format+0x64e>
1055fa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
fmt_params->files_per_root_dir = 512;
105600: bb 02 00 00 00 mov $0x2,%ebx <== NOT EXECUTED
105605: b9 ff 01 00 00 mov $0x1ff,%ecx <== NOT EXECUTED
10560a: e9 58 f9 ff ff jmp 104f67 <msdos_format+0x967> <== NOT EXECUTED
if (fat_type != fmt_params->fattype) {
10560f: 80 bd 07 ff ff ff 04 cmpb $0x4,-0xf9(%ebp)
fmt_params->fattype = msdos_get_fat_type(
105616: c6 45 c2 04 movb $0x4,-0x3e(%ebp)
if (fat_type != fmt_params->fattype) {
10561a: 0f 84 e5 fa ff ff je 105105 <msdos_format+0xb05>
if ( (gigs & ( 1 << b) ) != 0 )
105620: 8b 9d f8 fe ff ff mov -0x108(%ebp),%ebx
for ( b = 31; b > 0; b-- ) {
105626: b9 1f 00 00 00 mov $0x1f,%ecx
if ( (gigs & ( 1 << b) ) != 0 )
10562b: b8 01 00 00 00 mov $0x1,%eax
105630: eb 15 jmp 105647 <msdos_format+0x1047>
105632: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
105639: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
for ( b = 31; b > 0; b-- ) {
105640: 49 dec %ecx
105641: 0f 84 33 01 00 00 je 10577a <msdos_format+0x117a> <== NEVER TAKEN
if ( (gigs & ( 1 << b) ) != 0 )
105647: 89 c2 mov %eax,%edx
105649: d3 e2 shl %cl,%edx
10564b: 85 d3 test %edx,%ebx
10564d: 74 f1 je 105640 <msdos_format+0x1040>
fmt_params->sectors_per_cluster = 1 << b;
10564f: 89 55 9c mov %edx,-0x64(%ebp)
105652: e9 62 fd ff ff jmp 1053b9 <msdos_format+0xdb9>
FAT_SET_VAL8(fmt_params.sec,0,(fmt_params.media_code));
105657: 8b 45 e4 mov -0x1c(%ebp),%eax
break;
10565a: 31 ff xor %edi,%edi
10565c: 89 bd 18 ff ff ff mov %edi,-0xe8(%ebp)
FAT_SET_VAL8(fmt_params.sec,0,(fmt_params.media_code));
105662: 0f b6 5d c1 movzbl -0x3f(%ebp),%ebx
105666: 88 18 mov %bl,(%eax)
FAT_SET_VAL8(fmt_params.sec,1,(0x0f | (FAT_FAT12_EOC << 4)));
105668: 8b 45 e4 mov -0x1c(%ebp),%eax
10566b: c6 40 01 8f movb $0x8f,0x1(%eax)
FAT_SET_VAL8(fmt_params.sec,2,(FAT_FAT12_EOC >> 4));
10566f: 8b 45 e4 mov -0x1c(%ebp),%eax
105672: c6 40 02 ff movb $0xff,0x2(%eax)
break;
105676: e9 2b f6 ff ff jmp 104ca6 <msdos_format+0x6a6>
FAT_SET_VAL32(fmt_params.sec,0,0xffffff00|fmt_params.media_code);
10567b: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED
break;
10567e: 31 db xor %ebx,%ebx <== NOT EXECUTED
105680: 89 9d 18 ff ff ff mov %ebx,-0xe8(%ebp) <== NOT EXECUTED
FAT_SET_VAL32(fmt_params.sec,0,0xffffff00|fmt_params.media_code);
105686: 0f b6 55 c1 movzbl -0x3f(%ebp),%edx <== NOT EXECUTED
10568a: 88 10 mov %dl,(%eax) <== NOT EXECUTED
10568c: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED
10568f: c6 40 01 ff movb $0xff,0x1(%eax) <== NOT EXECUTED
105693: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED
105696: c6 40 02 ff movb $0xff,0x2(%eax) <== NOT EXECUTED
10569a: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED
10569d: c6 40 03 ff movb $0xff,0x3(%eax) <== NOT EXECUTED
FAT_SET_VAL32(fmt_params.sec,4,0xc0000000|FAT_FAT32_EOC);
1056a1: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED
1056a4: c6 40 04 f8 movb $0xf8,0x4(%eax) <== NOT EXECUTED
1056a8: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED
1056ab: c6 40 05 ff movb $0xff,0x5(%eax) <== NOT EXECUTED
1056af: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED
1056b2: c6 40 06 ff movb $0xff,0x6(%eax) <== NOT EXECUTED
1056b6: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED
1056b9: c6 40 07 cf movb $0xcf,0x7(%eax) <== NOT EXECUTED
break;
1056bd: e9 e4 f5 ff ff jmp 104ca6 <msdos_format+0x6a6> <== NOT EXECUTED
FAT_SET_VAL8(fmt_params.sec,0,fmt_params.media_code);
1056c2: 8b 45 e4 mov -0x1c(%ebp),%eax
break;
1056c5: 31 f6 xor %esi,%esi
1056c7: 89 b5 18 ff ff ff mov %esi,-0xe8(%ebp)
FAT_SET_VAL8(fmt_params.sec,0,fmt_params.media_code);
1056cd: 0f b6 5d c1 movzbl -0x3f(%ebp),%ebx
1056d1: 88 18 mov %bl,(%eax)
FAT_SET_VAL8(fmt_params.sec,1,0xff);
1056d3: 8b 45 e4 mov -0x1c(%ebp),%eax
1056d6: c6 40 01 ff movb $0xff,0x1(%eax)
FAT_SET_VAL16(fmt_params.sec,2,FAT_FAT16_EOC);
1056da: 8b 45 e4 mov -0x1c(%ebp),%eax
1056dd: c6 40 02 f8 movb $0xf8,0x2(%eax)
1056e1: 8b 45 e4 mov -0x1c(%ebp),%eax
1056e4: c6 40 03 ff movb $0xff,0x3(%eax)
break;
1056e8: e9 b9 f5 ff ff jmp 104ca6 <msdos_format+0x6a6>
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
1056ed: b8 02 00 00 00 mov $0x2,%eax
1056f2: ba 7a 2d 13 00 mov $0x132d7a,%edx
1056f7: 89 44 24 0c mov %eax,0xc(%esp)
1056fb: b9 02 00 00 00 mov $0x2,%ecx
105700: 89 54 24 08 mov %edx,0x8(%esp)
105704: 89 4c 24 04 mov %ecx,0x4(%esp)
105708: c7 04 24 00 00 00 00 movl $0x0,(%esp)
fmt_params->fat_num = 2;
10570f: c6 45 c0 02 movb $0x2,-0x40(%ebp)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
105713: e8 08 ec ff ff call 104320 <msdos_format_printf>
{
105718: b9 a8 7f 00 00 mov $0x7fa8,%ecx
uint32_t fat16_sect_per_clust = 32;
10571d: b8 20 00 00 00 mov $0x20,%eax
105722: e9 47 f7 ff ff jmp 104e6e <msdos_format+0x86e>
memset(fmt_params.sec,0,fmt_params.bytes_per_sector);
105727: f7 c7 01 00 00 00 test $0x1,%edi
10572d: 0f 85 62 02 00 00 jne 105995 <msdos_format+0x1395> <== NEVER TAKEN
105733: f7 c7 02 00 00 00 test $0x2,%edi
105739: 0f 85 46 02 00 00 jne 105985 <msdos_format+0x1385> <== NEVER TAKEN
10573f: f7 c7 04 00 00 00 test $0x4,%edi
105745: 0f 85 54 02 00 00 jne 10599f <msdos_format+0x139f> <== NEVER TAKEN
10574b: 89 d1 mov %edx,%ecx
10574d: 31 c0 xor %eax,%eax
10574f: c1 e9 02 shr $0x2,%ecx
105752: 83 e2 03 and $0x3,%edx
105755: f3 ab rep stos %eax,%es:(%edi)
105757: e9 cd fd ff ff jmp 105529 <msdos_format+0xf29>
else if (fmt_params->totl_sector_cnt < FAT_FAT16_MAX_CLN * fat16_sect_per_clust) {
10575c: 69 c0 f5 ff 00 00 imul $0xfff5,%eax,%eax
105762: 39 c2 cmp %eax,%edx
105764: 0f 83 46 01 00 00 jae 1058b0 <msdos_format+0x12b0>
fmt_params->fattype = FAT_FAT16;
10576a: c6 45 c2 02 movb $0x2,-0x3e(%ebp)
fmt_params->sectors_per_cluster = 2;
10576e: c7 45 9c 02 00 00 00 movl $0x2,-0x64(%ebp)
105775: e9 0a f7 ff ff jmp 104e84 <msdos_format+0x884>
10577a: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED
10577f: e9 cb fe ff ff jmp 10564f <msdos_format+0x104f> <== NOT EXECUTED
if ( fmt_params->totl_sector_cnt == 0 )
105784: 8b 85 14 ff ff ff mov -0xec(%ebp),%eax
10578a: 85 c0 test %eax,%eax
10578c: 0f 84 09 f0 ff ff je 10479b <msdos_format+0x19b> <== NEVER TAKEN
if (FAT_FAT32 != fmt_params->fattype)
105792: 80 bd 07 ff ff ff 04 cmpb $0x4,-0xf9(%ebp)
fmt_params->skip_alignment)
105799: 0f b6 45 e0 movzbl -0x20(%ebp),%eax
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
10579d: 8b 4d 9c mov -0x64(%ebp),%ecx
if (FAT_FAT32 != fmt_params->fattype)
1057a0: 74 1d je 1057bf <msdos_format+0x11bf>
if (! skip_alignment)
1057a2: 84 c0 test %al,%al
fmt_params->files_per_root_dir = loc_align_object (fmt_params->root_dir_sectors,
1057a4: 8b 5d ac mov -0x54(%ebp),%ebx
if (! skip_alignment)
1057a7: 75 0a jne 1057b3 <msdos_format+0x11b3>
return (sectors + clustersize - 1) & ~(clustersize - 1);
1057a9: 8d 5c 19 ff lea -0x1(%ecx,%ebx,1),%ebx
1057ad: 89 ca mov %ecx,%edx
1057af: f7 da neg %edx
1057b1: 21 d3 and %edx,%ebx
* (fmt_params->bytes_per_sector / FAT_DIRENTRY_SIZE);
1057b3: 8b 55 90 mov -0x70(%ebp),%edx
1057b6: c1 ea 05 shr $0x5,%edx
1057b9: 0f af d3 imul %ebx,%edx
fmt_params->files_per_root_dir = loc_align_object (fmt_params->root_dir_sectors,
1057bc: 89 55 a8 mov %edx,-0x58(%ebp)
if (! skip_alignment)
1057bf: 84 c0 test %al,%al
fmt_params->rsvd_sector_cnt = loc_align_object (fmt_params->rsvd_sector_cnt,
1057c1: 8b 75 98 mov -0x68(%ebp),%esi
if (! skip_alignment)
1057c4: 75 08 jne 1057ce <msdos_format+0x11ce>
return (sectors + clustersize - 1) & ~(clustersize - 1);
1057c6: 8d 74 31 ff lea -0x1(%ecx,%esi,1),%esi
1057ca: f7 d9 neg %ecx
1057cc: 21 ce and %ecx,%esi
fmt_params->rsvd_sector_cnt = loc_align_object (fmt_params->rsvd_sector_cnt,
1057ce: 89 75 98 mov %esi,-0x68(%ebp)
if ((rqdata != NULL) && (rqdata->media != 0)) {
1057d1: 8b 45 0c mov 0xc(%ebp),%eax
1057d4: 85 c0 test %eax,%eax
1057d6: 74 56 je 10582e <msdos_format+0x122e>
1057d8: 8b 45 0c mov 0xc(%ebp),%eax
1057db: 0f b6 58 14 movzbl 0x14(%eax),%ebx
1057df: 84 db test %bl,%bl
1057e1: 74 4b je 10582e <msdos_format+0x122e>
const char valid_media_codes[] =
1057e3: c6 85 34 ff ff ff ff movb $0xff,-0xcc(%ebp)
1057ea: b8 fb fc fd fe mov $0xfefdfcfb,%eax
1057ef: bf f0 f8 f9 fa mov $0xfaf9f8f0,%edi
1057f4: 89 85 30 ff ff ff mov %eax,-0xd0(%ebp)
if (NULL==memchr(valid_media_codes,
1057fa: b8 09 00 00 00 mov $0x9,%eax
1057ff: 89 44 24 08 mov %eax,0x8(%esp)
105803: 0f b6 c3 movzbl %bl,%eax
105806: 89 44 24 04 mov %eax,0x4(%esp)
10580a: 8d 85 2c ff ff ff lea -0xd4(%ebp),%eax
105810: 89 04 24 mov %eax,(%esp)
const char valid_media_codes[] =
105813: 89 bd 2c ff ff ff mov %edi,-0xd4(%ebp)
if (NULL==memchr(valid_media_codes,
105819: e8 02 18 02 00 call 127020 <memchr>
10581e: 85 c0 test %eax,%eax
105820: 0f 84 75 ef ff ff je 10479b <msdos_format+0x19b>
fmt_params->media_code = rqdata->media;
105826: 88 5d c1 mov %bl,-0x3f(%ebp) <== NOT EXECUTED
if ((rqdata != NULL) && (rqdata->media != 0)) {
105829: e9 86 ef ff ff jmp 1047b4 <msdos_format+0x1b4> <== NOT EXECUTED
fmt_params->media_code = FAT_BR_MEDIA_FIXED;
10582e: c6 45 c1 f8 movb $0xf8,-0x3f(%ebp)
105832: e9 7d ef ff ff jmp 1047b4 <msdos_format+0x1b4>
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
105837: 66 c7 02 00 00 movw $0x0,(%edx) <== NOT EXECUTED
10583c: 83 ef 02 sub $0x2,%edi <== NOT EXECUTED
10583f: 83 c2 02 add $0x2,%edx <== NOT EXECUTED
105842: e9 5a f9 ff ff jmp 1051a1 <msdos_format+0xba1> <== NOT EXECUTED
105847: c6 06 00 movb $0x0,(%esi) <== NOT EXECUTED
10584a: 8d 56 01 lea 0x1(%esi),%edx <== NOT EXECUTED
10584d: bf ff 01 00 00 mov $0x1ff,%edi <== NOT EXECUTED
105852: e9 41 f9 ff ff jmp 105198 <msdos_format+0xb98> <== NOT EXECUTED
FAT_SET_BR_FAT32_ROOT_CLUSTER(mbr , 2); /* put root dir to cluster 2 */
105857: c6 41 2c 02 movb $0x2,0x2c(%ecx)
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
10585b: 8b 45 a0 mov -0x60(%ebp),%eax
FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo to rsrvd sec 1*/
10585e: c6 41 30 01 movb $0x1,0x30(%ecx)
FAT_SET_BR_FAT32_BOOTSIG(mbr ,FAT_BR_FAT32_BOOTSIG_VAL);
105862: c6 41 42 29 movb $0x29,0x42(%ecx)
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
105866: 89 41 24 mov %eax,0x24(%ecx)
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
105869: 8b 45 b8 mov -0x48(%ebp),%eax
memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
10586c: c7 41 34 00 00 00 00 movl $0x0,0x34(%ecx)
105873: c7 41 38 00 00 00 00 movl $0x0,0x38(%ecx)
10587a: c7 41 3c 00 00 00 00 movl $0x0,0x3c(%ecx)
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
105881: 66 89 41 32 mov %ax,0x32(%ecx)
memset(FAT_GET_ADDR_BR_FAT32_VOLLAB(mbr) ,0,FAT_BR_VOLLAB_SIZE);
105885: c7 41 47 00 00 00 00 movl $0x0,0x47(%ecx)
10588c: c7 41 4b 00 00 00 00 movl $0x0,0x4b(%ecx)
105893: 66 c7 41 4f 00 00 movw $0x0,0x4f(%ecx)
105899: c6 41 51 00 movb $0x0,0x51(%ecx)
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
10589d: c7 41 52 46 41 54 33 movl $0x33544146,0x52(%ecx)
1058a4: c7 41 56 32 20 20 20 movl $0x20202032,0x56(%ecx)
1058ab: e9 2c f2 ff ff jmp 104adc <msdos_format+0x4dc>
fmt_params->fattype = FAT_FAT32;
1058b0: c6 45 c2 04 movb $0x4,-0x3e(%ebp)
uint32_t gigs = (total_size + ONE_GB) / ONE_GB;
1058b4: 89 f0 mov %esi,%eax
1058b6: 89 fa mov %edi,%edx
1058b8: 05 00 00 00 40 add $0x40000000,%eax
for (b = 31; b > 0; b--)
1058bd: b9 1f 00 00 00 mov $0x1f,%ecx
uint32_t gigs = (total_size + ONE_GB) / ONE_GB;
1058c2: 83 d2 00 adc $0x0,%edx
1058c5: 0f ac d0 1e shrd $0x1e,%edx,%eax
if ((gigs & (1 << b)) != 0)
1058c9: ba 01 00 00 00 mov $0x1,%edx
1058ce: eb 07 jmp 1058d7 <msdos_format+0x12d7>
for (b = 31; b > 0; b--)
1058d0: 49 dec %ecx
1058d1: 0f 84 84 00 00 00 je 10595b <msdos_format+0x135b>
if ((gigs & (1 << b)) != 0)
1058d7: 89 d3 mov %edx,%ebx
1058d9: d3 e3 shl %cl,%ebx
1058db: 85 d8 test %ebx,%eax
1058dd: 74 f1 je 1058d0 <msdos_format+0x12d0>
fmt_params->sectors_per_cluster = 1 << b;
1058df: 89 5d 9c mov %ebx,-0x64(%ebp)
1058e2: e9 9d f5 ff ff jmp 104e84 <msdos_format+0x884>
*volid_ptr = rand();
1058e7: e8 a4 22 02 00 call 127b90 <rand>
1058ec: 89 45 dc mov %eax,-0x24(%ebp)
1058ef: 90 nop
1058f0: e9 c6 ef ff ff jmp 1048bb <msdos_format+0x2bb>
1058f5: ba 32 20 20 20 mov $0x20202032,%edx
1058fa: e9 d7 f1 ff ff jmp 104ad6 <msdos_format+0x4d6>
if (ret_val == 0 && rqdata != NULL && rqdata->sync_device) {
1058ff: 8b b5 18 ff ff ff mov -0xe8(%ebp),%esi <== NOT EXECUTED
105905: 85 f6 test %esi,%esi <== NOT EXECUTED
105907: 0f 94 c0 sete %al <== NOT EXECUTED
10590a: 20 85 1c ff ff ff and %al,-0xe4(%ebp) <== NOT EXECUTED
105910: e9 5c f4 ff ff jmp 104d71 <msdos_format+0x771> <== NOT EXECUTED
errno = EINVAL;
105915: e8 86 0f 02 00 call 1268a0 <__errno>
ret_val = -1;
10591a: b9 ff ff ff ff mov $0xffffffff,%ecx
10591f: 89 8d 00 ff ff ff mov %ecx,-0x100(%ebp)
errno = EINVAL;
105925: c7 00 16 00 00 00 movl $0x16,(%eax)
if (ret_val == 0) {
10592b: e9 60 ee ff ff jmp 104790 <msdos_format+0x190>
memset(fmt_params.sec,0,fmt_params.bytes_per_sector);
105930: c7 07 00 00 00 00 movl $0x0,(%edi)
105936: 83 ea 04 sub $0x4,%edx
105939: 83 c7 04 add $0x4,%edi
10593c: e9 a8 fc ff ff jmp 1055e9 <msdos_format+0xfe9>
105941: 66 c7 07 00 00 movw $0x0,(%edi) <== NOT EXECUTED
105946: 83 ea 02 sub $0x2,%edx <== NOT EXECUTED
105949: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
10594c: e9 8c fc ff ff jmp 1055dd <msdos_format+0xfdd> <== NOT EXECUTED
105951: c6 07 00 movb $0x0,(%edi) <== NOT EXECUTED
105954: 4a dec %edx <== NOT EXECUTED
105955: 47 inc %edi <== NOT EXECUTED
105956: e9 76 fc ff ff jmp 1055d1 <msdos_format+0xfd1> <== NOT EXECUTED
10595b: bb 01 00 00 00 mov $0x1,%ebx
105960: e9 7a ff ff ff jmp 1058df <msdos_format+0x12df>
memset(mbr,0,RTEMS_IDE_PARTITION_TABLE_OFFSET);
105965: c6 01 00 movb $0x0,(%ecx) <== NOT EXECUTED
105968: 8d 71 01 lea 0x1(%ecx),%esi <== NOT EXECUTED
10596b: bf bd 01 00 00 mov $0x1bd,%edi <== NOT EXECUTED
105970: e9 42 f0 ff ff jmp 1049b7 <msdos_format+0x3b7> <== NOT EXECUTED
105975: 66 c7 06 00 00 movw $0x0,(%esi) <== NOT EXECUTED
10597a: 83 ef 02 sub $0x2,%edi <== NOT EXECUTED
10597d: 83 c6 02 add $0x2,%esi <== NOT EXECUTED
105980: e9 3e f0 ff ff jmp 1049c3 <msdos_format+0x3c3> <== NOT EXECUTED
memset(fmt_params.sec,0,fmt_params.bytes_per_sector);
105985: 66 c7 07 00 00 movw $0x0,(%edi) <== NOT EXECUTED
10598a: 83 ea 02 sub $0x2,%edx <== NOT EXECUTED
10598d: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
105990: e9 aa fd ff ff jmp 10573f <msdos_format+0x113f> <== NOT EXECUTED
105995: c6 07 00 movb $0x0,(%edi) <== NOT EXECUTED
105998: 4a dec %edx <== NOT EXECUTED
105999: 47 inc %edi <== NOT EXECUTED
10599a: e9 94 fd ff ff jmp 105733 <msdos_format+0x1133> <== NOT EXECUTED
10599f: c7 07 00 00 00 00 movl $0x0,(%edi) <== NOT EXECUTED
1059a5: 83 ea 04 sub $0x4,%edx <== NOT EXECUTED
1059a8: 83 c7 04 add $0x4,%edi <== NOT EXECUTED
1059ab: e9 9b fd ff ff jmp 10574b <msdos_format+0x114b> <== NOT EXECUTED
1059b0: 8b 85 18 ff ff ff mov -0xe8(%ebp),%eax
1059b6: 89 85 00 ff ff ff mov %eax,-0x100(%ebp)
1059bc: e9 2f ed ff ff jmp 1046f0 <msdos_format+0xf0>
1059c1: 90 nop
1059c2: 90 nop
1059c3: 90 nop
1059c4: 90 nop
1059c5: 90 nop
1059c6: 90 nop
1059c7: 90 nop
1059c8: 90 nop
1059c9: 90 nop
1059ca: 90 nop
1059cb: 90 nop
1059cc: 90 nop
1059cd: 90 nop
1059ce: 90 nop
1059cf: 90 nop
001125d0 <msdos_format_dirent_with_dot>:
{
1125d0: 55 push %ebp
for (i = MSDOS_SHORT_BASE_LEN, src_tmp = src + MSDOS_SHORT_BASE_LEN - 1;
1125d1: b8 08 00 00 00 mov $0x8,%eax
{
1125d6: 89 e5 mov %esp,%ebp
1125d8: 57 push %edi
1125d9: 56 push %esi
1125da: 53 push %ebx
1125db: 83 ec 08 sub $0x8,%esp
1125de: 8b 4d 0c mov 0xc(%ebp),%ecx
1125e1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1125e8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1125ef: 90 nop
i > 0 && *src_tmp == ' ';
1125f0: 0f b6 54 01 ff movzbl -0x1(%ecx,%eax,1),%edx
1125f5: 89 c3 mov %eax,%ebx
--i,--src_tmp)
1125f7: 48 dec %eax
i > 0 && *src_tmp == ' ';
1125f8: 80 fa 20 cmp $0x20,%dl
1125fb: 75 33 jne 112630 <msdos_format_dirent_with_dot+0x60>
for (i = MSDOS_SHORT_BASE_LEN, src_tmp = src + MSDOS_SHORT_BASE_LEN - 1;
1125fd: 85 c0 test %eax,%eax
1125ff: 75 ef jne 1125f0 <msdos_format_dirent_with_dot+0x20> <== ALWAYS TAKEN
i > 0 && *src_tmp == ' ';
112601: 8b 7d 0c mov 0xc(%ebp),%edi
112604: 80 7f 0a 20 cmpb $0x20,0xa(%edi)
112608: 75 6b jne 112675 <msdos_format_dirent_with_dot+0xa5>
11260a: 80 7f 09 20 cmpb $0x20,0x9(%edi)
11260e: 0f 85 cb 00 00 00 jne 1126df <msdos_format_dirent_with_dot+0x10f>
112614: 80 7f 08 20 cmpb $0x20,0x8(%edi)
112618: 0f 85 de 00 00 00 jne 1126fc <msdos_format_dirent_with_dot+0x12c>
*dst = '\0'; /* terminate string */
11261e: 8b 7d 08 mov 0x8(%ebp),%edi
112621: c6 07 00 movb $0x0,(%edi)
}
112624: 83 c4 08 add $0x8,%esp
112627: 5b pop %ebx
112628: 5e pop %esi
112629: 5f pop %edi
11262a: 5d pop %ebp
11262b: c3 ret
11262c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
112630: 89 5d f0 mov %ebx,-0x10(%ebp)
112633: 8b 75 0c mov 0xc(%ebp),%esi
112636: 8b 7d 08 mov 0x8(%ebp),%edi
112639: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
*dst++ = tolower((unsigned char)(*src_tmp++));
112640: 0f b6 1e movzbl (%esi),%ebx
112643: 46 inc %esi
112644: 0f b6 93 e1 6a 13 00 movzbl 0x136ae1(%ebx),%edx
11264b: 89 d9 mov %ebx,%ecx
11264d: 80 e2 03 and $0x3,%dl
112650: fe ca dec %dl
112652: 75 03 jne 112657 <msdos_format_dirent_with_dot+0x87>
112654: 80 c1 20 add $0x20,%cl
while (i-- > 0) {
112657: 8b 5d 0c mov 0xc(%ebp),%ebx
11265a: ba 01 00 00 00 mov $0x1,%edx
*dst++ = tolower((unsigned char)(*src_tmp++));
11265f: 47 inc %edi
112660: 88 4f ff mov %cl,-0x1(%edi)
while (i-- > 0) {
112663: 29 f2 sub %esi,%edx
112665: 01 da add %ebx,%edx
112667: 01 c2 add %eax,%edx
112669: 85 d2 test %edx,%edx
11266b: 7f d3 jg 112640 <msdos_format_dirent_with_dot+0x70>
*dst++ = tolower((unsigned char)(*src_tmp++));
11266d: 8b 45 f0 mov -0x10(%ebp),%eax
112670: 01 45 08 add %eax,0x8(%ebp)
112673: eb 8c jmp 112601 <msdos_format_dirent_with_dot+0x31>
*dst++ = '.'; /* append dot */
112675: 8b 5d 08 mov 0x8(%ebp),%ebx
++len; /* dot */
112678: 40 inc %eax
--i, --src_tmp)
112679: bf 02 00 00 00 mov $0x2,%edi
++len; /* dot */
11267e: 89 45 ec mov %eax,-0x14(%ebp)
src_tmp = src + MSDOS_SHORT_BASE_LEN;
112681: 8b 45 0c mov 0xc(%ebp),%eax
*dst++ = '.'; /* append dot */
112684: 43 inc %ebx
112685: 89 5d f0 mov %ebx,-0x10(%ebp)
112688: 8b 5d 08 mov 0x8(%ebp),%ebx
src_tmp = src + MSDOS_SHORT_BASE_LEN;
11268b: 83 c0 08 add $0x8,%eax
*dst++ = '.'; /* append dot */
11268e: c6 03 2e movb $0x2e,(%ebx)
--i, --src_tmp)
112691: 8b 75 f0 mov -0x10(%ebp),%esi
*dst++ = tolower((unsigned char)(*src_tmp++));
112694: 0f b6 18 movzbl (%eax),%ebx
112697: 40 inc %eax
112698: 0f b6 93 e1 6a 13 00 movzbl 0x136ae1(%ebx),%edx
11269f: 89 d9 mov %ebx,%ecx
1126a1: 80 e2 03 and $0x3,%dl
1126a4: fe ca dec %dl
1126a6: 75 03 jne 1126ab <msdos_format_dirent_with_dot+0xdb>
1126a8: 80 c1 20 add $0x20,%cl
1126ab: 88 0e mov %cl,(%esi)
while (i-- > 0) {
1126ad: 8b 4d 08 mov 0x8(%ebp),%ecx
*dst++ = tolower((unsigned char)(*src_tmp++));
1126b0: 46 inc %esi
while (i-- > 0) {
1126b1: ba 02 00 00 00 mov $0x2,%edx
1126b6: 29 f2 sub %esi,%edx
1126b8: 01 ca add %ecx,%edx
1126ba: 01 fa add %edi,%edx
1126bc: 85 d2 test %edx,%edx
1126be: 7f d4 jg 112694 <msdos_format_dirent_with_dot+0xc4>
*dst++ = tolower((unsigned char)(*src_tmp++));
1126c0: 8b 45 f0 mov -0x10(%ebp),%eax
1126c3: 8d 44 38 01 lea 0x1(%eax,%edi,1),%eax
1126c7: 89 45 08 mov %eax,0x8(%ebp)
++len;
1126ca: 8b 45 ec mov -0x14(%ebp),%eax
1126cd: 8d 44 38 01 lea 0x1(%eax,%edi,1),%eax
*dst = '\0'; /* terminate string */
1126d1: 8b 7d 08 mov 0x8(%ebp),%edi
1126d4: c6 07 00 movb $0x0,(%edi)
}
1126d7: 83 c4 08 add $0x8,%esp
1126da: 5b pop %ebx
1126db: 5e pop %esi
1126dc: 5f pop %edi
1126dd: 5d pop %ebp
1126de: c3 ret
*dst++ = '.'; /* append dot */
1126df: 8b 5d 08 mov 0x8(%ebp),%ebx
++len; /* dot */
1126e2: 40 inc %eax
1126e3: 89 45 ec mov %eax,-0x14(%ebp)
src_tmp = src + MSDOS_SHORT_BASE_LEN;
1126e6: 8b 45 0c mov 0xc(%ebp),%eax
*dst++ = '.'; /* append dot */
1126e9: c6 03 2e movb $0x2e,(%ebx)
1126ec: 8d 7b 01 lea 0x1(%ebx),%edi
1126ef: 89 7d f0 mov %edi,-0x10(%ebp)
src_tmp = src + MSDOS_SHORT_BASE_LEN;
1126f2: 83 c0 08 add $0x8,%eax
--i, --src_tmp)
1126f5: bf 01 00 00 00 mov $0x1,%edi
1126fa: eb 95 jmp 112691 <msdos_format_dirent_with_dot+0xc1>
*dst++ = '.'; /* append dot */
1126fc: 8b 7d 08 mov 0x8(%ebp),%edi
++len; /* dot */
1126ff: 40 inc %eax
112700: 89 45 ec mov %eax,-0x14(%ebp)
src_tmp = src + MSDOS_SHORT_BASE_LEN;
112703: 8b 45 0c mov 0xc(%ebp),%eax
*dst++ = '.'; /* append dot */
112706: c6 07 2e movb $0x2e,(%edi)
112709: 8d 5f 01 lea 0x1(%edi),%ebx
--i, --src_tmp)
11270c: 31 ff xor %edi,%edi
*dst++ = '.'; /* append dot */
11270e: 89 5d f0 mov %ebx,-0x10(%ebp)
src_tmp = src + MSDOS_SHORT_BASE_LEN;
112711: 83 c0 08 add $0x8,%eax
while (i-- > 0) {
112714: e9 78 ff ff ff jmp 112691 <msdos_format_dirent_with_dot+0xc1>
112719: 90 nop
11271a: 90 nop
11271b: 90 nop
11271c: 90 nop
11271d: 90 nop
11271e: 90 nop
11271f: 90 nop
00113690 <msdos_get_dotdot_dir_info_cluster_num_and_offset>:
{
113690: 55 push %ebp
113691: 89 e5 mov %esp,%ebp
113693: 57 push %edi
113694: 56 push %esi
113695: 53 push %ebx
rc = fat_file_open(&fs_info->fat, dir_pos, &fat_fd);
113696: 8d 5d a4 lea -0x5c(%ebp),%ebx
{
113699: 81 ec 8c 00 00 00 sub $0x8c,%esp
fat_file_fd_t *fat_fd = NULL;
11369f: c7 45 a4 00 00 00 00 movl $0x0,-0x5c(%ebp)
msdos_fs_info_t *fs_info = mt_entry->fs_info;
1136a6: 8b 45 08 mov 0x8(%ebp),%eax
1136a9: 8b 78 08 mov 0x8(%eax),%edi
rc = fat_file_open(&fs_info->fat, dir_pos, &fat_fd);
1136ac: 8b 45 10 mov 0x10(%ebp),%eax
rtems_dosfs_convert_control *converter = fs_info->converter;
1136af: 8b b7 c8 00 00 00 mov 0xc8(%edi),%esi
rc = fat_file_open(&fs_info->fat, dir_pos, &fat_fd);
1136b5: 89 5c 24 08 mov %ebx,0x8(%esp)
1136b9: 89 44 24 04 mov %eax,0x4(%esp)
1136bd: 89 3c 24 mov %edi,(%esp)
1136c0: e8 4b cc ff ff call 110310 <fat_file_open>
if (rc != RC_OK)
1136c5: 85 c0 test %eax,%eax
rc = fat_file_open(&fs_info->fat, dir_pos, &fat_fd);
1136c7: 89 c2 mov %eax,%edx
if (rc != RC_OK)
1136c9: 74 15 je 1136e0 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x50><== ALWAYS TAKEN
}
1136cb: 81 c4 8c 00 00 00 add $0x8c,%esp
1136d1: 89 d0 mov %edx,%eax
1136d3: 5b pop %ebx
1136d4: 5e pop %esi
1136d5: 5f pop %edi
1136d6: 5d pop %ebp
1136d7: c3 ret
1136d8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1136df: 90 nop
fat_fd->cln = cln;
1136e0: 8b 45 a4 mov -0x5c(%ebp),%eax
1136e3: 8b 4d 0c mov 0xc(%ebp),%ecx
fat_fd->fat_file_type = FAT_DIRECTORY;
1136e6: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax)
fat_fd->cln = cln;
1136ed: 89 48 1c mov %ecx,0x1c(%eax)
fat_fd->size_limit = MSDOS_MAX_DIR_LENGTH;
1136f0: c7 40 14 00 00 20 00 movl $0x200000,0x14(%eax)
fat_fd->map.file_cln = 0;
1136f7: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax)
fat_fd->map.disk_cln = fat_fd->cln;
1136fe: 89 48 38 mov %ecx,0x38(%eax)
rc = fat_file_size(&fs_info->fat, fat_fd);
113701: 89 44 24 04 mov %eax,0x4(%esp)
113705: 89 3c 24 mov %edi,(%esp)
113708: e8 53 d9 ff ff call 111060 <fat_file_size>
if (rc != RC_OK)
11370d: 85 c0 test %eax,%eax
rc = fat_file_size(&fs_info->fat, fat_fd);
11370f: 89 c2 mov %eax,%edx
if (rc != RC_OK)
113711: 0f 85 f9 01 00 00 jne 113910 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x280><== NEVER TAKEN
memset(dot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
113717: 8d 55 a8 lea -0x58(%ebp),%edx
11371a: 31 c9 xor %ecx,%ecx
11371c: 31 c0 xor %eax,%eax
11371e: 89 0c 02 mov %ecx,(%edx,%eax,1)
113721: 89 4c 02 04 mov %ecx,0x4(%edx,%eax,1)
113725: 83 c0 08 add $0x8,%eax
113728: 83 f8 20 cmp $0x20,%eax
11372b: 72 f1 jb 11371e <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x8e>
msdos_long_to_short(
11372d: 89 54 24 0c mov %edx,0xc(%esp) <== NOT EXECUTED
113731: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
113736: b9 0b 00 00 00 mov $0xb,%ecx <== NOT EXECUTED
11373b: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
11373f: b8 12 4c 13 00 mov $0x134c12,%eax <== NOT EXECUTED
113744: 89 4c 24 10 mov %ecx,0x10(%esp) <== NOT EXECUTED
113748: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
11374c: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
11374f: e8 dc e5 ff ff call 111d30 <msdos_long_to_short> <== NOT EXECUTED
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, (const uint8_t*)".", 1,
113754: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
113757: 8d 55 a8 lea -0x58(%ebp),%edx <== NOT EXECUTED
11375a: 89 54 24 1c mov %edx,0x1c(%esp) <== NOT EXECUTED
11375e: 31 d2 xor %edx,%edx <== NOT EXECUTED
113760: 89 54 24 08 mov %edx,0x8(%esp) <== NOT EXECUTED
113764: 89 44 24 18 mov %eax,0x18(%esp) <== NOT EXECUTED
113768: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
11376d: 89 44 24 14 mov %eax,0x14(%esp) <== NOT EXECUTED
113771: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
113776: 89 44 24 10 mov %eax,0x10(%esp) <== NOT EXECUTED
11377a: b8 12 4c 13 00 mov $0x134c12,%eax <== NOT EXECUTED
11377f: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
113783: 8b 45 a4 mov -0x5c(%ebp),%eax <== NOT EXECUTED
113786: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
11378a: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
11378d: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
113790: e8 8b ef ff ff call 112720 <msdos_find_name_in_fat_file> <== NOT EXECUTED
if (rc != RC_OK)
113795: 85 c0 test %eax,%eax
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, (const uint8_t*)".", 1,
113797: 89 c2 mov %eax,%edx
if (rc != RC_OK)
113799: 0f 85 71 01 00 00 jne 113910 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x280><== NEVER TAKEN
memset(dotdot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
11379f: 8d 55 c8 lea -0x38(%ebp),%edx
1137a2: 31 c9 xor %ecx,%ecx
1137a4: 31 c0 xor %eax,%eax
1137a6: 89 0c 02 mov %ecx,(%edx,%eax,1)
1137a9: 89 4c 02 04 mov %ecx,0x4(%edx,%eax,1)
1137ad: 83 c0 08 add $0x8,%eax
1137b0: 83 f8 20 cmp $0x20,%eax
1137b3: 72 f1 jb 1137a6 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x116>
msdos_long_to_short(
1137b5: 89 54 24 0c mov %edx,0xc(%esp)
1137b9: b8 02 00 00 00 mov $0x2,%eax
1137be: b9 0b 00 00 00 mov $0xb,%ecx
1137c3: 89 44 24 08 mov %eax,0x8(%esp)
1137c7: b8 11 4c 13 00 mov $0x134c11,%eax
1137cc: 89 4c 24 10 mov %ecx,0x10(%esp)
1137d0: 89 44 24 04 mov %eax,0x4(%esp)
1137d4: 89 34 24 mov %esi,(%esp)
1137d7: e8 54 e5 ff ff call 111d30 <msdos_long_to_short>
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, (const uint8_t*)"..", 2,
1137dc: 8b 45 10 mov 0x10(%ebp),%eax
1137df: 8d 55 c8 lea -0x38(%ebp),%edx
1137e2: 89 54 24 1c mov %edx,0x1c(%esp)
1137e6: 31 d2 xor %edx,%edx
1137e8: 89 54 24 08 mov %edx,0x8(%esp)
1137ec: 89 44 24 18 mov %eax,0x18(%esp)
1137f0: b8 01 00 00 00 mov $0x1,%eax
1137f5: 89 44 24 14 mov %eax,0x14(%esp)
1137f9: b8 02 00 00 00 mov $0x2,%eax
1137fe: 89 44 24 10 mov %eax,0x10(%esp)
113802: b8 11 4c 13 00 mov $0x134c11,%eax
113807: 89 44 24 0c mov %eax,0xc(%esp)
11380b: 8b 45 a4 mov -0x5c(%ebp),%eax
11380e: 89 44 24 04 mov %eax,0x4(%esp)
113812: 8b 45 08 mov 0x8(%ebp),%eax
113815: 89 04 24 mov %eax,(%esp)
113818: e8 03 ef ff ff call 112720 <msdos_find_name_in_fat_file>
if (rc != RC_OK)
11381d: 85 c0 test %eax,%eax
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, (const uint8_t*)"..", 2,
11381f: 89 c2 mov %eax,%edx
if (rc != RC_OK)
113821: 0f 85 e9 00 00 00 jne 113910 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x280><== NEVER TAKEN
rc = fat_file_close(&fs_info->fat, fat_fd);
113827: 89 3c 24 mov %edi,(%esp)
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
11382a: 0f b7 45 c2 movzwl -0x3e(%ebp),%eax
11382e: 0f b7 75 bc movzwl -0x44(%ebp),%esi
113832: 89 45 94 mov %eax,-0x6c(%ebp)
rc = fat_file_close(&fs_info->fat, fat_fd);
113835: 8b 45 a4 mov -0x5c(%ebp),%eax
113838: 89 44 24 04 mov %eax,0x4(%esp)
11383c: e8 0f d1 ff ff call 110950 <fat_file_close>
if ( rc != RC_OK )
113841: 85 c0 test %eax,%eax
rc = fat_file_close(&fs_info->fat, fat_fd);
113843: 89 c2 mov %eax,%edx
if ( rc != RC_OK )
113845: 0f 85 80 fe ff ff jne 1136cb <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x3b><== NEVER TAKEN
if ( (MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
11384b: 0f b7 45 dc movzwl -0x24(%ebp),%eax
11384f: 0f b7 55 e2 movzwl -0x1e(%ebp),%edx
113853: c1 e0 10 shl $0x10,%eax
113856: 09 d0 or %edx,%eax
113858: 0f 84 e2 00 00 00 je 113940 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2b0>
rc = fat_file_open(&fs_info->fat, dir_pos, &fat_fd);
11385e: 89 5c 24 08 mov %ebx,0x8(%esp)
113862: 8b 45 10 mov 0x10(%ebp),%eax
113865: 89 3c 24 mov %edi,(%esp)
113868: 89 44 24 04 mov %eax,0x4(%esp)
11386c: e8 9f ca ff ff call 110310 <fat_file_open>
if (rc != RC_OK)
113871: 85 c0 test %eax,%eax
rc = fat_file_open(&fs_info->fat, dir_pos, &fat_fd);
113873: 89 c2 mov %eax,%edx
if (rc != RC_OK)
113875: 0f 85 50 fe ff ff jne 1136cb <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x3b><== NEVER TAKEN
if ((MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
11387b: 0f b7 45 dc movzwl -0x24(%ebp),%eax
11387f: 0f b7 4d e2 movzwl -0x1e(%ebp),%ecx
fat_fd->cln = fs_info->fat.vol.rdir_cl;
113883: 8b 55 a4 mov -0x5c(%ebp),%edx
if ((MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
113886: c1 e0 10 shl $0x10,%eax
113889: 09 c8 or %ecx,%eax
11388b: 0f 84 df 00 00 00 je 113970 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2e0>
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node);
113891: 89 42 1c mov %eax,0x1c(%edx)
fat_fd->fat_file_type = FAT_DIRECTORY;
113894: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx)
fat_fd->size_limit = MSDOS_MAX_DIR_LENGTH;
11389b: c7 42 14 00 00 20 00 movl $0x200000,0x14(%edx)
fat_fd->map.file_cln = 0;
1138a2: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx)
fat_fd->map.disk_cln = fat_fd->cln;
1138a9: 89 42 38 mov %eax,0x38(%edx)
rc = fat_file_size(&fs_info->fat, fat_fd);
1138ac: 89 54 24 04 mov %edx,0x4(%esp)
1138b0: 89 3c 24 mov %edi,(%esp)
1138b3: e8 a8 d7 ff ff call 111060 <fat_file_size>
if (rc != RC_OK)
1138b8: 85 c0 test %eax,%eax
rc = fat_file_size(&fs_info->fat, fat_fd);
1138ba: 89 c2 mov %eax,%edx
if (rc != RC_OK)
1138bc: 75 52 jne 113910 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x280><== NEVER TAKEN
rc = msdos_find_node_by_cluster_num_in_fat_file(mt_entry, fat_fd, cl4find,
1138be: 8b 45 14 mov 0x14(%ebp),%eax
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
1138c1: c1 e6 10 shl $0x10,%esi
rc = msdos_find_node_by_cluster_num_in_fat_file(mt_entry, fat_fd, cl4find,
1138c4: 89 44 24 10 mov %eax,0x10(%esp)
1138c8: 8b 45 10 mov 0x10(%ebp),%eax
1138cb: 89 44 24 0c mov %eax,0xc(%esp)
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
1138cf: 8b 45 94 mov -0x6c(%ebp),%eax
1138d2: 09 c6 or %eax,%esi
rc = msdos_find_node_by_cluster_num_in_fat_file(mt_entry, fat_fd, cl4find,
1138d4: 8b 45 a4 mov -0x5c(%ebp),%eax
1138d7: 89 74 24 08 mov %esi,0x8(%esp)
1138db: 89 44 24 04 mov %eax,0x4(%esp)
1138df: 8b 45 08 mov 0x8(%ebp),%eax
1138e2: 89 04 24 mov %eax,(%esp)
1138e5: e8 96 fb ff ff call 113480 <msdos_find_node_by_cluster_num_in_fat_file>
if (rc != RC_OK)
1138ea: 85 c0 test %eax,%eax
rc = msdos_find_node_by_cluster_num_in_fat_file(mt_entry, fat_fd, cl4find,
1138ec: 89 c2 mov %eax,%edx
if (rc != RC_OK)
1138ee: 75 20 jne 113910 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x280><== NEVER TAKEN
rc = fat_file_close(&fs_info->fat, fat_fd);
1138f0: 89 3c 24 mov %edi,(%esp)
1138f3: 8b 45 a4 mov -0x5c(%ebp),%eax
1138f6: 89 44 24 04 mov %eax,0x4(%esp)
1138fa: e8 51 d0 ff ff call 110950 <fat_file_close>
1138ff: 89 c2 mov %eax,%edx
return rc;
113901: e9 c5 fd ff ff jmp 1136cb <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x3b>
113906: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11390d: 8d 76 00 lea 0x0(%esi),%esi
fat_file_close(&fs_info->fat, fat_fd);
113910: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
113913: 8b 45 a4 mov -0x5c(%ebp),%eax <== NOT EXECUTED
113916: 89 55 94 mov %edx,-0x6c(%ebp) <== NOT EXECUTED
113919: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
11391d: e8 2e d0 ff ff call 110950 <fat_file_close> <== NOT EXECUTED
return rc;
113922: 8b 55 94 mov -0x6c(%ebp),%edx <== NOT EXECUTED
}
113925: 81 c4 8c 00 00 00 add $0x8c,%esp <== NOT EXECUTED
11392b: 5b pop %ebx <== NOT EXECUTED
11392c: 5e pop %esi <== NOT EXECUTED
11392d: 89 d0 mov %edx,%eax <== NOT EXECUTED
11392f: 5f pop %edi <== NOT EXECUTED
113930: 5d pop %ebp <== NOT EXECUTED
113931: c3 ret <== NOT EXECUTED
113932: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
113939: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
dir_pos->sname.ofs = 0;
113940: 8b 45 10 mov 0x10(%ebp),%eax
113943: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
11394a: c7 40 08 ff ff ff ff movl $0xffffffff,0x8(%eax)
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
113951: c7 40 0c ff ff ff ff movl $0xffffffff,0xc(%eax)
dir_pos->sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
113958: c7 00 01 00 00 00 movl $0x1,(%eax)
11395e: e9 fb fe ff ff jmp 11385e <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1ce>
113963: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11396a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
fat_fd->cln = fs_info->fat.vol.rdir_cl;
113970: 8b 47 44 mov 0x44(%edi),%eax
113973: 89 42 1c mov %eax,0x1c(%edx)
113976: e9 19 ff ff ff jmp 113894 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x204>
11397b: 90 nop
11397c: 90 nop
11397d: 90 nop
11397e: 90 nop
11397f: 90 nop
00113980 <msdos_get_name_node>:
{
113980: 55 push %ebp
113981: 89 e5 mov %esp,%ebp
113983: 83 ec 48 sub $0x48,%esp
113986: 89 75 f8 mov %esi,-0x8(%ebp)
113989: 8b 45 20 mov 0x20(%ebp),%eax
11398c: 89 7d fc mov %edi,-0x4(%ebp)
11398f: 0f b6 4d 0c movzbl 0xc(%ebp),%ecx
113993: 89 5d f4 mov %ebx,-0xc(%ebp)
113996: 8b 75 10 mov 0x10(%ebp),%esi
113999: 8b 7d 1c mov 0x1c(%ebp),%edi
rc = msdos_find_name_in_fat_file(parent_loc->mt_entry, fat_fd,
11399c: 89 44 24 1c mov %eax,0x1c(%esp)
{
1139a0: 8b 5d 08 mov 0x8(%ebp),%ebx
rc = msdos_find_name_in_fat_file(parent_loc->mt_entry, fat_fd,
1139a3: 89 45 e0 mov %eax,-0x20(%ebp)
1139a6: 8b 45 18 mov 0x18(%ebp),%eax
1139a9: 89 74 24 0c mov %esi,0xc(%esp)
1139ad: 89 7c 24 18 mov %edi,0x18(%esp)
1139b1: 88 4d e7 mov %cl,-0x19(%ebp)
1139b4: 89 44 24 14 mov %eax,0x14(%esp)
1139b8: 8b 45 14 mov 0x14(%ebp),%eax
1139bb: 89 44 24 10 mov %eax,0x10(%esp)
1139bf: 0f b6 c1 movzbl %cl,%eax
1139c2: 89 44 24 08 mov %eax,0x8(%esp)
1139c6: 8b 43 08 mov 0x8(%ebx),%eax
1139c9: 89 44 24 04 mov %eax,0x4(%esp)
1139cd: 8b 43 14 mov 0x14(%ebx),%eax
1139d0: 89 04 24 mov %eax,(%esp)
1139d3: e8 48 ed ff ff call 112720 <msdos_find_name_in_fat_file>
if ((rc != RC_OK) && (rc != MSDOS_NAME_NOT_FOUND_ERR))
1139d8: 85 c0 test %eax,%eax
1139da: 0f 95 c1 setne %cl
1139dd: 3d 01 7d 00 00 cmp $0x7d01,%eax
1139e2: 0f 95 c2 setne %dl
if (!create_node)
1139e5: 84 d1 test %dl,%cl
1139e7: 75 06 jne 1139ef <msdos_get_name_node+0x6f>
1139e9: 80 7d e7 00 cmpb $0x0,-0x19(%ebp)
1139ed: 74 11 je 113a00 <msdos_get_name_node+0x80>
}
1139ef: 8b 5d f4 mov -0xc(%ebp),%ebx
1139f2: 8b 75 f8 mov -0x8(%ebp),%esi
1139f5: 8b 7d fc mov -0x4(%ebp),%edi
1139f8: 89 ec mov %ebp,%esp
1139fa: 5d pop %ebp
1139fb: c3 ret
1139fc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
if (rc == MSDOS_NAME_NOT_FOUND_ERR)
113a00: 3d 01 7d 00 00 cmp $0x7d01,%eax
113a05: 74 e8 je 1139ef <msdos_get_name_node+0x6f>
if (rc == RC_OK)
113a07: 85 c0 test %eax,%eax
113a09: 75 e4 jne 1139ef <msdos_get_name_node+0x6f> <== NEVER TAKEN
if (strncmp(name, "..", 2) == 0)
113a0b: 80 3e 2e cmpb $0x2e,(%esi)
113a0e: 75 df jne 1139ef <msdos_get_name_node+0x6f>
113a10: 80 7e 01 2e cmpb $0x2e,0x1(%esi)
113a14: 75 d9 jne 1139ef <msdos_get_name_node+0x6f> <== NEVER TAKEN
dotdot_cln = MSDOS_EXTRACT_CLUSTER_NUM((name_dir_entry));
113a16: 8b 75 e0 mov -0x20(%ebp),%esi
113a19: 0f b7 56 14 movzwl 0x14(%esi),%edx
113a1d: c1 e2 10 shl $0x10,%edx
113a20: 89 d1 mov %edx,%ecx
113a22: 0f b7 56 1a movzwl 0x1a(%esi),%edx
if (dotdot_cln == 0)
113a26: 09 ca or %ecx,%edx
113a28: 75 26 jne 113a50 <msdos_get_name_node+0xd0>
dir_pos->sname.ofs = 0;
113a2a: c7 47 04 00 00 00 00 movl $0x0,0x4(%edi)
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
113a31: c7 47 08 ff ff ff ff movl $0xffffffff,0x8(%edi)
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
113a38: c7 47 0c ff ff ff ff movl $0xffffffff,0xc(%edi)
dir_pos->sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
113a3f: c7 07 01 00 00 00 movl $0x1,(%edi)
113a45: eb a8 jmp 1139ef <msdos_get_name_node+0x6f>
113a47: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
113a4e: 66 90 xchg %ax,%ax
msdos_get_dotdot_dir_info_cluster_num_and_offset(parent_loc->mt_entry,
113a50: 89 7d 10 mov %edi,0x10(%ebp)
113a53: 8b 45 e0 mov -0x20(%ebp),%eax
113a56: 89 55 0c mov %edx,0xc(%ebp)
}
113a59: 8b 75 f8 mov -0x8(%ebp),%esi
113a5c: 8b 7d fc mov -0x4(%ebp),%edi
msdos_get_dotdot_dir_info_cluster_num_and_offset(parent_loc->mt_entry,
113a5f: 89 45 14 mov %eax,0x14(%ebp)
113a62: 8b 43 14 mov 0x14(%ebx),%eax
}
113a65: 8b 5d f4 mov -0xc(%ebp),%ebx
msdos_get_dotdot_dir_info_cluster_num_and_offset(parent_loc->mt_entry,
113a68: 89 45 08 mov %eax,0x8(%ebp)
}
113a6b: 89 ec mov %ebp,%esp
113a6d: 5d pop %ebp
msdos_get_dotdot_dir_info_cluster_num_and_offset(parent_loc->mt_entry,
113a6e: e9 1d fc ff ff jmp 113690 <msdos_get_dotdot_dir_info_cluster_num_and_offset>
113a73: 90 nop
113a74: 90 nop
113a75: 90 nop
113a76: 90 nop
113a77: 90 nop
113a78: 90 nop
113a79: 90 nop
113a7a: 90 nop
113a7b: 90 nop
113a7c: 90 nop
113a7d: 90 nop
113a7e: 90 nop
113a7f: 90 nop
00111c90 <msdos_get_utf16_string_from_long_entry.part.0>:
msdos_get_utf16_string_from_long_entry (
111c90: 55 push %ebp <== NOT EXECUTED
if (is_first_entry) {
111c91: 84 c9 test %cl,%cl <== NOT EXECUTED
msdos_get_utf16_string_from_long_entry (
111c93: 89 e5 mov %esp,%ebp <== NOT EXECUTED
111c95: 57 push %edi <== NOT EXECUTED
111c96: 56 push %esi <== NOT EXECUTED
111c97: 53 push %ebx <== NOT EXECUTED
memcpy (&entry_string_buf[0], &entry[1], 10 );
111c98: 8b 70 01 mov 0x1(%eax),%esi <== NOT EXECUTED
111c9b: 89 32 mov %esi,(%edx) <== NOT EXECUTED
111c9d: 8b 70 05 mov 0x5(%eax),%esi <== NOT EXECUTED
111ca0: 89 72 04 mov %esi,0x4(%edx) <== NOT EXECUTED
111ca3: 0f b7 58 09 movzwl 0x9(%eax),%ebx <== NOT EXECUTED
111ca7: 66 89 5a 08 mov %bx,0x8(%edx) <== NOT EXECUTED
memcpy (&entry_string_buf[5], &entry[14], 12 );
111cab: 8b 78 0e mov 0xe(%eax),%edi <== NOT EXECUTED
111cae: 89 7a 0a mov %edi,0xa(%edx) <== NOT EXECUTED
111cb1: 8b 78 12 mov 0x12(%eax),%edi <== NOT EXECUTED
111cb4: 89 7a 0e mov %edi,0xe(%edx) <== NOT EXECUTED
111cb7: 8b 70 16 mov 0x16(%eax),%esi <== NOT EXECUTED
111cba: 89 72 12 mov %esi,0x12(%edx) <== NOT EXECUTED
memcpy (&entry_string_buf[11], &entry[28], 4 );
111cbd: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED
111cc0: 89 42 16 mov %eax,0x16(%edx) <== NOT EXECUTED
if (is_first_entry) {
111cc3: 74 18 je 111cdd <msdos_get_utf16_string_from_long_entry.part.0+0x4d><== NOT EXECUTED
for (chars_in_entry = 0;
111cc5: 31 c0 xor %eax,%eax
111cc7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
111cce: 66 90 xchg %ax,%ax
&& entry_string_buf[chars_in_entry] != 0x0000);
111cd0: 66 83 3c 42 00 cmpw $0x0,(%edx,%eax,2)
111cd5: 74 19 je 111cf0 <msdos_get_utf16_string_from_long_entry.part.0+0x60>
++chars_in_entry) {
111cd7: 40 inc %eax
for (chars_in_entry = 0;
111cd8: 83 f8 0d cmp $0xd,%eax
111cdb: 75 f3 jne 111cd0 <msdos_get_utf16_string_from_long_entry.part.0+0x40>
}
111cdd: 5b pop %ebx
111cde: b8 1a 00 00 00 mov $0x1a,%eax
111ce3: 5e pop %esi
111ce4: 5f pop %edi
111ce5: 5d pop %ebp
111ce6: c3 ret
111ce7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
111cee: 66 90 xchg %ax,%ax
111cf0: 5b pop %ebx
return chars_in_entry * MSDOS_NAME_LFN_BYTES_PER_CHAR;
111cf1: 01 c0 add %eax,%eax
}
111cf3: 5e pop %esi
111cf4: 5f pop %edi
111cf5: 5d pop %ebp
111cf6: c3 ret
111cf7: 90 nop
111cf8: 90 nop
111cf9: 90 nop
111cfa: 90 nop
111cfb: 90 nop
111cfc: 90 nop
111cfd: 90 nop
111cfe: 90 nop
111cff: 90 nop
00105b30 <msdos_initialize_support>:
const rtems_filesystem_operations_table *op_table,
const rtems_filesystem_file_handlers_r *file_handlers,
const rtems_filesystem_file_handlers_r *directory_handlers,
rtems_dosfs_convert_control *converter
)
{
105b30: 55 push %ebp
msdos_fs_info_t *fs_info = NULL;
fat_file_fd_t *fat_fd = NULL;
fat_dir_pos_t root_pos;
uint32_t cl_buf_size;
fs_info = (msdos_fs_info_t *)calloc(1, sizeof(msdos_fs_info_t));
105b31: b9 cc 00 00 00 mov $0xcc,%ecx
{
105b36: 89 e5 mov %esp,%ebp
105b38: 57 push %edi
105b39: 56 push %esi
105b3a: 53 push %ebx
105b3b: 83 ec 4c sub $0x4c,%esp
fs_info = (msdos_fs_info_t *)calloc(1, sizeof(msdos_fs_info_t));
105b3e: 89 4c 24 04 mov %ecx,0x4(%esp)
{
105b42: 8b 7d 08 mov 0x8(%ebp),%edi
fs_info = (msdos_fs_info_t *)calloc(1, sizeof(msdos_fs_info_t));
105b45: c7 04 24 01 00 00 00 movl $0x1,(%esp)
fat_file_fd_t *fat_fd = NULL;
105b4c: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
fs_info = (msdos_fs_info_t *)calloc(1, sizeof(msdos_fs_info_t));
105b53: e8 68 7d 00 00 call 10d8c0 <calloc>
if (!fs_info)
105b58: 85 c0 test %eax,%eax
105b5a: 0f 84 c8 01 00 00 je 105d28 <msdos_initialize_support+0x1f8> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one(ENOMEM);
temp_mt_entry->fs_info = fs_info;
105b60: 89 47 08 mov %eax,0x8(%edi)
105b63: 89 c3 mov %eax,%ebx
fs_info->converter = converter;
105b65: 8b 45 18 mov 0x18(%ebp),%eax
105b68: 89 83 c8 00 00 00 mov %eax,0xc8(%ebx)
rc = fat_init_volume_info(&fs_info->fat, temp_mt_entry->dev);
105b6e: 8b 47 38 mov 0x38(%edi),%eax
105b71: 89 1c 24 mov %ebx,(%esp)
105b74: 89 44 24 04 mov %eax,0x4(%esp)
105b78: e8 53 94 00 00 call 10efd0 <fat_init_volume_info>
if (rc != RC_OK)
105b7d: 85 c0 test %eax,%eax
rc = fat_init_volume_info(&fs_info->fat, temp_mt_entry->dev);
105b7f: 89 c6 mov %eax,%esi
if (rc != RC_OK)
105b81: 0f 85 11 01 00 00 jne 105c98 <msdos_initialize_support+0x168> <== NEVER TAKEN
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
105b87: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp)
{
free(fs_info);
return rc;
}
fs_info->file_handlers = file_handlers;
105b8e: 8b 45 10 mov 0x10(%ebp),%eax
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
105b91: c7 45 e0 ff ff ff ff movl $0xffffffff,-0x20(%ebp)
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
105b98: c7 45 e4 ff ff ff ff movl $0xffffffff,-0x1c(%ebp)
/*
* open fat-file which correspondes to root directory
* (so inode number 0x00000010 is always used for root directory)
*/
fat_dir_pos_init(&root_pos);
root_pos.sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
105b9f: c7 45 d8 01 00 00 00 movl $0x1,-0x28(%ebp)
fs_info->file_handlers = file_handlers;
105ba6: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx)
fs_info->directory_handlers = directory_handlers;
105bac: 8b 45 14 mov 0x14(%ebp),%eax
105baf: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx)
rc = fat_file_open(&fs_info->fat, &root_pos, &fat_fd);
105bb5: 8d 45 d4 lea -0x2c(%ebp),%eax
105bb8: 89 44 24 08 mov %eax,0x8(%esp)
105bbc: 8d 45 d8 lea -0x28(%ebp),%eax
105bbf: 89 44 24 04 mov %eax,0x4(%esp)
105bc3: 89 1c 24 mov %ebx,(%esp)
105bc6: e8 45 a7 00 00 call 110310 <fat_file_open>
if (rc != RC_OK)
105bcb: 85 c0 test %eax,%eax
rc = fat_file_open(&fs_info->fat, &root_pos, &fat_fd);
105bcd: 89 c6 mov %eax,%esi
if (rc != RC_OK)
105bcf: 0f 85 bb 00 00 00 jne 105c90 <msdos_initialize_support+0x160> <== NEVER TAKEN
}
/* again: unfortunately "fat-file" is just almost fat file :( */
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGTH;
fat_fd->cln = fs_info->fat.vol.rdir_cl;
105bd5: 8b 43 44 mov 0x44(%ebx),%eax
fat_fd->fat_file_type = FAT_DIRECTORY;
105bd8: 8b 55 d4 mov -0x2c(%ebp),%edx
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
/* if we have FAT12/16 */
if ( fat_fd->cln == 0 )
105bdb: 85 c0 test %eax,%eax
fat_fd->fat_file_type = FAT_DIRECTORY;
105bdd: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx)
fat_fd->size_limit = MSDOS_MAX_DIR_LENGTH;
105be4: c7 42 14 00 00 20 00 movl $0x200000,0x14(%edx)
fat_fd->cln = fs_info->fat.vol.rdir_cl;
105beb: 89 42 1c mov %eax,0x1c(%edx)
fat_fd->map.file_cln = 0;
105bee: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx)
fat_fd->map.disk_cln = fat_fd->cln;
105bf5: 89 42 38 mov %eax,0x38(%edx)
if ( fat_fd->cln == 0 )
105bf8: 0f 85 c2 00 00 00 jne 105cc0 <msdos_initialize_support+0x190>
{
fat_fd->fat_file_size = fs_info->fat.vol.rdir_size;
105bfe: 8b 4b 34 mov 0x34(%ebx),%ecx
cl_buf_size = (fs_info->fat.vol.bpc > fs_info->fat.vol.rdir_size) ?
105c01: 8b 43 08 mov 0x8(%ebx),%eax
fat_fd->fat_file_size = fs_info->fat.vol.rdir_size;
105c04: 89 4a 18 mov %ecx,0x18(%edx)
cl_buf_size = (fs_info->fat.vol.bpc > fs_info->fat.vol.rdir_size) ?
105c07: 39 c8 cmp %ecx,%eax
105c09: 0f 82 a1 00 00 00 jb 105cb0 <msdos_initialize_support+0x180>
105c0f: 89 55 c4 mov %edx,-0x3c(%ebp)
return rc;
}
cl_buf_size = fs_info->fat.vol.bpc;
}
fs_info->cl_buf = (uint8_t *)calloc(cl_buf_size, sizeof(char));
105c12: ba 01 00 00 00 mov $0x1,%edx
105c17: 89 54 24 04 mov %edx,0x4(%esp)
105c1b: 89 04 24 mov %eax,(%esp)
105c1e: e8 9d 7c 00 00 call 10d8c0 <calloc>
if (fs_info->cl_buf == NULL)
105c23: 8b 55 c4 mov -0x3c(%ebp),%edx
fs_info->cl_buf = (uint8_t *)calloc(cl_buf_size, sizeof(char));
105c26: 89 83 c4 00 00 00 mov %eax,0xc4(%ebx)
if (fs_info->cl_buf == NULL)
105c2c: 85 c0 test %eax,%eax
105c2e: 0f 84 d8 00 00 00 je 105d0c <msdos_initialize_support+0x1dc> <== NEVER TAKEN
const char *_name)
{
struct _Mutex_recursive_Control _init =
_MUTEX_RECURSIVE_NAMED_INITIALIZER(_name);
*_mutex = _init;
105c34: 31 c0 xor %eax,%eax
105c36: 31 c9 xor %ecx,%ecx
105c38: 89 83 ac 00 00 00 mov %eax,0xac(%ebx)
105c3e: 31 c0 xor %eax,%eax
105c40: 89 83 b4 00 00 00 mov %eax,0xb4(%ebx)
105c46: 31 c0 xor %eax,%eax
105c48: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx)
105c4e: b8 14 26 13 00 mov $0x132614,%eax
105c53: 89 83 bc 00 00 00 mov %eax,0xbc(%ebx)
105c59: 31 c0 xor %eax,%eax
105c5b: 89 8b b0 00 00 00 mov %ecx,0xb0(%ebx)
rtems_recursive_mutex_init(&fs_info->vol_mutex,
RTEMS_FILESYSTEM_TYPE_DOSFS);
temp_mt_entry->mt_fs_root->location.node_access = fat_fd;
temp_mt_entry->mt_fs_root->location.handlers = directory_handlers;
105c61: 8b 4d 14 mov 0x14(%ebp),%ecx
105c64: 89 83 c0 00 00 00 mov %eax,0xc0(%ebx)
temp_mt_entry->mt_fs_root->location.node_access = fat_fd;
105c6a: 8b 47 24 mov 0x24(%edi),%eax
105c6d: 89 50 08 mov %edx,0x8(%eax)
temp_mt_entry->mt_fs_root->location.handlers = directory_handlers;
105c70: 89 48 10 mov %ecx,0x10(%eax)
temp_mt_entry->ops = op_table;
105c73: 8b 45 0c mov 0xc(%ebp),%eax
105c76: 89 47 0c mov %eax,0xc(%edi)
return rc;
}
105c79: 83 c4 4c add $0x4c,%esp
105c7c: 89 f0 mov %esi,%eax
105c7e: 5b pop %ebx
105c7f: 5e pop %esi
105c80: 5f pop %edi
105c81: 5d pop %ebp
105c82: c3 ret
105c83: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
105c8a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
fat_shutdown_drive(&fs_info->fat);
105c90: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
105c93: e8 88 9b 00 00 call 10f820 <fat_shutdown_drive> <== NOT EXECUTED
free(fs_info);
105c98: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
105c9b: e8 b0 bf ff ff call 101c50 <free> <== NOT EXECUTED
}
105ca0: 83 c4 4c add $0x4c,%esp <== NOT EXECUTED
105ca3: 89 f0 mov %esi,%eax <== NOT EXECUTED
105ca5: 5b pop %ebx <== NOT EXECUTED
105ca6: 5e pop %esi <== NOT EXECUTED
105ca7: 5f pop %edi <== NOT EXECUTED
105ca8: 5d pop %ebp <== NOT EXECUTED
105ca9: c3 ret <== NOT EXECUTED
105caa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
cl_buf_size = (fs_info->fat.vol.bpc > fs_info->fat.vol.rdir_size) ?
105cb0: 89 c8 mov %ecx,%eax
105cb2: e9 58 ff ff ff jmp 105c0f <msdos_initialize_support+0xdf>
105cb7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
105cbe: 66 90 xchg %ax,%ax
rc = fat_file_size(&fs_info->fat, fat_fd);
105cc0: 89 54 24 04 mov %edx,0x4(%esp)
105cc4: 89 1c 24 mov %ebx,(%esp)
105cc7: e8 94 b3 00 00 call 111060 <fat_file_size>
if ( rc != RC_OK )
105ccc: 85 c0 test %eax,%eax
105cce: 75 10 jne 105ce0 <msdos_initialize_support+0x1b0> <== NEVER TAKEN
cl_buf_size = fs_info->fat.vol.bpc;
105cd0: 8b 43 08 mov 0x8(%ebx),%eax
fat_file_close(&fs_info->fat, fat_fd);
105cd3: 8b 55 d4 mov -0x2c(%ebp),%edx
105cd6: e9 34 ff ff ff jmp 105c0f <msdos_initialize_support+0xdf>
105cdb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
105cdf: 90 nop
105ce0: 89 45 c4 mov %eax,-0x3c(%ebp) <== NOT EXECUTED
fat_file_close(&fs_info->fat, fat_fd);
105ce3: 8b 45 d4 mov -0x2c(%ebp),%eax <== NOT EXECUTED
105ce6: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
105ce9: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
105ced: e8 5e ac 00 00 call 110950 <fat_file_close> <== NOT EXECUTED
fat_shutdown_drive(&fs_info->fat);
105cf2: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
105cf5: e8 26 9b 00 00 call 10f820 <fat_shutdown_drive> <== NOT EXECUTED
free(fs_info);
105cfa: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
105cfd: e8 4e bf ff ff call 101c50 <free> <== NOT EXECUTED
return rc;
105d02: 8b 55 c4 mov -0x3c(%ebp),%edx <== NOT EXECUTED
105d05: 89 d6 mov %edx,%esi <== NOT EXECUTED
105d07: e9 6d ff ff ff jmp 105c79 <msdos_initialize_support+0x149> <== NOT EXECUTED
fat_file_close(&fs_info->fat, fat_fd);
105d0c: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
105d10: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
105d13: e8 38 ac 00 00 call 110950 <fat_file_close> <== NOT EXECUTED
fat_shutdown_drive(&fs_info->fat);
105d18: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
105d1b: e8 00 9b 00 00 call 10f820 <fat_shutdown_drive> <== NOT EXECUTED
free(fs_info);
105d20: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
105d23: e8 28 bf ff ff call 101c50 <free> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
105d28: e8 73 0b 02 00 call 1268a0 <__errno> <== NOT EXECUTED
105d2d: 83 ce ff or $0xffffffff,%esi <== NOT EXECUTED
105d30: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED
105d36: e9 3e ff ff ff jmp 105c79 <msdos_initialize_support+0x149> <== NOT EXECUTED
105d3b: 90 nop
105d3c: 90 nop
105d3d: 90 nop
105d3e: 90 nop
105d3f: 90 nop
00111d00 <msdos_lfn_checksum>:
{
111d00: 55 push %ebp <== NOT EXECUTED
cs = 0;
111d01: 31 c0 xor %eax,%eax
{
111d03: 89 e5 mov %esp,%ebp
111d05: 53 push %ebx
111d06: 8b 55 08 mov 0x8(%ebp),%edx
111d09: 8d 5a 0b lea 0xb(%edx),%ebx
111d0c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + name[i];
111d10: 88 c1 mov %al,%cl
for (i = 0; i < MSDOS_SHORT_NAME_LEN; ++i) {
111d12: 42 inc %edx
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + name[i];
111d13: d0 e8 shr %al
111d15: 02 42 ff add -0x1(%edx),%al
111d18: c0 e1 07 shl $0x7,%cl
111d1b: 00 c8 add %cl,%al
for (i = 0; i < MSDOS_SHORT_NAME_LEN; ++i) {
111d1d: 39 d3 cmp %edx,%ebx
111d1f: 75 ef jne 111d10 <msdos_lfn_checksum+0x10>
}
111d21: 5b pop %ebx
111d22: 5d pop %ebp
111d23: c3 ret
111d24: 90 nop
111d25: 90 nop
111d26: 90 nop
111d27: 90 nop
111d28: 90 nop
111d29: 90 nop
111d2a: 90 nop
111d2b: 90 nop
111d2c: 90 nop
111d2d: 90 nop
111d2e: 90 nop
111d2f: 90 nop
00111d30 <msdos_long_to_short>:
{
111d30: 55 push %ebp
111d31: 89 e5 mov %esp,%ebp
111d33: 57 push %edi
111d34: 56 push %esi
111d35: 53 push %ebx
111d36: 83 ec 4c sub $0x4c,%esp
void *buffer = converter->buffer.data;
111d39: 8b 45 08 mov 0x8(%ebp),%eax
memset (sfn, ' ', sfn_len);
111d3c: 8b 55 18 mov 0x18(%ebp),%edx
111d3f: 8b 7d 14 mov 0x14(%ebp),%edi
void *buffer = converter->buffer.data;
111d42: 8b 40 04 mov 0x4(%eax),%eax
memset (sfn, ' ', sfn_len);
111d45: 83 fa 08 cmp $0x8,%edx
void *buffer = converter->buffer.data;
111d48: 89 45 d0 mov %eax,-0x30(%ebp)
size_t codepage_name_len = converter->buffer.size;
111d4b: 8b 45 08 mov 0x8(%ebp),%eax
111d4e: 8b 40 08 mov 0x8(%eax),%eax
111d51: 89 45 e4 mov %eax,-0x1c(%ebp)
memset (sfn, ' ', sfn_len);
111d54: 0f 83 f6 01 00 00 jae 111f50 <msdos_long_to_short+0x220> <== ALWAYS TAKEN
111d5a: f6 c2 04 test $0x4,%dl
111d5d: 74 09 je 111d68 <msdos_long_to_short+0x38> <== ALWAYS TAKEN
111d5f: c7 07 20 20 20 20 movl $0x20202020,(%edi) <== NOT EXECUTED
111d65: 83 c7 04 add $0x4,%edi <== NOT EXECUTED
111d68: f6 c2 02 test $0x2,%dl
111d6b: 74 08 je 111d75 <msdos_long_to_short+0x45> <== NEVER TAKEN
111d6d: 66 c7 07 20 20 movw $0x2020,(%edi)
111d72: 83 c7 02 add $0x2,%edi
111d75: f6 c2 01 test $0x1,%dl
111d78: 74 03 je 111d7d <msdos_long_to_short+0x4d> <== NEVER TAKEN
111d7a: c6 07 20 movb $0x20,(%edi)
if ((lfn[0] == '.') && (lfn_len == 1))
111d7d: 8b 45 0c mov 0xc(%ebp),%eax
111d80: 0f b6 10 movzbl (%eax),%edx
111d83: 80 fa 2e cmp $0x2e,%dl
111d86: 0f 84 04 02 00 00 je 111f90 <msdos_long_to_short+0x260>
for (i = 0; i < lfn_len; i++)
111d8c: 8b 4d 10 mov 0x10(%ebp),%ecx
111d8f: 31 c0 xor %eax,%eax
111d91: 85 c9 test %ecx,%ecx
111d93: 0f 8e 27 02 00 00 jle 111fc0 <msdos_long_to_short+0x290> <== NEVER TAKEN
111d99: 8b 5d 0c mov 0xc(%ebp),%ebx
111d9c: 8b 4d 10 mov 0x10(%ebp),%ecx
111d9f: eb 1c jmp 111dbd <msdos_long_to_short+0x8d>
111da1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
111da8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
111daf: 90 nop
111db0: 40 inc %eax
111db1: 39 c1 cmp %eax,%ecx
111db3: 0f 84 bf 00 00 00 je 111e78 <msdos_long_to_short+0x148>
if ((lfn[i] != ' ') && (lfn[i] != '.'))
111db9: 0f b6 14 03 movzbl (%ebx,%eax,1),%edx
111dbd: 80 fa 20 cmp $0x20,%dl
111dc0: 74 ee je 111db0 <msdos_long_to_short+0x80>
111dc2: 80 fa 2e cmp $0x2e,%dl
111dc5: 74 e9 je 111db0 <msdos_long_to_short+0x80>
eno = (*converter->handler->utf8_to_codepage) (
111dc7: 8b 4d 10 mov 0x10(%ebp),%ecx
111dca: 8d 55 e4 lea -0x1c(%ebp),%edx
111dcd: 8b 45 08 mov 0x8(%ebp),%eax
111dd0: 8b 7d d0 mov -0x30(%ebp),%edi
111dd3: 8b 00 mov (%eax),%eax
111dd5: 89 4c 24 08 mov %ecx,0x8(%esp)
111dd9: 8b 4d 0c mov 0xc(%ebp),%ecx
111ddc: 89 54 24 10 mov %edx,0x10(%esp)
111de0: 89 7c 24 0c mov %edi,0xc(%esp)
111de4: 89 4c 24 04 mov %ecx,0x4(%esp)
111de8: 8b 4d 08 mov 0x8(%ebp),%ecx
111deb: 89 0c 24 mov %ecx,(%esp)
111dee: ff 10 call *(%eax)
if (eno == EINVAL)
111df0: 83 f8 16 cmp $0x16,%eax
111df3: 0f 84 f7 00 00 00 je 111ef0 <msdos_long_to_short+0x1c0>
while (*name && (count < name_len))
111df9: 0f b6 1f movzbl (%edi),%ebx
type = msdos_name_type (
111dfc: 8b 45 e4 mov -0x1c(%ebp),%eax
while (*name && (count < name_len))
111dff: 84 db test %bl,%bl
type = msdos_name_type (
111e01: 89 45 cc mov %eax,-0x34(%ebp)
while (*name && (count < name_len))
111e04: 0f 95 c2 setne %dl
111e07: 85 c0 test %eax,%eax
111e09: 0f 9f c0 setg %al
111e0c: 20 c2 and %al,%dl
111e0e: 88 55 cb mov %dl,-0x35(%ebp)
111e11: 0f 84 c7 00 00 00 je 111ede <msdos_long_to_short+0x1ae> <== NEVER TAKEN
bool uppercase = false;
111e17: c6 45 ca 00 movb $0x0,-0x36(%ebp)
int count = 0;
111e1b: 31 ff xor %edi,%edi
bool lowercase = false;
111e1d: c6 45 c9 00 movb $0x0,-0x37(%ebp)
int dot_at = -1;
111e21: 89 fe mov %edi,%esi
111e23: c7 45 d4 ff ff ff ff movl $0xffffffff,-0x2c(%ebp)
111e2a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
if (strchr(" +,;=[]", ch) != NULL)
111e30: c7 04 24 80 36 13 00 movl $0x133680,(%esp)
msdos_name_type_t type = msdos_is_valid_name_char(*name);
111e37: 0f be fb movsbl %bl,%edi
if (strchr(" +,;=[]", ch) != NULL)
111e3a: 89 7c 24 04 mov %edi,0x4(%esp)
111e3e: e8 ad 61 01 00 call 127ff0 <strchr>
111e43: 85 c0 test %eax,%eax
111e45: 0f 85 a5 00 00 00 jne 111ef0 <msdos_long_to_short+0x1c0>
if ((ch == '.') || isalnum((unsigned char)ch) ||
111e4b: 80 fb 2e cmp $0x2e,%bl
111e4e: 0f 84 ec 00 00 00 je 111f40 <msdos_long_to_short+0x210>
111e54: 0f b6 c3 movzbl %bl,%eax
111e57: f6 80 e1 6a 13 00 07 testb $0x7,0x136ae1(%eax)
111e5e: 75 30 jne 111e90 <msdos_long_to_short+0x160>
(strchr("$%'-_@~`!(){}^#&", ch) != NULL) || (unsigned char) ch > 127)
111e60: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED
111e64: c7 04 24 88 36 13 00 movl $0x133688,(%esp) <== NOT EXECUTED
111e6b: e8 80 61 01 00 call 127ff0 <strchr> <== NOT EXECUTED
111e70: 84 db test %bl,%bl
111e72: 78 1c js 111e90 <msdos_long_to_short+0x160>
111e74: 85 c0 test %eax,%eax
111e76: 75 18 jne 111e90 <msdos_long_to_short+0x160>
return MSDOS_NAME_INVALID;
111e78: 31 db xor %ebx,%ebx
}
111e7a: 83 c4 4c add $0x4c,%esp
111e7d: 89 d8 mov %ebx,%eax
111e7f: 5b pop %ebx
111e80: 5e pop %esi
111e81: 5f pop %edi
111e82: 5d pop %ebp
111e83: c3 ret
111e84: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
111e8b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
111e8f: 90 nop
if (dot_at >= 0)
111e90: 83 7d d4 ff cmpl $0xffffffff,-0x2c(%ebp)
111e94: 74 4f je 111ee5 <msdos_long_to_short+0x1b5>
if (is_dot || ((count - dot_at) > 3))
111e96: 8b 55 d4 mov -0x2c(%ebp),%edx
111e99: 89 f0 mov %esi,%eax
111e9b: 29 d0 sub %edx,%eax
111e9d: 83 f8 03 cmp $0x3,%eax
111ea0: 7f 4e jg 111ef0 <msdos_long_to_short+0x1c0>
else if ((*name >= 'A') && (*name <= 'Z'))
111ea2: 88 d8 mov %bl,%al
111ea4: 2c 41 sub $0x41,%al
111ea6: 3c 19 cmp $0x19,%al
111ea8: 0f 86 82 00 00 00 jbe 111f30 <msdos_long_to_short+0x200>
else if ((*name >= 'a') && (*name <= 'z'))
111eae: 80 eb 61 sub $0x61,%bl
111eb1: 80 fb 19 cmp $0x19,%bl
111eb4: 77 07 ja 111ebd <msdos_long_to_short+0x18d>
lowercase = true;
111eb6: 0f b6 45 cb movzbl -0x35(%ebp),%eax
111eba: 88 45 c9 mov %al,-0x37(%ebp)
count++;
111ebd: 46 inc %esi
while (*name && (count < name_len))
111ebe: 8b 45 d0 mov -0x30(%ebp),%eax
111ec1: 39 75 cc cmp %esi,-0x34(%ebp)
111ec4: 0f b6 1c 30 movzbl (%eax,%esi,1),%ebx
111ec8: 7e 08 jle 111ed2 <msdos_long_to_short+0x1a2>
111eca: 84 db test %bl,%bl
111ecc: 0f 85 5e ff ff ff jne 111e30 <msdos_long_to_short+0x100> <== ALWAYS TAKEN
if (lowercase && uppercase)
111ed2: 80 7d c9 00 cmpb $0x0,-0x37(%ebp)
111ed6: 74 06 je 111ede <msdos_long_to_short+0x1ae>
111ed8: 80 7d ca 00 cmpb $0x0,-0x36(%ebp)
111edc: 75 12 jne 111ef0 <msdos_long_to_short+0x1c0>
return MSDOS_NAME_SHORT;
111ede: bb 01 00 00 00 mov $0x1,%ebx
111ee3: eb 10 jmp 111ef5 <msdos_long_to_short+0x1c5>
if (count == 8 && !is_dot)
111ee5: 83 fe 08 cmp $0x8,%esi
111ee8: 75 b8 jne 111ea2 <msdos_long_to_short+0x172>
111eea: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
type = MSDOS_NAME_LONG;
111ef0: bb 02 00 00 00 mov $0x2,%ebx
short_filename_length = msdos_filename_utf8_to_short_name_for_save (
111ef5: 8b 45 18 mov 0x18(%ebp),%eax
111ef8: 89 44 24 10 mov %eax,0x10(%esp)
111efc: 8b 45 14 mov 0x14(%ebp),%eax
111eff: 89 44 24 0c mov %eax,0xc(%esp)
111f03: 8b 45 10 mov 0x10(%ebp),%eax
111f06: 89 44 24 08 mov %eax,0x8(%esp)
111f0a: 8b 45 0c mov 0xc(%ebp),%eax
111f0d: 89 44 24 04 mov %eax,0x4(%esp)
111f11: 8b 45 08 mov 0x8(%ebp),%eax
111f14: 89 04 24 mov %eax,(%esp)
111f17: e8 04 72 00 00 call 119120 <msdos_filename_utf8_to_short_name_for_save>
if (short_filename_length < 0 ) {
111f1c: 85 c0 test %eax,%eax
111f1e: 0f 88 54 ff ff ff js 111e78 <msdos_long_to_short+0x148> <== NEVER TAKEN
}
111f24: 83 c4 4c add $0x4c,%esp
111f27: 89 d8 mov %ebx,%eax
111f29: 5b pop %ebx
111f2a: 5e pop %esi
111f2b: 5f pop %edi
111f2c: 5d pop %ebp
111f2d: c3 ret
111f2e: 66 90 xchg %ax,%ax
uppercase = true;
111f30: 0f b6 45 cb movzbl -0x35(%ebp),%eax
111f34: 88 45 ca mov %al,-0x36(%ebp)
111f37: eb 84 jmp 111ebd <msdos_long_to_short+0x18d>
111f39: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
if (dot_at >= 0)
111f40: 83 7d d4 ff cmpl $0xffffffff,-0x2c(%ebp)
111f44: 75 aa jne 111ef0 <msdos_long_to_short+0x1c0> <== NEVER TAKEN
111f46: 89 75 d4 mov %esi,-0x2c(%ebp)
111f49: e9 6f ff ff ff jmp 111ebd <msdos_long_to_short+0x18d>
111f4e: 66 90 xchg %ax,%ax
memset (sfn, ' ', sfn_len);
111f50: f7 c7 01 00 00 00 test $0x1,%edi
111f56: 0f 85 84 00 00 00 jne 111fe0 <msdos_long_to_short+0x2b0> <== NEVER TAKEN
111f5c: f7 c7 02 00 00 00 test $0x2,%edi
111f62: 0f 85 8c 00 00 00 jne 111ff4 <msdos_long_to_short+0x2c4> <== NEVER TAKEN
111f68: f7 c7 04 00 00 00 test $0x4,%edi
111f6e: 0f 85 90 00 00 00 jne 112004 <msdos_long_to_short+0x2d4> <== NEVER TAKEN
111f74: 89 d1 mov %edx,%ecx
111f76: b8 20 20 20 20 mov $0x20202020,%eax
111f7b: c1 e9 02 shr $0x2,%ecx
111f7e: 83 e2 03 and $0x3,%edx
111f81: f3 ab rep stos %eax,%es:(%edi)
111f83: e9 d2 fd ff ff jmp 111d5a <msdos_long_to_short+0x2a>
111f88: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
111f8f: 90 nop
if ((lfn[0] == '.') && (lfn_len == 1))
111f90: 83 7d 10 01 cmpl $0x1,0x10(%ebp)
111f94: 74 3a je 111fd0 <msdos_long_to_short+0x2a0>
if ((lfn[0] == '.') && (lfn[1] == '.') && (lfn_len == 2))
111f96: 8b 45 0c mov 0xc(%ebp),%eax
111f99: 80 78 01 2e cmpb $0x2e,0x1(%eax)
111f9d: 0f 85 e9 fd ff ff jne 111d8c <msdos_long_to_short+0x5c> <== NEVER TAKEN
111fa3: 83 7d 10 02 cmpl $0x2,0x10(%ebp)
111fa7: 0f 85 df fd ff ff jne 111d8c <msdos_long_to_short+0x5c>
sfn[0] = sfn[1] = '.';
111fad: 8b 45 14 mov 0x14(%ebp),%eax
return MSDOS_NAME_SHORT;
111fb0: bb 01 00 00 00 mov $0x1,%ebx
sfn[0] = sfn[1] = '.';
111fb5: 66 c7 00 2e 2e movw $0x2e2e,(%eax)
return MSDOS_NAME_SHORT;
111fba: e9 bb fe ff ff jmp 111e7a <msdos_long_to_short+0x14a>
111fbf: 90 nop
if (i == lfn_len)
111fc0: 0f 85 01 fe ff ff jne 111dc7 <msdos_long_to_short+0x97> <== NOT EXECUTED
111fc6: e9 ad fe ff ff jmp 111e78 <msdos_long_to_short+0x148> <== NOT EXECUTED
111fcb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
111fcf: 90 nop <== NOT EXECUTED
sfn[0] = '.';
111fd0: 8b 45 14 mov 0x14(%ebp),%eax
return MSDOS_NAME_SHORT;
111fd3: bb 01 00 00 00 mov $0x1,%ebx
sfn[0] = '.';
111fd8: c6 00 2e movb $0x2e,(%eax)
return MSDOS_NAME_SHORT;
111fdb: e9 9a fe ff ff jmp 111e7a <msdos_long_to_short+0x14a>
memset (sfn, ' ', sfn_len);
111fe0: c6 07 20 movb $0x20,(%edi) <== NOT EXECUTED
111fe3: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED
111fe6: 8d 78 01 lea 0x1(%eax),%edi <== NOT EXECUTED
111fe9: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED
111fec: 8d 50 ff lea -0x1(%eax),%edx <== NOT EXECUTED
111fef: e9 68 ff ff ff jmp 111f5c <msdos_long_to_short+0x22c> <== NOT EXECUTED
111ff4: 66 c7 07 20 20 movw $0x2020,(%edi) <== NOT EXECUTED
111ff9: 83 ea 02 sub $0x2,%edx <== NOT EXECUTED
111ffc: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
111fff: e9 64 ff ff ff jmp 111f68 <msdos_long_to_short+0x238> <== NOT EXECUTED
112004: c7 07 20 20 20 20 movl $0x20202020,(%edi) <== NOT EXECUTED
11200a: 83 ea 04 sub $0x4,%edx <== NOT EXECUTED
11200d: 83 c7 04 add $0x4,%edi <== NOT EXECUTED
112010: e9 5f ff ff ff jmp 111f74 <msdos_long_to_short+0x244> <== NOT EXECUTED
112015: 90 nop
112016: 90 nop
112017: 90 nop
112018: 90 nop
112019: 90 nop
11201a: 90 nop
11201b: 90 nop
11201c: 90 nop
11201d: 90 nop
11201e: 90 nop
11201f: 90 nop
00105d40 <msdos_mknod>:
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
105d40: 55 push %ebp
105d41: 89 e5 mov %esp,%ebp
105d43: 83 ec 08 sub $0x8,%esp
105d46: 89 5d f8 mov %ebx,-0x8(%ebp)
105d49: 8b 45 14 mov 0x14(%ebp),%eax
105d4c: 89 75 fc mov %esi,-0x4(%ebp)
105d4f: 8b 4d 08 mov 0x8(%ebp),%ecx
105d52: 8b 5d 0c mov 0xc(%ebp),%ebx
105d55: 8b 75 10 mov 0x10(%ebp),%esi
fat_file_type_t type = 0;
/*
* Figure out what type of msdos node this is.
*/
if (S_ISDIR(mode))
105d58: 89 c2 mov %eax,%edx
105d5a: 81 e2 00 f0 00 00 and $0xf000,%edx
105d60: 81 fa 00 40 00 00 cmp $0x4000,%edx
105d66: 74 38 je 105da0 <msdos_mknod+0x60>
{
type = FAT_DIRECTORY;
}
else if (S_ISREG(mode))
105d68: 81 fa 00 80 00 00 cmp $0x8000,%edx
105d6e: 75 34 jne 105da4 <msdos_mknod+0x64> <== NEVER TAKEN
{
type = FAT_FILE;
105d70: ba 04 00 00 00 mov $0x4,%edx
}
else
rtems_set_errno_and_return_minus_one(EINVAL);
/* Create an MSDOS node */
rc = msdos_creat_node(parentloc, type, name, namelen, mode, NULL);
105d75: 89 75 14 mov %esi,0x14(%ebp)
return rc;
}
105d78: 8b 75 fc mov -0x4(%ebp),%esi
rc = msdos_creat_node(parentloc, type, name, namelen, mode, NULL);
105d7b: 89 5d 10 mov %ebx,0x10(%ebp)
}
105d7e: 8b 5d f8 mov -0x8(%ebp),%ebx
rc = msdos_creat_node(parentloc, type, name, namelen, mode, NULL);
105d81: c7 45 1c 00 00 00 00 movl $0x0,0x1c(%ebp)
105d88: 89 45 18 mov %eax,0x18(%ebp)
105d8b: 89 55 0c mov %edx,0xc(%ebp)
105d8e: 89 4d 08 mov %ecx,0x8(%ebp)
}
105d91: 89 ec mov %ebp,%esp
105d93: 5d pop %ebp
rc = msdos_creat_node(parentloc, type, name, namelen, mode, NULL);
105d94: e9 e7 b5 00 00 jmp 111380 <msdos_creat_node>
105d99: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
type = FAT_DIRECTORY;
105da0: 31 d2 xor %edx,%edx
105da2: eb d1 jmp 105d75 <msdos_mknod+0x35>
rtems_set_errno_and_return_minus_one(EINVAL);
105da4: e8 f7 0a 02 00 call 1268a0 <__errno> <== NOT EXECUTED
}
105da9: 8b 5d f8 mov -0x8(%ebp),%ebx <== NOT EXECUTED
105dac: 8b 75 fc mov -0x4(%ebp),%esi <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EINVAL);
105daf: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
}
105db5: 89 ec mov %ebp,%esp <== NOT EXECUTED
105db7: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
105dbc: 5d pop %ebp <== NOT EXECUTED
105dbd: c3 ret <== NOT EXECUTED
105dbe: 90 nop
105dbf: 90 nop
00105dc0 <msdos_rename>:
const rtems_filesystem_location_info_t *old_loc,
const rtems_filesystem_location_info_t *new_parent_loc,
const char *new_name,
size_t new_namelen
)
{
105dc0: 55 push %ebp <== NOT EXECUTED
/*
* create new directory entry as "hard link", copying relevant info from
* existing file
*/
rc = msdos_creat_node(new_parent_loc,
105dc1: b8 00 80 00 00 mov $0x8000,%eax <== NOT EXECUTED
{
105dc6: 89 e5 mov %esp,%ebp <== NOT EXECUTED
105dc8: 83 ec 28 sub $0x28,%esp <== NOT EXECUTED
105dcb: 89 75 fc mov %esi,-0x4(%ebp) <== NOT EXECUTED
105dce: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED
rc = msdos_creat_node(new_parent_loc,
105dd1: ba 02 00 00 00 mov $0x2,%edx <== NOT EXECUTED
{
105dd6: 89 5d f8 mov %ebx,-0x8(%ebp) <== NOT EXECUTED
fat_file_fd_t *old_fat_fd = old_loc->node_access;
105dd9: 8b 5e 08 mov 0x8(%esi),%ebx <== NOT EXECUTED
rc = msdos_creat_node(new_parent_loc,
105ddc: 89 44 24 10 mov %eax,0x10(%esp) <== NOT EXECUTED
105de0: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED
105de3: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
105de7: 89 5c 24 14 mov %ebx,0x14(%esp) <== NOT EXECUTED
105deb: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
105def: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED
105df2: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
105df6: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
105df9: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
105dfc: e8 7f b5 00 00 call 111380 <msdos_creat_node> <== NOT EXECUTED
FAT_HARD_LINK,new_name,new_namelen,S_IFREG,
old_fat_fd);
if (rc != RC_OK)
105e01: 85 c0 test %eax,%eax <== NOT EXECUTED
105e03: 74 0b je 105e10 <msdos_rename+0x50> <== NOT EXECUTED
rc = msdos_set_first_char4file_name(old_loc->mt_entry,
&old_fat_fd->dir_pos,
MSDOS_THIS_DIR_ENTRY_EMPTY);
return rc;
}
105e05: 8b 5d f8 mov -0x8(%ebp),%ebx <== NOT EXECUTED
105e08: 8b 75 fc mov -0x4(%ebp),%esi <== NOT EXECUTED
105e0b: 89 ec mov %ebp,%esp <== NOT EXECUTED
105e0d: 5d pop %ebp <== NOT EXECUTED
105e0e: c3 ret <== NOT EXECUTED
105e0f: 90 nop <== NOT EXECUTED
rc = msdos_set_first_char4file_name(old_loc->mt_entry,
105e10: c7 45 10 e5 00 00 00 movl $0xe5,0x10(%ebp) <== NOT EXECUTED
105e17: 83 c3 20 add $0x20,%ebx <== NOT EXECUTED
105e1a: 89 5d 0c mov %ebx,0xc(%ebp) <== NOT EXECUTED
}
105e1d: 8b 5d f8 mov -0x8(%ebp),%ebx <== NOT EXECUTED
rc = msdos_set_first_char4file_name(old_loc->mt_entry,
105e20: 8b 46 14 mov 0x14(%esi),%eax <== NOT EXECUTED
}
105e23: 8b 75 fc mov -0x4(%ebp),%esi <== NOT EXECUTED
rc = msdos_set_first_char4file_name(old_loc->mt_entry,
105e26: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED
}
105e29: 89 ec mov %ebp,%esp <== NOT EXECUTED
105e2b: 5d pop %ebp <== NOT EXECUTED
rc = msdos_set_first_char4file_name(old_loc->mt_entry,
105e2c: e9 ef c4 00 00 jmp 112320 <msdos_set_first_char4file_name> <== NOT EXECUTED
105e31: 90 nop
105e32: 90 nop
105e33: 90 nop
105e34: 90 nop
105e35: 90 nop
105e36: 90 nop
105e37: 90 nop
105e38: 90 nop
105e39: 90 nop
105e3a: 90 nop
105e3b: 90 nop
105e3c: 90 nop
105e3d: 90 nop
105e3e: 90 nop
105e3f: 90 nop
00105e40 <msdos_rmnod>:
#include "msdos.h"
int
msdos_rmnod(const rtems_filesystem_location_info_t *parent_pathloc,
const rtems_filesystem_location_info_t *pathloc)
{
105e40: 55 push %ebp
105e41: 89 e5 mov %esp,%ebp
105e43: 83 ec 48 sub $0x48,%esp
105e46: 89 7d fc mov %edi,-0x4(%ebp)
105e49: 8b 7d 0c mov 0xc(%ebp),%edi
105e4c: 89 75 f8 mov %esi,-0x8(%ebp)
105e4f: 89 5d f4 mov %ebx,-0xc(%ebp)
int rc = RC_OK;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = pathloc->node_access;
105e52: 8b 77 08 mov 0x8(%edi),%esi
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
105e55: 8b 47 14 mov 0x14(%edi),%eax
if (fat_fd->fat_file_type == FAT_DIRECTORY)
105e58: 8b 4e 10 mov 0x10(%esi),%ecx
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
105e5b: 8b 58 08 mov 0x8(%eax),%ebx
if (fat_fd->fat_file_type == FAT_DIRECTORY)
105e5e: 85 c9 test %ecx,%ecx
105e60: 75 2a jne 105e8c <msdos_rmnod+0x4c>
bool is_empty = false;
/*
* You cannot remove a node that still has children
*/
rc = msdos_dir_is_empty(pathloc->mt_entry, fat_fd, &is_empty);
105e62: 89 74 24 04 mov %esi,0x4(%esp)
105e66: 8d 55 e7 lea -0x19(%ebp),%edx
105e69: 89 54 24 08 mov %edx,0x8(%esp)
105e6d: 89 04 24 mov %eax,(%esp)
bool is_empty = false;
105e70: c6 45 e7 00 movb $0x0,-0x19(%ebp)
rc = msdos_dir_is_empty(pathloc->mt_entry, fat_fd, &is_empty);
105e74: e8 e7 c5 00 00 call 112460 <msdos_dir_is_empty>
if (rc != RC_OK)
105e79: 85 c0 test %eax,%eax
105e7b: 75 2b jne 105ea8 <msdos_rmnod+0x68> <== NEVER TAKEN
{
return rc;
}
if (!is_empty)
105e7d: 80 7d e7 00 cmpb $0x0,-0x19(%ebp)
105e81: 74 7d je 105f00 <msdos_rmnod+0xc0>
/*
* We deny attempts to delete open directory (if directory is current
* directory we assume it is open one)
*/
if (fat_fd->links_num > 1)
105e83: 83 7e 08 01 cmpl $0x1,0x8(%esi)
105e87: 77 57 ja 105ee0 <msdos_rmnod+0xa0> <== NEVER TAKEN
* not used - mount() not implemenetd yet.
*/
}
/* mark file removed */
rc = msdos_set_first_char4file_name(pathloc->mt_entry, &fat_fd->dir_pos,
105e89: 8b 47 14 mov 0x14(%edi),%eax
105e8c: 89 04 24 mov %eax,(%esp)
105e8f: ba e5 00 00 00 mov $0xe5,%edx
105e94: 89 54 24 08 mov %edx,0x8(%esp)
105e98: 8d 56 20 lea 0x20(%esi),%edx
105e9b: 89 54 24 04 mov %edx,0x4(%esp)
105e9f: e8 7c c4 00 00 call 112320 <msdos_set_first_char4file_name>
MSDOS_THIS_DIR_ENTRY_EMPTY);
if (rc != RC_OK)
105ea4: 85 c0 test %eax,%eax
105ea6: 74 18 je 105ec0 <msdos_rmnod+0x80> <== ALWAYS TAKEN
}
fat_file_mark_removed(&fs_info->fat, fat_fd);
return rc;
}
105ea8: 8b 5d f4 mov -0xc(%ebp),%ebx
105eab: 8b 75 f8 mov -0x8(%ebp),%esi
105eae: 8b 7d fc mov -0x4(%ebp),%edi
105eb1: 89 ec mov %ebp,%esp
105eb3: 5d pop %ebp
105eb4: c3 ret
105eb5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
105ebc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
fat_file_mark_removed(&fs_info->fat, fat_fd);
105ec0: 89 74 24 04 mov %esi,0x4(%esp)
105ec4: 89 1c 24 mov %ebx,(%esp)
105ec7: 89 45 d4 mov %eax,-0x2c(%ebp)
105eca: e8 41 b1 00 00 call 111010 <fat_file_mark_removed>
105ecf: 8b 45 d4 mov -0x2c(%ebp),%eax
}
105ed2: 8b 5d f4 mov -0xc(%ebp),%ebx
105ed5: 8b 75 f8 mov -0x8(%ebp),%esi
105ed8: 8b 7d fc mov -0x4(%ebp),%edi
105edb: 89 ec mov %ebp,%esp
105edd: 5d pop %ebp
105ede: c3 ret
105edf: 90 nop
rtems_set_errno_and_return_minus_one(EBUSY);
105ee0: e8 bb 09 02 00 call 1268a0 <__errno> <== NOT EXECUTED
105ee5: c7 00 10 00 00 00 movl $0x10,(%eax) <== NOT EXECUTED
105eeb: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
105ef0: eb b6 jmp 105ea8 <msdos_rmnod+0x68> <== NOT EXECUTED
105ef2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
105ef9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOTEMPTY);
105f00: e8 9b 09 02 00 call 1268a0 <__errno>
105f05: c7 00 5a 00 00 00 movl $0x5a,(%eax)
105f0b: b8 ff ff ff ff mov $0xffffffff,%eax
105f10: eb 96 jmp 105ea8 <msdos_rmnod+0x68>
105f12: 90 nop
105f13: 90 nop
105f14: 90 nop
105f15: 90 nop
105f16: 90 nop
105f17: 90 nop
105f18: 90 nop
105f19: 90 nop
105f1a: 90 nop
105f1b: 90 nop
105f1c: 90 nop
105f1d: 90 nop
105f1e: 90 nop
105f1f: 90 nop
00112320 <msdos_set_first_char4file_name>:
{
112320: 55 push %ebp
112321: 89 e5 mov %esp,%ebp
112323: 57 push %edi
112324: 56 push %esi
112325: 53 push %ebx
112326: 83 ec 4c sub $0x4c,%esp
112329: 8b 45 0c mov 0xc(%ebp),%eax
11232c: 0f b6 5d 10 movzbl 0x10(%ebp),%ebx
msdos_fs_info_t *fs_info = mt_entry->fs_info;
112330: 8b 55 08 mov 0x8(%ebp),%edx
fat_pos_t start = dir_pos->lname;
112333: 8b 48 08 mov 0x8(%eax),%ecx
{
112336: 88 5d d4 mov %bl,-0x2c(%ebp)
fat_pos_t start = dir_pos->lname;
112339: 8b 58 0c mov 0xc(%eax),%ebx
msdos_fs_info_t *fs_info = mt_entry->fs_info;
11233c: 8b 7a 08 mov 0x8(%edx),%edi
fat_pos_t end = dir_pos->sname;
11233f: 8b 70 04 mov 0x4(%eax),%esi
fat_pos_t start = dir_pos->lname;
112342: 89 4d e0 mov %ecx,-0x20(%ebp)
112345: 89 5d e4 mov %ebx,-0x1c(%ebp)
fat_pos_t end = dir_pos->sname;
112348: 8b 18 mov (%eax),%ebx
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
11234a: 39 5f 44 cmp %ebx,0x44(%edi)
fat_pos_t end = dir_pos->sname;
11234d: 89 75 cc mov %esi,-0x34(%ebp)
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
112350: 0f 84 ea 00 00 00 je 112440 <msdos_set_first_char4file_name+0x120>
dir_block_size = fs_info->fat.vol.bpc;
112356: 8b 77 08 mov 0x8(%edi),%esi
112359: 89 75 d0 mov %esi,-0x30(%ebp)
if (dir_pos->lname.cln == FAT_FILE_SHORT_NAME)
11235c: 83 78 08 ff cmpl $0xffffffff,0x8(%eax)
112360: 75 0b jne 11236d <msdos_set_first_char4file_name+0x4d>
start = dir_pos->sname;
112362: 8b 50 04 mov 0x4(%eax),%edx
112365: 8b 00 mov (%eax),%eax
112367: 89 55 e4 mov %edx,-0x1c(%ebp)
11236a: 89 45 e0 mov %eax,-0x20(%ebp)
(start.ofs >> fs_info->fat.vol.sec_log2));
11236d: 8b 45 e4 mov -0x1c(%ebp),%eax
112370: 8d 75 d4 lea -0x2c(%ebp),%esi
uint32_t sec = (fat_cluster_num_to_sector_num(&fs_info->fat, start.cln) +
112373: 8b 55 e0 mov -0x20(%ebp),%edx
112376: eb 17 jmp 11238f <msdos_set_first_char4file_name+0x6f>
112378: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11237f: 90 nop
start.ofs += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
112380: 83 c0 20 add $0x20,%eax
if (start.ofs >= dir_block_size)
112383: 3b 45 d0 cmp -0x30(%ebp),%eax
start.ofs += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
112386: 89 45 e4 mov %eax,-0x1c(%ebp)
if (start.ofs >= dir_block_size)
112389: 0f 83 81 00 00 00 jae 112410 <msdos_set_first_char4file_name+0xf0>
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
11238f: 85 d2 test %edx,%edx
112391: 75 06 jne 112399 <msdos_set_first_char4file_name+0x79>
112393: f6 47 16 03 testb $0x3,0x16(%edi)
112397: 75 57 jne 1123f0 <msdos_set_first_char4file_name+0xd0> <== ALWAYS TAKEN
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
112399: 0f b6 4f 05 movzbl 0x5(%edi),%ecx
11239d: 83 ea 02 sub $0x2,%edx
1123a0: d3 e2 shl %cl,%edx
1123a2: 8b 4f 3c mov 0x3c(%edi),%ecx
1123a5: 01 ca add %ecx,%edx
ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
1123a7: 89 74 24 10 mov %esi,0x10(%esp)
1123ab: b9 01 00 00 00 mov $0x1,%ecx
1123b0: 89 4c 24 0c mov %ecx,0xc(%esp)
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));
1123b4: 0f b7 0f movzwl (%edi),%ecx
1123b7: 49 dec %ecx
1123b8: 21 c1 and %eax,%ecx
ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
1123ba: 89 4c 24 08 mov %ecx,0x8(%esp)
(start.ofs >> fs_info->fat.vol.sec_log2));
1123be: 0f b6 4f 02 movzbl 0x2(%edi),%ecx
ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
1123c2: 89 3c 24 mov %edi,(%esp)
(start.ofs >> fs_info->fat.vol.sec_log2));
1123c5: d3 e8 shr %cl,%eax
uint32_t sec = (fat_cluster_num_to_sector_num(&fs_info->fat, start.cln) +
1123c7: 01 c2 add %eax,%edx
ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
1123c9: 89 54 24 04 mov %edx,0x4(%esp)
1123cd: e8 de c6 ff ff call 10eab0 <fat_sector_write>
if (ret < 0)
1123d2: 85 c0 test %eax,%eax
1123d4: 78 2a js 112400 <msdos_set_first_char4file_name+0xe0> <== NEVER TAKEN
if ((start.cln == end.cln) && (start.ofs == end.ofs))
1123d6: 8b 55 e0 mov -0x20(%ebp),%edx
1123d9: 8b 45 e4 mov -0x1c(%ebp),%eax
1123dc: 39 d3 cmp %edx,%ebx
1123de: 75 a0 jne 112380 <msdos_set_first_char4file_name+0x60>
1123e0: 39 45 cc cmp %eax,-0x34(%ebp)
1123e3: 75 9b jne 112380 <msdos_set_first_char4file_name+0x60>
}
1123e5: 83 c4 4c add $0x4c,%esp
return RC_OK;
1123e8: 31 c0 xor %eax,%eax
}
1123ea: 5b pop %ebx
1123eb: 5e pop %esi
1123ec: 5f pop %edi
1123ed: 5d pop %ebp
1123ee: c3 ret
1123ef: 90 nop
return fs_info->vol.rdir_loc;
1123f0: 8b 57 28 mov 0x28(%edi),%edx
1123f3: eb b2 jmp 1123a7 <msdos_set_first_char4file_name+0x87>
1123f5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1123fc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
return -1;
112400: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
}
112405: 83 c4 4c add $0x4c,%esp <== NOT EXECUTED
112408: 5b pop %ebx <== NOT EXECUTED
112409: 5e pop %esi <== NOT EXECUTED
11240a: 5f pop %edi <== NOT EXECUTED
11240b: 5d pop %ebp <== NOT EXECUTED
11240c: c3 ret <== NOT EXECUTED
11240d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
112410: 3b 5f 44 cmp 0x44(%edi),%ebx
112413: 75 06 jne 11241b <msdos_set_first_char4file_name+0xfb> <== ALWAYS TAKEN
112415: f6 47 16 03 testb $0x3,0x16(%edi) <== NOT EXECUTED
112419: 75 ca jne 1123e5 <msdos_set_first_char4file_name+0xc5> <== NOT EXECUTED
rc = fat_get_fat_cluster(&fs_info->fat, start.cln, &start.cln);
11241b: 89 54 24 04 mov %edx,0x4(%esp)
11241f: 8d 45 e0 lea -0x20(%ebp),%eax
112422: 89 44 24 08 mov %eax,0x8(%esp)
112426: 89 3c 24 mov %edi,(%esp)
112429: e8 22 d7 ff ff call 10fb50 <fat_get_fat_cluster>
if ( rc != RC_OK )
11242e: 85 c0 test %eax,%eax
112430: 75 d3 jne 112405 <msdos_set_first_char4file_name+0xe5> <== NEVER TAKEN
start.ofs = 0;
112432: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
112439: e9 35 ff ff ff jmp 112373 <msdos_set_first_char4file_name+0x53>
11243e: 66 90 xchg %ax,%ax
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
112440: f6 47 16 03 testb $0x3,0x16(%edi)
112444: 0f 84 0c ff ff ff je 112356 <msdos_set_first_char4file_name+0x36> <== NEVER TAKEN
dir_block_size = fs_info->fat.vol.rdir_size;
11244a: 8b 77 34 mov 0x34(%edi),%esi
11244d: 89 75 d0 mov %esi,-0x30(%ebp)
112450: e9 07 ff ff ff jmp 11235c <msdos_set_first_char4file_name+0x3c>
112455: 90 nop
112456: 90 nop
112457: 90 nop
112458: 90 nop
112459: 90 nop
11245a: 90 nop
11245b: 90 nop
11245c: 90 nop
11245d: 90 nop
11245e: 90 nop
11245f: 90 nop
001119e0 <msdos_shut_down>:
* temp_mt_entry - mount table entry
*
*/
void
msdos_shut_down(rtems_filesystem_mount_table_entry_t *temp_mt_entry)
{
1119e0: 55 push %ebp <== NOT EXECUTED
1119e1: 89 e5 mov %esp,%ebp <== NOT EXECUTED
1119e3: 83 ec 28 sub $0x28,%esp <== NOT EXECUTED
1119e6: 89 75 f8 mov %esi,-0x8(%ebp) <== NOT EXECUTED
1119e9: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED
1119ec: 89 5d f4 mov %ebx,-0xc(%ebp) <== NOT EXECUTED
1119ef: 89 7d fc mov %edi,-0x4(%ebp) <== NOT EXECUTED
msdos_fs_info_t *fs_info = temp_mt_entry->fs_info;
fat_file_fd_t *fat_fd = temp_mt_entry->mt_fs_root->location.node_access;
1119f2: 8b 46 24 mov 0x24(%esi),%eax <== NOT EXECUTED
msdos_fs_info_t *fs_info = temp_mt_entry->fs_info;
1119f5: 8b 5e 08 mov 0x8(%esi),%ebx <== NOT EXECUTED
rtems_dosfs_convert_control *converter = fs_info->converter;
/* close fat-file which corresponds to root directory */
fat_file_close(&fs_info->fat, fat_fd);
1119f8: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED
rtems_dosfs_convert_control *converter = fs_info->converter;
1119fb: 8b bb c8 00 00 00 mov 0xc8(%ebx),%edi <== NOT EXECUTED
fat_file_close(&fs_info->fat, fat_fd);
111a01: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
111a04: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
111a08: e8 43 ef ff ff call 110950 <fat_file_close> <== NOT EXECUTED
fat_shutdown_drive(&fs_info->fat);
111a0d: 89 1c 24 mov %ebx,(%esp)
111a10: e8 0b de ff ff call 10f820 <fat_shutdown_drive>
rtems_recursive_mutex_destroy(&fs_info->vol_mutex);
(*converter->handler->destroy)( converter );
111a15: 8b 07 mov (%edi),%eax
111a17: 89 3c 24 mov %edi,(%esp)
111a1a: ff 50 14 call *0x14(%eax)
free(fs_info->cl_buf);
111a1d: 8b 83 c4 00 00 00 mov 0xc4(%ebx),%eax
111a23: 89 04 24 mov %eax,(%esp)
111a26: e8 25 02 ff ff call 101c50 <free>
free(temp_mt_entry->fs_info);
111a2b: 8b 46 08 mov 0x8(%esi),%eax
}
111a2e: 8b 5d f4 mov -0xc(%ebp),%ebx
111a31: 8b 75 f8 mov -0x8(%ebp),%esi
111a34: 8b 7d fc mov -0x4(%ebp),%edi
free(temp_mt_entry->fs_info);
111a37: 89 45 08 mov %eax,0x8(%ebp)
}
111a3a: 89 ec mov %ebp,%esp
111a3c: 5d pop %ebp
free(temp_mt_entry->fs_info);
111a3d: e9 0e 02 ff ff jmp 101c50 <free>
111a42: 90 nop
111a43: 90 nop
111a44: 90 nop
111a45: 90 nop
111a46: 90 nop
111a47: 90 nop
111a48: 90 nop
111a49: 90 nop
111a4a: 90 nop
111a4b: 90 nop
111a4c: 90 nop
111a4d: 90 nop
111a4e: 90 nop
111a4f: 90 nop
00105f20 <msdos_statvfs>:
#include "msdos.h"
int msdos_statvfs(
const rtems_filesystem_location_info_t *__restrict root_loc,
struct statvfs *__restrict sb)
{
105f20: 55 push %ebp
105f21: 89 e5 mov %esp,%ebp
105f23: 57 push %edi
105f24: 56 push %esi
105f25: 53 push %ebx
105f26: 83 ec 3c sub $0x3c,%esp
msdos_fs_info_t *fs_info = root_loc->mt_entry->fs_info;
105f29: 8b 45 08 mov 0x8(%ebp),%eax
{
105f2c: 8b 5d 0c mov 0xc(%ebp),%ebx
msdos_fs_info_t *fs_info = root_loc->mt_entry->fs_info;
105f2f: 8b 40 14 mov 0x14(%eax),%eax
105f32: 8b 70 08 mov 0x8(%eax),%esi
rtems_recursive_mutex_lock(&fs_info->vol_mutex);
105f35: 8d 86 ac 00 00 00 lea 0xac(%esi),%eax
_Mutex_recursive_Acquire( mutex );
105f3b: 89 04 24 mov %eax,(%esp)
105f3e: 89 45 d0 mov %eax,-0x30(%ebp)
105f41: e8 ba 3d 00 00 call 109d00 <_Mutex_recursive_Acquire>
fat_vol_t *vol = &fs_info->fat.vol;
msdos_fs_lock(fs_info);
sb->f_bsize = FAT_SECTOR512_SIZE;
sb->f_frsize = vol->bpc;
105f46: 8b 46 08 mov 0x8(%esi),%eax
sb->f_bsize = FAT_SECTOR512_SIZE;
105f49: c7 03 00 02 00 00 movl $0x200,(%ebx)
sb->f_blocks = vol->data_cls;
105f4f: 8b 56 40 mov 0x40(%esi),%edx
105f52: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
sb->f_bfree = 0;
105f59: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx)
sb->f_frsize = vol->bpc;
105f60: 89 43 04 mov %eax,0x4(%ebx)
sb->f_ffree = 0;
sb->f_favail = 0;
sb->f_flag = 0;
sb->f_namemax = MSDOS_NAME_MAX_LNF_LEN;
if (vol->free_cls == FAT_UNDEFINED_VALUE)
105f63: 8b 46 4c mov 0x4c(%esi),%eax
sb->f_blocks = vol->data_cls;
105f66: 89 53 08 mov %edx,0x8(%ebx)
sb->f_bfree = 0;
105f69: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx)
sb->f_bavail = 0;
105f70: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx)
105f77: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx)
if (vol->free_cls == FAT_UNDEFINED_VALUE)
105f7e: 83 f8 ff cmp $0xffffffff,%eax
sb->f_files = 0; // FAT doesn't store inodes
105f81: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx)
sb->f_ffree = 0;
105f88: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
sb->f_favail = 0;
105f8f: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx)
sb->f_flag = 0;
105f96: c7 43 30 00 00 00 00 movl $0x0,0x30(%ebx)
sb->f_namemax = MSDOS_NAME_MAX_LNF_LEN;
105f9d: c7 43 34 ff 00 00 00 movl $0xff,0x34(%ebx)
if (vol->free_cls == FAT_UNDEFINED_VALUE)
105fa4: 74 2a je 105fd0 <msdos_statvfs+0xb0> <== ALWAYS TAKEN
}
}
}
else
{
sb->f_bfree = vol->free_cls;
105fa6: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED
105fa9: 31 d2 xor %edx,%edx <== NOT EXECUTED
105fab: 89 53 14 mov %edx,0x14(%ebx) <== NOT EXECUTED
sb->f_bavail = vol->free_cls;
105fae: 89 43 18 mov %eax,0x18(%ebx) <== NOT EXECUTED
105fb1: 89 53 1c mov %edx,0x1c(%ebx) <== NOT EXECUTED
_Mutex_recursive_Release( mutex );
105fb4: 8b 45 d0 mov -0x30(%ebp),%eax
105fb7: 89 04 24 mov %eax,(%esp)
105fba: e8 c1 3d 00 00 call 109d80 <_Mutex_recursive_Release>
}
msdos_fs_unlock(fs_info);
return RC_OK;
}
105fbf: 83 c4 3c add $0x3c,%esp
return RC_OK;
105fc2: 31 c0 xor %eax,%eax
}
105fc4: 5b pop %ebx
105fc5: 5e pop %esi
105fc6: 5f pop %edi
105fc7: 5d pop %ebp
105fc8: c3 ret
105fc9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
uint32_t value = 0;
105fd0: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
uint32_t data_cls_val = vol->data_cls + 2;
105fd7: 8d 42 02 lea 0x2(%edx),%eax
uint32_t cur_cl = 2;
105fda: bf 02 00 00 00 mov $0x2,%edi
uint32_t data_cls_val = vol->data_cls + 2;
105fdf: 89 45 d4 mov %eax,-0x2c(%ebp)
for (; cur_cl < data_cls_val; ++cur_cl)
105fe2: 83 f8 02 cmp $0x2,%eax
105fe5: 77 26 ja 10600d <msdos_statvfs+0xed> <== ALWAYS TAKEN
105fe7: eb cb jmp 105fb4 <msdos_statvfs+0x94> <== NOT EXECUTED
105fe9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
if (value == FAT_GENFAT_FREE)
105ff0: 8b 45 e4 mov -0x1c(%ebp),%eax
105ff3: 85 c0 test %eax,%eax
105ff5: 75 10 jne 106007 <msdos_statvfs+0xe7>
sb->f_bfree++;
105ff7: 83 43 10 01 addl $0x1,0x10(%ebx)
105ffb: 83 53 14 00 adcl $0x0,0x14(%ebx)
sb->f_bavail++;
105fff: 83 43 18 01 addl $0x1,0x18(%ebx)
106003: 83 53 1c 00 adcl $0x0,0x1c(%ebx)
for (; cur_cl < data_cls_val; ++cur_cl)
106007: 47 inc %edi
106008: 39 7d d4 cmp %edi,-0x2c(%ebp)
10600b: 74 a7 je 105fb4 <msdos_statvfs+0x94>
rc = fat_get_fat_cluster(&fs_info->fat, cur_cl, &value);
10600d: 89 7c 24 04 mov %edi,0x4(%esp)
106011: 8d 45 e4 lea -0x1c(%ebp),%eax
106014: 89 44 24 08 mov %eax,0x8(%esp)
106018: 89 34 24 mov %esi,(%esp)
10601b: e8 30 9b 00 00 call 10fb50 <fat_get_fat_cluster>
if (rc != RC_OK)
106020: 85 c0 test %eax,%eax
106022: 74 cc je 105ff0 <msdos_statvfs+0xd0> <== ALWAYS TAKEN
106024: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED
106027: 8b 45 d0 mov -0x30(%ebp),%eax <== NOT EXECUTED
10602a: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
10602d: e8 4e 3d 00 00 call 109d80 <_Mutex_recursive_Release> <== NOT EXECUTED
return rc;
106032: 8b 45 d4 mov -0x2c(%ebp),%eax <== NOT EXECUTED
}
106035: 83 c4 3c add $0x3c,%esp <== NOT EXECUTED
106038: 5b pop %ebx <== NOT EXECUTED
106039: 5e pop %esi <== NOT EXECUTED
10603a: 5f pop %edi <== NOT EXECUTED
10603b: 5d pop %ebp <== NOT EXECUTED
10603c: c3 ret <== NOT EXECUTED
10603d: 90 nop
10603e: 90 nop
10603f: 90 nop
00111350 <rtems_dosfs_create_default_converter>:
rtems_dosfs_convert_control super;
uint8_t buffer[MSDOS_NAME_MAX_LFN_BYTES];
} msdos_default_convert_control;
rtems_dosfs_convert_control *rtems_dosfs_create_default_converter(void)
{
111350: 55 push %ebp
111351: 89 e5 mov %esp,%ebp
111353: 83 ec 18 sub $0x18,%esp
msdos_default_convert_control *self = malloc( sizeof( *self ) );
111356: c7 04 24 14 02 00 00 movl $0x214,(%esp)
11135d: e8 be 0d ff ff call 102120 <malloc>
if ( self != NULL ) {
111362: 85 c0 test %eax,%eax
111364: 74 13 je 111379 <rtems_dosfs_create_default_converter+0x29><== NEVER TAKEN
rtems_dosfs_convert_control *super = &self->super;
super->handler = &msdos_default_convert_handler;
111366: c7 00 c8 35 13 00 movl $0x1335c8,(%eax)
super->buffer.data = &self->buffer;
11136c: 8d 50 0c lea 0xc(%eax),%edx
11136f: 89 50 04 mov %edx,0x4(%eax)
super->buffer.size = sizeof( self->buffer );
111372: c7 40 08 08 02 00 00 movl $0x208,0x8(%eax)
}
return &self->super;
}
111379: 89 ec mov %ebp,%esp
11137b: 5d pop %ebp
11137c: c3 ret
11137d: 90 nop
11137e: 90 nop
11137f: 90 nop
00106360 <rtems_dosfs_create_utf8_converter>:
};
rtems_dosfs_convert_control *rtems_dosfs_create_utf8_converter(
const char *codepage
)
{
106360: 55 push %ebp
106361: 89 e5 mov %esp,%ebp
106363: 56 push %esi
106364: 53 push %ebx
106365: 83 ec 10 sub $0x10,%esp
msdos_utf8_convert_control *self = malloc( sizeof( *self ) );
106368: c7 04 24 2c 04 00 00 movl $0x42c,(%esp)
{
10636f: 8b 75 08 mov 0x8(%ebp),%esi
msdos_utf8_convert_control *self = malloc( sizeof( *self ) );
106372: e8 e9 cf ff ff call 103360 <malloc>
if ( self != NULL ) {
106377: 85 c0 test %eax,%eax
msdos_utf8_convert_control *self = malloc( sizeof( *self ) );
106379: 89 c3 mov %eax,%ebx
if ( self != NULL ) {
10637b: 0f 84 99 00 00 00 je 10641a <rtems_dosfs_create_utf8_converter+0xba><== NEVER TAKEN
self->desc_codepage_to_utf8 = iconv_open( "UTF-8", codepage );
106381: 89 74 24 04 mov %esi,0x4(%esp)
106385: c7 04 24 5a 0b 14 00 movl $0x140b5a,(%esp)
10638c: e8 af 54 02 00 call 12b840 <iconv_open>
106391: 89 43 0c mov %eax,0xc(%ebx)
self->desc_utf8_to_codepage = iconv_open( codepage, "UTF-8" );
106394: b8 5a 0b 14 00 mov $0x140b5a,%eax
106399: 89 44 24 04 mov %eax,0x4(%esp)
10639d: 89 34 24 mov %esi,(%esp)
1063a0: e8 9b 54 02 00 call 12b840 <iconv_open>
self->desc_utf16_to_utf8 = iconv_open( "UTF-8", "UTF-16LE" );
1063a5: ba 60 0b 14 00 mov $0x140b60,%edx
self->desc_utf8_to_codepage = iconv_open( codepage, "UTF-8" );
1063aa: 89 43 10 mov %eax,0x10(%ebx)
self->desc_utf16_to_utf8 = iconv_open( "UTF-8", "UTF-16LE" );
1063ad: 89 54 24 04 mov %edx,0x4(%esp)
1063b1: c7 04 24 5a 0b 14 00 movl $0x140b5a,(%esp)
1063b8: e8 83 54 02 00 call 12b840 <iconv_open>
self->desc_utf8_to_utf16 = iconv_open( "UTF-16LE", "UTF-8" );
1063bd: b9 5a 0b 14 00 mov $0x140b5a,%ecx
self->desc_utf16_to_utf8 = iconv_open( "UTF-8", "UTF-16LE" );
1063c2: 89 43 14 mov %eax,0x14(%ebx)
self->desc_utf8_to_utf16 = iconv_open( "UTF-16LE", "UTF-8" );
1063c5: 89 4c 24 04 mov %ecx,0x4(%esp)
1063c9: c7 04 24 60 0b 14 00 movl $0x140b60,(%esp)
1063d0: e8 6b 54 02 00 call 12b840 <iconv_open>
if (
1063d5: 83 7b 14 ff cmpl $0xffffffff,0x14(%ebx)
self->desc_utf8_to_utf16 = iconv_open( "UTF-16LE", "UTF-8" );
1063d9: 89 43 18 mov %eax,0x18(%ebx)
if (
1063dc: 74 32 je 106410 <rtems_dosfs_create_utf8_converter+0xb0><== NEVER TAKEN
self->desc_utf16_to_utf8 != INVALID_ICONV_DESC
&& self->desc_utf8_to_codepage != INVALID_ICONV_DESC
1063de: 83 7b 10 ff cmpl $0xffffffff,0x10(%ebx)
1063e2: 74 2c je 106410 <rtems_dosfs_create_utf8_converter+0xb0><== NEVER TAKEN
&& self->desc_codepage_to_utf8 != INVALID_ICONV_DESC
&& self->desc_utf8_to_utf16 != INVALID_ICONV_DESC
1063e4: 83 7b 0c ff cmpl $0xffffffff,0xc(%ebx)
1063e8: 74 26 je 106410 <rtems_dosfs_create_utf8_converter+0xb0><== NEVER TAKEN
1063ea: 40 inc %eax
1063eb: 74 23 je 106410 <rtems_dosfs_create_utf8_converter+0xb0><== NEVER TAKEN
) {
rtems_dosfs_convert_control *super = &self->super;
super->handler = &msdos_utf8_convert_handler;
1063ed: c7 03 98 0b 14 00 movl $0x140b98,(%ebx)
super->buffer.data = &self->buffer;
1063f3: 8d 43 1c lea 0x1c(%ebx),%eax
1063f6: 89 43 04 mov %eax,0x4(%ebx)
self = NULL;
}
}
return &self->super;
}
1063f9: 89 d8 mov %ebx,%eax
super->buffer.size = sizeof( self->buffer );
1063fb: c7 43 08 10 04 00 00 movl $0x410,0x8(%ebx)
}
106402: 83 c4 10 add $0x10,%esp
106405: 5b pop %ebx
106406: 5e pop %esi
106407: 5d pop %ebp
106408: c3 ret
106409: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
msdos_utf8_destroy( &self->super );
106410: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
self = NULL;
106413: 31 db xor %ebx,%ebx <== NOT EXECUTED
msdos_utf8_destroy( &self->super );
106415: e8 f6 fc ff ff call 106110 <msdos_utf8_destroy> <== NOT EXECUTED
}
10641a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10641d: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10641f: 5b pop %ebx <== NOT EXECUTED
106420: 5e pop %esi <== NOT EXECUTED
106421: 5d pop %ebp <== NOT EXECUTED
106422: c3 ret <== NOT EXECUTED
106423: 90 nop
106424: 90 nop
106425: 90 nop
106426: 90 nop
106427: 90 nop
106428: 90 nop
106429: 90 nop
10642a: 90 nop
10642b: 90 nop
10642c: 90 nop
10642d: 90 nop
10642e: 90 nop
10642f: 90 nop
00105a80 <rtems_dosfs_initialize>:
*/
int rtems_dosfs_initialize(
rtems_filesystem_mount_table_entry_t *mt_entry,
const void *data
)
{
105a80: 55 push %ebp
105a81: 89 e5 mov %esp,%ebp
105a83: 83 ec 38 sub $0x38,%esp
105a86: 89 5d fc mov %ebx,-0x4(%ebp)
105a89: 8b 45 0c mov 0xc(%ebp),%eax
const rtems_dosfs_mount_options *mount_options = data;
rtems_dosfs_convert_control *converter;
bool converter_created = false;
if (mount_options == NULL || mount_options->converter == NULL) {
105a8c: 85 c0 test %eax,%eax
105a8e: 74 40 je 105ad0 <rtems_dosfs_initialize+0x50>
105a90: 8b 00 mov (%eax),%eax
105a92: 85 c0 test %eax,%eax
105a94: 74 3a je 105ad0 <rtems_dosfs_initialize+0x50> <== NEVER TAKEN
} else {
converter = mount_options->converter;
}
if (converter != NULL) {
rc = msdos_initialize_support(mt_entry,
105a96: 89 44 24 10 mov %eax,0x10(%esp)
105a9a: b8 00 36 13 00 mov $0x133600,%eax
105a9f: ba 40 36 13 00 mov $0x133640,%edx
105aa4: 89 44 24 0c mov %eax,0xc(%esp)
105aa8: 8b 45 08 mov 0x8(%ebp),%eax
105aab: b9 40 2e 13 00 mov $0x132e40,%ecx
105ab0: 89 54 24 08 mov %edx,0x8(%esp)
105ab4: 89 4c 24 04 mov %ecx,0x4(%esp)
105ab8: 89 04 24 mov %eax,(%esp)
105abb: e8 70 00 00 00 call 105b30 <msdos_initialize_support>
errno = ENOMEM;
rc = -1;
}
return rc;
}
105ac0: 8b 5d fc mov -0x4(%ebp),%ebx
105ac3: 89 ec mov %ebp,%esp
105ac5: 5d pop %ebp
105ac6: c3 ret
105ac7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
105ace: 66 90 xchg %ax,%ax
converter = rtems_dosfs_create_default_converter();
105ad0: e8 7b b8 00 00 call 111350 <rtems_dosfs_create_default_converter>
if (converter != NULL) {
105ad5: 85 c0 test %eax,%eax
converter = rtems_dosfs_create_default_converter();
105ad7: 89 c3 mov %eax,%ebx
if (converter != NULL) {
105ad9: 74 43 je 105b1e <rtems_dosfs_initialize+0x9e> <== NEVER TAKEN
rc = msdos_initialize_support(mt_entry,
105adb: 89 44 24 10 mov %eax,0x10(%esp)
105adf: b8 00 36 13 00 mov $0x133600,%eax
105ae4: 89 44 24 0c mov %eax,0xc(%esp)
105ae8: b8 40 36 13 00 mov $0x133640,%eax
105aed: 89 44 24 08 mov %eax,0x8(%esp)
105af1: b8 40 2e 13 00 mov $0x132e40,%eax
105af6: 89 44 24 04 mov %eax,0x4(%esp)
105afa: 8b 45 08 mov 0x8(%ebp),%eax
105afd: 89 04 24 mov %eax,(%esp)
105b00: e8 2b 00 00 00 call 105b30 <msdos_initialize_support>
if (rc != 0 && converter_created) {
105b05: 85 c0 test %eax,%eax
105b07: 74 b7 je 105ac0 <rtems_dosfs_initialize+0x40> <== ALWAYS TAKEN
105b09: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED
(*converter->handler->destroy)(converter);
105b0c: 8b 13 mov (%ebx),%edx <== NOT EXECUTED
105b0e: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
105b11: ff 52 14 call *0x14(%edx) <== NOT EXECUTED
105b14: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED
}
105b17: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
105b1a: 89 ec mov %ebp,%esp <== NOT EXECUTED
105b1c: 5d pop %ebp <== NOT EXECUTED
105b1d: c3 ret <== NOT EXECUTED
errno = ENOMEM;
105b1e: e8 7d 0d 02 00 call 1268a0 <__errno> <== NOT EXECUTED
105b23: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED
rc = -1;
105b29: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
return rc;
105b2e: eb 90 jmp 105ac0 <rtems_dosfs_initialize+0x40> <== NOT EXECUTED