000000004002d6a0 <_fat_block_read>:
uint32_t start,
uint32_t offset,
uint32_t count,
void *buff
)
{
4002d6a0: a9ba7bfd stp x29, x30, [sp, #-96]!
4002d6a4: 910003fd mov x29, sp
4002d6a8: a9025bf5 stp x21, x22, [sp, #32]
uint32_t sec_num = start;
uint32_t ofs = offset;
uint8_t *sec_buf;
uint32_t c = 0;
while (count > 0)
4002d6ac: 34000783 cbz w3, 4002d79c <_fat_block_read+0xfc> <== NEVER TAKEN
4002d6b0: aa0403f6 mov x22, x4
4002d6b4: a90153f3 stp x19, x20, [sp, #16]
4002d6b8: aa0003f3 mov x19, x0
4002d6bc: 2a0203f4 mov w20, w2
4002d6c0: a90363f7 stp x23, x24, [sp, #48]
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &fs_info->c.buf);
4002d6c4: 9102e017 add x23, x0, #0xb8
4002d6c8: a90573fb stp x27, x28, [sp, #80]
4002d6cc: 2a0103fc mov w28, w1
4002d6d0: 2a0303fb mov w27, w3
ssize_t cmpltd = 0;
4002d6d4: d2800015 mov x21, #0x0 // #0
fs_info->c.modified = 0;
4002d6d8: 52802018 mov w24, #0x100 // #256
4002d6dc: a9046bf9 stp x25, x26, [sp, #64]
return sector_number >> (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
4002d6e0: 39400a79 ldrb w25, [x19, #2]
4002d6e4: 39405265 ldrb w5, [x19, #20]
4002d6e8: aa1303e0 mov x0, x19
if (fs_info->c.state == FAT_CACHE_EMPTY || fs_info->c.blk_num != sec_num)
4002d6ec: 3942d661 ldrb w1, [x19, #181]
4002d6f0: 4b1900a5 sub w5, w5, w25
4002d6f4: 1ac5279a lsr w26, w28, w5
return block_number << (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
4002d6f8: 1ac52345 lsl w5, w26, w5
((sector -
4002d6fc: 4b050385 sub w5, w28, w5
<< fs_info->vol.sec_log2);
4002d700: 1ad920b9 lsl w25, w5, w25
4002d704: 340000a1 cbz w1, 4002d718 <_fat_block_read+0x78>
4002d708: b940b261 ldr w1, [x19, #176]
4002d70c: 6b1c003f cmp w1, w28
4002d710: 54000120 b.eq 4002d734 <_fat_block_read+0x94> // b.none
4002d714: 97ffff3b bl 4002d400 <fat_buf_release.part.0>
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &fs_info->c.buf);
4002d718: f9403a60 ldr x0, [x19, #112]
4002d71c: 2a1a03e1 mov w1, w26
4002d720: aa1703e2 mov x2, x23
4002d724: 940022c7 bl 40036240 <rtems_bdbuf_read>
if (sc != RTEMS_SUCCESSFUL)
4002d728: 350003e0 cbnz w0, 4002d7a4 <_fat_block_read+0x104> <== NEVER TAKEN
fs_info->c.blk_num = sec_num;
4002d72c: b900b27c str w28, [x19, #176]
fs_info->c.modified = 0;
4002d730: 79016a78 strh w24, [x19, #180]
*sec_buf = &fs_info->c.buf->buffer[blk_ofs];
4002d734: f9405e61 ldr x1, [x19, #184]
4002d738: 2a1903e5 mov w5, w25
{
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));
4002d73c: 79400264 ldrh w4, [x19]
memcpy((buff + cmpltd), (sec_buf + ofs), c);
4002d740: 8b3440a5 add x5, x5, w20, uxtw
4002d744: 8b1502c0 add x0, x22, x21
count -= c;
cmpltd += c;
sec_num++;
4002d748: 1100079c add w28, w28, #0x1
c = MIN(count, (fs_info->vol.bps - ofs));
4002d74c: 4b140084 sub w4, w4, w20
ofs = 0;
4002d750: 52800014 mov w20, #0x0 // #0
c = MIN(count, (fs_info->vol.bps - ofs));
4002d754: 6b1b009f cmp w4, w27
memcpy((buff + cmpltd), (sec_buf + ofs), c);
4002d758: f9401c21 ldr x1, [x1, #56]
4002d75c: 1a9b9099 csel w25, w4, w27, ls // ls = plast
c = MIN(count, (fs_info->vol.bps - ofs));
4002d760: 1a9b909a csel w26, w4, w27, ls // ls = plast
memcpy((buff + cmpltd), (sec_buf + ofs), c);
4002d764: aa1903e2 mov x2, x25
4002d768: 8b050021 add x1, x1, x5
4002d76c: 94003723 bl 4003b3f8 <memcpy>
cmpltd += c;
4002d770: 8b1902b5 add x21, x21, x25
while (count > 0)
4002d774: 6b1a037b subs w27, w27, w26
4002d778: 54fffb41 b.ne 4002d6e0 <_fat_block_read+0x40> // b.any
4002d77c: a94153f3 ldp x19, x20, [sp, #16]
4002d780: a94363f7 ldp x23, x24, [sp, #48]
4002d784: a9446bf9 ldp x25, x26, [sp, #64]
4002d788: a94573fb ldp x27, x28, [sp, #80]
}
return cmpltd;
}
4002d78c: aa1503e0 mov x0, x21
4002d790: a9425bf5 ldp x21, x22, [sp, #32]
4002d794: a8c67bfd ldp x29, x30, [sp], #96
4002d798: d65f03c0 ret
ssize_t cmpltd = 0;
4002d79c: d2800015 mov x21, #0x0 // #0 <== NOT EXECUTED
4002d7a0: 17fffffb b 4002d78c <_fat_block_read+0xec> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
4002d7a4: 94003472 bl 4003a96c <__errno> <== NOT EXECUTED
return -1;
4002d7a8: 92800015 mov x21, #0xffffffffffffffff // #-1 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
4002d7ac: 528000a1 mov w1, #0x5 // #5 <== NOT EXECUTED
4002d7b0: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
4002d7b4: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
4002d7b8: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
4002d7bc: a94573fb ldp x27, x28, [sp, #80] <== NOT EXECUTED
4002d7c0: b9000001 str w1, [x0] <== NOT EXECUTED
if (rc != RC_OK)
4002d7c4: 17fffff2 b 4002d78c <_fat_block_read+0xec> <== NOT EXECUTED
...
000000004002d5b0 <fat_buf_access>:
{
4002d5b0: a9bc7bfd stp x29, x30, [sp, #-64]!
4002d5b4: 910003fd mov x29, sp
4002d5b8: a90153f3 stp x19, x20, [sp, #16]
4002d5bc: aa0003f3 mov x19, x0
4002d5c0: a9025bf5 stp x21, x22, [sp, #32]
4002d5c4: 2a0103f5 mov w21, w1
4002d5c8: aa0303f6 mov x22, x3
4002d5cc: a90363f7 stp x23, x24, [sp, #48]
4002d5d0: 2a0203f7 mov w23, w2
return sector_number >> (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
4002d5d4: 39400814 ldrb w20, [x0, #2]
4002d5d8: 39405004 ldrb w4, [x0, #20]
if (fs_info->c.state == FAT_CACHE_EMPTY || fs_info->c.blk_num != sec_num)
4002d5dc: 3942d401 ldrb w1, [x0, #181]
4002d5e0: 4b140084 sub w4, w4, w20
4002d5e4: 1ac426b8 lsr w24, w21, w4
return block_number << (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
4002d5e8: 1ac42304 lsl w4, w24, w4
((sector -
4002d5ec: 4b0402a4 sub w4, w21, w4
<< fs_info->vol.sec_log2);
4002d5f0: 1ad42094 lsl w20, w4, w20
4002d5f4: 340000a1 cbz w1, 4002d608 <fat_buf_access+0x58>
4002d5f8: b940b001 ldr w1, [x0, #176]
4002d5fc: 6b15003f cmp w1, w21
4002d600: 54000180 b.eq 4002d630 <fat_buf_access+0x80> // b.none
if (fs_info->c.state == FAT_CACHE_EMPTY)
4002d604: 97ffff7f bl 4002d400 <fat_buf_release.part.0>
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &fs_info->c.buf);
4002d608: 2a1803e1 mov w1, w24
if (op_type == FAT_OP_TYPE_READ)
4002d60c: 710006ff cmp w23, #0x1
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &fs_info->c.buf);
4002d610: 9102e262 add x2, x19, #0xb8
4002d614: f9403a60 ldr x0, [x19, #112]
if (op_type == FAT_OP_TYPE_READ)
4002d618: 54000200 b.eq 4002d658 <fat_buf_access+0xa8> // b.none
sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &fs_info->c.buf);
4002d61c: 940022c1 bl 40036120 <rtems_bdbuf_get>
if (sc != RTEMS_SUCCESSFUL)
4002d620: 35000200 cbnz w0, 4002d660 <fat_buf_access+0xb0> <== NEVER TAKEN
fs_info->c.modified = 0;
4002d624: 52802000 mov w0, #0x100 // #256
fs_info->c.blk_num = sec_num;
4002d628: b900b275 str w21, [x19, #176]
fs_info->c.modified = 0;
4002d62c: 79016a60 strh w0, [x19, #180]
*sec_buf = &fs_info->c.buf->buffer[blk_ofs];
4002d630: f9405e61 ldr x1, [x19, #184]
return RC_OK;
4002d634: 52800000 mov w0, #0x0 // #0
*sec_buf = &fs_info->c.buf->buffer[blk_ofs];
4002d638: f9401c24 ldr x4, [x1, #56]
4002d63c: 8b344084 add x4, x4, w20, uxtw
4002d640: f90002c4 str x4, [x22]
}
4002d644: a94153f3 ldp x19, x20, [sp, #16]
4002d648: a9425bf5 ldp x21, x22, [sp, #32]
4002d64c: a94363f7 ldp x23, x24, [sp, #48]
4002d650: a8c47bfd ldp x29, x30, [sp], #64
4002d654: d65f03c0 ret
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &fs_info->c.buf);
4002d658: 940022fa bl 40036240 <rtems_bdbuf_read>
4002d65c: 17fffff1 b 4002d620 <fat_buf_access+0x70>
rtems_set_errno_and_return_minus_one(EIO);
4002d660: 940034c3 bl 4003a96c <__errno> <== NOT EXECUTED
4002d664: aa0003e1 mov x1, x0 <== NOT EXECUTED
4002d668: 528000a2 mov w2, #0x5 // #5 <== NOT EXECUTED
4002d66c: 12800000 mov w0, #0xffffffff // #-1 <== NOT EXECUTED
4002d670: b9000022 str w2, [x1] <== NOT EXECUTED
4002d674: 17fffff4 b 4002d644 <fat_buf_access+0x94> <== NOT EXECUTED
...
000000004002d400 <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)
4002d400: a9bc7bfd stp x29, x30, [sp, #-64]! <== NOT EXECUTED
4002d404: 910003fd mov x29, sp <== NOT EXECUTED
4002d408: a90153f3 stp x19, x20, [sp, #16] <== NOT EXECUTED
4002d40c: aa0003f3 mov x19, x0 <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (fs_info->c.state == FAT_CACHE_EMPTY)
return RC_OK;
if (fs_info->c.modified)
4002d410: 3942d000 ldrb w0, [x0, #180] <== NOT EXECUTED
sec_num,
0);
if (sec_of_fat && !fs_info->vol.mirror)
memcpy(fs_info->sec_buf,
fs_info->c.buf->buffer + blk_ofs,
4002d414: f9405e61 ldr x1, [x19, #184] <== NOT EXECUTED
if (fs_info->c.modified)
4002d418: 34000860 cbz w0, 4002d524 <fat_buf_release.part.0+0x124> <== NOT EXECUTED
bool sec_of_fat = ((sec_num >= fs_info->vol.fat_loc) &&
4002d41c: 79404260 ldrh w0, [x19, #32] <== NOT EXECUTED
uint32_t sec_num = fs_info->c.blk_num;
4002d420: b940b263 ldr w3, [x19, #176] <== NOT EXECUTED
bool sec_of_fat = ((sec_num >= fs_info->vol.fat_loc) &&
4002d424: 6b00007f cmp w3, w0 <== NOT EXECUTED
4002d428: 54000142 b.cs 4002d450 <fat_buf_release.part.0+0x50> // b.hs, b.nlast<== NOT EXECUTED
fs_info->vol.bps);
sc = rtems_bdbuf_release_modified(fs_info->c.buf);
4002d42c: aa0103e0 mov x0, x1 <== NOT EXECUTED
4002d430: 94002444 bl 40036540 <rtems_bdbuf_release_modified> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
4002d434: 350007e0 cbnz w0, 4002d530 <fat_buf_release.part.0+0x130> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
fs_info->c.modified = 0;
4002d438: 3902d27f strb wzr, [x19, #180] <== 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;
return RC_OK;
4002d43c: 52800000 mov w0, #0x0 // #0 <== NOT EXECUTED
fs_info->c.state = FAT_CACHE_EMPTY;
4002d440: 3902d67f strb wzr, [x19, #181] <== NOT EXECUTED
}
4002d444: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
4002d448: a8c47bfd ldp x29, x30, [sp], #64 <== NOT EXECUTED
4002d44c: d65f03c0 ret <== NOT EXECUTED
bool sec_of_fat = ((sec_num >= fs_info->vol.fat_loc) &&
4002d450: b9402a60 ldr w0, [x19, #40] <== NOT EXECUTED
4002d454: 6b00007f cmp w3, w0 <== NOT EXECUTED
4002d458: 54fffea2 b.cs 4002d42c <fat_buf_release.part.0+0x2c> // b.hs, b.nlast<== NOT EXECUTED
if (sec_of_fat && !fs_info->vol.mirror)
4002d45c: 39417260 ldrb w0, [x19, #92] <== NOT EXECUTED
4002d460: 34000780 cbz w0, 4002d550 <fat_buf_release.part.0+0x150> <== NOT EXECUTED
sc = rtems_bdbuf_release_modified(fs_info->c.buf);
4002d464: aa0103e0 mov x0, x1 <== NOT EXECUTED
4002d468: 94002436 bl 40036540 <rtems_bdbuf_release_modified> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
4002d46c: 35000620 cbnz w0, 4002d530 <fat_buf_release.part.0+0x130> <== NOT EXECUTED
if (sec_of_fat && !fs_info->vol.mirror)
4002d470: 39417260 ldrb w0, [x19, #92] <== NOT EXECUTED
fs_info->c.modified = 0;
4002d474: 3902d27f strb wzr, [x19, #180] <== NOT EXECUTED
if (sec_of_fat && !fs_info->vol.mirror)
4002d478: 35fffe20 cbnz w0, 4002d43c <fat_buf_release.part.0+0x3c> <== NOT EXECUTED
for (i = 1; i < fs_info->vol.fats; i++)
4002d47c: f90013f5 str x21, [sp, #32] <== NOT EXECUTED
4002d480: 52800035 mov w21, #0x1 // #1 <== NOT EXECUTED
4002d484: 39405660 ldrb w0, [x19, #21] <== NOT EXECUTED
4002d488: 6b15001f cmp w0, w21 <== NOT EXECUTED
4002d48c: 54000489 b.ls 4002d51c <fat_buf_release.part.0+0x11c> // b.plast <== NOT EXECUTED
sec_num = fs_info->c.blk_num + fs_info->vol.fat_length * i,
4002d490: b940b260 ldr w0, [x19, #176] <== NOT EXECUTED
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &bd);
4002d494: 9100e3e2 add x2, sp, #0x38 <== NOT EXECUTED
sec_num = fs_info->c.blk_num + fs_info->vol.fat_length * i,
4002d498: b9402663 ldr w3, [x19, #36] <== 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);
4002d49c: 39400a65 ldrb w5, [x19, #2] <== NOT EXECUTED
4002d4a0: 39405274 ldrb w20, [x19, #20] <== NOT EXECUTED
sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &bd);
4002d4a4: f9403a66 ldr x6, [x19, #112] <== NOT EXECUTED
sec_num = fs_info->c.blk_num + fs_info->vol.fat_length * i,
4002d4a8: 1b0302a3 madd w3, w21, w3, w0 <== NOT EXECUTED
4002d4ac: 4b050294 sub w20, w20, w5 <== NOT EXECUTED
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &bd);
4002d4b0: aa0603e0 mov x0, x6 <== NOT EXECUTED
4002d4b4: 1ad42464 lsr w4, w3, w20 <== NOT EXECUTED
4002d4b8: 2a0403e1 mov w1, w4 <== NOT EXECUTED
return block_number << (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
4002d4bc: 1ad42094 lsl w20, w4, w20 <== 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 -
4002d4c0: 4b140063 sub w3, w3, w20 <== NOT EXECUTED
fat_block_num_to_sector_num (fs_info,
fat_sector_num_to_block_num (fs_info, sector)))
<< fs_info->vol.sec_log2);
4002d4c4: 1ac52074 lsl w20, w3, w5 <== NOT EXECUTED
if (blk_ofs == 0
4002d4c8: 350000b4 cbnz w20, 4002d4dc <fat_buf_release.part.0+0xdc> <== NOT EXECUTED
&& fs_info->vol.bps == fs_info->vol.bytes_per_block)
4002d4cc: 79400265 ldrh w5, [x19] <== NOT EXECUTED
4002d4d0: b9401263 ldr w3, [x19, #16] <== NOT EXECUTED
4002d4d4: 6b0300bf cmp w5, w3 <== NOT EXECUTED
4002d4d8: 54000380 b.eq 4002d548 <fat_buf_release.part.0+0x148> // b.none <== NOT EXECUTED
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &bd);
4002d4dc: 94002359 bl 40036240 <rtems_bdbuf_read> <== NOT EXECUTED
if ( sc != RTEMS_SUCCESSFUL)
4002d4e0: 35000540 cbnz w0, 4002d588 <fat_buf_release.part.0+0x188> <== NOT EXECUTED
memcpy(bd->buffer + blk_ofs, fs_info->sec_buf, fs_info->vol.bps);
4002d4e4: f9401fe0 ldr x0, [sp, #56] <== NOT EXECUTED
4002d4e8: 79400262 ldrh w2, [x19] <== NOT EXECUTED
4002d4ec: f9406261 ldr x1, [x19, #192] <== NOT EXECUTED
4002d4f0: f9401c00 ldr x0, [x0, #56] <== NOT EXECUTED
4002d4f4: 8b344000 add x0, x0, w20, uxtw <== NOT EXECUTED
4002d4f8: 940037c0 bl 4003b3f8 <memcpy> <== NOT EXECUTED
sc = rtems_bdbuf_release_modified(bd);
4002d4fc: f9401fe0 ldr x0, [sp, #56] <== NOT EXECUTED
4002d500: 94002410 bl 40036540 <rtems_bdbuf_release_modified> <== NOT EXECUTED
for (i = 1; i < fs_info->vol.fats; i++)
4002d504: 110006a1 add w1, w21, #0x1 <== NOT EXECUTED
if ( sc != RTEMS_SUCCESSFUL)
4002d508: 35000400 cbnz w0, 4002d588 <fat_buf_release.part.0+0x188> <== NOT EXECUTED
for (i = 1; i < fs_info->vol.fats; i++)
4002d50c: 39405660 ldrb w0, [x19, #21] <== NOT EXECUTED
4002d510: 12001c35 and w21, w1, #0xff <== NOT EXECUTED
4002d514: 6b21001f cmp w0, w1, uxtb <== NOT EXECUTED
4002d518: 54fffbc8 b.hi 4002d490 <fat_buf_release.part.0+0x90> // b.pmore <== NOT EXECUTED
4002d51c: f94013f5 ldr x21, [sp, #32] <== NOT EXECUTED
4002d520: 17ffffc7 b 4002d43c <fat_buf_release.part.0+0x3c> <== NOT EXECUTED
sc = rtems_bdbuf_release(fs_info->c.buf);
4002d524: aa0103e0 mov x0, x1 <== NOT EXECUTED
4002d528: 940023c6 bl 40036440 <rtems_bdbuf_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
4002d52c: 34fff880 cbz w0, 4002d43c <fat_buf_release.part.0+0x3c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
4002d530: 9400350f bl 4003a96c <__errno> <== NOT EXECUTED
4002d534: aa0003e1 mov x1, x0 <== NOT EXECUTED
4002d538: 528000a2 mov w2, #0x5 // #5 <== NOT EXECUTED
4002d53c: 12800000 mov w0, #0xffffffff // #-1 <== NOT EXECUTED
4002d540: b9000022 str w2, [x1] <== NOT EXECUTED
4002d544: 17ffffc0 b 4002d444 <fat_buf_release.part.0+0x44> <== NOT EXECUTED
sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &bd);
4002d548: 940022f6 bl 40036120 <rtems_bdbuf_get> <== NOT EXECUTED
4002d54c: 17ffffe5 b 4002d4e0 <fat_buf_release.part.0+0xe0> <== NOT EXECUTED
return sector_number >> (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
4002d550: 39400a66 ldrb w6, [x19, #2] <== NOT EXECUTED
4002d554: 39405264 ldrb w4, [x19, #20] <== NOT EXECUTED
memcpy(fs_info->sec_buf,
4002d558: 79400262 ldrh w2, [x19] <== NOT EXECUTED
4002d55c: 4b060084 sub w4, w4, w6 <== NOT EXECUTED
4002d560: f9406260 ldr x0, [x19, #192] <== NOT EXECUTED
4002d564: 1ac42465 lsr w5, w3, w4 <== NOT EXECUTED
return block_number << (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
4002d568: 1ac420a4 lsl w4, w5, w4 <== NOT EXECUTED
((sector -
4002d56c: 4b040063 sub w3, w3, w4 <== NOT EXECUTED
fs_info->c.buf->buffer + blk_ofs,
4002d570: f9401c21 ldr x1, [x1, #56] <== NOT EXECUTED
memcpy(fs_info->sec_buf,
4002d574: 1ac62063 lsl w3, w3, w6 <== NOT EXECUTED
4002d578: 8b030021 add x1, x1, x3 <== NOT EXECUTED
4002d57c: 9400379f bl 4003b3f8 <memcpy> <== NOT EXECUTED
sc = rtems_bdbuf_release_modified(fs_info->c.buf);
4002d580: f9405e61 ldr x1, [x19, #184] <== NOT EXECUTED
4002d584: 17ffffb8 b 4002d464 <fat_buf_release.part.0+0x64> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
4002d588: 940034f9 bl 4003a96c <__errno> <== NOT EXECUTED
4002d58c: 52800181 mov w1, #0xc // #12 <== NOT EXECUTED
4002d590: b9000001 str w1, [x0] <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
4002d594: 12800000 mov w0, #0xffffffff // #-1 <== NOT EXECUTED
}
4002d598: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
4002d59c: f94013f5 ldr x21, [sp, #32] <== NOT EXECUTED
4002d5a0: a8c47bfd ldp x29, x30, [sp], #64 <== NOT EXECUTED
4002d5a4: d65f03c0 ret <== NOT EXECUTED
...
000000004002d8b0 <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)
{
4002d8b0: a9b97bfd stp x29, x30, [sp, #-112]!
4002d8b4: 910003fd mov x29, sp
4002d8b8: a90153f3 stp x19, x20, [sp, #16]
ssize_t rc = RC_OK; uint32_t bytes_to_write = MIN(count, (fs_info->vol.bpc - offset));
4002d8bc: b9400814 ldr w20, [x0, #8]
{
4002d8c0: a9025bf5 stp x21, x22, [sp, #32]
4002d8c4: 12001c95 and w21, w4, #0xff
uint32_t bytes_to_write = MIN(count, (fs_info->vol.bpc - offset));
4002d8c8: 4b020294 sub w20, w20, w2
{
4002d8cc: a90363f7 stp x23, x24, [sp, #48]
uint32_t bytes_to_write = MIN(count, (fs_info->vol.bpc - offset));
4002d8d0: 6b03029f cmp w20, w3
4002d8d4: 1a839294 csel w20, w20, w3, ls // ls = plast
{
4002d8d8: a9046bf9 stp x25, x26, [sp, #64]
4002d8dc: aa0003f7 mov x23, x0
4002d8e0: f9002bfb str x27, [sp, #80]
4002d8e4: 39405004 ldrb w4, [x0, #20]
4002d8e8: 39400805 ldrb w5, [x0, #2]
return sector_number >> (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
4002d8ec: 4b050083 sub w3, w4, w5
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
4002d8f0: 35000081 cbnz w1, 4002d900 <fat_cluster_set+0x50> <== ALWAYS TAKEN
4002d8f4: 39405800 ldrb w0, [x0, #22] <== NOT EXECUTED
4002d8f8: f240041f tst x0, #0x3 <== NOT EXECUTED
4002d8fc: 54000961 b.ne 4002da28 <fat_cluster_set+0x178> // b.any <== NOT EXECUTED
blk = cln << (fs_info->vol.bpc_log2 - fs_info->vol.bytes_per_block_log2);
4002d900: 394032e0 ldrb w0, [x23, #12]
cln -= FAT_RSRVD_CLN;
4002d904: 51000821 sub w1, w1, #0x2
4002d908: b9403ef9 ldr w25, [x23, #60]
blk = cln << (fs_info->vol.bpc_log2 - fs_info->vol.bytes_per_block_log2);
4002d90c: 4b040000 sub w0, w0, w4
4002d910: 1ac32739 lsr w25, w25, w3
4002d914: 1ac02021 lsl w1, w1, w0
blk += fat_sector_num_to_block_num(fs_info, fs_info->vol.data_fsec);
4002d918: 0b010339 add w25, w25, w1
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;
4002d91c: 1ac4245a lsr w26, w2, w4
uint32_t ofs_blk = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2); ssize_t bytes_written = 0;
4002d920: d280001b mov x27, #0x0 // #0
ssize_t ret;
cur_blk += blocks_in_offset;
4002d924: 0b190359 add w25, w26, w25
uint32_t ofs_blk = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2);
4002d928: 1ac4235a lsl w26, w26, w4
4002d92c: 4b1a005a sub w26, w2, w26
while ( (RC_OK == rc)
4002d930: 340002f4 cbz w20, 4002d98c <fat_cluster_set+0xdc> <== NEVER TAKEN
&& (0 < bytes_to_write))
{
uint32_t c = MIN(bytes_to_write, (fs_info->vol.bytes_per_block - ofs_blk));
4002d934: b94012e0 ldr w0, [x23, #16]
fs_info->c.modified = true;
4002d938: 52800036 mov w22, #0x1 // #1
4002d93c: 4b1a0002 sub w2, w0, w26
4002d940: 6b14005f cmp w2, w20
4002d944: 1a949058 csel w24, w2, w20, ls // ls = plast
uint32_t bytes_to_write = MIN(count, (fs_info->vol.bytes_per_block - offset));
4002d948: 6b18005f cmp w2, w24
4002d94c: 1a989053 csel w19, w2, w24, ls // ls = plast
if (0 < bytes_to_write)
4002d950: 340004b3 cbz w19, 4002d9e4 <fat_cluster_set+0x134> <== NEVER TAKEN
4002d954: d503201f nop
return block_number << (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
4002d958: 4b050084 sub w4, w4, w5
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &blk_buf);
4002d95c: 9101a3e3 add x3, sp, #0x68
if (bytes_to_write == fs_info->vol.bytes_per_block)
4002d960: 6b13001f cmp w0, w19
4002d964: 1ac42321 lsl w1, w25, w4
4002d968: 54000440 b.eq 4002d9f0 <fat_cluster_set+0x140> // b.none
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &blk_buf);
4002d96c: 52800022 mov w2, #0x1 // #1
4002d970: aa1703e0 mov x0, x23
4002d974: 97ffff0f bl 4002d5b0 <fat_buf_access>
return rc;
4002d978: 93407c02 sxtw x2, w0
if (RC_OK == rc)
4002d97c: 34000440 cbz w0, 4002da04 <fat_cluster_set+0x154> <== ALWAYS TAKEN
fs_info,
cur_blk,
ofs_blk,
c,
pattern);
if (c != ret)
4002d980: eb38405f cmp x2, w24, uxtw
4002d984: 54000140 b.eq 4002d9ac <fat_cluster_set+0xfc> // b.none <== ALWAYS TAKEN
4002d988: 9280001b mov x27, #0xffffffffffffffff // #-1 <== NOT EXECUTED
}
if (RC_OK != rc)
return rc;
else
return bytes_written;
}
4002d98c: aa1b03e0 mov x0, x27
4002d990: a94153f3 ldp x19, x20, [sp, #16]
4002d994: a9425bf5 ldp x21, x22, [sp, #32]
4002d998: a94363f7 ldp x23, x24, [sp, #48]
4002d99c: a9446bf9 ldp x25, x26, [sp, #64]
4002d9a0: f9402bfb ldr x27, [sp, #80]
4002d9a4: a8c77bfd ldp x29, x30, [sp], #112
4002d9a8: d65f03c0 ret
bytes_written += ret;
4002d9ac: 8b02037b add x27, x27, x2
++cur_blk;
4002d9b0: 11000739 add w25, w25, #0x1
while ( (RC_OK == rc)
4002d9b4: 6b020294 subs w20, w20, w2
4002d9b8: 54fffea0 b.eq 4002d98c <fat_cluster_set+0xdc> // b.none
uint32_t c = MIN(bytes_to_write, (fs_info->vol.bytes_per_block - ofs_blk));
4002d9bc: b94012e0 ldr w0, [x23, #16]
4002d9c0: 5280001a mov w26, #0x0 // #0
4002d9c4: 394052e4 ldrb w4, [x23, #20]
4002d9c8: 4b1a0002 sub w2, w0, w26
4002d9cc: 39400ae5 ldrb w5, [x23, #2]
4002d9d0: 6b14005f cmp w2, w20
4002d9d4: 1a949058 csel w24, w2, w20, ls // ls = plast
uint32_t bytes_to_write = MIN(count, (fs_info->vol.bytes_per_block - offset));
4002d9d8: 6b18005f cmp w2, w24
4002d9dc: 1a989053 csel w19, w2, w24, ls // ls = plast
if (0 < bytes_to_write)
4002d9e0: 35fffbd3 cbnz w19, 4002d958 <fat_cluster_set+0xa8> <== ALWAYS TAKEN
4002d9e4: d2800013 mov x19, #0x0 // #0 <== NOT EXECUTED
return bytes_to_write;
4002d9e8: aa1303e2 mov x2, x19 <== NOT EXECUTED
4002d9ec: 17ffffe5 b 4002d980 <fat_cluster_set+0xd0> <== NOT EXECUTED
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &blk_buf);
4002d9f0: 52800042 mov w2, #0x2 // #2
4002d9f4: aa1703e0 mov x0, x23
4002d9f8: 97fffeee bl 4002d5b0 <fat_buf_access>
return rc;
4002d9fc: 93407c02 sxtw x2, w0
if (RC_OK == rc)
4002da00: 35fffc00 cbnz w0, 4002d980 <fat_cluster_set+0xd0> <== NEVER TAKEN
memset(blk_buf + offset, pattern, bytes_to_write);
4002da04: f94037e0 ldr x0, [sp, #104]
4002da08: 2a1303f3 mov w19, w19
4002da0c: aa1303e2 mov x2, x19
4002da10: 2a1503e1 mov w1, w21
4002da14: 8b3a4000 add x0, x0, w26, uxtw
4002da18: 94003693 bl 4003b464 <memset>
return bytes_to_write;
4002da1c: aa1303e2 mov x2, x19
fs_info->c.modified = true;
4002da20: 3902d2f6 strb w22, [x23, #180]
4002da24: 17ffffd7 b 4002d980 <fat_cluster_set+0xd0>
return sector_number >> (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
4002da28: b9402ae1 ldr w1, [x23, #40] <== NOT EXECUTED
4002da2c: 1ac32439 lsr w25, w1, w3 <== NOT EXECUTED
return blk;
4002da30: 17ffffbb b 4002d91c <fat_cluster_set+0x6c> <== NOT EXECUTED
...
000000004002da40 <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)
{
4002da40: a9b97bfd stp x29, x30, [sp, #-112]!
4002da44: 910003fd mov x29, sp
4002da48: a90153f3 stp x19, x20, [sp, #16]
ssize_t rc = RC_OK;
uint32_t bytes_to_write = MIN(count, (fs_info->vol.bpc - offset));
4002da4c: b9400814 ldr w20, [x0, #8]
{
4002da50: a9025bf5 stp x21, x22, [sp, #32]
4002da54: aa0003f5 mov x21, x0
uint32_t bytes_to_write = MIN(count, (fs_info->vol.bpc - offset));
4002da58: 4b020294 sub w20, w20, w2
{
4002da5c: a9046bf9 stp x25, x26, [sp, #64]
uint32_t bytes_to_write = MIN(count, (fs_info->vol.bpc - offset));
4002da60: 6b03029f cmp w20, w3
{
4002da64: aa0403f6 mov x22, x4
4002da68: f9002bfb str x27, [sp, #80]
uint32_t bytes_to_write = MIN(count, (fs_info->vol.bpc - offset));
4002da6c: 1a839294 csel w20, w20, w3, ls // ls = plast
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
4002da70: 39405005 ldrb w5, [x0, #20]
4002da74: 39400800 ldrb w0, [x0, #2]
4002da78: 4b0000a4 sub w4, w5, w0
4002da7c: 35000081 cbnz w1, 4002da8c <fat_cluster_write+0x4c>
4002da80: 39405aa3 ldrb w3, [x21, #22]
4002da84: f240047f tst x3, #0x3
4002da88: 54000981 b.ne 4002dbb8 <fat_cluster_write+0x178> // b.any <== ALWAYS TAKEN
blk = cln << (fs_info->vol.bpc_log2 - fs_info->vol.bytes_per_block_log2);
4002da8c: 394032a3 ldrb w3, [x21, #12]
cln -= FAT_RSRVD_CLN;
4002da90: 51000821 sub w1, w1, #0x2
4002da94: b9403eb9 ldr w25, [x21, #60]
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);
4002da98: 1ac5245a lsr w26, w2, w5
blk = cln << (fs_info->vol.bpc_log2 - fs_info->vol.bytes_per_block_log2);
4002da9c: 4b050063 sub w3, w3, w5
4002daa0: 1ac42739 lsr w25, w25, w4
4002daa4: 1ac32021 lsl w1, w1, w3
blk += fat_sector_num_to_block_num(fs_info, fs_info->vol.data_fsec);
4002daa8: 0b010339 add w25, w25, w1
ssize_t bytes_written = 0;
uint8_t *buffer = (uint8_t*)buff;
ssize_t ret;
uint32_t c;
cur_blk += blocks_in_offset;
4002daac: 0b190359 add w25, w26, w25
uint32_t ofs_blk = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2);
4002dab0: 1ac5235a lsl w26, w26, w5
4002dab4: 4b1a005a sub w26, w2, w26
while ( (RC_OK == rc)
4002dab8: 340008f4 cbz w20, 4002dbd4 <fat_cluster_write+0x194> <== NEVER TAKEN
&& (0 < bytes_to_write))
{
c = MIN(bytes_to_write, (fs_info->vol.bytes_per_block - ofs_blk));
4002dabc: b94012a3 ldr w3, [x21, #16]
ssize_t bytes_written = 0;
4002dac0: d280001b mov x27, #0x0 // #0
c = MIN(bytes_to_write, (fs_info->vol.bytes_per_block - ofs_blk));
4002dac4: a90363f7 stp x23, x24, [sp, #48]
fs_info->c.modified = true;
4002dac8: 52800037 mov w23, #0x1 // #1
4002dacc: 4b1a0062 sub w2, w3, w26
4002dad0: 6b14005f cmp w2, w20
4002dad4: 1a949058 csel w24, w2, w20, ls // ls = plast
uint32_t bytes_to_write = MIN(count, (fs_info->vol.bytes_per_block - offset));
4002dad8: 6b18005f cmp w2, w24
4002dadc: 1a989053 csel w19, w2, w24, ls // ls = plast
if (0 < bytes_to_write)
4002dae0: 340004b3 cbz w19, 4002db74 <fat_cluster_write+0x134> <== NEVER TAKEN
4002dae4: d503201f nop
return block_number << (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
4002dae8: 4b0000a0 sub w0, w5, w0
if (bytes_to_write == fs_info->vol.bytes_per_block)
4002daec: 6b13007f cmp w3, w19
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &blk_buf);
4002daf0: 9101a3e3 add x3, sp, #0x68
4002daf4: 1ac02321 lsl w1, w25, w0
if (bytes_to_write == fs_info->vol.bytes_per_block)
4002daf8: 54000440 b.eq 4002db80 <fat_cluster_write+0x140> // b.none
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &blk_buf);
4002dafc: 52800022 mov w2, #0x1 // #1
4002db00: aa1503e0 mov x0, x21
4002db04: 97fffeab bl 4002d5b0 <fat_buf_access>
return rc;
4002db08: 93407c02 sxtw x2, w0
if (RC_OK == rc)
4002db0c: 34000440 cbz w0, 4002db94 <fat_cluster_write+0x154> <== ALWAYS TAKEN
fs_info,
cur_blk,
ofs_blk,
c,
&buffer[bytes_written]);
if (c != ret)
4002db10: eb38405f cmp x2, w24, uxtw
4002db14: 54000140 b.eq 4002db3c <fat_cluster_write+0xfc> // b.none <== ALWAYS TAKEN
4002db18: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
4002db1c: 9280001b mov x27, #0xffffffffffffffff // #-1 <== NOT EXECUTED
}
if (RC_OK != rc)
return rc;
else
return bytes_written;
}
4002db20: aa1b03e0 mov x0, x27
4002db24: a94153f3 ldp x19, x20, [sp, #16]
4002db28: a9425bf5 ldp x21, x22, [sp, #32]
4002db2c: a9446bf9 ldp x25, x26, [sp, #64]
4002db30: f9402bfb ldr x27, [sp, #80]
4002db34: a8c77bfd ldp x29, x30, [sp], #112
4002db38: d65f03c0 ret
bytes_written += ret;
4002db3c: 8b02037b add x27, x27, x2
++cur_blk;
4002db40: 11000739 add w25, w25, #0x1
while ( (RC_OK == rc)
4002db44: 6b020294 subs w20, w20, w2
4002db48: 54000560 b.eq 4002dbf4 <fat_cluster_write+0x1b4> // b.none <== ALWAYS TAKEN
c = MIN(bytes_to_write, (fs_info->vol.bytes_per_block - ofs_blk));
4002db4c: b94012a3 ldr w3, [x21, #16] <== NOT EXECUTED
4002db50: 5280001a mov w26, #0x0 // #0 <== NOT EXECUTED
4002db54: 394052a5 ldrb w5, [x21, #20] <== NOT EXECUTED
4002db58: 4b1a0062 sub w2, w3, w26 <== NOT EXECUTED
4002db5c: 39400aa0 ldrb w0, [x21, #2] <== NOT EXECUTED
4002db60: 6b14005f cmp w2, w20 <== NOT EXECUTED
4002db64: 1a949058 csel w24, w2, w20, ls // ls = plast <== NOT EXECUTED
uint32_t bytes_to_write = MIN(count, (fs_info->vol.bytes_per_block - offset));
4002db68: 6b18005f cmp w2, w24 <== NOT EXECUTED
4002db6c: 1a989053 csel w19, w2, w24, ls // ls = plast <== NOT EXECUTED
if (0 < bytes_to_write)
4002db70: 35fffbd3 cbnz w19, 4002dae8 <fat_cluster_write+0xa8> <== NOT EXECUTED
4002db74: d2800013 mov x19, #0x0 // #0 <== NOT EXECUTED
return bytes_to_write;
4002db78: aa1303e2 mov x2, x19 <== NOT EXECUTED
4002db7c: 17ffffe5 b 4002db10 <fat_cluster_write+0xd0> <== NOT EXECUTED
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &blk_buf);
4002db80: 52800042 mov w2, #0x2 // #2
4002db84: aa1503e0 mov x0, x21
4002db88: 97fffe8a bl 4002d5b0 <fat_buf_access>
return rc;
4002db8c: 93407c02 sxtw x2, w0
if (RC_OK == rc)
4002db90: 35fffc00 cbnz w0, 4002db10 <fat_cluster_write+0xd0> <== NEVER TAKEN
memcpy(blk_buf + offset, buf, bytes_to_write);
4002db94: f94037e0 ldr x0, [sp, #104]
4002db98: 2a1303f3 mov w19, w19
4002db9c: aa1303e2 mov x2, x19
4002dba0: 8b1b02c1 add x1, x22, x27
4002dba4: 8b3a4000 add x0, x0, w26, uxtw
4002dba8: 94003614 bl 4003b3f8 <memcpy>
return bytes_to_write;
4002dbac: aa1303e2 mov x2, x19
fs_info->c.modified = true;
4002dbb0: 3902d2b7 strb w23, [x21, #180]
4002dbb4: 17ffffd7 b 4002db10 <fat_cluster_write+0xd0>
return sector_number >> (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
4002dbb8: b9402aa1 ldr w1, [x21, #40]
uint32_t blocks_in_offset = (offset >> fs_info->vol.bytes_per_block_log2);
4002dbbc: 1ac5245a lsr w26, w2, w5
4002dbc0: 1ac42439 lsr w25, w1, w4
cur_blk += blocks_in_offset;
4002dbc4: 0b190359 add w25, w26, w25
uint32_t ofs_blk = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2);
4002dbc8: 1ac5235a lsl w26, w26, w5
4002dbcc: 4b1a005a sub w26, w2, w26
while ( (RC_OK == rc)
4002dbd0: 35fff774 cbnz w20, 4002dabc <fat_cluster_write+0x7c> <== ALWAYS TAKEN
ssize_t bytes_written = 0;
4002dbd4: d280001b mov x27, #0x0 // #0 <== NOT EXECUTED
}
4002dbd8: aa1b03e0 mov x0, x27 <== NOT EXECUTED
4002dbdc: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
4002dbe0: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
4002dbe4: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
4002dbe8: f9402bfb ldr x27, [sp, #80] <== NOT EXECUTED
4002dbec: a8c77bfd ldp x29, x30, [sp], #112 <== NOT EXECUTED
4002dbf0: d65f03c0 ret <== NOT EXECUTED
4002dbf4: a94363f7 ldp x23, x24, [sp, #48]
4002dbf8: 17ffffca b 4002db20 <fat_cluster_write+0xe0>
4002dbfc: 00000000 udf #0
000000004002f690 <fat_file_close>:
{
4002f690: a9be7bfd stp x29, x30, [sp, #-32]!
4002f694: 910003fd mov x29, sp
if (fat_fd->links_num > 1)
4002f698: b9401022 ldr w2, [x1, #16]
{
4002f69c: a90153f3 stp x19, x20, [sp, #16]
4002f6a0: aa0103f3 mov x19, x1
4002f6a4: aa0003f4 mov x20, x0
if (fat_fd->links_num > 1)
4002f6a8: 7100045f cmp w2, #0x1
4002f6ac: 540000e9 b.ls 4002f6c8 <fat_file_close+0x38> // b.plast
fat_fd->links_num--;
4002f6b0: 51000442 sub w2, w2, #0x1
4002f6b4: b9001022 str w2, [x1, #16]
rc = fat_buf_release(fs_info);
4002f6b8: aa1403e0 mov x0, x20
}
4002f6bc: a94153f3 ldp x19, x20, [sp, #16]
4002f6c0: a8c27bfd ldp x29, x30, [sp], #32
rc = fat_buf_release(fs_info);
4002f6c4: 17fff7ef b 4002d680 <fat_buf_release>
fat_file_update(fs_info, fat_fd);
4002f6c8: 97fffefa bl 4002f2b0 <fat_file_update>
if (fat_fd->flags & FAT_FILE_REMOVED)
4002f6cc: 3940e260 ldrb w0, [x19, #56]
4002f6d0: 37000100 tbnz w0, #0, 4002f6f0 <fat_file_close+0x60>
if (fat_ino_is_unique(fs_info, fat_fd->ino))
4002f6d4: b9401661 ldr w1, [x19, #20]
4002f6d8: aa1403e0 mov x0, x20
4002f6dc: 97fffbe9 bl 4002e680 <fat_ino_is_unique>
4002f6e0: 72001c1f tst w0, #0xff
4002f6e4: 54000260 b.eq 4002f730 <fat_file_close+0xa0> // b.none
fat_fd->links_num = 0;
4002f6e8: b900127f str wzr, [x19, #16]
4002f6ec: 17fffff3 b 4002f6b8 <fat_file_close+0x28>
rc = fat_file_truncate(fs_info, fat_fd, 0);
4002f6f0: aa1303e1 mov x1, x19
4002f6f4: aa1403e0 mov x0, x20
4002f6f8: 52800002 mov w2, #0x0 // #0
4002f6fc: 97ffffa1 bl 4002f580 <fat_file_truncate>
if (rc == RC_OK)
4002f700: 35fffdc0 cbnz w0, 4002f6b8 <fat_file_close+0x28> <== NEVER TAKEN
previous = the_node->previous;
4002f704: a9400a63 ldp x3, x2, [x19]
if (fat_ino_is_unique(fs_info, fat_fd->ino))
4002f708: aa1403e0 mov x0, x20
_hash_delete(fs_info->rhash, key, fat_fd->ino, fat_fd);
4002f70c: b9401661 ldr w1, [x19, #20]
next->previous = previous;
4002f710: f9000462 str x2, [x3, #8]
previous->next = next;
4002f714: f9000043 str x3, [x2]
if (fat_ino_is_unique(fs_info, fat_fd->ino))
4002f718: 97fffbda bl 4002e680 <fat_ino_is_unique>
4002f71c: 72001c1f tst w0, #0xff
4002f720: 54000141 b.ne 4002f748 <fat_file_close+0xb8> // b.any <== NEVER TAKEN
free(fat_fd);
4002f724: aa1303e0 mov x0, x19
4002f728: 97ffc996 bl 40021d80 <free>
4002f72c: 17ffffe3 b 4002f6b8 <fat_file_close+0x28>
previous = the_node->previous;
4002f730: a9400662 ldp x2, x1, [x19]
next->previous = previous;
4002f734: f9000441 str x1, [x2, #8]
free(fat_fd);
4002f738: aa1303e0 mov x0, x19
previous->next = next;
4002f73c: f9000022 str x2, [x1]
4002f740: 97ffc990 bl 40021d80 <free>
4002f744: 17ffffdd b 4002f6b8 <fat_file_close+0x28>
fat_free_unique_ino(fs_info, fat_fd->ino);
4002f748: b9401661 ldr w1, [x19, #20] <== NOT EXECUTED
4002f74c: aa1403e0 mov x0, x20 <== NOT EXECUTED
4002f750: 97fffbc0 bl 4002e650 <fat_free_unique_ino> <== NOT EXECUTED
4002f754: 17fffff4 b 4002f724 <fat_file_close+0x94> <== NOT EXECUTED
...
000000004002f850 <fat_file_extend>:
{
4002f850: a9b97bfd stp x29, x30, [sp, #-112]!
4002f854: 910003fd mov x29, sp
4002f858: a90363f7 stp x23, x24, [sp, #48]
4002f85c: a9046bf9 stp x25, x26, [sp, #64]
4002f860: 12001c5a and w26, w2, #0xff
4002f864: aa0403f9 mov x25, x4
*a_length = new_length;
4002f868: b9000083 str w3, [x4]
uint32_t chain = 0;
4002f86c: b90063ff str wzr, [sp, #96]
if (new_length <= fat_fd->fat_file_size)
4002f870: b9402022 ldr w2, [x1, #32]
uint32_t last_cl = 0;
4002f874: b9006bff str wzr, [sp, #104]
if (new_length <= fat_fd->fat_file_size)
4002f878: 6b03005f cmp w2, w3
4002f87c: 540002c2 b.cs 4002f8d4 <fat_file_extend+0x84> // b.hs, b.nlast
4002f880: a9025bf5 stp x21, x22, [sp, #32]
4002f884: aa0003f5 mov x21, x0
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
4002f888: aa0103f8 mov x24, x1
4002f88c: f9401420 ldr x0, [x1, #40]
4002f890: a90153f3 stp x19, x20, [sp, #16]
4002f894: 2a0303f3 mov w19, w3
4002f898: f100041f cmp x0, #0x1
4002f89c: 54000a00 b.eq 4002f9dc <fat_file_extend+0x18c> // b.none
bytes_remain = (fs_info->vol.bpc -
4002f8a0: b9400ab4 ldr w20, [x21, #8]
bytes2add = new_length - fat_fd->fat_file_size;
4002f8a4: 4b020276 sub w22, w19, w2
4002f8a8: a90573fb stp x27, x28, [sp, #80]
(fat_fd->fat_file_size & (fs_info->vol.bpc - 1))) &
4002f8ac: 51000680 sub w0, w20, #0x1
4002f8b0: 0a00005b and w27, w2, w0
bytes_remain = (fs_info->vol.bpc -
4002f8b4: 4b1b0294 sub w20, w20, w27
4002f8b8: 0a000294 and w20, w20, w0
if (bytes2add > bytes_remain)
4002f8bc: 6b16029f cmp w20, w22
4002f8c0: 54000163 b.cc 4002f8ec <fat_file_extend+0x9c> // b.lo, b.ul, b.last
if (zero_fill && bytes_remain > 0) {
4002f8c4: 35000a1a cbnz w26, 4002fa04 <fat_file_extend+0x1b4>
4002f8c8: a94153f3 ldp x19, x20, [sp, #16]
4002f8cc: a9425bf5 ldp x21, x22, [sp, #32]
4002f8d0: a94573fb ldp x27, x28, [sp, #80]
return RC_OK;
4002f8d4: 52800017 mov w23, #0x0 // #0
}
4002f8d8: 2a1703e0 mov w0, w23
4002f8dc: a94363f7 ldp x23, x24, [sp, #48]
4002f8e0: a9446bf9 ldp x25, x26, [sp, #64]
4002f8e4: a8c77bfd ldp x29, x30, [sp], #112
4002f8e8: d65f03c0 ret
if (zero_fill && bytes_remain > 0) {
4002f8ec: 7100029f cmp w20, #0x0
bytes2add -= bytes_remain;
4002f8f0: 4b1402dc sub w28, w22, w20
if (zero_fill && bytes_remain > 0) {
4002f8f4: 7a401b44 ccmp w26, #0x0, #0x4, ne // ne = any
4002f8f8: 54000881 b.ne 4002fa08 <fat_file_extend+0x1b8> // b.any <== NEVER TAKEN
if (bytes2add == 0)
4002f8fc: 34fffe7c cbz w28, 4002f8c8 <fat_file_extend+0x78>
cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;
4002f900: 394032a2 ldrb w2, [x21, #12]
4002f904: 51000796 sub w22, w28, #0x1
rc = fat_scan_fat_for_free_clusters(fs_info, &chain, cls2add,
4002f908: 2a1a03e5 mov w5, w26
4002f90c: 9101a3e4 add x4, sp, #0x68
4002f910: 9101b3e3 add x3, sp, #0x6c
4002f914: 910183e1 add x1, sp, #0x60
cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;
4002f918: 1ac226d6 lsr w22, w22, w2
4002f91c: 110006d6 add w22, w22, #0x1
rc = fat_scan_fat_for_free_clusters(fs_info, &chain, cls2add,
4002f920: 2a1603e2 mov w2, w22
4002f924: aa1503e0 mov x0, x21
4002f928: 97fffcde bl 4002eca0 <fat_scan_fat_for_free_clusters>
4002f92c: 2a0003f7 mov w23, w0
if (rc != RC_OK)
4002f930: 350007c0 cbnz w0, 4002fa28 <fat_file_extend+0x1d8> <== NEVER TAKEN
if ((cls_added == 0) && (bytes_remain == 0))
4002f934: b9406fe0 ldr w0, [sp, #108]
4002f938: 2a140014 orr w20, w0, w20
4002f93c: 34000d74 cbz w20, 4002fae8 <fat_file_extend+0x298>
if (cls2add != cls_added)
4002f940: 6b16001f cmp w0, w22
4002f944: 540000e0 b.eq 4002f960 <fat_file_extend+0x110> // b.none
uint32_t missing = (cls2add - cls_added) << fs_info->vol.bpc_log2;
4002f948: 394032a1 ldrb w1, [x21, #12]
4002f94c: 4b0002d6 sub w22, w22, w0
4002f950: 1ac122d6 lsl w22, w22, w1
new_length -= bytes2add < missing ? bytes2add : missing;
4002f954: 6b1c02df cmp w22, w28
4002f958: 1a9c92d6 csel w22, w22, w28, ls // ls = plast
4002f95c: 4b160273 sub w19, w19, w22
if (cls_added > 0)
4002f960: 34000880 cbz w0, 4002fa70 <fat_file_extend+0x220>
if ( fat_fd->fat_file_size == 0 )
4002f964: b9402303 ldr w3, [x24, #32]
4002f968: 340009e3 cbz w3, 4002faa4 <fat_file_extend+0x254>
if (fat_fd->map.last_cln != FAT_UNDEFINED_VALUE)
4002f96c: b9404701 ldr w1, [x24, #68]
4002f970: 3100043f cmn w1, #0x1
4002f974: 54000a60 b.eq 4002fac0 <fat_file_extend+0x270> // b.none <== NEVER TAKEN
old_last_cl = fat_fd->map.last_cln;
4002f978: b90067e1 str w1, [sp, #100]
rc = fat_set_fat_cluster(fs_info, old_last_cl, chain);
4002f97c: b94063e2 ldr w2, [sp, #96]
4002f980: aa1503e0 mov x0, x21
4002f984: 97fffbcf bl 4002e8c0 <fat_set_fat_cluster>
4002f988: 2a0003e2 mov w2, w0
if ( rc != RC_OK )
4002f98c: 35000180 cbnz w0, 4002f9bc <fat_file_extend+0x16c> <== NEVER TAKEN
fat_buf_release(fs_info);
4002f990: aa1503e0 mov x0, x21
4002f994: 97fff73b bl 4002d680 <fat_buf_release>
if (fat_fd->fat_file_type == FAT_DIRECTORY)
4002f998: b9401b00 ldr w0, [x24, #24]
fat_fd->map.last_cln = last_cl;
4002f99c: b9406be1 ldr w1, [sp, #104]
4002f9a0: b9004701 str w1, [x24, #68]
if (fat_fd->fat_file_type == FAT_DIRECTORY)
4002f9a4: 35000660 cbnz w0, 4002fa70 <fat_file_extend+0x220>
rc = fat_init_clusters_chain(fs_info, chain);
4002f9a8: b94063e1 ldr w1, [sp, #96]
4002f9ac: aa1503e0 mov x0, x21
4002f9b0: 97fffad0 bl 4002e4f0 <fat_init_clusters_chain>
4002f9b4: 2a0003e2 mov w2, w0
if ( rc != RC_OK )
4002f9b8: 340005c0 cbz w0, 4002fa70 <fat_file_extend+0x220> <== ALWAYS TAKEN
fat_free_fat_clusters_chain(fs_info, chain);
4002f9bc: b94063e1 ldr w1, [sp, #96] <== NOT EXECUTED
4002f9c0: aa1503e0 mov x0, x21 <== NOT EXECUTED
return rc;
4002f9c4: 2a0203f7 mov w23, w2 <== NOT EXECUTED
fat_free_fat_clusters_chain(fs_info, chain);
4002f9c8: 97fffc72 bl 4002eb90 <fat_free_fat_clusters_chain> <== NOT EXECUTED
return rc;
4002f9cc: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
4002f9d0: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
4002f9d4: a94573fb ldp x27, x28, [sp, #80] <== NOT EXECUTED
4002f9d8: 17ffffc0 b 4002f8d8 <fat_file_extend+0x88> <== NOT EXECUTED
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
4002f9dc: 39405aa0 ldrb w0, [x21, #22]
4002f9e0: f240041f tst x0, #0x3
4002f9e4: 54fff5e0 b.eq 4002f8a0 <fat_file_extend+0x50> // b.none <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( ENOSPC );
4002f9e8: 94002be1 bl 4003a96c <__errno>
4002f9ec: 12800017 mov w23, #0xffffffff // #-1
4002f9f0: 52800381 mov w1, #0x1c // #28
4002f9f4: a94153f3 ldp x19, x20, [sp, #16]
4002f9f8: a9425bf5 ldp x21, x22, [sp, #32]
4002f9fc: b9000001 str w1, [x0]
4002fa00: 17ffffb6 b 4002f8d8 <fat_file_extend+0x88>
bytes2add = 0;
4002fa04: 5280001c mov w28, #0x0 // #0
uint32_t cl_start = start >> fs_info->vol.bpc_log2;
4002fa08: 394032a4 ldrb w4, [x21, #12]
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
4002fa0c: 9101b3e3 add x3, sp, #0x6c
4002fa10: aa1803e1 mov x1, x24
4002fa14: aa1503e0 mov x0, x21
4002fa18: 1ac42442 lsr w2, w2, w4
4002fa1c: 97fffd35 bl 4002eef0 <fat_file_lseek>
4002fa20: 2a0003f7 mov w23, w0
if (rc != RC_OK)
4002fa24: 34000120 cbz w0, 4002fa48 <fat_file_extend+0x1f8> <== ALWAYS TAKEN
}
4002fa28: 2a1703e0 mov w0, w23 <== NOT EXECUTED
4002fa2c: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
4002fa30: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
4002fa34: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
4002fa38: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
4002fa3c: a94573fb ldp x27, x28, [sp, #80] <== NOT EXECUTED
4002fa40: a8c77bfd ldp x29, x30, [sp], #112 <== NOT EXECUTED
4002fa44: d65f03c0 ret <== NOT EXECUTED
bytes_written = fat_cluster_set (fs_info, cur_cln, ofs, bytes_remain, 0);
4002fa48: b9406fe1 ldr w1, [sp, #108]
4002fa4c: 2a1b03e2 mov w2, w27
4002fa50: 2a1403e3 mov w3, w20
4002fa54: aa1503e0 mov x0, x21
4002fa58: 52800004 mov w4, #0x0 // #0
return -1;
4002fa5c: 12800017 mov w23, #0xffffffff // #-1
bytes_written = fat_cluster_set (fs_info, cur_cln, ofs, bytes_remain, 0);
4002fa60: 97fff794 bl 4002d8b0 <fat_cluster_set>
if (bytes_remain != bytes_written)
4002fa64: eb34401f cmp x0, w20, uxtw
4002fa68: 54fffe01 b.ne 4002fa28 <fat_file_extend+0x1d8> // b.any <== NEVER TAKEN
4002fa6c: 17ffffa4 b 4002f8fc <fat_file_extend+0xac>
*a_length = new_length;
4002fa70: b9000333 str w19, [x25]
fat_fd->flags |= FAT_FILE_META_DATA_CHANGED;
4002fa74: 3940e300 ldrb w0, [x24, #56]
4002fa78: 321f0000 orr w0, w0, #0x2
4002fa7c: 3900e300 strb w0, [x24, #56]
}
4002fa80: 2a1703e0 mov w0, w23
return RC_OK;
4002fa84: a9425bf5 ldp x21, x22, [sp, #32]
4002fa88: a94573fb ldp x27, x28, [sp, #80]
fat_fd->fat_file_size = s;
4002fa8c: b9002313 str w19, [x24, #32]
4002fa90: a94153f3 ldp x19, x20, [sp, #16]
}
4002fa94: a94363f7 ldp x23, x24, [sp, #48]
4002fa98: a9446bf9 ldp x25, x26, [sp, #64]
4002fa9c: a8c77bfd ldp x29, x30, [sp], #112
4002faa0: d65f03c0 ret
fat_fd->flags |= FAT_FILE_META_DATA_CHANGED;
4002faa4: 3940e300 ldrb w0, [x24, #56]
fat_fd->map.disk_cln = chain;
4002faa8: b94063e1 ldr w1, [sp, #96]
4002faac: 321f0000 orr w0, w0, #0x2
fat_fd->cln = cln;
4002fab0: b9002701 str w1, [x24, #36]
fat_fd->flags |= FAT_FILE_META_DATA_CHANGED;
4002fab4: 3900e300 strb w0, [x24, #56]
4002fab8: 2907871f stp wzr, w1, [x24, #60]
}
4002fabc: 17ffffb7 b 4002f998 <fat_file_extend+0x148>
rc = fat_file_ioctl(fs_info, fat_fd, F_CLU_NUM,
4002fac0: aa1803e1 mov x1, x24 <== NOT EXECUTED
4002fac4: 52800022 mov w2, #0x1 // #1 <== NOT EXECUTED
4002fac8: 51000463 sub w3, w3, #0x1 <== NOT EXECUTED
4002facc: 910193e4 add x4, sp, #0x64 <== NOT EXECUTED
4002fad0: aa1503e0 mov x0, x21 <== NOT EXECUTED
4002fad4: 97ffff23 bl 4002f760 <fat_file_ioctl> <== NOT EXECUTED
rc = fat_set_fat_cluster(fs_info, old_last_cl, chain);
4002fad8: b94067e1 ldr w1, [sp, #100] <== NOT EXECUTED
rc = fat_file_ioctl(fs_info, fat_fd, F_CLU_NUM,
4002fadc: 2a0003e2 mov w2, w0 <== NOT EXECUTED
if ( rc != RC_OK )
4002fae0: 34fff4e0 cbz w0, 4002f97c <fat_file_extend+0x12c> <== NOT EXECUTED
4002fae4: 17ffffb6 b 4002f9bc <fat_file_extend+0x16c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOSPC);
4002fae8: 94002ba1 bl 4003a96c <__errno>
4002faec: 12800017 mov w23, #0xffffffff // #-1
4002faf0: 52800381 mov w1, #0x1c // #28
4002faf4: a94153f3 ldp x19, x20, [sp, #16]
4002faf8: a9425bf5 ldp x21, x22, [sp, #32]
4002fafc: a94573fb ldp x27, x28, [sp, #80]
4002fb00: b9000001 str w1, [x0]
4002fb04: 17ffff75 b 4002f8d8 <fat_file_extend+0x88>
...
000000004002f760 <fat_file_ioctl>:
{
4002f760: a9ba7bfd stp x29, x30, [sp, #-96]!
va_start(ap, cmd);
4002f764: 128001e5 mov w5, #0xfffffff0 // #-16
switch (cmd)
4002f768: 7100045f cmp w2, #0x1
{
4002f76c: 910003fd mov x29, sp
va_start(ap, cmd);
4002f770: 910143e6 add x6, sp, #0x50
4002f774: 910183e7 add x7, sp, #0x60
uint32_t cur_cln = 0;
4002f778: b9002fff str wzr, [sp, #44]
va_start(ap, cmd);
4002f77c: a9031fe7 stp x7, x7, [sp, #48]
4002f780: f90023e6 str x6, [sp, #64]
4002f784: 29097fe5 stp w5, wzr, [sp, #72]
{
4002f788: a90513e3 stp x3, x4, [sp, #80]
switch (cmd)
4002f78c: 54000361 b.ne 4002f7f8 <fat_file_ioctl+0x98> // b.any <== NEVER TAKEN
if ( pos >= fat_fd->fat_file_size ) {
4002f790: b9402023 ldr w3, [x1, #32]
pos = va_arg(ap, uint32_t);
4002f794: b94053e2 ldr w2, [sp, #80]
4002f798: f9000bf3 str x19, [sp, #16]
ret = va_arg(ap, uint32_t *);
4002f79c: aa0403f3 mov x19, x4
4002f7a0: b9004bff str wzr, [sp, #72]
if ( pos >= fat_fd->fat_file_size ) {
4002f7a4: 6b02007f cmp w3, w2
4002f7a8: 54000409 b.ls 4002f828 <fat_file_ioctl+0xc8> // b.plast <== NEVER TAKEN
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
4002f7ac: f9401423 ldr x3, [x1, #40]
4002f7b0: f100047f cmp x3, #0x1
4002f7b4: 54000121 b.ne 4002f7d8 <fat_file_ioctl+0x78> // b.any
4002f7b8: 39405803 ldrb w3, [x0, #22]
4002f7bc: f240047f tst x3, #0x3
4002f7c0: 540000c0 b.eq 4002f7d8 <fat_file_ioctl+0x78> // b.none
*ret = 0;
4002f7c4: b900009f str wzr, [x4]
rc = RC_OK;
4002f7c8: 52800000 mov w0, #0x0 // #0
break;
4002f7cc: f9400bf3 ldr x19, [sp, #16]
}
4002f7d0: a8c67bfd ldp x29, x30, [sp], #96
4002f7d4: d65f03c0 ret
cl_start = pos >> fs_info->vol.bpc_log2;
4002f7d8: 39403004 ldrb w4, [x0, #12]
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
4002f7dc: 9100b3e3 add x3, sp, #0x2c
4002f7e0: 1ac42442 lsr w2, w2, w4
4002f7e4: 97fffdc3 bl 4002eef0 <fat_file_lseek>
if ( rc != RC_OK )
4002f7e8: 34000160 cbz w0, 4002f814 <fat_file_ioctl+0xb4> <== ALWAYS TAKEN
4002f7ec: f9400bf3 ldr x19, [sp, #16] <== NOT EXECUTED
}
4002f7f0: a8c67bfd ldp x29, x30, [sp], #96 <== NOT EXECUTED
4002f7f4: d65f03c0 ret <== NOT EXECUTED
errno = EINVAL;
4002f7f8: 94002c5d bl 4003a96c <__errno> <== NOT EXECUTED
4002f7fc: aa0003e1 mov x1, x0 <== NOT EXECUTED
4002f800: 528002c2 mov w2, #0x16 // #22 <== NOT EXECUTED
rc = -1;
4002f804: 12800000 mov w0, #0xffffffff // #-1 <== NOT EXECUTED
errno = EINVAL;
4002f808: b9000022 str w2, [x1] <== NOT EXECUTED
}
4002f80c: a8c67bfd ldp x29, x30, [sp], #96 <== NOT EXECUTED
4002f810: d65f03c0 ret <== NOT EXECUTED
*ret = cur_cln;
4002f814: b9402fe1 ldr w1, [sp, #44]
4002f818: b9000261 str w1, [x19]
break;
4002f81c: f9400bf3 ldr x19, [sp, #16]
}
4002f820: a8c67bfd ldp x29, x30, [sp], #96
4002f824: d65f03c0 ret
rtems_set_errno_and_return_minus_one( EIO );
4002f828: 94002c51 bl 4003a96c <__errno> <== NOT EXECUTED
4002f82c: aa0003e1 mov x1, x0 <== NOT EXECUTED
4002f830: 528000a2 mov w2, #0x5 // #5 <== NOT EXECUTED
4002f834: 12800000 mov w0, #0xffffffff // #-1 <== NOT EXECUTED
4002f838: f9400bf3 ldr x19, [sp, #16] <== NOT EXECUTED
4002f83c: b9000022 str w2, [x1] <== NOT EXECUTED
4002f840: 17fffff3 b 4002f80c <fat_file_ioctl+0xac> <== NOT EXECUTED
...
000000004002efc0 <fat_file_open>:
{
4002efc0: a9bb7bfd stp x29, x30, [sp, #-80]!
4002efc4: 910003fd mov x29, sp
4002efc8: a90153f3 stp x19, x20, [sp, #16]
4002efcc: aa0003f3 mov x19, x0
4002efd0: a9025bf5 stp x21, x22, [sp, #32]
4002efd4: aa0103f6 mov x22, x1
4002efd8: 29400420 ldp w0, w1, [x1]
4002efdc: a90363f7 stp x23, x24, [sp, #48]
4002efe0: aa0203f8 mov x24, x2
if (cln == 1)
4002efe4: 7100041f cmp w0, #0x1
4002efe8: 54000120 b.eq 4002f00c <fat_file_open+0x4c> // b.none
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
4002efec: 34000f80 cbz w0, 4002f1dc <fat_file_open+0x21c>
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
4002eff0: 39401663 ldrb w3, [x19, #5]
4002eff4: 51000800 sub w0, w0, #0x2
4002eff8: b9403e62 ldr w2, [x19, #60]
4002effc: 1ac32000 lsl w0, w0, w3
4002f000: 0b020000 add w0, w0, w2
fs_info->vol.sec_mul);
4002f004: 39400e74 ldrb w20, [x19, #3]
return (fat_cluster_num_to_sector_num(fs_info, cln) <<
4002f008: 1ad42000 lsl w0, w0, w20
((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );
4002f00c: d3452022 ubfx x2, x1, #5, #4
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
4002f010: 52800303 mov w3, #0x18 // #24
uint32_t mod = (key1) % FAT_HASH_MODULE;
4002f014: 12000057 and w23, w2, #0x1
return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) +
4002f018: 0b412414 add w20, w0, w1, lsr #9
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
4002f01c: f9404660 ldr x0, [x19, #136]
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
4002f020: 0b141054 add w20, w2, w20, lsl #4
4002f024: 9ba37ef7 umull x23, w23, w3
4002f028: 8b170015 add x21, x0, x23
return &the_chain->Tail.Node;
4002f02c: 910022b5 add x21, x21, #0x8
return _Chain_Immutable_head( the_chain )->next;
4002f030: f8776803 ldr x3, [x0, x23]
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
4002f034: eb15007f cmp x3, x21
4002f038: 540002e0 b.eq 4002f094 <fat_file_open+0xd4> // b.none
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
4002f03c: 29451060 ldp w0, w4, [x3, #40]
4002f040: 51000801 sub w1, w0, #0x2
if (cln == 1)
4002f044: 7100041f cmp w0, #0x1
4002f048: 54000160 b.eq 4002f074 <fat_file_open+0xb4> // b.none
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
4002f04c: 35000080 cbnz w0, 4002f05c <fat_file_open+0x9c>
4002f050: 39405a60 ldrb w0, [x19, #22]
4002f054: f240041f tst x0, #0x3
4002f058: 54000cc1 b.ne 4002f1f0 <fat_file_open+0x230> // b.any <== ALWAYS TAKEN
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
4002f05c: 39401662 ldrb w2, [x19, #5]
4002f060: b9403e60 ldr w0, [x19, #60]
4002f064: 1ac22021 lsl w1, w1, w2
4002f068: 0b000020 add w0, w1, w0
fs_info->vol.sec_mul);
4002f06c: 39400e61 ldrb w1, [x19, #3]
return (fat_cluster_num_to_sector_num(fs_info, cln) <<
4002f070: 1ac12000 lsl w0, w0, w1
return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) +
4002f074: 0b442400 add w0, w0, w4, lsr #9
((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );
4002f078: d3452084 ubfx x4, x4, #5, #4
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
4002f07c: 0b001080 add w0, w4, w0, lsl #4
if ( (key1) == ck)
4002f080: 6b00029f cmp w20, w0
4002f084: 54000980 b.eq 4002f1b4 <fat_file_open+0x1f4> // b.none
the_node = the_node->next;
4002f088: f9400063 ldr x3, [x3]
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
4002f08c: eb15007f cmp x3, x21
4002f090: 54fffd61 b.ne 4002f03c <fat_file_open+0x7c> // b.any
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
4002f094: f9404a60 ldr x0, [x19, #144]
4002f098: 8b170002 add x2, x0, x23
4002f09c: f8776804 ldr x4, [x0, x23]
return &the_chain->Tail.Node;
4002f0a0: f90023f9 str x25, [sp, #64]
4002f0a4: 91002042 add x2, x2, #0x8
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
4002f0a8: eb02009f cmp x4, x2
4002f0ac: 540000a1 b.ne 4002f0c0 <fat_file_open+0x100> // b.any <== NEVER TAKEN
4002f0b0: 14000054 b 4002f200 <fat_file_open+0x240>
the_node = the_node->next;
4002f0b4: f9400084 ldr x4, [x4] <== NOT EXECUTED
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
4002f0b8: eb02009f cmp x4, x2 <== NOT EXECUTED
4002f0bc: 54000a20 b.eq 4002f200 <fat_file_open+0x240> // b.none <== NOT EXECUTED
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
4002f0c0: 29451483 ldp w3, w5, [x4, #40] <== NOT EXECUTED
4002f0c4: 51000860 sub w0, w3, #0x2 <== NOT EXECUTED
if (cln == 1)
4002f0c8: 7100047f cmp w3, #0x1 <== NOT EXECUTED
4002f0cc: 54000160 b.eq 4002f0f8 <fat_file_open+0x138> // b.none <== NOT EXECUTED
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
4002f0d0: 35000083 cbnz w3, 4002f0e0 <fat_file_open+0x120> <== NOT EXECUTED
4002f0d4: 39405a61 ldrb w1, [x19, #22] <== NOT EXECUTED
4002f0d8: f240043f tst x1, #0x3 <== NOT EXECUTED
4002f0dc: 540008e1 b.ne 4002f1f8 <fat_file_open+0x238> // b.any <== NOT EXECUTED
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
4002f0e0: 39401661 ldrb w1, [x19, #5] <== NOT EXECUTED
4002f0e4: b9403e63 ldr w3, [x19, #60] <== NOT EXECUTED
4002f0e8: 1ac12000 lsl w0, w0, w1 <== NOT EXECUTED
4002f0ec: 0b030003 add w3, w0, w3 <== NOT EXECUTED
fs_info->vol.sec_mul);
4002f0f0: 39400e60 ldrb w0, [x19, #3] <== NOT EXECUTED
return (fat_cluster_num_to_sector_num(fs_info, cln) <<
4002f0f4: 1ac02063 lsl w3, w3, w0 <== NOT EXECUTED
return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) +
4002f0f8: 0b452463 add w3, w3, w5, lsr #9 <== NOT EXECUTED
((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );
4002f0fc: d34520a5 ubfx x5, x5, #5, #4 <== NOT EXECUTED
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
4002f100: 0b0310a3 add w3, w5, w3, lsl #4 <== NOT EXECUTED
if ( (key1) == ck)
4002f104: 6b03029f cmp w20, w3 <== NOT EXECUTED
4002f108: 54fffd61 b.ne 4002f0b4 <fat_file_open+0xf4> // b.any <== NOT EXECUTED
if ( ((key2) == 0) || ((key2) == ffd->ino) )
4002f10c: 34000094 cbz w20, 4002f11c <fat_file_open+0x15c> <== NOT EXECUTED
4002f110: b9401480 ldr w0, [x4, #20] <== NOT EXECUTED
4002f114: 6b00029f cmp w20, w0 <== NOT EXECUTED
4002f118: 54fffce1 b.ne 4002f0b4 <fat_file_open+0xf4> // b.any <== NOT EXECUTED
lfat_fd = (*fat_fd) = (fat_file_fd_t*)calloc(1, sizeof(fat_file_fd_t));
4002f11c: d2800b01 mov x1, #0x58 // #88 <== NOT EXECUTED
4002f120: d2800020 mov x0, #0x1 // #1 <== NOT EXECUTED
4002f124: 97fff52f bl 4002c5e0 <calloc> <== NOT EXECUTED
4002f128: f9000300 str x0, [x24] <== NOT EXECUTED
4002f12c: aa0003f9 mov x25, x0 <== NOT EXECUTED
if ( lfat_fd == NULL )
4002f130: b4000900 cbz x0, 4002f250 <fat_file_open+0x290> <== NOT EXECUTED
lfat_fd->flags &= ~FAT_FILE_REMOVED;
4002f134: 3940e322 ldrb w2, [x25, #56] <== NOT EXECUTED
lfat_fd->links_num = 1;
4002f138: 52800020 mov w0, #0x1 // #1 <== NOT EXECUTED
lfat_fd->dir_pos = *dir_pos;
4002f13c: 294012c3 ldp w3, w4, [x22] <== NOT EXECUTED
lfat_fd->flags &= ~FAT_FILE_REMOVED;
4002f140: 121f7842 and w2, w2, #0xfffffffe <== NOT EXECUTED
lfat_fd->dir_pos = *dir_pos;
4002f144: 29051323 stp w3, w4, [x25, #40] <== NOT EXECUTED
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
4002f148: 12800014 mov w20, #0xffffffff // #-1 <== NOT EXECUTED
lfat_fd->dir_pos = *dir_pos;
4002f14c: b9400ac3 ldr w3, [x22, #8] <== NOT EXECUTED
lfat_fd->flags &= ~FAT_FILE_REMOVED;
4002f150: 3900e322 strb w2, [x25, #56] <== NOT EXECUTED
lfat_fd->dir_pos = *dir_pos;
4002f154: b9400ec2 ldr w2, [x22, #12] <== NOT EXECUTED
lfat_fd->links_num = 1;
4002f158: b9001320 str w0, [x25, #16] <== NOT EXECUTED
lfat_fd->ino = fat_get_unique_ino(fs_info);
4002f15c: aa1303e0 mov x0, x19 <== NOT EXECUTED
lfat_fd->dir_pos = *dir_pos;
4002f160: b9003323 str w3, [x25, #48] <== NOT EXECUTED
4002f164: b9003722 str w2, [x25, #52] <== NOT EXECUTED
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
4002f168: b9004734 str w20, [x25, #68] <== NOT EXECUTED
lfat_fd->ino = fat_get_unique_ino(fs_info);
4002f16c: 97fffd05 bl 4002e580 <fat_get_unique_ino> <== NOT EXECUTED
4002f170: b9001720 str w0, [x25, #20] <== NOT EXECUTED
if ( lfat_fd->ino == 0 )
4002f174: 340007c0 cbz w0, 4002f26c <fat_file_open+0x2ac> <== NOT EXECUTED
rtems_chain_append_unprotected((hash) + ((key1) % FAT_HASH_MODULE), &(el)->link);
4002f178: f9404675 ldr x21, [x19, #136] <== NOT EXECUTED
4002f17c: 8b1702b5 add x21, x21, x23 <== NOT EXECUTED
return &the_chain->Tail.Node;
4002f180: 910022b5 add x21, x21, #0x8 <== NOT EXECUTED
old_last = tail->previous;
4002f184: f94006a1 ldr x1, [x21, #8]
the_node->next = tail;
4002f188: f9000335 str x21, [x25]
tail->previous = the_node;
4002f18c: f90006b9 str x25, [x21, #8]
return RC_OK;
4002f190: 52800000 mov w0, #0x0 // #0
}
4002f194: a94153f3 ldp x19, x20, [sp, #16]
old_last->next = the_node;
4002f198: f9000039 str x25, [x1]
the_node->previous = old_last;
4002f19c: f9000721 str x1, [x25, #8]
4002f1a0: a9425bf5 ldp x21, x22, [sp, #32]
4002f1a4: a94363f7 ldp x23, x24, [sp, #48]
return RC_OK;
4002f1a8: f94023f9 ldr x25, [sp, #64]
}
4002f1ac: a8c57bfd ldp x29, x30, [sp], #80
4002f1b0: d65f03c0 ret
lfat_fd->links_num++;
4002f1b4: b9401061 ldr w1, [x3, #16]
return rc;
4002f1b8: 52800000 mov w0, #0x0 // #0
(*fat_fd) = lfat_fd;
4002f1bc: f9000303 str x3, [x24]
lfat_fd->links_num++;
4002f1c0: 11000421 add w1, w1, #0x1
4002f1c4: b9001061 str w1, [x3, #16]
}
4002f1c8: a94153f3 ldp x19, x20, [sp, #16]
4002f1cc: a9425bf5 ldp x21, x22, [sp, #32]
4002f1d0: a94363f7 ldp x23, x24, [sp, #48]
4002f1d4: a8c57bfd ldp x29, x30, [sp], #80
4002f1d8: d65f03c0 ret
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
4002f1dc: 39405a62 ldrb w2, [x19, #22]
4002f1e0: f240045f tst x2, #0x3
4002f1e4: 54fff060 b.eq 4002eff0 <fat_file_open+0x30> // b.none <== NEVER TAKEN
return fs_info->vol.rdir_loc;
4002f1e8: b9402a60 ldr w0, [x19, #40]
4002f1ec: 17ffff86 b 4002f004 <fat_file_open+0x44>
4002f1f0: b9402a60 ldr w0, [x19, #40]
4002f1f4: 17ffff9e b 4002f06c <fat_file_open+0xac>
4002f1f8: b9402a63 ldr w3, [x19, #40] <== NOT EXECUTED
4002f1fc: 17ffffbd b 4002f0f0 <fat_file_open+0x130> <== NOT EXECUTED
lfat_fd = (*fat_fd) = (fat_file_fd_t*)calloc(1, sizeof(fat_file_fd_t));
4002f200: d2800b01 mov x1, #0x58 // #88
4002f204: d2800020 mov x0, #0x1 // #1
4002f208: 97fff4f6 bl 4002c5e0 <calloc>
4002f20c: f9000300 str x0, [x24]
4002f210: aa0003f9 mov x25, x0
if ( lfat_fd == NULL )
4002f214: b40001e0 cbz x0, 4002f250 <fat_file_open+0x290> <== NEVER TAKEN
lfat_fd->flags &= ~FAT_FILE_REMOVED;
4002f218: 3940e321 ldrb w1, [x25, #56]
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
4002f21c: 12800002 mov w2, #0xffffffff // #-1
lfat_fd->dir_pos = *dir_pos;
4002f220: b94002c3 ldr w3, [x22]
lfat_fd->links_num = 1;
4002f224: 52800024 mov w4, #0x1 // #1
lfat_fd->flags &= ~FAT_FILE_REMOVED;
4002f228: 121f7821 and w1, w1, #0xfffffffe
lfat_fd->dir_pos = *dir_pos;
4002f22c: b9002b23 str w3, [x25, #40]
lfat_fd->flags &= ~FAT_FILE_REMOVED;
4002f230: 3900e321 strb w1, [x25, #56]
lfat_fd->dir_pos = *dir_pos;
4002f234: b9400ec1 ldr w1, [x22, #12]
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
4002f238: b9004722 str w2, [x25, #68]
lfat_fd->dir_pos = *dir_pos;
4002f23c: 29408ac3 ldp w3, w2, [x22, #4]
lfat_fd->ino = key;
4002f240: 29025324 stp w4, w20, [x25, #16]
lfat_fd->dir_pos = *dir_pos;
4002f244: 29058b23 stp w3, w2, [x25, #44]
4002f248: b9003721 str w1, [x25, #52]
4002f24c: 17ffffce b 4002f184 <fat_file_open+0x1c4>
rtems_set_errno_and_return_minus_one( ENOMEM );
4002f250: 94002dc7 bl 4003a96c <__errno> <== NOT EXECUTED
4002f254: aa0003e1 mov x1, x0 <== NOT EXECUTED
4002f258: 52800182 mov w2, #0xc // #12 <== NOT EXECUTED
4002f25c: 12800000 mov w0, #0xffffffff // #-1 <== NOT EXECUTED
4002f260: f94023f9 ldr x25, [sp, #64] <== NOT EXECUTED
4002f264: b9000022 str w2, [x1] <== NOT EXECUTED
4002f268: 17ffffd8 b 4002f1c8 <fat_file_open+0x208> <== NOT EXECUTED
free((*fat_fd));
4002f26c: f9400300 ldr x0, [x24] <== NOT EXECUTED
4002f270: 97ffcac4 bl 40021d80 <free> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
4002f274: 94002dbe bl 4003a96c <__errno> <== NOT EXECUTED
4002f278: aa0003e1 mov x1, x0 <== NOT EXECUTED
4002f27c: 52800182 mov w2, #0xc // #12 <== NOT EXECUTED
4002f280: 2a1403e0 mov w0, w20 <== NOT EXECUTED
4002f284: f94023f9 ldr x25, [sp, #64] <== NOT EXECUTED
4002f288: b9000022 str w2, [x1] <== NOT EXECUTED
4002f28c: 17ffffcf b 4002f1c8 <fat_file_open+0x208> <== NOT EXECUTED
000000004002f340 <fat_file_read>:
{
4002f340: a9b97bfd stp x29, x30, [sp, #-112]!
4002f344: 910003fd mov x29, sp
uint32_t cur_cln = 0;
4002f348: b9006fff str wzr, [sp, #108]
if (count == 0)
4002f34c: 34000aa3 cbz w3, 4002f4a0 <fat_file_read+0x160> <== NEVER TAKEN
4002f350: a90153f3 stp x19, x20, [sp, #16]
4002f354: aa0003f3 mov x19, x0
return cmpltd;
4002f358: d2800000 mov x0, #0x0 // #0
4002f35c: a90363f7 stp x23, x24, [sp, #48]
4002f360: aa0103f8 mov x24, x1
if ( start >= fat_fd->fat_file_size )
4002f364: b9402021 ldr w1, [x1, #32]
4002f368: a9046bf9 stp x25, x26, [sp, #64]
4002f36c: 2a0203f9 mov w25, w2
4002f370: 6b02003f cmp w1, w2
4002f374: 54000889 b.ls 4002f484 <fat_file_read+0x144> // b.plast
4002f378: a9025bf5 stp x21, x22, [sp, #32]
4002f37c: aa0403f7 mov x23, x4
if ((count > fat_fd->fat_file_size) ||
4002f380: 2a0303f5 mov w21, w3
4002f384: 6b03003f cmp w1, w3
4002f388: 54000883 b.cc 4002f498 <fat_file_read+0x158> // b.lo, b.ul, b.last
(start > fat_fd->fat_file_size - count))
4002f38c: 4b030020 sub w0, w1, w3
if ((count > fat_fd->fat_file_size) ||
4002f390: 6b02001f cmp w0, w2
4002f394: 54000823 b.cc 4002f498 <fat_file_read+0x158> // b.lo, b.ul, b.last
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
4002f398: f9401700 ldr x0, [x24, #40]
4002f39c: f100041f cmp x0, #0x1
4002f3a0: 54000081 b.ne 4002f3b0 <fat_file_read+0x70> // b.any
4002f3a4: 39405a60 ldrb w0, [x19, #22]
4002f3a8: f240041f tst x0, #0x3
4002f3ac: 54000801 b.ne 4002f4ac <fat_file_read+0x16c> // b.any
cl_start = start >> fs_info->vol.bpc_log2;
4002f3b0: 3940327a ldrb w26, [x19, #12]
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
4002f3b4: 9101b3e3 add x3, sp, #0x6c
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
4002f3b8: b9400a74 ldr w20, [x19, #8]
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
4002f3bc: aa1803e1 mov x1, x24
4002f3c0: aa1303e0 mov x0, x19
cl_start = start >> fs_info->vol.bpc_log2;
4002f3c4: 1ada273a lsr w26, w25, w26
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
4002f3c8: 2a1a03e2 mov w2, w26
4002f3cc: 97fffec9 bl 4002eef0 <fat_file_lseek>
if (rc != RC_OK)
4002f3d0: 35000980 cbnz w0, 4002f500 <fat_file_read+0x1c0> <== NEVER TAKEN
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
4002f3d4: 51000694 sub w20, w20, #0x1
uint32_t cmpltd = 0;
4002f3d8: 52800016 mov w22, #0x0 // #0
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
4002f3dc: 0a190299 and w25, w20, w25
4002f3e0: f9002bfb str x27, [sp, #80]
4002f3e4: 2a1903e5 mov w5, w25
4002f3e8: 1400001b b 4002f454 <fat_file_read+0x114>
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
4002f3ec: 39401661 ldrb w1, [x19, #5]
4002f3f0: b9403e62 ldr w2, [x19, #60]
4002f3f4: 1ac12001 lsl w1, w0, w1
4002f3f8: 0b020021 add w1, w1, w2
byte = ofs & (fs_info->vol.bps - 1);
4002f3fc: 79400262 ldrh w2, [x19]
ret = _fat_block_read(fs_info, sec, byte, c, buf + cmpltd);
4002f400: 8b3642e4 add x4, x23, w22, uxtw
sec += (ofs >> fs_info->vol.sec_log2);
4002f404: 39400a66 ldrb w6, [x19, #2]
ret = _fat_block_read(fs_info, sec, byte, c, buf + cmpltd);
4002f408: 2a1403e3 mov w3, w20
byte = ofs & (fs_info->vol.bps - 1);
4002f40c: 51000442 sub w2, w2, #0x1
ret = _fat_block_read(fs_info, sec, byte, c, buf + cmpltd);
4002f410: aa1303e0 mov x0, x19
4002f414: 0a050042 and w2, w2, w5
count -= c;
4002f418: 4b1402b5 sub w21, w21, w20
sec += (ofs >> fs_info->vol.sec_log2);
4002f41c: 1ac624a5 lsr w5, w5, w6
ret = _fat_block_read(fs_info, sec, byte, c, buf + cmpltd);
4002f420: 0b0100a1 add w1, w5, w1
4002f424: 97fff89f bl 4002d6a0 <_fat_block_read>
4002f428: aa0003e1 mov x1, x0
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
4002f42c: 9101b3e2 add x2, sp, #0x6c
4002f430: aa1303e0 mov x0, x19
if ( ret < 0 )
4002f434: b7f80901 tbnz x1, #63, 4002f554 <fat_file_read+0x214> <== NEVER TAKEN
save_cln = cur_cln;
4002f438: b9406ffb ldr w27, [sp, #108]
cmpltd += c;
4002f43c: 0b1402d6 add w22, w22, w20
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
4002f440: 2a1b03e1 mov w1, w27
4002f444: 97fffc93 bl 4002e690 <fat_get_fat_cluster>
ofs = 0;
4002f448: 52800005 mov w5, #0x0 // #0
if ( rc != RC_OK )
4002f44c: 35000880 cbnz w0, 4002f55c <fat_file_read+0x21c> <== NEVER TAKEN
while (count > 0)
4002f450: 34000675 cbz w21, 4002f51c <fat_file_read+0x1dc>
c = MIN(count, (fs_info->vol.bpc - ofs));
4002f454: b9400a74 ldr w20, [x19, #8]
sec = fat_cluster_num_to_sector_num(fs_info, cur_cln);
4002f458: b9406fe1 ldr w1, [sp, #108]
c = MIN(count, (fs_info->vol.bpc - ofs));
4002f45c: 4b050294 sub w20, w20, w5
4002f460: 6b15029f cmp w20, w21
4002f464: 51000820 sub w0, w1, #0x2
4002f468: 1a959294 csel w20, w20, w21, ls // ls = plast
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
4002f46c: 35fffc01 cbnz w1, 4002f3ec <fat_file_read+0xac> <== ALWAYS TAKEN
4002f470: 39405a61 ldrb w1, [x19, #22] <== NOT EXECUTED
4002f474: f240043f tst x1, #0x3 <== NOT EXECUTED
4002f478: 54fffba0 b.eq 4002f3ec <fat_file_read+0xac> // b.none <== NOT EXECUTED
return fs_info->vol.rdir_loc;
4002f47c: b9402a61 ldr w1, [x19, #40] <== NOT EXECUTED
4002f480: 17ffffdf b 4002f3fc <fat_file_read+0xbc> <== NOT EXECUTED
4002f484: a94153f3 ldp x19, x20, [sp, #16]
4002f488: a94363f7 ldp x23, x24, [sp, #48]
4002f48c: a9446bf9 ldp x25, x26, [sp, #64]
}
4002f490: a8c77bfd ldp x29, x30, [sp], #112
4002f494: d65f03c0 ret
count = fat_fd->fat_file_size - start;
4002f498: 4b190035 sub w21, w1, w25
4002f49c: 17ffffbf b 4002f398 <fat_file_read+0x58>
return cmpltd;
4002f4a0: d2800000 mov x0, #0x0 // #0 <== NOT EXECUTED
}
4002f4a4: a8c77bfd ldp x29, x30, [sp], #112 <== NOT EXECUTED
4002f4a8: d65f03c0 ret <== NOT EXECUTED
sec = fat_cluster_num_to_sector_num(fs_info, fat_fd->cln);
4002f4ac: b9402700 ldr w0, [x24, #36]
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
4002f4b0: 350005a0 cbnz w0, 4002f564 <fat_file_read+0x224> <== NEVER TAKEN
return fs_info->vol.rdir_loc;
4002f4b4: b9402a61 ldr w1, [x19, #40]
sec += (start >> fs_info->vol.sec_log2);
4002f4b8: 39400a65 ldrb w5, [x19, #2]
ret = _fat_block_read(fs_info, sec, byte, count, buf);
4002f4bc: aa1703e4 mov x4, x23
byte = start & (fs_info->vol.bps - 1);
4002f4c0: 79400262 ldrh w2, [x19]
ret = _fat_block_read(fs_info, sec, byte, count, buf);
4002f4c4: 2a1503e3 mov w3, w21
4002f4c8: aa1303e0 mov x0, x19
byte = start & (fs_info->vol.bps - 1);
4002f4cc: 51000442 sub w2, w2, #0x1
ret = _fat_block_read(fs_info, sec, byte, count, buf);
4002f4d0: 0a190042 and w2, w2, w25
sec += (start >> fs_info->vol.sec_log2);
4002f4d4: 1ac52739 lsr w25, w25, w5
ret = _fat_block_read(fs_info, sec, byte, count, buf);
4002f4d8: 0b010321 add w1, w25, w1
4002f4dc: 97fff871 bl 4002d6a0 <_fat_block_read>
if ( ret < 0 )
4002f4e0: f100001f cmp x0, #0x0
4002f4e4: da9fa000 csinv x0, x0, xzr, ge // ge = tcont
4002f4e8: a94153f3 ldp x19, x20, [sp, #16]
4002f4ec: a9425bf5 ldp x21, x22, [sp, #32]
4002f4f0: a94363f7 ldp x23, x24, [sp, #48]
4002f4f4: a9446bf9 ldp x25, x26, [sp, #64]
}
4002f4f8: a8c77bfd ldp x29, x30, [sp], #112
4002f4fc: d65f03c0 ret
return rc;
4002f500: 93407c00 sxtw x0, w0 <== NOT EXECUTED
4002f504: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
4002f508: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
4002f50c: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
4002f510: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
}
4002f514: a8c77bfd ldp x29, x30, [sp], #112 <== NOT EXECUTED
4002f518: d65f03c0 ret <== NOT EXECUTED
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
4002f51c: 39403261 ldrb w1, [x19, #12]
4002f520: 51000739 sub w25, w25, #0x1
4002f524: 0b160339 add w25, w25, w22
return cmpltd;
4002f528: 2a1603e0 mov w0, w22
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
4002f52c: 1ac12739 lsr w25, w25, w1
fat_fd->map.file_cln = cl_start +
4002f530: 0b1a033a add w26, w25, w26
fat_fd->map.disk_cln = save_cln;
4002f534: 2907ef1a stp w26, w27, [x24, #60]
return cmpltd;
4002f538: a94153f3 ldp x19, x20, [sp, #16]
4002f53c: a9425bf5 ldp x21, x22, [sp, #32]
4002f540: a94363f7 ldp x23, x24, [sp, #48]
4002f544: a9446bf9 ldp x25, x26, [sp, #64]
4002f548: f9402bfb ldr x27, [sp, #80]
}
4002f54c: a8c77bfd ldp x29, x30, [sp], #112
4002f550: d65f03c0 ret
return -1;
4002f554: 92800000 mov x0, #0xffffffffffffffff // #-1 <== NOT EXECUTED
4002f558: 17fffff8 b 4002f538 <fat_file_read+0x1f8> <== NOT EXECUTED
return rc;
4002f55c: 93407c00 sxtw x0, w0 <== NOT EXECUTED
4002f560: 17fffff6 b 4002f538 <fat_file_read+0x1f8> <== NOT EXECUTED
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
4002f564: 39401662 ldrb w2, [x19, #5] <== NOT EXECUTED
4002f568: 51000801 sub w1, w0, #0x2 <== NOT EXECUTED
4002f56c: b9403e60 ldr w0, [x19, #60] <== NOT EXECUTED
4002f570: 1ac22021 lsl w1, w1, w2 <== NOT EXECUTED
4002f574: 0b000021 add w1, w1, w0 <== NOT EXECUTED
4002f578: 17ffffd0 b 4002f4b8 <fat_file_read+0x178> <== NOT EXECUTED
4002f57c: 00000000 udf #0
000000004002fdc0 <fat_file_size>:
{
4002fdc0: a9bc7bfd stp x29, x30, [sp, #-64]!
4002fdc4: 910003fd mov x29, sp
4002fdc8: a90153f3 stp x19, x20, [sp, #16]
4002fdcc: aa0003f3 mov x19, x0
4002fdd0: aa0103f4 mov x20, x1
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
4002fdd4: f9401420 ldr x0, [x1, #40]
{
4002fdd8: f90013f5 str x21, [sp, #32]
uint32_t cur_cln = fat_fd->cln;
4002fddc: b9402435 ldr w21, [x1, #36]
4002fde0: b9003ff5 str w21, [sp, #60]
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
4002fde4: f100041f cmp x0, #0x1
4002fde8: 54000440 b.eq 4002fe70 <fat_file_size+0xb0> // b.none
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
4002fdec: 29430660 ldp w0, w1, [x19, #24]
fat_fd->fat_file_size = 0;
4002fdf0: b900229f str wzr, [x20, #32]
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
4002fdf4: 0a0002a0 and w0, w21, w0
4002fdf8: 6b01001f cmp w0, w1
4002fdfc: 540001a3 b.cc 4002fe30 <fat_file_size+0x70> // b.lo, b.ul, b.last <== ALWAYS TAKEN
4002fe00: 14000015 b 4002fe54 <fat_file_size+0x94> <== NOT EXECUTED
fat_fd->fat_file_size += fs_info->vol.bpc;
4002fe04: b9400a61 ldr w1, [x19, #8]
4002fe08: b9402282 ldr w2, [x20, #32]
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
4002fe0c: b9401a60 ldr w0, [x19, #24]
4002fe10: b9403fe3 ldr w3, [sp, #60]
fat_fd->fat_file_size += fs_info->vol.bpc;
4002fe14: 0b010042 add w2, w2, w1
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
4002fe18: b9401e61 ldr w1, [x19, #28]
fat_fd->fat_file_size += fs_info->vol.bpc;
4002fe1c: b9002282 str w2, [x20, #32]
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
4002fe20: 0a000060 and w0, w3, w0
4002fe24: 6b01001f cmp w0, w1
4002fe28: 54000182 b.cs 4002fe58 <fat_file_size+0x98> // b.hs, b.nlast
4002fe2c: 2a0303f5 mov w21, w3
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
4002fe30: 9100f3e2 add x2, sp, #0x3c
4002fe34: 2a1503e1 mov w1, w21
4002fe38: aa1303e0 mov x0, x19
4002fe3c: 97fffa15 bl 4002e690 <fat_get_fat_cluster>
if ( rc != RC_OK )
4002fe40: 34fffe20 cbz w0, 4002fe04 <fat_file_size+0x44> <== ALWAYS TAKEN
}
4002fe44: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
4002fe48: f94013f5 ldr x21, [sp, #32] <== NOT EXECUTED
4002fe4c: a8c47bfd ldp x29, x30, [sp], #64 <== NOT EXECUTED
4002fe50: d65f03c0 ret <== NOT EXECUTED
uint32_t save_cln = 0;
4002fe54: 52800015 mov w21, #0x0 // #0 <== NOT EXECUTED
fat_fd->map.last_cln = save_cln;
4002fe58: b9004695 str w21, [x20, #68]
return rc;
4002fe5c: 52800000 mov w0, #0x0 // #0
}
4002fe60: a94153f3 ldp x19, x20, [sp, #16]
4002fe64: f94013f5 ldr x21, [sp, #32]
4002fe68: a8c47bfd ldp x29, x30, [sp], #64
4002fe6c: d65f03c0 ret
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
4002fe70: 39405a60 ldrb w0, [x19, #22]
4002fe74: f240041f tst x0, #0x3
4002fe78: 54fffba0 b.eq 4002fdec <fat_file_size+0x2c> // b.none
fat_fd->fat_file_size = fs_info->vol.rdir_size;
4002fe7c: b9403661 ldr w1, [x19, #52]
return rc;
4002fe80: 52800000 mov w0, #0x0 // #0
fat_fd->fat_file_size = fs_info->vol.rdir_size;
4002fe84: b9002281 str w1, [x20, #32]
}
4002fe88: a94153f3 ldp x19, x20, [sp, #16]
4002fe8c: f94013f5 ldr x21, [sp, #32]
4002fe90: a8c47bfd ldp x29, x30, [sp], #64
4002fe94: d65f03c0 ret
...
000000004002f580 <fat_file_truncate>:
{
4002f580: a9bc7bfd stp x29, x30, [sp, #-64]!
uint32_t new_last_cln = FAT_UNDEFINED_VALUE;
4002f584: 12800003 mov w3, #0xffffffff // #-1
{
4002f588: 910003fd mov x29, sp
uint32_t new_last_cln = FAT_UNDEFINED_VALUE;
4002f58c: 29070fff stp wzr, w3, [sp, #56]
if ( new_length >= fat_fd->fat_file_size )
4002f590: b9402023 ldr w3, [x1, #32]
4002f594: 6b02007f cmp w3, w2
4002f598: 540003c9 b.ls 4002f610 <fat_file_truncate+0x90> // b.plast
assert(fat_fd->fat_file_size);
4002f59c: a90153f3 stp x19, x20, [sp, #16]
4002f5a0: 34000663 cbz w3, 4002f66c <fat_file_truncate+0xec> <== NEVER TAKEN
cl_start = (new_length + fs_info->vol.bpc - 1) >> fs_info->vol.bpc_log2;
4002f5a4: b9400813 ldr w19, [x0, #8]
4002f5a8: aa0003f4 mov x20, x0
4002f5ac: 39403004 ldrb w4, [x0, #12]
4002f5b0: 0b130053 add w19, w2, w19
4002f5b4: 51000673 sub w19, w19, #0x1
4002f5b8: 1ac42673 lsr w19, w19, w4
if ((cl_start << fs_info->vol.bpc_log2) >= fat_fd->fat_file_size)
4002f5bc: 1ac42264 lsl w4, w19, w4
4002f5c0: 6b04007f cmp w3, w4
4002f5c4: 54000249 b.ls 4002f60c <fat_file_truncate+0x8c> // b.plast
if (cl_start != 0)
4002f5c8: f90013f5 str x21, [sp, #32]
4002f5cc: aa0103f5 mov x21, x1
4002f5d0: 340000b3 cbz w19, 4002f5e4 <fat_file_truncate+0x64>
rc = fat_file_lseek(fs_info, fat_fd, cl_start - 1, &new_last_cln);
4002f5d4: 9100f3e3 add x3, sp, #0x3c
4002f5d8: 51000662 sub w2, w19, #0x1
4002f5dc: 97fffe45 bl 4002eef0 <fat_file_lseek>
if (rc != RC_OK)
4002f5e0: 350000e0 cbnz w0, 4002f5fc <fat_file_truncate+0x7c> <== NEVER TAKEN
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
4002f5e4: 9100e3e3 add x3, sp, #0x38
4002f5e8: 2a1303e2 mov w2, w19
4002f5ec: aa1503e1 mov x1, x21
4002f5f0: aa1403e0 mov x0, x20
4002f5f4: 97fffe3f bl 4002eef0 <fat_file_lseek>
if (rc != RC_OK)
4002f5f8: 34000120 cbz w0, 4002f61c <fat_file_truncate+0x9c> <== ALWAYS TAKEN
4002f5fc: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
4002f600: f94013f5 ldr x21, [sp, #32] <== NOT EXECUTED
}
4002f604: a8c47bfd ldp x29, x30, [sp], #64 <== NOT EXECUTED
4002f608: d65f03c0 ret <== NOT EXECUTED
4002f60c: a94153f3 ldp x19, x20, [sp, #16]
return rc;
4002f610: 52800000 mov w0, #0x0 // #0
}
4002f614: a8c47bfd ldp x29, x30, [sp], #64
4002f618: d65f03c0 ret
rc = fat_free_fat_clusters_chain(fs_info, cur_cln);
4002f61c: b9403be1 ldr w1, [sp, #56]
4002f620: aa1403e0 mov x0, x20
4002f624: 97fffd5b bl 4002eb90 <fat_free_fat_clusters_chain>
if (rc != RC_OK)
4002f628: 35fffea0 cbnz w0, 4002f5fc <fat_file_truncate+0x7c> <== NEVER TAKEN
if (cl_start != 0)
4002f62c: 35000093 cbnz w19, 4002f63c <fat_file_truncate+0xbc>
4002f630: a94153f3 ldp x19, x20, [sp, #16]
4002f634: f94013f5 ldr x21, [sp, #32]
4002f638: 17fffff6 b 4002f610 <fat_file_truncate+0x90>
rc = fat_set_fat_cluster(fs_info, new_last_cln, FAT_GENFAT_EOC);
4002f63c: b9403fe1 ldr w1, [sp, #60]
4002f640: aa1403e0 mov x0, x20
4002f644: 12800002 mov w2, #0xffffffff // #-1
4002f648: 97fffc9e bl 4002e8c0 <fat_set_fat_cluster>
if ( rc != RC_OK )
4002f64c: 35fffd80 cbnz w0, 4002f5fc <fat_file_truncate+0x7c> <== NEVER TAKEN
fat_fd->map.disk_cln = new_last_cln;
4002f650: b9403fe1 ldr w1, [sp, #60]
fat_fd->map.file_cln = cl_start - 1;
4002f654: 51000673 sub w19, w19, #0x1
fat_fd->map.disk_cln = new_last_cln;
4002f658: 290786b3 stp w19, w1, [x21, #60]
fat_fd->map.last_cln = new_last_cln;
4002f65c: b90046a1 str w1, [x21, #68]
4002f660: a94153f3 ldp x19, x20, [sp, #16]
4002f664: f94013f5 ldr x21, [sp, #32]
4002f668: 17ffffeb b 4002f614 <fat_file_truncate+0x94>
assert(fat_fd->fat_file_size);
4002f66c: d00000c3 adrp x3, 40049000 <IMFS_node_control_sym_link+0xe0> <== NOT EXECUTED
4002f670: d00000c2 adrp x2, 40049000 <IMFS_node_control_sym_link+0xe0> <== NOT EXECUTED
4002f674: d00000c0 adrp x0, 40049000 <IMFS_node_control_sym_link+0xe0> <== NOT EXECUTED
4002f678: 91076063 add x3, x3, #0x1d8 <== NOT EXECUTED
4002f67c: 91088042 add x2, x2, #0x220 <== NOT EXECUTED
4002f680: 9107c000 add x0, x0, #0x1f0 <== NOT EXECUTED
4002f684: 52805c81 mov w1, #0x2e4 // #740 <== NOT EXECUTED
4002f688: f90013f5 str x21, [sp, #32] <== NOT EXECUTED
4002f68c: 94001c85 bl 400368a0 <__assert_func> <== NOT EXECUTED
000000004002fb10 <fat_file_write>:
{
4002fb10: a9b87bfd stp x29, x30, [sp, #-128]!
4002fb14: 910003fd mov x29, sp
uint32_t c = 0;
4002fb18: b9007bff str wzr, [sp, #120]
if ( count == 0 )
4002fb1c: 34000a03 cbz w3, 4002fc5c <fat_file_write+0x14c> <== NEVER TAKEN
4002fb20: a90153f3 stp x19, x20, [sp, #16]
4002fb24: 2a0203f4 mov w20, w2
if (start >= fat_fd->size_limit)
4002fb28: b9401c33 ldr w19, [x1, #28]
4002fb2c: a90363f7 stp x23, x24, [sp, #48]
4002fb30: aa0103f8 mov x24, x1
4002fb34: 6b02027f cmp w19, w2
4002fb38: 54000fe9 b.ls 4002fd34 <fat_file_write+0x224> // b.plast <== NEVER TAKEN
if (count > fat_fd->size_limit - start)
4002fb3c: 4b020273 sub w19, w19, w2
4002fb40: a9046bf9 stp x25, x26, [sp, #64]
4002fb44: 6b03027f cmp w19, w3
4002fb48: 1a839273 csel w19, w19, w3, ls // ls = plast
rc = fat_file_extend(fs_info, fat_fd, zero_fill, start + count, &c);
4002fb4c: aa0403f7 mov x23, x4
4002fb50: 0b130059 add w25, w2, w19
bool zero_fill = start > fat_fd->fat_file_size;
4002fb54: b9402022 ldr w2, [x1, #32]
rc = fat_file_extend(fs_info, fat_fd, zero_fill, start + count, &c);
4002fb58: 9101e3e4 add x4, sp, #0x78
4002fb5c: 2a1903e3 mov w3, w25
bool zero_fill = start > fat_fd->fat_file_size;
4002fb60: 6b14005f cmp w2, w20
4002fb64: a9025bf5 stp x21, x22, [sp, #32]
rc = fat_file_extend(fs_info, fat_fd, zero_fill, start + count, &c);
4002fb68: 1a9f27e2 cset w2, cc // cc = lo, ul, last
4002fb6c: aa0003f6 mov x22, x0
4002fb70: 97ffff38 bl 4002f850 <fat_file_extend>
if (RC_OK == rc)
4002fb74: 35000660 cbnz w0, 4002fc40 <fat_file_write+0x130>
if (c != (start + count))
4002fb78: b9407be0 ldr w0, [sp, #120]
cln += (start >> fs_info->vol.bpc_log2);
4002fb7c: 394032d5 ldrb w21, [x22, #12]
return (FAT_FD_OF_ROOT_DIR(fat_fd)) && (volume_type & (FAT_FAT12 | FAT_FAT16));
4002fb80: f9401701 ldr x1, [x24, #40]
count = c - start;
4002fb84: 6b00033f cmp w25, w0
4002fb88: 4b140000 sub w0, w0, w20
cln += (start >> fs_info->vol.bpc_log2);
4002fb8c: 1ad5269a lsr w26, w20, w21
count = c - start;
4002fb90: 1a931013 csel w19, w0, w19, ne // ne = any
return (FAT_FD_OF_ROOT_DIR(fat_fd)) && (volume_type & (FAT_FAT12 | FAT_FAT16));
4002fb94: f100043f cmp x1, #0x1
4002fb98: 54000940 b.eq 4002fcc0 <fat_file_write+0x1b0> // b.none
rc = fat_file_lseek(fs_info, fat_fd, start_cln, &cur_cln);
4002fb9c: aa1803e1 mov x1, x24
4002fba0: 2a1a03e2 mov w2, w26
4002fba4: 9101f3e3 add x3, sp, #0x7c
4002fba8: aa1603e0 mov x0, x22
uint32_t cur_cln = 0;
4002fbac: b9007fff str wzr, [sp, #124]
rc = fat_file_lseek(fs_info, fat_fd, start_cln, &cur_cln);
4002fbb0: 97fffcd0 bl 4002eef0 <fat_file_lseek>
4002fbb4: 2a0003e1 mov w1, w0
if (RC_OK == rc)
4002fbb8: 35000740 cbnz w0, 4002fca0 <fat_file_write+0x190> <== NEVER TAKEN
4002fbbc: f9002bfb str x27, [sp, #80]
uint32_t ofs_cln = start - (start_cln << fs_info->vol.bpc_log2);
4002fbc0: 1ad52342 lsl w2, w26, w21
4002fbc4: 4b020282 sub w2, w20, w2
uint32_t save_cln = 0; /* FIXME: This might be incorrect, cf. below */
4002fbc8: 52800019 mov w25, #0x0 // #0
((ofs_cln_save + cmpltd - 1) >> fs_info->vol.bpc_log2);
4002fbcc: 5100045b sub w27, w2, #0x1
uint32_t cmpltd = 0;
4002fbd0: 52800015 mov w21, #0x0 // #0
while ( (RC_OK == rc)
4002fbd4: 34000a93 cbz w19, 4002fd24 <fat_file_write+0x214> <== NEVER TAKEN
c = MIN(bytes_to_write, (fs_info->vol.bpc - ofs_cln));
4002fbd8: b9400ac3 ldr w3, [x22, #8]
ret = fat_cluster_write(fs_info,
4002fbdc: 8b3542e4 add x4, x23, w21, uxtw
4002fbe0: b9407fe1 ldr w1, [sp, #124]
4002fbe4: aa1603e0 mov x0, x22
c = MIN(bytes_to_write, (fs_info->vol.bpc - ofs_cln));
4002fbe8: 4b020063 sub w3, w3, w2
4002fbec: 6b13007f cmp w3, w19
ret = fat_cluster_write(fs_info,
4002fbf0: 1a939063 csel w3, w3, w19, ls // ls = plast
4002fbf4: 97fff793 bl 4002da40 <fat_cluster_write>
if (0 > ret)
4002fbf8: b7f80ae0 tbnz x0, #63, 4002fd54 <fat_file_write+0x244> <== NEVER TAKEN
save_cln = cur_cln;
4002fbfc: b9407ff9 ldr w25, [sp, #124]
cmpltd += ret;
4002fc00: 0b0002b5 add w21, w21, w0
if (0 < bytes_to_write)
4002fc04: 6b000273 subs w19, w19, w0
4002fc08: 54000301 b.ne 4002fc68 <fat_file_write+0x158> // b.any
((ofs_cln_save + cmpltd - 1) >> fs_info->vol.bpc_log2);
4002fc0c: 0b1b02bb add w27, w21, w27
return cmpltd;
4002fc10: 2a1503e0 mov w0, w21
((ofs_cln_save + cmpltd - 1) >> fs_info->vol.bpc_log2);
4002fc14: 394032c1 ldrb w1, [x22, #12]
fat_fd->map.disk_cln = save_cln;
4002fc18: b9004319 str w25, [x24, #64]
((ofs_cln_save + cmpltd - 1) >> fs_info->vol.bpc_log2);
4002fc1c: 1ac1277b lsr w27, w27, w1
fat_fd->map.file_cln = start_cln +
4002fc20: 0b1a037a add w26, w27, w26
4002fc24: a94153f3 ldp x19, x20, [sp, #16]
4002fc28: a9425bf5 ldp x21, x22, [sp, #32]
4002fc2c: f9402bfb ldr x27, [sp, #80]
4002fc30: b9003f1a str w26, [x24, #60]
4002fc34: a94363f7 ldp x23, x24, [sp, #48]
4002fc38: a9446bf9 ldp x25, x26, [sp, #64]
4002fc3c: 14000006 b 4002fc54 <fat_file_write+0x144>
return rc;
4002fc40: a94153f3 ldp x19, x20, [sp, #16]
4002fc44: 93407c00 sxtw x0, w0
4002fc48: a9425bf5 ldp x21, x22, [sp, #32]
4002fc4c: a94363f7 ldp x23, x24, [sp, #48]
4002fc50: a9446bf9 ldp x25, x26, [sp, #64]
}
4002fc54: a8c87bfd ldp x29, x30, [sp], #128
4002fc58: d65f03c0 ret
return cmpltd;
4002fc5c: d2800000 mov x0, #0x0 // #0 <== NOT EXECUTED
}
4002fc60: a8c87bfd ldp x29, x30, [sp], #128 <== NOT EXECUTED
4002fc64: d65f03c0 ret <== NOT EXECUTED
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
4002fc68: 9101f3e2 add x2, sp, #0x7c
4002fc6c: 2a1903e1 mov w1, w25
4002fc70: aa1603e0 mov x0, x22
4002fc74: 97fffa87 bl 4002e690 <fat_get_fat_cluster>
4002fc78: b9006fe0 str w0, [sp, #108]
4002fc7c: 2a0003e1 mov w1, w0
ofs_cln = 0;
4002fc80: 52800002 mov w2, #0x0 // #0
while ( (RC_OK == rc)
4002fc84: 34fffaa1 cbz w1, 4002fbd8 <fat_file_write+0xc8> <== ALWAYS TAKEN
((ofs_cln_save + cmpltd - 1) >> fs_info->vol.bpc_log2);
4002fc88: 394032c2 ldrb w2, [x22, #12] <== NOT EXECUTED
4002fc8c: 0b1b02a0 add w0, w21, w27 <== NOT EXECUTED
4002fc90: f9402bfb ldr x27, [sp, #80] <== NOT EXECUTED
4002fc94: 1ac22400 lsr w0, w0, w2 <== NOT EXECUTED
fat_fd->map.file_cln = start_cln +
4002fc98: 0b1a001a add w26, w0, w26 <== NOT EXECUTED
fat_fd->map.disk_cln = save_cln;
4002fc9c: 2907e71a stp w26, w25, [x24, #60] <== NOT EXECUTED
return rc;
4002fca0: 93407c20 sxtw x0, w1 <== NOT EXECUTED
if (0 > ret)
4002fca4: 36f80361 tbz w1, #31, 4002fd10 <fat_file_write+0x200> <== NOT EXECUTED
fat_fd->map.disk_cln = save_cln;
4002fca8: 92800000 mov x0, #0xffffffffffffffff // #-1 <== NOT EXECUTED
4002fcac: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
4002fcb0: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
4002fcb4: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
4002fcb8: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
4002fcbc: 17ffffe6 b 4002fc54 <fat_file_write+0x144> <== NOT EXECUTED
return (FAT_FD_OF_ROOT_DIR(fat_fd)) && (volume_type & (FAT_FAT12 | FAT_FAT16));
4002fcc0: 39405ac0 ldrb w0, [x22, #22]
4002fcc4: f240041f tst x0, #0x3
4002fcc8: 54fff6a0 b.eq 4002fb9c <fat_file_write+0x8c> // b.none
byte = start & (fs_info->vol.bpc -1);
4002fccc: b9400ac2 ldr w2, [x22, #8]
ret = fat_cluster_write(fs_info,
4002fcd0: aa1703e4 mov x4, x23
cln = fat_fd->cln;
4002fcd4: b9402701 ldr w1, [x24, #36]
ret = fat_cluster_write(fs_info,
4002fcd8: 2a1303e3 mov w3, w19
byte = start & (fs_info->vol.bpc -1);
4002fcdc: 51000442 sub w2, w2, #0x1
ret = fat_cluster_write(fs_info,
4002fce0: aa1603e0 mov x0, x22
4002fce4: 0a140042 and w2, w2, w20
4002fce8: 0b1a0021 add w1, w1, w26
4002fcec: 97fff755 bl 4002da40 <fat_cluster_write>
if (0 > ret)
4002fcf0: b7fffdc0 tbnz x0, #63, 4002fca8 <fat_file_write+0x198> <== NEVER TAKEN
cmpltd = ret;
4002fcf4: 92407c00 and x0, x0, #0xffffffff
4002fcf8: a94153f3 ldp x19, x20, [sp, #16]
4002fcfc: a9425bf5 ldp x21, x22, [sp, #32]
4002fd00: a94363f7 ldp x23, x24, [sp, #48]
4002fd04: a9446bf9 ldp x25, x26, [sp, #64]
}
4002fd08: a8c87bfd ldp x29, x30, [sp], #128
4002fd0c: d65f03c0 ret
4002fd10: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
4002fd14: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
4002fd18: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
4002fd1c: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
4002fd20: 17ffffcd b 4002fc54 <fat_file_write+0x144> <== NOT EXECUTED
((ofs_cln_save + cmpltd - 1) >> fs_info->vol.bpc_log2);
4002fd24: 394032c1 ldrb w1, [x22, #12] <== NOT EXECUTED
fat_fd->map.disk_cln = save_cln;
4002fd28: d2800000 mov x0, #0x0 // #0 <== NOT EXECUTED
4002fd2c: b900431f str wzr, [x24, #64] <== NOT EXECUTED
4002fd30: 17ffffbb b 4002fc1c <fat_file_write+0x10c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EFBIG);
4002fd34: 94002b0e bl 4003a96c <__errno> <== NOT EXECUTED
4002fd38: aa0003e1 mov x1, x0 <== NOT EXECUTED
4002fd3c: 52800362 mov w2, #0x1b // #27 <== NOT EXECUTED
4002fd40: 92800000 mov x0, #0xffffffffffffffff // #-1 <== NOT EXECUTED
4002fd44: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
4002fd48: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
4002fd4c: b9000022 str w2, [x1] <== NOT EXECUTED
4002fd50: 17ffffc1 b 4002fc54 <fat_file_write+0x144> <== NOT EXECUTED
((ofs_cln_save + cmpltd - 1) >> fs_info->vol.bpc_log2);
4002fd54: 394032c1 ldrb w1, [x22, #12] <== NOT EXECUTED
4002fd58: 0b150360 add w0, w27, w21 <== NOT EXECUTED
4002fd5c: f9402bfb ldr x27, [sp, #80] <== NOT EXECUTED
4002fd60: 1ac12400 lsr w0, w0, w1 <== NOT EXECUTED
fat_fd->map.file_cln = start_cln +
4002fd64: 0b1a001a add w26, w0, w26 <== NOT EXECUTED
fat_fd->map.disk_cln = save_cln;
4002fd68: 2907e71a stp w26, w25, [x24, #60] <== NOT EXECUTED
4002fd6c: 17ffffcf b 4002fca8 <fat_file_write+0x198> <== NOT EXECUTED
0000000040030cb0 <fat_file_write_file_size>:
{
40030cb0: a9be7bfd stp x29, x30, [sp, #-32]!
40030cb4: aa0103e5 mov x5, x1
40030cb8: 910003fd mov x29, sp
sec = fat_cluster_num_to_sector_num(fs_info, fat_fd->dir_pos.sname.cln);
40030cbc: b9402822 ldr w2, [x1, #40]
uint32_t le_new_length = 0;
40030cc0: b9001fff str wzr, [sp, #28]
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
40030cc4: 35000082 cbnz w2, 40030cd4 <fat_file_write_file_size+0x24>
40030cc8: 39405801 ldrb w1, [x0, #22]
40030ccc: f240043f tst x1, #0x3
40030cd0: 54000301 b.ne 40030d30 <fat_file_write_file_size+0x80> // b.any <== ALWAYS TAKEN
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
40030cd4: 39401404 ldrb w4, [x0, #5]
40030cd8: 51000843 sub w3, w2, #0x2
40030cdc: b9403c01 ldr w1, [x0, #60]
40030ce0: 1ac42063 lsl w3, w3, w4
40030ce4: 0b010063 add w3, w3, w1
if (fat_fd->fat_file_type == FAT_DIRECTORY) {
40030ce8: b94018a6 ldr w6, [x5, #24]
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->vol.sec_log2);
40030cec: 39400801 ldrb w1, [x0, #2]
40030cf0: b9402ca4 ldr w4, [x5, #44]
byte = (fat_fd->dir_pos.sname.ofs & (fs_info->vol.bps - 1));
40030cf4: 79400002 ldrh w2, [x0]
40030cf8: 51000442 sub w2, w2, #0x1
40030cfc: 0a040042 and w2, w2, w4
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->vol.sec_log2);
40030d00: 1ac12484 lsr w4, w4, w1
40030d04: 0b030081 add w1, w4, w3
if (fat_fd->fat_file_type == FAT_DIRECTORY) {
40030d08: 34000066 cbz w6, 40030d14 <fat_file_write_file_size+0x64>
le_new_length = CT_LE_L(fat_fd->fat_file_size);
40030d0c: b94020a3 ldr w3, [x5, #32]
40030d10: b9001fe3 str w3, [sp, #28]
ret = fat_sector_write(fs_info, sec, byte + MSDOS_FILE_SIZE_OFFSET, 4,
40030d14: 910073e4 add x4, sp, #0x1c
40030d18: 11007042 add w2, w2, #0x1c
40030d1c: 52800083 mov w3, #0x4 // #4
40030d20: 97fff2ac bl 4002d7d0 <fat_sector_write>
}
40030d24: 937ffc00 asr x0, x0, #63
40030d28: a8c27bfd ldp x29, x30, [sp], #32
40030d2c: d65f03c0 ret
return fs_info->vol.rdir_loc;
40030d30: b9402803 ldr w3, [x0, #40]
40030d34: 17ffffed b 40030ce8 <fat_file_write_file_size+0x38>
...
0000000040030bf0 <fat_file_write_first_cluster_num>:
{
40030bf0: a9bc7bfd stp x29, x30, [sp, #-64]!
40030bf4: 910003fd mov x29, sp
40030bf8: a90153f3 stp x19, x20, [sp, #16]
40030bfc: aa0003f3 mov x19, x0
40030c00: a9025bf5 stp x21, x22, [sp, #32]
sec = fat_cluster_num_to_sector_num(fs_info, fat_fd->dir_pos.sname.cln);
40030c04: 29448036 ldp w22, w0, [x1, #36]
uint16_t le_cl_hi = 0;
40030c08: 79007fff strh wzr, [sp, #62]
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
40030c0c: 35000080 cbnz w0, 40030c1c <fat_file_write_first_cluster_num+0x2c>
40030c10: 39405a62 ldrb w2, [x19, #22]
40030c14: f240045f tst x2, #0x3
40030c18: 54000481 b.ne 40030ca8 <fat_file_write_first_cluster_num+0xb8> // b.any<== ALWAYS TAKEN
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
40030c1c: 39401662 ldrb w2, [x19, #5]
40030c20: 51000805 sub w5, w0, #0x2
40030c24: b9403e60 ldr w0, [x19, #60]
40030c28: 1ac220a5 lsl w5, w5, w2
40030c2c: 0b0000a5 add w5, w5, w0
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->vol.sec_log2);
40030c30: 39400a62 ldrb w2, [x19, #2]
ret1 = fat_sector_write(fs_info, sec,
40030c34: 9100f3e4 add x4, sp, #0x3c
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->vol.sec_log2);
40030c38: b9402c34 ldr w20, [x1, #44]
ret1 = fat_sector_write(fs_info, sec,
40030c3c: aa1303e0 mov x0, x19
byte = fat_fd->dir_pos.sname.ofs & (fs_info->vol.bps - 1);
40030c40: 79400275 ldrh w21, [x19]
ret1 = fat_sector_write(fs_info, sec,
40030c44: 52800043 mov w3, #0x2 // #2
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
40030c48: 79007bf6 strh w22, [sp, #60]
le_cl_hi = CT_LE_W((uint16_t )((new_cln & 0xFFFF0000) >> 16));
40030c4c: 53107ed6 lsr w22, w22, #16
byte = fat_fd->dir_pos.sname.ofs & (fs_info->vol.bps - 1);
40030c50: 510006b5 sub w21, w21, #0x1
40030c54: 0a1402b5 and w21, w21, w20
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->vol.sec_log2);
40030c58: 1ac22694 lsr w20, w20, w2
40030c5c: 0b050294 add w20, w20, w5
ret1 = fat_sector_write(fs_info, sec,
40030c60: 11006aa2 add w2, w21, #0x1a
40030c64: 2a1403e1 mov w1, w20
40030c68: 97fff2da bl 4002d7d0 <fat_sector_write>
ret2 = fat_sector_write(fs_info, sec,
40030c6c: 110052a2 add w2, w21, #0x14
40030c70: 2a1403e1 mov w1, w20
40030c74: 9100fbe4 add x4, sp, #0x3e
ret1 = fat_sector_write(fs_info, sec,
40030c78: aa0003f4 mov x20, x0
ret2 = fat_sector_write(fs_info, sec,
40030c7c: 52800043 mov w3, #0x2 // #2
40030c80: aa1303e0 mov x0, x19
le_cl_hi = CT_LE_W((uint16_t )((new_cln & 0xFFFF0000) >> 16));
40030c84: 79007ff6 strh w22, [sp, #62]
ret2 = fat_sector_write(fs_info, sec,
40030c88: 97fff2d2 bl 4002d7d0 <fat_sector_write>
if ( (ret1 < 0) || (ret2 < 0) )
40030c8c: f100029f cmp x20, #0x0
40030c90: fa40a801 ccmp x0, #0x0, #0x1, ge // ge = tcont
}
40030c94: 5a9fa3e0 csetm w0, lt // lt = tstop
40030c98: a94153f3 ldp x19, x20, [sp, #16]
40030c9c: a9425bf5 ldp x21, x22, [sp, #32]
40030ca0: a8c47bfd ldp x29, x30, [sp], #64
40030ca4: d65f03c0 ret
return fs_info->vol.rdir_loc;
40030ca8: b9402a65 ldr w5, [x19, #40]
40030cac: 17ffffe1 b 40030c30 <fat_file_write_first_cluster_num+0x40>
0000000040030ab0 <fat_file_write_time_and_date>:
{
40030ab0: a9bb7bfd stp x29, x30, [sp, #-80]!
40030ab4: 910003fd mov x29, sp
40030ab8: a90153f3 stp x19, x20, [sp, #16]
40030abc: aa0003f3 mov x19, x0
sec = fat_cluster_num_to_sector_num(fs_info, fat_fd->dir_pos.sname.cln);
40030ac0: b9402820 ldr w0, [x1, #40]
{
40030ac4: a9025bf5 stp x21, x22, [sp, #32]
40030ac8: a90363f7 stp x23, x24, [sp, #48]
40030acc: aa0103f8 mov x24, x1
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
40030ad0: 35000080 cbnz w0, 40030ae0 <fat_file_write_time_and_date+0x30>
40030ad4: 39405a61 ldrb w1, [x19, #22]
40030ad8: f240043f tst x1, #0x3
40030adc: 54000861 b.ne 40030be8 <fat_file_write_time_and_date+0x138> // b.any<== ALWAYS TAKEN
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
40030ae0: 39401675 ldrb w21, [x19, #5]
40030ae4: 51000800 sub w0, w0, #0x2
40030ae8: b9403e63 ldr w3, [x19, #60]
40030aec: 1ad52015 lsl w21, w0, w21
40030af0: 0b0302a3 add w3, w21, w3
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->vol.sec_log2);
40030af4: 39400a64 ldrb w4, [x19, #2]
msdos_date_unix2dos(fat_fd->mtime, &date, &time_val);
40030af8: 910133e2 add x2, sp, #0x4c
40030afc: b9405300 ldr w0, [x24, #80]
40030b00: 91013be1 add x1, sp, #0x4e
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->vol.sec_log2);
40030b04: b9402f15 ldr w21, [x24, #44]
if ( ret < 0 )
40030b08: 12800017 mov w23, #0xffffffff // #-1
byte = fat_fd->dir_pos.sname.ofs & (fs_info->vol.bps - 1);
40030b0c: 79400276 ldrh w22, [x19]
40030b10: 510006d6 sub w22, w22, #0x1
40030b14: 0a1502d6 and w22, w22, w21
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->vol.sec_log2);
40030b18: 1ac426b5 lsr w21, w21, w4
40030b1c: 0b0302b5 add w21, w21, w3
msdos_date_unix2dos(fat_fd->mtime, &date, &time_val);
40030b20: 94001868 bl 40036cc0 <msdos_date_unix2dos>
ret = fat_sector_write(fs_info, sec, byte + MSDOS_FILE_WTIME_OFFSET,
40030b24: 910133e4 add x4, sp, #0x4c
40030b28: 11005ac2 add w2, w22, #0x16
40030b2c: 2a1503e1 mov w1, w21
40030b30: aa1303e0 mov x0, x19
40030b34: 52800043 mov w3, #0x2 // #2
40030b38: 97fff326 bl 4002d7d0 <fat_sector_write>
ret = fat_sector_write(fs_info, sec, byte + MSDOS_FILE_WDATE_OFFSET,
40030b3c: 110062c2 add w2, w22, #0x18
40030b40: 2a1503e1 mov w1, w21
40030b44: 91013be4 add x4, sp, #0x4e
ret = fat_sector_write(fs_info, sec, byte + MSDOS_FILE_WTIME_OFFSET,
40030b48: aa0003f4 mov x20, x0
ret = fat_sector_write(fs_info, sec, byte + MSDOS_FILE_WDATE_OFFSET,
40030b4c: 52800043 mov w3, #0x2 // #2
40030b50: aa1303e0 mov x0, x19
40030b54: 97fff31f bl 4002d7d0 <fat_sector_write>
if ( ret < 0 )
40030b58: f100001f cmp x0, #0x0
40030b5c: 937ffe94 asr x20, x20, #63
ret = fat_sector_write(fs_info, sec, byte + MSDOS_FILE_ADATE_OFFSET,
40030b60: 91013be4 add x4, sp, #0x4e
if ( ret < 0 )
40030b64: 1a97a294 csel w20, w20, w23, ge // ge = tcont
ret = fat_sector_write(fs_info, sec, byte + MSDOS_FILE_ADATE_OFFSET,
40030b68: 11004ac2 add w2, w22, #0x12
40030b6c: 2a1503e1 mov w1, w21
40030b70: 52800043 mov w3, #0x2 // #2
40030b74: aa1303e0 mov x0, x19
40030b78: 97fff316 bl 4002d7d0 <fat_sector_write>
rc = -1;
40030b7c: f100001f cmp x0, #0x0
msdos_date_unix2dos(fat_fd->ctime, &date, &time_val);
40030b80: b9404b00 ldr w0, [x24, #72]
rc = -1;
40030b84: 1a97a294 csel w20, w20, w23, ge // ge = tcont
msdos_date_unix2dos(fat_fd->ctime, &date, &time_val);
40030b88: 910133e2 add x2, sp, #0x4c
40030b8c: 91013be1 add x1, sp, #0x4e
40030b90: 9400184c bl 40036cc0 <msdos_date_unix2dos>
ret = fat_sector_write(fs_info, sec, byte + MSDOS_FILE_CTIME_OFFSET,
40030b94: 910133e4 add x4, sp, #0x4c
40030b98: 11003ac2 add w2, w22, #0xe
40030b9c: 2a1503e1 mov w1, w21
40030ba0: aa1303e0 mov x0, x19
40030ba4: 52800043 mov w3, #0x2 // #2
40030ba8: 97fff30a bl 4002d7d0 <fat_sector_write>
rc = -1;
40030bac: f100001f cmp x0, #0x0
ret = fat_sector_write(fs_info, sec, byte + MSDOS_FILE_CDATE_OFFSET,
40030bb0: 110042c2 add w2, w22, #0x10
rc = -1;
40030bb4: 1a97a294 csel w20, w20, w23, ge // ge = tcont
ret = fat_sector_write(fs_info, sec, byte + MSDOS_FILE_CDATE_OFFSET,
40030bb8: 2a1503e1 mov w1, w21
40030bbc: 91013be4 add x4, sp, #0x4e
40030bc0: aa1303e0 mov x0, x19
40030bc4: 52800043 mov w3, #0x2 // #2
40030bc8: 97fff302 bl 4002d7d0 <fat_sector_write>
rc = -1;
40030bcc: f100001f cmp x0, #0x0
}
40030bd0: 1a97a280 csel w0, w20, w23, ge // ge = tcont
40030bd4: a94153f3 ldp x19, x20, [sp, #16]
40030bd8: a9425bf5 ldp x21, x22, [sp, #32]
40030bdc: a94363f7 ldp x23, x24, [sp, #48]
40030be0: a8c57bfd ldp x29, x30, [sp], #80
40030be4: d65f03c0 ret
return fs_info->vol.rdir_loc;
40030be8: b9402a63 ldr w3, [x19, #40]
40030bec: 17ffffc2 b 40030af4 <fat_file_write_time_and_date+0x44>
000000004002eb90 <fat_free_fat_clusters_chain>:
{
4002eb90: a9bb7bfd stp x29, x30, [sp, #-80]!
4002eb94: 910003fd mov x29, sp
4002eb98: a90153f3 stp x19, x20, [sp, #16]
4002eb9c: aa0003f3 mov x19, x0
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
4002eba0: b9401800 ldr w0, [x0, #24]
{
4002eba4: a9025bf5 stp x21, x22, [sp, #32]
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
4002eba8: 0a000020 and w0, w1, w0
{
4002ebac: f9001bf7 str x23, [sp, #48]
4002ebb0: 2a0103f7 mov w23, w1
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
4002ebb4: b9401e61 ldr w1, [x19, #28]
uint32_t next_cln = 0;
4002ebb8: b9004fff str wzr, [sp, #76]
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
4002ebbc: 6b00003f cmp w1, w0
4002ebc0: 540004a9 b.ls 4002ec54 <fat_free_fat_clusters_chain+0xc4> // b.plast<== NEVER TAKEN
uint32_t cur_cln = chain;
4002ebc4: 2a1703f4 mov w20, w23
uint32_t freed_cls_cnt = 0;
4002ebc8: 52800016 mov w22, #0x0 // #0
int rc = RC_OK, rc1 = RC_OK;
4002ebcc: 52800015 mov w21, #0x0 // #0
4002ebd0: 1400000a b 4002ebf8 <fat_free_fat_clusters_chain+0x68>
rc = fat_set_fat_cluster(fs_info, cur_cln, FAT_GENFAT_FREE);
4002ebd4: 97ffff3b bl 4002e8c0 <fat_set_fat_cluster>
cur_cln = next_cln;
4002ebd8: b9404ff4 ldr w20, [sp, #76]
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
4002ebdc: 29430a61 ldp w1, w2, [x19, #24]
if ( rc != RC_OK )
4002ebe0: 7100001f cmp w0, #0x0
4002ebe4: 1a8002b5 csel w21, w21, w0, eq // eq = none
freed_cls_cnt++;
4002ebe8: 110006d6 add w22, w22, #0x1
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
4002ebec: 0a010280 and w0, w20, w1
4002ebf0: 6b02001f cmp w0, w2
4002ebf4: 54000362 b.cs 4002ec60 <fat_free_fat_clusters_chain+0xd0> // b.hs, b.nlast
rc = fat_get_fat_cluster(fs_info, cur_cln, &next_cln);
4002ebf8: 910133e2 add x2, sp, #0x4c
4002ebfc: 2a1403e1 mov w1, w20
4002ec00: aa1303e0 mov x0, x19
4002ec04: 97fffea3 bl 4002e690 <fat_get_fat_cluster>
rc = fat_set_fat_cluster(fs_info, cur_cln, FAT_GENFAT_FREE);
4002ec08: 2a1403e1 mov w1, w20
rc = fat_get_fat_cluster(fs_info, cur_cln, &next_cln);
4002ec0c: 2a0003e3 mov w3, w0
rc = fat_set_fat_cluster(fs_info, cur_cln, FAT_GENFAT_FREE);
4002ec10: 52800002 mov w2, #0x0 // #0
4002ec14: aa1303e0 mov x0, x19
if ( rc != RC_OK )
4002ec18: 34fffde3 cbz w3, 4002ebd4 <fat_free_fat_clusters_chain+0x44> <== ALWAYS TAKEN
if(fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
4002ec1c: b9404e60 ldr w0, [x19, #76] <== NOT EXECUTED
4002ec20: 3100041f cmn w0, #0x1 <== NOT EXECUTED
4002ec24: 54000060 b.eq 4002ec30 <fat_free_fat_clusters_chain+0xa0> // b.none<== NOT EXECUTED
fs_info->vol.free_cls += freed_cls_cnt;
4002ec28: 0b160000 add w0, w0, w22 <== NOT EXECUTED
4002ec2c: b9004e60 str w0, [x19, #76] <== NOT EXECUTED
rc = fat_get_fat_cluster(fs_info, cur_cln, &next_cln);
4002ec30: 2a0303f5 mov w21, w3 <== NOT EXECUTED
fat_buf_release(fs_info);
4002ec34: aa1303e0 mov x0, x19 <== NOT EXECUTED
4002ec38: 97fffa92 bl 4002d680 <fat_buf_release> <== NOT EXECUTED
}
4002ec3c: 2a1503e0 mov w0, w21 <== NOT EXECUTED
4002ec40: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
4002ec44: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
4002ec48: f9401bf7 ldr x23, [sp, #48] <== NOT EXECUTED
4002ec4c: a8c57bfd ldp x29, x30, [sp], #80 <== NOT EXECUTED
4002ec50: d65f03c0 ret <== NOT EXECUTED
uint32_t freed_cls_cnt = 0;
4002ec54: 52800016 mov w22, #0x0 // #0 <== NOT EXECUTED
int rc = RC_OK, rc1 = RC_OK;
4002ec58: 52800015 mov w21, #0x0 // #0 <== NOT EXECUTED
4002ec5c: d503201f nop <== NOT EXECUTED
if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
4002ec60: b9404e60 ldr w0, [x19, #76]
fs_info->vol.next_cl = chain;
4002ec64: b9005677 str w23, [x19, #84]
if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
4002ec68: 3100041f cmn w0, #0x1
4002ec6c: 54000060 b.eq 4002ec78 <fat_free_fat_clusters_chain+0xe8> // b.none<== ALWAYS TAKEN
fs_info->vol.free_cls += freed_cls_cnt;
4002ec70: 0b160000 add w0, w0, w22 <== NOT EXECUTED
4002ec74: b9004e60 str w0, [x19, #76] <== NOT EXECUTED
fat_buf_release(fs_info);
4002ec78: aa1303e0 mov x0, x19
4002ec7c: 97fffa81 bl 4002d680 <fat_buf_release>
}
4002ec80: 2a1503e0 mov w0, w21
4002ec84: a94153f3 ldp x19, x20, [sp, #16]
4002ec88: a9425bf5 ldp x21, x22, [sp, #32]
4002ec8c: f9401bf7 ldr x23, [sp, #48]
4002ec90: a8c57bfd ldp x29, x30, [sp], #80
4002ec94: d65f03c0 ret
...
000000004002e650 <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);
4002e650: b940a803 ldr w3, [x0, #168] <== NOT EXECUTED
4002e654: 52800022 mov w2, #0x1 // #1 <== NOT EXECUTED
4002e658: f9404c00 ldr x0, [x0, #152] <== NOT EXECUTED
4002e65c: 4b030021 sub w1, w1, w3 <== NOT EXECUTED
4002e660: 12000823 and w3, w1, #0x7 <== NOT EXECUTED
4002e664: 53037c21 lsr w1, w1, #3 <== NOT EXECUTED
4002e668: 1ac32042 lsl w2, w2, w3 <== NOT EXECUTED
4002e66c: 38614803 ldrb w3, [x0, w1, uxtw] <== NOT EXECUTED
4002e670: 0a220062 bic w2, w3, w2 <== NOT EXECUTED
4002e674: 38214802 strb w2, [x0, w1, uxtw] <== NOT EXECUTED
}
4002e678: d65f03c0 ret <== NOT EXECUTED
4002e67c: 00000000 udf #0
000000004002e690 <fat_get_fat_cluster>:
fat_get_fat_cluster(
fat_fs_info_t *fs_info,
uint32_t cln,
uint32_t *ret_val
)
{
4002e690: a9ba7bfd stp x29, x30, [sp, #-96]!
uint8_t *sec_buf;
uint32_t sec = 0;
uint32_t ofs = 0;
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
4002e694: 7100043f cmp w1, #0x1
{
4002e698: 910003fd mov x29, sp
4002e69c: a90153f3 stp x19, x20, [sp, #16]
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
4002e6a0: 54000f69 b.ls 4002e88c <fat_get_fat_cluster+0x1fc> // b.plast <== NEVER TAKEN
4002e6a4: aa0003f3 mov x19, x0
4002e6a8: b9404000 ldr w0, [x0, #64]
4002e6ac: f90023f9 str x25, [sp, #64]
4002e6b0: 2a0103f9 mov w25, w1
4002e6b4: 11000400 add w0, w0, #0x1
4002e6b8: 6b01001f cmp w0, w1
4002e6bc: 54000e63 b.cc 4002e888 <fat_get_fat_cluster+0x1f8> // b.lo, b.ul, b.last<== NEVER TAKEN
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
4002e6c0: a9025bf5 stp x21, x22, [sp, #32]
fs_info->vol.afat_loc;
4002e6c4: b9406276 ldr w22, [x19, #96]
4002e6c8: a90363f7 stp x23, x24, [sp, #48]
4002e6cc: aa0203f7 mov x23, x2
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
4002e6d0: 39405a62 ldrb w2, [x19, #22]
4002e6d4: 39400a60 ldrb w0, [x19, #2]
4002e6d8: 37000422 tbnz w2, #0, 4002e75c <fat_get_fat_cluster+0xcc>
4002e6dc: 36080642 tbz w2, #1, 4002e7a4 <fat_get_fat_cluster+0x114>
4002e6e0: 0b010038 add w24, w1, w1
4002e6e4: 1ac02700 lsr w0, w24, w0
4002e6e8: 0b160016 add w22, w0, w22
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
4002e6ec: 79400275 ldrh w21, [x19]
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
4002e6f0: 910163e3 add x3, sp, #0x58
4002e6f4: 2a1603e1 mov w1, w22
4002e6f8: aa1303e0 mov x0, x19
4002e6fc: 52800022 mov w2, #0x1 // #1
4002e700: 97fffbac bl 4002d5b0 <fat_buf_access>
4002e704: 2a0003f4 mov w20, w0
if (rc != RC_OK)
4002e708: 35000400 cbnz w0, 4002e788 <fat_get_fat_cluster+0xf8> <== NEVER TAKEN
return rc;
switch ( fs_info->vol.type )
4002e70c: 39405a62 ldrb w2, [x19, #22]
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
4002e710: 510006b5 sub w21, w21, #0x1
4002e714: 0a1802b5 and w21, w21, w24
switch ( fs_info->vol.type )
4002e718: 7100085f cmp w2, #0x2
4002e71c: 540004c0 b.eq 4002e7b4 <fat_get_fat_cluster+0x124> // b.none
4002e720: 7100105f cmp w2, #0x4
4002e724: 540005c0 b.eq 4002e7dc <fat_get_fat_cluster+0x14c> // b.none
4002e728: 7100045f cmp w2, #0x1
4002e72c: 540006c0 b.eq 4002e804 <fat_get_fat_cluster+0x174> // b.none <== ALWAYS TAKEN
*ret_val = *((uint32_t *)(sec_buf + ofs));
*ret_val = CF_LE_L(*ret_val);
break;
default:
rtems_set_errno_and_return_minus_one(EIO);
4002e730: 9400308f bl 4003a96c <__errno> <== NOT EXECUTED
4002e734: 12800014 mov w20, #0xffffffff // #-1 <== NOT EXECUTED
4002e738: 528000a1 mov w1, #0x5 // #5 <== NOT EXECUTED
4002e73c: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
4002e740: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
4002e744: f94023f9 ldr x25, [sp, #64] <== NOT EXECUTED
4002e748: b9000001 str w1, [x0] <== NOT EXECUTED
break;
}
return RC_OK;
}
4002e74c: 2a1403e0 mov w0, w20 <== NOT EXECUTED
4002e750: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
4002e754: a8c67bfd ldp x29, x30, [sp], #96 <== NOT EXECUTED
4002e758: d65f03c0 ret <== NOT EXECUTED
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
4002e75c: 0b410438 add w24, w1, w1, lsr #1
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
4002e760: 79400275 ldrh w21, [x19]
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
4002e764: 910163e3 add x3, sp, #0x58
4002e768: 52800022 mov w2, #0x1 // #1
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
4002e76c: 1ac02700 lsr w0, w24, w0
4002e770: 0b160016 add w22, w0, w22
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
4002e774: 2a1603e1 mov w1, w22
4002e778: aa1303e0 mov x0, x19
4002e77c: 97fffb8d bl 4002d5b0 <fat_buf_access>
4002e780: 2a0003f4 mov w20, w0
if (rc != RC_OK)
4002e784: 34fffc40 cbz w0, 4002e70c <fat_get_fat_cluster+0x7c> <== ALWAYS TAKEN
}
4002e788: 2a1403e0 mov w0, w20 <== NOT EXECUTED
4002e78c: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
4002e790: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
4002e794: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
4002e798: f94023f9 ldr x25, [sp, #64] <== NOT EXECUTED
4002e79c: a8c67bfd ldp x29, x30, [sp], #96 <== NOT EXECUTED
4002e7a0: d65f03c0 ret <== NOT EXECUTED
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
4002e7a4: 531e7438 lsl w24, w1, #2
4002e7a8: 1ac02700 lsr w0, w24, w0
4002e7ac: 0b160016 add w22, w0, w22
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
4002e7b0: 17ffffcf b 4002e6ec <fat_get_fat_cluster+0x5c>
*ret_val = *((uint16_t *)(sec_buf + ofs));
4002e7b4: f9402fe0 ldr x0, [sp, #88]
break;
4002e7b8: f94023f9 ldr x25, [sp, #64]
*ret_val = *((uint16_t *)(sec_buf + ofs));
4002e7bc: 78754800 ldrh w0, [x0, w21, uxtw]
break;
4002e7c0: a9425bf5 ldp x21, x22, [sp, #32]
*ret_val = *((uint16_t *)(sec_buf + ofs));
4002e7c4: b90002e0 str w0, [x23]
}
4002e7c8: 2a1403e0 mov w0, w20
4002e7cc: a94153f3 ldp x19, x20, [sp, #16]
break;
4002e7d0: a94363f7 ldp x23, x24, [sp, #48]
}
4002e7d4: a8c67bfd ldp x29, x30, [sp], #96
4002e7d8: d65f03c0 ret
*ret_val = *((uint32_t *)(sec_buf + ofs));
4002e7dc: f9402fe0 ldr x0, [sp, #88]
break;
4002e7e0: f94023f9 ldr x25, [sp, #64]
*ret_val = *((uint32_t *)(sec_buf + ofs));
4002e7e4: b8754800 ldr w0, [x0, w21, uxtw]
break;
4002e7e8: a9425bf5 ldp x21, x22, [sp, #32]
*ret_val = *((uint32_t *)(sec_buf + ofs));
4002e7ec: b90002e0 str w0, [x23]
}
4002e7f0: 2a1403e0 mov w0, w20
4002e7f4: a94153f3 ldp x19, x20, [sp, #16]
break;
4002e7f8: a94363f7 ldp x23, x24, [sp, #48]
}
4002e7fc: a8c67bfd ldp x29, x30, [sp], #96
4002e800: d65f03c0 ret
*ret_val = (*(sec_buf + ofs));
4002e804: f9402fe1 ldr x1, [sp, #88]
4002e808: 2a1503e0 mov w0, w21
if ( ofs == (fs_info->vol.bps - 1) )
4002e80c: 79400263 ldrh w3, [x19]
*ret_val = (*(sec_buf + ofs));
4002e810: 38754824 ldrb w4, [x1, w21, uxtw]
if ( ofs == (fs_info->vol.bps - 1) )
4002e814: 51000463 sub w3, w3, #0x1
*ret_val = (*(sec_buf + ofs));
4002e818: b90002e4 str w4, [x23]
if ( ofs == (fs_info->vol.bps - 1) )
4002e81c: 6b15007f cmp w3, w21
4002e820: 54000200 b.eq 4002e860 <fat_get_fat_cluster+0x1d0> // b.none
*ret_val |= *(sec_buf + ofs + 1) << 8;
4002e824: 8b000021 add x1, x1, x0
4002e828: 39400420 ldrb w0, [x1, #1]
4002e82c: 2a002080 orr w0, w4, w0, lsl #8
*ret_val = (*ret_val) >> FAT12_SHIFT;
4002e830: f240033f tst x25, #0x1
4002e834: 12002c01 and w1, w0, #0xfff
4002e838: 53047c00 lsr w0, w0, #4
4002e83c: 1a811000 csel w0, w0, w1, ne // ne = any
4002e840: a9425bf5 ldp x21, x22, [sp, #32]
4002e844: f94023f9 ldr x25, [sp, #64]
4002e848: b90002e0 str w0, [x23]
}
4002e84c: 2a1403e0 mov w0, w20
4002e850: a94153f3 ldp x19, x20, [sp, #16]
4002e854: a94363f7 ldp x23, x24, [sp, #48]
4002e858: a8c67bfd ldp x29, x30, [sp], #96
4002e85c: d65f03c0 ret
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
4002e860: 910163e3 add x3, sp, #0x58
4002e864: 110006c1 add w1, w22, #0x1
4002e868: aa1303e0 mov x0, x19
4002e86c: 97fffb51 bl 4002d5b0 <fat_buf_access>
if (rc != RC_OK)
4002e870: 35000180 cbnz w0, 4002e8a0 <fat_get_fat_cluster+0x210> <== NEVER TAKEN
*ret_val |= *sec_buf << 8;
4002e874: f9402fe0 ldr x0, [sp, #88]
4002e878: b94002e1 ldr w1, [x23]
4002e87c: 39400000 ldrb w0, [x0]
4002e880: 2a002020 orr w0, w1, w0, lsl #8
4002e884: 17ffffeb b 4002e830 <fat_get_fat_cluster+0x1a0>
4002e888: f94023f9 ldr x25, [sp, #64] <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
4002e88c: 94003038 bl 4003a96c <__errno> <== NOT EXECUTED
4002e890: 528000a1 mov w1, #0x5 // #5 <== NOT EXECUTED
4002e894: 12800014 mov w20, #0xffffffff // #-1 <== NOT EXECUTED
4002e898: b9000001 str w1, [x0] <== NOT EXECUTED
4002e89c: 17ffffac b 4002e74c <fat_get_fat_cluster+0xbc> <== NOT EXECUTED
4002e8a0: 2a0003f4 mov w20, w0 <== NOT EXECUTED
4002e8a4: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
4002e8a8: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
4002e8ac: f94023f9 ldr x25, [sp, #64] <== NOT EXECUTED
4002e8b0: 17ffffa7 b 4002e74c <fat_get_fat_cluster+0xbc> <== NOT EXECUTED
...
000000004002e580 <fat_get_unique_ino>:
* 0 means FAILED !!!
*
*/
uint32_t
fat_get_unique_ino(fat_fs_info_t *fs_info)
{
4002e580: a9be7bfd stp x29, x30, [sp, #-32]! <== NOT EXECUTED
4002e584: 910003fd mov x29, sp <== NOT EXECUTED
uint32_t j = 0;
bool resrc_unsuff = false;
while (!resrc_unsuff)
{
for (j = 0; j < fs_info->uino_pool_size; j++)
4002e588: b940a401 ldr w1, [x0, #164] <== NOT EXECUTED
{
4002e58c: a90153f3 stp x19, x20, [sp, #16] <== NOT EXECUTED
4002e590: aa0003f3 mov x19, x0 <== 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))
4002e594: 12be0014 mov w20, #0xfffffff // #268435455 <== NOT EXECUTED
for (j = 0; j < fs_info->uino_pool_size; j++)
4002e598: 340003c1 cbz w1, 4002e610 <fat_get_unique_ino+0x90> <== NOT EXECUTED
4002e59c: 52800005 mov w5, #0x0 // #0 <== NOT EXECUTED
if (!FAT_UNIQ_INO_IS_BUSY(fs_info->index, fs_info->uino))
4002e5a0: f9404e60 ldr x0, [x19, #152] <== NOT EXECUTED
4002e5a4: 14000006 b 4002e5bc <fat_get_unique_ino+0x3c> <== NOT EXECUTED
fs_info->index++;
4002e5a8: 6b01007f cmp w3, w1 <== NOT EXECUTED
4002e5ac: 1a9f3063 csel w3, w3, wzr, cc // cc = lo, ul, last <== NOT EXECUTED
4002e5b0: b900a263 str w3, [x19, #160] <== NOT EXECUTED
for (j = 0; j < fs_info->uino_pool_size; j++)
4002e5b4: 6b0100bf cmp w5, w1 <== NOT EXECUTED
4002e5b8: 540002a0 b.eq 4002e60c <fat_get_unique_ino+0x8c> // b.none <== NOT EXECUTED
if (!FAT_UNIQ_INO_IS_BUSY(fs_info->index, fs_info->uino))
4002e5bc: b940a262 ldr w2, [x19, #160] <== NOT EXECUTED
for (j = 0; j < fs_info->uino_pool_size; j++)
4002e5c0: 110004a5 add w5, w5, #0x1 <== NOT EXECUTED
if (!FAT_UNIQ_INO_IS_BUSY(fs_info->index, fs_info->uino))
4002e5c4: 12000846 and w6, w2, #0x7 <== NOT EXECUTED
fs_info->index++;
4002e5c8: 11000443 add w3, w2, #0x1 <== NOT EXECUTED
if (!FAT_UNIQ_INO_IS_BUSY(fs_info->index, fs_info->uino))
4002e5cc: 53037c44 lsr w4, w2, #3 <== NOT EXECUTED
4002e5d0: aa0403e2 mov x2, x4 <== NOT EXECUTED
4002e5d4: 8b040004 add x4, x0, x4 <== NOT EXECUTED
4002e5d8: 38624802 ldrb w2, [x0, w2, uxtw] <== NOT EXECUTED
4002e5dc: 1ac62847 asr w7, w2, w6 <== NOT EXECUTED
4002e5e0: 3707fe47 tbnz w7, #0, 4002e5a8 <fat_get_unique_ino+0x28> <== NOT EXECUTED
FAT_SET_UNIQ_INO_BUSY(fs_info->index, fs_info->uino);
4002e5e4: 52800020 mov w0, #0x1 // #1 <== NOT EXECUTED
4002e5e8: 1ac62006 lsl w6, w0, w6 <== NOT EXECUTED
4002e5ec: 2a0200c2 orr w2, w6, w2 <== NOT EXECUTED
4002e5f0: 39000082 strb w2, [x4] <== NOT EXECUTED
return (fs_info->uino_base + fs_info->index);
4002e5f4: b940a261 ldr w1, [x19, #160] <== NOT EXECUTED
4002e5f8: b940aa60 ldr w0, [x19, #168] <== NOT EXECUTED
4002e5fc: 0b010000 add w0, w0, w1 <== NOT EXECUTED
}
else
resrc_unsuff = true;
}
return 0;
}
4002e600: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
4002e604: a8c27bfd ldp x29, x30, [sp], #32 <== NOT EXECUTED
4002e608: d65f03c0 ret <== NOT EXECUTED
if ((fs_info->uino_pool_size << 1) < (0x0FFFFFFF - fs_info->uino_base))
4002e60c: 0b010021 add w1, w1, w1 <== NOT EXECUTED
4002e610: b940aa60 ldr w0, [x19, #168] <== NOT EXECUTED
4002e614: 4b000280 sub w0, w20, w0 <== NOT EXECUTED
4002e618: 6b01001f cmp w0, w1 <== NOT EXECUTED
4002e61c: 54000149 b.ls 4002e644 <fat_get_unique_ino+0xc4> // b.plast <== NOT EXECUTED
fs_info->uino = realloc(fs_info->uino, fs_info->uino_pool_size);
4002e620: f9404e60 ldr x0, [x19, #152] <== NOT EXECUTED
fs_info->uino_pool_size <<= 1;
4002e624: b900a661 str w1, [x19, #164] <== NOT EXECUTED
fs_info->uino = realloc(fs_info->uino, fs_info->uino_pool_size);
4002e628: 2a0103e1 mov w1, w1 <== NOT EXECUTED
4002e62c: 940020e5 bl 400369c0 <realloc> <== NOT EXECUTED
4002e630: f9004e60 str x0, [x19, #152] <== NOT EXECUTED
if (fs_info->uino != NULL)
4002e634: b4000080 cbz x0, 4002e644 <fat_get_unique_ino+0xc4> <== NOT EXECUTED
fs_info->index = fs_info->uino_pool_size;
4002e638: b940a661 ldr w1, [x19, #164] <== NOT EXECUTED
4002e63c: b900a261 str w1, [x19, #160] <== NOT EXECUTED
4002e640: 17ffffd6 b 4002e598 <fat_get_unique_ino+0x18> <== NOT EXECUTED
return 0;
4002e644: 52800000 mov w0, #0x0 // #0 <== NOT EXECUTED
4002e648: 17ffffee b 4002e600 <fat_get_unique_ino+0x80> <== NOT EXECUTED
4002e64c: 00000000 udf #0
000000004002e4f0 <fat_init_clusters_chain>:
int
fat_init_clusters_chain(
fat_fs_info_t *fs_info,
uint32_t start_cln
)
{
4002e4f0: a9bd7bfd stp x29, x30, [sp, #-48]!
4002e4f4: 910003fd mov x29, sp
4002e4f8: f9000bf3 str x19, [sp, #16]
4002e4fc: aa0003f3 mov x19, x0
int rc = RC_OK;
ssize_t ret = 0;
uint32_t cur_cln = start_cln;
4002e500: b9002fe1 str w1, [sp, #44]
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
4002e504: 1400000d b 4002e538 <fat_init_clusters_chain+0x48>
{
ret = fat_cluster_set(fs_info, cur_cln, 0, fs_info->vol.bpc, 0);
4002e508: b9400a63 ldr w3, [x19, #8]
4002e50c: 97fffce9 bl 4002d8b0 <fat_cluster_set>
4002e510: aa0003e1 mov x1, x0
if ( ret != fs_info->vol.bpc )
4002e514: b9400a63 ldr w3, [x19, #8]
{
return -1;
}
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
4002e518: 9100b3e2 add x2, sp, #0x2c
4002e51c: aa1303e0 mov x0, x19
if ( ret != fs_info->vol.bpc )
4002e520: eb01007f cmp x3, x1
4002e524: 54000201 b.ne 4002e564 <fat_init_clusters_chain+0x74> // b.any <== NEVER TAKEN
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
4002e528: b9402fe1 ldr w1, [sp, #44]
4002e52c: 94000059 bl 4002e690 <fat_get_fat_cluster>
if ( rc != RC_OK )
4002e530: 35000140 cbnz w0, 4002e558 <fat_init_clusters_chain+0x68> <== NEVER TAKEN
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
4002e534: b9402fe1 ldr w1, [sp, #44]
4002e538: 29431663 ldp w3, w5, [x19, #24]
ret = fat_cluster_set(fs_info, cur_cln, 0, fs_info->vol.bpc, 0);
4002e53c: aa1303e0 mov x0, x19
4002e540: 52800004 mov w4, #0x0 // #0
4002e544: 52800002 mov w2, #0x0 // #0
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
4002e548: 0a030023 and w3, w1, w3
4002e54c: 6b05007f cmp w3, w5
4002e550: 54fffdc3 b.cc 4002e508 <fat_init_clusters_chain+0x18> // b.lo, b.ul, b.last
return rc;
}
}
return rc;
4002e554: 52800000 mov w0, #0x0 // #0
}
4002e558: f9400bf3 ldr x19, [sp, #16]
4002e55c: a8c37bfd ldp x29, x30, [sp], #48
4002e560: d65f03c0 ret
return -1;
4002e564: 12800000 mov w0, #0xffffffff // #-1 <== NOT EXECUTED
}
4002e568: f9400bf3 ldr x19, [sp, #16] <== NOT EXECUTED
4002e56c: a8c37bfd ldp x29, x30, [sp], #48 <== NOT EXECUTED
4002e570: d65f03c0 ret <== NOT EXECUTED
...
000000004002dc00 <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)
{
4002dc00: a9b07bfd stp x29, x30, [sp, #-256]!
4002dc04: 910003fd mov x29, sp
4002dc08: a90153f3 stp x19, x20, [sp, #16]
4002dc0c: aa0003f3 mov x19, x0
ssize_t ret = 0;
struct stat stat_buf;
int i = 0;
rtems_bdbuf_buffer *block = NULL;
vol->fd = open(device, O_RDWR);
4002dc10: aa0103e0 mov x0, x1
4002dc14: 52800041 mov w1, #0x2 // #2
{
4002dc18: a9025bf5 stp x21, x22, [sp, #32]
rtems_bdbuf_buffer *block = NULL;
4002dc1c: f90043ff str xzr, [sp, #128]
vol->fd = open(device, O_RDWR);
4002dc20: 97ffd360 bl 400229a0 <open>
4002dc24: b9006a60 str w0, [x19, #104]
if (vol->fd < 0)
4002dc28: 37f829a0 tbnz w0, #31, 4002e15c <fat_init_volume_info+0x55c> <== NEVER TAKEN
{
rtems_set_errno_and_return_minus_one(ENXIO);
}
rc = fstat(vol->fd, &stat_buf);
4002dc2c: 910263e1 add x1, sp, #0x98
4002dc30: 97ffd094 bl 40021e80 <fstat>
if (rc != 0)
4002dc34: 350029e0 cbnz w0, 4002e170 <fat_init_volume_info+0x570> <== NEVER TAKEN
close(vol->fd);
rtems_set_errno_and_return_minus_one(ENXIO);
}
/* Must be a block device. */
if (!S_ISBLK(stat_buf.st_mode))
4002dc38: b940abe1 ldr w1, [sp, #168]
close(vol->fd);
4002dc3c: b9406a60 ldr w0, [x19, #104]
if (!S_ISBLK(stat_buf.st_mode))
4002dc40: 12140c21 and w1, w1, #0xf000
4002dc44: 7140183f cmp w1, #0x6, lsl #12
4002dc48: 54002881 b.ne 4002e158 <fat_init_volume_info+0x558> // b.any <== NEVER TAKEN
return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);
4002dc4c: 9101c262 add x2, x19, #0x70
4002dc50: d2884121 mov x1, #0x4209 // #16905
4002dc54: f2a80101 movk x1, #0x4008, lsl #16
4002dc58: 97fffafa bl 4002c840 <ioctl>
4002dc5c: 2a0003f5 mov w21, w0
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) {
4002dc60: 35002880 cbnz w0, 4002e170 <fat_init_volume_info+0x570> <== NEVER TAKEN
vol->dev = stat_buf.st_rdev;
/* Read boot record */
/* FIXME: Asserts FAT_MAX_BPB_SIZE < bdbuf block size */
sc = rtems_bdbuf_read( vol->dd, 0, &block);
4002dc64: f9403a60 ldr x0, [x19, #112]
4002dc68: 910203e2 add x2, sp, #0x80
vol->dev = stat_buf.st_rdev;
4002dc6c: f9405fe1 ldr x1, [sp, #184]
4002dc70: f9003e61 str x1, [x19, #120]
sc = rtems_bdbuf_read( vol->dd, 0, &block);
4002dc74: 52800001 mov w1, #0x0 // #0
4002dc78: 94002172 bl 40036240 <rtems_bdbuf_read>
if (sc != RTEMS_SUCCESSFUL)
4002dc7c: 35002880 cbnz w0, 4002e18c <fat_init_volume_info+0x58c> <== NEVER TAKEN
{
close(vol->fd);
rtems_set_errno_and_return_minus_one( EIO);
}
memcpy( boot_rec, block->buffer, FAT_MAX_BPB_SIZE);
4002dc80: f94043e0 ldr x0, [sp, #128]
4002dc84: a90363f7 stp x23, x24, [sp, #48]
4002dc88: a9046bf9 stp x25, x26, [sp, #64]
4002dc8c: f9401c02 ldr x2, [x0, #56]
4002dc90: a90573fb stp x27, x28, [sp, #80]
vol->rdir_loc = vol->fat_loc + vol->fats * vol->fat_length;
if ( (FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec)) != 0)
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec);
else
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM32(boot_rec);
4002dc94: 39408444 ldrb w4, [x2, #33]
4002dc98: 39408046 ldrb w6, [x2, #32]
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT32(boot_rec);
4002dc9c: 39409445 ldrb w5, [x2, #37]
}
}
if (vol->type == FAT_FAT32)
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
4002dca0: 3940b047 ldrb w7, [x2, #44]
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT32(boot_rec);
4002dca4: 39409041 ldrb w1, [x2, #36]
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM32(boot_rec);
4002dca8: aa0420c6 orr x6, x6, x4, lsl #8
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
4002dcac: 3940b45b ldrb w27, [x2, #45]
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM32(boot_rec);
4002dcb0: 39408844 ldrb w4, [x2, #34]
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
4002dcb4: 3940b843 ldrb w3, [x2, #46]
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT32(boot_rec);
4002dcb8: aa052021 orr x1, x1, x5, lsl #8
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
4002dcbc: aa1b20fb orr x27, x7, x27, lsl #8
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT32(boot_rec);
4002dcc0: 39409845 ldrb w5, [x2, #38]
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM32(boot_rec);
4002dcc4: 39408c47 ldrb w7, [x2, #35]
4002dcc8: aa0440c4 orr x4, x6, x4, lsl #16
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
4002dccc: 3940bc46 ldrb w6, [x2, #47]
4002dcd0: aa034363 orr x3, x27, x3, lsl #16
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT32(boot_rec);
4002dcd4: aa054025 orr x5, x1, x5, lsl #16
4002dcd8: 39402c41 ldrb w1, [x2, #11]
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM32(boot_rec);
4002dcdc: 2a07609c orr w28, w4, w7, lsl #24
4002dce0: 39403047 ldrb w7, [x2, #12]
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT32(boot_rec);
4002dce4: 39409c48 ldrb w8, [x2, #39]
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
4002dce8: aa066063 orr x3, x3, x6, lsl #24
4002dcec: 39404856 ldrb w22, [x2, #18]
4002dcf0: 39404446 ldrb w6, [x2, #17]
4002dcf4: 2a072021 orr w1, w1, w7, lsl #8
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT32(boot_rec);
4002dcf8: 2a0860a5 orr w5, w5, w8, lsl #24
4002dcfc: 39403c57 ldrb w23, [x2, #15]
4002dd00: 39403848 ldrb w8, [x2, #14]
4002dd04: 39404c47 ldrb w7, [x2, #19]
4002dd08: 2a1620d6 orr w22, w6, w22, lsl #8
4002dd0c: 39405058 ldrb w24, [x2, #20]
4002dd10: 290d97e1 stp w1, w5, [sp, #108]
4002dd14: 2a172117 orr w23, w8, w23, lsl #8
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
4002dd18: f9003fe3 str x3, [sp, #120]
4002dd1c: 39405843 ldrb w3, [x2, #22]
4002dd20: 2a1820f8 orr w24, w7, w24, lsl #8
4002dd24: 39405c59 ldrb w25, [x2, #23]
memcpy( boot_rec, block->buffer, FAT_MAX_BPB_SIZE);
4002dd28: 3940a041 ldrb w1, [x2, #40]
4002dd2c: 3940c046 ldrb w6, [x2, #48]
4002dd30: 3940c45a ldrb w26, [x2, #49]
4002dd34: 2a192079 orr w25, w3, w25, lsl #8
4002dd38: 3940345b ldrb w27, [x2, #13]
4002dd3c: 39404054 ldrb w20, [x2, #16]
4002dd40: 2a1a20da orr w26, w6, w26, lsl #8
4002dd44: b90077e1 str w1, [sp, #116]
sc = rtems_bdbuf_release( block);
4002dd48: 940021be bl 40036440 <rtems_bdbuf_release>
if (sc != RTEMS_SUCCESSFUL)
4002dd4c: 294d97e1 ldp w1, w5, [sp, #108]
4002dd50: 350022c0 cbnz w0, 4002e1a8 <fat_init_volume_info+0x5a8> <== NEVER TAKEN
if ( (vol->bps != 512) &&
4002dd54: 51080020 sub w0, w1, #0x200
(vol->bps != 1024) &&
4002dd58: 51200022 sub w2, w1, #0x800
if ( (vol->bps != 512) &&
4002dd5c: 12167800 and w0, w0, #0xfffffdff
vol->bps = FAT_GET_BR_BYTES_PER_SECTOR(boot_rec);
4002dd60: 79000261 strh w1, [x19]
(vol->bps != 2048) &&
4002dd64: 12003c00 and w0, w0, #0xffff
4002dd68: 529effe6 mov w6, #0xf7ff // #63487
4002dd6c: 6a06005f tst w2, w6
4002dd70: 7a401804 ccmp w0, #0x0, #0x4, ne // ne = any
4002dd74: 54001de1 b.ne 4002e130 <fat_init_volume_info+0x530> // b.any <== NEVER TAKEN
for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
4002dd78: 39000e7f strb wzr, [x19, #3]
4002dd7c: 53097c20 lsr w0, w1, #9
4002dd80: 37480101 tbnz w1, #9, 4002dda0 <fat_init_volume_info+0x1a0> <== ALWAYS TAKEN
4002dd84: 52800022 mov w2, #0x1 // #1 <== NOT EXECUTED
4002dd88: 11000446 add w6, w2, #0x1 <== NOT EXECUTED
4002dd8c: 2a0203e7 mov w7, w2 <== NOT EXECUTED
i >>= 1, vol->sec_mul++);
4002dd90: 13017c00 asr w0, w0, #1 <== NOT EXECUTED
for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
4002dd94: 12001cc2 and w2, w6, #0xff <== NOT EXECUTED
4002dd98: 3607ff80 tbz w0, #0, 4002dd88 <fat_init_volume_info+0x188> <== NOT EXECUTED
4002dd9c: 39000e67 strb w7, [x19, #3] <== NOT EXECUTED
for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0;
4002dda0: 39000a7f strb wzr, [x19, #2]
4002dda4: 2a0103e0 mov w0, w1
4002dda8: 37000101 tbnz w1, #0, 4002ddc8 <fat_init_volume_info+0x1c8> <== NEVER TAKEN
4002ddac: 52800022 mov w2, #0x1 // #1
4002ddb0: 11000446 add w6, w2, #0x1
4002ddb4: 2a0203e7 mov w7, w2
i >>= 1, vol->sec_log2++);
4002ddb8: 13017c00 asr w0, w0, #1
for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0;
4002ddbc: 12001cc2 and w2, w6, #0xff
4002ddc0: 3607ff80 tbz w0, #0, 4002ddb0 <fat_init_volume_info+0x1b0>
4002ddc4: 39000a67 strb w7, [x19, #2]
sc = rtems_bdbuf_set_block_size (vol->dd, vol->bps, true);
4002ddc8: f9403a60 ldr x0, [x19, #112]
4002ddcc: 52800022 mov w2, #0x1 // #1
4002ddd0: b9006fe5 str w5, [sp, #108]
4002ddd4: 9400223b bl 400366c0 <rtems_bdbuf_set_block_size>
if (sc != RTEMS_SUCCESSFUL)
4002ddd8: b9406fe5 ldr w5, [sp, #108]
4002dddc: 35001aa0 cbnz w0, 4002e130 <fat_init_volume_info+0x530> <== NEVER TAKEN
vol->bytes_per_block = vol->bps;
4002dde0: 79400268 ldrh w8, [x19]
vol->sectors_per_block = 1;
4002dde4: 52800020 mov w0, #0x1 // #1
vol->bytes_per_block_log2 = vol->sec_log2;
4002dde8: 39400a67 ldrb w7, [x19, #2]
vol->spc = FAT_GET_BR_SECTORS_PER_CLUSTER(boot_rec);
4002ddec: 3900127b strb w27, [x19, #4]
vol->sectors_per_block = 1;
4002ddf0: 39003660 strb w0, [x19, #13]
vol->bytes_per_block = vol->bps;
4002ddf4: b9001268 str w8, [x19, #16]
vol->bytes_per_block_log2 = vol->sec_log2;
4002ddf8: 39005267 strb w7, [x19, #20]
if (vol->spc == 0)
4002ddfc: 340019bb cbz w27, 4002e130 <fat_init_volume_info+0x530> <== NEVER TAKEN
for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;
4002de00: 3900167f strb wzr, [x19, #5]
4002de04: 2a1b03e0 mov w0, w27
4002de08: 3700187b tbnz w27, #0, 4002e114 <fat_init_volume_info+0x514>
4002de0c: 52800021 mov w1, #0x1 // #1
4002de10: 11000422 add w2, w1, #0x1
4002de14: 2a0103e6 mov w6, w1
i >>= 1, vol->spc_log2++);
4002de18: 13017c00 asr w0, w0, #1
for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;
4002de1c: 12001c41 and w1, w2, #0xff
4002de20: 3607ff80 tbz w0, #0, 4002de10 <fat_init_volume_info+0x210>
if (vol->spc != UINT32_C(1) << vol->spc_log2)
4002de24: 52800021 mov w1, #0x1 // #1
4002de28: 2a0603e0 mov w0, w6
4002de2c: 1ac62021 lsl w1, w1, w6
4002de30: 39001666 strb w6, [x19, #5]
4002de34: 6b01037f cmp w27, w1
4002de38: 540017c1 b.ne 4002e130 <fat_init_volume_info+0x530> // b.any <== NEVER TAKEN
vol->bpc = ((uint32_t) vol->bps) << vol->spc_log2;
4002de3c: 1ac02100 lsl w0, w8, w0
4002de40: b9000a60 str w0, [x19, #8]
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
4002de44: 3900327f strb wzr, [x19, #12]
4002de48: 37000100 tbnz w0, #0, 4002de68 <fat_init_volume_info+0x268> <== NEVER TAKEN
4002de4c: 52800021 mov w1, #0x1 // #1
4002de50: 11000422 add w2, w1, #0x1
4002de54: 2a0103e6 mov w6, w1
i >>= 1, vol->bpc_log2++);
4002de58: 13017c00 asr w0, w0, #1
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
4002de5c: 12001c41 and w1, w2, #0xff
4002de60: 3607ff80 tbz w0, #0, 4002de50 <fat_init_volume_info+0x250>
4002de64: 39003266 strb w6, [x19, #12]
vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
4002de68: 51000500 sub w0, w8, #0x1
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT(boot_rec);
4002de6c: 7100033f cmp w25, #0x0
vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
4002de70: 0b161400 add w0, w0, w22, lsl #5
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT(boot_rec);
4002de74: 1a9900a5 csel w5, w5, w25, eq // eq = none
vol->fats = FAT_GET_BR_FAT_NUM(boot_rec);
4002de78: 39005674 strb w20, [x19, #21]
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec);
4002de7c: 7100031f cmp w24, #0x0
4002de80: 1a98039c csel w28, w28, w24, eq // eq = none
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
4002de84: 79004277 strh w23, [x19, #32]
vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
4002de88: 1ac80c00 sdiv w0, w0, w8
vol->data_fsec = vol->fat_loc + vol->fats * vol->fat_length +
4002de8c: 1b055e94 madd w20, w20, w5, w23
vol->rdir_loc = vol->fat_loc + vol->fats * vol->fat_length;
4002de90: 2904d265 stp w5, w20, [x19, #36]
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
4002de94: 79005a76 strh w22, [x19, #44]
vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
4002de98: b9003a7c str w28, [x19, #56]
vol->data_fsec = vol->fat_loc + vol->fats * vol->fat_length +
4002de9c: 0b140014 add w20, w0, w20
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
4002dea0: 1ac72007 lsl w7, w0, w7
data_secs = vol->tot_secs - vol->data_fsec;
4002dea4: 4b140381 sub w1, w28, w20
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
4002dea8: 29061e60 stp w0, w7, [x19, #48]
vol->data_cls = data_secs / vol->spc;
4002deac: 1adb0823 udiv w3, w1, w27
4002deb0: 29078e74 stp w20, w3, [x19, #60]
if ( vol->data_cls < FAT_FAT12_MAX_CLN)
4002deb4: 713fd07f cmp w3, #0xff4
4002deb8: 54000a89 b.ls 4002e008 <fat_init_volume_info+0x408> // b.plast
if ( vol->data_cls < FAT_FAT16_MAX_CLN)
4002debc: 529ffe80 mov w0, #0xfff4 // #65524
4002dec0: 6b00007f cmp w3, w0
4002dec4: 54000d48 b.hi 4002e06c <fat_init_volume_info+0x46c> // b.pmore
vol->mask = FAT_FAT16_MASK;
4002dec8: d29fffe0 mov x0, #0xffff // #65535
vol->type = FAT_FAT16;
4002decc: 52800041 mov w1, #0x2 // #2
vol->mask = FAT_FAT16_MASK;
4002ded0: f2dfff00 movk x0, #0xfff8, lsl #32
vol->type = FAT_FAT16;
4002ded4: 39005a61 strb w1, [x19, #22]
vol->mask = FAT_FAT16_MASK;
4002ded8: f9000e60 str x0, [x19, #24]
else
{
vol->rdir_cl = 0;
vol->mirror = 0;
vol->afat = 0;
vol->free_cls = FAT_UNDEFINED_VALUE;
4002dedc: 12800000 mov w0, #0xffffffff // #-1
vol->rdir_cl = 0;
4002dee0: b900467f str wzr, [x19, #68]
vol->free_cls = FAT_UNDEFINED_VALUE;
4002dee4: b9004e60 str w0, [x19, #76]
vol->next_cl = FAT_UNDEFINED_VALUE;
4002dee8: b9005660 str w0, [x19, #84]
vol->mirror = 0;
4002deec: 3901727f strb wzr, [x19, #92]
vol->afat = 0;
4002def0: 3901927f strb wzr, [x19, #100]
if (fs_info->c.state == FAT_CACHE_EMPTY)
4002def4: 3942d660 ldrb w0, [x19, #181]
4002def8: 34000060 cbz w0, 4002df04 <fat_init_volume_info+0x304>
4002defc: aa1303e0 mov x0, x19
4002df00: 97fffd40 bl 4002d400 <fat_buf_release.part.0>
}
_fat_block_release(fs_info);
vol->afat_loc = vol->fat_loc + vol->fat_length * vol->afat;
4002df04: 39419262 ldrb w2, [x19, #100]
/* set up collection of fat-files fd */
fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
4002df08: d2800301 mov x1, #0x18 // #24
vol->afat_loc = vol->fat_loc + vol->fat_length * vol->afat;
4002df0c: 79404263 ldrh w3, [x19, #32]
fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
4002df10: d2800040 mov x0, #0x2 // #2
vol->afat_loc = vol->fat_loc + vol->fat_length * vol->afat;
4002df14: b9402664 ldr w4, [x19, #36]
4002df18: 1b040c42 madd w2, w2, w4, w3
4002df1c: b9006262 str w2, [x19, #96]
fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
4002df20: 97fff9b0 bl 4002c5e0 <calloc>
4002df24: f9004660 str x0, [x19, #136]
4002df28: aa0003e2 mov x2, x0
if ( fs_info->vhash == NULL )
4002df2c: b4001680 cbz x0, 4002e1fc <fat_init_volume_info+0x5fc> <== NEVER TAKEN
head->next = tail;
4002df30: 91006044 add x4, x2, #0x18
return &the_chain->Tail.Node;
4002df34: 91008043 add x3, x2, #0x20
4002df38: 91002000 add x0, x0, #0x8
head->previous = NULL;
4002df3c: a9007c40 stp x0, xzr, [x2]
}
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));
4002df40: d2800301 mov x1, #0x18 // #24
head->next = tail;
4002df44: a9010c42 stp x2, x3, [x2, #16]
4002df48: d2800040 mov x0, #0x2 // #2
tail->previous = head;
4002df4c: a902105f stp xzr, x4, [x2, #32]
4002df50: 97fff9a4 bl 4002c5e0 <calloc>
4002df54: f9004a60 str x0, [x19, #144]
if ( fs_info->rhash == NULL )
4002df58: b4001660 cbz x0, 4002e224 <fat_init_volume_info+0x624> <== NEVER TAKEN
}
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;
4002df5c: 39400e66 ldrb w6, [x19, #3]
head->next = tail;
4002df60: 91006004 add x4, x0, #0x18
4002df64: b9403a62 ldr w2, [x19, #56]
return &the_chain->Tail.Node;
4002df68: 91008003 add x3, x0, #0x20
4002df6c: 91002001 add x1, x0, #0x8
head->previous = NULL;
4002df70: a9007c01 stp x1, xzr, [x0]
fs_info->index = 0;
4002df74: d2c02005 mov x5, #0x10000000000 // #1099511627776
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
4002df78: 1ac62042 lsl w2, w2, w6
head->next = tail;
4002df7c: a9010c00 stp x0, x3, [x0, #16]
4002df80: 531c6c42 lsl w2, w2, #4
head->previous = NULL;
4002df84: f900049f str xzr, [x4, #8]
fs_info->uino = (char *)calloc(fs_info->uino_pool_size, sizeof(char));
4002df88: d2800021 mov x1, #0x1 // #1
tail->previous = head;
4002df8c: f9000464 str x4, [x3, #8]
4002df90: d2802000 mov x0, #0x100 // #256
fs_info->index = 0;
4002df94: f9005265 str x5, [x19, #160]
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
4002df98: b900aa62 str w2, [x19, #168]
fs_info->uino = (char *)calloc(fs_info->uino_pool_size, sizeof(char));
4002df9c: 97fff991 bl 4002c5e0 <calloc>
4002dfa0: f9004e60 str x0, [x19, #152]
if ( fs_info->uino == NULL )
4002dfa4: b40014c0 cbz x0, 4002e23c <fat_init_volume_info+0x63c> <== NEVER TAKEN
close(vol->fd);
free(fs_info->vhash);
free(fs_info->rhash);
rtems_set_errno_and_return_minus_one( ENOMEM );
}
fs_info->sec_buf = (uint8_t *)calloc(vol->bps, sizeof(uint8_t));
4002dfa8: 79400260 ldrh w0, [x19]
4002dfac: d2800021 mov x1, #0x1 // #1
4002dfb0: 97fff98c bl 4002c5e0 <calloc>
4002dfb4: f9006260 str x0, [x19, #192]
if (fs_info->sec_buf == NULL)
4002dfb8: b4001520 cbz x0, 4002e25c <fat_init_volume_info+0x65c> <== NEVER TAKEN
return (sec_num & (vol->spc - 1)) == 0;
4002dfbc: 39401260 ldrb w0, [x19, #4]
4002dfc0: b9403e61 ldr w1, [x19, #60]
4002dfc4: 51000400 sub w0, w0, #0x1
/*
* 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)
4002dfc8: 6a01001f tst w0, w1
4002dfcc: 540000e1 b.ne 4002dfe8 <fat_init_volume_info+0x3e8> // b.any <== NEVER TAKEN
&& (FAT_FAT32 == vol->type || is_cluster_aligned(vol, vol->rdir_loc)))
4002dfd0: 39405a61 ldrb w1, [x19, #22]
4002dfd4: 7100103f cmp w1, #0x4
4002dfd8: 54000240 b.eq 4002e020 <fat_init_volume_info+0x420> // b.none
return (sec_num & (vol->spc - 1)) == 0;
4002dfdc: b9402a61 ldr w1, [x19, #40]
&& (FAT_FAT32 == vol->type || is_cluster_aligned(vol, vol->rdir_loc)))
4002dfe0: 6a01001f tst w0, w1
4002dfe4: 540001e0 b.eq 4002e020 <fat_init_volume_info+0x420> // b.none <== ALWAYS TAKEN
4002dfe8: a94363f7 ldp x23, x24, [sp, #48]
4002dfec: a9446bf9 ldp x25, x26, [sp, #64]
4002dff0: a94573fb ldp x27, x28, [sp, #80]
vol->sectors_per_block = vol->spc;
}
}
return RC_OK;
}
4002dff4: 2a1503e0 mov w0, w21
4002dff8: a94153f3 ldp x19, x20, [sp, #16]
4002dffc: a9425bf5 ldp x21, x22, [sp, #32]
4002e000: a8d07bfd ldp x29, x30, [sp], #256
4002e004: d65f03c0 ret
vol->mask = FAT_FAT12_MASK;
4002e008: d281ffe0 mov x0, #0xfff // #4095
vol->type = FAT_FAT12;
4002e00c: 52800021 mov w1, #0x1 // #1
vol->mask = FAT_FAT12_MASK;
4002e010: f2c1ff00 movk x0, #0xff8, lsl #32
vol->type = FAT_FAT12;
4002e014: 39005a61 strb w1, [x19, #22]
vol->mask = FAT_FAT12_MASK;
4002e018: f9000e60 str x0, [x19, #24]
4002e01c: 17ffffb0 b 4002dedc <fat_init_volume_info+0x2dc>
sc = rtems_bdbuf_set_block_size (vol->dd, vol->bpc, true);
4002e020: b9400a61 ldr w1, [x19, #8]
4002e024: 52800022 mov w2, #0x1 // #1
4002e028: f9403a60 ldr x0, [x19, #112]
4002e02c: 940021a5 bl 400366c0 <rtems_bdbuf_set_block_size>
if (sc == RTEMS_SUCCESSFUL)
4002e030: 35fffdc0 cbnz w0, 4002dfe8 <fat_init_volume_info+0x3e8>
vol->bytes_per_block_log2 = vol->bpc_log2;
4002e034: 39403260 ldrb w0, [x19, #12]
vol->sectors_per_block = vol->spc;
4002e038: 39401262 ldrb w2, [x19, #4]
4002e03c: 39003662 strb w2, [x19, #13]
vol->bytes_per_block_log2 = vol->bpc_log2;
4002e040: 39005260 strb w0, [x19, #20]
}
4002e044: 2a1503e0 mov w0, w21
vol->bytes_per_block = vol->bpc;
4002e048: b9400a61 ldr w1, [x19, #8]
4002e04c: a94363f7 ldp x23, x24, [sp, #48]
4002e050: a9446bf9 ldp x25, x26, [sp, #64]
4002e054: a94573fb ldp x27, x28, [sp, #80]
4002e058: b9001261 str w1, [x19, #16]
}
4002e05c: a94153f3 ldp x19, x20, [sp, #16]
4002e060: a9425bf5 ldp x21, x22, [sp, #32]
4002e064: a8d07bfd ldp x29, x30, [sp], #256
4002e068: d65f03c0 ret
else if ( vol->data_cls < FAT_FAT32_MASK - 1 )
4002e06c: 321f6be0 mov w0, #0xffffffe // #268435454
4002e070: 6b00007f cmp w3, w0
4002e074: 540005e2 b.cs 4002e130 <fat_init_volume_info+0x530> // b.hs, b.nlast<== NEVER TAKEN
vol->afat = 0;
4002e078: b94077e1 ldr w1, [sp, #116]
vol->type = FAT_FAT32;
4002e07c: 52800082 mov w2, #0x4 // #4
4002e080: 39005a62 strb w2, [x19, #22]
vol->afat = 0;
4002e084: 12000c20 and w0, w1, #0xf
vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
4002e088: 1219603c and w28, w1, #0xffffff80
vol->afat = 0;
4002e08c: f279003f tst x1, #0x80
vol->mask = FAT_FAT32_MASK;
4002e090: b21d63e1 mov x1, #0xffffff80ffffff8 // #1152921470515544056
4002e094: f29fffe1 movk x1, #0xffff
4002e098: f9000e61 str x1, [x19, #24]
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
4002e09c: b9407be1 ldr w1, [sp, #120]
vol->afat = 0;
4002e0a0: 1a9f1000 csel w0, w0, wzr, ne // ne = any
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
4002e0a4: b9004661 str w1, [x19, #68]
vol->info_sec = FAT_GET_BR_FAT32_FS_INFO_SECTOR(boot_rec);
4002e0a8: 7900927a strh w26, [x19, #72]
vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
4002e0ac: 3901727c strb w28, [x19, #92]
4002e0b0: 39019260 strb w0, [x19, #100]
if( vol->info_sec == 0 )
4002e0b4: 340003fa cbz w26, 4002e130 <fat_init_volume_info+0x530> <== NEVER TAKEN
ret = _fat_block_read(fs_info, vol->info_sec , 0,
4002e0b8: 2a1a03e1 mov w1, w26
4002e0bc: 910223e4 add x4, sp, #0x88
4002e0c0: aa1303e0 mov x0, x19
4002e0c4: 52800083 mov w3, #0x4 // #4
4002e0c8: 52800002 mov w2, #0x0 // #0
4002e0cc: 97fffd75 bl 4002d6a0 <_fat_block_read>
if ( ret < 0 )
4002e0d0: b7f80880 tbnz x0, #63, 4002e1e0 <fat_init_volume_info+0x5e0> <== NEVER TAKEN
if (FAT_GET_FSINFO_LEAD_SIGNATURE(fs_info_sector) !=
4002e0d4: b9408be1 ldr w1, [sp, #136]
4002e0d8: 528a4a40 mov w0, #0x5252 // #21074
4002e0dc: 72a82c20 movk w0, #0x4161, lsl #16
4002e0e0: 6b00003f cmp w1, w0
4002e0e4: 540001e1 b.ne 4002e120 <fat_init_volume_info+0x520> // b.any <== NEVER TAKEN
ret = _fat_block_read(fs_info, vol->info_sec , FAT_FSI_INFO,
4002e0e8: 79409261 ldrh w1, [x19, #72]
4002e0ec: 910223e4 add x4, sp, #0x88
4002e0f0: aa1303e0 mov x0, x19
4002e0f4: 52800183 mov w3, #0xc // #12
4002e0f8: 52803c82 mov w2, #0x1e4 // #484
4002e0fc: 97fffd69 bl 4002d6a0 <_fat_block_read>
if ( ret < 0 )
4002e100: b7f80680 tbnz x0, #63, 4002e1d0 <fat_init_volume_info+0x5d0> <== NEVER TAKEN
FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
4002e104: 295183e1 ldp w1, w0, [sp, #140]
vol->free_cls_in_fs_info =
4002e108: 29098661 stp w1, w1, [x19, #76]
vol->next_cl_in_fs_info =
4002e10c: 290a8260 stp w0, w0, [x19, #84]
vol->next_cl = vol->next_cl_in_fs_info;
4002e110: 17ffff79 b 4002def4 <fat_init_volume_info+0x2f4>
for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;
4002e114: 52800000 mov w0, #0x0 // #0
4002e118: 52800021 mov w1, #0x1 // #1
4002e11c: 17ffff46 b 4002de34 <fat_init_volume_info+0x234>
if (fs_info->c.state == FAT_CACHE_EMPTY)
4002e120: 3942d660 ldrb w0, [x19, #181] <== NOT EXECUTED
4002e124: 34000060 cbz w0, 4002e130 <fat_init_volume_info+0x530> <== NOT EXECUTED
4002e128: aa1303e0 mov x0, x19 <== NOT EXECUTED
4002e12c: 97fffcb5 bl 4002d400 <fat_buf_release.part.0> <== NOT EXECUTED
close(vol->fd);
4002e130: b9406a60 ldr w0, [x19, #104] <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
4002e134: 12800015 mov w21, #0xffffffff // #-1 <== NOT EXECUTED
close(vol->fd);
4002e138: 97ffce9a bl 40021ba0 <close> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
4002e13c: 9400320c bl 4003a96c <__errno> <== NOT EXECUTED
4002e140: 528002c1 mov w1, #0x16 // #22 <== NOT EXECUTED
4002e144: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
4002e148: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
4002e14c: a94573fb ldp x27, x28, [sp, #80] <== NOT EXECUTED
4002e150: b9000001 str w1, [x0] <== NOT EXECUTED
4002e154: 17ffffa8 b 4002dff4 <fat_init_volume_info+0x3f4> <== NOT EXECUTED
close(vol->fd);
4002e158: 97ffce92 bl 40021ba0 <close> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENXIO);
4002e15c: 94003204 bl 4003a96c <__errno> <== NOT EXECUTED
4002e160: 12800015 mov w21, #0xffffffff // #-1 <== NOT EXECUTED
4002e164: 528000c1 mov w1, #0x6 // #6 <== NOT EXECUTED
4002e168: b9000001 str w1, [x0] <== NOT EXECUTED
4002e16c: 17ffffa2 b 4002dff4 <fat_init_volume_info+0x3f4> <== NOT EXECUTED
close(vol->fd);
4002e170: b9406a60 ldr w0, [x19, #104] <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENXIO);
4002e174: 12800015 mov w21, #0xffffffff // #-1 <== NOT EXECUTED
close(vol->fd);
4002e178: 97ffce8a bl 40021ba0 <close> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENXIO);
4002e17c: 940031fc bl 4003a96c <__errno> <== NOT EXECUTED
4002e180: 528000c1 mov w1, #0x6 // #6 <== NOT EXECUTED
4002e184: b9000001 str w1, [x0] <== NOT EXECUTED
4002e188: 17ffff9b b 4002dff4 <fat_init_volume_info+0x3f4> <== NOT EXECUTED
close(vol->fd);
4002e18c: b9406a60 ldr w0, [x19, #104] <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO);
4002e190: 12800015 mov w21, #0xffffffff // #-1 <== NOT EXECUTED
close(vol->fd);
4002e194: 97ffce83 bl 40021ba0 <close> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO);
4002e198: 940031f5 bl 4003a96c <__errno> <== NOT EXECUTED
4002e19c: 528000a1 mov w1, #0x5 // #5 <== NOT EXECUTED
4002e1a0: b9000001 str w1, [x0] <== NOT EXECUTED
4002e1a4: 17ffff94 b 4002dff4 <fat_init_volume_info+0x3f4> <== NOT EXECUTED
close(vol->fd);
4002e1a8: b9406a60 ldr w0, [x19, #104] <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
4002e1ac: 12800015 mov w21, #0xffffffff // #-1 <== NOT EXECUTED
close(vol->fd);
4002e1b0: 97ffce7c bl 40021ba0 <close> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
4002e1b4: 940031ee bl 4003a96c <__errno> <== NOT EXECUTED
4002e1b8: 528000a1 mov w1, #0x5 // #5 <== NOT EXECUTED
4002e1bc: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
4002e1c0: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
4002e1c4: a94573fb ldp x27, x28, [sp, #80] <== NOT EXECUTED
4002e1c8: b9000001 str w1, [x0] <== NOT EXECUTED
4002e1cc: 17ffff8a b 4002dff4 <fat_init_volume_info+0x3f4> <== NOT EXECUTED
if (fs_info->c.state == FAT_CACHE_EMPTY)
4002e1d0: 3942d660 ldrb w0, [x19, #181] <== NOT EXECUTED
4002e1d4: 34000060 cbz w0, 4002e1e0 <fat_init_volume_info+0x5e0> <== NOT EXECUTED
4002e1d8: aa1303e0 mov x0, x19 <== NOT EXECUTED
4002e1dc: 97fffc89 bl 4002d400 <fat_buf_release.part.0> <== NOT EXECUTED
close(vol->fd);
4002e1e0: b9406a60 ldr w0, [x19, #104] <== NOT EXECUTED
return -1;
4002e1e4: 12800015 mov w21, #0xffffffff // #-1 <== NOT EXECUTED
close(vol->fd);
4002e1e8: 97ffce6e bl 40021ba0 <close> <== NOT EXECUTED
return -1;
4002e1ec: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
4002e1f0: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
4002e1f4: a94573fb ldp x27, x28, [sp, #80] <== NOT EXECUTED
4002e1f8: 17ffff7f b 4002dff4 <fat_init_volume_info+0x3f4> <== NOT EXECUTED
close(vol->fd);
4002e1fc: b9406a60 ldr w0, [x19, #104] <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
4002e200: 12800015 mov w21, #0xffffffff // #-1 <== NOT EXECUTED
close(vol->fd);
4002e204: 97ffce67 bl 40021ba0 <close> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
4002e208: 940031d9 bl 4003a96c <__errno> <== NOT EXECUTED
4002e20c: 52800181 mov w1, #0xc // #12 <== NOT EXECUTED
4002e210: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
4002e214: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
4002e218: a94573fb ldp x27, x28, [sp, #80] <== NOT EXECUTED
4002e21c: b9000001 str w1, [x0] <== NOT EXECUTED
4002e220: 17ffff75 b 4002dff4 <fat_init_volume_info+0x3f4> <== NOT EXECUTED
close(vol->fd);
4002e224: b9406a60 ldr w0, [x19, #104] <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
4002e228: 12800015 mov w21, #0xffffffff // #-1 <== NOT EXECUTED
close(vol->fd);
4002e22c: 97ffce5d bl 40021ba0 <close> <== NOT EXECUTED
free(fs_info->vhash);
4002e230: f9404660 ldr x0, [x19, #136] <== NOT EXECUTED
free(fs_info->uino);
4002e234: 97ffced3 bl 40021d80 <free> <== NOT EXECUTED
4002e238: 17fffff4 b 4002e208 <fat_init_volume_info+0x608> <== NOT EXECUTED
close(vol->fd);
4002e23c: b9406a60 ldr w0, [x19, #104] <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
4002e240: 12800015 mov w21, #0xffffffff // #-1 <== NOT EXECUTED
close(vol->fd);
4002e244: 97ffce57 bl 40021ba0 <close> <== NOT EXECUTED
free(fs_info->vhash);
4002e248: f9404660 ldr x0, [x19, #136] <== NOT EXECUTED
4002e24c: 97ffcecd bl 40021d80 <free> <== NOT EXECUTED
free(fs_info->rhash);
4002e250: f9404a60 ldr x0, [x19, #144] <== NOT EXECUTED
free(fs_info->uino);
4002e254: 97ffcecb bl 40021d80 <free> <== NOT EXECUTED
4002e258: 17ffffec b 4002e208 <fat_init_volume_info+0x608> <== NOT EXECUTED
close(vol->fd);
4002e25c: b9406a60 ldr w0, [x19, #104] <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
4002e260: 12800015 mov w21, #0xffffffff // #-1 <== NOT EXECUTED
close(vol->fd);
4002e264: 97ffce4f bl 40021ba0 <close> <== NOT EXECUTED
free(fs_info->vhash);
4002e268: f9404660 ldr x0, [x19, #136] <== NOT EXECUTED
4002e26c: 97ffcec5 bl 40021d80 <free> <== NOT EXECUTED
free(fs_info->rhash);
4002e270: f9404a60 ldr x0, [x19, #144] <== NOT EXECUTED
4002e274: 97ffcec3 bl 40021d80 <free> <== NOT EXECUTED
free(fs_info->uino);
4002e278: f9404e60 ldr x0, [x19, #152] <== NOT EXECUTED
4002e27c: 97ffcec1 bl 40021d80 <free> <== NOT EXECUTED
4002e280: 17ffffe2 b 4002e208 <fat_init_volume_info+0x608> <== NOT EXECUTED
...
000000004002eca0 <fat_scan_fat_for_free_clusters>:
{
4002eca0: a9b87bfd stp x29, x30, [sp, #-128]!
4002eca4: 910003fd mov x29, sp
4002eca8: a90153f3 stp x19, x20, [sp, #16]
uint32_t cl4find = 2;
4002ecac: 52800054 mov w20, #0x2 // #2
if (fs_info->vol.next_cl - 2 < fs_info->vol.data_cls)
4002ecb0: b9405413 ldr w19, [x0, #84]
{
4002ecb4: a9025bf5 stp x21, x22, [sp, #32]
4002ecb8: aa0303f6 mov x22, x3
uint32_t data_cls_val = fs_info->vol.data_cls + 2;
4002ecbc: b9404015 ldr w21, [x0, #64]
{
4002ecc0: a9046bf9 stp x25, x26, [sp, #64]
4002ecc4: a90573fb stp x27, x28, [sp, #80]
4002ecc8: aa0003fc mov x28, x0
if (fs_info->vol.next_cl - 2 < fs_info->vol.data_cls)
4002eccc: 51000a60 sub w0, w19, #0x2
uint32_t cl4find = 2;
4002ecd0: 6b0002bf cmp w21, w0
*cls_added = 0;
4002ecd4: b900007f str wzr, [x3]
{
4002ecd8: f90037e4 str x4, [sp, #104]
uint32_t data_cls_val = fs_info->vol.data_cls + 2;
4002ecdc: 0b1402b5 add w21, w21, w20
uint32_t cl4find = 2;
4002ece0: 1a948273 csel w19, w19, w20, hi // hi = pmore
while (*cls_added != count && i < data_cls_val)
4002ece4: 7100005f cmp w2, #0x0
4002ece8: 7a5412a0 ccmp w21, w20, #0x0, ne // ne = any
4002ecec: 54000f89 b.ls 4002eedc <fat_scan_fat_for_free_clusters+0x23c> // b.plast<== NEVER TAKEN
4002ecf0: aa0103fb mov x27, x1
4002ecf4: 12001cba and w26, w5, #0xff
4002ecf8: a90363f7 stp x23, x24, [sp, #48]
4002ecfc: 2a0203f7 mov w23, w2
cl4find = 2;
4002ed00: 2a1403f8 mov w24, w20
uint32_t save_cln = FAT_UNDEFINED_VALUE;
4002ed04: 12800019 mov w25, #0xffffffff // #-1
rc = fat_get_fat_cluster(fs_info, cl4find, &next_cln);
4002ed08: 9101f3e2 add x2, sp, #0x7c
4002ed0c: 2a1303e1 mov w1, w19
4002ed10: aa1c03e0 mov x0, x28
uint32_t next_cln = 0;
4002ed14: b9007fff str wzr, [sp, #124]
rc = fat_get_fat_cluster(fs_info, cl4find, &next_cln);
4002ed18: 97fffe5e bl 4002e690 <fat_get_fat_cluster>
4002ed1c: 2a0003e3 mov w3, w0
if ( rc != RC_OK )
4002ed20: 35000b00 cbnz w0, 4002ee80 <fat_scan_fat_for_free_clusters+0x1e0> <== NEVER TAKEN
if (next_cln == FAT_GENFAT_FREE)
4002ed24: b9407fe0 ldr w0, [sp, #124]
if (*cls_added != 0)
4002ed28: b94002c1 ldr w1, [x22]
if (next_cln == FAT_GENFAT_FREE)
4002ed2c: 350001c0 cbnz w0, 4002ed64 <fat_scan_fat_for_free_clusters+0xc4>
if (*cls_added == 0)
4002ed30: 35000541 cbnz w1, 4002edd8 <fat_scan_fat_for_free_clusters+0x138>
*chain = cl4find;
4002ed34: b9000373 str w19, [x27]
rc = fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_EOC);
4002ed38: 2a1303e1 mov w1, w19
4002ed3c: aa1c03e0 mov x0, x28
4002ed40: 12800002 mov w2, #0xffffffff // #-1
4002ed44: 97fffedf bl 4002e8c0 <fat_set_fat_cluster>
4002ed48: 2a0003e3 mov w3, w0
if ( rc != RC_OK )
4002ed4c: 350009e0 cbnz w0, 4002ee88 <fat_scan_fat_for_free_clusters+0x1e8> <== NEVER TAKEN
if (zero_fill)
4002ed50: 3500083a cbnz w26, 4002ee54 <fat_scan_fat_for_free_clusters+0x1b4>
(*cls_added)++;
4002ed54: b94002c1 ldr w1, [x22]
4002ed58: 2a1303f9 mov w25, w19
4002ed5c: 11000421 add w1, w1, #0x1
4002ed60: b90002c1 str w1, [x22]
cl4find++;
4002ed64: 11000673 add w19, w19, #0x1
i++;
4002ed68: 11000694 add w20, w20, #0x1
cl4find = 2;
4002ed6c: 6b1302bf cmp w21, w19
4002ed70: 1a988273 csel w19, w19, w24, hi // hi = pmore
while (*cls_added != count && i < data_cls_val)
4002ed74: 6b1402bf cmp w21, w20
4002ed78: 7a4182e4 ccmp w23, w1, #0x4, hi // hi = pmore
4002ed7c: 54fffc61 b.ne 4002ed08 <fat_scan_fat_for_free_clusters+0x68> // b.any
4002ed80: a94363f7 ldp x23, x24, [sp, #48]
*last_cl = save_cln;
4002ed84: f94037e0 ldr x0, [sp, #104]
4002ed88: b9000019 str w25, [x0]
fs_info->vol.next_cl = save_cln;
4002ed8c: b9005799 str w25, [x28, #84]
if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
4002ed90: b9404f80 ldr w0, [x28, #76]
4002ed94: 3100041f cmn w0, #0x1
4002ed98: 54000080 b.eq 4002eda8 <fat_scan_fat_for_free_clusters+0x108> // b.none<== ALWAYS TAKEN
fs_info->vol.free_cls -= (*cls_added);
4002ed9c: b94002c1 ldr w1, [x22] <== NOT EXECUTED
4002eda0: 4b010000 sub w0, w0, w1 <== NOT EXECUTED
4002eda4: b9004f80 str w0, [x28, #76] <== NOT EXECUTED
return RC_OK;
4002eda8: 52800003 mov w3, #0x0 // #0
fat_buf_release(fs_info);
4002edac: aa1c03e0 mov x0, x28
return RC_OK;
4002edb0: b9006be3 str w3, [sp, #104]
fat_buf_release(fs_info);
4002edb4: 97fffa33 bl 4002d680 <fat_buf_release>
4002edb8: b9406be3 ldr w3, [sp, #104]
}
4002edbc: a94153f3 ldp x19, x20, [sp, #16]
4002edc0: 2a0303e0 mov w0, w3
4002edc4: a9425bf5 ldp x21, x22, [sp, #32]
4002edc8: a9446bf9 ldp x25, x26, [sp, #64]
4002edcc: a94573fb ldp x27, x28, [sp, #80]
4002edd0: a8c87bfd ldp x29, x30, [sp], #128
4002edd4: d65f03c0 ret
rc = fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_EOC);
4002edd8: 2a1303e1 mov w1, w19
4002eddc: aa1c03e0 mov x0, x28
4002ede0: 12800002 mov w2, #0xffffffff // #-1
4002ede4: 97fffeb7 bl 4002e8c0 <fat_set_fat_cluster>
4002ede8: 2a0003e3 mov w3, w0
if ( rc != RC_OK )
4002edec: 350005e0 cbnz w0, 4002eea8 <fat_scan_fat_for_free_clusters+0x208> <== NEVER TAKEN
rc = fat_set_fat_cluster(fs_info, save_cln, cl4find);
4002edf0: 2a1903e1 mov w1, w25
4002edf4: 2a1303e2 mov w2, w19
4002edf8: aa1c03e0 mov x0, x28
4002edfc: 97fffeb1 bl 4002e8c0 <fat_set_fat_cluster>
4002ee00: 2a0003e3 mov w3, w0
if ( rc != RC_OK )
4002ee04: 34fffa60 cbz w0, 4002ed50 <fat_scan_fat_for_free_clusters+0xb0> <== ALWAYS TAKEN
fat_free_fat_clusters_chain(fs_info, (*chain));
4002ee08: b9400361 ldr w1, [x27] <== NOT EXECUTED
4002ee0c: aa1c03e0 mov x0, x28 <== NOT EXECUTED
4002ee10: b9006be3 str w3, [sp, #104] <== NOT EXECUTED
4002ee14: 97ffff5f bl 4002eb90 <fat_free_fat_clusters_chain> <== NOT EXECUTED
(void) fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_FREE);
4002ee18: 2a1303e1 mov w1, w19 <== NOT EXECUTED
4002ee1c: 52800002 mov w2, #0x0 // #0 <== NOT EXECUTED
4002ee20: aa1c03e0 mov x0, x28 <== NOT EXECUTED
4002ee24: 97fffea7 bl 4002e8c0 <fat_set_fat_cluster> <== NOT EXECUTED
fat_buf_release(fs_info);
4002ee28: aa1c03e0 mov x0, x28 <== NOT EXECUTED
4002ee2c: 97fffa15 bl 4002d680 <fat_buf_release> <== NOT EXECUTED
return rc;
4002ee30: b9406be3 ldr w3, [sp, #104] <== NOT EXECUTED
}
4002ee34: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
4002ee38: 2a0303e0 mov w0, w3 <== NOT EXECUTED
4002ee3c: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
return rc;
4002ee40: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
}
4002ee44: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
4002ee48: a94573fb ldp x27, x28, [sp, #80] <== NOT EXECUTED
4002ee4c: a8c87bfd ldp x29, x30, [sp], #128 <== NOT EXECUTED
4002ee50: d65f03c0 ret <== NOT EXECUTED
fat_cluster_set(fs_info, cl4find, 0, fs_info->vol.bpc, 0);
4002ee54: b9400b83 ldr w3, [x28, #8]
4002ee58: 2a1303e1 mov w1, w19
4002ee5c: aa1c03e0 mov x0, x28
4002ee60: 52800004 mov w4, #0x0 // #0
4002ee64: 52800002 mov w2, #0x0 // #0
4002ee68: 97fffa92 bl 4002d8b0 <fat_cluster_set>
if (fs_info->vol.bpc != bytes_written)
4002ee6c: b9400b81 ldr w1, [x28, #8]
4002ee70: eb00003f cmp x1, x0
4002ee74: 54fff700 b.eq 4002ed54 <fat_scan_fat_for_free_clusters+0xb4> // b.none<== ALWAYS TAKEN
rc = -1;
4002ee78: 12800003 mov w3, #0xffffffff // #-1 <== NOT EXECUTED
4002ee7c: 17ffffe3 b 4002ee08 <fat_scan_fat_for_free_clusters+0x168> <== NOT EXECUTED
if (*cls_added != 0)
4002ee80: b94002c0 ldr w0, [x22] <== NOT EXECUTED
4002ee84: 35000120 cbnz w0, 4002eea8 <fat_scan_fat_for_free_clusters+0x208> <== NOT EXECUTED
}
4002ee88: 2a0303e0 mov w0, w3 <== NOT EXECUTED
4002ee8c: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
4002ee90: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
4002ee94: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
4002ee98: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
4002ee9c: a94573fb ldp x27, x28, [sp, #80] <== NOT EXECUTED
4002eea0: a8c87bfd ldp x29, x30, [sp], #128 <== NOT EXECUTED
4002eea4: d65f03c0 ret <== NOT EXECUTED
fat_free_fat_clusters_chain(fs_info, (*chain));
4002eea8: b9400361 ldr w1, [x27] <== NOT EXECUTED
4002eeac: aa1c03e0 mov x0, x28 <== NOT EXECUTED
4002eeb0: b9006be3 str w3, [sp, #104] <== NOT EXECUTED
4002eeb4: 97ffff37 bl 4002eb90 <fat_free_fat_clusters_chain> <== NOT EXECUTED
return rc;
4002eeb8: b9406be3 ldr w3, [sp, #104] <== NOT EXECUTED
}
4002eebc: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
4002eec0: 2a0303e0 mov w0, w3 <== NOT EXECUTED
4002eec4: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
return rc;
4002eec8: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
}
4002eecc: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
4002eed0: a94573fb ldp x27, x28, [sp, #80] <== NOT EXECUTED
4002eed4: a8c87bfd ldp x29, x30, [sp], #128 <== NOT EXECUTED
4002eed8: d65f03c0 ret <== NOT EXECUTED
uint32_t save_cln = FAT_UNDEFINED_VALUE;
4002eedc: 12800019 mov w25, #0xffffffff // #-1 <== NOT EXECUTED
4002eee0: 17ffffa9 b 4002ed84 <fat_scan_fat_for_free_clusters+0xe4> <== NOT EXECUTED
...
000000004002d7d0 <fat_sector_write>:
fat_fs_info_t *fs_info,
uint32_t start,
uint32_t offset,
uint32_t count,
const void *buff)
{
4002d7d0: a9ba7bfd stp x29, x30, [sp, #-96]!
4002d7d4: 910003fd mov x29, sp
4002d7d8: a9025bf5 stp x21, x22, [sp, #32]
uint32_t sec_num = start;
uint32_t ofs = offset;
uint8_t *sec_buf;
uint32_t c = 0;
while(count > 0)
4002d7dc: 34000663 cbz w3, 4002d8a8 <fat_sector_write+0xd8> <== NEVER TAKEN
4002d7e0: aa0003f5 mov x21, x0
ssize_t cmpltd = 0;
4002d7e4: d2800016 mov x22, #0x0 // #0
4002d7e8: a90153f3 stp x19, x20, [sp, #16]
4002d7ec: 2a0303f4 mov w20, w3
4002d7f0: a90363f7 stp x23, x24, [sp, #48]
4002d7f4: aa0403f7 mov x23, x4
}
static inline void
fat_buf_mark_modified(fat_fs_info_t *fs_info)
{
fs_info->c.modified = true;
4002d7f8: 52800038 mov w24, #0x1 // #1
4002d7fc: a9046bf9 stp x25, x26, [sp, #64]
4002d800: 2a0103f9 mov w25, w1
4002d804: 2a0203fa mov w26, w2
4002d808: 1400000f b 4002d844 <fat_sector_write+0x74>
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);
4002d80c: 97ffff69 bl 4002d5b0 <fat_buf_access>
if (rc != RC_OK)
return -1;
memcpy((sec_buf + ofs), (buff + cmpltd), c);
4002d810: 2a1303e3 mov w3, w19
4002d814: 8b1602e1 add x1, x23, x22
4002d818: aa0303e2 mov x2, x3
if (rc != RC_OK)
4002d81c: 35000360 cbnz w0, 4002d888 <fat_sector_write+0xb8> <== NEVER TAKEN
memcpy((sec_buf + ofs), (buff + cmpltd), c);
4002d820: f9402fe0 ldr x0, [sp, #88]
fat_buf_mark_modified(fs_info);
count -= c;
cmpltd +=c;
4002d824: 8b0302d6 add x22, x22, x3
sec_num++;
4002d828: 11000739 add w25, w25, #0x1
memcpy((sec_buf + ofs), (buff + cmpltd), c);
4002d82c: 8b3a4000 add x0, x0, w26, uxtw
4002d830: 940036f2 bl 4003b3f8 <memcpy>
4002d834: 3902d2b8 strb w24, [x21, #180]
while(count > 0)
4002d838: 6b130294 subs w20, w20, w19
ofs = 0;
4002d83c: 5280001a mov w26, #0x0 // #0
while(count > 0)
4002d840: 54000260 b.eq 4002d88c <fat_sector_write+0xbc> // b.none <== ALWAYS TAKEN
c = MIN(count, (fs_info->vol.bps - ofs));
4002d844: 794002b3 ldrh w19, [x21]
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
4002d848: 2a1903e1 mov w1, w25
if (c == fs_info->vol.bytes_per_block)
4002d84c: b94012a4 ldr w4, [x21, #16]
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
4002d850: 910163e3 add x3, sp, #0x58
c = MIN(count, (fs_info->vol.bps - ofs));
4002d854: 4b1a0273 sub w19, w19, w26
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
4002d858: aa1503e0 mov x0, x21
c = MIN(count, (fs_info->vol.bps - ofs));
4002d85c: 6b14027f cmp w19, w20
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
4002d860: 52800022 mov w2, #0x1 // #1
c = MIN(count, (fs_info->vol.bps - ofs));
4002d864: 1a949273 csel w19, w19, w20, ls // ls = plast
if (c == fs_info->vol.bytes_per_block)
4002d868: 6b13009f cmp w4, w19
4002d86c: 54fffd01 b.ne 4002d80c <fat_sector_write+0x3c> // b.any <== ALWAYS TAKEN
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &sec_buf);
4002d870: 52800042 mov w2, #0x2 // #2 <== NOT EXECUTED
4002d874: 97ffff4f bl 4002d5b0 <fat_buf_access> <== NOT EXECUTED
memcpy((sec_buf + ofs), (buff + cmpltd), c);
4002d878: 2a1303e3 mov w3, w19 <== NOT EXECUTED
4002d87c: 8b1602e1 add x1, x23, x22 <== NOT EXECUTED
4002d880: aa0303e2 mov x2, x3 <== NOT EXECUTED
if (rc != RC_OK)
4002d884: 34fffce0 cbz w0, 4002d820 <fat_sector_write+0x50> <== NOT EXECUTED
return -1;
4002d888: 92800016 mov x22, #0xffffffffffffffff // #-1 <== NOT EXECUTED
4002d88c: a94153f3 ldp x19, x20, [sp, #16]
4002d890: a94363f7 ldp x23, x24, [sp, #48]
4002d894: a9446bf9 ldp x25, x26, [sp, #64]
}
return cmpltd;
}
4002d898: aa1603e0 mov x0, x22
4002d89c: a9425bf5 ldp x21, x22, [sp, #32]
4002d8a0: a8c67bfd ldp x29, x30, [sp], #96
4002d8a4: d65f03c0 ret
ssize_t cmpltd = 0;
4002d8a8: d2800016 mov x22, #0x0 // #0 <== NOT EXECUTED
4002d8ac: 17fffffb b 4002d898 <fat_sector_write+0xc8> <== NOT EXECUTED
000000004002e8c0 <fat_set_fat_cluster>:
fat_set_fat_cluster(
fat_fs_info_t *fs_info,
uint32_t cln,
uint32_t in_val
)
{
4002e8c0: a9ba7bfd stp x29, x30, [sp, #-96]!
uint16_t fat16_clv = 0;
uint32_t fat32_clv = 0;
uint8_t *sec_buf = NULL;
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
4002e8c4: 7100043f cmp w1, #0x1
{
4002e8c8: 910003fd mov x29, sp
uint8_t *sec_buf = NULL;
4002e8cc: f9002fff str xzr, [sp, #88]
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
4002e8d0: 54001549 b.ls 4002eb78 <fat_set_fat_cluster+0x2b8> // b.plast <== NEVER TAKEN
4002e8d4: a90153f3 stp x19, x20, [sp, #16]
4002e8d8: aa0003f3 mov x19, x0
4002e8dc: b9404000 ldr w0, [x0, #64]
4002e8e0: 2a0103f4 mov w20, w1
4002e8e4: 11000400 add w0, w0, #0x1
4002e8e8: 6b01001f cmp w0, w1
4002e8ec: 54001443 b.cc 4002eb74 <fat_set_fat_cluster+0x2b4> // b.lo, b.ul, b.last<== NEVER TAKEN
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
4002e8f0: a9025bf5 stp x21, x22, [sp, #32]
4002e8f4: 2a0203f6 mov w22, w2
4002e8f8: a90363f7 stp x23, x24, [sp, #48]
fs_info->vol.afat_loc;
4002e8fc: b9406277 ldr w23, [x19, #96]
4002e900: f90023f9 str x25, [sp, #64]
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
4002e904: 39405a60 ldrb w0, [x19, #22]
4002e908: 39400a61 ldrb w1, [x19, #2]
4002e90c: 37000400 tbnz w0, #0, 4002e98c <fat_set_fat_cluster+0xcc>
4002e910: 360805e0 tbz w0, #1, 4002e9cc <fat_set_fat_cluster+0x10c>
4002e914: 0b140299 add w25, w20, w20
4002e918: 1ac12721 lsr w1, w25, w1
4002e91c: 0b170037 add w23, w1, w23
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
4002e920: 79400275 ldrh w21, [x19]
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
4002e924: 910163e3 add x3, sp, #0x58
4002e928: 2a1703e1 mov w1, w23
4002e92c: aa1303e0 mov x0, x19
4002e930: 52800022 mov w2, #0x1 // #1
4002e934: 97fffb1f bl 4002d5b0 <fat_buf_access>
if (rc != RC_OK)
4002e938: 350003e0 cbnz w0, 4002e9b4 <fat_set_fat_cluster+0xf4> <== NEVER TAKEN
return rc;
switch ( fs_info->vol.type )
4002e93c: 39405a78 ldrb w24, [x19, #22]
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
4002e940: 510006a3 sub w3, w21, #0x1
4002e944: 0a190063 and w3, w3, w25
switch ( fs_info->vol.type )
4002e948: 71000b1f cmp w24, #0x2
4002e94c: 54000480 b.eq 4002e9dc <fat_set_fat_cluster+0x11c> // b.none
4002e950: 7100131f cmp w24, #0x4
4002e954: 54000580 b.eq 4002ea04 <fat_set_fat_cluster+0x144> // b.none
4002e958: 7100071f cmp w24, #0x1
4002e95c: 540006c0 b.eq 4002ea34 <fat_set_fat_cluster+0x174> // b.none <== ALWAYS TAKEN
fat_buf_mark_modified(fs_info);
break;
default:
rtems_set_errno_and_return_minus_one(EIO);
4002e960: 94003003 bl 4003a96c <__errno> <== NOT EXECUTED
4002e964: aa0003e1 mov x1, x0 <== NOT EXECUTED
4002e968: 528000a2 mov w2, #0x5 // #5 <== NOT EXECUTED
4002e96c: 12800000 mov w0, #0xffffffff // #-1 <== NOT EXECUTED
4002e970: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
4002e974: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
4002e978: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
4002e97c: f94023f9 ldr x25, [sp, #64] <== NOT EXECUTED
4002e980: b9000022 str w2, [x1] <== NOT EXECUTED
break;
}
return RC_OK;
}
4002e984: a8c67bfd ldp x29, x30, [sp], #96
4002e988: d65f03c0 ret
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
4002e98c: 0b540699 add w25, w20, w20, lsr #1
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
4002e990: 79400275 ldrh w21, [x19]
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
4002e994: 910163e3 add x3, sp, #0x58
4002e998: aa1303e0 mov x0, x19
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
4002e99c: 1ac12721 lsr w1, w25, w1
4002e9a0: 0b170037 add w23, w1, w23
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
4002e9a4: 2a1703e1 mov w1, w23
4002e9a8: 52800022 mov w2, #0x1 // #1
4002e9ac: 97fffb01 bl 4002d5b0 <fat_buf_access>
if (rc != RC_OK)
4002e9b0: 34fffc60 cbz w0, 4002e93c <fat_set_fat_cluster+0x7c> <== ALWAYS TAKEN
4002e9b4: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
4002e9b8: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
4002e9bc: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
4002e9c0: f94023f9 ldr x25, [sp, #64] <== NOT EXECUTED
}
4002e9c4: a8c67bfd ldp x29, x30, [sp], #96 <== NOT EXECUTED
4002e9c8: d65f03c0 ret <== NOT EXECUTED
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
4002e9cc: 531e7699 lsl w25, w20, #2
4002e9d0: 1ac12721 lsr w1, w25, w1
4002e9d4: 0b170037 add w23, w1, w23
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
4002e9d8: 17ffffd2 b 4002e920 <fat_set_fat_cluster+0x60>
*((uint16_t *)(sec_buf + ofs)) =
4002e9dc: f9402fe2 ldr x2, [sp, #88]
fs_info->c.modified = true;
4002e9e0: 52800021 mov w1, #0x1 // #1
}
4002e9e4: a94363f7 ldp x23, x24, [sp, #48]
4002e9e8: f94023f9 ldr x25, [sp, #64]
(uint16_t )(CT_LE_W(in_val));
4002e9ec: 78234856 strh w22, [x2, w3, uxtw]
fs_info->c.modified = true;
4002e9f0: 3902d261 strb w1, [x19, #180]
}
4002e9f4: a94153f3 ldp x19, x20, [sp, #16]
4002e9f8: a9425bf5 ldp x21, x22, [sp, #32]
}
4002e9fc: a8c67bfd ldp x29, x30, [sp], #96
4002ea00: d65f03c0 ret
*((uint32_t *)(sec_buf + ofs)) &= CT_LE_L(0xF0000000);
4002ea04: f9402fe2 ldr x2, [sp, #88]
fs_info->c.modified = true;
4002ea08: 52800024 mov w4, #0x1 // #1
}
4002ea0c: a94363f7 ldp x23, x24, [sp, #48]
4002ea10: b8634841 ldr w1, [x2, w3, uxtw]
4002ea14: f94023f9 ldr x25, [sp, #64]
*((uint32_t *)(sec_buf + ofs)) |= fat32_clv;
4002ea18: 33006ec1 bfxil w1, w22, #0, #28
4002ea1c: b8234841 str w1, [x2, w3, uxtw]
fs_info->c.modified = true;
4002ea20: 3902d264 strb w4, [x19, #180]
}
4002ea24: a94153f3 ldp x19, x20, [sp, #16]
4002ea28: a9425bf5 ldp x21, x22, [sp, #32]
}
4002ea2c: a8c67bfd ldp x29, x30, [sp], #96
4002ea30: d65f03c0 ret
fat16_clv = ((uint16_t )in_val) << FAT_FAT12_SHIFT;
4002ea34: 12003ed6 and w22, w22, #0xffff
*(sec_buf + ofs) &= 0x0F;
4002ea38: 2a0303e1 mov w1, w3
4002ea3c: f9402fe2 ldr x2, [sp, #88]
if ( FAT_CLUSTER_IS_ODD(cln) )
4002ea40: 36000374 tbz w20, #0, 4002eaac <fat_set_fat_cluster+0x1ec>
*(sec_buf + ofs) &= 0x0F;
4002ea44: 38634844 ldrb w4, [x2, w3, uxtw]
fat16_clv = ((uint16_t )in_val) << FAT_FAT12_SHIFT;
4002ea48: 531c2ed6 ubfiz w22, w22, #4, #12
*(sec_buf + ofs) &= 0x0F;
4002ea4c: 12000c84 and w4, w4, #0xf
4002ea50: 38234844 strb w4, [x2, w3, uxtw]
*(sec_buf + ofs) |= (uint8_t)(fat16_clv & 0x00F0);
4002ea54: f9402fe4 ldr x4, [sp, #88]
4002ea58: 38634882 ldrb w2, [x4, w3, uxtw]
4002ea5c: 2a0202c2 orr w2, w22, w2
4002ea60: 38234882 strb w2, [x4, w3, uxtw]
fs_info->c.modified = true;
4002ea64: 3902d278 strb w24, [x19, #180]
if ( ofs == (fs_info->vol.bps - 1) )
4002ea68: 79400262 ldrh w2, [x19]
4002ea6c: 51000442 sub w2, w2, #0x1
4002ea70: 6b03005f cmp w2, w3
4002ea74: 540003e0 b.eq 4002eaf0 <fat_set_fat_cluster+0x230> // b.none
*(sec_buf + ofs + 1) &= 0x00;
4002ea78: f9402fe2 ldr x2, [sp, #88]
4002ea7c: 91000421 add x1, x1, #0x1
4002ea80: 3821685f strb wzr, [x2, x1]
*(sec_buf + ofs+1) |= (uint8_t)((fat16_clv & 0xFF00)>>8);
4002ea84: f9402fe2 ldr x2, [sp, #88]
4002ea88: 38616843 ldrb w3, [x2, x1]
4002ea8c: 2a562076 orr w22, w3, w22, lsr #8
4002ea90: 38216856 strb w22, [x2, x1]
4002ea94: a94153f3 ldp x19, x20, [sp, #16]
4002ea98: a9425bf5 ldp x21, x22, [sp, #32]
4002ea9c: a94363f7 ldp x23, x24, [sp, #48]
4002eaa0: f94023f9 ldr x25, [sp, #64]
}
4002eaa4: a8c67bfd ldp x29, x30, [sp], #96
4002eaa8: d65f03c0 ret
*(sec_buf + ofs) &= 0x00;
4002eaac: 3823485f strb wzr, [x2, w3, uxtw]
fat16_clv = ((uint16_t )in_val) & FAT_FAT12_MASK;
4002eab0: 12002ed6 and w22, w22, #0xfff
*(sec_buf + ofs) |= (uint8_t)(fat16_clv & 0x00FF);
4002eab4: f9402fe4 ldr x4, [sp, #88]
4002eab8: 38634882 ldrb w2, [x4, w3, uxtw]
4002eabc: 2a0202c2 orr w2, w22, w2
4002eac0: 38234882 strb w2, [x4, w3, uxtw]
4002eac4: 3902d278 strb w24, [x19, #180]
if ( ofs == (fs_info->vol.bps - 1) )
4002eac8: 79400262 ldrh w2, [x19]
4002eacc: 51000442 sub w2, w2, #0x1
4002ead0: 6b03005f cmp w2, w3
4002ead4: 54000320 b.eq 4002eb38 <fat_set_fat_cluster+0x278> // b.none <== NEVER TAKEN
*(sec_buf + ofs + 1) &= 0xF0;
4002ead8: f9402fe3 ldr x3, [sp, #88]
4002eadc: 91000421 add x1, x1, #0x1
4002eae0: 38616862 ldrb w2, [x3, x1]
4002eae4: 121c6c42 and w2, w2, #0xfffffff0
4002eae8: 38216862 strb w2, [x3, x1]
4002eaec: 17ffffe6 b 4002ea84 <fat_set_fat_cluster+0x1c4>
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
4002eaf0: 910163e3 add x3, sp, #0x58
4002eaf4: 110006e1 add w1, w23, #0x1
4002eaf8: 2a1803e2 mov w2, w24
4002eafc: aa1303e0 mov x0, x19
4002eb00: 97fffaac bl 4002d5b0 <fat_buf_access>
if (rc != RC_OK)
4002eb04: 35fff580 cbnz w0, 4002e9b4 <fat_set_fat_cluster+0xf4> <== NEVER TAKEN
*sec_buf &= 0x00;
4002eb08: f9402fe1 ldr x1, [sp, #88]
4002eb0c: 3900003f strb wzr, [x1]
*sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8);
4002eb10: f9402fe1 ldr x1, [sp, #88]
4002eb14: 39400022 ldrb w2, [x1]
4002eb18: 2a562056 orr w22, w2, w22, lsr #8
4002eb1c: 39000036 strb w22, [x1]
4002eb20: 3902d278 strb w24, [x19, #180]
}
4002eb24: a94153f3 ldp x19, x20, [sp, #16]
4002eb28: a9425bf5 ldp x21, x22, [sp, #32]
4002eb2c: a94363f7 ldp x23, x24, [sp, #48]
4002eb30: f94023f9 ldr x25, [sp, #64]
4002eb34: 17ffff94 b 4002e984 <fat_set_fat_cluster+0xc4>
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
4002eb38: 910163e3 add x3, sp, #0x58 <== NOT EXECUTED
4002eb3c: 110006e1 add w1, w23, #0x1 <== NOT EXECUTED
4002eb40: 2a1803e2 mov w2, w24 <== NOT EXECUTED
4002eb44: aa1303e0 mov x0, x19 <== NOT EXECUTED
4002eb48: 97fffa9a bl 4002d5b0 <fat_buf_access> <== NOT EXECUTED
if (rc != RC_OK)
4002eb4c: 35fff340 cbnz w0, 4002e9b4 <fat_set_fat_cluster+0xf4> <== NOT EXECUTED
*sec_buf &= 0xF0;
4002eb50: f9402fe2 ldr x2, [sp, #88] <== NOT EXECUTED
4002eb54: 39400041 ldrb w1, [x2] <== NOT EXECUTED
4002eb58: 121c6c21 and w1, w1, #0xfffffff0 <== NOT EXECUTED
4002eb5c: 39000041 strb w1, [x2] <== NOT EXECUTED
*sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8);
4002eb60: f9402fe2 ldr x2, [sp, #88] <== NOT EXECUTED
4002eb64: 39400041 ldrb w1, [x2] <== NOT EXECUTED
4002eb68: 2a562036 orr w22, w1, w22, lsr #8 <== NOT EXECUTED
4002eb6c: 39000056 strb w22, [x2] <== NOT EXECUTED
4002eb70: 17ffffec b 4002eb20 <fat_set_fat_cluster+0x260> <== NOT EXECUTED
4002eb74: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
4002eb78: 94002f7d bl 4003a96c <__errno> <== NOT EXECUTED
4002eb7c: aa0003e1 mov x1, x0 <== NOT EXECUTED
4002eb80: 528000a2 mov w2, #0x5 // #5 <== NOT EXECUTED
4002eb84: 12800000 mov w0, #0xffffffff // #-1 <== NOT EXECUTED
4002eb88: b9000022 str w2, [x1] <== NOT EXECUTED
4002eb8c: 17ffff7e b 4002e984 <fat_set_fat_cluster+0xc4> <== NOT EXECUTED
000000004002e380 <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)
{
4002e380: a9bc7bfd stp x29, x30, [sp, #-64]!
4002e384: 910003fd mov x29, sp
4002e388: a90153f3 stp x19, x20, [sp, #16]
4002e38c: aa0003f4 mov x20, x0
4002e390: a9025bf5 stp x21, x22, [sp, #32]
4002e394: f9001bf7 str x23, [sp, #48]
int rc = RC_OK;
int i = 0;
rc = fat_sync(fs_info);
4002e398: 97ffffbe bl 4002e290 <fat_sync>
rc = -1;
for (i = 0; i < FAT_HASH_SIZE; i++)
{
rtems_chain_node *node = NULL;
rtems_chain_control *the_chain = fs_info->vhash + i;
4002e39c: f9404693 ldr x19, [x20, #136]
if ( rc != RC_OK )
4002e3a0: 7100001f cmp w0, #0x0
rc = fat_sync(fs_info);
4002e3a4: 2a0003f5 mov w21, w0
if ( rc != RC_OK )
4002e3a8: 5a9f03f6 csetm w22, ne // ne = any
return _Chain_Immutable_head( the_chain )->next;
4002e3ac: aa1303f7 mov x23, x19
4002e3b0: f84086e0 ldr x0, [x23], #8
if ( !_Chain_Is_empty(the_chain))
4002e3b4: eb0002ff cmp x23, x0
4002e3b8: 54000140 b.eq 4002e3e0 <fat_shutdown_drive+0x60> // b.none
4002e3bc: d503201f nop
new_first = old_first->next;
4002e3c0: f9400001 ldr x1, [x0]
head->next = new_first;
4002e3c4: f9000261 str x1, [x19]
new_first->previous = head;
4002e3c8: f9000433 str x19, [x1, #8]
while ( (node = rtems_chain_get_unprotected(the_chain)) != NULL )
free(node);
4002e3cc: 97ffce6d bl 40021d80 <free>
return _Chain_Immutable_head( the_chain )->next;
4002e3d0: f9400260 ldr x0, [x19]
if ( !_Chain_Is_empty(the_chain))
4002e3d4: eb0002ff cmp x23, x0
4002e3d8: 54ffff41 b.ne 4002e3c0 <fat_shutdown_drive+0x40> // b.any
rtems_chain_control *the_chain = fs_info->vhash + i;
4002e3dc: f9404693 ldr x19, [x20, #136]
return &the_chain->Tail.Node;
4002e3e0: 91008277 add x23, x19, #0x20
return _Chain_Immutable_head( the_chain )->next;
4002e3e4: f9400e60 ldr x0, [x19, #24]
4002e3e8: 91006273 add x19, x19, #0x18
if ( !_Chain_Is_empty(the_chain))
4002e3ec: eb17001f cmp x0, x23
4002e3f0: 54000120 b.eq 4002e414 <fat_shutdown_drive+0x94> // b.none <== ALWAYS TAKEN
4002e3f4: d503201f nop
new_first = old_first->next;
4002e3f8: f9400001 ldr x1, [x0] <== NOT EXECUTED
head->next = new_first;
4002e3fc: f9000261 str x1, [x19] <== NOT EXECUTED
new_first->previous = head;
4002e400: f9000433 str x19, [x1, #8] <== NOT EXECUTED
free(node);
4002e404: 97ffce5f bl 40021d80 <free> <== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
4002e408: f9400260 ldr x0, [x19] <== NOT EXECUTED
if ( !_Chain_Is_empty(the_chain))
4002e40c: eb0002ff cmp x23, x0 <== NOT EXECUTED
4002e410: 54ffff41 b.ne 4002e3f8 <fat_shutdown_drive+0x78> // b.any <== NOT EXECUTED
}
for (i = 0; i < FAT_HASH_SIZE; i++)
{
rtems_chain_node *node = NULL;
rtems_chain_control *the_chain = fs_info->rhash + i;
4002e414: f9404a93 ldr x19, [x20, #144]
return _Chain_Immutable_head( the_chain )->next;
4002e418: aa1303f7 mov x23, x19
4002e41c: f84086e0 ldr x0, [x23], #8
if ( !_Chain_Is_empty(the_chain))
4002e420: eb0002ff cmp x23, x0
4002e424: 54000120 b.eq 4002e448 <fat_shutdown_drive+0xc8> // b.none <== ALWAYS TAKEN
new_first = old_first->next;
4002e428: f9400001 ldr x1, [x0] <== NOT EXECUTED
head->next = new_first;
4002e42c: f9000261 str x1, [x19] <== NOT EXECUTED
new_first->previous = head;
4002e430: f9000433 str x19, [x1, #8] <== NOT EXECUTED
while ( (node = rtems_chain_get_unprotected(the_chain)) != NULL )
free(node);
4002e434: 97ffce53 bl 40021d80 <free> <== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
4002e438: f9400260 ldr x0, [x19] <== NOT EXECUTED
if ( !_Chain_Is_empty(the_chain))
4002e43c: eb17001f cmp x0, x23 <== NOT EXECUTED
4002e440: 54ffff41 b.ne 4002e428 <fat_shutdown_drive+0xa8> // b.any <== NOT EXECUTED
rtems_chain_control *the_chain = fs_info->rhash + i;
4002e444: f9404a93 ldr x19, [x20, #144] <== NOT EXECUTED
return &the_chain->Tail.Node;
4002e448: 91008277 add x23, x19, #0x20
return _Chain_Immutable_head( the_chain )->next;
4002e44c: f9400e60 ldr x0, [x19, #24]
4002e450: 91006273 add x19, x19, #0x18
if ( !_Chain_Is_empty(the_chain))
4002e454: eb0002ff cmp x23, x0
4002e458: 54000120 b.eq 4002e47c <fat_shutdown_drive+0xfc> // b.none <== ALWAYS TAKEN
4002e45c: d503201f nop
new_first = old_first->next;
4002e460: f9400001 ldr x1, [x0] <== NOT EXECUTED
head->next = new_first;
4002e464: f9000261 str x1, [x19] <== NOT EXECUTED
new_first->previous = head;
4002e468: f9000433 str x19, [x1, #8] <== NOT EXECUTED
free(node);
4002e46c: 97ffce45 bl 40021d80 <free> <== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
4002e470: f9400260 ldr x0, [x19] <== NOT EXECUTED
if ( !_Chain_Is_empty(the_chain))
4002e474: eb0002ff cmp x23, x0 <== NOT EXECUTED
4002e478: 54ffff41 b.ne 4002e460 <fat_shutdown_drive+0xe0> // b.any <== NOT EXECUTED
}
free(fs_info->vhash);
4002e47c: f9404680 ldr x0, [x20, #136]
4002e480: 97ffce40 bl 40021d80 <free>
free(fs_info->rhash);
4002e484: f9404a80 ldr x0, [x20, #144]
4002e488: 97ffce3e bl 40021d80 <free>
free(fs_info->uino);
4002e48c: f9404e80 ldr x0, [x20, #152]
4002e490: 97ffce3c bl 40021d80 <free>
free(fs_info->sec_buf);
4002e494: f9406280 ldr x0, [x20, #192]
4002e498: 97ffce3a bl 40021d80 <free>
close(fs_info->vol.fd);
4002e49c: b9406a80 ldr w0, [x20, #104]
4002e4a0: 97ffcdc0 bl 40021ba0 <close>
if (rc)
4002e4a4: 350000f5 cbnz w21, 4002e4c0 <fat_shutdown_drive+0x140> <== NEVER TAKEN
errno = EIO;
return rc;
}
4002e4a8: 2a1603e0 mov w0, w22
4002e4ac: a94153f3 ldp x19, x20, [sp, #16]
4002e4b0: a9425bf5 ldp x21, x22, [sp, #32]
4002e4b4: f9401bf7 ldr x23, [sp, #48]
4002e4b8: a8c47bfd ldp x29, x30, [sp], #64
4002e4bc: d65f03c0 ret
errno = EIO;
4002e4c0: 9400312b bl 4003a96c <__errno> <== NOT EXECUTED
4002e4c4: 528000a1 mov w1, #0x5 // #5 <== NOT EXECUTED
4002e4c8: b9000001 str w1, [x0] <== NOT EXECUTED
}
4002e4cc: 2a1603e0 mov w0, w22 <== NOT EXECUTED
4002e4d0: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
4002e4d4: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
4002e4d8: f9401bf7 ldr x23, [sp, #48] <== NOT EXECUTED
4002e4dc: a8c47bfd ldp x29, x30, [sp], #64 <== NOT EXECUTED
4002e4e0: d65f03c0 ret <== NOT EXECUTED
...
000000004002e290 <fat_sync>:
return RC_OK;
}
int
fat_sync(fat_fs_info_t *fs_info)
{
4002e290: a9bc7bfd stp x29, x30, [sp, #-64]!
4002e294: 910003fd mov x29, sp
4002e298: a90153f3 stp x19, x20, [sp, #16]
4002e29c: aa0003f3 mov x19, x0
return RC_OK;
4002e2a0: 52800014 mov w20, #0x0 // #0
if (fs_info->vol.type == FAT_FAT32)
4002e2a4: 39405803 ldrb w3, [x0, #22]
4002e2a8: 7100107f cmp w3, #0x4
4002e2ac: 540001a0 b.eq 4002e2e0 <fat_sync+0x50> // b.none
if (fs_info->c.state == FAT_CACHE_EMPTY)
4002e2b0: 3942d660 ldrb w0, [x19, #181]
4002e2b4: 34000060 cbz w0, 4002e2c0 <fat_sync+0x30>
4002e2b8: aa1303e0 mov x0, x19
4002e2bc: 97fffc51 bl 4002d400 <fat_buf_release.part.0>
if ( rc != RC_OK )
rc = -1;
fat_buf_release(fs_info);
if (rtems_bdbuf_syncdev(fs_info->vol.dd) != RTEMS_SUCCESSFUL)
4002e2c0: f9403a60 ldr x0, [x19, #112]
4002e2c4: 940020c3 bl 400365d0 <rtems_bdbuf_syncdev>
rc = -1;
4002e2c8: 7100001f cmp w0, #0x0
4002e2cc: 5a9f0294 csinv w20, w20, wzr, eq // eq = none
return rc;
}
4002e2d0: 2a1403e0 mov w0, w20
4002e2d4: a94153f3 ldp x19, x20, [sp, #16]
4002e2d8: a8c47bfd ldp x29, x30, [sp], #64
4002e2dc: d65f03c0 ret
if (free_count != fs_info->vol.free_cls_in_fs_info)
4002e2e0: 29498405 ldp w5, w1, [x0, #76]
4002e2e4: a9025bf5 stp x21, x22, [sp, #32]
uint32_t next_free = fs_info->vol.next_cl;
4002e2e8: b9405415 ldr w21, [x0, #84]
if (free_count != fs_info->vol.free_cls_in_fs_info)
4002e2ec: 6b0100bf cmp w5, w1
4002e2f0: 54000261 b.ne 4002e33c <fat_sync+0xac> // b.any <== NEVER TAKEN
if (next_free != fs_info->vol.next_cl_in_fs_info)
4002e2f4: b9405800 ldr w0, [x0, #88]
4002e2f8: 6b0002bf cmp w21, w0
4002e2fc: 540003a0 b.eq 4002e370 <fat_sync+0xe0> // b.none
4002e300: 9100f3f6 add x22, sp, #0x3c
4002e304: 52800014 mov w20, #0x0 // #0
ret2 = fat_sector_write(fs_info,
4002e308: 79409261 ldrh w1, [x19, #72]
4002e30c: aa1603e4 mov x4, x22
fs_info->vol.next_cl_in_fs_info = next_free;
4002e310: b9005a75 str w21, [x19, #88]
ret2 = fat_sector_write(fs_info,
4002e314: aa1303e0 mov x0, x19
4002e318: 52800083 mov w3, #0x4 // #4
4002e31c: 52803d82 mov w2, #0x1ec // #492
uint32_t le_next_free = CT_LE_L(next_free);
4002e320: b9003ff5 str w21, [sp, #60]
ret2 = fat_sector_write(fs_info,
4002e324: 97fffd2b bl 4002d7d0 <fat_sector_write>
if ( (ret1 < 0) || (ret2 < 0) )
4002e328: d37ffc00 lsr x0, x0, #63
4002e32c: 2a000294 orr w20, w20, w0
4002e330: 4b1403f4 neg w20, w20
4002e334: a9425bf5 ldp x21, x22, [sp, #32]
4002e338: 17ffffde b 4002e2b0 <fat_sync+0x20>
ret1 = fat_sector_write(fs_info,
4002e33c: 79409001 ldrh w1, [x0, #72] <== NOT EXECUTED
4002e340: 9100f3f6 add x22, sp, #0x3c <== NOT EXECUTED
fs_info->vol.free_cls_in_fs_info = free_count;
4002e344: b9005005 str w5, [x0, #80] <== NOT EXECUTED
ret1 = fat_sector_write(fs_info,
4002e348: aa1603e4 mov x4, x22 <== NOT EXECUTED
4002e34c: 52803d02 mov w2, #0x1e8 // #488 <== NOT EXECUTED
uint32_t le_free_count = CT_LE_L(free_count);
4002e350: b9003fe5 str w5, [sp, #60] <== NOT EXECUTED
ret1 = fat_sector_write(fs_info,
4002e354: 97fffd1f bl 4002d7d0 <fat_sector_write> <== NOT EXECUTED
if ( (ret1 < 0) || (ret2 < 0) )
4002e358: d37ffc14 lsr x20, x0, #63 <== NOT EXECUTED
if (next_free != fs_info->vol.next_cl_in_fs_info)
4002e35c: b9405a61 ldr w1, [x19, #88] <== NOT EXECUTED
if ( (ret1 < 0) || (ret2 < 0) )
4002e360: 12001e94 and w20, w20, #0xff <== NOT EXECUTED
if (next_free != fs_info->vol.next_cl_in_fs_info)
4002e364: 6b0102bf cmp w21, w1 <== NOT EXECUTED
4002e368: 54fffe40 b.eq 4002e330 <fat_sync+0xa0> // b.none <== NOT EXECUTED
4002e36c: 17ffffe7 b 4002e308 <fat_sync+0x78> <== NOT EXECUTED
4002e370: a9425bf5 ldp x21, x22, [sp, #32]
4002e374: 17ffffcf b 4002e2b0 <fat_sync+0x20>
...
0000000040030050 <msdos_creat_node>:
fat_file_type_t type,
const char *name,
int name_len,
mode_t mode,
const fat_file_fd_t *link_fd)
{
40030050: a9b07bfd stp x29, x30, [sp, #-256]!
fat_dir_pos_init(&dir_pos);
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memset(dot_dotdot, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2);
if (name_len > MSDOS_NAME_MAX_LFN_WITH_DOT) {
40030054: 7104107f cmp w3, #0x104
{
40030058: 910003fd mov x29, sp
4003005c: a90153f3 stp x19, x20, [sp, #16]
40030060: aa0003f4 mov x20, x0
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
40030064: 12800013 mov w19, #0xffffffff // #-1
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
40030068: f9401400 ldr x0, [x0, #40]
{
4003006c: a9025bf5 stp x21, x22, [sp, #32]
40030070: a90363f7 stp x23, x24, [sp, #48]
uint16_t time_val = 0;
40030074: 7900cbff strh wzr, [sp, #100]
uint16_t date = 0;
40030078: 7900cfff strh wzr, [sp, #102]
fat_file_fd_t *fat_fd = NULL;
4003007c: f90037ff str xzr, [sp, #104]
dir_pos->sname.ofs = 0;
40030080: 290e7fff stp wzr, wzr, [sp, #112]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
40030084: 290f4ff3 stp w19, w19, [sp, #120]
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
40030088: f9400817 ldr x23, [x0, #16]
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
4003008c: a9087fff stp xzr, xzr, [sp, #128]
40030090: a9097fff stp xzr, xzr, [sp, #144]
memset(dot_dotdot, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2);
40030094: a90c7fff stp xzr, xzr, [sp, #192]
40030098: a90d7fff stp xzr, xzr, [sp, #208]
4003009c: a90e7fff stp xzr, xzr, [sp, #224]
400300a0: a90f7fff stp xzr, xzr, [sp, #240]
fat_file_fd_t *parent_fat_fd = parent_loc->node_access;
400300a4: f9400a96 ldr x22, [x20, #16]
if (name_len > MSDOS_NAME_MAX_LFN_WITH_DOT) {
400300a8: 540019cc b.gt 400303e0 <msdos_creat_node+0x390> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one(ENAMETOOLONG);
}
name_type = msdos_long_to_short (fs_info->converter,
400300ac: f94086e0 ldr x0, [x23, #264]
400300b0: a9046bf9 stp x25, x26, [sp, #64]
400300b4: 2a0303fa mov w26, w3
400300b8: a90573fb stp x27, x28, [sp, #80]
400300bc: aa0203fb mov x27, x2
400300c0: 2a0103f8 mov w24, w1
400300c4: aa0503f9 mov x25, x5
400300c8: 910203e3 add x3, sp, #0x80
400300cc: 2a1a03e2 mov w2, w26
400300d0: aa1b03e1 mov x1, x27
400300d4: 52800164 mov w4, #0xb // #11
400300d8: 940001ca bl 40030800 <msdos_long_to_short>
400300dc: 2a0003fc mov w28, w0
name, name_len,
MSDOS_DIR_NAME(short_node),
MSDOS_NAME_MAX);
if (name_type == MSDOS_NAME_INVALID) {
400300e0: 34001880 cbz w0, 400303f0 <msdos_creat_node+0x3a0> <== NEVER TAKEN
/* fill reserved field */
*MSDOS_DIR_NT_RES(short_node) = MSDOS_RES_NT_VALUE;
/* set up last write date and time */
now = time(NULL);
400300e4: d2800000 mov x0, #0x0 // #0
*MSDOS_DIR_NT_RES(short_node) = MSDOS_RES_NT_VALUE;
400300e8: 390233ff strb wzr, [sp, #140]
now = time(NULL);
400300ec: 94003e5f bl 4003fa68 <time>
}
static inline void fat_file_set_ctime_mtime(fat_file_fd_t *fat_fd, time_t t)
{
fat_fd->ctime = t;
fat_fd->mtime = t;
400300f0: a90482c0 stp x0, x0, [x22, #72]
fat_fd->flags |= FAT_FILE_META_DATA_CHANGED;
400300f4: 3940e2c6 ldrb w6, [x22, #56]
400300f8: aa0003f5 mov x21, x0
fat_file_set_ctime_mtime(parent_fat_fd, now);
msdos_date_unix2dos(now, &date, &time_val);
400300fc: 910193e2 add x2, sp, #0x64
40030100: 321f00c6 orr w6, w6, #0x2
40030104: 3900e2c6 strb w6, [x22, #56]
40030108: 91019be1 add x1, sp, #0x66
4003010c: 94001aed bl 40036cc0 <msdos_date_unix2dos>
*MSDOS_DIR_WRITE_TIME(short_node) = CT_LE_W(time_val);
*MSDOS_DIR_WRITE_DATE(short_node) = CT_LE_W(date);
*MSDOS_DIR_LAST_ACCESS_DATE(short_node) = CT_LE_W(date);
/* initialize directory/file size */
*MSDOS_DIR_FILE_SIZE(short_node) = MSDOS_INIT_DIR_SIZE;
40030110: b9009fff str wzr, [sp, #156]
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
40030114: 7940cfe6 ldrh w6, [sp, #102]
*MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);
40030118: 7940cbe5 ldrh w5, [sp, #100]
4003011c: 79011fe5 strh w5, [sp, #142]
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
40030120: 790123e6 strh w6, [sp, #144]
*MSDOS_DIR_LAST_ACCESS_DATE(short_node) = CT_LE_W(date);
40030124: 790127e6 strh w6, [sp, #146]
*MSDOS_DIR_WRITE_TIME(short_node) = CT_LE_W(time_val);
40030128: 79012fe5 strh w5, [sp, #150]
*MSDOS_DIR_WRITE_DATE(short_node) = CT_LE_W(date);
4003012c: 790133e6 strh w6, [sp, #152]
if (type == FAT_DIRECTORY) {
40030130: 340002f8 cbz w24, 4003018c <msdos_creat_node+0x13c>
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_DIRECTORY;
}
else if (type == FAT_HARD_LINK) {
40030134: 71000b1f cmp w24, #0x2
40030138: 54000f00 b.eq 40030318 <msdos_creat_node+0x2c8> // b.none <== NEVER TAKEN
* 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;
4003013c: 39422fe0 ldrb w0, [sp, #139]
40030140: 321b0000 orr w0, w0, #0x20
40030144: 39022fe0 strb w0, [sp, #139]
/*
* 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,
40030148: 2a1c03e4 mov w4, w28
4003014c: 2a1a03e3 mov w3, w26
40030150: aa1b03e2 mov x2, x27
40030154: 910203e6 add x6, sp, #0x80
40030158: aa1403e0 mov x0, x20
4003015c: 9101c3e5 add x5, sp, #0x70
40030160: 52800021 mov w1, #0x1 // #1
40030164: 9400078f bl 40031fa0 <msdos_get_name_node>
40030168: a9446bf9 ldp x25, x26, [sp, #64]
4003016c: 2a0003f3 mov w19, w0
40030170: a94573fb ldp x27, x28, [sp, #80]
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;
}
40030174: 2a1303e0 mov w0, w19
40030178: a94153f3 ldp x19, x20, [sp, #16]
4003017c: a9425bf5 ldp x21, x22, [sp, #32]
40030180: a94363f7 ldp x23, x24, [sp, #48]
40030184: a8d07bfd ldp x29, x30, [sp], #256
40030188: d65f03c0 ret
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_DIRECTORY;
4003018c: 39422fe7 ldrb w7, [sp, #139]
rc = msdos_get_name_node(parent_loc, true, name, name_len,
40030190: 910203e6 add x6, sp, #0x80
40030194: 2a1c03e4 mov w4, w28
40030198: 2a1a03e3 mov w3, w26
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_DIRECTORY;
4003019c: 321c00e7 orr w7, w7, #0x10
rc = msdos_get_name_node(parent_loc, true, name, name_len,
400301a0: aa1b03e2 mov x2, x27
400301a4: 9101c3e5 add x5, sp, #0x70
400301a8: aa1403e0 mov x0, x20
400301ac: 52800021 mov w1, #0x1 // #1
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_DIRECTORY;
400301b0: 39022fe7 strb w7, [sp, #139]
rc = msdos_get_name_node(parent_loc, true, name, name_len,
400301b4: 9400077b bl 40031fa0 <msdos_get_name_node>
400301b8: 2a0003f3 mov w19, w0
if ( rc != RC_OK )
400301bc: 34000120 cbz w0, 400301e0 <msdos_creat_node+0x190> <== ALWAYS TAKEN
}
400301c0: 2a1303e0 mov w0, w19 <== NOT EXECUTED
400301c4: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
400301c8: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
400301cc: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
400301d0: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
400301d4: a94573fb ldp x27, x28, [sp, #80] <== NOT EXECUTED
400301d8: a8d07bfd ldp x29, x30, [sp], #256 <== NOT EXECUTED
400301dc: d65f03c0 ret <== NOT EXECUTED
rc = fat_file_open(&fs_info->fat, &dir_pos, &fat_fd);
400301e0: 9101a3e2 add x2, sp, #0x68
400301e4: 9101c3e1 add x1, sp, #0x70
400301e8: aa1703e0 mov x0, x23
400301ec: 97fffb75 bl 4002efc0 <fat_file_open>
400301f0: 2a0003f3 mov w19, w0
if (rc != RC_OK)
400301f4: 340001a0 cbz w0, 40030228 <msdos_creat_node+0x1d8> <== ALWAYS TAKEN
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
400301f8: f9401680 ldr x0, [x20, #40] <== NOT EXECUTED
400301fc: 9101c3e1 add x1, sp, #0x70 <== NOT EXECUTED
40030200: 12800342 mov w2, #0xffffffe5 // #-27 <== NOT EXECUTED
40030204: 940002cf bl 40030d40 <msdos_set_first_char4file_name> <== NOT EXECUTED
}
40030208: 2a1303e0 mov w0, w19 <== NOT EXECUTED
4003020c: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40030210: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
40030214: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
return rc;
40030218: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
4003021c: a94573fb ldp x27, x28, [sp, #80] <== NOT EXECUTED
}
40030220: a8d07bfd ldp x29, x30, [sp], #256 <== NOT EXECUTED
40030224: d65f03c0 ret <== NOT EXECUTED
fat_fd->fat_file_type = FAT_DIRECTORY;
40030228: f94037e1 ldr x1, [sp, #104]
4003022c: d2e00405 mov x5, #0x20000000000000 // #9007199254740992
rc = fat_file_extend(&fs_info->fat,
40030230: 910283e4 add x4, sp, #0xa0
40030234: aa1703e0 mov x0, x23
40030238: 52800022 mov w2, #0x1 // #1
4003023c: 3940e023 ldrb w3, [x1, #56]
fat_fd->fat_file_type = FAT_DIRECTORY;
40030240: f9000c25 str x5, [x1, #24]
40030244: 321f0063 orr w3, w3, #0x2
40030248: 3900e023 strb w3, [x1, #56]
fat_fd->ctime = t;
4003024c: f9002435 str x21, [x1, #72]
rc = fat_file_extend(&fs_info->fat,
40030250: b9400ae3 ldr w3, [x23, #8]
fat_fd->mtime = t;
40030254: f9002835 str x21, [x1, #80]
40030258: 97fffd7e bl 4002f850 <fat_file_extend>
4003025c: 2a0003f3 mov w19, w0
if (rc != RC_OK)
40030260: 35fffcc0 cbnz w0, 400301f8 <msdos_creat_node+0x1a8> <== NEVER TAKEN
memcpy(MSDOS_DIR_NAME(DOT_NODE_P(dot_dotdot)), MSDOS_DOT_NAME,
40030264: b00000c1 adrp x1, 40049000 <IMFS_node_control_sym_link+0xe0>
40030268: d2800162 mov x2, #0xb // #11
memcpy(DOT_NODE_P(dot_dotdot), short_node,
4003026c: a9481fe6 ldp x6, x7, [sp, #128]
memcpy(MSDOS_DIR_NAME(DOT_NODE_P(dot_dotdot)), MSDOS_DOT_NAME,
40030270: 910303e0 add x0, sp, #0xc0
memcpy(DOT_NODE_P(dot_dotdot), short_node,
40030274: a94917e4 ldp x4, x5, [sp, #144]
40030278: a90c1fe6 stp x6, x7, [sp, #192]
memcpy(MSDOS_DIR_NAME(DOT_NODE_P(dot_dotdot)), MSDOS_DOT_NAME,
4003027c: f9423421 ldr x1, [x1, #1128]
memcpy(DOT_NODE_P(dot_dotdot), short_node,
40030280: a90d17e4 stp x4, x5, [sp, #208]
memcpy(DOTDOT_NODE_P(dot_dotdot), short_node,
40030284: a90e1fe6 stp x6, x7, [sp, #224]
40030288: a90f17e4 stp x4, x5, [sp, #240]
memcpy(MSDOS_DIR_NAME(DOT_NODE_P(dot_dotdot)), MSDOS_DOT_NAME,
4003028c: 94002c5b bl 4003b3f8 <memcpy>
memcpy(MSDOS_DIR_NAME(DOTDOT_NODE_P(dot_dotdot)), MSDOS_DOTDOT_NAME,
40030290: b00000c1 adrp x1, 40049000 <IMFS_node_control_sym_link+0xe0>
40030294: 910383e0 add x0, sp, #0xe0
40030298: d2800162 mov x2, #0xb // #11
4003029c: f9423021 ldr x1, [x1, #1120]
400302a0: 94002c56 bl 4003b3f8 <memcpy>
if ((FAT_FD_OF_ROOT_DIR(parent_fat_fd)) &&
400302a4: f94016c0 ldr x0, [x22, #40]
400302a8: f100041f cmp x0, #0x1
400302ac: 54000820 b.eq 400303b0 <msdos_creat_node+0x360> // b.none
CT_LE_W((uint16_t )((parent_fat_fd->cln) & 0x0000FFFF));
400302b0: b94026c0 ldr w0, [x22, #36]
400302b4: 7901f7e0 strh w0, [sp, #250]
CT_LE_W((uint16_t )(((parent_fat_fd->cln) & 0xFFFF0000)>>16));
400302b8: 53107c00 lsr w0, w0, #16
400302bc: 7901ebe0 strh w0, [sp, #244]
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
400302c0: f94037e1 ldr x1, [sp, #104]
ret = fat_file_write(&fs_info->fat, fat_fd, 0,
400302c4: 910303e4 add x4, sp, #0xc0
400302c8: aa1703e0 mov x0, x23
400302cc: 52800803 mov w3, #0x40 // #64
400302d0: 52800002 mov w2, #0x0 // #0
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
400302d4: b9402425 ldr w5, [x1, #36]
400302d8: 7901b7e5 strh w5, [sp, #218]
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
400302dc: 53107ca5 lsr w5, w5, #16
400302e0: 7901abe5 strh w5, [sp, #212]
ret = fat_file_write(&fs_info->fat, fat_fd, 0,
400302e4: 97fffe0b bl 4002fb10 <fat_file_write>
if (ret < 0)
400302e8: b7f806e0 tbnz x0, #63, 400303c4 <msdos_creat_node+0x374> <== NEVER TAKEN
rc = fat_file_write_first_cluster_num(&fs_info->fat, fat_fd);
400302ec: f94037e1 ldr x1, [sp, #104]
400302f0: aa1703e0 mov x0, x23
400302f4: 9400023f bl 40030bf0 <fat_file_write_first_cluster_num>
400302f8: 2a0003f3 mov w19, w0
if (rc != RC_OK)
400302fc: 35000660 cbnz w0, 400303c8 <msdos_creat_node+0x378> <== NEVER TAKEN
fat_file_close(&fs_info->fat, fat_fd);
40030300: f94037e1 ldr x1, [sp, #104]
40030304: aa1703e0 mov x0, x23
40030308: 97fffce2 bl 4002f690 <fat_file_close>
4003030c: a9446bf9 ldp x25, x26, [sp, #64]
40030310: a94573fb ldp x27, x28, [sp, #80]
40030314: 17ffff98 b 40030174 <msdos_creat_node+0x124>
sec = fat_cluster_num_to_sector_num(&fs_info->fat,
40030318: b9402b20 ldr w0, [x25, #40] <== NOT EXECUTED
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
4003031c: 35000080 cbnz w0, 4003032c <msdos_creat_node+0x2dc> <== NOT EXECUTED
40030320: 39405ae1 ldrb w1, [x23, #22] <== NOT EXECUTED
40030324: f240043f tst x1, #0x3 <== NOT EXECUTED
40030328: 54000581 b.ne 400303d8 <msdos_creat_node+0x388> // b.any <== NOT EXECUTED
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
4003032c: 394016e2 ldrb w2, [x23, #5] <== NOT EXECUTED
40030330: 51000801 sub w1, w0, #0x2 <== NOT EXECUTED
40030334: b9403ee0 ldr w0, [x23, #60] <== NOT EXECUTED
40030338: 1ac22021 lsl w1, w1, w2 <== NOT EXECUTED
4003033c: 0b000021 add w1, w1, w0 <== NOT EXECUTED
sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
40030340: b9402f25 ldr w5, [x25, #44] <== NOT EXECUTED
ret = _fat_block_read(&fs_info->fat,
40030344: aa1703e0 mov x0, x23 <== NOT EXECUTED
sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
40030348: 39400ae6 ldrb w6, [x23, #2] <== NOT EXECUTED
ret = _fat_block_read(&fs_info->fat,
4003034c: 910283e4 add x4, sp, #0xa0 <== NOT EXECUTED
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
40030350: 794002e2 ldrh w2, [x23] <== NOT EXECUTED
ret = _fat_block_read(&fs_info->fat,
40030354: 52800403 mov w3, #0x20 // #32 <== NOT EXECUTED
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
40030358: 51000442 sub w2, w2, #0x1 <== NOT EXECUTED
ret = _fat_block_read(&fs_info->fat,
4003035c: 0a050042 and w2, w2, w5 <== NOT EXECUTED
sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
40030360: 1ac624a5 lsr w5, w5, w6 <== NOT EXECUTED
ret = _fat_block_read(&fs_info->fat,
40030364: 0b0100a1 add w1, w5, w1 <== NOT EXECUTED
40030368: 97fff4ce bl 4002d6a0 <_fat_block_read> <== NOT EXECUTED
if (ret < 0) {
4003036c: b7f804e0 tbnz x0, #63, 40030408 <msdos_creat_node+0x3b8> <== NOT EXECUTED
*MSDOS_DIR_ATTR(short_node) =*MSDOS_DIR_ATTR(link_node);
40030370: 3942afe0 ldrb w0, [sp, #171] <== NOT EXECUTED
*MSDOS_DIR_CRT_TIME_TENTH(short_node)=*MSDOS_DIR_CRT_TIME_TENTH(link_node);
40030374: 3942b7e6 ldrb w6, [sp, #173] <== NOT EXECUTED
*MSDOS_DIR_CRT_TIME(short_node) =*MSDOS_DIR_CRT_TIME(link_node);
40030378: 79415fe5 ldrh w5, [sp, #174] <== NOT EXECUTED
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
4003037c: 321b0000 orr w0, w0, #0x20 <== NOT EXECUTED
*MSDOS_DIR_CRT_DATE(short_node) =*MSDOS_DIR_CRT_DATE(link_node);
40030380: 794163e4 ldrh w4, [sp, #176] <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_HI(short_node) =
40030384: 79416be3 ldrh w3, [sp, #180] <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_LOW(short_node) =
40030388: 794177e2 ldrh w2, [sp, #186] <== NOT EXECUTED
*MSDOS_DIR_FILE_SIZE(short_node) =*MSDOS_DIR_FILE_SIZE(link_node);
4003038c: b940bfe1 ldr w1, [sp, #188] <== NOT EXECUTED
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
40030390: 39022fe0 strb w0, [sp, #139] <== NOT EXECUTED
*MSDOS_DIR_CRT_TIME_TENTH(short_node)=*MSDOS_DIR_CRT_TIME_TENTH(link_node);
40030394: 390237e6 strb w6, [sp, #141] <== NOT EXECUTED
*MSDOS_DIR_CRT_TIME(short_node) =*MSDOS_DIR_CRT_TIME(link_node);
40030398: 79011fe5 strh w5, [sp, #142] <== NOT EXECUTED
*MSDOS_DIR_CRT_DATE(short_node) =*MSDOS_DIR_CRT_DATE(link_node);
4003039c: 790123e4 strh w4, [sp, #144] <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_HI(short_node) =
400303a0: 79012be3 strh w3, [sp, #148] <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_LOW(short_node) =
400303a4: 790137e2 strh w2, [sp, #154] <== NOT EXECUTED
*MSDOS_DIR_FILE_SIZE(short_node) =*MSDOS_DIR_FILE_SIZE(link_node);
400303a8: b9009fe1 str w1, [sp, #156] <== NOT EXECUTED
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
400303ac: 17ffff67 b 40030148 <msdos_creat_node+0xf8> <== NOT EXECUTED
if ((FAT_FD_OF_ROOT_DIR(parent_fat_fd)) &&
400303b0: 39405ae0 ldrb w0, [x23, #22]
400303b4: 3617f7e0 tbz w0, #2, 400302b0 <msdos_creat_node+0x260> <== ALWAYS TAKEN
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
400303b8: 7901ebff strh wzr, [sp, #244] <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
400303bc: 7901f7ff strh wzr, [sp, #250] <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
400303c0: 17ffffc0 b 400302c0 <msdos_creat_node+0x270> <== NOT EXECUTED
rc = -1;
400303c4: 12800013 mov w19, #0xffffffff // #-1 <== NOT EXECUTED
fat_file_close(&fs_info->fat, fat_fd);
400303c8: f94037e1 ldr x1, [sp, #104] <== NOT EXECUTED
400303cc: aa1703e0 mov x0, x23 <== NOT EXECUTED
400303d0: 97fffcb0 bl 4002f690 <fat_file_close> <== NOT EXECUTED
400303d4: 17ffff89 b 400301f8 <msdos_creat_node+0x1a8> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
400303d8: b9402ae1 ldr w1, [x23, #40] <== NOT EXECUTED
400303dc: 17ffffd9 b 40030340 <msdos_creat_node+0x2f0> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENAMETOOLONG);
400303e0: 94002963 bl 4003a96c <__errno> <== NOT EXECUTED
400303e4: 52800b61 mov w1, #0x5b // #91 <== NOT EXECUTED
400303e8: b9000001 str w1, [x0] <== NOT EXECUTED
400303ec: 17ffff62 b 40030174 <msdos_creat_node+0x124> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EINVAL);
400303f0: 9400295f bl 4003a96c <__errno> <== NOT EXECUTED
400303f4: 528002c1 mov w1, #0x16 // #22 <== NOT EXECUTED
400303f8: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
400303fc: a94573fb ldp x27, x28, [sp, #80] <== NOT EXECUTED
40030400: b9000001 str w1, [x0] <== NOT EXECUTED
40030404: 17ffff5c b 40030174 <msdos_creat_node+0x124> <== NOT EXECUTED
return -1;
40030408: 12800013 mov w19, #0xffffffff // #-1 <== NOT EXECUTED
4003040c: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
40030410: a94573fb ldp x27, x28, [sp, #80] <== NOT EXECUTED
40030414: 17ffff58 b 40030174 <msdos_creat_node+0x124> <== NOT EXECUTED
...
0000000040036e50 <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
40036e50: d3452824 ubfx x4, x1, #5, #6
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
40036e54: d34b3c22 ubfx x2, x1, #11, #5
+ ((dt & MSDOS_DT_MINUTES_MASK) >> MSDOS_DT_MINUTES_SHIFT) * 60
40036e58: 528003c8 mov w8, #0x1e // #30
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
40036e5c: 5280e105 mov w5, #0x708 // #1800
seconds = 2 * ((dt & MSDOS_DT_2SECONDS_MASK) >> MSDOS_DT_2SECONDS_SHIFT)
40036e60: 12001023 and w3, w1, #0x1f
/*
* If the year, month, and day from the last conversion are the
* same then use the saved value.
*/
if (lastdosdate != dd) {
40036e64: b0000666 adrp x6, 40103000 <_Thread_Heads+0x28>
40036e68: 79587cc7 ldrh w7, [x6, #3134]
+ ((dt & MSDOS_DT_MINUTES_MASK) >> MSDOS_DT_MINUTES_SHIFT) * 60
40036e6c: 1b087c81 mul w1, w4, w8
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
40036e70: 1b050441 madd w1, w2, w5, w1
if (lastdosdate != dd) {
40036e74: 6b0000ff cmp w7, w0
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
40036e78: 0b030021 add w1, w1, w3
seconds = 2 * ((dt & MSDOS_DT_2SECONDS_MASK) >> MSDOS_DT_2SECONDS_SHIFT)
40036e7c: 0b010025 add w5, w1, w1
if (lastdosdate != dd) {
40036e80: 540005c0 b.eq 40036f38 <msdos_date_dos2unix+0xe8> // b.none
lastdosdate = dd;
40036e84: 79187cc0 strh w0, [x6, #3134]
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
40036e88: 53097c06 lsr w6, w0, #9
for (y = 0; y < year; y++)
40036e8c: 720018c4 ands w4, w6, #0x7f
days = 0;
40036e90: 52800001 mov w1, #0x0 // #0
for (y = 0; y < year; y++)
40036e94: 52800002 mov w2, #0x0 // #0
days += y & 0x03 ? 365 : 366;
40036e98: 52802dc3 mov w3, #0x16e // #366
for (y = 0; y < year; y++)
40036e9c: 540000a1 b.ne 40036eb0 <msdos_date_dos2unix+0x60> // b.any <== ALWAYS TAKEN
40036ea0: 14000008 b 40036ec0 <msdos_date_dos2unix+0x70> <== NOT EXECUTED
days += y & 0x03 ? 365 : 366;
40036ea4: f240045f tst x2, #0x3
40036ea8: 1a9f17e3 cset w3, eq // eq = none
40036eac: 1105b463 add w3, w3, #0x16d
for (y = 0; y < year; y++)
40036eb0: 11000442 add w2, w2, #0x1
days += y & 0x03 ? 365 : 366;
40036eb4: 0b030021 add w1, w1, w3
for (y = 0; y < year; y++)
40036eb8: 6b02009f cmp w4, w2
40036ebc: 54ffff41 b.ne 40036ea4 <msdos_date_dos2unix+0x54> // b.any
months = year & 0x03 ? regyear : leapyear;
40036ec0: d0000642 adrp x2, 40100000 <_RTEMS_tasks_Information>
40036ec4: 91110043 add x3, x2, #0x440
40036ec8: f24004df tst x6, #0x3
/*
* Prevent going from 0 to 0xffffffff in the following
* loop.
*/
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
40036ecc: 53057c04 lsr w4, w0, #5
months = year & 0x03 ? regyear : leapyear;
40036ed0: d0000642 adrp x2, 40100000 <_RTEMS_tasks_Information>
40036ed4: 91116042 add x2, x2, #0x458
40036ed8: 9a831042 csel x2, x2, x3, ne // ne = any
if (month == 0) {
40036edc: 72000c83 ands w3, w4, #0xf
40036ee0: 1a9f1463 csinc w3, w3, wzr, ne // ne = any
month = 1;
}
for (m = 0; m < month - 1; m++)
40036ee4: 721f089f tst w4, #0xe
40036ee8: 54000100 b.eq 40036f08 <msdos_date_dos2unix+0xb8> // b.none
40036eec: 51000463 sub w3, w3, #0x1
40036ef0: 8b234444 add x4, x2, w3, uxtw #1
40036ef4: d503201f nop
days += months[m];
40036ef8: 78402443 ldrh w3, [x2], #2
40036efc: 0b030021 add w1, w1, w3
for (m = 0; m < month - 1; m++)
40036f00: eb02009f cmp x4, x2
40036f04: 54ffffa1 b.ne 40036ef8 <msdos_date_dos2unix+0xa8> // b.any <== NEVER TAKEN
days += ((dd & MSDOS_DD_DAY_MASK) >> MSDOS_DD_DAY_SHIFT) - 1;
40036f08: 12001002 and w2, w0, #0x1f
lastseconds = (days + DAYSTO1980) * SECONDSPERDAY;
40036f0c: 528a3004 mov w4, #0x5180 // #20864
40036f10: 72a00024 movk w4, #0x1, lsl #16
days += ((dd & MSDOS_DD_DAY_MASK) >> MSDOS_DD_DAY_SHIFT) - 1;
40036f14: 51000442 sub w2, w2, #0x1
40036f18: 0b010041 add w1, w2, w1
lastseconds = (days + DAYSTO1980) * SECONDSPERDAY;
40036f1c: 5294c003 mov w3, #0xa600 // #42496
40036f20: 72a259c3 movk w3, #0x12ce, lsl #16
40036f24: b0000660 adrp x0, 40103000 <_Thread_Heads+0x28>
40036f28: 1b040c21 madd w1, w1, w4, w3
40036f2c: b90c4401 str w1, [x0, #3140]
}
return seconds + lastseconds;
}
40036f30: 0b0100a0 add w0, w5, w1
40036f34: d65f03c0 ret
return seconds + lastseconds;
40036f38: b0000660 adrp x0, 40103000 <_Thread_Heads+0x28>
40036f3c: b94c4401 ldr w1, [x0, #3140]
}
40036f40: 0b0100a0 add w0, w5, w1
40036f44: d65f03c0 ret
...
0000000040036cc0 <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) {
40036cc0: b0000668 adrp x8, 40103000 <_Thread_Heads+0x28>
40036cc4: b94c4903 ldr w3, [x8, #3144]
40036cc8: 6b00007f cmp w3, w0
40036ccc: 54000980 b.eq 40036dfc <msdos_date_unix2dos+0x13c> // b.none
lasttime = t;
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
40036cd0: 529678a7 mov w7, #0xb3c5 // #46021
40036cd4: 72b23447 movk w7, #0x91a2, lsl #16
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
40036cd8: 52911124 mov w4, #0x8889 // #34953
40036cdc: 72b11104 movk w4, #0x8888, lsl #16
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
40036ce0: 9ba77c07 umull x7, w0, w7
lasttime = t;
40036ce4: b90c4900 str w0, [x8, #3144]
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
40036ce8: 9ba47c05 umull x5, w0, w4
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
40036cec: 52955566 mov w6, #0xaaab // #43691
40036cf0: 72b55546 movk w6, #0xaaaa, lsl #16
40036cf4: 5280030c mov w12, #0x18 // #24
40036cf8: d36bfce7 lsr x7, x7, #43
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
40036cfc: 52800789 mov w9, #0x3c // #60
40036d00: d365fca8 lsr x8, x5, #37
/*
* 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);
40036d04: 5288a0e3 mov w3, #0x4507 // #17671
40036d08: 72b845c3 movk w3, #0xc22e, lsl #16
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
40036d0c: b000066b adrp x11, 40103000 <_Thread_Heads+0x28>
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
40036d10: 9ba67ce6 umull x6, w7, w6
if (days != lastday) {
40036d14: b000066a adrp x10, 40103000 <_Thread_Heads+0x28>
40036d18: b94c394d ldr w13, [x10, #3128]
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
40036d1c: 9ba47d05 umull x5, w8, w4
days = t / (SECONDSPERDAY);
40036d20: 9ba37c03 umull x3, w0, w3
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
40036d24: d364fcc4 lsr x4, x6, #36
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
40036d28: 1b098100 msub w0, w8, w9, w0
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
40036d2c: d365fca5 lsr x5, x5, #37
days = t / (SECONDSPERDAY);
40036d30: d370fc63 lsr x3, x3, #48
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
40036d34: 1b0c9c84 msub w4, w4, w12, w7
if (days != lastday) {
40036d38: 6b0301bf cmp w13, w3
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
40036d3c: 1b09a0a5 msub w5, w5, w9, w8
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
40036d40: 53155084 lsl w4, w4, #11
40036d44: 0b051485 add w5, w4, w5, lsl #5
40036d48: 0b4004a5 add w5, w5, w0, lsr #1
40036d4c: 12003ca5 and w5, w5, #0xffff
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
40036d50: 79188165 strh w5, [x11, #3136]
if (days != lastday) {
40036d54: 540004a0 b.eq 40036de8 <msdos_date_unix2dos+0x128> // b.none
lastday = days;
40036d58: b90c3943 str w3, [x10, #3128]
for (year = 1970;; year++) {
40036d5c: 5280f644 mov w4, #0x7b2 // #1970
40036d60: 14000003 b 40036d6c <msdos_date_unix2dos+0xac>
inc = year & 0x03 ? 365 : 366;
if (days < inc)
break;
days -= inc;
40036d64: 4b000063 sub w3, w3, w0
for (year = 1970;; year++) {
40036d68: 11000484 add w4, w4, #0x1
inc = year & 0x03 ? 365 : 366;
40036d6c: 72000486 ands w6, w4, #0x3
40036d70: 1a9f17e0 cset w0, eq // eq = none
40036d74: 1105b400 add w0, w0, #0x16d
if (days < inc)
40036d78: 6b00007f cmp w3, w0
40036d7c: 54ffff42 b.cs 40036d64 <msdos_date_unix2dos+0xa4> // b.hs, b.nlast
}
months = year & 0x03 ? regyear : leapyear;
40036d80: 710000df cmp w6, #0x0
40036d84: d0000647 adrp x7, 40100000 <_RTEMS_tasks_Information>
40036d88: 911100e6 add x6, x7, #0x440
40036d8c: d0000647 adrp x7, 40100000 <_RTEMS_tasks_Information>
40036d90: 911160e7 add x7, x7, #0x458
40036d94: d2800000 mov x0, #0x0 // #0
40036d98: 9a8610e7 csel x7, x7, x6, ne // ne = any
for (month = 0; month < 12; month++) {
40036d9c: d503201f nop
if (days < months[month])
40036da0: 786078e6 ldrh w6, [x7, x0, lsl #1]
40036da4: 6b0300df cmp w6, w3
40036da8: 54000488 b.hi 40036e38 <msdos_date_unix2dos+0x178> // b.pmore <== ALWAYS TAKEN
for (month = 0; month < 12; month++) {
40036dac: 91000400 add x0, x0, #0x1 <== NOT EXECUTED
break;
days -= months[month];
40036db0: 4b060063 sub w3, w3, w6 <== NOT EXECUTED
for (month = 0; month < 12; month++) {
40036db4: f100301f cmp x0, #0xc <== NOT EXECUTED
40036db8: 54ffff41 b.ne 40036da0 <msdos_date_unix2dos+0xe0> // b.any <== NOT EXECUTED
40036dbc: 52803400 mov w0, #0x1a0 // #416 <== NOT EXECUTED
}
lastddate = ((days + 1) << MSDOS_DD_DAY_SHIFT)
+ ((month + 1) << MSDOS_DD_MONTH_SHIFT);
40036dc0: 11000400 add w0, w0, #0x1
* Remember dos's idea of time is relative to 1980.
* unix's is relative to 1970. If somehow we get a
* time before 1980 then don't give totally crazy
* results.
*/
if (year > 1980)
40036dc4: 711ef09f cmp w4, #0x7bc
+ ((month + 1) << MSDOS_DD_MONTH_SHIFT);
40036dc8: 0b030003 add w3, w0, w3
40036dcc: 12003c63 and w3, w3, #0xffff
if (year > 1980)
40036dd0: 54000248 b.hi 40036e18 <msdos_date_unix2dos+0x158> // b.pmore <== ALWAYS TAKEN
lastddate = ((days + 1) << MSDOS_DD_DAY_SHIFT)
40036dd4: b0000660 adrp x0, 40103000 <_Thread_Heads+0x28> <== NOT EXECUTED
lastddate += (year - 1980) <<
MSDOS_DD_YEAR_SHIFT;
}
}
*dtp = lastdtime;
40036dd8: 79000045 strh w5, [x2] <== NOT EXECUTED
*ddp = lastddate;
40036ddc: 79000023 strh w3, [x1] <== NOT EXECUTED
lastddate = ((days + 1) << MSDOS_DD_DAY_SHIFT)
40036de0: 79187803 strh w3, [x0, #3132] <== NOT EXECUTED
}
40036de4: d65f03c0 ret <== NOT EXECUTED
*ddp = lastddate;
40036de8: b0000660 adrp x0, 40103000 <_Thread_Heads+0x28>
40036dec: 79587803 ldrh w3, [x0, #3132]
*dtp = lastdtime;
40036df0: 79000045 strh w5, [x2]
*ddp = lastddate;
40036df4: 79000023 strh w3, [x1]
}
40036df8: d65f03c0 ret
*dtp = lastdtime;
40036dfc: b0000660 adrp x0, 40103000 <_Thread_Heads+0x28>
40036e00: 79588005 ldrh w5, [x0, #3136]
*ddp = lastddate;
40036e04: b0000660 adrp x0, 40103000 <_Thread_Heads+0x28>
40036e08: 79587803 ldrh w3, [x0, #3132]
*dtp = lastdtime;
40036e0c: 79000045 strh w5, [x2]
*ddp = lastddate;
40036e10: 79000023 strh w3, [x1]
}
40036e14: d65f03c0 ret
lastddate += (year - 1980) <<
40036e18: 511ef084 sub w4, w4, #0x7bc
40036e1c: b0000660 adrp x0, 40103000 <_Thread_Heads+0x28>
*dtp = lastdtime;
40036e20: 79000045 strh w5, [x2]
lastddate += (year - 1980) <<
40036e24: 0b042463 add w3, w3, w4, lsl #9
40036e28: 12003c63 and w3, w3, #0xffff
40036e2c: 79187803 strh w3, [x0, #3132]
*ddp = lastddate;
40036e30: 79000023 strh w3, [x1]
}
40036e34: d65f03c0 ret
+ ((month + 1) << MSDOS_DD_MONTH_SHIFT);
40036e38: 11000400 add w0, w0, #0x1
40036e3c: 531b2800 ubfiz w0, w0, #5, #11
40036e40: 17ffffe0 b 40036dc0 <msdos_date_unix2dos+0x100>
...
0000000040030e90 <msdos_dir_is_empty>:
{
40030e90: a9b97bfd stp x29, x30, [sp, #-112]!
40030e94: 910003fd mov x29, sp
40030e98: a9025bf5 stp x21, x22, [sp, #32]
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
40030e9c: b00000d6 adrp x22, 40049000 <IMFS_node_control_sym_link+0xe0>
40030ea0: 910fa2d6 add x22, x22, #0x3e8
msdos_fs_info_t *fs_info = mt_entry->fs_info;
40030ea4: f9400815 ldr x21, [x0, #16]
{
40030ea8: a90153f3 stp x19, x20, [sp, #16]
40030eac: a90573fb stp x27, x28, [sp, #80]
while ((ret = fat_file_read(&fs_info->fat, fat_fd, j * fs_info->fat.vol.bps,
40030eb0: 794002bc ldrh w28, [x21]
40030eb4: f94082b4 ldr x20, [x21, #256]
{
40030eb8: a90363f7 stp x23, x24, [sp, #48]
(strncmp(MSDOS_DIR_NAME((entry)),
40030ebc: b00000d7 adrp x23, 40049000 <IMFS_node_control_sym_link+0xe0>
40030ec0: 910fe2f7 add x23, x23, #0x3f8
{
40030ec4: a9046bf9 stp x25, x26, [sp, #64]
40030ec8: aa0103f9 mov x25, x1
uint32_t j = 0, i = 0;
40030ecc: 5280001a mov w26, #0x0 // #0
*ret_val = false;
40030ed0: 3900005f strb wzr, [x2]
{
40030ed4: f90037e2 str x2, [sp, #104]
while ((ret = fat_file_read(&fs_info->fat, fat_fd, j * fs_info->fat.vol.bps,
40030ed8: 1b1a7f82 mul w2, w28, w26
40030edc: aa1403e4 mov x4, x20
40030ee0: 2a1c03e3 mov w3, w28
40030ee4: aa1903e1 mov x1, x25
40030ee8: aa1503e0 mov x0, x21
40030eec: 97fff915 bl 4002f340 <fat_file_read>
40030ef0: b4000520 cbz x0, 40030f94 <msdos_dir_is_empty+0x104> <== NEVER TAKEN
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
40030ef4: f1007c1f cmp x0, #0x1f
40030ef8: 5400064d b.le 40030fc0 <msdos_dir_is_empty+0x130> <== NEVER TAKEN
assert(ret == fs_info->fat.vol.bps);
40030efc: 794002bc ldrh w28, [x21]
40030f00: eb3c201f cmp x0, w28, uxth
40030f04: 54000621 b.ne 40030fc8 <msdos_dir_is_empty+0x138> // b.any <== NEVER TAKEN
for (i = 0;
40030f08: 52800013 mov w19, #0x0 // #0
char* entry = (char*) fs_info->cl_buf + i;
40030f0c: f94082b4 ldr x20, [x21, #256]
for (i = 0;
40030f10: 340003fc cbz w28, 40030f8c <msdos_dir_is_empty+0xfc> <== NEVER TAKEN
if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
40030f14: 38734a98 ldrb w24, [x20, w19, uxtw]
char* entry = (char*) fs_info->cl_buf + i;
40030f18: 8b33429b add x27, x20, w19, uxtw
if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
40030f1c: 7103971f cmp w24, #0xe5
40030f20: 54000300 b.eq 40030f80 <msdos_dir_is_empty+0xf0> // b.none
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
40030f24: 39402f60 ldrb w0, [x27, #11]
40030f28: 12001400 and w0, w0, #0x3f
40030f2c: 71003c1f cmp w0, #0xf
40030f30: 54000280 b.eq 40030f80 <msdos_dir_is_empty+0xf0> // b.none
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
40030f34: aa1603e1 mov x1, x22
40030f38: aa1b03e0 mov x0, x27
40030f3c: d2800162 mov x2, #0xb // #11
40030f40: 94002dcc bl 4003c670 <strncmp>
MSDOS_ATTR_LFN) ||
40030f44: 340001e0 cbz w0, 40030f80 <msdos_dir_is_empty+0xf0>
(strncmp(MSDOS_DIR_NAME((entry)),
40030f48: aa1b03e0 mov x0, x27
40030f4c: aa1703e1 mov x1, x23
40030f50: d2800162 mov x2, #0xb // #11
40030f54: 94002dc7 bl 4003c670 <strncmp>
MSDOS_SHORT_NAME_LEN) == 0) ||
40030f58: 34000140 cbz w0, 40030f80 <msdos_dir_is_empty+0xf0>
return RC_OK;
40030f5c: 52800000 mov w0, #0x0 // #0
if ((*MSDOS_DIR_NAME(entry)) ==
40030f60: 340001b8 cbz w24, 40030f94 <msdos_dir_is_empty+0x104>
}
40030f64: a94153f3 ldp x19, x20, [sp, #16]
40030f68: a9425bf5 ldp x21, x22, [sp, #32]
40030f6c: a94363f7 ldp x23, x24, [sp, #48]
40030f70: a9446bf9 ldp x25, x26, [sp, #64]
40030f74: a94573fb ldp x27, x28, [sp, #80]
40030f78: a8c77bfd ldp x29, x30, [sp], #112
40030f7c: d65f03c0 ret
i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
40030f80: 11008273 add w19, w19, #0x20
for (i = 0;
40030f84: 6b1c027f cmp w19, w28
40030f88: 54fffc63 b.cc 40030f14 <msdos_dir_is_empty+0x84> // b.lo, b.ul, b.last
j++;
40030f8c: 1100075a add w26, w26, #0x1
40030f90: 17ffffd2 b 40030ed8 <msdos_dir_is_empty+0x48>
*ret_val = true;
40030f94: f94037e2 ldr x2, [sp, #104]
40030f98: 52800021 mov w1, #0x1 // #1
return RC_OK;
40030f9c: 52800000 mov w0, #0x0 // #0
}
40030fa0: a94153f3 ldp x19, x20, [sp, #16]
*ret_val = true;
40030fa4: 39000041 strb w1, [x2]
}
40030fa8: a9425bf5 ldp x21, x22, [sp, #32]
40030fac: a94363f7 ldp x23, x24, [sp, #48]
40030fb0: a9446bf9 ldp x25, x26, [sp, #64]
40030fb4: a94573fb ldp x27, x28, [sp, #80]
40030fb8: a8c77bfd ldp x29, x30, [sp], #112
40030fbc: d65f03c0 ret
return -1;
40030fc0: 12800000 mov w0, #0xffffffff // #-1 <== NOT EXECUTED
40030fc4: 17ffffe8 b 40030f64 <msdos_dir_is_empty+0xd4> <== NOT EXECUTED
assert(ret == fs_info->fat.vol.bps);
40030fc8: b00000c3 adrp x3, 40049000 <IMFS_node_control_sym_link+0xe0> <== NOT EXECUTED
40030fcc: b00000c2 adrp x2, 40049000 <IMFS_node_control_sym_link+0xe0> <== NOT EXECUTED
40030fd0: b00000c0 adrp x0, 40049000 <IMFS_node_control_sym_link+0xe0> <== NOT EXECUTED
40030fd4: 910e6063 add x3, x3, #0x398 <== NOT EXECUTED
40030fd8: 91138042 add x2, x2, #0x4e0 <== NOT EXECUTED
40030fdc: 910ee000 add x0, x0, #0x3b8 <== NOT EXECUTED
40030fe0: 528078c1 mov w1, #0x3c6 // #966 <== NOT EXECUTED
40030fe4: 9400162f bl 400368a0 <__assert_func> <== NOT EXECUTED
...
0000000040037640 <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)
{
40037640: d10843ff sub sp, sp, #0x210
40037644: a9007bfd stp x29, x30, [sp]
40037648: 910003fd mov x29, sp
4003764c: a90363f7 stp x23, x24, [sp, #48]
40037650: aa0003f8 mov x24, x0
int rc = RC_OK;
int eno = 0;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
40037654: f9401c00 ldr x0, [x0, #56]
{
40037658: a90153f3 stp x19, x20, [sp, #16]
4003765c: aa0203f4 mov x20, x2
40037660: f90047e1 str x1, [sp, #136]
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
40037664: f9400813 ldr x19, [x0, #16]
{
40037668: a9046bf9 stp x25, x26, [sp, #64]
4003766c: 91036260 add x0, x19, #0xd8
40037670: a90573fb stp x27, x28, [sp, #80]
rtems_dosfs_convert_control *converter = fs_info->converter;
40037674: f9408661 ldr x1, [x19, #264]
40037678: f9005fe0 str x0, [sp, #184]
const rtems_dosfs_convert_handler *convert_handler = converter->handler;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
4003767c: f940131b ldr x27, [x24, #32]
fat_file_fd_t *tmp_fat_fd = NULL;
struct dirent tmp_dirent;
size_t lfn_len = 0;
uint16_t *lfn_buf = converter->buffer.data;
40037680: a9406822 ldp x2, x26, [x1]
const rtems_dosfs_convert_handler *convert_handler = converter->handler;
40037684: a9078be1 stp x1, x2, [sp, #120]
char *sfn_buf = converter->buffer.data;
const size_t buf_size = converter->buffer.size;
40037688: f9400821 ldr x1, [x1, #16]
4003768c: f90067e1 str x1, [sp, #200]
uint32_t start = 0;
ssize_t ret = 0;
ssize_t cmpltd = 0;
uint32_t j = 0, i = 0;
uint32_t bts2rd = 0;
uint32_t cur_cln = 0;
40037690: b900d7ff str wzr, [sp, #212]
fat_file_fd_t *tmp_fat_fd = NULL;
40037694: f9006fff str xzr, [sp, #216]
_Mutex_recursive_Acquire( mutex );
40037698: 97ffc6f2 bl 40029260 <_Mutex_recursive_Acquire>
/*
* 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);
4003769c: d29d41e0 mov x0, #0xea0f // #59919
400376a0: f2a1d400 movk x0, #0xea0, lsl #16
400376a4: f2d41d40 movk x0, #0xa0ea, lsl #32
400376a8: f2fd41c0 movk x0, #0xea0e, lsl #48
400376ac: f9400717 ldr x23, [x24, #8]
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
400376b0: 9bc07e94 umulh x20, x20, x0
* 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 :
400376b4: f9401762 ldr x2, [x27, #40]
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
400376b8: d2802301 mov x1, #0x118 // #280
start = iop->offset / sizeof(struct dirent);
400376bc: 9bc07ef7 umulh x23, x23, x0
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
400376c0: d348fe94 lsr x20, x20, #8
fat_fd->fat_file_size :
400376c4: f100045f cmp x2, #0x1
start = iop->offset / sizeof(struct dirent);
400376c8: d3489ee0 ubfx x0, x23, #8, #32
400376cc: aa0003e2 mov x2, x0
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
400376d0: 9b017e80 mul x0, x20, x1
400376d4: f90037e0 str x0, [sp, #104]
fat_fd->fat_file_size :
400376d8: 54001ec0 b.eq 40037ab0 <msdos_dir_read+0x470> // b.none
400376dc: b9400a60 ldr w0, [x19, #8]
400376e0: b900abe0 str w0, [sp, #168]
fs_info->fat.vol.bpc;
while (count > 0 && cmpltd >= 0)
400376e4: f94037e0 ldr x0, [sp, #104]
400376e8: b40020e0 cbz x0, 40037b04 <msdos_dir_read+0x4c4> <== NEVER TAKEN
* trailing nul character. We need to range check the length to
* fit in the directory entry name field.
*/
lfn_entries--;
offset_lfn = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
400376ec: 2a0203f7 mov w23, w2
ret = fat_file_read(&fs_info->fat, fat_fd, (j * bts2rd),
400376f0: 52800019 mov w25, #0x0 // #0
ssize_t cmpltd = 0;
400376f4: d2800014 mov x20, #0x0 // #0
400376f8: a9025bf5 stp x21, x22, [sp, #32]
uint32_t lfn_start = FAT_FILE_SHORT_NAME;
400376fc: 12800016 mov w22, #0xffffffff // #-1
int lfn_entries = 0;
40037700: b90077ff str wzr, [sp, #116]
offset_lfn = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
40037704: f9004bf8 str x24, [sp, #144]
uint8_t lfn_checksum = 0;
40037708: b9009fff str wzr, [sp, #156]
size_t lfn_len = 0;
4003770c: f90053ff str xzr, [sp, #160]
ret = fat_file_read(&fs_info->fat, fat_fd, (j * bts2rd),
40037710: b940abe3 ldr w3, [sp, #168]
40037714: 2a1903e2 mov w2, w25
40037718: f9408264 ldr x4, [x19, #256]
4003771c: aa1b03e1 mov x1, x27
40037720: aa1303e0 mov x0, x19
40037724: 97ffdf07 bl 4002f340 <fat_file_read>
40037728: aa0003f5 mov x21, x0
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
4003772c: f1007c1f cmp x0, #0x1f
40037730: 54001ccd b.le 40037ac8 <msdos_dir_read+0x488> <== NEVER TAKEN
for (i = 0; i < ret && cmpltd >= 0; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
40037734: b7f805d4 tbnz x20, #63, 400377ec <msdos_dir_read+0x1ac> <== NEVER TAKEN
40037738: 5280041c mov w28, #0x20 // #32
4003773c: 2a1c03f8 mov w24, w28
40037740: aa1b03fc mov x28, x27
lfn_start =
40037744: 51008320 sub w0, w25, #0x20
for (i = 0; i < ret && cmpltd >= 0; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
40037748: b9009bf9 str w25, [sp, #152]
lfn_start =
4003774c: b900afe0 str w0, [sp, #172]
char* entry = (char*) fs_info->cl_buf + i;
40037750: f9408269 ldr x9, [x19, #256]
40037754: 5100831b sub w27, w24, #0x20
40037758: 51008301 sub w1, w24, #0x20
4003775c: 8b010139 add x25, x9, x1
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
40037760: 387b4920 ldrb w0, [x9, w27, uxtw]
40037764: 34001900 cbz w0, 40037a84 <msdos_dir_read+0x444>
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) == MSDOS_THIS_DIR_ENTRY_EMPTY)
40037768: 7103941f cmp w0, #0xe5
4003776c: 54000fa0 b.eq 40037960 <msdos_dir_read+0x320> // b.none
if (((*MSDOS_DIR_ATTR(entry)) & MSDOS_ATTR_VOLUME_ID) &&
40037770: 39402f22 ldrb w2, [x25, #11]
40037774: 12001441 and w1, w2, #0x3f
40037778: 36180642 tbz w2, #3, 40037840 <msdos_dir_read+0x200>
for (i = 0; i < ret && cmpltd >= 0; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
4003777c: aa3403e2 mvn x2, x20
40037780: eb3842bf cmp x21, w24, uxtw
40037784: 1a9fd7e8 cset w8, gt
if (((*MSDOS_DIR_ATTR(entry)) & MSDOS_ATTR_VOLUME_ID) &&
40037788: 71003c3f cmp w1, #0xf
for (i = 0; i < ret && cmpltd >= 0; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
4003778c: d37ffc42 lsr x2, x2, #63
40037790: 0a020108 and w8, w8, w2
40037794: 12001c44 and w4, w2, #0xff
if (((*MSDOS_DIR_ATTR(entry)) & MSDOS_ATTR_VOLUME_ID) &&
40037798: 540001c1 b.ne 400377d0 <msdos_dir_read+0x190> // b.any
if (lfn_start == FAT_FILE_SHORT_NAME)
4003779c: 310006df cmn w22, #0x1
is_first_entry = false;
400377a0: 52800003 mov w3, #0x0 // #0
if (lfn_start == FAT_FILE_SHORT_NAME)
400377a4: 54000fe0 b.eq 400379a0 <msdos_dir_read+0x360> // b.none
if ((lfn_entries != (*MSDOS_DIR_ENTRY_TYPE(entry) &
400377a8: b94077e1 ldr w1, [sp, #116]
400377ac: 12001400 and w0, w0, #0x3f
400377b0: 6b01001f cmp w0, w1
400377b4: 540000a1 b.ne 400377c8 <msdos_dir_read+0x188> // b.any
MSDOS_LAST_LONG_ENTRY_MASK)) ||
400377b8: 39403720 ldrb w0, [x25, #13]
400377bc: b9409fe1 ldr w1, [sp, #156]
400377c0: 6b01001f cmp w0, w1
400377c4: 54000180 b.eq 400377f4 <msdos_dir_read+0x1b4> // b.none <== ALWAYS TAKEN
lfn_start = FAT_FILE_SHORT_NAME;
400377c8: 12800016 mov w22, #0xffffffff // #-1
400377cc: d503201f nop
for (i = 0; i < ret && cmpltd >= 0; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
400377d0: 11008318 add w24, w24, #0x20
400377d4: 35fffbe8 cbnz w8, 40037750 <msdos_dir_read+0x110>
while (count > 0 && cmpltd >= 0)
400377d8: b9409bf9 ldr w25, [sp, #152]
400377dc: aa1c03fb mov x27, x28
400377e0: b940abe0 ldr w0, [sp, #168]
400377e4: 0b000339 add w25, w25, w0
400377e8: 35fff944 cbnz w4, 40037710 <msdos_dir_read+0xd0> <== ALWAYS TAKEN
400377ec: a9425bf5 ldp x21, x22, [sp, #32]
400377f0: 14000085 b 40037a04 <msdos_dir_read+0x3c4>
lfn_entries--;
400377f4: b94077e0 ldr w0, [sp, #116]
offset_lfn = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
400377f8: 528001a2 mov w2, #0xd // #13
400377fc: b900b3e8 str w8, [sp, #176]
lfn_entries--;
40037800: 51000400 sub w0, w0, #0x1
40037804: b900c3e4 str w4, [sp, #192]
40037808: 2a0003e1 mov w1, w0
4003780c: b90077e1 str w1, [sp, #116]
lfn_len += msdos_get_utf16_string_from_long_entry (
40037810: aa1903e0 mov x0, x25
offset_lfn = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
40037814: 1b027c21 mul w1, w1, w2
lfn_len += msdos_get_utf16_string_from_long_entry (
40037818: f94067e2 ldr x2, [sp, #200]
4003781c: cb21c042 sub x2, x2, w1, sxtw
40037820: 8b21c741 add x1, x26, w1, sxtw #1
40037824: 97ffe5f3 bl 40030ff0 <msdos_get_utf16_string_from_long_entry>
40037828: f94053e1 ldr x1, [sp, #160]
4003782c: b940b3e8 ldr w8, [sp, #176]
40037830: 8b000020 add x0, x1, x0
40037834: b940c3e4 ldr w4, [sp, #192]
40037838: f90053e0 str x0, [sp, #160]
return rc;
}
}
}
if (count <= 0)
4003783c: 17ffffe5 b 400377d0 <msdos_dir_read+0x190>
if ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
40037840: 71003c3f cmp w1, #0xf
40037844: 54001520 b.eq 40037ae8 <msdos_dir_read+0x4a8> // b.none <== NEVER TAKEN
if (start)
40037848: 350009b7 cbnz w23, 4003797c <msdos_dir_read+0x33c>
rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
4003784c: b9409be3 ldr w3, [sp, #152]
tmp_dirent.d_type = DT_REG;
40037850: f27c005f tst x2, #0x10
40037854: 52800101 mov w1, #0x8 // #8
40037858: 52800080 mov w0, #0x4 // #4
4003785c: 1a811000 csel w0, w0, w1, ne // ne = any
rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
40037860: 910353e4 add x4, sp, #0xd4
40037864: aa1c03e1 mov x1, x28
40037868: 52800022 mov w2, #0x1 // #1
4003786c: 39042be0 strb w0, [sp, #266]
40037870: aa1303e0 mov x0, x19
40037874: 97ffdfbb bl 4002f760 <fat_file_ioctl>
if (rc != RC_OK)
40037878: 35001040 cbnz w0, 40037a80 <msdos_dir_read+0x440> <== NEVER TAKEN
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
4003787c: 12800003 mov w3, #0xffffffff // #-1
dir_pos.sname.cln = cur_cln;
40037880: b940d7e0 ldr w0, [sp, #212]
rc = fat_file_open(&fs_info->fat, &dir_pos, &tmp_fat_fd);
40037884: 910363e2 add x2, sp, #0xd8
40037888: 9103a3e1 add x1, sp, #0xe8
dir_pos.sname.ofs = i;
4003788c: 291d6fe0 stp w0, w27, [sp, #232]
rc = fat_file_open(&fs_info->fat, &dir_pos, &tmp_fat_fd);
40037890: aa1303e0 mov x0, x19
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
40037894: 291e0fe3 stp w3, w3, [sp, #240]
40037898: 97ffddca bl 4002efc0 <fat_file_open>
if (rc != RC_OK)
4003789c: 35000f20 cbnz w0, 40037a80 <msdos_dir_read+0x440> <== NEVER TAKEN
tmp_dirent.d_ino = tmp_fat_fd->ino;
400378a0: f9406fe0 ldr x0, [sp, #216]
tmp_dirent.d_reclen = sizeof(struct dirent);
400378a4: 52802301 mov w1, #0x118 // #280
if (lfn_entries == 0 &&
400378a8: b94077e2 ldr w2, [sp, #116]
tmp_dirent.d_reclen = sizeof(struct dirent);
400378ac: 790213e1 strh w1, [sp, #264]
tmp_dirent.d_ino = tmp_fat_fd->ino;
400378b0: b9401400 ldr w0, [x0, #20]
if (lfn_entries == 0 &&
400378b4: 7100005f cmp w2, #0x0
tmp_dirent.d_off = start + cmpltd;
400378b8: a90fd3e0 stp x0, x20, [sp, #248]
if (lfn_entries == 0 &&
400378bc: 3a410ac4 ccmn w22, #0x1, #0x4, eq // eq = none
400378c0: 54000b61 b.ne 40037a2c <msdos_dir_read+0x3ec> // b.any
size_t len = sizeof(tmp_dirent.d_name) - 1;
400378c4: d2801fe2 mov x2, #0xff // #255
tmp_dirent.d_namlen = msdos_format_dirent_with_dot(
400378c8: aa1903e1 mov x1, x25
400378cc: aa1a03e0 mov x0, x26
size_t len = sizeof(tmp_dirent.d_name) - 1;
400378d0: f90073e2 str x2, [sp, #224]
tmp_dirent.d_namlen = msdos_format_dirent_with_dot(
400378d4: 97ffe5cf bl 40031010 <msdos_format_dirent_with_dot>
eno = (*convert_handler->codepage_to_utf8) (
400378d8: 92403c02 and x2, x0, #0xffff
400378dc: f94043e1 ldr x1, [sp, #128]
400378e0: 910383e4 add x4, sp, #0xe0
400378e4: 91043be3 add x3, sp, #0x10e
400378e8: f9400426 ldr x6, [x1, #8]
tmp_dirent.d_namlen = msdos_format_dirent_with_dot(
400378ec: 79021be0 strh w0, [sp, #268]
eno = (*convert_handler->codepage_to_utf8) (
400378f0: f9403fe0 ldr x0, [sp, #120]
400378f4: aa1a03e1 mov x1, x26
400378f8: d63f00c0 blr x6
if ( 0 == eno ) {
400378fc: 350007a0 cbnz w0, 400379f0 <msdos_dir_read+0x3b0> <== NEVER TAKEN
tmp_dirent.d_namlen = len;
40037900: f94073e0 ldr x0, [sp, #224]
tmp_dirent.d_name[len] = '\0';
40037904: 91043be1 add x1, sp, #0x10e
tmp_dirent.d_namlen = len;
40037908: 79021be0 strh w0, [sp, #268]
tmp_dirent.d_name[len] = '\0';
4003790c: 12800016 mov w22, #0xffffffff // #-1
40037910: 3820683f strb wzr, [x1, x0]
memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
40037914: f94047e0 ldr x0, [sp, #136]
40037918: 9103e3e1 add x1, sp, #0xf8
4003791c: d2802302 mov x2, #0x118 // #280
40037920: 8b140000 add x0, x0, x20
40037924: 94000eb5 bl 4003b3f8 <memcpy>
iop->offset = iop->offset + sizeof(struct dirent);
40037928: f9404be3 ldr x3, [sp, #144]
rc = fat_file_close(&fs_info->fat, tmp_fat_fd);
4003792c: aa1303e0 mov x0, x19
40037930: f9406fe1 ldr x1, [sp, #216]
cmpltd += (sizeof(struct dirent));
40037934: 91046294 add x20, x20, #0x118
iop->offset = iop->offset + sizeof(struct dirent);
40037938: f9400462 ldr x2, [x3, #8]
4003793c: 91046042 add x2, x2, #0x118
40037940: f9000462 str x2, [x3, #8]
count -= (sizeof(struct dirent));
40037944: f94037e2 ldr x2, [sp, #104]
40037948: d1046042 sub x2, x2, #0x118
4003794c: f90037e2 str x2, [sp, #104]
rc = fat_file_close(&fs_info->fat, tmp_fat_fd);
40037950: 97ffdf50 bl 4002f690 <fat_file_close>
if (rc != RC_OK)
40037954: 35000960 cbnz w0, 40037a80 <msdos_dir_read+0x440> <== NEVER TAKEN
if (count <= 0)
40037958: f94037e0 ldr x0, [sp, #104]
4003795c: b4fff480 cbz x0, 400377ec <msdos_dir_read+0x1ac> <== ALWAYS TAKEN
for (i = 0; i < ret && cmpltd >= 0; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
40037960: aa3403e2 mvn x2, x20
40037964: eb3842bf cmp x21, w24, uxtw
40037968: 1a9fd7e8 cset w8, gt
4003796c: d37ffc42 lsr x2, x2, #63
40037970: 0a020108 and w8, w8, w2
40037974: 12001c44 and w4, w2, #0xff
40037978: 17ffff96 b 400377d0 <msdos_dir_read+0x190>
4003797c: aa3403e2 mvn x2, x20
40037980: eb3842bf cmp x21, w24, uxtw
40037984: 1a9fd7e8 cset w8, gt
start--;
40037988: 510006f7 sub w23, w23, #0x1
for (i = 0; i < ret && cmpltd >= 0; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
4003798c: d37ffc42 lsr x2, x2, #63
lfn_start = FAT_FILE_SHORT_NAME;
40037990: 12800016 mov w22, #0xffffffff // #-1
for (i = 0; i < ret && cmpltd >= 0; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
40037994: 0a020108 and w8, w8, w2
40037998: 12001c44 and w4, w2, #0xff
4003799c: 17ffff8d b 400377d0 <msdos_dir_read+0x190>
if ((*MSDOS_DIR_ENTRY_TYPE(entry) &
400379a0: f9005be9 str x9, [sp, #176]
400379a4: 3637f160 tbz w0, #6, 400377d0 <msdos_dir_read+0x190>
lfn_start =
400379a8: b940afe1 ldr w1, [sp, #172]
lfn_entries = (*MSDOS_DIR_ENTRY_TYPE(entry) &
400379ac: 12001400 and w0, w0, #0x3f
400379b0: b90077e0 str w0, [sp, #116]
memset (tmp_dirent.d_name, 0, sizeof(tmp_dirent.d_name));
400379b4: d2802002 mov x2, #0x100 // #256
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
400379b8: 39403720 ldrb w0, [x25, #13]
lfn_start =
400379bc: 0b180036 add w22, w1, w24
memset (tmp_dirent.d_name, 0, sizeof(tmp_dirent.d_name));
400379c0: 52800001 mov w1, #0x0 // #0
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
400379c4: b9009fe0 str w0, [sp, #156]
memset (tmp_dirent.d_name, 0, sizeof(tmp_dirent.d_name));
400379c8: 91043be0 add x0, sp, #0x10e
400379cc: 291813e8 stp w8, w4, [sp, #192]
400379d0: 94000ea5 bl 4003b464 <memset>
lfn_start =
400379d4: 53057ed6 lsr w22, w22, #5
if ((lfn_entries != (*MSDOS_DIR_ENTRY_TYPE(entry) &
400379d8: f9405be9 ldr x9, [sp, #176]
is_first_entry = true;
400379dc: 52800023 mov w3, #0x1 // #1
lfn_len = 0;
400379e0: 295813e8 ldp w8, w4, [sp, #192]
400379e4: f90053ff str xzr, [sp, #160]
if ((lfn_entries != (*MSDOS_DIR_ENTRY_TYPE(entry) &
400379e8: 387b4920 ldrb w0, [x9, w27, uxtw]
400379ec: 17ffff6f b 400377a8 <msdos_dir_read+0x168>
errno = eno;
400379f0: 2a0003f6 mov w22, w0 <== NOT EXECUTED
400379f4: 94000bde bl 4003a96c <__errno> <== NOT EXECUTED
400379f8: b9000016 str w22, [x0] <== NOT EXECUTED
cmpltd = -1;
400379fc: 92800014 mov x20, #0xffffffffffffffff // #-1 <== NOT EXECUTED
40037a00: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
_Mutex_recursive_Release( mutex );
40037a04: f9405fe0 ldr x0, [sp, #184]
40037a08: 97ffc63a bl 400292f0 <_Mutex_recursive_Release>
j++;
}
msdos_fs_unlock(fs_info);
return cmpltd;
}
40037a0c: aa1403e0 mov x0, x20
40037a10: a9407bfd ldp x29, x30, [sp]
40037a14: a94153f3 ldp x19, x20, [sp, #16]
40037a18: a94363f7 ldp x23, x24, [sp, #48]
40037a1c: a9446bf9 ldp x25, x26, [sp, #64]
40037a20: a94573fb ldp x27, x28, [sp, #80]
40037a24: 910843ff add sp, sp, #0x210
40037a28: d65f03c0 ret
lfn_checksum == msdos_lfn_checksum(entry)) {
40037a2c: aa1903e0 mov x0, x25
40037a30: 97ffe368 bl 400307d0 <msdos_lfn_checksum>
if (lfn_entries == 0 &&
40037a34: b9409fe1 ldr w1, [sp, #156]
40037a38: 6b20003f cmp w1, w0, uxtb
40037a3c: 54fff441 b.ne 400378c4 <msdos_dir_read+0x284> // b.any <== NEVER TAKEN
eno = (*convert_handler->utf16_to_utf8) (
40037a40: f94043e0 ldr x0, [sp, #128]
40037a44: 910383e4 add x4, sp, #0xe0
40037a48: f94053e2 ldr x2, [sp, #160]
40037a4c: 91043be3 add x3, sp, #0x10e
40037a50: f9400c07 ldr x7, [x0, #24]
size_t len = sizeof(tmp_dirent.d_name) - 1;
40037a54: d2801fe0 mov x0, #0xff // #255
40037a58: f90073e0 str x0, [sp, #224]
eno = (*convert_handler->utf16_to_utf8) (
40037a5c: aa1a03e1 mov x1, x26
40037a60: f9403fe0 ldr x0, [sp, #120]
40037a64: d63f00e0 blr x7
if (eno == 0) {
40037a68: 35fff2e0 cbnz w0, 400378c4 <msdos_dir_read+0x284>
tmp_dirent.d_namlen = len;
40037a6c: f94073e0 ldr x0, [sp, #224]
tmp_dirent.d_name[len] = '\0';
40037a70: 91043be1 add x1, sp, #0x10e
tmp_dirent.d_namlen = len;
40037a74: 79021be0 strh w0, [sp, #268]
tmp_dirent.d_name[len] = '\0';
40037a78: 3820683f strb wzr, [x1, x0]
if (lfn_start == FAT_FILE_SHORT_NAME) {
40037a7c: 17ffffa6 b 40037914 <msdos_dir_read+0x2d4>
40037a80: 93407c14 sxtw x20, w0 <== NOT EXECUTED
40037a84: f9405fe0 ldr x0, [sp, #184]
40037a88: 97ffc61a bl 400292f0 <_Mutex_recursive_Release>
}
40037a8c: aa1403e0 mov x0, x20
40037a90: a9407bfd ldp x29, x30, [sp]
40037a94: a94153f3 ldp x19, x20, [sp, #16]
return rc;
40037a98: a9425bf5 ldp x21, x22, [sp, #32]
}
40037a9c: a94363f7 ldp x23, x24, [sp, #48]
40037aa0: a9446bf9 ldp x25, x26, [sp, #64]
40037aa4: a94573fb ldp x27, x28, [sp, #80]
40037aa8: 910843ff add sp, sp, #0x210
40037aac: d65f03c0 ret
bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&
40037ab0: 39405a60 ldrb w0, [x19, #22]
40037ab4: f240041f tst x0, #0x3
40037ab8: 54ffe120 b.eq 400376dc <msdos_dir_read+0x9c> // b.none <== NEVER TAKEN
fat_fd->fat_file_size :
40037abc: b9402360 ldr w0, [x27, #32]
40037ac0: b900abe0 str w0, [sp, #168]
40037ac4: 17ffff08 b 400376e4 <msdos_dir_read+0xa4>
40037ac8: f9405fe0 ldr x0, [sp, #184] <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
40037acc: 92800014 mov x20, #0xffffffffffffffff // #-1 <== NOT EXECUTED
40037ad0: 97ffc608 bl 400292f0 <_Mutex_recursive_Release> <== NOT EXECUTED
40037ad4: 94000ba6 bl 4003a96c <__errno> <== NOT EXECUTED
40037ad8: 528000a1 mov w1, #0x5 // #5 <== NOT EXECUTED
40037adc: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
40037ae0: b9000001 str w1, [x0] <== NOT EXECUTED
40037ae4: 17ffffca b 40037a0c <msdos_dir_read+0x3cc> <== NOT EXECUTED
for (i = 0; i < ret && cmpltd >= 0; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
40037ae8: aa3403e2 mvn x2, x20 <== NOT EXECUTED
40037aec: eb3842bf cmp x21, w24, uxtw <== NOT EXECUTED
40037af0: 1a9fd7e8 cset w8, gt <== NOT EXECUTED
40037af4: d37ffc42 lsr x2, x2, #63 <== NOT EXECUTED
40037af8: 0a020108 and w8, w8, w2 <== NOT EXECUTED
40037afc: 12001c44 and w4, w2, #0xff <== NOT EXECUTED
40037b00: 17ffff27 b 4003779c <msdos_dir_read+0x15c> <== NOT EXECUTED
ssize_t cmpltd = 0;
40037b04: d2800014 mov x20, #0x0 // #0 <== NOT EXECUTED
40037b08: 17ffffbf b 40037a04 <msdos_dir_read+0x3c4> <== NOT EXECUTED
40037b0c: 00000000 udf #0
0000000040037dc0 <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)
{
40037dc0: a9bb7bfd stp x29, x30, [sp, #-80]!
40037dc4: 910003fd mov x29, sp
40037dc8: a90153f3 stp x19, x20, [sp, #16]
40037dcc: aa0103f3 mov x19, x1
int rc = RC_OK;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
40037dd0: f9401c01 ldr x1, [x0, #56]
{
40037dd4: a9025bf5 stp x21, x22, [sp, #32]
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
40037dd8: f9401014 ldr x20, [x0, #32]
{
40037ddc: a90363f7 stp x23, x24, [sp, #48]
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
40037de0: f9400836 ldr x22, [x1, #16]
40037de4: 910362d8 add x24, x22, #0xd8
_Mutex_recursive_Acquire( mutex );
40037de8: aa1803e0 mov x0, x24
40037dec: 97ffc51d bl 40029260 <_Mutex_recursive_Acquire>
uint32_t old_length;
msdos_fs_lock(fs_info);
old_length = fat_fd->fat_file_size;
40037df0: b9402297 ldr w23, [x20, #32]
if (length < old_length) {
40037df4: eb37427f cmp x19, w23, uxtw
40037df8: 540001ea b.ge 40037e34 <msdos_file_ftruncate+0x74> // b.tcont
rc = fat_file_truncate(&fs_info->fat, fat_fd, length);
40037dfc: aa1603e0 mov x0, x22
40037e00: 2a1303e2 mov w2, w19
40037e04: aa1403e1 mov x1, x20
40037e08: 97ffddde bl 4002f580 <fat_file_truncate>
40037e0c: 2a0003f5 mov w21, w0
errno = ENOSPC;
rc = -1;
}
}
if (rc == RC_OK)
40037e10: 34000280 cbz w0, 40037e60 <msdos_file_ftruncate+0xa0> <== ALWAYS TAKEN
_Mutex_recursive_Release( mutex );
40037e14: aa1803e0 mov x0, x24 <== NOT EXECUTED
40037e18: 97ffc536 bl 400292f0 <_Mutex_recursive_Release> <== NOT EXECUTED
}
msdos_fs_unlock(fs_info);
return rc;
}
40037e1c: 2a1503e0 mov w0, w21 <== NOT EXECUTED
40037e20: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40037e24: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
40037e28: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
40037e2c: a8c57bfd ldp x29, x30, [sp], #80 <== NOT EXECUTED
40037e30: d65f03c0 ret <== NOT EXECUTED
rc = fat_file_extend(&fs_info->fat,
40037e34: 910133e4 add x4, sp, #0x4c
40037e38: 2a1303e3 mov w3, w19
40037e3c: aa1403e1 mov x1, x20
40037e40: aa1603e0 mov x0, x22
40037e44: 52800022 mov w2, #0x1 // #1
40037e48: 97ffde82 bl 4002f850 <fat_file_extend>
40037e4c: 2a0003f5 mov w21, w0
if (rc == RC_OK && length != new_length) {
40037e50: 35fffe20 cbnz w0, 40037e14 <msdos_file_ftruncate+0x54> <== NEVER TAKEN
40037e54: b9404fe0 ldr w0, [sp, #76]
40037e58: eb13001f cmp x0, x19
40037e5c: 54000261 b.ne 40037ea8 <msdos_file_ftruncate+0xe8> // b.any <== NEVER TAKEN
fat_fd->flags |= FAT_FILE_META_DATA_CHANGED;
40037e60: 3940e281 ldrb w1, [x20, #56]
fat_file_set_ctime_mtime(fat_fd, time(NULL));
40037e64: d2800000 mov x0, #0x0 // #0
fat_fd->fat_file_size = s;
40037e68: b9002293 str w19, [x20, #32]
fat_fd->flags |= FAT_FILE_META_DATA_CHANGED;
40037e6c: 321f0021 orr w1, w1, #0x2
40037e70: 3900e281 strb w1, [x20, #56]
40037e74: 94001efd bl 4003fa68 <time>
fat_fd->mtime = t;
40037e78: a9048280 stp x0, x0, [x20, #72]
fat_fd->flags |= FAT_FILE_META_DATA_CHANGED;
40037e7c: 3940e281 ldrb w1, [x20, #56]
40037e80: aa1803e0 mov x0, x24
40037e84: 321f0021 orr w1, w1, #0x2
40037e88: 3900e281 strb w1, [x20, #56]
40037e8c: 97ffc519 bl 400292f0 <_Mutex_recursive_Release>
}
40037e90: 2a1503e0 mov w0, w21
40037e94: a94153f3 ldp x19, x20, [sp, #16]
40037e98: a9425bf5 ldp x21, x22, [sp, #32]
40037e9c: a94363f7 ldp x23, x24, [sp, #48]
40037ea0: a8c57bfd ldp x29, x30, [sp], #80
40037ea4: d65f03c0 ret
fat_file_truncate(&fs_info->fat, fat_fd, old_length);
40037ea8: aa1403e1 mov x1, x20 <== NOT EXECUTED
40037eac: 2a1703e2 mov w2, w23 <== NOT EXECUTED
40037eb0: aa1603e0 mov x0, x22 <== NOT EXECUTED
40037eb4: 97ffddb3 bl 4002f580 <fat_file_truncate> <== NOT EXECUTED
rc = -1;
40037eb8: 12800015 mov w21, #0xffffffff // #-1 <== NOT EXECUTED
errno = ENOSPC;
40037ebc: 94000aac bl 4003a96c <__errno> <== NOT EXECUTED
40037ec0: 52800381 mov w1, #0x1c // #28 <== NOT EXECUTED
40037ec4: b9000001 str w1, [x0] <== NOT EXECUTED
if (rc == RC_OK)
40037ec8: 17ffffd3 b 40037e14 <msdos_file_ftruncate+0x54> <== NOT EXECUTED
40037ecc: 00000000 udf #0
0000000040037ed0 <msdos_file_sync>:
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
int
msdos_file_sync(rtems_libio_t *iop)
{
40037ed0: a9bd7bfd stp x29, x30, [sp, #-48]!
40037ed4: 910003fd mov x29, sp
int rc = RC_OK;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
40037ed8: f9401c01 ldr x1, [x0, #56]
{
40037edc: a90153f3 stp x19, x20, [sp, #16]
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
40037ee0: f9401013 ldr x19, [x0, #32]
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
40037ee4: f9400834 ldr x20, [x1, #16]
{
40037ee8: f90013f5 str x21, [sp, #32]
40037eec: 91036295 add x21, x20, #0xd8
_Mutex_recursive_Acquire( mutex );
40037ef0: aa1503e0 mov x0, x21
40037ef4: 97ffc4db bl 40029260 <_Mutex_recursive_Acquire>
msdos_fs_lock(fs_info);
rc = fat_file_update(&fs_info->fat, fat_fd);
40037ef8: aa1303e1 mov x1, x19
40037efc: aa1403e0 mov x0, x20
40037f00: 97ffdcec bl 4002f2b0 <fat_file_update>
40037f04: 2a0003f3 mov w19, w0
if (rc != RC_OK)
40037f08: 35000060 cbnz w0, 40037f14 <msdos_file_sync+0x44> <== NEVER TAKEN
{
msdos_fs_unlock(fs_info);
return rc;
}
rc = fat_sync(&fs_info->fat);
40037f0c: aa1403e0 mov x0, x20
40037f10: 97ffd8e0 bl 4002e290 <fat_sync>
_Mutex_recursive_Release( mutex );
40037f14: aa1503e0 mov x0, x21
40037f18: 97ffc4f6 bl 400292f0 <_Mutex_recursive_Release>
msdos_fs_unlock(fs_info);
return RC_OK;
}
40037f1c: 2a1303e0 mov w0, w19
40037f20: a94153f3 ldp x19, x20, [sp, #16]
40037f24: f94013f5 ldr x21, [sp, #32]
40037f28: a8c37bfd ldp x29, x30, [sp], #48
40037f2c: d65f03c0 ret
0000000040037c30 <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)
{
40037c30: a9bc7bfd stp x29, x30, [sp, #-64]!
40037c34: 910003fd mov x29, sp
40037c38: a90153f3 stp x19, x20, [sp, #16]
40037c3c: aa0003f3 mov x19, x0
40037c40: aa0203f4 mov x20, x2
ssize_t ret = 0;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
40037c44: f9401c00 ldr x0, [x0, #56]
{
40037c48: a90363f7 stp x23, x24, [sp, #48]
40037c4c: a9025bf5 stp x21, x22, [sp, #32]
40037c50: aa0103f6 mov x22, x1
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
40037c54: f9400817 ldr x23, [x0, #16]
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
40037c58: f9401275 ldr x21, [x19, #32]
40037c5c: 910362f8 add x24, x23, #0xd8
_Mutex_recursive_Acquire( mutex );
40037c60: aa1803e0 mov x0, x24
40037c64: 97ffc57f bl 40029260 <_Mutex_recursive_Acquire>
40037c68: b9400260 ldr w0, [x19]
msdos_fs_lock(fs_info);
if (rtems_libio_iop_is_append(iop))
40037c6c: 37480300 tbnz w0, #9, 40037ccc <msdos_file_write+0x9c>
iop->offset = fat_fd->fat_file_size;
ret = fat_file_write(&fs_info->fat, fat_fd, iop->offset, count,
40037c70: b9400a62 ldr w2, [x19, #8]
40037c74: 2a1403e3 mov w3, w20
40037c78: aa1603e4 mov x4, x22
40037c7c: aa1703e0 mov x0, x23
40037c80: aa1503e1 mov x1, x21
40037c84: 97ffdfa3 bl 4002fb10 <fat_file_write>
40037c88: aa0003f4 mov x20, x0
buffer);
if (ret < 0)
40037c8c: b7f80400 tbnz x0, #63, 40037d0c <msdos_file_write+0xdc>
/*
* update file size in both fat-file descriptor and file control block if
* file was extended
*/
iop->offset += ret;
40037c90: f9400660 ldr x0, [x19, #8]
if (iop->offset > fat_fd->fat_file_size)
40037c94: b94022a1 ldr w1, [x21, #32]
iop->offset += ret;
40037c98: 8b000280 add x0, x20, x0
40037c9c: f9000660 str x0, [x19, #8]
if (iop->offset > fat_fd->fat_file_size)
40037ca0: eb01001f cmp x0, x1
40037ca4: 540001cc b.gt 40037cdc <msdos_file_write+0xac>
fat_file_set_file_size(fat_fd, (uint32_t) iop->offset);
if (ret > 0)
40037ca8: b5000254 cbnz x20, 40037cf0 <msdos_file_write+0xc0> <== ALWAYS TAKEN
_Mutex_recursive_Release( mutex );
40037cac: aa1803e0 mov x0, x24
40037cb0: 97ffc590 bl 400292f0 <_Mutex_recursive_Release>
fat_file_set_ctime_mtime(fat_fd, time(NULL));
msdos_fs_unlock(fs_info);
return ret;
}
40037cb4: aa1403e0 mov x0, x20
40037cb8: a94153f3 ldp x19, x20, [sp, #16]
40037cbc: a9425bf5 ldp x21, x22, [sp, #32]
40037cc0: a94363f7 ldp x23, x24, [sp, #48]
40037cc4: a8c47bfd ldp x29, x30, [sp], #64
40037cc8: d65f03c0 ret
iop->offset = fat_fd->fat_file_size;
40037ccc: b94022a2 ldr w2, [x21, #32]
40037cd0: 2a0203e0 mov w0, w2
40037cd4: f9000660 str x0, [x19, #8]
40037cd8: 17ffffe7 b 40037c74 <msdos_file_write+0x44>
fat_fd->flags |= FAT_FILE_META_DATA_CHANGED;
40037cdc: 3940e2a1 ldrb w1, [x21, #56]
fat_file_set_file_size(fat_fd, (uint32_t) iop->offset);
40037ce0: b90022a0 str w0, [x21, #32]
40037ce4: 321f0020 orr w0, w1, #0x2
40037ce8: 3900e2a0 strb w0, [x21, #56]
if (ret > 0)
40037cec: b4fffe14 cbz x20, 40037cac <msdos_file_write+0x7c> <== NEVER TAKEN
fat_file_set_ctime_mtime(fat_fd, time(NULL));
40037cf0: d2800000 mov x0, #0x0 // #0
40037cf4: 94001f5d bl 4003fa68 <time>
fat_fd->flags |= FAT_FILE_META_DATA_CHANGED;
40037cf8: 3940e2a1 ldrb w1, [x21, #56]
fat_fd->mtime = t;
40037cfc: a90482a0 stp x0, x0, [x21, #72]
fat_fd->flags |= FAT_FILE_META_DATA_CHANGED;
40037d00: 321f0021 orr w1, w1, #0x2
40037d04: 3900e2a1 strb w1, [x21, #56]
}
40037d08: 17ffffe9 b 40037cac <msdos_file_write+0x7c>
40037d0c: aa1803e0 mov x0, x24
return -1;
40037d10: 92800014 mov x20, #0xffffffffffffffff // #-1
40037d14: 97ffc577 bl 400292f0 <_Mutex_recursive_Release>
40037d18: 17ffffe7 b 40037cb4 <msdos_file_write+0x84>
40037d1c: 00000000 udf #0
0000000040036f50 <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)
{
40036f50: a9bd7bfd stp x29, x30, [sp, #-48]!
40036f54: 910003fd mov x29, sp
if ( src_name[0] == UTF8_FULL_STOP
40036f58: 39400025 ldrb w5, [x1]
ssize_t returned_size = 0;
int eno = 0;
size_t name_size;
size_t dest_size = long_name_size;
40036f5c: f90017e4 str x4, [sp, #40]
if ( src_name[0] == UTF8_FULL_STOP
40036f60: 7100b8bf cmp w5, #0x2e
40036f64: 540003a0 b.eq 40036fd8 <msdos_filename_utf8_to_long_name_for_compare+0x88> // b.none<== NEVER TAKEN
size_returned >= UTF8_FULL_STOP_SIZE
40036f68: f9000bf3 str x19, [sp, #16]
for ( i = size_returned - UTF8_FULL_STOP_SIZE;
40036f6c: f100005f cmp x2, #0x0
ssize_t size_returned = filename_size;
40036f70: aa0203e4 mov x4, x2
for ( i = size_returned - UTF8_FULL_STOP_SIZE;
40036f74: 540000ec b.gt 40036f90 <msdos_filename_utf8_to_long_name_for_compare+0x40><== ALWAYS TAKEN
if (returned_size == 0) {
name_size = msdos_filename_delete_trailing_dots (
&utf8_name[0],
utf8_name_size);
if (name_size > 0) {
40036f78: 54000161 b.ne 40036fa4 <msdos_filename_utf8_to_long_name_for_compare+0x54> // b.any<== NOT EXECUTED
40036f7c: d503201f nop <== NOT EXECUTED
&dest_size);
if (eno == 0) {
returned_size = (ssize_t)dest_size;
}
} else {
eno = EINVAL;
40036f80: 528002d3 mov w19, #0x16 // #22 <== NOT EXECUTED
40036f84: 1400000e b 40036fbc <msdos_filename_utf8_to_long_name_for_compare+0x6c><== NOT EXECUTED
for ( i = size_returned - UTF8_FULL_STOP_SIZE;
40036f88: f1000484 subs x4, x4, #0x1
40036f8c: 54ffffa0 b.eq 40036f80 <msdos_filename_utf8_to_long_name_for_compare+0x30> // b.none<== NEVER TAKEN
&& filename_utf8[i] == UTF8_FULL_STOP;) {
40036f90: 51000482 sub w2, w4, #0x1
40036f94: 38624822 ldrb w2, [x1, w2, uxtw]
40036f98: 7100b85f cmp w2, #0x2e
40036f9c: 54ffff60 b.eq 40036f88 <msdos_filename_utf8_to_long_name_for_compare+0x38> // b.none
name_size = msdos_filename_delete_trailing_dots (
40036fa0: aa0403e2 mov x2, x4
eno = (*converter->handler->utf8_normalize_and_fold) (
40036fa4: f9400005 ldr x5, [x0]
40036fa8: 9100a3e4 add x4, sp, #0x28
40036fac: f94010a5 ldr x5, [x5, #32]
40036fb0: d63f00a0 blr x5
40036fb4: 2a0003f3 mov w19, w0
if (eno == 0) {
40036fb8: 34000280 cbz w0, 40037008 <msdos_filename_utf8_to_long_name_for_compare+0xb8><== ALWAYS TAKEN
}
}
if ( eno != 0 ) {
errno = eno;
40036fbc: 94000e6c bl 4003a96c <__errno> <== NOT EXECUTED
40036fc0: aa0003e1 mov x1, x0 <== NOT EXECUTED
returned_size = -1;
40036fc4: 92800000 mov x0, #0xffffffffffffffff // #-1 <== NOT EXECUTED
errno = eno;
40036fc8: b9000033 str w19, [x1] <== NOT EXECUTED
40036fcc: f9400bf3 ldr x19, [sp, #16] <== NOT EXECUTED
}
return returned_size;
}
40036fd0: a8c37bfd ldp x29, x30, [sp], #48 <== NOT EXECUTED
40036fd4: d65f03c0 ret <== NOT EXECUTED
&& src_size == UTF8_FULL_STOP_SIZE) {
40036fd8: f100045f cmp x2, #0x1 <== NOT EXECUTED
40036fdc: 540001e0 b.eq 40037018 <msdos_filename_utf8_to_long_name_for_compare+0xc8> // b.none<== NOT EXECUTED
&& src_size == ( 2 * UTF8_FULL_STOP_SIZE ) ) {
40036fe0: 39400426 ldrb w6, [x1, #1] <== NOT EXECUTED
40036fe4: 7100b8df cmp w6, #0x2e <== NOT EXECUTED
40036fe8: fa420840 ccmp x2, #0x2, #0x0, eq // eq = none <== NOT EXECUTED
40036fec: 54fffbe1 b.ne 40036f68 <msdos_filename_utf8_to_long_name_for_compare+0x18> // b.any<== NOT EXECUTED
if (dest_size >= 2 * UTF8_FULL_STOP_SIZE) {
40036ff0: f100049f cmp x4, #0x1 <== NOT EXECUTED
40036ff4: 540001c9 b.ls 4003702c <msdos_filename_utf8_to_long_name_for_compare+0xdc> // b.plast<== NOT EXECUTED
returned_size = 2 * UTF8_FULL_STOP_SIZE;
40036ff8: d2800040 mov x0, #0x2 // #2 <== NOT EXECUTED
dest_name[0] = UTF8_FULL_STOP;
40036ffc: 39000065 strb w5, [x3] <== NOT EXECUTED
dest_name[1] = UTF8_FULL_STOP;
40037000: 39000465 strb w5, [x3, #1] <== NOT EXECUTED
if (returned_size == 0) {
40037004: 17fffff3 b 40036fd0 <msdos_filename_utf8_to_long_name_for_compare+0x80><== NOT EXECUTED
returned_size = (ssize_t)dest_size;
40037008: f9400bf3 ldr x19, [sp, #16]
4003700c: f94017e0 ldr x0, [sp, #40]
}
40037010: a8c37bfd ldp x29, x30, [sp], #48
40037014: d65f03c0 ret
if (dest_size >= UTF8_FULL_STOP_SIZE) {
40037018: b40000a4 cbz x4, 4003702c <msdos_filename_utf8_to_long_name_for_compare+0xdc><== NOT EXECUTED
dest_name[0] = UTF8_FULL_STOP;
4003701c: 39000065 strb w5, [x3] <== NOT EXECUTED
returned_size = UTF8_FULL_STOP_SIZE;
40037020: aa0203e0 mov x0, x2 <== NOT EXECUTED
}
40037024: a8c37bfd ldp x29, x30, [sp], #48 <== NOT EXECUTED
40037028: d65f03c0 ret <== NOT EXECUTED
errno = eno;
4003702c: 94000e50 bl 4003a96c <__errno> <== NOT EXECUTED
40037030: aa0003e1 mov x1, x0 <== NOT EXECUTED
40037034: 52800b62 mov w2, #0x5b // #91 <== NOT EXECUTED
40037038: 92800000 mov x0, #0xffffffffffffffff // #-1 <== NOT EXECUTED
4003703c: b9000022 str w2, [x1] <== NOT EXECUTED
if (returned_size == 0) {
40037040: 17ffffe4 b 40036fd0 <msdos_filename_utf8_to_long_name_for_compare+0x80><== NOT EXECUTED
...
0000000040037050 <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)
{
40037050: a9bc7bfd stp x29, x30, [sp, #-64]!
40037054: aa0203e5 mov x5, x2
for ( i = size_returned - UTF8_FULL_STOP_SIZE;
40037058: f100005f cmp x2, #0x0
{
4003705c: 910003fd mov x29, sp
40037060: a90153f3 stp x19, x20, [sp, #16]
40037064: aa0303f3 mov x19, x3
40037068: f90013f5 str x21, [sp, #32]
4003706c: aa0403f5 mov x21, x4
size_t name_size_tmp;
int i;
uint16_t c;
unsigned int chars_written;
name_size_tmp = long_name_size;
40037070: f9001fe4 str x4, [sp, #56]
for ( i = size_returned - UTF8_FULL_STOP_SIZE;
40037074: 5400008c b.gt 40037084 <msdos_filename_utf8_to_long_name_for_save+0x34><== ALWAYS TAKEN
40037078: 14000047 b 40037194 <msdos_filename_utf8_to_long_name_for_save+0x144><== NOT EXECUTED
4003707c: f10004a5 subs x5, x5, #0x1
40037080: 54000d00 b.eq 40037220 <msdos_filename_utf8_to_long_name_for_save+0x1d0> // b.none<== NEVER TAKEN
&& filename_utf8[i] == UTF8_FULL_STOP;) {
40037084: 510004a2 sub w2, w5, #0x1
40037088: 38624822 ldrb w2, [x1, w2, uxtw]
4003708c: 7100b85f cmp w2, #0x2e
40037090: 54ffff60 b.eq 4003707c <msdos_filename_utf8_to_long_name_for_save+0x2c> // b.none
name_size = msdos_filename_delete_trailing_dots (
40037094: aa0503e2 mov x2, x5
utf8_name_size);
if (name_size > 0) {
/*
* Finally convert from UTF-8 to UTF-16
*/
eno = (*converter->handler->utf8_to_utf16) (
40037098: 9100e3e4 add x4, sp, #0x38
4003709c: f9400005 ldr x5, [x0]
400370a0: aa1303e3 mov x3, x19
400370a4: f94008a5 ldr x5, [x5, #16]
400370a8: d63f00a0 blr x5
400370ac: 2a0003f4 mov w20, w0
converter,
utf8_name,
name_size,
&long_name[0],
&name_size_tmp);
if (eno == 0) {
400370b0: 350008a0 cbnz w0, 400371c4 <msdos_filename_utf8_to_long_name_for_save+0x174><== NEVER TAKEN
if (name_size_tmp <= (MSDOS_NAME_MAX_LNF_LEN * MSDOS_NAME_LFN_BYTES_PER_CHAR))
400370b4: f9401fe3 ldr x3, [sp, #56]
400370b8: f107f87f cmp x3, #0x1fe
400370bc: 54000828 b.hi 400371c0 <msdos_filename_utf8_to_long_name_for_save+0x170> // b.pmore
ssize_t returned_size = 0;
400370c0: d2800000 mov x0, #0x0 // #0
if ( eno == 0 )
{
/*
* Validate the characters and assign them to the UTF-16 file name
*/
for ( i = 0;
400370c4: b4000a83 cbz x3, 40037214 <msdos_filename_utf8_to_long_name_for_save+0x1c4><== NEVER TAKEN
400370c8: d2800027 mov x7, #0x1 // #1
400370cc: f2a80007 movk x7, #0x4000, lsl #16
400370d0: d2cb0006 mov x6, #0x580000000000 // #96757023244288
retval = codepage_valid_char_map[char_num];
400370d4: d0000088 adrp x8, 40049000 <IMFS_node_control_sym_link+0xe0>
400370d8: 91178108 add x8, x8, #0x5e0
400370dc: f2dffe27 movk x7, #0xfff1, lsl #32
400370e0: f2e7ffe7 movk x7, #0x3fff, lsl #48
400370e4: d2800024 mov x4, #0x1 // #1
400370e8: f2e10006 movk x6, #0x800, lsl #48
400370ec: 1400000f b 40037128 <msdos_filename_utf8_to_long_name_for_save+0xd8>
switch ( char_num )
400370f0: 5100f422 sub w2, w1, #0x3d
400370f4: 12003c42 and w2, w2, #0xffff
400370f8: 7100f45f cmp w2, #0x3d
400370fc: 54000088 b.hi 4003710c <msdos_filename_utf8_to_long_name_for_save+0xbc> // b.pmore
40037100: 9ac22082 lsl x2, x4, x2
40037104: ea07005f tst x2, x7
40037108: 54000081 b.ne 40037118 <msdos_filename_utf8_to_long_name_for_save+0xc8> // b.any
retval = codepage_valid_char_map[char_num];
4003710c: 3861c901 ldrb w1, [x8, w1, sxtw]
name_size
&& (c = msdos_get_valid_utf16_filename_character ( long_name[i]) );
40037110: 72003c21 ands w1, w1, #0xffff
40037114: 54000260 b.eq 40037160 <msdos_filename_utf8_to_long_name_for_save+0x110> // b.none
++i ) {
long_name[i] = c;
40037118: 78206a61 strh w1, [x19, x0]
for ( i = 0;
4003711c: f1000863 subs x3, x3, #0x2
returned_size += MSDOS_NAME_LFN_BYTES_PER_CHAR;
40037120: 91000800 add x0, x0, #0x2
for ( i = 0;
40037124: 54000260 b.eq 40037170 <msdos_filename_utf8_to_long_name_for_save+0x120> // b.none
&& (c = msdos_get_valid_utf16_filename_character ( long_name[i]) );
40037128: 78606a61 ldrh w1, [x19, x0]
if ( char_num <= 0x00ff ) {
4003712c: 8b000265 add x5, x19, x0
40037130: 7103fc3f cmp w1, #0xff
40037134: 54ffff28 b.hi 40037118 <msdos_filename_utf8_to_long_name_for_save+0xc8> // b.pmore
switch ( char_num )
40037138: 7100ec3f cmp w1, #0x3b
4003713c: 54fffda8 b.hi 400370f0 <msdos_filename_utf8_to_long_name_for_save+0xa0> // b.pmore
40037140: 7100a83f cmp w1, #0x2a
40037144: 54fffe49 b.ls 4003710c <msdos_filename_utf8_to_long_name_for_save+0xbc> // b.plast
40037148: 9ac12082 lsl x2, x4, x1
4003714c: ea06005f tst x2, x6
40037150: 54fffe41 b.ne 40037118 <msdos_filename_utf8_to_long_name_for_save+0xc8> // b.any
retval = codepage_valid_char_map[char_num];
40037154: 3861c901 ldrb w1, [x8, w1, sxtw]
&& (c = msdos_get_valid_utf16_filename_character ( long_name[i]) );
40037158: 72003c21 ands w1, w1, #0xffff
4003715c: 54fffde1 b.ne 40037118 <msdos_filename_utf8_to_long_name_for_save+0xc8> // b.any
name_size -= MSDOS_NAME_LFN_BYTES_PER_CHAR;
}
if ( name_size == UTF16_NULL_SIZE && c == UTF16_NULL ) {
40037160: f100087f cmp x3, #0x2
40037164: 540003a1 b.ne 400371d8 <msdos_filename_utf8_to_long_name_for_save+0x188> // b.any<== ALWAYS TAKEN
long_name[i] = c;
returned_size += MSDOS_NAME_LFN_BYTES_PER_CHAR;
40037168: 91000800 add x0, x0, #0x2 <== NOT EXECUTED
long_name[i] = c;
4003716c: 790000bf strh wzr, [x5] <== NOT EXECUTED
}
else if ( name_size != 0 )
eno = EINVAL;
chars_written = returned_size / MSDOS_NAME_LFN_BYTES_PER_CHAR;
40037170: 9341fc02 asr x2, x0, #1
if ( long_name [chars_written - 1] != UTF16_NULL
40037174: 51000441 sub w1, w2, #0x1
40037178: 8b010021 add x1, x1, x1
4003717c: 78616a61 ldrh w1, [x19, x1]
40037180: 35000401 cbnz w1, 40037200 <msdos_filename_utf8_to_long_name_for_save+0x1b0><== ALWAYS TAKEN
errno = eno;
returned_size = -1;
}
return returned_size;
}
40037184: a94153f3 ldp x19, x20, [sp, #16]
40037188: f94013f5 ldr x21, [sp, #32]
4003718c: a8c47bfd ldp x29, x30, [sp], #64
40037190: d65f03c0 ret
if (name_size > 0) {
40037194: 54000460 b.eq 40037220 <msdos_filename_utf8_to_long_name_for_save+0x1d0> // b.none<== NOT EXECUTED
eno = (*converter->handler->utf8_to_utf16) (
40037198: f9400005 ldr x5, [x0] <== NOT EXECUTED
4003719c: 9100e3e4 add x4, sp, #0x38 <== NOT EXECUTED
400371a0: aa1303e3 mov x3, x19 <== NOT EXECUTED
400371a4: f94008a5 ldr x5, [x5, #16] <== NOT EXECUTED
400371a8: d63f00a0 blr x5 <== NOT EXECUTED
400371ac: 2a0003f4 mov w20, w0 <== NOT EXECUTED
if (eno == 0) {
400371b0: 350000a0 cbnz w0, 400371c4 <msdos_filename_utf8_to_long_name_for_save+0x174><== NOT EXECUTED
if (name_size_tmp <= (MSDOS_NAME_MAX_LNF_LEN * MSDOS_NAME_LFN_BYTES_PER_CHAR))
400371b4: f9401fe3 ldr x3, [sp, #56] <== NOT EXECUTED
400371b8: f107f87f cmp x3, #0x1fe <== NOT EXECUTED
400371bc: 54fff829 b.ls 400370c0 <msdos_filename_utf8_to_long_name_for_save+0x70> // b.plast<== NOT EXECUTED
eno = ENAMETOOLONG;
400371c0: 52800b74 mov w20, #0x5b // #91
errno = eno;
400371c4: 94000dea bl 4003a96c <__errno>
400371c8: aa0003e1 mov x1, x0
returned_size = -1;
400371cc: 92800000 mov x0, #0xffffffffffffffff // #-1
errno = eno;
400371d0: b9000034 str w20, [x1]
return returned_size;
400371d4: 17ffffec b 40037184 <msdos_filename_utf8_to_long_name_for_save+0x134>
chars_written = returned_size / MSDOS_NAME_LFN_BYTES_PER_CHAR;
400371d8: 9341fc01 asr x1, x0, #1
if ( long_name [chars_written - 1] != UTF16_NULL
400371dc: 51000422 sub w2, w1, #0x1
400371e0: 78627a62 ldrh w2, [x19, x2, lsl #1]
400371e4: 340001e2 cbz w2, 40037220 <msdos_filename_utf8_to_long_name_for_save+0x1d0><== NEVER TAKEN
&& (returned_size + UTF16_NULL_SIZE ) <= long_name_size ) {
400371e8: 91000800 add x0, x0, #0x2
400371ec: eb15001f cmp x0, x21
400371f0: 54000188 b.hi 40037220 <msdos_filename_utf8_to_long_name_for_save+0x1d0> // b.pmore<== NEVER TAKEN
eno = EINVAL;
400371f4: 528002d4 mov w20, #0x16 // #22
long_name[chars_written] = UTF16_NULL;
400371f8: 78217a7f strh wzr, [x19, x1, lsl #1]
if ( eno != 0 ) {
400371fc: 17fffff2 b 400371c4 <msdos_filename_utf8_to_long_name_for_save+0x174>
&& (returned_size + UTF16_NULL_SIZE ) <= long_name_size ) {
40037200: 91000801 add x1, x0, #0x2
40037204: eb15003f cmp x1, x21
40037208: 54fffbe8 b.hi 40037184 <msdos_filename_utf8_to_long_name_for_save+0x134> // b.pmore<== NEVER TAKEN
long_name[chars_written] = UTF16_NULL;
4003720c: 78227a7f strh wzr, [x19, x2, lsl #1]
if ( eno != 0 ) {
40037210: 17ffffdd b 40037184 <msdos_filename_utf8_to_long_name_for_save+0x134>
for ( i = 0;
40037214: b27f7fe1 mov x1, #0x1fffffffe // #8589934590 <== NOT EXECUTED
40037218: d2800002 mov x2, #0x0 // #0 <== NOT EXECUTED
4003721c: 17ffffd8 b 4003717c <msdos_filename_utf8_to_long_name_for_save+0x12c><== NOT EXECUTED
eno = EINVAL;
40037220: 528002d4 mov w20, #0x16 // #22 <== NOT EXECUTED
40037224: 17ffffe8 b 400371c4 <msdos_filename_utf8_to_long_name_for_save+0x174><== NOT EXECUTED
...
0000000040037230 <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)
{
40037230: a9b97bfd stp x29, x30, [sp, #-112]!
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);
40037234: d2800605 mov x5, #0x30 // #48
{
40037238: 910003fd mov x29, sp
4003723c: a90153f3 stp x19, x20, [sp, #16]
40037240: aa0303f4 mov x20, x3
40037244: f90013f5 str x21, [sp, #32]
size_t name_size_tmp = sizeof(name_normalized_buf);
40037248: f9001fe5 str x5, [sp, #56]
if ( src_name[0] == UTF8_FULL_STOP
4003724c: 39400025 ldrb w5, [x1]
40037250: 7100b8bf cmp w5, #0x2e
40037254: 540003c0 b.eq 400372cc <msdos_filename_utf8_to_short_name_for_compare+0x9c> // b.none
while ( *name_size >= UTF8_FULL_STOP_SIZE
40037258: b5000142 cbnz x2, 40037280 <msdos_filename_utf8_to_short_name_for_compare+0x50><== ALWAYS TAKEN
if ( eno == 0 ) {
memcpy (&dest_ptr[0], &name_ptr[0], name_size);
returned_size = name_size;
}
} else
eno = EINVAL;
4003725c: 528002d5 mov w21, #0x16 // #22 <== NOT EXECUTED
}
if ( eno != 0 ) {
errno = eno;
40037260: 94000dc3 bl 4003a96c <__errno> <== NOT EXECUTED
40037264: aa0003e1 mov x1, x0 <== NOT EXECUTED
returned_size = -1;
40037268: 92800000 mov x0, #0xffffffffffffffff // #-1 <== NOT EXECUTED
errno = eno;
4003726c: b9000035 str w21, [x1] <== NOT EXECUTED
}
return returned_size;
}
40037270: a94153f3 ldp x19, x20, [sp, #16]
40037274: f94013f5 ldr x21, [sp, #32]
40037278: a8c77bfd ldp x29, x30, [sp], #112
4003727c: d65f03c0 ret
eno = (*converter->handler->utf8_normalize_and_fold) (
40037280: f9400004 ldr x4, [x0]
40037284: 910103e3 add x3, sp, #0x40
40037288: f9401085 ldr x5, [x4, #32]
4003728c: 9100e3e4 add x4, sp, #0x38
40037290: d63f00a0 blr x5
40037294: 2a0003f5 mov w21, w0
if ( eno == ENOMEM ) {
40037298: 7100301f cmp w0, #0xc
name_size = name_size_tmp;
4003729c: f9401ff3 ldr x19, [sp, #56]
if ( eno == ENOMEM ) {
400372a0: 54000040 b.eq 400372a8 <msdos_filename_utf8_to_short_name_for_compare+0x78> // b.none<== NEVER TAKEN
if ( eno == 0 ) {
400372a4: 35fffdf5 cbnz w21, 40037260 <msdos_filename_utf8_to_short_name_for_compare+0x30><== NEVER TAKEN
memcpy (&dest_ptr[0], &name_ptr[0], name_size);
400372a8: 910103e1 add x1, sp, #0x40
400372ac: aa1303e2 mov x2, x19
400372b0: aa1403e0 mov x0, x20
400372b4: 94001051 bl 4003b3f8 <memcpy>
returned_size = name_size;
400372b8: aa1303e0 mov x0, x19
}
400372bc: a94153f3 ldp x19, x20, [sp, #16]
400372c0: f94013f5 ldr x21, [sp, #32]
400372c4: a8c77bfd ldp x29, x30, [sp], #112
400372c8: d65f03c0 ret
&& src_size == UTF8_FULL_STOP_SIZE) {
400372cc: f100045f cmp x2, #0x1
400372d0: 540001c0 b.eq 40037308 <msdos_filename_utf8_to_short_name_for_compare+0xd8> // b.none
&& src_size == ( 2 * UTF8_FULL_STOP_SIZE ) ) {
400372d4: 39400423 ldrb w3, [x1, #1]
400372d8: 7100b87f cmp w3, #0x2e
400372dc: fa420840 ccmp x2, #0x2, #0x0, eq // eq = none
400372e0: 54000220 b.eq 40037324 <msdos_filename_utf8_to_short_name_for_compare+0xf4> // b.none<== ALWAYS TAKEN
while ( *name_size >= UTF8_FULL_STOP_SIZE
400372e4: b50000a2 cbnz x2, 400372f8 <msdos_filename_utf8_to_short_name_for_compare+0xc8><== NOT EXECUTED
400372e8: 17ffffdd b 4003725c <msdos_filename_utf8_to_short_name_for_compare+0x2c><== NOT EXECUTED
&& **name_utf8 == UTF8_FULL_STOP) {
400372ec: 39400024 ldrb w4, [x1] <== NOT EXECUTED
400372f0: 7100b89f cmp w4, #0x2e <== NOT EXECUTED
400372f4: 54fffc61 b.ne 40037280 <msdos_filename_utf8_to_short_name_for_compare+0x50> // b.any<== NOT EXECUTED
*name_utf8 += UTF8_FULL_STOP_SIZE;
400372f8: 91000421 add x1, x1, #0x1 <== NOT EXECUTED
while ( *name_size >= UTF8_FULL_STOP_SIZE
400372fc: f1000442 subs x2, x2, #0x1 <== NOT EXECUTED
40037300: 54ffff61 b.ne 400372ec <msdos_filename_utf8_to_short_name_for_compare+0xbc> // b.any<== NOT EXECUTED
40037304: 17ffffd6 b 4003725c <msdos_filename_utf8_to_short_name_for_compare+0x2c><== NOT EXECUTED
if (dest_size >= UTF8_FULL_STOP_SIZE) {
40037308: b40001a4 cbz x4, 4003733c <msdos_filename_utf8_to_short_name_for_compare+0x10c><== NEVER TAKEN
dest_name[0] = UTF8_FULL_STOP;
4003730c: 39000065 strb w5, [x3]
returned_size = UTF8_FULL_STOP_SIZE;
40037310: aa0203e0 mov x0, x2
}
40037314: a94153f3 ldp x19, x20, [sp, #16]
40037318: f94013f5 ldr x21, [sp, #32]
4003731c: a8c77bfd ldp x29, x30, [sp], #112
40037320: d65f03c0 ret
if (dest_size >= 2 * UTF8_FULL_STOP_SIZE) {
40037324: f100049f cmp x4, #0x1
40037328: 540000a9 b.ls 4003733c <msdos_filename_utf8_to_short_name_for_compare+0x10c> // b.plast<== NEVER TAKEN
returned_size = 2 * UTF8_FULL_STOP_SIZE;
4003732c: d2800040 mov x0, #0x2 // #2
dest_name[0] = UTF8_FULL_STOP;
40037330: 39000285 strb w5, [x20]
dest_name[1] = UTF8_FULL_STOP;
40037334: 39000685 strb w5, [x20, #1]
if (returned_size == 0) {
40037338: 17ffffce b 40037270 <msdos_filename_utf8_to_short_name_for_compare+0x40>
errno = eno;
4003733c: 94000d8c bl 4003a96c <__errno> <== NOT EXECUTED
40037340: aa0003e1 mov x1, x0 <== NOT EXECUTED
40037344: 52800b62 mov w2, #0x5b // #91 <== NOT EXECUTED
40037348: 92800000 mov x0, #0xffffffffffffffff // #-1 <== NOT EXECUTED
4003734c: b9000022 str w2, [x1] <== NOT EXECUTED
if (returned_size == 0) {
40037350: 17ffffc8 b 40037270 <msdos_filename_utf8_to_short_name_for_compare+0x40><== NOT EXECUTED
...
0000000040037360 <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)
{
40037360: a9ba7bfd stp x29, x30, [sp, #-96]!
40037364: 910003fd mov x29, sp
40037368: a9025bf5 stp x21, x22, [sp, #32]
4003736c: aa0303f5 mov x21, x3
40037370: aa0403f6 mov x22, x4
if ( src_name[0] == UTF8_FULL_STOP
40037374: 39400025 ldrb w5, [x1]
40037378: 7100b8bf cmp w5, #0x2e
4003737c: 54000ec0 b.eq 40037554 <msdos_filename_utf8_to_short_name_for_save+0x1f4> // b.none<== NEVER TAKEN
while ( *name_size >= UTF8_FULL_STOP_SIZE
40037380: b5000122 cbnz x2, 400373a4 <msdos_filename_utf8_to_short_name_for_save+0x44><== ALWAYS TAKEN
else
eno = EINVAL;
}
if ( eno != 0 ) {
errno = eno;
40037384: 94000d7a bl 4003a96c <__errno> <== NOT EXECUTED
40037388: aa0003e1 mov x1, x0 <== NOT EXECUTED
4003738c: 528002c2 mov w2, #0x16 // #22 <== NOT EXECUTED
return -1;
40037390: 92800000 mov x0, #0xffffffffffffffff // #-1 <== NOT EXECUTED
errno = eno;
40037394: b9000022 str w2, [x1] <== NOT EXECUTED
}
return returned_size;
}
40037398: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
4003739c: a8c67bfd ldp x29, x30, [sp], #96 <== NOT EXECUTED
400373a0: d65f03c0 ret <== NOT EXECUTED
eno = (*converter->handler->utf8_to_codepage) (
400373a4: f9400003 ldr x3, [x0]
name_size_tmp = sizeof ( name_to_format_buf );
400373a8: d2800184 mov x4, #0xc // #12
eno = (*converter->handler->utf8_to_codepage) (
400373ac: f9400065 ldr x5, [x3]
name_size_tmp = sizeof ( name_to_format_buf );
400373b0: f90027e4 str x4, [sp, #72]
eno = (*converter->handler->utf8_to_codepage) (
400373b4: 910143e3 add x3, sp, #0x50
400373b8: 910123e4 add x4, sp, #0x48
400373bc: d63f00a0 blr x5
name_size = name_size_tmp;
400373c0: f94027e1 ldr x1, [sp, #72]
returned_size = msdos_filename_process_dot_names (
400373c4: d2800000 mov x0, #0x0 // #0
for (i = 0; i < name_size; ++i)
400373c8: b4fffe81 cbz x1, 40037398 <msdos_filename_utf8_to_short_name_for_save+0x38><== NEVER TAKEN
400373cc: 910143e2 add x2, sp, #0x50
400373d0: f0000084 adrp x4, 4004a000 <fatal_source_text+0x558>
400373d4: 91322484 add x4, x4, #0xc89
400373d8: 8b010047 add x7, x2, x1
400373dc: a90153f3 stp x19, x20, [sp, #16]
400373e0: a90363f7 stp x23, x24, [sp, #48]
400373e4: d503201f nop
name_to_format_buf[i] = toupper ( (unsigned char)(name_to_format_buf[i]) );
400373e8: 39400040 ldrb w0, [x2]
400373ec: 92401c03 and x3, x0, #0xff
400373f0: 51008005 sub w5, w0, #0x20
400373f4: 12001ca5 and w5, w5, #0xff
400373f8: 38636886 ldrb w6, [x4, x3]
400373fc: 120004c6 and w6, w6, #0x3
40037400: 710008df cmp w6, #0x2
40037404: 1a8000a0 csel w0, w5, w0, eq // eq = none
40037408: 38001440 strb w0, [x2], #1
for (i = 0; i < name_size; ++i)
4003740c: eb07005f cmp x2, x7
40037410: 54fffec1 b.ne 400373e8 <msdos_filename_utf8_to_short_name_for_save+0x88> // b.any
if ( 0x20 == *name_ptr )
40037414: 394143e0 ldrb w0, [sp, #80]
40037418: 7100801f cmp w0, #0x20
4003741c: 54000c40 b.eq 400375a4 <msdos_filename_utf8_to_short_name_for_save+0x244> // b.none
else if ( 0xE5 == *name_ptr )
40037420: 7103941f cmp w0, #0xe5
40037424: 54000e80 b.eq 400375f4 <msdos_filename_utf8_to_short_name_for_save+0x294> // b.none<== NEVER TAKEN
char c = codepage_valid_char_map[character];
40037428: d0000082 adrp x2, 40049000 <IMFS_node_control_sym_link+0xe0>
4003742c: 91178042 add x2, x2, #0x5e0
c = '_';
40037430: 52800be3 mov w3, #0x5f // #95
char c = codepage_valid_char_map[character];
40037434: 3860c840 ldrb w0, [x2, w0, sxtw]
c = '_';
40037438: 7100001f cmp w0, #0x0
4003743c: 1a831000 csel w0, w0, w3, ne // ne = any
dest_ptr[0] = msdos_get_valid_codepage_filename_character(*name_ptr);
40037440: 390002a0 strb w0, [x21]
char c = codepage_valid_char_map[character];
40037444: d0000083 adrp x3, 40049000 <IMFS_node_control_sym_link+0xe0>
40037448: 91178063 add x3, x3, #0x5e0
++returned_size;
4003744c: d2800034 mov x20, #0x1 // #1
--name_size;
40037450: d1000433 sub x19, x1, #0x1
++name_ptr;
40037454: 910147f7 add x23, sp, #0x51
40037458: 2a1403f8 mov w24, w20
c = '_';
4003745c: 52800be4 mov w4, #0x5f // #95
for (i = 1; i <= 7 && name_size && *name_ptr != '.'; ++i) {
40037460: b4000233 cbz x19, 400374a4 <msdos_filename_utf8_to_short_name_for_save+0x144>
40037464: 394002e0 ldrb w0, [x23]
++name_ptr;
40037468: 910006e2 add x2, x23, #0x1
--name_size;
4003746c: d1000661 sub x1, x19, #0x1
for (i = 1; i <= 7 && name_size && *name_ptr != '.'; ++i) {
40037470: 7100b81f cmp w0, #0x2e
40037474: 54000de0 b.eq 40037630 <msdos_filename_utf8_to_short_name_for_save+0x2d0> // b.none
char c = codepage_valid_char_map[character];
40037478: 3860c860 ldrb w0, [x3, w0, sxtw]
c = '_';
4003747c: 7100001f cmp w0, #0x0
40037480: 1a841000 csel w0, w0, w4, ne // ne = any
dest_ptr[i] = msdos_get_valid_codepage_filename_character(*name_ptr);
40037484: 38346aa0 strb w0, [x21, x20]
++returned_size;
40037488: 91000694 add x20, x20, #0x1
for (i = 1; i <= 7 && name_size && *name_ptr != '.'; ++i) {
4003748c: f100229f cmp x20, #0x8
40037490: 54000900 b.eq 400375b0 <msdos_filename_utf8_to_short_name_for_save+0x250> // b.none
--name_size;
40037494: aa0103f3 mov x19, x1
++name_ptr;
40037498: aa0203f7 mov x23, x2
dest_ptr[i] = msdos_get_valid_codepage_filename_character(*name_ptr);
4003749c: 2a1403f8 mov w24, w20
for (i = 1; i <= 7 && name_size && *name_ptr != '.'; ++i) {
400374a0: b5fffe33 cbnz x19, 40037464 <msdos_filename_utf8_to_short_name_for_save+0x104>
dest_ptr[i] = ' ';
400374a4: 8b1402a0 add x0, x21, x20
400374a8: 52800102 mov w2, #0x8 // #8
400374ac: 52800401 mov w1, #0x20 // #32
400374b0: 4b180042 sub w2, w2, w24
400374b4: 94000fec bl 4003b464 <memset>
400374b8: 91000694 add x20, x20, #0x1
400374bc: 528000e0 mov w0, #0x7 // #7
++returned_size;
400374c0: 4b180018 sub w24, w0, w24
400374c4: 8b140314 add x20, x24, x20
char c = codepage_valid_char_map[character];
400374c8: d0000084 adrp x4, 40049000 <IMFS_node_control_sym_link+0xe0>
400374cc: 91178084 add x4, x4, #0x5e0
400374d0: 91002261 add x1, x19, #0x8
dest_ptr[i] = msdos_get_valid_codepage_filename_character(*name_ptr);
400374d4: cb1402f7 sub x23, x23, x20
++returned_size;
400374d8: d2800100 mov x0, #0x8 // #8
c = '_';
400374dc: 52800be5 mov w5, #0x5f // #95
for (; i <= 10 && name_size ; i++) {
400374e0: eb00003f cmp x1, x0
400374e4: 2a0003e3 mov w3, w0
400374e8: 54000180 b.eq 40037518 <msdos_filename_utf8_to_short_name_for_save+0x1b8> // b.none
char c = codepage_valid_char_map[character];
400374ec: 38746ae2 ldrb w2, [x23, x20]
for (; i <= 10 && name_size ; i++) {
400374f0: 11000463 add w3, w3, #0x1
++returned_size;
400374f4: 91000694 add x20, x20, #0x1
char c = codepage_valid_char_map[character];
400374f8: 3862c882 ldrb w2, [x4, w2, sxtw]
c = '_';
400374fc: 7100005f cmp w2, #0x0
40037500: 1a851042 csel w2, w2, w5, ne // ne = any
dest_ptr[i] = msdos_get_valid_codepage_filename_character(*name_ptr);
40037504: 38206aa2 strb w2, [x21, x0]
for (; i <= 10 && name_size ; i++) {
40037508: 91000400 add x0, x0, #0x1
4003750c: 7100281f cmp w0, #0xa
40037510: 54fffe89 b.ls 400374e0 <msdos_filename_utf8_to_short_name_for_save+0x180> // b.plast
for ( ; i < short_name_size; ++i ) {
40037514: 2a0303e1 mov w1, w3
40037518: eb16003f cmp x1, x22
4003751c: aa1403e0 mov x0, x20
dest_ptr[i] = ' ';
40037520: 52800402 mov w2, #0x20 // #32
for ( ; i < short_name_size; ++i ) {
40037524: 540000e2 b.cs 40037540 <msdos_filename_utf8_to_short_name_for_save+0x1e0> // b.hs, b.nlast
++returned_size;
40037528: 91000400 add x0, x0, #0x1
dest_ptr[i] = ' ';
4003752c: 38216aa2 strb w2, [x21, x1]
for ( ; i < short_name_size; ++i ) {
40037530: 0b000061 add w1, w3, w0
40037534: 4b140021 sub w1, w1, w20
40037538: eb16003f cmp x1, x22
4003753c: 54ffff63 b.cc 40037528 <msdos_filename_utf8_to_short_name_for_save+0x1c8> // b.lo, b.ul, b.last
40037540: a94153f3 ldp x19, x20, [sp, #16]
}
40037544: a9425bf5 ldp x21, x22, [sp, #32]
40037548: a94363f7 ldp x23, x24, [sp, #48]
4003754c: a8c67bfd ldp x29, x30, [sp], #96
40037550: d65f03c0 ret
&& src_size == UTF8_FULL_STOP_SIZE) {
40037554: f100045f cmp x2, #0x1 <== NOT EXECUTED
40037558: 54000340 b.eq 400375c0 <msdos_filename_utf8_to_short_name_for_save+0x260> // b.none<== NOT EXECUTED
&& src_size == ( 2 * UTF8_FULL_STOP_SIZE ) ) {
4003755c: 39400423 ldrb w3, [x1, #1] <== NOT EXECUTED
40037560: 7100b87f cmp w3, #0x2e <== NOT EXECUTED
40037564: fa420840 ccmp x2, #0x2, #0x0, eq // eq = none <== NOT EXECUTED
40037568: 540004c0 b.eq 40037600 <msdos_filename_utf8_to_short_name_for_save+0x2a0> // b.none<== NOT EXECUTED
while ( *name_size >= UTF8_FULL_STOP_SIZE
4003756c: b50000a2 cbnz x2, 40037580 <msdos_filename_utf8_to_short_name_for_save+0x220><== NOT EXECUTED
40037570: 17ffff85 b 40037384 <msdos_filename_utf8_to_short_name_for_save+0x24><== NOT EXECUTED
&& **name_utf8 == UTF8_FULL_STOP) {
40037574: 39400023 ldrb w3, [x1] <== NOT EXECUTED
40037578: 7100b87f cmp w3, #0x2e <== NOT EXECUTED
4003757c: 54fff141 b.ne 400373a4 <msdos_filename_utf8_to_short_name_for_save+0x44> // b.any<== NOT EXECUTED
*name_utf8 += UTF8_FULL_STOP_SIZE;
40037580: 91000421 add x1, x1, #0x1 <== NOT EXECUTED
while ( *name_size >= UTF8_FULL_STOP_SIZE
40037584: f1000442 subs x2, x2, #0x1 <== NOT EXECUTED
40037588: 54ffff61 b.ne 40037574 <msdos_filename_utf8_to_short_name_for_save+0x214> // b.any<== NOT EXECUTED
errno = eno;
4003758c: 94000cf8 bl 4003a96c <__errno> <== NOT EXECUTED
40037590: aa0003e1 mov x1, x0 <== NOT EXECUTED
40037594: 528002c2 mov w2, #0x16 // #22 <== NOT EXECUTED
return -1;
40037598: 92800000 mov x0, #0xffffffffffffffff // #-1 <== NOT EXECUTED
errno = eno;
4003759c: b9000022 str w2, [x1] <== NOT EXECUTED
return -1;
400375a0: 17ffff7e b 40037398 <msdos_filename_utf8_to_short_name_for_save+0x38><== NOT EXECUTED
dest_ptr[0] = '_';
400375a4: 52800be0 mov w0, #0x5f // #95
400375a8: 390002a0 strb w0, [x21]
400375ac: 17ffffa6 b 40037444 <msdos_filename_utf8_to_short_name_for_save+0xe4>
if ( name_size > 0 && *name_ptr == '.' ) {
400375b0: b5000141 cbnz x1, 400375d8 <msdos_filename_utf8_to_short_name_for_save+0x278>
400375b4: aa1403e1 mov x1, x20
400375b8: 2a1403e3 mov w3, w20
400375bc: 17ffffd7 b 40037518 <msdos_filename_utf8_to_short_name_for_save+0x1b8>
if (dest_size >= UTF8_FULL_STOP_SIZE) {
400375c0: b40002c4 cbz x4, 40037618 <msdos_filename_utf8_to_short_name_for_save+0x2b8><== NOT EXECUTED
dest_name[0] = UTF8_FULL_STOP;
400375c4: 39000065 strb w5, [x3] <== NOT EXECUTED
returned_size = UTF8_FULL_STOP_SIZE;
400375c8: aa0203e0 mov x0, x2 <== NOT EXECUTED
}
400375cc: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
400375d0: a8c67bfd ldp x29, x30, [sp], #96 <== NOT EXECUTED
400375d4: d65f03c0 ret <== NOT EXECUTED
if ( name_size > 0 && *name_ptr == '.' ) {
400375d8: 39400040 ldrb w0, [x2]
++name_ptr;
400375dc: 91000af7 add x23, x23, #0x2
--name_size;
400375e0: d1000a73 sub x19, x19, #0x2
if ( name_size > 0 && *name_ptr == '.' ) {
400375e4: 7100b81f cmp w0, #0x2e
400375e8: 9a810273 csel x19, x19, x1, eq // eq = none
400375ec: 9a8202f7 csel x23, x23, x2, eq // eq = none
400375f0: 17ffffb6 b 400374c8 <msdos_filename_utf8_to_short_name_for_save+0x168>
dest_ptr[0] = 0x05;
400375f4: 528000a0 mov w0, #0x5 // #5 <== NOT EXECUTED
400375f8: 390002a0 strb w0, [x21] <== NOT EXECUTED
400375fc: 17ffff92 b 40037444 <msdos_filename_utf8_to_short_name_for_save+0xe4><== NOT EXECUTED
if (dest_size >= 2 * UTF8_FULL_STOP_SIZE) {
40037600: f100049f cmp x4, #0x1 <== NOT EXECUTED
40037604: 540000a9 b.ls 40037618 <msdos_filename_utf8_to_short_name_for_save+0x2b8> // b.plast<== NOT EXECUTED
returned_size = 2 * UTF8_FULL_STOP_SIZE;
40037608: d2800040 mov x0, #0x2 // #2 <== NOT EXECUTED
dest_name[0] = UTF8_FULL_STOP;
4003760c: 390002a5 strb w5, [x21] <== NOT EXECUTED
dest_name[1] = UTF8_FULL_STOP;
40037610: 390006a5 strb w5, [x21, #1] <== NOT EXECUTED
if (returned_size == 0) {
40037614: 17ffff61 b 40037398 <msdos_filename_utf8_to_short_name_for_save+0x38><== NOT EXECUTED
errno = eno;
40037618: 94000cd5 bl 4003a96c <__errno> <== NOT EXECUTED
4003761c: aa0003e1 mov x1, x0 <== NOT EXECUTED
40037620: 52800b62 mov w2, #0x5b // #91 <== NOT EXECUTED
40037624: 92800000 mov x0, #0xffffffffffffffff // #-1 <== NOT EXECUTED
40037628: b9000022 str w2, [x1] <== NOT EXECUTED
if (returned_size == 0) {
4003762c: 17ffff5b b 40037398 <msdos_filename_utf8_to_short_name_for_save+0x38><== NOT EXECUTED
++name_ptr;
40037630: 910006f7 add x23, x23, #0x1
--name_size;
40037634: d1000673 sub x19, x19, #0x1
40037638: 17ffff9b b 400374a4 <msdos_filename_utf8_to_short_name_for_save+0x144>
4003763c: 00000000 udf #0
0000000040032080 <msdos_find_name>:
{
40032080: a9b97bfd stp x29, x30, [sp, #-112]!
name_type = msdos_long_to_short (
40032084: 52800164 mov w4, #0xb // #11
{
40032088: 910003fd mov x29, sp
4003208c: a90153f3 stp x19, x20, [sp, #16]
40032090: aa0003f4 mov x20, x0
40032094: aa0103f3 mov x19, x1
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
40032098: f9401400 ldr x0, [x0, #40]
{
4003209c: a9025bf5 stp x21, x22, [sp, #32]
name_type = msdos_long_to_short (
400320a0: 910143e3 add x3, sp, #0x50
{
400320a4: 2a0203f5 mov w21, w2
fat_file_fd_t *fat_fd = NULL;
400320a8: f9001fff str xzr, [sp, #56]
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
400320ac: f9400816 ldr x22, [x0, #16]
memset(node_entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
400320b0: a9057fff stp xzr, xzr, [sp, #80]
400320b4: a9067fff stp xzr, xzr, [sp, #96]
name_type = msdos_long_to_short (
400320b8: f94086c0 ldr x0, [x22, #264]
400320bc: 97fff9d1 bl 40030800 <msdos_long_to_short>
rc = msdos_get_name_node(parent_loc, false, name, name_len, name_type,
400320c0: 2a0003e4 mov w4, w0
400320c4: aa1303e2 mov x2, x19
400320c8: 2a1503e3 mov w3, w21
400320cc: 910143e6 add x6, sp, #0x50
400320d0: aa1403e0 mov x0, x20
400320d4: 910103e5 add x5, sp, #0x40
400320d8: 52800001 mov w1, #0x0 // #0
400320dc: 97ffffb1 bl 40031fa0 <msdos_get_name_node>
400320e0: 2a0003f3 mov w19, w0
if (rc != RC_OK)
400320e4: 35000340 cbnz w0, 4003214c <msdos_find_name+0xcc>
if (((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_VOLUME_ID) ||
400320e8: 39416fe0 ldrb w0, [sp, #91]
return MSDOS_NAME_NOT_FOUND_ERR;
400320ec: 528fa033 mov w19, #0x7d01 // #32001
if (((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_VOLUME_ID) ||
400320f0: 371802e0 tbnz w0, #3, 4003214c <msdos_find_name+0xcc> <== NEVER TAKEN
400320f4: 12001400 and w0, w0, #0x3f
400320f8: 71003c1f cmp w0, #0xf
400320fc: 54000280 b.eq 4003214c <msdos_find_name+0xcc> // b.none <== NEVER TAKEN
rc = fat_file_open(&fs_info->fat, &dir_pos, &fat_fd);
40032100: 910103e1 add x1, sp, #0x40
40032104: 9100e3e2 add x2, sp, #0x38
40032108: aa1603e0 mov x0, x22
4003210c: 97fff3ad bl 4002efc0 <fat_file_open>
40032110: 2a0003f3 mov w19, w0
if (rc != RC_OK)
40032114: 350001c0 cbnz w0, 4003214c <msdos_find_name+0xcc> <== NEVER TAKEN
fat_fd->dir_pos = dir_pos;
40032118: a94387e2 ldp x2, x1, [sp, #56]
4003211c: f94027e0 ldr x0, [sp, #72]
40032120: a9028041 stp x1, x0, [x2, #40]
if (fat_fd->links_num == 1)
40032124: b9401040 ldr w0, [x2, #16]
40032128: 7100041f cmp w0, #0x1
4003212c: 540001a0 b.eq 40032160 <msdos_find_name+0xe0> // b.none
rc = fat_file_close(&fs_info->fat, parent_loc->node_access);
40032130: f9400a81 ldr x1, [x20, #16]
40032134: aa1603e0 mov x0, x22
40032138: 97fff556 bl 4002f690 <fat_file_close>
4003213c: 2a0003f3 mov w19, w0
if (rc != RC_OK)
40032140: 35000540 cbnz w0, 400321e8 <msdos_find_name+0x168> <== NEVER TAKEN
parent_loc->node_access = fat_fd;
40032144: f9401fe0 ldr x0, [sp, #56]
40032148: f9000a80 str x0, [x20, #16]
}
4003214c: 2a1303e0 mov w0, w19
40032150: a94153f3 ldp x19, x20, [sp, #16]
40032154: a9425bf5 ldp x21, x22, [sp, #32]
40032158: a8c77bfd ldp x29, x30, [sp], #112
4003215c: d65f03c0 ret
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);
40032160: 7940d7e4 ldrh w4, [sp, #106]
40032164: 7940cbe3 ldrh w3, [sp, #100]
fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
40032168: 7940cfe1 ldrh w1, [sp, #102]
4003216c: 7940d3e0 ldrh w0, [sp, #104]
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);
40032170: 2a034083 orr w3, w4, w3, lsl #16
40032174: b9002443 str w3, [x2, #36]
fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
40032178: 94001336 bl 40036e50 <msdos_date_dos2unix>
4003217c: 2a0003e2 mov w2, w0
40032180: f9401fe3 ldr x3, [sp, #56]
fat_fd->ctime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
40032184: 7940bfe1 ldrh w1, [sp, #94]
40032188: 7940c3e0 ldrh w0, [sp, #96]
fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
4003218c: f9002862 str x2, [x3, #80]
fat_fd->ctime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
40032190: 94001330 bl 40036e50 <msdos_date_dos2unix>
40032194: 2a0003e0 mov w0, w0
40032198: f9401fe1 ldr x1, [sp, #56]
if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
4003219c: 39416fe2 ldrb w2, [sp, #91]
fat_fd->ctime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
400321a0: f9002420 str x0, [x1, #72]
if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
400321a4: 372002a2 tbnz w2, #4, 400321f8 <msdos_find_name+0x178>
fat_fd->fat_file_size = CF_LE_L(*MSDOS_DIR_FILE_SIZE(node_entry));
400321a8: b9406fe0 ldr w0, [sp, #108]
fat_fd->fat_file_type = FAT_FILE;
400321ac: 929fff62 mov x2, #0xffffffffffff0004 // #-65532
400321b0: f2a00002 movk x2, #0x0, lsl #16
400321b4: f9000c22 str x2, [x1, #24]
fat_fd->fat_file_size = CF_LE_L(*MSDOS_DIR_FILE_SIZE(node_entry));
400321b8: b9002020 str w0, [x1, #32]
fat_fd->map.disk_cln = fat_fd->cln;
400321bc: b9402422 ldr w2, [x1, #36]
400321c0: 2907883f stp wzr, w2, [x1, #60]
if ((fat_fd->fat_file_size != 0) &&
400321c4: 340000c0 cbz w0, 400321dc <msdos_find_name+0x15c>
400321c8: b9400ac3 ldr w3, [x22, #8]
400321cc: 6b00007f cmp w3, w0
400321d0: 54000063 b.cc 400321dc <msdos_find_name+0x15c> // b.lo, b.ul, b.last
fat_fd->map.last_cln = fat_fd->cln;
400321d4: b9004422 str w2, [x1, #68]
400321d8: 17ffffd6 b 40032130 <msdos_find_name+0xb0>
fat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
400321dc: 12800000 mov w0, #0xffffffff // #-1
400321e0: b9004420 str w0, [x1, #68]
400321e4: 17ffffd3 b 40032130 <msdos_find_name+0xb0>
fat_file_close(&fs_info->fat, fat_fd);
400321e8: f9401fe1 ldr x1, [sp, #56] <== NOT EXECUTED
400321ec: aa1603e0 mov x0, x22 <== NOT EXECUTED
400321f0: 97fff528 bl 4002f690 <fat_file_close> <== NOT EXECUTED
return rc;
400321f4: 17ffffd6 b 4003214c <msdos_find_name+0xcc> <== NOT EXECUTED
fat_fd->fat_file_type = FAT_DIRECTORY;
400321f8: d2e00400 mov x0, #0x20000000000000 // #9007199254740992
400321fc: f9000c20 str x0, [x1, #24]
rc = fat_file_size(&fs_info->fat, fat_fd);
40032200: aa1603e0 mov x0, x22
40032204: 97fff6ef bl 4002fdc0 <fat_file_size>
40032208: 2a0003f3 mov w19, w0
fat_file_close(&fs_info->fat, fat_fd);
4003220c: f9401fe1 ldr x1, [sp, #56]
if (rc != RC_OK)
40032210: 35fffee0 cbnz w0, 400321ec <msdos_find_name+0x16c> <== NEVER TAKEN
if ((fat_fd->fat_file_size != 0) &&
40032214: b9402020 ldr w0, [x1, #32]
40032218: 17ffffe9 b 400321bc <msdos_find_name+0x13c>
4003221c: 00000000 udf #0
0000000040031170 <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)
{
40031170: d106c3ff sub sp, sp, #0x1b0
unsigned int lfn_entries;
rtems_dosfs_convert_control *converter = fs_info->converter;
void *buffer = converter->buffer.data;
size_t buffer_size = converter->buffer.size;
assert(name_utf8_len > 0);
40031174: 7100009f cmp w4, #0x0
{
40031178: a9017bfd stp x29, x30, [sp, #16]
4003117c: 910043fd add x29, sp, #0x10
40031180: a90253f3 stp x19, x20, [sp, #32]
msdos_fs_info_t *fs_info = mt_entry->fs_info;
40031184: f9400814 ldr x20, [x0, #16]
{
40031188: f90047e1 str x1, [sp, #136]
4003118c: a90d1fe3 stp x3, x7, [sp, #208]
rtems_dosfs_convert_control *converter = fs_info->converter;
40031190: f9408680 ldr x0, [x20, #264]
40031194: a90c03e6 stp x6, x0, [sp, #192]
{
40031198: b900f3e5 str w5, [sp, #240]
size_t buffer_size = converter->buffer.size;
4003119c: a9408001 ldp x1, x0, [x0, #8]
void *buffer = converter->buffer.data;
400311a0: f9005fe1 str x1, [sp, #184]
size_t buffer_size = converter->buffer.size;
400311a4: f90073e0 str x0, [sp, #224]
assert(name_utf8_len > 0);
400311a8: 54004f2d b.le 40031b8c <msdos_find_name_in_fat_file+0xa1c> <== NEVER TAKEN
400311ac: a90463f7 stp x23, x24, [sp, #64]
400311b0: 12001c58 and w24, w2, #0xff
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
400311b4: 12800000 mov w0, #0xffffffff // #-1
dir_pos->sname.cln = 0;
400311b8: f94063e2 ldr x2, [sp, #192]
400311bc: a90673fb stp x27, x28, [sp, #96]
fat_dir_pos_init(dir_pos);
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
400311c0: f94047e1 ldr x1, [sp, #136]
dir_pos->sname.ofs = 0;
400311c4: 29007c5f stp wzr, wzr, [x2]
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
400311c8: b9000840 str w0, [x2, #8]
400311cc: f9401421 ldr x1, [x1, #40]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
400311d0: b9000c40 str w0, [x2, #12]
400311d4: f100043f cmp x1, #0x1
400311d8: 54000560 b.eq 40031284 <msdos_find_name_in_fat_file+0x114> // b.none
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
else
bts2rd = fs_info->fat.vol.bpc;
switch ( name_type ) {
400311dc: b940f3e0 ldr w0, [sp, #240]
bts2rd = fs_info->fat.vol.bpc;
400311e0: b9400a9b ldr w27, [x20, #8]
switch ( name_type ) {
400311e4: 7100041f cmp w0, #0x1
400311e8: 540005e0 b.eq 400312a4 <msdos_find_name_in_fat_file+0x134> // b.none
400311ec: 7100081f cmp w0, #0x2
400311f0: 54000180 b.eq 40031220 <msdos_find_name_in_fat_file+0xb0> // b.none
}
else
retval = -1;
break;
default:
errno = EINVAL;
400311f4: 940025de bl 4003a96c <__errno>
400311f8: aa0003e1 mov x1, x0
400311fc: 528002c2 mov w2, #0x16 // #22
40031200: 12800000 mov w0, #0xffffffff // #-1
40031204: b9000022 str w2, [x1]
empty_entry_count
);
}
return retval;
}
40031208: a9417bfd ldp x29, x30, [sp, #16]
4003120c: a94253f3 ldp x19, x20, [sp, #32]
40031210: a94463f7 ldp x23, x24, [sp, #64]
40031214: a94673fb ldp x27, x28, [sp, #96]
40031218: 9106c3ff add sp, sp, #0x1b0
4003121c: d65f03c0 ret
40031220: a9035bf5 stp x21, x22, [sp, #48]
name_len_for_save = msdos_filename_utf8_to_long_name_for_save (
40031224: 93407c93 sxtw x19, w4
40031228: aa1303e2 mov x2, x19
4003122c: a94cdff6 ldp x22, x23, [sp, #200]
40031230: a9056bf9 stp x25, x26, [sp, #80]
40031234: f9405ff9 ldr x25, [sp, #184]
40031238: f9007ff3 str x19, [sp, #248]
4003123c: f94073fa ldr x26, [sp, #224]
40031240: aa1903e3 mov x3, x25
40031244: aa1703e1 mov x1, x23
40031248: aa1603e0 mov x0, x22
4003124c: aa1a03e4 mov x4, x26
40031250: 94001780 bl 40037050 <msdos_filename_utf8_to_long_name_for_save>
40031254: aa0003f5 mov x21, x0
if (name_len_for_save > 0) {
40031258: f100001f cmp x0, #0x0
4003125c: 54000d6c b.gt 40031408 <msdos_find_name_in_fat_file+0x298>
40031260: a9435bf5 ldp x21, x22, [sp, #48]
40031264: a9456bf9 ldp x25, x26, [sp, #80]
entry = fs_info->cl_buf;
40031268: 12800000 mov w0, #0xffffffff // #-1
}
4003126c: a9417bfd ldp x29, x30, [sp, #16]
40031270: a94253f3 ldp x19, x20, [sp, #32]
40031274: a94463f7 ldp x23, x24, [sp, #64]
40031278: a94673fb ldp x27, x28, [sp, #96]
4003127c: 9106c3ff add sp, sp, #0x1b0
40031280: d65f03c0 ret
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
40031284: 39405a80 ldrb w0, [x20, #22]
40031288: f240041f tst x0, #0x3
4003128c: 54fffa80 b.eq 400311dc <msdos_find_name_in_fat_file+0x6c> // b.none
bts2rd = fat_fd->fat_file_size;
40031290: f94047e0 ldr x0, [sp, #136]
40031294: b940201b ldr w27, [x0, #32]
switch ( name_type ) {
40031298: b940f3e0 ldr w0, [sp, #240]
4003129c: 7100041f cmp w0, #0x1
400312a0: 54fffa61 b.ne 400311ec <msdos_find_name_in_fat_file+0x7c> // b.any
name_len_for_compare = msdos_filename_utf8_to_short_name_for_compare (
400312a4: 93407c80 sxtw x0, w4
400312a8: f9007fe0 str x0, [sp, #248]
400312ac: aa0003e2 mov x2, x0
400312b0: d2800164 mov x4, #0xb // #11
400312b4: f9405fe3 ldr x3, [sp, #184]
400312b8: f94067e0 ldr x0, [sp, #200]
400312bc: f9406be1 ldr x1, [sp, #208]
400312c0: 940017dc bl 40037230 <msdos_filename_utf8_to_short_name_for_compare>
lfn_entries = 0;
400312c4: b90093ff str wzr, [sp, #144]
name_len_for_compare = msdos_filename_utf8_to_short_name_for_compare (
400312c8: aa0003f3 mov x19, x0
if (name_len_for_compare > 0) {
400312cc: f100001f cmp x0, #0x0
400312d0: 54fffccd b.le 40031268 <msdos_find_name_in_fat_file+0xf8> <== NEVER TAKEN
400312d4: a9035bf5 stp x21, x22, [sp, #48]
400312d8: a9056bf9 stp x25, x26, [sp, #80]
uint32_t entries_per_block = bts2rd / MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
400312dc: 53057f61 lsr w1, w27, #5
lfn_start->cln = FAT_FILE_SHORT_NAME;
400312e0: 12800000 mov w0, #0xffffffff // #-1
400312e4: f9003ff4 str x20, [sp, #120]
uint32_t entries_per_block = bts2rd / MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
400312e8: b900f7e1 str w1, [sp, #244]
assert(bytes_read == bts2rd);
400312ec: 2a1b03e1 mov w1, w27
lfn_start->cln = FAT_FILE_SHORT_NAME;
400312f0: b90113e0 str w0, [sp, #272]
int lfn_entry = 0;
400312f4: 52800002 mov w2, #0x0 // #0
rtems_dosfs_convert_control *converter = fs_info->converter;
400312f8: f9408680 ldr x0, [x20, #264]
assert(bytes_read == bts2rd);
400312fc: a90a87e0 stp x0, x1, [sp, #168]
bool empty_space_found = false;
40031300: 52800015 mov w21, #0x0 // #0
while ( (bytes_read = fat_file_read (&fs_info->fat, fat_fd, (dir_offset * bts2rd),
40031304: f9403fe0 ldr x0, [sp, #120]
40031308: aa1303f9 mov x25, x19
4003130c: f94047e1 ldr x1, [sp, #136]
40031310: 2a1503f6 mov w22, w21
40031314: f9408284 ldr x4, [x20, #256]
40031318: 2a1b03e3 mov w3, w27
4003131c: 2a1803f4 mov w20, w24
uint32_t empty_entry_count = 0;
40031320: 5280001c mov w28, #0x0 // #0
40031324: aa1303f8 mov x24, x19
uint32_t empty_file_offset = 0;
40031328: 5280001a mov w26, #0x0 // #0
4003132c: 2a0203f3 mov w19, w2
while ( (bytes_read = fat_file_read (&fs_info->fat, fat_fd, (dir_offset * bts2rd),
40031330: 2a1503e2 mov w2, w21
uint32_t dir_offset = 0;
40031334: b90083ff str wzr, [sp, #128]
uint8_t lfn_checksum = 0;
40031338: b9009fff str wzr, [sp, #156]
*entry_matched = false;
4003133c: 39043fff strb wzr, [sp, #271]
while ( (bytes_read = fat_file_read (&fs_info->fat, fat_fd, (dir_offset * bts2rd),
40031340: 97fff800 bl 4002f340 <fat_file_read>
&& rc == RC_OK)
40031344: b4001240 cbz x0, 4003158c <msdos_find_name_in_fat_file+0x41c> <== NEVER TAKEN
if (bytes_read < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
40031348: f1007c1f cmp x0, #0x1f
4003134c: 5400288d b.le 4003185c <msdos_find_name_in_fat_file+0x6ec> <== NEVER TAKEN
assert(bytes_read == bts2rd);
40031350: f9405be1 ldr x1, [sp, #176]
40031354: eb01001f cmp x0, x1
40031358: 540040a1 b.ne 40031b6c <msdos_find_name_in_fat_file+0x9fc> // b.any<== NEVER TAKEN
dir_entry < bts2rd && rc == RC_OK && (! filename_matched);
4003135c: f9403fe0 ldr x0, [sp, #120]
40031360: f9408004 ldr x4, [x0, #256]
for (dir_entry = 0;
40031364: 3400101b cbz w27, 40031564 <msdos_find_name_in_fat_file+0x3f4> <== NEVER TAKEN
lfn_start->cln = FAT_FILE_SHORT_NAME;
40031368: aa1903e5 mov x5, x25
for (dir_entry = 0;
4003136c: 52800017 mov w23, #0x0 // #0
lfn_start->cln = FAT_FILE_SHORT_NAME;
40031370: aa1803f9 mov x25, x24
40031374: 1280000b mov w11, #0xffffffff // #-1
40031378: 2a1503f8 mov w24, w21
4003137c: 14000014 b 400313cc <msdos_find_name_in_fat_file+0x25c>
if ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
40031380: 39402ea3 ldrb w3, [x21, #11]
if (create_node && !empty_space_found)
40031384: 520002c1 eor w1, w22, #0x1
40031388: 6a010281 ands w1, w20, w1
if ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
4003138c: 12001460 and w0, w3, #0x3f
*empty_entry_count = 0;
40031390: 1a9f035a csel w26, w26, wzr, eq // eq = none
40031394: 1a9f039c csel w28, w28, wzr, eq // eq = none
if ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
40031398: 71003c1f cmp w0, #0xf
4003139c: 540005a0 b.eq 40031450 <msdos_find_name_in_fat_file+0x2e0> // b.none
if (entry_matched)
400313a0: 39443fe0 ldrb w0, [sp, #271]
400313a4: 340006c0 cbz w0, 4003147c <msdos_find_name_in_fat_file+0x30c>
if (lfn_entry ||
400313a8: f10000bf cmp x5, #0x0
400313ac: 7a40da60 ccmp w19, #0x0, #0x0, le
400313b0: 54001bc0 b.eq 40031728 <msdos_find_name_in_fat_file+0x5b8> // b.none
}
400313b4: aa1903e5 mov x5, x25
*entry_matched = false;
400313b8: 39043fff strb wzr, [sp, #271]
lfn_start->cln = FAT_FILE_SHORT_NAME;
400313bc: b90113eb str w11, [sp, #272]
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
400313c0: 110082f7 add w23, w23, #0x20
for (dir_entry = 0;
400313c4: 6b17037f cmp w27, w23
400313c8: 54000c89 b.ls 40031558 <msdos_find_name_in_fat_file+0x3e8> // b.plast
bool entry_empty = (*MSDOS_DIR_ENTRY_TYPE(entry) ==
400313cc: 38774882 ldrb w2, [x4, w23, uxtw]
400313d0: 7100035f cmp w26, #0x0
400313d4: 0b170301 add w1, w24, w23
char* entry = (char*) fs_info->cl_buf + dir_entry;
400313d8: 8b374095 add x21, x4, w23, uxtw
if (*empty_entry_count == 0)
400313dc: 1a9c003c csel w28, w1, w28, eq // eq = none
if (remainder_empty)
400313e0: 340016e2 cbz w2, 400316bc <msdos_find_name_in_fat_file+0x54c>
else if (entry_empty)
400313e4: 7103945f cmp w2, #0xe5
400313e8: 54fffcc1 b.ne 40031380 <msdos_find_name_in_fat_file+0x210> // b.any
if (create_node)
400313ec: 34fffe54 cbz w20, 400313b4 <msdos_find_name_in_fat_file+0x244>
if (*empty_entry_count == (lfn_entries + 1))
400313f0: b94093e0 ldr w0, [sp, #144]
400313f4: 6b00035f cmp w26, w0
(*empty_entry_count)++;
400313f8: 1100075a add w26, w26, #0x1
if (*empty_entry_count == (lfn_entries + 1))
400313fc: 54fffdc1 b.ne 400313b4 <msdos_find_name_in_fat_file+0x244> // b.any
empty_space_found = true;
40031400: 2a1403f6 mov w22, w20
lfn_start->cln = FAT_FILE_SHORT_NAME;
40031404: 17ffffec b 400313b4 <msdos_find_name_in_fat_file+0x244>
name_len_for_compare = msdos_filename_utf8_to_long_name_for_compare (
40031408: aa1303e2 mov x2, x19
4003140c: aa1a03e4 mov x4, x26
40031410: aa1903e3 mov x3, x25
40031414: aa1703e1 mov x1, x23
40031418: aa1603e0 mov x0, x22
4003141c: 940016cd bl 40036f50 <msdos_filename_utf8_to_long_name_for_compare>
40031420: aa0003f3 mov x19, x0
if (0 >= name_len_for_compare) {
40031424: f100001f cmp x0, #0x0
40031428: 54fff1cd b.le 40031260 <msdos_find_name_in_fat_file+0xf0> <== NEVER TAKEN
lfn_entries = (name_len_for_save + MSDOS_LFN_ENTRY_SIZE - 1)
4003142c: 910066a1 add x1, x21, #0x19
/ MSDOS_LFN_ENTRY_SIZE;
40031430: d289d8a0 mov x0, #0x4ec5 // #20165
40031434: f2b89d80 movk x0, #0xc4ec, lsl #16
40031438: f2dd89c0 movk x0, #0xec4e, lsl #32
4003143c: f2e9d880 movk x0, #0x4ec4, lsl #48
40031440: 9bc07c20 umulh x0, x1, x0
lfn_entries = (name_len_for_save + MSDOS_LFN_ENTRY_SIZE - 1)
40031444: d3438800 ubfx x0, x0, #3, #32
40031448: f9004be0 str x0, [sp, #144]
4003144c: 17ffffa4 b 400312dc <msdos_find_name_in_fat_file+0x16c>
(lfn_start.cln == FAT_FILE_SHORT_NAME);
40031450: b94113e0 ldr w0, [sp, #272]
if (is_first_lfn_entry)
40031454: 3100041f cmn w0, #0x1
40031458: 54000b80 b.eq 400315c8 <msdos_find_name_in_fat_file+0x458> // b.none
if ((lfn_entry != (*MSDOS_DIR_ENTRY_TYPE(entry) &
4003145c: 12001442 and w2, w2, #0x3f
40031460: 6b13005f cmp w2, w19
40031464: 54fffa81 b.ne 400313b4 <msdos_find_name_in_fat_file+0x244> // b.any<== NEVER TAKEN
MSDOS_LAST_LONG_ENTRY_MASK)) ||
40031468: 394036a1 ldrb w1, [x21, #13]
4003146c: b9409fe2 ldr w2, [sp, #156]
40031470: 6b02003f cmp w1, w2
40031474: 54fffa01 b.ne 400313b4 <msdos_find_name_in_fat_file+0x244> // b.any<== NEVER TAKEN
40031478: 1400005e b 400315f0 <msdos_find_name_in_fat_file+0x480>
} else if ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_VOLUME_ID)
4003147c: 371ffa23 tbnz w3, #3, 400313c0 <msdos_find_name_in_fat_file+0x250>
size_t bytes_converted = buf_size;
40031480: d2800182 mov x2, #0xc // #12
ssize_t bytes_written = msdos_format_dirent_with_dot(char_buf, entry);
40031484: aa1503e1 mov x1, x21
40031488: 910483e0 add x0, sp, #0x120
size_t bytes_converted = buf_size;
4003148c: f9008fe2 str x2, [sp, #280]
ssize_t bytes_written = msdos_format_dirent_with_dot(char_buf, entry);
40031490: 97fffee0 bl 40031010 <msdos_format_dirent_with_dot>
40031494: aa0003e2 mov x2, x0
if (bytes_written > 0) {
40031498: f100001f cmp x0, #0x0
4003149c: 5400344d b.le 40031b24 <msdos_find_name_in_fat_file+0x9b4> <== NEVER TAKEN
if (char_buf[0] == 0x05)
400314a0: 394483e0 ldrb w0, [sp, #288]
400314a4: 7100141f cmp w0, #0x5
400314a8: 54000061 b.ne 400314b4 <msdos_find_name_in_fat_file+0x344> // b.any<== ALWAYS TAKEN
char_buf[0] = 0xE5;
400314ac: 12800340 mov w0, #0xffffffe5 // #-27 <== NOT EXECUTED
400314b0: 390483e0 strb w0, [sp, #288] <== NOT EXECUTED
eno = (*converter->handler->codepage_to_utf8) (
400314b4: f94057e6 ldr x6, [sp, #168]
400314b8: 910503e3 add x3, sp, #0x140
400314bc: 910483e1 add x1, sp, #0x120
400314c0: 910463e4 add x4, sp, #0x118
400314c4: f90053e3 str x3, [sp, #160]
400314c8: f94000c0 ldr x0, [x6]
400314cc: f9400405 ldr x5, [x0, #8]
400314d0: aa0603e0 mov x0, x6
400314d4: d63f00a0 blr x5
400314d8: 2a0003e1 mov w1, w0
if (eno == 0)
400314dc: 1280000b mov w11, #0xffffffff // #-1
400314e0: f94053e3 ldr x3, [sp, #160]
400314e4: 34000e60 cbz w0, 400316b0 <msdos_find_name_in_fat_file+0x540> <== ALWAYS TAKEN
errno = eno;
400314e8: b900a3e1 str w1, [sp, #160] <== NOT EXECUTED
400314ec: f90077e3 str x3, [sp, #232] <== NOT EXECUTED
400314f0: 9400251f bl 4003a96c <__errno> <== NOT EXECUTED
400314f4: f94077e3 ldr x3, [sp, #232] <== NOT EXECUTED
bytes_in_entry = msdos_short_entry_to_utf8_name (
400314f8: 92800002 mov x2, #0xffffffffffffffff // #-1 <== NOT EXECUTED
errno = eno;
400314fc: b940a3e1 ldr w1, [sp, #160] <== NOT EXECUTED
40031500: b9000001 str w1, [x0] <== NOT EXECUTED
40031504: d503201f nop <== NOT EXECUTED
name_len_remaining = msdos_compare_entry_against_filename (
40031508: aa0303e1 mov x1, x3
4003150c: 91043fe5 add x5, sp, #0x10f
40031510: f94057e0 ldr x0, [sp, #168]
40031514: aa1903e4 mov x4, x25
40031518: f9405fe3 ldr x3, [sp, #184]
4003151c: 97fffc19 bl 40030580 <msdos_compare_entry_against_filename>
if (entry_matched && name_len_remaining == 0) {
40031520: f100001f cmp x0, #0x0
40031524: 39443fe0 ldrb w0, [sp, #271]
40031528: 1a9f17e1 cset w1, eq // eq = none
4003152c: 1280000b mov w11, #0xffffffff // #-1
40031530: 6a00003f tst w1, w0
40031534: 54001161 b.ne 40031760 <msdos_find_name_in_fat_file+0x5f0> // b.any
}
40031538: aa1903e5 mov x5, x25
*entry_matched = false;
4003153c: 39043fff strb wzr, [sp, #271]
lfn_start->cln = FAT_FILE_SHORT_NAME;
40031540: b90113eb str w11, [sp, #272]
*name_len_remaining = name_len_for_compare;
40031544: f9403fe0 ldr x0, [sp, #120]
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
40031548: 110082f7 add w23, w23, #0x20
for (dir_entry = 0;
4003154c: 6b17037f cmp w27, w23
40031550: f9408004 ldr x4, [x0, #256]
40031554: 54fff3c8 b.hi 400313cc <msdos_find_name_in_fat_file+0x25c> // b.pmore
40031558: 2a1803f5 mov w21, w24
4003155c: aa1903f8 mov x24, x25
40031560: aa0503f9 mov x25, x5
dir_offset++;
40031564: b94083e0 ldr w0, [sp, #128]
40031568: 0b1b02b5 add w21, w21, w27
while ( (bytes_read = fat_file_read (&fs_info->fat, fat_fd, (dir_offset * bts2rd),
4003156c: f94047e1 ldr x1, [sp, #136]
dir_offset++;
40031570: 11000400 add w0, w0, #0x1
40031574: b90083e0 str w0, [sp, #128]
while ( (bytes_read = fat_file_read (&fs_info->fat, fat_fd, (dir_offset * bts2rd),
40031578: 2a1b03e3 mov w3, w27
4003157c: f9403fe0 ldr x0, [sp, #120]
40031580: 2a1503e2 mov w2, w21
40031584: 97fff76f bl 4002f340 <fat_file_read>
&& rc == RC_OK)
40031588: b5ffee00 cbnz x0, 40031348 <msdos_find_name_in_fat_file+0x1d8>
rc = MSDOS_NAME_NOT_FOUND_ERR;
4003158c: 2a1c03e0 mov w0, w28
40031590: 2a1403f8 mov w24, w20
40031594: 2a1a03fc mov w28, w26
40031598: 2a0003fa mov w26, w0
4003159c: 528fa020 mov w0, #0x7d01 // #32001
400315a0: f9403ff4 ldr x20, [sp, #120]
if (!create_node)
400315a4: 35000a38 cbnz w24, 400316e8 <msdos_find_name_in_fat_file+0x578>
}
400315a8: a9417bfd ldp x29, x30, [sp, #16]
400315ac: a94253f3 ldp x19, x20, [sp, #32]
400315b0: a9435bf5 ldp x21, x22, [sp, #48]
400315b4: a94463f7 ldp x23, x24, [sp, #64]
400315b8: a9456bf9 ldp x25, x26, [sp, #80]
400315bc: a94673fb ldp x27, x28, [sp, #96]
400315c0: 9106c3ff add sp, sp, #0x1b0
400315c4: d65f03c0 ret
entry_matched = false;
400315c8: 39043fff strb wzr, [sp, #271]
if ((*MSDOS_DIR_ENTRY_TYPE(entry) &
400315cc: 394002a1 ldrb w1, [x21]
400315d0: 3637ef81 tbz w1, #6, 400313c0 <msdos_find_name_in_fat_file+0x250>
lfn_start.cln = dir_offset;
400315d4: b94083e1 ldr w1, [sp, #128]
400315d8: b90113e1 str w1, [sp, #272]
lfn_start.ofs = dir_entry;
400315dc: b90117f7 str w23, [sp, #276]
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
400315e0: 394036a1 ldrb w1, [x21, #13]
lfn_entry = (*MSDOS_DIR_ENTRY_TYPE(entry)
400315e4: 394002a6 ldrb w6, [x21]
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
400315e8: b9009fe1 str w1, [sp, #156]
lfn_entry = (*MSDOS_DIR_ENTRY_TYPE(entry)
400315ec: 120014d3 and w19, w6, #0x3f
bool is_first_lfn_entry =
400315f0: 3100041f cmn w0, #0x1
size_t bytes_in_utf8 = buf_size;
400315f4: d2800e01 mov x1, #0x70 // #112
400315f8: 1a9f17e2 cset w2, eq // eq = none
400315fc: aa1503e0 mov x0, x21
40031600: f90053e5 str x5, [sp, #160]
lfn_entry--;
40031604: 51000673 sub w19, w19, #0x1
size_t bytes_in_utf8 = buf_size;
40031608: f9008fe1 str x1, [sp, #280]
4003160c: 910483e1 add x1, sp, #0x120
40031610: 97fffc44 bl 40030720 <msdos_get_utf16_string_from_long_entry.part.0>
if (buf_size >= MSDOS_LFN_ENTRY_SIZE) {
40031614: aa0003e2 mov x2, x0
if (retval >= 0) {
40031618: 910503e3 add x3, sp, #0x140
4003161c: f94053e5 ldr x5, [sp, #160]
40031620: b7f80300 tbnz x0, #63, 40031680 <msdos_find_name_in_fat_file+0x510> <== NEVER TAKEN
eno = (*converter->handler->utf16_to_utf8) (
40031624: f90077e5 str x5, [sp, #232]
40031628: 910503e3 add x3, sp, #0x140
4003162c: f94057e5 ldr x5, [sp, #168]
40031630: 910463e4 add x4, sp, #0x118
40031634: 910483e1 add x1, sp, #0x120
40031638: f90053e3 str x3, [sp, #160]
4003163c: f94000a0 ldr x0, [x5]
40031640: f9400c07 ldr x7, [x0, #24]
40031644: aa0503e0 mov x0, x5
40031648: d63f00e0 blr x7
4003164c: 2a0003f5 mov w21, w0
if ( eno == 0 ) {
40031650: 1280000b mov w11, #0xffffffff // #-1
40031654: f94053e3 ldr x3, [sp, #160]
40031658: f94077e5 ldr x5, [sp, #232]
4003165c: 34000600 cbz w0, 4003171c <msdos_find_name_in_fat_file+0x5ac>
errno = eno;
40031660: f90053e3 str x3, [sp, #160]
40031664: f90077e5 str x5, [sp, #232]
40031668: 940024c1 bl 4003a96c <__errno>
4003166c: f94053e3 ldr x3, [sp, #160]
bytes_in_entry = msdos_long_entry_to_utf8_name (
40031670: 92800002 mov x2, #0xffffffffffffffff // #-1
40031674: f94077e5 ldr x5, [sp, #232]
errno = eno;
40031678: b9000015 str w21, [x0]
if (bytes_in_entry > 0) {
4003167c: d503201f nop
name_len_remaining = msdos_compare_entry_against_filename (
40031680: aa0303e1 mov x1, x3
40031684: aa0503e4 mov x4, x5
40031688: f94057e0 ldr x0, [sp, #168]
4003168c: 91043fe5 add x5, sp, #0x10f
40031690: f9405fe3 ldr x3, [sp, #184]
40031694: 97fffbbb bl 40030580 <msdos_compare_entry_against_filename>
40031698: aa0003e5 mov x5, x0
if (name_len_remaining < 0 || !entry_matched) {
4003169c: 1280000b mov w11, #0xffffffff // #-1
400316a0: b7fff4c0 tbnz x0, #63, 40031538 <msdos_find_name_in_fat_file+0x3c8> <== NEVER TAKEN
400316a4: 39443fe0 ldrb w0, [sp, #271]
400316a8: 34fff480 cbz w0, 40031538 <msdos_find_name_in_fat_file+0x3c8>
400316ac: 17ffffa6 b 40031544 <msdos_find_name_in_fat_file+0x3d4>
bytes_written = bytes_converted;
400316b0: f9408fe2 ldr x2, [sp, #280]
if (bytes_in_entry > 0) {
400316b4: b4fff422 cbz x2, 40031538 <msdos_find_name_in_fat_file+0x3c8> <== NEVER TAKEN
400316b8: 17ffff94 b 40031508 <msdos_find_name_in_fat_file+0x398>
rc = MSDOS_NAME_NOT_FOUND_ERR;
400316bc: 2a1c03e0 mov w0, w28
400316c0: 2a1403f8 mov w24, w20
400316c4: 2a1a03fc mov w28, w26
400316c8: 2a0003fa mov w26, w0
400316cc: 528fa020 mov w0, #0x7d01 // #32001
400316d0: f9403ff4 ldr x20, [sp, #120]
if (!create_node)
400316d4: 34fff6b8 cbz w24, 400315a8 <msdos_find_name_in_fat_file+0x438>
if ( !empty_space_found
400316d8: 35000096 cbnz w22, 400316e8 <msdos_find_name_in_fat_file+0x578>
*empty_entry_count +=
400316dc: b940f7e0 ldr w0, [sp, #244]
400316e0: 0b1c0009 add w9, w0, w28
400316e4: 4b57153c sub w28, w9, w23, lsr #5
switch (name_type) {
400316e8: b940f3e0 ldr w0, [sp, #240]
400316ec: 7100041f cmp w0, #0x1
400316f0: 54000680 b.eq 400317c0 <msdos_find_name_in_fat_file+0x650> // b.none
400316f4: 7100081f cmp w0, #0x2
400316f8: 54000c20 b.eq 4003187c <msdos_find_name_in_fat_file+0x70c> // b.none<== ALWAYS TAKEN
errno = EINVAL;
400316fc: 9400249c bl 4003a96c <__errno> <== NOT EXECUTED
40031700: aa0003e1 mov x1, x0 <== NOT EXECUTED
40031704: 528002c2 mov w2, #0x16 // #22 <== NOT EXECUTED
retval = -1;
40031708: 12800000 mov w0, #0xffffffff // #-1 <== NOT EXECUTED
4003170c: a9435bf5 ldp x21, x22, [sp, #48] <== NOT EXECUTED
40031710: a9456bf9 ldp x25, x26, [sp, #80] <== NOT EXECUTED
errno = EINVAL;
40031714: b9000022 str w2, [x1] <== NOT EXECUTED
if (retval == RC_OK)
40031718: 17fffebc b 40031208 <msdos_find_name_in_fat_file+0x98> <== NOT EXECUTED
retval = bytes_in_utf8;
4003171c: f9408fe2 ldr x2, [sp, #280]
if (bytes_in_entry > 0) {
40031720: b4fff0c2 cbz x2, 40031538 <msdos_find_name_in_fat_file+0x3c8> <== NEVER TAKEN
40031724: 17ffffd7 b 40031680 <msdos_find_name_in_fat_file+0x510>
40031728: 910006a3 add x3, x21, #0x1
4003172c: 91002ea5 add x5, x21, #0xb
cs = 0;
40031730: 52800000 mov w0, #0x0 // #0
40031734: 14000002 b 4003173c <msdos_find_name_in_fat_file+0x5cc>
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + name[i];
40031738: 38401462 ldrb w2, [x3], #1
4003173c: 53017c01 lsr w1, w0, #1
for (i = 0; i < MSDOS_SHORT_NAME_LEN; ++i) {
40031740: eb0300bf cmp x5, x3
40031744: 0b001c20 add w0, w1, w0, lsl #7
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + name[i];
40031748: 0b200040 add w0, w2, w0, uxtb
4003174c: 12001c00 and w0, w0, #0xff
for (i = 0; i < MSDOS_SHORT_NAME_LEN; ++i) {
40031750: 54ffff41 b.ne 40031738 <msdos_find_name_in_fat_file+0x5c8> // b.any
name_len_remaining > 0 ||
40031754: b9409fe1 ldr w1, [sp, #156]
40031758: 6b01001f cmp w0, w1
4003175c: 54ffe2c1 b.ne 400313b4 <msdos_find_name_in_fat_file+0x244> // b.any<== NEVER TAKEN
rc = msdos_on_entry_found (
40031760: b94083e6 ldr w6, [sp, #128]
40031764: 2a1c03e0 mov w0, w28
40031768: f94047e1 ldr x1, [sp, #136]
4003176c: 2a1403f8 mov w24, w20
40031770: f94063e5 ldr x5, [sp, #192]
40031774: 2a1a03fc mov w28, w26
40031778: f9406fe3 ldr x3, [sp, #216]
4003177c: 2a0003fa mov w26, w0
40031780: f9403ff4 ldr x20, [sp, #120]
40031784: 910443e0 add x0, sp, #0x110
40031788: f90003e0 str x0, [sp]
4003178c: 2a1703e7 mov w7, w23
40031790: aa1503e4 mov x4, x21
40031794: 2a1b03e2 mov w2, w27
40031798: aa1403e0 mov x0, x20
4003179c: 97fffba9 bl 40030640 <msdos_on_entry_found>
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
400317a0: 110082e7 add w7, w23, #0x20
dir_entry < bts2rd && rc == RC_OK && (! filename_matched);
400317a4: 7100001f cmp w0, #0x0
for (dir_entry = 0;
400317a8: 7a470360 ccmp w27, w7, #0x0, eq // eq = none
400317ac: 54001d69 b.ls 40031b58 <msdos_find_name_in_fat_file+0x9e8> // b.plast
if ( retval == RC_OK
400317b0: 34ffefd8 cbz w24, 400315a8 <msdos_find_name_in_fat_file+0x438> <== ALWAYS TAKEN
switch (name_type) {
400317b4: b940f3e0 ldr w0, [sp, #240] <== NOT EXECUTED
400317b8: 7100041f cmp w0, #0x1 <== NOT EXECUTED
400317bc: 54fff9c1 b.ne 400316f4 <msdos_find_name_in_fat_file+0x584> // b.any<== NOT EXECUTED
name_len_for_save = msdos_filename_utf8_to_short_name_for_save (
400317c0: a94c87e0 ldp x0, x1, [sp, #200]
400317c4: d2800164 mov x4, #0xb // #11
400317c8: f9405fe3 ldr x3, [sp, #184]
400317cc: f9407fe2 ldr x2, [sp, #248]
400317d0: 940016e4 bl 40037360 <msdos_filename_utf8_to_short_name_for_save>
if (name_len_for_save > 0 ) {
400317d4: f100001f cmp x0, #0x0
400317d8: 54ffd44d b.le 40031260 <msdos_find_name_in_fat_file+0xf0> <== NEVER TAKEN
if (empty_entry_count < lfn_entries + 1)
400317dc: 34001abc cbz w28, 40031b30 <msdos_find_name_in_fat_file+0x9c0>
pos->ofs = file_offset & (bts2rd - 1);
400317e0: f94063e2 ldr x2, [sp, #192]
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
400317e4: 12800001 mov w1, #0xffffffff // #-1
pos->ofs = file_offset & (bts2rd - 1);
400317e8: 51000760 sub w0, w27, #0x1
return fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
400317ec: 2a1a03e3 mov w3, w26
pos->ofs = file_offset & (bts2rd - 1);
400317f0: 0a1a0000 and w0, w0, w26
return fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
400317f4: aa0203e4 mov x4, x2
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
400317f8: 29008440 stp w0, w1, [x2, #4]
return fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
400317fc: aa1403e0 mov x0, x20
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
40031800: b9000c41 str w1, [x2, #12]
return fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
40031804: 52800022 mov w2, #0x1 // #1
40031808: f94047e1 ldr x1, [sp, #136]
entry = fs_info->cl_buf;
4003180c: d2800415 mov x21, #0x20 // #32
return fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
40031810: 97fff7d4 bl 4002f760 <fat_file_ioctl>
entry = fs_info->cl_buf;
40031814: b9007bf5 str w21, [sp, #120]
40031818: f940829b ldr x27, [x20, #256]
memcpy(entry, name_dir_entry, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
4003181c: d2800402 mov x2, #0x20 // #32
40031820: f9406fe1 ldr x1, [sp, #216]
40031824: aa1b03e0 mov x0, x27
40031828: 940026f4 bl 4003b3f8 <memcpy>
bytes_written = fat_file_write(&fs_info->fat, fat_fd,
4003182c: b9407be3 ldr w3, [sp, #120]
40031830: 2a1a03e2 mov w2, w26
40031834: f94047e1 ldr x1, [sp, #136]
40031838: aa1403e0 mov x0, x20
4003183c: f9408284 ldr x4, [x20, #256]
40031840: 97fff8b4 bl 4002fb10 <fat_file_write>
40031844: aa0003e1 mov x1, x0
if (bytes_written == (ssize_t) length)
40031848: eb15003f cmp x1, x21
return 0;
4003184c: 52800000 mov w0, #0x0 // #0
if (bytes_written == (ssize_t) length)
40031850: 54ffeac0 b.eq 400315a8 <msdos_find_name_in_fat_file+0x438> // b.none<== ALWAYS TAKEN
else if (bytes_written == -1)
40031854: b100043f cmn x1, #0x1 <== NOT EXECUTED
40031858: 54ffd040 b.eq 40031260 <msdos_find_name_in_fat_file+0xf0> // b.none<== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
4003185c: 94002444 bl 4003a96c <__errno> <== NOT EXECUTED
40031860: aa0003e1 mov x1, x0 <== NOT EXECUTED
40031864: 528000a2 mov w2, #0x5 // #5 <== NOT EXECUTED
40031868: 12800000 mov w0, #0xffffffff // #-1 <== NOT EXECUTED
4003186c: a9435bf5 ldp x21, x22, [sp, #48] <== NOT EXECUTED
40031870: a9456bf9 ldp x25, x26, [sp, #80] <== NOT EXECUTED
40031874: b9000022 str w2, [x1] <== NOT EXECUTED
40031878: 17fffe64 b 40031208 <msdos_find_name_in_fat_file+0x98> <== NOT EXECUTED
name_len_for_save = msdos_filename_utf8_to_long_name_for_save (
4003187c: a94c87e0 ldp x0, x1, [sp, #200]
40031880: f9405fe3 ldr x3, [sp, #184]
40031884: f94073e4 ldr x4, [sp, #224]
40031888: f9407fe2 ldr x2, [sp, #248]
4003188c: 940015f1 bl 40037050 <msdos_filename_utf8_to_long_name_for_save>
if (name_len_for_save > 0) {
40031890: f100001f cmp x0, #0x0
40031894: 54ffce6d b.le 40031260 <msdos_find_name_in_fat_file+0xf0> <== NEVER TAKEN
lfn_entries = (name_len_for_save + MSDOS_LFN_ENTRY_SIZE - 1)
40031898: 91006416 add x22, x0, #0x19
/ MSDOS_LFN_ENTRY_SIZE;
4003189c: d289d8a0 mov x0, #0x4ec5 // #20165
400318a0: f2b89d80 movk x0, #0xc4ec, lsl #16
400318a4: f2dd89c0 movk x0, #0xec4e, lsl #32
400318a8: f2e9d880 movk x0, #0x4ec4, lsl #48
400318ac: 9bc07ed6 umulh x22, x22, x0
400318b0: d343fed6 lsr x22, x22, #3
if (empty_entry_count < lfn_entries + 1)
400318b4: 110006d9 add w25, w22, #0x1
400318b8: 6b1c033f cmp w25, w28
400318bc: 54000169 b.ls 400318e8 <msdos_find_name_in_fat_file+0x778> // b.plast
empty_file_offset = fat_fd->fat_file_size -
400318c0: f94047e1 ldr x1, [sp, #136]
ret = fat_file_extend(&fs_info->fat,
400318c4: 910503e4 add x4, sp, #0x140
400318c8: b9400a83 ldr w3, [x20, #8]
400318cc: aa1403e0 mov x0, x20
400318d0: 52800022 mov w2, #0x1 // #1
empty_file_offset = fat_fd->fat_file_size -
400318d4: b9402033 ldr w19, [x1, #32]
ret = fat_file_extend(&fs_info->fat,
400318d8: 0b030263 add w3, w19, w3
400318dc: 97fff7dd bl 4002f850 <fat_file_extend>
if (ret != RC_OK)
400318e0: 35ffe640 cbnz w0, 400315a8 <msdos_find_name_in_fat_file+0x438> <== NEVER TAKEN
empty_file_offset = fat_fd->fat_file_size -
400318e4: 4b1c167a sub w26, w19, w28, lsl #5
if ((*c == ' ') || (*c == '.'))
400318e8: f9406fe2 ldr x2, [sp, #216]
400318ec: 528005c1 mov w1, #0x2e // #46
slot = (empty_file_offset /
400318f0: 0b5a1724 add w4, w25, w26, lsr #5
if ((*c == ' ') || (*c == '.'))
400318f4: 39400040 ldrb w0, [x2]
400318f8: 7100801f cmp w0, #0x20
400318fc: 7a411004 ccmp w0, w1, #0x4, ne // ne = any
40031900: 54000061 b.ne 4003190c <msdos_find_name_in_fat_file+0x79c> // b.any<== ALWAYS TAKEN
*c = '_';
40031904: 52800be0 mov w0, #0x5f // #95 <== NOT EXECUTED
40031908: 39000040 strb w0, [x2] <== NOT EXECUTED
if ((*c == ' ') || (*c == '.'))
4003190c: f9406fe2 ldr x2, [sp, #216]
40031910: 528005c1 mov w1, #0x2e // #46
40031914: 39400440 ldrb w0, [x2, #1]
40031918: 7100801f cmp w0, #0x20
4003191c: 7a411004 ccmp w0, w1, #0x4, ne // ne = any
40031920: 54000fc0 b.eq 40031b18 <msdos_find_name_in_fat_file+0x9a8> // b.none
for (i = 0; i < 2; i++, c++)
40031924: f9406fe0 ldr x0, [sp, #216]
40031928: 900000c3 adrp x3, 40049000 <IMFS_node_control_sym_link+0xe0>
4003192c: 9110e063 add x3, x3, #0x438
40031930: 91000802 add x2, x0, #0x2
40031934: 52800180 mov w0, #0xc // #12
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
40031938: 1ac02481 lsr w1, w4, w0
4003193c: 12000c21 and w1, w1, #0xf
for (i = 0; i < 4; i++, c++)
40031940: 51001000 sub w0, w0, #0x4
40031944: 3100101f cmn w0, #0x4
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
40031948: 38614861 ldrb w1, [x3, w1, uxtw]
4003194c: 38001441 strb w1, [x2], #1
for (i = 0; i < 4; i++, c++)
40031950: 54ffff41 b.ne 40031938 <msdos_find_name_in_fat_file+0x7c8> // b.any
*c++ = '~';
40031954: f9406fe4 ldr x4, [sp, #216]
40031958: 52800fc2 mov w2, #0x7e // #126
*c = '1';
4003195c: 52800620 mov w0, #0x31 // #49
cs = 0;
40031960: 52800013 mov w19, #0x0 // #0
40031964: aa0403e1 mov x1, x4
40031968: 91002c83 add x3, x4, #0xb
*c++ = '~';
4003196c: 39001882 strb w2, [x4, #6]
*c = '1';
40031970: 39001c80 strb w0, [x4, #7]
for (i = 0; i < MSDOS_SHORT_NAME_LEN; ++i) {
40031974: d503201f nop
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + name[i];
40031978: 38401422 ldrb w2, [x1], #1
4003197c: 53190260 ubfiz w0, w19, #7, #1
for (i = 0; i < MSDOS_SHORT_NAME_LEN; ++i) {
40031980: eb01007f cmp x3, x1
40031984: 0b530453 add w19, w2, w19, lsr #1
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + name[i];
40031988: 0b330013 add w19, w0, w19, uxtb
4003198c: 12001e73 and w19, w19, #0xff
for (i = 0; i < MSDOS_SHORT_NAME_LEN; ++i) {
40031990: 54ffff41 b.ne 40031978 <msdos_find_name_in_fat_file+0x808> // b.any
pos->ofs = file_offset & (bts2rd - 1);
40031994: f94063f5 ldr x21, [sp, #192]
40031998: 5100077b sub w27, w27, #0x1
return fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
4003199c: f94047f7 ldr x23, [sp, #136]
pos->ofs = file_offset & (bts2rd - 1);
400319a0: 910022a4 add x4, x21, #0x8
400319a4: 0a1a0360 and w0, w27, w26
return fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
400319a8: 2a1a03e3 mov w3, w26
400319ac: aa1703e1 mov x1, x23
400319b0: 52800022 mov w2, #0x1 // #1
pos->ofs = file_offset & (bts2rd - 1);
400319b4: b9000480 str w0, [x4, #4]
return fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
400319b8: aa1403e0 mov x0, x20
400319bc: 97fff769 bl 4002f760 <fat_file_ioctl>
if (ret != RC_OK)
400319c0: 35ffdf40 cbnz w0, 400315a8 <msdos_find_name_in_fat_file+0x438> <== NEVER TAKEN
length = (lfn_entries + 1) * MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
400319c4: 531b6b25 lsl w5, w25, #5
short_file_offset = empty_file_offset + lfn_entries
400319c8: 0b161743 add w3, w26, w22, lsl #5
pos->ofs = file_offset & (bts2rd - 1);
400319cc: 0a1b0060 and w0, w3, w27
400319d0: b90006a0 str w0, [x21, #4]
return fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
400319d4: aa1503e4 mov x4, x21
400319d8: aa1703e1 mov x1, x23
400319dc: aa1403e0 mov x0, x20
if (bytes_written == (ssize_t) length)
400319e0: 2a0503f5 mov w21, w5
return fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
400319e4: 52800022 mov w2, #0x1 // #1
length = (lfn_entries + 1) * MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
400319e8: b9007be5 str w5, [sp, #120]
return fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
400319ec: 97fff75d bl 4002f760 <fat_file_ioctl>
entry = fs_info->cl_buf;
400319f0: f940829b ldr x27, [x20, #256]
for (lfn_entry = 0; lfn_entry < lfn_entries; ++lfn_entry) {
400319f4: 34fff156 cbz w22, 4003181c <msdos_find_name_in_fat_file+0x6ac> <== NEVER TAKEN
400319f8: 52800349 mov w9, #0x1a // #26
*MSDOS_DIR_ENTRY_TYPE(entry) = lfn_entries - lfn_entry;
400319fc: 12001ed8 and w24, w22, #0xff
for (lfn_entry = 0; lfn_entry < lfn_entries; ++lfn_entry) {
40031a00: 52800019 mov w25, #0x0 // #0
40031a04: 2a1303f7 mov w23, w19
40031a08: 1b167d29 mul w9, w9, w22
entry = fs_info->cl_buf;
40031a0c: aa1b03e6 mov x6, x27
40031a10: f9405ff3 ldr x19, [sp, #184]
40031a14: 5100693c sub w28, w9, #0x1a
40031a18: f90043f4 str x20, [sp, #128]
40031a1c: 2a1c03f4 mov w20, w28
40031a20: 2a1903fc mov w28, w25
40031a24: 2a1803f9 mov w25, w24
40031a28: 2a1603f8 mov w24, w22
40031a2c: d503201f nop
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
40031a30: aa0603e0 mov x0, x6
40031a34: d2800402 mov x2, #0x20 // #32
40031a38: 52800001 mov w1, #0x0 // #0
40031a3c: 9400268a bl 4003b464 <memset>
40031a40: aa0003e6 mov x6, x0
n = (const uint8_t *) name_converted +
40031a44: 8b344262 add x2, x19, w20, uxtw
40031a48: 91000400 add x0, x0, #0x1
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; ++i)
40031a4c: 52800001 mov w1, #0x0 // #0
uint8_t fill = 0;
40031a50: 52800005 mov w5, #0x0 // #0
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
40031a54: 390034d7 strb w23, [x6, #13]
if (*n != 0 || *(n + 1) != 0)
40031a58: 39400043 ldrb w3, [x2]
40031a5c: 35000223 cbnz w3, 40031aa0 <msdos_find_name_in_fat_file+0x930> <== ALWAYS TAKEN
40031a60: 39400444 ldrb w4, [x2, #1]
40031a64: 350001e4 cbnz w4, 40031aa0 <msdos_find_name_in_fat_file+0x930>
p [0] = fill;
40031a68: 39000005 strb w5, [x0]
switch (i)
40031a6c: 7100103f cmp w1, #0x4
p [1] = fill;
40031a70: 39000405 strb w5, [x0, #1]
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; ++i)
40031a74: 11000423 add w3, w1, #0x1
fill = 0xff;
40031a78: 52801fe5 mov w5, #0xff // #255
switch (i)
40031a7c: 54000200 b.eq 40031abc <msdos_find_name_in_fat_file+0x94c> // b.none
40031a80: 7100283f cmp w1, #0xa
40031a84: 54000440 b.eq 40031b0c <msdos_find_name_in_fat_file+0x99c> // b.none
p += 2;
40031a88: 91000800 add x0, x0, #0x2
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; ++i)
40031a8c: 7100347f cmp w3, #0xd
40031a90: 540001c0 b.eq 40031ac8 <msdos_find_name_in_fat_file+0x958> // b.none
40031a94: 2a0303e1 mov w1, w3
if (*n != 0 || *(n + 1) != 0)
40031a98: 39400043 ldrb w3, [x2]
40031a9c: 34fffe23 cbz w3, 40031a60 <msdos_find_name_in_fat_file+0x8f0>
*p = *n;
40031aa0: 39000003 strb w3, [x0]
n += MSDOS_NAME_LFN_BYTES_PER_CHAR;
40031aa4: 91000842 add x2, x2, #0x2
switch (i)
40031aa8: 7100103f cmp w1, #0x4
*(p + 1) = *(n + 1);
40031aac: 385ff043 ldurb w3, [x2, #-1]
40031ab0: 39000403 strb w3, [x0, #1]
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; ++i)
40031ab4: 11000423 add w3, w1, #0x1
switch (i)
40031ab8: 54fffe41 b.ne 40031a80 <msdos_find_name_in_fat_file+0x910> // b.any
p += 5;
40031abc: 91001400 add x0, x0, #0x5
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; ++i)
40031ac0: 2a0303e1 mov w1, w3
40031ac4: 17fffff5 b 40031a98 <msdos_find_name_in_fat_file+0x928>
*MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;
40031ac8: 39402cc0 ldrb w0, [x6, #11]
*MSDOS_DIR_ENTRY_TYPE(entry) = lfn_entries - lfn_entry;
40031acc: 4b1c0322 sub w2, w25, w28
40031ad0: 7100039f cmp w28, #0x0
40031ad4: 321a0041 orr w1, w2, #0x40
40031ad8: 1a820021 csel w1, w1, w2, eq // eq = none
*MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;
40031adc: 32000c00 orr w0, w0, #0xf
*MSDOS_DIR_ENTRY_TYPE(entry) = lfn_entries - lfn_entry;
40031ae0: 390000c1 strb w1, [x6]
for (lfn_entry = 0; lfn_entry < lfn_entries; ++lfn_entry) {
40031ae4: 1100079c add w28, w28, #0x1
*MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;
40031ae8: 39002cc0 strb w0, [x6, #11]
for (lfn_entry = 0; lfn_entry < lfn_entries; ++lfn_entry) {
40031aec: 51006a94 sub w20, w20, #0x1a
40031af0: 6b18039f cmp w28, w24
entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
40031af4: 910080c6 add x6, x6, #0x20
for (lfn_entry = 0; lfn_entry < lfn_entries; ++lfn_entry) {
40031af8: 54fff9c1 b.ne 40031a30 <msdos_find_name_in_fat_file+0x8c0> // b.any
entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
40031afc: d37b7ed6 ubfiz x22, x22, #5, #32
40031b00: 8b16037b add x27, x27, x22
40031b04: f94043f4 ldr x20, [sp, #128]
40031b08: 17ffff45 b 4003181c <msdos_find_name_in_fat_file+0x6ac>
p += 4;
40031b0c: 91001000 add x0, x0, #0x4
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; ++i)
40031b10: 2a0303e1 mov w1, w3
40031b14: 17ffffe1 b 40031a98 <msdos_find_name_in_fat_file+0x928>
*c = '_';
40031b18: 52800be0 mov w0, #0x5f // #95
40031b1c: 39000440 strb w0, [x2, #1]
40031b20: 17ffff81 b 40031924 <msdos_find_name_in_fat_file+0x7b4>
40031b24: 910503e3 add x3, sp, #0x140 <== NOT EXECUTED
eno = EINVAL;
40031b28: 528002c1 mov w1, #0x16 // #22 <== NOT EXECUTED
40031b2c: 17fffe6f b 400314e8 <msdos_find_name_in_fat_file+0x378> <== NOT EXECUTED
empty_file_offset = fat_fd->fat_file_size -
40031b30: f94047e1 ldr x1, [sp, #136]
ret = fat_file_extend(&fs_info->fat,
40031b34: 910503e4 add x4, sp, #0x140
40031b38: 3943c3e2 ldrb w2, [sp, #240]
40031b3c: aa1403e0 mov x0, x20
40031b40: b9400a83 ldr w3, [x20, #8]
empty_file_offset = fat_fd->fat_file_size -
40031b44: b940203a ldr w26, [x1, #32]
ret = fat_file_extend(&fs_info->fat,
40031b48: 0b030343 add w3, w26, w3
40031b4c: 97fff741 bl 4002f850 <fat_file_extend>
if (ret != RC_OK)
40031b50: 34ffe480 cbz w0, 400317e0 <msdos_find_name_in_fat_file+0x670> <== NEVER TAKEN
40031b54: 17fffe95 b 400315a8 <msdos_find_name_in_fat_file+0x438>
if ( retval == RC_OK
40031b58: 7100001f cmp w0, #0x0
40031b5c: 1a9f17e1 cset w1, eq // eq = none
&& create_node) {
40031b60: 0a010318 and w24, w24, w1
if ( retval == RC_OK
40031b64: 35ffe298 cbnz w24, 400317b4 <msdos_find_name_in_fat_file+0x644> <== NEVER TAKEN
40031b68: 17fffe90 b 400315a8 <msdos_find_name_in_fat_file+0x438>
assert(bytes_read == bts2rd);
40031b6c: 900000c3 adrp x3, 40049000 <IMFS_node_control_sym_link+0xe0> <== NOT EXECUTED
40031b70: 900000c2 adrp x2, 40049000 <IMFS_node_control_sym_link+0xe0> <== NOT EXECUTED
40031b74: 900000c0 adrp x0, 40049000 <IMFS_node_control_sym_link+0xe0> <== NOT EXECUTED
40031b78: 91108063 add x3, x3, #0x420 <== NOT EXECUTED
40031b7c: 91128042 add x2, x2, #0x4a0 <== NOT EXECUTED
40031b80: 910ee000 add x0, x0, #0x3b8 <== NOT EXECUTED
40031b84: 5280a9a1 mov w1, #0x54d // #1357 <== NOT EXECUTED
40031b88: 94001346 bl 400368a0 <__assert_func> <== NOT EXECUTED
assert(name_utf8_len > 0);
40031b8c: 900000c3 adrp x3, 40049000 <IMFS_node_control_sym_link+0xe0> <== NOT EXECUTED
40031b90: 900000c2 adrp x2, 40049000 <IMFS_node_control_sym_link+0xe0> <== NOT EXECUTED
40031b94: 900000c0 adrp x0, 40049000 <IMFS_node_control_sym_link+0xe0> <== NOT EXECUTED
40031b98: 91102063 add x3, x3, #0x408 <== NOT EXECUTED
40031b9c: 91130042 add x2, x2, #0x4c0 <== NOT EXECUTED
40031ba0: 910ee000 add x0, x0, #0x3b8 <== NOT EXECUTED
40031ba4: 5280e8c1 mov w1, #0x746 // #1862 <== NOT EXECUTED
40031ba8: a9035bf5 stp x21, x22, [sp, #48] <== NOT EXECUTED
40031bac: a90463f7 stp x23, x24, [sp, #64] <== NOT EXECUTED
40031bb0: a9056bf9 stp x25, x26, [sp, #80] <== NOT EXECUTED
40031bb4: a90673fb stp x27, x28, [sp, #96] <== NOT EXECUTED
40031bb8: 9400133a bl 400368a0 <__assert_func> <== NOT EXECUTED
40031bbc: 00000000 udf #0
0000000040031bc0 <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
)
{
40031bc0: a9ba7bfd stp x29, x30, [sp, #-96]!
40031bc4: 910003fd mov x29, sp
40031bc8: a90573fb stp x27, x28, [sp, #80]
40031bcc: aa0103fb mov x27, x1
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) &&
40031bd0: f9401421 ldr x1, [x1, #40]
{
40031bd4: a90153f3 stp x19, x20, [sp, #16]
40031bd8: a9025bf5 stp x21, x22, [sp, #32]
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
40031bdc: f100043f cmp x1, #0x1
{
40031be0: aa0303f5 mov x21, x3
40031be4: a90363f7 stp x23, x24, [sp, #48]
40031be8: aa0403f6 mov x22, x4
40031bec: a9046bf9 stp x25, x26, [sp, #64]
40031bf0: 2a0203f9 mov w25, w2
msdos_fs_info_t *fs_info = mt_entry->fs_info;
40031bf4: f940081a ldr x26, [x0, #16]
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
40031bf8: 54000560 b.eq 40031ca4 <msdos_find_node_by_cluster_num_in_fat_file+0xe4> // b.none
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
else
bts2rd = fs_info->fat.vol.bpc;
40031bfc: b9400b58 ldr w24, [x26, #8]
while ((ret = fat_file_read(&fs_info->fat, fat_fd, j * bts2rd, bts2rd,
40031c00: f9408344 ldr x4, [x26, #256]
fs_info->cl_buf)) != FAT_EOF)
{
if ( ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE )
rtems_set_errno_and_return_minus_one( EIO );
assert(ret == bts2rd);
40031c04: 2a1803f7 mov w23, w24
while ((ret = fat_file_read(&fs_info->fat, fat_fd, j * bts2rd, bts2rd,
40031c08: 5280001c mov w28, #0x0 // #0
40031c0c: 2a1803e3 mov w3, w24
40031c10: 2a1c03e2 mov w2, w28
40031c14: aa1b03e1 mov x1, x27
40031c18: aa1a03e0 mov x0, x26
40031c1c: 97fff5c9 bl 4002f340 <fat_file_read>
40031c20: b40002c0 cbz x0, 40031c78 <msdos_find_node_by_cluster_num_in_fat_file+0xb8><== NEVER TAKEN
if ( ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE )
40031c24: f1007c1f cmp x0, #0x1f
40031c28: 5400076d b.le 40031d14 <msdos_find_node_by_cluster_num_in_fat_file+0x154><== NEVER TAKEN
assert(ret == bts2rd);
40031c2c: eb0002ff cmp x23, x0
40031c30: 540007c1 b.ne 40031d28 <msdos_find_node_by_cluster_num_in_fat_file+0x168> // b.any<== NEVER TAKEN
for (i = 0; i < bts2rd; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
40031c34: 52800013 mov w19, #0x0 // #0
{
char* entry = (char*) fs_info->cl_buf + i;
40031c38: f9408344 ldr x4, [x26, #256]
for (i = 0; i < bts2rd; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
40031c3c: 35000198 cbnz w24, 40031c6c <msdos_find_node_by_cluster_num_in_fat_file+0xac><== ALWAYS TAKEN
40031c40: 14000017 b 40031c9c <msdos_find_node_by_cluster_num_in_fat_file+0xdc><== NOT EXECUTED
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)
return MSDOS_NAME_NOT_FOUND_ERR;
/* if this entry is empty - skip it */
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
40031c44: 7103941f cmp w0, #0xe5
40031c48: 540000c0 b.eq 40031c60 <msdos_find_node_by_cluster_num_in_fat_file+0xa0> // b.none<== NEVER TAKEN
MSDOS_THIS_DIR_ENTRY_EMPTY)
continue;
/* if get a non-empty entry - compare clusters num */
if (MSDOS_EXTRACT_CLUSTER_NUM(entry) == cl4find)
40031c4c: 79402a80 ldrh w0, [x20, #20]
40031c50: 79403685 ldrh w5, [x20, #26]
40031c54: 2a0040a0 orr w0, w5, w0, lsl #16
40031c58: 6b19001f cmp w0, w25
40031c5c: 540002e0 b.eq 40031cb8 <msdos_find_node_by_cluster_num_in_fat_file+0xf8> // b.none
for (i = 0; i < bts2rd; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
40031c60: 11008273 add w19, w19, #0x20
40031c64: 6b18027f cmp w19, w24
40031c68: 540001a2 b.cs 40031c9c <msdos_find_node_by_cluster_num_in_fat_file+0xdc> // b.hs, b.nlast<== NEVER TAKEN
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
40031c6c: 38734880 ldrb w0, [x4, w19, uxtw]
char* entry = (char*) fs_info->cl_buf + i;
40031c70: 8b334094 add x20, x4, w19, uxtw
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
40031c74: 35fffe80 cbnz w0, 40031c44 <msdos_find_node_by_cluster_num_in_fat_file+0x84><== ALWAYS TAKEN
return MSDOS_NAME_NOT_FOUND_ERR;
40031c78: 528fa037 mov w23, #0x7d01 // #32001 <== NOT EXECUTED
}
}
j++;
}
return MSDOS_NAME_NOT_FOUND_ERR;
}
40031c7c: 2a1703e0 mov w0, w23 <== NOT EXECUTED
40031c80: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40031c84: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
40031c88: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
40031c8c: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
40031c90: a94573fb ldp x27, x28, [sp, #80] <== NOT EXECUTED
40031c94: a8c67bfd ldp x29, x30, [sp], #96 <== NOT EXECUTED
40031c98: d65f03c0 ret <== NOT EXECUTED
j++;
40031c9c: 0b18039c add w28, w28, w24 <== NOT EXECUTED
40031ca0: 17ffffdb b 40031c0c <msdos_find_node_by_cluster_num_in_fat_file+0x4c><== NOT EXECUTED
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
40031ca4: 39405b40 ldrb w0, [x26, #22]
40031ca8: f240041f tst x0, #0x3
40031cac: 54fffa80 b.eq 40031bfc <msdos_find_node_by_cluster_num_in_fat_file+0x3c> // b.none<== NEVER TAKEN
bts2rd = fat_fd->fat_file_size;
40031cb0: b9402378 ldr w24, [x27, #32]
40031cb4: 17ffffd3 b 40031c00 <msdos_find_node_by_cluster_num_in_fat_file+0x40>
rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM, j * bts2rd,
40031cb8: 2a1c03e3 mov w3, w28
40031cbc: aa1b03e1 mov x1, x27
40031cc0: aa1a03e0 mov x0, x26
40031cc4: aa1503e4 mov x4, x21
40031cc8: 52800022 mov w2, #0x1 // #1
40031ccc: 97fff6a5 bl 4002f760 <fat_file_ioctl>
40031cd0: 2a0003f7 mov w23, w0
if (rc != RC_OK)
40031cd4: 35fffd40 cbnz w0, 40031c7c <msdos_find_node_by_cluster_num_in_fat_file+0xbc><== NEVER TAKEN
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
40031cd8: 12800000 mov w0, #0xffffffff // #-1
40031cdc: 290082b3 stp w19, w0, [x21, #4]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
40031ce0: b9000ea0 str w0, [x21, #12]
memcpy(dir_entry, entry,
40031ce4: aa1403e1 mov x1, x20
40031ce8: aa1603e0 mov x0, x22
40031cec: d2800402 mov x2, #0x20 // #32
40031cf0: 940025c2 bl 4003b3f8 <memcpy>
}
40031cf4: 2a1703e0 mov w0, w23
40031cf8: a94153f3 ldp x19, x20, [sp, #16]
40031cfc: a9425bf5 ldp x21, x22, [sp, #32]
40031d00: a94363f7 ldp x23, x24, [sp, #48]
40031d04: a9446bf9 ldp x25, x26, [sp, #64]
40031d08: a94573fb ldp x27, x28, [sp, #80]
40031d0c: a8c67bfd ldp x29, x30, [sp], #96
40031d10: d65f03c0 ret
rtems_set_errno_and_return_minus_one( EIO );
40031d14: 94002316 bl 4003a96c <__errno> <== NOT EXECUTED
40031d18: 12800017 mov w23, #0xffffffff // #-1 <== NOT EXECUTED
40031d1c: 528000a1 mov w1, #0x5 // #5 <== NOT EXECUTED
40031d20: b9000001 str w1, [x0] <== NOT EXECUTED
40031d24: 17ffffd6 b 40031c7c <msdos_find_node_by_cluster_num_in_fat_file+0xbc><== NOT EXECUTED
assert(ret == bts2rd);
40031d28: 900000c3 adrp x3, 40049000 <IMFS_node_control_sym_link+0xe0> <== NOT EXECUTED
40031d2c: 900000c2 adrp x2, 40049000 <IMFS_node_control_sym_link+0xe0> <== NOT EXECUTED
40031d30: 900000c0 adrp x0, 40049000 <IMFS_node_control_sym_link+0xe0> <== NOT EXECUTED
40031d34: 91114063 add x3, x3, #0x450 <== NOT EXECUTED
40031d38: 9111c042 add x2, x2, #0x470 <== NOT EXECUTED
40031d3c: 910ee000 add x0, x0, #0x3b8 <== NOT EXECUTED
40031d40: 5280fe21 mov w1, #0x7f1 // #2033 <== NOT EXECUTED
40031d44: 940012d7 bl 400368a0 <__assert_func> <== NOT EXECUTED
...
0000000040024600 <msdos_format>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
40024600: a9ac7bfd stp x29, x30, [sp, #-320]!
memset(&fmt_params, 0, sizeof(fmt_params));
/*
* open device for writing
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "open device\n");
40024604: 90000122 adrp x2, 40048000 <bsp_section_rodata_begin+0x78>
40024608: 91288042 add x2, x2, #0xa20
{
4002460c: 910003fd mov x29, sp
40024610: a90153f3 stp x19, x20, [sp, #16]
40024614: aa0103f4 mov x20, x1
40024618: a9025bf5 stp x21, x22, [sp, #32]
4002461c: aa0003f6 mov x22, x0
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "open device\n");
40024620: aa0103e0 mov x0, x1
40024624: 52800041 mov w1, #0x2 // #2
memset(&fmt_params, 0, sizeof(fmt_params));
40024628: a907ffff stp xzr, xzr, [sp, #120]
4002462c: a908ffff stp xzr, xzr, [sp, #136]
40024630: a909ffff stp xzr, xzr, [sp, #152]
40024634: a90affff stp xzr, xzr, [sp, #168]
40024638: a90bffff stp xzr, xzr, [sp, #184]
4002463c: a90cffff stp xzr, xzr, [sp, #200]
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "open device\n");
40024640: 97ffff3c bl 40024330 <msdos_format_printf>
fd = open(devname, O_RDWR);
40024644: 52800041 mov w1, #0x2 // #2
40024648: aa1603e0 mov x0, x22
4002464c: 97fff8d5 bl 400229a0 <open>
}
/*
* sanity check on device
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
40024650: 90000122 adrp x2, 40048000 <bsp_section_rodata_begin+0x78>
fd = open(devname, O_RDWR);
40024654: 2a0003f3 mov w19, w0
if (fd == -1) {
40024658: 3100041f cmn w0, #0x1
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4002465c: aa1603e3 mov x3, x22
40024660: 9128c042 add x2, x2, #0xa30
40024664: aa1403e0 mov x0, x20
40024668: 52800041 mov w1, #0x2 // #2
if (fd == -1) {
4002466c: 540024e0 b.eq 40024b08 <msdos_format+0x508> // b.none <== NEVER TAKEN
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
40024670: 97ffff30 bl 40024330 <msdos_format_printf>
"stat check: %s\n", devname);
if (ret_val == 0) {
ret_val = fstat(fd, &stat_buf);
40024674: 910363e1 add x1, sp, #0xd8
40024678: 2a1303e0 mov w0, w19
4002467c: 97fff601 bl 40021e80 <fstat>
40024680: 2a0003f5 mov w21, w0
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
40024684: 90000122 adrp x2, 40048000 <bsp_section_rodata_begin+0x78>
40024688: aa1603e3 mov x3, x22
4002468c: 91290042 add x2, x2, #0xa40
40024690: aa1403e0 mov x0, x20
40024694: 52800021 mov w1, #0x1 // #1
40024698: 97ffff26 bl 40024330 <msdos_format_printf>
"formating: %s\n", devname);
/* rtems feature: no block devices, all are character devices */
if ((ret_val == 0) && (!S_ISBLK(stat_buf.st_mode))) {
4002469c: 35002255 cbnz w21, 40024ae4 <msdos_format+0x4e4> <== NEVER TAKEN
400246a0: b940ebe0 ldr w0, [sp, #232]
400246a4: 12140c00 and w0, w0, #0xf000
400246a8: 7140181f cmp w0, #0x6, lsl #12
400246ac: 54002141 b.ne 40024ad4 <msdos_format+0x4d4> // b.any <== NEVER TAKEN
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);
400246b0: 9101e3e2 add x2, sp, #0x78
400246b4: 2a1303e0 mov w0, w19
400246b8: d2884041 mov x1, #0x4202 // #16898
400246bc: f2a80081 movk x1, #0x4004, lsl #16
memset(fmt_params,0,sizeof(*fmt_params));
400246c0: a907ffff stp xzr, xzr, [sp, #120]
400246c4: a908ffff stp xzr, xzr, [sp, #136]
400246c8: a909ffff stp xzr, xzr, [sp, #152]
400246cc: a90affff stp xzr, xzr, [sp, #168]
400246d0: a90bffff stp xzr, xzr, [sp, #184]
400246d4: a90cffff stp xzr, xzr, [sp, #200]
400246d8: 9400205a bl 4002c840 <ioctl>
400246dc: b9407fe2 ldr w2, [sp, #124]
400246e0: 2a0003f5 mov w21, w0
if (ret_val == 0) {
400246e4: 34002380 cbz w0, 40024b54 <msdos_format+0x554> <== ALWAYS TAKEN
fmt_params->rsvd_sector_cnt
400246e8: b94083f6 ldr w22, [sp, #128]
if ( fmt_params->totl_sector_cnt == 0 )
400246ec: 350000c2 cbnz w2, 40024704 <msdos_format+0x104> <== ALWAYS TAKEN
errno = EINVAL;
400246f0: 9400589f bl 4003a96c <__errno> <== NOT EXECUTED
ret_val = -1;
400246f4: 12800015 mov w21, #0xffffffff // #-1 <== NOT EXECUTED
errno = EINVAL;
400246f8: 528002c1 mov w1, #0x16 // #22 <== NOT EXECUTED
400246fc: b9000001 str w1, [x0] <== NOT EXECUTED
fmt_params->rsvd_sector_cnt
40024700: b94083f6 ldr w22, [sp, #128] <== NOT EXECUTED
+ (fmt_params-> fat_num*fmt_params->sectors_per_fat);
40024704: 3942a3e0 ldrb w0, [sp, #168]
40024708: b9408be2 ldr w2, [sp, #136]
if (fmt_params->root_dir_sectors > 0) {
4002470c: b94097e1 ldr w1, [sp, #148]
+ (fmt_params-> fat_num*fmt_params->sectors_per_fat);
40024710: 1b025800 madd w0, w0, w2, w22
if (fmt_params->root_dir_sectors > 0) {
40024714: 34002181 cbz w1, 40024b44 <msdos_format+0x544>
fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
40024718: 291307e0 stp w0, w1, [sp, #152]
if (ret_val == 0) {
4002471c: 35001e55 cbnz w21, 40024ae4 <msdos_format+0x4e4>
if ((rqdata != NULL) && (rqdata->OEMName != NULL)) {
40024720: a90363f7 stp x23, x24, [sp, #48]
40024724: a9046bf9 stp x25, x26, [sp, #64]
40024728: a90573fb stp x27, x28, [sp, #80]
4002472c: b4005134 cbz x20, 40025150 <msdos_format+0xb50>
40024730: f9400283 ldr x3, [x20]
40024734: b40050e3 cbz x3, 40025150 <msdos_format+0xb50>
if (isprint((unsigned char)*from)) {
40024738: 39400062 ldrb w2, [x3]
4002473c: d0000124 adrp x4, 4004a000 <fatal_source_text+0x558>
40024740: 91322484 add x4, x4, #0xc89
from = "RTEMS"; /* default: make "from" point to OS Name */
40024744: 9102afe1 add x1, sp, #0xab
40024748: 9102cfe6 add x6, sp, #0xb3
if (isprint((unsigned char)*from)) {
4002474c: 12800d05 mov w5, #0xffffff97 // #-105
40024750: 14000007 b 4002476c <msdos_format+0x16c>
40024754: 381ff022 sturb w2, [x1, #-1]
*to++ = *from++;
40024758: 91000463 add x3, x3, #0x1
*to = '\0';
4002475c: 3900003f strb wzr, [x1]
for (cnt = 0; cnt < (sizeof(fmt_params->OEMName)-1); cnt++) {
40024760: eb06003f cmp x1, x6
40024764: 540001a0 b.eq 40024798 <msdos_format+0x198> // b.none <== NEVER TAKEN
if (isprint((unsigned char)*from)) {
40024768: 39400062 ldrb w2, [x3]
4002476c: 92401c40 and x0, x2, #0xff
*to++ = *from++;
40024770: 91000421 add x1, x1, #0x1
if (isprint((unsigned char)*from)) {
40024774: 38606880 ldrb w0, [x4, x0]
40024778: 0a050000 and w0, w0, w5
4002477c: 12001c00 and w0, w0, #0xff
40024780: 35fffea0 cbnz w0, 40024754 <msdos_format+0x154>
*to++=' ';
40024784: 52800402 mov w2, #0x20 // #32
40024788: 381ff022 sturb w2, [x1, #-1]
*to = '\0';
4002478c: 3900003f strb wzr, [x1]
for (cnt = 0; cnt < (sizeof(fmt_params->OEMName)-1); cnt++) {
40024790: eb06003f cmp x1, x6
40024794: 54fffea1 b.ne 40024768 <msdos_format+0x168> // b.any
if ((rqdata != NULL) &&
40024798: b4004d54 cbz x20, 40025140 <msdos_format+0xb40>
(rqdata->VolLabel != NULL)) {
4002479c: f9400683 ldr x3, [x20, #8]
if ((rqdata != NULL) &&
400247a0: b4004d03 cbz x3, 40025140 <msdos_format+0xb40>
fmt_params->VolLabel_present = true;
400247a4: 52800020 mov w0, #0x1 // #1
400247a8: 390303e0 strb w0, [sp, #192]
if (isprint((unsigned char)*from)) {
400247ac: 39400062 ldrb w2, [x3]
400247b0: 9102ffe6 add x6, sp, #0xbf
from = ""; /* default: make "from" point to empty string */
400247b4: 9102d3e1 add x1, sp, #0xb4
if (isprint((unsigned char)*from)) {
400247b8: 12800d05 mov w5, #0xffffff97 // #-105
400247bc: 14000007 b 400247d8 <msdos_format+0x1d8>
400247c0: 381ff022 sturb w2, [x1, #-1]
*to++ = *from++;
400247c4: 91000463 add x3, x3, #0x1
*to = '\0';
400247c8: 3900003f strb wzr, [x1]
for (cnt = 0; cnt < (sizeof(fmt_params->VolLabel)-1); cnt++) {
400247cc: eb06003f cmp x1, x6
400247d0: 540001a0 b.eq 40024804 <msdos_format+0x204> // b.none <== NEVER TAKEN
if (isprint((unsigned char)*from)) {
400247d4: 39400062 ldrb w2, [x3]
400247d8: 92401c40 and x0, x2, #0xff
*to++ = *from++;
400247dc: 91000421 add x1, x1, #0x1
if (isprint((unsigned char)*from)) {
400247e0: 38606880 ldrb w0, [x4, x0]
400247e4: 0a050000 and w0, w0, w5
400247e8: 12001c00 and w0, w0, #0xff
400247ec: 35fffea0 cbnz w0, 400247c0 <msdos_format+0x1c0>
*to++=' ';
400247f0: 52800402 mov w2, #0x20 // #32
400247f4: 381ff022 sturb w2, [x1, #-1]
*to = '\0';
400247f8: 3900003f strb wzr, [x1]
for (cnt = 0; cnt < (sizeof(fmt_params->VolLabel)-1); cnt++) {
400247fc: eb06003f cmp x1, x6
40024800: 54fffea1 b.ne 400247d4 <msdos_format+0x1d4> // b.any
rc = rtems_clock_get_tod_timeval(&time_value);
40024804: 9101a3e0 add x0, sp, #0x68
40024808: 94000afa bl 400273f0 <rtems_clock_get_tod_timeval>
if (rc == RTEMS_SUCCESSFUL) {
4002480c: 35006ae0 cbnz w0, 40025568 <msdos_format+0xf68> <== ALWAYS TAKEN
*volid_ptr = time_value.tv_sec + time_value.tv_sec;
40024810: f94037e0 ldr x0, [sp, #104] <== NOT EXECUTED
40024814: 0b000000 add w0, w0, w0 <== NOT EXECUTED
40024818: b900c7e0 str w0, [sp, #196] <== 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);
4002481c: b9407be0 ldr w0, [sp, #120]
40024820: 97fff658 bl 40022180 <malloc>
40024824: f9006be0 str x0, [sp, #208]
if (fmt_params.sec == NULL) {
40024828: b4003380 cbz x0, 40024e98 <msdos_format+0x898> <== NEVER TAKEN
/*
* if requested, write whole disk/partition with 0xe5
*/
if ((ret_val == 0) &&
(rqdata != NULL) &&
4002482c: 52800019 mov w25, #0x0 // #0
if ((ret_val == 0) &&
40024830: b5002c14 cbnz x20, 40024db0 <msdos_format+0x7b0>
*/
if (ret_val == 0) {
/*
* Read the current MBR to obtain the partition table.
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
40024834: aa1403e0 mov x0, x20
40024838: 52800041 mov w1, #0x2 // #2
4002483c: 90000122 adrp x2, 40048000 <bsp_section_rodata_begin+0x78>
40024840: 912b0042 add x2, x2, #0xac0
40024844: 97fffebb bl 40024330 <msdos_format_printf>
"read MRB sector\n");
ret_val = msdos_format_read_sec(fd,
40024848: b9407bf6 ldr w22, [sp, #120]
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
4002484c: 2a1303e0 mov w0, w19
40024850: 52800002 mov w2, #0x0 // #0
40024854: d2800001 mov x1, #0x0 // #0
ret_val = msdos_format_read_sec(fd,
40024858: f9406bf5 ldr x21, [sp, #208]
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
4002485c: 94002045 bl 4002c970 <lseek>
40024860: b7f831c0 tbnz x0, #63, 40024e98 <msdos_format+0x898> <== NEVER TAKEN
if (0 > read(fd,buffer,sector_size)) {
40024864: 2a1603e2 mov w2, w22
40024868: aa1503e1 mov x1, x21
4002486c: 2a1303e0 mov w0, w19
40024870: 940020e4 bl 4002cc00 <read>
40024874: b7f83120 tbnz x0, #63, 40024e98 <msdos_format+0x898> <== NEVER TAKEN
0,
fmt_params.bytes_per_sector,
fmt_params.sec);
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
40024878: aa1403e0 mov x0, x20
4002487c: 52800041 mov w1, #0x2 // #2
40024880: 90000122 adrp x2, 40048000 <bsp_section_rodata_begin+0x78>
40024884: 912b6042 add x2, x2, #0xad8
40024888: 97fffeaa bl 40024330 <msdos_format_printf>
if (fmt_params->totl_sector_cnt < 0x10000) {
4002488c: b9407fe0 ldr w0, [sp, #124]
40024890: 529fffe1 mov w1, #0xffff // #65535
40024894: 6b01001f cmp w0, w1
40024898: 54003de9 b.ls 40025054 <msdos_format+0xa54> // b.plast
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
4002489c: 12001c1b and w27, w0, #0xff
400248a0: d3483c1a ubfx x26, x0, #8, #8
400248a4: d3505c18 ubfx x24, x0, #16, #8
400248a8: 53187c17 lsr w23, w0, #24
400248ac: 52800016 mov w22, #0x0 // #0
400248b0: 5280001c mov w28, #0x0 // #0
"generate MRB sector\n");
ret_val = msdos_format_gen_mbr(fmt_params.sec,&fmt_params);
400248b4: f9406bf5 ldr x21, [sp, #208]
memset(mbr,0,RTEMS_IDE_PARTITION_TABLE_OFFSET);
400248b8: d28037c2 mov x2, #0x1be // #446
400248bc: 52800001 mov w1, #0x0 // #0
400248c0: aa1503e0 mov x0, x21
400248c4: 94005ae8 bl 4003b464 <memset>
memset(mbr + RTEMS_IDE_PARTITION_TABLE_OFFSET + RTEMS_IDE_PARTITION_TABLE_SIZE,
400248c8: 3907fabf strb wzr, [x21, #510]
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
400248cc: 9102afe1 add x1, sp, #0xab
memset(mbr + RTEMS_IDE_PARTITION_TABLE_OFFSET + RTEMS_IDE_PARTITION_TABLE_SIZE,
400248d0: 3907febf strb wzr, [x21, #511]
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
400248d4: d2800102 mov x2, #0x8 // #8
400248d8: 91000ea0 add x0, x21, #0x3
400248dc: 94005ac7 bl 4003b3f8 <memcpy>
FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector);
400248e0: b9407be0 ldr w0, [sp, #120]
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
400248e4: 52800041 mov w1, #0x2 // #2
FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector);
400248e8: 39002ea0 strb w0, [x21, #11]
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
400248ec: 12800004 mov w4, #0xffffffff // #-1
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
400248f0: 390042a1 strb w1, [x21, #16]
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
400248f4: 528000c3 mov w3, #0x6 // #6
FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector);
400248f8: 53087c00 lsr w0, w0, #8
400248fc: 390032a0 strb w0, [x21, #12]
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
40024900: 52800022 mov w2, #0x1 // #1
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
40024904: 295017e0 ldp w0, w5, [sp, #128]
40024908: 390036a5 strb w5, [x21, #13]
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
4002490c: 39003aa0 strb w0, [x21, #14]
40024910: 53087c05 lsr w5, w0, #8
40024914: 39003ea5 strb w5, [x21, #15]
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
40024918: b94093e0 ldr w0, [sp, #144]
4002491c: 390046a0 strb w0, [x21, #17]
40024920: b94093e0 ldr w0, [sp, #144]
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
40024924: 39004ebc strb w28, [x21, #19]
40024928: 390052b6 strb w22, [x21, #20]
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
4002492c: 53087c00 lsr w0, w0, #8
40024930: 39004aa0 strb w0, [x21, #18]
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
40024934: 3942a7e0 ldrb w0, [sp, #169]
40024938: 390056a0 strb w0, [x21, #21]
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
4002493c: 390062a4 strb w4, [x21, #24]
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
40024940: 39006aa3 strb w3, [x21, #26]
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
40024944: 390072a2 strb w2, [x21, #28]
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
40024948: 390082bb strb w27, [x21, #32]
4002494c: 390086ba strb w26, [x21, #33]
40024950: 39008ab8 strb w24, [x21, #34]
40024954: 39008eb7 strb w23, [x21, #35]
if (fmt_params->fattype != FAT_FAT32) {
40024958: 3942abe0 ldrb w0, [sp, #170]
4002495c: 7100101f cmp w0, #0x4
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
40024960: b9408be0 ldr w0, [sp, #136]
if (fmt_params->fattype != FAT_FAT32) {
40024964: 540058a0 b.eq 40025478 <msdos_format+0xe78> // b.none
FAT_SET_BR_BOOTSIG(mbr , FAT_BR_BOOTSIG_VAL);
40024968: 52800521 mov w1, #0x29 // #41
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
4002496c: 39005aa0 strb w0, [x21, #22]
40024970: 53087c00 lsr w0, w0, #8
40024974: 39005ea0 strb w0, [x21, #23]
FAT_SET_BR_BOOTSIG(mbr , FAT_BR_BOOTSIG_VAL);
40024978: 39009aa1 strb w1, [x21, #38]
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
4002497c: d2800162 mov x2, #0xb // #11
40024980: 9102d3e1 add x1, sp, #0xb4
40024984: 9100aea0 add x0, x21, #0x2b
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
40024988: b940c7e3 ldr w3, [sp, #196]
4002498c: 39009ea3 strb w3, [x21, #39]
40024990: 53087c65 lsr w5, w3, #8
40024994: 53107c64 lsr w4, w3, #16
40024998: 53187c63 lsr w3, w3, #24
4002499c: 3900a2a5 strb w5, [x21, #40]
400249a0: 3900a6a4 strb w4, [x21, #41]
400249a4: 3900aaa3 strb w3, [x21, #42]
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
400249a8: 94005a94 bl 4003b3f8 <memcpy>
memcpy(FAT_GET_ADDR_BR_FILSYSTYPE(mbr),
400249ac: 3942abe1 ldrb w1, [sp, #170]
400249b0: 90000120 adrp x0, 40048000 <bsp_section_rodata_begin+0x78>
400249b4: 91284000 add x0, x0, #0xa10
400249b8: d2800102 mov x2, #0x8 // #8
400249bc: 7100043f cmp w1, #0x1
400249c0: 90000121 adrp x1, 40048000 <bsp_section_rodata_begin+0x78>
400249c4: 91280021 add x1, x1, #0xa00
400249c8: 9a800021 csel x1, x1, x0, eq // eq = none
400249cc: 9100daa0 add x0, x21, #0x36
400249d0: 94005a8a bl 4003b3f8 <memcpy>
FAT_SET_BR_SIGNATURE(mbr, FAT_BR_SIGNATURE_VAL);
400249d4: 52800aa1 mov w1, #0x55 // #85
400249d8: 12800aa0 mov w0, #0xffffffaa // #-86
FAT_SET_VAL8(mbr,0,0xeb);
400249dc: 12800284 mov w4, #0xffffffeb // #-21
FAT_SET_VAL8(mbr,1,0x3c);
400249e0: 52800782 mov w2, #0x3c // #60
FAT_SET_VAL8(mbr,2,0x90);
400249e4: 12800de3 mov w3, #0xffffff90 // #-112
FAT_SET_VAL8(mbr,0,0xeb);
400249e8: 390002a4 strb w4, [x21]
FAT_SET_VAL8(mbr,1,0x3c);
400249ec: 390006a2 strb w2, [x21, #1]
/*
* 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,
400249f0: 90000122 adrp x2, 40048000 <bsp_section_rodata_begin+0x78>
400249f4: 912c0042 add x2, x2, #0xb00
FAT_SET_VAL8(mbr,2,0x90);
400249f8: 39000aa3 strb w3, [x21, #2]
FAT_SET_BR_SIGNATURE(mbr, FAT_BR_SIGNATURE_VAL);
400249fc: 3907faa1 strb w1, [x21, #510]
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
40024a00: 52800041 mov w1, #0x2 // #2
FAT_SET_BR_SIGNATURE(mbr, FAT_BR_SIGNATURE_VAL);
40024a04: 3907fea0 strb w0, [x21, #511]
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
40024a08: aa1403e0 mov x0, x20
40024a0c: 97fffe49 bl 40024330 <msdos_format_printf>
"write MRB sector\n");
ret_val = msdos_format_write_sec(fd,
40024a10: b9407bf6 ldr w22, [sp, #120]
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
40024a14: 2a1303e0 mov w0, w19
40024a18: 52800002 mov w2, #0x0 // #0
40024a1c: d2800001 mov x1, #0x0 // #0
0,
fmt_params.bytes_per_sector,
fmt_params.sec);
40024a20: f9406bf5 ldr x21, [sp, #208]
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
40024a24: 94001fd3 bl 4002c970 <lseek>
40024a28: b7f82380 tbnz x0, #63, 40024e98 <msdos_format+0x898> <== NEVER TAKEN
if (0 > write(fd,buffer,sector_size)) {
40024a2c: 2a1603e2 mov w2, w22
40024a30: aa1503e1 mov x1, x21
40024a34: 2a1303e0 mov w0, w19
40024a38: 97fffd12 bl 40023e80 <write>
40024a3c: b7f822e0 tbnz x0, #63, 40024e98 <msdos_format+0x898> <== NEVER TAKEN
}
if ((ret_val == 0) &&
40024a40: b940a3e0 ldr w0, [sp, #160]
40024a44: 34000260 cbz w0, 40024a90 <msdos_format+0x490>
(fmt_params.mbr_copy_sec != 0)) {
/*
* write copy of MBR
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
40024a48: aa1403e0 mov x0, x20
40024a4c: 52800041 mov w1, #0x2 // #2
40024a50: 90000122 adrp x2, 40048000 <bsp_section_rodata_begin+0x78>
40024a54: 912c6042 add x2, x2, #0xb18
40024a58: 97fffe36 bl 40024330 <msdos_format_printf>
"write back up MRB sector\n");
ret_val = msdos_format_write_sec(fd,
40024a5c: b9407bf5 ldr w21, [sp, #120]
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
40024a60: b940a3e1 ldr w1, [sp, #160]
40024a64: 2a1303e0 mov w0, w19
40024a68: 52800002 mov w2, #0x0 // #0
fmt_params.mbr_copy_sec ,
fmt_params.bytes_per_sector,
fmt_params.sec);
40024a6c: f9406bf6 ldr x22, [sp, #208]
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
40024a70: 9ba17ea1 umull x1, w21, w1
40024a74: 94001fbf bl 4002c970 <lseek>
40024a78: b7f82100 tbnz x0, #63, 40024e98 <msdos_format+0x898> <== NEVER TAKEN
if (0 > write(fd,buffer,sector_size)) {
40024a7c: 2a1503e2 mov w2, w21
40024a80: aa1603e1 mov x1, x22
40024a84: 2a1303e0 mov w0, w19
40024a88: 97fffcfe bl 40023e80 <write>
40024a8c: b7f82060 tbnz x0, #63, 40024e98 <msdos_format+0x898> <== NEVER TAKEN
}
}
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
40024a90: b940a7e0 ldr w0, [sp, #164]
40024a94: 35001a80 cbnz w0, 40024de4 <msdos_format+0x7e4>
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 */
40024a98: 3942a3e6 ldrb w6, [sp, #168]
ret_val = msdos_format_fill_sectors
40024a9c: 2a1303e2 mov w2, w19
40024aa0: b9408be4 ldr w4, [sp, #136]
40024aa4: aa1403e1 mov x1, x20
40024aa8: b94083e3 ldr w3, [sp, #128]
40024aac: 9101e3e0 add x0, sp, #0x78
40024ab0: 52800005 mov w5, #0x0 // #0
40024ab4: 1b047cc4 mul w4, w6, w4
40024ab8: 97fffe6a bl 40024460 <msdos_format_fill_sectors>
40024abc: 2a0003f5 mov w21, w0
}
/*
* clear/init root directory
* -> write all directory sectors as 0x00
*/
if (ret_val == 0) {
40024ac0: 34001f60 cbz w0, 40024eac <msdos_format+0x8ac> <== ALWAYS TAKEN
40024ac4: a94363f7 ldp x23, x24, [sp, #48]
40024ac8: a9446bf9 ldp x25, x26, [sp, #64]
40024acc: a94573fb ldp x27, x28, [sp, #80]
40024ad0: 14000005 b 40024ae4 <msdos_format+0x4e4>
errno = ENOTTY;
40024ad4: 940057a6 bl 4003a96c <__errno> <== NOT EXECUTED
ret_val = -1;
40024ad8: 12800015 mov w21, #0xffffffff // #-1 <== NOT EXECUTED
errno = ENOTTY;
40024adc: 52800321 mov w1, #0x19 // #25 <== NOT EXECUTED
40024ae0: b9000001 str w1, [x0] <== NOT EXECUTED
* cleanup:
* sync and unlock disk
* free any data structures (not needed now)
*/
if (fd != -1) {
close(fd);
40024ae4: 2a1303e0 mov w0, w19
40024ae8: 97fff42e bl 40021ba0 <close>
}
free(fmt_params.sec);
40024aec: f9406be0 ldr x0, [sp, #208]
40024af0: 97fff4a4 bl 40021d80 <free>
return ret_val;
}
40024af4: 2a1503e0 mov w0, w21
40024af8: a94153f3 ldp x19, x20, [sp, #16]
40024afc: a9425bf5 ldp x21, x22, [sp, #32]
40024b00: a8d47bfd ldp x29, x30, [sp], #320
40024b04: d65f03c0 ret
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
40024b08: 97fffe0a bl 40024330 <msdos_format_printf> <== NOT EXECUTED
ret_val= -1;
40024b0c: 2a1303f5 mov w21, w19 <== NOT EXECUTED
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
40024b10: aa1603e3 mov x3, x22 <== NOT EXECUTED
40024b14: aa1403e0 mov x0, x20 <== NOT EXECUTED
40024b18: 52800021 mov w1, #0x1 // #1 <== NOT EXECUTED
40024b1c: 90000122 adrp x2, 40048000 <bsp_section_rodata_begin+0x78> <== NOT EXECUTED
40024b20: 91290042 add x2, x2, #0xa40 <== NOT EXECUTED
40024b24: 97fffe03 bl 40024330 <msdos_format_printf> <== NOT EXECUTED
free(fmt_params.sec);
40024b28: f9406be0 ldr x0, [sp, #208] <== NOT EXECUTED
40024b2c: 97fff495 bl 40021d80 <free> <== NOT EXECUTED
}
40024b30: 2a1503e0 mov w0, w21 <== NOT EXECUTED
40024b34: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40024b38: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
40024b3c: a8d47bfd ldp x29, x30, [sp], #320 <== NOT EXECUTED
40024b40: d65f03c0 ret <== NOT EXECUTED
fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
40024b44: b94087e1 ldr w1, [sp, #132]
40024b48: 291307e0 stp w0, w1, [sp, #152]
if (ret_val == 0) {
40024b4c: 35fffcd5 cbnz w21, 40024ae4 <msdos_format+0x4e4>
40024b50: 17fffef4 b 40024720 <msdos_format+0x120>
static inline int rtems_disk_fd_get_block_count(
int fd,
rtems_blkdev_bnum *block_count
)
{
return ioctl(fd, RTEMS_BLKIO_GETSIZE, block_count);
40024b54: 9101f3e2 add x2, sp, #0x7c
40024b58: 2a1303e0 mov w0, w19
40024b5c: d28840a1 mov x1, #0x4205 // #16901
40024b60: f2a80081 movk x1, #0x4004, lsl #16
40024b64: 94001f37 bl 4002c840 <ioctl>
40024b68: 2a0003f5 mov w21, w0
if (ret_val == 0) {
40024b6c: 35002e60 cbnz w0, 40025138 <msdos_format+0xb38> <== NEVER TAKEN
total_size = (uint64_t)fmt_params->bytes_per_sector * fmt_params->totl_sector_cnt;
40024b70: 294f13e3 ldp w3, w4, [sp, #120]
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
40024b74: 90000122 adrp x2, 40048000 <bsp_section_rodata_begin+0x78>
40024b78: 91294042 add x2, x2, #0xa50
40024b7c: aa1403e0 mov x0, x20
40024b80: 52800041 mov w1, #0x2 // #2
total_size = (uint64_t)fmt_params->bytes_per_sector * fmt_params->totl_sector_cnt;
40024b84: 9ba47c76 umull x22, w3, w4
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
40024b88: aa1603e5 mov x5, x22
40024b8c: 97fffde9 bl 40024330 <msdos_format_printf>
if ((rqdata == NULL) || (rqdata->fat_num == 0)) {
40024b90: b4003e14 cbz x20, 40025350 <msdos_format+0xd50>
40024b94: b9401683 ldr w3, [x20, #20]
40024b98: 34002e43 cbz w3, 40025160 <msdos_format+0xb60>
else if (rqdata->fat_num <= 6) {
40024b9c: 7100187f cmp w3, #0x6
40024ba0: 54002c48 b.hi 40025128 <msdos_format+0xb28> // b.pmore
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
40024ba4: 90000122 adrp x2, 40048000 <bsp_section_rodata_begin+0x78>
40024ba8: aa1403e0 mov x0, x20
40024bac: 912a2042 add x2, x2, #0xa88
40024bb0: 52800041 mov w1, #0x2 // #2
fmt_params->fat_num = rqdata->fat_num;
40024bb4: 3902a3e3 strb w3, [sp, #168]
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
40024bb8: 97fffdde bl 40024330 <msdos_format_printf>
if (rqdata != NULL && rqdata->sectors_per_cluster != 0) {
40024bbc: b9401280 ldr w0, [x20, #16]
40024bc0: 34003d80 cbz w0, 40025370 <msdos_format+0xd70>
if (fmt_params->totl_sector_cnt < FAT_FAT12_MAX_CLN * fat12_sect_per_clust) {
40024bc4: 5281fea1 mov w1, #0xff5 // #4085
40024bc8: 1b017c01 mul w1, w0, w1
40024bcc: b9407fe2 ldr w2, [sp, #124]
40024bd0: 6b01005f cmp w2, w1
40024bd4: 54003d42 b.cs 4002537c <msdos_format+0xd7c> // b.hs, b.nlast
fmt_params->fattype = FAT_FAT12;
40024bd8: 52800020 mov w0, #0x1 // #1
fmt_params->sectors_per_cluster = 2;
40024bdc: 52800041 mov w1, #0x2 // #2
40024be0: b90087e1 str w1, [sp, #132]
fmt_params->fattype = FAT_FAT12;
40024be4: 3902abe0 strb w0, [sp, #170]
ret_val = msdos_set_sectors_per_cluster_from_request( rqdata, fmt_params );
40024be8: 9101e3e1 add x1, sp, #0x78
40024bec: aa1403e0 mov x0, x20
40024bf0: 97fffdfc bl 400243e0 <msdos_set_sectors_per_cluster_from_request>
40024bf4: 2a0003f5 mov w21, w0
if (ret_val == 0) {
40024bf8: 35002a00 cbnz w0, 40025138 <msdos_format+0xb38> <== NEVER TAKEN
40024bfc: 3942abe1 ldrb w1, [sp, #170]
&& fmt_params->totl_sector_cnt > 0 ) {
40024c00: b9407fea ldr w10, [sp, #124]
40024c04: a90363f7 stp x23, x24, [sp, #48]
uint32_t gigs = ( total_size + ONE_GB ) / ONE_GB;
40024c08: d2a80017 mov x23, #0x40000000 // #1073741824
40024c0c: 8b1702d6 add x22, x22, x23
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
40024c10: 90000138 adrp x24, 40048000 <bsp_section_rodata_begin+0x78>
40024c14: 912a8318 add x24, x24, #0xaa0
40024c18: a9046bf9 stp x25, x26, [sp, #64]
fmt_params->mbr_copy_sec = 6;
40024c1c: d28000d9 mov x25, #0x6 // #6
uint32_t gigs = ( total_size + ONE_GB ) / ONE_GB;
40024c20: d35ef6d7 ubfx x23, x22, #30, #32
&& fmt_params->totl_sector_cnt > 0 ) {
40024c24: 52801ffa mov w26, #0xff // #255
40024c28: 52800016 mov w22, #0x0 // #0
fmt_params->mbr_copy_sec = 6;
40024c2c: f2c00039 movk x25, #0x1, lsl #32
&& fmt_params->fattype != fat_type
40024c30: 6b1a003f cmp w1, w26
40024c34: 54003bc0 b.eq 400253ac <msdos_format+0xdac> // b.none
&& fmt_params->totl_sector_cnt > 0 ) {
40024c38: 340041aa cbz w10, 4002546c <msdos_format+0xe6c> <== NEVER TAKEN
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
40024c3c: b94087e3 ldr w3, [sp, #132]
if (ret_val == 0 && rqdata != NULL)
40024c40: b4003334 cbz x20, 400252a4 <msdos_format+0xca4>
fmt_params->skip_alignment = rqdata->skip_alignment;
40024c44: 39407a84 ldrb w4, [x20, #30]
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
40024c48: aa1803e2 mov x2, x24
40024c4c: aa1403e0 mov x0, x20
40024c50: 52800041 mov w1, #0x2 // #2
fmt_params->skip_alignment = rqdata->skip_alignment;
40024c54: 390323e4 strb w4, [sp, #200]
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
40024c58: 97fffdb6 bl 40024330 <msdos_format_printf>
if (fmt_params->fattype == FAT_FAT32) {
40024c5c: 3942abfa ldrb w26, [sp, #170]
40024c60: 7100135f cmp w26, #0x4
40024c64: 540032e0 b.eq 400252c0 <msdos_format+0xcc0> // b.none
(rqdata->files_per_root_dir > 0)) {
40024c68: b9401a80 ldr w0, [x20, #24]
fmt_params->rsvd_sector_cnt = 1;
40024c6c: 52800029 mov w9, #0x1 // #1
40024c70: b90083e9 str w9, [sp, #128]
if ((rqdata != NULL) &&
40024c74: 340033e0 cbz w0, 400252f0 <msdos_format+0xcf0>
fmt_params->files_per_root_dir = rqdata->files_per_root_dir;
40024c78: 51000400 sub w0, w0, #0x1
ret_val = msdos_format_eval_sectors_per_cluster(fmt_params->fattype,
40024c7c: 2a1a03e3 mov w3, w26
(2*fmt_params->bytes_per_sector/
40024c80: b9407be4 ldr w4, [sp, #120]
40024c84: d3447881 ubfx x1, x4, #4, #27
fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
40024c88: 0b010000 add w0, w0, w1
fmt_params->files_per_root_dir -= (fmt_params->files_per_root_dir %
40024c8c: 1ac10806 udiv w6, w0, w1
40024c90: 1b0180c6 msub w6, w6, w1, w0
40024c94: 4b060006 sub w6, w0, w6
40024c98: b90093e6 str w6, [sp, #144]
(((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)
40024c9c: 531b68c6 lsl w6, w6, #5
fmt_params->root_dir_sectors =
40024ca0: 51000488 sub w8, w4, #0x1
while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
40024ca4: 52a00020 mov w0, #0x10000 // #65536
+ fmt_params->bytes_per_sector - 1)
40024ca8: 0b0800c6 add w6, w6, w8
ret_val = msdos_format_eval_sectors_per_cluster(fmt_params->fattype,
40024cac: b94087e1 ldr w1, [sp, #132]
while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
40024cb0: 1ac40800 udiv w0, w0, w4
ret_val = msdos_format_eval_sectors_per_cluster(fmt_params->fattype,
40024cb4: 3942a3e7 ldrb w7, [sp, #168]
40024cb8: 394323e5 ldrb w5, [sp, #200]
/ fmt_params->bytes_per_sector);
40024cbc: 1ac408c6 udiv w6, w6, w4
ret_val = msdos_format_eval_sectors_per_cluster(fmt_params->fattype,
40024cc0: b9407fea ldr w10, [sp, #124]
while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
40024cc4: 6b00003f cmp w1, w0
fmt_params->root_dir_sectors =
40024cc8: b90097e6 str w6, [sp, #148]
while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
40024ccc: 54000089 b.ls 40024cdc <msdos_format+0x6dc> // b.plast <== ALWAYS TAKEN
sectors_per_cluster /= 2;
40024cd0: 53017c21 lsr w1, w1, #1 <== NOT EXECUTED
while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
40024cd4: 6b00003f cmp w1, w0 <== NOT EXECUTED
40024cd8: 54ffffc8 b.hi 40024cd0 <msdos_format+0x6d0> // b.pmore <== NOT EXECUTED
fatdata_sect_cnt = total_sector_cnt
40024cdc: 4b09014c sub w12, w10, w9
return (sectors + clustersize - 1) & ~(clustersize - 1);
40024ce0: 510004cd sub w13, w6, #0x1
40024ce4: 51000529 sub w9, w9, #0x1
((fattype == FAT_FAT16) && (*data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
40024ce8: 529ffeab mov w11, #0xfff5 // #65525
40024cec: d503201f nop
if (! skip_alignment)
40024cf0: 350024a5 cbnz w5, 40025184 <msdos_format+0xb84>
return (sectors + clustersize - 1) & ~(clustersize - 1);
40024cf4: 4b0103e2 neg w2, w1
40024cf8: 0b010120 add w0, w9, w1
40024cfc: 0a020000 and w0, w0, w2
if (fattype == FAT_FAT12) {
40024d00: 7100047f cmp w3, #0x1
fatdata_sect_cnt = total_sector_cnt
40024d04: 4b000140 sub w0, w10, w0
if (fattype == FAT_FAT12) {
40024d08: 54002c20 b.eq 4002528c <msdos_format+0xc8c> // b.none
else if (fattype == FAT_FAT16) {
40024d0c: 7100087f cmp w3, #0x2
40024d10: 54002c40 b.eq 40025298 <msdos_format+0xc98> // b.none
fatdata_cluster_cnt = fatdata_sect_cnt/sectors_per_cluster;
40024d14: 1ac10800 udiv w0, w0, w1
fat_capacity = fatdata_cluster_cnt * 4;
40024d18: 531e7402 lsl w2, w0, #2
+ (bytes_per_sector - 1))
40024d1c: 0b080042 add w2, w2, w8
40024d20: 5100042f sub w15, w1, #0x1
sectors_per_fat = ((fat_capacity
40024d24: 1ac40842 udiv w2, w2, w4
fat_sectors_cnt = loc_align_object (sectors_per_fat * fat_num,
40024d28: 1b077c42 mul w2, w2, w7
return (sectors + clustersize - 1) & ~(clustersize - 1);
40024d2c: 0b0201ee add w14, w15, w2
if (! skip_alignment)
40024d30: 35000085 cbnz w5, 40024d40 <msdos_format+0x740>
return (sectors + clustersize - 1) & ~(clustersize - 1);
40024d34: 4b0103e2 neg w2, w1
40024d38: 0a0e0042 and w2, w2, w14
+ (sectors_per_cluster - 1))
40024d3c: 0b0201ee add w14, w15, w2
/ sectors_per_cluster));
40024d40: 1ac109ce udiv w14, w14, w1
if (((fattype == FAT_FAT12) && (*data_cluster_cnt > FAT_FAT12_MAX_CLN)) ||
40024d44: 7100047f cmp w3, #0x1
*data_cluster_cnt = (fatdata_cluster_cnt -
40024d48: 4b0e0000 sub w0, w0, w14
if (((fattype == FAT_FAT12) && (*data_cluster_cnt > FAT_FAT12_MAX_CLN)) ||
40024d4c: 54002300 b.eq 400251ac <msdos_format+0xbac> // b.none
40024d50: 7100087f cmp w3, #0x2
40024d54: 54002301 b.ne 400251b4 <msdos_format+0xbb4> // b.any
((fattype == FAT_FAT16) && (*data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
40024d58: 6b0b001f cmp w0, w11
40024d5c: 540024c9 b.ls 400251f4 <msdos_format+0xbf4> // b.plast
sectors_per_cluster *= 2;
40024d60: 0b010021 add w1, w1, w1
} else if ((sectors_per_cluster * bytes_per_sector)
40024d64: 1b017c8e mul w14, w4, w1
40024d68: 714041df cmp w14, #0x10, lsl #12
40024d6c: 54fffc29 b.ls 40024cf0 <msdos_format+0x6f0> // b.plast <== ALWAYS TAKEN
*sectors_per_fat_ptr = fat_sectors_cnt / fat_num;
40024d70: 1ac70842 udiv w2, w2, w7 <== NOT EXECUTED
uint32_t ms_sectors_per_cluster_limit_FAT16 =
40024d74: 52900023 mov w3, #0x8001 // #32769 <== NOT EXECUTED
40024d78: 1ac40864 udiv w4, w3, w4 <== NOT EXECUTED
*sectors_per_fat_ptr = fat_sectors_cnt / fat_num;
40024d7c: 29108be1 stp w1, w2, [sp, #132] <== NOT EXECUTED
&& sectors_per_cluster <= ms_sectors_per_cluster_limit_FAT16 ) {
40024d80: 529ffe82 mov w2, #0xfff4 // #65524
40024d84: 6b02001f cmp w0, w2
else if ( number_of_clusters < FAT_FAT16_MAX_CLN
40024d88: 7a419080 ccmp w4, w1, #0x0, ls // ls = plast
40024d8c: 54002c63 b.cc 40025318 <msdos_format+0xd18> // b.lo, b.ul, b.last
fattype = FAT_FAT16;
40024d90: 52800040 mov w0, #0x2 // #2
fmt_params->fattype = msdos_get_fat_type(
40024d94: 3902abe0 strb w0, [sp, #170]
if (fat_type != fmt_params->fattype) {
40024d98: 6b1a001f cmp w0, w26
40024d9c: 54002421 b.ne 40025220 <msdos_format+0xc20> // b.any
++iteration_cnt;
40024da0: 110006d6 add w22, w22, #0x1
40024da4: 3942abe1 ldrb w1, [sp, #170]
40024da8: 12001ed6 and w22, w22, #0xff
while( ret_val == 0
40024dac: 17ffffa1 b 40024c30 <msdos_format+0x630>
(rqdata != NULL) &&
40024db0: 39407680 ldrb w0, [x20, #29]
40024db4: 35000140 cbnz w0, 40024ddc <msdos_format+0x7dc> <== ALWAYS TAKEN
ret_val = msdos_format_fill_sectors
40024db8: b9407fe4 ldr w4, [sp, #124] <== NOT EXECUTED
40024dbc: 2a1303e2 mov w2, w19 <== NOT EXECUTED
40024dc0: aa1403e1 mov x1, x20 <== NOT EXECUTED
40024dc4: 9101e3e0 add x0, sp, #0x78 <== NOT EXECUTED
40024dc8: 12800345 mov w5, #0xffffffe5 // #-27 <== NOT EXECUTED
40024dcc: 52800003 mov w3, #0x0 // #0 <== NOT EXECUTED
40024dd0: 97fffda4 bl 40024460 <msdos_format_fill_sectors> <== NOT EXECUTED
40024dd4: 2a0003f5 mov w21, w0 <== NOT EXECUTED
if (ret_val == 0) {
40024dd8: 35ffe760 cbnz w0, 40024ac4 <msdos_format+0x4c4> <== NOT EXECUTED
*to++=' ';
40024ddc: 52800039 mov w25, #0x1 // #1
40024de0: 17fffe95 b 40024834 <msdos_format+0x234>
ret_val = msdos_format_gen_fsinfo(fmt_params.sec);
40024de4: f9406be3 ldr x3, [sp, #208]
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
40024de8: d2804002 mov x2, #0x200 // #512
40024dec: 52800001 mov w1, #0x0 // #0
40024df0: aa0303e0 mov x0, x3
40024df4: 9400599c bl 4003b464 <memset>
40024df8: aa0003e3 mov x3, x0
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
40024dfc: 52800c22 mov w2, #0x61 // #97
40024e00: 52800a40 mov w0, #0x52 // #82
40024e04: 52800824 mov w4, #0x41 // #65
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
40024e08: 52800e45 mov w5, #0x72 // #114
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
40024e0c: 39000060 strb w0, [x3]
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
40024e10: 52800aa7 mov w7, #0x55 // #85
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
40024e14: 39000460 strb w0, [x3, #1]
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
40024e18: 12800aa6 mov w6, #0xffffffaa // #-86
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
40024e1c: 39000862 strb w2, [x3, #2]
FAT_SET_FSINFO_FREE_CLUSTER_COUNT(fsinfo+FAT_FSI_INFO, 0xffffffff);
40024e20: 12800000 mov w0, #0xffffffff // #-1
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
40024e24: 39000c64 strb w4, [x3, #3]
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
40024e28: 39079065 strb w5, [x3, #484]
(fmt_params.fsinfo_sec != 0)) {
40024e2c: b940a7e1 ldr w1, [sp, #164]
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
40024e30: 39079465 strb w5, [x3, #485]
40024e34: 39079864 strb w4, [x3, #486]
40024e38: 39079c62 strb w2, [x3, #487]
FAT_SET_FSINFO_FREE_CLUSTER_COUNT(fsinfo+FAT_FSI_INFO, 0xffffffff);
40024e3c: 3907a060 strb w0, [x3, #488]
40024e40: 3907a460 strb w0, [x3, #489]
40024e44: 3907a860 strb w0, [x3, #490]
40024e48: 3907ac60 strb w0, [x3, #491]
FAT_SET_FSINFO_NEXT_FREE_CLUSTER (fsinfo+FAT_FSI_INFO, 0xffffffff);
40024e4c: 3907b060 strb w0, [x3, #492]
40024e50: 3907b460 strb w0, [x3, #493]
40024e54: 3907b860 strb w0, [x3, #494]
40024e58: 3907bc60 strb w0, [x3, #495]
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
40024e5c: 3907f867 strb w7, [x3, #510]
40024e60: 3907fc66 strb w6, [x3, #511]
if ((ret_val == 0) &&
40024e64: 34ffe1a1 cbz w1, 40024a98 <msdos_format+0x498> <== NEVER TAKEN
ret_val = msdos_format_write_sec(fd,
40024e68: b9407bf5 ldr w21, [sp, #120]
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
40024e6c: 2a1303e0 mov w0, w19
40024e70: 52800002 mov w2, #0x0 // #0
fmt_params.sec);
40024e74: f9406bf6 ldr x22, [sp, #208]
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
40024e78: 9bb57c21 umull x1, w1, w21
40024e7c: 94001ebd bl 4002c970 <lseek>
40024e80: b7f800c0 tbnz x0, #63, 40024e98 <msdos_format+0x898> <== NEVER TAKEN
if (0 > write(fd,buffer,sector_size)) {
40024e84: 2a1503e2 mov w2, w21
40024e88: aa1603e1 mov x1, x22
40024e8c: 2a1303e0 mov w0, w19
40024e90: 97fffbfc bl 40023e80 <write>
40024e94: b6ffe020 tbz x0, #63, 40024a98 <msdos_format+0x498> <== ALWAYS TAKEN
ret_val = -1;
40024e98: 12800015 mov w21, #0xffffffff // #-1 <== NOT EXECUTED
40024e9c: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
40024ea0: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
40024ea4: a94573fb ldp x27, x28, [sp, #80] <== NOT EXECUTED
40024ea8: 17ffff0f b 40024ae4 <msdos_format+0x4e4> <== NOT EXECUTED
ret_val = msdos_format_fill_sectors
40024eac: 295313e3 ldp w3, w4, [sp, #152]
40024eb0: 9101e3e0 add x0, sp, #0x78
40024eb4: 2a1303e2 mov w2, w19
40024eb8: aa1403e1 mov x1, x20
40024ebc: 52800005 mov w5, #0x0 // #0
40024ec0: 97fffd68 bl 40024460 <msdos_format_fill_sectors>
40024ec4: 2a0003f5 mov w21, w0
if ((ret_val == 0) && fmt_params.VolLabel_present) {
40024ec8: 35ffdfe0 cbnz w0, 40024ac4 <msdos_format+0x4c4> <== NEVER TAKEN
40024ecc: 394303e1 ldrb w1, [sp, #192]
memset(fmt_params.sec,0,fmt_params.bytes_per_sector);
40024ed0: b9407be2 ldr w2, [sp, #120]
40024ed4: f9406be0 ldr x0, [sp, #208]
if ((ret_val == 0) && fmt_params.VolLabel_present) {
40024ed8: 350008c1 cbnz w1, 40024ff0 <msdos_format+0x9f0>
memset(fmt_params.sec,0,fmt_params.bytes_per_sector);
40024edc: 52800001 mov w1, #0x0 // #0
40024ee0: 94005961 bl 4003b464 <memset>
switch(fmt_params.fattype) {
40024ee4: 3942abe0 ldrb w0, [sp, #170]
40024ee8: 7100081f cmp w0, #0x2
40024eec: 54001040 b.eq 400250f4 <msdos_format+0xaf4> // b.none
40024ef0: 7100101f cmp w0, #0x4
40024ef4: 54000d40 b.eq 4002509c <msdos_format+0xa9c> // b.none
40024ef8: 7100041f cmp w0, #0x1
40024efc: 54000ba0 b.eq 40025070 <msdos_format+0xa70> // b.none <== ALWAYS TAKEN
errno = EINVAL;
40024f00: 9400569b bl 4003a96c <__errno> <== NOT EXECUTED
ret_val = -1;
40024f04: 1280001a mov w26, #0xffffffff // #-1 <== NOT EXECUTED
errno = EINVAL;
40024f08: 528002c1 mov w1, #0x16 // #22 <== NOT EXECUTED
40024f0c: b9000001 str w1, [x0] <== NOT EXECUTED
if (fmt_params.fattype == FAT_FAT32) {
40024f10: 3942abe0 ldrb w0, [sp, #170]
40024f14: 7100101f cmp w0, #0x4
40024f18: 54000181 b.ne 40024f48 <msdos_format+0x948> // b.any
FAT_SET_VAL32(fmt_params.sec,8,FAT_FAT32_EOC);
40024f1c: f9406be2 ldr x2, [sp, #208]
40024f20: 128000e3 mov w3, #0xfffffff8 // #-8
40024f24: 12800000 mov w0, #0xffffffff // #-1
40024f28: 528001e1 mov w1, #0xf // #15
40024f2c: 39002043 strb w3, [x2, #8]
40024f30: f9406be2 ldr x2, [sp, #208]
40024f34: 39002440 strb w0, [x2, #9]
40024f38: f9406be2 ldr x2, [sp, #208]
40024f3c: 39002840 strb w0, [x2, #10]
40024f40: f9406be0 ldr x0, [sp, #208]
40024f44: 39002c01 strb w1, [x0, #11]
start_sector = loc_align_object (fmt_params.rsvd_sector_cnt,
40024f48: 295007f8 ldp w24, w1, [sp, #128]
for (i = 0;
40024f4c: 3942a3e2 ldrb w2, [sp, #168]
return (sectors + clustersize - 1) & ~(clustersize - 1);
40024f50: 0b010300 add w0, w24, w1
if (! skip_alignment)
40024f54: 394323e3 ldrb w3, [sp, #200]
return (sectors + clustersize - 1) & ~(clustersize - 1);
40024f58: 51000400 sub w0, w0, #0x1
40024f5c: 4b0103e1 neg w1, w1
40024f60: 7100007f cmp w3, #0x0
40024f64: 0a010000 and w0, w0, w1
40024f68: 1a980018 csel w24, w0, w24, eq // eq = none
for (i = 0;
40024f6c: 34003042 cbz w2, 40025574 <msdos_format+0xf74> <== NEVER TAKEN
40024f70: 52800016 mov w22, #0x0 // #0
(i < fmt_params.fat_num) && (ret_val == 0);
40024f74: 35fff93a cbnz w26, 40024e98 <msdos_format+0x898> <== NEVER TAKEN
+ (i * fmt_params.sectors_per_fat),
40024f78: b9408be1 ldr w1, [sp, #136]
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
40024f7c: 2a1303e0 mov w0, w19
ret_val = msdos_format_write_sec
40024f80: b9407bf7 ldr w23, [sp, #120]
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
40024f84: 52800002 mov w2, #0x0 // #0
fmt_params.sec);
40024f88: f9406bfb ldr x27, [sp, #208]
ret_val = msdos_format_write_sec
40024f8c: 1b0162c1 madd w1, w22, w1, w24
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
40024f90: 110006d6 add w22, w22, #0x1
40024f94: 9bb77c21 umull x1, w1, w23
40024f98: 94001e76 bl 4002c970 <lseek>
40024f9c: b7fff7e0 tbnz x0, #63, 40024e98 <msdos_format+0x898> <== NEVER TAKEN
if (0 > write(fd,buffer,sector_size)) {
40024fa0: 2a1703e2 mov w2, w23
40024fa4: aa1b03e1 mov x1, x27
40024fa8: 2a1303e0 mov w0, w19
40024fac: 97fffbb5 bl 40023e80 <write>
40024fb0: b7fff740 tbnz x0, #63, 40024e98 <msdos_format+0x898> <== NEVER TAKEN
(i < fmt_params.fat_num) && (ret_val == 0);
40024fb4: 3942a3e0 ldrb w0, [sp, #168]
for (i = 0;
40024fb8: 6b0002df cmp w22, w0
40024fbc: 54fffdeb b.lt 40024f78 <msdos_format+0x978> // b.tstop
if (ret_val == 0 && rqdata != NULL && rqdata->sync_device) {
40024fc0: 34002f79 cbz w25, 400255ac <msdos_format+0xfac>
40024fc4: 39407e80 ldrb w0, [x20, #31]
40024fc8: 34ffd7e0 cbz w0, 40024ac4 <msdos_format+0x4c4>
return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);
}
static inline int rtems_disk_fd_sync(int fd)
{
return ioctl(fd, RTEMS_BLKIO_SYNCDEV);
40024fcc: 2a1303e0 mov w0, w19
40024fd0: d28840c1 mov x1, #0x4206 // #16902
40024fd4: f2a40001 movk x1, #0x2000, lsl #16
40024fd8: 94001e1a bl 4002c840 <ioctl>
40024fdc: 2a0003f5 mov w21, w0
40024fe0: a94363f7 ldp x23, x24, [sp, #48]
40024fe4: a9446bf9 ldp x25, x26, [sp, #64]
40024fe8: a94573fb ldp x27, x28, [sp, #80]
40024fec: 17fffebe b 40024ae4 <msdos_format+0x4e4>
memset(fmt_params.sec,0,fmt_params.bytes_per_sector);
40024ff0: 52800001 mov w1, #0x0 // #0
40024ff4: 9400591c bl 4003b464 <memset>
memcpy(MSDOS_DIR_NAME(fmt_params.sec),fmt_params.VolLabel,MSDOS_SHORT_NAME_LEN);
40024ff8: f9406be0 ldr x0, [sp, #208]
40024ffc: 9102d3e1 add x1, sp, #0xb4
40025000: d2800162 mov x2, #0xb // #11
40025004: 940058fd bl 4003b3f8 <memcpy>
ret_val = msdos_format_write_sec
40025008: b9407bf6 ldr w22, [sp, #120]
*MSDOS_DIR_ATTR(fmt_params.sec) = MSDOS_ATTR_VOLUME_ID;
4002500c: f9406be1 ldr x1, [sp, #208]
40025010: 52800103 mov w3, #0x8 // #8
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
40025014: 2a1303e0 mov w0, w19
40025018: 52800002 mov w2, #0x0 // #0
*MSDOS_DIR_ATTR(fmt_params.sec) = MSDOS_ATTR_VOLUME_ID;
4002501c: 39002c23 strb w3, [x1, #11]
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
40025020: b9409be1 ldr w1, [sp, #152]
fmt_params.sec);
40025024: f9406bf7 ldr x23, [sp, #208]
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
40025028: 9ba17ec1 umull x1, w22, w1
4002502c: 94001e51 bl 4002c970 <lseek>
40025030: b7fff340 tbnz x0, #63, 40024e98 <msdos_format+0x898> <== NEVER TAKEN
if (0 > write(fd,buffer,sector_size)) {
40025034: 2a1603e2 mov w2, w22
40025038: aa1703e1 mov x1, x23
4002503c: 2a1303e0 mov w0, w19
40025040: 97fffb90 bl 40023e80 <write>
40025044: b7fff2a0 tbnz x0, #63, 40024e98 <msdos_format+0x898> <== NEVER TAKEN
memset(fmt_params.sec,0,fmt_params.bytes_per_sector);
40025048: b9407be2 ldr w2, [sp, #120]
4002504c: f9406be0 ldr x0, [sp, #208]
40025050: 17ffffa3 b 40024edc <msdos_format+0x8dc>
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
40025054: 12001c1c and w28, w0, #0xff
40025058: d3483c16 ubfx x22, x0, #8, #8
4002505c: 52800017 mov w23, #0x0 // #0
40025060: 52800018 mov w24, #0x0 // #0
40025064: 5280001a mov w26, #0x0 // #0
40025068: 5280001b mov w27, #0x0 // #0
4002506c: 17fffe12 b 400248b4 <msdos_format+0x2b4>
FAT_SET_VAL8(fmt_params.sec,0,(fmt_params.media_code));
40025070: f9406be0 ldr x0, [sp, #208]
FAT_SET_VAL8(fmt_params.sec,1,(0x0f | (FAT_FAT12_EOC << 4)));
40025074: 12800e02 mov w2, #0xffffff8f // #-113
FAT_SET_VAL8(fmt_params.sec,0,(fmt_params.media_code));
40025078: 3942a7e3 ldrb w3, [sp, #169]
FAT_SET_VAL8(fmt_params.sec,2,(FAT_FAT12_EOC >> 4));
4002507c: 12800001 mov w1, #0xffffffff // #-1
break;
40025080: 5280001a mov w26, #0x0 // #0
FAT_SET_VAL8(fmt_params.sec,0,(fmt_params.media_code));
40025084: 39000003 strb w3, [x0]
FAT_SET_VAL8(fmt_params.sec,1,(0x0f | (FAT_FAT12_EOC << 4)));
40025088: f9406be0 ldr x0, [sp, #208]
4002508c: 39000402 strb w2, [x0, #1]
FAT_SET_VAL8(fmt_params.sec,2,(FAT_FAT12_EOC >> 4));
40025090: f9406be0 ldr x0, [sp, #208]
40025094: 39000801 strb w1, [x0, #2]
break;
40025098: 17ffff9e b 40024f10 <msdos_format+0x910>
FAT_SET_VAL32(fmt_params.sec,0,0xffffff00|fmt_params.media_code);
4002509c: f9406be2 ldr x2, [sp, #208]
400250a0: 12800000 mov w0, #0xffffffff // #-1
400250a4: 3942a7e4 ldrb w4, [sp, #169]
FAT_SET_VAL32(fmt_params.sec,4,0xc0000000|FAT_FAT32_EOC);
400250a8: 128000e3 mov w3, #0xfffffff8 // #-8
400250ac: 12800601 mov w1, #0xffffffcf // #-49
break;
400250b0: 5280001a mov w26, #0x0 // #0
FAT_SET_VAL32(fmt_params.sec,0,0xffffff00|fmt_params.media_code);
400250b4: 39000044 strb w4, [x2]
400250b8: f9406be2 ldr x2, [sp, #208]
400250bc: 39000440 strb w0, [x2, #1]
400250c0: f9406be2 ldr x2, [sp, #208]
400250c4: 39000840 strb w0, [x2, #2]
400250c8: f9406be2 ldr x2, [sp, #208]
400250cc: 39000c40 strb w0, [x2, #3]
FAT_SET_VAL32(fmt_params.sec,4,0xc0000000|FAT_FAT32_EOC);
400250d0: f9406be2 ldr x2, [sp, #208]
400250d4: 39001043 strb w3, [x2, #4]
400250d8: f9406be2 ldr x2, [sp, #208]
400250dc: 39001440 strb w0, [x2, #5]
400250e0: f9406be2 ldr x2, [sp, #208]
400250e4: 39001840 strb w0, [x2, #6]
400250e8: f9406be0 ldr x0, [sp, #208]
400250ec: 39001c01 strb w1, [x0, #7]
break;
400250f0: 17ffff88 b 40024f10 <msdos_format+0x910>
FAT_SET_VAL8(fmt_params.sec,0,fmt_params.media_code);
400250f4: f9406be1 ldr x1, [sp, #208]
FAT_SET_VAL8(fmt_params.sec,1,0xff);
400250f8: 12800000 mov w0, #0xffffffff // #-1
FAT_SET_VAL8(fmt_params.sec,0,fmt_params.media_code);
400250fc: 3942a7e3 ldrb w3, [sp, #169]
FAT_SET_VAL16(fmt_params.sec,2,FAT_FAT16_EOC);
40025100: 128000e2 mov w2, #0xfffffff8 // #-8
break;
40025104: 5280001a mov w26, #0x0 // #0
FAT_SET_VAL8(fmt_params.sec,0,fmt_params.media_code);
40025108: 39000023 strb w3, [x1]
FAT_SET_VAL8(fmt_params.sec,1,0xff);
4002510c: f9406be1 ldr x1, [sp, #208]
40025110: 39000420 strb w0, [x1, #1]
FAT_SET_VAL16(fmt_params.sec,2,FAT_FAT16_EOC);
40025114: f9406be1 ldr x1, [sp, #208]
40025118: 39000822 strb w2, [x1, #2]
4002511c: f9406be1 ldr x1, [sp, #208]
40025120: 39000c20 strb w0, [x1, #3]
break;
40025124: 17ffff7b b 40024f10 <msdos_format+0x910>
errno = EINVAL;
40025128: 94005611 bl 4003a96c <__errno>
ret_val = -1;
4002512c: 12800015 mov w21, #0xffffffff // #-1
errno = EINVAL;
40025130: 528002c1 mov w1, #0x16 // #22
40025134: b9000001 str w1, [x0]
if (ret_val == 0) {
40025138: b9407fe2 ldr w2, [sp, #124]
4002513c: 17fffd6b b 400246e8 <msdos_format+0xe8>
from = ""; /* default: make "from" point to empty string */
40025140: f0000103 adrp x3, 40048000 <bsp_section_rodata_begin+0x78>
40025144: 912ae063 add x3, x3, #0xab8
40025148: 52800002 mov w2, #0x0 // #0
4002514c: 17fffd99 b 400247b0 <msdos_format+0x1b0>
from = "RTEMS"; /* default: make "from" point to OS Name */
40025150: f0000103 adrp x3, 40048000 <bsp_section_rodata_begin+0x78>
40025154: 9127e063 add x3, x3, #0x9f8
40025158: 52800a42 mov w2, #0x52 // #82
4002515c: 17fffd78 b 4002473c <msdos_format+0x13c>
fmt_params->fat_num = 2;
40025160: 52800044 mov w4, #0x2 // #2
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
40025164: 52800043 mov w3, #0x2 // #2
40025168: aa1403e0 mov x0, x20
4002516c: 2a0303e1 mov w1, w3
40025170: f0000102 adrp x2, 40048000 <bsp_section_rodata_begin+0x78>
40025174: 912a2042 add x2, x2, #0xa88
fmt_params->fat_num = 2;
40025178: 3902a3e4 strb w4, [sp, #168]
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4002517c: 97fffc6d bl 40024330 <msdos_format_printf>
if (rqdata != NULL && rqdata->sectors_per_cluster != 0) {
40025180: 17fffe8f b 40024bbc <msdos_format+0x5bc>
if (fattype == FAT_FAT12) {
40025184: 7100047f cmp w3, #0x1
fatdata_sect_cnt = total_sector_cnt
40025188: 2a0c03e0 mov w0, w12
if (fattype == FAT_FAT12) {
4002518c: 54000740 b.eq 40025274 <msdos_format+0xc74> // b.none
else if (fattype == FAT_FAT16) {
40025190: 7100087f cmp w3, #0x2
40025194: 54ffdc01 b.ne 40024d14 <msdos_format+0x714> // b.any <== NEVER TAKEN
return sectors;
40025198: 2a0603e2 mov w2, w6
fatdata_sect_cnt = fatdata_sect_cnt
4002519c: 4b020000 sub w0, w0, w2
fatdata_cluster_cnt = fatdata_sect_cnt/sectors_per_cluster;
400251a0: 1ac10800 udiv w0, w0, w1
fat_capacity = fatdata_cluster_cnt * 2;
400251a4: 0b000002 add w2, w0, w0
400251a8: 17fffedd b 40024d1c <msdos_format+0x71c>
if (((fattype == FAT_FAT12) && (*data_cluster_cnt > FAT_FAT12_MAX_CLN)) ||
400251ac: 713fd41f cmp w0, #0xff5
400251b0: 54000188 b.hi 400251e0 <msdos_format+0xbe0> // b.pmore
*sectors_per_fat_ptr = fat_sectors_cnt / fat_num;
400251b4: 1ac70842 udiv w2, w2, w7
uint32_t ms_sectors_per_cluster_limit_FAT12 =
400251b8: 52820023 mov w3, #0x1001 // #4097
uint32_t ms_sectors_per_cluster_limit_FAT16 =
400251bc: 52900025 mov w5, #0x8001 // #32769
&& sectors_per_cluster <= ms_sectors_per_cluster_limit_FAT12 ) {
400251c0: 713fd01f cmp w0, #0xff4
uint32_t ms_sectors_per_cluster_limit_FAT12 =
400251c4: 1ac40863 udiv w3, w3, w4
uint32_t ms_sectors_per_cluster_limit_FAT16 =
400251c8: 1ac408a4 udiv w4, w5, w4
*sectors_per_fat_ptr = fat_sectors_cnt / fat_num;
400251cc: 29108be1 stp w1, w2, [sp, #132]
if ( number_of_clusters < FAT_FAT12_MAX_CLN
400251d0: 7a439022 ccmp w1, w3, #0x2, ls // ls = plast
400251d4: 54ffdd68 b.hi 40024d80 <msdos_format+0x780> // b.pmore
fattype = FAT_FAT12;
400251d8: 52800020 mov w0, #0x1 // #1
400251dc: 17fffeee b 40024d94 <msdos_format+0x794>
sectors_per_cluster *= 2;
400251e0: 0b010021 add w1, w1, w1
if (MS_BYTES_PER_CLUSTER_LIMIT_FAT12 < (sectors_per_cluster * bytes_per_sector)) {
400251e4: 1b047c2e mul w14, w1, w4
400251e8: 714005df cmp w14, #0x1, lsl #12
400251ec: 54ffd829 b.ls 40024cf0 <msdos_format+0x6f0> // b.plast <== ALWAYS TAKEN
400251f0: 17fffee0 b 40024d70 <msdos_format+0x770> <== NOT EXECUTED
*sectors_per_fat_ptr = fat_sectors_cnt / fat_num;
400251f4: 1ac70842 udiv w2, w2, w7
uint32_t ms_sectors_per_cluster_limit_FAT12 =
400251f8: 52820023 mov w3, #0x1001 // #4097
uint32_t ms_sectors_per_cluster_limit_FAT16 =
400251fc: 52900025 mov w5, #0x8001 // #32769
&& sectors_per_cluster <= ms_sectors_per_cluster_limit_FAT12 ) {
40025200: 713fd01f cmp w0, #0xff4
uint32_t ms_sectors_per_cluster_limit_FAT12 =
40025204: 1ac40863 udiv w3, w3, w4
uint32_t ms_sectors_per_cluster_limit_FAT16 =
40025208: 1ac408a4 udiv w4, w5, w4
*sectors_per_fat_ptr = fat_sectors_cnt / fat_num;
4002520c: 29108be1 stp w1, w2, [sp, #132]
if ( number_of_clusters < FAT_FAT12_MAX_CLN
40025210: 7a419060 ccmp w3, w1, #0x0, ls // ls = plast
40025214: 54ffdb63 b.cc 40024d80 <msdos_format+0x780> // b.lo, b.ul, b.last <== ALWAYS TAKEN
fmt_params->fattype = msdos_get_fat_type(
40025218: 52800020 mov w0, #0x1 // #1 <== NOT EXECUTED
4002521c: 3902abe0 strb w0, [sp, #170] <== NOT EXECUTED
fmt_params->sectors_per_cluster = 2;
40025220: 52800040 mov w0, #0x2 // #2
40025224: b90087e0 str w0, [sp, #132]
ret_val = msdos_set_sectors_per_cluster_from_request( rqdata,
40025228: 9101e3e1 add x1, sp, #0x78
4002522c: aa1403e0 mov x0, x20
40025230: 97fffc6c bl 400243e0 <msdos_set_sectors_per_cluster_from_request>
if (fat_type != fmt_params->fattype && 1 < iteration_cnt) {
40025234: 3942abe1 ldrb w1, [sp, #170]
--fmt_params->totl_sector_cnt;
40025238: b9407fe2 ldr w2, [sp, #124]
if (fat_type != fmt_params->fattype && 1 < iteration_cnt) {
4002523c: 6b1a003f cmp w1, w26
40025240: 7a411ac0 ccmp w22, #0x1, #0x0, ne // ne = any
if ( fmt_params->totl_sector_cnt == 0 )
40025244: 2a0203ea mov w10, w2
if (fat_type != fmt_params->fattype && 1 < iteration_cnt) {
40025248: 54000089 b.ls 40025258 <msdos_format+0xc58> // b.plast
--fmt_params->totl_sector_cnt;
4002524c: 5100044a sub w10, w2, #0x1
40025250: b9007fea str w10, [sp, #124]
40025254: 2a0a03e2 mov w2, w10
++iteration_cnt;
40025258: 110006d6 add w22, w22, #0x1
4002525c: 12001ed6 and w22, w22, #0xff
while( ret_val == 0
40025260: 34ffce80 cbz w0, 40024c30 <msdos_format+0x630> <== ALWAYS TAKEN
40025264: 2a0003f5 mov w21, w0 <== NOT EXECUTED
40025268: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
4002526c: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
40025270: 17fffd1e b 400246e8 <msdos_format+0xe8> <== NOT EXECUTED
return sectors;
40025274: 2a0603e2 mov w2, w6
fatdata_sect_cnt = fatdata_sect_cnt
40025278: 4b020000 sub w0, w0, w2
fatdata_cluster_cnt = fatdata_sect_cnt/sectors_per_cluster;
4002527c: 1ac10800 udiv w0, w0, w1
fat_capacity = fatdata_cluster_cnt * 3 / 2;
40025280: 0b000402 add w2, w0, w0, lsl #1
40025284: 53017c42 lsr w2, w2, #1
40025288: 17fffea5 b 40024d1c <msdos_format+0x71c>
return (sectors + clustersize - 1) & ~(clustersize - 1);
4002528c: 0b0101ae add w14, w13, w1
40025290: 0a0201c2 and w2, w14, w2
40025294: 17fffff9 b 40025278 <msdos_format+0xc78>
40025298: 0b0101ae add w14, w13, w1
4002529c: 0a0201c2 and w2, w14, w2
400252a0: 17ffffbf b 4002519c <msdos_format+0xb9c>
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
400252a4: aa1803e2 mov x2, x24
400252a8: 52800041 mov w1, #0x2 // #2
400252ac: d2800000 mov x0, #0x0 // #0
400252b0: 97fffc20 bl 40024330 <msdos_format_printf>
if (fmt_params->fattype == FAT_FAT32) {
400252b4: 3942abfa ldrb w26, [sp, #170]
400252b8: 7100135f cmp w26, #0x4
400252bc: 54000161 b.ne 400252e8 <msdos_format+0xce8> // b.any
fmt_params->rsvd_sector_cnt = 32;
400252c0: 52800400 mov w0, #0x20 // #32
400252c4: 52800083 mov w3, #0x4 // #4
+ fmt_params->bytes_per_sector - 1)
400252c8: b9407be4 ldr w4, [sp, #120]
400252cc: 2a0003e9 mov w9, w0
400252d0: 2a0303fa mov w26, w3
400252d4: 52800006 mov w6, #0x0 // #0
fmt_params->rsvd_sector_cnt = 32;
400252d8: b90083e0 str w0, [sp, #128]
fmt_params->files_per_root_dir = 0;
400252dc: b90093ff str wzr, [sp, #144]
fmt_params->mbr_copy_sec = 6;
400252e0: f90053f9 str x25, [sp, #160]
400252e4: 17fffe6f b 40024ca0 <msdos_format+0x6a0>
fmt_params->rsvd_sector_cnt = 1;
400252e8: 52800020 mov w0, #0x1 // #1
400252ec: b90083e0 str w0, [sp, #128]
if (fmt_params->fattype == FAT_FAT16) {
400252f0: 71000b5f cmp w26, #0x2
400252f4: 540000a0 b.eq 40025308 <msdos_format+0xd08> // b.none
ret_val = msdos_format_eval_sectors_per_cluster(fmt_params->fattype,
400252f8: b94083e9 ldr w9, [sp, #128]
400252fc: 2a1a03e3 mov w3, w26
40025300: 528007e0 mov w0, #0x3f // #63
40025304: 17fffe5f b 40024c80 <msdos_format+0x680>
40025308: b94083e9 ldr w9, [sp, #128]
4002530c: 2a1a03e3 mov w3, w26
40025310: 52803fe0 mov w0, #0x1ff // #511
40025314: 17fffe5b b 40024c80 <msdos_format+0x680>
fmt_params->fattype = msdos_get_fat_type(
40025318: 52800080 mov w0, #0x4 // #4
4002531c: 3902abe0 strb w0, [sp, #170]
if (fat_type != fmt_params->fattype) {
40025320: 7100135f cmp w26, #0x4
for ( b = 31; b > 0; b-- ) {
40025324: 528003e0 mov w0, #0x1f // #31
if ( (gigs & ( 1 << b) ) != 0 )
40025328: 52800022 mov w2, #0x1 // #1
if (fat_type != fmt_params->fattype) {
4002532c: 54000081 b.ne 4002533c <msdos_format+0xd3c> // b.any
40025330: 17fffe9c b 40024da0 <msdos_format+0x7a0>
for ( b = 31; b > 0; b-- ) {
40025334: 71000400 subs w0, w0, #0x1
40025338: 54000340 b.eq 400253a0 <msdos_format+0xda0> // b.none <== NEVER TAKEN
if ( (gigs & ( 1 << b) ) != 0 )
4002533c: 1ac02041 lsl w1, w2, w0
40025340: 6a0102ff tst w23, w1
40025344: 54ffff80 b.eq 40025334 <msdos_format+0xd34> // b.none
fmt_params->sectors_per_cluster = 1 << b;
40025348: b90087e1 str w1, [sp, #132]
4002534c: 17ffffb7 b 40025228 <msdos_format+0xc28>
fmt_params->fat_num = 2;
40025350: 52800044 mov w4, #0x2 // #2
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
40025354: f0000102 adrp x2, 40048000 <bsp_section_rodata_begin+0x78>
40025358: 52800043 mov w3, #0x2 // #2
4002535c: 912a2042 add x2, x2, #0xa88
40025360: 2a0303e1 mov w1, w3
40025364: d2800000 mov x0, #0x0 // #0
fmt_params->fat_num = 2;
40025368: 3902a3e4 strb w4, [sp, #168]
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4002536c: 97fffbf1 bl 40024330 <msdos_format_printf>
{
40025370: 528ff501 mov w1, #0x7fa8 // #32680
uint32_t fat16_sect_per_clust = 32;
40025374: 52800400 mov w0, #0x20 // #32
40025378: 17fffe15 b 40024bcc <msdos_format+0x5cc>
else if (fmt_params->totl_sector_cnt < FAT_FAT16_MAX_CLN * fat16_sect_per_clust) {
4002537c: 529ffea1 mov w1, #0xfff5 // #65525
40025380: 1b017c00 mul w0, w0, w1
40025384: 6b00005f cmp w2, w0
40025388: 54000d22 b.cs 4002552c <msdos_format+0xf2c> // b.hs, b.nlast
fmt_params->fattype = FAT_FAT16;
4002538c: 52800040 mov w0, #0x2 // #2
fmt_params->sectors_per_cluster = 2;
40025390: 52800041 mov w1, #0x2 // #2
40025394: b90087e1 str w1, [sp, #132]
fmt_params->fattype = FAT_FAT16;
40025398: 3902abe0 strb w0, [sp, #170]
fmt_params->sectors_per_cluster = 2;
4002539c: 17fffe13 b 40024be8 <msdos_format+0x5e8>
400253a0: 52800021 mov w1, #0x1 // #1 <== NOT EXECUTED
fmt_params->sectors_per_cluster = 1 << b;
400253a4: b90087e1 str w1, [sp, #132] <== NOT EXECUTED
400253a8: 17ffffa0 b 40025228 <msdos_format+0xc28> <== NOT EXECUTED
if ( fmt_params->totl_sector_cnt == 0 )
400253ac: 3400060a cbz w10, 4002546c <msdos_format+0xe6c> <== NEVER TAKEN
fmt_params->files_per_root_dir = loc_align_object (fmt_params->root_dir_sectors,
400253b0: 394323e4 ldrb w4, [sp, #200]
if (FAT_FAT32 != fmt_params->fattype)
400253b4: 7100103f cmp w1, #0x4
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
400253b8: b94087e0 ldr w0, [sp, #132]
if (FAT_FAT32 != fmt_params->fattype)
400253bc: 54000180 b.eq 400253ec <msdos_format+0xdec> // b.none
fmt_params->files_per_root_dir = loc_align_object (fmt_params->root_dir_sectors,
400253c0: b94097e3 ldr w3, [sp, #148]
return (sectors + clustersize - 1) & ~(clustersize - 1);
400253c4: 4b0003e5 neg w5, w0
* (fmt_params->bytes_per_sector / FAT_DIRENTRY_SIZE);
400253c8: b9407be1 ldr w1, [sp, #120]
return (sectors + clustersize - 1) & ~(clustersize - 1);
400253cc: 7100009f cmp w4, #0x0
400253d0: 0b030002 add w2, w0, w3
400253d4: 51000442 sub w2, w2, #0x1
400253d8: 0a050042 and w2, w2, w5
* (fmt_params->bytes_per_sector / FAT_DIRENTRY_SIZE);
400253dc: 53057c21 lsr w1, w1, #5
return (sectors + clustersize - 1) & ~(clustersize - 1);
400253e0: 1a830043 csel w3, w2, w3, eq // eq = none
* (fmt_params->bytes_per_sector / FAT_DIRENTRY_SIZE);
400253e4: 1b037c21 mul w1, w1, w3
fmt_params->files_per_root_dir = loc_align_object (fmt_params->root_dir_sectors,
400253e8: b90093e1 str w1, [sp, #144]
fmt_params->rsvd_sector_cnt = loc_align_object (fmt_params->rsvd_sector_cnt,
400253ec: b94083f6 ldr w22, [sp, #128]
return (sectors + clustersize - 1) & ~(clustersize - 1);
400253f0: 4b0003e1 neg w1, w0
400253f4: 7100009f cmp w4, #0x0
400253f8: 0b160000 add w0, w0, w22
400253fc: 51000400 sub w0, w0, #0x1
40025400: 0a010000 and w0, w0, w1
40025404: 1a960016 csel w22, w0, w22, eq // eq = none
fmt_params->rsvd_sector_cnt = loc_align_object (fmt_params->rsvd_sector_cnt,
40025408: b90083f6 str w22, [sp, #128]
if ((rqdata != NULL) && (rqdata->media != 0)) {
4002540c: b4000274 cbz x20, 40025458 <msdos_format+0xe58>
40025410: 39407297 ldrb w23, [x20, #28]
40025414: 34000237 cbz w23, 40025458 <msdos_format+0xe58>
const char valid_media_codes[] =
40025418: d29f1e04 mov x4, #0xf8f0 // #63728
4002541c: f2bf5f24 movk x4, #0xfaf9, lsl #16
40025420: f2df9f64 movk x4, #0xfcfb, lsl #32
40025424: f2ffdfa4 movk x4, #0xfefd, lsl #48
40025428: 12800003 mov w3, #0xffffffff // #-1
if (NULL==memchr(valid_media_codes,
4002542c: 2a1703e1 mov w1, w23
40025430: 9101a3e0 add x0, sp, #0x68
40025434: d2800122 mov x2, #0x9 // #9
const char valid_media_codes[] =
40025438: f90037e4 str x4, [sp, #104]
4002543c: 3901c3e3 strb w3, [sp, #112]
if (NULL==memchr(valid_media_codes,
40025440: 940057af bl 4003b2fc <memchr>
40025444: b4000a40 cbz x0, 4002558c <msdos_format+0xf8c> <== ALWAYS TAKEN
fmt_params->media_code = rqdata->media;
40025448: 3902a7f7 strb w23, [sp, #169] <== NOT EXECUTED
if ((rqdata != NULL) && (rqdata->media != 0)) {
4002544c: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
40025450: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
40025454: 17fffcac b 40024704 <msdos_format+0x104> <== NOT EXECUTED
fmt_params->media_code = FAT_BR_MEDIA_FIXED;
40025458: 128000e0 mov w0, #0xfffffff8 // #-8
4002545c: 3902a7e0 strb w0, [sp, #169]
40025460: a94363f7 ldp x23, x24, [sp, #48]
40025464: a9446bf9 ldp x25, x26, [sp, #64]
40025468: 17fffca7 b 40024704 <msdos_format+0x104>
4002546c: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
40025470: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
40025474: 17fffc9f b 400246f0 <msdos_format+0xf0> <== NOT EXECUTED
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
40025478: 53087c05 lsr w5, w0, #8
4002547c: 390092a0 strb w0, [x21, #36]
40025480: 390096a5 strb w5, [x21, #37]
memset(FAT_GET_ADDR_BR_FAT32_VOLLAB(mbr) ,0,FAT_BR_VOLLAB_SIZE);
40025484: 91011ea4 add x4, x21, #0x47
FAT_SET_BR_FAT32_ROOT_CLUSTER(mbr , 2); /* put root dir to cluster 2 */
40025488: 3900b2a1 strb w1, [x21, #44]
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
4002548c: 53107c01 lsr w1, w0, #16
40025490: 53187c00 lsr w0, w0, #24
40025494: 39009aa1 strb w1, [x21, #38]
40025498: 39009ea0 strb w0, [x21, #39]
FAT_SET_BR_FAT32_BOOTSIG(mbr ,FAT_BR_FAT32_BOOTSIG_VAL);
4002549c: 52800526 mov w6, #0x29 // #41
FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo to rsrvd sec 1*/
400254a0: 3900c2a2 strb w2, [x21, #48]
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
400254a4: 91014aa0 add x0, x21, #0x52
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
400254a8: b940a3e5 ldr w5, [sp, #160]
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
400254ac: f0000101 adrp x1, 40048000 <bsp_section_rodata_begin+0x78>
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
400254b0: 3900caa5 strb w5, [x21, #50]
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
400254b4: 912bc021 add x1, x1, #0xaf0
memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
400254b8: 3900d2bf strb wzr, [x21, #52]
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
400254bc: d2800102 mov x2, #0x8 // #8
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
400254c0: 53087ca5 lsr w5, w5, #8
400254c4: 3900cea5 strb w5, [x21, #51]
memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
400254c8: 3900d6bf strb wzr, [x21, #53]
400254cc: 3900dabf strb wzr, [x21, #54]
400254d0: 3900debf strb wzr, [x21, #55]
400254d4: 3900e2bf strb wzr, [x21, #56]
400254d8: 3900e6bf strb wzr, [x21, #57]
400254dc: 3900eabf strb wzr, [x21, #58]
400254e0: 3900eebf strb wzr, [x21, #59]
400254e4: 3900f2bf strb wzr, [x21, #60]
400254e8: 3900f6bf strb wzr, [x21, #61]
400254ec: 3900fabf strb wzr, [x21, #62]
400254f0: 3900febf strb wzr, [x21, #63]
FAT_SET_BR_FAT32_BOOTSIG(mbr ,FAT_BR_FAT32_BOOTSIG_VAL);
400254f4: 39010aa6 strb w6, [x21, #66]
memset(FAT_GET_ADDR_BR_FAT32_VOLLAB(mbr) ,0,FAT_BR_VOLLAB_SIZE);
400254f8: 39011ebf strb wzr, [x21, #71]
400254fc: 3900049f strb wzr, [x4, #1]
40025500: 3900089f strb wzr, [x4, #2]
40025504: 39000c9f strb wzr, [x4, #3]
40025508: 3900109f strb wzr, [x4, #4]
4002550c: 3900149f strb wzr, [x4, #5]
40025510: 3900189f strb wzr, [x4, #6]
40025514: 39001c9f strb wzr, [x4, #7]
40025518: 3900209f strb wzr, [x4, #8]
4002551c: 3900249f strb wzr, [x4, #9]
40025520: 3900289f strb wzr, [x4, #10]
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
40025524: 940057b5 bl 4003b3f8 <memcpy>
40025528: 17fffd2b b 400249d4 <msdos_format+0x3d4>
uint32_t gigs = (total_size + ONE_GB) / ONE_GB;
4002552c: d2a80002 mov x2, #0x40000000 // #1073741824
40025530: 8b0202c2 add x2, x22, x2
fmt_params->fattype = FAT_FAT32;
40025534: 52800081 mov w1, #0x4 // #4
for (b = 31; b > 0; b--)
40025538: 528003e0 mov w0, #0x1f // #31
uint32_t gigs = (total_size + ONE_GB) / ONE_GB;
4002553c: d35ef442 ubfx x2, x2, #30, #32
if ((gigs & (1 << b)) != 0)
40025540: 52800023 mov w3, #0x1 // #1
fmt_params->fattype = FAT_FAT32;
40025544: 3902abe1 strb w1, [sp, #170]
for (b = 31; b > 0; b--)
40025548: 14000003 b 40025554 <msdos_format+0xf54>
4002554c: 71000400 subs w0, w0, #0x1
40025550: 54000180 b.eq 40025580 <msdos_format+0xf80> // b.none
if ((gigs & (1 << b)) != 0)
40025554: 1ac02061 lsl w1, w3, w0
40025558: 6a01005f tst w2, w1
4002555c: 54ffff80 b.eq 4002554c <msdos_format+0xf4c> // b.none
fmt_params->sectors_per_cluster = 1 << b;
40025560: b90087e1 str w1, [sp, #132]
40025564: 17fffda1 b 40024be8 <msdos_format+0x5e8>
*volid_ptr = rand();
40025568: 94005a78 bl 4003bf48 <rand>
4002556c: b900c7e0 str w0, [sp, #196]
40025570: 17fffcab b 4002481c <msdos_format+0x21c>
if (ret_val == 0 && rqdata != NULL && rqdata->sync_device) {
40025574: 11000740 add w0, w26, #0x1 <== NOT EXECUTED
40025578: 0a000339 and w25, w25, w0 <== NOT EXECUTED
4002557c: 17fffe91 b 40024fc0 <msdos_format+0x9c0> <== NOT EXECUTED
40025580: 52800021 mov w1, #0x1 // #1
fmt_params->sectors_per_cluster = 1 << b;
40025584: b90087e1 str w1, [sp, #132]
40025588: 17fffd98 b 40024be8 <msdos_format+0x5e8>
errno = EINVAL;
4002558c: 940054f8 bl 4003a96c <__errno>
ret_val = -1;
40025590: 12800015 mov w21, #0xffffffff // #-1
errno = EINVAL;
40025594: 528002c1 mov w1, #0x16 // #22
40025598: a94363f7 ldp x23, x24, [sp, #48]
4002559c: a9446bf9 ldp x25, x26, [sp, #64]
400255a0: b9000001 str w1, [x0]
fmt_params->rsvd_sector_cnt
400255a4: b94083f6 ldr w22, [sp, #128]
400255a8: 17fffc57 b 40024704 <msdos_format+0x104>
400255ac: 2a1a03f5 mov w21, w26
400255b0: a94363f7 ldp x23, x24, [sp, #48]
400255b4: a9446bf9 ldp x25, x26, [sp, #64]
400255b8: a94573fb ldp x27, x28, [sp, #80]
400255bc: 17fffd4a b 40024ae4 <msdos_format+0x4e4>
0000000040031010 <msdos_format_dirent_with_dot>:
{
40031010: aa0003e7 mov x7, x0
for (i = MSDOS_SHORT_BASE_LEN, src_tmp = src + MSDOS_SHORT_BASE_LEN - 1;
40031014: 91001c23 add x3, x1, #0x7
40031018: 52800102 mov w2, #0x8 // #8
4003101c: d503201f nop
i > 0 && *src_tmp == ' ';
40031020: 39400060 ldrb w0, [x3]
40031024: 2a0203e6 mov w6, w2
--i,--src_tmp)
40031028: d1000463 sub x3, x3, #0x1
4003102c: 51000442 sub w2, w2, #0x1
i > 0 && *src_tmp == ' ';
40031030: 7100801f cmp w0, #0x20
40031034: 540001c1 b.ne 4003106c <msdos_format_dirent_with_dot+0x5c> // b.any
for (i = MSDOS_SHORT_BASE_LEN, src_tmp = src + MSDOS_SHORT_BASE_LEN - 1;
40031038: 35ffff42 cbnz w2, 40031020 <msdos_format_dirent_with_dot+0x10> <== ALWAYS TAKEN
len = i;
4003103c: d2800000 mov x0, #0x0 // #0 <== NOT EXECUTED
i > 0 && *src_tmp == ' ';
40031040: 39402823 ldrb w3, [x1, #10]
40031044: 7100807f cmp w3, #0x20
40031048: 540003c1 b.ne 400310c0 <msdos_format_dirent_with_dot+0xb0> // b.any
4003104c: 39402423 ldrb w3, [x1, #9]
40031050: 7100807f cmp w3, #0x20
40031054: 54000721 b.ne 40031138 <msdos_format_dirent_with_dot+0x128> // b.any
40031058: 39402023 ldrb w3, [x1, #8]
4003105c: 7100807f cmp w3, #0x20
40031060: 540007a1 b.ne 40031154 <msdos_format_dirent_with_dot+0x144> // b.any
*dst = '\0'; /* terminate string */
40031064: 390000ff strb wzr, [x7]
}
40031068: d65f03c0 ret
len = i;
4003106c: 93407cc9 sxtw x9, w6
40031070: b00000c8 adrp x8, 4004a000 <fatal_source_text+0x558>
40031074: 91322508 add x8, x8, #0xc89
40031078: aa0903e0 mov x0, x9
4003107c: d2800003 mov x3, #0x0 // #0
*dst++ = tolower((unsigned char)(*src_tmp++));
40031080: 38636822 ldrb w2, [x1, x3]
40031084: 92401c45 and x5, x2, #0xff
40031088: 11008044 add w4, w2, #0x20
4003108c: 12001c84 and w4, w4, #0xff
40031090: 38656905 ldrb w5, [x8, x5]
40031094: 120004a5 and w5, w5, #0x3
40031098: 710004bf cmp w5, #0x1
4003109c: 1a820082 csel w2, w4, w2, eq // eq = none
400310a0: 382368e2 strb w2, [x7, x3]
while (i-- > 0) {
400310a4: 91000463 add x3, x3, #0x1
400310a8: 4b0300c2 sub w2, w6, w3
400310ac: 7100005f cmp w2, #0x0
400310b0: 54fffe8c b.gt 40031080 <msdos_format_dirent_with_dot+0x70>
*dst++ = tolower((unsigned char)(*src_tmp++));
400310b4: 8b0900e7 add x7, x7, x9
400310b8: 2a0603e2 mov w2, w6
400310bc: 17ffffe1 b 40031040 <msdos_format_dirent_with_dot+0x30>
++len; /* dot */
400310c0: 11000442 add w2, w2, #0x1
src_tmp = src + MSDOS_SHORT_BASE_LEN;
400310c4: 91002020 add x0, x1, #0x8
*dst++ = '.'; /* append dot */
400310c8: 528005c3 mov w3, #0x2e // #46
--i, --src_tmp)
400310cc: 52800046 mov w6, #0x2 // #2
++len; /* dot */
400310d0: 93407c41 sxtw x1, w2
*dst++ = '.'; /* append dot */
400310d4: 380014e3 strb w3, [x7], #1
while (i-- > 0) {
400310d8: b00000c8 adrp x8, 4004a000 <fatal_source_text+0x558>
400310dc: 91322508 add x8, x8, #0xc89
400310e0: 110004c9 add w9, w6, #0x1
--i, --src_tmp)
400310e4: d2800003 mov x3, #0x0 // #0
*dst++ = tolower((unsigned char)(*src_tmp++));
400310e8: 38636802 ldrb w2, [x0, x3]
400310ec: 92401c45 and x5, x2, #0xff
400310f0: 11008044 add w4, w2, #0x20
400310f4: 12001c84 and w4, w4, #0xff
400310f8: 38656905 ldrb w5, [x8, x5]
400310fc: 120004a5 and w5, w5, #0x3
40031100: 710004bf cmp w5, #0x1
40031104: 1a820082 csel w2, w4, w2, eq // eq = none
40031108: 382368e2 strb w2, [x7, x3]
while (i-- > 0) {
4003110c: 91000463 add x3, x3, #0x1
40031110: 4b030122 sub w2, w9, w3
40031114: 7100005f cmp w2, #0x0
40031118: 54fffe8c b.gt 400310e8 <msdos_format_dirent_with_dot+0xd8>
*dst++ = tolower((unsigned char)(*src_tmp++));
4003111c: 93407d29 sxtw x9, w9
40031120: 91000421 add x1, x1, #0x1
40031124: 8b0900e7 add x7, x7, x9
++len;
40031128: 93407cc0 sxtw x0, w6
4003112c: 8b010000 add x0, x0, x1
*dst = '\0'; /* terminate string */
40031130: 390000ff strb wzr, [x7]
}
40031134: d65f03c0 ret
++len; /* dot */
40031138: 11000442 add w2, w2, #0x1
src_tmp = src + MSDOS_SHORT_BASE_LEN;
4003113c: 91002020 add x0, x1, #0x8
*dst++ = '.'; /* append dot */
40031140: 528005c3 mov w3, #0x2e // #46
--i, --src_tmp)
40031144: 52800026 mov w6, #0x1 // #1
++len; /* dot */
40031148: 93407c41 sxtw x1, w2
*dst++ = '.'; /* append dot */
4003114c: 380014e3 strb w3, [x7], #1
while (i-- > 0) {
40031150: 17ffffe2 b 400310d8 <msdos_format_dirent_with_dot+0xc8>
++len; /* dot */
40031154: 11000442 add w2, w2, #0x1
src_tmp = src + MSDOS_SHORT_BASE_LEN;
40031158: 91002020 add x0, x1, #0x8
*dst++ = '.'; /* append dot */
4003115c: 528005c3 mov w3, #0x2e // #46
--i, --src_tmp)
40031160: 52800006 mov w6, #0x0 // #0
++len; /* dot */
40031164: 93407c41 sxtw x1, w2
*dst++ = '.'; /* append dot */
40031168: 380014e3 strb w3, [x7], #1
while (i-- > 0) {
4003116c: 17ffffdb b 400310d8 <msdos_format_dirent_with_dot+0xc8>
0000000040031d50 <msdos_get_dotdot_dir_info_cluster_num_and_offset>:
{
40031d50: a9b67bfd stp x29, x30, [sp, #-160]!
40031d54: 910003fd mov x29, sp
40031d58: a90363f7 stp x23, x24, [sp, #48]
msdos_fs_info_t *fs_info = mt_entry->fs_info;
40031d5c: f9400817 ldr x23, [x0, #16]
{
40031d60: a90153f3 stp x19, x20, [sp, #16]
40031d64: aa0203f4 mov x20, x2
40031d68: a9025bf5 stp x21, x22, [sp, #32]
40031d6c: aa0003f5 mov x21, x0
40031d70: aa0303f6 mov x22, x3
rc = fat_file_open(&fs_info->fat, dir_pos, &fat_fd);
40031d74: aa1703e0 mov x0, x23
fat_file_fd_t *fat_fd = NULL;
40031d78: f9002fff str xzr, [sp, #88]
rtems_dosfs_convert_control *converter = fs_info->converter;
40031d7c: f94086f8 ldr x24, [x23, #264]
{
40031d80: f90023f9 str x25, [sp, #64]
40031d84: 2a0103f9 mov w25, w1
rc = fat_file_open(&fs_info->fat, dir_pos, &fat_fd);
40031d88: aa0203e1 mov x1, x2
40031d8c: 910163e2 add x2, sp, #0x58
40031d90: 97fff48c bl 4002efc0 <fat_file_open>
40031d94: 2a0003f3 mov w19, w0
if (rc != RC_OK)
40031d98: 34000100 cbz w0, 40031db8 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x68><== ALWAYS TAKEN
}
40031d9c: 2a1303e0 mov w0, w19
40031da0: a94153f3 ldp x19, x20, [sp, #16]
40031da4: a9425bf5 ldp x21, x22, [sp, #32]
40031da8: a94363f7 ldp x23, x24, [sp, #48]
40031dac: f94023f9 ldr x25, [sp, #64]
40031db0: a8ca7bfd ldp x29, x30, [sp], #160
40031db4: d65f03c0 ret
fat_fd->cln = cln;
40031db8: f9402fe1 ldr x1, [sp, #88]
fat_fd->fat_file_type = FAT_DIRECTORY;
40031dbc: d2e00402 mov x2, #0x20000000000000 // #9007199254740992
rc = fat_file_size(&fs_info->fat, fat_fd);
40031dc0: aa1703e0 mov x0, x23
fat_fd->fat_file_type = FAT_DIRECTORY;
40031dc4: f9000c22 str x2, [x1, #24]
fat_fd->cln = cln;
40031dc8: b9002439 str w25, [x1, #36]
fat_fd->map.disk_cln = fat_fd->cln;
40031dcc: 2907e43f stp wzr, w25, [x1, #60]
rc = fat_file_size(&fs_info->fat, fat_fd);
40031dd0: 97fff7fc bl 4002fdc0 <fat_file_size>
40031dd4: 2a0003f3 mov w19, w0
if (rc != RC_OK)
40031dd8: 35000ac0 cbnz w0, 40031f30 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1e0><== NEVER TAKEN
msdos_long_to_short(
40031ddc: f00000b3 adrp x19, 40048000 <bsp_section_rodata_begin+0x78>
40031de0: 9122a273 add x19, x19, #0x8a8
40031de4: aa1303e1 mov x1, x19
40031de8: 910183e3 add x3, sp, #0x60
40031dec: 52800164 mov w4, #0xb // #11
40031df0: 52800022 mov w2, #0x1 // #1
40031df4: aa1803e0 mov x0, x24
memset(dot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
40031df8: a9067fff stp xzr, xzr, [sp, #96]
40031dfc: a9077fff stp xzr, xzr, [sp, #112]
msdos_long_to_short(
40031e00: 97fffa80 bl 40030800 <msdos_long_to_short>
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, (const uint8_t*)".", 1,
40031e04: aa1303e3 mov x3, x19
40031e08: f9402fe1 ldr x1, [sp, #88]
40031e0c: 52800025 mov w5, #0x1 // #1
40031e10: 910183e7 add x7, sp, #0x60
40031e14: aa1403e6 mov x6, x20
40031e18: 2a0503e4 mov w4, w5
40031e1c: aa1503e0 mov x0, x21
40031e20: 52800002 mov w2, #0x0 // #0
40031e24: 97fffcd3 bl 40031170 <msdos_find_name_in_fat_file>
40031e28: 2a0003f3 mov w19, w0
if (rc != RC_OK)
40031e2c: 35000820 cbnz w0, 40031f30 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1e0><== NEVER TAKEN
msdos_long_to_short(
40031e30: 900000d3 adrp x19, 40049000 <IMFS_node_control_sym_link+0xe0>
40031e34: 91074273 add x19, x19, #0x1d0
40031e38: aa1303e1 mov x1, x19
40031e3c: 910203e3 add x3, sp, #0x80
40031e40: 52800164 mov w4, #0xb // #11
40031e44: 52800042 mov w2, #0x2 // #2
40031e48: aa1803e0 mov x0, x24
memset(dotdot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
40031e4c: a9087fff stp xzr, xzr, [sp, #128]
40031e50: a9097fff stp xzr, xzr, [sp, #144]
msdos_long_to_short(
40031e54: 97fffa6b bl 40030800 <msdos_long_to_short>
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, (const uint8_t*)"..", 2,
40031e58: aa1303e3 mov x3, x19
40031e5c: f9402fe1 ldr x1, [sp, #88]
40031e60: 910203e7 add x7, sp, #0x80
40031e64: aa1403e6 mov x6, x20
40031e68: aa1503e0 mov x0, x21
40031e6c: 52800025 mov w5, #0x1 // #1
40031e70: 52800044 mov w4, #0x2 // #2
40031e74: 52800002 mov w2, #0x0 // #0
40031e78: 97fffcbe bl 40031170 <msdos_find_name_in_fat_file>
40031e7c: 2a0003f3 mov w19, w0
fat_file_close(&fs_info->fat, fat_fd);
40031e80: aa1703e0 mov x0, x23
40031e84: f9402fe1 ldr x1, [sp, #88]
if (rc != RC_OK)
40031e88: 350006b3 cbnz w19, 40031f5c <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x20c><== NEVER TAKEN
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
40031e8c: 7940f7f8 ldrh w24, [sp, #122]
40031e90: 7940ebf9 ldrh w25, [sp, #116]
rc = fat_file_close(&fs_info->fat, fat_fd);
40031e94: 97fff5ff bl 4002f690 <fat_file_close>
40031e98: 2a0003f3 mov w19, w0
if ( rc != RC_OK )
40031e9c: 35fff800 cbnz w0, 40031d9c <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x4c><== NEVER TAKEN
if ( (MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
40031ea0: 79412be0 ldrh w0, [sp, #148]
40031ea4: 794137e1 ldrh w1, [sp, #154]
40031ea8: 2a004020 orr w0, w1, w0, lsl #16
40031eac: 34000680 cbz w0, 40031f7c <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x22c>
rc = fat_file_open(&fs_info->fat, dir_pos, &fat_fd);
40031eb0: 910163e2 add x2, sp, #0x58
40031eb4: aa1403e1 mov x1, x20
40031eb8: aa1703e0 mov x0, x23
40031ebc: 97fff441 bl 4002efc0 <fat_file_open>
40031ec0: 2a0003f3 mov w19, w0
if (rc != RC_OK)
40031ec4: 35fff6c0 cbnz w0, 40031d9c <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x4c><== NEVER TAKEN
if ((MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
40031ec8: 79412be0 ldrh w0, [sp, #148]
40031ecc: 794137e2 ldrh w2, [sp, #154]
fat_fd->cln = fs_info->fat.vol.rdir_cl;
40031ed0: f9402fe1 ldr x1, [sp, #88]
if ((MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
40031ed4: 2a004040 orr w0, w2, w0, lsl #16
40031ed8: 340005c0 cbz w0, 40031f90 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x240>
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node);
40031edc: b9002420 str w0, [x1, #36]
fat_fd->fat_file_type = FAT_DIRECTORY;
40031ee0: d2e00402 mov x2, #0x20000000000000 // #9007199254740992
40031ee4: f9000c22 str x2, [x1, #24]
fat_fd->map.disk_cln = fat_fd->cln;
40031ee8: 2907803f stp wzr, w0, [x1, #60]
rc = fat_file_size(&fs_info->fat, fat_fd);
40031eec: aa1703e0 mov x0, x23
40031ef0: 97fff7b4 bl 4002fdc0 <fat_file_size>
40031ef4: 2a0003f3 mov w19, w0
fat_file_close(&fs_info->fat, fat_fd);
40031ef8: f9402fe1 ldr x1, [sp, #88]
if (rc != RC_OK)
40031efc: 350002e0 cbnz w0, 40031f58 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x208><== NEVER TAKEN
rc = msdos_find_node_by_cluster_num_in_fat_file(mt_entry, fat_fd, cl4find,
40031f00: aa1603e4 mov x4, x22
40031f04: aa1403e3 mov x3, x20
40031f08: 2a194302 orr w2, w24, w25, lsl #16
40031f0c: aa1503e0 mov x0, x21
40031f10: 97ffff2c bl 40031bc0 <msdos_find_node_by_cluster_num_in_fat_file>
40031f14: 2a0003f3 mov w19, w0
fat_file_close(&fs_info->fat, fat_fd);
40031f18: aa1703e0 mov x0, x23
40031f1c: f9402fe1 ldr x1, [sp, #88]
if (rc != RC_OK)
40031f20: 350001f3 cbnz w19, 40031f5c <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x20c><== NEVER TAKEN
rc = fat_file_close(&fs_info->fat, fat_fd);
40031f24: 97fff5db bl 4002f690 <fat_file_close>
40031f28: 2a0003f3 mov w19, w0
return rc;
40031f2c: 17ffff9c b 40031d9c <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x4c>
fat_file_close(&fs_info->fat, fat_fd);
40031f30: f9402fe1 ldr x1, [sp, #88] <== NOT EXECUTED
40031f34: aa1703e0 mov x0, x23 <== NOT EXECUTED
40031f38: 97fff5d6 bl 4002f690 <fat_file_close> <== NOT EXECUTED
}
40031f3c: 2a1303e0 mov w0, w19 <== NOT EXECUTED
40031f40: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40031f44: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
40031f48: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
40031f4c: f94023f9 ldr x25, [sp, #64] <== NOT EXECUTED
40031f50: a8ca7bfd ldp x29, x30, [sp], #160 <== NOT EXECUTED
40031f54: d65f03c0 ret <== NOT EXECUTED
fat_file_close(&fs_info->fat, fat_fd);
40031f58: aa1703e0 mov x0, x23 <== NOT EXECUTED
40031f5c: 97fff5cd bl 4002f690 <fat_file_close> <== NOT EXECUTED
}
40031f60: 2a1303e0 mov w0, w19 <== NOT EXECUTED
40031f64: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40031f68: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
40031f6c: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
40031f70: f94023f9 ldr x25, [sp, #64] <== NOT EXECUTED
40031f74: a8ca7bfd ldp x29, x30, [sp], #160 <== NOT EXECUTED
40031f78: d65f03c0 ret <== NOT EXECUTED
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
40031f7c: 12800000 mov w0, #0xffffffff // #-1
dir_pos->sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
40031f80: 52800021 mov w1, #0x1 // #1
dir_pos->sname.ofs = 0;
40031f84: 29007e81 stp w1, wzr, [x20]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
40031f88: 29010280 stp w0, w0, [x20, #8]
40031f8c: 17ffffc9 b 40031eb0 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x160>
fat_fd->cln = fs_info->fat.vol.rdir_cl;
40031f90: b94046e0 ldr w0, [x23, #68]
40031f94: b9002420 str w0, [x1, #36]
40031f98: 17ffffd2 b 40031ee0 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x190>
40031f9c: 00000000 udf #0
0000000040031fa0 <msdos_get_name_node>:
{
40031fa0: a9bc7bfd stp x29, x30, [sp, #-64]!
rc = msdos_find_name_in_fat_file(parent_loc->mt_entry, fat_fd,
40031fa4: aa0603e7 mov x7, x6
{
40031fa8: 910003fd mov x29, sp
40031fac: a90153f3 stp x19, x20, [sp, #16]
40031fb0: aa0003f3 mov x19, x0
40031fb4: aa0203f4 mov x20, x2
40031fb8: f9001bf7 str x23, [sp, #48]
40031fbc: 12001c37 and w23, w1, #0xff
rc = msdos_find_name_in_fat_file(parent_loc->mt_entry, fat_fd,
40031fc0: f9400801 ldr x1, [x0, #16]
{
40031fc4: a9025bf5 stp x21, x22, [sp, #32]
40031fc8: aa0503f5 mov x21, x5
rc = msdos_find_name_in_fat_file(parent_loc->mt_entry, fat_fd,
40031fcc: f9401400 ldr x0, [x0, #40]
40031fd0: 2a0403e5 mov w5, w4
{
40031fd4: aa0603f6 mov x22, x6
rc = msdos_find_name_in_fat_file(parent_loc->mt_entry, fat_fd,
40031fd8: 2a0303e4 mov w4, w3
40031fdc: aa1503e6 mov x6, x21
40031fe0: aa0203e3 mov x3, x2
40031fe4: 2a1703e2 mov w2, w23
40031fe8: 97fffc62 bl 40031170 <msdos_find_name_in_fat_file>
if (!create_node)
40031fec: 7100001f cmp w0, #0x0
40031ff0: 528fa021 mov w1, #0x7d01 // #32001
40031ff4: 7a411004 ccmp w0, w1, #0x4, ne // ne = any
40031ff8: 7a400ae0 ccmp w23, #0x0, #0x0, eq // eq = none
40031ffc: 540000c0 b.eq 40032014 <msdos_get_name_node+0x74> // b.none
}
40032000: a94153f3 ldp x19, x20, [sp, #16]
40032004: a9425bf5 ldp x21, x22, [sp, #32]
40032008: f9401bf7 ldr x23, [sp, #48]
4003200c: a8c47bfd ldp x29, x30, [sp], #64
40032010: d65f03c0 ret
if (rc == MSDOS_NAME_NOT_FOUND_ERR)
40032014: 6b01001f cmp w0, w1
40032018: 54ffff40 b.eq 40032000 <msdos_get_name_node+0x60> // b.none
if (rc == RC_OK)
4003201c: 35ffff20 cbnz w0, 40032000 <msdos_get_name_node+0x60> <== NEVER TAKEN
if (strncmp(name, "..", 2) == 0)
40032020: 39400281 ldrb w1, [x20]
40032024: 7100b83f cmp w1, #0x2e
40032028: 54fffec1 b.ne 40032000 <msdos_get_name_node+0x60> // b.any
4003202c: 39400681 ldrb w1, [x20, #1]
40032030: 7100b83f cmp w1, #0x2e
40032034: 54fffe61 b.ne 40032000 <msdos_get_name_node+0x60> // b.any <== NEVER TAKEN
dotdot_cln = MSDOS_EXTRACT_CLUSTER_NUM((name_dir_entry));
40032038: 79402ac1 ldrh w1, [x22, #20]
4003203c: 794036c2 ldrh w2, [x22, #26]
40032040: 2a014041 orr w1, w2, w1, lsl #16
if (dotdot_cln == 0)
40032044: 350000c1 cbnz w1, 4003205c <msdos_get_name_node+0xbc>
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
40032048: 12800001 mov w1, #0xffffffff // #-1
dir_pos->sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
4003204c: 52800022 mov w2, #0x1 // #1
dir_pos->sname.ofs = 0;
40032050: 29007ea2 stp w2, wzr, [x21]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
40032054: 290106a1 stp w1, w1, [x21, #8]
40032058: 17ffffea b 40032000 <msdos_get_name_node+0x60>
msdos_get_dotdot_dir_info_cluster_num_and_offset(parent_loc->mt_entry,
4003205c: aa1603e3 mov x3, x22
40032060: aa1503e2 mov x2, x21
}
40032064: a9425bf5 ldp x21, x22, [sp, #32]
msdos_get_dotdot_dir_info_cluster_num_and_offset(parent_loc->mt_entry,
40032068: f9401660 ldr x0, [x19, #40]
}
4003206c: a94153f3 ldp x19, x20, [sp, #16]
40032070: f9401bf7 ldr x23, [sp, #48]
40032074: a8c47bfd ldp x29, x30, [sp], #64
msdos_get_dotdot_dir_info_cluster_num_and_offset(parent_loc->mt_entry,
40032078: 17ffff36 b 40031d50 <msdos_get_dotdot_dir_info_cluster_num_and_offset>
4003207c: 00000000 udf #0
0000000040030720 <msdos_get_utf16_string_from_long_entry.part.0>:
msdos_get_utf16_string_from_long_entry (
40030720: a9bd7bfd stp x29, x30, [sp, #-48]! <== NOT EXECUTED
40030724: 910003fd mov x29, sp <== NOT EXECUTED
40030728: a90153f3 stp x19, x20, [sp, #16] <== NOT EXECUTED
4003072c: aa0103f3 mov x19, x1 <== NOT EXECUTED
40030730: aa0003f4 mov x20, x0 <== NOT EXECUTED
memcpy (&entry_string_buf[0], &entry[1], 10 );
40030734: 91000401 add x1, x0, #0x1 <== NOT EXECUTED
40030738: aa1303e0 mov x0, x19 <== NOT EXECUTED
msdos_get_utf16_string_from_long_entry (
4003073c: f90013f5 str x21, [sp, #32] <== NOT EXECUTED
40030740: 12001c55 and w21, w2, #0xff <== NOT EXECUTED
memcpy (&entry_string_buf[0], &entry[1], 10 );
40030744: d2800142 mov x2, #0xa // #10 <== NOT EXECUTED
40030748: 94002b2c bl 4003b3f8 <memcpy> <== NOT EXECUTED
memcpy (&entry_string_buf[5], &entry[14], 12 );
4003074c: 91003a81 add x1, x20, #0xe <== NOT EXECUTED
40030750: d2800182 mov x2, #0xc // #12 <== NOT EXECUTED
40030754: 91002a60 add x0, x19, #0xa <== NOT EXECUTED
40030758: 94002b28 bl 4003b3f8 <memcpy> <== NOT EXECUTED
memcpy (&entry_string_buf[11], &entry[28], 4 );
4003075c: 39407282 ldrb w2, [x20, #28] <== NOT EXECUTED
40030760: 39005a62 strb w2, [x19, #22] <== NOT EXECUTED
40030764: 39407682 ldrb w2, [x20, #29] <== NOT EXECUTED
40030768: 39005e62 strb w2, [x19, #23] <== NOT EXECUTED
4003076c: 39407a82 ldrb w2, [x20, #30] <== NOT EXECUTED
40030770: 39006262 strb w2, [x19, #24] <== NOT EXECUTED
40030774: 39407e81 ldrb w1, [x20, #31] <== NOT EXECUTED
40030778: 39006661 strb w1, [x19, #25] <== NOT EXECUTED
if (is_first_entry) {
4003077c: 34000115 cbz w21, 4003079c <msdos_get_utf16_string_from_long_entry.part.0+0x7c><== NOT EXECUTED
for (chars_in_entry = 0;
40030780: d2800000 mov x0, #0x0 // #0 <== NOT EXECUTED
40030784: d503201f nop
&& entry_string_buf[chars_in_entry] != 0x0000);
40030788: 78607a61 ldrh w1, [x19, x0, lsl #1]
4003078c: 34000121 cbz w1, 400307b0 <msdos_get_utf16_string_from_long_entry.part.0+0x90>
++chars_in_entry) {
40030790: 91000400 add x0, x0, #0x1
for (chars_in_entry = 0;
40030794: f100341f cmp x0, #0xd
40030798: 54ffff81 b.ne 40030788 <msdos_get_utf16_string_from_long_entry.part.0+0x68> // b.any
4003079c: d2800340 mov x0, #0x1a // #26
}
400307a0: a94153f3 ldp x19, x20, [sp, #16]
400307a4: f94013f5 ldr x21, [sp, #32]
400307a8: a8c37bfd ldp x29, x30, [sp], #48
400307ac: d65f03c0 ret
return chars_in_entry * MSDOS_NAME_LFN_BYTES_PER_CHAR;
400307b0: 8b000000 add x0, x0, x0
}
400307b4: a94153f3 ldp x19, x20, [sp, #16]
400307b8: f94013f5 ldr x21, [sp, #32]
400307bc: a8c37bfd ldp x29, x30, [sp], #48
400307c0: d65f03c0 ret
...
00000000400256f0 <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
)
{
400256f0: a9ba7bfd stp x29, x30, [sp, #-96]!
400256f4: 910003fd mov x29, sp
400256f8: a90153f3 stp x19, x20, [sp, #16]
400256fc: aa0403f4 mov x20, x4
40025700: a9025bf5 stp x21, x22, [sp, #32]
40025704: aa0003f5 mov x21, x0
40025708: aa0303f6 mov x22, x3
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));
4002570c: d2800020 mov x0, #0x1 // #1
{
40025710: a90363f7 stp x23, x24, [sp, #48]
40025714: aa0103f7 mov x23, x1
40025718: aa0203f8 mov x24, x2
fs_info = (msdos_fs_info_t *)calloc(1, sizeof(msdos_fs_info_t));
4002571c: d2802201 mov x1, #0x110 // #272
fat_file_fd_t *fat_fd = NULL;
40025720: f90027ff str xzr, [sp, #72]
fs_info = (msdos_fs_info_t *)calloc(1, sizeof(msdos_fs_info_t));
40025724: 94001baf bl 4002c5e0 <calloc>
if (!fs_info)
40025728: b4000920 cbz x0, 4002584c <msdos_initialize_support+0x15c> <== NEVER TAKEN
temp_mt_entry->fs_info = fs_info;
fs_info->converter = converter;
rc = fat_init_volume_info(&fs_info->fat, temp_mt_entry->dev);
4002572c: f9403aa1 ldr x1, [x21, #112]
temp_mt_entry->fs_info = fs_info;
40025730: f9000aa0 str x0, [x21, #16]
fs_info->converter = converter;
40025734: f9008414 str x20, [x0, #264]
40025738: aa0003f3 mov x19, x0
rc = fat_init_volume_info(&fs_info->fat, temp_mt_entry->dev);
4002573c: 94002131 bl 4002dc00 <fat_init_volume_info>
40025740: 2a0003f4 mov w20, w0
if (rc != RC_OK)
40025744: 35000660 cbnz w0, 40025810 <msdos_initialize_support+0x120> <== NEVER TAKEN
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
40025748: 12800003 mov w3, #0xffffffff // #-1
/*
* 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;
4002574c: 52800024 mov w4, #0x1 // #1
fs_info->file_handlers = file_handlers;
40025750: a90ce276 stp x22, x24, [x19, #200]
rc = fat_file_open(&fs_info->fat, &root_pos, &fat_fd);
40025754: 910123e2 add x2, sp, #0x48
40025758: 910143e1 add x1, sp, #0x50
4002575c: aa1303e0 mov x0, x19
dir_pos->sname.ofs = 0;
40025760: 290a7fe4 stp w4, wzr, [sp, #80]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
40025764: 290b0fe3 stp w3, w3, [sp, #88]
40025768: 94002616 bl 4002efc0 <fat_file_open>
4002576c: 2a0003f4 mov w20, w0
if (rc != RC_OK)
40025770: 350004c0 cbnz w0, 40025808 <msdos_initialize_support+0x118> <== NEVER TAKEN
free(fs_info);
return rc;
}
/* again: unfortunately "fat-file" is just almost fat file :( */
fat_fd->fat_file_type = FAT_DIRECTORY;
40025774: f94027f8 ldr x24, [sp, #72]
40025778: d2e00400 mov x0, #0x20000000000000 // #9007199254740992
4002577c: f9000f00 str x0, [x24, #24]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGTH;
fat_fd->cln = fs_info->fat.vol.rdir_cl;
40025780: b9404660 ldr w0, [x19, #68]
40025784: b9002700 str w0, [x24, #36]
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
40025788: 2907831f stp wzr, w0, [x24, #60]
/* if we have FAT12/16 */
if ( fat_fd->cln == 0 )
4002578c: 35000520 cbnz w0, 40025830 <msdos_initialize_support+0x140>
{
fat_fd->fat_file_size = fs_info->fat.vol.rdir_size;
cl_buf_size = (fs_info->fat.vol.bpc > fs_info->fat.vol.rdir_size) ?
40025790: b9400a60 ldr w0, [x19, #8]
fat_fd->fat_file_size = fs_info->fat.vol.rdir_size;
40025794: b9403661 ldr w1, [x19, #52]
40025798: b9002301 str w1, [x24, #32]
cl_buf_size = (fs_info->fat.vol.bpc > fs_info->fat.vol.rdir_size) ?
4002579c: 6b01001f cmp w0, w1
400257a0: 1a812000 csel w0, w0, w1, cs // cs = hs, nlast
return rc;
}
cl_buf_size = fs_info->fat.vol.bpc;
}
fs_info->cl_buf = (uint8_t *)calloc(cl_buf_size, sizeof(char));
400257a4: 2a0003e0 mov w0, w0
400257a8: d2800021 mov x1, #0x1 // #1
400257ac: 94001b8d bl 4002c5e0 <calloc>
400257b0: f9008260 str x0, [x19, #256]
if (fs_info->cl_buf == NULL)
400257b4: b4000560 cbz x0, 40025860 <msdos_initialize_support+0x170> <== NEVER TAKEN
}
rtems_recursive_mutex_init(&fs_info->vol_mutex,
RTEMS_FILESYSTEM_TYPE_DOSFS);
temp_mt_entry->mt_fs_root->location.node_access = fat_fd;
400257b8: f94026a1 ldr x1, [x21, #72]
const char *_name)
{
struct _Mutex_recursive_Control _init =
_MUTEX_RECURSIVE_NAMED_INITIALIZER(_name);
*_mutex = _init;
400257bc: f80d8e7f str xzr, [x19, #216]!
400257c0: d0000100 adrp x0, 40047000 <__sfvwrite_r+0x58>
400257c4: 913ee000 add x0, x0, #0xfb8
400257c8: a900fe7f stp xzr, xzr, [x19, #8]
400257cc: f9000e60 str x0, [x19, #24]
temp_mt_entry->mt_fs_root->location.handlers = directory_handlers;
temp_mt_entry->ops = op_table;
return rc;
}
400257d0: 2a1403e0 mov w0, w20
400257d4: b900227f str wzr, [x19, #32]
temp_mt_entry->mt_fs_root->location.node_access = fat_fd;
400257d8: f9000838 str x24, [x1, #16]
temp_mt_entry->mt_fs_root->location.handlers = directory_handlers;
400257dc: f9001036 str x22, [x1, #32]
temp_mt_entry->ops = op_table;
400257e0: f9000eb7 str x23, [x21, #24]
}
400257e4: a94153f3 ldp x19, x20, [sp, #16]
400257e8: a9425bf5 ldp x21, x22, [sp, #32]
400257ec: a94363f7 ldp x23, x24, [sp, #48]
400257f0: a8c67bfd ldp x29, x30, [sp], #96
400257f4: d65f03c0 ret
fat_file_close(&fs_info->fat, fat_fd);
400257f8: f94027e1 ldr x1, [sp, #72] <== NOT EXECUTED
return rc;
400257fc: 2a0003f4 mov w20, w0 <== NOT EXECUTED
fat_file_close(&fs_info->fat, fat_fd);
40025800: aa1303e0 mov x0, x19 <== NOT EXECUTED
40025804: 940027a3 bl 4002f690 <fat_file_close> <== NOT EXECUTED
fat_shutdown_drive(&fs_info->fat);
40025808: aa1303e0 mov x0, x19 <== NOT EXECUTED
4002580c: 940022dd bl 4002e380 <fat_shutdown_drive> <== NOT EXECUTED
free(fs_info);
40025810: aa1303e0 mov x0, x19 <== NOT EXECUTED
40025814: 97fff15b bl 40021d80 <free> <== NOT EXECUTED
}
40025818: 2a1403e0 mov w0, w20 <== NOT EXECUTED
4002581c: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40025820: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
40025824: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
40025828: a8c67bfd ldp x29, x30, [sp], #96 <== NOT EXECUTED
4002582c: d65f03c0 ret <== NOT EXECUTED
rc = fat_file_size(&fs_info->fat, fat_fd);
40025830: aa1803e1 mov x1, x24
40025834: aa1303e0 mov x0, x19
40025838: 94002962 bl 4002fdc0 <fat_file_size>
if ( rc != RC_OK )
4002583c: 35fffde0 cbnz w0, 400257f8 <msdos_initialize_support+0x108> <== NEVER TAKEN
cl_buf_size = fs_info->fat.vol.bpc;
40025840: b9400a60 ldr w0, [x19, #8]
fat_file_close(&fs_info->fat, fat_fd);
40025844: f94027f8 ldr x24, [sp, #72]
40025848: 17ffffd7 b 400257a4 <msdos_initialize_support+0xb4>
rtems_set_errno_and_return_minus_one(ENOMEM);
4002584c: 94005448 bl 4003a96c <__errno> <== NOT EXECUTED
40025850: 12800014 mov w20, #0xffffffff // #-1 <== NOT EXECUTED
40025854: 52800181 mov w1, #0xc // #12 <== NOT EXECUTED
40025858: b9000001 str w1, [x0] <== NOT EXECUTED
4002585c: 17ffffef b 40025818 <msdos_initialize_support+0x128> <== NOT EXECUTED
fat_file_close(&fs_info->fat, fat_fd);
40025860: aa1803e1 mov x1, x24 <== NOT EXECUTED
40025864: aa1303e0 mov x0, x19 <== NOT EXECUTED
40025868: 9400278a bl 4002f690 <fat_file_close> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
4002586c: 12800014 mov w20, #0xffffffff // #-1 <== NOT EXECUTED
fat_shutdown_drive(&fs_info->fat);
40025870: aa1303e0 mov x0, x19 <== NOT EXECUTED
40025874: 940022c3 bl 4002e380 <fat_shutdown_drive> <== NOT EXECUTED
free(fs_info);
40025878: aa1303e0 mov x0, x19 <== NOT EXECUTED
4002587c: 97fff141 bl 40021d80 <free> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
40025880: 9400543b bl 4003a96c <__errno> <== NOT EXECUTED
40025884: 52800181 mov w1, #0xc // #12 <== NOT EXECUTED
40025888: b9000001 str w1, [x0] <== NOT EXECUTED
4002588c: 17ffffe3 b 40025818 <msdos_initialize_support+0x128> <== NOT EXECUTED
00000000400307d0 <msdos_lfn_checksum>:
for (i = 0; i < MSDOS_SHORT_NAME_LEN; ++i) {
400307d0: 91002c04 add x4, x0, #0xb <== NOT EXECUTED
cs = 0;
400307d4: 52800001 mov w1, #0x0 // #0 <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + name[i];
400307d8: 38401403 ldrb w3, [x0], #1 <== NOT EXECUTED
400307dc: 53190022 ubfiz w2, w1, #7, #1 <== NOT EXECUTED
for (i = 0; i < MSDOS_SHORT_NAME_LEN; ++i) {
400307e0: eb00009f cmp x4, x0 <== NOT EXECUTED
400307e4: 0b410461 add w1, w3, w1, lsr #1 <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + name[i];
400307e8: 0b210041 add w1, w2, w1, uxtb <== NOT EXECUTED
400307ec: 12001c21 and w1, w1, #0xff <== NOT EXECUTED
for (i = 0; i < MSDOS_SHORT_NAME_LEN; ++i) {
400307f0: 54ffff41 b.ne 400307d8 <msdos_lfn_checksum+0x8> // b.any <== NOT EXECUTED
}
400307f4: 2a0103e0 mov w0, w1 <== NOT EXECUTED
400307f8: d65f03c0 ret <== NOT EXECUTED
400307fc: 00000000 udf #0
0000000040030800 <msdos_long_to_short>:
{
40030800: a9b67bfd stp x29, x30, [sp, #-160]!
40030804: 910003fd mov x29, sp
40030808: a90363f7 stp x23, x24, [sp, #48]
4003080c: aa0003f8 mov x24, x0
40030810: aa0303e0 mov x0, x3
40030814: a90153f3 stp x19, x20, [sp, #16]
40030818: aa0103f4 mov x20, x1
memset (sfn, ' ', sfn_len);
4003081c: 93407c81 sxtw x1, w4
40030820: a90787e3 stp x3, x1, [sp, #120]
size_t codepage_name_len = converter->buffer.size;
40030824: f9400b03 ldr x3, [x24, #16]
{
40030828: a9025bf5 stp x21, x22, [sp, #32]
4003082c: 2a0203f5 mov w21, w2
memset (sfn, ' ', sfn_len);
40030830: aa0103e2 mov x2, x1
40030834: 52800401 mov w1, #0x20 // #32
size_t codepage_name_len = converter->buffer.size;
40030838: f9004fe3 str x3, [sp, #152]
void *buffer = converter->buffer.data;
4003083c: f9400713 ldr x19, [x24, #8]
memset (sfn, ' ', sfn_len);
40030840: 94002b09 bl 4003b464 <memset>
if ((lfn[0] == '.') && (lfn_len == 1))
40030844: 39400281 ldrb w1, [x20]
40030848: 7100b83f cmp w1, #0x2e
4003084c: 54001040 b.eq 40030a54 <msdos_long_to_short+0x254> // b.none
for (i = 0; i < lfn_len; i++)
40030850: 710002bf cmp w21, #0x0
40030854: 52800003 mov w3, #0x0 // #0
40030858: d2800020 mov x0, #0x1 // #1
if ((lfn[i] != ' ') && (lfn[i] != '.'))
4003085c: 528005c2 mov w2, #0x2e // #46
for (i = 0; i < lfn_len; i++)
40030860: 540000cc b.gt 40030878 <msdos_long_to_short+0x78> <== ALWAYS TAKEN
40030864: 14000079 b 40030a48 <msdos_long_to_short+0x248> <== NOT EXECUTED
40030868: 6b0002bf cmp w21, w0
4003086c: 54000eed b.le 40030a48 <msdos_long_to_short+0x248>
if ((lfn[i] != ' ') && (lfn[i] != '.'))
40030870: 38606a81 ldrb w1, [x20, x0]
40030874: 91000400 add x0, x0, #0x1
40030878: 7100803f cmp w1, #0x20
for (i = 0; i < lfn_len; i++)
4003087c: 2a0003e3 mov w3, w0
if ((lfn[i] != ' ') && (lfn[i] != '.'))
40030880: 7a421024 ccmp w1, w2, #0x4, ne // ne = any
40030884: 54ffff20 b.eq 40030868 <msdos_long_to_short+0x68> // b.none
eno = (*converter->handler->utf8_to_codepage) (
40030888: f9400300 ldr x0, [x24]
4003088c: 93407ea1 sxtw x1, w21
40030890: aa0103e2 mov x2, x1
40030894: 910263e4 add x4, sp, #0x98
40030898: aa1303e3 mov x3, x19
4003089c: f90047e1 str x1, [sp, #136]
400308a0: f9400005 ldr x5, [x0]
400308a4: aa1403e1 mov x1, x20
400308a8: aa1803e0 mov x0, x24
400308ac: d63f00a0 blr x5
if (eno == EINVAL)
400308b0: 7100581f cmp w0, #0x16
400308b4: 54000e60 b.eq 40030a80 <msdos_long_to_short+0x280> // b.none
type = msdos_name_type (
400308b8: a9046bf9 stp x25, x26, [sp, #64]
while (*name && (count < name_len))
400308bc: 3940027a ldrb w26, [x19]
type = msdos_name_type (
400308c0: f9404ff5 ldr x21, [sp, #152]
while (*name && (count < name_len))
400308c4: 7100035f cmp w26, #0x0
400308c8: 1a9f07f9 cset w25, ne // ne = any
400308cc: 710002bf cmp w21, #0x0
400308d0: 1a9fd7e0 cset w0, gt
400308d4: 6a000339 ands w25, w25, w0
400308d8: 54000de0 b.eq 40030a94 <msdos_long_to_short+0x294> // b.none <== NEVER TAKEN
400308dc: b00000d7 adrp x23, 40049000 <IMFS_node_control_sym_link+0xe0>
400308e0: 910de2f7 add x23, x23, #0x378
if ((ch == '.') || isalnum((unsigned char)ch) ||
400308e4: d00000c0 adrp x0, 4004a000 <fatal_source_text+0x558>
400308e8: 91322400 add x0, x0, #0xc89
int dot_at = -1;
400308ec: 12800016 mov w22, #0xffffffff // #-1
400308f0: a90573fb stp x27, x28, [sp, #80]
(strchr("$%'-_@~`!(){}^#&", ch) != NULL) || (unsigned char) ch > 127)
400308f4: b00000dc adrp x28, 40049000 <IMFS_node_control_sym_link+0xe0>
400308f8: 910e039c add x28, x28, #0x380
int count = 0;
400308fc: 5280001b mov w27, #0x0 // #0
if ((ch == '.') || isalnum((unsigned char)ch) ||
40030900: f90037e0 str x0, [sp, #104]
bool uppercase = false;
40030904: 290e7fff stp wzr, wzr, [sp, #112]
40030908: 14000020 b 40030988 <msdos_long_to_short+0x188>
if ((ch == '.') || isalnum((unsigned char)ch) ||
4003090c: 7100bb5f cmp w26, #0x2e
40030910: 54000940 b.eq 40030a38 <msdos_long_to_short+0x238> // b.none
40030914: f94037e1 ldr x1, [sp, #104]
40030918: 92401f40 and x0, x26, #0xff
4003091c: 38616800 ldrb w0, [x0, x1]
40030920: f240081f tst x0, #0x7
40030924: 540000a1 b.ne 40030938 <msdos_long_to_short+0x138> // b.any
(strchr("$%'-_@~`!(){}^#&", ch) != NULL) || (unsigned char) ch > 127)
40030928: 2a1a03e1 mov w1, w26
4003092c: aa1c03e0 mov x0, x28
40030930: 94002ec4 bl 4003c440 <strchr>
if ((ch == '.') || isalnum((unsigned char)ch) ||
40030934: b4000500 cbz x0, 400309d4 <msdos_long_to_short+0x1d4>
if (dot_at >= 0)
40030938: 310006df cmn w22, #0x1
4003093c: 54000b20 b.eq 40030aa0 <msdos_long_to_short+0x2a0> // b.none
if (is_dot || ((count - dot_at) > 3))
40030940: 4b160360 sub w0, w27, w22
40030944: 71000c1f cmp w0, #0x3
40030948: 5400028c b.gt 40030998 <msdos_long_to_short+0x198>
else if ((*name >= 'A') && (*name <= 'Z'))
4003094c: 51010740 sub w0, w26, #0x41
40030950: 12001c00 and w0, w0, #0xff
40030954: 7100641f cmp w0, #0x19
40030958: 54000529 b.ls 400309fc <msdos_long_to_short+0x1fc> // b.plast
else if ((*name >= 'a') && (*name <= 'z'))
4003095c: 51018741 sub w1, w26, #0x61
lowercase = true;
40030960: b94073e0 ldr w0, [sp, #112]
else if ((*name >= 'a') && (*name <= 'z'))
40030964: 12001c21 and w1, w1, #0xff
lowercase = true;
40030968: 7100643f cmp w1, #0x19
4003096c: 1a998000 csel w0, w0, w25, hi // hi = pmore
40030970: b90073e0 str w0, [sp, #112]
while (*name && (count < name_len))
40030974: 38401e7a ldrb w26, [x19, #1]!
count++;
40030978: 1100077b add w27, w27, #0x1
while (*name && (count < name_len))
4003097c: 7100035f cmp w26, #0x0
40030980: 7a5b12a4 ccmp w21, w27, #0x4, ne // ne = any
40030984: 5400048d b.le 40030a14 <msdos_long_to_short+0x214>
if (strchr(" +,;=[]", ch) != NULL)
40030988: 2a1a03e1 mov w1, w26
4003098c: aa1703e0 mov x0, x23
40030990: 94002eac bl 4003c440 <strchr>
40030994: b4fffbc0 cbz x0, 4003090c <msdos_long_to_short+0x10c>
type = MSDOS_NAME_LONG;
40030998: a9446bf9 ldp x25, x26, [sp, #64]
4003099c: 52800055 mov w21, #0x2 // #2
400309a0: a94573fb ldp x27, x28, [sp, #80]
short_filename_length = msdos_filename_utf8_to_short_name_for_save (
400309a4: aa1403e1 mov x1, x20
400309a8: a94793e3 ldp x3, x4, [sp, #120]
400309ac: aa1803e0 mov x0, x24
400309b0: f94047e2 ldr x2, [sp, #136]
400309b4: 94001a6b bl 40037360 <msdos_filename_utf8_to_short_name_for_save>
if (short_filename_length < 0 ) {
400309b8: b7f80140 tbnz x0, #63, 400309e0 <msdos_long_to_short+0x1e0> <== NEVER TAKEN
}
400309bc: 2a1503e0 mov w0, w21
400309c0: a94153f3 ldp x19, x20, [sp, #16]
400309c4: a9425bf5 ldp x21, x22, [sp, #32]
400309c8: a94363f7 ldp x23, x24, [sp, #48]
400309cc: a8ca7bfd ldp x29, x30, [sp], #160
400309d0: d65f03c0 ret
(strchr("$%'-_@~`!(){}^#&", ch) != NULL) || (unsigned char) ch > 127)
400309d4: 373ffb3a tbnz w26, #7, 40030938 <msdos_long_to_short+0x138>
400309d8: a9446bf9 ldp x25, x26, [sp, #64]
400309dc: a94573fb ldp x27, x28, [sp, #80]
return MSDOS_NAME_INVALID;
400309e0: 52800015 mov w21, #0x0 // #0
}
400309e4: 2a1503e0 mov w0, w21
400309e8: a94153f3 ldp x19, x20, [sp, #16]
400309ec: a9425bf5 ldp x21, x22, [sp, #32]
400309f0: a94363f7 ldp x23, x24, [sp, #48]
400309f4: a8ca7bfd ldp x29, x30, [sp], #160
400309f8: d65f03c0 ret
while (*name && (count < name_len))
400309fc: 38401e7a ldrb w26, [x19, #1]!
count++;
40030a00: 1100077b add w27, w27, #0x1
uppercase = true;
40030a04: b90077f9 str w25, [sp, #116]
while (*name && (count < name_len))
40030a08: 7100035f cmp w26, #0x0
40030a0c: 7a5b12a4 ccmp w21, w27, #0x4, ne // ne = any
40030a10: 54fffbcc b.gt 40030988 <msdos_long_to_short+0x188>
if (lowercase && uppercase)
40030a14: b94073e0 ldr w0, [sp, #112]
40030a18: a9446bf9 ldp x25, x26, [sp, #64]
40030a1c: 7100001f cmp w0, #0x0
type = MSDOS_NAME_LONG;
40030a20: b94077e0 ldr w0, [sp, #116]
40030a24: a94573fb ldp x27, x28, [sp, #80]
40030a28: 7a401804 ccmp w0, #0x0, #0x4, ne // ne = any
40030a2c: 1a9f07f5 cset w21, ne // ne = any
40030a30: 110006b5 add w21, w21, #0x1
40030a34: 17ffffdc b 400309a4 <msdos_long_to_short+0x1a4>
if (dot_at >= 0)
40030a38: 310006df cmn w22, #0x1
40030a3c: 54fffae1 b.ne 40030998 <msdos_long_to_short+0x198> // b.any
40030a40: 2a1b03f6 mov w22, w27
40030a44: 17ffffcc b 40030974 <msdos_long_to_short+0x174>
if (i == lfn_len)
40030a48: 6b0302bf cmp w21, w3
40030a4c: 54fff1e1 b.ne 40030888 <msdos_long_to_short+0x88> // b.any <== NEVER TAKEN
40030a50: 17ffffe4 b 400309e0 <msdos_long_to_short+0x1e0>
if ((lfn[0] == '.') && (lfn_len == 1))
40030a54: 710006bf cmp w21, #0x1
40030a58: 54000180 b.eq 40030a88 <msdos_long_to_short+0x288> // b.none
if ((lfn[0] == '.') && (lfn[1] == '.') && (lfn_len == 2))
40030a5c: 39400680 ldrb w0, [x20, #1]
40030a60: 7100b81f cmp w0, #0x2e
40030a64: 7a420aa0 ccmp w21, #0x2, #0x0, eq // eq = none
40030a68: 54ffef41 b.ne 40030850 <msdos_long_to_short+0x50> // b.any
sfn[0] = sfn[1] = '.';
40030a6c: f9403fe0 ldr x0, [sp, #120]
return MSDOS_NAME_SHORT;
40030a70: 52800035 mov w21, #0x1 // #1
sfn[0] = sfn[1] = '.';
40030a74: 39000001 strb w1, [x0]
40030a78: 39000401 strb w1, [x0, #1]
return MSDOS_NAME_SHORT;
40030a7c: 17ffffd0 b 400309bc <msdos_long_to_short+0x1bc>
type = MSDOS_NAME_LONG;
40030a80: 52800055 mov w21, #0x2 // #2
40030a84: 17ffffc8 b 400309a4 <msdos_long_to_short+0x1a4>
sfn[0] = '.';
40030a88: f9403fe0 ldr x0, [sp, #120]
40030a8c: 39000001 strb w1, [x0]
return MSDOS_NAME_SHORT;
40030a90: 17ffffcb b 400309bc <msdos_long_to_short+0x1bc>
return MSDOS_NAME_SHORT;
40030a94: 52800035 mov w21, #0x1 // #1 <== NOT EXECUTED
40030a98: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
40030a9c: 17ffffc2 b 400309a4 <msdos_long_to_short+0x1a4> <== NOT EXECUTED
if (count == 8 && !is_dot)
40030aa0: 7100bb5f cmp w26, #0x2e
40030aa4: 7a481b60 ccmp w27, #0x8, #0x0, ne // ne = any
40030aa8: 54fff521 b.ne 4003094c <msdos_long_to_short+0x14c> // b.any
40030aac: 17ffffbb b 40030998 <msdos_long_to_short+0x198>
0000000040025890 <msdos_mknod>:
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
40025890: 2a0303e4 mov w4, w3
fat_file_type_t type = 0;
/*
* Figure out what type of msdos node this is.
*/
if (S_ISDIR(mode))
40025894: 12140c63 and w3, w3, #0xf000
{
40025898: aa0103e5 mov x5, x1
if (S_ISDIR(mode))
4002589c: 7140107f cmp w3, #0x4, lsl #12
400258a0: 54000100 b.eq 400258c0 <msdos_mknod+0x30> // b.none
{
type = FAT_DIRECTORY;
}
else if (S_ISREG(mode))
400258a4: 7140207f cmp w3, #0x8, lsl #12
{
type = FAT_FILE;
400258a8: 52800081 mov w1, #0x4 // #4
else if (S_ISREG(mode))
400258ac: 54000141 b.ne 400258d4 <msdos_mknod+0x44> // b.any <== NEVER TAKEN
}
else
rtems_set_errno_and_return_minus_one(EINVAL);
/* Create an MSDOS node */
rc = msdos_creat_node(parentloc, type, name, namelen, mode, NULL);
400258b0: 2a0203e3 mov w3, w2
400258b4: aa0503e2 mov x2, x5
400258b8: d2800005 mov x5, #0x0 // #0
400258bc: 140029e5 b 40030050 <msdos_creat_node>
400258c0: 2a0203e3 mov w3, w2
type = FAT_DIRECTORY;
400258c4: 52800001 mov w1, #0x0 // #0
rc = msdos_creat_node(parentloc, type, name, namelen, mode, NULL);
400258c8: aa0503e2 mov x2, x5
400258cc: d2800005 mov x5, #0x0 // #0
400258d0: 140029e0 b 40030050 <msdos_creat_node>
{
400258d4: a9bf7bfd stp x29, x30, [sp, #-16]! <== NOT EXECUTED
400258d8: 910003fd mov x29, sp <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EINVAL);
400258dc: 94005424 bl 4003a96c <__errno> <== NOT EXECUTED
400258e0: 528002c1 mov w1, #0x16 // #22 <== NOT EXECUTED
400258e4: b9000001 str w1, [x0] <== NOT EXECUTED
return rc;
}
400258e8: 12800000 mov w0, #0xffffffff // #-1 <== NOT EXECUTED
400258ec: a8c17bfd ldp x29, x30, [sp], #16 <== NOT EXECUTED
400258f0: d65f03c0 ret <== NOT EXECUTED
...
0000000040025900 <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
)
{
40025900: a9be7bfd stp x29, x30, [sp, #-32]! <== NOT EXECUTED
40025904: aa0203e0 mov x0, x2 <== NOT EXECUTED
/*
* create new directory entry as "hard link", copying relevant info from
* existing file
*/
rc = msdos_creat_node(new_parent_loc,
40025908: aa0303e2 mov x2, x3 <== NOT EXECUTED
{
4002590c: 910003fd mov x29, sp <== NOT EXECUTED
40025910: a90153f3 stp x19, x20, [sp, #16] <== NOT EXECUTED
rc = msdos_creat_node(new_parent_loc,
40025914: 2a0403e3 mov w3, w4 <== NOT EXECUTED
{
40025918: aa0103f3 mov x19, x1 <== NOT EXECUTED
fat_file_fd_t *old_fat_fd = old_loc->node_access;
4002591c: f9400834 ldr x20, [x1, #16] <== NOT EXECUTED
rc = msdos_creat_node(new_parent_loc,
40025920: 52900004 mov w4, #0x8000 // #32768 <== NOT EXECUTED
40025924: 52800041 mov w1, #0x2 // #2 <== NOT EXECUTED
40025928: aa1403e5 mov x5, x20 <== NOT EXECUTED
4002592c: 940029c9 bl 40030050 <msdos_creat_node> <== NOT EXECUTED
FAT_HARD_LINK,new_name,new_namelen,S_IFREG,
old_fat_fd);
if (rc != RC_OK)
40025930: 34000080 cbz w0, 40025940 <msdos_rename+0x40> <== NOT EXECUTED
rc = msdos_set_first_char4file_name(old_loc->mt_entry,
&old_fat_fd->dir_pos,
MSDOS_THIS_DIR_ENTRY_EMPTY);
return rc;
}
40025934: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40025938: a8c27bfd ldp x29, x30, [sp], #32 <== NOT EXECUTED
4002593c: d65f03c0 ret <== NOT EXECUTED
rc = msdos_set_first_char4file_name(old_loc->mt_entry,
40025940: 9100a281 add x1, x20, #0x28 <== NOT EXECUTED
40025944: 12800342 mov w2, #0xffffffe5 // #-27 <== NOT EXECUTED
40025948: f9401660 ldr x0, [x19, #40] <== NOT EXECUTED
}
4002594c: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40025950: a8c27bfd ldp x29, x30, [sp], #32 <== NOT EXECUTED
rc = msdos_set_first_char4file_name(old_loc->mt_entry,
40025954: 14002cfb b 40030d40 <msdos_set_first_char4file_name> <== NOT EXECUTED
...
0000000040025960 <msdos_rmnod>:
#include "msdos.h"
int
msdos_rmnod(const rtems_filesystem_location_info_t *parent_pathloc,
const rtems_filesystem_location_info_t *pathloc)
{
40025960: a9bc7bfd stp x29, x30, [sp, #-64]!
40025964: 910003fd mov x29, sp
40025968: a9025bf5 stp x21, x22, [sp, #32]
int rc = RC_OK;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = pathloc->node_access;
4002596c: f9400835 ldr x21, [x1, #16]
{
40025970: a90153f3 stp x19, x20, [sp, #16]
40025974: aa0103f4 mov x20, x1
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
40025978: f9401420 ldr x0, [x1, #40]
if (fat_fd->fat_file_type == FAT_DIRECTORY)
4002597c: b9401aa1 ldr w1, [x21, #24]
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
40025980: f9400816 ldr x22, [x0, #16]
if (fat_fd->fat_file_type == FAT_DIRECTORY)
40025984: 350001a1 cbnz w1, 400259b8 <msdos_rmnod+0x58>
bool is_empty = false;
/*
* You cannot remove a node that still has children
*/
rc = msdos_dir_is_empty(pathloc->mt_entry, fat_fd, &is_empty);
40025988: 9100ffe2 add x2, sp, #0x3f
4002598c: aa1503e1 mov x1, x21
bool is_empty = false;
40025990: 3900ffff strb wzr, [sp, #63]
rc = msdos_dir_is_empty(pathloc->mt_entry, fat_fd, &is_empty);
40025994: 94002d3f bl 40030e90 <msdos_dir_is_empty>
40025998: 2a0003f3 mov w19, w0
if (rc != RC_OK)
4002599c: 35000180 cbnz w0, 400259cc <msdos_rmnod+0x6c> <== NEVER TAKEN
{
return rc;
}
if (!is_empty)
400259a0: 3940ffe0 ldrb w0, [sp, #63]
400259a4: 34000380 cbz w0, 40025a14 <msdos_rmnod+0xb4>
/*
* We deny attempts to delete open directory (if directory is current
* directory we assume it is open one)
*/
if (fat_fd->links_num > 1)
400259a8: b94012a0 ldr w0, [x21, #16]
400259ac: 7100041f cmp w0, #0x1
400259b0: 54000288 b.hi 40025a00 <msdos_rmnod+0xa0> // b.pmore <== NEVER TAKEN
* not used - mount() not implemenetd yet.
*/
}
/* mark file removed */
rc = msdos_set_first_char4file_name(pathloc->mt_entry, &fat_fd->dir_pos,
400259b4: f9401680 ldr x0, [x20, #40]
400259b8: 9100a2a1 add x1, x21, #0x28
400259bc: 12800342 mov w2, #0xffffffe5 // #-27
400259c0: 94002ce0 bl 40030d40 <msdos_set_first_char4file_name>
400259c4: 2a0003f3 mov w19, w0
MSDOS_THIS_DIR_ENTRY_EMPTY);
if (rc != RC_OK)
400259c8: 340000c0 cbz w0, 400259e0 <msdos_rmnod+0x80> <== ALWAYS TAKEN
}
fat_file_mark_removed(&fs_info->fat, fat_fd);
return rc;
}
400259cc: 2a1303e0 mov w0, w19
400259d0: a94153f3 ldp x19, x20, [sp, #16]
400259d4: a9425bf5 ldp x21, x22, [sp, #32]
400259d8: a8c47bfd ldp x29, x30, [sp], #64
400259dc: d65f03c0 ret
fat_file_mark_removed(&fs_info->fat, fat_fd);
400259e0: aa1503e1 mov x1, x21
400259e4: aa1603e0 mov x0, x22
400259e8: 940028e2 bl 4002fd70 <fat_file_mark_removed>
}
400259ec: 2a1303e0 mov w0, w19
400259f0: a94153f3 ldp x19, x20, [sp, #16]
400259f4: a9425bf5 ldp x21, x22, [sp, #32]
400259f8: a8c47bfd ldp x29, x30, [sp], #64
400259fc: d65f03c0 ret
rtems_set_errno_and_return_minus_one(EBUSY);
40025a00: 940053db bl 4003a96c <__errno> <== NOT EXECUTED
40025a04: 12800013 mov w19, #0xffffffff // #-1 <== NOT EXECUTED
40025a08: 52800201 mov w1, #0x10 // #16 <== NOT EXECUTED
40025a0c: b9000001 str w1, [x0] <== NOT EXECUTED
40025a10: 17ffffef b 400259cc <msdos_rmnod+0x6c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOTEMPTY);
40025a14: 940053d6 bl 4003a96c <__errno>
40025a18: 12800013 mov w19, #0xffffffff // #-1
40025a1c: 52800b41 mov w1, #0x5a // #90
40025a20: b9000001 str w1, [x0]
40025a24: 17ffffea b 400259cc <msdos_rmnod+0x6c>
...
0000000040030d40 <msdos_set_first_char4file_name>:
{
40030d40: a9bb7bfd stp x29, x30, [sp, #-80]!
40030d44: 910003fd mov x29, sp
40030d48: a90153f3 stp x19, x20, [sp, #16]
msdos_fs_info_t *fs_info = mt_entry->fs_info;
40030d4c: f9400813 ldr x19, [x0, #16]
{
40030d50: a9025bf5 stp x21, x22, [sp, #32]
fat_pos_t start = dir_pos->lname;
40030d54: b9400c20 ldr w0, [x1, #12]
fat_pos_t end = dir_pos->sname;
40030d58: 29405834 ldp w20, w22, [x1]
{
40030d5c: 3900ffe2 strb w2, [sp, #63]
fat_pos_t start = dir_pos->lname;
40030d60: b9400822 ldr w2, [x1, #8]
40030d64: 290903e2 stp w2, w0, [sp, #72]
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
40030d68: b9404660 ldr w0, [x19, #68]
40030d6c: 6b14001f cmp w0, w20
40030d70: 54000840 b.eq 40030e78 <msdos_set_first_char4file_name+0x138> // b.none
dir_block_size = fs_info->fat.vol.bpc;
40030d74: b9400a75 ldr w21, [x19, #8]
if (dir_pos->lname.cln == FAT_FILE_SHORT_NAME)
40030d78: b9400820 ldr w0, [x1, #8]
40030d7c: 3100041f cmn w0, #0x1
40030d80: 54000740 b.eq 40030e68 <msdos_set_first_char4file_name+0x128> // b.none
(start.ofs >> fs_info->fat.vol.sec_log2));
40030d84: b9404fe5 ldr w5, [sp, #76]
uint32_t sec = (fat_cluster_num_to_sector_num(&fs_info->fat, start.cln) +
40030d88: b9404be1 ldr w1, [sp, #72]
40030d8c: 14000005 b 40030da0 <msdos_set_first_char4file_name+0x60>
start.ofs += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
40030d90: 110080a5 add w5, w5, #0x20
40030d94: b9004fe5 str w5, [sp, #76]
if (start.ofs >= dir_block_size)
40030d98: 6b1500bf cmp w5, w21
40030d9c: 540004c2 b.cs 40030e34 <msdos_set_first_char4file_name+0xf4> // b.hs, b.nlast
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
40030da0: 51000820 sub w0, w1, #0x2
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
40030da4: 35000081 cbnz w1, 40030db4 <msdos_set_first_char4file_name+0x74>
40030da8: 39405a61 ldrb w1, [x19, #22]
40030dac: f240043f tst x1, #0x3
40030db0: 54000341 b.ne 40030e18 <msdos_set_first_char4file_name+0xd8> // b.any<== ALWAYS TAKEN
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
40030db4: 39401661 ldrb w1, [x19, #5]
40030db8: b9403e62 ldr w2, [x19, #60]
40030dbc: 1ac12001 lsl w1, w0, w1
40030dc0: 0b020021 add w1, w1, w2
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));
40030dc4: 79400262 ldrh w2, [x19]
ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
40030dc8: 9100ffe4 add x4, sp, #0x3f
(start.ofs >> fs_info->fat.vol.sec_log2));
40030dcc: 39400a66 ldrb w6, [x19, #2]
ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
40030dd0: aa1303e0 mov x0, x19
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));
40030dd4: 51000442 sub w2, w2, #0x1
ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
40030dd8: 52800023 mov w3, #0x1 // #1
40030ddc: 0a050042 and w2, w2, w5
(start.ofs >> fs_info->fat.vol.sec_log2));
40030de0: 1ac624a5 lsr w5, w5, w6
ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
40030de4: 0b0100a1 add w1, w5, w1
40030de8: 97fff27a bl 4002d7d0 <fat_sector_write>
if (ret < 0)
40030dec: b7f801a0 tbnz x0, #63, 40030e20 <msdos_set_first_char4file_name+0xe0><== NEVER TAKEN
if ((start.cln == end.cln) && (start.ofs == end.ofs))
40030df0: 294917e1 ldp w1, w5, [sp, #72]
40030df4: 6b01029f cmp w20, w1
40030df8: 54fffcc1 b.ne 40030d90 <msdos_set_first_char4file_name+0x50> // b.any
40030dfc: 6b0502df cmp w22, w5
40030e00: 54fffc81 b.ne 40030d90 <msdos_set_first_char4file_name+0x50> // b.any
return RC_OK;
40030e04: 52800000 mov w0, #0x0 // #0
}
40030e08: a94153f3 ldp x19, x20, [sp, #16]
40030e0c: a9425bf5 ldp x21, x22, [sp, #32]
40030e10: a8c57bfd ldp x29, x30, [sp], #80
40030e14: d65f03c0 ret
return fs_info->vol.rdir_loc;
40030e18: b9402a61 ldr w1, [x19, #40]
40030e1c: 17ffffea b 40030dc4 <msdos_set_first_char4file_name+0x84>
return -1;
40030e20: 12800000 mov w0, #0xffffffff // #-1 <== NOT EXECUTED
}
40030e24: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40030e28: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
40030e2c: a8c57bfd ldp x29, x30, [sp], #80 <== NOT EXECUTED
40030e30: d65f03c0 ret <== NOT EXECUTED
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
40030e34: b9404660 ldr w0, [x19, #68]
40030e38: 6b00029f cmp w20, w0
40030e3c: 54000081 b.ne 40030e4c <msdos_set_first_char4file_name+0x10c> // b.any<== ALWAYS TAKEN
40030e40: 39405a60 ldrb w0, [x19, #22] <== NOT EXECUTED
40030e44: f240041f tst x0, #0x3 <== NOT EXECUTED
40030e48: 54fffde1 b.ne 40030e04 <msdos_set_first_char4file_name+0xc4> // b.any<== NOT EXECUTED
rc = fat_get_fat_cluster(&fs_info->fat, start.cln, &start.cln);
40030e4c: 910123e2 add x2, sp, #0x48
40030e50: aa1303e0 mov x0, x19
40030e54: 97fff60f bl 4002e690 <fat_get_fat_cluster>
if ( rc != RC_OK )
40030e58: 35fffe60 cbnz w0, 40030e24 <msdos_set_first_char4file_name+0xe4> <== NEVER TAKEN
start.ofs = 0;
40030e5c: 52800005 mov w5, #0x0 // #0
40030e60: b9004fff str wzr, [sp, #76]
40030e64: 17ffffc9 b 40030d88 <msdos_set_first_char4file_name+0x48>
start = dir_pos->sname;
40030e68: 29400022 ldp w2, w0, [x1]
40030e6c: 290903e2 stp w2, w0, [sp, #72]
(start.ofs >> fs_info->fat.vol.sec_log2));
40030e70: b9404fe5 ldr w5, [sp, #76]
40030e74: 17ffffc5 b 40030d88 <msdos_set_first_char4file_name+0x48>
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
40030e78: 39405a60 ldrb w0, [x19, #22]
40030e7c: f240041f tst x0, #0x3
40030e80: 54fff7a0 b.eq 40030d74 <msdos_set_first_char4file_name+0x34> // b.none<== NEVER TAKEN
dir_block_size = fs_info->fat.vol.rdir_size;
40030e84: b9403675 ldr w21, [x19, #52]
40030e88: 17ffffbc b 40030d78 <msdos_set_first_char4file_name+0x38>
40030e8c: 00000000 udf #0
0000000040025a30 <msdos_statvfs>:
#include "msdos.h"
int msdos_statvfs(
const rtems_filesystem_location_info_t *__restrict root_loc,
struct statvfs *__restrict sb)
{
40025a30: a9bb7bfd stp x29, x30, [sp, #-80]!
40025a34: 910003fd mov x29, sp
msdos_fs_info_t *fs_info = root_loc->mt_entry->fs_info;
40025a38: f9401400 ldr x0, [x0, #40]
{
40025a3c: a9025bf5 stp x21, x22, [sp, #32]
40025a40: a90153f3 stp x19, x20, [sp, #16]
40025a44: aa0103f3 mov x19, x1
msdos_fs_info_t *fs_info = root_loc->mt_entry->fs_info;
40025a48: f9400816 ldr x22, [x0, #16]
{
40025a4c: a90363f7 stp x23, x24, [sp, #48]
rtems_recursive_mutex_lock(&fs_info->vol_mutex);
40025a50: 910362d8 add x24, x22, #0xd8
_Mutex_recursive_Acquire( mutex );
40025a54: aa1803e0 mov x0, x24
40025a58: 94000e02 bl 40029260 <_Mutex_recursive_Acquire>
msdos_fs_lock(fs_info);
sb->f_bsize = FAT_SECTOR512_SIZE;
sb->f_frsize = vol->bpc;
sb->f_blocks = vol->data_cls;
40025a5c: b94042d7 ldr w23, [x22, #64]
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;
40025a60: d2801fe0 mov x0, #0xff // #255
sb->f_frsize = vol->bpc;
40025a64: b9400ac2 ldr w2, [x22, #8]
sb->f_bsize = FAT_SECTOR512_SIZE;
40025a68: d2804003 mov x3, #0x200 // #512
sb->f_blocks = vol->data_cls;
40025a6c: 2a1703e1 mov w1, w23
sb->f_frsize = vol->bpc;
40025a70: a9000a63 stp x3, x2, [x19]
sb->f_bfree = 0;
40025a74: a9017e61 stp x1, xzr, [x19, #16]
sb->f_files = 0; // FAT doesn't store inodes
40025a78: a9027e7f stp xzr, xzr, [x19, #32]
sb->f_favail = 0;
40025a7c: b900327f str wzr, [x19, #48]
sb->f_namemax = MSDOS_NAME_MAX_LNF_LEN;
40025a80: a904027f stp xzr, x0, [x19, #64]
if (vol->free_cls == FAT_UNDEFINED_VALUE)
40025a84: b9404ec0 ldr w0, [x22, #76]
40025a88: 3100041f cmn w0, #0x1
40025a8c: 54000180 b.eq 40025abc <msdos_statvfs+0x8c> // b.none <== ALWAYS TAKEN
}
}
}
else
{
sb->f_bfree = vol->free_cls;
40025a90: 2a0003e0 mov w0, w0 <== NOT EXECUTED
sb->f_bavail = vol->free_cls;
40025a94: a9018260 stp x0, x0, [x19, #24] <== NOT EXECUTED
}
msdos_fs_unlock(fs_info);
return RC_OK;
40025a98: 52800014 mov w20, #0x0 // #0
_Mutex_recursive_Release( mutex );
40025a9c: aa1803e0 mov x0, x24
40025aa0: 94000e14 bl 400292f0 <_Mutex_recursive_Release>
}
40025aa4: 2a1403e0 mov w0, w20
40025aa8: a94153f3 ldp x19, x20, [sp, #16]
40025aac: a9425bf5 ldp x21, x22, [sp, #32]
40025ab0: a94363f7 ldp x23, x24, [sp, #48]
40025ab4: a8c57bfd ldp x29, x30, [sp], #80
40025ab8: d65f03c0 ret
uint32_t value = 0;
40025abc: b9004fff str wzr, [sp, #76]
uint32_t data_cls_val = vol->data_cls + 2;
40025ac0: 11000af7 add w23, w23, #0x2
for (; cur_cl < data_cls_val; ++cur_cl)
40025ac4: 71000aff cmp w23, #0x2
uint32_t cur_cl = 2;
40025ac8: 52800055 mov w21, #0x2 // #2
for (; cur_cl < data_cls_val; ++cur_cl)
40025acc: 54fffe69 b.ls 40025a98 <msdos_statvfs+0x68> // b.plast <== NEVER TAKEN
rc = fat_get_fat_cluster(&fs_info->fat, cur_cl, &value);
40025ad0: 2a1503e1 mov w1, w21
40025ad4: 910133e2 add x2, sp, #0x4c
40025ad8: aa1603e0 mov x0, x22
for (; cur_cl < data_cls_val; ++cur_cl)
40025adc: 110006b5 add w21, w21, #0x1
rc = fat_get_fat_cluster(&fs_info->fat, cur_cl, &value);
40025ae0: 940022ec bl 4002e690 <fat_get_fat_cluster>
40025ae4: 2a0003f4 mov w20, w0
if (rc != RC_OK)
40025ae8: 35fffda0 cbnz w0, 40025a9c <msdos_statvfs+0x6c> <== NEVER TAKEN
if (value == FAT_GENFAT_FREE)
40025aec: b9404fe0 ldr w0, [sp, #76]
for (; cur_cl < data_cls_val; ++cur_cl)
40025af0: 6b1502ff cmp w23, w21
if (value == FAT_GENFAT_FREE)
40025af4: 350000a0 cbnz w0, 40025b08 <msdos_statvfs+0xd8>
sb->f_bavail++;
40025af8: a9418261 ldp x1, x0, [x19, #24]
sb->f_bfree++;
40025afc: 91000421 add x1, x1, #0x1
sb->f_bavail++;
40025b00: 91000400 add x0, x0, #0x1
40025b04: a9018261 stp x1, x0, [x19, #24]
for (; cur_cl < data_cls_val; ++cur_cl)
40025b08: 54fffe41 b.ne 40025ad0 <msdos_statvfs+0xa0> // b.any
40025b0c: 17ffffe3 b 40025a98 <msdos_statvfs+0x68>
0000000040030010 <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)
{
40030010: a9bf7bfd stp x29, x30, [sp, #-16]!
msdos_default_convert_control *self = malloc( sizeof( *self ) );
40030014: d2804400 mov x0, #0x220 // #544
{
40030018: 910003fd mov x29, sp
msdos_default_convert_control *self = malloc( sizeof( *self ) );
4003001c: 97ffc859 bl 40022180 <malloc>
if ( self != NULL ) {
40030020: b40000e0 cbz x0, 4003003c <rtems_dosfs_create_default_converter+0x2c> <== NEVER TAKEN
rtems_dosfs_convert_control *super = &self->super;
super->handler = &msdos_default_convert_handler;
40030024: aa0003e1 mov x1, x0
40030028: b00000c2 adrp x2, 40049000 <IMFS_node_control_sym_link+0xe0>
4003002c: 9108e042 add x2, x2, #0x238
super->buffer.data = &self->buffer;
super->buffer.size = sizeof( self->buffer );
40030030: d2804103 mov x3, #0x208 // #520
super->handler = &msdos_default_convert_handler;
40030034: f8018422 str x2, [x1], #24
super->buffer.size = sizeof( self->buffer );
40030038: a9008c01 stp x1, x3, [x0, #8]
}
return &self->super;
}
4003003c: a8c17bfd ldp x29, x30, [sp], #16
40030040: d65f03c0 ret
...
00000000400263c0 <rtems_dosfs_create_utf8_converter>:
};
rtems_dosfs_convert_control *rtems_dosfs_create_utf8_converter(
const char *codepage
)
{
400263c0: a9bd7bfd stp x29, x30, [sp, #-48]!
400263c4: 910003fd mov x29, sp
400263c8: a90153f3 stp x19, x20, [sp, #16]
400263cc: f90013f5 str x21, [sp, #32]
400263d0: aa0003f5 mov x21, x0
msdos_utf8_convert_control *self = malloc( sizeof( *self ) );
400263d4: d2808900 mov x0, #0x448 // #1096
400263d8: 97fff476 bl 400235b0 <malloc>
400263dc: aa0003f3 mov x19, x0
if ( self != NULL ) {
400263e0: b4000440 cbz x0, 40026468 <rtems_dosfs_create_utf8_converter+0xa8> <== NEVER TAKEN
self->desc_codepage_to_utf8 = iconv_open( "UTF-8", codepage );
400263e4: d0000194 adrp x20, 40058000 <_Console_simple_Handlers+0x78>
400263e8: 910c0294 add x20, x20, #0x300
400263ec: aa1503e1 mov x1, x21
400263f0: aa1403e0 mov x0, x20
400263f4: 940064bd bl 4003f6e8 <iconv_open>
400263f8: f9000e60 str x0, [x19, #24]
self->desc_utf8_to_codepage = iconv_open( codepage, "UTF-8" );
400263fc: aa1403e1 mov x1, x20
40026400: aa1503e0 mov x0, x21
40026404: 940064b9 bl 4003f6e8 <iconv_open>
40026408: f9001260 str x0, [x19, #32]
self->desc_utf16_to_utf8 = iconv_open( "UTF-8", "UTF-16LE" );
4002640c: d0000195 adrp x21, 40058000 <_Console_simple_Handlers+0x78>
40026410: 910c22b5 add x21, x21, #0x308
40026414: aa1503e1 mov x1, x21
40026418: aa1403e0 mov x0, x20
4002641c: 940064b3 bl 4003f6e8 <iconv_open>
40026420: f9001660 str x0, [x19, #40]
self->desc_utf8_to_utf16 = iconv_open( "UTF-16LE", "UTF-8" );
40026424: aa1403e1 mov x1, x20
40026428: aa1503e0 mov x0, x21
4002642c: 940064af bl 4003f6e8 <iconv_open>
40026430: f9001a60 str x0, [x19, #48]
if (
40026434: f9401661 ldr x1, [x19, #40]
40026438: b100043f cmn x1, #0x1
4002643c: 54000100 b.eq 4002645c <rtems_dosfs_create_utf8_converter+0x9c> // b.none<== NEVER TAKEN
self->desc_utf16_to_utf8 != INVALID_ICONV_DESC
&& self->desc_utf8_to_codepage != INVALID_ICONV_DESC
40026440: f9401261 ldr x1, [x19, #32]
40026444: b100043f cmn x1, #0x1
40026448: 540000a0 b.eq 4002645c <rtems_dosfs_create_utf8_converter+0x9c> // b.none<== NEVER TAKEN
&& self->desc_codepage_to_utf8 != INVALID_ICONV_DESC
&& self->desc_utf8_to_utf16 != INVALID_ICONV_DESC
4002644c: f9400e61 ldr x1, [x19, #24]
40026450: b100043f cmn x1, #0x1
40026454: ba411804 ccmn x0, #0x1, #0x4, ne // ne = any
40026458: 54000121 b.ne 4002647c <rtems_dosfs_create_utf8_converter+0xbc> // b.any<== ALWAYS TAKEN
super->handler = &msdos_utf8_convert_handler;
super->buffer.data = &self->buffer;
super->buffer.size = sizeof( self->buffer );
} else {
msdos_utf8_destroy( &self->super );
4002645c: aa1303e0 mov x0, x19 <== NOT EXECUTED
self = NULL;
40026460: d2800013 mov x19, #0x0 // #0 <== NOT EXECUTED
msdos_utf8_destroy( &self->super );
40026464: 97ffff2f bl 40026120 <msdos_utf8_destroy> <== NOT EXECUTED
}
}
return &self->super;
}
40026468: aa1303e0 mov x0, x19 <== NOT EXECUTED
4002646c: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40026470: f94013f5 ldr x21, [sp, #32] <== NOT EXECUTED
40026474: a8c37bfd ldp x29, x30, [sp], #48 <== NOT EXECUTED
40026478: d65f03c0 ret <== NOT EXECUTED
super->handler = &msdos_utf8_convert_handler;
4002647c: aa1303e0 mov x0, x19
40026480: d0000181 adrp x1, 40058000 <_Console_simple_Handlers+0x78>
40026484: 910d2021 add x1, x1, #0x348
super->buffer.size = sizeof( self->buffer );
40026488: d2808202 mov x2, #0x410 // #1040
}
4002648c: f94013f5 ldr x21, [sp, #32]
super->handler = &msdos_utf8_convert_handler;
40026490: f8038401 str x1, [x0], #56
super->buffer.size = sizeof( self->buffer );
40026494: a9008a60 stp x0, x2, [x19, #8]
}
40026498: aa1303e0 mov x0, x19
4002649c: a94153f3 ldp x19, x20, [sp, #16]
400264a0: a8c37bfd ldp x29, x30, [sp], #48
400264a4: d65f03c0 ret
...
0000000040025640 <rtems_dosfs_initialize>:
*/
int rtems_dosfs_initialize(
rtems_filesystem_mount_table_entry_t *mt_entry,
const void *data
)
{
40025640: a9be7bfd stp x29, x30, [sp, #-32]!
40025644: 910003fd mov x29, sp
40025648: a90153f3 stp x19, x20, [sp, #16]
4002564c: aa0003f3 mov x19, x0
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) {
40025650: b4000181 cbz x1, 40025680 <rtems_dosfs_initialize+0x40>
40025654: f9400024 ldr x4, [x1]
40025658: b4000144 cbz x4, 40025680 <rtems_dosfs_initialize+0x40> <== NEVER TAKEN
errno = ENOMEM;
rc = -1;
}
return rc;
}
4002565c: a94153f3 ldp x19, x20, [sp, #16]
rc = msdos_initialize_support(mt_entry,
40025660: 90000123 adrp x3, 40049000 <IMFS_node_control_sym_link+0xe0>
}
40025664: a8c27bfd ldp x29, x30, [sp], #32
rc = msdos_initialize_support(mt_entry,
40025668: 9109e063 add x3, x3, #0x278
4002566c: 90000122 adrp x2, 40049000 <IMFS_node_control_sym_link+0xe0>
40025670: f0000101 adrp x1, 40048000 <bsp_section_rodata_begin+0x78>
40025674: 912ce021 add x1, x1, #0xb38
40025678: 910be042 add x2, x2, #0x2f8
4002567c: 1400001d b 400256f0 <msdos_initialize_support>
converter = rtems_dosfs_create_default_converter();
40025680: 94002a64 bl 40030010 <rtems_dosfs_create_default_converter>
40025684: aa0003f4 mov x20, x0
if (converter != NULL) {
40025688: b4000280 cbz x0, 400256d8 <rtems_dosfs_initialize+0x98> <== NEVER TAKEN
rc = msdos_initialize_support(mt_entry,
4002568c: aa1303e0 mov x0, x19
40025690: aa1403e4 mov x4, x20
40025694: 90000123 adrp x3, 40049000 <IMFS_node_control_sym_link+0xe0>
40025698: 90000122 adrp x2, 40049000 <IMFS_node_control_sym_link+0xe0>
4002569c: 9109e063 add x3, x3, #0x278
400256a0: 910be042 add x2, x2, #0x2f8
400256a4: f0000101 adrp x1, 40048000 <bsp_section_rodata_begin+0x78>
400256a8: 912ce021 add x1, x1, #0xb38
400256ac: 94000011 bl 400256f0 <msdos_initialize_support>
400256b0: 2a0003f3 mov w19, w0
if (rc != 0 && converter_created) {
400256b4: 340000a0 cbz w0, 400256c8 <rtems_dosfs_initialize+0x88> <== ALWAYS TAKEN
(*converter->handler->destroy)(converter);
400256b8: f9400281 ldr x1, [x20] <== NOT EXECUTED
400256bc: aa1403e0 mov x0, x20 <== NOT EXECUTED
400256c0: f9401421 ldr x1, [x1, #40] <== NOT EXECUTED
400256c4: d63f0020 blr x1 <== NOT EXECUTED
}
400256c8: 2a1303e0 mov w0, w19
400256cc: a94153f3 ldp x19, x20, [sp, #16]
400256d0: a8c27bfd ldp x29, x30, [sp], #32
400256d4: d65f03c0 ret
errno = ENOMEM;
400256d8: 940054a5 bl 4003a96c <__errno> <== NOT EXECUTED
rc = -1;
400256dc: 12800013 mov w19, #0xffffffff // #-1 <== NOT EXECUTED
errno = ENOMEM;
400256e0: 52800181 mov w1, #0xc // #12 <== NOT EXECUTED
400256e4: b9000001 str w1, [x0] <== NOT EXECUTED
return rc;
400256e8: 17fffff8 b 400256c8 <rtems_dosfs_initialize+0x88> <== NOT EXECUTED
400256ec: 00000000 udf #0