=============================================================================== 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 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 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 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 : { 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 4002d5f8: b940b001 ldr w1, [x0, #176] 4002d5fc: 6b15003f cmp w1, w21 4002d600: 54000180 b.eq 4002d630 // b.none if (fs_info->c.state == FAT_CACHE_EMPTY) 4002d604: 97ffff7f bl 4002d400 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 // b.none sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &fs_info->c.buf); 4002d61c: 940022c1 bl 40036120 if (sc != RTEMS_SUCCESSFUL) 4002d620: 35000200 cbnz w0, 4002d660 <== 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 4002d65c: 17fffff1 b 4002d620 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 <== NOT EXECUTED ... =============================================================================== 000000004002d400 : *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 <== 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 // 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 <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) 4002d434: 350007e0 cbnz w0, 4002d530 <== 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 // 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 <== NOT EXECUTED sc = rtems_bdbuf_release_modified(fs_info->c.buf); 4002d464: aa0103e0 mov x0, x1 <== NOT EXECUTED 4002d468: 94002436 bl 40036540 <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) 4002d46c: 35000620 cbnz w0, 4002d530 <== 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 <== 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 // 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 <== 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 // b.none <== NOT EXECUTED sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &bd); 4002d4dc: 94002359 bl 40036240 <== NOT EXECUTED if ( sc != RTEMS_SUCCESSFUL) 4002d4e0: 35000540 cbnz w0, 4002d588 <== 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 <== NOT EXECUTED sc = rtems_bdbuf_release_modified(bd); 4002d4fc: f9401fe0 ldr x0, [sp, #56] <== NOT EXECUTED 4002d500: 94002410 bl 40036540 <== 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 <== 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 // b.pmore <== NOT EXECUTED 4002d51c: f94013f5 ldr x21, [sp, #32] <== NOT EXECUTED 4002d520: 17ffffc7 b 4002d43c <== NOT EXECUTED sc = rtems_bdbuf_release(fs_info->c.buf); 4002d524: aa0103e0 mov x0, x1 <== NOT EXECUTED 4002d528: 940023c6 bl 40036440 <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) 4002d52c: 34fff880 cbz w0, 4002d43c <== 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 <== NOT EXECUTED sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &bd); 4002d548: 940022f6 bl 40036120 <== NOT EXECUTED 4002d54c: 17ffffe5 b 4002d4e0 <== 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 <== NOT EXECUTED sc = rtems_bdbuf_release_modified(fs_info->c.buf); 4002d580: f9405e61 ldr x1, [x19, #184] <== NOT EXECUTED 4002d584: 17ffffb8 b 4002d464 <== 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_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 <== ALWAYS TAKEN 4002d8f4: 39405800 ldrb w0, [x0, #22] <== NOT EXECUTED 4002d8f8: f240041f tst x0, #0x3 <== NOT EXECUTED 4002d8fc: 54000961 b.ne 4002da28 // 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 <== 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 <== 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 // 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 return rc; 4002d978: 93407c02 sxtw x2, w0 if (RC_OK == rc) 4002d97c: 34000440 cbz w0, 4002da04 <== ALWAYS TAKEN fs_info, cur_blk, ofs_blk, c, pattern); if (c != ret) 4002d980: eb38405f cmp x2, w24, uxtw 4002d984: 54000140 b.eq 4002d9ac // 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 // 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 <== 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 <== 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 return rc; 4002d9fc: 93407c02 sxtw x2, w0 if (RC_OK == rc) 4002da00: 35fffc00 cbnz w0, 4002d980 <== 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 return bytes_to_write; 4002da1c: aa1303e2 mov x2, x19 fs_info->c.modified = true; 4002da20: 3902d2f6 strb w22, [x23, #180] 4002da24: 17ffffd7 b 4002d980 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 <== NOT EXECUTED ... =============================================================================== 000000004002da40 : 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 4002da80: 39405aa3 ldrb w3, [x21, #22] 4002da84: f240047f tst x3, #0x3 4002da88: 54000981 b.ne 4002dbb8 // 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 <== 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 <== 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 // 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 return rc; 4002db08: 93407c02 sxtw x2, w0 if (RC_OK == rc) 4002db0c: 34000440 cbz w0, 4002db94 <== 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 // 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 // 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 <== 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 <== 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 return rc; 4002db8c: 93407c02 sxtw x2, w0 if (RC_OK == rc) 4002db90: 35fffc00 cbnz w0, 4002db10 <== 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 return bytes_to_write; 4002dbac: aa1303e2 mov x2, x19 fs_info->c.modified = true; 4002dbb0: 3902d2b7 strb w23, [x21, #180] 4002dbb4: 17ffffd7 b 4002db10 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 <== 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 4002dbfc: 00000000 udf #0 =============================================================================== 000000004002f690 : { 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 // 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_file_update(fs_info, fat_fd); 4002f6c8: 97fffefa bl 4002f2b0 if (fat_fd->flags & FAT_FILE_REMOVED) 4002f6cc: 3940e260 ldrb w0, [x19, #56] 4002f6d0: 37000100 tbnz w0, #0, 4002f6f0 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 4002f6e0: 72001c1f tst w0, #0xff 4002f6e4: 54000260 b.eq 4002f730 // b.none fat_fd->links_num = 0; 4002f6e8: b900127f str wzr, [x19, #16] 4002f6ec: 17fffff3 b 4002f6b8 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 if (rc == RC_OK) 4002f700: 35fffdc0 cbnz w0, 4002f6b8 <== 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 4002f71c: 72001c1f tst w0, #0xff 4002f720: 54000141 b.ne 4002f748 // b.any <== NEVER TAKEN free(fat_fd); 4002f724: aa1303e0 mov x0, x19 4002f728: 97ffc996 bl 40021d80 4002f72c: 17ffffe3 b 4002f6b8 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 4002f744: 17ffffdd b 4002f6b8 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 <== NOT EXECUTED 4002f754: 17fffff4 b 4002f724 <== NOT EXECUTED ... =============================================================================== 000000004002f850 : { 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 // 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 // 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 // b.lo, b.ul, b.last if (zero_fill && bytes_remain > 0) { 4002f8c4: 35000a1a cbnz w26, 4002fa04 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 // b.any <== NEVER TAKEN if (bytes2add == 0) 4002f8fc: 34fffe7c cbz w28, 4002f8c8 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 4002f92c: 2a0003f7 mov w23, w0 if (rc != RC_OK) 4002f930: 350007c0 cbnz w0, 4002fa28 <== 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 if (cls2add != cls_added) 4002f940: 6b16001f cmp w0, w22 4002f944: 540000e0 b.eq 4002f960 // 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 if ( fat_fd->fat_file_size == 0 ) 4002f964: b9402303 ldr w3, [x24, #32] 4002f968: 340009e3 cbz w3, 4002faa4 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 // 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 4002f988: 2a0003e2 mov w2, w0 if ( rc != RC_OK ) 4002f98c: 35000180 cbnz w0, 4002f9bc <== NEVER TAKEN fat_buf_release(fs_info); 4002f990: aa1503e0 mov x0, x21 4002f994: 97fff73b bl 4002d680 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 rc = fat_init_clusters_chain(fs_info, chain); 4002f9a8: b94063e1 ldr w1, [sp, #96] 4002f9ac: aa1503e0 mov x0, x21 4002f9b0: 97fffad0 bl 4002e4f0 4002f9b4: 2a0003e2 mov w2, w0 if ( rc != RC_OK ) 4002f9b8: 340005c0 cbz w0, 4002fa70 <== 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 <== 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 <== 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 // 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 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 4002fa20: 2a0003f7 mov w23, w0 if (rc != RC_OK) 4002fa24: 34000120 cbz w0, 4002fa48 <== 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 if (bytes_remain != bytes_written) 4002fa64: eb34401f cmp x0, w20, uxtw 4002fa68: 54fffe01 b.ne 4002fa28 // b.any <== NEVER TAKEN 4002fa6c: 17ffffa4 b 4002f8fc *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 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 <== 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 <== NOT EXECUTED 4002fae4: 17ffffb6 b 4002f9bc <== 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 ... =============================================================================== 000000004002f760 : { 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 // 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 // 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 // b.any 4002f7b8: 39405803 ldrb w3, [x0, #22] 4002f7bc: f240047f tst x3, #0x3 4002f7c0: 540000c0 b.eq 4002f7d8 // 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 if ( rc != RC_OK ) 4002f7e8: 34000160 cbz w0, 4002f814 <== 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 <== NOT EXECUTED ... =============================================================================== 000000004002efc0 : { 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 // b.none if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) ) 4002efec: 34000f80 cbz w0, 4002f1dc 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 // 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 // b.none if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) ) 4002f04c: 35000080 cbnz w0, 4002f05c 4002f050: 39405a60 ldrb w0, [x19, #22] 4002f054: f240041f tst x0, #0x3 4002f058: 54000cc1 b.ne 4002f1f0 // 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 // 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 // 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 // b.any <== NEVER TAKEN 4002f0b0: 14000054 b 4002f200 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 // 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 // b.none <== NOT EXECUTED if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) ) 4002f0d0: 35000083 cbnz w3, 4002f0e0 <== NOT EXECUTED 4002f0d4: 39405a61 ldrb w1, [x19, #22] <== NOT EXECUTED 4002f0d8: f240043f tst x1, #0x3 <== NOT EXECUTED 4002f0dc: 540008e1 b.ne 4002f1f8 // 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 // b.any <== NOT EXECUTED if ( ((key2) == 0) || ((key2) == ffd->ino) ) 4002f10c: 34000094 cbz w20, 4002f11c <== NOT EXECUTED 4002f110: b9401480 ldr w0, [x4, #20] <== NOT EXECUTED 4002f114: 6b00029f cmp w20, w0 <== NOT EXECUTED 4002f118: 54fffce1 b.ne 4002f0b4 // 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 <== 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 <== 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 <== NOT EXECUTED 4002f170: b9001720 str w0, [x25, #20] <== NOT EXECUTED if ( lfat_fd->ino == 0 ) 4002f174: 340007c0 cbz w0, 4002f26c <== 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 // b.none <== NEVER TAKEN return fs_info->vol.rdir_loc; 4002f1e8: b9402a60 ldr w0, [x19, #40] 4002f1ec: 17ffff86 b 4002f004 4002f1f0: b9402a60 ldr w0, [x19, #40] 4002f1f4: 17ffff9e b 4002f06c 4002f1f8: b9402a63 ldr w3, [x19, #40] <== NOT EXECUTED 4002f1fc: 17ffffbd b 4002f0f0 <== 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 4002f20c: f9000300 str x0, [x24] 4002f210: aa0003f9 mov x25, x0 if ( lfat_fd == NULL ) 4002f214: b40001e0 cbz x0, 4002f250 <== 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 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 <== NOT EXECUTED free((*fat_fd)); 4002f26c: f9400300 ldr x0, [x24] <== NOT EXECUTED 4002f270: 97ffcac4 bl 40021d80 <== 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 <== NOT EXECUTED =============================================================================== 000000004002f340 : { 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 <== 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 // 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 // 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 // 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 // b.any 4002f3a4: 39405a60 ldrb w0, [x19, #22] 4002f3a8: f240041f tst x0, #0x3 4002f3ac: 54000801 b.ne 4002f4ac // 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 if (rc != RC_OK) 4002f3d0: 35000980 cbnz w0, 4002f500 <== 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 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 <== 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 ofs = 0; 4002f448: 52800005 mov w5, #0x0 // #0 if ( rc != RC_OK ) 4002f44c: 35000880 cbnz w0, 4002f55c <== NEVER TAKEN while (count > 0) 4002f450: 34000675 cbz w21, 4002f51c 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 <== ALWAYS TAKEN 4002f470: 39405a61 ldrb w1, [x19, #22] <== NOT EXECUTED 4002f474: f240043f tst x1, #0x3 <== NOT EXECUTED 4002f478: 54fffba0 b.eq 4002f3ec // b.none <== NOT EXECUTED return fs_info->vol.rdir_loc; 4002f47c: b9402a61 ldr w1, [x19, #40] <== NOT EXECUTED 4002f480: 17ffffdf b 4002f3fc <== 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 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 <== 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 <== NOT EXECUTED return rc; 4002f55c: 93407c00 sxtw x0, w0 <== NOT EXECUTED 4002f560: 17fffff6 b 4002f538 <== 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 <== NOT EXECUTED 4002f57c: 00000000 udf #0 =============================================================================== 000000004002fdc0 : { 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 // 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 // b.lo, b.ul, b.last <== ALWAYS TAKEN 4002fe00: 14000015 b 4002fe54 <== 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 // 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 if ( rc != RC_OK ) 4002fe40: 34fffe20 cbz w0, 4002fe04 <== 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 // 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 : { 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 // b.plast assert(fat_fd->fat_file_size); 4002f59c: a90153f3 stp x19, x20, [sp, #16] 4002f5a0: 34000663 cbz w3, 4002f66c <== 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 // b.plast if (cl_start != 0) 4002f5c8: f90013f5 str x21, [sp, #32] 4002f5cc: aa0103f5 mov x21, x1 4002f5d0: 340000b3 cbz w19, 4002f5e4 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 if (rc != RC_OK) 4002f5e0: 350000e0 cbnz w0, 4002f5fc <== 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 if (rc != RC_OK) 4002f5f8: 34000120 cbz w0, 4002f61c <== 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 if (rc != RC_OK) 4002f628: 35fffea0 cbnz w0, 4002f5fc <== NEVER TAKEN if (cl_start != 0) 4002f62c: 35000093 cbnz w19, 4002f63c 4002f630: a94153f3 ldp x19, x20, [sp, #16] 4002f634: f94013f5 ldr x21, [sp, #32] 4002f638: 17fffff6 b 4002f610 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 if ( rc != RC_OK ) 4002f64c: 35fffd80 cbnz w0, 4002f5fc <== 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 assert(fat_fd->fat_file_size); 4002f66c: d00000c3 adrp x3, 40049000 <== NOT EXECUTED 4002f670: d00000c2 adrp x2, 40049000 <== NOT EXECUTED 4002f674: d00000c0 adrp x0, 40049000 <== 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 : { 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 <== 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 // 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 if (RC_OK == rc) 4002fb74: 35000660 cbnz w0, 4002fc40 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 // 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 4002fbb4: 2a0003e1 mov w1, w0 if (RC_OK == rc) 4002fbb8: 35000740 cbnz w0, 4002fca0 <== 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 <== 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 if (0 > ret) 4002fbf8: b7f80ae0 tbnz x0, #63, 4002fd54 <== 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 // 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 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 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 <== 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 <== 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 <== 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 // 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 if (0 > ret) 4002fcf0: b7fffdc0 tbnz x0, #63, 4002fca8 <== 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 <== 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 <== 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 <== 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 <== NOT EXECUTED =============================================================================== 0000000040030cb0 : { 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 40030cc8: 39405801 ldrb w1, [x0, #22] 40030ccc: f240043f tst x1, #0x3 40030cd0: 54000301 b.ne 40030d30 // 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 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 } 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 ... =============================================================================== 0000000040030bf0 : { 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 40030c10: 39405a62 ldrb w2, [x19, #22] 40030c14: f240045f tst x2, #0x3 40030c18: 54000481 b.ne 40030ca8 // 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 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 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 =============================================================================== 0000000040030ab0 : { 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 40030ad4: 39405a61 ldrb w1, [x19, #22] 40030ad8: f240043f tst x1, #0x3 40030adc: 54000861 b.ne 40030be8 // 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 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 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 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 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 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 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 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 =============================================================================== 000000004002eb90 : { 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 // 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 rc = fat_set_fat_cluster(fs_info, cur_cln, FAT_GENFAT_FREE); 4002ebd4: 97ffff3b bl 4002e8c0 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 // 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 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 <== 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 // 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 <== 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 // 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 } 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_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_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 // 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 // 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 4002e6dc: 36080642 tbz w2, #1, 4002e7a4 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 4002e704: 2a0003f4 mov w20, w0 if (rc != RC_OK) 4002e708: 35000400 cbnz w0, 4002e788 <== 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 // b.none 4002e720: 7100105f cmp w2, #0x4 4002e724: 540005c0 b.eq 4002e7dc // b.none 4002e728: 7100045f cmp w2, #0x1 4002e72c: 540006c0 b.eq 4002e804 // 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 4002e780: 2a0003f4 mov w20, w0 if (rc != RC_OK) 4002e784: 34fffc40 cbz w0, 4002e70c <== 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 *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 // 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 if (rc != RC_OK) 4002e870: 35000180 cbnz w0, 4002e8a0 <== 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 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 <== 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 <== NOT EXECUTED ... =============================================================================== 000000004002e580 : * 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 <== 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 <== 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 // 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 <== 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 // 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 <== NOT EXECUTED 4002e630: f9004e60 str x0, [x19, #152] <== NOT EXECUTED if (fs_info->uino != NULL) 4002e634: b4000080 cbz x0, 4002e644 <== 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 <== NOT EXECUTED return 0; 4002e644: 52800000 mov w0, #0x0 // #0 <== NOT EXECUTED 4002e648: 17ffffee b 4002e600 <== NOT EXECUTED 4002e64c: 00000000 udf #0 =============================================================================== 000000004002e4f0 : 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 { ret = fat_cluster_set(fs_info, cur_cln, 0, fs_info->vol.bpc, 0); 4002e508: b9400a63 ldr w3, [x19, #8] 4002e50c: 97fffce9 bl 4002d8b0 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 // 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 if ( rc != RC_OK ) 4002e530: 35000140 cbnz w0, 4002e558 <== 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 // 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 : * 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 4002dc24: b9006a60 str w0, [x19, #104] if (vol->fd < 0) 4002dc28: 37f829a0 tbnz w0, #31, 4002e15c <== 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 if (rc != 0) 4002dc34: 350029e0 cbnz w0, 4002e170 <== 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 // 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 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 <== 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 if (sc != RTEMS_SUCCESSFUL) 4002dc7c: 35002880 cbnz w0, 4002e18c <== 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 if (sc != RTEMS_SUCCESSFUL) 4002dd4c: 294d97e1 ldp w1, w5, [sp, #108] 4002dd50: 350022c0 cbnz w0, 4002e1a8 <== 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 // 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 <== 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 <== 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 <== 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 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 if (sc != RTEMS_SUCCESSFUL) 4002ddd8: b9406fe5 ldr w5, [sp, #108] 4002dddc: 35001aa0 cbnz w0, 4002e130 <== 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 <== 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 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 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 // 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 <== 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 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 // 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 // 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 4002defc: aa1303e0 mov x0, x19 4002df00: 97fffd40 bl 4002d400 } _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 4002df24: f9004660 str x0, [x19, #136] 4002df28: aa0003e2 mov x2, x0 if ( fs_info->vhash == NULL ) 4002df2c: b4001680 cbz x0, 4002e1fc <== 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 4002df54: f9004a60 str x0, [x19, #144] if ( fs_info->rhash == NULL ) 4002df58: b4001660 cbz x0, 4002e224 <== 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 4002dfa0: f9004e60 str x0, [x19, #152] if ( fs_info->uino == NULL ) 4002dfa4: b40014c0 cbz x0, 4002e23c <== 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 4002dfb4: f9006260 str x0, [x19, #192] if (fs_info->sec_buf == NULL) 4002dfb8: b4001520 cbz x0, 4002e25c <== 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 // 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 // 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 // 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 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 if (sc == RTEMS_SUCCESSFUL) 4002e030: 35fffdc0 cbnz w0, 4002dfe8 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 // 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 <== 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 <== 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 // 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 <== 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 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 if (fs_info->c.state == FAT_CACHE_EMPTY) 4002e120: 3942d660 ldrb w0, [x19, #181] <== NOT EXECUTED 4002e124: 34000060 cbz w0, 4002e130 <== NOT EXECUTED 4002e128: aa1303e0 mov x0, x19 <== NOT EXECUTED 4002e12c: 97fffcb5 bl 4002d400 <== 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 <== 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 <== NOT EXECUTED close(vol->fd); 4002e158: 97ffce92 bl 40021ba0 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== NOT EXECUTED if (fs_info->c.state == FAT_CACHE_EMPTY) 4002e1d0: 3942d660 ldrb w0, [x19, #181] <== NOT EXECUTED 4002e1d4: 34000060 cbz w0, 4002e1e0 <== NOT EXECUTED 4002e1d8: aa1303e0 mov x0, x19 <== NOT EXECUTED 4002e1dc: 97fffc89 bl 4002d400 <== 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 <== 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 <== 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 <== 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 <== 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 <== NOT EXECUTED free(fs_info->vhash); 4002e230: f9404660 ldr x0, [x19, #136] <== NOT EXECUTED free(fs_info->uino); 4002e234: 97ffced3 bl 40021d80 <== NOT EXECUTED 4002e238: 17fffff4 b 4002e208 <== 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 <== NOT EXECUTED free(fs_info->vhash); 4002e248: f9404660 ldr x0, [x19, #136] <== NOT EXECUTED 4002e24c: 97ffcecd bl 40021d80 <== NOT EXECUTED free(fs_info->rhash); 4002e250: f9404a60 ldr x0, [x19, #144] <== NOT EXECUTED free(fs_info->uino); 4002e254: 97ffcecb bl 40021d80 <== NOT EXECUTED 4002e258: 17ffffec b 4002e208 <== 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 <== NOT EXECUTED free(fs_info->vhash); 4002e268: f9404660 ldr x0, [x19, #136] <== NOT EXECUTED 4002e26c: 97ffcec5 bl 40021d80 <== NOT EXECUTED free(fs_info->rhash); 4002e270: f9404a60 ldr x0, [x19, #144] <== NOT EXECUTED 4002e274: 97ffcec3 bl 40021d80 <== NOT EXECUTED free(fs_info->uino); 4002e278: f9404e60 ldr x0, [x19, #152] <== NOT EXECUTED 4002e27c: 97ffcec1 bl 40021d80 <== NOT EXECUTED 4002e280: 17ffffe2 b 4002e208 <== NOT EXECUTED ... =============================================================================== 000000004002eca0 : { 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 // 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 4002ed1c: 2a0003e3 mov w3, w0 if ( rc != RC_OK ) 4002ed20: 35000b00 cbnz w0, 4002ee80 <== 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 if (*cls_added == 0) 4002ed30: 35000541 cbnz w1, 4002edd8 *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 4002ed48: 2a0003e3 mov w3, w0 if ( rc != RC_OK ) 4002ed4c: 350009e0 cbnz w0, 4002ee88 <== NEVER TAKEN if (zero_fill) 4002ed50: 3500083a cbnz w26, 4002ee54 (*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 // 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 // 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 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 4002ede8: 2a0003e3 mov w3, w0 if ( rc != RC_OK ) 4002edec: 350005e0 cbnz w0, 4002eea8 <== 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 4002ee00: 2a0003e3 mov w3, w0 if ( rc != RC_OK ) 4002ee04: 34fffa60 cbz w0, 4002ed50 <== 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 <== 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 <== NOT EXECUTED fat_buf_release(fs_info); 4002ee28: aa1c03e0 mov x0, x28 <== NOT EXECUTED 4002ee2c: 97fffa15 bl 4002d680 <== 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 if (fs_info->vol.bpc != bytes_written) 4002ee6c: b9400b81 ldr w1, [x28, #8] 4002ee70: eb00003f cmp x1, x0 4002ee74: 54fff700 b.eq 4002ed54 // b.none<== ALWAYS TAKEN rc = -1; 4002ee78: 12800003 mov w3, #0xffffffff // #-1 <== NOT EXECUTED 4002ee7c: 17ffffe3 b 4002ee08 <== NOT EXECUTED if (*cls_added != 0) 4002ee80: b94002c0 ldr w0, [x22] <== NOT EXECUTED 4002ee84: 35000120 cbnz w0, 4002eea8 <== 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 <== 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 <== NOT EXECUTED ... =============================================================================== 000000004002d7d0 : 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 <== 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 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 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 <== 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 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 // 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 // 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 <== 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 <== 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 <== NOT EXECUTED =============================================================================== 000000004002e8c0 : 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 // 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 // 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 4002e910: 360805e0 tbz w0, #1, 4002e9cc 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 if (rc != RC_OK) 4002e938: 350003e0 cbnz w0, 4002e9b4 <== 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 // b.none 4002e950: 7100131f cmp w24, #0x4 4002e954: 54000580 b.eq 4002ea04 // b.none 4002e958: 7100071f cmp w24, #0x1 4002e95c: 540006c0 b.eq 4002ea34 // 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 if (rc != RC_OK) 4002e9b0: 34fffc60 cbz w0, 4002e93c <== 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 *((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 *(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 // 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 // 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 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 if (rc != RC_OK) 4002eb04: 35fff580 cbnz w0, 4002e9b4 <== 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 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 <== NOT EXECUTED if (rc != RC_OK) 4002eb4c: 35fff340 cbnz w0, 4002e9b4 <== 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 <== 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 <== NOT EXECUTED =============================================================================== 000000004002e380 : * 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 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 // 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 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 // 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 // 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 <== 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 // 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 // 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 <== 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 // 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 // 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 <== 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 // b.any <== NOT EXECUTED } free(fs_info->vhash); 4002e47c: f9404680 ldr x0, [x20, #136] 4002e480: 97ffce40 bl 40021d80 free(fs_info->rhash); 4002e484: f9404a80 ldr x0, [x20, #144] 4002e488: 97ffce3e bl 40021d80 free(fs_info->uino); 4002e48c: f9404e80 ldr x0, [x20, #152] 4002e490: 97ffce3c bl 40021d80 free(fs_info->sec_buf); 4002e494: f9406280 ldr x0, [x20, #192] 4002e498: 97ffce3a bl 40021d80 close(fs_info->vol.fd); 4002e49c: b9406a80 ldr w0, [x20, #104] 4002e4a0: 97ffcdc0 bl 40021ba0 if (rc) 4002e4a4: 350000f5 cbnz w21, 4002e4c0 <== 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 : 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 // b.none if (fs_info->c.state == FAT_CACHE_EMPTY) 4002e2b0: 3942d660 ldrb w0, [x19, #181] 4002e2b4: 34000060 cbz w0, 4002e2c0 4002e2b8: aa1303e0 mov x0, x19 4002e2bc: 97fffc51 bl 4002d400 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 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 // 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 // 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 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 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 <== 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 // b.none <== NOT EXECUTED 4002e36c: 17ffffe7 b 4002e308 <== NOT EXECUTED 4002e370: a9425bf5 ldp x21, x22, [sp, #32] 4002e374: 17ffffcf b 4002e2b0 ... =============================================================================== 0000000040030050 : 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 <== 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 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 <== 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