RTEMS-6
Annotated Report
libdosfs
Sun Feb 28 22:25:42 2021
4000dcd0 <_fat_block_read>:
uint32_t start,
uint32_t offset,
uint32_t count,
void *buff
)
{
4000dcd0: 9d e3 bf a0 save %sp, -96, %sp
uint32_t sec_num = start;
uint32_t ofs = offset;
uint8_t *sec_buf;
uint32_t c = 0;
while (count > 0)
4000dcd4: 80 a6 e0 00 cmp %i3, 0
4000dcd8: 02 80 00 2d be 4000dd8c <_fat_block_read+0xbc> <== NEVER TAKEN
4000dcdc: a0 10 20 00 clr %l0
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &fs_info->c.buf);
4000dce0: a2 06 20 a0 add %i0, 0xa0, %l1
fs_info->c.modified = 0;
4000dce4: a4 10 20 01 mov 1, %l2
return sector_number >> (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
4000dce8: fa 0e 20 02 ldub [ %i0 + 2 ], %i5
4000dcec: c2 0e 20 14 ldub [ %i0 + 0x14 ], %g1
if (fs_info->c.state == FAT_CACHE_EMPTY || fs_info->c.blk_num != sec_num)
4000dcf0: c4 0e 20 9d ldub [ %i0 + 0x9d ], %g2
4000dcf4: 82 20 40 1d sub %g1, %i5, %g1
4000dcf8: 80 a0 a0 00 cmp %g2, 0
4000dcfc: a7 36 40 01 srl %i1, %g1, %l3
return block_number << (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
4000dd00: 83 2c c0 01 sll %l3, %g1, %g1
((sector -
4000dd04: 82 26 40 01 sub %i1, %g1, %g1
4000dd08: 02 80 00 08 be 4000dd28 <_fat_block_read+0x58>
4000dd0c: bb 28 40 1d sll %g1, %i5, %i5
4000dd10: c2 06 20 98 ld [ %i0 + 0x98 ], %g1
4000dd14: 80 a0 40 19 cmp %g1, %i1
4000dd18: 02 80 00 0d be 4000dd4c <_fat_block_read+0x7c>
4000dd1c: 82 07 40 1a add %i5, %i2, %g1
4000dd20: 7f ff ff 40 call 4000da20 <fat_buf_release.part.0>
4000dd24: 90 10 00 18 mov %i0, %o0
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &fs_info->c.buf);
4000dd28: d0 06 20 6c ld [ %i0 + 0x6c ], %o0
4000dd2c: 94 10 00 11 mov %l1, %o2
4000dd30: 40 00 24 31 call 40016df4 <rtems_bdbuf_read>
4000dd34: 92 10 00 13 mov %l3, %o1
if (sc != RTEMS_SUCCESSFUL)
4000dd38: 80 a2 20 00 cmp %o0, 0
4000dd3c: 12 80 00 16 bne 4000dd94 <_fat_block_read+0xc4> <== NEVER TAKEN
4000dd40: 82 07 40 1a add %i5, %i2, %g1
fs_info->c.blk_num = sec_num;
4000dd44: f2 26 20 98 st %i1, [ %i0 + 0x98 ]
fs_info->c.modified = 0;
4000dd48: e4 36 20 9c sth %l2, [ %i0 + 0x9c ]
{
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));
4000dd4c: fa 16 00 00 lduh [ %i0 ], %i5
4000dd50: ba 27 40 1a sub %i5, %i2, %i5
4000dd54: 80 a7 40 1b cmp %i5, %i3
4000dd58: 08 80 00 03 bleu 4000dd64 <_fat_block_read+0x94>
4000dd5c: 90 07 00 10 add %i4, %l0, %o0
4000dd60: ba 10 00 1b mov %i3, %i5
*sec_buf = &fs_info->c.buf->buffer[blk_ofs];
4000dd64: c4 06 20 a0 ld [ %i0 + 0xa0 ], %g2
memcpy((buff + cmpltd), (sec_buf + ofs), c);
4000dd68: d2 00 a0 1c ld [ %g2 + 0x1c ], %o1
4000dd6c: 94 10 00 1d mov %i5, %o2
4000dd70: 40 00 39 3d call 4001c264 <memcpy>
4000dd74: 92 02 40 01 add %o1, %g1, %o1
count -= c;
cmpltd += c;
4000dd78: a0 04 00 1d add %l0, %i5, %l0
sec_num++;
4000dd7c: b2 06 60 01 inc %i1
while (count > 0)
4000dd80: b6 a6 c0 1d subcc %i3, %i5, %i3
4000dd84: 12 bf ff d9 bne 4000dce8 <_fat_block_read+0x18>
4000dd88: b4 10 20 00 clr %i2
ofs = 0;
}
return cmpltd;
}
4000dd8c: 81 c7 e0 08 ret
4000dd90: 91 e8 00 10 restore %g0, %l0, %o0
rtems_set_errno_and_return_minus_one(EIO);
4000dd94: 40 00 37 46 call 4001baac <__errno> <== NOT EXECUTED
4000dd98: a0 10 3f ff mov -1, %l0 <== NOT EXECUTED
4000dd9c: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4000dda0: 10 bf ff fb b 4000dd8c <_fat_block_read+0xbc> <== NOT EXECUTED
4000dda4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4000dbf4 <fat_buf_access>:
{
4000dbf4: 9d e3 bf a0 save %sp, -96, %sp
return sector_number >> (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
4000dbf8: fa 0e 20 02 ldub [ %i0 + 2 ], %i5
4000dbfc: c2 0e 20 14 ldub [ %i0 + 0x14 ], %g1
if (fs_info->c.state == FAT_CACHE_EMPTY || fs_info->c.blk_num != sec_num)
4000dc00: c4 0e 20 9d ldub [ %i0 + 0x9d ], %g2
4000dc04: 82 20 40 1d sub %g1, %i5, %g1
{
4000dc08: b8 10 00 18 mov %i0, %i4
if (fs_info->c.state == FAT_CACHE_EMPTY || fs_info->c.blk_num != sec_num)
4000dc0c: 80 a0 a0 00 cmp %g2, 0
4000dc10: b1 36 40 01 srl %i1, %g1, %i0
return block_number << (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
4000dc14: 83 2e 00 01 sll %i0, %g1, %g1
((sector -
4000dc18: 82 26 40 01 sub %i1, %g1, %g1
4000dc1c: 02 80 00 08 be 4000dc3c <fat_buf_access+0x48>
4000dc20: bb 28 40 1d sll %g1, %i5, %i5
4000dc24: c2 07 20 98 ld [ %i4 + 0x98 ], %g1
4000dc28: 80 a0 40 19 cmp %g1, %i1
4000dc2c: 22 80 00 11 be,a 4000dc70 <fat_buf_access+0x7c>
4000dc30: c2 07 20 a0 ld [ %i4 + 0xa0 ], %g1
if (fs_info->c.state == FAT_CACHE_EMPTY)
4000dc34: 7f ff ff 7b call 4000da20 <fat_buf_release.part.0>
4000dc38: 90 10 00 1c mov %i4, %o0
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &fs_info->c.buf);
4000dc3c: d0 07 20 6c ld [ %i4 + 0x6c ], %o0
4000dc40: 94 07 20 a0 add %i4, 0xa0, %o2
if (op_type == FAT_OP_TYPE_READ)
4000dc44: 80 a6 a0 01 cmp %i2, 1
4000dc48: 02 80 00 0f be 4000dc84 <fat_buf_access+0x90>
4000dc4c: 92 10 00 18 mov %i0, %o1
sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &fs_info->c.buf);
4000dc50: 40 00 24 29 call 40016cf4 <rtems_bdbuf_get>
4000dc54: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL)
4000dc58: 80 a2 20 00 cmp %o0, 0
4000dc5c: 12 80 00 0e bne 4000dc94 <fat_buf_access+0xa0> <== NEVER TAKEN
4000dc60: 82 10 20 01 mov 1, %g1
fs_info->c.blk_num = sec_num;
4000dc64: f2 27 20 98 st %i1, [ %i4 + 0x98 ]
fs_info->c.modified = 0;
4000dc68: c2 37 20 9c sth %g1, [ %i4 + 0x9c ]
*sec_buf = &fs_info->c.buf->buffer[blk_ofs];
4000dc6c: c2 07 20 a0 ld [ %i4 + 0xa0 ], %g1
4000dc70: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
4000dc74: 82 00 40 1d add %g1, %i5, %g1
4000dc78: c2 26 c0 00 st %g1, [ %i3 ]
}
4000dc7c: 81 c7 e0 08 ret
4000dc80: 91 e8 20 00 restore %g0, 0, %o0
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &fs_info->c.buf);
4000dc84: 40 00 24 5c call 40016df4 <rtems_bdbuf_read>
4000dc88: 01 00 00 00 nop
4000dc8c: 10 bf ff f4 b 4000dc5c <fat_buf_access+0x68>
4000dc90: 80 a2 20 00 cmp %o0, 0
rtems_set_errno_and_return_minus_one(EIO);
4000dc94: 40 00 37 86 call 4001baac <__errno> <== NOT EXECUTED
4000dc98: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4000dc9c: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4000dca0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4000dca4: 81 c7 e0 08 ret <== NOT EXECUTED
4000dca8: 81 e8 00 00 restore <== NOT EXECUTED
4000da20 <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)
4000da20: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (fs_info->c.state == FAT_CACHE_EMPTY)
return RC_OK;
if (fs_info->c.modified)
4000da24: c2 0e 20 9c ldub [ %i0 + 0x9c ], %g1 <== NOT EXECUTED
4000da28: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000da2c: 02 80 00 50 be 4000db6c <fat_buf_release.part.0+0x14c> <== NOT EXECUTED
4000da30: d0 06 20 a0 ld [ %i0 + 0xa0 ], %o0 <== NOT EXECUTED
{
uint32_t sec_num = fs_info->c.blk_num;
4000da34: c2 06 20 98 ld [ %i0 + 0x98 ], %g1 <== NOT EXECUTED
bool sec_of_fat = ((sec_num >= fs_info->vol.fat_loc) &&
4000da38: c4 16 20 20 lduh [ %i0 + 0x20 ], %g2 <== NOT EXECUTED
4000da3c: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
4000da40: 3a 80 00 0b bcc,a 4000da6c <fat_buf_release.part.0+0x4c> <== NOT EXECUTED
4000da44: c4 06 20 28 ld [ %i0 + 0x28 ], %g2 <== NOT EXECUTED
if (sec_of_fat && !fs_info->vol.mirror)
memcpy(fs_info->sec_buf,
fs_info->c.buf->buffer + blk_ofs,
fs_info->vol.bps);
sc = rtems_bdbuf_release_modified(fs_info->c.buf);
4000da48: 40 00 25 ba call 40017130 <rtems_bdbuf_release_modified> <== NOT EXECUTED
4000da4c: 01 00 00 00 nop <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
4000da50: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000da54: 12 80 00 4b bne 4000db80 <fat_buf_release.part.0+0x160> <== NOT EXECUTED
4000da58: 01 00 00 00 nop <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
fs_info->c.modified = 0;
4000da5c: c0 2e 20 9c clrb [ %i0 + 0x9c ] <== 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;
4000da60: c0 2e 20 9d clrb [ %i0 + 0x9d ] <== NOT EXECUTED
return RC_OK;
}
4000da64: 81 c7 e0 08 ret <== NOT EXECUTED
4000da68: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
bool sec_of_fat = ((sec_num >= fs_info->vol.fat_loc) &&
4000da6c: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
4000da70: 1a bf ff f6 bcc 4000da48 <fat_buf_release.part.0+0x28> <== NOT EXECUTED
4000da74: 01 00 00 00 nop <== NOT EXECUTED
if (sec_of_fat && !fs_info->vol.mirror)
4000da78: c4 0e 20 5c ldub [ %i0 + 0x5c ], %g2 <== NOT EXECUTED
4000da7c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
4000da80: 22 80 00 4a be,a 4000dba8 <fat_buf_release.part.0+0x188> <== NOT EXECUTED
4000da84: c8 0e 20 02 ldub [ %i0 + 2 ], %g4 <== NOT EXECUTED
sc = rtems_bdbuf_release_modified(fs_info->c.buf);
4000da88: 40 00 25 aa call 40017130 <rtems_bdbuf_release_modified> <== NOT EXECUTED
4000da8c: 01 00 00 00 nop <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
4000da90: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000da94: 12 80 00 3b bne 4000db80 <fat_buf_release.part.0+0x160> <== NOT EXECUTED
4000da98: 01 00 00 00 nop <== NOT EXECUTED
fs_info->c.modified = 0;
4000da9c: c0 2e 20 9c clrb [ %i0 + 0x9c ] <== NOT EXECUTED
if (sec_of_fat && !fs_info->vol.mirror)
4000daa0: c2 0e 20 5c ldub [ %i0 + 0x5c ], %g1 <== NOT EXECUTED
4000daa4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000daa8: 32 bf ff ef bne,a 4000da64 <fat_buf_release.part.0+0x44> <== NOT EXECUTED
4000daac: c0 2e 20 9d clrb [ %i0 + 0x9d ] <== NOT EXECUTED
for (i = 1; i < fs_info->vol.fats; i++)
4000dab0: c2 0e 20 15 ldub [ %i0 + 0x15 ], %g1 <== NOT EXECUTED
4000dab4: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED
4000dab8: 08 bf ff ea bleu 4000da60 <fat_buf_release.part.0+0x40> <== NOT EXECUTED
4000dabc: b8 10 20 01 mov 1, %i4 <== NOT EXECUTED
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);
4000dac0: c4 0e 20 02 ldub [ %i0 + 2 ], %g2 <== NOT EXECUTED
sec_num = fs_info->c.blk_num + fs_info->vol.fat_length * i,
4000dac4: c8 06 20 24 ld [ %i0 + 0x24 ], %g4 <== NOT EXECUTED
4000dac8: c6 06 20 98 ld [ %i0 + 0x98 ], %g3 <== NOT EXECUTED
4000dacc: fa 0e 20 14 ldub [ %i0 + 0x14 ], %i5 <== NOT EXECUTED
4000dad0: ba 27 40 02 sub %i5, %g2, %i5 <== NOT EXECUTED
4000dad4: 82 0f 20 ff and %i4, 0xff, %g1 <== NOT EXECUTED
4000dad8: 82 58 40 04 smul %g1, %g4, %g1 <== NOT EXECUTED
4000dadc: 82 00 40 03 add %g1, %g3, %g1 <== NOT EXECUTED
4000dae0: 93 30 40 1d srl %g1, %i5, %o1 <== NOT EXECUTED
return block_number << (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
4000dae4: bb 2a 40 1d sll %o1, %i5, %i5 <== NOT EXECUTED
sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &bd);
4000dae8: d0 06 20 6c ld [ %i0 + 0x6c ], %o0 <== NOT EXECUTED
fat_sector_offset_to_block_offset (const fat_fs_info_t *fs_info,
const uint32_t sector,
const uint32_t sector_offset)
{
return sector_offset +
((sector -
4000daec: 82 20 40 1d sub %g1, %i5, %g1 <== NOT EXECUTED
fat_block_num_to_sector_num (fs_info,
fat_sector_num_to_block_num (fs_info, sector)))
<< fs_info->vol.sec_log2);
4000daf0: bb 28 40 02 sll %g1, %g2, %i5 <== NOT EXECUTED
if (blk_ofs == 0
4000daf4: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
4000daf8: 12 80 00 07 bne 4000db14 <fat_buf_release.part.0+0xf4> <== NOT EXECUTED
4000dafc: 94 07 bf fc add %fp, -4, %o2 <== NOT EXECUTED
&& fs_info->vol.bps == fs_info->vol.bytes_per_block)
4000db00: c4 16 00 00 lduh [ %i0 ], %g2 <== NOT EXECUTED
4000db04: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 <== NOT EXECUTED
4000db08: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
4000db0c: 02 80 00 23 be 4000db98 <fat_buf_release.part.0+0x178> <== NOT EXECUTED
4000db10: 01 00 00 00 nop <== NOT EXECUTED
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &bd);
4000db14: 40 00 24 b8 call 40016df4 <rtems_bdbuf_read> <== NOT EXECUTED
4000db18: 01 00 00 00 nop <== NOT EXECUTED
if ( sc != RTEMS_SUCCESSFUL)
4000db1c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000db20: 12 80 00 2f bne 4000dbdc <fat_buf_release.part.0+0x1bc> <== NOT EXECUTED
4000db24: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
memcpy(bd->buffer + blk_ofs, fs_info->sec_buf, fs_info->vol.bps);
4000db28: d0 00 60 1c ld [ %g1 + 0x1c ], %o0 <== NOT EXECUTED
4000db2c: d4 16 00 00 lduh [ %i0 ], %o2 <== NOT EXECUTED
4000db30: d2 06 20 a4 ld [ %i0 + 0xa4 ], %o1 <== NOT EXECUTED
4000db34: 40 00 39 cc call 4001c264 <memcpy> <== NOT EXECUTED
4000db38: 90 02 00 1d add %o0, %i5, %o0 <== NOT EXECUTED
sc = rtems_bdbuf_release_modified(bd);
4000db3c: 40 00 25 7d call 40017130 <rtems_bdbuf_release_modified> <== NOT EXECUTED
4000db40: d0 07 bf fc ld [ %fp + -4 ], %o0 <== NOT EXECUTED
if ( sc != RTEMS_SUCCESSFUL)
4000db44: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000db48: 12 80 00 25 bne 4000dbdc <fat_buf_release.part.0+0x1bc> <== NOT EXECUTED
4000db4c: b8 07 20 01 inc %i4 <== NOT EXECUTED
for (i = 1; i < fs_info->vol.fats; i++)
4000db50: c2 0e 20 15 ldub [ %i0 + 0x15 ], %g1 <== NOT EXECUTED
4000db54: 84 0f 20 ff and %i4, 0xff, %g2 <== NOT EXECUTED
4000db58: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
4000db5c: 2a bf ff da bcs,a 4000dac4 <fat_buf_release.part.0+0xa4> <== NOT EXECUTED
4000db60: c4 0e 20 02 ldub [ %i0 + 2 ], %g2 <== NOT EXECUTED
fs_info->c.state = FAT_CACHE_EMPTY;
4000db64: 10 bf ff c0 b 4000da64 <fat_buf_release.part.0+0x44> <== NOT EXECUTED
4000db68: c0 2e 20 9d clrb [ %i0 + 0x9d ] <== NOT EXECUTED
sc = rtems_bdbuf_release(fs_info->c.buf);
4000db6c: 40 00 25 2a call 40017014 <rtems_bdbuf_release> <== NOT EXECUTED
4000db70: 01 00 00 00 nop <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
4000db74: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000db78: 22 bf ff bb be,a 4000da64 <fat_buf_release.part.0+0x44> <== NOT EXECUTED
4000db7c: c0 2e 20 9d clrb [ %i0 + 0x9d ] <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
4000db80: 40 00 37 cb call 4001baac <__errno> <== NOT EXECUTED
4000db84: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4000db88: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4000db8c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4000db90: 81 c7 e0 08 ret <== NOT EXECUTED
4000db94: 81 e8 00 00 restore <== NOT EXECUTED
sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &bd);
4000db98: 40 00 24 57 call 40016cf4 <rtems_bdbuf_get> <== NOT EXECUTED
4000db9c: 01 00 00 00 nop <== NOT EXECUTED
4000dba0: 10 bf ff e0 b 4000db20 <fat_buf_release.part.0+0x100> <== NOT EXECUTED
4000dba4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
return sector_number >> (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
4000dba8: c4 0e 20 14 ldub [ %i0 + 0x14 ], %g2 <== NOT EXECUTED
fs_info->c.buf->buffer + blk_ofs,
4000dbac: d2 02 20 1c ld [ %o0 + 0x1c ], %o1 <== NOT EXECUTED
4000dbb0: 84 20 80 04 sub %g2, %g4, %g2 <== NOT EXECUTED
memcpy(fs_info->sec_buf,
4000dbb4: d4 16 00 00 lduh [ %i0 ], %o2 <== NOT EXECUTED
4000dbb8: 87 30 40 02 srl %g1, %g2, %g3 <== NOT EXECUTED
4000dbbc: d0 06 20 a4 ld [ %i0 + 0xa4 ], %o0 <== NOT EXECUTED
return block_number << (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
4000dbc0: 85 28 c0 02 sll %g3, %g2, %g2 <== NOT EXECUTED
((sector -
4000dbc4: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED
<< fs_info->vol.sec_log2);
4000dbc8: 83 28 40 04 sll %g1, %g4, %g1 <== NOT EXECUTED
4000dbcc: 40 00 39 a6 call 4001c264 <memcpy> <== NOT EXECUTED
4000dbd0: 92 02 40 01 add %o1, %g1, %o1 <== NOT EXECUTED
sc = rtems_bdbuf_release_modified(fs_info->c.buf);
4000dbd4: 10 bf ff ad b 4000da88 <fat_buf_release.part.0+0x68> <== NOT EXECUTED
4000dbd8: d0 06 20 a0 ld [ %i0 + 0xa0 ], %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
4000dbdc: 40 00 37 b4 call 4001baac <__errno> <== NOT EXECUTED
4000dbe0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4000dbe4: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
4000dbe8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4000dbec: 81 c7 e0 08 ret <== NOT EXECUTED
4000dbf0: 81 e8 00 00 restore <== NOT EXECUTED
4000de54 <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)
{
4000de54: 9d e3 bf 98 save %sp, -104, %sp
ssize_t rc = RC_OK;
uint32_t bytes_to_write = MIN(count, (fs_info->vol.bpc - offset));
4000de58: e0 06 20 08 ld [ %i0 + 8 ], %l0
4000de5c: a0 24 00 1a sub %l0, %i2, %l0
4000de60: 80 a4 00 1b cmp %l0, %i3
4000de64: 38 80 00 02 bgu,a 4000de6c <fat_cluster_set+0x18> <== NEVER TAKEN
4000de68: a0 10 00 1b mov %i3, %l0 <== NOT EXECUTED
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
4000de6c: d2 0e 20 14 ldub [ %i0 + 0x14 ], %o1
4000de70: c4 0e 20 02 ldub [ %i0 + 2 ], %g2
return sector_number >> (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
4000de74: 82 0a 60 ff and %o1, 0xff, %g1
4000de78: a4 08 a0 ff and %g2, 0xff, %l2
4000de7c: 80 a6 60 00 cmp %i1, 0
4000de80: 12 80 00 06 bne 4000de98 <fat_cluster_set+0x44> <== ALWAYS TAKEN
4000de84: a4 20 40 12 sub %g1, %l2, %l2
4000de88: c6 0e 20 16 ldub [ %i0 + 0x16 ], %g3 <== NOT EXECUTED
4000de8c: 80 88 e0 03 btst 3, %g3 <== NOT EXECUTED
4000de90: 32 80 00 41 bne,a 4000df94 <fat_cluster_set+0x140> <== NOT EXECUTED
4000de94: f2 06 20 28 ld [ %i0 + 0x28 ], %i1 <== NOT EXECUTED
blk = cln << (fs_info->vol.bpc_log2 - fs_info->vol.bytes_per_block_log2);
4000de98: c8 0e 20 0c ldub [ %i0 + 0xc ], %g4
4000de9c: c6 06 20 3c ld [ %i0 + 0x3c ], %g3
cln -= FAT_RSRVD_CLN;
4000dea0: b2 06 7f fe add %i1, -2, %i1
blk = cln << (fs_info->vol.bpc_log2 - fs_info->vol.bytes_per_block_log2);
4000dea4: 88 21 00 01 sub %g4, %g1, %g4
4000dea8: a5 30 c0 12 srl %g3, %l2, %l2
4000deac: b3 2e 40 04 sll %i1, %g4, %i1
blk += fat_sector_num_to_block_num(fs_info, fs_info->vol.data_fsec);
4000deb0: b2 04 80 19 add %l2, %i1, %i1
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;
4000deb4: a5 36 80 01 srl %i2, %g1, %l2
ssize_t bytes_written = 0;
ssize_t ret;
cur_blk += blocks_in_offset;
while ( (RC_OK == rc)
4000deb8: 80 a4 20 00 cmp %l0, 0
uint32_t ofs_blk = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2);
4000debc: 83 2c 80 01 sll %l2, %g1, %g1
cur_blk += blocks_in_offset;
4000dec0: a4 04 80 19 add %l2, %i1, %l2
uint32_t ofs_blk = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2);
4000dec4: b4 26 80 01 sub %i2, %g1, %i2
while ( (RC_OK == rc)
4000dec8: 02 80 00 1e be 4000df40 <fat_cluster_set+0xec> <== NEVER TAKEN
4000decc: b2 10 20 00 clr %i1
fs_info->c.modified = true;
4000ded0: a2 10 20 01 mov 1, %l1
&& (0 < bytes_to_write))
{
uint32_t c = MIN(bytes_to_write, (fs_info->vol.bytes_per_block - ofs_blk));
4000ded4: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
4000ded8: ba 20 40 1a sub %g1, %i2, %i5
4000dedc: 80 a7 40 10 cmp %i5, %l0
4000dee0: 08 80 00 03 bleu 4000deec <fat_cluster_set+0x98> <== ALWAYS TAKEN
4000dee4: b6 10 00 1d mov %i5, %i3
4000dee8: b6 10 00 10 mov %l0, %i3 <== NOT EXECUTED
uint32_t bytes_to_write = MIN(count, (fs_info->vol.bytes_per_block - offset));
4000deec: 80 a7 40 1b cmp %i5, %i3
4000def0: 38 80 00 02 bgu,a 4000def8 <fat_cluster_set+0xa4> <== NEVER TAKEN
4000def4: ba 10 00 1b mov %i3, %i5 <== NOT EXECUTED
if (0 < bytes_to_write)
4000def8: 80 a7 60 00 cmp %i5, 0
4000defc: 02 80 00 1f be 4000df78 <fat_cluster_set+0x124> <== NEVER TAKEN
4000df00: 92 22 40 02 sub %o1, %g2, %o1
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &blk_buf);
4000df04: 96 07 bf fc add %fp, -4, %o3
if (bytes_to_write == fs_info->vol.bytes_per_block)
4000df08: 80 a0 40 1d cmp %g1, %i5
4000df0c: 02 80 00 1d be 4000df80 <fat_cluster_set+0x12c>
4000df10: 93 2c 80 09 sll %l2, %o1, %o1
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &blk_buf);
4000df14: 94 10 20 01 mov 1, %o2
4000df18: 7f ff ff 37 call 4000dbf4 <fat_buf_access>
4000df1c: 90 10 00 18 mov %i0, %o0
if (RC_OK == rc)
4000df20: 80 a2 20 00 cmp %o0, 0
4000df24: 22 80 00 10 be,a 4000df64 <fat_cluster_set+0x110> <== ALWAYS TAKEN
4000df28: d0 07 bf fc ld [ %fp + -4 ], %o0
fs_info,
cur_blk,
ofs_blk,
c,
pattern);
if (c != ret)
4000df2c: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
4000df30: 80 a6 c0 1d cmp %i3, %i5
4000df34: 02 80 00 05 be 4000df48 <fat_cluster_set+0xf4> <== ALWAYS TAKEN
4000df38: b2 06 40 08 add %i1, %o0, %i1
4000df3c: b2 10 3f ff mov -1, %i1 <== NOT EXECUTED
}
if (RC_OK != rc)
return rc;
else
return bytes_written;
}
4000df40: 81 c7 e0 08 ret
4000df44: 91 e8 00 19 restore %g0, %i1, %o0
while ( (RC_OK == rc)
4000df48: a0 a4 00 1b subcc %l0, %i3, %l0
4000df4c: 02 bf ff fd be 4000df40 <fat_cluster_set+0xec>
4000df50: a4 04 a0 01 inc %l2
return block_number << (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
4000df54: d2 0e 20 14 ldub [ %i0 + 0x14 ], %o1
4000df58: c4 0e 20 02 ldub [ %i0 + 2 ], %g2
4000df5c: 10 bf ff de b 4000ded4 <fat_cluster_set+0x80>
4000df60: b4 10 20 00 clr %i2
memset(blk_buf + offset, pattern, bytes_to_write);
4000df64: 94 10 00 1d mov %i5, %o2
4000df68: 92 10 00 1c mov %i4, %o1
4000df6c: 40 00 38 fd call 4001c360 <memset>
4000df70: 90 02 00 1a add %o0, %i2, %o0
fs_info->c.modified = true;
4000df74: e2 2e 20 9c stb %l1, [ %i0 + 0x9c ]
return bytes_to_write;
4000df78: 10 bf ff ee b 4000df30 <fat_cluster_set+0xdc>
4000df7c: 90 10 00 1d mov %i5, %o0
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &blk_buf);
4000df80: 94 10 20 02 mov 2, %o2
4000df84: 7f ff ff 1c call 4000dbf4 <fat_buf_access>
4000df88: 90 10 00 18 mov %i0, %o0
4000df8c: 10 bf ff e6 b 4000df24 <fat_cluster_set+0xd0>
4000df90: 80 a2 20 00 cmp %o0, 0
return sector_number >> (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
4000df94: 10 bf ff c8 b 4000deb4 <fat_cluster_set+0x60> <== NOT EXECUTED
4000df98: b3 36 40 12 srl %i1, %l2, %i1 <== NOT EXECUTED
4000df9c <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)
{
4000df9c: 9d e3 bf 98 save %sp, -104, %sp
ssize_t rc = RC_OK;
uint32_t bytes_to_write = MIN(count, (fs_info->vol.bpc - offset));
4000dfa0: e0 06 20 08 ld [ %i0 + 8 ], %l0
4000dfa4: a0 24 00 1a sub %l0, %i2, %l0
4000dfa8: 80 a4 00 1b cmp %l0, %i3
4000dfac: 38 80 00 02 bgu,a 4000dfb4 <fat_cluster_write+0x18>
4000dfb0: a0 10 00 1b mov %i3, %l0
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
4000dfb4: d2 0e 20 14 ldub [ %i0 + 0x14 ], %o1
4000dfb8: c4 0e 20 02 ldub [ %i0 + 2 ], %g2
4000dfbc: 82 0a 60 ff and %o1, 0xff, %g1
4000dfc0: a4 08 a0 ff and %g2, 0xff, %l2
4000dfc4: 80 a6 60 00 cmp %i1, 0
4000dfc8: 12 80 00 06 bne 4000dfe0 <fat_cluster_write+0x44>
4000dfcc: a4 20 40 12 sub %g1, %l2, %l2
4000dfd0: c6 0e 20 16 ldub [ %i0 + 0x16 ], %g3
4000dfd4: 80 88 e0 03 btst 3, %g3
4000dfd8: 32 80 00 41 bne,a 4000e0dc <fat_cluster_write+0x140> <== ALWAYS TAKEN
4000dfdc: f2 06 20 28 ld [ %i0 + 0x28 ], %i1
blk = cln << (fs_info->vol.bpc_log2 - fs_info->vol.bytes_per_block_log2);
4000dfe0: c8 0e 20 0c ldub [ %i0 + 0xc ], %g4
4000dfe4: c6 06 20 3c ld [ %i0 + 0x3c ], %g3
cln -= FAT_RSRVD_CLN;
4000dfe8: b2 06 7f fe add %i1, -2, %i1
blk = cln << (fs_info->vol.bpc_log2 - fs_info->vol.bytes_per_block_log2);
4000dfec: 88 21 00 01 sub %g4, %g1, %g4
4000dff0: a5 30 c0 12 srl %g3, %l2, %l2
4000dff4: b3 2e 40 04 sll %i1, %g4, %i1
blk += fat_sector_num_to_block_num(fs_info, fs_info->vol.data_fsec);
4000dff8: b2 04 80 19 add %l2, %i1, %i1
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);
4000dffc: a5 36 80 01 srl %i2, %g1, %l2
ssize_t ret;
uint32_t c;
cur_blk += blocks_in_offset;
while ( (RC_OK == rc)
4000e000: 80 a4 20 00 cmp %l0, 0
uint32_t ofs_blk = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2);
4000e004: 83 2c 80 01 sll %l2, %g1, %g1
cur_blk += blocks_in_offset;
4000e008: a4 04 80 19 add %l2, %i1, %l2
uint32_t ofs_blk = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2);
4000e00c: b4 26 80 01 sub %i2, %g1, %i2
while ( (RC_OK == rc)
4000e010: 02 80 00 1e be 4000e088 <fat_cluster_write+0xec> <== NEVER TAKEN
4000e014: b2 10 20 00 clr %i1
fs_info->c.modified = true;
4000e018: a2 10 20 01 mov 1, %l1
&& (0 < bytes_to_write))
{
c = MIN(bytes_to_write, (fs_info->vol.bytes_per_block - ofs_blk));
4000e01c: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
4000e020: ba 20 40 1a sub %g1, %i2, %i5
4000e024: 80 a7 40 10 cmp %i5, %l0
4000e028: 08 80 00 03 bleu 4000e034 <fat_cluster_write+0x98>
4000e02c: b6 10 00 1d mov %i5, %i3
4000e030: b6 10 00 10 mov %l0, %i3
uint32_t bytes_to_write = MIN(count, (fs_info->vol.bytes_per_block - offset));
4000e034: 80 a7 40 1b cmp %i5, %i3
4000e038: 38 80 00 02 bgu,a 4000e040 <fat_cluster_write+0xa4>
4000e03c: ba 10 00 1b mov %i3, %i5
if (0 < bytes_to_write)
4000e040: 80 a7 60 00 cmp %i5, 0
4000e044: 02 80 00 1f be 4000e0c0 <fat_cluster_write+0x124> <== NEVER TAKEN
4000e048: 92 22 40 02 sub %o1, %g2, %o1
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &blk_buf);
4000e04c: 96 07 bf fc add %fp, -4, %o3
if (bytes_to_write == fs_info->vol.bytes_per_block)
4000e050: 80 a0 40 1d cmp %g1, %i5
4000e054: 02 80 00 1d be 4000e0c8 <fat_cluster_write+0x12c>
4000e058: 93 2c 80 09 sll %l2, %o1, %o1
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &blk_buf);
4000e05c: 94 10 20 01 mov 1, %o2
4000e060: 7f ff fe e5 call 4000dbf4 <fat_buf_access>
4000e064: 90 10 00 18 mov %i0, %o0
if (RC_OK == rc)
4000e068: 80 a2 20 00 cmp %o0, 0
4000e06c: 22 80 00 10 be,a 4000e0ac <fat_cluster_write+0x110> <== ALWAYS TAKEN
4000e070: d0 07 bf fc ld [ %fp + -4 ], %o0
fs_info,
cur_blk,
ofs_blk,
c,
&buffer[bytes_written]);
if (c != ret)
4000e074: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
4000e078: 80 a6 c0 1d cmp %i3, %i5
4000e07c: 02 80 00 05 be 4000e090 <fat_cluster_write+0xf4> <== ALWAYS TAKEN
4000e080: b2 06 40 08 add %i1, %o0, %i1
4000e084: b2 10 3f ff mov -1, %i1 <== NOT EXECUTED
}
if (RC_OK != rc)
return rc;
else
return bytes_written;
}
4000e088: 81 c7 e0 08 ret
4000e08c: 91 e8 00 19 restore %g0, %i1, %o0
while ( (RC_OK == rc)
4000e090: a0 a4 00 1b subcc %l0, %i3, %l0
4000e094: 02 bf ff fd be 4000e088 <fat_cluster_write+0xec> <== ALWAYS TAKEN
4000e098: a4 04 a0 01 inc %l2
return block_number << (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
4000e09c: d2 0e 20 14 ldub [ %i0 + 0x14 ], %o1 <== NOT EXECUTED
4000e0a0: c4 0e 20 02 ldub [ %i0 + 2 ], %g2 <== NOT EXECUTED
4000e0a4: 10 bf ff de b 4000e01c <fat_cluster_write+0x80> <== NOT EXECUTED
4000e0a8: b4 10 20 00 clr %i2 <== NOT EXECUTED
memcpy(blk_buf + offset, buf, bytes_to_write);
4000e0ac: 94 10 00 1d mov %i5, %o2
4000e0b0: 92 07 00 19 add %i4, %i1, %o1
4000e0b4: 40 00 38 6c call 4001c264 <memcpy>
4000e0b8: 90 02 00 1a add %o0, %i2, %o0
fs_info->c.modified = true;
4000e0bc: e2 2e 20 9c stb %l1, [ %i0 + 0x9c ]
return bytes_to_write;
4000e0c0: 10 bf ff ee b 4000e078 <fat_cluster_write+0xdc>
4000e0c4: 90 10 00 1d mov %i5, %o0
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &blk_buf);
4000e0c8: 94 10 20 02 mov 2, %o2
4000e0cc: 7f ff fe ca call 4000dbf4 <fat_buf_access>
4000e0d0: 90 10 00 18 mov %i0, %o0
4000e0d4: 10 bf ff e6 b 4000e06c <fat_cluster_write+0xd0>
4000e0d8: 80 a2 20 00 cmp %o0, 0
return sector_number >> (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
4000e0dc: 10 bf ff c8 b 4000dffc <fat_cluster_write+0x60>
4000e0e0: b3 36 40 12 srl %i1, %l2, %i1
4000fbc0 <fat_file_close>:
{
4000fbc0: 9d e3 bf a0 save %sp, -96, %sp
if (fat_fd->links_num > 1)
4000fbc4: c2 06 60 08 ld [ %i1 + 8 ], %g1
4000fbc8: 80 a0 60 01 cmp %g1, 1
4000fbcc: 08 80 00 05 bleu 4000fbe0 <fat_file_close+0x20>
4000fbd0: 82 00 7f ff add %g1, -1, %g1
fat_fd->links_num--;
4000fbd4: c2 26 60 08 st %g1, [ %i1 + 8 ]
rc = fat_buf_release(fs_info);
4000fbd8: 7f ff f8 35 call 4000dcac <fat_buf_release>
4000fbdc: 81 e8 00 00 restore
fat_file_update(fs_info, fat_fd);
4000fbe0: 92 10 00 19 mov %i1, %o1
4000fbe4: 7f ff ff 1c call 4000f854 <fat_file_update>
4000fbe8: 90 10 00 18 mov %i0, %o0
if (fat_fd->flags & FAT_FILE_REMOVED)
4000fbec: c2 0e 60 30 ldub [ %i1 + 0x30 ], %g1
4000fbf0: 80 88 60 01 btst 1, %g1
4000fbf4: 12 80 00 0b bne 4000fc20 <fat_file_close+0x60>
4000fbf8: 94 10 20 00 clr %o2
if (fat_ino_is_unique(fs_info, fat_fd->ino))
4000fbfc: d2 06 60 0c ld [ %i1 + 0xc ], %o1
4000fc00: 7f ff fc 5b call 4000ed6c <fat_ino_is_unique>
4000fc04: 90 10 00 18 mov %i0, %o0
4000fc08: 80 a2 20 00 cmp %o0, 0
4000fc0c: 22 80 00 18 be,a 4000fc6c <fat_file_close+0xac>
4000fc10: c4 06 40 00 ld [ %i1 ], %g2
fat_fd->links_num = 0;
4000fc14: c0 26 60 08 clr [ %i1 + 8 ]
rc = fat_buf_release(fs_info);
4000fc18: 7f ff f8 25 call 4000dcac <fat_buf_release>
4000fc1c: 81 e8 00 00 restore
rc = fat_file_truncate(fs_info, fat_fd, 0);
4000fc20: 92 10 00 19 mov %i1, %o1
4000fc24: 7f ff ff a5 call 4000fab8 <fat_file_truncate>
4000fc28: 90 10 00 18 mov %i0, %o0
if (rc == RC_OK)
4000fc2c: 80 a2 20 00 cmp %o0, 0
4000fc30: 12 bf ff ea bne 4000fbd8 <fat_file_close+0x18> <== NEVER TAKEN
4000fc34: 90 10 00 18 mov %i0, %o0
next = the_node->next;
4000fc38: c4 06 40 00 ld [ %i1 ], %g2
previous = the_node->previous;
4000fc3c: c2 06 60 04 ld [ %i1 + 4 ], %g1
_hash_delete(fs_info->rhash, key, fat_fd->ino, fat_fd);
4000fc40: d2 06 60 0c ld [ %i1 + 0xc ], %o1
next->previous = previous;
4000fc44: c2 20 a0 04 st %g1, [ %g2 + 4 ]
if (fat_ino_is_unique(fs_info, fat_fd->ino))
4000fc48: 7f ff fc 49 call 4000ed6c <fat_ino_is_unique>
4000fc4c: c4 20 40 00 st %g2, [ %g1 ]
4000fc50: 80 a2 20 00 cmp %o0, 0
4000fc54: 32 80 00 0d bne,a 4000fc88 <fat_file_close+0xc8> <== NEVER TAKEN
4000fc58: d2 06 60 0c ld [ %i1 + 0xc ], %o1 <== NOT EXECUTED
free(fat_fd);
4000fc5c: 7f ff ca 31 call 40002520 <free>
4000fc60: 90 10 00 19 mov %i1, %o0
rc = fat_buf_release(fs_info);
4000fc64: 7f ff f8 12 call 4000dcac <fat_buf_release>
4000fc68: 81 e8 00 00 restore
previous = the_node->previous;
4000fc6c: c2 06 60 04 ld [ %i1 + 4 ], %g1
next->previous = previous;
4000fc70: c2 20 a0 04 st %g1, [ %g2 + 4 ]
free(fat_fd);
4000fc74: 90 10 00 19 mov %i1, %o0
4000fc78: 7f ff ca 2a call 40002520 <free>
4000fc7c: c4 20 40 00 st %g2, [ %g1 ]
rc = fat_buf_release(fs_info);
4000fc80: 7f ff f8 0b call 4000dcac <fat_buf_release>
4000fc84: 81 e8 00 00 restore
fat_free_unique_ino(fs_info, fat_fd->ino);
4000fc88: 7f ff fc 2e call 4000ed40 <fat_free_unique_ino> <== NOT EXECUTED
4000fc8c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4000fc90: 30 bf ff f3 b,a 4000fc5c <fat_file_close+0x9c> <== NOT EXECUTED
4000fd68 <fat_file_extend>:
{
4000fd68: 9d e3 bf 90 save %sp, -112, %sp
*a_length = new_length;
4000fd6c: f6 27 00 00 st %i3, [ %i4 ]
uint32_t chain = 0;
4000fd70: c0 27 bf f0 clr [ %fp + -16 ]
uint32_t last_cl = 0;
4000fd74: c0 27 bf f8 clr [ %fp + -8 ]
if (new_length <= fat_fd->fat_file_size)
4000fd78: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
4000fd7c: 80 a0 40 1b cmp %g1, %i3
4000fd80: 1a 80 00 58 bcc 4000fee0 <fat_file_extend+0x178>
4000fd84: a0 10 00 18 mov %i0, %l0
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
4000fd88: c4 06 60 20 ld [ %i1 + 0x20 ], %g2
4000fd8c: 80 a0 a0 01 cmp %g2, 1
4000fd90: 22 80 00 56 be,a 4000fee8 <fat_file_extend+0x180>
4000fd94: c4 06 60 24 ld [ %i1 + 0x24 ], %g2
bytes_remain = (fs_info->vol.bpc -
4000fd98: fa 04 20 08 ld [ %l0 + 8 ], %i5
(fat_fd->fat_file_size & (fs_info->vol.bpc - 1))) &
4000fd9c: 84 07 7f ff add %i5, -1, %g2
bytes2add = new_length - fat_fd->fat_file_size;
4000fda0: 86 26 c0 01 sub %i3, %g1, %g3
(fat_fd->fat_file_size & (fs_info->vol.bpc - 1))) &
4000fda4: a4 08 40 02 and %g1, %g2, %l2
bytes_remain = (fs_info->vol.bpc -
4000fda8: ba 27 40 12 sub %i5, %l2, %i5
4000fdac: ba 0f 40 02 and %i5, %g2, %i5
if (bytes2add > bytes_remain)
4000fdb0: 80 a7 40 03 cmp %i5, %g3
4000fdb4: 1a 80 00 49 bcc 4000fed8 <fat_file_extend+0x170>
4000fdb8: 80 a6 a0 00 cmp %i2, 0
if (zero_fill && bytes_remain > 0) {
4000fdbc: 80 a7 60 00 cmp %i5, 0
4000fdc0: 02 80 00 05 be 4000fdd4 <fat_file_extend+0x6c>
4000fdc4: a2 20 c0 1d sub %g3, %i5, %l1
4000fdc8: 80 a6 a0 00 cmp %i2, 0
4000fdcc: 32 80 00 55 bne,a 4000ff20 <fat_file_extend+0x1b8> <== NEVER TAKEN
4000fdd0: d4 0c 20 0c ldub [ %l0 + 0xc ], %o2 <== NOT EXECUTED
if (bytes2add == 0)
4000fdd4: 80 a4 60 00 cmp %l1, 0
4000fdd8: 02 80 00 42 be 4000fee0 <fat_file_extend+0x178>
4000fddc: 94 04 7f ff add %l1, -1, %o2
cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;
4000fde0: c2 0c 20 0c ldub [ %l0 + 0xc ], %g1
rc = fat_scan_fat_for_free_clusters(fs_info, &chain, cls2add,
4000fde4: 9a 10 00 1a mov %i2, %o5
4000fde8: 98 07 bf f8 add %fp, -8, %o4
cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;
4000fdec: b5 32 80 01 srl %o2, %g1, %i2
rc = fat_scan_fat_for_free_clusters(fs_info, &chain, cls2add,
4000fdf0: 96 07 bf fc add %fp, -4, %o3
cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;
4000fdf4: b4 06 a0 01 inc %i2
rc = fat_scan_fat_for_free_clusters(fs_info, &chain, cls2add,
4000fdf8: 92 07 bf f0 add %fp, -16, %o1
4000fdfc: 94 10 00 1a mov %i2, %o2
4000fe00: 7f ff fd 35 call 4000f2d4 <fat_scan_fat_for_free_clusters>
4000fe04: 90 10 00 10 mov %l0, %o0
if (rc != RC_OK)
4000fe08: b0 92 20 00 orcc %o0, 0, %i0
4000fe0c: 12 80 00 31 bne 4000fed0 <fat_file_extend+0x168> <== NEVER TAKEN
4000fe10: c2 07 bf fc ld [ %fp + -4 ], %g1
if ((cls_added == 0) && (bytes_remain == 0))
4000fe14: 80 90 40 1d orcc %g1, %i5, %g0
4000fe18: 02 80 00 3b be 4000ff04 <fat_file_extend+0x19c>
4000fe1c: 80 a0 40 1a cmp %g1, %i2
if (cls2add != cls_added)
4000fe20: 02 80 00 08 be 4000fe40 <fat_file_extend+0xd8>
4000fe24: b4 26 80 01 sub %i2, %g1, %i2
uint32_t missing = (cls2add - cls_added) << fs_info->vol.bpc_log2;
4000fe28: d4 0c 20 0c ldub [ %l0 + 0xc ], %o2
4000fe2c: b5 2e 80 0a sll %i2, %o2, %i2
new_length -= bytes2add < missing ? bytes2add : missing;
4000fe30: 80 a6 80 11 cmp %i2, %l1
4000fe34: 38 80 00 02 bgu,a 4000fe3c <fat_file_extend+0xd4> <== ALWAYS TAKEN
4000fe38: b4 10 00 11 mov %l1, %i2
4000fe3c: b6 26 c0 1a sub %i3, %i2, %i3
if (cls_added > 0)
4000fe40: 80 a0 60 00 cmp %g1, 0
4000fe44: 22 80 00 4a be,a 4000ff6c <fat_file_extend+0x204>
4000fe48: f6 27 00 00 st %i3, [ %i4 ]
if ( fat_fd->fat_file_size == 0 )
4000fe4c: d6 06 60 18 ld [ %i1 + 0x18 ], %o3
4000fe50: 80 a2 e0 00 cmp %o3, 0
4000fe54: 02 80 00 4c be 4000ff84 <fat_file_extend+0x21c>
4000fe58: c4 07 bf f0 ld [ %fp + -16 ], %g2
if (fat_fd->map.last_cln != FAT_UNDEFINED_VALUE)
4000fe5c: d2 06 60 3c ld [ %i1 + 0x3c ], %o1
4000fe60: 80 a2 7f ff cmp %o1, -1
4000fe64: 22 80 00 4f be,a 4000ffa0 <fat_file_extend+0x238> <== NEVER TAKEN
4000fe68: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
old_last_cl = fat_fd->map.last_cln;
4000fe6c: d2 27 bf f4 st %o1, [ %fp + -12 ]
rc = fat_set_fat_cluster(fs_info, old_last_cl, chain);
4000fe70: 90 10 00 10 mov %l0, %o0
4000fe74: 7f ff fc 37 call 4000ef50 <fat_set_fat_cluster>
4000fe78: d4 07 bf f0 ld [ %fp + -16 ], %o2
if ( rc != RC_OK )
4000fe7c: 82 92 20 00 orcc %o0, 0, %g1
4000fe80: 12 80 00 11 bne 4000fec4 <fat_file_extend+0x15c> <== NEVER TAKEN
4000fe84: d2 07 bf f0 ld [ %fp + -16 ], %o1
fat_buf_release(fs_info);
4000fe88: 7f ff f7 89 call 4000dcac <fat_buf_release>
4000fe8c: 90 10 00 10 mov %l0, %o0
fat_fd->map.last_cln = last_cl;
4000fe90: c2 07 bf f8 ld [ %fp + -8 ], %g1
4000fe94: c2 26 60 3c st %g1, [ %i1 + 0x3c ]
if (fat_fd->fat_file_type == FAT_DIRECTORY)
4000fe98: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
4000fe9c: 80 a0 60 00 cmp %g1, 0
4000fea0: 32 80 00 33 bne,a 4000ff6c <fat_file_extend+0x204>
4000fea4: f6 27 00 00 st %i3, [ %i4 ]
rc = fat_init_clusters_chain(fs_info, chain);
4000fea8: d2 07 bf f0 ld [ %fp + -16 ], %o1
4000feac: 7f ff fb 50 call 4000ebec <fat_init_clusters_chain>
4000feb0: 90 10 00 10 mov %l0, %o0
if ( rc != RC_OK )
4000feb4: 82 92 20 00 orcc %o0, 0, %g1
4000feb8: 22 80 00 2d be,a 4000ff6c <fat_file_extend+0x204> <== ALWAYS TAKEN
4000febc: f6 27 00 00 st %i3, [ %i4 ]
fat_free_fat_clusters_chain(fs_info, chain);
4000fec0: d2 07 bf f0 ld [ %fp + -16 ], %o1 <== NOT EXECUTED
return rc;
4000fec4: b0 10 00 01 mov %g1, %i0 <== NOT EXECUTED
fat_free_fat_clusters_chain(fs_info, chain);
4000fec8: 7f ff fc cb call 4000f1f4 <fat_free_fat_clusters_chain> <== NOT EXECUTED
4000fecc: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
return rc;
4000fed0: 81 c7 e0 08 ret <== NOT EXECUTED
4000fed4: 81 e8 00 00 restore <== NOT EXECUTED
if (zero_fill && bytes_remain > 0) {
4000fed8: 12 80 00 11 bne 4000ff1c <fat_file_extend+0x1b4>
4000fedc: a2 10 20 00 clr %l1
return RC_OK;
4000fee0: 81 c7 e0 08 ret
4000fee4: 91 e8 20 00 restore %g0, 0, %o0
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
4000fee8: 80 a0 a0 00 cmp %g2, 0
4000feec: 32 bf ff ac bne,a 4000fd9c <fat_file_extend+0x34> <== NEVER TAKEN
4000fef0: fa 04 20 08 ld [ %l0 + 8 ], %i5 <== NOT EXECUTED
4000fef4: c4 0e 20 16 ldub [ %i0 + 0x16 ], %g2
4000fef8: 80 88 a0 03 btst 3, %g2
4000fefc: 22 bf ff a8 be,a 4000fd9c <fat_file_extend+0x34> <== NEVER TAKEN
4000ff00: fa 04 20 08 ld [ %l0 + 8 ], %i5 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOSPC);
4000ff04: 40 00 2e ea call 4001baac <__errno>
4000ff08: b0 10 3f ff mov -1, %i0
4000ff0c: 82 10 20 1c mov 0x1c, %g1
4000ff10: c2 22 00 00 st %g1, [ %o0 ]
4000ff14: 81 c7 e0 08 ret
4000ff18: 81 e8 00 00 restore
uint32_t cl_start = start >> fs_info->vol.bpc_log2;
4000ff1c: d4 0c 20 0c ldub [ %l0 + 0xc ], %o2
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
4000ff20: 96 07 bf fc add %fp, -4, %o3
4000ff24: 95 30 40 0a srl %g1, %o2, %o2
4000ff28: 92 10 00 19 mov %i1, %o1
4000ff2c: 7f ff fd 5f call 4000f4a8 <fat_file_lseek>
4000ff30: 90 10 00 10 mov %l0, %o0
if (rc != RC_OK)
4000ff34: b0 92 60 00 orcc %o1, 0, %i0
4000ff38: 12 bf ff e6 bne 4000fed0 <fat_file_extend+0x168> <== NEVER TAKEN
4000ff3c: d2 07 bf fc ld [ %fp + -4 ], %o1
bytes_written = fat_cluster_set (fs_info, cur_cln, ofs, bytes_remain, 0);
4000ff40: 98 10 20 00 clr %o4
4000ff44: 96 10 00 1d mov %i5, %o3
4000ff48: 94 10 00 12 mov %l2, %o2
4000ff4c: 90 10 00 10 mov %l0, %o0
4000ff50: 7f ff f7 c1 call 4000de54 <fat_cluster_set>
4000ff54: b0 10 3f ff mov -1, %i0
if (bytes_remain != bytes_written)
4000ff58: 80 a2 00 1d cmp %o0, %i5
4000ff5c: 02 bf ff 9f be 4000fdd8 <fat_file_extend+0x70> <== ALWAYS TAKEN
4000ff60: 80 a4 60 00 cmp %l1, 0
}
4000ff64: 81 c7 e0 08 ret <== NOT EXECUTED
4000ff68: 81 e8 00 00 restore <== NOT EXECUTED
fat_fd->flags |= FAT_FILE_META_DATA_CHANGED;
4000ff6c: c2 0e 60 30 ldub [ %i1 + 0x30 ], %g1
4000ff70: 82 10 60 02 or %g1, 2, %g1
fat_fd->fat_file_size = s;
4000ff74: f6 26 60 18 st %i3, [ %i1 + 0x18 ]
fat_fd->flags |= FAT_FILE_META_DATA_CHANGED;
4000ff78: c2 2e 60 30 stb %g1, [ %i1 + 0x30 ]
return RC_OK;
4000ff7c: 81 c7 e0 08 ret
4000ff80: 81 e8 00 00 restore
fat_fd->flags |= FAT_FILE_META_DATA_CHANGED;
4000ff84: c2 0e 60 30 ldub [ %i1 + 0x30 ], %g1
4000ff88: 82 10 60 02 or %g1, 2, %g1
fat_fd->map.disk_cln = chain;
4000ff8c: c4 26 60 38 st %g2, [ %i1 + 0x38 ]
fat_fd->map.file_cln = 0;
4000ff90: c0 26 60 34 clr [ %i1 + 0x34 ]
fat_fd->cln = cln;
4000ff94: c4 26 60 1c st %g2, [ %i1 + 0x1c ]
}
4000ff98: 10 bf ff be b 4000fe90 <fat_file_extend+0x128>
4000ff9c: c2 2e 60 30 stb %g1, [ %i1 + 0x30 ]
rc = fat_file_ioctl(fs_info, fat_fd, F_CLU_NUM,
4000ffa0: 98 07 bf f4 add %fp, -12, %o4 <== NOT EXECUTED
4000ffa4: 96 02 ff ff add %o3, -1, %o3 <== NOT EXECUTED
4000ffa8: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
4000ffac: 7f ff ff 3a call 4000fc94 <fat_file_ioctl> <== NOT EXECUTED
4000ffb0: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
if ( rc != RC_OK )
4000ffb4: 82 92 20 00 orcc %o0, 0, %g1 <== NOT EXECUTED
4000ffb8: 02 bf ff ae be 4000fe70 <fat_file_extend+0x108> <== NOT EXECUTED
4000ffbc: d2 07 bf f4 ld [ %fp + -12 ], %o1 <== NOT EXECUTED
4000ffc0: 10 bf ff c1 b 4000fec4 <fat_file_extend+0x15c> <== NOT EXECUTED
4000ffc4: d2 07 bf f0 ld [ %fp + -16 ], %o1 <== NOT EXECUTED
4000fc94 <fat_file_ioctl>:
{
4000fc94: 9d e3 bf 98 save %sp, -104, %sp
va_start(ap, cmd);
4000fc98: 82 07 a0 50 add %fp, 0x50, %g1
4000fc9c: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
switch (cmd)
4000fca0: 80 a6 a0 01 cmp %i2, 1
va_start(ap, cmd);
4000fca4: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
4000fca8: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
uint32_t cur_cln = 0;
4000fcac: c0 27 bf f8 clr [ %fp + -8 ]
switch (cmd)
4000fcb0: 12 80 00 22 bne 4000fd38 <fat_file_ioctl+0xa4> <== NEVER TAKEN
4000fcb4: c2 27 bf fc st %g1, [ %fp + -4 ]
ret = va_arg(ap, uint32_t *);
4000fcb8: 84 07 a0 58 add %fp, 0x58, %g2
4000fcbc: c4 27 bf fc st %g2, [ %fp + -4 ]
if ( pos >= fat_fd->fat_file_size ) {
4000fcc0: c4 06 60 18 ld [ %i1 + 0x18 ], %g2
4000fcc4: 80 a0 80 1b cmp %g2, %i3
4000fcc8: 08 80 00 22 bleu 4000fd50 <fat_file_ioctl+0xbc> <== NEVER TAKEN
4000fccc: ba 10 00 1c mov %i4, %i5
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
4000fcd0: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
4000fcd4: 80 a0 60 01 cmp %g1, 1
4000fcd8: 32 80 00 0d bne,a 4000fd0c <fat_file_ioctl+0x78>
4000fcdc: d4 0e 20 0c ldub [ %i0 + 0xc ], %o2
4000fce0: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
4000fce4: 80 a0 60 00 cmp %g1, 0
4000fce8: 32 80 00 09 bne,a 4000fd0c <fat_file_ioctl+0x78> <== NEVER TAKEN
4000fcec: d4 0e 20 0c ldub [ %i0 + 0xc ], %o2 <== NOT EXECUTED
4000fcf0: c2 0e 20 16 ldub [ %i0 + 0x16 ], %g1
4000fcf4: 80 88 60 03 btst 3, %g1
4000fcf8: 22 80 00 05 be,a 4000fd0c <fat_file_ioctl+0x78>
4000fcfc: d4 0e 20 0c ldub [ %i0 + 0xc ], %o2
*ret = 0;
4000fd00: c0 27 00 00 clr [ %i4 ]
break;
4000fd04: 81 c7 e0 08 ret
4000fd08: 91 e8 20 00 restore %g0, 0, %o0
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
4000fd0c: 90 10 00 18 mov %i0, %o0
4000fd10: 96 07 bf f8 add %fp, -8, %o3
4000fd14: 95 36 c0 0a srl %i3, %o2, %o2
4000fd18: 7f ff fd e4 call 4000f4a8 <fat_file_lseek>
4000fd1c: 92 10 00 19 mov %i1, %o1
if ( rc != RC_OK )
4000fd20: b0 92 60 00 orcc %o1, 0, %i0
4000fd24: 12 80 00 03 bne 4000fd30 <fat_file_ioctl+0x9c> <== NEVER TAKEN
4000fd28: c2 07 bf f8 ld [ %fp + -8 ], %g1
*ret = cur_cln;
4000fd2c: c2 27 40 00 st %g1, [ %i5 ]
break;
4000fd30: 81 c7 e0 08 ret
4000fd34: 81 e8 00 00 restore
errno = EINVAL;
4000fd38: 40 00 2f 5d call 4001baac <__errno> <== NOT EXECUTED
4000fd3c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4000fd40: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
4000fd44: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
4000fd48: 81 c7 e0 08 ret <== NOT EXECUTED
4000fd4c: 81 e8 00 00 restore <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
4000fd50: 40 00 2f 57 call 4001baac <__errno> <== NOT EXECUTED
4000fd54: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4000fd58: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4000fd5c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4000fd60: 81 c7 e0 08 ret <== NOT EXECUTED
4000fd64: 81 e8 00 00 restore <== NOT EXECUTED
4000f544 <fat_file_open>:
{
4000f544: 9d e3 bf a0 save %sp, -96, %sp
key = fat_construct_key(fs_info, &dir_pos->sname);
4000f548: c2 06 40 00 ld [ %i1 ], %g1
if (cln == 1)
4000f54c: 80 a0 60 01 cmp %g1, 1
4000f550: 02 80 00 10 be 4000f590 <fat_file_open+0x4c>
4000f554: c4 06 60 04 ld [ %i1 + 4 ], %g2
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
4000f558: 80 a0 60 00 cmp %g1, 0
4000f55c: 32 80 00 07 bne,a 4000f578 <fat_file_open+0x34>
4000f560: c8 0e 20 05 ldub [ %i0 + 5 ], %g4
4000f564: c6 0e 20 16 ldub [ %i0 + 0x16 ], %g3
4000f568: 80 88 e0 03 btst 3, %g3
4000f56c: 32 80 00 07 bne,a 4000f588 <fat_file_open+0x44> <== ALWAYS TAKEN
4000f570: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
4000f574: c8 0e 20 05 ldub [ %i0 + 5 ], %g4 <== NOT EXECUTED
4000f578: c6 06 20 3c ld [ %i0 + 0x3c ], %g3
4000f57c: 82 00 7f fe add %g1, -2, %g1
4000f580: 83 28 40 04 sll %g1, %g4, %g1
4000f584: 82 00 40 03 add %g1, %g3, %g1
fs_info->vol.sec_mul);
4000f588: fa 0e 20 03 ldub [ %i0 + 3 ], %i5
return (fat_cluster_num_to_sector_num(fs_info, cln) <<
4000f58c: 83 28 40 1d sll %g1, %i5, %g1
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
4000f590: f6 06 20 80 ld [ %i0 + 0x80 ], %i3
((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );
4000f594: bb 30 a0 05 srl %g2, 5, %i5
4000f598: 86 0f 60 0f and %i5, 0xf, %g3
uint32_t mod = (key1) % FAT_HASH_MODULE;
4000f59c: 88 08 e0 01 and %g3, 1, %g4
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
4000f5a0: b9 29 20 01 sll %g4, 1, %i4
4000f5a4: b8 07 00 04 add %i4, %g4, %i4
4000f5a8: b9 2f 20 02 sll %i4, 2, %i4
return _Chain_Immutable_head( the_chain )->next;
4000f5ac: c8 06 c0 1c ld [ %i3 + %i4 ], %g4
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
4000f5b0: bb 30 a0 09 srl %g2, 9, %i5
4000f5b4: b6 06 c0 1c add %i3, %i4, %i3
return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) +
4000f5b8: ba 07 40 01 add %i5, %g1, %i5
return &the_chain->Tail.Node;
4000f5bc: a0 06 e0 04 add %i3, 4, %l0
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
4000f5c0: bb 2f 60 04 sll %i5, 4, %i5
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
4000f5c4: 80 a1 00 10 cmp %g4, %l0
4000f5c8: 02 80 00 21 be 4000f64c <fat_file_open+0x108>
4000f5cc: ba 07 40 03 add %i5, %g3, %i5
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
4000f5d0: c2 01 20 20 ld [ %g4 + 0x20 ], %g1
if (cln == 1)
4000f5d4: 80 a0 60 01 cmp %g1, 1
4000f5d8: 02 80 00 10 be 4000f618 <fat_file_open+0xd4>
4000f5dc: c6 01 20 24 ld [ %g4 + 0x24 ], %g3
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
4000f5e0: 80 a0 60 00 cmp %g1, 0
4000f5e4: 32 80 00 07 bne,a 4000f600 <fat_file_open+0xbc>
4000f5e8: de 0e 20 05 ldub [ %i0 + 5 ], %o7
4000f5ec: c4 0e 20 16 ldub [ %i0 + 0x16 ], %g2
4000f5f0: 80 88 a0 03 btst 3, %g2
4000f5f4: 32 80 00 07 bne,a 4000f610 <fat_file_open+0xcc> <== ALWAYS TAKEN
4000f5f8: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
4000f5fc: de 0e 20 05 ldub [ %i0 + 5 ], %o7 <== NOT EXECUTED
4000f600: c4 06 20 3c ld [ %i0 + 0x3c ], %g2
4000f604: 82 00 7f fe add %g1, -2, %g1
4000f608: 83 28 40 0f sll %g1, %o7, %g1
4000f60c: 82 00 40 02 add %g1, %g2, %g1
fs_info->vol.sec_mul);
4000f610: c4 0e 20 03 ldub [ %i0 + 3 ], %g2
return (fat_cluster_num_to_sector_num(fs_info, cln) <<
4000f614: 83 28 40 02 sll %g1, %g2, %g1
4000f618: 85 30 e0 09 srl %g3, 9, %g2
((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );
4000f61c: 87 30 e0 05 srl %g3, 5, %g3
return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) +
4000f620: 82 00 80 01 add %g2, %g1, %g1
((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );
4000f624: 86 08 e0 0f and %g3, 0xf, %g3
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
4000f628: 83 28 60 04 sll %g1, 4, %g1
4000f62c: 82 00 40 03 add %g1, %g3, %g1
if ( (key1) == ck)
4000f630: 80 a7 40 01 cmp %i5, %g1
4000f634: 22 80 00 4a be,a 4000f75c <fat_file_open+0x218>
4000f638: c2 01 20 08 ld [ %g4 + 8 ], %g1
the_node = the_node->next;
4000f63c: c8 01 00 00 ld [ %g4 ], %g4
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
4000f640: 80 a1 00 10 cmp %g4, %l0
4000f644: 32 bf ff e4 bne,a 4000f5d4 <fat_file_open+0x90>
4000f648: c2 01 20 20 ld [ %g4 + 0x20 ], %g1
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
4000f64c: de 06 20 84 ld [ %i0 + 0x84 ], %o7
return _Chain_Immutable_head( the_chain )->next;
4000f650: c8 03 c0 1c ld [ %o7 + %i4 ], %g4
4000f654: 9e 03 c0 1c add %o7, %i4, %o7
return &the_chain->Tail.Node;
4000f658: 9e 03 e0 04 add %o7, 4, %o7
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
4000f65c: 80 a1 00 0f cmp %g4, %o7
4000f660: 02 80 00 22 be 4000f6e8 <fat_file_open+0x1a4> <== ALWAYS TAKEN
4000f664: 92 10 20 50 mov 0x50, %o1
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
4000f668: c2 01 20 20 ld [ %g4 + 0x20 ], %g1 <== NOT EXECUTED
if (cln == 1)
4000f66c: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED
4000f670: 02 80 00 10 be 4000f6b0 <fat_file_open+0x16c> <== NOT EXECUTED
4000f674: c6 01 20 24 ld [ %g4 + 0x24 ], %g3 <== NOT EXECUTED
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
4000f678: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000f67c: 32 80 00 07 bne,a 4000f698 <fat_file_open+0x154> <== NOT EXECUTED
4000f680: da 0e 20 05 ldub [ %i0 + 5 ], %o5 <== NOT EXECUTED
4000f684: c4 0e 20 16 ldub [ %i0 + 0x16 ], %g2 <== NOT EXECUTED
4000f688: 80 88 a0 03 btst 3, %g2 <== NOT EXECUTED
4000f68c: 32 80 00 07 bne,a 4000f6a8 <fat_file_open+0x164> <== NOT EXECUTED
4000f690: c2 06 20 28 ld [ %i0 + 0x28 ], %g1 <== NOT EXECUTED
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
4000f694: da 0e 20 05 ldub [ %i0 + 5 ], %o5 <== NOT EXECUTED
4000f698: c4 06 20 3c ld [ %i0 + 0x3c ], %g2 <== NOT EXECUTED
4000f69c: 82 00 7f fe add %g1, -2, %g1 <== NOT EXECUTED
4000f6a0: 83 28 40 0d sll %g1, %o5, %g1 <== NOT EXECUTED
4000f6a4: 82 00 40 02 add %g1, %g2, %g1 <== NOT EXECUTED
fs_info->vol.sec_mul);
4000f6a8: c4 0e 20 03 ldub [ %i0 + 3 ], %g2 <== NOT EXECUTED
return (fat_cluster_num_to_sector_num(fs_info, cln) <<
4000f6ac: 83 28 40 02 sll %g1, %g2, %g1 <== NOT EXECUTED
4000f6b0: 85 30 e0 09 srl %g3, 9, %g2 <== NOT EXECUTED
((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );
4000f6b4: 87 30 e0 05 srl %g3, 5, %g3 <== NOT EXECUTED
return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) +
4000f6b8: 82 00 80 01 add %g2, %g1, %g1 <== NOT EXECUTED
((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );
4000f6bc: 86 08 e0 0f and %g3, 0xf, %g3 <== NOT EXECUTED
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
4000f6c0: 83 28 60 04 sll %g1, 4, %g1 <== NOT EXECUTED
4000f6c4: 82 00 40 03 add %g1, %g3, %g1 <== NOT EXECUTED
if ( (key1) == ck)
4000f6c8: 80 a7 40 01 cmp %i5, %g1 <== NOT EXECUTED
4000f6cc: 02 80 00 29 be 4000f770 <fat_file_open+0x22c> <== NOT EXECUTED
4000f6d0: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
the_node = the_node->next;
4000f6d4: c8 01 00 00 ld [ %g4 ], %g4 <== NOT EXECUTED
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
4000f6d8: 80 a1 00 0f cmp %g4, %o7 <== NOT EXECUTED
4000f6dc: 32 bf ff e4 bne,a 4000f66c <fat_file_open+0x128> <== NOT EXECUTED
4000f6e0: c2 01 20 20 ld [ %g4 + 0x20 ], %g1 <== NOT EXECUTED
lfat_fd = (*fat_fd) = (fat_file_fd_t*)calloc(1, sizeof(fat_file_fd_t));
4000f6e4: 92 10 20 50 mov 0x50, %o1 <== NOT EXECUTED
4000f6e8: 7f ff f5 a4 call 4000cd78 <calloc>
4000f6ec: 90 10 20 01 mov 1, %o0
4000f6f0: d0 26 80 00 st %o0, [ %i2 ]
if ( lfat_fd == NULL )
4000f6f4: 80 a2 20 00 cmp %o0, 0
4000f6f8: 02 80 00 4b be 4000f824 <fat_file_open+0x2e0> <== NEVER TAKEN
4000f6fc: a2 10 00 08 mov %o0, %l1
lfat_fd->flags &= ~FAT_FILE_REMOVED;
4000f700: c2 0c 60 30 ldub [ %l1 + 0x30 ], %g1
4000f704: 82 08 7f fe and %g1, -2, %g1
4000f708: c2 2c 60 30 stb %g1, [ %l1 + 0x30 ]
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
4000f70c: 82 10 3f ff mov -1, %g1
lfat_fd->dir_pos = *dir_pos;
4000f710: f8 06 40 00 ld [ %i1 ], %i4
4000f714: c8 06 60 04 ld [ %i1 + 4 ], %g4
4000f718: c6 06 60 08 ld [ %i1 + 8 ], %g3
4000f71c: c4 06 60 0c ld [ %i1 + 0xc ], %g2
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
4000f720: c2 24 60 3c st %g1, [ %l1 + 0x3c ]
lfat_fd->links_num = 1;
4000f724: b4 10 20 01 mov 1, %i2
old_last = tail->previous;
4000f728: c2 06 e0 08 ld [ %i3 + 8 ], %g1
4000f72c: f4 24 60 08 st %i2, [ %l1 + 8 ]
lfat_fd->dir_pos = *dir_pos;
4000f730: f8 24 60 20 st %i4, [ %l1 + 0x20 ]
4000f734: c8 24 60 24 st %g4, [ %l1 + 0x24 ]
4000f738: c6 24 60 28 st %g3, [ %l1 + 0x28 ]
4000f73c: c4 24 60 2c st %g2, [ %l1 + 0x2c ]
lfat_fd->ino = key;
4000f740: fa 24 60 0c st %i5, [ %l1 + 0xc ]
the_node->next = tail;
4000f744: e0 24 40 00 st %l0, [ %l1 ]
tail->previous = the_node;
4000f748: e2 26 e0 08 st %l1, [ %i3 + 8 ]
old_last->next = the_node;
4000f74c: e2 20 40 00 st %l1, [ %g1 ]
the_node->previous = old_last;
4000f750: c2 24 60 04 st %g1, [ %l1 + 4 ]
return RC_OK;
4000f754: 81 c7 e0 08 ret
4000f758: 91 e8 20 00 restore %g0, 0, %o0
(*fat_fd) = lfat_fd;
4000f75c: c8 26 80 00 st %g4, [ %i2 ]
lfat_fd->links_num++;
4000f760: 82 00 60 01 inc %g1
4000f764: c2 21 20 08 st %g1, [ %g4 + 8 ]
}
4000f768: 81 c7 e0 08 ret
4000f76c: 91 e8 20 00 restore %g0, 0, %o0
if ( ((key2) == 0) || ((key2) == ffd->ino) )
4000f770: 02 80 00 07 be 4000f78c <fat_file_open+0x248> <== NOT EXECUTED
4000f774: 92 10 20 50 mov 0x50, %o1 <== NOT EXECUTED
4000f778: c2 01 20 0c ld [ %g4 + 0xc ], %g1 <== NOT EXECUTED
4000f77c: 80 a7 40 01 cmp %i5, %g1 <== NOT EXECUTED
4000f780: 32 bf ff d6 bne,a 4000f6d8 <fat_file_open+0x194> <== NOT EXECUTED
4000f784: c8 01 00 00 ld [ %g4 ], %g4 <== NOT EXECUTED
lfat_fd = (*fat_fd) = (fat_file_fd_t*)calloc(1, sizeof(fat_file_fd_t));
4000f788: 92 10 20 50 mov 0x50, %o1 <== NOT EXECUTED
4000f78c: 7f ff f5 7b call 4000cd78 <calloc> <== NOT EXECUTED
4000f790: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED
4000f794: d0 26 80 00 st %o0, [ %i2 ] <== NOT EXECUTED
if ( lfat_fd == NULL )
4000f798: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000f79c: 02 80 00 22 be 4000f824 <fat_file_open+0x2e0> <== NOT EXECUTED
4000f7a0: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED
lfat_fd->flags &= ~FAT_FILE_REMOVED;
4000f7a4: c2 0c 60 30 ldub [ %l1 + 0x30 ], %g1 <== NOT EXECUTED
4000f7a8: 82 08 7f fe and %g1, -2, %g1 <== NOT EXECUTED
lfat_fd->dir_pos = *dir_pos;
4000f7ac: fa 06 40 00 ld [ %i1 ], %i5 <== NOT EXECUTED
lfat_fd->flags &= ~FAT_FILE_REMOVED;
4000f7b0: c2 2c 60 30 stb %g1, [ %l1 + 0x30 ] <== NOT EXECUTED
lfat_fd->links_num = 1;
4000f7b4: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
lfat_fd->dir_pos = *dir_pos;
4000f7b8: c8 06 60 04 ld [ %i1 + 4 ], %g4 <== NOT EXECUTED
4000f7bc: c6 06 60 08 ld [ %i1 + 8 ], %g3 <== NOT EXECUTED
4000f7c0: c4 06 60 0c ld [ %i1 + 0xc ], %g2 <== NOT EXECUTED
lfat_fd->links_num = 1;
4000f7c4: c2 24 60 08 st %g1, [ %l1 + 8 ] <== NOT EXECUTED
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
4000f7c8: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
lfat_fd->dir_pos = *dir_pos;
4000f7cc: fa 24 60 20 st %i5, [ %l1 + 0x20 ] <== NOT EXECUTED
lfat_fd->ino = fat_get_unique_ino(fs_info);
4000f7d0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
4000f7d4: c2 24 60 3c st %g1, [ %l1 + 0x3c ] <== NOT EXECUTED
lfat_fd->dir_pos = *dir_pos;
4000f7d8: c8 24 60 24 st %g4, [ %l1 + 0x24 ] <== NOT EXECUTED
4000f7dc: c6 24 60 28 st %g3, [ %l1 + 0x28 ] <== NOT EXECUTED
lfat_fd->ino = fat_get_unique_ino(fs_info);
4000f7e0: 7f ff fd 22 call 4000ec68 <fat_get_unique_ino> <== NOT EXECUTED
4000f7e4: c4 24 60 2c st %g2, [ %l1 + 0x2c ] <== NOT EXECUTED
if ( lfat_fd->ino == 0 )
4000f7e8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000f7ec: 02 80 00 0c be 4000f81c <fat_file_open+0x2d8> <== NOT EXECUTED
4000f7f0: d0 24 60 0c st %o0, [ %l1 + 0xc ] <== NOT EXECUTED
rtems_chain_append_unprotected((hash) + ((key1) % FAT_HASH_MODULE), &(el)->link);
4000f7f4: f6 06 20 80 ld [ %i0 + 0x80 ], %i3 <== NOT EXECUTED
4000f7f8: b6 06 c0 1c add %i3, %i4, %i3 <== NOT EXECUTED
old_last = tail->previous;
4000f7fc: c2 06 e0 08 ld [ %i3 + 8 ], %g1 <== NOT EXECUTED
return &the_chain->Tail.Node;
4000f800: a0 06 e0 04 add %i3, 4, %l0 <== NOT EXECUTED
the_node->next = tail;
4000f804: e0 24 40 00 st %l0, [ %l1 ] <== NOT EXECUTED
tail->previous = the_node;
4000f808: e2 26 e0 08 st %l1, [ %i3 + 8 ] <== NOT EXECUTED
old_last->next = the_node;
4000f80c: e2 20 40 00 st %l1, [ %g1 ] <== NOT EXECUTED
the_node->previous = old_last;
4000f810: c2 24 60 04 st %g1, [ %l1 + 4 ] <== NOT EXECUTED
return RC_OK;
4000f814: 81 c7 e0 08 ret <== NOT EXECUTED
4000f818: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
free((*fat_fd));
4000f81c: 7f ff cb 41 call 40002520 <free> <== NOT EXECUTED
4000f820: d0 06 80 00 ld [ %i2 ], %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
4000f824: 40 00 30 a2 call 4001baac <__errno> <== NOT EXECUTED
4000f828: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4000f82c: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
4000f830: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4000f834: 81 c7 e0 08 ret <== NOT EXECUTED
4000f838: 81 e8 00 00 restore <== NOT EXECUTED
4000f8d8 <fat_file_read>:
{
4000f8d8: 9d e3 bf 98 save %sp, -104, %sp
uint32_t cur_cln = 0;
4000f8dc: c0 27 bf fc clr [ %fp + -4 ]
{
4000f8e0: ba 10 00 18 mov %i0, %i5
if (count == 0)
4000f8e4: 80 a6 e0 00 cmp %i3, 0
4000f8e8: 02 80 00 69 be 4000fa8c <fat_file_read+0x1b4> <== NEVER TAKEN
4000f8ec: 90 10 20 00 clr %o0
if ( start >= fat_fd->fat_file_size )
4000f8f0: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
4000f8f4: 80 a0 40 1a cmp %g1, %i2
4000f8f8: 08 80 00 65 bleu 4000fa8c <fat_file_read+0x1b4>
4000f8fc: 80 a0 40 1b cmp %g1, %i3
if ((count > fat_fd->fat_file_size) ||
4000f900: 2a 80 00 06 bcs,a 4000f918 <fat_file_read+0x40>
4000f904: b6 20 40 1a sub %g1, %i2, %i3
(start > fat_fd->fat_file_size - count))
4000f908: 84 20 40 1b sub %g1, %i3, %g2
if ((count > fat_fd->fat_file_size) ||
4000f90c: 80 a0 80 1a cmp %g2, %i2
4000f910: 2a 80 00 02 bcs,a 4000f918 <fat_file_read+0x40>
4000f914: b6 20 40 1a sub %g1, %i2, %i3
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
4000f918: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
4000f91c: 80 a0 60 01 cmp %g1, 1
4000f920: 32 80 00 07 bne,a 4000f93c <fat_file_read+0x64>
4000f924: e2 0f 60 0c ldub [ %i5 + 0xc ], %l1
4000f928: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
4000f92c: 80 a0 60 00 cmp %g1, 0
4000f930: 22 80 00 3d be,a 4000fa24 <fat_file_read+0x14c> <== ALWAYS TAKEN
4000f934: c2 0f 60 16 ldub [ %i5 + 0x16 ], %g1
cl_start = start >> fs_info->vol.bpc_log2;
4000f938: e2 0f 60 0c ldub [ %i5 + 0xc ], %l1 <== NOT EXECUTED
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
4000f93c: f0 07 60 08 ld [ %i5 + 8 ], %i0
cl_start = start >> fs_info->vol.bpc_log2;
4000f940: a3 36 80 11 srl %i2, %l1, %l1
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
4000f944: 96 07 bf fc add %fp, -4, %o3
4000f948: 94 10 00 11 mov %l1, %o2
4000f94c: 92 10 00 19 mov %i1, %o1
4000f950: 7f ff fe d6 call 4000f4a8 <fat_file_lseek>
4000f954: 90 10 00 1d mov %i5, %o0
if (rc != RC_OK)
4000f958: 90 92 60 00 orcc %o1, 0, %o0
4000f95c: 12 80 00 4c bne 4000fa8c <fat_file_read+0x1b4> <== NEVER TAKEN
4000f960: 82 06 3f ff add %i0, -1, %g1
uint32_t cmpltd = 0;
4000f964: b0 10 20 00 clr %i0
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
4000f968: b4 08 40 1a and %g1, %i2, %i2
4000f96c: 10 80 00 1f b 4000f9e8 <fat_file_read+0x110>
4000f970: 84 10 00 1a mov %i2, %g2
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
4000f974: d2 07 60 3c ld [ %i5 + 0x3c ], %o1
4000f978: 82 00 7f fe add %g1, -2, %g1
4000f97c: 83 28 40 03 sll %g1, %g3, %g1
4000f980: 82 00 40 09 add %g1, %o1, %g1
byte = ofs & (fs_info->vol.bps - 1);
4000f984: d4 17 40 00 lduh [ %i5 ], %o2
sec += (ofs >> fs_info->vol.sec_log2);
4000f988: d2 0f 60 02 ldub [ %i5 + 2 ], %o1
4000f98c: 93 30 80 09 srl %g2, %o1, %o1
ret = _fat_block_read(fs_info, sec, byte, c, buf + cmpltd);
4000f990: 98 07 00 18 add %i4, %i0, %o4
4000f994: 92 02 40 01 add %o1, %g1, %o1
byte = ofs & (fs_info->vol.bps - 1);
4000f998: 94 02 bf ff add %o2, -1, %o2
ret = _fat_block_read(fs_info, sec, byte, c, buf + cmpltd);
4000f99c: 96 10 00 10 mov %l0, %o3
4000f9a0: 94 0a 80 02 and %o2, %g2, %o2
4000f9a4: 7f ff f8 cb call 4000dcd0 <_fat_block_read>
4000f9a8: 90 10 00 1d mov %i5, %o0
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
4000f9ac: 94 07 bf fc add %fp, -4, %o2
ret = _fat_block_read(fs_info, sec, byte, c, buf + cmpltd);
4000f9b0: 82 10 00 08 mov %o0, %g1
if ( ret < 0 )
4000f9b4: 80 a0 60 00 cmp %g1, 0
4000f9b8: 06 80 00 34 bl 4000fa88 <fat_file_read+0x1b0> <== NEVER TAKEN
4000f9bc: 90 10 00 1d mov %i5, %o0
save_cln = cur_cln;
4000f9c0: e4 07 bf fc ld [ %fp + -4 ], %l2
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
4000f9c4: 92 10 00 12 mov %l2, %o1
4000f9c8: 7f ff fc ed call 4000ed7c <fat_get_fat_cluster>
4000f9cc: b6 26 c0 10 sub %i3, %l0, %i3
if ( rc != RC_OK )
4000f9d0: 80 a2 20 00 cmp %o0, 0
4000f9d4: 12 80 00 2e bne 4000fa8c <fat_file_read+0x1b4> <== NEVER TAKEN
4000f9d8: b0 06 00 10 add %i0, %l0, %i0
while (count > 0)
4000f9dc: 80 a6 e0 00 cmp %i3, 0
4000f9e0: 02 80 00 2d be 4000fa94 <fat_file_read+0x1bc>
4000f9e4: 84 10 20 00 clr %g2
c = MIN(count, (fs_info->vol.bpc - ofs));
4000f9e8: e0 07 60 08 ld [ %i5 + 8 ], %l0
4000f9ec: a0 24 00 02 sub %l0, %g2, %l0
4000f9f0: 80 a4 00 1b cmp %l0, %i3
4000f9f4: 38 80 00 02 bgu,a 4000f9fc <fat_file_read+0x124>
4000f9f8: a0 10 00 1b mov %i3, %l0
sec = fat_cluster_num_to_sector_num(fs_info, cur_cln);
4000f9fc: c2 07 bf fc ld [ %fp + -4 ], %g1
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
4000fa00: 80 a0 60 00 cmp %g1, 0
4000fa04: 32 bf ff dc bne,a 4000f974 <fat_file_read+0x9c> <== ALWAYS TAKEN
4000fa08: c6 0f 60 05 ldub [ %i5 + 5 ], %g3
4000fa0c: c6 0f 60 16 ldub [ %i5 + 0x16 ], %g3 <== NOT EXECUTED
4000fa10: 80 88 e0 03 btst 3, %g3 <== NOT EXECUTED
4000fa14: 22 bf ff d8 be,a 4000f974 <fat_file_read+0x9c> <== NOT EXECUTED
4000fa18: c6 0f 60 05 ldub [ %i5 + 5 ], %g3 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
4000fa1c: 10 bf ff da b 4000f984 <fat_file_read+0xac> <== NOT EXECUTED
4000fa20: c2 07 60 28 ld [ %i5 + 0x28 ], %g1 <== NOT EXECUTED
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
4000fa24: 80 88 60 03 btst 3, %g1
4000fa28: 22 bf ff c5 be,a 4000f93c <fat_file_read+0x64>
4000fa2c: e2 0f 60 0c ldub [ %i5 + 0xc ], %l1
sec = fat_cluster_num_to_sector_num(fs_info, fat_fd->cln);
4000fa30: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
4000fa34: 80 a0 60 00 cmp %g1, 0
4000fa38: 22 80 00 07 be,a 4000fa54 <fat_file_read+0x17c> <== ALWAYS TAKEN
4000fa3c: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
4000fa40: c6 0f 60 05 ldub [ %i5 + 5 ], %g3 <== NOT EXECUTED
4000fa44: c4 07 60 3c ld [ %i5 + 0x3c ], %g2 <== NOT EXECUTED
4000fa48: 82 00 7f fe add %g1, -2, %g1 <== NOT EXECUTED
4000fa4c: 83 28 40 03 sll %g1, %g3, %g1 <== NOT EXECUTED
4000fa50: 82 00 40 02 add %g1, %g2, %g1 <== NOT EXECUTED
byte = start & (fs_info->vol.bps - 1);
4000fa54: d4 17 40 00 lduh [ %i5 ], %o2
sec += (start >> fs_info->vol.sec_log2);
4000fa58: d2 0f 60 02 ldub [ %i5 + 2 ], %o1
byte = start & (fs_info->vol.bps - 1);
4000fa5c: 94 02 bf ff add %o2, -1, %o2
sec += (start >> fs_info->vol.sec_log2);
4000fa60: 93 36 80 09 srl %i2, %o1, %o1
ret = _fat_block_read(fs_info, sec, byte, count, buf);
4000fa64: 98 10 00 1c mov %i4, %o4
4000fa68: 96 10 00 1b mov %i3, %o3
4000fa6c: 94 0a 80 1a and %o2, %i2, %o2
4000fa70: 92 02 40 01 add %o1, %g1, %o1
4000fa74: 7f ff f8 97 call 4000dcd0 <_fat_block_read>
4000fa78: 90 10 00 1d mov %i5, %o0
if ( ret < 0 )
4000fa7c: 80 a2 20 00 cmp %o0, 0
4000fa80: 16 80 00 03 bge 4000fa8c <fat_file_read+0x1b4> <== ALWAYS TAKEN
4000fa84: 01 00 00 00 nop
return -1;
4000fa88: 90 10 3f ff mov -1, %o0 ! ffffffff <RAM_END+0xbfbfffff> <== NOT EXECUTED
}
4000fa8c: 81 c7 e0 08 ret
4000fa90: 91 e8 00 08 restore %g0, %o0, %o0
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
4000fa94: c2 0f 60 0c ldub [ %i5 + 0xc ], %g1
4000fa98: b4 06 bf ff add %i2, -1, %i2
fat_fd->map.disk_cln = save_cln;
4000fa9c: e4 26 60 38 st %l2, [ %i1 + 0x38 ]
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
4000faa0: b4 06 80 18 add %i2, %i0, %i2
return cmpltd;
4000faa4: 90 10 00 18 mov %i0, %o0
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
4000faa8: b5 36 80 01 srl %i2, %g1, %i2
fat_fd->map.file_cln = cl_start +
4000faac: a2 06 80 11 add %i2, %l1, %l1
return cmpltd;
4000fab0: 10 bf ff f7 b 4000fa8c <fat_file_read+0x1b4>
4000fab4: e2 26 60 34 st %l1, [ %i1 + 0x34 ]
40010264 <fat_file_size>:
{
40010264: 9d e3 bf 98 save %sp, -104, %sp
uint32_t cur_cln = fat_fd->cln;
40010268: f8 06 60 1c ld [ %i1 + 0x1c ], %i4
4001026c: f8 27 bf fc st %i4, [ %fp + -4 ]
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
40010270: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
40010274: 80 a0 60 01 cmp %g1, 1
40010278: 22 80 00 22 be,a 40010300 <fat_file_size+0x9c>
4001027c: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
fat_fd->fat_file_size = 0;
40010280: c0 26 60 18 clr [ %i1 + 0x18 ]
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
40010284: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
40010288: c4 06 20 1c ld [ %i0 + 0x1c ], %g2
4001028c: 82 0f 00 01 and %i4, %g1, %g1
40010290: 80 a0 80 01 cmp %g2, %g1
40010294: 18 80 00 0f bgu 400102d0 <fat_file_size+0x6c> <== ALWAYS TAKEN
40010298: 92 10 00 1c mov %i4, %o1
uint32_t save_cln = 0;
4001029c: 10 80 00 15 b 400102f0 <fat_file_size+0x8c> <== NOT EXECUTED
400102a0: b8 10 20 00 clr %i4 <== NOT EXECUTED
fat_fd->fat_file_size += fs_info->vol.bpc;
400102a4: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
400102a8: 82 00 40 02 add %g1, %g2, %g1
400102ac: c2 26 60 18 st %g1, [ %i1 + 0x18 ]
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
400102b0: c4 07 bf fc ld [ %fp + -4 ], %g2
400102b4: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
400102b8: c6 06 20 1c ld [ %i0 + 0x1c ], %g3
400102bc: 82 08 80 01 and %g2, %g1, %g1
400102c0: 80 a0 40 03 cmp %g1, %g3
400102c4: 1a 80 00 0b bcc 400102f0 <fat_file_size+0x8c>
400102c8: 92 10 00 02 mov %g2, %o1
400102cc: b8 10 00 02 mov %g2, %i4
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
400102d0: 94 07 bf fc add %fp, -4, %o2
400102d4: 7f ff fa aa call 4000ed7c <fat_get_fat_cluster>
400102d8: 90 10 00 18 mov %i0, %o0
if ( rc != RC_OK )
400102dc: 80 a2 20 00 cmp %o0, 0
400102e0: 22 bf ff f1 be,a 400102a4 <fat_file_size+0x40> <== ALWAYS TAKEN
400102e4: c4 06 20 08 ld [ %i0 + 8 ], %g2
}
400102e8: 81 c7 e0 08 ret
400102ec: 91 e8 00 08 restore %g0, %o0, %o0
return rc;
400102f0: 90 10 20 00 clr %o0
fat_fd->map.last_cln = save_cln;
400102f4: f8 26 60 3c st %i4, [ %i1 + 0x3c ]
}
400102f8: 81 c7 e0 08 ret
400102fc: 91 e8 00 08 restore %g0, %o0, %o0
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
40010300: 80 a0 60 00 cmp %g1, 0
40010304: 32 bf ff e0 bne,a 40010284 <fat_file_size+0x20> <== NEVER TAKEN
40010308: c0 26 60 18 clr [ %i1 + 0x18 ] <== NOT EXECUTED
4001030c: c2 0e 20 16 ldub [ %i0 + 0x16 ], %g1
40010310: 80 88 60 03 btst 3, %g1
40010314: 22 bf ff dc be,a 40010284 <fat_file_size+0x20>
40010318: c0 26 60 18 clr [ %i1 + 0x18 ]
fat_fd->fat_file_size = fs_info->vol.rdir_size;
4001031c: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
40010320: c2 26 60 18 st %g1, [ %i1 + 0x18 ]
return rc;
40010324: 10 bf ff f1 b 400102e8 <fat_file_size+0x84>
40010328: 90 10 20 00 clr %o0
4000fab8 <fat_file_truncate>:
{
4000fab8: 9d e3 bf 98 save %sp, -104, %sp
uint32_t new_last_cln = FAT_UNDEFINED_VALUE;
4000fabc: 82 10 3f ff mov -1, %g1
uint32_t cur_cln = 0;
4000fac0: c0 27 bf f8 clr [ %fp + -8 ]
uint32_t new_last_cln = FAT_UNDEFINED_VALUE;
4000fac4: c2 27 bf fc st %g1, [ %fp + -4 ]
if ( new_length >= fat_fd->fat_file_size )
4000fac8: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
4000facc: 80 a0 40 1a cmp %g1, %i2
4000fad0: 08 80 00 26 bleu 4000fb68 <fat_file_truncate+0xb0>
4000fad4: 80 a0 60 00 cmp %g1, 0
assert(fat_fd->fat_file_size);
4000fad8: 02 80 00 32 be 4000fba0 <fat_file_truncate+0xe8> <== NEVER TAKEN
4000fadc: 17 10 00 9b sethi %hi(0x40026c00), %o3
cl_start = (new_length + fs_info->vol.bpc - 1) >> fs_info->vol.bpc_log2;
4000fae0: c4 0e 20 0c ldub [ %i0 + 0xc ], %g2
4000fae4: c6 06 20 08 ld [ %i0 + 8 ], %g3
4000fae8: b4 06 80 03 add %i2, %g3, %i2
4000faec: b4 06 bf ff add %i2, -1, %i2
4000faf0: b5 36 80 02 srl %i2, %g2, %i2
if ((cl_start << fs_info->vol.bpc_log2) >= fat_fd->fat_file_size)
4000faf4: 85 2e 80 02 sll %i2, %g2, %g2
4000faf8: 80 a0 40 02 cmp %g1, %g2
4000fafc: 08 80 00 1b bleu 4000fb68 <fat_file_truncate+0xb0>
4000fb00: 80 a6 a0 00 cmp %i2, 0
if (cl_start != 0)
4000fb04: 02 80 00 0a be 4000fb2c <fat_file_truncate+0x74>
4000fb08: 96 07 bf f8 add %fp, -8, %o3
rc = fat_file_lseek(fs_info, fat_fd, cl_start - 1, &new_last_cln);
4000fb0c: 96 07 bf fc add %fp, -4, %o3
4000fb10: 94 06 bf ff add %i2, -1, %o2
4000fb14: 92 10 00 19 mov %i1, %o1
4000fb18: 7f ff fe 64 call 4000f4a8 <fat_file_lseek>
4000fb1c: 90 10 00 18 mov %i0, %o0
if (rc != RC_OK)
4000fb20: 80 a2 60 00 cmp %o1, 0
4000fb24: 12 80 00 12 bne 4000fb6c <fat_file_truncate+0xb4> <== NEVER TAKEN
4000fb28: 96 07 bf f8 add %fp, -8, %o3
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
4000fb2c: 94 10 00 1a mov %i2, %o2
4000fb30: 92 10 00 19 mov %i1, %o1
4000fb34: 7f ff fe 5d call 4000f4a8 <fat_file_lseek>
4000fb38: 90 10 00 18 mov %i0, %o0
if (rc != RC_OK)
4000fb3c: 80 a2 60 00 cmp %o1, 0
4000fb40: 12 80 00 0b bne 4000fb6c <fat_file_truncate+0xb4> <== NEVER TAKEN
4000fb44: 01 00 00 00 nop
rc = fat_free_fat_clusters_chain(fs_info, cur_cln);
4000fb48: d2 07 bf f8 ld [ %fp + -8 ], %o1
4000fb4c: 7f ff fd aa call 4000f1f4 <fat_free_fat_clusters_chain>
4000fb50: 90 10 00 18 mov %i0, %o0
if (rc != RC_OK)
4000fb54: 92 92 20 00 orcc %o0, 0, %o1
4000fb58: 12 80 00 05 bne 4000fb6c <fat_file_truncate+0xb4> <== NEVER TAKEN
4000fb5c: 80 a6 a0 00 cmp %i2, 0
if (cl_start != 0)
4000fb60: 12 80 00 05 bne 4000fb74 <fat_file_truncate+0xbc>
4000fb64: d2 07 bf fc ld [ %fp + -4 ], %o1
return rc;
4000fb68: 92 10 20 00 clr %o1
}
4000fb6c: 81 c7 e0 08 ret
4000fb70: 91 e8 00 09 restore %g0, %o1, %o0
rc = fat_set_fat_cluster(fs_info, new_last_cln, FAT_GENFAT_EOC);
4000fb74: 94 10 3f ff mov -1, %o2
4000fb78: 7f ff fc f6 call 4000ef50 <fat_set_fat_cluster>
4000fb7c: 90 10 00 18 mov %i0, %o0
if ( rc != RC_OK )
4000fb80: 92 92 20 00 orcc %o0, 0, %o1
4000fb84: 12 bf ff fa bne 4000fb6c <fat_file_truncate+0xb4> <== NEVER TAKEN
4000fb88: c2 07 bf fc ld [ %fp + -4 ], %g1
fat_fd->map.file_cln = cl_start - 1;
4000fb8c: b4 06 bf ff add %i2, -1, %i2
fat_fd->map.disk_cln = new_last_cln;
4000fb90: c2 26 60 38 st %g1, [ %i1 + 0x38 ]
fat_fd->map.file_cln = cl_start - 1;
4000fb94: f4 26 60 34 st %i2, [ %i1 + 0x34 ]
fat_fd->map.last_cln = new_last_cln;
4000fb98: 10 bf ff f5 b 4000fb6c <fat_file_truncate+0xb4>
4000fb9c: c2 26 60 3c st %g1, [ %i1 + 0x3c ]
assert(fat_fd->fat_file_size);
4000fba0: 15 10 00 9b sethi %hi(0x40026c00), %o2 <== NOT EXECUTED
4000fba4: 11 10 00 9b sethi %hi(0x40026c00), %o0 <== NOT EXECUTED
4000fba8: 96 12 e2 58 or %o3, 0x258, %o3 <== NOT EXECUTED
4000fbac: 94 12 a2 a0 or %o2, 0x2a0, %o2 <== NOT EXECUTED
4000fbb0: 92 10 22 e4 mov 0x2e4, %o1 <== NOT EXECUTED
4000fbb4: 40 00 1e 1c call 40017424 <__assert_func> <== NOT EXECUTED
4000fbb8: 90 12 22 70 or %o0, 0x270, %o0 <== NOT EXECUTED
4000fbbc: 01 00 00 00 nop <== NOT EXECUTED
4000f854 <fat_file_update>:
{
4000f854: 9d e3 bf a0 save %sp, -96, %sp
return (fat_fd->flags & FAT_FILE_REMOVED) != 0;
4000f858: c2 0e 60 30 ldub [ %i1 + 0x30 ], %g1
if (!FAT_FILE_IS_REMOVED(fat_fd) &&
4000f85c: 80 88 60 01 btst 1, %g1
4000f860: 12 80 00 1c bne 4000f8d0 <fat_file_update+0x7c>
4000f864: ba 10 20 00 clr %i5
4000f868: 80 88 60 02 btst 2, %g1
4000f86c: 02 80 00 19 be 4000f8d0 <fat_file_update+0x7c>
4000f870: 01 00 00 00 nop
FAT_FILE_HAS_META_DATA_CHANGED(fat_fd) &&
4000f874: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
4000f878: 80 a0 60 01 cmp %g1, 1
4000f87c: 12 80 00 06 bne 4000f894 <fat_file_update+0x40>
4000f880: 92 10 00 19 mov %i1, %o1
!FAT_FD_OF_ROOT_DIR(fat_fd))
4000f884: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
4000f888: 80 a0 60 00 cmp %g1, 0
4000f88c: 02 80 00 11 be 4000f8d0 <fat_file_update+0x7c> <== ALWAYS TAKEN
4000f890: 01 00 00 00 nop
rc = fat_file_write_first_cluster_num(fs_info, fat_fd);
4000f894: 40 00 06 04 call 400110a4 <fat_file_write_first_cluster_num>
4000f898: 90 10 00 18 mov %i0, %o0
rc = fat_file_write_file_size(fs_info, fat_fd);
4000f89c: 92 10 00 19 mov %i1, %o1
rc = fat_file_write_first_cluster_num(fs_info, fat_fd);
4000f8a0: ba 10 00 08 mov %o0, %i5
rc = fat_file_write_file_size(fs_info, fat_fd);
4000f8a4: 40 00 06 31 call 40011168 <fat_file_write_file_size>
4000f8a8: 90 10 00 18 mov %i0, %o0
if (rc != RC_OK)
4000f8ac: 80 a2 20 00 cmp %o0, 0
4000f8b0: 32 80 00 02 bne,a 4000f8b8 <fat_file_update+0x64> <== NEVER TAKEN
4000f8b4: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
rc = fat_file_write_time_and_date(fs_info, fat_fd);
4000f8b8: 92 10 00 19 mov %i1, %o1
4000f8bc: 40 00 05 95 call 40010f10 <fat_file_write_time_and_date>
4000f8c0: 90 10 00 18 mov %i0, %o0
if (rc != RC_OK)
4000f8c4: 80 a2 20 00 cmp %o0, 0
4000f8c8: 32 80 00 02 bne,a 4000f8d0 <fat_file_update+0x7c> <== NEVER TAKEN
4000f8cc: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
}
4000f8d0: 81 c7 e0 08 ret
4000f8d4: 91 e8 00 1d restore %g0, %i5, %o0
4000ffc8 <fat_file_write>:
{
4000ffc8: 9d e3 bf 98 save %sp, -104, %sp
uint32_t c = 0;
4000ffcc: c0 27 bf f8 clr [ %fp + -8 ]
if ( count == 0 )
4000ffd0: 80 a6 e0 00 cmp %i3, 0
4000ffd4: 02 80 00 45 be 400100e8 <fat_file_write+0x120> <== NEVER TAKEN
4000ffd8: 90 10 20 00 clr %o0
if (start >= fat_fd->size_limit)
4000ffdc: fa 06 60 14 ld [ %i1 + 0x14 ], %i5
4000ffe0: 80 a7 40 1a cmp %i5, %i2
4000ffe4: 08 80 00 83 bleu 400101f0 <fat_file_write+0x228> <== NEVER TAKEN
4000ffe8: ba 27 40 1a sub %i5, %i2, %i5
if (count > fat_fd->size_limit - start)
4000ffec: 80 a7 40 1b cmp %i5, %i3
bool zero_fill = start > fat_fd->fat_file_size;
4000fff0: 18 80 00 40 bgu 400100f0 <fat_file_write+0x128> <== ALWAYS TAKEN
4000fff4: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
4000fff8: 80 a0 40 1a cmp %g1, %i2 <== NOT EXECUTED
rc = fat_file_extend(fs_info, fat_fd, zero_fill, start + count, &c);
4000fffc: b6 06 80 1d add %i2, %i5, %i3 <== NOT EXECUTED
40010000: 94 40 20 00 addx %g0, 0, %o2 <== NOT EXECUTED
40010004: 98 07 bf f8 add %fp, -8, %o4 <== NOT EXECUTED
40010008: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
4001000c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40010010: 7f ff ff 56 call 4000fd68 <fat_file_extend> <== NOT EXECUTED
40010014: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
if (RC_OK == rc)
40010018: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4001001c: 12 80 00 33 bne 400100e8 <fat_file_write+0x120> <== NOT EXECUTED
40010020: c2 07 bf f8 ld [ %fp + -8 ], %g1 <== NOT EXECUTED
if (c != (start + count))
40010024: 80 a6 c0 01 cmp %i3, %g1 <== NOT EXECUTED
40010028: 32 80 00 02 bne,a 40010030 <fat_file_write+0x68>
4001002c: ba 20 40 1a sub %g1, %i2, %i5
cln += (start >> fs_info->vol.bpc_log2);
40010030: f6 0e 20 0c ldub [ %i0 + 0xc ], %i3
return (FAT_FD_OF_ROOT_DIR(fat_fd)) && (volume_type & (FAT_FAT12 | FAT_FAT16));
40010034: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
40010038: 80 a0 60 01 cmp %g1, 1
4001003c: 02 80 00 49 be 40010160 <fat_file_write+0x198>
40010040: a1 36 80 1b srl %i2, %i3, %l0
uint32_t cur_cln = 0;
40010044: c0 27 bf fc clr [ %fp + -4 ]
rc = fat_file_lseek(fs_info, fat_fd, start_cln, &cur_cln);
40010048: 94 10 00 10 mov %l0, %o2
4001004c: 96 07 bf fc add %fp, -4, %o3
40010050: 92 10 00 19 mov %i1, %o1
40010054: 7f ff fd 15 call 4000f4a8 <fat_file_lseek>
40010058: 90 10 00 18 mov %i0, %o0
if (RC_OK == rc)
4001005c: 90 92 60 00 orcc %o1, 0, %o0
40010060: 12 80 00 20 bne 400100e0 <fat_file_write+0x118> <== NEVER TAKEN
40010064: 80 a2 20 00 cmp %o0, 0
uint32_t ofs_cln = start - (start_cln << fs_info->vol.bpc_log2);
40010068: 97 2c 00 1b sll %l0, %i3, %o3
uint32_t save_cln = 0; /* FIXME: This might be incorrect, cf. below */
4001006c: a2 10 20 00 clr %l1
uint32_t ofs_cln = start - (start_cln << fs_info->vol.bpc_log2);
40010070: 94 26 80 0b sub %i2, %o3, %o2
uint32_t cmpltd = 0;
40010074: b6 10 20 00 clr %i3
while ( (RC_OK == rc)
40010078: 80 a7 60 00 cmp %i5, 0
4001007c: 02 80 00 57 be 400101d8 <fat_file_write+0x210> <== NEVER TAKEN
40010080: b4 02 bf ff add %o2, -1, %i2
c = MIN(bytes_to_write, (fs_info->vol.bpc - ofs_cln));
40010084: d6 06 20 08 ld [ %i0 + 8 ], %o3
40010088: 96 22 c0 0a sub %o3, %o2, %o3
ret = fat_cluster_write(fs_info,
4001008c: 90 10 00 18 mov %i0, %o0
c = MIN(bytes_to_write, (fs_info->vol.bpc - ofs_cln));
40010090: 80 a2 c0 1d cmp %o3, %i5
40010094: 08 80 00 03 bleu 400100a0 <fat_file_write+0xd8>
40010098: 98 07 00 1b add %i4, %i3, %o4
4001009c: 96 10 00 1d mov %i5, %o3
ret = fat_cluster_write(fs_info,
400100a0: 7f ff f7 bf call 4000df9c <fat_cluster_write>
400100a4: d2 07 bf fc ld [ %fp + -4 ], %o1
if (0 > ret)
400100a8: 80 a2 20 00 cmp %o0, 0
400100ac: 06 80 00 43 bl 400101b8 <fat_file_write+0x1f0> <== NEVER TAKEN
400100b0: ba a7 40 08 subcc %i5, %o0, %i5
save_cln = cur_cln;
400100b4: e2 07 bf fc ld [ %fp + -4 ], %l1
if (0 < bytes_to_write)
400100b8: 12 80 00 1c bne 40010128 <fat_file_write+0x160>
400100bc: b6 06 c0 08 add %i3, %o0, %i3
((ofs_cln_save + cmpltd - 1) >> fs_info->vol.bpc_log2);
400100c0: c2 0e 20 0c ldub [ %i0 + 0xc ], %g1
400100c4: b4 06 c0 1a add %i3, %i2, %i2
fat_fd->map.disk_cln = save_cln;
400100c8: e2 26 60 38 st %l1, [ %i1 + 0x38 ]
((ofs_cln_save + cmpltd - 1) >> fs_info->vol.bpc_log2);
400100cc: b5 36 80 01 srl %i2, %g1, %i2
fat_fd->map.file_cln = start_cln +
400100d0: a0 06 80 10 add %i2, %l0, %l0
400100d4: e0 26 60 34 st %l0, [ %i1 + 0x34 ]
return cmpltd;
400100d8: 90 10 00 1b mov %i3, %o0
if (0 > ret)
400100dc: 80 a2 20 00 cmp %o0, 0
400100e0: 26 80 00 02 bl,a 400100e8 <fat_file_write+0x120> <== NEVER TAKEN
400100e4: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
}
400100e8: 81 c7 e0 08 ret
400100ec: 91 e8 00 08 restore %g0, %o0, %o0
bool zero_fill = start > fat_fd->fat_file_size;
400100f0: 80 a0 40 1a cmp %g1, %i2
400100f4: ba 10 00 1b mov %i3, %i5
rc = fat_file_extend(fs_info, fat_fd, zero_fill, start + count, &c);
400100f8: 94 40 20 00 addx %g0, 0, %o2
400100fc: b6 06 80 1d add %i2, %i5, %i3
40010100: 98 07 bf f8 add %fp, -8, %o4
40010104: 96 10 00 1b mov %i3, %o3
40010108: 92 10 00 19 mov %i1, %o1
4001010c: 7f ff ff 17 call 4000fd68 <fat_file_extend>
40010110: 90 10 00 18 mov %i0, %o0
if (RC_OK == rc)
40010114: 80 a2 20 00 cmp %o0, 0
40010118: 12 bf ff f4 bne 400100e8 <fat_file_write+0x120>
4001011c: c2 07 bf f8 ld [ %fp + -8 ], %g1
if (c != (start + count))
40010120: 10 bf ff c2 b 40010028 <fat_file_write+0x60>
40010124: 80 a6 c0 01 cmp %i3, %g1
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
40010128: 94 07 bf fc add %fp, -4, %o2
4001012c: 92 10 00 11 mov %l1, %o1
40010130: 7f ff fb 13 call 4000ed7c <fat_get_fat_cluster>
40010134: 90 10 00 18 mov %i0, %o0
while ( (RC_OK == rc)
40010138: 80 a2 20 00 cmp %o0, 0
4001013c: 02 bf ff d2 be 40010084 <fat_file_write+0xbc> <== ALWAYS TAKEN
40010140: 94 10 20 00 clr %o2
((ofs_cln_save + cmpltd - 1) >> fs_info->vol.bpc_log2);
40010144: c4 0e 20 0c ldub [ %i0 + 0xc ], %g2 <== NOT EXECUTED
40010148: 82 06 c0 1a add %i3, %i2, %g1 <== NOT EXECUTED
fat_fd->map.disk_cln = save_cln;
4001014c: e2 26 60 38 st %l1, [ %i1 + 0x38 ] <== NOT EXECUTED
((ofs_cln_save + cmpltd - 1) >> fs_info->vol.bpc_log2);
40010150: 83 30 40 02 srl %g1, %g2, %g1 <== NOT EXECUTED
fat_fd->map.file_cln = start_cln +
40010154: a0 00 40 10 add %g1, %l0, %l0 <== NOT EXECUTED
40010158: 10 bf ff e2 b 400100e0 <fat_file_write+0x118> <== NOT EXECUTED
4001015c: e0 26 60 34 st %l0, [ %i1 + 0x34 ] <== NOT EXECUTED
return (FAT_FD_OF_ROOT_DIR(fat_fd)) && (volume_type & (FAT_FAT12 | FAT_FAT16));
40010160: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
40010164: 80 a0 60 00 cmp %g1, 0
40010168: 32 bf ff b8 bne,a 40010048 <fat_file_write+0x80> <== NEVER TAKEN
4001016c: c0 27 bf fc clr [ %fp + -4 ] <== NOT EXECUTED
40010170: c2 0e 20 16 ldub [ %i0 + 0x16 ], %g1
40010174: 80 88 60 03 btst 3, %g1
40010178: 22 bf ff b4 be,a 40010048 <fat_file_write+0x80>
4001017c: c0 27 bf fc clr [ %fp + -4 ]
cln = fat_fd->cln;
40010180: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
byte = start & (fs_info->vol.bpc -1);
40010184: d4 06 20 08 ld [ %i0 + 8 ], %o2
40010188: 94 02 bf ff add %o2, -1, %o2
ret = fat_cluster_write(fs_info,
4001018c: 98 10 00 1c mov %i4, %o4
40010190: 96 10 00 1d mov %i5, %o3
40010194: 94 0a 80 1a and %o2, %i2, %o2
40010198: 92 02 40 10 add %o1, %l0, %o1
4001019c: 7f ff f7 80 call 4000df9c <fat_cluster_write>
400101a0: 90 10 00 18 mov %i0, %o0
if (0 > ret)
400101a4: 80 a2 20 00 cmp %o0, 0
400101a8: 16 bf ff d0 bge 400100e8 <fat_file_write+0x120> <== ALWAYS TAKEN
400101ac: 01 00 00 00 nop
rc = -1;
400101b0: 10 bf ff ce b 400100e8 <fat_file_write+0x120> <== NOT EXECUTED
400101b4: 90 10 3f ff mov -1, %o0 ! ffffffff <RAM_END+0xbfbfffff> <== NOT EXECUTED
((ofs_cln_save + cmpltd - 1) >> fs_info->vol.bpc_log2);
400101b8: c2 0e 20 0c ldub [ %i0 + 0xc ], %g1 <== NOT EXECUTED
400101bc: b6 06 80 1b add %i2, %i3, %i3 <== NOT EXECUTED
fat_fd->map.disk_cln = save_cln;
400101c0: e2 26 60 38 st %l1, [ %i1 + 0x38 ] <== NOT EXECUTED
((ofs_cln_save + cmpltd - 1) >> fs_info->vol.bpc_log2);
400101c4: b7 36 c0 01 srl %i3, %g1, %i3 <== NOT EXECUTED
rc = -1;
400101c8: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
fat_fd->map.file_cln = start_cln +
400101cc: a0 06 c0 10 add %i3, %l0, %l0 <== NOT EXECUTED
400101d0: 10 bf ff c6 b 400100e8 <fat_file_write+0x120> <== NOT EXECUTED
400101d4: e0 26 60 34 st %l0, [ %i1 + 0x34 ] <== NOT EXECUTED
((ofs_cln_save + cmpltd - 1) >> fs_info->vol.bpc_log2);
400101d8: c2 0e 20 0c ldub [ %i0 + 0xc ], %g1 <== NOT EXECUTED
400101dc: b5 36 80 01 srl %i2, %g1, %i2 <== NOT EXECUTED
fat_fd->map.disk_cln = save_cln;
400101e0: c0 26 60 38 clr [ %i1 + 0x38 ] <== NOT EXECUTED
fat_fd->map.file_cln = start_cln +
400101e4: a0 06 80 10 add %i2, %l0, %l0 <== NOT EXECUTED
400101e8: 10 bf ff c0 b 400100e8 <fat_file_write+0x120> <== NOT EXECUTED
400101ec: e0 26 60 34 st %l0, [ %i1 + 0x34 ] <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EFBIG);
400101f0: 40 00 2e 2f call 4001baac <__errno> <== NOT EXECUTED
400101f4: 01 00 00 00 nop <== NOT EXECUTED
400101f8: 84 10 20 1b mov 0x1b, %g2 ! 1b <_TLS_Alignment+0x1a> <== NOT EXECUTED
400101fc: 82 10 00 08 mov %o0, %g1 <== NOT EXECUTED
40010200: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
40010204: 10 bf ff b9 b 400100e8 <fat_file_write+0x120> <== NOT EXECUTED
40010208: c4 20 40 00 st %g2, [ %g1 ] <== NOT EXECUTED
40011168 <fat_file_write_file_size>:
{
40011168: 9d e3 bf 90 save %sp, -112, %sp
uint32_t le_new_length = 0;
4001116c: c0 27 bf fc clr [ %fp + -4 ]
sec = fat_cluster_num_to_sector_num(fs_info, fat_fd->dir_pos.sname.cln);
40011170: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
40011174: 80 a0 60 00 cmp %g1, 0
40011178: 32 80 00 07 bne,a 40011194 <fat_file_write_file_size+0x2c>
4001117c: c6 0e 20 05 ldub [ %i0 + 5 ], %g3
40011180: c4 0e 20 16 ldub [ %i0 + 0x16 ], %g2
40011184: 80 88 a0 03 btst 3, %g2
40011188: 32 80 00 07 bne,a 400111a4 <fat_file_write_file_size+0x3c> <== ALWAYS TAKEN
4001118c: d2 06 20 28 ld [ %i0 + 0x28 ], %o1
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
40011190: c6 0e 20 05 ldub [ %i0 + 5 ], %g3 <== NOT EXECUTED
40011194: c4 06 20 3c ld [ %i0 + 0x3c ], %g2
40011198: 92 00 7f fe add %g1, -2, %o1
4001119c: 93 2a 40 03 sll %o1, %g3, %o1
400111a0: 92 02 40 02 add %o1, %g2, %o1
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->vol.sec_log2);
400111a4: d4 06 60 24 ld [ %i1 + 0x24 ], %o2
400111a8: c2 0e 20 02 ldub [ %i0 + 2 ], %g1
byte = (fat_fd->dir_pos.sname.ofs & (fs_info->vol.bps - 1));
400111ac: fa 16 00 00 lduh [ %i0 ], %i5
if (fat_fd->fat_file_type == FAT_DIRECTORY) {
400111b0: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->vol.sec_log2);
400111b4: 83 32 80 01 srl %o2, %g1, %g1
byte = (fat_fd->dir_pos.sname.ofs & (fs_info->vol.bps - 1));
400111b8: ba 07 7f ff add %i5, -1, %i5
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->vol.sec_log2);
400111bc: 92 00 40 09 add %g1, %o1, %o1
if (fat_fd->fat_file_type == FAT_DIRECTORY) {
400111c0: 80 a0 a0 00 cmp %g2, 0
400111c4: 02 80 00 07 be 400111e0 <fat_file_write_file_size+0x78>
400111c8: ba 0f 40 0a and %i5, %o2, %i5
le_new_length = CT_LE_L(fat_fd->fat_file_size);
400111cc: d0 06 60 18 ld [ %i1 + 0x18 ], %o0
400111d0: 40 00 27 a8 call 4001b070 <__bswapsi2>
400111d4: d2 27 bf f4 st %o1, [ %fp + -12 ]
400111d8: d0 27 bf fc st %o0, [ %fp + -4 ]
400111dc: d2 07 bf f4 ld [ %fp + -12 ], %o1
ret = fat_sector_write(fs_info, sec, byte + MSDOS_FILE_SIZE_OFFSET, 4,
400111e0: 98 07 bf fc add %fp, -4, %o4
400111e4: 96 10 20 04 mov 4, %o3
400111e8: 94 07 60 1c add %i5, 0x1c, %o2
400111ec: 7f ff f2 ef call 4000dda8 <fat_sector_write>
400111f0: 90 10 00 18 mov %i0, %o0
}
400111f4: b1 3a 20 1f sra %o0, 0x1f, %i0
400111f8: 81 c7 e0 08 ret
400111fc: 81 e8 00 00 restore
400110a4 <fat_file_write_first_cluster_num>:
{
400110a4: 9d e3 bf 90 save %sp, -112, %sp
uint16_t le_cl_hi = 0;
400110a8: c0 37 bf fe clrh [ %fp + -2 ]
sec = fat_cluster_num_to_sector_num(fs_info, fat_fd->dir_pos.sname.cln);
400110ac: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
400110b0: 80 a0 60 00 cmp %g1, 0
400110b4: 12 80 00 06 bne 400110cc <fat_file_write_first_cluster_num+0x28>
400110b8: fa 06 60 1c ld [ %i1 + 0x1c ], %i5
400110bc: c4 0e 20 16 ldub [ %i0 + 0x16 ], %g2
400110c0: 80 88 a0 03 btst 3, %g2
400110c4: 32 80 00 07 bne,a 400110e0 <fat_file_write_first_cluster_num+0x3c> <== ALWAYS TAKEN
400110c8: d2 06 20 28 ld [ %i0 + 0x28 ], %o1
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
400110cc: c6 0e 20 05 ldub [ %i0 + 5 ], %g3
400110d0: c4 06 20 3c ld [ %i0 + 0x3c ], %g2
400110d4: 92 00 7f fe add %g1, -2, %o1
400110d8: 93 2a 40 03 sll %o1, %g3, %o1
400110dc: 92 02 40 02 add %o1, %g2, %o1
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->vol.sec_log2);
400110e0: c4 06 60 24 ld [ %i1 + 0x24 ], %g2
400110e4: c2 0e 20 02 ldub [ %i0 + 2 ], %g1
byte = fat_fd->dir_pos.sname.ofs & (fs_info->vol.bps - 1);
400110e8: f8 16 00 00 lduh [ %i0 ], %i4
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->vol.sec_log2);
400110ec: 83 30 80 01 srl %g2, %g1, %g1
byte = fat_fd->dir_pos.sname.ofs & (fs_info->vol.bps - 1);
400110f0: b8 07 3f ff add %i4, -1, %i4
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->vol.sec_log2);
400110f4: 92 00 40 09 add %g1, %o1, %o1
byte = fat_fd->dir_pos.sname.ofs & (fs_info->vol.bps - 1);
400110f8: b8 0f 00 02 and %i4, %g2, %i4
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
400110fc: 83 2f 60 08 sll %i5, 8, %g1
40011100: 85 2f 60 10 sll %i5, 0x10, %g2
40011104: 85 30 a0 18 srl %g2, 0x18, %g2
40011108: 82 10 40 02 or %g1, %g2, %g1
ret1 = fat_sector_write(fs_info, sec,
4001110c: d2 27 bf f4 st %o1, [ %fp + -12 ]
40011110: 98 07 bf fc add %fp, -4, %o4
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
40011114: c2 37 bf fc sth %g1, [ %fp + -4 ]
ret1 = fat_sector_write(fs_info, sec,
40011118: 94 07 20 1a add %i4, 0x1a, %o2
4001111c: 96 10 20 02 mov 2, %o3
40011120: 7f ff f3 22 call 4000dda8 <fat_sector_write>
40011124: 90 10 00 18 mov %i0, %o0
ret2 = fat_sector_write(fs_info, sec,
40011128: d2 07 bf f4 ld [ %fp + -12 ], %o1
le_cl_hi = CT_LE_W((uint16_t )((new_cln & 0xFFFF0000) >> 16));
4001112c: bb 37 60 10 srl %i5, 0x10, %i5
40011130: 83 2f 60 08 sll %i5, 8, %g1
ret1 = fat_sector_write(fs_info, sec,
40011134: b6 10 00 08 mov %o0, %i3
ret2 = fat_sector_write(fs_info, sec,
40011138: 98 07 bf fe add %fp, -2, %o4
4001113c: 96 10 20 02 mov 2, %o3
40011140: 94 07 20 14 add %i4, 0x14, %o2
40011144: 90 10 00 18 mov %i0, %o0
le_cl_hi = CT_LE_W((uint16_t )((new_cln & 0xFFFF0000) >> 16));
40011148: bb 37 60 08 srl %i5, 8, %i5
4001114c: ba 10 40 1d or %g1, %i5, %i5
ret2 = fat_sector_write(fs_info, sec,
40011150: 7f ff f3 16 call 4000dda8 <fat_sector_write>
40011154: fa 37 bf fe sth %i5, [ %fp + -2 ]
if ( (ret1 < 0) || (ret2 < 0) )
40011158: 90 12 00 1b or %o0, %i3, %o0
}
4001115c: b1 3a 20 1f sra %o0, 0x1f, %i0
40011160: 81 c7 e0 08 ret
40011164: 81 e8 00 00 restore
40010f10 <fat_file_write_time_and_date>:
{
40010f10: 9d e3 bf 98 save %sp, -104, %sp
sec = fat_cluster_num_to_sector_num(fs_info, fat_fd->dir_pos.sname.cln);
40010f14: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
40010f18: 80 a0 60 00 cmp %g1, 0
40010f1c: 32 80 00 07 bne,a 40010f38 <fat_file_write_time_and_date+0x28>
40010f20: c4 0e 20 05 ldub [ %i0 + 5 ], %g2
40010f24: c4 0e 20 16 ldub [ %i0 + 0x16 ], %g2
40010f28: 80 88 a0 03 btst 3, %g2
40010f2c: 32 80 00 07 bne,a 40010f48 <fat_file_write_time_and_date+0x38> <== ALWAYS TAKEN
40010f30: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
40010f34: c4 0e 20 05 ldub [ %i0 + 5 ], %g2 <== NOT EXECUTED
40010f38: fa 06 20 3c ld [ %i0 + 0x3c ], %i5
40010f3c: 82 00 7f fe add %g1, -2, %g1
40010f40: 83 28 40 02 sll %g1, %g2, %g1
40010f44: 82 00 40 1d add %g1, %i5, %g1
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->vol.sec_log2);
40010f48: c4 06 60 24 ld [ %i1 + 0x24 ], %g2
40010f4c: fa 0e 20 02 ldub [ %i0 + 2 ], %i5
byte = fat_fd->dir_pos.sname.ofs & (fs_info->vol.bps - 1);
40010f50: f8 16 00 00 lduh [ %i0 ], %i4
msdos_date_unix2dos(fat_fd->mtime, &date, &time_val);
40010f54: d0 06 60 4c ld [ %i1 + 0x4c ], %o0
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->vol.sec_log2);
40010f58: bb 30 80 1d srl %g2, %i5, %i5
msdos_date_unix2dos(fat_fd->mtime, &date, &time_val);
40010f5c: 94 07 bf fc add %fp, -4, %o2
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->vol.sec_log2);
40010f60: ba 07 40 01 add %i5, %g1, %i5
msdos_date_unix2dos(fat_fd->mtime, &date, &time_val);
40010f64: 92 07 bf fe add %fp, -2, %o1
byte = fat_fd->dir_pos.sname.ofs & (fs_info->vol.bps - 1);
40010f68: b8 07 3f ff add %i4, -1, %i4
msdos_date_unix2dos(fat_fd->mtime, &date, &time_val);
40010f6c: 40 00 1a 04 call 4001777c <msdos_date_unix2dos>
40010f70: b8 0f 00 02 and %i4, %g2, %i4
time_val = CT_LE_W(time_val);
40010f74: c2 17 bf fc lduh [ %fp + -4 ], %g1
40010f78: 85 28 60 08 sll %g1, 8, %g2
40010f7c: 83 28 60 10 sll %g1, 0x10, %g1
40010f80: 83 30 60 18 srl %g1, 0x18, %g1
40010f84: 82 10 80 01 or %g2, %g1, %g1
ret = fat_sector_write(fs_info, sec, byte + MSDOS_FILE_WTIME_OFFSET,
40010f88: 98 07 bf fc add %fp, -4, %o4
time_val = CT_LE_W(time_val);
40010f8c: c2 37 bf fc sth %g1, [ %fp + -4 ]
ret = fat_sector_write(fs_info, sec, byte + MSDOS_FILE_WTIME_OFFSET,
40010f90: 96 10 20 02 mov 2, %o3
40010f94: 94 07 20 16 add %i4, 0x16, %o2
40010f98: 92 10 00 1d mov %i5, %o1
40010f9c: 7f ff f3 83 call 4000dda8 <fat_sector_write>
40010fa0: 90 10 00 18 mov %i0, %o0
date = CT_LE_W(date);
40010fa4: c2 17 bf fe lduh [ %fp + -2 ], %g1
40010fa8: 85 28 60 08 sll %g1, 8, %g2
40010fac: 83 28 60 10 sll %g1, 0x10, %g1
40010fb0: 83 30 60 18 srl %g1, 0x18, %g1
40010fb4: 82 10 80 01 or %g2, %g1, %g1
ret = fat_sector_write(fs_info, sec, byte + MSDOS_FILE_WTIME_OFFSET,
40010fb8: b4 10 00 08 mov %o0, %i2
date = CT_LE_W(date);
40010fbc: c2 37 bf fe sth %g1, [ %fp + -2 ]
ret = fat_sector_write(fs_info, sec, byte + MSDOS_FILE_WDATE_OFFSET,
40010fc0: 98 07 bf fe add %fp, -2, %o4
40010fc4: 96 10 20 02 mov 2, %o3
40010fc8: 94 07 20 18 add %i4, 0x18, %o2
40010fcc: 92 10 00 1d mov %i5, %o1
40010fd0: 90 10 00 18 mov %i0, %o0
40010fd4: 7f ff f3 75 call 4000dda8 <fat_sector_write>
40010fd8: b6 10 3f ff mov -1, %i3
if ( ret < 0 )
40010fdc: 80 a2 20 00 cmp %o0, 0
40010fe0: 36 80 00 02 bge,a 40010fe8 <fat_file_write_time_and_date+0xd8> <== ALWAYS TAKEN
40010fe4: b7 3e a0 1f sra %i2, 0x1f, %i3
ret = fat_sector_write(fs_info, sec, byte + MSDOS_FILE_ADATE_OFFSET,
40010fe8: 98 07 bf fe add %fp, -2, %o4
40010fec: 96 10 20 02 mov 2, %o3
40010ff0: 94 07 20 12 add %i4, 0x12, %o2
40010ff4: 92 10 00 1d mov %i5, %o1
40010ff8: 7f ff f3 6c call 4000dda8 <fat_sector_write>
40010ffc: 90 10 00 18 mov %i0, %o0
if ( ret < 0 )
40011000: 80 a2 20 00 cmp %o0, 0
40011004: 26 80 00 02 bl,a 4001100c <fat_file_write_time_and_date+0xfc> <== NEVER TAKEN
40011008: b6 10 3f ff mov -1, %i3 <== NOT EXECUTED
msdos_date_unix2dos(fat_fd->ctime, &date, &time_val);
4001100c: d0 06 60 44 ld [ %i1 + 0x44 ], %o0
40011010: 94 07 bf fc add %fp, -4, %o2
40011014: 40 00 19 da call 4001777c <msdos_date_unix2dos>
40011018: 92 07 bf fe add %fp, -2, %o1
time_val = CT_LE_W(time_val);
4001101c: c2 17 bf fc lduh [ %fp + -4 ], %g1
40011020: 85 28 60 08 sll %g1, 8, %g2
40011024: 83 28 60 10 sll %g1, 0x10, %g1
40011028: 83 30 60 18 srl %g1, 0x18, %g1
4001102c: 82 10 80 01 or %g2, %g1, %g1
ret = fat_sector_write(fs_info, sec, byte + MSDOS_FILE_CTIME_OFFSET,
40011030: 98 07 bf fc add %fp, -4, %o4
time_val = CT_LE_W(time_val);
40011034: c2 37 bf fc sth %g1, [ %fp + -4 ]
ret = fat_sector_write(fs_info, sec, byte + MSDOS_FILE_CTIME_OFFSET,
40011038: 96 10 20 02 mov 2, %o3
4001103c: 94 07 20 0e add %i4, 0xe, %o2
40011040: 92 10 00 1d mov %i5, %o1
40011044: 7f ff f3 59 call 4000dda8 <fat_sector_write>
40011048: 90 10 00 18 mov %i0, %o0
if ( ret < 0 )
4001104c: 80 a2 20 00 cmp %o0, 0
40011050: 26 80 00 02 bl,a 40011058 <fat_file_write_time_and_date+0x148> <== NEVER TAKEN
40011054: b6 10 3f ff mov -1, %i3 <== NOT EXECUTED
date = CT_LE_W(date);
40011058: c2 17 bf fe lduh [ %fp + -2 ], %g1
4001105c: 85 28 60 08 sll %g1, 8, %g2
40011060: 83 28 60 10 sll %g1, 0x10, %g1
40011064: 83 30 60 18 srl %g1, 0x18, %g1
40011068: 82 10 80 01 or %g2, %g1, %g1
ret = fat_sector_write(fs_info, sec, byte + MSDOS_FILE_CDATE_OFFSET,
4001106c: 98 07 bf fe add %fp, -2, %o4
date = CT_LE_W(date);
40011070: c2 37 bf fe sth %g1, [ %fp + -2 ]
ret = fat_sector_write(fs_info, sec, byte + MSDOS_FILE_CDATE_OFFSET,
40011074: 96 10 20 02 mov 2, %o3
40011078: 94 07 20 10 add %i4, 0x10, %o2
4001107c: 92 10 00 1d mov %i5, %o1
40011080: 7f ff f3 4a call 4000dda8 <fat_sector_write>
40011084: 90 10 00 18 mov %i0, %o0
if ( ret < 0 )
40011088: 80 a2 20 00 cmp %o0, 0
4001108c: 26 80 00 02 bl,a 40011094 <fat_file_write_time_and_date+0x184> <== NEVER TAKEN
40011090: b6 10 3f ff mov -1, %i3 <== NOT EXECUTED
}
40011094: 81 c7 e0 08 ret
40011098: 91 e8 00 1b restore %g0, %i3, %o0
return rc;
4001109c: 10 bf ff fe b 40011094 <fat_file_write_time_and_date+0x184> <== NOT EXECUTED
400110a0: b6 10 3f ff mov -1, %i3 <== NOT EXECUTED
4000f1f4 <fat_free_fat_clusters_chain>:
{
4000f1f4: 9d e3 bf 90 save %sp, -112, %sp
uint32_t next_cln = 0;
4000f1f8: c0 27 bf fc clr [ %fp + -4 ]
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
4000f1fc: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
4000f200: c4 06 20 1c ld [ %i0 + 0x1c ], %g2
4000f204: 82 0e 40 01 and %i1, %g1, %g1
4000f208: 80 a0 80 01 cmp %g2, %g1
4000f20c: 08 80 00 26 bleu 4000f2a4 <fat_free_fat_clusters_chain+0xb0> <== NEVER TAKEN
4000f210: ba 10 00 18 mov %i0, %i5
uint32_t cur_cln = chain;
4000f214: 92 10 00 19 mov %i1, %o1
uint32_t freed_cls_cnt = 0;
4000f218: b8 10 20 00 clr %i4
int rc = RC_OK, rc1 = RC_OK;
4000f21c: 10 80 00 0e b 4000f254 <fat_free_fat_clusters_chain+0x60>
4000f220: b0 10 20 00 clr %i0
rc = fat_set_fat_cluster(fs_info, cur_cln, FAT_GENFAT_FREE);
4000f224: 7f ff ff 4b call 4000ef50 <fat_set_fat_cluster>
4000f228: 01 00 00 00 nop
if ( rc != RC_OK )
4000f22c: 80 a2 20 00 cmp %o0, 0
4000f230: 32 80 00 02 bne,a 4000f238 <fat_free_fat_clusters_chain+0x44> <== NEVER TAKEN
4000f234: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
cur_cln = next_cln;
4000f238: d2 07 bf fc ld [ %fp + -4 ], %o1
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
4000f23c: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
4000f240: c4 07 60 1c ld [ %i5 + 0x1c ], %g2
4000f244: 82 0a 40 01 and %o1, %g1, %g1
4000f248: 80 a0 40 02 cmp %g1, %g2
4000f24c: 1a 80 00 18 bcc 4000f2ac <fat_free_fat_clusters_chain+0xb8>
4000f250: b8 07 20 01 inc %i4
rc = fat_get_fat_cluster(fs_info, cur_cln, &next_cln);
4000f254: d2 27 bf f4 st %o1, [ %fp + -12 ]
4000f258: 94 07 bf fc add %fp, -4, %o2
4000f25c: 7f ff fe c8 call 4000ed7c <fat_get_fat_cluster>
4000f260: 90 10 00 1d mov %i5, %o0
rc = fat_set_fat_cluster(fs_info, cur_cln, FAT_GENFAT_FREE);
4000f264: d2 07 bf f4 ld [ %fp + -12 ], %o1
rc = fat_get_fat_cluster(fs_info, cur_cln, &next_cln);
4000f268: 82 10 00 08 mov %o0, %g1
rc = fat_set_fat_cluster(fs_info, cur_cln, FAT_GENFAT_FREE);
4000f26c: 94 10 20 00 clr %o2
if ( rc != RC_OK )
4000f270: 80 a0 60 00 cmp %g1, 0
4000f274: 02 bf ff ec be 4000f224 <fat_free_fat_clusters_chain+0x30> <== ALWAYS TAKEN
4000f278: 90 10 00 1d mov %i5, %o0
if(fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
4000f27c: c4 07 60 4c ld [ %i5 + 0x4c ], %g2 <== NOT EXECUTED
4000f280: 80 a0 bf ff cmp %g2, -1 <== NOT EXECUTED
4000f284: 02 80 00 03 be 4000f290 <fat_free_fat_clusters_chain+0x9c> <== NOT EXECUTED
4000f288: 84 00 80 1c add %g2, %i4, %g2 <== NOT EXECUTED
fs_info->vol.free_cls += freed_cls_cnt;
4000f28c: c4 27 60 4c st %g2, [ %i5 + 0x4c ] <== NOT EXECUTED
rc = fat_get_fat_cluster(fs_info, cur_cln, &next_cln);
4000f290: b0 10 00 01 mov %g1, %i0 <== NOT EXECUTED
fat_buf_release(fs_info);
4000f294: 7f ff fa 86 call 4000dcac <fat_buf_release> <== NOT EXECUTED
4000f298: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rc;
4000f29c: 81 c7 e0 08 ret <== NOT EXECUTED
4000f2a0: 81 e8 00 00 restore <== NOT EXECUTED
uint32_t freed_cls_cnt = 0;
4000f2a4: b8 10 20 00 clr %i4 <== NOT EXECUTED
int rc = RC_OK, rc1 = RC_OK;
4000f2a8: b0 10 20 00 clr %i0 <== NOT EXECUTED
fs_info->vol.next_cl = chain;
4000f2ac: f2 27 60 54 st %i1, [ %i5 + 0x54 ]
if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
4000f2b0: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
4000f2b4: 80 a0 7f ff cmp %g1, -1
4000f2b8: 02 80 00 03 be 4000f2c4 <fat_free_fat_clusters_chain+0xd0> <== ALWAYS TAKEN
4000f2bc: 82 00 40 1c add %g1, %i4, %g1
fs_info->vol.free_cls += freed_cls_cnt;
4000f2c0: c2 27 60 4c st %g1, [ %i5 + 0x4c ] <== NOT EXECUTED
fat_buf_release(fs_info);
4000f2c4: 7f ff fa 7a call 4000dcac <fat_buf_release>
4000f2c8: 90 10 00 1d mov %i5, %o0
}
4000f2cc: 81 c7 e0 08 ret
4000f2d0: 81 e8 00 00 restore
4000ed40 <fat_free_unique_ino>:
fat_free_unique_ino(
fat_fs_info_t *fs_info,
uint32_t ino
)
{
FAT_SET_UNIQ_INO_FREE((ino - fs_info->uino_base), fs_info->uino);
4000ed40: c2 02 20 94 ld [ %o0 + 0x94 ], %g1 <== NOT EXECUTED
4000ed44: c6 02 20 88 ld [ %o0 + 0x88 ], %g3 <== NOT EXECUTED
4000ed48: 92 22 40 01 sub %o1, %g1, %o1 <== NOT EXECUTED
4000ed4c: 85 32 60 03 srl %o1, 3, %g2 <== NOT EXECUTED
4000ed50: c8 08 c0 02 ldub [ %g3 + %g2 ], %g4 <== NOT EXECUTED
4000ed54: 92 0a 60 07 and %o1, 7, %o1 <== NOT EXECUTED
4000ed58: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
4000ed5c: 93 28 40 09 sll %g1, %o1, %o1 <== NOT EXECUTED
4000ed60: 92 29 00 09 andn %g4, %o1, %o1 <== NOT EXECUTED
}
4000ed64: 81 c3 e0 08 retl <== NOT EXECUTED
4000ed68: d2 28 c0 02 stb %o1, [ %g3 + %g2 ] <== NOT EXECUTED
4000ed7c <fat_get_fat_cluster>:
fat_get_fat_cluster(
fat_fs_info_t *fs_info,
uint32_t cln,
uint32_t *ret_val
)
{
4000ed7c: 9d e3 bf 98 save %sp, -104, %sp
uint8_t *sec_buf;
uint32_t sec = 0;
uint32_t ofs = 0;
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
4000ed80: 80 a6 60 01 cmp %i1, 1
4000ed84: 08 80 00 27 bleu 4000ee20 <fat_get_fat_cluster+0xa4> <== NEVER TAKEN
4000ed88: ba 10 00 18 mov %i0, %i5
4000ed8c: c2 06 20 40 ld [ %i0 + 0x40 ], %g1
4000ed90: 82 00 60 01 inc %g1
4000ed94: 80 a0 40 19 cmp %g1, %i1
4000ed98: 0a 80 00 22 bcs 4000ee20 <fat_get_fat_cluster+0xa4> <== NEVER TAKEN
4000ed9c: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
4000eda0: c2 0e 20 16 ldub [ %i0 + 0x16 ], %g1
fs_info->vol.afat_loc;
4000eda4: f6 06 20 60 ld [ %i0 + 0x60 ], %i3
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
4000eda8: 80 88 60 01 btst 1, %g1
4000edac: 12 80 00 23 bne 4000ee38 <fat_get_fat_cluster+0xbc>
4000edb0: d2 0e 20 02 ldub [ %i0 + 2 ], %o1
4000edb4: 80 88 60 02 btst 2, %g1
4000edb8: 02 80 00 2f be 4000ee74 <fat_get_fat_cluster+0xf8>
4000edbc: a1 2e 60 02 sll %i1, 2, %l0
4000edc0: a1 2e 60 01 sll %i1, 1, %l0
4000edc4: 93 34 00 09 srl %l0, %o1, %o1
4000edc8: b6 02 40 1b add %o1, %i3, %i3
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
4000edcc: f8 17 40 00 lduh [ %i5 ], %i4
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
4000edd0: 94 10 20 01 mov 1, %o2
4000edd4: 96 07 bf fc add %fp, -4, %o3
4000edd8: 92 10 00 1b mov %i3, %o1
4000eddc: 7f ff fb 86 call 4000dbf4 <fat_buf_access>
4000ede0: 90 10 00 1d mov %i5, %o0
if (rc != RC_OK)
4000ede4: b0 92 20 00 orcc %o0, 0, %i0
4000ede8: 12 80 00 49 bne 4000ef0c <fat_get_fat_cluster+0x190> <== NEVER TAKEN
4000edec: 01 00 00 00 nop
return rc;
switch ( fs_info->vol.type )
4000edf0: c2 0f 60 16 ldub [ %i5 + 0x16 ], %g1
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
4000edf4: b9 2f 20 10 sll %i4, 0x10, %i4
switch ( fs_info->vol.type )
4000edf8: 80 a0 60 02 cmp %g1, 2
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
4000edfc: b9 37 20 10 srl %i4, 0x10, %i4
4000ee00: b8 07 3f ff add %i4, -1, %i4
switch ( fs_info->vol.type )
4000ee04: 02 80 00 1f be 4000ee80 <fat_get_fat_cluster+0x104>
4000ee08: b8 0f 00 10 and %i4, %l0, %i4
4000ee0c: 80 a0 60 04 cmp %g1, 4
4000ee10: 02 80 00 38 be 4000eef0 <fat_get_fat_cluster+0x174>
4000ee14: 80 a0 60 01 cmp %g1, 1
4000ee18: 02 80 00 25 be 4000eeac <fat_get_fat_cluster+0x130> <== ALWAYS TAKEN
4000ee1c: c4 07 bf fc ld [ %fp + -4 ], %g2
*ret_val = *((uint32_t *)(sec_buf + ofs));
*ret_val = CF_LE_L(*ret_val);
break;
default:
rtems_set_errno_and_return_minus_one(EIO);
4000ee20: 40 00 33 23 call 4001baac <__errno> <== NOT EXECUTED
4000ee24: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4000ee28: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4000ee2c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4000ee30: 81 c7 e0 08 ret <== NOT EXECUTED
4000ee34: 81 e8 00 00 restore <== NOT EXECUTED
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
4000ee38: b9 36 60 01 srl %i1, 1, %i4
4000ee3c: a0 07 00 19 add %i4, %i1, %l0
4000ee40: 93 34 00 09 srl %l0, %o1, %o1
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
4000ee44: f8 17 40 00 lduh [ %i5 ], %i4
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
4000ee48: b6 02 40 1b add %o1, %i3, %i3
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
4000ee4c: 94 10 20 01 mov 1, %o2
4000ee50: 96 07 bf fc add %fp, -4, %o3
4000ee54: 92 10 00 1b mov %i3, %o1
4000ee58: 7f ff fb 67 call 4000dbf4 <fat_buf_access>
4000ee5c: 90 10 00 1d mov %i5, %o0
if (rc != RC_OK)
4000ee60: b0 92 20 00 orcc %o0, 0, %i0
4000ee64: 22 bf ff e4 be,a 4000edf4 <fat_get_fat_cluster+0x78> <== ALWAYS TAKEN
4000ee68: c2 0f 60 16 ldub [ %i5 + 0x16 ], %g1
break;
}
return RC_OK;
}
4000ee6c: 81 c7 e0 08 ret <== NOT EXECUTED
4000ee70: 81 e8 00 00 restore <== NOT EXECUTED
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
4000ee74: 93 34 00 09 srl %l0, %o1, %o1
4000ee78: 10 bf ff d5 b 4000edcc <fat_get_fat_cluster+0x50>
4000ee7c: b6 02 40 1b add %o1, %i3, %i3
*ret_val = *((uint16_t *)(sec_buf + ofs));
4000ee80: c2 07 bf fc ld [ %fp + -4 ], %g1
*ret_val = CF_LE_W(*ret_val);
4000ee84: c4 10 40 1c lduh [ %g1 + %i4 ], %g2
4000ee88: 83 28 a0 08 sll %g2, 8, %g1
4000ee8c: 85 28 a0 10 sll %g2, 0x10, %g2
4000ee90: 85 30 a0 18 srl %g2, 0x18, %g2
4000ee94: 82 10 40 02 or %g1, %g2, %g1
4000ee98: 83 28 60 10 sll %g1, 0x10, %g1
4000ee9c: 83 30 60 10 srl %g1, 0x10, %g1
4000eea0: c2 26 80 00 st %g1, [ %i2 ]
break;
4000eea4: 81 c7 e0 08 ret
4000eea8: 81 e8 00 00 restore
*ret_val = (*(sec_buf + ofs));
4000eeac: c8 08 80 1c ldub [ %g2 + %i4 ], %g4
4000eeb0: c8 26 80 00 st %g4, [ %i2 ]
if ( ofs == (fs_info->vol.bps - 1) )
4000eeb4: c6 17 40 00 lduh [ %i5 ], %g3
4000eeb8: 86 00 ff ff add %g3, -1, %g3
4000eebc: 80 a0 c0 1c cmp %g3, %i4
4000eec0: 02 80 00 15 be 4000ef14 <fat_get_fat_cluster+0x198>
4000eec4: 84 00 80 1c add %g2, %i4, %g2
*ret_val |= *(sec_buf + ofs + 1) << 8;
4000eec8: c2 08 a0 01 ldub [ %g2 + 1 ], %g1
4000eecc: 83 28 60 08 sll %g1, 8, %g1
4000eed0: 82 10 40 04 or %g1, %g4, %g1
if ( FAT_CLUSTER_IS_ODD(cln) )
4000eed4: 80 8e 60 01 btst 1, %i1
4000eed8: 22 80 00 0c be,a 4000ef08 <fat_get_fat_cluster+0x18c>
4000eedc: 82 08 6f ff and %g1, 0xfff, %g1
*ret_val = (*ret_val) >> FAT12_SHIFT;
4000eee0: 83 30 60 04 srl %g1, 4, %g1
4000eee4: c2 26 80 00 st %g1, [ %i2 ]
4000eee8: 81 c7 e0 08 ret
4000eeec: 81 e8 00 00 restore
*ret_val = *((uint32_t *)(sec_buf + ofs));
4000eef0: c2 07 bf fc ld [ %fp + -4 ], %g1
*ret_val = CF_LE_L(*ret_val);
4000eef4: 40 00 30 5f call 4001b070 <__bswapsi2>
4000eef8: d0 00 40 1c ld [ %g1 + %i4 ], %o0
4000eefc: d0 26 80 00 st %o0, [ %i2 ]
break;
4000ef00: 81 c7 e0 08 ret
4000ef04: 81 e8 00 00 restore
*ret_val = (*ret_val) & FAT_FAT12_MASK;
4000ef08: c2 26 80 00 st %g1, [ %i2 ]
4000ef0c: 81 c7 e0 08 ret
4000ef10: 81 e8 00 00 restore
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
4000ef14: 96 07 bf fc add %fp, -4, %o3
4000ef18: 94 10 20 01 mov 1, %o2
4000ef1c: 92 06 e0 01 add %i3, 1, %o1
4000ef20: 7f ff fb 35 call 4000dbf4 <fat_buf_access>
4000ef24: 90 10 00 1d mov %i5, %o0
if (rc != RC_OK)
4000ef28: 80 a2 20 00 cmp %o0, 0
4000ef2c: 12 80 00 07 bne 4000ef48 <fat_get_fat_cluster+0x1cc> <== NEVER TAKEN
4000ef30: c2 07 bf fc ld [ %fp + -4 ], %g1
*ret_val |= *sec_buf << 8;
4000ef34: c2 08 40 00 ldub [ %g1 ], %g1
4000ef38: c4 06 80 00 ld [ %i2 ], %g2
4000ef3c: 83 28 60 08 sll %g1, 8, %g1
4000ef40: 10 bf ff e5 b 4000eed4 <fat_get_fat_cluster+0x158>
4000ef44: 82 10 40 02 or %g1, %g2, %g1
}
4000ef48: 81 c7 e0 08 ret <== NOT EXECUTED
4000ef4c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
4000ec68 <fat_get_unique_ino>:
* 0 means FAILED !!!
*
*/
uint32_t
fat_get_unique_ino(fat_fs_info_t *fs_info)
{
4000ec68: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
uint32_t j = 0;
bool resrc_unsuff = false;
while (!resrc_unsuff)
{
for (j = 0; j < fs_info->uino_pool_size; j++)
4000ec6c: d2 06 20 90 ld [ %i0 + 0x90 ], %o1 <== NOT EXECUTED
fs_info->index++;
if (fs_info->index >= fs_info->uino_pool_size)
fs_info->index = 0;
}
if ((fs_info->uino_pool_size << 1) < (0x0FFFFFFF - fs_info->uino_base))
4000ec70: 35 03 ff ff sethi %hi(0xffffc00), %i2 <== NOT EXECUTED
4000ec74: b4 16 a3 ff or %i2, 0x3ff, %i2 ! fffffff <RAM_SIZE+0xfbfffff> <== NOT EXECUTED
for (j = 0; j < fs_info->uino_pool_size; j++)
4000ec78: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED
4000ec7c: 22 80 00 1a be,a 4000ece4 <fat_get_unique_ino+0x7c> <== NOT EXECUTED
4000ec80: c2 06 20 94 ld [ %i0 + 0x94 ], %g1 <== NOT EXECUTED
if (!FAT_UNIQ_INO_IS_BUSY(fs_info->index, fs_info->uino))
4000ec84: c8 06 20 88 ld [ %i0 + 0x88 ], %g4 <== NOT EXECUTED
for (j = 0; j < fs_info->uino_pool_size; j++)
4000ec88: 10 80 00 05 b 4000ec9c <fat_get_unique_ino+0x34> <== NOT EXECUTED
4000ec8c: ba 10 20 00 clr %i5 <== NOT EXECUTED
4000ec90: 80 a7 40 09 cmp %i5, %o1 <== NOT EXECUTED
4000ec94: 02 80 00 12 be 4000ecdc <fat_get_unique_ino+0x74> <== NOT EXECUTED
4000ec98: c2 26 20 8c st %g1, [ %i0 + 0x8c ] <== NOT EXECUTED
if (!FAT_UNIQ_INO_IS_BUSY(fs_info->index, fs_info->uino))
4000ec9c: c2 06 20 8c ld [ %i0 + 0x8c ], %g1 <== NOT EXECUTED
4000eca0: 85 30 60 03 srl %g1, 3, %g2 <== NOT EXECUTED
4000eca4: c6 49 00 02 ldsb [ %g4 + %g2 ], %g3 <== NOT EXECUTED
4000eca8: f6 09 00 02 ldub [ %g4 + %g2 ], %i3 <== NOT EXECUTED
4000ecac: b8 08 60 07 and %g1, 7, %i4 <== NOT EXECUTED
4000ecb0: 87 38 c0 1c sra %g3, %i4, %g3 <== NOT EXECUTED
4000ecb4: 80 88 e0 01 btst 1, %g3 <== NOT EXECUTED
4000ecb8: 02 80 00 18 be 4000ed18 <fat_get_unique_ino+0xb0> <== NOT EXECUTED
4000ecbc: 84 01 00 02 add %g4, %g2, %g2 <== NOT EXECUTED
fs_info->index++;
4000ecc0: 82 00 60 01 inc %g1 <== NOT EXECUTED
if (fs_info->index >= fs_info->uino_pool_size)
4000ecc4: 80 a0 40 09 cmp %g1, %o1 <== NOT EXECUTED
4000ecc8: 0a bf ff f2 bcs 4000ec90 <fat_get_unique_ino+0x28> <== NOT EXECUTED
4000eccc: ba 07 60 01 inc %i5 <== NOT EXECUTED
for (j = 0; j < fs_info->uino_pool_size; j++)
4000ecd0: 80 a7 40 09 cmp %i5, %o1 <== NOT EXECUTED
4000ecd4: 12 bf ff f2 bne 4000ec9c <fat_get_unique_ino+0x34> <== NOT EXECUTED
4000ecd8: c0 26 20 8c clr [ %i0 + 0x8c ] <== NOT EXECUTED
if ((fs_info->uino_pool_size << 1) < (0x0FFFFFFF - fs_info->uino_base))
4000ecdc: 93 2a 60 01 sll %o1, 1, %o1 <== NOT EXECUTED
4000ece0: c2 06 20 94 ld [ %i0 + 0x94 ], %g1 <== NOT EXECUTED
4000ece4: 82 26 80 01 sub %i2, %g1, %g1 <== NOT EXECUTED
4000ece8: 80 a0 40 09 cmp %g1, %o1 <== NOT EXECUTED
4000ecec: 08 80 00 13 bleu 4000ed38 <fat_get_unique_ino+0xd0> <== NOT EXECUTED
4000ecf0: 01 00 00 00 nop <== NOT EXECUTED
{
fs_info->uino_pool_size <<= 1;
4000ecf4: d2 26 20 90 st %o1, [ %i0 + 0x90 ] <== NOT EXECUTED
fs_info->uino = realloc(fs_info->uino, fs_info->uino_pool_size);
4000ecf8: 40 00 21 f8 call 400174d8 <realloc> <== NOT EXECUTED
4000ecfc: d0 06 20 88 ld [ %i0 + 0x88 ], %o0 <== NOT EXECUTED
if (fs_info->uino != NULL)
4000ed00: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000ed04: 02 80 00 0d be 4000ed38 <fat_get_unique_ino+0xd0> <== NOT EXECUTED
4000ed08: d0 26 20 88 st %o0, [ %i0 + 0x88 ] <== NOT EXECUTED
fs_info->index = fs_info->uino_pool_size;
4000ed0c: d2 06 20 90 ld [ %i0 + 0x90 ], %o1 <== NOT EXECUTED
4000ed10: 10 bf ff da b 4000ec78 <fat_get_unique_ino+0x10> <== NOT EXECUTED
4000ed14: d2 26 20 8c st %o1, [ %i0 + 0x8c ] <== NOT EXECUTED
FAT_SET_UNIQ_INO_BUSY(fs_info->index, fs_info->uino);
4000ed18: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
4000ed1c: b9 28 40 1c sll %g1, %i4, %i4 <== NOT EXECUTED
4000ed20: b6 17 00 1b or %i4, %i3, %i3 <== NOT EXECUTED
4000ed24: f6 28 80 00 stb %i3, [ %g2 ] <== NOT EXECUTED
return (fs_info->uino_base + fs_info->index);
4000ed28: c2 06 20 94 ld [ %i0 + 0x94 ], %g1 <== NOT EXECUTED
4000ed2c: f0 06 20 8c ld [ %i0 + 0x8c ], %i0 <== NOT EXECUTED
4000ed30: 81 c7 e0 08 ret <== NOT EXECUTED
4000ed34: 91 e8 40 18 restore %g1, %i0, %o0 <== NOT EXECUTED
}
else
resrc_unsuff = true;
}
return 0;
}
4000ed38: 81 c7 e0 08 ret <== NOT EXECUTED
4000ed3c: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
4000ebec <fat_init_clusters_chain>:
int
fat_init_clusters_chain(
fat_fs_info_t *fs_info,
uint32_t start_cln
)
{
4000ebec: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
ssize_t ret = 0;
uint32_t cur_cln = start_cln;
4000ebf0: f2 27 bf fc st %i1, [ %fp + -4 ]
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
4000ebf4: 10 80 00 0f b 4000ec30 <fat_init_clusters_chain+0x44>
4000ebf8: 92 10 00 19 mov %i1, %o1
{
ret = fat_cluster_set(fs_info, cur_cln, 0, fs_info->vol.bpc, 0);
4000ebfc: 7f ff fc 96 call 4000de54 <fat_cluster_set>
4000ec00: d6 06 20 08 ld [ %i0 + 8 ], %o3
if ( ret != fs_info->vol.bpc )
4000ec04: c4 06 20 08 ld [ %i0 + 8 ], %g2
ret = fat_cluster_set(fs_info, cur_cln, 0, fs_info->vol.bpc, 0);
4000ec08: 82 10 00 08 mov %o0, %g1
{
return -1;
}
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
4000ec0c: 94 07 bf fc add %fp, -4, %o2
if ( ret != fs_info->vol.bpc )
4000ec10: 80 a0 80 01 cmp %g2, %g1
4000ec14: 12 80 00 12 bne 4000ec5c <fat_init_clusters_chain+0x70> <== NEVER TAKEN
4000ec18: 90 10 00 18 mov %i0, %o0
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
4000ec1c: 40 00 00 58 call 4000ed7c <fat_get_fat_cluster>
4000ec20: d2 07 bf fc ld [ %fp + -4 ], %o1
if ( rc != RC_OK )
4000ec24: 80 a2 20 00 cmp %o0, 0
4000ec28: 12 80 00 0b bne 4000ec54 <fat_init_clusters_chain+0x68> <== NEVER TAKEN
4000ec2c: d2 07 bf fc ld [ %fp + -4 ], %o1
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
4000ec30: f2 06 20 18 ld [ %i0 + 0x18 ], %i1
4000ec34: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
4000ec38: b2 0a 40 19 and %o1, %i1, %i1
ret = fat_cluster_set(fs_info, cur_cln, 0, fs_info->vol.bpc, 0);
4000ec3c: 98 10 20 00 clr %o4
4000ec40: 94 10 20 00 clr %o2
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
4000ec44: 80 a6 40 01 cmp %i1, %g1
4000ec48: 0a bf ff ed bcs 4000ebfc <fat_init_clusters_chain+0x10>
4000ec4c: 90 10 00 18 mov %i0, %o0
return rc;
}
}
return rc;
4000ec50: 90 10 20 00 clr %o0
}
4000ec54: 81 c7 e0 08 ret
4000ec58: 91 e8 00 08 restore %g0, %o0, %o0
return -1;
4000ec5c: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
}
4000ec60: 81 c7 e0 08 ret <== NOT EXECUTED
4000ec64: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
4000e0e4 <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)
{
4000e0e4: 9d e3 bf 10 save %sp, -240, %sp
ssize_t ret = 0;
struct stat stat_buf;
int i = 0;
rtems_bdbuf_buffer *block = NULL;
vol->fd = open(device, O_RDWR);
4000e0e8: 92 10 20 02 mov 2, %o1
rtems_bdbuf_buffer *block = NULL;
4000e0ec: c0 27 bf 84 clr [ %fp + -124 ]
vol->fd = open(device, O_RDWR);
4000e0f0: 7f ff d3 cc call 40003020 <open>
4000e0f4: 90 10 00 19 mov %i1, %o0
4000e0f8: d0 26 20 68 st %o0, [ %i0 + 0x68 ]
if (vol->fd < 0)
4000e0fc: 80 a2 20 00 cmp %o0, 0
4000e100: 06 80 01 ea bl 4000e8a8 <fat_init_volume_info+0x7c4> <== NEVER TAKEN
4000e104: a0 10 00 18 mov %i0, %l0
{
rtems_set_errno_and_return_minus_one(ENXIO);
}
rc = fstat(vol->fd, &stat_buf);
4000e108: 7f ff d1 40 call 40002608 <fstat>
4000e10c: 92 07 bf 98 add %fp, -104, %o1
if (rc != 0)
4000e110: 80 a2 20 00 cmp %o0, 0
4000e114: 12 80 01 e2 bne 4000e89c <fat_init_volume_info+0x7b8> <== NEVER TAKEN
4000e118: 07 00 00 3c sethi %hi(0xf000), %g3
close(vol->fd);
rtems_set_errno_and_return_minus_one(ENXIO);
}
/* Must be a block device. */
if (!S_ISBLK(stat_buf.st_mode))
4000e11c: c4 07 bf a8 ld [ %fp + -88 ], %g2
4000e120: 84 08 80 03 and %g2, %g3, %g2
4000e124: 07 00 00 18 sethi %hi(0x6000), %g3
4000e128: 80 a0 80 03 cmp %g2, %g3
4000e12c: 12 80 01 dd bne 4000e8a0 <fat_init_volume_info+0x7bc> <== NEVER TAKEN
4000e130: d0 06 20 68 ld [ %i0 + 0x68 ], %o0
return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);
4000e134: 94 06 20 6c add %i0, 0x6c, %o2
4000e138: 13 10 01 10 sethi %hi(0x40044000), %o1
4000e13c: 7f ff fb 8c call 4000cf6c <ioctl>
4000e140: 92 12 62 09 or %o1, 0x209, %o1 ! 40044209 <__end+0x178c9>
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);
if (rc != 0) {
4000e144: b0 92 20 00 orcc %o0, 0, %i0
4000e148: 12 80 01 d5 bne 4000e89c <fat_init_volume_info+0x7b8> <== NEVER TAKEN
4000e14c: c4 1f bf b8 ldd [ %fp + -72 ], %g2
close(vol->fd);
rtems_set_errno_and_return_minus_one(ENXIO);
}
vol->dev = stat_buf.st_rdev;
4000e150: c4 3c 20 70 std %g2, [ %l0 + 0x70 ]
/* Read boot record */
/* FIXME: Asserts FAT_MAX_BPB_SIZE < bdbuf block size */
sc = rtems_bdbuf_read( vol->dd, 0, &block);
4000e154: 94 07 bf 84 add %fp, -124, %o2
4000e158: d0 04 20 6c ld [ %l0 + 0x6c ], %o0
4000e15c: 40 00 23 26 call 40016df4 <rtems_bdbuf_read>
4000e160: 92 10 20 00 clr %o1
if (sc != RTEMS_SUCCESSFUL)
4000e164: 80 a2 20 00 cmp %o0, 0
4000e168: 12 80 01 d6 bne 4000e8c0 <fat_init_volume_info+0x7dc> <== NEVER TAKEN
4000e16c: d0 07 bf 84 ld [ %fp + -124 ], %o0
{
close(vol->fd);
rtems_set_errno_and_return_minus_one( EIO);
}
memcpy( boot_rec, block->buffer, FAT_MAX_BPB_SIZE);
4000e170: c4 02 20 1c ld [ %o0 + 0x1c ], %g2
4000e174: c2 08 a0 20 ldub [ %g2 + 0x20 ], %g1
4000e178: c2 2f bf 7f stb %g1, [ %fp + -129 ]
4000e17c: c2 08 a0 21 ldub [ %g2 + 0x21 ], %g1
4000e180: c2 2f bf 7e stb %g1, [ %fp + -130 ]
4000e184: c2 08 a0 22 ldub [ %g2 + 0x22 ], %g1
4000e188: c2 2f bf 7d stb %g1, [ %fp + -131 ]
4000e18c: c2 08 a0 23 ldub [ %g2 + 0x23 ], %g1
4000e190: f6 08 a0 13 ldub [ %g2 + 0x13 ], %i3
4000e194: c2 2f bf 7b stb %g1, [ %fp + -133 ]
4000e198: b7 2e e0 08 sll %i3, 8, %i3
4000e19c: c2 08 a0 25 ldub [ %g2 + 0x25 ], %g1
4000e1a0: c8 08 a0 14 ldub [ %g2 + 0x14 ], %g4
4000e1a4: c2 2f bf 7c stb %g1, [ %fp + -132 ]
4000e1a8: 88 11 00 1b or %g4, %i3, %g4
4000e1ac: c2 08 a0 2c ldub [ %g2 + 0x2c ], %g1
4000e1b0: f2 08 a0 0b ldub [ %g2 + 0xb ], %i1
4000e1b4: da 08 a0 0c ldub [ %g2 + 0xc ], %o5
4000e1b8: fa 08 a0 0e ldub [ %g2 + 0xe ], %i5
4000e1bc: f4 08 a0 0f ldub [ %g2 + 0xf ], %i2
4000e1c0: e4 08 a0 11 ldub [ %g2 + 0x11 ], %l2
4000e1c4: de 08 a0 12 ldub [ %g2 + 0x12 ], %o7
4000e1c8: c6 08 a0 16 ldub [ %g2 + 0x16 ], %g3
4000e1cc: f8 08 a0 17 ldub [ %g2 + 0x17 ], %i4
4000e1d0: d8 08 a0 30 ldub [ %g2 + 0x30 ], %o4
4000e1d4: d6 08 a0 31 ldub [ %g2 + 0x31 ], %o3
4000e1d8: e2 08 a0 0d ldub [ %g2 + 0xd ], %l1
4000e1dc: f6 08 a0 10 ldub [ %g2 + 0x10 ], %i3
4000e1e0: ec 08 a0 24 ldub [ %g2 + 0x24 ], %l6
4000e1e4: e8 08 a0 26 ldub [ %g2 + 0x26 ], %l4
4000e1e8: ea 08 a0 27 ldub [ %g2 + 0x27 ], %l5
4000e1ec: ee 08 a0 28 ldub [ %g2 + 0x28 ], %l7
4000e1f0: c2 2f bf 76 stb %g1, [ %fp + -138 ]
4000e1f4: bb 2f 60 08 sll %i5, 8, %i5
4000e1f8: c2 08 a0 2d ldub [ %g2 + 0x2d ], %g1
4000e1fc: c2 2f bf 75 stb %g1, [ %fp + -139 ]
4000e200: a5 2c a0 08 sll %l2, 8, %l2
4000e204: c2 08 a0 2e ldub [ %g2 + 0x2e ], %g1
4000e208: 87 28 e0 08 sll %g3, 8, %g3
4000e20c: b4 16 80 1d or %i2, %i5, %i2
4000e210: 93 29 20 08 sll %g4, 8, %o1
4000e214: a7 2e a0 08 sll %i2, 8, %l3
4000e218: b8 17 00 03 or %i4, %g3, %i4
4000e21c: c2 2f bf 77 stb %g1, [ %fp + -137 ]
4000e220: b3 2e 60 08 sll %i1, 8, %i1
4000e224: c2 08 a0 2f ldub [ %g2 + 0x2f ], %g1
4000e228: 9a 13 40 19 or %o5, %i1, %o5
4000e22c: 9e 13 c0 12 or %o7, %l2, %o7
4000e230: bb 2b 60 08 sll %o5, 8, %i5
4000e234: a5 2b e0 08 sll %o7, 8, %l2
4000e238: 9b 33 60 08 srl %o5, 8, %o5
4000e23c: 9f 33 e0 08 srl %o7, 8, %o7
4000e240: 89 31 20 08 srl %g4, 8, %g4
4000e244: 99 2b 20 08 sll %o4, 8, %o4
4000e248: 95 2f 20 08 sll %i4, 8, %o2
4000e24c: 87 37 20 08 srl %i4, 8, %g3
4000e250: b2 17 40 0d or %i5, %o5, %i1
4000e254: c2 2f bf 73 stb %g1, [ %fp + -141 ]
4000e258: b5 36 a0 08 srl %i2, 8, %i2
4000e25c: a4 14 80 0f or %l2, %o7, %l2
4000e260: b4 14 c0 1a or %l3, %i2, %i2
4000e264: ba 12 40 04 or %o1, %g4, %i5
4000e268: b8 12 80 03 or %o2, %g3, %i4
sc = rtems_bdbuf_release( block);
4000e26c: 40 00 23 6a call 40017014 <rtems_bdbuf_release>
4000e270: a6 12 c0 0c or %o3, %o4, %l3
if (sc != RTEMS_SUCCESSFUL)
4000e274: 80 a2 20 00 cmp %o0, 0
4000e278: 12 80 01 92 bne 4000e8c0 <fat_init_volume_info+0x7dc> <== NEVER TAKEN
4000e27c: 86 06 78 00 add %i1, -2048, %g3
/* Evaluate boot record */
vol->bps = FAT_GET_BR_BYTES_PER_SECTOR(boot_rec);
if ( (vol->bps != 512) &&
(vol->bps != 1024) &&
4000e280: 09 3f ff c2 sethi %hi(0xffff0800), %g4
(vol->bps != 2048) &&
4000e284: 80 a8 c0 04 andncc %g3, %g4, %g0
4000e288: 02 80 00 08 be 4000e2a8 <fat_init_volume_info+0x1c4> <== NEVER TAKEN
4000e28c: f2 34 00 00 sth %i1, [ %l0 ]
if ( (vol->bps != 512) &&
4000e290: 86 06 7e 00 add %i1, -512, %g3
4000e294: 86 08 fd ff and %g3, -513, %g3
4000e298: 87 28 e0 10 sll %g3, 0x10, %g3
(vol->bps != 2048) &&
4000e29c: 80 a0 e0 00 cmp %g3, 0
4000e2a0: 12 80 01 77 bne 4000e87c <fat_init_volume_info+0x798> <== NEVER TAKEN
4000e2a4: 01 00 00 00 nop
(vol->bps != 4096))
{
close(vol->fd);
rtems_set_errno_and_return_minus_one( EINVAL );
}
for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
4000e2a8: 93 2e 60 10 sll %i1, 0x10, %o1
4000e2ac: 87 32 60 19 srl %o1, 0x19, %g3
4000e2b0: 80 88 e0 01 btst 1, %g3
4000e2b4: 12 80 00 09 bne 4000e2d8 <fat_init_volume_info+0x1f4> <== ALWAYS TAKEN
4000e2b8: c0 2c 20 03 clrb [ %l0 + 3 ]
4000e2bc: 88 10 20 01 mov 1, %g4 <== NOT EXECUTED
i >>= 1, vol->sec_mul++);
4000e2c0: 87 38 e0 01 sra %g3, 1, %g3 <== NOT EXECUTED
for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
4000e2c4: 9e 10 00 04 mov %g4, %o7 <== NOT EXECUTED
4000e2c8: 80 88 e0 01 btst 1, %g3 <== NOT EXECUTED
4000e2cc: 02 bf ff fd be 4000e2c0 <fat_init_volume_info+0x1dc> <== NOT EXECUTED
4000e2d0: 88 01 20 01 inc %g4 <== NOT EXECUTED
4000e2d4: de 2c 20 03 stb %o7, [ %l0 + 3 ] <== NOT EXECUTED
for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0;
4000e2d8: 87 32 60 10 srl %o1, 0x10, %g3
4000e2dc: 80 8e 60 01 btst 1, %i1
4000e2e0: 12 80 00 09 bne 4000e304 <fat_init_volume_info+0x220> <== NEVER TAKEN
4000e2e4: c0 2c 20 02 clrb [ %l0 + 2 ]
4000e2e8: 84 10 20 01 mov 1, %g2
i >>= 1, vol->sec_log2++);
4000e2ec: 87 38 e0 01 sra %g3, 1, %g3
for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0;
4000e2f0: 88 10 00 02 mov %g2, %g4
4000e2f4: 80 88 e0 01 btst 1, %g3
4000e2f8: 02 bf ff fd be 4000e2ec <fat_init_volume_info+0x208>
4000e2fc: 84 00 a0 01 inc %g2
4000e300: c8 2c 20 02 stb %g4, [ %l0 + 2 ]
/* Assign the sector size as bdbuf block size for now.
* If possible the bdbuf block size will get increased to the cluster
* size at the end of this method for better performance */
sc = rtems_bdbuf_set_block_size (vol->dd, vol->bps, true);
4000e304: 94 10 20 01 mov 1, %o2
4000e308: d0 04 20 6c ld [ %l0 + 0x6c ], %o0
4000e30c: 40 00 23 dd call 40017280 <rtems_bdbuf_set_block_size>
4000e310: 93 32 60 10 srl %o1, 0x10, %o1
if (sc != RTEMS_SUCCESSFUL)
4000e314: 80 a2 20 00 cmp %o0, 0
4000e318: 12 80 01 59 bne 4000e87c <fat_init_volume_info+0x798> <== NEVER TAKEN
4000e31c: 84 10 20 01 mov 1, %g2
{
close(vol->fd);
rtems_set_errno_and_return_minus_one( EINVAL );
}
vol->bytes_per_block = vol->bps;
4000e320: c8 14 00 00 lduh [ %l0 ], %g4
vol->bytes_per_block_log2 = vol->sec_log2;
4000e324: da 0c 20 02 ldub [ %l0 + 2 ], %o5
vol->bytes_per_block = vol->bps;
4000e328: 89 29 20 10 sll %g4, 0x10, %g4
4000e32c: 9f 31 20 10 srl %g4, 0x10, %o7
vol->bytes_per_block_log2 = vol->sec_log2;
4000e330: da 2c 20 14 stb %o5, [ %l0 + 0x14 ]
vol->spc = FAT_GET_BR_SECTORS_PER_CLUSTER(boot_rec);
/*
* "sectors per cluster" of zero is invalid
* (and would hang the following loop)
*/
if (vol->spc == 0)
4000e334: 98 8c 60 ff andcc %l1, 0xff, %o4
vol->bytes_per_block = vol->bps;
4000e338: de 24 20 10 st %o7, [ %l0 + 0x10 ]
vol->sectors_per_block = 1;
4000e33c: c4 2c 20 0d stb %g2, [ %l0 + 0xd ]
if (vol->spc == 0)
4000e340: 02 80 01 4f be 4000e87c <fat_init_volume_info+0x798> <== NEVER TAKEN
4000e344: e2 2c 20 04 stb %l1, [ %l0 + 4 ]
{
close(vol->fd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;
4000e348: c0 2c 20 05 clrb [ %l0 + 5 ]
4000e34c: 80 8c 60 01 btst 1, %l1
4000e350: 12 80 01 42 bne 4000e858 <fat_init_volume_info+0x774>
4000e354: 84 10 00 0c mov %o4, %g2
4000e358: 86 10 20 01 mov 1, %g3
i >>= 1, vol->spc_log2++);
4000e35c: 85 38 a0 01 sra %g2, 1, %g2
for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;
4000e360: 96 10 00 03 mov %g3, %o3
4000e364: 80 88 a0 01 btst 1, %g2
4000e368: 02 bf ff fd be 4000e35c <fat_init_volume_info+0x278>
4000e36c: 86 00 e0 01 inc %g3
4000e370: d6 2c 20 05 stb %o3, [ %l0 + 5 ]
/* Sectors per cluster must be a power of two */
if (vol->spc != UINT32_C(1) << vol->spc_log2)
4000e374: 84 10 20 01 mov 1, %g2
4000e378: 86 0a e0 ff and %o3, 0xff, %g3
4000e37c: 85 28 80 0b sll %g2, %o3, %g2
4000e380: 80 a3 00 02 cmp %o4, %g2
4000e384: 12 80 01 3e bne 4000e87c <fat_init_volume_info+0x798> <== NEVER TAKEN
4000e388: 87 2b c0 03 sll %o7, %g3, %g3
rtems_set_errno_and_return_minus_one(EINVAL);
}
vol->bpc = ((uint32_t) vol->bps) << vol->spc_log2;
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
4000e38c: c0 2c 20 0c clrb [ %l0 + 0xc ]
4000e390: 84 10 00 03 mov %g3, %g2
4000e394: 80 88 e0 01 btst 1, %g3
4000e398: 12 80 00 09 bne 4000e3bc <fat_init_volume_info+0x2d8> <== NEVER TAKEN
4000e39c: c6 24 20 08 st %g3, [ %l0 + 8 ]
4000e3a0: 86 10 20 01 mov 1, %g3
i >>= 1, vol->bpc_log2++);
4000e3a4: 85 38 a0 01 sra %g2, 1, %g2
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
4000e3a8: 9e 10 00 03 mov %g3, %o7
4000e3ac: 80 88 a0 01 btst 1, %g2
4000e3b0: 02 bf ff fd be 4000e3a4 <fat_init_volume_info+0x2c0>
4000e3b4: 86 00 e0 01 inc %g3
4000e3b8: de 2c 20 0c stb %o7, [ %l0 + 0xc ]
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
/* calculate the count of sectors occupied by the root directory */
vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
4000e3bc: 89 31 20 10 srl %g4, 0x10, %g4
4000e3c0: 85 2c a0 10 sll %l2, 0x10, %g2
4000e3c4: 86 01 3f ff add %g4, -1, %g3
4000e3c8: 85 30 a0 0b srl %g2, 0xb, %g2
vol->fats = FAT_GET_BR_FAT_NUM(boot_rec);
4000e3cc: f6 2c 20 15 stb %i3, [ %l0 + 0x15 ]
vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
4000e3d0: 84 00 80 03 add %g2, %g3, %g2
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
4000e3d4: f4 34 20 20 sth %i2, [ %l0 + 0x20 ]
vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
4000e3d8: 83 38 a0 1f sra %g2, 0x1f, %g1
4000e3dc: 81 80 60 00 wr %g1, %y
4000e3e0: 01 00 00 00 nop
4000e3e4: 01 00 00 00 nop
4000e3e8: 01 00 00 00 nop
4000e3ec: 88 78 80 04 sdiv %g2, %g4, %g4
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
4000e3f0: e4 34 20 2c sth %l2, [ %l0 + 0x2c ]
vol->bps;
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
4000e3f4: 9b 29 00 0d sll %g4, %o5, %o5
vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
4000e3f8: c8 24 20 30 st %g4, [ %l0 + 0x30 ]
if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)
4000e3fc: b9 2f 20 10 sll %i4, 0x10, %i4
4000e400: b9 37 20 10 srl %i4, 0x10, %i4
4000e404: 80 a7 20 00 cmp %i4, 0
4000e408: 02 80 00 a2 be 4000e690 <fat_init_volume_info+0x5ac>
4000e40c: da 24 20 34 st %o5, [ %l0 + 0x34 ]
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT(boot_rec);
else
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT32(boot_rec);
vol->data_fsec = vol->fat_loc + vol->fats * vol->fat_length +
4000e410: b6 0e e0 ff and %i3, 0xff, %i3
4000e414: b5 2e a0 10 sll %i2, 0x10, %i2
4000e418: b6 5e c0 1c smul %i3, %i4, %i3
4000e41c: b5 36 a0 10 srl %i2, 0x10, %i2
4000e420: f8 24 20 24 st %i4, [ %l0 + 0x24 ]
4000e424: b6 06 c0 1a add %i3, %i2, %i3
4000e428: 88 01 00 1b add %g4, %i3, %g4
vol->rdir_secs;
/* for FAT12/16 root dir starts at(sector) */
vol->rdir_loc = vol->fat_loc + vol->fats * vol->fat_length;
4000e42c: f6 24 20 28 st %i3, [ %l0 + 0x28 ]
if ( (FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec)) != 0)
4000e430: bb 2f 60 10 sll %i5, 0x10, %i5
4000e434: bb 37 60 10 srl %i5, 0x10, %i5
4000e438: 80 a7 60 00 cmp %i5, 0
4000e43c: 02 80 00 7a be 4000e624 <fat_init_volume_info+0x540>
4000e440: c8 24 20 3c st %g4, [ %l0 + 0x3c ]
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec);
else
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM32(boot_rec);
data_secs = vol->tot_secs - vol->data_fsec;
4000e444: 88 27 40 04 sub %i5, %g4, %g4
4000e448: fa 24 20 38 st %i5, [ %l0 + 0x38 ]
vol->data_cls = data_secs / vol->spc;
4000e44c: 81 80 20 00 wr %g0, %y
4000e450: 01 00 00 00 nop
4000e454: 01 00 00 00 nop
4000e458: 01 00 00 00 nop
4000e45c: 98 71 00 0c udiv %g4, %o4, %o4
/* determine FAT type at least */
if ( vol->data_cls < FAT_FAT12_MAX_CLN)
4000e460: 80 a3 2f f4 cmp %o4, 0xff4
4000e464: 08 80 00 84 bleu 4000e674 <fat_init_volume_info+0x590>
4000e468: d8 24 20 40 st %o4, [ %l0 + 0x40 ]
vol->mask = FAT_FAT12_MASK;
vol->eoc_val = FAT_FAT12_EOC;
}
else
{
if ( vol->data_cls < FAT_FAT16_MAX_CLN)
4000e46c: 05 00 00 3f sethi %hi(0xfc00), %g2
4000e470: 86 10 a3 f4 or %g2, 0x3f4, %g3 ! fff4 <_ISR_Stack_size+0xeff4>
4000e474: 80 a3 00 03 cmp %o4, %g3
4000e478: 38 80 00 9e bgu,a 4000e6f0 <fat_init_volume_info+0x60c>
4000e47c: 05 03 ff ff sethi %hi(0xffffc00), %g2
{
vol->type = FAT_FAT16;
vol->mask = FAT_FAT16_MASK;
4000e480: 86 10 a3 ff or %g2, 0x3ff, %g3 ! fffffff <RAM_SIZE+0xfbfffff>
vol->type = FAT_FAT16;
4000e484: 88 10 20 02 mov 2, %g4
vol->eoc_val = FAT_FAT16_EOC;
4000e488: 84 10 a3 f8 or %g2, 0x3f8, %g2
vol->type = FAT_FAT16;
4000e48c: c8 2c 20 16 stb %g4, [ %l0 + 0x16 ]
vol->mask = FAT_FAT16_MASK;
4000e490: c6 24 20 18 st %g3, [ %l0 + 0x18 ]
vol->eoc_val = FAT_FAT16_EOC;
4000e494: c4 24 20 1c st %g2, [ %l0 + 0x1c ]
else
{
vol->rdir_cl = 0;
vol->mirror = 0;
vol->afat = 0;
vol->free_cls = FAT_UNDEFINED_VALUE;
4000e498: 84 10 3f ff mov -1, %g2
vol->rdir_cl = 0;
4000e49c: c0 24 20 44 clr [ %l0 + 0x44 ]
vol->mirror = 0;
4000e4a0: c0 2c 20 5c clrb [ %l0 + 0x5c ]
vol->afat = 0;
4000e4a4: c0 2c 20 64 clrb [ %l0 + 0x64 ]
vol->free_cls = FAT_UNDEFINED_VALUE;
4000e4a8: c4 24 20 4c st %g2, [ %l0 + 0x4c ]
vol->next_cl = FAT_UNDEFINED_VALUE;
4000e4ac: c4 24 20 54 st %g2, [ %l0 + 0x54 ]
if (fs_info->c.state == FAT_CACHE_EMPTY)
4000e4b0: c4 0c 20 9d ldub [ %l0 + 0x9d ], %g2
4000e4b4: 80 a0 a0 00 cmp %g2, 0
4000e4b8: 22 80 00 05 be,a 4000e4cc <fat_init_volume_info+0x3e8>
4000e4bc: c4 0c 20 64 ldub [ %l0 + 0x64 ], %g2
4000e4c0: 7f ff fd 58 call 4000da20 <fat_buf_release.part.0>
4000e4c4: 90 10 00 10 mov %l0, %o0
}
_fat_block_release(fs_info);
vol->afat_loc = vol->fat_loc + vol->fat_length * vol->afat;
4000e4c8: c4 0c 20 64 ldub [ %l0 + 0x64 ], %g2
4000e4cc: c8 04 20 24 ld [ %l0 + 0x24 ], %g4
4000e4d0: c6 14 20 20 lduh [ %l0 + 0x20 ], %g3
4000e4d4: 84 58 80 04 smul %g2, %g4, %g2
4000e4d8: 84 00 80 03 add %g2, %g3, %g2
4000e4dc: c4 24 20 60 st %g2, [ %l0 + 0x60 ]
/* set up collection of fat-files fd */
fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
4000e4e0: 92 10 20 0c mov 0xc, %o1
4000e4e4: 7f ff fa 25 call 4000cd78 <calloc>
4000e4e8: 90 10 20 02 mov 2, %o0
4000e4ec: d0 24 20 80 st %o0, [ %l0 + 0x80 ]
if ( fs_info->vhash == NULL )
4000e4f0: 80 a2 20 00 cmp %o0, 0
4000e4f4: 02 80 01 05 be 4000e908 <fat_init_volume_info+0x824> <== NEVER TAKEN
4000e4f8: 84 10 00 08 mov %o0, %g2
head->previous = NULL;
4000e4fc: c0 22 20 04 clr [ %o0 + 4 ]
return &the_chain->Tail.Node;
4000e500: ba 02 20 04 add %o0, 4, %i5
head->next = tail;
4000e504: fa 22 00 00 st %i5, [ %o0 ]
return &the_chain->Tail.Node;
4000e508: 86 02 20 0c add %o0, 0xc, %g3
4000e50c: 88 02 20 10 add %o0, 0x10, %g4
tail->previous = head;
4000e510: c4 20 a0 08 st %g2, [ %g2 + 8 ]
}
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));
4000e514: 92 10 20 0c mov 0xc, %o1
head->next = tail;
4000e518: c8 20 a0 0c st %g4, [ %g2 + 0xc ]
4000e51c: 90 10 20 02 mov 2, %o0
head->previous = NULL;
4000e520: c0 20 a0 10 clr [ %g2 + 0x10 ]
4000e524: 7f ff fa 15 call 4000cd78 <calloc>
4000e528: c6 20 a0 14 st %g3, [ %g2 + 0x14 ]
4000e52c: d0 24 20 84 st %o0, [ %l0 + 0x84 ]
if ( fs_info->rhash == NULL )
4000e530: 80 a2 20 00 cmp %o0, 0
4000e534: 02 80 01 0c be 4000e964 <fat_init_volume_info+0x880> <== NEVER TAKEN
4000e538: 84 10 00 08 mov %o0, %g2
}
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;
4000e53c: c8 0c 20 03 ldub [ %l0 + 3 ], %g4
4000e540: c6 04 20 38 ld [ %l0 + 0x38 ], %g3
4000e544: 87 28 c0 04 sll %g3, %g4, %g3
4000e548: 87 28 e0 04 sll %g3, 4, %g3
4000e54c: c0 22 20 04 clr [ %o0 + 4 ]
return &the_chain->Tail.Node;
4000e550: ba 02 20 04 add %o0, 4, %i5
4000e554: c6 24 20 94 st %g3, [ %l0 + 0x94 ]
fs_info->uino_pool_size = FAT_UINO_POOL_INIT_SIZE;
4000e558: 86 10 21 00 mov 0x100, %g3
head->next = tail;
4000e55c: fa 22 00 00 st %i5, [ %o0 ]
return &the_chain->Tail.Node;
4000e560: 88 02 20 10 add %o0, 0x10, %g4
4000e564: c6 24 20 90 st %g3, [ %l0 + 0x90 ]
4000e568: 86 02 20 0c add %o0, 0xc, %g3
fs_info->index = 0;
4000e56c: c0 24 20 8c clr [ %l0 + 0x8c ]
fs_info->uino = (char *)calloc(fs_info->uino_pool_size, sizeof(char));
4000e570: 92 10 20 01 mov 1, %o1
tail->previous = head;
4000e574: c4 20 a0 08 st %g2, [ %g2 + 8 ]
4000e578: 90 10 21 00 mov 0x100, %o0
head->next = tail;
4000e57c: c8 20 a0 0c st %g4, [ %g2 + 0xc ]
head->previous = NULL;
4000e580: c0 20 a0 10 clr [ %g2 + 0x10 ]
4000e584: 7f ff f9 fd call 4000cd78 <calloc>
4000e588: c6 20 a0 14 st %g3, [ %g2 + 0x14 ]
if ( fs_info->uino == NULL )
4000e58c: 80 a2 20 00 cmp %o0, 0
4000e590: 02 80 00 f9 be 4000e974 <fat_init_volume_info+0x890> <== NEVER TAKEN
4000e594: d0 24 20 88 st %o0, [ %l0 + 0x88 ]
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));
4000e598: d0 14 00 00 lduh [ %l0 ], %o0
4000e59c: 7f ff f9 f7 call 4000cd78 <calloc>
4000e5a0: 92 10 20 01 mov 1, %o1
if (fs_info->sec_buf == NULL)
4000e5a4: 80 a2 20 00 cmp %o0, 0
4000e5a8: 02 80 00 e0 be 4000e928 <fat_init_volume_info+0x844> <== NEVER TAKEN
4000e5ac: d0 24 20 a4 st %o0, [ %l0 + 0xa4 ]
return (sec_num & (vol->spc - 1)) == 0;
4000e5b0: c4 0c 20 04 ldub [ %l0 + 4 ], %g2
4000e5b4: c6 04 20 3c ld [ %l0 + 0x3c ], %g3
4000e5b8: 84 00 bf ff add %g2, -1, %g2
/*
* 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)
4000e5bc: 80 88 80 03 btst %g2, %g3
4000e5c0: 12 80 00 e7 bne 4000e95c <fat_init_volume_info+0x878> <== NEVER TAKEN
4000e5c4: 01 00 00 00 nop
&& (FAT_FAT32 == vol->type || is_cluster_aligned(vol, vol->rdir_loc)))
4000e5c8: c6 0c 20 16 ldub [ %l0 + 0x16 ], %g3
4000e5cc: 80 a0 e0 04 cmp %g3, 4
4000e5d0: 22 80 00 07 be,a 4000e5ec <fat_init_volume_info+0x508>
4000e5d4: d2 04 20 08 ld [ %l0 + 8 ], %o1
return (sec_num & (vol->spc - 1)) == 0;
4000e5d8: c6 04 20 28 ld [ %l0 + 0x28 ], %g3
&& (FAT_FAT32 == vol->type || is_cluster_aligned(vol, vol->rdir_loc)))
4000e5dc: 80 88 80 03 btst %g2, %g3
4000e5e0: 12 80 00 df bne 4000e95c <fat_init_volume_info+0x878> <== NEVER TAKEN
4000e5e4: 01 00 00 00 nop
{
sc = rtems_bdbuf_set_block_size (vol->dd, vol->bpc, true);
4000e5e8: d2 04 20 08 ld [ %l0 + 8 ], %o1
4000e5ec: d0 04 20 6c ld [ %l0 + 0x6c ], %o0
4000e5f0: 40 00 23 24 call 40017280 <rtems_bdbuf_set_block_size>
4000e5f4: 94 10 20 01 mov 1, %o2
if (sc == RTEMS_SUCCESSFUL)
4000e5f8: 80 a2 20 00 cmp %o0, 0
4000e5fc: 12 80 00 d8 bne 4000e95c <fat_init_volume_info+0x878>
4000e600: 01 00 00 00 nop
{
vol->bytes_per_block = vol->bpc;
4000e604: c8 04 20 08 ld [ %l0 + 8 ], %g4
vol->bytes_per_block_log2 = vol->bpc_log2;
4000e608: c6 0c 20 0c ldub [ %l0 + 0xc ], %g3
vol->sectors_per_block = vol->spc;
4000e60c: c4 0c 20 04 ldub [ %l0 + 4 ], %g2
vol->bytes_per_block = vol->bpc;
4000e610: c8 24 20 10 st %g4, [ %l0 + 0x10 ]
vol->bytes_per_block_log2 = vol->bpc_log2;
4000e614: c6 2c 20 14 stb %g3, [ %l0 + 0x14 ]
vol->sectors_per_block = vol->spc;
4000e618: c4 2c 20 0d stb %g2, [ %l0 + 0xd ]
4000e61c: 81 c7 e0 08 ret
4000e620: 81 e8 00 00 restore
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM32(boot_rec);
4000e624: c4 0f bf 7d ldub [ %fp + -131 ], %g2
4000e628: 85 28 a0 10 sll %g2, 0x10, %g2
4000e62c: fa 0f bf 7e ldub [ %fp + -130 ], %i5
4000e630: c6 0f bf 7f ldub [ %fp + -129 ], %g3
4000e634: c2 07 bf 78 ld [ %fp + -136 ], %g1
4000e638: bb 2f 60 08 sll %i5, 8, %i5
4000e63c: ba 17 40 02 or %i5, %g2, %i5
4000e640: 85 28 60 18 sll %g1, 0x18, %g2
4000e644: ba 17 40 03 or %i5, %g3, %i5
4000e648: ba 17 40 02 or %i5, %g2, %i5
data_secs = vol->tot_secs - vol->data_fsec;
4000e64c: 88 27 40 04 sub %i5, %g4, %g4
4000e650: fa 24 20 38 st %i5, [ %l0 + 0x38 ]
vol->data_cls = data_secs / vol->spc;
4000e654: 81 80 20 00 wr %g0, %y
4000e658: 01 00 00 00 nop
4000e65c: 01 00 00 00 nop
4000e660: 01 00 00 00 nop
4000e664: 98 71 00 0c udiv %g4, %o4, %o4
if ( vol->data_cls < FAT_FAT12_MAX_CLN)
4000e668: 80 a3 2f f4 cmp %o4, 0xff4
4000e66c: 18 bf ff 80 bgu 4000e46c <fat_init_volume_info+0x388>
4000e670: d8 24 20 40 st %o4, [ %l0 + 0x40 ]
vol->type = FAT_FAT12;
4000e674: 84 10 20 01 mov 1, %g2
4000e678: c4 2c 20 16 stb %g2, [ %l0 + 0x16 ]
vol->mask = FAT_FAT12_MASK;
4000e67c: 84 10 2f ff mov 0xfff, %g2
4000e680: c4 24 20 18 st %g2, [ %l0 + 0x18 ]
vol->eoc_val = FAT_FAT12_EOC;
4000e684: 84 10 2f f8 mov 0xff8, %g2
4000e688: 10 bf ff 84 b 4000e498 <fat_init_volume_info+0x3b4>
4000e68c: c4 24 20 1c st %g2, [ %l0 + 0x1c ]
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT32(boot_rec);
4000e690: f8 0f bf 7c ldub [ %fp + -132 ], %i4
4000e694: a8 0d 20 ff and %l4, 0xff, %l4
4000e698: b9 2f 20 08 sll %i4, 8, %i4
4000e69c: a9 2d 20 10 sll %l4, 0x10, %l4
4000e6a0: ac 0d a0 ff and %l6, 0xff, %l6
4000e6a4: b8 17 00 14 or %i4, %l4, %i4
4000e6a8: ab 2d 60 18 sll %l5, 0x18, %l5
4000e6ac: b8 17 00 16 or %i4, %l6, %i4
vol->data_fsec = vol->fat_loc + vol->fats * vol->fat_length +
4000e6b0: b6 0e e0 ff and %i3, 0xff, %i3
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT32(boot_rec);
4000e6b4: b8 17 00 15 or %i4, %l5, %i4
vol->data_fsec = vol->fat_loc + vol->fats * vol->fat_length +
4000e6b8: b5 2e a0 10 sll %i2, 0x10, %i2
4000e6bc: b6 5e c0 1c smul %i3, %i4, %i3
4000e6c0: b5 36 a0 10 srl %i2, 0x10, %i2
4000e6c4: f8 24 20 24 st %i4, [ %l0 + 0x24 ]
4000e6c8: b6 06 c0 1a add %i3, %i2, %i3
4000e6cc: 88 01 00 1b add %g4, %i3, %g4
vol->rdir_loc = vol->fat_loc + vol->fats * vol->fat_length;
4000e6d0: f6 24 20 28 st %i3, [ %l0 + 0x28 ]
if ( (FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec)) != 0)
4000e6d4: bb 2f 60 10 sll %i5, 0x10, %i5
4000e6d8: bb 37 60 10 srl %i5, 0x10, %i5
4000e6dc: 80 a7 60 00 cmp %i5, 0
4000e6e0: 12 bf ff 59 bne 4000e444 <fat_init_volume_info+0x360> <== NEVER TAKEN
4000e6e4: c8 24 20 3c st %g4, [ %l0 + 0x3c ]
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM32(boot_rec);
4000e6e8: 10 bf ff d0 b 4000e628 <fat_init_volume_info+0x544>
4000e6ec: c4 0f bf 7d ldub [ %fp + -131 ], %g2
else if ( vol->data_cls < FAT_FAT32_MASK - 1 )
4000e6f0: 86 10 a3 fd or %g2, 0x3fd, %g3
4000e6f4: 80 a3 00 03 cmp %o4, %g3
4000e6f8: 18 80 00 61 bgu 4000e87c <fat_init_volume_info+0x798> <== NEVER TAKEN
4000e6fc: c6 0f bf 77 ldub [ %fp + -137 ], %g3
vol->mask = FAT_FAT32_MASK;
4000e700: b8 10 a3 ff or %g2, 0x3ff, %i4
vol->eoc_val = FAT_FAT32_EOC;
4000e704: ba 10 a3 f8 or %g2, 0x3f8, %i5
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
4000e708: 87 28 e0 10 sll %g3, 0x10, %g3
4000e70c: c4 0f bf 75 ldub [ %fp + -139 ], %g2
4000e710: c2 07 bf 70 ld [ %fp + -144 ], %g1
4000e714: c8 0f bf 76 ldub [ %fp + -138 ], %g4
4000e718: 85 28 a0 08 sll %g2, 8, %g2
4000e71c: 84 10 80 03 or %g2, %g3, %g2
4000e720: 87 28 60 18 sll %g1, 0x18, %g3
4000e724: 84 10 80 04 or %g2, %g4, %g2
vol->mask = FAT_FAT32_MASK;
4000e728: f8 24 20 18 st %i4, [ %l0 + 0x18 ]
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
4000e72c: 84 10 80 03 or %g2, %g3, %g2
vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
4000e730: 88 0d ff 80 and %l7, -128, %g4
vol->type = FAT_FAT32;
4000e734: 86 10 20 04 mov 4, %g3
vol->eoc_val = FAT_FAT32_EOC;
4000e738: fa 24 20 1c st %i5, [ %l0 + 0x1c ]
if (vol->mirror)
4000e73c: 80 8d e0 80 btst 0x80, %l7
vol->type = FAT_FAT32;
4000e740: c6 2c 20 16 stb %g3, [ %l0 + 0x16 ]
vol->afat = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_FAT_NUM;
4000e744: 86 0d e0 0f and %l7, 0xf, %g3
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
4000e748: c4 24 20 44 st %g2, [ %l0 + 0x44 ]
if (vol->mirror)
4000e74c: 02 80 00 41 be 4000e850 <fat_init_volume_info+0x76c> <== ALWAYS TAKEN
4000e750: c8 2c 20 5c stb %g4, [ %l0 + 0x5c ]
4000e754: 93 2c e0 08 sll %l3, 8, %o1
4000e758: c6 2c 20 64 stb %g3, [ %l0 + 0x64 ]
vol->info_sec = FAT_GET_BR_FAT32_FS_INFO_SECTOR(boot_rec);
4000e75c: a7 34 e0 08 srl %l3, 8, %l3
4000e760: 92 12 40 13 or %o1, %l3, %o1
4000e764: d2 34 20 48 sth %o1, [ %l0 + 0x48 ]
if( vol->info_sec == 0 )
4000e768: 93 2a 60 10 sll %o1, 0x10, %o1
4000e76c: 93 32 60 10 srl %o1, 0x10, %o1
4000e770: 80 a2 60 00 cmp %o1, 0
4000e774: 02 80 00 42 be 4000e87c <fat_init_volume_info+0x798> <== NEVER TAKEN
4000e778: 96 10 20 04 mov 4, %o3
ret = _fat_block_read(fs_info, vol->info_sec , 0,
4000e77c: 98 07 bf 88 add %fp, -120, %o4
4000e780: 94 10 20 00 clr %o2
4000e784: 7f ff fd 53 call 4000dcd0 <_fat_block_read>
4000e788: 90 10 00 10 mov %l0, %o0
if ( ret < 0 )
4000e78c: 80 a2 20 00 cmp %o0, 0
4000e790: 06 80 00 5a bl 4000e8f8 <fat_init_volume_info+0x814> <== NEVER TAKEN
4000e794: c6 0f bf 8b ldub [ %fp + -117 ], %g3
if (FAT_GET_FSINFO_LEAD_SIGNATURE(fs_info_sector) !=
4000e798: 87 28 e0 18 sll %g3, 0x18, %g3
4000e79c: c4 0f bf 89 ldub [ %fp + -119 ], %g2
4000e7a0: c8 0f bf 8a ldub [ %fp + -118 ], %g4
4000e7a4: fa 0f bf 88 ldub [ %fp + -120 ], %i5
4000e7a8: 85 28 a0 08 sll %g2, 8, %g2
4000e7ac: 89 29 20 10 sll %g4, 0x10, %g4
4000e7b0: 84 10 80 04 or %g2, %g4, %g2
4000e7b4: 84 10 80 1d or %g2, %i5, %g2
4000e7b8: 84 10 80 03 or %g2, %g3, %g2
4000e7bc: 07 10 58 54 sethi %hi(0x41615000), %g3
4000e7c0: 86 10 e2 52 or %g3, 0x252, %g3 ! 41615252 <RAM_END+0x1215252>
4000e7c4: 80 a0 80 03 cmp %g2, %g3
4000e7c8: 12 80 00 27 bne 4000e864 <fat_init_volume_info+0x780> <== NEVER TAKEN
4000e7cc: 98 07 bf 88 add %fp, -120, %o4
ret = _fat_block_read(fs_info, vol->info_sec , FAT_FSI_INFO,
4000e7d0: d2 14 20 48 lduh [ %l0 + 0x48 ], %o1
4000e7d4: 96 10 20 0c mov 0xc, %o3
4000e7d8: 94 10 21 e4 mov 0x1e4, %o2
4000e7dc: 7f ff fd 3d call 4000dcd0 <_fat_block_read>
4000e7e0: 90 10 00 10 mov %l0, %o0
if ( ret < 0 )
4000e7e4: 80 a2 20 00 cmp %o0, 0
4000e7e8: 06 80 00 3e bl 4000e8e0 <fat_init_volume_info+0x7fc> <== NEVER TAKEN
4000e7ec: c6 0f bf 8d ldub [ %fp + -115 ], %g3
FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
4000e7f0: f6 0f bf 8e ldub [ %fp + -114 ], %i3
4000e7f4: f2 0f bf 8c ldub [ %fp + -116 ], %i1
4000e7f8: f8 0f bf 8f ldub [ %fp + -113 ], %i4
FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
4000e7fc: c4 0f bf 91 ldub [ %fp + -111 ], %g2
4000e800: fa 0f bf 92 ldub [ %fp + -110 ], %i5
4000e804: f4 0f bf 90 ldub [ %fp + -112 ], %i2
4000e808: c8 0f bf 93 ldub [ %fp + -109 ], %g4
FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
4000e80c: 87 28 e0 08 sll %g3, 8, %g3
4000e810: b7 2e e0 10 sll %i3, 0x10, %i3
4000e814: b9 2f 20 18 sll %i4, 0x18, %i4
4000e818: 86 10 c0 1b or %g3, %i3, %g3
FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
4000e81c: 85 28 a0 08 sll %g2, 8, %g2
FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
4000e820: 86 10 c0 19 or %g3, %i1, %g3
FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
4000e824: bb 2f 60 10 sll %i5, 0x10, %i5
FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
4000e828: 86 10 c0 1c or %g3, %i4, %g3
FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
4000e82c: 84 10 80 1d or %g2, %i5, %g2
4000e830: 89 29 20 18 sll %g4, 0x18, %g4
4000e834: 84 10 80 1a or %g2, %i2, %g2
vol->free_cls_in_fs_info =
4000e838: c6 24 20 50 st %g3, [ %l0 + 0x50 ]
FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
4000e83c: 84 10 80 04 or %g2, %g4, %g2
vol->free_cls = vol->free_cls_in_fs_info;
4000e840: c6 24 20 4c st %g3, [ %l0 + 0x4c ]
vol->next_cl_in_fs_info =
4000e844: c4 24 20 58 st %g2, [ %l0 + 0x58 ]
vol->next_cl = vol->next_cl_in_fs_info;
4000e848: 10 bf ff 1a b 4000e4b0 <fat_init_volume_info+0x3cc>
4000e84c: c4 24 20 54 st %g2, [ %l0 + 0x54 ]
vol->afat = 0;
4000e850: 10 bf ff c1 b 4000e754 <fat_init_volume_info+0x670>
4000e854: 86 10 20 00 clr %g3
for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;
4000e858: 86 10 20 00 clr %g3
4000e85c: 10 bf fe c9 b 4000e380 <fat_init_volume_info+0x29c>
4000e860: 84 10 20 01 mov 1, %g2
if (fs_info->c.state == FAT_CACHE_EMPTY)
4000e864: c4 0c 20 9d ldub [ %l0 + 0x9d ], %g2 <== NOT EXECUTED
4000e868: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
4000e86c: 02 80 00 04 be 4000e87c <fat_init_volume_info+0x798> <== NOT EXECUTED
4000e870: 01 00 00 00 nop <== NOT EXECUTED
4000e874: 7f ff fc 6b call 4000da20 <fat_buf_release.part.0> <== NOT EXECUTED
4000e878: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
close(vol->fd);
4000e87c: 7f ff ce c7 call 40002398 <close> <== NOT EXECUTED
4000e880: d0 04 20 68 ld [ %l0 + 0x68 ], %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
4000e884: 40 00 34 8a call 4001baac <__errno> <== NOT EXECUTED
4000e888: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4000e88c: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
4000e890: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4000e894: 81 c7 e0 08 ret <== NOT EXECUTED
4000e898: 81 e8 00 00 restore <== NOT EXECUTED
close(vol->fd);
4000e89c: d0 04 20 68 ld [ %l0 + 0x68 ], %o0 <== NOT EXECUTED
4000e8a0: 7f ff ce be call 40002398 <close> <== NOT EXECUTED
4000e8a4: 01 00 00 00 nop <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENXIO);
4000e8a8: 40 00 34 81 call 4001baac <__errno> <== NOT EXECUTED
4000e8ac: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff> <== NOT EXECUTED
4000e8b0: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED
4000e8b4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4000e8b8: 81 c7 e0 08 ret <== NOT EXECUTED
4000e8bc: 81 e8 00 00 restore <== NOT EXECUTED
close(vol->fd);
4000e8c0: 7f ff ce b6 call 40002398 <close> <== NOT EXECUTED
4000e8c4: d0 04 20 68 ld [ %l0 + 0x68 ], %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
4000e8c8: 40 00 34 79 call 4001baac <__errno> <== NOT EXECUTED
4000e8cc: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4000e8d0: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4000e8d4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4000e8d8: 81 c7 e0 08 ret <== NOT EXECUTED
4000e8dc: 81 e8 00 00 restore <== NOT EXECUTED
if (fs_info->c.state == FAT_CACHE_EMPTY)
4000e8e0: c4 0c 20 9d ldub [ %l0 + 0x9d ], %g2 <== NOT EXECUTED
4000e8e4: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
4000e8e8: 02 80 00 04 be 4000e8f8 <fat_init_volume_info+0x814> <== NOT EXECUTED
4000e8ec: 01 00 00 00 nop <== NOT EXECUTED
4000e8f0: 7f ff fc 4c call 4000da20 <fat_buf_release.part.0> <== NOT EXECUTED
4000e8f4: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
close(vol->fd);
4000e8f8: 7f ff ce a8 call 40002398 <close> <== NOT EXECUTED
4000e8fc: d0 04 20 68 ld [ %l0 + 0x68 ], %o0 <== NOT EXECUTED
return -1;
4000e900: 81 c7 e0 08 ret <== NOT EXECUTED
4000e904: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
close(vol->fd);
4000e908: 7f ff ce a4 call 40002398 <close> <== NOT EXECUTED
4000e90c: d0 04 20 68 ld [ %l0 + 0x68 ], %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
4000e910: 40 00 34 67 call 4001baac <__errno> <== NOT EXECUTED
4000e914: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4000e918: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
4000e91c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4000e920: 81 c7 e0 08 ret <== NOT EXECUTED
4000e924: 81 e8 00 00 restore <== NOT EXECUTED
close(vol->fd);
4000e928: 7f ff ce 9c call 40002398 <close> <== NOT EXECUTED
4000e92c: d0 04 20 68 ld [ %l0 + 0x68 ], %o0 <== NOT EXECUTED
free(fs_info->vhash);
4000e930: 7f ff ce fc call 40002520 <free> <== NOT EXECUTED
4000e934: d0 04 20 80 ld [ %l0 + 0x80 ], %o0 <== NOT EXECUTED
free(fs_info->rhash);
4000e938: 7f ff ce fa call 40002520 <free> <== NOT EXECUTED
4000e93c: d0 04 20 84 ld [ %l0 + 0x84 ], %o0 <== NOT EXECUTED
free(fs_info->uino);
4000e940: d0 04 20 88 ld [ %l0 + 0x88 ], %o0 <== NOT EXECUTED
4000e944: 7f ff ce f7 call 40002520 <free> <== NOT EXECUTED
4000e948: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
4000e94c: 40 00 34 58 call 4001baac <__errno> <== NOT EXECUTED
4000e950: 01 00 00 00 nop <== NOT EXECUTED
4000e954: 82 10 20 0c mov 0xc, %g1 ! c <_TLS_Alignment+0xb> <== NOT EXECUTED
4000e958: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4000e95c: 81 c7 e0 08 ret
4000e960: 81 e8 00 00 restore
close(vol->fd);
4000e964: 7f ff ce 8d call 40002398 <close> <== NOT EXECUTED
4000e968: d0 04 20 68 ld [ %l0 + 0x68 ], %o0 <== NOT EXECUTED
free(fs_info->vhash);
4000e96c: 10 bf ff f6 b 4000e944 <fat_init_volume_info+0x860> <== NOT EXECUTED
4000e970: d0 04 20 80 ld [ %l0 + 0x80 ], %o0 <== NOT EXECUTED
close(vol->fd);
4000e974: 7f ff ce 89 call 40002398 <close> <== NOT EXECUTED
4000e978: d0 04 20 68 ld [ %l0 + 0x68 ], %o0 <== NOT EXECUTED
free(fs_info->vhash);
4000e97c: 7f ff ce e9 call 40002520 <free> <== NOT EXECUTED
4000e980: d0 04 20 80 ld [ %l0 + 0x80 ], %o0 <== NOT EXECUTED
free(fs_info->rhash);
4000e984: 10 bf ff f0 b 4000e944 <fat_init_volume_info+0x860> <== NOT EXECUTED
4000e988: d0 04 20 84 ld [ %l0 + 0x84 ], %o0 <== NOT EXECUTED
4000f2d4 <fat_scan_fat_for_free_clusters>:
{
4000f2d4: 9d e3 bf 98 save %sp, -104, %sp
uint32_t data_cls_val = fs_info->vol.data_cls + 2;
4000f2d8: c2 06 20 40 ld [ %i0 + 0x40 ], %g1
if (fs_info->vol.next_cl - 2 < fs_info->vol.data_cls)
4000f2dc: e2 06 20 54 ld [ %i0 + 0x54 ], %l1
4000f2e0: 84 04 7f fe add %l1, -2, %g2
4000f2e4: 80 a0 40 02 cmp %g1, %g2
4000f2e8: 18 80 00 03 bgu 4000f2f4 <fat_scan_fat_for_free_clusters+0x20>
4000f2ec: a6 00 60 02 add %g1, 2, %l3
uint32_t cl4find = 2;
4000f2f0: a2 10 20 02 mov 2, %l1
*cls_added = 0;
4000f2f4: c0 26 c0 00 clr [ %i3 ]
while (*cls_added != count && i < data_cls_val)
4000f2f8: 80 a4 e0 02 cmp %l3, 2
4000f2fc: 18 80 00 03 bgu 4000f308 <fat_scan_fat_for_free_clusters+0x34> <== ALWAYS TAKEN
4000f300: 82 10 20 01 mov 1, %g1
4000f304: 82 10 20 00 clr %g1 <== NOT EXECUTED
4000f308: 80 88 60 ff btst 0xff, %g1
4000f30c: 02 80 00 50 be 4000f44c <fat_scan_fat_for_free_clusters+0x178> <== NEVER TAKEN
4000f310: 80 a6 a0 00 cmp %i2, 0
4000f314: 02 80 00 4e be 4000f44c <fat_scan_fat_for_free_clusters+0x178> <== NEVER TAKEN
4000f318: a4 10 20 02 mov 2, %l2
uint32_t save_cln = FAT_UNDEFINED_VALUE;
4000f31c: 10 80 00 19 b 4000f380 <fat_scan_fat_for_free_clusters+0xac>
4000f320: a8 10 3f ff mov -1, %l4
rc = fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_EOC);
4000f324: 94 10 3f ff mov -1, %o2
4000f328: 92 10 00 11 mov %l1, %o1
4000f32c: 7f ff ff 09 call 4000ef50 <fat_set_fat_cluster>
4000f330: 90 10 00 18 mov %i0, %o0
if ( rc != RC_OK )
4000f334: a0 92 20 00 orcc %o0, 0, %l0
4000f338: 12 80 00 38 bne 4000f418 <fat_scan_fat_for_free_clusters+0x144> <== NEVER TAKEN
4000f33c: 80 a7 60 00 cmp %i5, 0
if (zero_fill)
4000f340: 32 80 00 38 bne,a 4000f420 <fat_scan_fat_for_free_clusters+0x14c>
4000f344: d6 06 20 08 ld [ %i0 + 8 ], %o3
(*cls_added)++;
4000f348: c2 06 c0 00 ld [ %i3 ], %g1
4000f34c: 82 00 60 01 inc %g1
4000f350: c2 26 c0 00 st %g1, [ %i3 ]
4000f354: a8 10 00 11 mov %l1, %l4
cl4find++;
4000f358: a2 04 60 01 inc %l1
if (cl4find >= data_cls_val)
4000f35c: 80 a4 c0 11 cmp %l3, %l1
4000f360: 18 80 00 03 bgu 4000f36c <fat_scan_fat_for_free_clusters+0x98>
4000f364: a4 04 a0 01 inc %l2
cl4find = 2;
4000f368: a2 10 20 02 mov 2, %l1
while (*cls_added != count && i < data_cls_val)
4000f36c: 80 a4 80 13 cmp %l2, %l3
4000f370: 1a 80 00 38 bcc 4000f450 <fat_scan_fat_for_free_clusters+0x17c>
4000f374: 80 a6 80 01 cmp %i2, %g1
4000f378: 22 80 00 37 be,a 4000f454 <fat_scan_fat_for_free_clusters+0x180>
4000f37c: e8 27 00 00 st %l4, [ %i4 ]
uint32_t next_cln = 0;
4000f380: c0 27 bf fc clr [ %fp + -4 ]
rc = fat_get_fat_cluster(fs_info, cl4find, &next_cln);
4000f384: 94 07 bf fc add %fp, -4, %o2
4000f388: 92 10 00 11 mov %l1, %o1
4000f38c: 7f ff fe 7c call 4000ed7c <fat_get_fat_cluster>
4000f390: 90 10 00 18 mov %i0, %o0
if (*cls_added != 0)
4000f394: c2 06 c0 00 ld [ %i3 ], %g1
if ( rc != RC_OK )
4000f398: 80 a2 20 00 cmp %o0, 0
4000f39c: 12 80 00 3a bne 4000f484 <fat_scan_fat_for_free_clusters+0x1b0> <== NEVER TAKEN
4000f3a0: a0 10 00 08 mov %o0, %l0
if (next_cln == FAT_GENFAT_FREE)
4000f3a4: c4 07 bf fc ld [ %fp + -4 ], %g2
4000f3a8: 80 a0 a0 00 cmp %g2, 0
4000f3ac: 32 bf ff ec bne,a 4000f35c <fat_scan_fat_for_free_clusters+0x88>
4000f3b0: a2 04 60 01 inc %l1
if (*cls_added == 0)
4000f3b4: 80 a0 60 00 cmp %g1, 0
4000f3b8: 22 bf ff db be,a 4000f324 <fat_scan_fat_for_free_clusters+0x50>
4000f3bc: e2 26 40 00 st %l1, [ %i1 ]
rc = fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_EOC);
4000f3c0: 94 10 3f ff mov -1, %o2
4000f3c4: 92 10 00 11 mov %l1, %o1
4000f3c8: 7f ff fe e2 call 4000ef50 <fat_set_fat_cluster>
4000f3cc: 90 10 00 18 mov %i0, %o0
if ( rc != RC_OK )
4000f3d0: a0 92 20 00 orcc %o0, 0, %l0
4000f3d4: 12 80 00 2f bne 4000f490 <fat_scan_fat_for_free_clusters+0x1bc> <== NEVER TAKEN
4000f3d8: 94 10 00 11 mov %l1, %o2
rc = fat_set_fat_cluster(fs_info, save_cln, cl4find);
4000f3dc: 92 10 00 14 mov %l4, %o1
4000f3e0: 7f ff fe dc call 4000ef50 <fat_set_fat_cluster>
4000f3e4: 90 10 00 18 mov %i0, %o0
if ( rc != RC_OK )
4000f3e8: a0 92 20 00 orcc %o0, 0, %l0
4000f3ec: 02 bf ff d5 be 4000f340 <fat_scan_fat_for_free_clusters+0x6c> <== ALWAYS TAKEN
4000f3f0: 80 a7 60 00 cmp %i5, 0
fat_free_fat_clusters_chain(fs_info, (*chain));
4000f3f4: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
4000f3f8: 7f ff ff 7f call 4000f1f4 <fat_free_fat_clusters_chain> <== NOT EXECUTED
4000f3fc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
(void) fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_FREE);
4000f400: 94 10 20 00 clr %o2 <== NOT EXECUTED
4000f404: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
4000f408: 7f ff fe d2 call 4000ef50 <fat_set_fat_cluster> <== NOT EXECUTED
4000f40c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
fat_buf_release(fs_info);
4000f410: 7f ff fa 27 call 4000dcac <fat_buf_release> <== NOT EXECUTED
4000f414: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
}
4000f418: 81 c7 e0 08 ret <== NOT EXECUTED
4000f41c: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED
fat_cluster_set(fs_info, cl4find, 0, fs_info->vol.bpc, 0);
4000f420: 98 10 20 00 clr %o4
4000f424: 94 10 20 00 clr %o2
4000f428: 92 10 00 11 mov %l1, %o1
4000f42c: 7f ff fa 8a call 4000de54 <fat_cluster_set>
4000f430: 90 10 00 18 mov %i0, %o0
if (fs_info->vol.bpc != bytes_written)
4000f434: c2 06 20 08 ld [ %i0 + 8 ], %g1
4000f438: 80 a0 40 08 cmp %g1, %o0
4000f43c: 22 bf ff c4 be,a 4000f34c <fat_scan_fat_for_free_clusters+0x78> <== ALWAYS TAKEN
4000f440: c2 06 c0 00 ld [ %i3 ], %g1
rc = -1;
4000f444: 10 bf ff ec b 4000f3f4 <fat_scan_fat_for_free_clusters+0x120> <== NOT EXECUTED
4000f448: a0 10 3f ff mov -1, %l0 <== NOT EXECUTED
uint32_t save_cln = FAT_UNDEFINED_VALUE;
4000f44c: a8 10 3f ff mov -1, %l4 <== NOT EXECUTED
*last_cl = save_cln;
4000f450: e8 27 00 00 st %l4, [ %i4 ]
fs_info->vol.next_cl = save_cln;
4000f454: e8 26 20 54 st %l4, [ %i0 + 0x54 ]
if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
4000f458: c2 06 20 4c ld [ %i0 + 0x4c ], %g1
4000f45c: 80 a0 7f ff cmp %g1, -1
4000f460: 02 80 00 05 be 4000f474 <fat_scan_fat_for_free_clusters+0x1a0> <== ALWAYS TAKEN
4000f464: 90 10 00 18 mov %i0, %o0
fs_info->vol.free_cls -= (*cls_added);
4000f468: c4 06 c0 00 ld [ %i3 ], %g2 <== NOT EXECUTED
4000f46c: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED
4000f470: c2 26 20 4c st %g1, [ %i0 + 0x4c ] <== NOT EXECUTED
fat_buf_release(fs_info);
4000f474: 7f ff fa 0e call 4000dcac <fat_buf_release>
4000f478: a0 10 20 00 clr %l0
}
4000f47c: 81 c7 e0 08 ret
4000f480: 91 e8 00 10 restore %g0, %l0, %o0
if (*cls_added != 0)
4000f484: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000f488: 02 bf ff e4 be 4000f418 <fat_scan_fat_for_free_clusters+0x144> <== NOT EXECUTED
4000f48c: 01 00 00 00 nop <== NOT EXECUTED
fat_free_fat_clusters_chain(fs_info, (*chain));
4000f490: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
4000f494: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4000f498: 7f ff ff 57 call 4000f1f4 <fat_free_fat_clusters_chain> <== NOT EXECUTED
4000f49c: b0 10 00 10 mov %l0, %i0 <== NOT EXECUTED
}
4000f4a0: 81 c7 e0 08 ret <== NOT EXECUTED
4000f4a4: 81 e8 00 00 restore <== NOT EXECUTED
4000dda8 <fat_sector_write>:
fat_fs_info_t *fs_info,
uint32_t start,
uint32_t offset,
uint32_t count,
const void *buff)
{
4000dda8: 9d e3 bf 98 save %sp, -104, %sp
uint32_t sec_num = start;
uint32_t ofs = offset;
uint8_t *sec_buf;
uint32_t c = 0;
while(count > 0)
4000ddac: 80 a6 e0 00 cmp %i3, 0
4000ddb0: 02 80 00 27 be 4000de4c <fat_sector_write+0xa4> <== NEVER TAKEN
4000ddb4: a0 10 20 00 clr %l0
}
static inline void
fat_buf_mark_modified(fat_fs_info_t *fs_info)
{
fs_info->c.modified = true;
4000ddb8: 10 80 00 13 b 4000de04 <fat_sector_write+0x5c>
4000ddbc: a2 10 20 01 mov 1, %l1
c = MIN(count, (fs_info->vol.bps - ofs));
if (c == fs_info->vol.bytes_per_block)
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &sec_buf);
else
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
4000ddc0: 94 10 20 01 mov 1, %o2
4000ddc4: 96 07 bf fc add %fp, -4, %o3
4000ddc8: 7f ff ff 8b call 4000dbf4 <fat_buf_access>
4000ddcc: 90 10 00 18 mov %i0, %o0
if (rc != RC_OK)
return -1;
memcpy((sec_buf + ofs), (buff + cmpltd), c);
4000ddd0: 92 07 00 10 add %i4, %l0, %o1
if (rc != RC_OK)
4000ddd4: 80 a2 20 00 cmp %o0, 0
4000ddd8: 12 80 00 1c bne 4000de48 <fat_sector_write+0xa0> <== NEVER TAKEN
4000dddc: 94 10 00 1d mov %i5, %o2
memcpy((sec_buf + ofs), (buff + cmpltd), c);
4000dde0: d0 07 bf fc ld [ %fp + -4 ], %o0
4000dde4: 40 00 39 20 call 4001c264 <memcpy>
4000dde8: 90 02 00 1a add %o0, %i2, %o0
4000ddec: e2 2e 20 9c stb %l1, [ %i0 + 0x9c ]
fat_buf_mark_modified(fs_info);
count -= c;
cmpltd +=c;
4000ddf0: a0 04 00 1d add %l0, %i5, %l0
sec_num++;
4000ddf4: b2 06 60 01 inc %i1
while(count > 0)
4000ddf8: b6 a6 c0 1d subcc %i3, %i5, %i3
4000ddfc: 02 80 00 14 be 4000de4c <fat_sector_write+0xa4> <== ALWAYS TAKEN
4000de00: b4 10 20 00 clr %i2
c = MIN(count, (fs_info->vol.bps - ofs));
4000de04: fa 16 00 00 lduh [ %i0 ], %i5
4000de08: ba 27 40 1a sub %i5, %i2, %i5
4000de0c: 80 a7 40 1b cmp %i5, %i3
4000de10: 38 80 00 02 bgu,a 4000de18 <fat_sector_write+0x70>
4000de14: ba 10 00 1b mov %i3, %i5
if (c == fs_info->vol.bytes_per_block)
4000de18: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
4000de1c: 80 a0 40 1d cmp %g1, %i5
4000de20: 12 bf ff e8 bne 4000ddc0 <fat_sector_write+0x18> <== ALWAYS TAKEN
4000de24: 92 10 00 19 mov %i1, %o1
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &sec_buf);
4000de28: 94 10 20 02 mov 2, %o2 <== NOT EXECUTED
4000de2c: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
4000de30: 7f ff ff 71 call 4000dbf4 <fat_buf_access> <== NOT EXECUTED
4000de34: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
memcpy((sec_buf + ofs), (buff + cmpltd), c);
4000de38: 92 07 00 10 add %i4, %l0, %o1 <== NOT EXECUTED
if (rc != RC_OK)
4000de3c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000de40: 02 bf ff e8 be 4000dde0 <fat_sector_write+0x38> <== NOT EXECUTED
4000de44: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
return -1;
4000de48: a0 10 3f ff mov -1, %l0 <== NOT EXECUTED
ofs = 0;
}
return cmpltd;
}
4000de4c: 81 c7 e0 08 ret
4000de50: 91 e8 00 10 restore %g0, %l0, %o0
4000ef50 <fat_set_fat_cluster>:
fat_set_fat_cluster(
fat_fs_info_t *fs_info,
uint32_t cln,
uint32_t in_val
)
{
4000ef50: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
uint32_t sec = 0;
uint32_t ofs = 0;
uint16_t fat16_clv = 0;
uint32_t fat32_clv = 0;
uint8_t *sec_buf = NULL;
4000ef54: c0 27 bf fc clr [ %fp + -4 ]
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
4000ef58: 80 a6 60 01 cmp %i1, 1
4000ef5c: 08 80 00 a0 bleu 4000f1dc <fat_set_fat_cluster+0x28c> <== NEVER TAKEN
4000ef60: ba 10 00 18 mov %i0, %i5
4000ef64: c2 06 20 40 ld [ %i0 + 0x40 ], %g1
4000ef68: 82 00 60 01 inc %g1
4000ef6c: 80 a0 40 19 cmp %g1, %i1
4000ef70: 0a 80 00 9b bcs 4000f1dc <fat_set_fat_cluster+0x28c> <== NEVER TAKEN
4000ef74: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
4000ef78: c2 0e 20 16 ldub [ %i0 + 0x16 ], %g1
fs_info->vol.afat_loc;
4000ef7c: e0 06 20 60 ld [ %i0 + 0x60 ], %l0
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
4000ef80: 80 88 60 01 btst 1, %g1
4000ef84: 12 80 00 22 bne 4000f00c <fat_set_fat_cluster+0xbc>
4000ef88: d2 0e 20 02 ldub [ %i0 + 2 ], %o1
4000ef8c: 80 88 60 02 btst 2, %g1
4000ef90: 02 80 00 24 be 4000f020 <fat_set_fat_cluster+0xd0>
4000ef94: a3 2e 60 02 sll %i1, 2, %l1
4000ef98: a3 2e 60 01 sll %i1, 1, %l1
4000ef9c: 93 34 40 09 srl %l1, %o1, %o1
4000efa0: a0 02 40 10 add %o1, %l0, %l0
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
4000efa4: f8 17 40 00 lduh [ %i5 ], %i4
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
4000efa8: 94 10 20 01 mov 1, %o2
4000efac: 96 07 bf fc add %fp, -4, %o3
4000efb0: 92 10 00 10 mov %l0, %o1
4000efb4: 7f ff fb 10 call 4000dbf4 <fat_buf_access>
4000efb8: 90 10 00 1d mov %i5, %o0
if (rc != RC_OK)
4000efbc: b0 92 20 00 orcc %o0, 0, %i0
4000efc0: 12 80 00 11 bne 4000f004 <fat_set_fat_cluster+0xb4> <== NEVER TAKEN
4000efc4: b9 2f 20 10 sll %i4, 0x10, %i4
return rc;
switch ( fs_info->vol.type )
4000efc8: e4 0f 60 16 ldub [ %i5 + 0x16 ], %l2
4000efcc: 80 a4 a0 02 cmp %l2, 2
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
4000efd0: b9 37 20 10 srl %i4, 0x10, %i4
4000efd4: b8 07 3f ff add %i4, -1, %i4
switch ( fs_info->vol.type )
4000efd8: 02 80 00 15 be 4000f02c <fat_set_fat_cluster+0xdc>
4000efdc: b8 0f 00 11 and %i4, %l1, %i4
4000efe0: 80 a4 a0 04 cmp %l2, 4
4000efe4: 02 80 00 1c be 4000f054 <fat_set_fat_cluster+0x104>
4000efe8: 80 a4 a0 01 cmp %l2, 1
4000efec: 02 80 00 26 be 4000f084 <fat_set_fat_cluster+0x134> <== ALWAYS TAKEN
4000eff0: 80 8e 60 01 btst 1, %i1
fat_buf_mark_modified(fs_info);
break;
default:
rtems_set_errno_and_return_minus_one(EIO);
4000eff4: 40 00 32 ae call 4001baac <__errno> <== NOT EXECUTED
4000eff8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4000effc: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4000f000: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
break;
}
return RC_OK;
}
4000f004: 81 c7 e0 08 ret <== NOT EXECUTED
4000f008: 81 e8 00 00 restore <== NOT EXECUTED
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
4000f00c: b9 36 60 01 srl %i1, 1, %i4
4000f010: a2 07 00 19 add %i4, %i1, %l1
4000f014: 93 34 40 09 srl %l1, %o1, %o1
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
4000f018: 10 bf ff e3 b 4000efa4 <fat_set_fat_cluster+0x54>
4000f01c: a0 02 40 10 add %o1, %l0, %l0
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
4000f020: 93 34 40 09 srl %l1, %o1, %o1
4000f024: 10 bf ff e0 b 4000efa4 <fat_set_fat_cluster+0x54>
4000f028: a0 02 40 10 add %o1, %l0, %l0
*((uint16_t *)(sec_buf + ofs)) =
4000f02c: c4 07 bf fc ld [ %fp + -4 ], %g2
(uint16_t )(CT_LE_W(in_val));
4000f030: 83 2e a0 08 sll %i2, 8, %g1
4000f034: b5 2e a0 10 sll %i2, 0x10, %i2
4000f038: b5 36 a0 18 srl %i2, 0x18, %i2
4000f03c: 82 10 40 1a or %g1, %i2, %g1
*((uint16_t *)(sec_buf + ofs)) =
4000f040: c2 30 80 1c sth %g1, [ %g2 + %i4 ]
fs_info->c.modified = true;
4000f044: 82 10 20 01 mov 1, %g1
4000f048: c2 2f 60 9c stb %g1, [ %i5 + 0x9c ]
}
4000f04c: 81 c7 e0 08 ret
4000f050: 81 e8 00 00 restore
fat32_clv = CT_LE_L((in_val & FAT_FAT32_MASK));
4000f054: 11 3c 00 00 sethi %hi(0xf0000000), %o0
4000f058: 40 00 30 06 call 4001b070 <__bswapsi2>
4000f05c: 90 2e 80 08 andn %i2, %o0, %o0
*((uint32_t *)(sec_buf + ofs)) &= CT_LE_L(0xF0000000);
4000f060: c4 07 bf fc ld [ %fp + -4 ], %g2
4000f064: c2 00 80 1c ld [ %g2 + %i4 ], %g1
4000f068: 82 08 60 f0 and %g1, 0xf0, %g1
*((uint32_t *)(sec_buf + ofs)) |= fat32_clv;
4000f06c: 82 10 40 08 or %g1, %o0, %g1
4000f070: c2 20 80 1c st %g1, [ %g2 + %i4 ]
fs_info->c.modified = true;
4000f074: 82 10 20 01 mov 1, %g1
4000f078: c2 2f 60 9c stb %g1, [ %i5 + 0x9c ]
}
4000f07c: 81 c7 e0 08 ret
4000f080: 81 e8 00 00 restore
if ( FAT_CLUSTER_IS_ODD(cln) )
4000f084: 02 80 00 1a be 4000f0ec <fat_set_fat_cluster+0x19c>
4000f088: c2 07 bf fc ld [ %fp + -4 ], %g1
*(sec_buf + ofs) &= 0x0F;
4000f08c: c4 08 40 1c ldub [ %g1 + %i4 ], %g2
4000f090: 84 08 a0 0f and %g2, 0xf, %g2
4000f094: c4 28 40 1c stb %g2, [ %g1 + %i4 ]
fat16_clv = ((uint16_t )in_val) << FAT_FAT12_SHIFT;
4000f098: 83 2e a0 04 sll %i2, 4, %g1
*(sec_buf + ofs) |= (uint8_t)(fat16_clv & 0x00F0);
4000f09c: c4 07 bf fc ld [ %fp + -4 ], %g2
4000f0a0: c6 08 80 1c ldub [ %g2 + %i4 ], %g3
4000f0a4: 82 10 40 03 or %g1, %g3, %g1
4000f0a8: c2 28 80 1c stb %g1, [ %g2 + %i4 ]
fs_info->c.modified = true;
4000f0ac: e4 2f 60 9c stb %l2, [ %i5 + 0x9c ]
if ( ofs == (fs_info->vol.bps - 1) )
4000f0b0: c2 17 40 00 lduh [ %i5 ], %g1
4000f0b4: 82 00 7f ff add %g1, -1, %g1
4000f0b8: 80 a0 40 1c cmp %g1, %i4
4000f0bc: 02 80 00 23 be 4000f148 <fat_set_fat_cluster+0x1f8>
4000f0c0: c2 07 bf fc ld [ %fp + -4 ], %g1
*(sec_buf + ofs + 1) &= 0x00;
4000f0c4: b8 07 20 01 inc %i4
4000f0c8: c0 28 40 1c clrb [ %g1 + %i4 ]
*(sec_buf + ofs + 1) |= (uint8_t )((fat16_clv & 0xFF00)>>8);
4000f0cc: b5 2e a0 14 sll %i2, 0x14, %i2
4000f0d0: c2 07 bf fc ld [ %fp + -4 ], %g1
4000f0d4: c4 08 40 1c ldub [ %g1 + %i4 ], %g2
4000f0d8: b5 36 a0 18 srl %i2, 0x18, %i2
4000f0dc: b4 16 80 02 or %i2, %g2, %i2
4000f0e0: f4 28 40 1c stb %i2, [ %g1 + %i4 ]
4000f0e4: 81 c7 e0 08 ret
4000f0e8: 81 e8 00 00 restore
*(sec_buf + ofs) &= 0x00;
4000f0ec: c0 28 40 1c clrb [ %g1 + %i4 ]
fat16_clv = ((uint16_t )in_val) & FAT_FAT12_MASK;
4000f0f0: b4 0e af ff and %i2, 0xfff, %i2
*(sec_buf + ofs) |= (uint8_t)(fat16_clv & 0x00FF);
4000f0f4: c4 07 bf fc ld [ %fp + -4 ], %g2
4000f0f8: c2 08 80 1c ldub [ %g2 + %i4 ], %g1
4000f0fc: 82 16 80 01 or %i2, %g1, %g1
4000f100: c2 28 80 1c stb %g1, [ %g2 + %i4 ]
4000f104: e4 2f 60 9c stb %l2, [ %i5 + 0x9c ]
if ( ofs == (fs_info->vol.bps - 1) )
4000f108: c2 17 40 00 lduh [ %i5 ], %g1
4000f10c: 82 00 7f ff add %g1, -1, %g1
4000f110: 80 a0 40 1c cmp %g1, %i4
4000f114: 02 80 00 1f be 4000f190 <fat_set_fat_cluster+0x240> <== NEVER TAKEN
4000f118: c4 07 bf fc ld [ %fp + -4 ], %g2
*(sec_buf + ofs + 1) &= 0xF0;
4000f11c: b8 07 20 01 inc %i4
4000f120: c2 08 80 1c ldub [ %g2 + %i4 ], %g1
4000f124: 82 08 7f f0 and %g1, -16, %g1
4000f128: c2 28 80 1c stb %g1, [ %g2 + %i4 ]
*(sec_buf + ofs+1) |= (uint8_t)((fat16_clv & 0xFF00)>>8);
4000f12c: b5 36 a0 08 srl %i2, 8, %i2
4000f130: c2 07 bf fc ld [ %fp + -4 ], %g1
4000f134: c4 08 40 1c ldub [ %g1 + %i4 ], %g2
4000f138: b4 16 80 02 or %i2, %g2, %i2
4000f13c: f4 28 40 1c stb %i2, [ %g1 + %i4 ]
4000f140: 81 c7 e0 08 ret
4000f144: 81 e8 00 00 restore
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
4000f148: 96 07 bf fc add %fp, -4, %o3
4000f14c: 94 10 20 01 mov 1, %o2
4000f150: 92 04 20 01 add %l0, 1, %o1
4000f154: 7f ff fa a8 call 4000dbf4 <fat_buf_access>
4000f158: 90 10 00 1d mov %i5, %o0
if (rc != RC_OK)
4000f15c: b0 92 20 00 orcc %o0, 0, %i0
4000f160: 12 bf ff a9 bne 4000f004 <fat_set_fat_cluster+0xb4> <== NEVER TAKEN
4000f164: c2 07 bf fc ld [ %fp + -4 ], %g1
*sec_buf &= 0x00;
4000f168: c0 28 40 00 clrb [ %g1 ]
*sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8);
4000f16c: 83 2e a0 14 sll %i2, 0x14, %g1
4000f170: c4 07 bf fc ld [ %fp + -4 ], %g2
4000f174: c6 08 80 00 ldub [ %g2 ], %g3
4000f178: 83 30 60 18 srl %g1, 0x18, %g1
4000f17c: 82 10 40 03 or %g1, %g3, %g1
4000f180: c2 28 80 00 stb %g1, [ %g2 ]
4000f184: e4 2f 60 9c stb %l2, [ %i5 + 0x9c ]
}
4000f188: 81 c7 e0 08 ret
4000f18c: 81 e8 00 00 restore
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
4000f190: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
4000f194: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
4000f198: 92 04 20 01 add %l0, 1, %o1 <== NOT EXECUTED
4000f19c: 7f ff fa 96 call 4000dbf4 <fat_buf_access> <== NOT EXECUTED
4000f1a0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
if (rc != RC_OK)
4000f1a4: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
4000f1a8: 12 bf ff 97 bne 4000f004 <fat_set_fat_cluster+0xb4> <== NOT EXECUTED
4000f1ac: c4 07 bf fc ld [ %fp + -4 ], %g2 <== NOT EXECUTED
*sec_buf &= 0xF0;
4000f1b0: c2 08 80 00 ldub [ %g2 ], %g1 <== NOT EXECUTED
4000f1b4: 82 08 7f f0 and %g1, -16, %g1 <== NOT EXECUTED
4000f1b8: c2 28 80 00 stb %g1, [ %g2 ] <== NOT EXECUTED
*sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8);
4000f1bc: b5 36 a0 08 srl %i2, 8, %i2 <== NOT EXECUTED
4000f1c0: c4 07 bf fc ld [ %fp + -4 ], %g2 <== NOT EXECUTED
4000f1c4: c2 08 80 00 ldub [ %g2 ], %g1 <== NOT EXECUTED
4000f1c8: 82 16 80 01 or %i2, %g1, %g1 <== NOT EXECUTED
4000f1cc: c2 28 80 00 stb %g1, [ %g2 ] <== NOT EXECUTED
fs_info->c.modified = true;
4000f1d0: e4 2f 60 9c stb %l2, [ %i5 + 0x9c ] <== NOT EXECUTED
}
4000f1d4: 81 c7 e0 08 ret <== NOT EXECUTED
4000f1d8: 81 e8 00 00 restore <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
4000f1dc: 40 00 32 34 call 4001baac <__errno> <== NOT EXECUTED
4000f1e0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4000f1e4: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4000f1e8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4000f1ec: 81 c7 e0 08 ret <== NOT EXECUTED
4000f1f0: 81 e8 00 00 restore <== NOT EXECUTED
4000ea9c <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)
{
4000ea9c: 9d e3 bf a0 save %sp, -96, %sp
int rc = RC_OK;
int i = 0;
rc = fat_sync(fs_info);
4000eaa0: 7f ff ff bb call 4000e98c <fat_sync>
4000eaa4: 90 10 00 18 mov %i0, %o0
rc = -1;
for (i = 0; i < FAT_HASH_SIZE; i++)
{
rtems_chain_node *node = NULL;
rtems_chain_control *the_chain = fs_info->vhash + i;
4000eaa8: fa 06 20 80 ld [ %i0 + 0x80 ], %i5
rc = fat_sync(fs_info);
4000eaac: b4 10 00 08 mov %o0, %i2
return _Chain_Immutable_head( the_chain )->next;
4000eab0: d0 07 40 00 ld [ %i5 ], %o0
if ( rc != RC_OK )
4000eab4: 80 a0 00 1a cmp %g0, %i2
{
4000eab8: b8 10 00 18 mov %i0, %i4
return &the_chain->Tail.Node;
4000eabc: b6 07 60 04 add %i5, 4, %i3
if ( rc != RC_OK )
4000eac0: b0 60 20 00 subx %g0, 0, %i0
if ( !_Chain_Is_empty(the_chain))
4000eac4: 80 a6 c0 08 cmp %i3, %o0
4000eac8: 22 80 00 0c be,a 4000eaf8 <fat_shutdown_drive+0x5c>
4000eacc: d0 07 60 0c ld [ %i5 + 0xc ], %o0
new_first = old_first->next;
4000ead0: c2 02 00 00 ld [ %o0 ], %g1
head->next = new_first;
4000ead4: c2 27 40 00 st %g1, [ %i5 ]
while ( (node = rtems_chain_get_unprotected(the_chain)) != NULL )
free(node);
4000ead8: 7f ff ce 92 call 40002520 <free>
4000eadc: fa 20 60 04 st %i5, [ %g1 + 4 ]
return _Chain_Immutable_head( the_chain )->next;
4000eae0: d0 07 40 00 ld [ %i5 ], %o0
if ( !_Chain_Is_empty(the_chain))
4000eae4: 80 a6 c0 08 cmp %i3, %o0
4000eae8: 32 bf ff fb bne,a 4000ead4 <fat_shutdown_drive+0x38>
4000eaec: c2 02 00 00 ld [ %o0 ], %g1
rtems_chain_control *the_chain = fs_info->vhash + i;
4000eaf0: fa 07 20 80 ld [ %i4 + 0x80 ], %i5
return _Chain_Immutable_head( the_chain )->next;
4000eaf4: d0 07 60 0c ld [ %i5 + 0xc ], %o0
return &the_chain->Tail.Node;
4000eaf8: b6 07 60 10 add %i5, 0x10, %i3
if ( !_Chain_Is_empty(the_chain))
4000eafc: 80 a2 00 1b cmp %o0, %i3
4000eb00: 02 80 00 0a be 4000eb28 <fat_shutdown_drive+0x8c> <== ALWAYS TAKEN
4000eb04: b2 07 60 0c add %i5, 0xc, %i1
new_first = old_first->next;
4000eb08: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED
head->next = new_first;
4000eb0c: c2 27 60 0c st %g1, [ %i5 + 0xc ] <== NOT EXECUTED
free(node);
4000eb10: 7f ff ce 84 call 40002520 <free> <== NOT EXECUTED
4000eb14: f2 20 60 04 st %i1, [ %g1 + 4 ] <== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
4000eb18: d0 07 60 0c ld [ %i5 + 0xc ], %o0 <== NOT EXECUTED
if ( !_Chain_Is_empty(the_chain))
4000eb1c: 80 a6 c0 08 cmp %i3, %o0 <== NOT EXECUTED
4000eb20: 32 bf ff fb bne,a 4000eb0c <fat_shutdown_drive+0x70> <== NOT EXECUTED
4000eb24: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED
}
for (i = 0; i < FAT_HASH_SIZE; i++)
{
rtems_chain_node *node = NULL;
rtems_chain_control *the_chain = fs_info->rhash + i;
4000eb28: fa 07 20 84 ld [ %i4 + 0x84 ], %i5
return _Chain_Immutable_head( the_chain )->next;
4000eb2c: d0 07 40 00 ld [ %i5 ], %o0
return &the_chain->Tail.Node;
4000eb30: b6 07 60 04 add %i5, 4, %i3
if ( !_Chain_Is_empty(the_chain))
4000eb34: 80 a6 c0 08 cmp %i3, %o0
4000eb38: 22 80 00 0c be,a 4000eb68 <fat_shutdown_drive+0xcc> <== ALWAYS TAKEN
4000eb3c: d0 07 60 0c ld [ %i5 + 0xc ], %o0
new_first = old_first->next;
4000eb40: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED
head->next = new_first;
4000eb44: c2 27 40 00 st %g1, [ %i5 ] <== NOT EXECUTED
while ( (node = rtems_chain_get_unprotected(the_chain)) != NULL )
free(node);
4000eb48: 7f ff ce 76 call 40002520 <free> <== NOT EXECUTED
4000eb4c: fa 20 60 04 st %i5, [ %g1 + 4 ] <== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
4000eb50: d0 07 40 00 ld [ %i5 ], %o0 <== NOT EXECUTED
if ( !_Chain_Is_empty(the_chain))
4000eb54: 80 a2 00 1b cmp %o0, %i3 <== NOT EXECUTED
4000eb58: 32 bf ff fb bne,a 4000eb44 <fat_shutdown_drive+0xa8> <== NOT EXECUTED
4000eb5c: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED
rtems_chain_control *the_chain = fs_info->rhash + i;
4000eb60: fa 07 20 84 ld [ %i4 + 0x84 ], %i5 <== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
4000eb64: d0 07 60 0c ld [ %i5 + 0xc ], %o0 <== NOT EXECUTED
return &the_chain->Tail.Node;
4000eb68: b6 07 60 10 add %i5, 0x10, %i3
if ( !_Chain_Is_empty(the_chain))
4000eb6c: 80 a6 c0 08 cmp %i3, %o0
4000eb70: 02 80 00 0a be 4000eb98 <fat_shutdown_drive+0xfc> <== ALWAYS TAKEN
4000eb74: b2 07 60 0c add %i5, 0xc, %i1
new_first = old_first->next;
4000eb78: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED
head->next = new_first;
4000eb7c: c2 27 60 0c st %g1, [ %i5 + 0xc ] <== NOT EXECUTED
free(node);
4000eb80: 7f ff ce 68 call 40002520 <free> <== NOT EXECUTED
4000eb84: f2 20 60 04 st %i1, [ %g1 + 4 ] <== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
4000eb88: d0 07 60 0c ld [ %i5 + 0xc ], %o0 <== NOT EXECUTED
if ( !_Chain_Is_empty(the_chain))
4000eb8c: 80 a6 c0 08 cmp %i3, %o0 <== NOT EXECUTED
4000eb90: 32 bf ff fb bne,a 4000eb7c <fat_shutdown_drive+0xe0> <== NOT EXECUTED
4000eb94: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED
}
free(fs_info->vhash);
4000eb98: 7f ff ce 62 call 40002520 <free>
4000eb9c: d0 07 20 80 ld [ %i4 + 0x80 ], %o0
free(fs_info->rhash);
4000eba0: 7f ff ce 60 call 40002520 <free>
4000eba4: d0 07 20 84 ld [ %i4 + 0x84 ], %o0
free(fs_info->uino);
4000eba8: 7f ff ce 5e call 40002520 <free>
4000ebac: d0 07 20 88 ld [ %i4 + 0x88 ], %o0
free(fs_info->sec_buf);
4000ebb0: 7f ff ce 5c call 40002520 <free>
4000ebb4: d0 07 20 a4 ld [ %i4 + 0xa4 ], %o0
close(fs_info->vol.fd);
4000ebb8: 7f ff cd f8 call 40002398 <close>
4000ebbc: d0 07 20 68 ld [ %i4 + 0x68 ], %o0
if (rc)
4000ebc0: 80 a6 a0 00 cmp %i2, 0
4000ebc4: 12 80 00 04 bne 4000ebd4 <fat_shutdown_drive+0x138> <== NEVER TAKEN
4000ebc8: 01 00 00 00 nop
errno = EIO;
return rc;
}
4000ebcc: 81 c7 e0 08 ret
4000ebd0: 81 e8 00 00 restore
errno = EIO;
4000ebd4: 40 00 33 b6 call 4001baac <__errno> <== NOT EXECUTED
4000ebd8: 01 00 00 00 nop <== NOT EXECUTED
4000ebdc: 82 10 20 05 mov 5, %g1 ! 5 <_TLS_Alignment+0x4> <== NOT EXECUTED
4000ebe0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
4000ebe4: 81 c7 e0 08 ret <== NOT EXECUTED
4000ebe8: 81 e8 00 00 restore <== NOT EXECUTED
4000e98c <fat_sync>:
return RC_OK;
}
int
fat_sync(fat_fs_info_t *fs_info)
{
4000e98c: 9d e3 bf 90 save %sp, -112, %sp
if (fs_info->vol.type == FAT_FAT32)
4000e990: c2 0e 20 16 ldub [ %i0 + 0x16 ], %g1
{
4000e994: ba 10 00 18 mov %i0, %i5
if (fs_info->vol.type == FAT_FAT32)
4000e998: 80 a0 60 04 cmp %g1, 4
4000e99c: 02 80 00 0f be 4000e9d8 <fat_sync+0x4c>
4000e9a0: b0 10 20 00 clr %i0
if (fs_info->c.state == FAT_CACHE_EMPTY)
4000e9a4: c2 0f 60 9d ldub [ %i5 + 0x9d ], %g1
4000e9a8: 80 a0 60 00 cmp %g1, 0
4000e9ac: 02 80 00 04 be 4000e9bc <fat_sync+0x30>
4000e9b0: 01 00 00 00 nop
4000e9b4: 7f ff fc 1b call 4000da20 <fat_buf_release.part.0>
4000e9b8: 90 10 00 1d mov %i5, %o0
if ( rc != RC_OK )
rc = -1;
fat_buf_release(fs_info);
if (rtems_bdbuf_syncdev(fs_info->vol.dd) != RTEMS_SUCCESSFUL)
4000e9bc: 40 00 21 ff call 400171b8 <rtems_bdbuf_syncdev>
4000e9c0: d0 07 60 6c ld [ %i5 + 0x6c ], %o0
4000e9c4: 80 a2 20 00 cmp %o0, 0
4000e9c8: 12 80 00 33 bne 4000ea94 <fat_sync+0x108> <== NEVER TAKEN
4000e9cc: 01 00 00 00 nop
rc = -1;
return rc;
}
4000e9d0: 81 c7 e0 08 ret
4000e9d4: 81 e8 00 00 restore
uint32_t free_count = fs_info->vol.free_cls;
4000e9d8: f8 07 60 4c ld [ %i5 + 0x4c ], %i4
if (free_count != fs_info->vol.free_cls_in_fs_info)
4000e9dc: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
4000e9e0: 80 a7 00 01 cmp %i4, %g1
4000e9e4: 12 80 00 18 bne 4000ea44 <fat_sync+0xb8> <== NEVER TAKEN
4000e9e8: f6 07 60 54 ld [ %i5 + 0x54 ], %i3
if (next_free != fs_info->vol.next_cl_in_fs_info)
4000e9ec: c2 07 60 58 ld [ %i5 + 0x58 ], %g1
4000e9f0: 80 a6 c0 01 cmp %i3, %g1
4000e9f4: 22 bf ff ed be,a 4000e9a8 <fat_sync+0x1c>
4000e9f8: c2 0f 60 9d ldub [ %i5 + 0x9d ], %g1
4000e9fc: b8 10 20 00 clr %i4
4000ea00: 98 07 bf fc add %fp, -4, %o4
uint32_t le_next_free = CT_LE_L(next_free);
4000ea04: d8 27 bf f4 st %o4, [ %fp + -12 ]
4000ea08: 40 00 31 9a call 4001b070 <__bswapsi2>
4000ea0c: 90 10 00 1b mov %i3, %o0
fs_info->vol.next_cl_in_fs_info = next_free;
4000ea10: f6 27 60 58 st %i3, [ %i5 + 0x58 ]
ret2 = fat_sector_write(fs_info,
4000ea14: 96 10 20 04 mov 4, %o3
4000ea18: d8 07 bf f4 ld [ %fp + -12 ], %o4
4000ea1c: d2 17 60 48 lduh [ %i5 + 0x48 ], %o1
uint32_t le_next_free = CT_LE_L(next_free);
4000ea20: d0 27 bf fc st %o0, [ %fp + -4 ]
ret2 = fat_sector_write(fs_info,
4000ea24: 94 10 21 ec mov 0x1ec, %o2
4000ea28: 7f ff fc e0 call 4000dda8 <fat_sector_write>
4000ea2c: 90 10 00 1d mov %i5, %o0
if ( (ret1 < 0) || (ret2 < 0) )
4000ea30: b1 32 20 1f srl %o0, 0x1f, %i0
4000ea34: b0 16 00 1c or %i0, %i4, %i0
4000ea38: b0 0e 20 ff and %i0, 0xff, %i0
4000ea3c: 10 bf ff da b 4000e9a4 <fat_sync+0x18>
4000ea40: b0 20 00 18 neg %i0
uint32_t le_free_count = CT_LE_L(free_count);
4000ea44: 40 00 31 8b call 4001b070 <__bswapsi2> <== NOT EXECUTED
4000ea48: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
fs_info->vol.free_cls_in_fs_info = free_count;
4000ea4c: f8 27 60 50 st %i4, [ %i5 + 0x50 ] <== NOT EXECUTED
ret1 = fat_sector_write(fs_info,
4000ea50: 98 07 bf fc add %fp, -4, %o4 <== NOT EXECUTED
4000ea54: d2 17 60 48 lduh [ %i5 + 0x48 ], %o1 <== NOT EXECUTED
uint32_t le_free_count = CT_LE_L(free_count);
4000ea58: d0 27 bf fc st %o0, [ %fp + -4 ] <== NOT EXECUTED
ret1 = fat_sector_write(fs_info,
4000ea5c: 96 10 20 04 mov 4, %o3 <== NOT EXECUTED
4000ea60: d8 27 bf f4 st %o4, [ %fp + -12 ] <== NOT EXECUTED
4000ea64: 94 10 21 e8 mov 0x1e8, %o2 <== NOT EXECUTED
4000ea68: 7f ff fc d0 call 4000dda8 <fat_sector_write> <== NOT EXECUTED
4000ea6c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
if (next_free != fs_info->vol.next_cl_in_fs_info)
4000ea70: c2 07 60 58 ld [ %i5 + 0x58 ], %g1 <== NOT EXECUTED
4000ea74: d8 07 bf f4 ld [ %fp + -12 ], %o4 <== NOT EXECUTED
if ( (ret1 < 0) || (ret2 < 0) )
4000ea78: b1 32 20 1f srl %o0, 0x1f, %i0 <== NOT EXECUTED
if (next_free != fs_info->vol.next_cl_in_fs_info)
4000ea7c: 80 a6 c0 01 cmp %i3, %g1 <== NOT EXECUTED
4000ea80: 12 bf ff e1 bne 4000ea04 <fat_sync+0x78> <== NOT EXECUTED
4000ea84: b9 32 20 1f srl %o0, 0x1f, %i4 <== NOT EXECUTED
if ( (ret1 < 0) || (ret2 < 0) )
4000ea88: b0 0e 20 ff and %i0, 0xff, %i0 <== NOT EXECUTED
4000ea8c: 10 bf ff c6 b 4000e9a4 <fat_sync+0x18> <== NOT EXECUTED
4000ea90: b0 20 00 18 neg %i0 <== NOT EXECUTED
return rc;
4000ea94: 81 c7 e0 08 ret <== NOT EXECUTED
4000ea98: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
400104fc <msdos_creat_node>:
fat_file_type_t type,
const char *name,
int name_len,
mode_t mode,
const fat_file_fd_t *link_fd)
{
400104fc: 9d e3 bf 00 save %sp, -256, %sp
int rc = RC_OK;
ssize_t ret = 0;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
40010500: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
40010504: e4 00 60 08 ld [ %g1 + 8 ], %l2
fat_file_fd_t *parent_fat_fd = parent_loc->node_access;
fat_file_fd_t *fat_fd = NULL;
40010508: c0 27 bf 6c clr [ %fp + -148 ]
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
4001050c: 82 10 3f ff mov -1, %g1
uint32_t sec = 0;
uint32_t byte = 0;
fat_dir_pos_init(&dir_pos);
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
40010510: c0 27 bf 80 clr [ %fp + -128 ]
{
40010514: a2 10 00 18 mov %i0, %l1
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
40010518: c0 27 bf 84 clr [ %fp + -124 ]
memset(dot_dotdot, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2);
if (name_len > MSDOS_NAME_MAX_LFN_WITH_DOT) {
4001051c: 80 a6 e1 04 cmp %i3, 0x104
uint16_t time_val = 0;
40010520: c0 37 bf 68 clrh [ %fp + -152 ]
memset(dot_dotdot, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2);
40010524: c0 27 bf c0 clr [ %fp + -64 ]
40010528: c0 27 bf c4 clr [ %fp + -60 ]
uint16_t date = 0;
4001052c: c0 37 bf 6a clrh [ %fp + -150 ]
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
40010530: c0 27 bf 88 clr [ %fp + -120 ]
40010534: c0 27 bf 8c clr [ %fp + -116 ]
dir_pos->sname.cln = 0;
40010538: c0 27 bf 70 clr [ %fp + -144 ]
4001053c: c0 27 bf 90 clr [ %fp + -112 ]
40010540: c0 27 bf 94 clr [ %fp + -108 ]
dir_pos->sname.ofs = 0;
40010544: c0 27 bf 74 clr [ %fp + -140 ]
40010548: c0 27 bf 98 clr [ %fp + -104 ]
4001054c: c0 27 bf 9c clr [ %fp + -100 ]
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
40010550: c2 27 bf 78 st %g1, [ %fp + -136 ]
memset(dot_dotdot, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2);
40010554: c0 27 bf c8 clr [ %fp + -56 ]
40010558: c0 27 bf cc clr [ %fp + -52 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
4001055c: c2 27 bf 7c st %g1, [ %fp + -132 ]
40010560: c0 27 bf d0 clr [ %fp + -48 ]
40010564: c0 27 bf d4 clr [ %fp + -44 ]
40010568: c0 27 bf d8 clr [ %fp + -40 ]
4001056c: c0 27 bf dc clr [ %fp + -36 ]
40010570: c0 27 bf e0 clr [ %fp + -32 ]
40010574: c0 27 bf e4 clr [ %fp + -28 ]
40010578: c0 27 bf e8 clr [ %fp + -24 ]
4001057c: c0 27 bf ec clr [ %fp + -20 ]
40010580: c0 27 bf f0 clr [ %fp + -16 ]
40010584: c0 27 bf f4 clr [ %fp + -12 ]
40010588: c0 27 bf f8 clr [ %fp + -8 ]
4001058c: c0 27 bf fc clr [ %fp + -4 ]
if (name_len > MSDOS_NAME_MAX_LFN_WITH_DOT) {
40010590: 14 80 00 e6 bg 40010928 <msdos_creat_node+0x42c> <== NEVER TAKEN
40010594: f8 06 20 08 ld [ %i0 + 8 ], %i4
rtems_set_errno_and_return_minus_one(ENAMETOOLONG);
}
name_type = msdos_long_to_short (fs_info->converter,
40010598: d0 04 a0 cc ld [ %l2 + 0xcc ], %o0
4001059c: 98 10 20 0b mov 0xb, %o4
400105a0: 96 07 bf 80 add %fp, -128, %o3
400105a4: 94 10 00 1b mov %i3, %o2
400105a8: 40 00 01 b3 call 40010c74 <msdos_long_to_short>
400105ac: 92 10 00 1a mov %i2, %o1
name, name_len,
MSDOS_DIR_NAME(short_node),
MSDOS_NAME_MAX);
if (name_type == MSDOS_NAME_INVALID) {
400105b0: b0 92 20 00 orcc %o0, 0, %i0
400105b4: 02 80 00 e3 be 40010940 <msdos_creat_node+0x444> <== NEVER TAKEN
400105b8: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(EINVAL);
}
/* fill reserved field */
*MSDOS_DIR_NT_RES(short_node) = MSDOS_RES_NT_VALUE;
400105bc: c0 2f bf 8c clrb [ %fp + -116 ]
/* set up last write date and time */
now = time(NULL);
400105c0: 40 00 3e 49 call 4001fee4 <time>
400105c4: 90 10 20 00 clr %o0
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;
400105c8: c2 0f 20 30 ldub [ %i4 + 0x30 ], %g1
400105cc: a6 10 00 08 mov %o0, %l3
400105d0: 82 10 60 02 or %g1, 2, %g1
400105d4: a0 10 00 09 mov %o1, %l0
fat_fd->ctime = t;
400105d8: d2 27 20 44 st %o1, [ %i4 + 0x44 ]
fat_file_set_ctime_mtime(parent_fat_fd, now);
msdos_date_unix2dos(now, &date, &time_val);
400105dc: 94 07 bf 68 add %fp, -152, %o2
fat_fd->flags |= FAT_FILE_META_DATA_CHANGED;
400105e0: c2 2f 20 30 stb %g1, [ %i4 + 0x30 ]
400105e4: 92 07 bf 6a add %fp, -150, %o1
fat_fd->ctime = t;
400105e8: e6 27 20 40 st %l3, [ %i4 + 0x40 ]
400105ec: 90 10 00 10 mov %l0, %o0
fat_fd->mtime = t;
400105f0: e6 27 20 48 st %l3, [ %i4 + 0x48 ]
400105f4: 40 00 1c 62 call 4001777c <msdos_date_unix2dos>
400105f8: e0 27 20 4c st %l0, [ %i4 + 0x4c ]
*MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);
400105fc: c4 17 bf 68 lduh [ %fp + -152 ], %g2
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
40010600: c2 17 bf 6a lduh [ %fp + -150 ], %g1
*MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);
40010604: 89 28 a0 08 sll %g2, 8, %g4
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
40010608: 87 28 60 08 sll %g1, 8, %g3
*MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);
4001060c: 85 28 a0 10 sll %g2, 0x10, %g2
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
40010610: 83 28 60 10 sll %g1, 0x10, %g1
*MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);
40010614: 85 30 a0 18 srl %g2, 0x18, %g2
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
40010618: 83 30 60 18 srl %g1, 0x18, %g1
*MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);
4001061c: 84 11 00 02 or %g4, %g2, %g2
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
40010620: 82 10 c0 01 or %g3, %g1, %g1
*MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);
40010624: c4 37 bf 8e sth %g2, [ %fp + -114 ]
*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;
if (type == FAT_DIRECTORY) {
40010628: 80 a6 60 00 cmp %i1, 0
*MSDOS_DIR_WRITE_TIME(short_node) = CT_LE_W(time_val);
4001062c: c4 37 bf 96 sth %g2, [ %fp + -106 ]
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
40010630: c2 37 bf 90 sth %g1, [ %fp + -112 ]
*MSDOS_DIR_WRITE_DATE(short_node) = CT_LE_W(date);
40010634: c2 37 bf 98 sth %g1, [ %fp + -104 ]
*MSDOS_DIR_LAST_ACCESS_DATE(short_node) = CT_LE_W(date);
40010638: c2 37 bf 92 sth %g1, [ %fp + -110 ]
if (type == FAT_DIRECTORY) {
4001063c: 02 80 00 12 be 40010684 <msdos_creat_node+0x188>
40010640: c0 27 bf 9c clr [ %fp + -100 ]
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_DIRECTORY;
}
else if (type == FAT_HARD_LINK) {
40010644: 80 a6 60 02 cmp %i1, 2
40010648: 02 80 00 7f be 40010844 <msdos_creat_node+0x348> <== NEVER TAKEN
4001064c: c2 0f bf 8b ldub [ %fp + -117 ], %g1
* set "archive bit" due to changes
*/
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
}
else { /* regular file... */
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
40010650: 82 10 60 20 or %g1, 0x20, %g1
40010654: c2 2f bf 8b stb %g1, [ %fp + -117 ]
/*
* 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,
40010658: 82 07 bf 80 add %fp, -128, %g1
4001065c: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
40010660: 98 10 00 18 mov %i0, %o4
40010664: 9a 07 bf 70 add %fp, -144, %o5
40010668: 96 10 00 1b mov %i3, %o3
4001066c: 94 10 00 1a mov %i2, %o2
40010670: 92 10 20 01 mov 1, %o1
40010674: 40 00 07 85 call 40012488 <msdos_get_name_node>
40010678: 90 10 00 11 mov %l1, %o0
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;
}
4001067c: 81 c7 e0 08 ret
40010680: 91 e8 00 08 restore %g0, %o0, %o0
rc = msdos_get_name_node(parent_loc, true, name, name_len,
40010684: 82 07 bf 80 add %fp, -128, %g1
40010688: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
4001068c: 98 10 00 18 mov %i0, %o4
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_DIRECTORY;
40010690: c2 0f bf 8b ldub [ %fp + -117 ], %g1
40010694: 82 10 60 10 or %g1, 0x10, %g1
rc = msdos_get_name_node(parent_loc, true, name, name_len,
40010698: 9a 07 bf 70 add %fp, -144, %o5
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_DIRECTORY;
4001069c: c2 2f bf 8b stb %g1, [ %fp + -117 ]
rc = msdos_get_name_node(parent_loc, true, name, name_len,
400106a0: 96 10 00 1b mov %i3, %o3
400106a4: 94 10 00 1a mov %i2, %o2
400106a8: 92 10 20 01 mov 1, %o1
400106ac: 40 00 07 77 call 40012488 <msdos_get_name_node>
400106b0: 90 10 00 11 mov %l1, %o0
if ( rc != RC_OK )
400106b4: b0 92 20 00 orcc %o0, 0, %i0
400106b8: 12 80 00 0c bne 400106e8 <msdos_creat_node+0x1ec> <== NEVER TAKEN
400106bc: 94 07 bf 6c add %fp, -148, %o2
rc = fat_file_open(&fs_info->fat, &dir_pos, &fat_fd);
400106c0: 92 07 bf 70 add %fp, -144, %o1
400106c4: 7f ff fb a0 call 4000f544 <fat_file_open>
400106c8: 90 10 00 12 mov %l2, %o0
if (rc != RC_OK)
400106cc: b0 92 20 00 orcc %o0, 0, %i0
400106d0: 02 80 00 08 be 400106f0 <msdos_creat_node+0x1f4> <== ALWAYS TAKEN
400106d4: d2 07 bf 6c ld [ %fp + -148 ], %o1
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
400106d8: d0 04 60 14 ld [ %l1 + 0x14 ], %o0 <== NOT EXECUTED
400106dc: 94 10 20 e5 mov 0xe5, %o2 <== NOT EXECUTED
400106e0: 40 00 02 c8 call 40011200 <msdos_set_first_char4file_name> <== NOT EXECUTED
400106e4: 92 07 bf 70 add %fp, -144, %o1 <== NOT EXECUTED
return rc;
400106e8: 81 c7 e0 08 ret <== NOT EXECUTED
400106ec: 81 e8 00 00 restore <== NOT EXECUTED
fat_fd->flags |= FAT_FILE_META_DATA_CHANGED;
400106f0: c2 0a 60 30 ldub [ %o1 + 0x30 ], %g1
400106f4: 82 10 60 02 or %g1, 2, %g1
400106f8: c2 2a 60 30 stb %g1, [ %o1 + 0x30 ]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGTH;
400106fc: 03 00 08 00 sethi %hi(0x200000), %g1
fat_fd->fat_file_type = FAT_DIRECTORY;
40010700: c0 22 60 10 clr [ %o1 + 0x10 ]
rc = fat_file_extend(&fs_info->fat,
40010704: 98 07 bf a0 add %fp, -96, %o4
fat_fd->size_limit = MSDOS_MAX_DIR_LENGTH;
40010708: c2 22 60 14 st %g1, [ %o1 + 0x14 ]
rc = fat_file_extend(&fs_info->fat,
4001070c: 94 10 20 01 mov 1, %o2
fat_fd->ctime = t;
40010710: e6 22 60 40 st %l3, [ %o1 + 0x40 ]
40010714: 90 10 00 12 mov %l2, %o0
40010718: e0 22 60 44 st %l0, [ %o1 + 0x44 ]
fat_fd->mtime = t;
4001071c: e6 22 60 48 st %l3, [ %o1 + 0x48 ]
40010720: e0 22 60 4c st %l0, [ %o1 + 0x4c ]
40010724: 7f ff fd 91 call 4000fd68 <fat_file_extend>
40010728: d6 04 a0 08 ld [ %l2 + 8 ], %o3
if (rc != RC_OK)
4001072c: b0 92 20 00 orcc %o0, 0, %i0
40010730: 32 bf ff eb bne,a 400106dc <msdos_creat_node+0x1e0> <== NEVER TAKEN
40010734: d0 04 60 14 ld [ %l1 + 0x14 ], %o0 <== NOT EXECUTED
memcpy(DOT_NODE_P(dot_dotdot), short_node,
40010738: d8 1f bf 80 ldd [ %fp + -128 ], %o4
4001073c: c4 1f bf 98 ldd [ %fp + -104 ], %g2
40010740: f0 1f bf 88 ldd [ %fp + -120 ], %i0
40010744: f4 1f bf 90 ldd [ %fp + -112 ], %i2
memcpy(MSDOS_DIR_NAME(DOT_NODE_P(dot_dotdot)), MSDOS_DOT_NAME,
40010748: 03 10 00 9c sethi %hi(0x40027000), %g1
4001074c: d2 00 60 c8 ld [ %g1 + 0xc8 ], %o1 ! 400270c8 <MSDOS_DOT_NAME>
memcpy(DOT_NODE_P(dot_dotdot), short_node,
40010750: d8 3f bf c0 std %o4, [ %fp + -64 ]
memcpy(MSDOS_DIR_NAME(DOT_NODE_P(dot_dotdot)), MSDOS_DOT_NAME,
40010754: 94 10 20 0b mov 0xb, %o2
memcpy(DOT_NODE_P(dot_dotdot), short_node,
40010758: c4 3f bf d8 std %g2, [ %fp + -40 ]
memcpy(MSDOS_DIR_NAME(DOT_NODE_P(dot_dotdot)), MSDOS_DOT_NAME,
4001075c: 90 07 bf c0 add %fp, -64, %o0
memcpy(DOTDOT_NODE_P(dot_dotdot), short_node,
40010760: d8 3f bf e0 std %o4, [ %fp + -32 ]
40010764: c4 3f bf f8 std %g2, [ %fp + -8 ]
memcpy(DOT_NODE_P(dot_dotdot), short_node,
40010768: f0 3f bf c8 std %i0, [ %fp + -56 ]
4001076c: f4 3f bf d0 std %i2, [ %fp + -48 ]
memcpy(DOTDOT_NODE_P(dot_dotdot), short_node,
40010770: f0 3f bf e8 std %i0, [ %fp + -24 ]
memcpy(MSDOS_DIR_NAME(DOT_NODE_P(dot_dotdot)), MSDOS_DOT_NAME,
40010774: 40 00 2e bc call 4001c264 <memcpy>
40010778: f4 3f bf f0 std %i2, [ %fp + -16 ]
memcpy(MSDOS_DIR_NAME(DOTDOT_NODE_P(dot_dotdot)), MSDOS_DOTDOT_NAME,
4001077c: 03 10 00 9c sethi %hi(0x40027000), %g1
40010780: d2 00 60 c4 ld [ %g1 + 0xc4 ], %o1 ! 400270c4 <MSDOS_DOTDOT_NAME>
40010784: 94 10 20 0b mov 0xb, %o2
40010788: 40 00 2e b7 call 4001c264 <memcpy>
4001078c: 90 07 bf e0 add %fp, -32, %o0
if ((FAT_FD_OF_ROOT_DIR(parent_fat_fd)) &&
40010790: c2 07 20 20 ld [ %i4 + 0x20 ], %g1
40010794: 80 a0 60 01 cmp %g1, 1
40010798: 22 80 00 55 be,a 400108ec <msdos_creat_node+0x3f0>
4001079c: c2 07 20 24 ld [ %i4 + 0x24 ], %g1
CT_LE_W((uint16_t )((parent_fat_fd->cln) & 0x0000FFFF));
400107a0: c2 07 20 1c ld [ %i4 + 0x1c ], %g1
CT_LE_W((uint16_t )(((parent_fat_fd->cln) & 0xFFFF0000)>>16));
400107a4: 85 30 60 10 srl %g1, 0x10, %g2
CT_LE_W((uint16_t )((parent_fat_fd->cln) & 0x0000FFFF));
400107a8: 89 28 60 08 sll %g1, 8, %g4
CT_LE_W((uint16_t )(((parent_fat_fd->cln) & 0xFFFF0000)>>16));
400107ac: 87 28 a0 08 sll %g2, 8, %g3
CT_LE_W((uint16_t )((parent_fat_fd->cln) & 0x0000FFFF));
400107b0: 83 28 60 10 sll %g1, 0x10, %g1
CT_LE_W((uint16_t )(((parent_fat_fd->cln) & 0xFFFF0000)>>16));
400107b4: 85 30 a0 08 srl %g2, 8, %g2
CT_LE_W((uint16_t )((parent_fat_fd->cln) & 0x0000FFFF));
400107b8: 83 30 60 18 srl %g1, 0x18, %g1
CT_LE_W((uint16_t )(((parent_fat_fd->cln) & 0xFFFF0000)>>16));
400107bc: 84 10 c0 02 or %g3, %g2, %g2
CT_LE_W((uint16_t )((parent_fat_fd->cln) & 0x0000FFFF));
400107c0: 82 11 00 01 or %g4, %g1, %g1
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) =
400107c4: c4 37 bf f4 sth %g2, [ %fp + -12 ]
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) =
400107c8: c2 37 bf fa sth %g1, [ %fp + -6 ]
ret = fat_file_write(&fs_info->fat, fat_fd, 0,
400107cc: 98 07 bf c0 add %fp, -64, %o4
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
400107d0: d2 07 bf 6c ld [ %fp + -148 ], %o1
400107d4: c2 02 60 1c ld [ %o1 + 0x1c ], %g1
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
400107d8: 85 30 60 10 srl %g1, 0x10, %g2
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
400107dc: 89 28 60 08 sll %g1, 8, %g4
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
400107e0: 87 28 a0 08 sll %g2, 8, %g3
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
400107e4: 83 28 60 10 sll %g1, 0x10, %g1
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
400107e8: 85 30 a0 08 srl %g2, 8, %g2
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
400107ec: 83 30 60 18 srl %g1, 0x18, %g1
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
400107f0: 84 10 c0 02 or %g3, %g2, %g2
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
400107f4: 82 11 00 01 or %g4, %g1, %g1
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
400107f8: c4 37 bf d4 sth %g2, [ %fp + -44 ]
ret = fat_file_write(&fs_info->fat, fat_fd, 0,
400107fc: 96 10 20 40 mov 0x40, %o3
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
40010800: c2 37 bf da sth %g1, [ %fp + -38 ]
ret = fat_file_write(&fs_info->fat, fat_fd, 0,
40010804: 94 10 20 00 clr %o2
40010808: 7f ff fd f0 call 4000ffc8 <fat_file_write>
4001080c: 90 10 00 12 mov %l2, %o0
if (ret < 0)
40010810: 80 a2 20 00 cmp %o0, 0
40010814: 06 80 00 40 bl 40010914 <msdos_creat_node+0x418> <== NEVER TAKEN
40010818: b0 10 3f ff mov -1, %i0
rc = fat_file_write_first_cluster_num(&fs_info->fat, fat_fd);
4001081c: d2 07 bf 6c ld [ %fp + -148 ], %o1
40010820: 40 00 02 21 call 400110a4 <fat_file_write_first_cluster_num>
40010824: 90 10 00 12 mov %l2, %o0
if (rc != RC_OK)
40010828: b0 92 20 00 orcc %o0, 0, %i0
4001082c: 12 80 00 3b bne 40010918 <msdos_creat_node+0x41c> <== NEVER TAKEN
40010830: d2 07 bf 6c ld [ %fp + -148 ], %o1
fat_file_close(&fs_info->fat, fat_fd);
40010834: 7f ff fc e3 call 4000fbc0 <fat_file_close>
40010838: 90 10 00 12 mov %l2, %o0
4001083c: 81 c7 e0 08 ret
40010840: 81 e8 00 00 restore
sec = fat_cluster_num_to_sector_num(&fs_info->fat,
40010844: c2 07 60 20 ld [ %i5 + 0x20 ], %g1 <== NOT EXECUTED
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
40010848: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4001084c: 32 80 00 07 bne,a 40010868 <msdos_creat_node+0x36c> <== NOT EXECUTED
40010850: c4 0c a0 05 ldub [ %l2 + 5 ], %g2 <== NOT EXECUTED
40010854: c4 0c a0 16 ldub [ %l2 + 0x16 ], %g2 <== NOT EXECUTED
40010858: 80 88 a0 03 btst 3, %g2 <== NOT EXECUTED
4001085c: 32 80 00 07 bne,a 40010878 <msdos_creat_node+0x37c> <== NOT EXECUTED
40010860: c2 04 a0 28 ld [ %l2 + 0x28 ], %g1 <== NOT EXECUTED
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
40010864: c4 0c a0 05 ldub [ %l2 + 5 ], %g2 <== NOT EXECUTED
40010868: d2 04 a0 3c ld [ %l2 + 0x3c ], %o1 <== NOT EXECUTED
4001086c: 82 00 7f fe add %g1, -2, %g1 <== NOT EXECUTED
40010870: 83 28 40 02 sll %g1, %g2, %g1 <== NOT EXECUTED
40010874: 82 00 40 09 add %g1, %o1, %g1 <== NOT EXECUTED
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
40010878: c4 14 80 00 lduh [ %l2 ], %g2 <== NOT EXECUTED
sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
4001087c: d4 07 60 24 ld [ %i5 + 0x24 ], %o2 <== NOT EXECUTED
40010880: d2 0c a0 02 ldub [ %l2 + 2 ], %o1 <== NOT EXECUTED
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
40010884: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
40010888: 93 32 80 09 srl %o2, %o1, %o1 <== NOT EXECUTED
ret = _fat_block_read(&fs_info->fat,
4001088c: 98 07 bf a0 add %fp, -96, %o4 <== NOT EXECUTED
40010890: 96 10 20 20 mov 0x20, %o3 <== NOT EXECUTED
40010894: 94 08 80 0a and %g2, %o2, %o2 <== NOT EXECUTED
40010898: 92 02 40 01 add %o1, %g1, %o1 <== NOT EXECUTED
4001089c: 7f ff f5 0d call 4000dcd0 <_fat_block_read> <== NOT EXECUTED
400108a0: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
if (ret < 0) {
400108a4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400108a8: 06 80 00 2c bl 40010958 <msdos_creat_node+0x45c> <== NOT EXECUTED
400108ac: c4 0f bf ad ldub [ %fp + -83 ], %g2 <== NOT EXECUTED
*MSDOS_DIR_CRT_TIME_TENTH(short_node)=*MSDOS_DIR_CRT_TIME_TENTH(link_node);
400108b0: c4 2f bf 8d stb %g2, [ %fp + -115 ] <== NOT EXECUTED
*MSDOS_DIR_CRT_TIME(short_node) =*MSDOS_DIR_CRT_TIME(link_node);
400108b4: c4 17 bf ae lduh [ %fp + -82 ], %g2 <== NOT EXECUTED
400108b8: c4 37 bf 8e sth %g2, [ %fp + -114 ] <== NOT EXECUTED
*MSDOS_DIR_CRT_DATE(short_node) =*MSDOS_DIR_CRT_DATE(link_node);
400108bc: c4 17 bf b0 lduh [ %fp + -80 ], %g2 <== NOT EXECUTED
400108c0: c4 37 bf 90 sth %g2, [ %fp + -112 ] <== NOT EXECUTED
*MSDOS_DIR_FILE_SIZE(short_node) =*MSDOS_DIR_FILE_SIZE(link_node);
400108c4: c4 07 bf bc ld [ %fp + -68 ], %g2 <== NOT EXECUTED
400108c8: c4 27 bf 9c st %g2, [ %fp + -100 ] <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_LOW(short_node) =
400108cc: c4 17 bf ba lduh [ %fp + -70 ], %g2 <== NOT EXECUTED
400108d0: c4 37 bf 9a sth %g2, [ %fp + -102 ] <== NOT EXECUTED
*MSDOS_DIR_ATTR(short_node) =*MSDOS_DIR_ATTR(link_node);
400108d4: c2 0f bf ab ldub [ %fp + -85 ], %g1 <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_HI(short_node) =
400108d8: c4 17 bf b4 lduh [ %fp + -76 ], %g2 <== NOT EXECUTED
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
400108dc: 82 10 60 20 or %g1, 0x20, %g1 <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_HI(short_node) =
400108e0: c4 37 bf 94 sth %g2, [ %fp + -108 ] <== NOT EXECUTED
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
400108e4: 10 bf ff 5d b 40010658 <msdos_creat_node+0x15c> <== NOT EXECUTED
400108e8: c2 2f bf 8b stb %g1, [ %fp + -117 ] <== NOT EXECUTED
if ((FAT_FD_OF_ROOT_DIR(parent_fat_fd)) &&
400108ec: 80 a0 60 00 cmp %g1, 0
400108f0: 32 bf ff ad bne,a 400107a4 <msdos_creat_node+0x2a8> <== NEVER TAKEN
400108f4: c2 07 20 1c ld [ %i4 + 0x1c ], %g1 <== NOT EXECUTED
400108f8: c2 0c a0 16 ldub [ %l2 + 0x16 ], %g1
400108fc: 80 88 60 04 btst 4, %g1
40010900: 22 bf ff a9 be,a 400107a4 <msdos_creat_node+0x2a8> <== ALWAYS TAKEN
40010904: c2 07 20 1c ld [ %i4 + 0x1c ], %g1
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
40010908: c0 37 bf fa clrh [ %fp + -6 ] <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
4001090c: 10 bf ff b0 b 400107cc <msdos_creat_node+0x2d0> <== NOT EXECUTED
40010910: c0 37 bf f4 clrh [ %fp + -12 ] <== NOT EXECUTED
fat_file_close(&fs_info->fat, fat_fd);
40010914: d2 07 bf 6c ld [ %fp + -148 ], %o1 <== NOT EXECUTED
40010918: 7f ff fc aa call 4000fbc0 <fat_file_close> <== NOT EXECUTED
4001091c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
40010920: 10 bf ff 6f b 400106dc <msdos_creat_node+0x1e0> <== NOT EXECUTED
40010924: d0 04 60 14 ld [ %l1 + 0x14 ], %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENAMETOOLONG);
40010928: 40 00 2c 61 call 4001baac <__errno> <== NOT EXECUTED
4001092c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40010930: 82 10 20 5b mov 0x5b, %g1 <== NOT EXECUTED
40010934: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40010938: 81 c7 e0 08 ret <== NOT EXECUTED
4001093c: 81 e8 00 00 restore <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EINVAL);
40010940: 40 00 2c 5b call 4001baac <__errno> <== NOT EXECUTED
40010944: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40010948: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
4001094c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40010950: 81 c7 e0 08 ret <== NOT EXECUTED
40010954: 81 e8 00 00 restore <== NOT EXECUTED
return -1;
40010958: 81 c7 e0 08 ret <== NOT EXECUTED
4001095c: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
4001792c <msdos_date_dos2unix>:
uint32_t y, year;
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
4001792c: 89 32 60 05 srl %o1, 5, %g4
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
/*
* If the year, month, and day from the last conversion are the
* same then use the saved value.
*/
if (lastdosdate != dd) {
40017930: 07 10 00 b0 sethi %hi(0x4002c000), %g3
40017934: da 10 e2 98 lduh [ %g3 + 0x298 ], %o5 ! 4002c298 <lastdosdate>
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
40017938: 83 32 60 0b srl %o1, 0xb, %g1
+ ((dt & MSDOS_DT_MINUTES_MASK) >> MSDOS_DT_MINUTES_SHIFT) * 60
4001793c: 84 09 20 3f and %g4, 0x3f, %g2
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
40017940: 82 08 60 1f and %g1, 0x1f, %g1
+ ((dt & MSDOS_DT_MINUTES_MASK) >> MSDOS_DT_MINUTES_SHIFT) * 60
40017944: 89 28 a0 04 sll %g2, 4, %g4
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
40017948: 82 58 67 08 smul %g1, 0x708, %g1
seconds = 2 * ((dt & MSDOS_DT_2SECONDS_MASK) >> MSDOS_DT_2SECONDS_SHIFT)
4001794c: 92 0a 60 1f and %o1, 0x1f, %o1
+ ((dt & MSDOS_DT_MINUTES_MASK) >> MSDOS_DT_MINUTES_SHIFT) * 60
40017950: 88 21 00 02 sub %g4, %g2, %g4
if (lastdosdate != dd) {
40017954: 80 a3 40 08 cmp %o5, %o0
+ ((dt & MSDOS_DT_MINUTES_MASK) >> MSDOS_DT_MINUTES_SHIFT) * 60
40017958: 89 29 20 01 sll %g4, 1, %g4
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
4001795c: 88 00 40 04 add %g1, %g4, %g4
40017960: 88 01 00 09 add %g4, %o1, %g4
if (lastdosdate != dd) {
40017964: 02 80 00 36 be 40017a3c <msdos_date_dos2unix+0x110>
40017968: 89 29 20 01 sll %g4, 1, %g4
lastdosdate = dd;
4001796c: d0 30 e2 98 sth %o0, [ %g3 + 0x298 ]
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
40017970: 99 32 20 09 srl %o0, 9, %o4
days = 0;
40017974: 84 10 20 00 clr %g2
for (y = 0; y < year; y++)
40017978: 82 10 20 00 clr %g1
4001797c: 9a 8b 20 7f andcc %o4, 0x7f, %o5
40017980: 12 80 00 08 bne 400179a0 <msdos_date_dos2unix+0x74> <== ALWAYS TAKEN
40017984: 86 10 21 6e mov 0x16e, %g3
days += y & 0x03 ? 365 : 366;
months = year & 0x03 ? regyear : leapyear;
40017988: 10 80 00 0b b 400179b4 <msdos_date_dos2unix+0x88> <== NOT EXECUTED
4001798c: 80 8b 20 03 btst 3, %o4 <== NOT EXECUTED
days += y & 0x03 ? 365 : 366;
40017990: 86 08 60 03 and %g1, 3, %g3
40017994: 80 a0 00 03 cmp %g0, %g3
40017998: 86 60 3f ff subx %g0, -1, %g3
4001799c: 86 00 e1 6d add %g3, 0x16d, %g3
for (y = 0; y < year; y++)
400179a0: 82 00 60 01 inc %g1
400179a4: 80 a3 40 01 cmp %o5, %g1
400179a8: 12 bf ff fa bne 40017990 <msdos_date_dos2unix+0x64>
400179ac: 84 00 80 03 add %g2, %g3, %g2
months = year & 0x03 ? regyear : leapyear;
400179b0: 80 8b 20 03 btst 3, %o4
400179b4: 12 80 00 20 bne 40017a34 <msdos_date_dos2unix+0x108>
400179b8: 03 10 00 a7 sethi %hi(0x40029c00), %g1
400179bc: 03 10 00 a7 sethi %hi(0x40029c00), %g1
400179c0: 82 10 62 28 or %g1, 0x228, %g1 ! 40029e28 <leapyear>
/*
* Prevent going from 0 to 0xffffffff in the following
* loop.
*/
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
400179c4: 87 32 20 05 srl %o0, 5, %g3
400179c8: 9a 88 e0 0f andcc %g3, 0xf, %o5
400179cc: 22 80 00 02 be,a 400179d4 <msdos_date_dos2unix+0xa8> <== NEVER TAKEN
400179d0: 9a 10 20 01 mov 1, %o5 <== NOT EXECUTED
if (month == 0) {
month = 1;
}
for (m = 0; m < month - 1; m++)
400179d4: 80 88 e0 0e btst 0xe, %g3
400179d8: 22 80 00 0b be,a 40017a04 <msdos_date_dos2unix+0xd8>
400179dc: 82 0a 20 1f and %o0, 0x1f, %g1
400179e0: 9b 2b 60 01 sll %o5, 1, %o5
400179e4: 9a 03 7f fe add %o5, -2, %o5
400179e8: 9a 00 40 0d add %g1, %o5, %o5
days += months[m];
400179ec: c6 10 40 00 lduh [ %g1 ], %g3
for (m = 0; m < month - 1; m++)
400179f0: 82 00 60 02 add %g1, 2, %g1
400179f4: 80 a3 40 01 cmp %o5, %g1
400179f8: 12 bf ff fd bne 400179ec <msdos_date_dos2unix+0xc0> <== NEVER TAKEN
400179fc: 84 00 80 03 add %g2, %g3, %g2
days += ((dd & MSDOS_DD_DAY_MASK) >> MSDOS_DD_DAY_SHIFT) - 1;
40017a00: 82 0a 20 1f and %o0, 0x1f, %g1
lastseconds = (days + DAYSTO1980) * SECONDSPERDAY;
40017a04: 11 00 00 54 sethi %hi(0x15000), %o0
days += ((dd & MSDOS_DD_DAY_MASK) >> MSDOS_DD_DAY_SHIFT) - 1;
40017a08: 82 00 7f ff add %g1, -1, %g1
lastseconds = (days + DAYSTO1980) * SECONDSPERDAY;
40017a0c: 90 12 21 80 or %o0, 0x180, %o0
days += ((dd & MSDOS_DD_DAY_MASK) >> MSDOS_DD_DAY_SHIFT) - 1;
40017a10: 84 00 40 02 add %g1, %g2, %g2
lastseconds = (days + DAYSTO1980) * SECONDSPERDAY;
40017a14: 03 10 00 b0 sethi %hi(0x4002c000), %g1
40017a18: 84 58 80 08 smul %g2, %o0, %g2
40017a1c: 11 04 b3 a9 sethi %hi(0x12cea400), %o0
40017a20: 90 12 22 00 or %o0, 0x200, %o0 ! 12cea600 <RAM_SIZE+0x128ea600>
40017a24: 90 00 80 08 add %g2, %o0, %o0
40017a28: d0 20 62 94 st %o0, [ %g1 + 0x294 ]
}
return seconds + lastseconds;
}
40017a2c: 81 c3 e0 08 retl
40017a30: 90 01 00 08 add %g4, %o0, %o0
months = year & 0x03 ? regyear : leapyear;
40017a34: 10 bf ff e4 b 400179c4 <msdos_date_dos2unix+0x98>
40017a38: 82 10 62 40 or %g1, 0x240, %g1
return seconds + lastseconds;
40017a3c: 03 10 00 b0 sethi %hi(0x4002c000), %g1
40017a40: d0 00 62 94 ld [ %g1 + 0x294 ], %o0 ! 4002c294 <lastseconds>
}
40017a44: 81 c3 e0 08 retl
40017a48: 90 01 00 08 add %g4, %o0, %o0
4001777c <msdos_date_unix2dos>:
/*
* If the time from the last conversion is the same as now, then
* skip the computations and use the saved result.
*/
if (lasttime != t) {
4001777c: 1b 10 00 b0 sethi %hi(0x4002c000), %o5
40017780: c2 03 62 a4 ld [ %o5 + 0x2a4 ], %g1 ! 4002c2a4 <lasttime>
40017784: 80 a0 40 08 cmp %g1, %o0
40017788: 02 80 00 56 be 400178e0 <msdos_date_unix2dos+0x164>
4001778c: 07 22 22 22 sethi %hi(0x88888800), %g3
lasttime = t;
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
40017790: 86 10 e0 89 or %g3, 0x89, %g3 ! 88888889 <RAM_END+0x48488889>
40017794: 80 52 00 03 umul %o0, %g3, %g0
40017798: 85 40 00 00 rd %y, %g2
4001779c: 97 30 a0 05 srl %g2, 5, %o3
400177a0: 80 52 c0 03 umul %o3, %g3, %g0
400177a4: 87 40 00 00 rd %y, %g3
400177a8: 89 30 e0 05 srl %g3, 5, %g4
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
400177ac: 03 24 68 ac sethi %hi(0x91a2b000), %g1
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
400177b0: 87 29 20 04 sll %g4, 4, %g3
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
400177b4: 82 10 63 c5 or %g1, 0x3c5, %g1
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
400177b8: 86 20 c0 04 sub %g3, %g4, %g3
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
400177bc: 80 52 00 01 umul %o0, %g1, %g0
400177c0: 83 40 00 00 rd %y, %g1
400177c4: 19 2a aa aa sethi %hi(0xaaaaa800), %o4
400177c8: 83 30 60 0b srl %g1, 0xb, %g1
400177cc: 98 13 22 ab or %o4, 0x2ab, %o4
400177d0: 80 50 40 0c umul %g1, %o4, %g0
400177d4: 99 40 00 00 rd %y, %o4
400177d8: 89 33 20 04 srl %o4, 4, %g4
400177dc: 85 29 20 01 sll %g4, 1, %g2
400177e0: 88 00 80 04 add %g2, %g4, %g4
400177e4: 89 29 20 03 sll %g4, 3, %g4
400177e8: 82 20 40 04 sub %g1, %g4, %g1
400177ec: 83 28 60 0b sll %g1, 0xb, %g1
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
400177f0: 87 28 e0 02 sll %g3, 2, %g3
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
400177f4: 85 2a e0 04 sll %o3, 4, %g2
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
400177f8: 86 22 c0 03 sub %o3, %g3, %g3
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
400177fc: 84 20 80 0b sub %g2, %o3, %g2
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
40017800: 87 28 e0 05 sll %g3, 5, %g3
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
40017804: 85 28 a0 02 sll %g2, 2, %g2
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
40017808: 86 00 c0 01 add %g3, %g1, %g3
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
4001780c: 82 22 00 02 sub %o0, %g2, %g1
40017810: 83 30 60 01 srl %g1, 1, %g1
lasttime = t;
40017814: d0 23 62 a4 st %o0, [ %o5 + 0x2a4 ]
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
40017818: 86 00 c0 01 add %g3, %g1, %g3
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
4001781c: 03 10 00 b0 sethi %hi(0x4002c000), %g1
40017820: c6 30 62 9a sth %g3, [ %g1 + 0x29a ] ! 4002c29a <lastdtime>
* 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);
if (days != lastday) {
40017824: 05 10 00 b0 sethi %hi(0x4002c000), %g2
days = t / (SECONDSPERDAY);
40017828: 03 30 8b 91 sethi %hi(0xc22e4400), %g1
if (days != lastday) {
4001782c: c8 00 a2 a0 ld [ %g2 + 0x2a0 ], %g4
days = t / (SECONDSPERDAY);
40017830: 82 10 61 07 or %g1, 0x107, %g1
40017834: 80 52 00 01 umul %o0, %g1, %g0
40017838: 91 40 00 00 rd %y, %o0
lastddate += (year - 1980) <<
MSDOS_DD_YEAR_SHIFT;
}
}
*dtp = lastdtime;
*ddp = lastddate;
4001783c: 03 10 00 b0 sethi %hi(0x4002c000), %g1
days = t / (SECONDSPERDAY);
40017840: 91 32 20 10 srl %o0, 0x10, %o0
if (days != lastday) {
40017844: 80 a1 00 08 cmp %g4, %o0
40017848: 02 80 00 23 be 400178d4 <msdos_date_unix2dos+0x158>
4001784c: c2 10 62 9c lduh [ %g1 + 0x29c ], %g1
lastday = days;
40017850: d0 20 a2 a0 st %o0, [ %g2 + 0x2a0 ]
for (year = 1970;; year++) {
40017854: 10 80 00 03 b 40017860 <msdos_date_unix2dos+0xe4>
40017858: 84 10 27 b2 mov 0x7b2, %g2
4001785c: 84 00 a0 01 inc %g2
inc = year & 0x03 ? 365 : 366;
40017860: 88 08 a0 03 and %g2, 3, %g4
40017864: 80 a0 00 04 cmp %g0, %g4
40017868: 82 60 3f ff subx %g0, -1, %g1
4001786c: 82 00 61 6d add %g1, 0x16d, %g1
if (days < inc)
40017870: 80 a2 00 01 cmp %o0, %g1
40017874: 3a bf ff fa bcc,a 4001785c <msdos_date_unix2dos+0xe0>
40017878: 90 22 00 01 sub %o0, %g1, %o0
months = year & 0x03 ? regyear : leapyear;
4001787c: 80 a1 20 00 cmp %g4, 0
40017880: 12 80 00 1f bne 400178fc <msdos_date_unix2dos+0x180> <== NEVER TAKEN
40017884: 1b 10 00 a7 sethi %hi(0x40029c00), %o5
40017888: 1b 10 00 a7 sethi %hi(0x40029c00), %o5
4001788c: 9a 13 62 28 or %o5, 0x228, %o5 ! 40029e28 <leapyear>
for (month = 0; month < 12; month++) {
40017890: 82 10 20 00 clr %g1
if (days < months[month])
40017894: 89 28 60 01 sll %g1, 1, %g4
40017898: c8 13 40 04 lduh [ %o5 + %g4 ], %g4
4001789c: 80 a1 00 08 cmp %g4, %o0
400178a0: 18 80 00 21 bgu 40017924 <msdos_date_unix2dos+0x1a8> <== ALWAYS TAKEN
400178a4: 82 00 60 01 inc %g1
for (month = 0; month < 12; month++) {
400178a8: 80 a0 60 0c cmp %g1, 0xc <== NOT EXECUTED
400178ac: 12 bf ff fa bne 40017894 <msdos_date_unix2dos+0x118> <== NOT EXECUTED
400178b0: 90 22 00 04 sub %o0, %g4, %o0 <== NOT EXECUTED
400178b4: 82 10 21 a0 mov 0x1a0, %g1 <== NOT EXECUTED
+ ((month + 1) << MSDOS_DD_MONTH_SHIFT);
400178b8: 82 00 60 01 inc %g1
if (year > 1980)
400178bc: 80 a0 a7 bc cmp %g2, 0x7bc
+ ((month + 1) << MSDOS_DD_MONTH_SHIFT);
400178c0: 90 00 40 08 add %g1, %o0, %o0
if (year > 1980)
400178c4: 18 80 00 10 bgu 40017904 <msdos_date_unix2dos+0x188> <== ALWAYS TAKEN
400178c8: 82 10 00 08 mov %o0, %g1
lastddate = ((days + 1) << MSDOS_DD_DAY_SHIFT)
400178cc: 05 10 00 b0 sethi %hi(0x4002c000), %g2 <== NOT EXECUTED
400178d0: d0 30 a2 9c sth %o0, [ %g2 + 0x29c ] ! 4002c29c <lastddate> <== NOT EXECUTED
*dtp = lastdtime;
400178d4: c6 32 80 00 sth %g3, [ %o2 ]
}
400178d8: 81 c3 e0 08 retl
400178dc: c2 32 40 00 sth %g1, [ %o1 ]
*dtp = lastdtime;
400178e0: 03 10 00 b0 sethi %hi(0x4002c000), %g1
400178e4: c6 10 62 9a lduh [ %g1 + 0x29a ], %g3 ! 4002c29a <lastdtime>
400178e8: c6 32 80 00 sth %g3, [ %o2 ]
*ddp = lastddate;
400178ec: 03 10 00 b0 sethi %hi(0x4002c000), %g1
400178f0: c2 10 62 9c lduh [ %g1 + 0x29c ], %g1 ! 4002c29c <lastddate>
}
400178f4: 81 c3 e0 08 retl
400178f8: c2 32 40 00 sth %g1, [ %o1 ]
months = year & 0x03 ? regyear : leapyear;
400178fc: 10 bf ff e5 b 40017890 <msdos_date_unix2dos+0x114> <== NOT EXECUTED
40017900: 9a 13 62 40 or %o5, 0x240, %o5 <== NOT EXECUTED
*dtp = lastdtime;
40017904: c6 32 80 00 sth %g3, [ %o2 ]
lastddate += (year - 1980) <<
40017908: 84 00 b8 44 add %g2, -1980, %g2
4001790c: 85 28 a0 09 sll %g2, 9, %g2
40017910: 82 02 00 02 add %o0, %g2, %g1
40017914: 05 10 00 b0 sethi %hi(0x4002c000), %g2
*ddp = lastddate;
40017918: c2 32 40 00 sth %g1, [ %o1 ]
}
4001791c: 81 c3 e0 08 retl
40017920: c2 30 a2 9c sth %g1, [ %g2 + 0x29c ]
+ ((month + 1) << MSDOS_DD_MONTH_SHIFT);
40017924: 10 bf ff e5 b 400178b8 <msdos_date_unix2dos+0x13c>
40017928: 83 28 60 05 sll %g1, 5, %g1
40011390 <msdos_dir_is_empty>:
{
40011390: 9d e3 bf a0 save %sp, -96, %sp
msdos_fs_info_t *fs_info = mt_entry->fs_info;
40011394: f0 06 20 08 ld [ %i0 + 8 ], %i0
while ((ret = fat_file_read(&fs_info->fat, fat_fd, j * fs_info->fat.vol.bps,
40011398: f8 16 00 00 lduh [ %i0 ], %i4
*ret_val = false;
4001139c: c0 2e 80 00 clrb [ %i2 ]
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
400113a0: 23 10 00 9b sethi %hi(0x40026c00), %l1
while ((ret = fat_file_read(&fs_info->fat, fat_fd, j * fs_info->fat.vol.bps,
400113a4: ea 06 20 c8 ld [ %i0 + 0xc8 ], %l5
(strncmp(MSDOS_DIR_NAME((entry)),
400113a8: 25 10 00 9b sethi %hi(0x40026c00), %l2
uint32_t j = 0, i = 0;
400113ac: a6 10 20 00 clr %l3
400113b0: b9 2f 20 10 sll %i4, 0x10, %i4
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
400113b4: a2 14 63 c8 or %l1, 0x3c8, %l1
(strncmp(MSDOS_DIR_NAME((entry)),
400113b8: a4 14 a3 d8 or %l2, 0x3d8, %l2
while ((ret = fat_file_read(&fs_info->fat, fat_fd, j * fs_info->fat.vol.bps,
400113bc: 97 37 20 10 srl %i4, 0x10, %o3
400113c0: 98 10 00 15 mov %l5, %o4
400113c4: 94 5a c0 13 smul %o3, %l3, %o2
400113c8: 92 10 00 19 mov %i1, %o1
400113cc: 7f ff f9 43 call 4000f8d8 <fat_file_read>
400113d0: 90 10 00 18 mov %i0, %o0
400113d4: 80 a2 20 00 cmp %o0, 0
400113d8: 02 80 00 2d be 4001148c <msdos_dir_is_empty+0xfc> <== NEVER TAKEN
400113dc: 80 a2 20 1f cmp %o0, 0x1f
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
400113e0: 04 80 00 2f ble 4001149c <msdos_dir_is_empty+0x10c> <== NEVER TAKEN
400113e4: 01 00 00 00 nop
assert(ret == fs_info->fat.vol.bps);
400113e8: f8 16 00 00 lduh [ %i0 ], %i4
400113ec: b9 2f 20 10 sll %i4, 0x10, %i4
400113f0: a9 37 20 10 srl %i4, 0x10, %l4
400113f4: 80 a5 00 08 cmp %l4, %o0
400113f8: 12 80 00 2b bne 400114a4 <msdos_dir_is_empty+0x114> <== NEVER TAKEN
400113fc: 80 a5 20 00 cmp %l4, 0
char* entry = (char*) fs_info->cl_buf + i;
40011400: ea 06 20 c8 ld [ %i0 + 0xc8 ], %l5
40011404: ba 10 00 15 mov %l5, %i5
for (i = 0;
40011408: 02 80 00 1f be 40011484 <msdos_dir_is_empty+0xf4> <== NEVER TAKEN
4001140c: b6 10 20 00 clr %i3
if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
40011410: e0 0f 40 00 ldub [ %i5 ], %l0
40011414: 80 a4 20 e5 cmp %l0, 0xe5
40011418: 22 80 00 18 be,a 40011478 <msdos_dir_is_empty+0xe8>
4001141c: b6 06 e0 20 add %i3, 0x20, %i3
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
40011420: c2 0f 60 0b ldub [ %i5 + 0xb ], %g1
40011424: 82 08 60 3f and %g1, 0x3f, %g1
40011428: 80 a0 60 0f cmp %g1, 0xf
4001142c: 02 80 00 12 be 40011474 <msdos_dir_is_empty+0xe4>
40011430: 94 10 20 0b mov 0xb, %o2
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
40011434: 92 10 00 11 mov %l1, %o1
40011438: 40 00 30 49 call 4001d55c <strncmp>
4001143c: 90 10 00 1d mov %i5, %o0
MSDOS_ATTR_LFN) ||
40011440: 80 a2 20 00 cmp %o0, 0
40011444: 02 80 00 0c be 40011474 <msdos_dir_is_empty+0xe4>
40011448: 94 10 20 0b mov 0xb, %o2
(strncmp(MSDOS_DIR_NAME((entry)),
4001144c: 92 10 00 12 mov %l2, %o1
40011450: 40 00 30 43 call 4001d55c <strncmp>
40011454: 90 10 00 1d mov %i5, %o0
MSDOS_SHORT_NAME_LEN) == 0) ||
40011458: 80 a2 20 00 cmp %o0, 0
4001145c: 02 80 00 06 be 40011474 <msdos_dir_is_empty+0xe4>
40011460: 80 a4 20 00 cmp %l0, 0
if ((*MSDOS_DIR_NAME(entry)) ==
40011464: 02 80 00 0a be 4001148c <msdos_dir_is_empty+0xfc>
40011468: b0 10 20 00 clr %i0
}
4001146c: 81 c7 e0 08 ret
40011470: 81 e8 00 00 restore
i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
40011474: b6 06 e0 20 add %i3, 0x20, %i3
for (i = 0;
40011478: 80 a6 c0 14 cmp %i3, %l4
4001147c: 0a bf ff e5 bcs 40011410 <msdos_dir_is_empty+0x80>
40011480: ba 07 60 20 add %i5, 0x20, %i5
j++;
40011484: 10 bf ff ce b 400113bc <msdos_dir_is_empty+0x2c>
40011488: a6 04 e0 01 inc %l3
*ret_val = true;
4001148c: 82 10 20 01 mov 1, %g1
40011490: c2 2e 80 00 stb %g1, [ %i2 ]
return RC_OK;
40011494: 81 c7 e0 08 ret
40011498: 91 e8 20 00 restore %g0, 0, %o0
}
4001149c: 81 c7 e0 08 ret <== NOT EXECUTED
400114a0: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
assert(ret == fs_info->fat.vol.bps);
400114a4: 17 10 00 9b sethi %hi(0x40026c00), %o3 <== NOT EXECUTED
400114a8: 15 10 00 9c sethi %hi(0x40027000), %o2 <== NOT EXECUTED
400114ac: 11 10 00 9b sethi %hi(0x40026c00), %o0 <== NOT EXECUTED
400114b0: 96 12 e3 78 or %o3, 0x378, %o3 <== NOT EXECUTED
400114b4: 94 12 a0 b0 or %o2, 0xb0, %o2 <== NOT EXECUTED
400114b8: 92 10 23 c6 mov 0x3c6, %o1 <== NOT EXECUTED
400114bc: 40 00 17 da call 40017424 <__assert_func> <== NOT EXECUTED
400114c0: 90 12 23 98 or %o0, 0x398, %o0 <== NOT EXECUTED
400114c4: 01 00 00 00 nop <== NOT EXECUTED
400181f8 <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)
{
400181f8: 9d e3 be 38 save %sp, -456, %sp
int rc = RC_OK;
int eno = 0;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
400181fc: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
40018200: f8 00 60 08 ld [ %g1 + 8 ], %i4
rtems_dosfs_convert_control *converter = fs_info->converter;
40018204: c2 07 20 cc ld [ %i4 + 0xcc ], %g1
const rtems_dosfs_convert_handler *convert_handler = converter->handler;
40018208: c4 00 40 00 ld [ %g1 ], %g2
rtems_dosfs_convert_control *converter = fs_info->converter;
4001820c: c2 27 be c4 st %g1, [ %fp + -316 ]
* 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);
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
40018210: b5 36 a0 03 srl %i2, 3, %i2
const rtems_dosfs_convert_handler *convert_handler = converter->handler;
40018214: c4 27 be c0 st %g2, [ %fp + -320 ]
40018218: 84 07 20 b0 add %i4, 0xb0, %g2
uint16_t *lfn_buf = converter->buffer.data;
4001821c: e4 00 60 04 ld [ %g1 + 4 ], %l2
const size_t buf_size = converter->buffer.size;
40018220: c2 00 60 08 ld [ %g1 + 8 ], %g1
40018224: c2 27 be 9c st %g1, [ %fp + -356 ]
_Mutex_recursive_Acquire( mutex );
40018228: 90 10 00 02 mov %g2, %o0
4001822c: c4 27 be a0 st %g2, [ %fp + -352 ]
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
40018230: e6 06 20 18 ld [ %i0 + 0x18 ], %l3
fat_file_fd_t *tmp_fat_fd = NULL;
40018234: c0 27 be cc clr [ %fp + -308 ]
40018238: 7f ff c5 14 call 40009688 <_Mutex_recursive_Acquire>
4001823c: c0 27 be d0 clr [ %fp + -304 ]
start = iop->offset / sizeof(struct dirent);
40018240: d0 1e 20 08 ldd [ %i0 + 8 ], %o0
40018244: 94 10 20 00 clr %o2
40018248: 40 00 0b 97 call 4001b0a4 <__divdi3>
4001824c: 96 10 21 18 mov 0x118, %o3
{
40018250: f2 27 be bc st %i1, [ %fp + -324 ]
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
40018254: 33 03 a8 3a sethi %hi(0xea0e800), %i1
* 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 :
40018258: c2 04 e0 20 ld [ %l3 + 0x20 ], %g1
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
4001825c: b2 16 62 0f or %i1, 0x20f, %i1
start = iop->offset / sizeof(struct dirent);
40018260: a0 10 00 09 mov %o1, %l0
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
40018264: 80 56 80 19 umul %i2, %i1, %g0
40018268: b5 40 00 00 rd %y, %i2
fat_fd->fat_file_size :
4001826c: 80 a0 60 01 cmp %g1, 1
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
40018270: b5 36 a0 01 srl %i2, 1, %i2
fat_fd->fat_file_size :
40018274: 02 80 00 f1 be 40018638 <msdos_dir_read+0x440>
40018278: b2 5e a1 18 smul %i2, 0x118, %i1
4001827c: c2 07 20 08 ld [ %i4 + 8 ], %g1
40018280: c2 27 be ac st %g1, [ %fp + -340 ]
fs_info->fat.vol.bpc;
while (count > 0 && cmpltd >= 0)
40018284: 80 a6 60 00 cmp %i1, 0
40018288: 02 80 01 0b be 400186b4 <msdos_dir_read+0x4bc> <== NEVER TAKEN
4001828c: 03 00 00 3f sethi %hi(0xfc00), %g1
uint8_t lfn_checksum = 0;
40018290: c0 2f be b7 clrb [ %fp + -329 ]
* 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(
sfn_buf, entry); /* src text */
eno = (*convert_handler->codepage_to_utf8) (
40018294: 82 10 63 ff or %g1, 0x3ff, %g1
size_t lfn_len = 0;
40018298: c0 27 be b0 clr [ %fp + -336 ]
ret = fat_file_read(&fs_info->fat, fat_fd, (j * bts2rd),
4001829c: ac 10 20 00 clr %l6
eno = (*convert_handler->codepage_to_utf8) (
400182a0: c2 27 be b8 st %g1, [ %fp + -328 ]
int lfn_entries = 0;
400182a4: a2 10 20 00 clr %l1
uint32_t lfn_start = FAT_FILE_SHORT_NAME;
400182a8: b4 10 3f ff mov -1, %i2
ssize_t cmpltd = 0;
400182ac: ba 10 20 00 clr %i5
ret = fat_file_read(&fs_info->fat, fat_fd, (j * bts2rd),
400182b0: d8 07 20 c8 ld [ %i4 + 0xc8 ], %o4
400182b4: d6 07 be ac ld [ %fp + -340 ], %o3
400182b8: 94 10 00 16 mov %l6, %o2
400182bc: 92 10 00 13 mov %l3, %o1
400182c0: 7f ff dd 86 call 4000f8d8 <fat_file_read>
400182c4: 90 10 00 1c mov %i4, %o0
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
400182c8: 80 a2 20 1f cmp %o0, 0x1f
400182cc: 04 80 00 ec ble 4001867c <msdos_dir_read+0x484> <== NEVER TAKEN
400182d0: b6 10 00 08 mov %o0, %i3
for (i = 0; i < ret && cmpltd >= 0; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
400182d4: 80 a7 60 00 cmp %i5, 0
400182d8: 06 80 00 bd bl 400185cc <msdos_dir_read+0x3d4> <== NEVER TAKEN
400182dc: 82 05 bf e0 add %l6, -32, %g1
lfn_start =
400182e0: c2 27 be a4 st %g1, [ %fp + -348 ]
for (i = 0; i < ret && cmpltd >= 0; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
400182e4: ae 10 20 20 mov 0x20, %l7
char* entry = (char*) fs_info->cl_buf + i;
400182e8: d6 07 20 c8 ld [ %i4 + 0xc8 ], %o3
400182ec: aa 05 ff e0 add %l7, -32, %l5
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
400182f0: c6 0a c0 15 ldub [ %o3 + %l5 ], %g3
400182f4: 82 88 e0 ff andcc %g3, 0xff, %g1
400182f8: 02 80 00 b5 be 400185cc <msdos_dir_read+0x3d4>
400182fc: a8 02 c0 15 add %o3, %l5, %l4
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) == MSDOS_THIS_DIR_ENTRY_EMPTY)
40018300: 80 a0 60 e5 cmp %g1, 0xe5
40018304: 02 80 00 89 be 40018528 <msdos_dir_read+0x330>
40018308: 82 38 00 1d xnor %g0, %i5, %g1
if (((*MSDOS_DIR_ATTR(entry)) & MSDOS_ATTR_VOLUME_ID) &&
4001830c: c2 0d 20 0b ldub [ %l4 + 0xb ], %g1
40018310: 80 88 60 08 btst 8, %g1
40018314: 02 80 00 31 be 400183d8 <msdos_dir_read+0x1e0>
40018318: 9e 08 60 3f and %g1, 0x3f, %o7
for (i = 0; i < ret && cmpltd >= 0; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
4001831c: 80 a5 c0 1b cmp %l7, %i3
40018320: 82 38 00 1d xnor %g0, %i5, %g1
40018324: 94 40 20 00 addx %g0, 0, %o2
40018328: 83 30 60 1f srl %g1, 0x1f, %g1
if (((*MSDOS_DIR_ATTR(entry)) & MSDOS_ATTR_VOLUME_ID) &&
4001832c: 80 a3 e0 0f cmp %o7, 0xf
for (i = 0; i < ret && cmpltd >= 0; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
40018330: 98 10 00 01 mov %g1, %o4
if (((*MSDOS_DIR_ATTR(entry)) & MSDOS_ATTR_VOLUME_ID) &&
40018334: 12 80 00 0e bne 4001836c <msdos_dir_read+0x174>
40018338: 82 08 40 0a and %g1, %o2, %g1
if (lfn_start == FAT_FILE_SHORT_NAME)
4001833c: 80 a6 bf ff cmp %i2, -1
40018340: 02 80 00 89 be 40018564 <msdos_dir_read+0x36c>
40018344: 9e 10 20 00 clr %o7
if ((lfn_entries != (*MSDOS_DIR_ENTRY_TYPE(entry) &
40018348: 86 08 e0 3f and %g3, 0x3f, %g3
4001834c: 80 a0 c0 11 cmp %g3, %l1
40018350: 12 80 00 06 bne 40018368 <msdos_dir_read+0x170>
40018354: c6 0f be b7 ldub [ %fp + -329 ], %g3
MSDOS_LAST_LONG_ENTRY_MASK)) ||
40018358: c8 0d 20 0d ldub [ %l4 + 0xd ], %g4
4001835c: 80 a1 00 03 cmp %g4, %g3
40018360: 22 80 00 0b be,a 4001838c <msdos_dir_read+0x194> <== ALWAYS TAKEN
40018364: c2 2f be a8 stb %g1, [ %fp + -344 ]
lfn_start = FAT_FILE_SHORT_NAME;
40018368: b4 10 3f ff mov -1, %i2
for (i = 0; i < ret && cmpltd >= 0; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
4001836c: 80 88 60 ff btst 0xff, %g1
40018370: 12 bf ff de bne 400182e8 <msdos_dir_read+0xf0>
40018374: ae 05 e0 20 add %l7, 0x20, %l7
while (count > 0 && cmpltd >= 0)
40018378: c2 07 be ac ld [ %fp + -340 ], %g1
4001837c: 80 8b 20 ff btst 0xff, %o4
40018380: 12 bf ff cc bne 400182b0 <msdos_dir_read+0xb8> <== ALWAYS TAKEN
40018384: ac 05 80 01 add %l6, %g1, %l6
40018388: 30 80 00 91 b,a 400185cc <msdos_dir_read+0x3d4> <== NOT EXECUTED
lfn_entries--;
4001838c: a2 04 7f ff add %l1, -1, %l1
lfn_len += msdos_get_utf16_string_from_long_entry (
40018390: c2 07 be 9c ld [ %fp + -356 ], %g1
40018394: d8 2f be b6 stb %o4, [ %fp + -330 ]
40018398: 96 0b e0 01 and %o7, 1, %o3
offset_lfn = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
4001839c: 95 2c 60 01 sll %l1, 1, %o2
lfn_len += msdos_get_utf16_string_from_long_entry (
400183a0: 90 10 00 14 mov %l4, %o0
offset_lfn = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
400183a4: 94 02 80 11 add %o2, %l1, %o2
400183a8: 95 2a a0 02 sll %o2, 2, %o2
400183ac: 94 02 80 11 add %o2, %l1, %o2
&lfn_buf[offset_lfn],
400183b0: 93 2a a0 01 sll %o2, 1, %o1
lfn_len += msdos_get_utf16_string_from_long_entry (
400183b4: 94 20 40 0a sub %g1, %o2, %o2
400183b8: 7f ff e4 44 call 400114c8 <msdos_get_utf16_string_from_long_entry>
400183bc: 92 04 80 09 add %l2, %o1, %o1
400183c0: c2 07 be b0 ld [ %fp + -336 ], %g1
400183c4: 82 00 40 08 add %g1, %o0, %g1
400183c8: d8 0f be b6 ldub [ %fp + -330 ], %o4
400183cc: c2 27 be b0 st %g1, [ %fp + -336 ]
return rc;
}
}
}
if (count <= 0)
400183d0: 10 bf ff e7 b 4001836c <msdos_dir_read+0x174>
400183d4: c2 0f be a8 ldub [ %fp + -344 ], %g1
if ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
400183d8: 80 a3 e0 0f cmp %o7, 0xf
400183dc: 02 80 00 af be 40018698 <msdos_dir_read+0x4a0> <== NEVER TAKEN
400183e0: 80 a4 20 00 cmp %l0, 0
if (start)
400183e4: 12 80 00 57 bne 40018540 <msdos_dir_read+0x348>
400183e8: 80 88 60 10 btst 0x10, %g1
if ((*MSDOS_DIR_ATTR(entry)) & MSDOS_ATTR_DIRECTORY)
400183ec: 12 80 00 03 bne 400183f8 <msdos_dir_read+0x200>
400183f0: 86 10 20 04 mov 4, %g3
tmp_dirent.d_type = DT_REG;
400183f4: 86 10 20 08 mov 8, %g3
400183f8: c6 2f be fa stb %g3, [ %fp + -262 ]
rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
400183fc: 98 07 be d0 add %fp, -304, %o4
40018400: 96 10 00 16 mov %l6, %o3
40018404: 94 10 20 01 mov 1, %o2
40018408: 92 10 00 13 mov %l3, %o1
4001840c: 7f ff de 22 call 4000fc94 <fat_file_ioctl>
40018410: 90 10 00 1c mov %i4, %o0
if (rc != RC_OK)
40018414: 80 a2 20 00 cmp %o0, 0
40018418: 12 80 00 93 bne 40018664 <msdos_dir_read+0x46c> <== NEVER TAKEN
4001841c: 82 10 3f ff mov -1, %g1
dir_pos.sname.cln = cur_cln;
40018420: c6 07 be d0 ld [ %fp + -304 ], %g3
40018424: c6 27 be d8 st %g3, [ %fp + -296 ]
rc = fat_file_open(&fs_info->fat, &dir_pos, &tmp_fat_fd);
40018428: 94 07 be cc add %fp, -308, %o2
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
4001842c: c2 27 be e0 st %g1, [ %fp + -288 ]
40018430: 92 07 be d8 add %fp, -296, %o1
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
40018434: c2 27 be e4 st %g1, [ %fp + -284 ]
40018438: 90 10 00 1c mov %i4, %o0
4001843c: 7f ff dc 42 call 4000f544 <fat_file_open>
40018440: ea 27 be dc st %l5, [ %fp + -292 ]
if (rc != RC_OK)
40018444: 80 a2 20 00 cmp %o0, 0
40018448: 12 80 00 87 bne 40018664 <msdos_dir_read+0x46c> <== NEVER TAKEN
4001844c: c2 07 be cc ld [ %fp + -308 ], %g1
tmp_dirent.d_ino = tmp_fat_fd->ino;
40018450: c2 00 60 0c ld [ %g1 + 0xc ], %g1
tmp_dirent.d_off = start + cmpltd;
40018454: 87 3f 60 1f sra %i5, 0x1f, %g3
40018458: fa 27 be f4 st %i5, [ %fp + -268 ]
if (lfn_entries == 0 &&
4001845c: 80 a6 bf ff cmp %i2, -1
tmp_dirent.d_off = start + cmpltd;
40018460: c6 27 be f0 st %g3, [ %fp + -272 ]
tmp_dirent.d_reclen = sizeof(struct dirent);
40018464: 86 10 21 18 mov 0x118, %g3
tmp_dirent.d_ino = tmp_fat_fd->ino;
40018468: c0 27 be e8 clr [ %fp + -280 ]
tmp_dirent.d_reclen = sizeof(struct dirent);
4001846c: c6 37 be f8 sth %g3, [ %fp + -264 ]
if (lfn_entries == 0 &&
40018470: 02 80 00 05 be 40018484 <msdos_dir_read+0x28c>
40018474: c2 27 be ec st %g1, [ %fp + -276 ]
40018478: 80 a4 60 00 cmp %l1, 0
4001847c: 02 80 00 58 be 400185dc <msdos_dir_read+0x3e4> <== ALWAYS TAKEN
40018480: 01 00 00 00 nop
size_t len = sizeof(tmp_dirent.d_name) - 1;
40018484: 82 10 20 ff mov 0xff, %g1 ! ff <_TLS_Alignment+0xfe>
tmp_dirent.d_namlen = msdos_format_dirent_with_dot(
40018488: 92 10 00 14 mov %l4, %o1
size_t len = sizeof(tmp_dirent.d_name) - 1;
4001848c: c2 27 be d4 st %g1, [ %fp + -300 ]
tmp_dirent.d_namlen = msdos_format_dirent_with_dot(
40018490: 7f ff e4 16 call 400114e8 <msdos_format_dirent_with_dot>
40018494: 90 10 00 12 mov %l2, %o0
eno = (*convert_handler->codepage_to_utf8) (
40018498: c2 07 be c0 ld [ %fp + -320 ], %g1
tmp_dirent.d_namlen = msdos_format_dirent_with_dot(
4001849c: d0 37 be fc sth %o0, [ %fp + -260 ]
eno = (*convert_handler->codepage_to_utf8) (
400184a0: 98 07 be d4 add %fp, -300, %o4
400184a4: c4 07 be b8 ld [ %fp + -328 ], %g2
400184a8: 94 0a 00 02 and %o0, %g2, %o2
400184ac: c2 00 60 04 ld [ %g1 + 4 ], %g1
400184b0: d0 07 be c4 ld [ %fp + -316 ], %o0
400184b4: 96 07 be fe add %fp, -258, %o3
400184b8: 9f c0 40 00 call %g1
400184bc: 92 10 00 12 mov %l2, %o1
if ( 0 == eno ) {
400184c0: 80 a2 20 00 cmp %o0, 0
400184c4: 12 80 00 3e bne 400185bc <msdos_dir_read+0x3c4> <== NEVER TAKEN
400184c8: c2 07 be d4 ld [ %fp + -300 ], %g1
tmp_dirent.d_namlen = len;
400184cc: c2 37 be fc sth %g1, [ %fp + -260 ]
tmp_dirent.d_name[len] = '\0';
400184d0: 86 07 80 01 add %fp, %g1, %g3
400184d4: c0 28 fe fe clrb [ %g3 + -258 ]
400184d8: b4 10 3f ff mov -1, %i2
memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
400184dc: c2 07 be bc ld [ %fp + -324 ], %g1
400184e0: 90 00 40 1d add %g1, %i5, %o0
400184e4: 94 10 21 18 mov 0x118, %o2
400184e8: 40 00 0f 5f call 4001c264 <memcpy>
400184ec: 92 07 be e8 add %fp, -280, %o1
iop->offset = iop->offset + sizeof(struct dirent);
400184f0: d8 1e 20 08 ldd [ %i0 + 8 ], %o4
400184f4: 96 83 61 18 addcc %o5, 0x118, %o3
400184f8: 94 43 20 00 addx %o4, 0, %o2
400184fc: d4 3e 20 08 std %o2, [ %i0 + 8 ]
rc = fat_file_close(&fs_info->fat, tmp_fat_fd);
40018500: 90 10 00 1c mov %i4, %o0
40018504: 7f ff dd af call 4000fbc0 <fat_file_close>
40018508: d2 07 be cc ld [ %fp + -308 ], %o1
cmpltd += (sizeof(struct dirent));
4001850c: ba 07 61 18 add %i5, 0x118, %i5
if (rc != RC_OK)
40018510: 80 a2 20 00 cmp %o0, 0
40018514: 12 80 00 54 bne 40018664 <msdos_dir_read+0x46c> <== NEVER TAKEN
40018518: b2 06 7e e8 add %i1, -280, %i1
if (count <= 0)
4001851c: 80 a6 60 00 cmp %i1, 0
40018520: 02 80 00 2b be 400185cc <msdos_dir_read+0x3d4> <== ALWAYS TAKEN
40018524: 82 38 00 1d xnor %g0, %i5, %g1
for (i = 0; i < ret && cmpltd >= 0; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
40018528: 80 a5 c0 1b cmp %l7, %i3
4001852c: 83 30 60 1f srl %g1, 0x1f, %g1
40018530: 86 40 20 00 addx %g0, 0, %g3
40018534: 98 10 00 01 mov %g1, %o4
40018538: 10 bf ff 8d b 4001836c <msdos_dir_read+0x174>
4001853c: 82 08 40 03 and %g1, %g3, %g1
40018540: 82 38 00 1d xnor %g0, %i5, %g1
40018544: 80 a5 c0 1b cmp %l7, %i3
40018548: 83 30 60 1f srl %g1, 0x1f, %g1
4001854c: 86 40 20 00 addx %g0, 0, %g3
40018550: 98 10 00 01 mov %g1, %o4
start--;
40018554: a0 04 3f ff add %l0, -1, %l0
for (i = 0; i < ret && cmpltd >= 0; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
40018558: 82 08 40 03 and %g1, %g3, %g1
lfn_start = FAT_FILE_SHORT_NAME;
4001855c: 10 bf ff 84 b 4001836c <msdos_dir_read+0x174>
40018560: b4 10 3f ff mov -1, %i2
if ((*MSDOS_DIR_ENTRY_TYPE(entry) &
40018564: 80 88 e0 40 btst 0x40, %g3
40018568: 02 bf ff 81 be 4001836c <msdos_dir_read+0x174>
4001856c: d6 27 be a8 st %o3, [ %fp + -344 ]
lfn_start =
40018570: c2 2f be b6 stb %g1, [ %fp + -330 ]
lfn_entries = (*MSDOS_DIR_ENTRY_TYPE(entry) &
40018574: a2 08 e0 3f and %g3, 0x3f, %l1
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
40018578: c2 0d 20 0d ldub [ %l4 + 0xd ], %g1
4001857c: c2 2f be b7 stb %g1, [ %fp + -329 ]
memset (tmp_dirent.d_name, 0, sizeof(tmp_dirent.d_name));
40018580: 94 10 21 00 mov 0x100, %o2
lfn_start =
40018584: c2 07 be a4 ld [ %fp + -348 ], %g1
40018588: b4 00 40 17 add %g1, %l7, %i2
4001858c: d8 2f be b5 stb %o4, [ %fp + -331 ]
memset (tmp_dirent.d_name, 0, sizeof(tmp_dirent.d_name));
40018590: 92 10 20 00 clr %o1
40018594: 40 00 0f 73 call 4001c360 <memset>
40018598: 90 07 be fe add %fp, -258, %o0
if ((lfn_entries != (*MSDOS_DIR_ENTRY_TYPE(entry) &
4001859c: d6 07 be a8 ld [ %fp + -344 ], %o3
lfn_len = 0;
400185a0: c0 27 be b0 clr [ %fp + -336 ]
lfn_start =
400185a4: b5 36 a0 05 srl %i2, 5, %i2
if ((lfn_entries != (*MSDOS_DIR_ENTRY_TYPE(entry) &
400185a8: c6 0a c0 15 ldub [ %o3 + %l5 ], %g3
lfn_len = 0;
400185ac: d8 0f be b5 ldub [ %fp + -331 ], %o4
400185b0: c2 0f be b6 ldub [ %fp + -330 ], %g1
400185b4: 10 bf ff 65 b 40018348 <msdos_dir_read+0x150>
400185b8: 9e 10 20 01 mov 1, %o7
errno = eno;
400185bc: 40 00 0d 3c call 4001baac <__errno> <== NOT EXECUTED
400185c0: b4 10 00 08 mov %o0, %i2 <== NOT EXECUTED
400185c4: f4 22 00 00 st %i2, [ %o0 ] <== NOT EXECUTED
cmpltd = -1;
400185c8: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
_Mutex_recursive_Release( mutex );
400185cc: 7f ff c4 54 call 4000971c <_Mutex_recursive_Release>
400185d0: d0 07 be a0 ld [ %fp + -352 ], %o0
j++;
}
msdos_fs_unlock(fs_info);
return cmpltd;
}
400185d4: 81 c7 e0 08 ret
400185d8: 91 e8 00 1d restore %g0, %i5, %o0
lfn_checksum == msdos_lfn_checksum(entry)) {
400185dc: 7f ff e1 99 call 40010c40 <msdos_lfn_checksum>
400185e0: 90 10 00 14 mov %l4, %o0
if (lfn_entries == 0 &&
400185e4: c2 0f be b7 ldub [ %fp + -329 ], %g1
400185e8: 80 a2 00 01 cmp %o0, %g1
400185ec: 12 bf ff a7 bne 40018488 <msdos_dir_read+0x290> <== NEVER TAKEN
400185f0: 82 10 20 ff mov 0xff, %g1
size_t len = sizeof(tmp_dirent.d_name) - 1;
400185f4: c2 27 be d4 st %g1, [ %fp + -300 ]
eno = (*convert_handler->utf16_to_utf8) (
400185f8: 98 07 be d4 add %fp, -300, %o4
400185fc: c2 07 be c0 ld [ %fp + -320 ], %g1
40018600: c2 00 60 0c ld [ %g1 + 0xc ], %g1
40018604: d4 07 be b0 ld [ %fp + -336 ], %o2
40018608: d0 07 be c4 ld [ %fp + -316 ], %o0
4001860c: 96 07 be fe add %fp, -258, %o3
40018610: 9f c0 40 00 call %g1
40018614: 92 10 00 12 mov %l2, %o1
if (eno == 0) {
40018618: 80 a2 20 00 cmp %o0, 0
4001861c: 12 bf ff 9b bne 40018488 <msdos_dir_read+0x290>
40018620: 82 10 20 ff mov 0xff, %g1
tmp_dirent.d_namlen = len;
40018624: c2 07 be d4 ld [ %fp + -300 ], %g1
40018628: c2 37 be fc sth %g1, [ %fp + -260 ]
tmp_dirent.d_name[len] = '\0';
4001862c: 86 07 80 01 add %fp, %g1, %g3
40018630: 10 bf ff ab b 400184dc <msdos_dir_read+0x2e4>
40018634: c0 28 fe fe clrb [ %g3 + -258 ]
bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&
40018638: c2 04 e0 24 ld [ %l3 + 0x24 ], %g1
4001863c: 80 a0 60 00 cmp %g1, 0
40018640: 32 bf ff 10 bne,a 40018280 <msdos_dir_read+0x88> <== NEVER TAKEN
40018644: c2 07 20 08 ld [ %i4 + 8 ], %g1 <== NOT EXECUTED
40018648: c2 0f 20 16 ldub [ %i4 + 0x16 ], %g1
4001864c: 80 88 60 03 btst 3, %g1
40018650: 22 bf ff 0c be,a 40018280 <msdos_dir_read+0x88> <== NEVER TAKEN
40018654: c2 07 20 08 ld [ %i4 + 8 ], %g1 <== NOT EXECUTED
fat_fd->fat_file_size :
40018658: c2 04 e0 18 ld [ %l3 + 0x18 ], %g1
4001865c: 10 bf ff 0a b 40018284 <msdos_dir_read+0x8c>
40018660: c2 27 be ac st %g1, [ %fp + -340 ]
40018664: 82 10 00 08 mov %o0, %g1 <== NOT EXECUTED
40018668: d0 07 be a0 ld [ %fp + -352 ], %o0 <== NOT EXECUTED
4001866c: 7f ff c4 2c call 4000971c <_Mutex_recursive_Release> <== NOT EXECUTED
40018670: ba 10 00 01 mov %g1, %i5 <== NOT EXECUTED
}
40018674: 81 c7 e0 08 ret <== NOT EXECUTED
40018678: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
4001867c: 7f ff c4 28 call 4000971c <_Mutex_recursive_Release> <== NOT EXECUTED
40018680: d0 07 be a0 ld [ %fp + -352 ], %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
40018684: 40 00 0d 0a call 4001baac <__errno> <== NOT EXECUTED
40018688: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
4001868c: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
40018690: 10 bf ff d1 b 400185d4 <msdos_dir_read+0x3dc> <== NOT EXECUTED
40018694: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
for (i = 0; i < ret && cmpltd >= 0; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
40018698: 82 38 00 1d xnor %g0, %i5, %g1 <== NOT EXECUTED
4001869c: 80 a5 c0 1b cmp %l7, %i3 <== NOT EXECUTED
400186a0: 83 30 60 1f srl %g1, 0x1f, %g1 <== NOT EXECUTED
400186a4: 9e 40 20 00 addx %g0, 0, %o7 <== NOT EXECUTED
400186a8: 98 10 00 01 mov %g1, %o4 <== NOT EXECUTED
400186ac: 10 bf ff 24 b 4001833c <msdos_dir_read+0x144> <== NOT EXECUTED
400186b0: 82 08 40 0f and %g1, %o7, %g1 <== NOT EXECUTED
ssize_t cmpltd = 0;
400186b4: 10 bf ff c6 b 400185cc <msdos_dir_read+0x3d4> <== NOT EXECUTED
400186b8: ba 10 20 00 clr %i5 <== NOT EXECUTED
40018950 <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)
{
40018950: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
40018954: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
40018958: f8 00 60 08 ld [ %g1 + 8 ], %i4
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
4001895c: fa 06 20 18 ld [ %i0 + 0x18 ], %i5
40018960: b6 07 20 b0 add %i4, 0xb0, %i3
_Mutex_recursive_Acquire( mutex );
40018964: 7f ff c3 49 call 40009688 <_Mutex_recursive_Acquire>
40018968: 90 10 00 1b mov %i3, %o0
uint32_t old_length;
msdos_fs_lock(fs_info);
old_length = fat_fd->fat_file_size;
if (length < old_length) {
4001896c: 82 10 20 00 clr %g1
40018970: 80 a0 40 19 cmp %g1, %i1
40018974: 14 80 00 23 bg 40018a00 <msdos_file_ftruncate+0xb0> <== NEVER TAKEN
40018978: e0 07 60 18 ld [ %i5 + 0x18 ], %l0
4001897c: 02 80 00 1f be 400189f8 <msdos_file_ftruncate+0xa8> <== ALWAYS TAKEN
40018980: 80 a4 00 1a cmp %l0, %i2
rc = fat_file_truncate(&fs_info->fat, fat_fd, length);
} else {
uint32_t new_length;
rc = fat_file_extend(&fs_info->fat,
40018984: 98 07 bf fc add %fp, -4, %o4 <== NOT EXECUTED
40018988: 96 10 00 1a mov %i2, %o3
4001898c: 94 10 20 01 mov 1, %o2
40018990: 92 10 00 1d mov %i5, %o1
40018994: 7f ff dc f5 call 4000fd68 <fat_file_extend>
40018998: 90 10 00 1c mov %i4, %o0
fat_fd,
true,
length,
&new_length);
if (rc == RC_OK && length != new_length) {
4001899c: b0 92 20 00 orcc %o0, 0, %i0
400189a0: 12 80 00 12 bne 400189e8 <msdos_file_ftruncate+0x98> <== NEVER TAKEN
400189a4: 80 a6 00 19 cmp %i0, %i1
400189a8: 12 80 00 21 bne 40018a2c <msdos_file_ftruncate+0xdc> <== NEVER TAKEN
400189ac: c2 07 bf fc ld [ %fp + -4 ], %g1
400189b0: 80 a0 40 1a cmp %g1, %i2
400189b4: 12 80 00 1f bne 40018a30 <msdos_file_ftruncate+0xe0> <== NEVER TAKEN
400189b8: 94 10 00 10 mov %l0, %o2
fat_fd->flags |= FAT_FILE_META_DATA_CHANGED;
400189bc: c2 0f 60 30 ldub [ %i5 + 0x30 ], %g1
400189c0: 82 10 60 02 or %g1, 2, %g1
fat_fd->fat_file_size = s;
400189c4: f4 27 60 18 st %i2, [ %i5 + 0x18 ]
}
if (rc == RC_OK)
{
fat_file_set_file_size(fat_fd, length);
fat_file_set_ctime_mtime(fat_fd, time(NULL));
400189c8: 90 10 20 00 clr %o0
400189cc: 40 00 1d 46 call 4001fee4 <time>
400189d0: c2 2f 60 30 stb %g1, [ %i5 + 0x30 ]
fat_fd->flags |= FAT_FILE_META_DATA_CHANGED;
400189d4: c2 0f 60 30 ldub [ %i5 + 0x30 ], %g1
400189d8: 82 10 60 02 or %g1, 2, %g1
fat_fd->ctime = t;
400189dc: d0 3f 60 40 std %o0, [ %i5 + 0x40 ]
fat_fd->mtime = t;
400189e0: d0 3f 60 48 std %o0, [ %i5 + 0x48 ]
fat_fd->flags |= FAT_FILE_META_DATA_CHANGED;
400189e4: c2 2f 60 30 stb %g1, [ %i5 + 0x30 ]
_Mutex_recursive_Release( mutex );
400189e8: 7f ff c3 4d call 4000971c <_Mutex_recursive_Release>
400189ec: 90 10 00 1b mov %i3, %o0
}
msdos_fs_unlock(fs_info);
return rc;
}
400189f0: 81 c7 e0 08 ret
400189f4: 81 e8 00 00 restore
if (length < old_length) {
400189f8: 08 bf ff e4 bleu 40018988 <msdos_file_ftruncate+0x38>
400189fc: 98 07 bf fc add %fp, -4, %o4
rc = fat_file_truncate(&fs_info->fat, fat_fd, length);
40018a00: 94 10 00 1a mov %i2, %o2
40018a04: 92 10 00 1d mov %i5, %o1
40018a08: 7f ff dc 2c call 4000fab8 <fat_file_truncate>
40018a0c: 90 10 00 1c mov %i4, %o0
if (rc == RC_OK)
40018a10: b0 92 20 00 orcc %o0, 0, %i0
40018a14: 22 bf ff eb be,a 400189c0 <msdos_file_ftruncate+0x70> <== ALWAYS TAKEN
40018a18: c2 0f 60 30 ldub [ %i5 + 0x30 ], %g1
40018a1c: 7f ff c3 40 call 4000971c <_Mutex_recursive_Release> <== NOT EXECUTED
40018a20: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
}
40018a24: 81 c7 e0 08 ret <== NOT EXECUTED
40018a28: 81 e8 00 00 restore <== NOT EXECUTED
fat_file_truncate(&fs_info->fat, fat_fd, old_length);
40018a2c: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
40018a30: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40018a34: 7f ff dc 21 call 4000fab8 <fat_file_truncate> <== NOT EXECUTED
40018a38: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
errno = ENOSPC;
40018a3c: 40 00 0c 1c call 4001baac <__errno> <== NOT EXECUTED
40018a40: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40018a44: 82 10 20 1c mov 0x1c, %g1 <== NOT EXECUTED
40018a48: 10 bf ff e8 b 400189e8 <msdos_file_ftruncate+0x98> <== NOT EXECUTED
40018a4c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40018a50 <msdos_file_sync>:
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
int
msdos_file_sync(rtems_libio_t *iop)
{
40018a50: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
40018a54: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
40018a58: fa 00 60 08 ld [ %g1 + 8 ], %i5
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
40018a5c: d2 06 20 18 ld [ %i0 + 0x18 ], %o1
40018a60: d2 27 bf fc st %o1, [ %fp + -4 ]
40018a64: b8 07 60 b0 add %i5, 0xb0, %i4
_Mutex_recursive_Acquire( mutex );
40018a68: 7f ff c3 08 call 40009688 <_Mutex_recursive_Acquire>
40018a6c: 90 10 00 1c mov %i4, %o0
msdos_fs_lock(fs_info);
rc = fat_file_update(&fs_info->fat, fat_fd);
40018a70: d2 07 bf fc ld [ %fp + -4 ], %o1
40018a74: 7f ff db 78 call 4000f854 <fat_file_update>
40018a78: 90 10 00 1d mov %i5, %o0
if (rc != RC_OK)
40018a7c: b0 92 20 00 orcc %o0, 0, %i0
40018a80: 12 80 00 04 bne 40018a90 <msdos_file_sync+0x40> <== NEVER TAKEN
40018a84: 01 00 00 00 nop
{
msdos_fs_unlock(fs_info);
return rc;
}
rc = fat_sync(&fs_info->fat);
40018a88: 7f ff d7 c1 call 4000e98c <fat_sync>
40018a8c: 90 10 00 1d mov %i5, %o0
_Mutex_recursive_Release( mutex );
40018a90: 7f ff c3 23 call 4000971c <_Mutex_recursive_Release>
40018a94: 90 10 00 1c mov %i4, %o0
msdos_fs_unlock(fs_info);
return RC_OK;
}
40018a98: 81 c7 e0 08 ret
40018a9c: 81 e8 00 00 restore
400187ac <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)
{
400187ac: 9d e3 bf a0 save %sp, -96, %sp
ssize_t ret = 0;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
400187b0: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
400187b4: f6 00 60 08 ld [ %g1 + 8 ], %i3
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
400187b8: f8 06 20 18 ld [ %i0 + 0x18 ], %i4
400187bc: a0 06 e0 b0 add %i3, 0xb0, %l0
_Mutex_recursive_Acquire( mutex );
400187c0: 7f ff c3 b2 call 40009688 <_Mutex_recursive_Acquire>
400187c4: 90 10 00 10 mov %l0, %o0
400187c8: c2 06 00 00 ld [ %i0 ], %g1
{
400187cc: ba 10 00 18 mov %i0, %i5
msdos_fs_lock(fs_info);
if (rtems_libio_iop_is_append(iop))
400187d0: 80 88 62 00 btst 0x200, %g1
400187d4: 32 80 00 1d bne,a 40018848 <msdos_file_write+0x9c>
400187d8: d4 07 20 18 ld [ %i4 + 0x18 ], %o2
iop->offset = fat_fd->fat_file_size;
ret = fat_file_write(&fs_info->fat, fat_fd, iop->offset, count,
400187dc: d4 06 20 0c ld [ %i0 + 0xc ], %o2
400187e0: 98 10 00 19 mov %i1, %o4
400187e4: 96 10 00 1a mov %i2, %o3
400187e8: 92 10 00 1c mov %i4, %o1
400187ec: 7f ff dd f7 call 4000ffc8 <fat_file_write>
400187f0: 90 10 00 1b mov %i3, %o0
buffer);
if (ret < 0)
400187f4: b0 92 20 00 orcc %o0, 0, %i0
400187f8: 06 80 00 2a bl 400188a0 <msdos_file_write+0xf4>
400187fc: 85 3e 20 1f sra %i0, 0x1f, %g2
/*
* update file size in both fat-file descriptor and file control block if
* file was extended
*/
iop->offset += ret;
40018800: f4 1f 60 08 ldd [ %i5 + 8 ], %i2
40018804: 9a 86 00 1b addcc %i0, %i3, %o5
40018808: 98 40 80 1a addx %g2, %i2, %o4
4001880c: d8 3f 60 08 std %o4, [ %i5 + 8 ]
if (iop->offset > fat_fd->fat_file_size)
40018810: 80 a3 20 00 cmp %o4, 0
40018814: 04 80 00 10 ble 40018854 <msdos_file_write+0xa8> <== ALWAYS TAKEN
40018818: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
fat_fd->flags |= FAT_FILE_META_DATA_CHANGED;
4001881c: c2 0f 20 30 ldub [ %i4 + 0x30 ], %g1 <== NOT EXECUTED
40018820: 82 10 60 02 or %g1, 2, %g1
fat_file_set_file_size(fat_fd, (uint32_t) iop->offset);
40018824: da 27 20 18 st %o5, [ %i4 + 0x18 ]
40018828: c2 2f 20 30 stb %g1, [ %i4 + 0x30 ]
if (ret > 0)
4001882c: 80 a6 20 00 cmp %i0, 0
40018830: 12 80 00 11 bne 40018874 <msdos_file_write+0xc8> <== ALWAYS TAKEN
40018834: 01 00 00 00 nop
_Mutex_recursive_Release( mutex );
40018838: 7f ff c3 b9 call 4000971c <_Mutex_recursive_Release> <== NOT EXECUTED
4001883c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
fat_file_set_ctime_mtime(fat_fd, time(NULL));
msdos_fs_unlock(fs_info);
return ret;
}
40018840: 81 c7 e0 08 ret <== NOT EXECUTED
40018844: 81 e8 00 00 restore <== NOT EXECUTED
iop->offset = fat_fd->fat_file_size;
40018848: d4 26 20 0c st %o2, [ %i0 + 0xc ]
4001884c: 10 bf ff e5 b 400187e0 <msdos_file_write+0x34>
40018850: c0 26 20 08 clr [ %i0 + 8 ]
if (iop->offset > fat_fd->fat_file_size)
40018854: 12 bf ff f7 bne 40018830 <msdos_file_write+0x84> <== NEVER TAKEN
40018858: 80 a6 20 00 cmp %i0, 0
4001885c: 80 a3 40 01 cmp %o5, %g1
40018860: 38 bf ff f0 bgu,a 40018820 <msdos_file_write+0x74>
40018864: c2 0f 20 30 ldub [ %i4 + 0x30 ], %g1
if (ret > 0)
40018868: 80 a6 20 00 cmp %i0, 0
4001886c: 02 bf ff f3 be 40018838 <msdos_file_write+0x8c> <== NEVER TAKEN
40018870: 01 00 00 00 nop
fat_file_set_ctime_mtime(fat_fd, time(NULL));
40018874: 40 00 1d 9c call 4001fee4 <time>
40018878: 90 10 20 00 clr %o0 ! 0 <PROM_START>
fat_fd->flags |= FAT_FILE_META_DATA_CHANGED;
4001887c: c2 0f 20 30 ldub [ %i4 + 0x30 ], %g1
fat_fd->ctime = t;
40018880: d0 3f 20 40 std %o0, [ %i4 + 0x40 ]
fat_fd->flags |= FAT_FILE_META_DATA_CHANGED;
40018884: 82 10 60 02 or %g1, 2, %g1
fat_fd->mtime = t;
40018888: d0 3f 20 48 std %o0, [ %i4 + 0x48 ]
4001888c: 90 10 00 10 mov %l0, %o0
40018890: 7f ff c3 a3 call 4000971c <_Mutex_recursive_Release>
40018894: c2 2f 20 30 stb %g1, [ %i4 + 0x30 ]
}
40018898: 81 c7 e0 08 ret
4001889c: 81 e8 00 00 restore
return -1;
400188a0: b0 10 3f ff mov -1, %i0
400188a4: 7f ff c3 9e call 4000971c <_Mutex_recursive_Release>
400188a8: 90 10 00 10 mov %l0, %o0
400188ac: 81 c7 e0 08 ret
400188b0: 81 e8 00 00 restore
40017a4c <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)
{
40017a4c: 9d e3 bf 98 save %sp, -104, %sp
ssize_t returned_size = 0;
int eno = 0;
size_t name_size;
size_t dest_size = long_name_size;
40017a50: f8 27 bf fc st %i4, [ %fp + -4 ]
if ( src_name[0] == UTF8_FULL_STOP
40017a54: c2 0e 40 00 ldub [ %i1 ], %g1
40017a58: 80 a0 60 2e cmp %g1, 0x2e
40017a5c: 02 80 00 21 be 40017ae0 <msdos_filename_utf8_to_long_name_for_compare+0x94><== NEVER TAKEN
40017a60: 80 a6 a0 01 cmp %i2, 1
ssize_t size_returned = filename_size;
40017a64: 82 10 00 1a mov %i2, %g1
for ( i = size_returned - UTF8_FULL_STOP_SIZE;
40017a68: 80 a6 a0 00 cmp %i2, 0
40017a6c: 14 80 00 17 bg 40017ac8 <msdos_filename_utf8_to_long_name_for_compare+0x7c><== ALWAYS TAKEN
40017a70: 86 06 7f ff add %i1, -1, %g3
if (returned_size == 0) {
name_size = msdos_filename_delete_trailing_dots (
&utf8_name[0],
utf8_name_size);
if (name_size > 0) {
40017a74: 02 80 00 2a be 40017b1c <msdos_filename_utf8_to_long_name_for_compare+0xd0><== NOT EXECUTED
40017a78: 01 00 00 00 nop <== NOT EXECUTED
eno = (*converter->handler->utf8_normalize_and_fold) (
40017a7c: c2 06 00 00 ld [ %i0 ], %g1 <== NOT EXECUTED
40017a80: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
40017a84: 98 07 bf fc add %fp, -4, %o4
40017a88: 96 10 00 1b mov %i3, %o3
40017a8c: 94 10 00 1a mov %i2, %o2
40017a90: 92 10 00 19 mov %i1, %o1
40017a94: 9f c0 40 00 call %g1
40017a98: 90 10 00 18 mov %i0, %o0
converter,
utf8_name,
name_size,
long_name,
&dest_size);
if (eno == 0) {
40017a9c: ba 92 20 00 orcc %o0, 0, %i5
40017aa0: 22 80 00 05 be,a 40017ab4 <msdos_filename_utf8_to_long_name_for_compare+0x68><== ALWAYS TAKEN
40017aa4: f0 07 bf fc ld [ %fp + -4 ], %i0
eno = EINVAL;
}
}
if ( eno != 0 ) {
errno = eno;
40017aa8: 40 00 10 01 call 4001baac <__errno> <== NOT EXECUTED
40017aac: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40017ab0: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
returned_size = -1;
}
return returned_size;
}
40017ab4: 81 c7 e0 08 ret
40017ab8: 81 e8 00 00 restore
for ( i = size_returned - UTF8_FULL_STOP_SIZE;
40017abc: 82 80 7f ff addcc %g1, -1, %g1
40017ac0: 02 80 00 17 be 40017b1c <msdos_filename_utf8_to_long_name_for_compare+0xd0><== NEVER TAKEN
40017ac4: 01 00 00 00 nop
&& filename_utf8[i] == UTF8_FULL_STOP;) {
40017ac8: c4 08 c0 01 ldub [ %g3 + %g1 ], %g2
40017acc: 80 a0 a0 2e cmp %g2, 0x2e
40017ad0: 02 bf ff fb be 40017abc <msdos_filename_utf8_to_long_name_for_compare+0x70>
40017ad4: b4 10 00 01 mov %g1, %i2
eno = (*converter->handler->utf8_normalize_and_fold) (
40017ad8: 10 bf ff ea b 40017a80 <msdos_filename_utf8_to_long_name_for_compare+0x34>
40017adc: c2 06 00 00 ld [ %i0 ], %g1
&& src_size == UTF8_FULL_STOP_SIZE) {
40017ae0: 02 80 00 14 be 40017b30 <msdos_filename_utf8_to_long_name_for_compare+0xe4><== NOT EXECUTED
40017ae4: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
&& src_name[1] == UTF8_FULL_STOP
40017ae8: c4 0e 60 01 ldub [ %i1 + 1 ], %g2 <== NOT EXECUTED
&& src_size == ( 2 * UTF8_FULL_STOP_SIZE ) ) {
40017aec: 80 a0 a0 2e cmp %g2, 0x2e <== NOT EXECUTED
40017af0: 12 bf ff dd bne 40017a64 <msdos_filename_utf8_to_long_name_for_compare+0x18><== NOT EXECUTED
40017af4: 80 a6 a0 02 cmp %i2, 2 <== NOT EXECUTED
40017af8: 32 bf ff dc bne,a 40017a68 <msdos_filename_utf8_to_long_name_for_compare+0x1c><== NOT EXECUTED
40017afc: 82 10 00 1a mov %i2, %g1 <== NOT EXECUTED
if (dest_size >= 2 * UTF8_FULL_STOP_SIZE) {
40017b00: 80 a7 20 01 cmp %i4, 1 <== NOT EXECUTED
40017b04: 08 80 00 10 bleu 40017b44 <msdos_filename_utf8_to_long_name_for_compare+0xf8><== NOT EXECUTED
40017b08: 01 00 00 00 nop <== NOT EXECUTED
dest_name[0] = UTF8_FULL_STOP;
40017b0c: c2 2e c0 00 stb %g1, [ %i3 ] <== NOT EXECUTED
dest_name[1] = UTF8_FULL_STOP;
40017b10: c2 2e e0 01 stb %g1, [ %i3 + 1 ] <== NOT EXECUTED
returned_size = 2 * UTF8_FULL_STOP_SIZE;
40017b14: 81 c7 e0 08 ret <== NOT EXECUTED
40017b18: 91 e8 20 02 restore %g0, 2, %o0 <== NOT EXECUTED
errno = eno;
40017b1c: 40 00 0f e4 call 4001baac <__errno> <== NOT EXECUTED
40017b20: ba 10 20 16 mov 0x16, %i5 <== NOT EXECUTED
40017b24: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
40017b28: 81 c7 e0 08 ret <== NOT EXECUTED
40017b2c: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
if (dest_size >= UTF8_FULL_STOP_SIZE) {
40017b30: 02 80 00 05 be 40017b44 <msdos_filename_utf8_to_long_name_for_compare+0xf8><== NOT EXECUTED
40017b34: 01 00 00 00 nop <== NOT EXECUTED
dest_name[0] = UTF8_FULL_STOP;
40017b38: c2 2e c0 00 stb %g1, [ %i3 ] <== NOT EXECUTED
returned_size = UTF8_FULL_STOP_SIZE;
40017b3c: 81 c7 e0 08 ret <== NOT EXECUTED
40017b40: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED
errno = eno;
40017b44: 40 00 0f da call 4001baac <__errno> <== NOT EXECUTED
40017b48: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40017b4c: 82 10 20 5b mov 0x5b, %g1 <== NOT EXECUTED
40017b50: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
if (returned_size == 0) {
40017b54: 81 c7 e0 08 ret <== NOT EXECUTED
40017b58: 81 e8 00 00 restore <== NOT EXECUTED
40017c28 <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)
{
40017c28: 9d e3 bf 98 save %sp, -104, %sp
size_t name_size_tmp;
int i;
uint16_t c;
unsigned int chars_written;
name_size_tmp = long_name_size;
40017c2c: f8 27 bf fc st %i4, [ %fp + -4 ]
ssize_t size_returned = filename_size;
40017c30: 82 10 00 1a mov %i2, %g1
for ( i = size_returned - UTF8_FULL_STOP_SIZE;
40017c34: 80 a6 a0 00 cmp %i2, 0
40017c38: 14 80 00 06 bg 40017c50 <msdos_filename_utf8_to_long_name_for_save+0x28> <== ALWAYS TAKEN
40017c3c: 86 06 7f ff add %i1, -1, %g3
40017c40: 30 80 00 35 b,a 40017d14 <msdos_filename_utf8_to_long_name_for_save+0xec><== NOT EXECUTED
40017c44: 82 80 7f ff addcc %g1, -1, %g1
40017c48: 22 80 00 59 be,a 40017dac <msdos_filename_utf8_to_long_name_for_save+0x184><== NEVER TAKEN
40017c4c: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
&& filename_utf8[i] == UTF8_FULL_STOP;) {
40017c50: c4 08 c0 01 ldub [ %g3 + %g1 ], %g2
40017c54: 80 a0 a0 2e cmp %g2, 0x2e
40017c58: 02 bf ff fb be 40017c44 <msdos_filename_utf8_to_long_name_for_save+0x1c>
40017c5c: b4 10 00 01 mov %g1, %i2
utf8_name_size);
if (name_size > 0) {
/*
* Finally convert from UTF-8 to UTF-16
*/
eno = (*converter->handler->utf8_to_utf16) (
40017c60: c2 06 00 00 ld [ %i0 ], %g1
40017c64: c2 00 60 08 ld [ %g1 + 8 ], %g1
40017c68: 90 10 00 18 mov %i0, %o0
40017c6c: 98 07 bf fc add %fp, -4, %o4
40017c70: 96 10 00 1b mov %i3, %o3
40017c74: 94 10 00 1a mov %i2, %o2
40017c78: 9f c0 40 00 call %g1
40017c7c: 92 10 00 19 mov %i1, %o1
converter,
utf8_name,
name_size,
&long_name[0],
&name_size_tmp);
if (eno == 0) {
40017c80: b0 92 20 00 orcc %o0, 0, %i0
40017c84: 12 80 00 4a bne 40017dac <msdos_filename_utf8_to_long_name_for_save+0x184><== NEVER TAKEN
40017c88: c6 07 bf fc ld [ %fp + -4 ], %g3
if (name_size_tmp <= (MSDOS_NAME_MAX_LNF_LEN * MSDOS_NAME_LFN_BYTES_PER_CHAR))
40017c8c: 80 a0 e1 fe cmp %g3, 0x1fe
40017c90: 38 80 00 47 bgu,a 40017dac <msdos_filename_utf8_to_long_name_for_save+0x184>
40017c94: b0 10 20 5b mov 0x5b, %i0
if ( eno == 0 )
{
/*
* Validate the characters and assign them to the UTF-16 file name
*/
for ( i = 0;
40017c98: 80 a0 e0 00 cmp %g3, 0
40017c9c: 02 80 00 39 be 40017d80 <msdos_filename_utf8_to_long_name_for_save+0x158><== NEVER TAKEN
40017ca0: 82 10 3f fe mov -2, %g1
retval = codepage_valid_char_map[char_num];
40017ca4: 33 10 00 9c sethi %hi(0x40027000), %i1
40017ca8: 35 10 00 5e sethi %hi(0x40017800), %i2
40017cac: b2 16 61 a0 or %i1, 0x1a0, %i1
40017cb0: b4 16 a3 5c or %i2, 0x35c, %i2
uint16_t char_num = CF_LE_W( utf16_character );
40017cb4: c4 16 c0 18 lduh [ %i3 + %i0 ], %g2
40017cb8: 83 28 a0 08 sll %g2, 8, %g1
40017cbc: 85 28 a0 10 sll %g2, 0x10, %g2
40017cc0: 85 30 a0 18 srl %g2, 0x18, %g2
40017cc4: 9e 06 c0 18 add %i3, %i0, %o7
40017cc8: 82 10 40 02 or %g1, %g2, %g1
if ( char_num <= 0x00ff ) {
40017ccc: bb 28 60 10 sll %g1, 0x10, %i5
40017cd0: 89 37 60 10 srl %i5, 0x10, %g4
40017cd4: 80 a1 20 ff cmp %g4, 0xff
40017cd8: 18 80 00 1b bgu 40017d44 <msdos_filename_utf8_to_long_name_for_save+0x11c>
40017cdc: 84 10 00 01 mov %g1, %g2
switch ( char_num )
40017ce0: 80 a1 20 5d cmp %g4, 0x5d
40017ce4: 18 80 00 10 bgu 40017d24 <msdos_filename_utf8_to_long_name_for_save+0xfc>
40017ce8: 80 a1 20 2a cmp %g4, 0x2a
40017cec: 08 80 00 14 bleu 40017d3c <msdos_filename_utf8_to_long_name_for_save+0x114>
40017cf0: 82 00 7f d5 add %g1, -43, %g1
40017cf4: 83 28 60 10 sll %g1, 0x10, %g1
40017cf8: 83 30 60 10 srl %g1, 0x10, %g1
40017cfc: 80 a0 60 32 cmp %g1, 0x32
40017d00: 18 80 00 0f bgu 40017d3c <msdos_filename_utf8_to_long_name_for_save+0x114><== NEVER TAKEN
40017d04: 83 28 60 02 sll %g1, 2, %g1
40017d08: c2 06 80 01 ld [ %i2 + %g1 ], %g1
40017d0c: 81 c0 40 00 jmp %g1
40017d10: 01 00 00 00 nop
if (name_size > 0) {
40017d14: 32 bf ff d4 bne,a 40017c64 <msdos_filename_utf8_to_long_name_for_save+0x3c><== NOT EXECUTED
40017d18: c2 06 00 00 ld [ %i0 ], %g1 <== NOT EXECUTED
long_name[chars_written] = UTF16_NULL;
}
}
}
else
eno = EINVAL;
40017d1c: 10 80 00 24 b 40017dac <msdos_filename_utf8_to_long_name_for_save+0x184> <== NOT EXECUTED
40017d20: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
switch ( char_num )
40017d24: 82 00 7f 9f add %g1, -97, %g1
40017d28: 83 28 60 10 sll %g1, 0x10, %g1
40017d2c: 83 30 60 10 srl %g1, 0x10, %g1
40017d30: 80 a0 60 19 cmp %g1, 0x19
40017d34: 08 80 00 05 bleu 40017d48 <msdos_filename_utf8_to_long_name_for_save+0x120>
40017d38: 83 28 a0 08 sll %g2, 8, %g1
40017d3c: bb 37 60 10 srl %i5, 0x10, %i5
retval = codepage_valid_char_map[char_num];
40017d40: c4 0e 40 1d ldub [ %i1 + %i5 ], %g2
return CT_LE_W( retval );
40017d44: 83 28 a0 08 sll %g2, 8, %g1
40017d48: 85 28 a0 10 sll %g2, 0x10, %g2
40017d4c: 85 30 a0 18 srl %g2, 0x18, %g2
40017d50: 84 10 40 02 or %g1, %g2, %g2
&& (c = msdos_get_valid_utf16_filename_character ( long_name[i]) );
40017d54: 83 28 a0 10 sll %g2, 0x10, %g1
40017d58: 80 a0 60 00 cmp %g1, 0
40017d5c: 02 80 00 0f be 40017d98 <msdos_filename_utf8_to_long_name_for_save+0x170>
40017d60: 80 a0 e0 02 cmp %g3, 2
long_name[i] = c;
40017d64: c4 36 c0 18 sth %g2, [ %i3 + %i0 ]
for ( i = 0;
40017d68: 86 80 ff fe addcc %g3, -2, %g3
40017d6c: 12 bf ff d2 bne 40017cb4 <msdos_filename_utf8_to_long_name_for_save+0x8c>
40017d70: b0 06 20 02 add %i0, 2, %i0
if ( long_name [chars_written - 1] != UTF16_NULL
40017d74: 82 0e 3f fe and %i0, -2, %g1
chars_written = returned_size / MSDOS_NAME_LFN_BYTES_PER_CHAR;
40017d78: 87 3e 20 01 sra %i0, 1, %g3
if ( long_name [chars_written - 1] != UTF16_NULL
40017d7c: 82 00 7f fe add %g1, -2, %g1
40017d80: c2 16 c0 01 lduh [ %i3 + %g1 ], %g1
40017d84: 80 a0 60 00 cmp %g1, 0
40017d88: 12 80 00 1a bne 40017df0 <msdos_filename_utf8_to_long_name_for_save+0x1c8><== ALWAYS TAKEN
40017d8c: 82 06 20 02 add %i0, 2, %g1
errno = eno;
returned_size = -1;
}
return returned_size;
}
40017d90: 81 c7 e0 08 ret <== NOT EXECUTED
40017d94: 81 e8 00 00 restore <== NOT EXECUTED
if ( name_size == UTF16_NULL_SIZE && c == UTF16_NULL ) {
40017d98: 12 80 00 0a bne 40017dc0 <msdos_filename_utf8_to_long_name_for_save+0x198><== ALWAYS TAKEN
40017d9c: 82 0e 3f fe and %i0, -2, %g1
long_name[i] = c;
40017da0: c0 33 c0 00 clrh [ %o7 ] <== NOT EXECUTED
returned_size += MSDOS_NAME_LFN_BYTES_PER_CHAR;
40017da4: 10 bf ff f4 b 40017d74 <msdos_filename_utf8_to_long_name_for_save+0x14c> <== NOT EXECUTED
40017da8: b0 06 20 02 add %i0, 2, %i0 <== NOT EXECUTED
errno = eno;
40017dac: 40 00 0f 40 call 4001baac <__errno>
40017db0: 01 00 00 00 nop
40017db4: f0 22 00 00 st %i0, [ %o0 ]
return returned_size;
40017db8: 81 c7 e0 08 ret
40017dbc: 91 e8 3f ff restore %g0, -1, %o0
if ( long_name [chars_written - 1] != UTF16_NULL
40017dc0: 82 00 7f fe add %g1, -2, %g1
40017dc4: c4 16 c0 01 lduh [ %i3 + %g1 ], %g2
40017dc8: 80 a0 a0 00 cmp %g2, 0
40017dcc: 02 bf ff d4 be 40017d1c <msdos_filename_utf8_to_long_name_for_save+0xf4> <== NEVER TAKEN
40017dd0: 83 3e 20 01 sra %i0, 1, %g1
&& (returned_size + UTF16_NULL_SIZE ) <= long_name_size ) {
40017dd4: b0 06 20 02 add %i0, 2, %i0
40017dd8: 80 a7 00 18 cmp %i4, %i0
40017ddc: 0a bf ff d0 bcs 40017d1c <msdos_filename_utf8_to_long_name_for_save+0xf4><== NEVER TAKEN
40017de0: 83 28 60 01 sll %g1, 1, %g1
eno = EINVAL;
40017de4: b0 10 20 16 mov 0x16, %i0
long_name[chars_written] = UTF16_NULL;
40017de8: 10 bf ff f1 b 40017dac <msdos_filename_utf8_to_long_name_for_save+0x184>
40017dec: c0 36 c0 01 clrh [ %i3 + %g1 ]
&& (returned_size + UTF16_NULL_SIZE ) <= long_name_size ) {
40017df0: 80 a0 40 1c cmp %g1, %i4
40017df4: 18 bf ff e7 bgu 40017d90 <msdos_filename_utf8_to_long_name_for_save+0x168><== NEVER TAKEN
40017df8: 87 28 e0 01 sll %g3, 1, %g3
long_name[chars_written] = UTF16_NULL;
40017dfc: c0 36 c0 03 clrh [ %i3 + %g3 ]
if ( eno != 0 ) {
40017e00: 81 c7 e0 08 ret
40017e04: 81 e8 00 00 restore
40017e08 <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)
{
40017e08: 9d e3 bf 68 save %sp, -152, %sp
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);
40017e0c: 82 10 20 30 mov 0x30, %g1
40017e10: c2 27 bf cc st %g1, [ %fp + -52 ]
if ( src_name[0] == UTF8_FULL_STOP
40017e14: c2 0e 40 00 ldub [ %i1 ], %g1
40017e18: 80 a0 60 2e cmp %g1, 0x2e
40017e1c: 02 80 00 1e be 40017e94 <msdos_filename_utf8_to_short_name_for_compare+0x8c>
40017e20: 80 a6 a0 00 cmp %i2, 0
while ( *name_size >= UTF8_FULL_STOP_SIZE
40017e24: 32 80 00 08 bne,a 40017e44 <msdos_filename_utf8_to_short_name_for_compare+0x3c><== ALWAYS TAKEN
40017e28: c2 06 00 00 ld [ %i0 ], %g1
if ( eno == 0 ) {
memcpy (&dest_ptr[0], &name_ptr[0], name_size);
returned_size = name_size;
}
} else
eno = EINVAL;
40017e2c: ba 10 20 16 mov 0x16, %i5 <== NOT EXECUTED
}
if ( eno != 0 ) {
errno = eno;
40017e30: 40 00 0f 1f call 4001baac <__errno> <== NOT EXECUTED
40017e34: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40017e38: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
returned_size = -1;
}
return returned_size;
}
40017e3c: 81 c7 e0 08 ret <== NOT EXECUTED
40017e40: 81 e8 00 00 restore <== NOT EXECUTED
eno = (*converter->handler->utf8_normalize_and_fold) (
40017e44: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
40017e48: 90 10 00 18 mov %i0, %o0
40017e4c: 98 07 bf cc add %fp, -52, %o4
40017e50: 96 07 bf d0 add %fp, -48, %o3
40017e54: 94 10 00 1a mov %i2, %o2
40017e58: 9f c0 40 00 call %g1
40017e5c: 92 10 00 19 mov %i1, %o1
name_size = name_size_tmp;
40017e60: f0 07 bf cc ld [ %fp + -52 ], %i0
if ( eno == ENOMEM ) {
40017e64: 80 a2 20 0c cmp %o0, 0xc
40017e68: 02 80 00 05 be 40017e7c <msdos_filename_utf8_to_short_name_for_compare+0x74><== NEVER TAKEN
40017e6c: ba 10 00 08 mov %o0, %i5
if ( eno == 0 ) {
40017e70: 80 a7 60 00 cmp %i5, 0
40017e74: 12 bf ff ef bne 40017e30 <msdos_filename_utf8_to_short_name_for_compare+0x28><== NEVER TAKEN
40017e78: 01 00 00 00 nop
memcpy (&dest_ptr[0], &name_ptr[0], name_size);
40017e7c: 94 10 00 18 mov %i0, %o2
40017e80: 92 07 bf d0 add %fp, -48, %o1
40017e84: 40 00 10 f8 call 4001c264 <memcpy>
40017e88: 90 10 00 1b mov %i3, %o0
if ( eno != 0 ) {
40017e8c: 81 c7 e0 08 ret
40017e90: 81 e8 00 00 restore
&& src_size == UTF8_FULL_STOP_SIZE) {
40017e94: 80 a6 a0 01 cmp %i2, 1
40017e98: 02 80 00 16 be 40017ef0 <msdos_filename_utf8_to_short_name_for_compare+0xe8>
40017e9c: 80 a7 20 00 cmp %i4, 0
&& src_name[1] == UTF8_FULL_STOP
40017ea0: c4 0e 60 01 ldub [ %i1 + 1 ], %g2
&& src_size == ( 2 * UTF8_FULL_STOP_SIZE ) ) {
40017ea4: 80 a0 a0 2e cmp %g2, 0x2e
40017ea8: 12 80 00 04 bne 40017eb8 <msdos_filename_utf8_to_short_name_for_compare+0xb0><== NEVER TAKEN
40017eac: 80 a6 a0 02 cmp %i2, 2
40017eb0: 02 80 00 15 be 40017f04 <msdos_filename_utf8_to_short_name_for_compare+0xfc><== ALWAYS TAKEN
40017eb4: 80 a7 20 01 cmp %i4, 1
while ( *name_size >= UTF8_FULL_STOP_SIZE
40017eb8: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
40017ebc: 32 80 00 09 bne,a 40017ee0 <msdos_filename_utf8_to_short_name_for_compare+0xd8><== NOT EXECUTED
40017ec0: b4 86 bf ff addcc %i2, -1, %i2 <== NOT EXECUTED
eno = EINVAL;
40017ec4: 10 bf ff db b 40017e30 <msdos_filename_utf8_to_short_name_for_compare+0x28><== NOT EXECUTED
40017ec8: ba 10 20 16 mov 0x16, %i5 <== NOT EXECUTED
&& **name_utf8 == UTF8_FULL_STOP) {
40017ecc: c2 0e 40 00 ldub [ %i1 ], %g1 <== NOT EXECUTED
40017ed0: 80 a0 60 2e cmp %g1, 0x2e <== NOT EXECUTED
40017ed4: 32 bf ff dc bne,a 40017e44 <msdos_filename_utf8_to_short_name_for_compare+0x3c><== NOT EXECUTED
40017ed8: c2 06 00 00 ld [ %i0 ], %g1 <== NOT EXECUTED
while ( *name_size >= UTF8_FULL_STOP_SIZE
40017edc: b4 86 bf ff addcc %i2, -1, %i2 <== NOT EXECUTED
40017ee0: 12 bf ff fb bne 40017ecc <msdos_filename_utf8_to_short_name_for_compare+0xc4><== NOT EXECUTED
40017ee4: b2 06 60 01 inc %i1 <== NOT EXECUTED
40017ee8: 10 bf ff d2 b 40017e30 <msdos_filename_utf8_to_short_name_for_compare+0x28><== NOT EXECUTED
40017eec: ba 10 20 16 mov 0x16, %i5 <== NOT EXECUTED
if (dest_size >= UTF8_FULL_STOP_SIZE) {
40017ef0: 02 80 00 0b be 40017f1c <msdos_filename_utf8_to_short_name_for_compare+0x114><== NEVER TAKEN
40017ef4: 01 00 00 00 nop
dest_name[0] = UTF8_FULL_STOP;
40017ef8: c2 2e c0 00 stb %g1, [ %i3 ]
returned_size = UTF8_FULL_STOP_SIZE;
40017efc: 81 c7 e0 08 ret
40017f00: 91 e8 20 01 restore %g0, 1, %o0
if (dest_size >= 2 * UTF8_FULL_STOP_SIZE) {
40017f04: 08 80 00 06 bleu 40017f1c <msdos_filename_utf8_to_short_name_for_compare+0x114><== NEVER TAKEN
40017f08: 01 00 00 00 nop
dest_name[0] = UTF8_FULL_STOP;
40017f0c: c2 2e c0 00 stb %g1, [ %i3 ]
dest_name[1] = UTF8_FULL_STOP;
40017f10: c2 2e e0 01 stb %g1, [ %i3 + 1 ]
returned_size = 2 * UTF8_FULL_STOP_SIZE;
40017f14: 81 c7 e0 08 ret
40017f18: 91 e8 20 02 restore %g0, 2, %o0
errno = eno;
40017f1c: 40 00 0e e4 call 4001baac <__errno> <== NOT EXECUTED
40017f20: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40017f24: 82 10 20 5b mov 0x5b, %g1 <== NOT EXECUTED
40017f28: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
if (returned_size == 0) {
40017f2c: 81 c7 e0 08 ret <== NOT EXECUTED
40017f30: 81 e8 00 00 restore <== NOT EXECUTED
40017f34 <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)
{
40017f34: 9d e3 bf 88 save %sp, -120, %sp
if ( src_name[0] == UTF8_FULL_STOP
40017f38: c2 0e 40 00 ldub [ %i1 ], %g1
40017f3c: 80 a0 60 2e cmp %g1, 0x2e
40017f40: 02 80 00 6e be 400180f8 <msdos_filename_utf8_to_short_name_for_save+0x1c4><== NEVER TAKEN
40017f44: 80 a6 a0 00 cmp %i2, 0
while ( *name_size >= UTF8_FULL_STOP_SIZE
40017f48: 32 80 00 08 bne,a 40017f68 <msdos_filename_utf8_to_short_name_for_save+0x34><== ALWAYS TAKEN
40017f4c: c2 06 00 00 ld [ %i0 ], %g1
else
eno = EINVAL;
}
if ( eno != 0 ) {
errno = eno;
40017f50: 40 00 0e d7 call 4001baac <__errno> <== NOT EXECUTED
40017f54: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40017f58: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
40017f5c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return -1;
40017f60: 81 c7 e0 08 ret
40017f64: 81 e8 00 00 restore
name_size_tmp = sizeof ( name_to_format_buf );
40017f68: 84 10 20 0c mov 0xc, %g2
40017f6c: c4 27 bf ec st %g2, [ %fp + -20 ]
eno = (*converter->handler->utf8_to_codepage) (
40017f70: 98 07 bf ec add %fp, -20, %o4
40017f74: c2 00 40 00 ld [ %g1 ], %g1
40017f78: 96 07 bf f0 add %fp, -16, %o3
40017f7c: 94 10 00 1a mov %i2, %o2
40017f80: 92 10 00 19 mov %i1, %o1
40017f84: 9f c0 40 00 call %g1
40017f88: 90 10 00 18 mov %i0, %o0
name_size = name_size_tmp;
40017f8c: fa 07 bf ec ld [ %fp + -20 ], %i5
for (i = 0; i < name_size; ++i)
40017f90: 80 a7 60 00 cmp %i5, 0
40017f94: 02 80 00 89 be 400181b8 <msdos_filename_utf8_to_short_name_for_save+0x284><== NEVER TAKEN
40017f98: 82 07 bf f0 add %fp, -16, %g1
40017f9c: 35 10 00 9d sethi %hi(0x40027400), %i2
40017fa0: b2 00 40 1d add %g1, %i5, %i1
40017fa4: b4 16 a1 61 or %i2, 0x161, %i2
name_to_format_buf[i] = toupper ( (unsigned char)(name_to_format_buf[i]) );
40017fa8: c6 08 40 00 ldub [ %g1 ], %g3
40017fac: 88 08 e0 ff and %g3, 0xff, %g4
40017fb0: c4 0e 80 04 ldub [ %i2 + %g4 ], %g2
40017fb4: 84 08 a0 03 and %g2, 3, %g2
40017fb8: 80 a0 a0 02 cmp %g2, 2
40017fbc: 22 80 00 02 be,a 40017fc4 <msdos_filename_utf8_to_short_name_for_save+0x90>
40017fc0: 86 01 3f e0 add %g4, -32, %g3
40017fc4: c6 28 40 00 stb %g3, [ %g1 ]
for (i = 0; i < name_size; ++i)
40017fc8: 82 00 60 01 inc %g1
40017fcc: 80 a0 40 19 cmp %g1, %i1
40017fd0: 32 bf ff f7 bne,a 40017fac <msdos_filename_utf8_to_short_name_for_save+0x78>
40017fd4: c6 08 40 00 ldub [ %g1 ], %g3
if ( 0x20 == *name_ptr )
40017fd8: c2 0f bf f0 ldub [ %fp + -16 ], %g1
40017fdc: 80 a0 60 20 cmp %g1, 0x20
40017fe0: 02 80 00 60 be 40018160 <msdos_filename_utf8_to_short_name_for_save+0x22c>
40017fe4: 80 a0 60 e5 cmp %g1, 0xe5
else if ( 0xE5 == *name_ptr )
40017fe8: 02 80 00 71 be 400181ac <msdos_filename_utf8_to_short_name_for_save+0x278><== NEVER TAKEN
40017fec: 05 10 00 9c sethi %hi(0x40027000), %g2
char c = codepage_valid_char_map[character];
40017ff0: 84 10 a1 a0 or %g2, 0x1a0, %g2 ! 400271a0 <codepage_valid_char_map>
if (c == 0) {
40017ff4: c6 48 80 01 ldsb [ %g2 + %g1 ], %g3
40017ff8: 80 a0 e0 00 cmp %g3, 0
40017ffc: 02 80 00 59 be 40018160 <msdos_filename_utf8_to_short_name_for_save+0x22c>
40018000: c2 08 80 01 ldub [ %g2 + %g1 ], %g1
dest_ptr[0] = msdos_get_valid_codepage_filename_character(*name_ptr);
40018004: c2 2e c0 00 stb %g1, [ %i3 ]
--name_size;
40018008: ba 07 7f ff add %i5, -1, %i5
char c = codepage_valid_char_map[character];
4001800c: 05 10 00 9c sethi %hi(0x40027000), %g2
++name_ptr;
40018010: b4 07 bf f1 add %fp, -15, %i2
++returned_size;
40018014: b0 10 20 01 mov 1, %i0
for (i = 1; i <= 7 && name_size && *name_ptr != '.'; ++i) {
40018018: 80 a7 60 00 cmp %i5, 0
4001801c: 02 80 00 15 be 40018070 <msdos_filename_utf8_to_short_name_for_save+0x13c>
40018020: 84 10 a1 a0 or %g2, 0x1a0, %g2
40018024: c2 0e 80 00 ldub [ %i2 ], %g1
40018028: 80 a0 60 2e cmp %g1, 0x2e
4001802c: 22 80 00 71 be,a 400181f0 <msdos_filename_utf8_to_short_name_for_save+0x2bc>
40018030: b4 06 a0 01 inc %i2
if (c == 0) {
40018034: c6 48 80 01 ldsb [ %g2 + %g1 ], %g3
40018038: 80 a0 e0 00 cmp %g3, 0
4001803c: 12 80 00 03 bne 40018048 <msdos_filename_utf8_to_short_name_for_save+0x114>
40018040: c2 08 80 01 ldub [ %g2 + %g1 ], %g1
c = '_';
40018044: 82 10 20 5f mov 0x5f, %g1
dest_ptr[i] = msdos_get_valid_codepage_filename_character(*name_ptr);
40018048: c2 2e c0 18 stb %g1, [ %i3 + %i0 ]
++name_ptr;
4001804c: 86 06 a0 01 add %i2, 1, %g3
++returned_size;
40018050: b0 06 20 01 inc %i0
for (i = 1; i <= 7 && name_size && *name_ptr != '.'; ++i) {
40018054: 80 a6 20 08 cmp %i0, 8
40018058: 02 80 00 44 be 40018168 <msdos_filename_utf8_to_short_name_for_save+0x234>
4001805c: 82 07 7f ff add %i5, -1, %g1
--name_size;
40018060: ba 10 00 01 mov %g1, %i5
for (i = 1; i <= 7 && name_size && *name_ptr != '.'; ++i) {
40018064: 80 a7 60 00 cmp %i5, 0
40018068: 12 bf ff ef bne 40018024 <msdos_filename_utf8_to_short_name_for_save+0xf0>
4001806c: b4 10 00 03 mov %g3, %i2
dest_ptr[i] = ' ';
40018070: 94 10 20 08 mov 8, %o2
40018074: 92 10 20 20 mov 0x20, %o1
40018078: 94 22 80 18 sub %o2, %i0, %o2
4001807c: 40 00 10 b9 call 4001c360 <memset>
40018080: 90 06 c0 18 add %i3, %i0, %o0
40018084: 82 07 60 08 add %i5, 8, %g1
char c = codepage_valid_char_map[character];
40018088: 07 10 00 9c sethi %hi(0x40027000), %g3
if ( name_size > 0 && *name_ptr == '.' ) {
4001808c: ba 10 20 08 mov 8, %i5
40018090: b0 10 20 08 mov 8, %i0
char c = codepage_valid_char_map[character];
40018094: 86 10 e1 a0 or %g3, 0x1a0, %g3
dest_ptr[i] = msdos_get_valid_codepage_filename_character(*name_ptr);
40018098: b4 06 bf f8 add %i2, -8, %i2
for (; i <= 10 && name_size ; i++) {
4001809c: 80 a0 40 1d cmp %g1, %i5
400180a0: 02 80 00 0e be 400180d8 <msdos_filename_utf8_to_short_name_for_save+0x1a4>
400180a4: 80 a7 00 1d cmp %i4, %i5
char c = codepage_valid_char_map[character];
400180a8: c4 0e 80 1d ldub [ %i2 + %i5 ], %g2
if (c == 0) {
400180ac: c8 48 c0 02 ldsb [ %g3 + %g2 ], %g4
400180b0: 80 a1 20 00 cmp %g4, 0
400180b4: 12 80 00 03 bne 400180c0 <msdos_filename_utf8_to_short_name_for_save+0x18c>
400180b8: c4 08 c0 02 ldub [ %g3 + %g2 ], %g2
c = '_';
400180bc: 84 10 20 5f mov 0x5f, %g2
dest_ptr[i] = msdos_get_valid_codepage_filename_character(*name_ptr);
400180c0: c4 2e c0 1d stb %g2, [ %i3 + %i5 ]
for (; i <= 10 && name_size ; i++) {
400180c4: ba 07 60 01 inc %i5
400180c8: 80 a7 60 0b cmp %i5, 0xb
400180cc: 12 bf ff f4 bne 4001809c <msdos_filename_utf8_to_short_name_for_save+0x168>
400180d0: b0 06 20 01 inc %i0
for ( ; i < short_name_size; ++i ) {
400180d4: 80 a7 00 1d cmp %i4, %i5
400180d8: 08 bf ff a2 bleu 40017f60 <msdos_filename_utf8_to_short_name_for_save+0x2c>
400180dc: 94 27 00 1d sub %i4, %i5, %o2
dest_ptr[i] = ' ';
400180e0: 90 06 c0 1d add %i3, %i5, %o0
400180e4: 92 10 20 20 mov 0x20, %o1
400180e8: 40 00 10 9e call 4001c360 <memset>
400180ec: ba 26 00 1d sub %i0, %i5, %i5
++returned_size;
400180f0: 81 c7 e0 08 ret
400180f4: 91 ef 40 1c restore %i5, %i4, %o0
&& src_size == UTF8_FULL_STOP_SIZE) {
400180f8: 80 a6 a0 01 cmp %i2, 1 <== NOT EXECUTED
400180fc: 02 80 00 20 be 4001817c <msdos_filename_utf8_to_short_name_for_save+0x248><== NOT EXECUTED
40018100: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
&& src_name[1] == UTF8_FULL_STOP
40018104: c4 0e 60 01 ldub [ %i1 + 1 ], %g2 <== NOT EXECUTED
&& src_size == ( 2 * UTF8_FULL_STOP_SIZE ) ) {
40018108: 80 a0 a0 2e cmp %g2, 0x2e <== NOT EXECUTED
4001810c: 12 80 00 04 bne 4001811c <msdos_filename_utf8_to_short_name_for_save+0x1e8><== NOT EXECUTED
40018110: 80 a6 a0 02 cmp %i2, 2 <== NOT EXECUTED
40018114: 02 80 00 2b be 400181c0 <msdos_filename_utf8_to_short_name_for_save+0x28c><== NOT EXECUTED
40018118: 80 a7 20 01 cmp %i4, 1 <== NOT EXECUTED
while ( *name_size >= UTF8_FULL_STOP_SIZE
4001811c: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
40018120: 32 80 00 08 bne,a 40018140 <msdos_filename_utf8_to_short_name_for_save+0x20c><== NOT EXECUTED
40018124: b4 86 bf ff addcc %i2, -1, %i2 <== NOT EXECUTED
40018128: 30 bf ff 8a b,a 40017f50 <msdos_filename_utf8_to_short_name_for_save+0x1c><== NOT EXECUTED
&& **name_utf8 == UTF8_FULL_STOP) {
4001812c: c2 0e 40 00 ldub [ %i1 ], %g1 <== NOT EXECUTED
40018130: 80 a0 60 2e cmp %g1, 0x2e <== NOT EXECUTED
40018134: 32 bf ff 8d bne,a 40017f68 <msdos_filename_utf8_to_short_name_for_save+0x34><== NOT EXECUTED
40018138: c2 06 00 00 ld [ %i0 ], %g1 <== NOT EXECUTED
while ( *name_size >= UTF8_FULL_STOP_SIZE
4001813c: b4 86 bf ff addcc %i2, -1, %i2 <== NOT EXECUTED
40018140: 12 bf ff fb bne 4001812c <msdos_filename_utf8_to_short_name_for_save+0x1f8><== NOT EXECUTED
40018144: b2 06 60 01 inc %i1 <== NOT EXECUTED
errno = eno;
40018148: 40 00 0e 59 call 4001baac <__errno> <== NOT EXECUTED
4001814c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40018150: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
40018154: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return -1;
40018158: 81 c7 e0 08 ret <== NOT EXECUTED
4001815c: 81 e8 00 00 restore <== NOT EXECUTED
c = '_';
40018160: 10 bf ff a9 b 40018004 <msdos_filename_utf8_to_short_name_for_save+0xd0>
40018164: 82 10 20 5f mov 0x5f, %g1
if ( name_size > 0 && *name_ptr == '.' ) {
40018168: 80 a0 60 00 cmp %g1, 0
4001816c: 32 80 00 09 bne,a 40018190 <msdos_filename_utf8_to_short_name_for_save+0x25c>
40018170: c4 08 c0 00 ldub [ %g3 ], %g2
40018174: 10 bf ff d8 b 400180d4 <msdos_filename_utf8_to_short_name_for_save+0x1a0>
40018178: ba 10 20 08 mov 8, %i5
if (dest_size >= UTF8_FULL_STOP_SIZE) {
4001817c: 02 80 00 17 be 400181d8 <msdos_filename_utf8_to_short_name_for_save+0x2a4><== NOT EXECUTED
40018180: 01 00 00 00 nop <== NOT EXECUTED
dest_name[0] = UTF8_FULL_STOP;
40018184: c2 2e c0 00 stb %g1, [ %i3 ] <== NOT EXECUTED
returned_size = UTF8_FULL_STOP_SIZE;
40018188: 81 c7 e0 08 ret <== NOT EXECUTED
4001818c: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED
++name_ptr;
40018190: b4 06 a0 02 add %i2, 2, %i2
if ( name_size > 0 && *name_ptr == '.' ) {
40018194: 80 a0 a0 2e cmp %g2, 0x2e
40018198: 02 bf ff bb be 40018084 <msdos_filename_utf8_to_short_name_for_save+0x150>
4001819c: ba 07 7f fe add %i5, -2, %i5
400181a0: ba 10 00 01 mov %g1, %i5
400181a4: 10 bf ff b8 b 40018084 <msdos_filename_utf8_to_short_name_for_save+0x150>
400181a8: b4 10 00 03 mov %g3, %i2
dest_ptr[0] = 0x05;
400181ac: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
400181b0: 10 bf ff 96 b 40018008 <msdos_filename_utf8_to_short_name_for_save+0xd4> <== NOT EXECUTED
400181b4: c2 2e c0 00 stb %g1, [ %i3 ] <== NOT EXECUTED
}
return returned_size;
}
400181b8: 81 c7 e0 08 ret <== NOT EXECUTED
400181bc: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
if (dest_size >= 2 * UTF8_FULL_STOP_SIZE) {
400181c0: 08 80 00 06 bleu 400181d8 <msdos_filename_utf8_to_short_name_for_save+0x2a4><== NOT EXECUTED
400181c4: 01 00 00 00 nop <== NOT EXECUTED
dest_name[0] = UTF8_FULL_STOP;
400181c8: c2 2e c0 00 stb %g1, [ %i3 ] <== NOT EXECUTED
dest_name[1] = UTF8_FULL_STOP;
400181cc: c2 2e e0 01 stb %g1, [ %i3 + 1 ] <== NOT EXECUTED
returned_size = 2 * UTF8_FULL_STOP_SIZE;
400181d0: 81 c7 e0 08 ret <== NOT EXECUTED
400181d4: 91 e8 20 02 restore %g0, 2, %o0 <== NOT EXECUTED
errno = eno;
400181d8: 40 00 0e 35 call 4001baac <__errno> <== NOT EXECUTED
400181dc: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400181e0: 82 10 20 5b mov 0x5b, %g1 <== NOT EXECUTED
400181e4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
if (returned_size == 0) {
400181e8: 81 c7 e0 08 ret <== NOT EXECUTED
400181ec: 81 e8 00 00 restore <== NOT EXECUTED
--name_size;
400181f0: 10 bf ff a0 b 40018070 <msdos_filename_utf8_to_short_name_for_save+0x13c>
400181f4: ba 07 7f ff add %i5, -1, %i5
40012584 <msdos_find_name>:
{
40012584: 9d e3 bf 60 save %sp, -160, %sp
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
40012588: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
4001258c: f6 00 60 08 ld [ %g1 + 8 ], %i3
name_type = msdos_long_to_short (
40012590: d0 06 e0 cc ld [ %i3 + 0xcc ], %o0
memset(node_entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
40012594: ba 07 bf e0 add %fp, -32, %i5
name_type = msdos_long_to_short (
40012598: 98 10 20 0b mov 0xb, %o4
4001259c: 96 10 00 1d mov %i5, %o3
400125a0: 94 10 00 1a mov %i2, %o2
400125a4: 92 10 00 19 mov %i1, %o1
fat_file_fd_t *fat_fd = NULL;
400125a8: c0 27 bf cc clr [ %fp + -52 ]
{
400125ac: b8 10 00 18 mov %i0, %i4
memset(node_entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
400125b0: c0 27 bf e0 clr [ %fp + -32 ]
400125b4: c0 27 bf e4 clr [ %fp + -28 ]
400125b8: c0 27 bf e8 clr [ %fp + -24 ]
400125bc: c0 27 bf ec clr [ %fp + -20 ]
400125c0: c0 27 bf f0 clr [ %fp + -16 ]
400125c4: c0 27 bf f4 clr [ %fp + -12 ]
400125c8: c0 27 bf f8 clr [ %fp + -8 ]
name_type = msdos_long_to_short (
400125cc: 7f ff f9 aa call 40010c74 <msdos_long_to_short>
400125d0: c0 27 bf fc clr [ %fp + -4 ]
rc = msdos_get_name_node(parent_loc, false, name, name_len, name_type,
400125d4: fa 23 a0 5c st %i5, [ %sp + 0x5c ]
name_type = msdos_long_to_short (
400125d8: 98 10 00 08 mov %o0, %o4
rc = msdos_get_name_node(parent_loc, false, name, name_len, name_type,
400125dc: 9a 07 bf d0 add %fp, -48, %o5
400125e0: 90 10 00 18 mov %i0, %o0
400125e4: 96 10 00 1a mov %i2, %o3
400125e8: 94 10 00 19 mov %i1, %o2
400125ec: 7f ff ff a7 call 40012488 <msdos_get_name_node>
400125f0: 92 10 20 00 clr %o1
if (rc != RC_OK)
400125f4: b0 92 20 00 orcc %o0, 0, %i0
400125f8: 12 80 00 1d bne 4001266c <msdos_find_name+0xe8>
400125fc: c2 0f bf eb ldub [ %fp + -21 ], %g1
if (((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_VOLUME_ID) ||
40012600: 80 88 60 08 btst 8, %g1
40012604: 12 80 00 1c bne 40012674 <msdos_find_name+0xf0> <== NEVER TAKEN
40012608: 82 08 60 3f and %g1, 0x3f, %g1
4001260c: 80 a0 60 0f cmp %g1, 0xf
40012610: 02 80 00 19 be 40012674 <msdos_find_name+0xf0> <== NEVER TAKEN
40012614: 94 07 bf cc add %fp, -52, %o2
rc = fat_file_open(&fs_info->fat, &dir_pos, &fat_fd);
40012618: 92 07 bf d0 add %fp, -48, %o1
4001261c: 7f ff f3 ca call 4000f544 <fat_file_open>
40012620: 90 10 00 1b mov %i3, %o0
if (rc != RC_OK)
40012624: b0 92 20 00 orcc %o0, 0, %i0
40012628: 12 80 00 11 bne 4001266c <msdos_find_name+0xe8> <== NEVER TAKEN
4001262c: c2 07 bf cc ld [ %fp + -52 ], %g1
fat_fd->dir_pos = dir_pos;
40012630: c4 1f bf d0 ldd [ %fp + -48 ], %g2
40012634: c4 38 60 20 std %g2, [ %g1 + 0x20 ]
40012638: c4 1f bf d8 ldd [ %fp + -40 ], %g2
4001263c: c4 38 60 28 std %g2, [ %g1 + 0x28 ]
if (fat_fd->links_num == 1)
40012640: c4 00 60 08 ld [ %g1 + 8 ], %g2
40012644: 80 a0 a0 01 cmp %g2, 1
40012648: 02 80 00 0f be 40012684 <msdos_find_name+0x100>
4001264c: c4 17 bf fa lduh [ %fp + -6 ], %g2
rc = fat_file_close(&fs_info->fat, parent_loc->node_access);
40012650: d2 07 20 08 ld [ %i4 + 8 ], %o1
40012654: 7f ff f5 5b call 4000fbc0 <fat_file_close>
40012658: 90 10 00 1b mov %i3, %o0
if (rc != RC_OK)
4001265c: b0 92 20 00 orcc %o0, 0, %i0
40012660: 12 80 00 54 bne 400127b0 <msdos_find_name+0x22c> <== NEVER TAKEN
40012664: c2 07 bf cc ld [ %fp + -52 ], %g1
parent_loc->node_access = fat_fd;
40012668: c2 27 20 08 st %g1, [ %i4 + 8 ]
return rc;
4001266c: 81 c7 e0 08 ret
40012670: 81 e8 00 00 restore
return MSDOS_NAME_NOT_FOUND_ERR;
40012674: 31 00 00 1f sethi %hi(0x7c00), %i0 <== NOT EXECUTED
40012678: b0 16 21 01 or %i0, 0x101, %i0 ! 7d01 <_ISR_Stack_size+0x6d01> <== NOT EXECUTED
}
4001267c: 81 c7 e0 08 ret <== NOT EXECUTED
40012680: 81 e8 00 00 restore <== NOT EXECUTED
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);
40012684: c8 17 bf f4 lduh [ %fp + -12 ], %g4
40012688: 87 28 a0 08 sll %g2, 8, %g3
4001268c: bb 28 a0 10 sll %g2, 0x10, %i5
40012690: 85 29 20 08 sll %g4, 8, %g2
40012694: bb 37 60 18 srl %i5, 0x18, %i5
40012698: 89 29 20 10 sll %g4, 0x10, %g4
4001269c: 86 10 c0 1d or %g3, %i5, %g3
400126a0: 89 31 20 18 srl %g4, 0x18, %g4
400126a4: 87 28 e0 10 sll %g3, 0x10, %g3
400126a8: 84 10 80 04 or %g2, %g4, %g2
400126ac: 87 30 e0 10 srl %g3, 0x10, %g3
400126b0: 85 28 a0 10 sll %g2, 0x10, %g2
400126b4: 84 10 80 03 or %g2, %g3, %g2
400126b8: c4 20 60 1c st %g2, [ %g1 + 0x1c ]
fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
400126bc: c4 17 bf f8 lduh [ %fp + -8 ], %g2
400126c0: c2 17 bf f6 lduh [ %fp + -10 ], %g1
400126c4: 91 28 a0 08 sll %g2, 8, %o0
400126c8: 93 28 60 08 sll %g1, 8, %o1
400126cc: 85 28 a0 10 sll %g2, 0x10, %g2
400126d0: 83 28 60 10 sll %g1, 0x10, %g1
400126d4: 85 30 a0 18 srl %g2, 0x18, %g2
400126d8: 83 30 60 18 srl %g1, 0x18, %g1
400126dc: 84 12 00 02 or %o0, %g2, %g2
400126e0: 82 12 40 01 or %o1, %g1, %g1
400126e4: 83 28 60 10 sll %g1, 0x10, %g1
400126e8: 91 28 a0 10 sll %g2, 0x10, %o0
400126ec: 93 30 60 10 srl %g1, 0x10, %o1
400126f0: 40 00 14 8f call 4001792c <msdos_date_dos2unix>
400126f4: 91 32 20 10 srl %o0, 0x10, %o0
400126f8: c2 07 bf cc ld [ %fp + -52 ], %g1
400126fc: d0 20 60 4c st %o0, [ %g1 + 0x4c ]
fat_fd->ctime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
40012700: c4 17 bf f0 lduh [ %fp + -16 ], %g2
fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
40012704: c0 20 60 48 clr [ %g1 + 0x48 ]
fat_fd->ctime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
40012708: 91 28 a0 08 sll %g2, 8, %o0
4001270c: c2 17 bf ee lduh [ %fp + -18 ], %g1
40012710: 93 28 60 08 sll %g1, 8, %o1
40012714: 85 28 a0 10 sll %g2, 0x10, %g2
40012718: 83 28 60 10 sll %g1, 0x10, %g1
4001271c: 85 30 a0 18 srl %g2, 0x18, %g2
40012720: 83 30 60 18 srl %g1, 0x18, %g1
40012724: 84 12 00 02 or %o0, %g2, %g2
40012728: 82 12 40 01 or %o1, %g1, %g1
4001272c: 83 28 60 10 sll %g1, 0x10, %g1
40012730: 91 28 a0 10 sll %g2, 0x10, %o0
40012734: 93 30 60 10 srl %g1, 0x10, %o1
40012738: 40 00 14 7d call 4001792c <msdos_date_dos2unix>
4001273c: 91 32 20 10 srl %o0, 0x10, %o0
40012740: fa 07 bf cc ld [ %fp + -52 ], %i5
40012744: c0 27 60 40 clr [ %i5 + 0x40 ]
40012748: d0 27 60 44 st %o0, [ %i5 + 0x44 ]
if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
4001274c: c2 0f bf eb ldub [ %fp + -21 ], %g1
40012750: 80 88 60 10 btst 0x10, %g1
40012754: 12 80 00 1c bne 400127c4 <msdos_find_name+0x240>
40012758: 03 00 08 00 sethi %hi(0x200000), %g1
fat_fd->fat_file_size = CF_LE_L(*MSDOS_DIR_FILE_SIZE(node_entry));
4001275c: 40 00 22 45 call 4001b070 <__bswapsi2>
40012760: d0 07 bf fc ld [ %fp + -4 ], %o0
fat_fd->fat_file_type = FAT_FILE;
40012764: 82 10 20 04 mov 4, %g1
fat_fd->fat_file_size = CF_LE_L(*MSDOS_DIR_FILE_SIZE(node_entry));
40012768: d0 27 60 18 st %o0, [ %i5 + 0x18 ]
fat_fd->fat_file_type = FAT_FILE;
4001276c: c2 27 60 10 st %g1, [ %i5 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_FILE_SIZE;
40012770: 82 10 3f ff mov -1, %g1
40012774: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
if ((fat_fd->fat_file_size != 0) &&
40012778: 80 a2 20 00 cmp %o0, 0
fat_fd->map.disk_cln = fat_fd->cln;
4001277c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
fat_fd->map.file_cln = 0;
40012780: c0 27 60 34 clr [ %i5 + 0x34 ]
if ((fat_fd->fat_file_size != 0) &&
40012784: 02 80 00 08 be 400127a4 <msdos_find_name+0x220>
40012788: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
4001278c: c4 06 e0 08 ld [ %i3 + 8 ], %g2
40012790: 80 a0 80 08 cmp %g2, %o0
40012794: 2a 80 00 05 bcs,a 400127a8 <msdos_find_name+0x224>
40012798: 82 10 3f ff mov -1, %g1
fat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
4001279c: 10 bf ff ad b 40012650 <msdos_find_name+0xcc>
400127a0: c2 27 60 3c st %g1, [ %i5 + 0x3c ]
400127a4: 82 10 3f ff mov -1, %g1
400127a8: 10 bf ff aa b 40012650 <msdos_find_name+0xcc>
400127ac: c2 27 60 3c st %g1, [ %i5 + 0x3c ]
fat_file_close(&fs_info->fat, fat_fd);
400127b0: d2 07 bf cc ld [ %fp + -52 ], %o1 <== NOT EXECUTED
400127b4: 7f ff f5 03 call 4000fbc0 <fat_file_close> <== NOT EXECUTED
400127b8: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
return rc;
400127bc: 81 c7 e0 08 ret <== NOT EXECUTED
400127c0: 81 e8 00 00 restore <== NOT EXECUTED
fat_fd->fat_file_type = FAT_DIRECTORY;
400127c4: c0 27 60 10 clr [ %i5 + 0x10 ]
rc = fat_file_size(&fs_info->fat, fat_fd);
400127c8: 92 10 00 1d mov %i5, %o1
fat_fd->size_limit = MSDOS_MAX_DIR_LENGTH;
400127cc: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
rc = fat_file_size(&fs_info->fat, fat_fd);
400127d0: 7f ff f6 a5 call 40010264 <fat_file_size>
400127d4: 90 10 00 1b mov %i3, %o0
if (rc != RC_OK)
400127d8: b0 92 20 00 orcc %o0, 0, %i0
400127dc: 12 bf ff f5 bne 400127b0 <msdos_find_name+0x22c> <== NEVER TAKEN
400127e0: fa 07 bf cc ld [ %fp + -52 ], %i5
if ((fat_fd->fat_file_size != 0) &&
400127e4: 10 bf ff e5 b 40012778 <msdos_find_name+0x1f4>
400127e8: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
40011634 <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)
{
40011634: 9d e3 be c0 save %sp, -320, %sp
int retval = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
40011638: e2 06 20 08 ld [ %i0 + 8 ], %l1
ssize_t name_len_for_compare;
uint32_t bts2rd = 0;
uint32_t empty_file_offset = 0;
uint32_t empty_entry_count = 0;
unsigned int lfn_entries;
rtems_dosfs_convert_control *converter = fs_info->converter;
4001163c: c2 04 60 cc ld [ %l1 + 0xcc ], %g1
void *buffer = converter->buffer.data;
40011640: c4 00 60 04 ld [ %g1 + 4 ], %g2
rtems_dosfs_convert_control *converter = fs_info->converter;
40011644: c2 27 bf 44 st %g1, [ %fp + -188 ]
size_t buffer_size = converter->buffer.size;
40011648: c2 00 60 08 ld [ %g1 + 8 ], %g1
4001164c: c2 27 bf 38 st %g1, [ %fp + -200 ]
assert(name_utf8_len > 0);
40011650: 82 97 20 00 orcc %i4, 0, %g1
{
40011654: f8 27 bf 3c st %i4, [ %fp + -196 ]
void *buffer = converter->buffer.data;
40011658: c4 27 bf 4c st %g2, [ %fp + -180 ]
{
4001165c: f6 27 bf 40 st %i3, [ %fp + -192 ]
assert(name_utf8_len > 0);
40011660: 04 80 02 5e ble 40011fd8 <msdos_find_name_in_fat_file+0x9a4> <== NEVER TAKEN
40011664: fa 27 bf 48 st %i5, [ %fp + -184 ]
dir_pos->sname.cln = 0;
40011668: c2 07 a0 5c ld [ %fp + 0x5c ], %g1
4001166c: c0 20 40 00 clr [ %g1 ]
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
40011670: 82 10 3f ff mov -1, %g1
dir_pos->sname.ofs = 0;
40011674: c4 07 a0 5c ld [ %fp + 0x5c ], %g2
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
40011678: c2 20 a0 08 st %g1, [ %g2 + 8 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
4001167c: c2 20 a0 0c st %g1, [ %g2 + 0xc ]
dir_pos->sname.ofs = 0;
40011680: c0 20 a0 04 clr [ %g2 + 4 ]
fat_dir_pos_init(dir_pos);
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
40011684: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
40011688: 80 a0 60 01 cmp %g1, 1
4001168c: 22 80 00 1e be,a 40011704 <msdos_find_name_in_fat_file+0xd0>
40011690: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
else
bts2rd = fs_info->fat.vol.bpc;
40011694: e0 04 60 08 ld [ %l1 + 8 ], %l0
switch ( name_type ) {
40011698: c2 07 bf 48 ld [ %fp + -184 ], %g1
4001169c: 80 a0 60 01 cmp %g1, 1
400116a0: 02 80 00 22 be 40011728 <msdos_find_name_in_fat_file+0xf4>
400116a4: 80 a0 60 02 cmp %g1, 2
400116a8: 02 80 00 08 be 400116c8 <msdos_find_name_in_fat_file+0x94>
400116ac: f6 07 bf 38 ld [ %fp + -200 ], %i3
}
else
retval = -1;
break;
default:
errno = EINVAL;
400116b0: 40 00 28 ff call 4001baac <__errno>
400116b4: b0 10 3f ff mov -1, %i0
400116b8: 82 10 20 16 mov 0x16, %g1
400116bc: c2 22 00 00 st %g1, [ %o0 ]
retval = -1;
break;
}
if (retval == RC_OK)
400116c0: 81 c7 e0 08 ret
400116c4: 81 e8 00 00 restore
name_len_for_save = msdos_filename_utf8_to_long_name_for_save (
400116c8: e6 07 bf 4c ld [ %fp + -180 ], %l3
400116cc: e4 07 bf 3c ld [ %fp + -196 ], %l2
400116d0: f0 07 bf 40 ld [ %fp + -192 ], %i0
400116d4: f8 07 bf 44 ld [ %fp + -188 ], %i4
400116d8: 98 10 00 1b mov %i3, %o4
400116dc: 96 10 00 13 mov %l3, %o3
400116e0: 94 10 00 12 mov %l2, %o2
400116e4: 92 10 00 18 mov %i0, %o1
400116e8: 40 00 19 50 call 40017c28 <msdos_filename_utf8_to_long_name_for_save>
400116ec: 90 10 00 1c mov %i4, %o0
if (name_len_for_save > 0) {
400116f0: ba 92 20 00 orcc %o0, 0, %i5
400116f4: 14 80 01 51 bg 40011c38 <msdos_find_name_in_fat_file+0x604>
400116f8: 96 10 00 13 mov %l3, %o3
entry = fs_info->cl_buf;
400116fc: 81 c7 e0 08 ret
40011700: 91 e8 3f ff restore %g0, -1, %o0
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
40011704: 80 a0 60 00 cmp %g1, 0
40011708: 32 bf ff e4 bne,a 40011698 <msdos_find_name_in_fat_file+0x64> <== NEVER TAKEN
4001170c: e0 04 60 08 ld [ %l1 + 8 ], %l0 <== NOT EXECUTED
40011710: c2 0c 60 16 ldub [ %l1 + 0x16 ], %g1
40011714: 80 88 60 03 btst 3, %g1
40011718: 22 bf ff e0 be,a 40011698 <msdos_find_name_in_fat_file+0x64>
4001171c: e0 04 60 08 ld [ %l1 + 8 ], %l0
bts2rd = fat_fd->fat_file_size;
40011720: 10 bf ff de b 40011698 <msdos_find_name_in_fat_file+0x64>
40011724: e0 06 60 18 ld [ %i1 + 0x18 ], %l0
name_len_for_compare = msdos_filename_utf8_to_short_name_for_compare (
40011728: d6 07 bf 4c ld [ %fp + -180 ], %o3
4001172c: d4 07 bf 3c ld [ %fp + -196 ], %o2
40011730: d2 07 bf 40 ld [ %fp + -192 ], %o1
40011734: d0 07 bf 44 ld [ %fp + -188 ], %o0
40011738: 40 00 19 b4 call 40017e08 <msdos_filename_utf8_to_short_name_for_compare>
4001173c: 98 10 20 0b mov 0xb, %o4
if (name_len_for_compare > 0) {
40011740: a6 92 20 00 orcc %o0, 0, %l3
40011744: 04 bf ff ee ble 400116fc <msdos_find_name_in_fat_file+0xc8> <== NEVER TAKEN
40011748: c0 27 bf 54 clr [ %fp + -172 ]
uint32_t entries_per_block = bts2rd / MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
4001174c: f2 27 bf 58 st %i1, [ %fp + -168 ]
40011750: 83 34 20 05 srl %l0, 5, %g1
40011754: c2 27 bf 34 st %g1, [ %fp + -204 ]
lfn_start->cln = FAT_FILE_SHORT_NAME;
40011758: 82 10 3f ff mov -1, %g1
}
4001175c: ae 10 00 13 mov %l3, %l7
lfn_start->cln = FAT_FILE_SHORT_NAME;
40011760: c2 27 bf 68 st %g1, [ %fp + -152 ]
uint32_t empty_file_offset = 0;
40011764: a4 10 20 00 clr %l2
rtems_dosfs_convert_control *converter = fs_info->converter;
40011768: c2 04 60 cc ld [ %l1 + 0xcc ], %g1
bool empty_space_found = false;
4001176c: a8 10 20 00 clr %l4
while ( (bytes_read = fat_file_read (&fs_info->fat, fat_fd, (dir_offset * bts2rd),
40011770: d8 04 60 c8 ld [ %l1 + 0xc8 ], %o4
40011774: d2 07 bf 58 ld [ %fp + -168 ], %o1
*entry_matched = false;
40011778: c0 2f bf 63 clrb [ %fp + -157 ]
}
4001177c: ac 10 20 00 clr %l6
uint32_t dir_offset = 0;
40011780: c0 27 bf 5c clr [ %fp + -164 ]
40011784: b2 10 00 14 mov %l4, %i1
uint8_t lfn_checksum = 0;
40011788: c0 2f bf 53 clrb [ %fp + -173 ]
4001178c: a8 10 00 12 mov %l2, %l4
while ( (bytes_read = fat_file_read (&fs_info->fat, fat_fd, (dir_offset * bts2rd),
40011790: 96 10 00 10 mov %l0, %o3
40011794: a4 10 00 13 mov %l3, %l2
40011798: 94 10 00 16 mov %l6, %o2
4001179c: a6 10 00 1a mov %i2, %l3
400117a0: 90 10 00 11 mov %l1, %o0
400117a4: b4 10 00 17 mov %l7, %i2
uint32_t empty_entry_count = 0;
400117a8: b6 10 20 00 clr %i3
400117ac: ae 10 00 01 mov %g1, %l7
while ( (bytes_read = fat_file_read (&fs_info->fat, fat_fd, (dir_offset * bts2rd),
400117b0: 7f ff f8 4a call 4000f8d8 <fat_file_read>
400117b4: b0 10 20 00 clr %i0
&& rc == RC_OK)
400117b8: 80 a2 20 00 cmp %o0, 0
400117bc: 22 80 00 80 be,a 400119bc <msdos_find_name_in_fat_file+0x388> <== NEVER TAKEN
400117c0: f2 07 bf 58 ld [ %fp + -168 ], %i1 <== NOT EXECUTED
if (bytes_read < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
400117c4: 80 a2 20 1f cmp %o0, 0x1f
400117c8: 04 80 01 56 ble 40011d20 <msdos_find_name_in_fat_file+0x6ec> <== NEVER TAKEN
400117cc: 80 a2 00 10 cmp %o0, %l0
assert(bytes_read == bts2rd);
400117d0: 12 80 02 0e bne 40012008 <msdos_find_name_in_fat_file+0x9d4> <== NEVER TAKEN
400117d4: ba 10 20 00 clr %i5
for (dir_entry = 0;
400117d8: 80 a4 20 00 cmp %l0, 0
400117dc: 12 80 00 1e bne 40011854 <msdos_find_name_in_fat_file+0x220> <== ALWAYS TAKEN
400117e0: aa 10 3f ff mov -1, %l5
dir_offset++;
400117e4: 10 80 00 69 b 40011988 <msdos_find_name_in_fat_file+0x354> <== NOT EXECUTED
400117e8: c2 07 bf 5c ld [ %fp + -164 ], %g1 <== NOT EXECUTED
if (create_node && !empty_space_found)
400117ec: 12 80 00 06 bne 40011804 <msdos_find_name_in_fat_file+0x1d0> <== NEVER TAKEN
400117f0: 80 a4 e0 00 cmp %l3, 0
400117f4: 22 80 00 05 be,a 40011808 <msdos_find_name_in_fat_file+0x1d4>
400117f8: c4 0f 20 0b ldub [ %i4 + 0xb ], %g2
*empty_entry_count = 0;
400117fc: b6 10 20 00 clr %i3
*empty_file_offset = 0;
40011800: a8 10 20 00 clr %l4
if ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
40011804: c4 0f 20 0b ldub [ %i4 + 0xb ], %g2
40011808: 86 08 a0 3f and %g2, 0x3f, %g3
4001180c: 80 a0 e0 0f cmp %g3, 0xf
40011810: 02 80 00 26 be 400118a8 <msdos_find_name_in_fat_file+0x274>
40011814: c6 0f bf 63 ldub [ %fp + -157 ], %g3
if (entry_matched)
40011818: 80 a0 e0 00 cmp %g3, 0
4001181c: 02 80 00 31 be 400118e0 <msdos_find_name_in_fat_file+0x2ac>
40011820: 80 88 a0 08 btst 8, %g2
if (lfn_entry ||
40011824: 80 a6 a0 00 cmp %i2, 0
40011828: 14 80 00 04 bg 40011838 <msdos_find_name_in_fat_file+0x204>
4001182c: 80 a6 20 00 cmp %i0, 0
40011830: 02 80 00 b2 be 40011af8 <msdos_find_name_in_fat_file+0x4c4> <== ALWAYS TAKEN
40011834: 88 10 20 00 clr %g4
lfn_start->cln = FAT_FILE_SHORT_NAME;
40011838: ea 27 bf 68 st %l5, [ %fp + -152 ]
}
4001183c: b4 10 00 12 mov %l2, %i2
*entry_matched = false;
40011840: c0 2f bf 63 clrb [ %fp + -157 ]
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
40011844: ba 07 60 20 add %i5, 0x20, %i5
for (dir_entry = 0;
40011848: 80 a4 00 1d cmp %l0, %i5
4001184c: 08 80 00 4f bleu 40011988 <msdos_find_name_in_fat_file+0x354>
40011850: c2 07 bf 5c ld [ %fp + -164 ], %g1
char* entry = (char*) fs_info->cl_buf + dir_entry;
40011854: d2 04 60 c8 ld [ %l1 + 0xc8 ], %o1
bool entry_empty = (*MSDOS_DIR_ENTRY_TYPE(entry) ==
40011858: c2 0a 40 1d ldub [ %o1 + %i5 ], %g1
if (*empty_entry_count == 0)
4001185c: 80 a6 e0 00 cmp %i3, 0
40011860: 12 80 00 03 bne 4001186c <msdos_find_name_in_fat_file+0x238>
40011864: b8 02 40 1d add %o1, %i5, %i4
*empty_file_offset = dir_offset * bts2rd + dir_entry;
40011868: a8 05 80 1d add %l6, %i5, %l4
if (remainder_empty)
4001186c: 84 88 60 ff andcc %g1, 0xff, %g2
40011870: 02 80 00 92 be 40011ab8 <msdos_find_name_in_fat_file+0x484>
40011874: 80 a0 a0 e5 cmp %g2, 0xe5
else if (entry_empty)
40011878: 12 bf ff dd bne 400117ec <msdos_find_name_in_fat_file+0x1b8>
4001187c: 80 8e 60 ff btst 0xff, %i1
if (create_node)
40011880: 80 a4 e0 00 cmp %l3, 0
40011884: 22 bf ff ee be,a 4001183c <msdos_find_name_in_fat_file+0x208>
40011888: ea 27 bf 68 st %l5, [ %fp + -152 ]
if (*empty_entry_count == (lfn_entries + 1))
4001188c: c4 07 bf 54 ld [ %fp + -172 ], %g2
(*empty_entry_count)++;
40011890: 82 06 e0 01 add %i3, 1, %g1
if (*empty_entry_count == (lfn_entries + 1))
40011894: 80 a6 c0 02 cmp %i3, %g2
40011898: 12 bf ff e8 bne 40011838 <msdos_find_name_in_fat_file+0x204>
4001189c: b6 10 00 01 mov %g1, %i3
empty_space_found = true;
400118a0: 10 bf ff e6 b 40011838 <msdos_find_name_in_fat_file+0x204>
400118a4: b2 10 20 01 mov 1, %i1
(lfn_start.cln == FAT_FILE_SHORT_NAME);
400118a8: c4 07 bf 68 ld [ %fp + -152 ], %g2
if (is_first_lfn_entry)
400118ac: 80 a0 bf ff cmp %g2, -1
400118b0: 02 80 00 49 be 400119d4 <msdos_find_name_in_fat_file+0x3a0>
400118b4: 82 08 60 3f and %g1, 0x3f, %g1
if ((lfn_entry != (*MSDOS_DIR_ENTRY_TYPE(entry) &
400118b8: 80 a0 40 18 cmp %g1, %i0
400118bc: 32 bf ff e0 bne,a 4001183c <msdos_find_name_in_fat_file+0x208> <== NEVER TAKEN
400118c0: ea 27 bf 68 st %l5, [ %fp + -152 ] <== NOT EXECUTED
MSDOS_LAST_LONG_ENTRY_MASK)) ||
400118c4: c6 0f 20 0d ldub [ %i4 + 0xd ], %g3
400118c8: c2 0f bf 53 ldub [ %fp + -173 ], %g1
400118cc: 80 a0 c0 01 cmp %g3, %g1
400118d0: 32 bf ff db bne,a 4001183c <msdos_find_name_in_fat_file+0x208> <== NEVER TAKEN
400118d4: ea 27 bf 68 st %l5, [ %fp + -152 ] <== NOT EXECUTED
400118d8: 10 80 00 4c b 40011a08 <msdos_find_name_in_fat_file+0x3d4>
400118dc: 84 38 00 02 xnor %g0, %g2, %g2
} else if ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_VOLUME_ID)
400118e0: 32 bf ff da bne,a 40011848 <msdos_find_name_in_fat_file+0x214>
400118e4: ba 07 60 20 add %i5, 0x20, %i5
size_t bytes_converted = buf_size;
400118e8: 82 10 20 0c mov 0xc, %g1
ssize_t bytes_written = msdos_format_dirent_with_dot(char_buf, entry);
400118ec: 92 10 00 1c mov %i4, %o1
size_t bytes_converted = buf_size;
400118f0: c2 27 bf 64 st %g1, [ %fp + -156 ]
ssize_t bytes_written = msdos_format_dirent_with_dot(char_buf, entry);
400118f4: 7f ff fe fd call 400114e8 <msdos_format_dirent_with_dot>
400118f8: 90 07 bf 70 add %fp, -144, %o0
if (bytes_written > 0) {
400118fc: 94 92 20 00 orcc %o0, 0, %o2
40011900: 04 80 01 a8 ble 40011fa0 <msdos_find_name_in_fat_file+0x96c> <== NEVER TAKEN
40011904: c2 4f bf 70 ldsb [ %fp + -144 ], %g1
if (char_buf[0] == 0x05)
40011908: 80 a0 60 05 cmp %g1, 5
4001190c: 12 80 00 04 bne 4001191c <msdos_find_name_in_fat_file+0x2e8> <== ALWAYS TAKEN
40011910: 98 07 bf 64 add %fp, -156, %o4
char_buf[0] = 0xE5;
40011914: 82 10 3f e5 mov -27, %g1 <== NOT EXECUTED
40011918: c2 2f bf 70 stb %g1, [ %fp + -144 ] <== NOT EXECUTED
eno = (*converter->handler->codepage_to_utf8) (
4001191c: c2 05 c0 00 ld [ %l7 ], %g1
40011920: c2 00 60 04 ld [ %g1 + 4 ], %g1
40011924: 96 07 bf 90 add %fp, -112, %o3
40011928: 92 07 bf 70 add %fp, -144, %o1
4001192c: 9f c0 40 00 call %g1
40011930: 90 10 00 17 mov %l7, %o0
if (eno == 0)
40011934: b4 92 20 00 orcc %o0, 0, %i2
40011938: 02 80 00 5b be 40011aa4 <msdos_find_name_in_fat_file+0x470> <== ALWAYS TAKEN
4001193c: d4 07 bf 64 ld [ %fp + -156 ], %o2
errno = eno;
40011940: 40 00 28 5b call 4001baac <__errno> <== NOT EXECUTED
40011944: 01 00 00 00 nop <== NOT EXECUTED
40011948: f4 22 00 00 st %i2, [ %o0 ] <== NOT EXECUTED
bytes_in_entry = msdos_short_entry_to_utf8_name (
4001194c: 94 10 3f ff mov -1, %o2 <== NOT EXECUTED
name_len_remaining = msdos_compare_entry_against_filename (
40011950: d6 07 bf 4c ld [ %fp + -180 ], %o3 <== NOT EXECUTED
40011954: 9a 07 bf 63 add %fp, -157, %o5
40011958: 98 10 00 12 mov %l2, %o4
4001195c: 92 07 bf 90 add %fp, -112, %o1
40011960: 7f ff fc 4f call 40010a9c <msdos_compare_entry_against_filename>
40011964: 90 10 00 17 mov %l7, %o0
if (entry_matched && name_len_remaining == 0) {
40011968: c2 0f bf 63 ldub [ %fp + -157 ], %g1
4001196c: 80 a0 60 00 cmp %g1, 0
40011970: 02 bf ff b2 be 40011838 <msdos_find_name_in_fat_file+0x204>
40011974: 80 a2 20 00 cmp %o0, 0
40011978: 32 bf ff b1 bne,a 4001183c <msdos_find_name_in_fat_file+0x208>
4001197c: ea 27 bf 68 st %l5, [ %fp + -152 ]
40011980: 10 80 00 6f b 40011b3c <msdos_find_name_in_fat_file+0x508>
40011984: c2 07 bf 5c ld [ %fp + -164 ], %g1
dir_offset++;
40011988: 82 00 60 01 inc %g1
while ( (bytes_read = fat_file_read (&fs_info->fat, fat_fd, (dir_offset * bts2rd),
4001198c: d8 04 60 c8 ld [ %l1 + 0xc8 ], %o4
40011990: d2 07 bf 58 ld [ %fp + -168 ], %o1
dir_offset++;
40011994: c2 27 bf 5c st %g1, [ %fp + -164 ]
40011998: ac 05 80 10 add %l6, %l0, %l6
while ( (bytes_read = fat_file_read (&fs_info->fat, fat_fd, (dir_offset * bts2rd),
4001199c: 96 10 00 10 mov %l0, %o3
400119a0: 94 10 00 16 mov %l6, %o2
400119a4: 7f ff f7 cd call 4000f8d8 <fat_file_read>
400119a8: 90 10 00 11 mov %l1, %o0
&& rc == RC_OK)
400119ac: 80 a2 20 00 cmp %o0, 0
400119b0: 12 bf ff 86 bne 400117c8 <msdos_find_name_in_fat_file+0x194>
400119b4: 80 a2 20 1f cmp %o0, 0x1f
if (!create_node)
400119b8: f2 07 bf 58 ld [ %fp + -168 ], %i1
400119bc: b4 94 e0 00 orcc %l3, 0, %i2
400119c0: 02 80 01 6a be 40011f68 <msdos_find_name_in_fat_file+0x934>
400119c4: a4 10 00 14 mov %l4, %l2
uint8_t lfn_checksum = 0;
400119c8: 82 10 20 01 mov 1, %g1
400119cc: 10 80 00 71 b 40011b90 <msdos_find_name_in_fat_file+0x55c>
400119d0: b0 10 20 00 clr %i0
entry_matched = false;
400119d4: c0 2f bf 63 clrb [ %fp + -157 ]
if ((*MSDOS_DIR_ENTRY_TYPE(entry) &
400119d8: c2 0f 00 00 ldub [ %i4 ], %g1
400119dc: 80 88 60 40 btst 0x40, %g1
400119e0: 22 bf ff 9a be,a 40011848 <msdos_find_name_in_fat_file+0x214>
400119e4: ba 07 60 20 add %i5, 0x20, %i5
lfn_start.cln = dir_offset;
400119e8: c2 07 bf 5c ld [ %fp + -164 ], %g1
400119ec: c2 27 bf 68 st %g1, [ %fp + -152 ]
lfn_start.ofs = dir_entry;
400119f0: fa 27 bf 6c st %i5, [ %fp + -148 ]
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
400119f4: c2 0f 20 0d ldub [ %i4 + 0xd ], %g1
400119f8: c2 2f bf 53 stb %g1, [ %fp + -173 ]
lfn_entry = (*MSDOS_DIR_ENTRY_TYPE(entry)
400119fc: f0 0f 00 00 ldub [ %i4 ], %i0
40011a00: b0 0e 20 3f and %i0, 0x3f, %i0
bool is_first_lfn_entry =
40011a04: 84 38 00 02 xnor %g0, %g2, %g2
size_t bytes_in_utf8 = buf_size;
40011a08: 82 10 20 70 mov 0x70, %g1
40011a0c: 80 a0 00 02 cmp %g0, %g2
40011a10: 94 60 3f ff subx %g0, -1, %o2
40011a14: c2 27 bf 64 st %g1, [ %fp + -156 ]
40011a18: 92 07 bf 70 add %fp, -144, %o1
40011a1c: 90 10 00 1c mov %i4, %o0
40011a20: 7f ff fc 68 call 40010bc0 <msdos_get_utf16_string_from_long_entry.part.0>
40011a24: b0 06 3f ff add %i0, -1, %i0
if (retval >= 0) {
40011a28: 94 92 20 00 orcc %o0, 0, %o2
40011a2c: 06 80 00 0f bl 40011a68 <msdos_find_name_in_fat_file+0x434> <== NEVER TAKEN
40011a30: 98 07 bf 64 add %fp, -156, %o4
eno = (*converter->handler->utf16_to_utf8) (
40011a34: c2 05 c0 00 ld [ %l7 ], %g1
40011a38: c2 00 60 0c ld [ %g1 + 0xc ], %g1
40011a3c: 96 07 bf 90 add %fp, -112, %o3
40011a40: 92 07 bf 70 add %fp, -144, %o1
40011a44: 9f c0 40 00 call %g1
40011a48: 90 10 00 17 mov %l7, %o0
if ( eno == 0 ) {
40011a4c: b8 92 20 00 orcc %o0, 0, %i4
40011a50: 02 80 00 75 be 40011c24 <msdos_find_name_in_fat_file+0x5f0>
40011a54: d4 07 bf 64 ld [ %fp + -156 ], %o2
errno = eno;
40011a58: 40 00 28 15 call 4001baac <__errno>
40011a5c: 01 00 00 00 nop
40011a60: f8 22 00 00 st %i4, [ %o0 ]
bytes_in_entry = msdos_long_entry_to_utf8_name (
40011a64: 94 10 3f ff mov -1, %o2
name_len_remaining = msdos_compare_entry_against_filename (
40011a68: d6 07 bf 4c ld [ %fp + -180 ], %o3
40011a6c: 98 10 00 1a mov %i2, %o4
40011a70: 9a 07 bf 63 add %fp, -157, %o5
40011a74: 92 07 bf 90 add %fp, -112, %o1
40011a78: 7f ff fc 09 call 40010a9c <msdos_compare_entry_against_filename>
40011a7c: 90 10 00 17 mov %l7, %o0
if (name_len_remaining < 0 || !entry_matched) {
40011a80: b4 92 20 00 orcc %o0, 0, %i2
40011a84: 26 bf ff 6e bl,a 4001183c <msdos_find_name_in_fat_file+0x208> <== NEVER TAKEN
40011a88: ea 27 bf 68 st %l5, [ %fp + -152 ] <== NOT EXECUTED
40011a8c: c2 0f bf 63 ldub [ %fp + -157 ], %g1
40011a90: 80 a0 60 00 cmp %g1, 0
40011a94: 32 bf ff 6d bne,a 40011848 <msdos_find_name_in_fat_file+0x214>
40011a98: ba 07 60 20 add %i5, 0x20, %i5
40011a9c: 10 bf ff 68 b 4001183c <msdos_find_name_in_fat_file+0x208>
40011aa0: ea 27 bf 68 st %l5, [ %fp + -152 ]
if (bytes_in_entry > 0) {
40011aa4: 80 a2 a0 00 cmp %o2, 0
40011aa8: 22 bf ff 65 be,a 4001183c <msdos_find_name_in_fat_file+0x208> <== NEVER TAKEN
40011aac: ea 27 bf 68 st %l5, [ %fp + -152 ] <== NOT EXECUTED
name_len_remaining = msdos_compare_entry_against_filename (
40011ab0: 10 bf ff a9 b 40011954 <msdos_find_name_in_fat_file+0x320>
40011ab4: d6 07 bf 4c ld [ %fp + -180 ], %o3
if (!create_node)
40011ab8: a4 10 00 14 mov %l4, %l2
rc = MSDOS_NAME_NOT_FOUND_ERR;
40011abc: 31 00 00 1f sethi %hi(0x7c00), %i0
if (!create_node)
40011ac0: a8 10 00 19 mov %i1, %l4
40011ac4: b4 94 e0 00 orcc %l3, 0, %i2
40011ac8: f2 07 bf 58 ld [ %fp + -168 ], %i1
40011acc: 02 bf fe fd be 400116c0 <msdos_find_name_in_fat_file+0x8c>
40011ad0: b0 16 21 01 or %i0, 0x101, %i0
if ( !empty_space_found
40011ad4: 80 8d 20 ff btst 0xff, %l4
40011ad8: 12 bf ff bc bne 400119c8 <msdos_find_name_in_fat_file+0x394>
40011adc: bb 37 60 05 srl %i5, 5, %i5
*empty_entry_count +=
40011ae0: c2 07 bf 34 ld [ %fp + -204 ], %g1
40011ae4: b6 00 40 1b add %g1, %i3, %i3
uint8_t lfn_checksum = 0;
40011ae8: 82 10 20 01 mov 1, %g1
*empty_entry_count +=
40011aec: b6 26 c0 1d sub %i3, %i5, %i3
uint8_t lfn_checksum = 0;
40011af0: 10 80 00 28 b 40011b90 <msdos_find_name_in_fat_file+0x55c>
40011af4: b0 10 20 00 clr %i0
cs = 0;
40011af8: 10 80 00 03 b 40011b04 <msdos_find_name_in_fat_file+0x4d0>
40011afc: 84 10 20 00 clr %g2
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + name[i];
40011b00: c2 0f 00 04 ldub [ %i4 + %g4 ], %g1
40011b04: 84 08 a0 ff and %g2, 0xff, %g2
for (i = 0; i < MSDOS_SHORT_NAME_LEN; ++i) {
40011b08: 88 01 20 01 inc %g4
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + name[i];
40011b0c: 87 28 a0 07 sll %g2, 7, %g3
for (i = 0; i < MSDOS_SHORT_NAME_LEN; ++i) {
40011b10: 80 a1 20 0b cmp %g4, 0xb
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + name[i];
40011b14: 85 30 a0 01 srl %g2, 1, %g2
40011b18: 84 00 c0 02 add %g3, %g2, %g2
for (i = 0; i < MSDOS_SHORT_NAME_LEN; ++i) {
40011b1c: 12 bf ff f9 bne 40011b00 <msdos_find_name_in_fat_file+0x4cc>
40011b20: 84 00 80 01 add %g2, %g1, %g2
name_len_remaining > 0 ||
40011b24: c2 0f bf 53 ldub [ %fp + -173 ], %g1
40011b28: 84 08 a0 ff and %g2, 0xff, %g2
40011b2c: 80 a0 80 01 cmp %g2, %g1
40011b30: 32 bf ff 43 bne,a 4001183c <msdos_find_name_in_fat_file+0x208> <== NEVER TAKEN
40011b34: ea 27 bf 68 st %l5, [ %fp + -152 ] <== NOT EXECUTED
rc = msdos_on_entry_found (
40011b38: c2 07 bf 5c ld [ %fp + -164 ], %g1
40011b3c: fa 23 a0 60 st %i5, [ %sp + 0x60 ]
40011b40: 98 10 00 1c mov %i4, %o4
40011b44: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
40011b48: 82 07 bf 68 add %fp, -152, %g1
40011b4c: c2 23 a0 64 st %g1, [ %sp + 0x64 ]
40011b50: 94 10 00 10 mov %l0, %o2
40011b54: f2 07 bf 58 ld [ %fp + -168 ], %i1
40011b58: da 07 a0 5c ld [ %fp + 0x5c ], %o5
40011b5c: d6 07 a0 60 ld [ %fp + 0x60 ], %o3
40011b60: 92 10 00 19 mov %i1, %o1
40011b64: 7f ff fb f2 call 40010b2c <msdos_on_entry_found>
40011b68: 90 10 00 11 mov %l1, %o0
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
40011b6c: ba 07 60 20 add %i5, 0x20, %i5
rc = msdos_on_entry_found (
40011b70: a4 10 00 14 mov %l4, %l2
40011b74: b4 10 00 13 mov %l3, %i2
for (dir_entry = 0;
40011b78: 80 a7 40 10 cmp %i5, %l0
40011b7c: 1a 80 01 1f bcc 40011ff8 <msdos_find_name_in_fat_file+0x9c4>
40011b80: b0 10 00 08 mov %o0, %i0
40011b84: 80 a2 20 00 cmp %o0, 0
40011b88: 12 80 01 1c bne 40011ff8 <msdos_find_name_in_fat_file+0x9c4> <== NEVER TAKEN
40011b8c: 82 10 00 13 mov %l3, %g1
if ( retval == RC_OK
40011b90: 80 88 60 ff btst 0xff, %g1
40011b94: 02 bf fe cb be 400116c0 <msdos_find_name_in_fat_file+0x8c>
40011b98: c2 07 bf 48 ld [ %fp + -184 ], %g1
switch (name_type) {
40011b9c: 80 a0 60 01 cmp %g1, 1
40011ba0: 02 80 00 35 be 40011c74 <msdos_find_name_in_fat_file+0x640>
40011ba4: 80 a0 60 02 cmp %g1, 2
40011ba8: 12 bf fe c2 bne 400116b0 <msdos_find_name_in_fat_file+0x7c> <== NEVER TAKEN
40011bac: d8 07 bf 38 ld [ %fp + -200 ], %o4
name_len_for_save = msdos_filename_utf8_to_long_name_for_save (
40011bb0: d6 07 bf 4c ld [ %fp + -180 ], %o3
40011bb4: d4 07 bf 3c ld [ %fp + -196 ], %o2
40011bb8: d2 07 bf 40 ld [ %fp + -192 ], %o1
40011bbc: 40 00 18 1b call 40017c28 <msdos_filename_utf8_to_long_name_for_save>
40011bc0: d0 07 bf 44 ld [ %fp + -188 ], %o0
if (name_len_for_save > 0) {
40011bc4: 80 a2 20 00 cmp %o0, 0
40011bc8: 04 bf fe cd ble 400116fc <msdos_find_name_in_fat_file+0xc8> <== NEVER TAKEN
40011bcc: b8 02 20 19 add %o0, 0x19, %i4
/ MSDOS_LFN_ENTRY_SIZE;
40011bd0: 03 13 b1 3b sethi %hi(0x4ec4ec00), %g1
40011bd4: 82 10 60 4f or %g1, 0x4f, %g1 ! 4ec4ec4f <RAM_END+0xe84ec4f>
40011bd8: 80 57 00 01 umul %i4, %g1, %g0
40011bdc: b9 40 00 00 rd %y, %i4
40011be0: b9 37 20 03 srl %i4, 3, %i4
if (empty_entry_count < lfn_entries + 1)
40011be4: b4 07 20 01 add %i4, 1, %i2
40011be8: 80 a6 80 1b cmp %i2, %i3
40011bec: 08 80 00 54 bleu 40011d3c <msdos_find_name_in_fat_file+0x708>
40011bf0: 98 07 bf 90 add %fp, -112, %o4
empty_file_offset = fat_fd->fat_file_size -
40011bf4: e4 06 60 18 ld [ %i1 + 0x18 ], %l2
ret = fat_file_extend(&fs_info->fat,
40011bf8: d6 04 60 08 ld [ %l1 + 8 ], %o3
40011bfc: 96 04 80 0b add %l2, %o3, %o3
40011c00: 94 10 20 01 mov 1, %o2
40011c04: 92 10 00 19 mov %i1, %o1
40011c08: 7f ff f8 58 call 4000fd68 <fat_file_extend>
40011c0c: 90 10 00 11 mov %l1, %o0
if (ret != RC_OK)
40011c10: b0 92 20 00 orcc %o0, 0, %i0
40011c14: 02 80 00 49 be 40011d38 <msdos_find_name_in_fat_file+0x704> <== ALWAYS TAKEN
40011c18: b7 2e e0 05 sll %i3, 5, %i3
empty_entry_count
);
}
return retval;
}
40011c1c: 81 c7 e0 08 ret <== NOT EXECUTED
40011c20: 81 e8 00 00 restore <== NOT EXECUTED
if (bytes_in_entry > 0) {
40011c24: 80 a2 a0 00 cmp %o2, 0
40011c28: 22 bf ff 05 be,a 4001183c <msdos_find_name_in_fat_file+0x208> <== NEVER TAKEN
40011c2c: ea 27 bf 68 st %l5, [ %fp + -152 ] <== NOT EXECUTED
40011c30: 10 bf ff 8f b 40011a6c <msdos_find_name_in_fat_file+0x438>
40011c34: d6 07 bf 4c ld [ %fp + -180 ], %o3
name_len_for_compare = msdos_filename_utf8_to_long_name_for_compare (
40011c38: 98 10 00 1b mov %i3, %o4
40011c3c: 94 10 00 12 mov %l2, %o2
40011c40: 92 10 00 18 mov %i0, %o1
40011c44: 40 00 17 82 call 40017a4c <msdos_filename_utf8_to_long_name_for_compare>
40011c48: 90 10 00 1c mov %i4, %o0
if (0 >= name_len_for_compare) {
40011c4c: a6 92 20 00 orcc %o0, 0, %l3
40011c50: 04 bf fe ab ble 400116fc <msdos_find_name_in_fat_file+0xc8> <== NEVER TAKEN
40011c54: 82 07 60 19 add %i5, 0x19, %g1
/ MSDOS_LFN_ENTRY_SIZE;
40011c58: 07 13 b1 3b sethi %hi(0x4ec4ec00), %g3
40011c5c: 86 10 e0 4f or %g3, 0x4f, %g3 ! 4ec4ec4f <RAM_END+0xe84ec4f>
40011c60: 80 50 40 03 umul %g1, %g3, %g0
40011c64: 83 40 00 00 rd %y, %g1
40011c68: 83 30 60 03 srl %g1, 3, %g1
40011c6c: 10 bf fe b8 b 4001174c <msdos_find_name_in_fat_file+0x118>
40011c70: c2 27 bf 54 st %g1, [ %fp + -172 ]
name_len_for_save = msdos_filename_utf8_to_short_name_for_save (
40011c74: d6 07 bf 4c ld [ %fp + -180 ], %o3
40011c78: d4 07 bf 3c ld [ %fp + -196 ], %o2
40011c7c: d2 07 bf 40 ld [ %fp + -192 ], %o1
40011c80: d0 07 bf 44 ld [ %fp + -188 ], %o0
40011c84: 40 00 18 ac call 40017f34 <msdos_filename_utf8_to_short_name_for_save>
40011c88: 98 10 20 0b mov 0xb, %o4
if (name_len_for_save > 0 ) {
40011c8c: 80 a2 20 00 cmp %o0, 0
40011c90: 04 bf fe 9b ble 400116fc <msdos_find_name_in_fat_file+0xc8> <== NEVER TAKEN
40011c94: 80 a6 e0 00 cmp %i3, 0
if (empty_entry_count < lfn_entries + 1)
40011c98: 22 80 00 c4 be,a 40011fa8 <msdos_find_name_in_fat_file+0x974>
40011c9c: e4 06 60 18 ld [ %i1 + 0x18 ], %l2
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
40011ca0: c6 07 a0 5c ld [ %fp + 0x5c ], %g3
40011ca4: 84 10 3f ff mov -1, %g2
pos->ofs = file_offset & (bts2rd - 1);
40011ca8: 82 04 3f ff add %l0, -1, %g1
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
40011cac: c4 20 e0 08 st %g2, [ %g3 + 8 ]
pos->ofs = file_offset & (bts2rd - 1);
40011cb0: 82 08 40 12 and %g1, %l2, %g1
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
40011cb4: c4 20 e0 0c st %g2, [ %g3 + 0xc ]
return fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
40011cb8: 98 10 00 03 mov %g3, %o4
pos->ofs = file_offset & (bts2rd - 1);
40011cbc: c2 20 e0 04 st %g1, [ %g3 + 4 ]
return fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
40011cc0: 96 10 00 12 mov %l2, %o3
40011cc4: 94 10 20 01 mov 1, %o2
40011cc8: 92 10 00 19 mov %i1, %o1
40011ccc: 7f ff f7 f2 call 4000fc94 <fat_file_ioctl>
40011cd0: 90 10 00 11 mov %l1, %o0
entry = fs_info->cl_buf;
40011cd4: f0 04 60 c8 ld [ %l1 + 0xc8 ], %i0
40011cd8: b4 10 20 20 mov 0x20, %i2
40011cdc: b6 10 20 20 mov 0x20, %i3
memcpy(entry, name_dir_entry, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
40011ce0: d2 07 a0 60 ld [ %fp + 0x60 ], %o1
40011ce4: 94 10 20 20 mov 0x20, %o2
40011ce8: 40 00 29 5f call 4001c264 <memcpy>
40011cec: 90 10 00 18 mov %i0, %o0
bytes_written = fat_file_write(&fs_info->fat, fat_fd,
40011cf0: d8 04 60 c8 ld [ %l1 + 0xc8 ], %o4
40011cf4: 96 10 00 1b mov %i3, %o3
40011cf8: 94 10 00 12 mov %l2, %o2
40011cfc: 92 10 00 19 mov %i1, %o1
40011d00: 90 10 00 11 mov %l1, %o0
40011d04: 7f ff f8 b1 call 4000ffc8 <fat_file_write>
40011d08: b0 10 20 00 clr %i0
if (bytes_written == (ssize_t) length)
40011d0c: 80 a2 00 1a cmp %o0, %i2
40011d10: 02 bf fe 6c be 400116c0 <msdos_find_name_in_fat_file+0x8c> <== ALWAYS TAKEN
40011d14: 80 a2 3f ff cmp %o0, -1
else if (bytes_written == -1)
40011d18: 02 bf fe 79 be 400116fc <msdos_find_name_in_fat_file+0xc8> <== NOT EXECUTED
40011d1c: 01 00 00 00 nop <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
40011d20: 40 00 27 63 call 4001baac <__errno> <== NOT EXECUTED
40011d24: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff> <== NOT EXECUTED
40011d28: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
40011d2c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40011d30: 81 c7 e0 08 ret <== NOT EXECUTED
40011d34: 81 e8 00 00 restore <== NOT EXECUTED
empty_file_offset = fat_fd->fat_file_size -
40011d38: a4 24 80 1b sub %l2, %i3, %l2
if ((*c == ' ') || (*c == '.'))
40011d3c: c2 07 a0 60 ld [ %fp + 0x60 ], %g1
40011d40: c2 48 40 00 ldsb [ %g1 ], %g1
slot = (empty_file_offset /
40011d44: 89 34 a0 05 srl %l2, 5, %g4
if ((*c == ' ') || (*c == '.'))
40011d48: 80 a0 60 20 cmp %g1, 0x20
40011d4c: 02 80 00 8b be 40011f78 <msdos_find_name_in_fat_file+0x944> <== NEVER TAKEN
40011d50: 88 01 00 1a add %g4, %i2, %g4
40011d54: 80 a0 60 2e cmp %g1, 0x2e
40011d58: 02 80 00 89 be 40011f7c <msdos_find_name_in_fat_file+0x948> <== NEVER TAKEN
40011d5c: c4 07 a0 60 ld [ %fp + 0x60 ], %g2
40011d60: c2 07 a0 60 ld [ %fp + 0x60 ], %g1
40011d64: c2 48 60 01 ldsb [ %g1 + 1 ], %g1
40011d68: 80 a0 60 20 cmp %g1, 0x20
40011d6c: 02 80 00 89 be 40011f90 <msdos_find_name_in_fat_file+0x95c>
40011d70: 80 a0 60 2e cmp %g1, 0x2e
40011d74: 02 80 00 88 be 40011f94 <msdos_find_name_in_fat_file+0x960> <== NEVER TAKEN
40011d78: c4 07 a0 60 ld [ %fp + 0x60 ], %g2
for (i = 0; i < 2; i++, c++)
40011d7c: c2 07 a0 60 ld [ %fp + 0x60 ], %g1
40011d80: 86 00 60 02 add %g1, 2, %g3
for (i = 0; i < 4; i++, c++)
40011d84: 3b 10 00 9c sethi %hi(0x40027000), %i5
for (i = 0; i < 2; i++, c++)
40011d88: 82 10 20 0c mov 0xc, %g1
40011d8c: ba 17 60 18 or %i5, 0x18, %i5
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
40011d90: 85 31 00 01 srl %g4, %g1, %g2
40011d94: 84 08 a0 0f and %g2, 0xf, %g2
40011d98: c4 0f 40 02 ldub [ %i5 + %g2 ], %g2
40011d9c: c4 28 c0 00 stb %g2, [ %g3 ]
for (i = 0; i < 4; i++, c++)
40011da0: 82 00 7f fc add %g1, -4, %g1
40011da4: 80 a0 7f fc cmp %g1, -4
40011da8: 12 bf ff fa bne 40011d90 <msdos_find_name_in_fat_file+0x75c>
40011dac: 86 00 e0 01 inc %g3
*c++ = '~';
40011db0: c4 07 a0 60 ld [ %fp + 0x60 ], %g2
*c = '1';
40011db4: c6 07 a0 60 ld [ %fp + 0x60 ], %g3
*c++ = '~';
40011db8: 82 10 20 7e mov 0x7e, %g1
cs = 0;
40011dbc: ba 10 20 00 clr %i5
*c++ = '~';
40011dc0: c2 28 a0 06 stb %g1, [ %g2 + 6 ]
*c = '1';
40011dc4: 84 10 20 31 mov 0x31, %g2
for (i = 0; i < MSDOS_SHORT_NAME_LEN; ++i) {
40011dc8: 82 10 20 00 clr %g1
*c = '1';
40011dcc: c4 28 e0 07 stb %g2, [ %g3 + 7 ]
cs = 0;
40011dd0: 84 10 00 1d mov %i5, %g2
40011dd4: ba 10 00 03 mov %g3, %i5
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + name[i];
40011dd8: c8 0f 40 01 ldub [ %i5 + %g1 ], %g4
40011ddc: 84 08 a0 ff and %g2, 0xff, %g2
for (i = 0; i < MSDOS_SHORT_NAME_LEN; ++i) {
40011de0: 82 00 60 01 inc %g1
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + name[i];
40011de4: 87 28 a0 07 sll %g2, 7, %g3
for (i = 0; i < MSDOS_SHORT_NAME_LEN; ++i) {
40011de8: 80 a0 60 0b cmp %g1, 0xb
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + name[i];
40011dec: 85 30 a0 01 srl %g2, 1, %g2
40011df0: 84 00 80 04 add %g2, %g4, %g2
for (i = 0; i < MSDOS_SHORT_NAME_LEN; ++i) {
40011df4: 12 bf ff f9 bne 40011dd8 <msdos_find_name_in_fat_file+0x7a4>
40011df8: 84 00 c0 02 add %g3, %g2, %g2
pos->ofs = file_offset & (bts2rd - 1);
40011dfc: ba 10 00 02 mov %g2, %i5
40011e00: c4 07 a0 5c ld [ %fp + 0x5c ], %g2
40011e04: a0 04 3f ff add %l0, -1, %l0
40011e08: 82 0c 00 12 and %l0, %l2, %g1
40011e0c: c2 20 a0 0c st %g1, [ %g2 + 0xc ]
return fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
40011e10: 98 00 a0 08 add %g2, 8, %o4
40011e14: 96 10 00 12 mov %l2, %o3
40011e18: 94 10 20 01 mov 1, %o2
40011e1c: 92 10 00 19 mov %i1, %o1
40011e20: 7f ff f7 9d call 4000fc94 <fat_file_ioctl>
40011e24: 90 10 00 11 mov %l1, %o0
if (ret != RC_OK)
40011e28: b0 92 20 00 orcc %o0, 0, %i0
40011e2c: 12 bf fe 25 bne 400116c0 <msdos_find_name_in_fat_file+0x8c> <== NEVER TAKEN
40011e30: c4 07 a0 5c ld [ %fp + 0x5c ], %g2
* MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
40011e34: b1 2f 20 05 sll %i4, 5, %i0
short_file_offset = empty_file_offset + lfn_entries
40011e38: 96 06 00 12 add %i0, %l2, %o3
pos->ofs = file_offset & (bts2rd - 1);
40011e3c: 82 0a c0 10 and %o3, %l0, %g1
40011e40: c2 20 a0 04 st %g1, [ %g2 + 4 ]
return fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
40011e44: 98 10 00 02 mov %g2, %o4
40011e48: 94 10 20 01 mov 1, %o2
40011e4c: 92 10 00 19 mov %i1, %o1
40011e50: 7f ff f7 91 call 4000fc94 <fat_file_ioctl>
40011e54: 90 10 00 11 mov %l1, %o0
entry = fs_info->cl_buf;
40011e58: d8 04 60 c8 ld [ %l1 + 0xc8 ], %o4
40011e5c: c4 07 bf 4c ld [ %fp + -180 ], %g2
length = (lfn_entries + 1) * MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
40011e60: b7 2e a0 05 sll %i2, 5, %i3
40011e64: 82 5f 20 1a smul %i4, 0x1a, %g1
if (bytes_written == (ssize_t) length)
40011e68: b4 10 00 1b mov %i3, %i2
for (lfn_entry = 0; lfn_entry < lfn_entries; ++lfn_entry) {
40011e6c: 82 00 7f e6 add %g1, -26, %g1
40011e70: b0 03 00 18 add %o4, %i0, %i0
40011e74: a8 00 80 01 add %g2, %g1, %l4
40011e78: a0 10 20 00 clr %l0
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
40011e7c: 90 10 00 0c mov %o4, %o0
40011e80: 94 10 20 20 mov 0x20, %o2
40011e84: 40 00 29 37 call 4001c360 <memset>
40011e88: 92 10 20 00 clr %o1
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
40011e8c: fa 2a 20 0d stb %i5, [ %o0 + 0xd ]
n = (const uint8_t *) name_converted +
40011e90: 86 10 00 14 mov %l4, %g3
if (*n != 0 || *(n + 1) != 0)
40011e94: c8 08 c0 00 ldub [ %g3 ], %g4
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
40011e98: 98 10 00 08 mov %o0, %o4
p = entry + 1;
40011e9c: 82 02 20 01 add %o0, 1, %g1
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; ++i)
40011ea0: 84 10 20 00 clr %g2
if (*n != 0 || *(n + 1) != 0)
40011ea4: 80 89 20 ff btst 0xff, %g4
40011ea8: 12 80 00 17 bne 40011f04 <msdos_find_name_in_fat_file+0x8d0> <== ALWAYS TAKEN
40011eac: 9a 10 20 00 clr %o5
40011eb0: de 08 e0 01 ldub [ %g3 + 1 ], %o7 <== NOT EXECUTED
40011eb4: 80 a3 e0 00 cmp %o7, 0
40011eb8: 32 80 00 14 bne,a 40011f08 <msdos_find_name_in_fat_file+0x8d4>
40011ebc: c8 28 40 00 stb %g4, [ %g1 ]
p [0] = fill;
40011ec0: da 28 40 00 stb %o5, [ %g1 ]
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; ++i)
40011ec4: 88 00 a0 01 add %g2, 1, %g4
p [1] = fill;
40011ec8: da 28 60 01 stb %o5, [ %g1 + 1 ]
switch (i)
40011ecc: 80 a0 a0 04 cmp %g2, 4
40011ed0: 02 80 00 14 be 40011f20 <msdos_find_name_in_fat_file+0x8ec>
40011ed4: 9a 10 3f ff mov -1, %o5
40011ed8: 80 a0 a0 0a cmp %g2, 0xa
40011edc: 22 80 00 2b be,a 40011f88 <msdos_find_name_in_fat_file+0x954>
40011ee0: 82 00 60 04 add %g1, 4, %g1
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; ++i)
40011ee4: 80 a1 20 0d cmp %g4, 0xd
40011ee8: 02 80 00 11 be 40011f2c <msdos_find_name_in_fat_file+0x8f8>
40011eec: 82 00 60 02 add %g1, 2, %g1
40011ef0: 84 10 00 04 mov %g4, %g2
if (*n != 0 || *(n + 1) != 0)
40011ef4: c8 08 c0 00 ldub [ %g3 ], %g4
40011ef8: 80 89 20 ff btst 0xff, %g4
40011efc: 22 bf ff ee be,a 40011eb4 <msdos_find_name_in_fat_file+0x880>
40011f00: de 08 e0 01 ldub [ %g3 + 1 ], %o7
*p = *n;
40011f04: c8 28 40 00 stb %g4, [ %g1 ]
n += MSDOS_NAME_LFN_BYTES_PER_CHAR;
40011f08: 86 00 e0 02 add %g3, 2, %g3
*(p + 1) = *(n + 1);
40011f0c: c8 08 ff ff ldub [ %g3 + -1 ], %g4
40011f10: c8 28 60 01 stb %g4, [ %g1 + 1 ]
switch (i)
40011f14: 80 a0 a0 04 cmp %g2, 4
40011f18: 12 bf ff f0 bne 40011ed8 <msdos_find_name_in_fat_file+0x8a4>
40011f1c: 88 00 a0 01 add %g2, 1, %g4
p += 5;
40011f20: 82 00 60 05 add %g1, 5, %g1
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; ++i)
40011f24: 10 bf ff f4 b 40011ef4 <msdos_find_name_in_fat_file+0x8c0>
40011f28: 84 10 00 04 mov %g4, %g2
if (lfn_entry == 0)
40011f2c: 80 a4 20 00 cmp %l0, 0
40011f30: 12 80 00 03 bne 40011f3c <msdos_find_name_in_fat_file+0x908>
40011f34: 82 27 00 10 sub %i4, %l0, %g1
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
40011f38: 82 10 60 40 or %g1, 0x40, %g1
40011f3c: c2 2b 00 00 stb %g1, [ %o4 ]
for (lfn_entry = 0; lfn_entry < lfn_entries; ++lfn_entry) {
40011f40: a0 04 20 01 inc %l0
*MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;
40011f44: c2 0b 20 0b ldub [ %o4 + 0xb ], %g1
40011f48: 82 10 60 0f or %g1, 0xf, %g1
40011f4c: c2 2b 20 0b stb %g1, [ %o4 + 0xb ]
entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
40011f50: 98 03 20 20 add %o4, 0x20, %o4
for (lfn_entry = 0; lfn_entry < lfn_entries; ++lfn_entry) {
40011f54: 80 a3 00 18 cmp %o4, %i0
40011f58: 12 bf ff c9 bne 40011e7c <msdos_find_name_in_fat_file+0x848>
40011f5c: a8 05 3f e6 add %l4, -26, %l4
40011f60: 10 bf ff 61 b 40011ce4 <msdos_find_name_in_fat_file+0x6b0>
40011f64: d2 07 a0 60 ld [ %fp + 0x60 ], %o1
rc = MSDOS_NAME_NOT_FOUND_ERR;
40011f68: 31 00 00 1f sethi %hi(0x7c00), %i0
40011f6c: b0 16 21 01 or %i0, 0x101, %i0 ! 7d01 <_ISR_Stack_size+0x6d01>
if ( retval == RC_OK
40011f70: 81 c7 e0 08 ret
40011f74: 81 e8 00 00 restore
*c = '_';
40011f78: c4 07 a0 60 ld [ %fp + 0x60 ], %g2 <== NOT EXECUTED
40011f7c: 82 10 20 5f mov 0x5f, %g1 <== NOT EXECUTED
40011f80: 10 bf ff 78 b 40011d60 <msdos_find_name_in_fat_file+0x72c> <== NOT EXECUTED
40011f84: c2 28 80 00 stb %g1, [ %g2 ] <== NOT EXECUTED
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; ++i)
40011f88: 10 bf ff db b 40011ef4 <msdos_find_name_in_fat_file+0x8c0>
40011f8c: 84 10 00 04 mov %g4, %g2
*c = '_';
40011f90: c4 07 a0 60 ld [ %fp + 0x60 ], %g2
40011f94: 82 10 20 5f mov 0x5f, %g1
40011f98: 10 bf ff 79 b 40011d7c <msdos_find_name_in_fat_file+0x748>
40011f9c: c2 28 a0 01 stb %g1, [ %g2 + 1 ]
eno = EINVAL;
40011fa0: 10 bf fe 68 b 40011940 <msdos_find_name_in_fat_file+0x30c> <== NOT EXECUTED
40011fa4: b4 10 20 16 mov 0x16, %i2 <== NOT EXECUTED
ret = fat_file_extend(&fs_info->fat,
40011fa8: d6 04 60 08 ld [ %l1 + 8 ], %o3
40011fac: 98 07 bf 90 add %fp, -112, %o4
40011fb0: 96 04 80 0b add %l2, %o3, %o3
40011fb4: 94 10 20 01 mov 1, %o2
40011fb8: 92 10 00 19 mov %i1, %o1
40011fbc: 7f ff f7 6b call 4000fd68 <fat_file_extend>
40011fc0: 90 10 00 11 mov %l1, %o0
if (ret != RC_OK)
40011fc4: b0 92 20 00 orcc %o0, 0, %i0
40011fc8: 02 bf ff 37 be 40011ca4 <msdos_find_name_in_fat_file+0x670> <== NEVER TAKEN
40011fcc: c6 07 a0 5c ld [ %fp + 0x5c ], %g3
40011fd0: 81 c7 e0 08 ret
40011fd4: 81 e8 00 00 restore
assert(name_utf8_len > 0);
40011fd8: 17 10 00 9b sethi %hi(0x40026c00), %o3 <== NOT EXECUTED
40011fdc: 15 10 00 9c sethi %hi(0x40027000), %o2 <== NOT EXECUTED
40011fe0: 11 10 00 9b sethi %hi(0x40026c00), %o0 <== NOT EXECUTED
40011fe4: 96 12 e3 e8 or %o3, 0x3e8, %o3 <== NOT EXECUTED
40011fe8: 94 12 a0 90 or %o2, 0x90, %o2 <== NOT EXECUTED
40011fec: 92 10 27 46 mov 0x746, %o1 <== NOT EXECUTED
40011ff0: 40 00 15 0d call 40017424 <__assert_func> <== NOT EXECUTED
40011ff4: 90 12 23 98 or %o0, 0x398, %o0 <== NOT EXECUTED
if ( retval == RC_OK
40011ff8: 80 a0 00 18 cmp %g0, %i0
40011ffc: 82 60 3f ff subx %g0, -1, %g1
&& create_node) {
40012000: 10 bf fe e4 b 40011b90 <msdos_find_name_in_fat_file+0x55c>
40012004: 82 0e 80 01 and %i2, %g1, %g1
assert(bytes_read == bts2rd);
40012008: 17 10 00 9c sethi %hi(0x40027000), %o3 <== NOT EXECUTED
4001200c: 15 10 00 9c sethi %hi(0x40027000), %o2 <== NOT EXECUTED
40012010: 11 10 00 9b sethi %hi(0x40026c00), %o0 <== NOT EXECUTED
40012014: 96 12 e0 00 mov %o3, %o3 <== NOT EXECUTED
40012018: 94 12 a0 70 or %o2, 0x70, %o2 <== NOT EXECUTED
4001201c: 92 10 25 4d mov 0x54d, %o1 <== NOT EXECUTED
40012020: 40 00 15 01 call 40017424 <__assert_func> <== NOT EXECUTED
40012024: 90 12 23 98 or %o0, 0x398, %o0 <== NOT EXECUTED
40012028: 01 00 00 00 nop <== NOT EXECUTED
4001202c <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
)
{
4001202c: 9d e3 bf a0 save %sp, -96, %sp
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t bts2rd = 0;
uint32_t i = 0, j = 0;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
40012030: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
40012034: 80 a0 60 01 cmp %g1, 1
40012038: 02 80 00 34 be 40012108 <msdos_find_node_by_cluster_num_in_fat_file+0xdc>
4001203c: f0 06 20 08 ld [ %i0 + 8 ], %i0
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
else
bts2rd = fs_info->fat.vol.bpc;
40012040: e2 06 20 08 ld [ %i0 + 8 ], %l1
while ((ret = fat_file_read(&fs_info->fat, fat_fd, j * bts2rd, bts2rd,
40012044: d8 06 20 c8 ld [ %i0 + 0xc8 ], %o4
40012048: a4 10 20 00 clr %l2
4001204c: 96 10 00 11 mov %l1, %o3
40012050: 94 10 00 12 mov %l2, %o2
40012054: 92 10 00 19 mov %i1, %o1
40012058: 7f ff f6 20 call 4000f8d8 <fat_file_read>
4001205c: 90 10 00 18 mov %i0, %o0
40012060: 80 a2 20 00 cmp %o0, 0
40012064: 02 80 00 25 be 400120f8 <msdos_find_node_by_cluster_num_in_fat_file+0xcc><== NEVER TAKEN
40012068: 80 a2 20 1f cmp %o0, 0x1f
fs_info->cl_buf)) != FAT_EOF)
{
if ( ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE )
4001206c: 04 80 00 42 ble 40012174 <msdos_find_node_by_cluster_num_in_fat_file+0x148><== NEVER TAKEN
40012070: 80 a2 00 11 cmp %o0, %l1
rtems_set_errno_and_return_minus_one( EIO );
assert(ret == bts2rd);
40012074: 12 80 00 46 bne 4001218c <msdos_find_node_by_cluster_num_in_fat_file+0x160><== NEVER TAKEN
40012078: a0 10 20 00 clr %l0
for (i = 0; i < bts2rd; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + i;
4001207c: d8 06 20 c8 ld [ %i0 + 0xc8 ], %o4
40012080: ba 10 00 0c mov %o4, %i5
/* if this and all rest entries are empty - return not-found */
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
40012084: c2 0f 40 00 ldub [ %i5 ], %g1
40012088: 80 a0 60 00 cmp %g1, 0
4001208c: 02 80 00 1b be 400120f8 <msdos_find_node_by_cluster_num_in_fat_file+0xcc><== NEVER TAKEN
40012090: 80 a0 60 e5 cmp %g1, 0xe5
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)) ==
40012094: 22 80 00 14 be,a 400120e4 <msdos_find_node_by_cluster_num_in_fat_file+0xb8><== NEVER TAKEN
40012098: a0 04 20 20 add %l0, 0x20, %l0 <== NOT EXECUTED
MSDOS_THIS_DIR_ENTRY_EMPTY)
continue;
/* if get a non-empty entry - compare clusters num */
if (MSDOS_EXTRACT_CLUSTER_NUM(entry) == cl4find)
4001209c: c2 17 60 1a lduh [ %i5 + 0x1a ], %g1
400120a0: c6 17 60 14 lduh [ %i5 + 0x14 ], %g3
400120a4: 85 28 60 08 sll %g1, 8, %g2
400120a8: 89 28 60 10 sll %g1, 0x10, %g4
400120ac: 83 28 e0 08 sll %g3, 8, %g1
400120b0: 89 31 20 18 srl %g4, 0x18, %g4
400120b4: 87 28 e0 10 sll %g3, 0x10, %g3
400120b8: 84 10 80 04 or %g2, %g4, %g2
400120bc: 87 30 e0 18 srl %g3, 0x18, %g3
400120c0: 85 28 a0 10 sll %g2, 0x10, %g2
400120c4: 82 10 40 03 or %g1, %g3, %g1
400120c8: 85 30 a0 10 srl %g2, 0x10, %g2
400120cc: 83 28 60 10 sll %g1, 0x10, %g1
400120d0: 82 10 40 02 or %g1, %g2, %g1
400120d4: 80 a0 40 1a cmp %g1, %i2
400120d8: 22 80 00 16 be,a 40012130 <msdos_find_node_by_cluster_num_in_fat_file+0x104>
400120dc: 90 10 00 18 mov %i0, %o0
for (i = 0; i < bts2rd; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
400120e0: a0 04 20 20 add %l0, 0x20, %l0
400120e4: 80 a4 00 11 cmp %l0, %l1
400120e8: 0a bf ff e7 bcs 40012084 <msdos_find_node_by_cluster_num_in_fat_file+0x58><== ALWAYS TAKEN
400120ec: ba 07 60 20 add %i5, 0x20, %i5
memcpy(dir_entry, entry,
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
return RC_OK;
}
}
j++;
400120f0: 10 bf ff d7 b 4001204c <msdos_find_node_by_cluster_num_in_fat_file+0x20> <== NOT EXECUTED
400120f4: a4 04 80 11 add %l2, %l1, %l2 <== NOT EXECUTED
return MSDOS_NAME_NOT_FOUND_ERR;
400120f8: 31 00 00 1f sethi %hi(0x7c00), %i0 <== NOT EXECUTED
400120fc: b0 16 21 01 or %i0, 0x101, %i0 ! 7d01 <_ISR_Stack_size+0x6d01> <== NOT EXECUTED
}
return MSDOS_NAME_NOT_FOUND_ERR;
}
40012100: 81 c7 e0 08 ret <== NOT EXECUTED
40012104: 81 e8 00 00 restore <== NOT EXECUTED
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
40012108: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
4001210c: 80 a0 60 00 cmp %g1, 0
40012110: 32 bf ff cd bne,a 40012044 <msdos_find_node_by_cluster_num_in_fat_file+0x18><== NEVER TAKEN
40012114: e2 06 20 08 ld [ %i0 + 8 ], %l1 <== NOT EXECUTED
40012118: c2 0e 20 16 ldub [ %i0 + 0x16 ], %g1
4001211c: 80 88 60 03 btst 3, %g1
40012120: 22 bf ff c9 be,a 40012044 <msdos_find_node_by_cluster_num_in_fat_file+0x18><== NEVER TAKEN
40012124: e2 06 20 08 ld [ %i0 + 8 ], %l1 <== NOT EXECUTED
bts2rd = fat_fd->fat_file_size;
40012128: 10 bf ff c7 b 40012044 <msdos_find_node_by_cluster_num_in_fat_file+0x18>
4001212c: e2 06 60 18 ld [ %i1 + 0x18 ], %l1
rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM, j * bts2rd,
40012130: 98 10 00 1b mov %i3, %o4
40012134: 96 10 00 12 mov %l2, %o3
40012138: 94 10 20 01 mov 1, %o2
4001213c: 7f ff f6 d6 call 4000fc94 <fat_file_ioctl>
40012140: 92 10 00 19 mov %i1, %o1
if (rc != RC_OK)
40012144: b0 92 20 00 orcc %o0, 0, %i0
40012148: 12 bf ff ee bne 40012100 <msdos_find_node_by_cluster_num_in_fat_file+0xd4><== NEVER TAKEN
4001214c: 82 10 3f ff mov -1, %g1
dir_pos->sname.ofs = i;
40012150: e0 26 e0 04 st %l0, [ %i3 + 4 ]
memcpy(dir_entry, entry,
40012154: 94 10 20 20 mov 0x20, %o2
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
40012158: c2 26 e0 08 st %g1, [ %i3 + 8 ]
memcpy(dir_entry, entry,
4001215c: 92 10 00 1d mov %i5, %o1
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
40012160: c2 26 e0 0c st %g1, [ %i3 + 0xc ]
memcpy(dir_entry, entry,
40012164: 40 00 28 40 call 4001c264 <memcpy>
40012168: 90 10 00 1c mov %i4, %o0
return RC_OK;
4001216c: 81 c7 e0 08 ret
40012170: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( EIO );
40012174: 40 00 26 4e call 4001baac <__errno> <== NOT EXECUTED
40012178: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001217c: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
40012180: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40012184: 81 c7 e0 08 ret <== NOT EXECUTED
40012188: 81 e8 00 00 restore <== NOT EXECUTED
assert(ret == bts2rd);
4001218c: 17 10 00 9c sethi %hi(0x40027000), %o3 <== NOT EXECUTED
40012190: 15 10 00 9c sethi %hi(0x40027000), %o2 <== NOT EXECUTED
40012194: 11 10 00 9b sethi %hi(0x40026c00), %o0 <== NOT EXECUTED
40012198: 96 12 e0 30 or %o3, 0x30, %o3 <== NOT EXECUTED
4001219c: 94 12 a0 40 or %o2, 0x40, %o2 <== NOT EXECUTED
400121a0: 92 10 27 f1 mov 0x7f1, %o1 <== NOT EXECUTED
400121a4: 40 00 14 a0 call 40017424 <__assert_func> <== NOT EXECUTED
400121a8: 90 12 23 98 or %o0, 0x398, %o0 <== NOT EXECUTED
400121ac: 01 00 00 00 nop <== NOT EXECUTED
40004844 <msdos_format>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
40004844: 9d e3 be b0 save %sp, -336, %sp
memset(&fmt_params, 0, sizeof(fmt_params));
/*
* open device for writing
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "open device\n");
40004848: 92 10 20 02 mov 2, %o1
4000484c: 90 10 00 19 mov %i1, %o0
memset(&fmt_params, 0, sizeof(fmt_params));
40004850: c0 27 bf 40 clr [ %fp + -192 ]
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "open device\n");
40004854: 15 10 00 9a sethi %hi(0x40026800), %o2
memset(&fmt_params, 0, sizeof(fmt_params));
40004858: c0 27 bf 44 clr [ %fp + -188 ]
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "open device\n");
4000485c: 94 12 a1 f8 or %o2, 0x1f8, %o2
memset(&fmt_params, 0, sizeof(fmt_params));
40004860: c0 27 bf 48 clr [ %fp + -184 ]
40004864: c0 27 bf 4c clr [ %fp + -180 ]
40004868: c0 27 bf 50 clr [ %fp + -176 ]
4000486c: c0 27 bf 54 clr [ %fp + -172 ]
40004870: c0 27 bf 58 clr [ %fp + -168 ]
40004874: c0 27 bf 5c clr [ %fp + -164 ]
40004878: c0 27 bf 60 clr [ %fp + -160 ]
4000487c: c0 27 bf 64 clr [ %fp + -156 ]
40004880: c0 27 bf 68 clr [ %fp + -152 ]
40004884: c0 27 bf 6c clr [ %fp + -148 ]
40004888: c0 27 bf 70 clr [ %fp + -144 ]
4000488c: c0 27 bf 74 clr [ %fp + -140 ]
40004890: c0 27 bf 78 clr [ %fp + -136 ]
40004894: c0 27 bf 7c clr [ %fp + -132 ]
40004898: c0 27 bf 80 clr [ %fp + -128 ]
4000489c: c0 27 bf 84 clr [ %fp + -124 ]
400048a0: c0 27 bf 88 clr [ %fp + -120 ]
400048a4: c0 27 bf 8c clr [ %fp + -116 ]
400048a8: c0 27 bf 90 clr [ %fp + -112 ]
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "open device\n");
400048ac: 7f ff ff 4d call 400045e0 <msdos_format_printf>
400048b0: c0 27 bf 94 clr [ %fp + -108 ]
fd = open(devname, O_RDWR);
400048b4: 92 10 20 02 mov 2, %o1
400048b8: 7f ff f9 da call 40003020 <open>
400048bc: 90 10 00 18 mov %i0, %o0
if (fd == -1) {
400048c0: 80 a2 3f ff cmp %o0, -1
400048c4: 02 80 01 b5 be 40004f98 <msdos_format+0x754> <== NEVER TAKEN
400048c8: b4 10 00 08 mov %o0, %i2
}
/*
* sanity check on device
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
400048cc: 96 10 00 18 mov %i0, %o3
400048d0: 92 10 20 02 mov 2, %o1
400048d4: 90 10 00 19 mov %i1, %o0
400048d8: 15 10 00 9a sethi %hi(0x40026800), %o2
400048dc: 7f ff ff 41 call 400045e0 <msdos_format_printf>
400048e0: 94 12 a2 08 or %o2, 0x208, %o2 ! 40026a08 <rtems_filesystem_null_handlers+0xa8>
"stat check: %s\n", devname);
if (ret_val == 0) {
ret_val = fstat(fd, &stat_buf);
400048e4: 92 07 bf 98 add %fp, -104, %o1
400048e8: 7f ff f7 48 call 40002608 <fstat>
400048ec: 90 10 00 1a mov %i2, %o0
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
400048f0: 96 10 00 18 mov %i0, %o3
400048f4: 92 10 20 01 mov 1, %o1
ret_val = fstat(fd, &stat_buf);
400048f8: b0 10 00 08 mov %o0, %i0
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
400048fc: 15 10 00 9a sethi %hi(0x40026800), %o2
40004900: 90 10 00 19 mov %i1, %o0
40004904: 7f ff ff 37 call 400045e0 <msdos_format_printf>
40004908: 94 12 a2 18 or %o2, 0x218, %o2
"formating: %s\n", devname);
/* rtems feature: no block devices, all are character devices */
if ((ret_val == 0) && (!S_ISBLK(stat_buf.st_mode))) {
4000490c: 80 a6 20 00 cmp %i0, 0
40004910: 12 80 01 9c bne 40004f80 <msdos_format+0x73c> <== NEVER TAKEN
40004914: 05 00 00 3c sethi %hi(0xf000), %g2
40004918: c2 07 bf a8 ld [ %fp + -88 ], %g1
4000491c: 82 08 40 02 and %g1, %g2, %g1
40004920: 05 00 00 18 sethi %hi(0x6000), %g2
40004924: 80 a0 40 02 cmp %g1, %g2
40004928: 12 80 01 92 bne 40004f70 <msdos_format+0x72c> <== NEVER TAKEN
4000492c: 94 07 bf 40 add %fp, -192, %o2
memset(fmt_params,0,sizeof(*fmt_params));
40004930: c0 27 bf 40 clr [ %fp + -192 ]
40004934: c0 27 bf 44 clr [ %fp + -188 ]
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);
40004938: 3b 10 01 10 sethi %hi(0x40044000), %i5
4000493c: c0 27 bf 48 clr [ %fp + -184 ]
40004940: 90 10 00 1a mov %i2, %o0
40004944: c0 27 bf 4c clr [ %fp + -180 ]
40004948: 92 17 62 02 or %i5, 0x202, %o1
4000494c: c0 27 bf 50 clr [ %fp + -176 ]
40004950: c0 27 bf 54 clr [ %fp + -172 ]
40004954: c0 27 bf 58 clr [ %fp + -168 ]
40004958: c0 27 bf 5c clr [ %fp + -164 ]
4000495c: c0 27 bf 60 clr [ %fp + -160 ]
40004960: c0 27 bf 64 clr [ %fp + -156 ]
40004964: c0 27 bf 68 clr [ %fp + -152 ]
40004968: c0 27 bf 6c clr [ %fp + -148 ]
4000496c: c0 27 bf 70 clr [ %fp + -144 ]
40004970: c0 27 bf 74 clr [ %fp + -140 ]
40004974: c0 27 bf 78 clr [ %fp + -136 ]
40004978: c0 27 bf 7c clr [ %fp + -132 ]
4000497c: c0 27 bf 80 clr [ %fp + -128 ]
40004980: c0 27 bf 84 clr [ %fp + -124 ]
40004984: c0 27 bf 88 clr [ %fp + -120 ]
40004988: c0 27 bf 8c clr [ %fp + -116 ]
4000498c: c0 27 bf 90 clr [ %fp + -112 ]
40004990: 40 00 21 77 call 4000cf6c <ioctl>
40004994: c0 27 bf 94 clr [ %fp + -108 ]
if (ret_val == 0) {
40004998: b0 92 20 00 orcc %o0, 0, %i0
4000499c: 02 80 01 90 be 40004fdc <msdos_format+0x798> <== ALWAYS TAKEN
400049a0: c4 07 bf 44 ld [ %fp + -188 ], %g2
if ( fmt_params->totl_sector_cnt == 0 )
400049a4: 80 a0 a0 00 cmp %g2, 0
400049a8: 12 80 00 07 bne 400049c4 <msdos_format+0x180> <== ALWAYS TAKEN
400049ac: fa 07 bf 48 ld [ %fp + -184 ], %i5
errno = EINVAL;
400049b0: 40 00 5c 3f call 4001baac <__errno>
400049b4: b0 10 3f ff mov -1, %i0
400049b8: 82 10 20 16 mov 0x16, %g1
400049bc: c2 22 00 00 st %g1, [ %o0 ]
fmt_params->rsvd_sector_cnt
400049c0: fa 07 bf 48 ld [ %fp + -184 ], %i5
+ (fmt_params-> fat_num*fmt_params->sectors_per_fat);
400049c4: c2 0f bf 70 ldub [ %fp + -144 ], %g1
400049c8: c6 07 bf 50 ld [ %fp + -176 ], %g3
400049cc: 82 58 40 03 smul %g1, %g3, %g1
400049d0: 82 00 40 1d add %g1, %i5, %g1
fmt_params->root_dir_start_sec =
400049d4: c2 27 bf 60 st %g1, [ %fp + -160 ]
if (fmt_params->root_dir_sectors > 0) {
400049d8: c4 07 bf 5c ld [ %fp + -164 ], %g2
400049dc: 80 a0 a0 00 cmp %g2, 0
400049e0: 32 80 00 04 bne,a 400049f0 <msdos_format+0x1ac>
400049e4: c4 27 bf 64 st %g2, [ %fp + -156 ]
fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
400049e8: c2 07 bf 4c ld [ %fp + -180 ], %g1
400049ec: c2 27 bf 64 st %g1, [ %fp + -156 ]
if (ret_val == 0) {
400049f0: 80 a6 20 00 cmp %i0, 0
400049f4: 12 80 01 63 bne 40004f80 <msdos_format+0x73c>
400049f8: 80 a6 60 00 cmp %i1, 0
if ((rqdata != NULL) && (rqdata->OEMName != NULL)) {
400049fc: 02 80 02 a6 be 40005494 <msdos_format+0xc50>
40004a00: 07 10 00 9a sethi %hi(0x40026800), %g3
40004a04: c6 06 40 00 ld [ %i1 ], %g3
40004a08: 80 a0 e0 00 cmp %g3, 0
40004a0c: 22 80 02 a2 be,a 40005494 <msdos_format+0xc50>
40004a10: 07 10 00 9a sethi %hi(0x40026800), %g3
if (isprint((unsigned char)*from)) {
40004a14: c4 08 c0 00 ldub [ %g3 ], %g2
40004a18: 3b 10 00 9d sethi %hi(0x40027400), %i5
from = "RTEMS"; /* default: make "from" point to OS Name */
40004a1c: 82 07 bf 73 add %fp, -141, %g1
40004a20: ba 17 61 61 or %i5, 0x161, %i5
40004a24: 10 80 00 08 b 40004a44 <msdos_format+0x200>
40004a28: b8 07 bf 7b add %fp, -133, %i4
40004a2c: c4 28 7f ff stb %g2, [ %g1 + -1 ]
*to++ = *from++;
40004a30: 86 00 e0 01 inc %g3
for (cnt = 0; cnt < (sizeof(fmt_params->OEMName)-1); cnt++) {
40004a34: 80 a0 40 1c cmp %g1, %i4
40004a38: 02 80 00 0d be 40004a6c <msdos_format+0x228> <== NEVER TAKEN
40004a3c: c0 28 40 00 clrb [ %g1 ]
if (isprint((unsigned char)*from)) {
40004a40: c4 08 c0 00 ldub [ %g3 ], %g2
40004a44: 88 08 a0 ff and %g2, 0xff, %g4
40004a48: c8 4f 40 04 ldsb [ %i5 + %g4 ], %g4
40004a4c: 80 89 20 97 btst 0x97, %g4
40004a50: 12 bf ff f7 bne 40004a2c <msdos_format+0x1e8>
40004a54: 82 00 60 01 inc %g1
*to++=' ';
40004a58: 84 10 20 20 mov 0x20, %g2
*to = '\0';
40004a5c: c0 28 40 00 clrb [ %g1 ]
for (cnt = 0; cnt < (sizeof(fmt_params->OEMName)-1); cnt++) {
40004a60: 80 a0 40 1c cmp %g1, %i4
40004a64: 12 bf ff f7 bne 40004a40 <msdos_format+0x1fc>
40004a68: c4 28 7f ff stb %g2, [ %g1 + -1 ]
if ((rqdata != NULL) &&
40004a6c: 80 a6 60 00 cmp %i1, 0
40004a70: 02 80 02 86 be 40005488 <msdos_format+0xc44>
40004a74: 07 10 00 9a sethi %hi(0x40026800), %g3
(rqdata->VolLabel != NULL)) {
40004a78: c6 06 60 04 ld [ %i1 + 4 ], %g3
if ((rqdata != NULL) &&
40004a7c: 80 a0 e0 00 cmp %g3, 0
40004a80: 22 80 02 82 be,a 40005488 <msdos_format+0xc44>
40004a84: 07 10 00 9a sethi %hi(0x40026800), %g3
fmt_params->VolLabel_present = true;
40004a88: 82 10 20 01 mov 1, %g1
40004a8c: c2 2f bf 88 stb %g1, [ %fp + -120 ]
if (isprint((unsigned char)*from)) {
40004a90: c4 08 c0 00 ldub [ %g3 ], %g2
40004a94: b8 07 bf 87 add %fp, -121, %i4
from = ""; /* default: make "from" point to empty string */
40004a98: 10 80 00 08 b 40004ab8 <msdos_format+0x274>
40004a9c: 82 07 bf 7c add %fp, -132, %g1
40004aa0: c4 28 7f ff stb %g2, [ %g1 + -1 ]
*to++ = *from++;
40004aa4: 86 00 e0 01 inc %g3
for (cnt = 0; cnt < (sizeof(fmt_params->VolLabel)-1); cnt++) {
40004aa8: 80 a0 40 1c cmp %g1, %i4
40004aac: 02 80 00 0d be 40004ae0 <msdos_format+0x29c> <== NEVER TAKEN
40004ab0: c0 28 40 00 clrb [ %g1 ]
if (isprint((unsigned char)*from)) {
40004ab4: c4 08 c0 00 ldub [ %g3 ], %g2
40004ab8: 88 08 a0 ff and %g2, 0xff, %g4
40004abc: c8 4f 40 04 ldsb [ %i5 + %g4 ], %g4
40004ac0: 80 89 20 97 btst 0x97, %g4
40004ac4: 12 bf ff f7 bne 40004aa0 <msdos_format+0x25c>
40004ac8: 82 00 60 01 inc %g1
*to++=' ';
40004acc: 84 10 20 20 mov 0x20, %g2
*to = '\0';
40004ad0: c0 28 40 00 clrb [ %g1 ]
for (cnt = 0; cnt < (sizeof(fmt_params->VolLabel)-1); cnt++) {
40004ad4: 80 a0 40 1c cmp %g1, %i4
40004ad8: 12 bf ff f7 bne 40004ab4 <msdos_format+0x270>
40004adc: c4 28 7f ff stb %g2, [ %g1 + -1 ]
rc = rtems_clock_get_tod_timeval(&time_value);
40004ae0: 40 00 0b 57 call 4000783c <rtems_clock_get_tod_timeval>
40004ae4: 90 07 bf 30 add %fp, -208, %o0
if (rc == RTEMS_SUCCESSFUL) {
40004ae8: 80 a2 20 00 cmp %o0, 0
40004aec: 12 80 03 e2 bne 40005a74 <msdos_format+0x1230> <== ALWAYS TAKEN
40004af0: c2 07 bf 34 ld [ %fp + -204 ], %g1
*volid_ptr = time_value.tv_sec + time_value.tv_sec;
40004af4: 83 28 60 01 sll %g1, 1, %g1 <== NOT EXECUTED
40004af8: c2 27 bf 8c st %g1, [ %fp + -116 ] <== NOT EXECUTED
if (ret_val == 0) {
ret_val = msdos_format_determine_fmt_params(fd,rqdata,&fmt_params);
}
if (ret_val == 0) {
fmt_params.sec = malloc(fmt_params.bytes_per_sector);
40004afc: 7f ff f7 6d call 400028b0 <malloc>
40004b00: d0 07 bf 40 ld [ %fp + -192 ], %o0
if (fmt_params.sec == NULL) {
40004b04: 80 a2 20 00 cmp %o0, 0
40004b08: 02 80 02 52 be 40005450 <msdos_format+0xc0c> <== NEVER TAKEN
40004b0c: d0 27 bf 94 st %o0, [ %fp + -108 ]
}
/*
* if requested, write whole disk/partition with 0xe5
*/
if ((ret_val == 0) &&
40004b10: 80 a6 60 00 cmp %i1, 0
40004b14: 12 80 02 0e bne 4000534c <msdos_format+0xb08>
40004b18: a0 10 20 00 clr %l0
*/
if (ret_val == 0) {
/*
* Read the current MBR to obtain the partition table.
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
40004b1c: 92 10 20 02 mov 2, %o1
40004b20: 90 10 00 19 mov %i1, %o0
40004b24: 15 10 00 9a sethi %hi(0x40026800), %o2
40004b28: 7f ff fe ae call 400045e0 <msdos_format_printf>
40004b2c: 94 12 a2 a0 or %o2, 0x2a0, %o2 ! 40026aa0 <rtems_filesystem_null_handlers+0x140>
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
40004b30: 96 10 20 00 clr %o3
"read MRB sector\n");
ret_val = msdos_format_read_sec(fd,
40004b34: f8 07 bf 40 ld [ %fp + -192 ], %i4
40004b38: fa 07 bf 94 ld [ %fp + -108 ], %i5
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
40004b3c: 92 10 20 00 clr %o1
40004b40: 94 10 20 00 clr %o2
40004b44: 40 00 21 45 call 4000d058 <lseek>
40004b48: 90 10 00 1a mov %i2, %o0
40004b4c: 80 a2 20 00 cmp %o0, 0
40004b50: 06 80 02 40 bl 40005450 <msdos_format+0xc0c> <== NEVER TAKEN
40004b54: 94 10 00 1c mov %i4, %o2
if (0 > read(fd,buffer,sector_size)) {
40004b58: 92 10 00 1d mov %i5, %o1
40004b5c: 40 00 21 cf call 4000d298 <read>
40004b60: 90 10 00 1a mov %i2, %o0
40004b64: 80 a2 20 00 cmp %o0, 0
40004b68: 06 80 02 3a bl 40005450 <msdos_format+0xc0c> <== NEVER TAKEN
40004b6c: 92 10 20 02 mov 2, %o1
0,
fmt_params.bytes_per_sector,
fmt_params.sec);
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
40004b70: 15 10 00 9a sethi %hi(0x40026800), %o2
40004b74: 90 10 00 19 mov %i1, %o0
40004b78: 7f ff fe 9a call 400045e0 <msdos_format_printf>
40004b7c: 94 12 a2 b8 or %o2, 0x2b8, %o2
if (fmt_params->totl_sector_cnt < 0x10000) {
40004b80: c2 07 bf 44 ld [ %fp + -188 ], %g1
40004b84: 05 00 00 3f sethi %hi(0xfc00), %g2
40004b88: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff <_ISR_Stack_size+0xefff>
40004b8c: 80 a0 40 02 cmp %g1, %g2
40004b90: 08 80 02 32 bleu 40005458 <msdos_format+0xc14>
40004b94: b1 30 60 08 srl %g1, 8, %i0
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
40004b98: a5 30 60 08 srl %g1, 8, %l2
40004b9c: b7 30 60 10 srl %g1, 0x10, %i3
40004ba0: a6 10 00 01 mov %g1, %l3
40004ba4: a3 30 60 18 srl %g1, 0x18, %l1
40004ba8: b0 10 20 00 clr %i0
40004bac: b8 10 20 00 clr %i4
"generate MRB sector\n");
ret_val = msdos_format_gen_mbr(fmt_params.sec,&fmt_params);
40004bb0: fa 07 bf 94 ld [ %fp + -108 ], %i5
memset(mbr,0,RTEMS_IDE_PARTITION_TABLE_OFFSET);
40004bb4: 94 10 21 be mov 0x1be, %o2
40004bb8: 92 10 20 00 clr %o1
40004bbc: 40 00 5d e9 call 4001c360 <memset>
40004bc0: 90 10 00 1d mov %i5, %o0
memset(mbr + RTEMS_IDE_PARTITION_TABLE_OFFSET + RTEMS_IDE_PARTITION_TABLE_SIZE,
40004bc4: c0 2f 61 fe clrb [ %i5 + 0x1fe ]
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
40004bc8: 94 10 20 08 mov 8, %o2
memset(mbr + RTEMS_IDE_PARTITION_TABLE_OFFSET + RTEMS_IDE_PARTITION_TABLE_SIZE,
40004bcc: c0 2f 61 ff clrb [ %i5 + 0x1ff ]
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
40004bd0: 92 07 bf 73 add %fp, -141, %o1
40004bd4: 40 00 5d a4 call 4001c264 <memcpy>
40004bd8: 90 07 60 03 add %i5, 3, %o0
FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector);
40004bdc: c2 07 bf 40 ld [ %fp + -192 ], %g1
40004be0: c2 2f 60 0b stb %g1, [ %i5 + 0xb ]
40004be4: 83 30 60 08 srl %g1, 8, %g1
40004be8: c2 2f 60 0c stb %g1, [ %i5 + 0xc ]
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
40004bec: 86 10 20 02 mov 2, %g3
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
40004bf0: c4 07 bf 4c ld [ %fp + -180 ], %g2
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
40004bf4: c2 07 bf 48 ld [ %fp + -184 ], %g1
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
40004bf8: c4 2f 60 0d stb %g2, [ %i5 + 0xd ]
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
40004bfc: 85 30 60 08 srl %g1, 8, %g2
40004c00: c2 2f 60 0e stb %g1, [ %i5 + 0xe ]
40004c04: c4 2f 60 0f stb %g2, [ %i5 + 0xf ]
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
40004c08: 84 10 20 01 mov 1, %g2
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
40004c0c: c6 2f 60 10 stb %g3, [ %i5 + 0x10 ]
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
40004c10: c2 07 bf 58 ld [ %fp + -168 ], %g1
40004c14: c2 2f 60 11 stb %g1, [ %i5 + 0x11 ]
40004c18: c2 07 bf 58 ld [ %fp + -168 ], %g1
40004c1c: 83 30 60 08 srl %g1, 8, %g1
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
40004c20: f8 2f 60 13 stb %i4, [ %i5 + 0x13 ]
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
40004c24: c2 2f 60 12 stb %g1, [ %i5 + 0x12 ]
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
40004c28: f0 2f 60 14 stb %i0, [ %i5 + 0x14 ]
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
40004c2c: c2 0f bf 71 ldub [ %fp + -143 ], %g1
40004c30: c2 2f 60 15 stb %g1, [ %i5 + 0x15 ]
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
40004c34: 82 10 3f ff mov -1, %g1
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
40004c38: c4 2f 60 1c stb %g2, [ %i5 + 0x1c ]
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
40004c3c: c2 2f 60 18 stb %g1, [ %i5 + 0x18 ]
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
40004c40: 82 10 20 06 mov 6, %g1
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
40004c44: e6 2f 60 20 stb %l3, [ %i5 + 0x20 ]
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
40004c48: c2 2f 60 1a stb %g1, [ %i5 + 0x1a ]
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
40004c4c: e4 2f 60 21 stb %l2, [ %i5 + 0x21 ]
40004c50: f6 2f 60 22 stb %i3, [ %i5 + 0x22 ]
40004c54: e2 2f 60 23 stb %l1, [ %i5 + 0x23 ]
if (fmt_params->fattype != FAT_FAT32) {
40004c58: c2 0f bf 72 ldub [ %fp + -142 ], %g1
40004c5c: 80 a0 60 04 cmp %g1, 4
40004c60: 02 80 03 44 be 40005970 <msdos_format+0x112c>
40004c64: c2 07 bf 50 ld [ %fp + -176 ], %g1
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
40004c68: c2 2f 60 16 stb %g1, [ %i5 + 0x16 ]
40004c6c: 83 30 60 08 srl %g1, 8, %g1
40004c70: c2 2f 60 17 stb %g1, [ %i5 + 0x17 ]
FAT_SET_BR_BOOTSIG(mbr , FAT_BR_BOOTSIG_VAL);
40004c74: 82 10 20 29 mov 0x29, %g1
40004c78: c2 2f 60 26 stb %g1, [ %i5 + 0x26 ]
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
40004c7c: 94 10 20 0b mov 0xb, %o2
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
40004c80: c2 07 bf 8c ld [ %fp + -116 ], %g1
40004c84: 89 30 60 08 srl %g1, 8, %g4
40004c88: 87 30 60 10 srl %g1, 0x10, %g3
40004c8c: 85 30 60 18 srl %g1, 0x18, %g2
40004c90: c2 2f 60 27 stb %g1, [ %i5 + 0x27 ]
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
40004c94: 92 07 bf 7c add %fp, -132, %o1
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
40004c98: c8 2f 60 28 stb %g4, [ %i5 + 0x28 ]
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
40004c9c: 90 07 60 2b add %i5, 0x2b, %o0
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
40004ca0: c6 2f 60 29 stb %g3, [ %i5 + 0x29 ]
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
40004ca4: 40 00 5d 70 call 4001c264 <memcpy>
40004ca8: c4 2f 60 2a stb %g2, [ %i5 + 0x2a ]
memcpy(FAT_GET_ADDR_BR_FILSYSTYPE(mbr),
40004cac: c2 0f bf 72 ldub [ %fp + -142 ], %g1
40004cb0: 80 a0 60 01 cmp %g1, 1
40004cb4: 02 80 01 fd be 400054a8 <msdos_format+0xc64>
40004cb8: 90 07 60 36 add %i5, 0x36, %o0
40004cbc: 13 10 00 9a sethi %hi(0x40026800), %o1
40004cc0: 92 12 61 e8 or %o1, 0x1e8, %o1 ! 400269e8 <rtems_filesystem_null_handlers+0x88>
40004cc4: 40 00 5d 68 call 4001c264 <memcpy>
40004cc8: 94 10 20 08 mov 8, %o2
FAT_SET_BR_SIGNATURE(mbr, FAT_BR_SIGNATURE_VAL);
40004ccc: 82 10 20 55 mov 0x55, %g1
40004cd0: c2 2f 61 fe stb %g1, [ %i5 + 0x1fe ]
40004cd4: 82 10 3f aa mov -86, %g1
40004cd8: c2 2f 61 ff stb %g1, [ %i5 + 0x1ff ]
FAT_SET_VAL8(mbr,0,0xeb);
40004cdc: 82 10 3f eb mov -21, %g1
40004ce0: c2 2f 40 00 stb %g1, [ %i5 ]
FAT_SET_VAL8(mbr,1,0x3c);
40004ce4: 82 10 20 3c mov 0x3c, %g1
40004ce8: c2 2f 60 01 stb %g1, [ %i5 + 1 ]
FAT_SET_VAL8(mbr,2,0x90);
40004cec: 82 10 3f 90 mov -112, %g1
40004cf0: c2 2f 60 02 stb %g1, [ %i5 + 2 ]
/*
* write master boot record to disk
* also write copy of MBR to disk
*/
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
40004cf4: 92 10 20 02 mov 2, %o1
40004cf8: 90 10 00 19 mov %i1, %o0
40004cfc: 15 10 00 9a sethi %hi(0x40026800), %o2
40004d00: 7f ff fe 38 call 400045e0 <msdos_format_printf>
40004d04: 94 12 a2 e0 or %o2, 0x2e0, %o2 ! 40026ae0 <rtems_filesystem_null_handlers+0x180>
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
40004d08: 96 10 20 00 clr %o3
"write MRB sector\n");
ret_val = msdos_format_write_sec(fd,
40004d0c: f8 07 bf 40 ld [ %fp + -192 ], %i4
0,
fmt_params.bytes_per_sector,
fmt_params.sec);
40004d10: fa 07 bf 94 ld [ %fp + -108 ], %i5
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
40004d14: 92 10 20 00 clr %o1
40004d18: 94 10 20 00 clr %o2
40004d1c: 40 00 20 cf call 4000d058 <lseek>
40004d20: 90 10 00 1a mov %i2, %o0
40004d24: 80 a2 20 00 cmp %o0, 0
40004d28: 06 80 01 ca bl 40005450 <msdos_format+0xc0c> <== NEVER TAKEN
40004d2c: 94 10 00 1c mov %i4, %o2
if (0 > write(fd,buffer,sector_size)) {
40004d30: 92 10 00 1d mov %i5, %o1
40004d34: 7f ff fd 5e call 400042ac <write>
40004d38: 90 10 00 1a mov %i2, %o0
40004d3c: 80 a2 20 00 cmp %o0, 0
40004d40: 06 80 01 c4 bl 40005450 <msdos_format+0xc0c> <== NEVER TAKEN
40004d44: c2 07 bf 68 ld [ %fp + -152 ], %g1
}
if ((ret_val == 0) &&
40004d48: 80 a0 60 00 cmp %g1, 0
40004d4c: 02 80 00 19 be 40004db0 <msdos_format+0x56c>
40004d50: 92 10 20 02 mov 2, %o1
(fmt_params.mbr_copy_sec != 0)) {
/*
* write copy of MBR
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
40004d54: 90 10 00 19 mov %i1, %o0
40004d58: 15 10 00 9a sethi %hi(0x40026800), %o2
40004d5c: 7f ff fe 21 call 400045e0 <msdos_format_printf>
40004d60: 94 12 a2 f8 or %o2, 0x2f8, %o2 ! 40026af8 <rtems_filesystem_null_handlers+0x198>
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
40004d64: c4 07 bf 68 ld [ %fp + -152 ], %g2
"write back up MRB sector\n");
ret_val = msdos_format_write_sec(fd,
40004d68: fa 07 bf 40 ld [ %fp + -192 ], %i5
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
40004d6c: 86 57 40 02 umul %i5, %g2, %g3
40004d70: 85 40 00 00 rd %y, %g2
fmt_params.mbr_copy_sec ,
fmt_params.bytes_per_sector,
fmt_params.sec);
40004d74: f8 07 bf 94 ld [ %fp + -108 ], %i4
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
40004d78: 96 10 20 00 clr %o3
40004d7c: 92 10 00 02 mov %g2, %o1
40004d80: 94 10 00 03 mov %g3, %o2
40004d84: 40 00 20 b5 call 4000d058 <lseek>
40004d88: 90 10 00 1a mov %i2, %o0
40004d8c: 80 a2 20 00 cmp %o0, 0
40004d90: 06 80 01 b0 bl 40005450 <msdos_format+0xc0c> <== NEVER TAKEN
40004d94: 94 10 00 1d mov %i5, %o2
if (0 > write(fd,buffer,sector_size)) {
40004d98: 92 10 00 1c mov %i4, %o1
40004d9c: 7f ff fd 44 call 400042ac <write>
40004da0: 90 10 00 1a mov %i2, %o0
40004da4: 80 a2 20 00 cmp %o0, 0
40004da8: 06 80 00 76 bl 40004f80 <msdos_format+0x73c> <== NEVER TAKEN
40004dac: b0 10 3f ff mov -1, %i0
}
}
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
40004db0: c2 07 bf 6c ld [ %fp + -148 ], %g1
40004db4: 80 a0 60 00 cmp %g1, 0
40004db8: 12 80 01 74 bne 40005388 <msdos_format+0xb44>
40004dbc: c2 07 bf 94 ld [ %fp + -108 ], %g1
ret_val = msdos_format_fill_sectors
(&fmt_params,
rqdata,
fd,
fmt_params.rsvd_sector_cnt, /* start sector */
fmt_params.fat_num*fmt_params.sectors_per_fat,/* sector count */
40004dc0: d8 0f bf 70 ldub [ %fp + -144 ], %o4
ret_val = msdos_format_fill_sectors
40004dc4: c2 07 bf 50 ld [ %fp + -176 ], %g1
40004dc8: d6 07 bf 48 ld [ %fp + -184 ], %o3
40004dcc: 9a 10 20 00 clr %o5
40004dd0: 98 5b 00 01 smul %o4, %g1, %o4
40004dd4: 94 10 00 1a mov %i2, %o2
40004dd8: 92 10 00 19 mov %i1, %o1
40004ddc: 7f ff fe 3f call 400046d8 <msdos_format_fill_sectors>
40004de0: 90 07 bf 40 add %fp, -192, %o0
}
/*
* clear/init root directory
* -> write all directory sectors as 0x00
*/
if (ret_val == 0) {
40004de4: b0 92 20 00 orcc %o0, 0, %i0
40004de8: 12 80 00 66 bne 40004f80 <msdos_format+0x73c> <== NEVER TAKEN
40004dec: d8 07 bf 64 ld [ %fp + -156 ], %o4
ret_val = msdos_format_fill_sectors
40004df0: d6 07 bf 60 ld [ %fp + -160 ], %o3
40004df4: 9a 10 20 00 clr %o5
40004df8: 94 10 00 1a mov %i2, %o2
40004dfc: 92 10 00 19 mov %i1, %o1
40004e00: 7f ff fe 36 call 400046d8 <msdos_format_fill_sectors>
40004e04: 90 07 bf 40 add %fp, -192, %o0
0x00);
}
/*
* write volume label to first entry of directory
*/
if ((ret_val == 0) && fmt_params.VolLabel_present) {
40004e08: b0 92 20 00 orcc %o0, 0, %i0
40004e0c: 12 80 00 5d bne 40004f80 <msdos_format+0x73c> <== NEVER TAKEN
40004e10: c2 0f bf 88 ldub [ %fp + -120 ], %g1
memset(fmt_params.sec,0,fmt_params.bytes_per_sector);
40004e14: d0 07 bf 94 ld [ %fp + -108 ], %o0
if ((ret_val == 0) && fmt_params.VolLabel_present) {
40004e18: 80 a0 60 00 cmp %g1, 0
40004e1c: 12 80 02 32 bne 400056e4 <msdos_format+0xea0>
40004e20: d4 07 bf 40 ld [ %fp + -192 ], %o2
uint32_t start_sector;
/*
* empty sector: all clusters are free/do not link further on
*/
memset(fmt_params.sec,0,fmt_params.bytes_per_sector);
40004e24: 40 00 5d 4f call 4001c360 <memset>
40004e28: 92 10 20 00 clr %o1
switch(fmt_params.fattype) {
40004e2c: c2 0f bf 72 ldub [ %fp + -142 ], %g1
40004e30: 80 a0 60 02 cmp %g1, 2
40004e34: 02 80 02 7b be 40005820 <msdos_format+0xfdc>
40004e38: 80 a0 60 04 cmp %g1, 4
40004e3c: 02 80 02 63 be 400057c8 <msdos_format+0xf84>
40004e40: 80 a0 60 01 cmp %g1, 1
40004e44: 02 80 02 57 be 400057a0 <msdos_format+0xf5c> <== ALWAYS TAKEN
40004e48: c2 07 bf 94 ld [ %fp + -108 ], %g1
FAT_SET_VAL32(fmt_params.sec,4,0xc0000000|FAT_FAT32_EOC);
break;
default:
ret_val = -1;
errno = EINVAL;
40004e4c: 40 00 5b 18 call 4001baac <__errno> <== NOT EXECUTED
40004e50: a2 10 3f ff mov -1, %l1 <== NOT EXECUTED
40004e54: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
40004e58: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
if (fmt_params.fattype == FAT_FAT32) {
40004e5c: c2 0f bf 72 ldub [ %fp + -142 ], %g1
40004e60: 80 a0 60 04 cmp %g1, 4
40004e64: 12 80 00 0e bne 40004e9c <msdos_format+0x658>
40004e68: c4 0f bf 90 ldub [ %fp + -112 ], %g2
/*
* only first valid cluster (cluster number 2) belongs
* to root directory, and is end of chain
* mark this in every copy of the FAT
*/
FAT_SET_VAL32(fmt_params.sec,8,FAT_FAT32_EOC);
40004e6c: c2 07 bf 94 ld [ %fp + -108 ], %g1
40004e70: 84 10 3f f8 mov -8, %g2
40004e74: c4 28 60 08 stb %g2, [ %g1 + 8 ]
40004e78: 82 10 3f ff mov -1, %g1
40004e7c: c4 07 bf 94 ld [ %fp + -108 ], %g2
40004e80: c2 28 a0 09 stb %g1, [ %g2 + 9 ]
40004e84: c4 07 bf 94 ld [ %fp + -108 ], %g2
40004e88: c2 28 a0 0a stb %g1, [ %g2 + 0xa ]
40004e8c: 84 10 20 0f mov 0xf, %g2
40004e90: c2 07 bf 94 ld [ %fp + -108 ], %g1
40004e94: c4 28 60 0b stb %g2, [ %g1 + 0xb ]
if (! skip_alignment)
40004e98: c4 0f bf 90 ldub [ %fp + -112 ], %g2
}
start_sector = loc_align_object (fmt_params.rsvd_sector_cnt,
40004e9c: f6 07 bf 48 ld [ %fp + -184 ], %i3
if (! skip_alignment)
40004ea0: 80 a0 a0 00 cmp %g2, 0
40004ea4: 12 80 00 06 bne 40004ebc <msdos_format+0x678>
40004ea8: c2 07 bf 4c ld [ %fp + -180 ], %g1
return (sectors + clustersize - 1) & ~(clustersize - 1);
40004eac: b6 06 c0 01 add %i3, %g1, %i3
40004eb0: 82 20 00 01 neg %g1
40004eb4: b6 06 ff ff add %i3, -1, %i3
40004eb8: b6 0e c0 01 and %i3, %g1, %i3
fmt_params.sectors_per_cluster,
fmt_params.skip_alignment);
for (i = 0;
40004ebc: c2 0f bf 70 ldub [ %fp + -144 ], %g1
40004ec0: 80 a0 60 00 cmp %g1, 0
40004ec4: 02 80 02 f0 be 40005a84 <msdos_format+0x1240> <== NEVER TAKEN
40004ec8: 80 a4 60 00 cmp %l1, 0
(i < fmt_params.fat_num) && (ret_val == 0);
40004ecc: 12 80 01 61 bne 40005450 <msdos_format+0xc0c> <== NEVER TAKEN
40004ed0: ba 10 20 00 clr %i5
i++) {
ret_val = msdos_format_write_sec
40004ed4: f8 07 bf 40 ld [ %fp + -192 ], %i4
(fd,
start_sector
+ (i * fmt_params.sectors_per_fat),
40004ed8: c4 07 bf 50 ld [ %fp + -176 ], %g2
40004edc: 84 5f 40 02 smul %i5, %g2, %g2
ret_val = msdos_format_write_sec
40004ee0: 84 00 80 1b add %g2, %i3, %g2
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
40004ee4: 86 50 80 1c umul %g2, %i4, %g3
40004ee8: 85 40 00 00 rd %y, %g2
fmt_params.bytes_per_sector,
fmt_params.sec);
40004eec: e4 07 bf 94 ld [ %fp + -108 ], %l2
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
40004ef0: 94 10 00 03 mov %g3, %o2
40004ef4: 96 10 20 00 clr %o3
40004ef8: 90 10 00 1a mov %i2, %o0
40004efc: 40 00 20 57 call 4000d058 <lseek>
40004f00: 92 10 00 02 mov %g2, %o1
if (0 > write(fd,buffer,sector_size)) {
40004f04: 94 10 00 1c mov %i4, %o2
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
40004f08: 82 10 00 08 mov %o0, %g1
if (0 > write(fd,buffer,sector_size)) {
40004f0c: 92 10 00 12 mov %l2, %o1
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
40004f10: 80 a0 60 00 cmp %g1, 0
40004f14: 06 80 01 4f bl 40005450 <msdos_format+0xc0c> <== NEVER TAKEN
40004f18: 90 10 00 1a mov %i2, %o0
if (0 > write(fd,buffer,sector_size)) {
40004f1c: 7f ff fc e4 call 400042ac <write>
40004f20: 01 00 00 00 nop
40004f24: 80 a2 20 00 cmp %o0, 0
40004f28: 06 80 01 4a bl 40005450 <msdos_format+0xc0c> <== NEVER TAKEN
40004f2c: c2 0f bf 70 ldub [ %fp + -144 ], %g1
i++) {
40004f30: ba 07 60 01 inc %i5
for (i = 0;
40004f34: 80 a7 40 01 cmp %i5, %g1
40004f38: 06 bf ff e8 bl 40004ed8 <msdos_format+0x694>
40004f3c: f8 07 bf 40 ld [ %fp + -192 ], %i4
}
}
if (ret_val == 0 && rqdata != NULL && rqdata->sync_device) {
40004f40: 80 8c 20 ff btst 0xff, %l0
40004f44: 22 80 00 0f be,a 40004f80 <msdos_format+0x73c>
40004f48: b0 10 00 11 mov %l1, %i0
40004f4c: c2 0e 60 17 ldub [ %i1 + 0x17 ], %g1
40004f50: 80 a0 60 00 cmp %g1, 0
40004f54: 02 80 00 0b be 40004f80 <msdos_format+0x73c>
40004f58: 90 10 00 1a mov %i2, %o0
return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);
}
static inline int rtems_disk_fd_sync(int fd)
{
return ioctl(fd, RTEMS_BLKIO_SYNCDEV);
40004f5c: 13 08 00 10 sethi %hi(0x20004000), %o1
40004f60: 40 00 20 03 call 4000cf6c <ioctl>
40004f64: 92 12 62 06 or %o1, 0x206, %o1 ! 20004206 <RAM_SIZE+0x1fc04206>
40004f68: 10 80 00 06 b 40004f80 <msdos_format+0x73c>
40004f6c: b0 10 00 08 mov %o0, %i0
errno = ENOTTY;
40004f70: 40 00 5a cf call 4001baac <__errno> <== NOT EXECUTED
40004f74: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40004f78: 82 10 20 19 mov 0x19, %g1 <== NOT EXECUTED
40004f7c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
* cleanup:
* sync and unlock disk
* free any data structures (not needed now)
*/
if (fd != -1) {
close(fd);
40004f80: 7f ff f5 06 call 40002398 <close>
40004f84: 90 10 00 1a mov %i2, %o0
}
free(fmt_params.sec);
40004f88: 7f ff f5 66 call 40002520 <free>
40004f8c: d0 07 bf 94 ld [ %fp + -108 ], %o0
return ret_val;
}
40004f90: 81 c7 e0 08 ret
40004f94: 81 e8 00 00 restore
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
40004f98: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
40004f9c: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED
40004fa0: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
40004fa4: 15 10 00 9a sethi %hi(0x40026800), %o2 <== NOT EXECUTED
40004fa8: 7f ff fd 8e call 400045e0 <msdos_format_printf> <== NOT EXECUTED
40004fac: 94 12 a2 08 or %o2, 0x208, %o2 ! 40026a08 <rtems_filesystem_null_handlers+0xa8><== NOT EXECUTED
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
40004fb0: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED
40004fb4: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
40004fb8: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
40004fbc: 15 10 00 9a sethi %hi(0x40026800), %o2 <== NOT EXECUTED
40004fc0: 7f ff fd 88 call 400045e0 <msdos_format_printf> <== NOT EXECUTED
40004fc4: 94 12 a2 18 or %o2, 0x218, %o2 ! 40026a18 <rtems_filesystem_null_handlers+0xb8><== NOT EXECUTED
free(fmt_params.sec);
40004fc8: d0 07 bf 94 ld [ %fp + -108 ], %o0 <== NOT EXECUTED
40004fcc: 7f ff f5 55 call 40002520 <free> <== NOT EXECUTED
40004fd0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
}
40004fd4: 81 c7 e0 08 ret <== NOT EXECUTED
40004fd8: 81 e8 00 00 restore <== NOT EXECUTED
return ioctl(fd, RTEMS_BLKIO_GETSIZE, block_count);
40004fdc: 94 07 bf 44 add %fp, -188, %o2
40004fe0: 92 17 62 05 or %i5, 0x205, %o1
40004fe4: 40 00 1f e2 call 4000cf6c <ioctl>
40004fe8: 90 10 00 1a mov %i2, %o0
if (ret_val == 0) {
40004fec: b0 92 20 00 orcc %o0, 0, %i0
40004ff0: 12 80 01 24 bne 40005480 <msdos_format+0xc3c> <== NEVER TAKEN
40004ff4: d6 07 bf 40 ld [ %fp + -192 ], %o3
total_size = (uint64_t)fmt_params->bytes_per_sector * fmt_params->totl_sector_cnt;
40004ff8: d8 07 bf 44 ld [ %fp + -188 ], %o4
40004ffc: ba 52 c0 0c umul %o3, %o4, %i5
40005000: b9 40 00 00 rd %y, %i4
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
40005004: fa 23 a0 5c st %i5, [ %sp + 0x5c ]
40005008: 9a 10 00 1c mov %i4, %o5
4000500c: f8 3f bf 28 std %i4, [ %fp + -216 ]
40005010: 92 10 20 02 mov 2, %o1
40005014: 15 10 00 9a sethi %hi(0x40026800), %o2
40005018: 90 10 00 19 mov %i1, %o0
4000501c: 7f ff fd 71 call 400045e0 <msdos_format_printf>
40005020: 94 12 a2 28 or %o2, 0x228, %o2
if ((rqdata == NULL) || (rqdata->fat_num == 0)) {
40005024: 80 a6 60 00 cmp %i1, 0
40005028: 02 80 02 0b be 40005854 <msdos_format+0x1010>
4000502c: 82 10 20 02 mov 2, %g1
40005030: d6 06 60 0c ld [ %i1 + 0xc ], %o3
40005034: 80 a2 e0 00 cmp %o3, 0
40005038: 22 80 01 1a be,a 400054a0 <msdos_format+0xc5c>
4000503c: 96 10 20 02 mov 2, %o3
else if (rqdata->fat_num <= 6) {
40005040: 80 a2 e0 06 cmp %o3, 6
40005044: 18 80 01 0b bgu 40005470 <msdos_format+0xc2c>
40005048: 01 00 00 00 nop
fmt_params->fat_num = rqdata->fat_num;
4000504c: d6 2f bf 70 stb %o3, [ %fp + -144 ]
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
40005050: 15 10 00 9a sethi %hi(0x40026800), %o2
40005054: 92 10 20 02 mov 2, %o1
40005058: 94 12 a2 68 or %o2, 0x268, %o2
4000505c: 7f ff fd 61 call 400045e0 <msdos_format_printf>
40005060: 90 10 00 19 mov %i1, %o0
if (rqdata != NULL && rqdata->sectors_per_cluster != 0) {
40005064: c2 06 60 08 ld [ %i1 + 8 ], %g1
40005068: 80 a0 60 00 cmp %g1, 0
4000506c: 02 80 02 02 be 40005874 <msdos_format+0x1030>
40005070: 05 00 00 1f sethi %hi(0x7c00), %g2
if (fmt_params->totl_sector_cnt < FAT_FAT12_MAX_CLN * fat12_sect_per_clust) {
40005074: 84 58 6f f5 smul %g1, 0xff5, %g2
40005078: c6 07 bf 44 ld [ %fp + -188 ], %g3
4000507c: 80 a0 80 03 cmp %g2, %g3
40005080: 08 80 02 00 bleu 40005880 <msdos_format+0x103c>
40005084: 05 00 00 3f sethi %hi(0xfc00), %g2
fmt_params->fattype = FAT_FAT12;
40005088: 82 10 20 01 mov 1, %g1
4000508c: c2 2f bf 72 stb %g1, [ %fp + -142 ]
fmt_params->sectors_per_cluster = 2;
40005090: 82 10 20 02 mov 2, %g1
40005094: c2 27 bf 4c st %g1, [ %fp + -180 ]
ret_val = msdos_set_sectors_per_cluster_from_request( rqdata, fmt_params );
40005098: 92 07 bf 40 add %fp, -192, %o1
4000509c: 7f ff fd 6b call 40004648 <msdos_set_sectors_per_cluster_from_request>
400050a0: 90 10 00 19 mov %i1, %o0
if (ret_val == 0) {
400050a4: b0 92 20 00 orcc %o0, 0, %i0
400050a8: 12 bf fe 3f bne 400049a4 <msdos_format+0x160> <== NEVER TAKEN
400050ac: c4 07 bf 44 ld [ %fp + -188 ], %g2
uint32_t gigs = ( total_size + ONE_GB ) / ONE_GB;
400050b0: 94 10 20 00 clr %o2
400050b4: 17 10 00 00 sethi %hi(0x40000000), %o3
400050b8: 9a 87 40 0b addcc %i5, %o3, %o5
400050bc: 98 47 00 0a addx %i4, %o2, %o4
400050c0: 87 33 60 1e srl %o5, 0x1e, %g3
400050c4: 89 2b 20 02 sll %o4, 2, %g4
400050c8: 86 11 00 03 or %g4, %g3, %g3
((fattype == FAT_FAT16) && (*data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
400050cc: 05 00 00 3f sethi %hi(0xfc00), %g2
uint32_t gigs = ( total_size + ONE_GB ) / ONE_GB;
400050d0: c6 27 bf 1c st %g3, [ %fp + -228 ]
((fattype == FAT_FAT16) && (*data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
400050d4: a8 10 a3 f5 or %g2, 0x3f5, %l4
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
400050d8: 07 10 00 9a sethi %hi(0x40026800), %g3
else if ( number_of_clusters < FAT_FAT16_MAX_CLN
400050dc: 84 10 a3 f4 or %g2, 0x3f4, %g2
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
400050e0: 86 10 e2 80 or %g3, 0x280, %g3
else if ( number_of_clusters < FAT_FAT16_MAX_CLN
400050e4: c4 27 bf 20 st %g2, [ %fp + -224 ]
if (MS_BYTES_PER_CLUSTER_LIMIT_FAT12 < (sectors_per_cluster * bytes_per_sector)) {
400050e8: 21 00 00 04 sethi %hi(0x1000), %l0
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
400050ec: c6 27 bf 24 st %g3, [ %fp + -220 ]
uint32_t ms_sectors_per_cluster_limit_FAT16 =
400050f0: 23 00 00 20 sethi %hi(0x8000), %l1
&& fmt_params->totl_sector_cnt > 0 ) {
400050f4: d4 07 bf 44 ld [ %fp + -188 ], %o2
400050f8: c2 0f bf 72 ldub [ %fp + -142 ], %g1
400050fc: a6 10 20 00 clr %l3
40005100: aa 10 20 ff mov 0xff, %l5
uint32_t ms_sectors_per_cluster_limit_FAT16 =
40005104: a2 14 60 01 or %l1, 1, %l1
uint32_t ms_sectors_per_cluster_limit_FAT12 =
40005108: a4 14 20 01 or %l0, 1, %l2
&& fmt_params->fattype != fat_type
4000510c: 82 08 60 ff and %g1, 0xff, %g1
40005110: 80 a0 40 15 cmp %g1, %l5
40005114: 02 80 01 e7 be 400058b0 <msdos_format+0x106c>
40005118: 80 a2 a0 00 cmp %o2, 0
&& fmt_params->totl_sector_cnt > 0 ) {
4000511c: 02 bf fe 25 be 400049b0 <msdos_format+0x16c> <== NEVER TAKEN
40005120: 80 a6 60 00 cmp %i1, 0
if (ret_val == 0 && rqdata != NULL)
40005124: 02 80 01 50 be 40005664 <msdos_format+0xe20>
40005128: d6 07 bf 4c ld [ %fp + -180 ], %o3
fmt_params->skip_alignment = rqdata->skip_alignment;
4000512c: c2 0e 60 16 ldub [ %i1 + 0x16 ], %g1
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
40005130: d4 07 bf 24 ld [ %fp + -220 ], %o2
fmt_params->skip_alignment = rqdata->skip_alignment;
40005134: c2 2f bf 90 stb %g1, [ %fp + -112 ]
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
40005138: 92 10 20 02 mov 2, %o1
4000513c: 7f ff fd 29 call 400045e0 <msdos_format_printf>
40005140: 90 10 00 19 mov %i1, %o0
if (fmt_params->fattype == FAT_FAT32) {
40005144: ea 0f bf 72 ldub [ %fp + -142 ], %l5
40005148: 80 a5 60 04 cmp %l5, 4
4000514c: 02 80 01 4e be 40005684 <msdos_format+0xe40>
40005150: 82 10 20 01 mov 1, %g1
fmt_params->rsvd_sector_cnt = 1;
40005154: c2 27 bf 48 st %g1, [ %fp + -184 ]
(rqdata->files_per_root_dir > 0)) {
40005158: d8 06 60 10 ld [ %i1 + 0x10 ], %o4
if ((rqdata != NULL) &&
4000515c: 80 a3 20 00 cmp %o4, 0
40005160: 02 80 01 58 be 400056c0 <msdos_format+0xe7c>
40005164: ba 10 20 02 mov 2, %i5
fmt_params->files_per_root_dir = rqdata->files_per_root_dir;
40005168: 98 03 3f ff add %o4, -1, %o4
ret_val = msdos_format_eval_sectors_per_cluster(fmt_params->fattype,
4000516c: ba 10 00 15 mov %l5, %i5
fmt_params->files_per_root_dir = rqdata->files_per_root_dir;
40005170: 92 10 20 01 mov 1, %o1
(2*fmt_params->bytes_per_sector/
40005174: f6 07 bf 40 ld [ %fp + -192 ], %i3
40005178: 83 2e e0 01 sll %i3, 1, %g1
4000517c: 83 30 60 05 srl %g1, 5, %g1
fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
40005180: 98 00 40 0c add %g1, %o4, %o4
fmt_params->files_per_root_dir -= (fmt_params->files_per_root_dir %
40005184: 81 80 20 00 wr %g0, %y
40005188: 01 00 00 00 nop
4000518c: 01 00 00 00 nop
40005190: 01 00 00 00 nop
40005194: 98 73 00 01 udiv %o4, %g1, %o4
40005198: 98 5b 00 01 smul %o4, %g1, %o4
4000519c: d8 27 bf 58 st %o4, [ %fp + -168 ]
(((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)
400051a0: 99 2b 20 05 sll %o4, 5, %o4
fmt_params->root_dir_sectors =
400051a4: 96 06 ff ff add %i3, -1, %o3
+ fmt_params->bytes_per_sector - 1)
400051a8: 98 03 00 0b add %o4, %o3, %o4
/ fmt_params->bytes_per_sector);
400051ac: 81 80 20 00 wr %g0, %y
400051b0: 01 00 00 00 nop
400051b4: 01 00 00 00 nop
400051b8: 01 00 00 00 nop
400051bc: 98 73 00 1b udiv %o4, %i3, %o4
fmt_params->root_dir_sectors =
400051c0: d8 27 bf 5c st %o4, [ %fp + -164 ]
while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
400051c4: 03 00 00 40 sethi %hi(0x10000), %g1
ret_val = msdos_format_eval_sectors_per_cluster(fmt_params->fattype,
400051c8: c4 07 bf 4c ld [ %fp + -180 ], %g2
while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
400051cc: 81 80 20 00 wr %g0, %y
400051d0: 01 00 00 00 nop
400051d4: 01 00 00 00 nop
400051d8: 01 00 00 00 nop
400051dc: 82 70 40 1b udiv %g1, %i3, %g1
ret_val = msdos_format_eval_sectors_per_cluster(fmt_params->fattype,
400051e0: d4 07 bf 44 ld [ %fp + -188 ], %o2
400051e4: da 0f bf 70 ldub [ %fp + -144 ], %o5
while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
400051e8: 80 a0 80 01 cmp %g2, %g1
400051ec: 08 80 00 06 bleu 40005204 <msdos_format+0x9c0> <== ALWAYS TAKEN
400051f0: de 0f bf 90 ldub [ %fp + -112 ], %o7
sectors_per_cluster /= 2;
400051f4: 85 30 a0 01 srl %g2, 1, %g2 <== NOT EXECUTED
while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
400051f8: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
400051fc: 38 bf ff ff bgu,a 400051f8 <msdos_format+0x9b4> <== NOT EXECUTED
40005200: 85 30 a0 01 srl %g2, 1, %g2 <== NOT EXECUTED
fatdata_sect_cnt = total_sector_cnt
40005204: 90 22 80 09 sub %o2, %o1, %o0
fat_sectors_cnt = loc_align_object (sectors_per_fat * fat_num,
40005208: 9a 0b 60 ff and %o5, 0xff, %o5
4000520c: 9e 0b e0 ff and %o7, 0xff, %o7
return (sectors + clustersize - 1) & ~(clustersize - 1);
40005210: 92 02 7f ff add %o1, -1, %o1
40005214: ae 03 3f ff add %o4, -1, %l7
} else if ((sectors_per_cluster * bytes_per_sector)
40005218: 2d 00 00 40 sethi %hi(0x10000), %l6
if (! skip_alignment)
4000521c: 80 a3 e0 00 cmp %o7, 0
40005220: 12 80 00 a5 bne 400054b4 <msdos_format+0xc70>
40005224: 80 a7 60 01 cmp %i5, 1
return (sectors + clustersize - 1) & ~(clustersize - 1);
40005228: 88 20 00 02 neg %g2, %g4
4000522c: 86 02 40 02 add %o1, %g2, %g3
40005230: 82 05 c0 02 add %l7, %g2, %g1
40005234: 86 08 c0 04 and %g3, %g4, %g3
40005238: 82 08 40 04 and %g1, %g4, %g1
if (fattype == FAT_FAT12) {
4000523c: 02 80 00 c8 be 4000555c <msdos_format+0xd18>
40005240: 86 22 80 03 sub %o2, %g3, %g3
else if (fattype == FAT_FAT16) {
40005244: 80 a7 60 02 cmp %i5, 2
40005248: 02 80 01 05 be 4000565c <msdos_format+0xe18>
4000524c: 82 05 c0 02 add %l7, %g2, %g1
fatdata_cluster_cnt = fatdata_sect_cnt/sectors_per_cluster;
40005250: 81 80 20 00 wr %g0, %y
40005254: 01 00 00 00 nop
40005258: 01 00 00 00 nop
4000525c: 01 00 00 00 nop
40005260: 86 70 c0 02 udiv %g3, %g2, %g3
fat_capacity = fatdata_cluster_cnt * 4;
40005264: 83 28 e0 02 sll %g3, 2, %g1
+ (bytes_per_sector - 1))
40005268: 82 00 40 0b add %g1, %o3, %g1
4000526c: b8 00 bf ff add %g2, -1, %i4
sectors_per_fat = ((fat_capacity
40005270: 81 80 20 00 wr %g0, %y
40005274: 01 00 00 00 nop
40005278: 01 00 00 00 nop
4000527c: 01 00 00 00 nop
40005280: 82 70 40 1b udiv %g1, %i3, %g1
if (! skip_alignment)
40005284: 80 a3 e0 00 cmp %o7, 0
fat_sectors_cnt = loc_align_object (sectors_per_fat * fat_num,
40005288: 82 58 40 0d smul %g1, %o5, %g1
if (! skip_alignment)
4000528c: 12 80 00 05 bne 400052a0 <msdos_format+0xa5c>
40005290: 88 07 00 01 add %i4, %g1, %g4
return (sectors + clustersize - 1) & ~(clustersize - 1);
40005294: 82 20 00 02 neg %g2, %g1
40005298: 82 08 40 04 and %g1, %g4, %g1
+ (sectors_per_cluster - 1))
4000529c: 88 07 00 01 add %i4, %g1, %g4
/ sectors_per_cluster));
400052a0: 81 80 20 00 wr %g0, %y
400052a4: 01 00 00 00 nop
400052a8: 01 00 00 00 nop
400052ac: 01 00 00 00 nop
400052b0: 88 71 00 02 udiv %g4, %g2, %g4
if (((fattype == FAT_FAT12) && (*data_cluster_cnt > FAT_FAT12_MAX_CLN)) ||
400052b4: 80 a7 60 01 cmp %i5, 1
400052b8: 02 80 00 8d be 400054ec <msdos_format+0xca8>
400052bc: 86 20 c0 04 sub %g3, %g4, %g3
400052c0: 80 a7 60 02 cmp %i5, 2
400052c4: 12 80 00 8d bne 400054f8 <msdos_format+0xcb4>
400052c8: 80 a0 c0 14 cmp %g3, %l4
((fattype == FAT_FAT16) && (*data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
400052cc: 28 80 00 b3 bleu,a 40005598 <msdos_format+0xd54>
400052d0: c4 27 bf 4c st %g2, [ %fp + -180 ]
sectors_per_cluster *= 2;
400052d4: 85 28 a0 01 sll %g2, 1, %g2
} else if ((sectors_per_cluster * bytes_per_sector)
400052d8: 88 5e c0 02 smul %i3, %g2, %g4
400052dc: 80 a1 00 16 cmp %g4, %l6
400052e0: 08 bf ff d0 bleu 40005220 <msdos_format+0x9dc> <== ALWAYS TAKEN
400052e4: 80 a3 e0 00 cmp %o7, 0
*sectors_per_fat_ptr = fat_sectors_cnt / fat_num;
400052e8: 81 80 20 00 wr %g0, %y <== NOT EXECUTED
400052ec: 01 00 00 00 nop <== NOT EXECUTED
400052f0: 01 00 00 00 nop <== NOT EXECUTED
400052f4: 01 00 00 00 nop <== NOT EXECUTED
400052f8: 82 70 40 0d udiv %g1, %o5, %g1 <== NOT EXECUTED
fmt_params->sectors_per_cluster = sectors_per_cluster_adj;
400052fc: c4 27 bf 4c st %g2, [ %fp + -180 ] <== NOT EXECUTED
uint32_t ms_sectors_per_cluster_limit_FAT16 =
40005300: 81 80 20 00 wr %g0, %y <== NOT EXECUTED
40005304: 01 00 00 00 nop <== NOT EXECUTED
40005308: 01 00 00 00 nop <== NOT EXECUTED
4000530c: 01 00 00 00 nop <== NOT EXECUTED
40005310: b6 74 40 1b udiv %l1, %i3, %i3 <== NOT EXECUTED
*sectors_per_fat_ptr = fat_sectors_cnt / fat_num;
40005314: c2 27 bf 50 st %g1, [ %fp + -176 ] <== NOT EXECUTED
else if ( number_of_clusters < FAT_FAT16_MAX_CLN
40005318: c2 07 bf 20 ld [ %fp + -224 ], %g1
4000531c: 80 a0 40 03 cmp %g1, %g3
40005320: 0a 80 01 0f bcs 4000575c <msdos_format+0xf18>
40005324: 80 a6 c0 02 cmp %i3, %g2
40005328: 0a 80 01 0d bcs 4000575c <msdos_format+0xf18>
4000532c: 82 10 20 02 mov 2, %g1
fmt_params->fattype = msdos_get_fat_type(
40005330: c2 2f bf 72 stb %g1, [ %fp + -142 ]
if (fat_type != fmt_params->fattype) {
40005334: 82 08 60 ff and %g1, 0xff, %g1
40005338: 80 a0 40 15 cmp %g1, %l5
4000533c: 12 80 00 ae bne 400055f4 <msdos_format+0xdb0>
40005340: c2 0f bf 72 ldub [ %fp + -142 ], %g1
++iteration_cnt;
40005344: 10 bf ff 72 b 4000510c <msdos_format+0x8c8>
40005348: a6 04 e0 01 inc %l3
(rqdata != NULL) &&
4000534c: c2 0e 60 15 ldub [ %i1 + 0x15 ], %g1
40005350: 80 a0 60 00 cmp %g1, 0
40005354: 12 80 00 0b bne 40005380 <msdos_format+0xb3c> <== ALWAYS TAKEN
40005358: d8 07 bf 44 ld [ %fp + -188 ], %o4
ret_val = msdos_format_fill_sectors
4000535c: 9a 10 3f e5 mov -27, %o5 <== NOT EXECUTED
40005360: 96 10 20 00 clr %o3 <== NOT EXECUTED
40005364: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
40005368: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4000536c: 7f ff fc db call 400046d8 <msdos_format_fill_sectors> <== NOT EXECUTED
40005370: 90 07 bf 40 add %fp, -192, %o0 <== NOT EXECUTED
if (ret_val == 0) {
40005374: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
40005378: 12 bf ff 02 bne 40004f80 <msdos_format+0x73c> <== NOT EXECUTED
4000537c: 01 00 00 00 nop <== NOT EXECUTED
*to++=' ';
40005380: 10 bf fd e7 b 40004b1c <msdos_format+0x2d8>
40005384: a0 10 20 01 mov 1, %l0 ! 1 <_TLS_Alignment>
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
40005388: 94 10 22 00 mov 0x200, %o2
4000538c: 92 10 20 00 clr %o1
40005390: 40 00 5b f4 call 4001c360 <memset>
40005394: 90 10 00 01 mov %g1, %o0
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
40005398: 86 10 20 61 mov 0x61, %g3
4000539c: ba 10 20 52 mov 0x52, %i5
400053a0: c6 2a 20 02 stb %g3, [ %o0 + 2 ]
400053a4: 88 10 20 41 mov 0x41, %g4
400053a8: fa 2a 00 00 stb %i5, [ %o0 ]
FAT_SET_FSINFO_FREE_CLUSTER_COUNT(fsinfo+FAT_FSI_INFO, 0xffffffff);
400053ac: 84 10 3f ff mov -1, %g2
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
400053b0: fa 2a 20 01 stb %i5, [ %o0 + 1 ]
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
400053b4: ba 10 20 72 mov 0x72, %i5
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
400053b8: c8 2a 20 03 stb %g4, [ %o0 + 3 ]
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
400053bc: c6 2a 21 e7 stb %g3, [ %o0 + 0x1e7 ]
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
400053c0: 86 10 20 55 mov 0x55, %g3
FAT_SET_FSINFO_FREE_CLUSTER_COUNT(fsinfo+FAT_FSI_INFO, 0xffffffff);
400053c4: c4 2a 21 e8 stb %g2, [ %o0 + 0x1e8 ]
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
400053c8: c6 2a 21 fe stb %g3, [ %o0 + 0x1fe ]
400053cc: 86 10 3f aa mov -86, %g3
FAT_SET_FSINFO_FREE_CLUSTER_COUNT(fsinfo+FAT_FSI_INFO, 0xffffffff);
400053d0: c4 2a 21 e9 stb %g2, [ %o0 + 0x1e9 ]
400053d4: c4 2a 21 ea stb %g2, [ %o0 + 0x1ea ]
400053d8: c4 2a 21 eb stb %g2, [ %o0 + 0x1eb ]
FAT_SET_FSINFO_NEXT_FREE_CLUSTER (fsinfo+FAT_FSI_INFO, 0xffffffff);
400053dc: c4 2a 21 ec stb %g2, [ %o0 + 0x1ec ]
400053e0: c4 2a 21 ed stb %g2, [ %o0 + 0x1ed ]
400053e4: c4 2a 21 ee stb %g2, [ %o0 + 0x1ee ]
400053e8: c4 2a 21 ef stb %g2, [ %o0 + 0x1ef ]
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
400053ec: fa 2a 21 e4 stb %i5, [ %o0 + 0x1e4 ]
400053f0: fa 2a 21 e5 stb %i5, [ %o0 + 0x1e5 ]
400053f4: c8 2a 21 e6 stb %g4, [ %o0 + 0x1e6 ]
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
400053f8: c6 2a 21 ff stb %g3, [ %o0 + 0x1ff ]
(fmt_params.fsinfo_sec != 0)) {
400053fc: c4 07 bf 6c ld [ %fp + -148 ], %g2
if ((ret_val == 0) &&
40005400: 80 a0 a0 00 cmp %g2, 0
40005404: 02 bf fe 6f be 40004dc0 <msdos_format+0x57c> <== NEVER TAKEN
40005408: f8 07 bf 94 ld [ %fp + -108 ], %i4
ret_val = msdos_format_write_sec(fd,
4000540c: fa 07 bf 40 ld [ %fp + -192 ], %i5
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
40005410: 86 50 80 1d umul %g2, %i5, %g3
40005414: 85 40 00 00 rd %y, %g2
40005418: 96 10 20 00 clr %o3
4000541c: 92 10 00 02 mov %g2, %o1
40005420: 94 10 00 03 mov %g3, %o2
40005424: 40 00 1f 0d call 4000d058 <lseek>
40005428: 90 10 00 1a mov %i2, %o0
4000542c: 80 a2 20 00 cmp %o0, 0
40005430: 06 80 00 08 bl 40005450 <msdos_format+0xc0c> <== NEVER TAKEN
40005434: 94 10 00 1d mov %i5, %o2
if (0 > write(fd,buffer,sector_size)) {
40005438: 92 10 00 1c mov %i4, %o1
4000543c: 7f ff fb 9c call 400042ac <write>
40005440: 90 10 00 1a mov %i2, %o0
40005444: 80 a2 20 00 cmp %o0, 0
40005448: 16 bf fe 5f bge 40004dc4 <msdos_format+0x580> <== ALWAYS TAKEN
4000544c: d8 0f bf 70 ldub [ %fp + -144 ], %o4
ret_val = -1;
40005450: 10 bf fe cc b 40004f80 <msdos_format+0x73c> <== NOT EXECUTED
40005454: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
40005458: b8 10 00 01 mov %g1, %i4
4000545c: a2 10 20 00 clr %l1
40005460: b6 10 20 00 clr %i3
40005464: a4 10 20 00 clr %l2
40005468: 10 bf fd d2 b 40004bb0 <msdos_format+0x36c>
4000546c: a6 10 20 00 clr %l3
errno = EINVAL;
40005470: 40 00 59 8f call 4001baac <__errno>
40005474: b0 10 3f ff mov -1, %i0
40005478: 82 10 20 16 mov 0x16, %g1
4000547c: c2 22 00 00 st %g1, [ %o0 ]
if (ret_val == 0) {
40005480: 10 bf fd 49 b 400049a4 <msdos_format+0x160>
40005484: c4 07 bf 44 ld [ %fp + -188 ], %g2
40005488: 84 10 20 00 clr %g2
from = ""; /* default: make "from" point to empty string */
4000548c: 10 bf fd 82 b 40004a94 <msdos_format+0x250>
40005490: 86 10 e2 98 or %g3, 0x298, %g3
40005494: 84 10 20 52 mov 0x52, %g2
from = "RTEMS"; /* default: make "from" point to OS Name */
40005498: 10 bf fd 60 b 40004a18 <msdos_format+0x1d4>
4000549c: 86 10 e1 d0 or %g3, 0x1d0, %g3
fmt_params->fat_num = 2;
400054a0: 10 bf fe ec b 40005050 <msdos_format+0x80c>
400054a4: c2 2f bf 70 stb %g1, [ %fp + -144 ]
memcpy(FAT_GET_ADDR_BR_FILSYSTYPE(mbr),
400054a8: 13 10 00 9a sethi %hi(0x40026800), %o1
400054ac: 10 bf fe 06 b 40004cc4 <msdos_format+0x480>
400054b0: 92 12 61 d8 or %o1, 0x1d8, %o1 ! 400269d8 <rtems_filesystem_null_handlers+0x78>
if (fattype == FAT_FAT12) {
400054b4: 02 80 00 29 be 40005558 <msdos_format+0xd14>
400054b8: 86 10 00 08 mov %o0, %g3
else if (fattype == FAT_FAT16) {
400054bc: 80 a7 60 02 cmp %i5, 2
400054c0: 12 bf ff 64 bne 40005250 <msdos_format+0xa0c> <== NEVER TAKEN
400054c4: 01 00 00 00 nop
return sectors;
400054c8: 88 10 00 0c mov %o4, %g4
fatdata_sect_cnt = fatdata_sect_cnt
400054cc: 86 20 c0 04 sub %g3, %g4, %g3
fatdata_cluster_cnt = fatdata_sect_cnt/sectors_per_cluster;
400054d0: 81 80 20 00 wr %g0, %y
400054d4: 01 00 00 00 nop
400054d8: 01 00 00 00 nop
400054dc: 01 00 00 00 nop
400054e0: 86 70 c0 02 udiv %g3, %g2, %g3
fat_capacity = fatdata_cluster_cnt * 2;
400054e4: 10 bf ff 61 b 40005268 <msdos_format+0xa24>
400054e8: 83 28 e0 01 sll %g3, 1, %g1
if (((fattype == FAT_FAT12) && (*data_cluster_cnt > FAT_FAT12_MAX_CLN)) ||
400054ec: 80 a0 ef f5 cmp %g3, 0xff5
400054f0: 38 80 00 25 bgu,a 40005584 <msdos_format+0xd40>
400054f4: 85 28 a0 01 sll %g2, 1, %g2
*sectors_per_fat_ptr = fat_sectors_cnt / fat_num;
400054f8: 81 80 20 00 wr %g0, %y
400054fc: 01 00 00 00 nop
40005500: 01 00 00 00 nop
40005504: 01 00 00 00 nop
40005508: 82 70 40 0d udiv %g1, %o5, %g1
fmt_params->sectors_per_cluster = sectors_per_cluster_adj;
4000550c: c4 27 bf 4c st %g2, [ %fp + -180 ]
uint32_t ms_sectors_per_cluster_limit_FAT12 =
40005510: 81 80 20 00 wr %g0, %y
40005514: 01 00 00 00 nop
40005518: 01 00 00 00 nop
4000551c: 01 00 00 00 nop
40005520: 88 74 80 1b udiv %l2, %i3, %g4
uint32_t ms_sectors_per_cluster_limit_FAT16 =
40005524: 81 80 20 00 wr %g0, %y
40005528: 01 00 00 00 nop
4000552c: 01 00 00 00 nop
40005530: 01 00 00 00 nop
40005534: b6 74 40 1b udiv %l1, %i3, %i3
if ( number_of_clusters < FAT_FAT12_MAX_CLN
40005538: 80 a1 00 02 cmp %g4, %g2
4000553c: 0a bf ff 77 bcs 40005318 <msdos_format+0xad4>
40005540: c2 27 bf 50 st %g1, [ %fp + -176 ]
40005544: 80 a0 ef f4 cmp %g3, 0xff4
40005548: 08 bf ff 7a bleu 40005330 <msdos_format+0xaec>
4000554c: 82 10 20 01 mov 1, %g1
else if ( number_of_clusters < FAT_FAT16_MAX_CLN
40005550: 10 bf ff 73 b 4000531c <msdos_format+0xad8>
40005554: c2 07 bf 20 ld [ %fp + -224 ], %g1
return sectors;
40005558: 82 10 00 0c mov %o4, %g1
fatdata_sect_cnt = fatdata_sect_cnt
4000555c: 86 20 c0 01 sub %g3, %g1, %g3
fatdata_cluster_cnt = fatdata_sect_cnt/sectors_per_cluster;
40005560: 81 80 20 00 wr %g0, %y
40005564: 01 00 00 00 nop
40005568: 01 00 00 00 nop
4000556c: 01 00 00 00 nop
40005570: 86 70 c0 02 udiv %g3, %g2, %g3
fat_capacity = fatdata_cluster_cnt * 3 / 2;
40005574: 83 28 e0 01 sll %g3, 1, %g1
40005578: 82 00 40 03 add %g1, %g3, %g1
4000557c: 10 bf ff 3b b 40005268 <msdos_format+0xa24>
40005580: 83 30 60 01 srl %g1, 1, %g1
if (MS_BYTES_PER_CLUSTER_LIMIT_FAT12 < (sectors_per_cluster * bytes_per_sector)) {
40005584: 88 5e c0 02 smul %i3, %g2, %g4
40005588: 80 a1 00 10 cmp %g4, %l0
4000558c: 08 bf ff 25 bleu 40005220 <msdos_format+0x9dc> <== ALWAYS TAKEN
40005590: 80 a3 e0 00 cmp %o7, 0
40005594: 30 bf ff 55 b,a 400052e8 <msdos_format+0xaa4> <== NOT EXECUTED
*sectors_per_fat_ptr = fat_sectors_cnt / fat_num;
40005598: 81 80 20 00 wr %g0, %y
4000559c: 01 00 00 00 nop
400055a0: 01 00 00 00 nop
400055a4: 01 00 00 00 nop
400055a8: 82 70 40 0d udiv %g1, %o5, %g1
uint32_t ms_sectors_per_cluster_limit_FAT12 =
400055ac: 81 80 20 00 wr %g0, %y
400055b0: 01 00 00 00 nop
400055b4: 01 00 00 00 nop
400055b8: 01 00 00 00 nop
400055bc: 88 74 80 1b udiv %l2, %i3, %g4
uint32_t ms_sectors_per_cluster_limit_FAT16 =
400055c0: 81 80 20 00 wr %g0, %y
400055c4: 01 00 00 00 nop
400055c8: 01 00 00 00 nop
400055cc: 01 00 00 00 nop
400055d0: b6 74 40 1b udiv %l1, %i3, %i3
if ( number_of_clusters < FAT_FAT12_MAX_CLN
400055d4: 80 a1 00 02 cmp %g4, %g2
400055d8: 0a bf ff 50 bcs 40005318 <msdos_format+0xad4>
400055dc: c2 27 bf 50 st %g1, [ %fp + -176 ]
400055e0: 80 a0 ef f4 cmp %g3, 0xff4
400055e4: 18 bf ff 4e bgu 4000531c <msdos_format+0xad8> <== ALWAYS TAKEN
400055e8: c2 07 bf 20 ld [ %fp + -224 ], %g1
fmt_params->fattype = msdos_get_fat_type(
400055ec: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
400055f0: c2 2f bf 72 stb %g1, [ %fp + -142 ] <== NOT EXECUTED
fmt_params->sectors_per_cluster = 2;
400055f4: 82 10 20 02 mov 2, %g1
400055f8: c2 27 bf 4c st %g1, [ %fp + -180 ]
ret_val = msdos_set_sectors_per_cluster_from_request( rqdata,
400055fc: 92 07 bf 40 add %fp, -192, %o1
40005600: 7f ff fc 12 call 40004648 <msdos_set_sectors_per_cluster_from_request>
40005604: 90 10 00 19 mov %i1, %o0
if (fat_type != fmt_params->fattype && 1 < iteration_cnt) {
40005608: c2 0f bf 72 ldub [ %fp + -142 ], %g1
4000560c: 84 08 60 ff and %g1, 0xff, %g2
40005610: 80 a0 80 15 cmp %g2, %l5
40005614: 02 80 00 32 be 400056dc <msdos_format+0xe98> <== NEVER TAKEN
40005618: c4 07 bf 44 ld [ %fp + -188 ], %g2
4000561c: 84 0c e0 ff and %l3, 0xff, %g2
40005620: 80 a0 a0 01 cmp %g2, 1
40005624: 18 80 00 03 bgu 40005630 <msdos_format+0xdec>
40005628: 86 10 20 01 mov 1, %g3
4000562c: 86 10 20 00 clr %g3
40005630: 80 88 e0 ff btst 0xff, %g3
40005634: 02 80 00 2a be 400056dc <msdos_format+0xe98>
40005638: c4 07 bf 44 ld [ %fp + -188 ], %g2
--fmt_params->totl_sector_cnt;
4000563c: 94 00 bf ff add %g2, -1, %o2
40005640: d4 27 bf 44 st %o2, [ %fp + -188 ]
40005644: 84 10 00 0a mov %o2, %g2
while( ret_val == 0
40005648: 80 a2 20 00 cmp %o0, 0
4000564c: 02 bf fe b0 be 4000510c <msdos_format+0x8c8> <== ALWAYS TAKEN
40005650: a6 04 e0 01 inc %l3
40005654: 10 bf fc d4 b 400049a4 <msdos_format+0x160> <== NOT EXECUTED
40005658: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
return (sectors + clustersize - 1) & ~(clustersize - 1);
4000565c: 10 bf ff 9c b 400054cc <msdos_format+0xc88>
40005660: 88 08 40 04 and %g1, %g4, %g4
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
40005664: d4 07 bf 24 ld [ %fp + -220 ], %o2
40005668: 92 10 20 02 mov 2, %o1
4000566c: 7f ff fb dd call 400045e0 <msdos_format_printf>
40005670: 90 10 20 00 clr %o0
if (fmt_params->fattype == FAT_FAT32) {
40005674: ea 0f bf 72 ldub [ %fp + -142 ], %l5
40005678: 80 a5 60 04 cmp %l5, 4
4000567c: 12 80 00 0f bne 400056b8 <msdos_format+0xe74>
40005680: 82 10 20 01 mov 1, %g1
fmt_params->rsvd_sector_cnt = 32;
40005684: 82 10 20 20 mov 0x20, %g1
40005688: c2 27 bf 48 st %g1, [ %fp + -184 ]
fmt_params->mbr_copy_sec = 6;
4000568c: 82 10 20 06 mov 6, %g1
fmt_params->files_per_root_dir = 0;
40005690: c0 27 bf 58 clr [ %fp + -168 ]
fmt_params->mbr_copy_sec = 6;
40005694: 92 10 20 20 mov 0x20, %o1
40005698: c2 27 bf 68 st %g1, [ %fp + -152 ]
fmt_params->fsinfo_sec = 1;
4000569c: ba 10 20 04 mov 4, %i5
400056a0: 82 10 20 01 mov 1, %g1
+ fmt_params->bytes_per_sector - 1)
400056a4: f6 07 bf 40 ld [ %fp + -192 ], %i3
fmt_params->fsinfo_sec = 1;
400056a8: c2 27 bf 6c st %g1, [ %fp + -148 ]
400056ac: 98 10 20 00 clr %o4
400056b0: 10 bf fe bd b 400051a4 <msdos_format+0x960>
400056b4: aa 10 20 04 mov 4, %l5
fmt_params->rsvd_sector_cnt = 1;
400056b8: c2 27 bf 48 st %g1, [ %fp + -184 ]
if (fmt_params->fattype == FAT_FAT16) {
400056bc: ba 10 20 02 mov 2, %i5
ret_val = msdos_format_eval_sectors_per_cluster(fmt_params->fattype,
400056c0: d2 07 bf 48 ld [ %fp + -184 ], %o1
if (fmt_params->fattype == FAT_FAT16) {
400056c4: 80 a5 60 02 cmp %l5, 2
400056c8: 02 bf fe ab be 40005174 <msdos_format+0x930>
400056cc: 98 10 21 ff mov 0x1ff, %o4
ret_val = msdos_format_eval_sectors_per_cluster(fmt_params->fattype,
400056d0: ba 10 00 15 mov %l5, %i5
400056d4: 10 bf fe a8 b 40005174 <msdos_format+0x930>
400056d8: 98 10 20 3f mov 0x3f, %o4
if ( fmt_params->totl_sector_cnt == 0 )
400056dc: 10 bf ff db b 40005648 <msdos_format+0xe04>
400056e0: 94 10 00 02 mov %g2, %o2
memset(fmt_params.sec,0,fmt_params.bytes_per_sector);
400056e4: 40 00 5b 1f call 4001c360 <memset>
400056e8: 92 10 20 00 clr %o1
memcpy(MSDOS_DIR_NAME(fmt_params.sec),fmt_params.VolLabel,MSDOS_SHORT_NAME_LEN);
400056ec: d0 07 bf 94 ld [ %fp + -108 ], %o0
400056f0: 94 10 20 0b mov 0xb, %o2
400056f4: 40 00 5a dc call 4001c264 <memcpy>
400056f8: 92 07 bf 7c add %fp, -132, %o1
*MSDOS_DIR_ATTR(fmt_params.sec) = MSDOS_ATTR_VOLUME_ID;
400056fc: c2 07 bf 94 ld [ %fp + -108 ], %g1
40005700: 84 10 20 08 mov 8, %g2
40005704: c4 28 60 0b stb %g2, [ %g1 + 0xb ]
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
40005708: 96 10 20 00 clr %o3
ret_val = msdos_format_write_sec
4000570c: fa 07 bf 40 ld [ %fp + -192 ], %i5
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
40005710: c4 07 bf 60 ld [ %fp + -160 ], %g2
40005714: 86 57 40 02 umul %i5, %g2, %g3
40005718: 85 40 00 00 rd %y, %g2
fmt_params.sec);
4000571c: f8 07 bf 94 ld [ %fp + -108 ], %i4
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
40005720: 92 10 00 02 mov %g2, %o1
40005724: 94 10 00 03 mov %g3, %o2
40005728: 40 00 1e 4c call 4000d058 <lseek>
4000572c: 90 10 00 1a mov %i2, %o0
40005730: 80 a2 20 00 cmp %o0, 0
40005734: 06 bf ff 47 bl 40005450 <msdos_format+0xc0c> <== NEVER TAKEN
40005738: 94 10 00 1d mov %i5, %o2
if (0 > write(fd,buffer,sector_size)) {
4000573c: 92 10 00 1c mov %i4, %o1
40005740: 7f ff fa db call 400042ac <write>
40005744: 90 10 00 1a mov %i2, %o0
40005748: 80 a2 20 00 cmp %o0, 0
4000574c: 06 bf ff 41 bl 40005450 <msdos_format+0xc0c> <== NEVER TAKEN
40005750: d0 07 bf 94 ld [ %fp + -108 ], %o0
memset(fmt_params.sec,0,fmt_params.bytes_per_sector);
40005754: 10 bf fd b4 b 40004e24 <msdos_format+0x5e0>
40005758: d4 07 bf 40 ld [ %fp + -192 ], %o2
fmt_params->fattype = msdos_get_fat_type(
4000575c: 82 10 20 04 mov 4, %g1
40005760: c2 2f bf 72 stb %g1, [ %fp + -142 ]
if ( (gigs & ( 1 << b) ) != 0 )
40005764: 86 10 20 01 mov 1, %g3
40005768: c8 07 bf 1c ld [ %fp + -228 ], %g4
if (fat_type != fmt_params->fattype) {
4000576c: 80 a5 60 04 cmp %l5, 4
40005770: 12 80 00 06 bne 40005788 <msdos_format+0xf44>
40005774: 82 10 20 1f mov 0x1f, %g1
40005778: 10 bf fe f3 b 40005344 <msdos_format+0xb00>
4000577c: c2 0f bf 72 ldub [ %fp + -142 ], %g1
for ( b = 31; b > 0; b-- ) {
40005780: 02 80 00 4a be 400058a8 <msdos_format+0x1064> <== NEVER TAKEN
40005784: 84 10 20 01 mov 1, %g2
if ( (gigs & ( 1 << b) ) != 0 )
40005788: 85 28 c0 01 sll %g3, %g1, %g2
4000578c: 80 89 00 02 btst %g4, %g2
40005790: 02 bf ff fc be 40005780 <msdos_format+0xf3c>
40005794: 82 80 7f ff addcc %g1, -1, %g1
fmt_params->sectors_per_cluster = 1 << b;
40005798: 10 bf ff 99 b 400055fc <msdos_format+0xdb8>
4000579c: c4 27 bf 4c st %g2, [ %fp + -180 ]
FAT_SET_VAL8(fmt_params.sec,0,(fmt_params.media_code));
400057a0: c4 0f bf 71 ldub [ %fp + -143 ], %g2
400057a4: c4 28 40 00 stb %g2, [ %g1 ]
FAT_SET_VAL8(fmt_params.sec,1,(0x0f | (FAT_FAT12_EOC << 4)));
400057a8: 84 10 3f 8f mov -113, %g2
400057ac: c2 07 bf 94 ld [ %fp + -108 ], %g1
400057b0: c4 28 60 01 stb %g2, [ %g1 + 1 ]
break;
400057b4: a2 10 20 00 clr %l1
FAT_SET_VAL8(fmt_params.sec,2,(FAT_FAT12_EOC >> 4));
400057b8: c2 07 bf 94 ld [ %fp + -108 ], %g1
400057bc: 84 10 3f ff mov -1, %g2
break;
400057c0: 10 bf fd a7 b 40004e5c <msdos_format+0x618>
400057c4: c4 28 60 02 stb %g2, [ %g1 + 2 ]
FAT_SET_VAL32(fmt_params.sec,0,0xffffff00|fmt_params.media_code);
400057c8: c4 0f bf 71 ldub [ %fp + -143 ], %g2
400057cc: c2 07 bf 94 ld [ %fp + -108 ], %g1
400057d0: c4 28 40 00 stb %g2, [ %g1 ]
400057d4: 82 10 3f ff mov -1, %g1
400057d8: c4 07 bf 94 ld [ %fp + -108 ], %g2
400057dc: c2 28 a0 01 stb %g1, [ %g2 + 1 ]
FAT_SET_VAL32(fmt_params.sec,4,0xc0000000|FAT_FAT32_EOC);
400057e0: 86 10 3f f8 mov -8, %g3
FAT_SET_VAL32(fmt_params.sec,0,0xffffff00|fmt_params.media_code);
400057e4: c4 07 bf 94 ld [ %fp + -108 ], %g2
400057e8: c2 28 a0 02 stb %g1, [ %g2 + 2 ]
break;
400057ec: a2 10 20 00 clr %l1
FAT_SET_VAL32(fmt_params.sec,0,0xffffff00|fmt_params.media_code);
400057f0: c4 07 bf 94 ld [ %fp + -108 ], %g2
400057f4: c2 28 a0 03 stb %g1, [ %g2 + 3 ]
FAT_SET_VAL32(fmt_params.sec,4,0xc0000000|FAT_FAT32_EOC);
400057f8: c4 07 bf 94 ld [ %fp + -108 ], %g2
400057fc: c6 28 a0 04 stb %g3, [ %g2 + 4 ]
40005800: c4 07 bf 94 ld [ %fp + -108 ], %g2
40005804: c2 28 a0 05 stb %g1, [ %g2 + 5 ]
40005808: c4 07 bf 94 ld [ %fp + -108 ], %g2
4000580c: c2 28 a0 06 stb %g1, [ %g2 + 6 ]
40005810: 84 10 3f cf mov -49, %g2
40005814: c2 07 bf 94 ld [ %fp + -108 ], %g1
break;
40005818: 10 bf fd 91 b 40004e5c <msdos_format+0x618>
4000581c: c4 28 60 07 stb %g2, [ %g1 + 7 ]
FAT_SET_VAL8(fmt_params.sec,0,fmt_params.media_code);
40005820: c2 07 bf 94 ld [ %fp + -108 ], %g1
40005824: c4 0f bf 71 ldub [ %fp + -143 ], %g2
40005828: c4 28 40 00 stb %g2, [ %g1 ]
FAT_SET_VAL8(fmt_params.sec,1,0xff);
4000582c: 82 10 3f ff mov -1, %g1
40005830: c4 07 bf 94 ld [ %fp + -108 ], %g2
40005834: c2 28 a0 01 stb %g1, [ %g2 + 1 ]
FAT_SET_VAL16(fmt_params.sec,2,FAT_FAT16_EOC);
40005838: 86 10 3f f8 mov -8, %g3
4000583c: c4 07 bf 94 ld [ %fp + -108 ], %g2
40005840: c6 28 a0 02 stb %g3, [ %g2 + 2 ]
break;
40005844: a2 10 20 00 clr %l1
FAT_SET_VAL16(fmt_params.sec,2,FAT_FAT16_EOC);
40005848: c4 07 bf 94 ld [ %fp + -108 ], %g2
break;
4000584c: 10 bf fd 84 b 40004e5c <msdos_format+0x618>
40005850: c2 28 a0 03 stb %g1, [ %g2 + 3 ]
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
40005854: 15 10 00 9a sethi %hi(0x40026800), %o2
fmt_params->fat_num = 2;
40005858: c2 2f bf 70 stb %g1, [ %fp + -144 ]
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4000585c: 96 10 20 02 mov 2, %o3
40005860: 94 12 a2 68 or %o2, 0x268, %o2
40005864: 92 10 20 02 mov 2, %o1
40005868: 7f ff fb 5e call 400045e0 <msdos_format_printf>
4000586c: 90 10 20 00 clr %o0
{
40005870: 05 00 00 1f sethi %hi(0x7c00), %g2
uint32_t fat16_sect_per_clust = 32;
40005874: 82 10 20 20 mov 0x20, %g1
{
40005878: 10 bf fe 00 b 40005078 <msdos_format+0x834>
4000587c: 84 10 a3 a8 or %g2, 0x3a8, %g2
else if (fmt_params->totl_sector_cnt < FAT_FAT16_MAX_CLN * fat16_sect_per_clust) {
40005880: 84 10 a3 f5 or %g2, 0x3f5, %g2
40005884: 82 58 40 02 smul %g1, %g2, %g1
40005888: 80 a0 c0 01 cmp %g3, %g1
4000588c: 1a 80 00 67 bcc 40005a28 <msdos_format+0x11e4>
40005890: 82 10 20 04 mov 4, %g1
fmt_params->fattype = FAT_FAT16;
40005894: 82 10 20 02 mov 2, %g1
40005898: c2 2f bf 72 stb %g1, [ %fp + -142 ]
fmt_params->sectors_per_cluster = 2;
4000589c: 82 10 20 02 mov 2, %g1
400058a0: 10 bf fd fe b 40005098 <msdos_format+0x854>
400058a4: c2 27 bf 4c st %g1, [ %fp + -180 ]
fmt_params->sectors_per_cluster = 1 << b;
400058a8: 10 bf ff 55 b 400055fc <msdos_format+0xdb8> <== NOT EXECUTED
400058ac: c4 27 bf 4c st %g2, [ %fp + -180 ] <== NOT EXECUTED
if ( fmt_params->totl_sector_cnt == 0 )
400058b0: 02 bf fc 40 be 400049b0 <msdos_format+0x16c> <== NEVER TAKEN
400058b4: c4 07 bf 4c ld [ %fp + -180 ], %g2
if (FAT_FAT32 != fmt_params->fattype)
400058b8: 80 a5 60 04 cmp %l5, 4
400058bc: 02 80 00 0d be 400058f0 <msdos_format+0x10ac>
400058c0: c6 0f bf 90 ldub [ %fp + -112 ], %g3
if (! skip_alignment)
400058c4: 80 a0 e0 00 cmp %g3, 0
400058c8: 12 80 00 06 bne 400058e0 <msdos_format+0x109c>
400058cc: c8 07 bf 5c ld [ %fp + -164 ], %g4
return (sectors + clustersize - 1) & ~(clustersize - 1);
400058d0: 82 00 80 04 add %g2, %g4, %g1
400058d4: 88 20 00 02 neg %g2, %g4
400058d8: 82 00 7f ff add %g1, -1, %g1
400058dc: 88 08 40 04 and %g1, %g4, %g4
* (fmt_params->bytes_per_sector / FAT_DIRENTRY_SIZE);
400058e0: c2 07 bf 40 ld [ %fp + -192 ], %g1
400058e4: 83 30 60 05 srl %g1, 5, %g1
400058e8: 82 58 40 04 smul %g1, %g4, %g1
fmt_params->files_per_root_dir = loc_align_object (fmt_params->root_dir_sectors,
400058ec: c2 27 bf 58 st %g1, [ %fp + -168 ]
if (! skip_alignment)
400058f0: 80 a0 e0 00 cmp %g3, 0
400058f4: 12 80 00 06 bne 4000590c <msdos_format+0x10c8>
400058f8: fa 07 bf 48 ld [ %fp + -184 ], %i5
return (sectors + clustersize - 1) & ~(clustersize - 1);
400058fc: 82 00 80 1d add %g2, %i5, %g1
40005900: 84 20 00 02 neg %g2
40005904: 82 00 7f ff add %g1, -1, %g1
40005908: ba 08 40 02 and %g1, %g2, %i5
if ((rqdata != NULL) && (rqdata->media != 0)) {
4000590c: 80 a6 60 00 cmp %i1, 0
40005910: 02 80 00 15 be 40005964 <msdos_format+0x1120>
40005914: fa 27 bf 48 st %i5, [ %fp + -184 ]
40005918: f8 0e 60 14 ldub [ %i1 + 0x14 ], %i4
4000591c: 92 8f 20 ff andcc %i4, 0xff, %o1
40005920: 02 80 00 12 be 40005968 <msdos_format+0x1124>
40005924: 82 10 3f f8 mov -8, %g1
const char valid_media_codes[] =
40005928: 82 10 3f ff mov -1, %g1
4000592c: 05 3c 3e 3e sethi %hi(0xf0f8f800), %g2
40005930: 07 3e ff 3f sethi %hi(0xfbfcfc00), %g3
40005934: 84 10 a1 fa or %g2, 0x1fa, %g2
40005938: 86 10 e1 fe or %g3, 0x1fe, %g3
4000593c: c2 2f bf 38 stb %g1, [ %fp + -200 ]
if (NULL==memchr(valid_media_codes,
40005940: 94 10 20 09 mov 9, %o2
const char valid_media_codes[] =
40005944: c4 3f bf 30 std %g2, [ %fp + -208 ]
if (NULL==memchr(valid_media_codes,
40005948: 40 00 59 e7 call 4001c0e4 <memchr>
4000594c: 90 07 bf 30 add %fp, -208, %o0
40005950: 80 a2 20 00 cmp %o0, 0
40005954: 02 bf fc 17 be 400049b0 <msdos_format+0x16c> <== ALWAYS TAKEN
40005958: 01 00 00 00 nop
if ((rqdata != NULL) && (rqdata->media != 0)) {
4000595c: 10 bf fc 1a b 400049c4 <msdos_format+0x180> <== NOT EXECUTED
40005960: f8 2f bf 71 stb %i4, [ %fp + -143 ] <== NOT EXECUTED
fmt_params->media_code = FAT_BR_MEDIA_FIXED;
40005964: 82 10 3f f8 mov -8, %g1
40005968: 10 bf fc 17 b 400049c4 <msdos_format+0x180>
4000596c: c2 2f bf 71 stb %g1, [ %fp + -143 ]
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
40005970: 89 30 60 08 srl %g1, 8, %g4
40005974: c2 2f 60 24 stb %g1, [ %i5 + 0x24 ]
40005978: b9 30 60 10 srl %g1, 0x10, %i4
4000597c: c8 2f 60 25 stb %g4, [ %i5 + 0x25 ]
40005980: 89 30 60 18 srl %g1, 0x18, %g4
40005984: f8 2f 60 26 stb %i4, [ %i5 + 0x26 ]
FAT_SET_BR_FAT32_BOOTSIG(mbr ,FAT_BR_FAT32_BOOTSIG_VAL);
40005988: 82 10 20 29 mov 0x29, %g1
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
4000598c: c8 2f 60 27 stb %g4, [ %i5 + 0x27 ]
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
40005990: 94 10 20 08 mov 8, %o2
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
40005994: c8 07 bf 68 ld [ %fp + -152 ], %g4
FAT_SET_BR_FAT32_ROOT_CLUSTER(mbr , 2); /* put root dir to cluster 2 */
40005998: c6 2f 60 2c stb %g3, [ %i5 + 0x2c ]
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
4000599c: 87 31 20 08 srl %g4, 8, %g3
FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo to rsrvd sec 1*/
400059a0: c4 2f 60 30 stb %g2, [ %i5 + 0x30 ]
memset(FAT_GET_ADDR_BR_FAT32_VOLLAB(mbr) ,0,FAT_BR_VOLLAB_SIZE);
400059a4: 84 07 60 47 add %i5, 0x47, %g2
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
400059a8: c8 2f 60 32 stb %g4, [ %i5 + 0x32 ]
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
400059ac: 13 10 00 9a sethi %hi(0x40026800), %o1
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
400059b0: c6 2f 60 33 stb %g3, [ %i5 + 0x33 ]
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
400059b4: 92 12 62 d0 or %o1, 0x2d0, %o1
memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
400059b8: c0 2f 60 34 clrb [ %i5 + 0x34 ]
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
400059bc: 90 07 60 52 add %i5, 0x52, %o0
memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
400059c0: c0 2f 60 35 clrb [ %i5 + 0x35 ]
400059c4: c0 2f 60 36 clrb [ %i5 + 0x36 ]
400059c8: c0 2f 60 37 clrb [ %i5 + 0x37 ]
400059cc: c0 2f 60 38 clrb [ %i5 + 0x38 ]
400059d0: c0 2f 60 39 clrb [ %i5 + 0x39 ]
400059d4: c0 2f 60 3a clrb [ %i5 + 0x3a ]
400059d8: c0 2f 60 3b clrb [ %i5 + 0x3b ]
400059dc: c0 2f 60 3c clrb [ %i5 + 0x3c ]
400059e0: c0 2f 60 3d clrb [ %i5 + 0x3d ]
400059e4: c0 2f 60 3e clrb [ %i5 + 0x3e ]
400059e8: c0 2f 60 3f clrb [ %i5 + 0x3f ]
FAT_SET_BR_FAT32_BOOTSIG(mbr ,FAT_BR_FAT32_BOOTSIG_VAL);
400059ec: c2 2f 60 42 stb %g1, [ %i5 + 0x42 ]
memset(FAT_GET_ADDR_BR_FAT32_VOLLAB(mbr) ,0,FAT_BR_VOLLAB_SIZE);
400059f0: c0 2f 60 47 clrb [ %i5 + 0x47 ]
400059f4: c0 28 a0 01 clrb [ %g2 + 1 ]
400059f8: c0 28 a0 02 clrb [ %g2 + 2 ]
400059fc: c0 28 a0 03 clrb [ %g2 + 3 ]
40005a00: c0 28 a0 04 clrb [ %g2 + 4 ]
40005a04: c0 28 a0 05 clrb [ %g2 + 5 ]
40005a08: c0 28 a0 06 clrb [ %g2 + 6 ]
40005a0c: c0 28 a0 07 clrb [ %g2 + 7 ]
40005a10: c0 28 a0 08 clrb [ %g2 + 8 ]
40005a14: c0 28 a0 09 clrb [ %g2 + 9 ]
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
40005a18: 40 00 5a 13 call 4001c264 <memcpy>
40005a1c: c0 28 a0 0a clrb [ %g2 + 0xa ]
FAT_SET_BR_SIGNATURE(mbr, FAT_BR_SIGNATURE_VAL);
40005a20: 10 bf fc ac b 40004cd0 <msdos_format+0x48c>
40005a24: 82 10 20 55 mov 0x55, %g1
uint32_t gigs = (total_size + ONE_GB) / ONE_GB;
40005a28: 84 10 20 00 clr %g2
40005a2c: 07 10 00 00 sethi %hi(0x40000000), %g3
fmt_params->fattype = FAT_FAT32;
40005a30: c2 2f bf 72 stb %g1, [ %fp + -142 ]
uint32_t gigs = (total_size + ONE_GB) / ONE_GB;
40005a34: 9a 87 40 03 addcc %i5, %g3, %o5
for (b = 31; b > 0; b--)
40005a38: 82 10 20 1f mov 0x1f, %g1
uint32_t gigs = (total_size + ONE_GB) / ONE_GB;
40005a3c: 98 47 00 02 addx %i4, %g2, %o4
if ((gigs & (1 << b)) != 0)
40005a40: 88 10 20 01 mov 1, %g4
uint32_t gigs = (total_size + ONE_GB) / ONE_GB;
40005a44: 87 2b 20 02 sll %o4, 2, %g3
40005a48: 85 33 60 1e srl %o5, 0x1e, %g2
40005a4c: 10 80 00 04 b 40005a5c <msdos_format+0x1218>
40005a50: 86 10 c0 02 or %g3, %g2, %g3
for (b = 31; b > 0; b--)
40005a54: 02 80 00 10 be 40005a94 <msdos_format+0x1250>
40005a58: 84 10 20 01 mov 1, %g2
if ((gigs & (1 << b)) != 0)
40005a5c: 85 29 00 01 sll %g4, %g1, %g2
40005a60: 80 88 c0 02 btst %g3, %g2
40005a64: 02 bf ff fc be 40005a54 <msdos_format+0x1210>
40005a68: 82 80 7f ff addcc %g1, -1, %g1
fmt_params->sectors_per_cluster = 1 << b;
40005a6c: 10 bf fd 8b b 40005098 <msdos_format+0x854>
40005a70: c4 27 bf 4c st %g2, [ %fp + -180 ]
*volid_ptr = rand();
40005a74: 40 00 5c e8 call 4001ce14 <rand>
40005a78: 01 00 00 00 nop
40005a7c: 10 bf fc 20 b 40004afc <msdos_format+0x2b8>
40005a80: d0 27 bf 8c st %o0, [ %fp + -116 ]
if (ret_val == 0 && rqdata != NULL && rqdata->sync_device) {
40005a84: 80 a0 00 11 cmp %g0, %l1 <== NOT EXECUTED
40005a88: 82 60 3f ff subx %g0, -1, %g1 <== NOT EXECUTED
40005a8c: 10 bf fd 2d b 40004f40 <msdos_format+0x6fc> <== NOT EXECUTED
40005a90: a0 08 40 10 and %g1, %l0, %l0 <== NOT EXECUTED
fmt_params->sectors_per_cluster = 1 << b;
40005a94: 10 bf fd 81 b 40005098 <msdos_format+0x854>
40005a98: c4 27 bf 4c st %g2, [ %fp + -180 ]
400114e8 <msdos_format_dirent_with_dot>:
for (i = MSDOS_SHORT_BASE_LEN, src_tmp = src + MSDOS_SHORT_BASE_LEN - 1;
400114e8: 82 10 20 08 mov 8, %g1
400114ec: 86 02 7f ff add %o1, -1, %g3
i > 0 && *src_tmp == ' ';
400114f0: c4 48 c0 01 ldsb [ %g3 + %g1 ], %g2
400114f4: 88 10 00 01 mov %g1, %g4
400114f8: 80 a0 a0 20 cmp %g2, 0x20
400114fc: 12 80 00 14 bne 4001154c <msdos_format_dirent_with_dot+0x64>
40011500: 82 00 7f ff add %g1, -1, %g1
for (i = MSDOS_SHORT_BASE_LEN, src_tmp = src + MSDOS_SHORT_BASE_LEN - 1;
40011504: 80 a0 60 00 cmp %g1, 0
40011508: 32 bf ff fb bne,a 400114f4 <msdos_format_dirent_with_dot+0xc> <== ALWAYS TAKEN
4001150c: c4 48 c0 01 ldsb [ %g3 + %g1 ], %g2
i > 0 && *src_tmp == ' ';
40011510: c4 4a 60 0a ldsb [ %o1 + 0xa ], %g2
40011514: 80 a0 a0 20 cmp %g2, 0x20
40011518: 12 80 00 20 bne 40011598 <msdos_format_dirent_with_dot+0xb0>
4001151c: 84 10 20 2e mov 0x2e, %g2
40011520: c4 4a 60 09 ldsb [ %o1 + 9 ], %g2
40011524: 80 a0 a0 20 cmp %g2, 0x20
40011528: 12 80 00 37 bne 40011604 <msdos_format_dirent_with_dot+0x11c>
4001152c: 84 10 20 2e mov 0x2e, %g2
40011530: c4 4a 60 08 ldsb [ %o1 + 8 ], %g2
40011534: 80 a0 a0 20 cmp %g2, 0x20
40011538: 32 80 00 39 bne,a 4001161c <msdos_format_dirent_with_dot+0x134>
4001153c: 84 10 20 2e mov 0x2e, %g2
*dst = '\0'; /* terminate string */
40011540: c0 2a 00 00 clrb [ %o0 ]
}
40011544: 81 c3 e0 08 retl
40011548: 90 10 00 01 mov %g1, %o0
4001154c: 19 10 00 9d sethi %hi(0x40027400), %o4
40011550: 82 10 20 00 clr %g1
40011554: 98 13 21 61 or %o4, 0x161, %o4
*dst++ = tolower((unsigned char)(*src_tmp++));
40011558: c6 0a 40 01 ldub [ %o1 + %g1 ], %g3
4001155c: 9a 08 e0 ff and %g3, 0xff, %o5
40011560: c4 0b 00 0d ldub [ %o4 + %o5 ], %g2
40011564: 84 08 a0 03 and %g2, 3, %g2
40011568: 80 a0 a0 01 cmp %g2, 1
4001156c: 22 80 00 02 be,a 40011574 <msdos_format_dirent_with_dot+0x8c>
40011570: 86 03 60 20 add %o5, 0x20, %g3
40011574: c6 2a 00 01 stb %g3, [ %o0 + %g1 ]
while (i-- > 0) {
40011578: 82 00 60 01 inc %g1
4001157c: 84 21 00 01 sub %g4, %g1, %g2
40011580: 80 a0 a0 00 cmp %g2, 0
40011584: 34 bf ff f6 bg,a 4001155c <msdos_format_dirent_with_dot+0x74>
40011588: c6 0a 40 01 ldub [ %o1 + %g1 ], %g3
*dst++ = tolower((unsigned char)(*src_tmp++));
4001158c: 90 02 00 04 add %o0, %g4, %o0
40011590: 10 bf ff e0 b 40011510 <msdos_format_dirent_with_dot+0x28>
40011594: 82 10 00 04 mov %g4, %g1
*dst++ = '.'; /* append dot */
40011598: c4 2a 00 00 stb %g2, [ %o0 ]
++len; /* dot */
4001159c: 94 00 60 01 add %g1, 1, %o2
*dst++ = '.'; /* append dot */
400115a0: 96 02 20 01 add %o0, 1, %o3
src_tmp = src + MSDOS_SHORT_BASE_LEN;
400115a4: 92 02 60 08 add %o1, 8, %o1
--i, --src_tmp)
400115a8: 82 10 20 02 mov 2, %g1
400115ac: 19 10 00 9d sethi %hi(0x40027400), %o4
400115b0: 84 10 20 00 clr %g2
400115b4: 98 13 21 61 or %o4, 0x161, %o4
*dst++ = tolower((unsigned char)(*src_tmp++));
400115b8: c8 0a 40 02 ldub [ %o1 + %g2 ], %g4
400115bc: 9a 09 20 ff and %g4, 0xff, %o5
400115c0: c6 0b 00 0d ldub [ %o4 + %o5 ], %g3
400115c4: 86 08 e0 03 and %g3, 3, %g3
400115c8: 80 a0 e0 01 cmp %g3, 1
400115cc: 22 80 00 02 be,a 400115d4 <msdos_format_dirent_with_dot+0xec>
400115d0: 88 03 60 20 add %o5, 0x20, %g4
400115d4: c8 2a c0 02 stb %g4, [ %o3 + %g2 ]
while (i-- > 0) {
400115d8: 86 20 40 02 sub %g1, %g2, %g3
400115dc: 80 a0 e0 00 cmp %g3, 0
400115e0: 14 bf ff f6 bg 400115b8 <msdos_format_dirent_with_dot+0xd0>
400115e4: 84 00 a0 01 inc %g2
*dst++ = tolower((unsigned char)(*src_tmp++));
400115e8: 90 00 60 01 add %g1, 1, %o0
400115ec: 90 02 c0 08 add %o3, %o0, %o0
400115f0: 84 02 a0 01 add %o2, 1, %g2
*dst = '\0'; /* terminate string */
400115f4: c0 2a 00 00 clrb [ %o0 ]
++len;
400115f8: 82 00 40 02 add %g1, %g2, %g1
}
400115fc: 81 c3 e0 08 retl
40011600: 90 10 00 01 mov %g1, %o0
++len; /* dot */
40011604: 94 00 60 01 add %g1, 1, %o2
*dst++ = '.'; /* append dot */
40011608: c4 2a 00 00 stb %g2, [ %o0 ]
4001160c: 96 02 20 01 add %o0, 1, %o3
src_tmp = src + MSDOS_SHORT_BASE_LEN;
40011610: 92 02 60 08 add %o1, 8, %o1
--i, --src_tmp)
40011614: 10 bf ff e6 b 400115ac <msdos_format_dirent_with_dot+0xc4>
40011618: 82 10 20 01 mov 1, %g1
++len; /* dot */
4001161c: 94 00 60 01 add %g1, 1, %o2
*dst++ = '.'; /* append dot */
40011620: c4 2a 00 00 stb %g2, [ %o0 ]
40011624: 96 02 20 01 add %o0, 1, %o3
src_tmp = src + MSDOS_SHORT_BASE_LEN;
40011628: 92 02 60 08 add %o1, 8, %o1
--i, --src_tmp)
4001162c: 10 bf ff e0 b 400115ac <msdos_format_dirent_with_dot+0xc4>
40011630: 82 10 20 00 clr %g1
400121b0 <msdos_get_dotdot_dir_info_cluster_num_and_offset>:
{
400121b0: 9d e3 bf 50 save %sp, -176, %sp
msdos_fs_info_t *fs_info = mt_entry->fs_info;
400121b4: f8 06 20 08 ld [ %i0 + 8 ], %i4
fat_file_fd_t *fat_fd = NULL;
400121b8: c0 27 bf bc clr [ %fp + -68 ]
rc = fat_file_open(&fs_info->fat, dir_pos, &fat_fd);
400121bc: 92 10 00 1a mov %i2, %o1
rtems_dosfs_convert_control *converter = fs_info->converter;
400121c0: e0 07 20 cc ld [ %i4 + 0xcc ], %l0
rc = fat_file_open(&fs_info->fat, dir_pos, &fat_fd);
400121c4: 94 07 bf bc add %fp, -68, %o2
400121c8: 7f ff f4 df call 4000f544 <fat_file_open>
400121cc: 90 10 00 1c mov %i4, %o0
if (rc != RC_OK)
400121d0: ba 92 20 00 orcc %o0, 0, %i5
400121d4: 02 80 00 04 be 400121e4 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x34><== ALWAYS TAKEN
400121d8: d2 07 bf bc ld [ %fp + -68 ], %o1
}
400121dc: 81 c7 e0 08 ret
400121e0: 91 e8 00 1d restore %g0, %i5, %o0
fat_fd->size_limit = MSDOS_MAX_DIR_LENGTH;
400121e4: 03 00 08 00 sethi %hi(0x200000), %g1
fat_fd->cln = cln;
400121e8: f2 22 60 1c st %i1, [ %o1 + 0x1c ]
rc = fat_file_size(&fs_info->fat, fat_fd);
400121ec: 90 10 00 1c mov %i4, %o0
fat_fd->fat_file_type = FAT_DIRECTORY;
400121f0: c0 22 60 10 clr [ %o1 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGTH;
400121f4: c2 22 60 14 st %g1, [ %o1 + 0x14 ]
fat_fd->map.file_cln = 0;
400121f8: c0 22 60 34 clr [ %o1 + 0x34 ]
rc = fat_file_size(&fs_info->fat, fat_fd);
400121fc: 7f ff f8 1a call 40010264 <fat_file_size>
40012200: f2 22 60 38 st %i1, [ %o1 + 0x38 ]
if (rc != RC_OK)
40012204: ba 92 20 00 orcc %o0, 0, %i5
40012208: 12 80 00 8a bne 40012430 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x280><== NEVER TAKEN
4001220c: 98 10 20 0b mov 0xb, %o4
memset(dot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
40012210: ba 07 bf c0 add %fp, -64, %i5
msdos_long_to_short(
40012214: 96 10 00 1d mov %i5, %o3
40012218: 94 10 20 01 mov 1, %o2
4001221c: 33 10 00 9a sethi %hi(0x40026800), %i1
memset(dot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
40012220: c0 27 bf c0 clr [ %fp + -64 ]
msdos_long_to_short(
40012224: 92 16 61 10 or %i1, 0x110, %o1
memset(dot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
40012228: c0 27 bf c4 clr [ %fp + -60 ]
msdos_long_to_short(
4001222c: 90 10 00 10 mov %l0, %o0
memset(dot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
40012230: c0 27 bf c8 clr [ %fp + -56 ]
40012234: c0 27 bf cc clr [ %fp + -52 ]
40012238: c0 27 bf d0 clr [ %fp + -48 ]
4001223c: c0 27 bf d4 clr [ %fp + -44 ]
40012240: c0 27 bf d8 clr [ %fp + -40 ]
msdos_long_to_short(
40012244: 7f ff fa 8c call 40010c74 <msdos_long_to_short>
40012248: c0 27 bf dc clr [ %fp + -36 ]
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, (const uint8_t*)".", 1,
4001224c: fa 23 a0 60 st %i5, [ %sp + 0x60 ]
40012250: 9a 10 20 01 mov 1, %o5
40012254: f4 23 a0 5c st %i2, [ %sp + 0x5c ]
40012258: 98 10 20 01 mov 1, %o4
4001225c: d2 07 bf bc ld [ %fp + -68 ], %o1
40012260: 96 16 61 10 or %i1, 0x110, %o3
40012264: 94 10 20 00 clr %o2
40012268: 7f ff fc f3 call 40011634 <msdos_find_name_in_fat_file>
4001226c: 90 10 00 18 mov %i0, %o0
if (rc != RC_OK)
40012270: ba 92 20 00 orcc %o0, 0, %i5
40012274: 12 80 00 6f bne 40012430 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x280><== NEVER TAKEN
40012278: 98 10 20 0b mov 0xb, %o4
memset(dotdot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
4001227c: ba 07 bf e0 add %fp, -32, %i5
msdos_long_to_short(
40012280: 96 10 00 1d mov %i5, %o3
40012284: 94 10 20 02 mov 2, %o2
40012288: 33 10 00 9b sethi %hi(0x40026c00), %i1
memset(dotdot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
4001228c: c0 27 bf e0 clr [ %fp + -32 ]
msdos_long_to_short(
40012290: 92 16 62 50 or %i1, 0x250, %o1
memset(dotdot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
40012294: c0 27 bf e4 clr [ %fp + -28 ]
msdos_long_to_short(
40012298: 90 10 00 10 mov %l0, %o0
memset(dotdot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
4001229c: c0 27 bf e8 clr [ %fp + -24 ]
400122a0: c0 27 bf ec clr [ %fp + -20 ]
400122a4: c0 27 bf f0 clr [ %fp + -16 ]
400122a8: c0 27 bf f4 clr [ %fp + -12 ]
400122ac: c0 27 bf f8 clr [ %fp + -8 ]
msdos_long_to_short(
400122b0: 7f ff fa 71 call 40010c74 <msdos_long_to_short>
400122b4: c0 27 bf fc clr [ %fp + -4 ]
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, (const uint8_t*)"..", 2,
400122b8: fa 23 a0 60 st %i5, [ %sp + 0x60 ]
400122bc: 9a 10 20 01 mov 1, %o5
400122c0: f4 23 a0 5c st %i2, [ %sp + 0x5c ]
400122c4: 98 10 20 02 mov 2, %o4
400122c8: d2 07 bf bc ld [ %fp + -68 ], %o1
400122cc: 96 16 62 50 or %i1, 0x250, %o3
400122d0: 94 10 20 00 clr %o2
400122d4: 7f ff fc d8 call 40011634 <msdos_find_name_in_fat_file>
400122d8: 90 10 00 18 mov %i0, %o0
fat_file_close(&fs_info->fat, fat_fd);
400122dc: d2 07 bf bc ld [ %fp + -68 ], %o1
if (rc != RC_OK)
400122e0: 80 a2 20 00 cmp %o0, 0
400122e4: 12 80 00 59 bne 40012448 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x298><== NEVER TAKEN
400122e8: ba 10 00 08 mov %o0, %i5
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
400122ec: f2 17 bf da lduh [ %fp + -38 ], %i1
400122f0: e0 17 bf d4 lduh [ %fp + -44 ], %l0
rc = fat_file_close(&fs_info->fat, fat_fd);
400122f4: 7f ff f6 33 call 4000fbc0 <fat_file_close>
400122f8: 90 10 00 1c mov %i4, %o0
if ( rc != RC_OK )
400122fc: ba 92 20 00 orcc %o0, 0, %i5
40012300: 12 bf ff b7 bne 400121dc <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2c><== NEVER TAKEN
40012304: c6 17 bf fa lduh [ %fp + -6 ], %g3
if ( (MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
40012308: c4 17 bf f4 lduh [ %fp + -12 ], %g2
4001230c: 83 28 e0 08 sll %g3, 8, %g1
40012310: 89 28 a0 08 sll %g2, 8, %g4
40012314: 87 28 e0 10 sll %g3, 0x10, %g3
40012318: 85 28 a0 10 sll %g2, 0x10, %g2
4001231c: 87 30 e0 18 srl %g3, 0x18, %g3
40012320: 85 30 a0 18 srl %g2, 0x18, %g2
40012324: 82 10 40 03 or %g1, %g3, %g1
40012328: 84 11 00 02 or %g4, %g2, %g2
4001232c: 83 28 60 10 sll %g1, 0x10, %g1
40012330: 85 28 a0 10 sll %g2, 0x10, %g2
40012334: 83 30 60 10 srl %g1, 0x10, %g1
40012338: 80 90 80 01 orcc %g2, %g1, %g0
4001233c: 02 80 00 47 be 40012458 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2a8>
40012340: 82 10 3f ff mov -1, %g1
rc = fat_file_open(&fs_info->fat, dir_pos, &fat_fd);
40012344: 94 07 bf bc add %fp, -68, %o2
40012348: 92 10 00 1a mov %i2, %o1
4001234c: 7f ff f4 7e call 4000f544 <fat_file_open>
40012350: 90 10 00 1c mov %i4, %o0
if (rc != RC_OK)
40012354: ba 92 20 00 orcc %o0, 0, %i5
40012358: 12 bf ff a1 bne 400121dc <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2c><== NEVER TAKEN
4001235c: c2 17 bf fa lduh [ %fp + -6 ], %g1
if ((MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
40012360: c6 17 bf f4 lduh [ %fp + -12 ], %g3
40012364: 85 28 60 08 sll %g1, 8, %g2
40012368: 89 28 60 10 sll %g1, 0x10, %g4
4001236c: 83 28 e0 08 sll %g3, 8, %g1
40012370: 89 31 20 18 srl %g4, 0x18, %g4
40012374: 87 28 e0 10 sll %g3, 0x10, %g3
40012378: 84 10 80 04 or %g2, %g4, %g2
4001237c: 87 30 e0 18 srl %g3, 0x18, %g3
40012380: 85 28 a0 10 sll %g2, 0x10, %g2
40012384: 82 10 40 03 or %g1, %g3, %g1
40012388: 85 30 a0 10 srl %g2, 0x10, %g2
4001238c: 83 28 60 10 sll %g1, 0x10, %g1
40012390: 82 90 40 02 orcc %g1, %g2, %g1
40012394: 02 80 00 37 be 40012470 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2c0>
40012398: d2 07 bf bc ld [ %fp + -68 ], %o1
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node);
4001239c: c2 22 60 1c st %g1, [ %o1 + 0x1c ]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGTH;
400123a0: 05 00 08 00 sethi %hi(0x200000), %g2
fat_fd->fat_file_type = FAT_DIRECTORY;
400123a4: c0 22 60 10 clr [ %o1 + 0x10 ]
rc = fat_file_size(&fs_info->fat, fat_fd);
400123a8: 90 10 00 1c mov %i4, %o0
fat_fd->size_limit = MSDOS_MAX_DIR_LENGTH;
400123ac: c4 22 60 14 st %g2, [ %o1 + 0x14 ]
fat_fd->map.file_cln = 0;
400123b0: c0 22 60 34 clr [ %o1 + 0x34 ]
rc = fat_file_size(&fs_info->fat, fat_fd);
400123b4: 7f ff f7 ac call 40010264 <fat_file_size>
400123b8: c2 22 60 38 st %g1, [ %o1 + 0x38 ]
fat_file_close(&fs_info->fat, fat_fd);
400123bc: d2 07 bf bc ld [ %fp + -68 ], %o1
if (rc != RC_OK)
400123c0: 80 a2 20 00 cmp %o0, 0
400123c4: 12 80 00 21 bne 40012448 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x298><== NEVER TAKEN
400123c8: ba 10 00 08 mov %o0, %i5
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
400123cc: 95 2c 20 08 sll %l0, 8, %o2
400123d0: 83 2e 60 08 sll %i1, 8, %g1
400123d4: b3 2e 60 10 sll %i1, 0x10, %i1
400123d8: b3 36 60 18 srl %i1, 0x18, %i1
400123dc: 82 10 40 19 or %g1, %i1, %g1
400123e0: 83 28 60 10 sll %g1, 0x10, %g1
400123e4: 83 30 60 10 srl %g1, 0x10, %g1
400123e8: a1 2c 20 10 sll %l0, 0x10, %l0
rc = msdos_find_node_by_cluster_num_in_fat_file(mt_entry, fat_fd, cl4find,
400123ec: 98 10 00 1b mov %i3, %o4
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
400123f0: a1 34 20 18 srl %l0, 0x18, %l0
rc = msdos_find_node_by_cluster_num_in_fat_file(mt_entry, fat_fd, cl4find,
400123f4: 96 10 00 1a mov %i2, %o3
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
400123f8: a0 12 80 10 or %o2, %l0, %l0
rc = msdos_find_node_by_cluster_num_in_fat_file(mt_entry, fat_fd, cl4find,
400123fc: 90 10 00 18 mov %i0, %o0
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
40012400: 95 2c 20 10 sll %l0, 0x10, %o2
rc = msdos_find_node_by_cluster_num_in_fat_file(mt_entry, fat_fd, cl4find,
40012404: 7f ff ff 0a call 4001202c <msdos_find_node_by_cluster_num_in_fat_file>
40012408: 94 12 80 01 or %o2, %g1, %o2
fat_file_close(&fs_info->fat, fat_fd);
4001240c: d2 07 bf bc ld [ %fp + -68 ], %o1
rc = msdos_find_node_by_cluster_num_in_fat_file(mt_entry, fat_fd, cl4find,
40012410: ba 10 00 08 mov %o0, %i5
if (rc != RC_OK)
40012414: 80 a7 60 00 cmp %i5, 0
40012418: 12 80 00 19 bne 4001247c <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2cc><== NEVER TAKEN
4001241c: 90 10 00 1c mov %i4, %o0
rc = fat_file_close(&fs_info->fat, fat_fd);
40012420: 7f ff f5 e8 call 4000fbc0 <fat_file_close>
40012424: 01 00 00 00 nop
return rc;
40012428: 10 bf ff 6d b 400121dc <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2c>
4001242c: ba 10 00 08 mov %o0, %i5
fat_file_close(&fs_info->fat, fat_fd);
40012430: d2 07 bf bc ld [ %fp + -68 ], %o1 <== NOT EXECUTED
40012434: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
40012438: 7f ff f5 e2 call 4000fbc0 <fat_file_close> <== NOT EXECUTED
4001243c: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
}
40012440: 81 c7 e0 08 ret <== NOT EXECUTED
40012444: 81 e8 00 00 restore <== NOT EXECUTED
fat_file_close(&fs_info->fat, fat_fd);
40012448: 7f ff f5 de call 4000fbc0 <fat_file_close> <== NOT EXECUTED
4001244c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
return rc;
40012450: 81 c7 e0 08 ret <== NOT EXECUTED
40012454: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
40012458: c0 26 a0 04 clr [ %i2 + 4 ]
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
4001245c: c2 26 a0 08 st %g1, [ %i2 + 8 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
40012460: c2 26 a0 0c st %g1, [ %i2 + 0xc ]
dir_pos->sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
40012464: 82 10 20 01 mov 1, %g1
40012468: 10 bf ff b7 b 40012344 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x194>
4001246c: c2 26 80 00 st %g1, [ %i2 ]
fat_fd->cln = fs_info->fat.vol.rdir_cl;
40012470: c2 07 20 44 ld [ %i4 + 0x44 ], %g1
40012474: 10 bf ff cb b 400123a0 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1f0>
40012478: c2 22 60 1c st %g1, [ %o1 + 0x1c ]
fat_file_close(&fs_info->fat, fat_fd);
4001247c: 7f ff f5 d1 call 4000fbc0 <fat_file_close> <== NOT EXECUTED
40012480: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
return rc;
40012484: 30 bf ff ef b,a 40012440 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x290><== NOT EXECUTED
40012488 <msdos_get_name_node>:
{
40012488: 9d e3 bf 98 save %sp, -104, %sp
4001248c: e0 07 a0 5c ld [ %fp + 0x5c ], %l0
rc = msdos_find_name_in_fat_file(parent_loc->mt_entry, fat_fd,
40012490: e0 23 a0 60 st %l0, [ %sp + 0x60 ]
40012494: 9a 10 00 1c mov %i4, %o5
40012498: fa 23 a0 5c st %i5, [ %sp + 0x5c ]
4001249c: 98 10 00 1b mov %i3, %o4
400124a0: d2 06 20 08 ld [ %i0 + 8 ], %o1
400124a4: d0 06 20 14 ld [ %i0 + 0x14 ], %o0
400124a8: 96 10 00 1a mov %i2, %o3
400124ac: 7f ff fc 62 call 40011634 <msdos_find_name_in_fat_file>
400124b0: 94 10 00 19 mov %i1, %o2
if ((rc != RC_OK) && (rc != MSDOS_NAME_NOT_FOUND_ERR))
400124b4: 80 a0 00 08 cmp %g0, %o0
400124b8: 03 00 00 1f sethi %hi(0x7c00), %g1
400124bc: 86 40 20 00 addx %g0, 0, %g3
400124c0: 82 10 61 01 or %g1, 0x101, %g1
400124c4: 84 1a 00 01 xor %o0, %g1, %g2
400124c8: 80 a0 00 02 cmp %g0, %g2
400124cc: 84 40 20 00 addx %g0, 0, %g2
if (!create_node)
400124d0: 80 88 c0 02 btst %g3, %g2
400124d4: 12 80 00 04 bne 400124e4 <msdos_get_name_node+0x5c>
400124d8: 80 a6 60 00 cmp %i1, 0
400124dc: 02 80 00 04 be 400124ec <msdos_get_name_node+0x64>
400124e0: 80 a2 00 01 cmp %o0, %g1
}
400124e4: 81 c7 e0 08 ret
400124e8: 91 e8 00 08 restore %g0, %o0, %o0
if (rc == MSDOS_NAME_NOT_FOUND_ERR)
400124ec: 02 bf ff fe be 400124e4 <msdos_get_name_node+0x5c>
400124f0: 80 a2 20 00 cmp %o0, 0
if (rc == RC_OK)
400124f4: 12 bf ff fc bne 400124e4 <msdos_get_name_node+0x5c> <== NEVER TAKEN
400124f8: 01 00 00 00 nop
if (strncmp(name, "..", 2) == 0)
400124fc: c2 0e 80 00 ldub [ %i2 ], %g1
40012500: 80 a0 60 2e cmp %g1, 0x2e
40012504: 12 bf ff f8 bne 400124e4 <msdos_get_name_node+0x5c>
40012508: 01 00 00 00 nop
4001250c: c2 0e a0 01 ldub [ %i2 + 1 ], %g1
40012510: 80 a0 60 2e cmp %g1, 0x2e
40012514: 12 bf ff f4 bne 400124e4 <msdos_get_name_node+0x5c> <== NEVER TAKEN
40012518: 01 00 00 00 nop
dotdot_cln = MSDOS_EXTRACT_CLUSTER_NUM((name_dir_entry));
4001251c: c2 14 20 1a lduh [ %l0 + 0x1a ], %g1
40012520: c4 14 20 14 lduh [ %l0 + 0x14 ], %g2
40012524: b3 28 60 08 sll %g1, 8, %i1
40012528: 87 28 60 10 sll %g1, 0x10, %g3
4001252c: 83 28 a0 08 sll %g2, 8, %g1
40012530: 87 30 e0 18 srl %g3, 0x18, %g3
40012534: 85 28 a0 10 sll %g2, 0x10, %g2
40012538: b2 16 40 03 or %i1, %g3, %i1
4001253c: 85 30 a0 18 srl %g2, 0x18, %g2
40012540: b3 2e 60 10 sll %i1, 0x10, %i1
40012544: 82 10 40 02 or %g1, %g2, %g1
40012548: b3 36 60 10 srl %i1, 0x10, %i1
4001254c: 83 28 60 10 sll %g1, 0x10, %g1
if (dotdot_cln == 0)
40012550: b2 90 40 19 orcc %g1, %i1, %i1
40012554: 12 80 00 08 bne 40012574 <msdos_get_name_node+0xec>
40012558: 82 10 3f ff mov -1, %g1
dir_pos->sname.ofs = 0;
4001255c: c0 27 60 04 clr [ %i5 + 4 ]
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
40012560: c2 27 60 08 st %g1, [ %i5 + 8 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
40012564: c2 27 60 0c st %g1, [ %i5 + 0xc ]
dir_pos->sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
40012568: 82 10 20 01 mov 1, %g1
4001256c: 10 bf ff de b 400124e4 <msdos_get_name_node+0x5c>
40012570: c2 27 40 00 st %g1, [ %i5 ]
msdos_get_dotdot_dir_info_cluster_num_and_offset(parent_loc->mt_entry,
40012574: f0 06 20 14 ld [ %i0 + 0x14 ], %i0
40012578: b6 10 00 10 mov %l0, %i3
4001257c: 7f ff ff 0d call 400121b0 <msdos_get_dotdot_dir_info_cluster_num_and_offset>
40012580: 95 e8 00 1d restore %g0, %i5, %o2
40010bc0 <msdos_get_utf16_string_from_long_entry.part.0>:
msdos_get_utf16_string_from_long_entry (
40010bc0: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
memcpy (&entry_string_buf[0], &entry[1], 10 );
40010bc4: 94 10 20 0a mov 0xa, %o2 <== NOT EXECUTED
40010bc8: 92 06 20 01 add %i0, 1, %o1 <== NOT EXECUTED
40010bcc: 40 00 2d a6 call 4001c264 <memcpy> <== NOT EXECUTED
40010bd0: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
memcpy (&entry_string_buf[5], &entry[14], 12 );
40010bd4: 94 10 20 0c mov 0xc, %o2 <== NOT EXECUTED
40010bd8: 92 06 20 0e add %i0, 0xe, %o1 <== NOT EXECUTED
40010bdc: 40 00 2d a2 call 4001c264 <memcpy> <== NOT EXECUTED
40010be0: 90 06 60 0a add %i1, 0xa, %o0 <== NOT EXECUTED
memcpy (&entry_string_buf[11], &entry[28], 4 );
40010be4: c2 0e 20 1c ldub [ %i0 + 0x1c ], %g1 <== NOT EXECUTED
40010be8: c2 2e 60 16 stb %g1, [ %i1 + 0x16 ] <== NOT EXECUTED
if (is_first_entry) {
40010bec: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
memcpy (&entry_string_buf[11], &entry[28], 4 );
40010bf0: c4 0e 20 1d ldub [ %i0 + 0x1d ], %g2 <== NOT EXECUTED
40010bf4: c4 2e 60 17 stb %g2, [ %i1 + 0x17 ] <== NOT EXECUTED
40010bf8: c4 0e 20 1e ldub [ %i0 + 0x1e ], %g2 <== NOT EXECUTED
40010bfc: c4 2e 60 18 stb %g2, [ %i1 + 0x18 ] <== NOT EXECUTED
40010c00: c4 0e 20 1f ldub [ %i0 + 0x1f ], %g2 <== NOT EXECUTED
if (is_first_entry) {
40010c04: 02 80 00 0b be 40010c30 <msdos_get_utf16_string_from_long_entry.part.0+0x70><== NOT EXECUTED
40010c08: c4 2e 60 19 stb %g2, [ %i1 + 0x19 ] <== NOT EXECUTED
for (chars_in_entry = 0;
40010c0c: 82 10 20 00 clr %g1 <== NOT EXECUTED
&& entry_string_buf[chars_in_entry] != 0x0000);
40010c10: b1 28 60 01 sll %g1, 1, %i0 <== NOT EXECUTED
40010c14: c4 16 40 18 lduh [ %i1 + %i0 ], %g2 <== NOT EXECUTED
40010c18: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
40010c1c: 02 80 00 07 be 40010c38 <msdos_get_utf16_string_from_long_entry.part.0+0x78><== NOT EXECUTED
40010c20: 82 00 60 01 inc %g1 <== NOT EXECUTED
for (chars_in_entry = 0;
40010c24: 80 a0 60 0d cmp %g1, 0xd <== NOT EXECUTED
40010c28: 32 bf ff fb bne,a 40010c14 <msdos_get_utf16_string_from_long_entry.part.0+0x54><== NOT EXECUTED
40010c2c: b1 28 60 01 sll %g1, 1, %i0 <== NOT EXECUTED
}
40010c30: 81 c7 e0 08 ret <== NOT EXECUTED
40010c34: 91 e8 20 1a restore %g0, 0x1a, %o0 <== NOT EXECUTED
40010c38: 81 c7 e0 08 ret <== NOT EXECUTED
40010c3c: 81 e8 00 00 restore <== NOT EXECUTED
40005bcc <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
)
{
40005bcc: 9d e3 bf 88 save %sp, -120, %sp
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));
40005bd0: 92 10 20 d0 mov 0xd0, %o1
fat_file_fd_t *fat_fd = NULL;
40005bd4: c0 27 bf ec clr [ %fp + -20 ]
fs_info = (msdos_fs_info_t *)calloc(1, sizeof(msdos_fs_info_t));
40005bd8: 90 10 20 01 mov 1, %o0
40005bdc: 40 00 1c 67 call 4000cd78 <calloc>
40005be0: a0 10 00 18 mov %i0, %l0
if (!fs_info)
40005be4: ba 92 20 00 orcc %o0, 0, %i5
40005be8: 02 80 00 58 be 40005d48 <msdos_initialize_support+0x17c> <== NEVER TAKEN
40005bec: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(ENOMEM);
temp_mt_entry->fs_info = fs_info;
40005bf0: fa 26 20 08 st %i5, [ %i0 + 8 ]
fs_info->converter = converter;
40005bf4: f8 27 60 cc st %i4, [ %i5 + 0xcc ]
rc = fat_init_volume_info(&fs_info->fat, temp_mt_entry->dev);
40005bf8: 40 00 21 3b call 4000e0e4 <fat_init_volume_info>
40005bfc: d2 06 20 38 ld [ %i0 + 0x38 ], %o1
if (rc != RC_OK)
40005c00: b0 92 20 00 orcc %o0, 0, %i0
40005c04: 12 80 00 34 bne 40005cd4 <msdos_initialize_support+0x108> <== NEVER TAKEN
40005c08: 82 10 3f ff mov -1, %g1
{
free(fs_info);
return rc;
}
fs_info->file_handlers = file_handlers;
40005c0c: f4 27 60 ac st %i2, [ %i5 + 0xac ]
* 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;
rc = fat_file_open(&fs_info->fat, &root_pos, &fat_fd);
40005c10: 94 07 bf ec add %fp, -20, %o2
fs_info->directory_handlers = directory_handlers;
40005c14: f6 27 60 a8 st %i3, [ %i5 + 0xa8 ]
rc = fat_file_open(&fs_info->fat, &root_pos, &fat_fd);
40005c18: 92 07 bf f0 add %fp, -16, %o1
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
40005c1c: c2 27 bf f8 st %g1, [ %fp + -8 ]
40005c20: 90 10 00 1d mov %i5, %o0
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
40005c24: c2 27 bf fc st %g1, [ %fp + -4 ]
root_pos.sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
40005c28: 82 10 20 01 mov 1, %g1
dir_pos->sname.ofs = 0;
40005c2c: c0 27 bf f4 clr [ %fp + -12 ]
rc = fat_file_open(&fs_info->fat, &root_pos, &fat_fd);
40005c30: 40 00 26 45 call 4000f544 <fat_file_open>
40005c34: c2 27 bf f0 st %g1, [ %fp + -16 ]
if (rc != RC_OK)
40005c38: b0 92 20 00 orcc %o0, 0, %i0
40005c3c: 12 80 00 24 bne 40005ccc <msdos_initialize_support+0x100> <== NEVER TAKEN
40005c40: f8 07 bf ec ld [ %fp + -20 ], %i4
}
/* 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;
40005c44: c2 07 60 44 ld [ %i5 + 0x44 ], %g1
fat_fd->size_limit = MSDOS_MAX_DIR_LENGTH;
40005c48: 05 00 08 00 sethi %hi(0x200000), %g2
fat_fd->fat_file_type = FAT_DIRECTORY;
40005c4c: c0 27 20 10 clr [ %i4 + 0x10 ]
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
/* if we have FAT12/16 */
if ( fat_fd->cln == 0 )
40005c50: 80 a0 60 00 cmp %g1, 0
fat_fd->size_limit = MSDOS_MAX_DIR_LENGTH;
40005c54: c4 27 20 14 st %g2, [ %i4 + 0x14 ]
fat_fd->cln = fs_info->fat.vol.rdir_cl;
40005c58: c2 27 20 1c st %g1, [ %i4 + 0x1c ]
fat_fd->map.file_cln = 0;
40005c5c: c0 27 20 34 clr [ %i4 + 0x34 ]
if ( fat_fd->cln == 0 )
40005c60: 12 80 00 21 bne 40005ce4 <msdos_initialize_support+0x118>
40005c64: c2 27 20 38 st %g1, [ %i4 + 0x38 ]
{
fat_fd->fat_file_size = fs_info->fat.vol.rdir_size;
40005c68: c2 07 60 34 ld [ %i5 + 0x34 ], %g1
40005c6c: c2 27 20 18 st %g1, [ %i4 + 0x18 ]
cl_buf_size = (fs_info->fat.vol.bpc > fs_info->fat.vol.rdir_size) ?
40005c70: d0 07 60 08 ld [ %i5 + 8 ], %o0
40005c74: 80 a2 00 01 cmp %o0, %g1
40005c78: 2a 80 00 02 bcs,a 40005c80 <msdos_initialize_support+0xb4>
40005c7c: 90 10 00 01 mov %g1, %o0
return rc;
}
cl_buf_size = fs_info->fat.vol.bpc;
}
fs_info->cl_buf = (uint8_t *)calloc(cl_buf_size, sizeof(char));
40005c80: 40 00 1c 3e call 4000cd78 <calloc>
40005c84: 92 10 20 01 mov 1, %o1
if (fs_info->cl_buf == NULL)
40005c88: 80 a2 20 00 cmp %o0, 0
40005c8c: 02 80 00 28 be 40005d2c <msdos_initialize_support+0x160> <== NEVER TAKEN
40005c90: d0 27 60 c8 st %o0, [ %i5 + 0xc8 ]
const char *_name)
{
struct _Mutex_recursive_Control _init =
_MUTEX_RECURSIVE_NAMED_INITIALIZER(_name);
*_mutex = _init;
40005c94: 03 10 00 98 sethi %hi(0x40026000), %g1
40005c98: 82 10 62 50 or %g1, 0x250, %g1 ! 40026250 <_rodata_start+0x10>
40005c9c: c0 27 60 b0 clr [ %i5 + 0xb0 ]
40005ca0: c2 27 60 c0 st %g1, [ %i5 + 0xc0 ]
40005ca4: c0 27 60 b4 clr [ %i5 + 0xb4 ]
40005ca8: c0 27 60 b8 clr [ %i5 + 0xb8 ]
40005cac: c0 27 60 bc clr [ %i5 + 0xbc ]
40005cb0: c0 27 60 c4 clr [ %i5 + 0xc4 ]
}
rtems_recursive_mutex_init(&fs_info->vol_mutex,
RTEMS_FILESYSTEM_TYPE_DOSFS);
temp_mt_entry->mt_fs_root->location.node_access = fat_fd;
40005cb4: c2 04 20 24 ld [ %l0 + 0x24 ], %g1
40005cb8: f8 20 60 08 st %i4, [ %g1 + 8 ]
temp_mt_entry->mt_fs_root->location.handlers = directory_handlers;
40005cbc: f6 20 60 10 st %i3, [ %g1 + 0x10 ]
temp_mt_entry->ops = op_table;
40005cc0: f2 24 20 0c st %i1, [ %l0 + 0xc ]
return rc;
}
40005cc4: 81 c7 e0 08 ret
40005cc8: 81 e8 00 00 restore
fat_shutdown_drive(&fs_info->fat);
40005ccc: 40 00 23 74 call 4000ea9c <fat_shutdown_drive> <== NOT EXECUTED
40005cd0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
free(fs_info);
40005cd4: 7f ff f2 13 call 40002520 <free> <== NOT EXECUTED
40005cd8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rc;
40005cdc: 81 c7 e0 08 ret <== NOT EXECUTED
40005ce0: 81 e8 00 00 restore <== NOT EXECUTED
rc = fat_file_size(&fs_info->fat, fat_fd);
40005ce4: 92 10 00 1c mov %i4, %o1
40005ce8: 40 00 29 5f call 40010264 <fat_file_size>
40005cec: 90 10 00 1d mov %i5, %o0
if ( rc != RC_OK )
40005cf0: 82 92 20 00 orcc %o0, 0, %g1
40005cf4: 12 80 00 04 bne 40005d04 <msdos_initialize_support+0x138> <== NEVER TAKEN
40005cf8: f8 07 bf ec ld [ %fp + -20 ], %i4
cl_buf_size = fs_info->fat.vol.bpc;
40005cfc: 10 bf ff e1 b 40005c80 <msdos_initialize_support+0xb4>
40005d00: d0 07 60 08 ld [ %i5 + 8 ], %o0
fat_file_close(&fs_info->fat, fat_fd);
40005d04: d2 07 bf ec ld [ %fp + -20 ], %o1 <== NOT EXECUTED
return rc;
40005d08: b0 10 00 01 mov %g1, %i0 <== NOT EXECUTED
fat_file_close(&fs_info->fat, fat_fd);
40005d0c: 40 00 27 ad call 4000fbc0 <fat_file_close> <== NOT EXECUTED
40005d10: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
fat_shutdown_drive(&fs_info->fat);
40005d14: 40 00 23 62 call 4000ea9c <fat_shutdown_drive> <== NOT EXECUTED
40005d18: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
free(fs_info);
40005d1c: 7f ff f2 01 call 40002520 <free> <== NOT EXECUTED
40005d20: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rc;
40005d24: 81 c7 e0 08 ret <== NOT EXECUTED
40005d28: 81 e8 00 00 restore <== NOT EXECUTED
fat_file_close(&fs_info->fat, fat_fd);
40005d2c: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
40005d30: 40 00 27 a4 call 4000fbc0 <fat_file_close> <== NOT EXECUTED
40005d34: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
fat_shutdown_drive(&fs_info->fat);
40005d38: 40 00 23 59 call 4000ea9c <fat_shutdown_drive> <== NOT EXECUTED
40005d3c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
free(fs_info);
40005d40: 7f ff f1 f8 call 40002520 <free> <== NOT EXECUTED
40005d44: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
40005d48: 40 00 57 59 call 4001baac <__errno> <== NOT EXECUTED
40005d4c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40005d50: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
40005d54: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40005d58: 81 c7 e0 08 ret <== NOT EXECUTED
40005d5c: 81 e8 00 00 restore <== NOT EXECUTED
40010c40 <msdos_lfn_checksum>:
for (i = 0; i < MSDOS_SHORT_NAME_LEN; ++i) {
40010c40: 84 10 20 00 clr %g2 <== NOT EXECUTED
cs = 0;
40010c44: 82 10 20 00 clr %g1 <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + name[i];
40010c48: c8 0a 00 02 ldub [ %o0 + %g2 ], %g4 <== NOT EXECUTED
40010c4c: 82 08 60 ff and %g1, 0xff, %g1 <== NOT EXECUTED
for (i = 0; i < MSDOS_SHORT_NAME_LEN; ++i) {
40010c50: 84 00 a0 01 inc %g2 <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + name[i];
40010c54: 87 28 60 07 sll %g1, 7, %g3 <== NOT EXECUTED
for (i = 0; i < MSDOS_SHORT_NAME_LEN; ++i) {
40010c58: 80 a0 a0 0b cmp %g2, 0xb <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + name[i];
40010c5c: 83 30 60 01 srl %g1, 1, %g1 <== NOT EXECUTED
40010c60: 82 00 40 04 add %g1, %g4, %g1 <== NOT EXECUTED
for (i = 0; i < MSDOS_SHORT_NAME_LEN; ++i) {
40010c64: 12 bf ff f9 bne 40010c48 <msdos_lfn_checksum+0x8> <== NOT EXECUTED
40010c68: 82 00 c0 01 add %g3, %g1, %g1 <== NOT EXECUTED
}
40010c6c: 81 c3 e0 08 retl <== NOT EXECUTED
40010c70: 90 08 60 ff and %g1, 0xff, %o0 <== NOT EXECUTED
40010c74 <msdos_long_to_short>:
{
40010c74: 9d e3 bf 90 save %sp, -112, %sp
size_t codepage_name_len = converter->buffer.size;
40010c78: c2 06 20 08 ld [ %i0 + 8 ], %g1
40010c7c: c2 27 bf fc st %g1, [ %fp + -4 ]
memset (sfn, ' ', sfn_len);
40010c80: 92 10 20 20 mov 0x20, %o1
void *buffer = converter->buffer.data;
40010c84: fa 06 20 04 ld [ %i0 + 4 ], %i5
memset (sfn, ' ', sfn_len);
40010c88: 94 10 00 1c mov %i4, %o2
40010c8c: 40 00 2d b5 call 4001c360 <memset>
40010c90: 90 10 00 1b mov %i3, %o0
if ((lfn[0] == '.') && (lfn_len == 1))
40010c94: c2 0e 40 00 ldub [ %i1 ], %g1
40010c98: 83 28 60 18 sll %g1, 0x18, %g1
40010c9c: 85 38 60 18 sra %g1, 0x18, %g2
40010ca0: 80 a0 a0 2e cmp %g2, 0x2e
40010ca4: 02 80 00 89 be 40010ec8 <msdos_long_to_short+0x254>
40010ca8: 80 a6 a0 01 cmp %i2, 1
for (i = 0; i < lfn_len; i++)
40010cac: 80 a6 a0 00 cmp %i2, 0
40010cb0: 14 80 00 09 bg 40010cd4 <msdos_long_to_short+0x60> <== ALWAYS TAKEN
40010cb4: 84 10 20 00 clr %g2
40010cb8: 30 80 00 90 b,a 40010ef8 <msdos_long_to_short+0x284> <== NOT EXECUTED
40010cbc: 84 00 a0 01 inc %g2
40010cc0: 80 a6 80 02 cmp %i2, %g2
40010cc4: 22 80 00 42 be,a 40010dcc <msdos_long_to_short+0x158>
40010cc8: ba 10 20 00 clr %i5
if ((lfn[i] != ' ') && (lfn[i] != '.'))
40010ccc: c2 0e 40 02 ldub [ %i1 + %g2 ], %g1
40010cd0: 83 28 60 18 sll %g1, 0x18, %g1
40010cd4: 83 38 60 18 sra %g1, 0x18, %g1
40010cd8: 80 a0 60 20 cmp %g1, 0x20
40010cdc: 02 bf ff f8 be 40010cbc <msdos_long_to_short+0x48>
40010ce0: 80 a0 60 2e cmp %g1, 0x2e
40010ce4: 02 bf ff f7 be 40010cc0 <msdos_long_to_short+0x4c>
40010ce8: 84 00 a0 01 inc %g2
eno = (*converter->handler->utf8_to_codepage) (
40010cec: c2 06 00 00 ld [ %i0 ], %g1
40010cf0: c2 00 40 00 ld [ %g1 ], %g1
40010cf4: 98 07 bf fc add %fp, -4, %o4
40010cf8: 96 10 00 1d mov %i5, %o3
40010cfc: 94 10 00 1a mov %i2, %o2
40010d00: 92 10 00 19 mov %i1, %o1
40010d04: 9f c0 40 00 call %g1
40010d08: 90 10 00 18 mov %i0, %o0
if (eno == EINVAL)
40010d0c: 80 a2 20 16 cmp %o0, 0x16
40010d10: 22 80 00 5c be,a 40010e80 <msdos_long_to_short+0x20c>
40010d14: ba 10 20 02 mov 2, %i5
type = msdos_name_type (
40010d18: e4 07 bf fc ld [ %fp + -4 ], %l2
while (*name && (count < name_len))
40010d1c: ec 0f 40 00 ldub [ %i5 ], %l6
40010d20: 93 2d a0 18 sll %l6, 0x18, %o1
40010d24: 85 3c a0 1f sra %l2, 0x1f, %g2
40010d28: 80 a0 00 09 cmp %g0, %o1
40010d2c: 84 20 80 12 sub %g2, %l2, %g2
40010d30: 86 40 20 00 addx %g0, 0, %g3
40010d34: 85 30 a0 1f srl %g2, 0x1f, %g2
40010d38: 84 08 c0 02 and %g3, %g2, %g2
40010d3c: 80 a0 a0 00 cmp %g2, 0
40010d40: 02 80 00 4a be 40010e68 <msdos_long_to_short+0x1f4> <== NEVER TAKEN
40010d44: c4 2f bf f7 stb %g2, [ %fp + -9 ]
(strchr("$%'-_@~`!(){}^#&", ch) != NULL) || (unsigned char) ch > 127)
40010d48: 29 10 00 9b sethi %hi(0x40026c00), %l4
bool uppercase = false;
40010d4c: c0 2f bf f6 clrb [ %fp + -10 ]
(strchr("$%'-_@~`!(){}^#&", ch) != NULL) || (unsigned char) ch > 127)
40010d50: 82 15 23 60 or %l4, 0x360, %g1
bool lowercase = false;
40010d54: c0 2f bf f5 clrb [ %fp + -11 ]
if (strchr(" +,;=[]", ch) != NULL)
40010d58: 23 10 00 9b sethi %hi(0x40026c00), %l1
(strchr("$%'-_@~`!(){}^#&", ch) != NULL) || (unsigned char) ch > 127)
40010d5c: c2 27 bf f0 st %g1, [ %fp + -16 ]
if ((ch == '.') || isalnum((unsigned char)ch) ||
40010d60: 27 10 00 9d sethi %hi(0x40027400), %l3
int count = 0;
40010d64: ae 10 20 00 clr %l7
int dot_at = -1;
40010d68: a0 10 3f ff mov -1, %l0
if (strchr(" +,;=[]", ch) != NULL)
40010d6c: a2 14 63 58 or %l1, 0x358, %l1
if ((ch == '.') || isalnum((unsigned char)ch) ||
40010d70: a6 14 e1 61 or %l3, 0x161, %l3
if (strchr(" +,;=[]", ch) != NULL)
40010d74: a9 3a 60 18 sra %o1, 0x18, %l4
40010d78: 90 10 00 11 mov %l1, %o0
40010d7c: 40 00 31 19 call 4001d1e0 <strchr>
40010d80: 92 10 00 14 mov %l4, %o1
40010d84: 80 a2 20 00 cmp %o0, 0
40010d88: 12 80 00 3d bne 40010e7c <msdos_long_to_short+0x208>
40010d8c: 80 a5 20 2e cmp %l4, 0x2e
if ((ch == '.') || isalnum((unsigned char)ch) ||
40010d90: 02 80 00 49 be 40010eb4 <msdos_long_to_short+0x240>
40010d94: aa 0d a0 ff and %l6, 0xff, %l5
40010d98: c8 0d 40 13 ldub [ %l5 + %l3 ], %g4
40010d9c: 80 89 20 07 btst 7, %g4
40010da0: 12 80 00 0d bne 40010dd4 <msdos_long_to_short+0x160>
40010da4: d0 07 bf f0 ld [ %fp + -16 ], %o0
(strchr("$%'-_@~`!(){}^#&", ch) != NULL) || (unsigned char) ch > 127)
40010da8: 40 00 31 0e call 4001d1e0 <strchr>
40010dac: 92 10 00 14 mov %l4, %o1
40010db0: 87 35 60 07 srl %l5, 7, %g3
40010db4: 80 a0 e0 00 cmp %g3, 0
40010db8: 12 80 00 07 bne 40010dd4 <msdos_long_to_short+0x160>
40010dbc: 80 a2 20 00 cmp %o0, 0
40010dc0: 12 80 00 06 bne 40010dd8 <msdos_long_to_short+0x164>
40010dc4: 80 a4 3f ff cmp %l0, -1
return MSDOS_NAME_INVALID;
40010dc8: ba 10 20 00 clr %i5
}
40010dcc: 81 c7 e0 08 ret
40010dd0: 91 e8 00 1d restore %g0, %i5, %o0
if (dot_at >= 0)
40010dd4: 80 a4 3f ff cmp %l0, -1
40010dd8: 02 80 00 26 be 40010e70 <msdos_long_to_short+0x1fc>
40010ddc: 86 25 c0 10 sub %l7, %l0, %g3
if (is_dot || ((count - dot_at) > 3))
40010de0: 80 a0 e0 03 cmp %g3, 3
40010de4: 34 80 00 27 bg,a 40010e80 <msdos_long_to_short+0x20c>
40010de8: ba 10 20 02 mov 2, %i5
else if ((*name >= 'A') && (*name <= 'Z'))
40010dec: 86 05 bf bf add %l6, -65, %g3
40010df0: 86 08 e0 ff and %g3, 0xff, %g3
40010df4: 80 a0 e0 19 cmp %g3, 0x19
40010df8: 08 80 00 2d bleu 40010eac <msdos_long_to_short+0x238>
40010dfc: c2 0f bf f7 ldub [ %fp + -9 ], %g1
else if ((*name >= 'a') && (*name <= 'z'))
40010e00: 82 05 bf 9f add %l6, -97, %g1
40010e04: 82 08 60 ff and %g1, 0xff, %g1
40010e08: 80 a0 60 19 cmp %g1, 0x19
40010e0c: 38 80 00 05 bgu,a 40010e20 <msdos_long_to_short+0x1ac>
40010e10: ae 05 e0 01 inc %l7
lowercase = true;
40010e14: c2 0f bf f7 ldub [ %fp + -9 ], %g1
40010e18: c2 2f bf f5 stb %g1, [ %fp + -11 ]
count++;
40010e1c: ae 05 e0 01 inc %l7
while (*name && (count < name_len))
40010e20: ec 0f 40 17 ldub [ %i5 + %l7 ], %l6
40010e24: 93 2d a0 18 sll %l6, 0x18, %o1
40010e28: 80 a2 60 00 cmp %o1, 0
40010e2c: 02 80 00 08 be 40010e4c <msdos_long_to_short+0x1d8>
40010e30: 80 a4 80 17 cmp %l2, %l7
40010e34: 14 80 00 03 bg 40010e40 <msdos_long_to_short+0x1cc>
40010e38: 86 10 20 01 mov 1, %g3
40010e3c: 86 10 20 00 clr %g3
40010e40: 80 88 e0 ff btst 0xff, %g3
40010e44: 12 bf ff cd bne 40010d78 <msdos_long_to_short+0x104>
40010e48: a9 3a 60 18 sra %o1, 0x18, %l4
if (lowercase && uppercase)
40010e4c: c2 0f bf f5 ldub [ %fp + -11 ], %g1
40010e50: 80 88 60 ff btst 0xff, %g1
40010e54: 02 80 00 05 be 40010e68 <msdos_long_to_short+0x1f4>
40010e58: c2 0f bf f6 ldub [ %fp + -10 ], %g1
40010e5c: 80 88 60 ff btst 0xff, %g1
40010e60: 32 80 00 08 bne,a 40010e80 <msdos_long_to_short+0x20c>
40010e64: ba 10 20 02 mov 2, %i5
return MSDOS_NAME_SHORT;
40010e68: 10 80 00 06 b 40010e80 <msdos_long_to_short+0x20c>
40010e6c: ba 10 20 01 mov 1, %i5
if (count == 8 && !is_dot)
40010e70: 80 a5 e0 08 cmp %l7, 8
40010e74: 12 bf ff df bne 40010df0 <msdos_long_to_short+0x17c>
40010e78: 86 05 bf bf add %l6, -65, %g3
type = MSDOS_NAME_LONG;
40010e7c: ba 10 20 02 mov 2, %i5
short_filename_length = msdos_filename_utf8_to_short_name_for_save (
40010e80: 98 10 00 1c mov %i4, %o4
40010e84: 96 10 00 1b mov %i3, %o3
40010e88: 94 10 00 1a mov %i2, %o2
40010e8c: 92 10 00 19 mov %i1, %o1
40010e90: 40 00 1c 29 call 40017f34 <msdos_filename_utf8_to_short_name_for_save>
40010e94: 90 10 00 18 mov %i0, %o0
if (short_filename_length < 0 ) {
40010e98: 80 a2 20 00 cmp %o0, 0
40010e9c: 26 bf ff cc bl,a 40010dcc <msdos_long_to_short+0x158> <== NEVER TAKEN
40010ea0: ba 10 20 00 clr %i5 <== NOT EXECUTED
}
40010ea4: 81 c7 e0 08 ret
40010ea8: 91 e8 00 1d restore %g0, %i5, %o0
uppercase = true;
40010eac: 10 bf ff dc b 40010e1c <msdos_long_to_short+0x1a8>
40010eb0: c2 2f bf f6 stb %g1, [ %fp + -10 ]
if (dot_at >= 0)
40010eb4: 80 a4 3f ff cmp %l0, -1
40010eb8: 32 bf ff f2 bne,a 40010e80 <msdos_long_to_short+0x20c>
40010ebc: ba 10 20 02 mov 2, %i5
40010ec0: 10 bf ff d7 b 40010e1c <msdos_long_to_short+0x1a8>
40010ec4: a0 10 00 17 mov %l7, %l0
if ((lfn[0] == '.') && (lfn_len == 1))
40010ec8: 22 80 00 10 be,a 40010f08 <msdos_long_to_short+0x294>
40010ecc: c4 2e c0 00 stb %g2, [ %i3 ]
if ((lfn[0] == '.') && (lfn[1] == '.') && (lfn_len == 2))
40010ed0: c6 4e 60 01 ldsb [ %i1 + 1 ], %g3
40010ed4: 80 a0 e0 2e cmp %g3, 0x2e
40010ed8: 12 bf ff 75 bne 40010cac <msdos_long_to_short+0x38> <== NEVER TAKEN
40010edc: 80 a6 a0 02 cmp %i2, 2
40010ee0: 12 bf ff 74 bne 40010cb0 <msdos_long_to_short+0x3c>
40010ee4: 80 a6 a0 00 cmp %i2, 0
sfn[0] = sfn[1] = '.';
40010ee8: c4 2e e0 01 stb %g2, [ %i3 + 1 ]
return MSDOS_NAME_SHORT;
40010eec: ba 10 20 01 mov 1, %i5
40010ef0: 10 bf ff b7 b 40010dcc <msdos_long_to_short+0x158>
40010ef4: c4 2e c0 00 stb %g2, [ %i3 ]
if (i == lfn_len)
40010ef8: 32 bf ff 7e bne,a 40010cf0 <msdos_long_to_short+0x7c> <== NOT EXECUTED
40010efc: c2 06 00 00 ld [ %i0 ], %g1 <== NOT EXECUTED
40010f00: 10 bf ff b3 b 40010dcc <msdos_long_to_short+0x158> <== NOT EXECUTED
40010f04: ba 10 20 00 clr %i5 <== NOT EXECUTED
return MSDOS_NAME_SHORT;
40010f08: 10 bf ff b1 b 40010dcc <msdos_long_to_short+0x158>
40010f0c: ba 10 20 01 mov 1, %i5
40005d60 <msdos_mknod>:
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
40005d60: 9d e3 bf a0 save %sp, -96, %sp
fat_file_type_t type = 0;
/*
* Figure out what type of msdos node this is.
*/
if (S_ISDIR(mode))
40005d64: 03 00 00 3c sethi %hi(0xf000), %g1
40005d68: 05 00 00 10 sethi %hi(0x4000), %g2
40005d6c: 82 0e c0 01 and %i3, %g1, %g1
40005d70: 80 a0 40 02 cmp %g1, %g2
40005d74: 02 80 00 0b be 40005da0 <msdos_mknod+0x40>
40005d78: 07 00 00 20 sethi %hi(0x8000), %g3
{
type = FAT_DIRECTORY;
}
else if (S_ISREG(mode))
40005d7c: 80 a0 40 03 cmp %g1, %g3
40005d80: 12 80 00 0f bne 40005dbc <msdos_mknod+0x5c> <== NEVER TAKEN
40005d84: 84 10 20 04 mov 4, %g2
}
else
rtems_set_errno_and_return_minus_one(EINVAL);
/* Create an MSDOS node */
rc = msdos_creat_node(parentloc, type, name, namelen, mode, NULL);
40005d88: b8 10 00 1b mov %i3, %i4
40005d8c: ba 10 20 00 clr %i5
40005d90: b6 10 00 1a mov %i2, %i3
40005d94: b4 10 00 19 mov %i1, %i2
40005d98: 40 00 29 d9 call 400104fc <msdos_creat_node>
40005d9c: 93 e8 00 02 restore %g0, %g2, %o1
type = FAT_DIRECTORY;
40005da0: 84 10 20 00 clr %g2
rc = msdos_creat_node(parentloc, type, name, namelen, mode, NULL);
40005da4: b8 10 00 1b mov %i3, %i4
40005da8: ba 10 20 00 clr %i5
40005dac: b6 10 00 1a mov %i2, %i3
40005db0: b4 10 00 19 mov %i1, %i2
40005db4: 40 00 29 d2 call 400104fc <msdos_creat_node>
40005db8: 93 e8 00 02 restore %g0, %g2, %o1
rtems_set_errno_and_return_minus_one(EINVAL);
40005dbc: 40 00 57 3c call 4001baac <__errno> <== NOT EXECUTED
40005dc0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40005dc4: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
40005dc8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return rc;
}
40005dcc: 81 c7 e0 08 ret <== NOT EXECUTED
40005dd0: 81 e8 00 00 restore <== NOT EXECUTED
40005dd4 <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
)
{
40005dd4: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
int rc = RC_OK;
fat_file_fd_t *old_fat_fd = old_loc->node_access;
40005dd8: fa 06 60 08 ld [ %i1 + 8 ], %i5 <== NOT EXECUTED
/*
* create new directory entry as "hard link", copying relevant info from
* existing file
*/
rc = msdos_creat_node(new_parent_loc,
40005ddc: 9a 10 00 1d mov %i5, %o5 <== NOT EXECUTED
40005de0: 19 00 00 20 sethi %hi(0x8000), %o4 <== NOT EXECUTED
40005de4: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
40005de8: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
40005dec: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
40005df0: 40 00 29 c3 call 400104fc <msdos_creat_node> <== NOT EXECUTED
40005df4: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
FAT_HARD_LINK,new_name,new_namelen,S_IFREG,
old_fat_fd);
if (rc != RC_OK)
40005df8: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
40005dfc: 22 80 00 04 be,a 40005e0c <msdos_rename+0x38> <== NOT EXECUTED
40005e00: f0 06 60 14 ld [ %i1 + 0x14 ], %i0 <== NOT EXECUTED
rc = msdos_set_first_char4file_name(old_loc->mt_entry,
&old_fat_fd->dir_pos,
MSDOS_THIS_DIR_ENTRY_EMPTY);
return rc;
}
40005e04: 81 c7 e0 08 ret <== NOT EXECUTED
40005e08: 81 e8 00 00 restore <== NOT EXECUTED
rc = msdos_set_first_char4file_name(old_loc->mt_entry,
40005e0c: b4 10 20 e5 mov 0xe5, %i2 <== NOT EXECUTED
40005e10: 40 00 2c fc call 40011200 <msdos_set_first_char4file_name> <== NOT EXECUTED
40005e14: 93 ef 60 20 restore %i5, 0x20, %o1 <== NOT EXECUTED
40005e18 <msdos_rmnod>:
#include "msdos.h"
int
msdos_rmnod(const rtems_filesystem_location_info_t *parent_pathloc,
const rtems_filesystem_location_info_t *pathloc)
{
40005e18: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = pathloc->node_access;
40005e1c: fa 06 60 08 ld [ %i1 + 8 ], %i5
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
40005e20: d0 06 60 14 ld [ %i1 + 0x14 ], %o0
if (fat_fd->fat_file_type == FAT_DIRECTORY)
40005e24: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
40005e28: 80 a0 60 00 cmp %g1, 0
40005e2c: 12 80 00 11 bne 40005e70 <msdos_rmnod+0x58>
40005e30: f8 02 20 08 ld [ %o0 + 8 ], %i4
{
bool is_empty = false;
40005e34: c0 2f bf ff clrb [ %fp + -1 ]
/*
* You cannot remove a node that still has children
*/
rc = msdos_dir_is_empty(pathloc->mt_entry, fat_fd, &is_empty);
40005e38: 94 07 bf ff add %fp, -1, %o2
40005e3c: 40 00 2d 55 call 40011390 <msdos_dir_is_empty>
40005e40: 92 10 00 1d mov %i5, %o1
if (rc != RC_OK)
40005e44: b0 92 20 00 orcc %o0, 0, %i0
40005e48: 12 80 00 12 bne 40005e90 <msdos_rmnod+0x78> <== NEVER TAKEN
40005e4c: c2 0f bf ff ldub [ %fp + -1 ], %g1
{
return rc;
}
if (!is_empty)
40005e50: 80 a0 60 00 cmp %g1, 0
40005e54: 02 80 00 17 be 40005eb0 <msdos_rmnod+0x98>
40005e58: 01 00 00 00 nop
/*
* We deny attempts to delete open directory (if directory is current
* directory we assume it is open one)
*/
if (fat_fd->links_num > 1)
40005e5c: c2 07 60 08 ld [ %i5 + 8 ], %g1
40005e60: 80 a0 60 01 cmp %g1, 1
40005e64: 18 80 00 0d bgu 40005e98 <msdos_rmnod+0x80> <== NEVER TAKEN
40005e68: 01 00 00 00 nop
* not used - mount() not implemenetd yet.
*/
}
/* mark file removed */
rc = msdos_set_first_char4file_name(pathloc->mt_entry, &fat_fd->dir_pos,
40005e6c: d0 06 60 14 ld [ %i1 + 0x14 ], %o0
40005e70: 94 10 20 e5 mov 0xe5, %o2
40005e74: 40 00 2c e3 call 40011200 <msdos_set_first_char4file_name>
40005e78: 92 07 60 20 add %i5, 0x20, %o1
MSDOS_THIS_DIR_ENTRY_EMPTY);
if (rc != RC_OK)
40005e7c: b0 92 20 00 orcc %o0, 0, %i0
40005e80: 12 80 00 04 bne 40005e90 <msdos_rmnod+0x78> <== NEVER TAKEN
40005e84: 92 10 00 1d mov %i5, %o1
{
return rc;
}
fat_file_mark_removed(&fs_info->fat, fat_fd);
40005e88: 40 00 28 e1 call 4001020c <fat_file_mark_removed>
40005e8c: 90 10 00 1c mov %i4, %o0
return rc;
}
40005e90: 81 c7 e0 08 ret
40005e94: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one(EBUSY);
40005e98: 40 00 57 05 call 4001baac <__errno> <== NOT EXECUTED
40005e9c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40005ea0: 82 10 20 10 mov 0x10, %g1 <== NOT EXECUTED
40005ea4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40005ea8: 81 c7 e0 08 ret <== NOT EXECUTED
40005eac: 81 e8 00 00 restore <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOTEMPTY);
40005eb0: 40 00 56 ff call 4001baac <__errno>
40005eb4: b0 10 3f ff mov -1, %i0
40005eb8: 82 10 20 5a mov 0x5a, %g1
40005ebc: c2 22 00 00 st %g1, [ %o0 ]
40005ec0: 81 c7 e0 08 ret
40005ec4: 81 e8 00 00 restore
40011200 <msdos_set_first_char4file_name>:
{
40011200: 9d e3 bf 98 save %sp, -104, %sp
fat_pos_t start = dir_pos->lname;
40011204: c2 06 60 0c ld [ %i1 + 0xc ], %g1
40011208: c4 06 60 08 ld [ %i1 + 8 ], %g2
{
4001120c: f4 2f a0 4c stb %i2, [ %fp + 0x4c ]
fat_pos_t start = dir_pos->lname;
40011210: c2 27 bf fc st %g1, [ %fp + -4 ]
msdos_fs_info_t *fs_info = mt_entry->fs_info;
40011214: fa 06 20 08 ld [ %i0 + 8 ], %i5
fat_pos_t start = dir_pos->lname;
40011218: c4 27 bf f8 st %g2, [ %fp + -8 ]
fat_pos_t end = dir_pos->sname;
4001121c: f8 06 40 00 ld [ %i1 ], %i4
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
40011220: c2 07 60 44 ld [ %i5 + 0x44 ], %g1
40011224: 80 a0 40 1c cmp %g1, %i4
40011228: 02 80 00 54 be 40011378 <msdos_set_first_char4file_name+0x178>
4001122c: f4 06 60 04 ld [ %i1 + 4 ], %i2
dir_block_size = fs_info->fat.vol.bpc;
40011230: f6 07 60 08 ld [ %i5 + 8 ], %i3
if (dir_pos->lname.cln == FAT_FILE_SHORT_NAME)
40011234: c2 06 60 08 ld [ %i1 + 8 ], %g1
40011238: 80 a0 7f ff cmp %g1, -1
4001123c: 22 80 00 4a be,a 40011364 <msdos_set_first_char4file_name+0x164>
40011240: c2 06 60 04 ld [ %i1 + 4 ], %g1
(start.ofs >> fs_info->fat.vol.sec_log2));
40011244: c2 07 bf fc ld [ %fp + -4 ], %g1
uint32_t sec = (fat_cluster_num_to_sector_num(&fs_info->fat, start.cln) +
40011248: 10 80 00 05 b 4001125c <msdos_set_first_char4file_name+0x5c>
4001124c: d2 07 bf f8 ld [ %fp + -8 ], %o1
if (start.ofs >= dir_block_size)
40011250: 80 a0 40 1b cmp %g1, %i3
40011254: 1a 80 00 35 bcc 40011328 <msdos_set_first_char4file_name+0x128>
40011258: c2 27 bf fc st %g1, [ %fp + -4 ]
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
4001125c: 80 a2 60 00 cmp %o1, 0
40011260: 32 80 00 07 bne,a 4001127c <msdos_set_first_char4file_name+0x7c>
40011264: c4 07 60 3c ld [ %i5 + 0x3c ], %g2
40011268: c4 0f 60 16 ldub [ %i5 + 0x16 ], %g2
4001126c: 80 88 a0 03 btst 3, %g2
40011270: 32 80 00 1e bne,a 400112e8 <msdos_set_first_char4file_name+0xe8> <== ALWAYS TAKEN
40011274: c4 0f 60 02 ldub [ %i5 + 2 ], %g2
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
40011278: c4 07 60 3c ld [ %i5 + 0x3c ], %g2 <== NOT EXECUTED
4001127c: c6 0f 60 05 ldub [ %i5 + 5 ], %g3
40011280: 92 02 7f fe add %o1, -2, %o1
40011284: 93 2a 40 03 sll %o1, %g3, %o1
40011288: 92 02 40 02 add %o1, %g2, %o1
(start.ofs >> fs_info->fat.vol.sec_log2));
4001128c: c4 0f 60 02 ldub [ %i5 + 2 ], %g2
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));
40011290: d4 17 40 00 lduh [ %i5 ], %o2
(start.ofs >> fs_info->fat.vol.sec_log2));
40011294: 85 30 40 02 srl %g1, %g2, %g2
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));
40011298: 94 02 bf ff add %o2, -1, %o2
ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
4001129c: 98 07 a0 4c add %fp, 0x4c, %o4
400112a0: 94 0a 80 01 and %o2, %g1, %o2
400112a4: 96 10 20 01 mov 1, %o3
400112a8: 92 00 80 09 add %g2, %o1, %o1
400112ac: 7f ff f2 bf call 4000dda8 <fat_sector_write>
400112b0: 90 10 00 1d mov %i5, %o0
if (ret < 0)
400112b4: 80 a2 20 00 cmp %o0, 0
400112b8: 06 80 00 1a bl 40011320 <msdos_set_first_char4file_name+0x120> <== NEVER TAKEN
400112bc: b0 10 3f ff mov -1, %i0
if ((start.cln == end.cln) && (start.ofs == end.ofs))
400112c0: d2 07 bf f8 ld [ %fp + -8 ], %o1
400112c4: c4 07 bf fc ld [ %fp + -4 ], %g2
400112c8: 80 a7 00 09 cmp %i4, %o1
400112cc: 12 bf ff e1 bne 40011250 <msdos_set_first_char4file_name+0x50>
400112d0: 82 00 a0 20 add %g2, 0x20, %g1
400112d4: 80 a6 80 02 cmp %i2, %g2
400112d8: 12 bf ff df bne 40011254 <msdos_set_first_char4file_name+0x54>
400112dc: 80 a0 40 1b cmp %g1, %i3
return RC_OK;
400112e0: 81 c7 e0 08 ret
400112e4: 91 e8 20 00 restore %g0, 0, %o0
return fs_info->vol.rdir_loc;
400112e8: d2 07 60 28 ld [ %i5 + 0x28 ], %o1
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));
400112ec: d4 17 40 00 lduh [ %i5 ], %o2
(start.ofs >> fs_info->fat.vol.sec_log2));
400112f0: 85 30 40 02 srl %g1, %g2, %g2
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));
400112f4: 94 02 bf ff add %o2, -1, %o2
ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
400112f8: 98 07 a0 4c add %fp, 0x4c, %o4
400112fc: 94 0a 80 01 and %o2, %g1, %o2
40011300: 96 10 20 01 mov 1, %o3
40011304: 92 00 80 09 add %g2, %o1, %o1
40011308: 7f ff f2 a8 call 4000dda8 <fat_sector_write>
4001130c: 90 10 00 1d mov %i5, %o0
if (ret < 0)
40011310: 80 a2 20 00 cmp %o0, 0
40011314: 16 bf ff ec bge 400112c4 <msdos_set_first_char4file_name+0xc4> <== ALWAYS TAKEN
40011318: d2 07 bf f8 ld [ %fp + -8 ], %o1
return -1;
4001131c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
}
40011320: 81 c7 e0 08 ret <== NOT EXECUTED
40011324: 81 e8 00 00 restore <== NOT EXECUTED
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
40011328: c2 07 60 44 ld [ %i5 + 0x44 ], %g1
4001132c: 80 a7 00 01 cmp %i4, %g1
40011330: 12 80 00 06 bne 40011348 <msdos_set_first_char4file_name+0x148> <== ALWAYS TAKEN
40011334: 94 07 bf f8 add %fp, -8, %o2
40011338: c2 0f 60 16 ldub [ %i5 + 0x16 ], %g1 <== NOT EXECUTED
4001133c: 80 88 60 03 btst 3, %g1 <== NOT EXECUTED
40011340: 12 bf ff e8 bne 400112e0 <msdos_set_first_char4file_name+0xe0> <== NOT EXECUTED
40011344: 01 00 00 00 nop <== NOT EXECUTED
rc = fat_get_fat_cluster(&fs_info->fat, start.cln, &start.cln);
40011348: 7f ff f6 8d call 4000ed7c <fat_get_fat_cluster>
4001134c: 90 10 00 1d mov %i5, %o0
if ( rc != RC_OK )
40011350: b0 92 20 00 orcc %o0, 0, %i0
40011354: 12 bf ff f3 bne 40011320 <msdos_set_first_char4file_name+0x120> <== NEVER TAKEN
40011358: 82 10 20 00 clr %g1
start.ofs = 0;
4001135c: 10 bf ff bb b 40011248 <msdos_set_first_char4file_name+0x48>
40011360: c0 27 bf fc clr [ %fp + -4 ]
start = dir_pos->sname;
40011364: c2 27 bf fc st %g1, [ %fp + -4 ]
40011368: c4 06 40 00 ld [ %i1 ], %g2
4001136c: c4 27 bf f8 st %g2, [ %fp + -8 ]
(start.ofs >> fs_info->fat.vol.sec_log2));
40011370: 10 bf ff b6 b 40011248 <msdos_set_first_char4file_name+0x48>
40011374: c2 07 bf fc ld [ %fp + -4 ], %g1
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
40011378: c2 0f 60 16 ldub [ %i5 + 0x16 ], %g1
4001137c: 80 88 60 03 btst 3, %g1
40011380: 22 bf ff ad be,a 40011234 <msdos_set_first_char4file_name+0x34> <== NEVER TAKEN
40011384: f6 07 60 08 ld [ %i5 + 8 ], %i3 <== NOT EXECUTED
dir_block_size = fs_info->fat.vol.rdir_size;
40011388: 10 bf ff ab b 40011234 <msdos_set_first_char4file_name+0x34>
4001138c: f6 07 60 34 ld [ %i5 + 0x34 ], %i3
40005ec8 <msdos_statvfs>:
#include "msdos.h"
int msdos_statvfs(
const rtems_filesystem_location_info_t *__restrict root_loc,
struct statvfs *__restrict sb)
{
40005ec8: 9d e3 bf 98 save %sp, -104, %sp
msdos_fs_info_t *fs_info = root_loc->mt_entry->fs_info;
40005ecc: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
40005ed0: f8 00 60 08 ld [ %g1 + 8 ], %i4
rtems_recursive_mutex_lock(&fs_info->vol_mutex);
40005ed4: a2 07 20 b0 add %i4, 0xb0, %l1
_Mutex_recursive_Acquire( mutex );
40005ed8: 40 00 0d ec call 40009688 <_Mutex_recursive_Acquire>
40005edc: 90 10 00 11 mov %l1, %o0
fat_vol_t *vol = &fs_info->fat.vol;
msdos_fs_lock(fs_info);
sb->f_bsize = FAT_SECTOR512_SIZE;
sb->f_frsize = vol->bpc;
40005ee0: c2 07 20 08 ld [ %i4 + 8 ], %g1
sb->f_blocks = vol->data_cls;
40005ee4: e0 07 20 40 ld [ %i4 + 0x40 ], %l0
sb->f_frsize = vol->bpc;
40005ee8: c2 26 60 04 st %g1, [ %i1 + 4 ]
sb->f_bsize = FAT_SECTOR512_SIZE;
40005eec: 84 10 22 00 mov 0x200, %g2
sb->f_bavail = 0;
sb->f_files = 0; // FAT doesn't store inodes
sb->f_ffree = 0;
sb->f_favail = 0;
sb->f_flag = 0;
sb->f_namemax = MSDOS_NAME_MAX_LNF_LEN;
40005ef0: 82 10 20 ff mov 0xff, %g1
sb->f_bsize = FAT_SECTOR512_SIZE;
40005ef4: c4 26 40 00 st %g2, [ %i1 ]
sb->f_namemax = MSDOS_NAME_MAX_LNF_LEN;
40005ef8: c2 26 60 34 st %g1, [ %i1 + 0x34 ]
sb->f_bfree = 0;
40005efc: c0 26 60 10 clr [ %i1 + 0x10 ]
40005f00: c0 26 60 14 clr [ %i1 + 0x14 ]
sb->f_bavail = 0;
40005f04: c0 26 60 18 clr [ %i1 + 0x18 ]
40005f08: c0 26 60 1c clr [ %i1 + 0x1c ]
sb->f_blocks = vol->data_cls;
40005f0c: c0 26 60 08 clr [ %i1 + 8 ]
40005f10: e0 26 60 0c st %l0, [ %i1 + 0xc ]
sb->f_files = 0; // FAT doesn't store inodes
40005f14: c0 26 60 20 clr [ %i1 + 0x20 ]
sb->f_ffree = 0;
40005f18: c0 26 60 24 clr [ %i1 + 0x24 ]
sb->f_favail = 0;
40005f1c: c0 26 60 28 clr [ %i1 + 0x28 ]
sb->f_flag = 0;
40005f20: c0 26 60 30 clr [ %i1 + 0x30 ]
if (vol->free_cls == FAT_UNDEFINED_VALUE)
40005f24: c2 07 20 4c ld [ %i4 + 0x4c ], %g1
40005f28: 80 a0 7f ff cmp %g1, -1
40005f2c: 22 80 00 0b be,a 40005f58 <msdos_statvfs+0x90> <== ALWAYS TAKEN
40005f30: c0 27 bf fc clr [ %fp + -4 ]
}
}
}
else
{
sb->f_bfree = vol->free_cls;
40005f34: c0 26 60 10 clr [ %i1 + 0x10 ] <== NOT EXECUTED
40005f38: c2 26 60 14 st %g1, [ %i1 + 0x14 ] <== NOT EXECUTED
sb->f_bavail = vol->free_cls;
40005f3c: c0 26 60 18 clr [ %i1 + 0x18 ] <== NOT EXECUTED
40005f40: c2 26 60 1c st %g1, [ %i1 + 0x1c ] <== NOT EXECUTED
}
msdos_fs_unlock(fs_info);
return RC_OK;
40005f44: b0 10 20 00 clr %i0 <== NOT EXECUTED
_Mutex_recursive_Release( mutex );
40005f48: 40 00 0d f5 call 4000971c <_Mutex_recursive_Release>
40005f4c: 90 10 00 11 mov %l1, %o0
}
40005f50: 81 c7 e0 08 ret
40005f54: 81 e8 00 00 restore
uint32_t data_cls_val = vol->data_cls + 2;
40005f58: a0 04 20 02 add %l0, 2, %l0
for (; cur_cl < data_cls_val; ++cur_cl)
40005f5c: 80 a4 20 02 cmp %l0, 2
40005f60: 18 80 00 12 bgu 40005fa8 <msdos_statvfs+0xe0> <== ALWAYS TAKEN
40005f64: ba 10 20 02 mov 2, %i5
return RC_OK;
40005f68: 10 bf ff f8 b 40005f48 <msdos_statvfs+0x80> <== NOT EXECUTED
40005f6c: b0 10 20 00 clr %i0 <== NOT EXECUTED
if (value == FAT_GENFAT_FREE)
40005f70: 80 a0 60 00 cmp %g1, 0
40005f74: 12 80 00 0a bne 40005f9c <msdos_statvfs+0xd4>
40005f78: ba 07 60 01 inc %i5
sb->f_bfree++;
40005f7c: f4 1e 60 10 ldd [ %i1 + 0x10 ], %i2
sb->f_bavail++;
40005f80: c4 1e 60 18 ldd [ %i1 + 0x18 ], %g2
sb->f_bfree++;
40005f84: 9a 86 e0 01 addcc %i3, 1, %o5
40005f88: 98 46 a0 00 addx %i2, 0, %o4
sb->f_bavail++;
40005f8c: b6 80 e0 01 addcc %g3, 1, %i3
sb->f_bfree++;
40005f90: d8 3e 60 10 std %o4, [ %i1 + 0x10 ]
sb->f_bavail++;
40005f94: b4 40 a0 00 addx %g2, 0, %i2
40005f98: f4 3e 60 18 std %i2, [ %i1 + 0x18 ]
for (; cur_cl < data_cls_val; ++cur_cl)
40005f9c: 80 a4 00 1d cmp %l0, %i5
40005fa0: 02 bf ff ea be 40005f48 <msdos_statvfs+0x80>
40005fa4: b0 10 20 00 clr %i0
rc = fat_get_fat_cluster(&fs_info->fat, cur_cl, &value);
40005fa8: 92 10 00 1d mov %i5, %o1
40005fac: 94 07 bf fc add %fp, -4, %o2
40005fb0: 40 00 23 73 call 4000ed7c <fat_get_fat_cluster>
40005fb4: 90 10 00 1c mov %i4, %o0
if (rc != RC_OK)
40005fb8: b0 92 20 00 orcc %o0, 0, %i0
40005fbc: 02 bf ff ed be 40005f70 <msdos_statvfs+0xa8> <== ALWAYS TAKEN
40005fc0: c2 07 bf fc ld [ %fp + -4 ], %g1
40005fc4: 40 00 0d d6 call 4000971c <_Mutex_recursive_Release> <== NOT EXECUTED
40005fc8: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
return rc;
40005fcc: 81 c7 e0 08 ret <== NOT EXECUTED
40005fd0: 81 e8 00 00 restore <== NOT EXECUTED
400104c4 <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)
{
400104c4: 9d e3 bf a0 save %sp, -96, %sp
msdos_default_convert_control *self = malloc( sizeof( *self ) );
400104c8: 7f ff c8 fa call 400028b0 <malloc>
400104cc: 90 10 22 14 mov 0x214, %o0
if ( self != NULL ) {
400104d0: b0 92 20 00 orcc %o0, 0, %i0
400104d4: 02 80 00 08 be 400104f4 <rtems_dosfs_create_default_converter+0x30> <== NEVER TAKEN
400104d8: 03 10 00 9b sethi %hi(0x40026c00), %g1
rtems_dosfs_convert_control *super = &self->super;
super->handler = &msdos_default_convert_handler;
400104dc: 82 10 62 b4 or %g1, 0x2b4, %g1 ! 40026eb4 <msdos_default_convert_handler>
super->buffer.data = &self->buffer;
400104e0: 84 06 20 0c add %i0, 0xc, %g2
super->handler = &msdos_default_convert_handler;
400104e4: c2 26 00 00 st %g1, [ %i0 ]
super->buffer.size = sizeof( self->buffer );
400104e8: 82 10 22 08 mov 0x208, %g1
super->buffer.data = &self->buffer;
400104ec: c4 26 20 04 st %g2, [ %i0 + 4 ]
super->buffer.size = sizeof( self->buffer );
400104f0: c2 26 20 08 st %g1, [ %i0 + 8 ]
}
return &self->super;
}
400104f4: 81 c7 e0 08 ret
400104f8: 81 e8 00 00 restore
40006200 <rtems_dosfs_create_utf8_converter>:
};
rtems_dosfs_convert_control *rtems_dosfs_create_utf8_converter(
const char *codepage
)
{
40006200: 9d e3 bf a0 save %sp, -96, %sp
msdos_utf8_convert_control *self = malloc( sizeof( *self ) );
40006204: 7f ff f5 ee call 400039bc <malloc>
40006208: 90 10 24 2c mov 0x42c, %o0
if ( self != NULL ) {
4000620c: ba 92 20 00 orcc %o0, 0, %i5
40006210: 02 80 00 2c be 400062c0 <rtems_dosfs_create_utf8_converter+0xc0> <== NEVER TAKEN
40006214: 39 10 00 cd sethi %hi(0x40033400), %i4
self->desc_codepage_to_utf8 = iconv_open( "UTF-8", codepage );
40006218: 92 10 00 18 mov %i0, %o1
4000621c: 40 00 65 00 call 4001f61c <iconv_open>
40006220: 90 17 23 38 or %i4, 0x338, %o0
40006224: d0 27 60 0c st %o0, [ %i5 + 0xc ]
self->desc_utf8_to_codepage = iconv_open( codepage, "UTF-8" );
40006228: 92 17 23 38 or %i4, 0x338, %o1
4000622c: 40 00 64 fc call 4001f61c <iconv_open>
40006230: 90 10 00 18 mov %i0, %o0
40006234: d0 27 60 10 st %o0, [ %i5 + 0x10 ]
self->desc_utf16_to_utf8 = iconv_open( "UTF-8", "UTF-16LE" );
40006238: 37 10 00 cd sethi %hi(0x40033400), %i3
4000623c: 90 17 23 38 or %i4, 0x338, %o0
40006240: 40 00 64 f7 call 4001f61c <iconv_open>
40006244: 92 16 e3 40 or %i3, 0x340, %o1
40006248: d0 27 60 14 st %o0, [ %i5 + 0x14 ]
self->desc_utf8_to_utf16 = iconv_open( "UTF-16LE", "UTF-8" );
4000624c: 92 17 23 38 or %i4, 0x338, %o1
40006250: 40 00 64 f3 call 4001f61c <iconv_open>
40006254: 90 16 e3 40 or %i3, 0x340, %o0
40006258: d0 27 60 18 st %o0, [ %i5 + 0x18 ]
if (
4000625c: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
40006260: 80 a0 7f ff cmp %g1, -1
40006264: 22 80 00 15 be,a 400062b8 <rtems_dosfs_create_utf8_converter+0xb8> <== NEVER TAKEN
40006268: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
self->desc_utf16_to_utf8 != INVALID_ICONV_DESC
&& self->desc_utf8_to_codepage != INVALID_ICONV_DESC
4000626c: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
40006270: 80 a0 7f ff cmp %g1, -1
40006274: 22 80 00 11 be,a 400062b8 <rtems_dosfs_create_utf8_converter+0xb8> <== NEVER TAKEN
40006278: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
&& self->desc_codepage_to_utf8 != INVALID_ICONV_DESC
4000627c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
&& self->desc_utf8_to_utf16 != INVALID_ICONV_DESC
40006280: 80 a0 7f ff cmp %g1, -1
40006284: 02 80 00 0c be 400062b4 <rtems_dosfs_create_utf8_converter+0xb4> <== NEVER TAKEN
40006288: 80 a2 3f ff cmp %o0, -1
4000628c: 02 80 00 0a be 400062b4 <rtems_dosfs_create_utf8_converter+0xb4> <== NEVER TAKEN
40006290: 03 10 00 cd sethi %hi(0x40033400), %g1
) {
rtems_dosfs_convert_control *super = &self->super;
super->handler = &msdos_utf8_convert_handler;
40006294: 82 10 63 7c or %g1, 0x37c, %g1 ! 4003377c <msdos_utf8_convert_handler>
super->buffer.data = &self->buffer;
40006298: 84 07 60 1c add %i5, 0x1c, %g2
super->handler = &msdos_utf8_convert_handler;
4000629c: c2 27 40 00 st %g1, [ %i5 ]
super->buffer.size = sizeof( self->buffer );
400062a0: 82 10 24 10 mov 0x410, %g1
super->buffer.data = &self->buffer;
400062a4: c4 27 60 04 st %g2, [ %i5 + 4 ]
super->buffer.size = sizeof( self->buffer );
400062a8: c2 27 60 08 st %g1, [ %i5 + 8 ]
self = NULL;
}
}
return &self->super;
}
400062ac: 81 c7 e0 08 ret
400062b0: 91 e8 00 1d restore %g0, %i5, %o0
msdos_utf8_destroy( &self->super );
400062b4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
400062b8: 7f ff ff 43 call 40005fc4 <msdos_utf8_destroy> <== NOT EXECUTED
400062bc: ba 10 20 00 clr %i5 <== NOT EXECUTED
}
400062c0: 81 c7 e0 08 ret <== NOT EXECUTED
400062c4: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
40005b24 <rtems_dosfs_initialize>:
*/
int rtems_dosfs_initialize(
rtems_filesystem_mount_table_entry_t *mt_entry,
const void *data
)
{
40005b24: 9d e3 bf a0 save %sp, -96, %sp
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) {
40005b28: 80 a6 60 00 cmp %i1, 0
40005b2c: 02 80 00 0c be 40005b5c <rtems_dosfs_initialize+0x38>
40005b30: b6 10 00 18 mov %i0, %i3
40005b34: f8 06 40 00 ld [ %i1 ], %i4
40005b38: 80 a7 20 00 cmp %i4, 0
40005b3c: 02 80 00 08 be 40005b5c <rtems_dosfs_initialize+0x38> <== NEVER TAKEN
40005b40: 35 10 00 9b sethi %hi(0x40026c00), %i2
} else {
converter = mount_options->converter;
}
if (converter != NULL) {
rc = msdos_initialize_support(mt_entry,
40005b44: 37 10 00 9b sethi %hi(0x40026c00), %i3
40005b48: 33 10 00 9a sethi %hi(0x40026800), %i1
40005b4c: b6 16 e2 d4 or %i3, 0x2d4, %i3
40005b50: b4 16 a3 14 or %i2, 0x314, %i2
40005b54: 40 00 00 1e call 40005bcc <msdos_initialize_support>
40005b58: 93 ee 63 14 restore %i1, 0x314, %o1
converter = rtems_dosfs_create_default_converter();
40005b5c: 40 00 2a 5a call 400104c4 <rtems_dosfs_create_default_converter>
40005b60: 01 00 00 00 nop
if (converter != NULL) {
40005b64: ba 92 20 00 orcc %o0, 0, %i5
40005b68: 02 80 00 13 be 40005bb4 <rtems_dosfs_initialize+0x90> <== NEVER TAKEN
40005b6c: 98 10 00 1d mov %i5, %o4
rc = msdos_initialize_support(mt_entry,
40005b70: 17 10 00 9b sethi %hi(0x40026c00), %o3
40005b74: 15 10 00 9b sethi %hi(0x40026c00), %o2
40005b78: 96 12 e2 d4 or %o3, 0x2d4, %o3
40005b7c: 94 12 a3 14 or %o2, 0x314, %o2
40005b80: 90 10 00 1b mov %i3, %o0
40005b84: 13 10 00 9a sethi %hi(0x40026800), %o1
40005b88: 40 00 00 11 call 40005bcc <msdos_initialize_support>
40005b8c: 92 12 63 14 or %o1, 0x314, %o1 ! 40026b14 <msdos_ops>
&msdos_ops,
&msdos_file_handlers,
&msdos_dir_handlers,
converter);
if (rc != 0 && converter_created) {
40005b90: b0 92 20 00 orcc %o0, 0, %i0
40005b94: 02 80 00 0c be 40005bc4 <rtems_dosfs_initialize+0xa0> <== ALWAYS TAKEN
40005b98: 01 00 00 00 nop
(*converter->handler->destroy)(converter);
40005b9c: c2 07 40 00 ld [ %i5 ], %g1 <== NOT EXECUTED
40005ba0: c2 00 60 14 ld [ %g1 + 0x14 ], %g1 <== NOT EXECUTED
40005ba4: 9f c0 40 00 call %g1 <== NOT EXECUTED
40005ba8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40005bac: 81 c7 e0 08 ret <== NOT EXECUTED
40005bb0: 81 e8 00 00 restore <== NOT EXECUTED
}
} else {
errno = ENOMEM;
40005bb4: 40 00 57 be call 4001baac <__errno> <== NOT EXECUTED
40005bb8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40005bbc: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
40005bc0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rc = -1;
}
return rc;
40005bc4: 81 c7 e0 08 ret
40005bc8: 81 e8 00 00 restore