0000000040026a20 <rtems_rfs_bitmap_create_search>: if (!control->buffer)
40026a20: f9400001 ldr x1, [x0]
40026a24: b4000901 cbz x1, 40026b44 <rtems_rfs_bitmap_create_search+0x124>
int
rtems_rfs_bitmap_create_search (rtems_rfs_bitmap_control* control)
{
40026a28: a9be7bfd stp x29, x30, [sp, #-32]!
rc = rtems_rfs_buffer_handle_request (control->fs,
40026a2c: 52800023 mov w3, #0x1 // #1
{
40026a30: 910003fd mov x29, sp
rc = rtems_rfs_buffer_handle_request (control->fs,
40026a34: b9401002 ldr w2, [x0, #16]
{
40026a38: f9000bf3 str x19, [sp, #16]
40026a3c: aa0003f3 mov x19, x0
rc = rtems_rfs_buffer_handle_request (control->fs,
40026a40: f9400400 ldr x0, [x0, #8]
40026a44: 94000163 bl 40026fd0 <rtems_rfs_buffer_handle_request>
if (rc)
40026a48: 7100001f cmp w0, #0x0
40026a4c: 35000760 cbnz w0, 40026b38 <rtems_rfs_bitmap_create_search+0x118> <== NEVER TAKEN
*map = rtems_rfs_buffer_data (control->buffer);
40026a50: f9400260 ldr x0, [x19]
40026a54: f9400400 ldr x0, [x0, #8]
40026a58: f9401c05 ldr x5, [x0, #56]
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
control->free = 0;
40026a5c: f900127f str xzr, [x19, #32]
search_map = control->search_bits;
40026a60: f940166a ldr x10, [x19, #40]
size = control->size;
bit = 0;
rtems_rfs_bitmap_check(control, search_map);
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
40026a64: 12800009 mov w9, #0xffffffff // #-1
size = control->size;
40026a68: f9400e63 ldr x3, [x19, #24]
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
40026a6c: b9000149 str w9, [x10]
while (size)
40026a70: b40005c3 cbz x3, 40026b28 <rtems_rfs_bitmap_create_search+0x108> <== NEVER TAKEN
40026a74: 910010a5 add x5, x5, #0x4
{
rtems_rfs_bitmap_element bits;
int available;
if (size < rtems_rfs_bitmap_element_bits ())
40026a78: f1007c7f cmp x3, #0x1f
bit = 0;
40026a7c: 52800006 mov w6, #0x0 // #0
mask >>= (rtems_rfs_bitmap_element_bits () - size);
40026a80: 5280040b mov w11, #0x20 // #32
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
40026a84: 52800028 mov w8, #0x1 // #1
{
bits = rtems_rfs_bitmap_merge (*map,
40026a88: b85fc0a4 ldur w4, [x5, #-4]
if (size < rtems_rfs_bitmap_element_bits ())
40026a8c: 54000208 b.hi 40026acc <rtems_rfs_bitmap_create_search+0xac> // b.pmore
mask >>= (rtems_rfs_bitmap_element_bits () - size);
40026a90: 4b030161 sub w1, w11, w3
RTEMS_RFS_BITMAP_ELEMENT_SET,
rtems_rfs_bitmap_mask_section (0, size));
available = size;
40026a94: 2a0303e0 mov w0, w3
40026a98: aa0303e7 mov x7, x3
mask >>= (rtems_rfs_bitmap_element_bits () - size);
40026a9c: 1ac12521 lsr w1, w9, w1
40026aa0: 0a010084 and w4, w4, w1
{
bits = *map;
available = rtems_rfs_bitmap_element_bits ();
}
if (rtems_rfs_bitmap_match (bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
40026aa4: 350001a4 cbnz w4, 40026ad8 <rtems_rfs_bitmap_create_search+0xb8>
for (b = 0; b < available; b++)
if (!rtems_rfs_bitmap_test (bits, b))
control->free++;
}
size -= available;
40026aa8: cb070063 sub x3, x3, x7
/* Iterate from 0 to 1 less than the number of bits in an element */
if (bit == (rtems_rfs_bitmap_element_bits () - 1))
40026aac: 71007cdf cmp w6, #0x1f
40026ab0: 54000300 b.eq 40026b10 <rtems_rfs_bitmap_create_search+0xf0> // b.none
rtems_rfs_bitmap_check(control, search_map);
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
}
}
else
bit++;
40026ab4: 110004c6 add w6, w6, #0x1
while (size)
40026ab8: b4000383 cbz x3, 40026b28 <rtems_rfs_bitmap_create_search+0x108>
40026abc: 910010a5 add x5, x5, #0x4
bits = rtems_rfs_bitmap_merge (*map,
40026ac0: b85fc0a4 ldur w4, [x5, #-4]
if (size < rtems_rfs_bitmap_element_bits ())
40026ac4: f1007c7f cmp x3, #0x1f
40026ac8: 54fffe49 b.ls 40026a90 <rtems_rfs_bitmap_create_search+0x70> // b.plast
40026acc: d2800407 mov x7, #0x20 // #32
available = rtems_rfs_bitmap_element_bits ();
40026ad0: 2a0703e0 mov w0, w7
if (rtems_rfs_bitmap_match (bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
40026ad4: 34fffea4 cbz w4, 40026aa8 <rtems_rfs_bitmap_create_search+0x88>
for (b = 0; b < available; b++)
40026ad8: 52800001 mov w1, #0x0 // #0
40026adc: d503201f nop
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
40026ae0: 1ac12102 lsl w2, w8, w1
if (!rtems_rfs_bitmap_test (bits, b))
40026ae4: 11000421 add w1, w1, #0x1
40026ae8: 6a04005f tst w2, w4
40026aec: 54000080 b.eq 40026afc <rtems_rfs_bitmap_create_search+0xdc> // b.none
control->free++;
40026af0: f9401262 ldr x2, [x19, #32]
40026af4: 91000442 add x2, x2, #0x1
40026af8: f9001262 str x2, [x19, #32]
for (b = 0; b < available; b++)
40026afc: 6b01001f cmp w0, w1
40026b00: 54ffff01 b.ne 40026ae0 <rtems_rfs_bitmap_create_search+0xc0> // b.any
size -= available;
40026b04: cb070063 sub x3, x3, x7
if (bit == (rtems_rfs_bitmap_element_bits () - 1))
40026b08: 71007cdf cmp w6, #0x1f
40026b0c: 54fffd41 b.ne 40026ab4 <rtems_rfs_bitmap_create_search+0x94> // b.any
if (size > 0)
40026b10: b40000c3 cbz x3, 40026b28 <rtems_rfs_bitmap_create_search+0x108>
search_map++;
40026b14: 9100114a add x10, x10, #0x4
40026b18: 910010a5 add x5, x5, #0x4
bit = 0;
40026b1c: 52800006 mov w6, #0x0 // #0
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
40026b20: b9000149 str w9, [x10]
while (size)
40026b24: 17ffffe7 b 40026ac0 <rtems_rfs_bitmap_create_search+0xa0>
map++;
}
return 0;
40026b28: 52800000 mov w0, #0x0 // #0
}
40026b2c: f9400bf3 ldr x19, [sp, #16]
40026b30: a8c27bfd ldp x29, x30, [sp], #32
40026b34: d65f03c0 ret
if (rc > 0)
40026b38: 54ffffac b.gt 40026b2c <rtems_rfs_bitmap_create_search+0x10c> <== NOT EXECUTED
*map = NULL;
40026b3c: d2800005 mov x5, #0x0 // #0 <== NOT EXECUTED
40026b40: 17ffffc7 b 40026a5c <rtems_rfs_bitmap_create_search+0x3c> <== NOT EXECUTED
return ENXIO;
40026b44: 528000c0 mov w0, #0x6 // #6
}
40026b48: d65f03c0 ret
40026b4c: 00000000 udf #0
0000000040026920 <rtems_rfs_bitmap_map_alloc>:
int
rtems_rfs_bitmap_map_alloc (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit seed,
bool* allocated,
rtems_rfs_bitmap_bit* bit)
{
40026920: a9bc7bfd stp x29, x30, [sp, #-64]!
40026924: 910003fd mov x29, sp
40026928: a90153f3 stp x19, x20, [sp, #16]
4002692c: 2a0103f3 mov w19, w1
40026930: a9025bf5 stp x21, x22, [sp, #32]
40026934: aa0003f6 mov x22, x0
* seed up then from the seed down a window number of bits, then repeat the * process from the window distance from the seed, again above then * below. Keep moving out until all bits have been searched. */ upper_seed = seed; lower_seed = seed;
40026938: 2a0103f5 mov w21, w1
{
4002693c: a90363f7 stp x23, x24, [sp, #48]
40026940: aa0203f7 mov x23, x2
40026944: aa0303f8 mov x24, x3
*allocated = false;
40026948: 3900005f strb wzr, [x2]
* we have searched all of the map. The seed may not be aligned to a window * boundary so we may need to search a partial window and this may also not * be balanced for the upper or lower seeds. We move to the limits, search * then return false if no clear bits are found. */ while (((upper_seed >= 0) && (upper_seed < control->size))
4002694c: d503201f nop
40026950: 37f802d3 tbnz w19, #31, 400269a8 <rtems_rfs_bitmap_map_alloc+0x88>
40026954: f9400ec0 ldr x0, [x22, #24]
40026958: 93407e74 sxtw x20, w19
4002695c: eb00029f cmp x20, x0
40026960: 54000242 b.cs 400269a8 <rtems_rfs_bitmap_map_alloc+0x88> // b.hs, b.nlast
/*
* Search up first so bits allocated in succession are grouped together.
*/
if (upper_seed < control->size)
{
*bit = upper_seed;
40026964: b9000313 str w19, [x24]
rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
40026968: aa1703e2 mov x2, x23
4002696c: aa1803e1 mov x1, x24
40026970: aa1603e0 mov x0, x22
40026974: 52800023 mov w3, #0x1 // #1
40026978: 97fffe4e bl 400262b0 <rtems_rfs_search_map_for_clear_bit.constprop.0>
window, 1);
if ((rc > 0) || *allocated)
4002697c: 7100001f cmp w0, #0x0
40026980: 5400042c b.gt 40026a04 <rtems_rfs_bitmap_map_alloc+0xe4> <== NEVER TAKEN
40026984: 394002e0 ldrb w0, [x23]
40026988: 350003e0 cbnz w0, 40026a04 <rtems_rfs_bitmap_map_alloc+0xe4>
break;
}
if (lower_seed >= 0)
4002698c: 36f801d5 tbz w21, #31, 400269c4 <rtems_rfs_bitmap_map_alloc+0xa4>
/*
* Do not bound the limits at the edges of the map. Do not update if an
* edge has been passed.
*/
if (upper_seed < control->size)
40026990: f9400ec0 ldr x0, [x22, #24]
40026994: eb00029f cmp x20, x0
40026998: 54fffdc2 b.cs 40026950 <rtems_rfs_bitmap_map_alloc+0x30> // b.hs, b.nlast<== NEVER TAKEN
upper_seed += window;
4002699c: 11200273 add w19, w19, #0x800
while (((upper_seed >= 0) && (upper_seed < control->size))
400269a0: 36fffdb3 tbz w19, #31, 40026954 <rtems_rfs_bitmap_map_alloc+0x34> <== ALWAYS TAKEN
400269a4: d503201f nop
|| ((lower_seed >= 0) && (lower_seed < control->size)))
400269a8: 37f802f5 tbnz w21, #31, 40026a04 <rtems_rfs_bitmap_map_alloc+0xe4>
400269ac: f9400ec0 ldr x0, [x22, #24]
400269b0: eb35c01f cmp x0, w21, sxtw
400269b4: 54000289 b.ls 40026a04 <rtems_rfs_bitmap_map_alloc+0xe4> // b.plast
if (upper_seed < control->size)
400269b8: 93407e74 sxtw x20, w19
400269bc: eb00029f cmp x20, x0
400269c0: 54fffd23 b.cc 40026964 <rtems_rfs_bitmap_map_alloc+0x44> // b.lo, b.ul, b.last<== NEVER TAKEN
*bit = lower_seed;
400269c4: b9000315 str w21, [x24]
rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
400269c8: aa1703e2 mov x2, x23
400269cc: aa1803e1 mov x1, x24
400269d0: aa1603e0 mov x0, x22
400269d4: 12800003 mov w3, #0xffffffff // #-1
400269d8: 97fffe36 bl 400262b0 <rtems_rfs_search_map_for_clear_bit.constprop.0>
if ((rc > 0) || *allocated)
400269dc: 7100001f cmp w0, #0x0
400269e0: 5400012c b.gt 40026a04 <rtems_rfs_bitmap_map_alloc+0xe4> <== NEVER TAKEN
400269e4: 394002e0 ldrb w0, [x23]
400269e8: 350000e0 cbnz w0, 40026a04 <rtems_rfs_bitmap_map_alloc+0xe4>
if (upper_seed < control->size)
400269ec: f9400ec1 ldr x1, [x22, #24]
upper_seed += window;
400269f0: 11200260 add w0, w19, #0x800
if (lower_seed >= 0)
lower_seed -= window;
400269f4: 512002b5 sub w21, w21, #0x800
upper_seed += window;
400269f8: eb01029f cmp x20, x1
400269fc: 1a933013 csel w19, w0, w19, cc // cc = lo, ul, last
lower_seed -= window;
40026a00: 17ffffd4 b 40026950 <rtems_rfs_bitmap_map_alloc+0x30>
}
return 0;
}
40026a04: 52800000 mov w0, #0x0 // #0
40026a08: a94153f3 ldp x19, x20, [sp, #16]
40026a0c: a9425bf5 ldp x21, x22, [sp, #32]
40026a10: a94363f7 ldp x23, x24, [sp, #48]
40026a14: a8c47bfd ldp x29, x30, [sp], #64
40026a18: d65f03c0 ret
40026a1c: 00000000 udf #0
0000000040026600 <rtems_rfs_bitmap_map_clear>:
{
40026600: a9be7bfd stp x29, x30, [sp, #-32]!
40026604: 910003fd mov x29, sp
40026608: a90153f3 stp x19, x20, [sp, #16]
4002660c: 2a0103f4 mov w20, w1
if (!control->buffer)
40026610: f9400001 ldr x1, [x0]
40026614: b4000561 cbz x1, 400266c0 <rtems_rfs_bitmap_map_clear+0xc0>
rc = rtems_rfs_buffer_handle_request (control->fs,
40026618: b9401002 ldr w2, [x0, #16]
4002661c: aa0003f3 mov x19, x0
40026620: f9400400 ldr x0, [x0, #8]
40026624: 52800023 mov w3, #0x1 // #1
40026628: 9400026a bl 40026fd0 <rtems_rfs_buffer_handle_request>
if (rc)
4002662c: 7100001f cmp w0, #0x0
40026630: 35000420 cbnz w0, 400266b4 <rtems_rfs_bitmap_map_clear+0xb4> <== NEVER TAKEN
*map = rtems_rfs_buffer_data (control->buffer);
40026634: f9400260 ldr x0, [x19]
40026638: f9400400 ldr x0, [x0, #8]
4002663c: f9401c04 ldr x4, [x0, #56]
return EINVAL;
40026640: 528002c0 mov w0, #0x16 // #22
if (bit >= control->size)
40026644: f9400e61 ldr x1, [x19, #24]
40026648: eb34c03f cmp x1, w20, sxtw
4002664c: 540002e9 b.ls 400266a8 <rtems_rfs_bitmap_map_clear+0xa8> // b.plast
index = rtems_rfs_bitmap_map_index (bit);
40026650: 13057e82 asr w2, w20, #5
map[index] = rtems_rfs_bitmap_clear (element, 1 << offset);
40026654: 52800023 mov w3, #0x1 // #1
40026658: 1ad42061 lsl w1, w3, w20
return 0;
4002665c: 52800000 mov w0, #0x0 // #0
element = map[index];
40026660: 93407c46 sxtw x6, w2
search_map = control->search_bits;
40026664: f9401667 ldr x7, [x19, #40]
element = map[index];
40026668: b8667885 ldr w5, [x4, x6, lsl #2]
return RTEMS_RFS_BITMAP_CLEAR_BITS (target, bits);
4002666c: 2a050021 orr w1, w1, w5
map[index] = rtems_rfs_bitmap_clear (element, 1 << offset);
40026670: b8267881 str w1, [x4, x6, lsl #2]
if (rtems_rfs_bitmap_match(element, map[index]))
40026674: 6b0100bf cmp w5, w1
40026678: 54000180 b.eq 400266a8 <rtems_rfs_bitmap_map_clear+0xa8> // b.none <== NEVER TAKEN
index = rtems_rfs_bitmap_map_index (bit);
4002667c: 130a7e94 asr w20, w20, #10
search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset);
40026680: 1ac22062 lsl w2, w3, w2
rtems_rfs_buffer_mark_dirty (control->buffer);
40026684: f9400265 ldr x5, [x19]
search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset);
40026688: 93407e94 sxtw x20, w20
control->free++;
4002668c: f9401261 ldr x1, [x19, #32]
return RTEMS_RFS_BITMAP_CLEAR_BITS (target, bits);
40026690: b87478e4 ldr w4, [x7, x20, lsl #2]
control->free++;
40026694: 91000421 add x1, x1, #0x1
return RTEMS_RFS_BITMAP_CLEAR_BITS (target, bits);
40026698: 2a020082 orr w2, w4, w2
search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset);
4002669c: b83478e2 str w2, [x7, x20, lsl #2]
rtems_rfs_buffer_mark_dirty (control->buffer);
400266a0: 390000a3 strb w3, [x5]
control->free++;
400266a4: f9001261 str x1, [x19, #32]
}
400266a8: a94153f3 ldp x19, x20, [sp, #16]
400266ac: a8c27bfd ldp x29, x30, [sp], #32
400266b0: d65f03c0 ret
if (rc > 0)
400266b4: 54ffffac b.gt 400266a8 <rtems_rfs_bitmap_map_clear+0xa8> <== NOT EXECUTED
*map = NULL;
400266b8: d2800004 mov x4, #0x0 // #0 <== NOT EXECUTED
400266bc: 17ffffe1 b 40026640 <rtems_rfs_bitmap_map_clear+0x40> <== NOT EXECUTED
return ENXIO;
400266c0: 528000c0 mov w0, #0x6 // #6
}
400266c4: a94153f3 ldp x19, x20, [sp, #16]
400266c8: a8c27bfd ldp x29, x30, [sp], #32
400266cc: d65f03c0 ret
0000000040026840 <rtems_rfs_bitmap_map_clear_all>:
if (!control->buffer)
40026840: f9400001 ldr x1, [x0]
40026844: b4000641 cbz x1, 4002690c <rtems_rfs_bitmap_map_clear_all+0xcc>
{
40026848: a9bd7bfd stp x29, x30, [sp, #-48]!
rc = rtems_rfs_buffer_handle_request (control->fs,
4002684c: 52800023 mov w3, #0x1 // #1
{
40026850: 910003fd mov x29, sp
rc = rtems_rfs_buffer_handle_request (control->fs,
40026854: b9401002 ldr w2, [x0, #16]
{
40026858: a90153f3 stp x19, x20, [sp, #16]
4002685c: aa0003f3 mov x19, x0
rc = rtems_rfs_buffer_handle_request (control->fs,
40026860: f9400400 ldr x0, [x0, #8]
{
40026864: a9025bf5 stp x21, x22, [sp, #32]
rc = rtems_rfs_buffer_handle_request (control->fs,
40026868: 940001da bl 40026fd0 <rtems_rfs_buffer_handle_request>
if (rc)
4002686c: 7100001f cmp w0, #0x0
40026870: 35000460 cbnz w0, 400268fc <rtems_rfs_bitmap_map_clear_all+0xbc> <== NEVER TAKEN
*map = rtems_rfs_buffer_data (control->buffer);
40026874: f9400276 ldr x22, [x19]
40026878: f94006c0 ldr x0, [x22, #8]
4002687c: f9401c00 ldr x0, [x0, #56]
map[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
40026880: 52801fe1 mov w1, #0xff // #255
elements = rtems_rfs_bitmap_elements (control->size);
40026884: f9400e62 ldr x2, [x19, #24]
control->free = control->size;
40026888: f9001262 str x2, [x19, #32]
elements = rtems_rfs_bitmap_elements (control->size);
4002688c: d1000454 sub x20, x2, #0x1
40026890: d345fe95 lsr x21, x20, #5
40026894: 910006b5 add x21, x21, #0x1
map[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
40026898: d37ef6a2 lsl x2, x21, #2
4002689c: 94005dc4 bl 4003dfac <memset>
last_search_bit = rtems_rfs_bitmap_map_offset (elements);
400268a0: 720012b5 ands w21, w21, #0x1f
elements = rtems_rfs_bitmap_elements (elements);
400268a4: d34afe82 lsr x2, x20, #10
mask >>= (rtems_rfs_bitmap_element_bits () - size);
400268a8: 4b1503f4 neg w20, w21
400268ac: 12800000 mov w0, #0xffffffff // #-1
elements = rtems_rfs_bitmap_elements (elements);
400268b0: 91000455 add x21, x2, #0x1
mask >>= (rtems_rfs_bitmap_element_bits () - size);
400268b4: 1ad42414 lsr w20, w0, w20
400268b8: 1a801294 csel w20, w20, w0, ne // ne = any
control->search_bits[elements - 1] =
400268bc: f9401663 ldr x3, [x19, #40]
for (e = 0; e < (elements - 1); e++)
400268c0: b40000c2 cbz x2, 400268d8 <rtems_rfs_bitmap_map_clear_all+0x98>
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
400268c4: aa0303e0 mov x0, x3
400268c8: d37ef442 lsl x2, x2, #2
400268cc: 52801fe1 mov w1, #0xff // #255
400268d0: 94005db7 bl 4003dfac <memset>
400268d4: aa0003e3 mov x3, x0
control->search_bits[elements - 1] =
400268d8: 8b150875 add x21, x3, x21, lsl #2
rtems_rfs_buffer_mark_dirty (control->buffer);
400268dc: 52800021 mov w1, #0x1 // #1
return 0;
400268e0: 52800000 mov w0, #0x0 // #0
control->search_bits[elements - 1] =
400268e4: b81fc2b4 stur w20, [x21, #-4]
rtems_rfs_buffer_mark_dirty (control->buffer);
400268e8: 390002c1 strb w1, [x22]
}
400268ec: a94153f3 ldp x19, x20, [sp, #16]
400268f0: a9425bf5 ldp x21, x22, [sp, #32]
400268f4: a8c37bfd ldp x29, x30, [sp], #48
400268f8: d65f03c0 ret
if (rc > 0)
400268fc: 54ffff8c b.gt 400268ec <rtems_rfs_bitmap_map_clear_all+0xac> <== NOT EXECUTED
*map = NULL;
40026900: d2800000 mov x0, #0x0 // #0 <== NOT EXECUTED
*map = rtems_rfs_buffer_data (control->buffer);
40026904: f9400276 ldr x22, [x19] <== NOT EXECUTED
40026908: 17ffffde b 40026880 <rtems_rfs_bitmap_map_clear_all+0x40> <== NOT EXECUTED
return ENXIO;
4002690c: 528000c0 mov w0, #0x6 // #6
}
40026910: d65f03c0 ret
...
0000000040026520 <rtems_rfs_bitmap_map_set>:
{
40026520: a9be7bfd stp x29, x30, [sp, #-32]!
40026524: 910003fd mov x29, sp
40026528: a90153f3 stp x19, x20, [sp, #16]
4002652c: 2a0103f4 mov w20, w1
if (!control->buffer)
40026530: f9400001 ldr x1, [x0]
40026534: b40005e1 cbz x1, 400265f0 <rtems_rfs_bitmap_map_set+0xd0>
rc = rtems_rfs_buffer_handle_request (control->fs,
40026538: b9401002 ldr w2, [x0, #16]
4002653c: aa0003f3 mov x19, x0
40026540: f9400400 ldr x0, [x0, #8]
40026544: 52800023 mov w3, #0x1 // #1
40026548: 940002a2 bl 40026fd0 <rtems_rfs_buffer_handle_request>
if (rc)
4002654c: 7100001f cmp w0, #0x0
40026550: 350004a0 cbnz w0, 400265e4 <rtems_rfs_bitmap_map_set+0xc4> <== NEVER TAKEN
*map = rtems_rfs_buffer_data (control->buffer);
40026554: f9400260 ldr x0, [x19]
40026558: f9400400 ldr x0, [x0, #8]
4002655c: f9401c02 ldr x2, [x0, #56]
return EINVAL;
40026560: 528002c0 mov w0, #0x16 // #22
if (bit >= control->size)
40026564: f9400e61 ldr x1, [x19, #24]
40026568: eb34c03f cmp x1, w20, sxtw
4002656c: 540002e9 b.ls 400265c8 <rtems_rfs_bitmap_map_set+0xa8> // b.plast
index = rtems_rfs_bitmap_map_index (bit);
40026570: 13057e85 asr w5, w20, #5
map[index] = rtems_rfs_bitmap_set (element, 1 << offset);
40026574: 52800021 mov w1, #0x1 // #1
40026578: 1ad42020 lsl w0, w1, w20
element = map[index];
4002657c: 93407ca4 sxtw x4, w5
search_map = control->search_bits;
40026580: f9401666 ldr x6, [x19, #40]
element = map[index];
40026584: b8647843 ldr w3, [x2, x4, lsl #2]
return RTEMS_RFS_BITMAP_SET_BITS (target, bits);
40026588: 0a200060 bic w0, w3, w0
map[index] = rtems_rfs_bitmap_set (element, 1 << offset);
4002658c: b8247840 str w0, [x2, x4, lsl #2]
if (rtems_rfs_bitmap_match(element, map[index]))
40026590: 6b00007f cmp w3, w0
40026594: 54000200 b.eq 400265d4 <rtems_rfs_bitmap_map_set+0xb4> // b.none
rtems_rfs_buffer_mark_dirty (control->buffer);
40026598: f9400263 ldr x3, [x19]
control->free--;
4002659c: f9401262 ldr x2, [x19, #32]
400265a0: d1000442 sub x2, x2, #0x1
400265a4: f9001262 str x2, [x19, #32]
rtems_rfs_buffer_mark_dirty (control->buffer);
400265a8: 39000061 strb w1, [x3]
if (rtems_rfs_bitmap_match(map[index], RTEMS_RFS_BITMAP_ELEMENT_SET))
400265ac: 35000140 cbnz w0, 400265d4 <rtems_rfs_bitmap_map_set+0xb4>
index = rtems_rfs_bitmap_map_index (bit);
400265b0: 130a7e94 asr w20, w20, #10
search_map[index] = rtems_rfs_bitmap_set (search_map[index], 1 << offset);
400265b4: 1ac52021 lsl w1, w1, w5
400265b8: 93407e94 sxtw x20, w20
return RTEMS_RFS_BITMAP_SET_BITS (target, bits);
400265bc: b87478c2 ldr w2, [x6, x20, lsl #2]
400265c0: 0a210041 bic w1, w2, w1
search_map[index] = rtems_rfs_bitmap_set (search_map[index], 1 << offset);
400265c4: b83478c1 str w1, [x6, x20, lsl #2]
}
400265c8: a94153f3 ldp x19, x20, [sp, #16]
400265cc: a8c27bfd ldp x29, x30, [sp], #32
400265d0: d65f03c0 ret
return 0;
400265d4: 52800000 mov w0, #0x0 // #0
}
400265d8: a94153f3 ldp x19, x20, [sp, #16]
400265dc: a8c27bfd ldp x29, x30, [sp], #32
400265e0: d65f03c0 ret
if (rc > 0)
400265e4: 54ffff2c b.gt 400265c8 <rtems_rfs_bitmap_map_set+0xa8> <== NOT EXECUTED
*map = NULL;
400265e8: d2800002 mov x2, #0x0 // #0 <== NOT EXECUTED
400265ec: 17ffffdd b 40026560 <rtems_rfs_bitmap_map_set+0x40> <== NOT EXECUTED
return ENXIO;
400265f0: 528000c0 mov w0, #0x6 // #6
}
400265f4: a94153f3 ldp x19, x20, [sp, #16]
400265f8: a8c27bfd ldp x29, x30, [sp], #32
400265fc: d65f03c0 ret
0000000040026790 <rtems_rfs_bitmap_map_set_all>:
if (!control->buffer)
40026790: f9400001 ldr x1, [x0]
40026794: b4000501 cbz x1, 40026834 <rtems_rfs_bitmap_map_set_all+0xa4>
{
40026798: a9bd7bfd stp x29, x30, [sp, #-48]!
rc = rtems_rfs_buffer_handle_request (control->fs,
4002679c: 52800023 mov w3, #0x1 // #1
{
400267a0: 910003fd mov x29, sp
rc = rtems_rfs_buffer_handle_request (control->fs,
400267a4: b9401002 ldr w2, [x0, #16]
{
400267a8: a90153f3 stp x19, x20, [sp, #16]
400267ac: aa0003f3 mov x19, x0
rc = rtems_rfs_buffer_handle_request (control->fs,
400267b0: f9400400 ldr x0, [x0, #8]
{
400267b4: f90013f5 str x21, [sp, #32]
rc = rtems_rfs_buffer_handle_request (control->fs,
400267b8: 94000206 bl 40026fd0 <rtems_rfs_buffer_handle_request>
if (rc)
400267bc: 7100001f cmp w0, #0x0
400267c0: 35000320 cbnz w0, 40026824 <rtems_rfs_bitmap_map_set_all+0x94> <== NEVER TAKEN
*map = rtems_rfs_buffer_data (control->buffer);
400267c4: f9400275 ldr x21, [x19]
400267c8: f94006a0 ldr x0, [x21, #8]
400267cc: f9401c00 ldr x0, [x0, #56]
control->free = 0;
400267d0: f900127f str xzr, [x19, #32]
elements = rtems_rfs_bitmap_elements (control->size);
400267d4: f9400e74 ldr x20, [x19, #24]
map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
400267d8: 52800001 mov w1, #0x0 // #0
elements = rtems_rfs_bitmap_elements (control->size);
400267dc: d1000694 sub x20, x20, #0x1
400267e0: d345fe82 lsr x2, x20, #5
400267e4: 91000442 add x2, x2, #0x1
map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
400267e8: d37ef442 lsl x2, x2, #2
400267ec: 94005df0 bl 4003dfac <memset>
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
400267f0: f9401660 ldr x0, [x19, #40]
elements = rtems_rfs_bitmap_elements (elements);
400267f4: d34afe82 lsr x2, x20, #10
400267f8: 91000442 add x2, x2, #0x1
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
400267fc: 52800001 mov w1, #0x0 // #0
40026800: d37ef442 lsl x2, x2, #2
40026804: 94005dea bl 4003dfac <memset>
rtems_rfs_buffer_mark_dirty (control->buffer);
40026808: 52800021 mov w1, #0x1 // #1
return 0;
4002680c: 52800000 mov w0, #0x0 // #0
rtems_rfs_buffer_mark_dirty (control->buffer);
40026810: 390002a1 strb w1, [x21]
}
40026814: a94153f3 ldp x19, x20, [sp, #16]
40026818: f94013f5 ldr x21, [sp, #32]
4002681c: a8c37bfd ldp x29, x30, [sp], #48
40026820: d65f03c0 ret
if (rc > 0)
40026824: 54ffff8c b.gt 40026814 <rtems_rfs_bitmap_map_set_all+0x84> <== NOT EXECUTED
*map = NULL;
40026828: d2800000 mov x0, #0x0 // #0 <== NOT EXECUTED
*map = rtems_rfs_buffer_data (control->buffer);
4002682c: f9400275 ldr x21, [x19] <== NOT EXECUTED
40026830: 17ffffe8 b 400267d0 <rtems_rfs_bitmap_map_set_all+0x40> <== NOT EXECUTED
return ENXIO;
40026834: 528000c0 mov w0, #0x6 // #6
}
40026838: d65f03c0 ret
4002683c: 00000000 udf #0
00000000400266d0 <rtems_rfs_bitmap_map_test>:
{
400266d0: a9bd7bfd stp x29, x30, [sp, #-48]!
400266d4: 910003fd mov x29, sp
400266d8: a90153f3 stp x19, x20, [sp, #16]
400266dc: 2a0103f4 mov w20, w1
if (!control->buffer)
400266e0: f9400001 ldr x1, [x0]
400266e4: b4000481 cbz x1, 40026774 <rtems_rfs_bitmap_map_test+0xa4>
rc = rtems_rfs_buffer_handle_request (control->fs,
400266e8: aa0003f3 mov x19, x0
400266ec: 52800023 mov w3, #0x1 // #1
400266f0: f9400400 ldr x0, [x0, #8]
400266f4: f90013f5 str x21, [sp, #32]
400266f8: aa0203f5 mov x21, x2
400266fc: b9401262 ldr w2, [x19, #16]
40026700: 94000234 bl 40026fd0 <rtems_rfs_buffer_handle_request>
if (rc)
40026704: 7100001f cmp w0, #0x0
40026708: 35000280 cbnz w0, 40026758 <rtems_rfs_bitmap_map_test+0x88> <== NEVER TAKEN
*map = rtems_rfs_buffer_data (control->buffer);
4002670c: f9400260 ldr x0, [x19]
40026710: f9400400 ldr x0, [x0, #8]
40026714: f9401c02 ldr x2, [x0, #56]
return EINVAL;
40026718: 528002c0 mov w0, #0x16 // #22
if (bit >= control->size)
4002671c: f9400e61 ldr x1, [x19, #24]
40026720: eb34c03f cmp x1, w20, sxtw
40026724: 540001c9 b.ls 4002675c <rtems_rfs_bitmap_map_test+0x8c> // b.plast
index = rtems_rfs_bitmap_map_index (bit);
40026728: 13057e83 asr w3, w20, #5
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
4002672c: 52800021 mov w1, #0x1 // #1
40026730: 1ad42034 lsl w20, w1, w20
return 0;
40026734: 52800000 mov w0, #0x0 // #0
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
40026738: b863d841 ldr w1, [x2, w3, sxtw #2]
4002673c: 6a01029f tst w20, w1
40026740: 1a9f17e1 cset w1, eq // eq = none
40026744: 390002a1 strb w1, [x21]
}
40026748: a94153f3 ldp x19, x20, [sp, #16]
return 0;
4002674c: f94013f5 ldr x21, [sp, #32]
}
40026750: a8c37bfd ldp x29, x30, [sp], #48
40026754: d65f03c0 ret
if (rc > 0)
40026758: 540000ad b.le 4002676c <rtems_rfs_bitmap_map_test+0x9c> <== NOT EXECUTED
}
4002675c: a94153f3 ldp x19, x20, [sp, #16]
40026760: f94013f5 ldr x21, [sp, #32]
40026764: a8c37bfd ldp x29, x30, [sp], #48
40026768: d65f03c0 ret
*map = NULL;
4002676c: d2800002 mov x2, #0x0 // #0 <== NOT EXECUTED
40026770: 17ffffea b 40026718 <rtems_rfs_bitmap_map_test+0x48> <== NOT EXECUTED
return ENXIO;
40026774: 528000c0 mov w0, #0x6 // #6
}
40026778: a94153f3 ldp x19, x20, [sp, #16]
4002677c: a8c37bfd ldp x29, x30, [sp], #48
40026780: d65f03c0 ret
...
0000000040033e90 <rtems_rfs_block_map_close>:
{
40033e90: a9bc7bfd stp x29, x30, [sp, #-64]!
40033e94: 910003fd mov x29, sp
40033e98: a90153f3 stp x19, x20, [sp, #16]
40033e9c: aa0103f3 mov x19, x1
if (map->dirty && map->inode)
40033ea0: 39400021 ldrb w1, [x1]
{
40033ea4: a9025bf5 stp x21, x22, [sp, #32]
40033ea8: aa0003f4 mov x20, x0
40033eac: f9001bf7 str x23, [sp, #48]
int rc = 0;
40033eb0: 52800017 mov w23, #0x0 // #0
if (map->dirty && map->inode)
40033eb4: 34000101 cbz w1, 40033ed4 <rtems_rfs_block_map_close+0x44>
40033eb8: f9400661 ldr x1, [x19, #8]
int rc = 0;
40033ebc: 52800017 mov w23, #0x0 // #0
if (map->dirty && map->inode)
40033ec0: b40000a1 cbz x1, 40033ed4 <rtems_rfs_block_map_close+0x44> <== NEVER TAKEN
brc = rtems_rfs_inode_load (fs, map->inode);
40033ec4: 97ffd36f bl 40028c80 <rtems_rfs_inode_load>
40033ec8: 2a0003f7 mov w23, w0
if (brc > 0)
40033ecc: 7100001f cmp w0, #0x0
40033ed0: 540002cd b.le 40033f28 <rtems_rfs_block_map_close+0x98> <== ALWAYS TAKEN
map->inode = NULL;
40033ed4: f900067f str xzr, [x19, #8]
brc = rtems_rfs_buffer_handle_close (fs, &map->singly_buffer);
40033ed8: 91010276 add x22, x19, #0x40
rtems_rfs_buffer_handle_release (fs, handle);
40033edc: aa1603e1 mov x1, x22
40033ee0: aa1403e0 mov x0, x20
40033ee4: 97ffcceb bl 40027290 <rtems_rfs_buffer_handle_release>
handle->dirty = false;
40033ee8: 3901027f strb wzr, [x19, #64]
handle->bnum = 0;
40033eec: b900467f str wzr, [x19, #68]
brc = rtems_rfs_buffer_handle_close (fs, &map->doubly_buffer);
40033ef0: 91014275 add x21, x19, #0x50
handle->buffer = NULL;
40033ef4: f900267f str xzr, [x19, #72]
rtems_rfs_buffer_handle_release (fs, handle);
40033ef8: aa1503e1 mov x1, x21
40033efc: aa1403e0 mov x0, x20
40033f00: 97ffcce4 bl 40027290 <rtems_rfs_buffer_handle_release>
handle->dirty = false;
40033f04: 3901427f strb wzr, [x19, #80]
}
40033f08: 2a1703e0 mov w0, w23
40033f0c: a9425bf5 ldp x21, x22, [sp, #32]
40033f10: f9401bf7 ldr x23, [sp, #48]
handle->bnum = 0;
40033f14: b900567f str wzr, [x19, #84]
handle->buffer = NULL;
40033f18: f9002e7f str xzr, [x19, #88]
40033f1c: a94153f3 ldp x19, x20, [sp, #16]
40033f20: a8c47bfd ldp x29, x30, [sp], #64
40033f24: d65f03c0 ret
40033f28: 91004268 add x8, x19, #0x10
40033f2c: d2800380 mov x0, #0x1c // #28
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40033f30: 52800027 mov w7, #0x1 // #1
rtems_rfs_inode_set_block (map->inode, b, map->blocks[b]);
40033f34: f9400661 ldr x1, [x19, #8]
40033f38: b8606902 ldr w2, [x8, x0]
rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);
40033f3c: f9400c23 ldr x3, [x1, #24]
40033f40: 53187c46 lsr w6, w2, #24
40033f44: 53107c45 lsr w5, w2, #16
40033f48: 53087c44 lsr w4, w2, #8
40033f4c: 38206866 strb w6, [x3, x0]
40033f50: f9400c23 ldr x3, [x1, #24]
40033f54: 8b000063 add x3, x3, x0
40033f58: 39000465 strb w5, [x3, #1]
40033f5c: f9400c23 ldr x3, [x1, #24]
40033f60: 8b000063 add x3, x3, x0
40033f64: 39000864 strb w4, [x3, #2]
40033f68: f9400c23 ldr x3, [x1, #24]
40033f6c: 8b000063 add x3, x3, x0
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
40033f70: 91001000 add x0, x0, #0x4
40033f74: f100c01f cmp x0, #0x30
40033f78: 39000c62 strb w2, [x3, #3]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40033f7c: 39008027 strb w7, [x1, #32]
40033f80: 54fffda1 b.ne 40033f34 <rtems_rfs_block_map_close+0xa4> // b.any
rtems_rfs_inode_set_block_count (map->inode, map->size.count);
40033f84: f9400661 ldr x1, [x19, #8]
brc = rtems_rfs_inode_unload (fs, map->inode, true);
40033f88: aa1403e0 mov x0, x20
rtems_rfs_inode_set_block_count (map->inode, map->size.count);
40033f8c: b9401263 ldr w3, [x19, #16]
brc = rtems_rfs_inode_unload (fs, map->inode, true);
40033f90: 52800022 mov w2, #0x1 // #1
rtems_rfs_write_u32 (&handle->node->block_count, block_count);
40033f94: f9400c24 ldr x4, [x1, #24]
40033f98: 53187c68 lsr w8, w3, #24
40033f9c: 53107c66 lsr w6, w3, #16
40033fa0: 53087c65 lsr w5, w3, #8
40033fa4: 39003088 strb w8, [x4, #12]
40033fa8: f9400c24 ldr x4, [x1, #24]
40033fac: 39003486 strb w6, [x4, #13]
40033fb0: f9400c24 ldr x4, [x1, #24]
40033fb4: 39003885 strb w5, [x4, #14]
40033fb8: f9400c24 ldr x4, [x1, #24]
40033fbc: 39003c83 strb w3, [x4, #15]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40033fc0: 39008027 strb w7, [x1, #32]
rtems_rfs_inode_set_block_offset (map->inode, map->size.offset);
40033fc4: f9400661 ldr x1, [x19, #8]
40033fc8: b9401663 ldr w3, [x19, #20]
rtems_rfs_write_u16 (&handle->node->block_offset, block_offset);
40033fcc: f9400c24 ldr x4, [x1, #24]
40033fd0: d3483c65 ubfx x5, x3, #8, #8
40033fd4: 39002885 strb w5, [x4, #10]
40033fd8: f9400c24 ldr x4, [x1, #24]
40033fdc: 39002c83 strb w3, [x4, #11]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40033fe0: 39008027 strb w7, [x1, #32]
rtems_rfs_inode_set_last_map_block (map->inode, map->last_map_block);
40033fe4: f9400661 ldr x1, [x19, #8]
40033fe8: b9402663 ldr w3, [x19, #36]
rtems_rfs_write_u32 (&handle->node->last_map_block, last_map_block);
40033fec: f9400c24 ldr x4, [x1, #24]
40033ff0: 53187c68 lsr w8, w3, #24
40033ff4: 53107c66 lsr w6, w3, #16
40033ff8: 53087c65 lsr w5, w3, #8
40033ffc: 3900c088 strb w8, [x4, #48]
40034000: f9400c24 ldr x4, [x1, #24]
40034004: 3900c486 strb w6, [x4, #49]
40034008: f9400c24 ldr x4, [x1, #24]
4003400c: 3900c885 strb w5, [x4, #50]
40034010: f9400c24 ldr x4, [x1, #24]
40034014: 3900cc83 strb w3, [x4, #51]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40034018: 39008027 strb w7, [x1, #32]
rtems_rfs_inode_set_last_data_block (map->inode, map->last_data_block);
4003401c: f9400661 ldr x1, [x19, #8]
40034020: b9402a63 ldr w3, [x19, #40]
rtems_rfs_write_u32 (&handle->node->last_data_block, last_data_block);
40034024: f9400c24 ldr x4, [x1, #24]
40034028: 53187c68 lsr w8, w3, #24
4003402c: 53107c66 lsr w6, w3, #16
40034030: 53087c65 lsr w5, w3, #8
40034034: 3900d088 strb w8, [x4, #52]
40034038: f9400c24 ldr x4, [x1, #24]
4003403c: 3900d486 strb w6, [x4, #53]
40034040: f9400c24 ldr x4, [x1, #24]
40034044: 3900d885 strb w5, [x4, #54]
40034048: f9400c24 ldr x4, [x1, #24]
4003404c: 3900dc83 strb w3, [x4, #55]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40034050: 39008027 strb w7, [x1, #32]
brc = rtems_rfs_inode_unload (fs, map->inode, true);
40034054: f9400661 ldr x1, [x19, #8]
40034058: 97ffd372 bl 40028e20 <rtems_rfs_inode_unload>
if (brc > 0)
4003405c: 7100001f cmp w0, #0x0
40034060: 1a9fa017 csel w23, w0, wzr, ge // ge = tcont
map->dirty = false;
40034064: 3900027f strb wzr, [x19]
40034068: 17ffff9b b 40033ed4 <rtems_rfs_block_map_close+0x44>
4003406c: 00000000 udf #0
0000000040034070 <rtems_rfs_block_map_find>:
{
40034070: a9bb7bfd stp x29, x30, [sp, #-80]!
40034074: 910003fd mov x29, sp
40034078: a90153f3 stp x19, x20, [sp, #16]
4003407c: aa0103f3 mov x19, x1
40034080: a9025bf5 stp x21, x22, [sp, #32]
40034084: aa0203f6 mov x22, x2
40034088: aa0003f5 mov x21, x0
4003408c: f9001bf7 str x23, [sp, #48]
40034090: aa0303f7 mov x23, x3
*block = 0;
40034094: b900007f str wzr, [x3]
if (rtems_rfs_block_pos_block_past_end (bpos, &map->size))
40034098: b9400041 ldr w1, [x2]
4003409c: b9401265 ldr w5, [x19, #16]
400340a0: 34000061 cbz w1, 400340ac <rtems_rfs_block_map_find+0x3c>
return ENXIO;
400340a4: 528000c0 mov w0, #0x6 // #6
if (rtems_rfs_block_pos_block_past_end (bpos, &map->size))
400340a8: 34000265 cbz w5, 400340f4 <rtems_rfs_block_map_find+0x84> <== NEVER TAKEN
400340ac: 6b05003f cmp w1, w5
return ENXIO;
400340b0: 528000c0 mov w0, #0x6 // #6
if (rtems_rfs_block_pos_block_past_end (bpos, &map->size))
400340b4: 54000202 b.cs 400340f4 <rtems_rfs_block_map_find+0x84> // b.hs, b.nlast
if ((bpos->bno == map->bpos.bno) && (map->bpos.block != 0))
400340b8: b9401a60 ldr w0, [x19, #24]
400340bc: 6b00003f cmp w1, w0
400340c0: 54000600 b.eq 40034180 <rtems_rfs_block_map_find+0x110> // b.none
if (map->size.count <= RTEMS_RFS_INODE_BLOCKS)
400340c4: 710014bf cmp w5, #0x5
400340c8: 54000208 b.hi 40034108 <rtems_rfs_block_map_find+0x98> // b.pmore <== ALWAYS TAKEN
*block = map->blocks[bpos->bno];
400340cc: 8b214a61 add x1, x19, w1, uxtw #2
400340d0: b9402c20 ldr w0, [x1, #44]
400340d4: b90002e0 str w0, [x23]
rtems_rfs_block_copy_bpos (&map->bpos, bpos);
400340d8: b9400ac1 ldr w1, [x22, #8]
map->bpos.block = *block;
400340dc: 52800000 mov w0, #0x0 // #0
rtems_rfs_block_copy_bpos (&map->bpos, bpos);
400340e0: 29400ac3 ldp w3, w2, [x22]
400340e4: 29030a63 stp w3, w2, [x19, #24]
400340e8: b9002261 str w1, [x19, #32]
map->bpos.block = *block;
400340ec: b94002e1 ldr w1, [x23]
400340f0: b9002261 str w1, [x19, #32]
}
400340f4: a94153f3 ldp x19, x20, [sp, #16]
400340f8: a9425bf5 ldp x21, x22, [sp, #32]
400340fc: f9401bf7 ldr x23, [sp, #48]
40034100: a8c57bfd ldp x29, x30, [sp], #80
40034104: d65f03c0 ret
if (map->size.count <= fs->block_map_singly_blocks)
40034108: a9460aa3 ldp x3, x2, [x21, #96]
direct = bpos->bno % fs->blocks_per_block;
4003410c: 2a0103e1 mov w1, w1
if (map->size.count <= fs->block_map_singly_blocks)
40034110: 2a0503e5 mov w5, w5
direct = bpos->bno % fs->blocks_per_block;
40034114: 9ac30820 udiv x0, x1, x3
if (map->size.count <= fs->block_map_singly_blocks)
40034118: eb0200bf cmp x5, x2
singly = bpos->bno / fs->blocks_per_block;
4003411c: b9004fe0 str w0, [sp, #76]
direct = bpos->bno % fs->blocks_per_block;
40034120: 9b038414 msub x20, x0, x3, x1
if (map->size.count <= fs->block_map_singly_blocks)
40034124: 54000389 b.ls 40034194 <rtems_rfs_block_map_find+0x124> // b.plast <== ALWAYS TAKEN
singly %= fs->blocks_per_block;
40034128: 9ac30801 udiv x1, x0, x3 <== NOT EXECUTED
if (map->size.count < fs->block_map_doubly_blocks)
4003412c: f9403aa2 ldr x2, [x21, #112] <== NOT EXECUTED
singly %= fs->blocks_per_block;
40034130: 9b038023 msub x3, x1, x3, x0 <== NOT EXECUTED
if (map->size.count < fs->block_map_doubly_blocks)
40034134: eb0200bf cmp x5, x2 <== NOT EXECUTED
singly %= fs->blocks_per_block;
40034138: b9004fe3 str w3, [sp, #76] <== NOT EXECUTED
rc = ENXIO;
4003413c: 528000c0 mov w0, #0x6 // #6 <== NOT EXECUTED
if (map->size.count < fs->block_map_doubly_blocks)
40034140: 54fffda2 b.cs 400340f4 <rtems_rfs_block_map_find+0x84> // b.hs, b.nlast<== NOT EXECUTED
rc = rtems_rfs_block_find_indirect (fs,
40034144: 8b010a62 add x2, x19, x1, lsl #2 <== NOT EXECUTED
40034148: 910133e4 add x4, sp, #0x4c <== NOT EXECUTED
4003414c: 91014261 add x1, x19, #0x50 <== NOT EXECUTED
40034150: aa1503e0 mov x0, x21 <== NOT EXECUTED
40034154: b9402c42 ldr w2, [x2, #44] <== NOT EXECUTED
40034158: 97fffe92 bl 40033ba0 <rtems_rfs_block_find_indirect> <== NOT EXECUTED
if (rc == 0)
4003415c: 35fffcc0 cbnz w0, 400340f4 <rtems_rfs_block_map_find+0x84> <== NOT EXECUTED
rc = rtems_rfs_block_find_indirect (fs,
40034160: b9404fe2 ldr w2, [sp, #76] <== NOT EXECUTED
40034164: 2a1403e3 mov w3, w20 <== NOT EXECUTED
40034168: aa1503e0 mov x0, x21 <== NOT EXECUTED
4003416c: aa1703e4 mov x4, x23 <== NOT EXECUTED
40034170: 91010261 add x1, x19, #0x40 <== NOT EXECUTED
40034174: 97fffe8b bl 40033ba0 <rtems_rfs_block_find_indirect> <== NOT EXECUTED
if (rc == 0)
40034178: 34fffb00 cbz w0, 400340d8 <rtems_rfs_block_map_find+0x68> <== NOT EXECUTED
4003417c: 17ffffde b 400340f4 <rtems_rfs_block_map_find+0x84> <== NOT EXECUTED
if ((bpos->bno == map->bpos.bno) && (map->bpos.block != 0))
40034180: b9402260 ldr w0, [x19, #32]
40034184: 35fffa80 cbnz w0, 400340d4 <rtems_rfs_block_map_find+0x64> <== NEVER TAKEN
if (map->size.count <= RTEMS_RFS_INODE_BLOCKS)
40034188: 710014bf cmp w5, #0x5
4003418c: 54fffbe8 b.hi 40034108 <rtems_rfs_block_map_find+0x98> // b.pmore <== NEVER TAKEN
40034190: 17ffffcf b 400340cc <rtems_rfs_block_map_find+0x5c>
rc = rtems_rfs_block_find_indirect (fs,
40034194: 8b000a62 add x2, x19, x0, lsl #2
40034198: 2a1403e3 mov w3, w20
4003419c: aa1503e0 mov x0, x21
400341a0: aa1703e4 mov x4, x23
400341a4: 91010261 add x1, x19, #0x40
400341a8: b9402c42 ldr w2, [x2, #44]
400341ac: 97fffe7d bl 40033ba0 <rtems_rfs_block_find_indirect>
if (rc == 0)
400341b0: 34fff940 cbz w0, 400340d8 <rtems_rfs_block_map_find+0x68> <== ALWAYS TAKEN
400341b4: 17ffffd0 b 400340f4 <rtems_rfs_block_map_find+0x84> <== NOT EXECUTED
...
0000000040034230 <rtems_rfs_block_map_grow>:
{
40034230: a9b87bfd stp x29, x30, [sp, #-128]!
40034234: 910003fd mov x29, sp
40034238: a90153f3 stp x19, x20, [sp, #16]
4003423c: aa0103f3 mov x19, x1
40034240: a9025bf5 stp x21, x22, [sp, #32]
40034244: aa0203f6 mov x22, x2
40034248: a90573fb stp x27, x28, [sp, #80]
4003424c: aa0003fc mov x28, x0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
40034250: d2840000 mov x0, #0x2000 // #8192
{
40034254: f90033e3 str x3, [sp, #96]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
40034258: 97ffd9fe bl 4002aa50 <rtems_rfs_trace>
4003425c: 72001c1f tst w0, #0xff
40034260: 54001941 b.ne 40034588 <rtems_rfs_block_map_grow+0x358> // b.any <== NEVER TAKEN
if ((map->size.count + blocks) >= rtems_rfs_fs_max_block_map_blocks (fs))
40034264: b9401260 ldr w0, [x19, #16]
return EFBIG;
40034268: 52800374 mov w20, #0x1b // #27
if ((map->size.count + blocks) >= rtems_rfs_fs_max_block_map_blocks (fs))
4003426c: f9403b81 ldr x1, [x28, #112]
40034270: 8b160000 add x0, x0, x22
40034274: eb01001f cmp x0, x1
40034278: 54001502 b.cs 40034518 <rtems_rfs_block_map_grow+0x2e8> // b.hs, b.nlast<== NEVER TAKEN
for (b = 0; b < blocks; b++)
4003427c: b4001976 cbz x22, 400345a8 <rtems_rfs_block_map_grow+0x378> <== NEVER TAKEN
rc = rtems_rfs_group_bitmap_alloc (fs, map->last_data_block,
40034280: b9402a61 ldr w1, [x19, #40]
40034284: d280001b mov x27, #0x0 // #0
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
40034288: 52800035 mov w21, #0x1 // #1
4003428c: a90363f7 stp x23, x24, [sp, #48]
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
40034290: 91010278 add x24, x19, #0x40
40034294: a9046bf9 stp x25, x26, [sp, #64]
rc = rtems_rfs_buffer_handle_request (fs,
40034298: 91014279 add x25, x19, #0x50
4003429c: 1400000e b 400342d4 <rtems_rfs_block_map_grow+0xa4>
map->blocks[map->size.count] = block;
400342a0: 8b224a60 add x0, x19, w2, uxtw #2
400342a4: b9407be1 ldr w1, [sp, #120]
400342a8: b9002c01 str w1, [x0, #44]
map->size.count++;
400342ac: 11000442 add w2, w2, #0x1
map->size.offset = 0;
400342b0: 29027e62 stp w2, wzr, [x19, #16]
if (b == 0)
400342b4: b500007b cbnz x27, 400342c0 <rtems_rfs_block_map_grow+0x90> <== NEVER TAKEN
*new_block = block;
400342b8: f94033e0 ldr x0, [sp, #96]
400342bc: b9000001 str w1, [x0]
map->dirty = true;
400342c0: 39000275 strb w21, [x19]
for (b = 0; b < blocks; b++)
400342c4: 9100077b add x27, x27, #0x1
map->last_data_block = block;
400342c8: b9002a61 str w1, [x19, #40]
for (b = 0; b < blocks; b++)
400342cc: eb1b02df cmp x22, x27
400342d0: 54001680 b.eq 400345a0 <rtems_rfs_block_map_grow+0x370> // b.none <== ALWAYS TAKEN
rc = rtems_rfs_group_bitmap_alloc (fs, map->last_data_block,
400342d4: 9101e3e3 add x3, sp, #0x78
400342d8: aa1c03e0 mov x0, x28
400342dc: 52800002 mov w2, #0x0 // #0
400342e0: 97ffd168 bl 40028880 <rtems_rfs_group_bitmap_alloc>
400342e4: 2a0003f4 mov w20, w0
if (rc > 0)
400342e8: 7100001f cmp w0, #0x0
400342ec: 540016cc b.gt 400345c4 <rtems_rfs_block_map_grow+0x394>
if (map->size.count < RTEMS_RFS_INODE_BLOCKS)
400342f0: b9401262 ldr w2, [x19, #16]
400342f4: 7100105f cmp w2, #0x4
400342f8: 54fffd49 b.ls 400342a0 <rtems_rfs_block_map_grow+0x70> // b.plast
if (map->size.count < fs->block_map_singly_blocks)
400342fc: a946039a ldp x26, x0, [x28, #96]
direct = map->size.count % fs->blocks_per_block;
40034300: 2a0203e1 mov w1, w2
40034304: 9ada0823 udiv x3, x1, x26
if (map->size.count < fs->block_map_singly_blocks)
40034308: eb00003f cmp x1, x0
direct = map->size.count % fs->blocks_per_block;
4003430c: 9b1a8477 msub x23, x3, x26, x1
if (map->size.count < fs->block_map_singly_blocks)
40034310: 54000522 b.cs 400343b4 <rtems_rfs_block_map_grow+0x184> // b.hs, b.nlast<== NEVER TAKEN
if ((direct == 0) ||
40034314: b4000097 cbz x23, 40034324 <rtems_rfs_block_map_grow+0xf4> <== NEVER TAKEN
((singly == 0) && (direct == RTEMS_RFS_INODE_BLOCKS)))
40034318: 7100007f cmp w3, #0x0
if ((direct == 0) ||
4003431c: 7a450ae0 ccmp w23, #0x5, #0x0, eq // eq = none
40034320: 54001081 b.ne 40034530 <rtems_rfs_block_map_grow+0x300> // b.any
upping = map->size.count == RTEMS_RFS_INODE_BLOCKS;
40034324: 7100145f cmp w2, #0x5
&map->blocks[singly],
40034328: 91002c63 add x3, x3, #0xb
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
4003432c: 1a9f17e4 cset w4, eq // eq = none
40034330: aa1803e2 mov x2, x24
40034334: 8b030a63 add x3, x19, x3, lsl #2
40034338: aa1303e1 mov x1, x19
4003433c: aa1c03e0 mov x0, x28
40034340: 97fffdb4 bl 40033a10 <rtems_rfs_block_map_indirect_alloc>
40034344: 2a0003f4 mov w20, w0
if (rc > 0)
40034348: 7100029f cmp w20, #0x0
4003434c: 54000dac b.gt 40034500 <rtems_rfs_block_map_grow+0x2d0> <== NEVER TAKEN
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
40034350: f9402660 ldr x0, [x19, #72]
40034354: d37ef6e1 lsl x1, x23, #2
40034358: 3941efe2 ldrb w2, [sp, #123]
4003435c: f9401c00 ldr x0, [x0, #56]
40034360: 38216802 strb w2, [x0, x1]
40034364: f9402660 ldr x0, [x19, #72]
40034368: 7940f7e2 ldrh w2, [sp, #122]
4003436c: f9401c00 ldr x0, [x0, #56]
40034370: 8b010000 add x0, x0, x1
40034374: 39000402 strb w2, [x0, #1]
40034378: f9402660 ldr x0, [x19, #72]
4003437c: b9407be2 ldr w2, [sp, #120]
40034380: f9401c00 ldr x0, [x0, #56]
40034384: 53087c42 lsr w2, w2, #8
40034388: 8b010000 add x0, x0, x1
4003438c: 39000802 strb w2, [x0, #2]
40034390: f9402660 ldr x0, [x19, #72]
40034394: b9407be2 ldr w2, [sp, #120]
40034398: f9401c00 ldr x0, [x0, #56]
4003439c: 8b010001 add x1, x0, x1
400343a0: 39000c22 strb w2, [x1, #3]
400343a4: 39010275 strb w21, [x19, #64]
map->size.count++;
400343a8: b9401262 ldr w2, [x19, #16]
*new_block = block;
400343ac: b9407be1 ldr w1, [sp, #120]
400343b0: 17ffffbf b 400342ac <rtems_rfs_block_map_grow+0x7c>
doubly = singly / fs->blocks_per_block;
400343b4: 9ada0866 udiv x6, x3, x26 <== NOT EXECUTED
singly %= fs->blocks_per_block;
400343b8: 9b1a8cda msub x26, x6, x26, x3 <== NOT EXECUTED
if (direct == 0)
400343bc: b5000697 cbnz x23, 4003448c <rtems_rfs_block_map_grow+0x25c> <== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
400343c0: 9101f3e3 add x3, sp, #0x7c <== NOT EXECUTED
400343c4: aa1803e2 mov x2, x24 <== NOT EXECUTED
400343c8: aa1303e1 mov x1, x19 <== NOT EXECUTED
400343cc: aa1c03e0 mov x0, x28 <== NOT EXECUTED
400343d0: 52800004 mov w4, #0x0 // #0 <== NOT EXECUTED
400343d4: f90037e6 str x6, [sp, #104] <== NOT EXECUTED
400343d8: 97fffd8e bl 40033a10 <rtems_rfs_block_map_indirect_alloc> <== NOT EXECUTED
400343dc: 2a0003f4 mov w20, w0 <== NOT EXECUTED
if (rc > 0)
400343e0: 7100001f cmp w0, #0x0 <== NOT EXECUTED
400343e4: f94037e6 ldr x6, [sp, #104] <== NOT EXECUTED
400343e8: 540008cc b.gt 40034500 <rtems_rfs_block_map_grow+0x2d0> <== NOT EXECUTED
if ((singly == 0) ||
400343ec: b400009a cbz x26, 400343fc <rtems_rfs_block_map_grow+0x1cc> <== NOT EXECUTED
((doubly == 0) && (singly == RTEMS_RFS_INODE_BLOCKS)))
400343f0: 710000df cmp w6, #0x0 <== NOT EXECUTED
if ((singly == 0) ||
400343f4: 7a450b40 ccmp w26, #0x5, #0x0, eq // eq = none <== NOT EXECUTED
400343f8: 54000ac1 b.ne 40034550 <rtems_rfs_block_map_grow+0x320> // b.any <== NOT EXECUTED
upping = map->size.count == fs->block_map_singly_blocks;
400343fc: f9403780 ldr x0, [x28, #104] <== NOT EXECUTED
&map->blocks[doubly],
40034400: 91002cc3 add x3, x6, #0xb <== NOT EXECUTED
upping = map->size.count == fs->block_map_singly_blocks;
40034404: b9401264 ldr w4, [x19, #16] <== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
40034408: aa1903e2 mov x2, x25 <== NOT EXECUTED
4003440c: 8b030a63 add x3, x19, x3, lsl #2 <== NOT EXECUTED
40034410: aa1303e1 mov x1, x19 <== NOT EXECUTED
upping = map->size.count == fs->block_map_singly_blocks;
40034414: eb00009f cmp x4, x0 <== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
40034418: aa1c03e0 mov x0, x28 <== NOT EXECUTED
4003441c: 1a9f17e4 cset w4, eq // eq = none <== NOT EXECUTED
40034420: 97fffd7c bl 40033a10 <rtems_rfs_block_map_indirect_alloc> <== NOT EXECUTED
40034424: 2a0003f4 mov w20, w0 <== NOT EXECUTED
if (rc > 0)
40034428: 7100001f cmp w0, #0x0 <== NOT EXECUTED
4003442c: 54000a4c b.gt 40034574 <rtems_rfs_block_map_grow+0x344> <== NOT EXECUTED
rtems_rfs_block_set_number (&map->doubly_buffer,
40034430: f9402e60 ldr x0, [x19, #88] <== NOT EXECUTED
40034434: d37ef75a lsl x26, x26, #2 <== NOT EXECUTED
40034438: 3941ffe1 ldrb w1, [sp, #127] <== NOT EXECUTED
4003443c: f9401c00 ldr x0, [x0, #56] <== NOT EXECUTED
40034440: 383a6801 strb w1, [x0, x26] <== NOT EXECUTED
40034444: f9402e60 ldr x0, [x19, #88] <== NOT EXECUTED
40034448: 7940ffe1 ldrh w1, [sp, #126] <== NOT EXECUTED
4003444c: f9401c00 ldr x0, [x0, #56] <== NOT EXECUTED
40034450: 8b1a0000 add x0, x0, x26 <== NOT EXECUTED
40034454: 39000401 strb w1, [x0, #1] <== NOT EXECUTED
40034458: f9402e60 ldr x0, [x19, #88] <== NOT EXECUTED
4003445c: b9407fe1 ldr w1, [sp, #124] <== NOT EXECUTED
40034460: f9401c00 ldr x0, [x0, #56] <== NOT EXECUTED
40034464: 53087c21 lsr w1, w1, #8 <== NOT EXECUTED
40034468: 8b1a0000 add x0, x0, x26 <== NOT EXECUTED
4003446c: 39000801 strb w1, [x0, #2] <== NOT EXECUTED
40034470: f9402e60 ldr x0, [x19, #88] <== NOT EXECUTED
40034474: b9407fe1 ldr w1, [sp, #124] <== NOT EXECUTED
40034478: f9401c00 ldr x0, [x0, #56] <== NOT EXECUTED
4003447c: 8b1a001a add x26, x0, x26 <== NOT EXECUTED
40034480: 39000f41 strb w1, [x26, #3] <== NOT EXECUTED
40034484: 39014275 strb w21, [x19, #80] <== NOT EXECUTED
40034488: 17ffffb2 b 40034350 <rtems_rfs_block_map_grow+0x120> <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs,
4003448c: 8b060a66 add x6, x19, x6, lsl #2 <== NOT EXECUTED
40034490: aa1903e1 mov x1, x25 <== NOT EXECUTED
40034494: aa1c03e0 mov x0, x28 <== NOT EXECUTED
40034498: 52800023 mov w3, #0x1 // #1 <== NOT EXECUTED
4003449c: b9402cc2 ldr w2, [x6, #44] <== NOT EXECUTED
400344a0: 97ffcacc bl 40026fd0 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
400344a4: 2a0003f4 mov w20, w0 <== NOT EXECUTED
if (rc > 0)
400344a8: 7100001f cmp w0, #0x0 <== NOT EXECUTED
400344ac: 540002ac b.gt 40034500 <rtems_rfs_block_map_grow+0x2d0> <== NOT EXECUTED
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
400344b0: f9402e62 ldr x2, [x19, #88] <== NOT EXECUTED
400344b4: d37ef75a lsl x26, x26, #2 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
400344b8: aa1803e1 mov x1, x24 <== NOT EXECUTED
400344bc: aa1c03e0 mov x0, x28 <== NOT EXECUTED
400344c0: 52800023 mov w3, #0x1 // #1 <== NOT EXECUTED
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
400344c4: f9401c42 ldr x2, [x2, #56] <== NOT EXECUTED
400344c8: 8b1a0047 add x7, x2, x26 <== NOT EXECUTED
400344cc: 387a6844 ldrb w4, [x2, x26] <== NOT EXECUTED
400344d0: 394008e6 ldrb w6, [x7, #2] <== NOT EXECUTED
400344d4: 39400ce8 ldrb w8, [x7, #3] <== NOT EXECUTED
400344d8: 394004e2 ldrb w2, [x7, #1] <== NOT EXECUTED
400344dc: 53185cc6 lsl w6, w6, #8 <== NOT EXECUTED
400344e0: 2a046104 orr w4, w8, w4, lsl #24 <== NOT EXECUTED
400344e4: 2a0240c2 orr w2, w6, w2, lsl #16 <== NOT EXECUTED
400344e8: 2a040042 orr w2, w2, w4 <== NOT EXECUTED
400344ec: b9007fe2 str w2, [sp, #124] <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
400344f0: 97ffcab8 bl 40026fd0 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
400344f4: 2a0003f4 mov w20, w0 <== NOT EXECUTED
if (rc > 0)
400344f8: 7100029f cmp w20, #0x0 <== NOT EXECUTED
400344fc: 54fff2ad b.le 40034350 <rtems_rfs_block_map_grow+0x120> <== NOT EXECUTED
rtems_rfs_group_bitmap_free (fs, false, block);
40034500: b9407be2 ldr w2, [sp, #120] <== NOT EXECUTED
40034504: aa1c03e0 mov x0, x28 <== NOT EXECUTED
40034508: 52800001 mov w1, #0x0 // #0 <== NOT EXECUTED
4003450c: 97ffd175 bl 40028ae0 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
return rc;
40034510: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
40034514: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
}
40034518: 2a1403e0 mov w0, w20 <== NOT EXECUTED
4003451c: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40034520: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
40034524: a94573fb ldp x27, x28, [sp, #80] <== NOT EXECUTED
40034528: a8c87bfd ldp x29, x30, [sp], #128 <== NOT EXECUTED
4003452c: d65f03c0 ret <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
40034530: 8b030a7a add x26, x19, x3, lsl #2
40034534: aa1803e1 mov x1, x24
40034538: aa1c03e0 mov x0, x28
4003453c: 52800023 mov w3, #0x1 // #1
40034540: b9402f42 ldr w2, [x26, #44]
40034544: 97ffcaa3 bl 40026fd0 <rtems_rfs_buffer_handle_request>
40034548: 2a0003f4 mov w20, w0
if (rc > 0)
4003454c: 17ffff7f b 40034348 <rtems_rfs_block_map_grow+0x118>
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
40034550: 8b060a66 add x6, x19, x6, lsl #2 <== NOT EXECUTED
40034554: aa1903e1 mov x1, x25 <== NOT EXECUTED
40034558: aa1c03e0 mov x0, x28 <== NOT EXECUTED
4003455c: 52800023 mov w3, #0x1 // #1 <== NOT EXECUTED
40034560: b9402cc2 ldr w2, [x6, #44] <== NOT EXECUTED
40034564: 97ffca9b bl 40026fd0 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
40034568: 2a0003f4 mov w20, w0 <== NOT EXECUTED
if (rc > 0)
4003456c: 7100001f cmp w0, #0x0 <== NOT EXECUTED
40034570: 54fff60d b.le 40034430 <rtems_rfs_block_map_grow+0x200> <== NOT EXECUTED
rtems_rfs_group_bitmap_free (fs, false, singly_block);
40034574: b9407fe2 ldr w2, [sp, #124] <== NOT EXECUTED
40034578: aa1c03e0 mov x0, x28 <== NOT EXECUTED
4003457c: 52800001 mov w1, #0x0 // #0 <== NOT EXECUTED
40034580: 97ffd158 bl 40028ae0 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
rtems_rfs_group_bitmap_free (fs, false, block);
40034584: 17ffffdf b 40034500 <rtems_rfs_block_map_grow+0x2d0> <== NOT EXECUTED
printf ("rtems-rfs: block-map-grow: entry: blocks=%zd count=%" PRIu32 "\n",
40034588: b9401262 ldr w2, [x19, #16] <== NOT EXECUTED
4003458c: aa1603e1 mov x1, x22 <== NOT EXECUTED
40034590: d00000a0 adrp x0, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
40034594: 91140000 add x0, x0, #0x500 <== NOT EXECUTED
40034598: 97ffb79e bl 40022410 <__wrap_printf> <== NOT EXECUTED
4003459c: 17ffff32 b 40034264 <rtems_rfs_block_map_grow+0x34> <== NOT EXECUTED
400345a0: a94363f7 ldp x23, x24, [sp, #48]
400345a4: a9446bf9 ldp x25, x26, [sp, #64]
return 0;
400345a8: 52800014 mov w20, #0x0 // #0
}
400345ac: 2a1403e0 mov w0, w20
400345b0: a94153f3 ldp x19, x20, [sp, #16]
400345b4: a9425bf5 ldp x21, x22, [sp, #32]
400345b8: a94573fb ldp x27, x28, [sp, #80]
400345bc: a8c87bfd ldp x29, x30, [sp], #128
400345c0: d65f03c0 ret
400345c4: 2a1403e0 mov w0, w20
400345c8: a94153f3 ldp x19, x20, [sp, #16]
400345cc: a9425bf5 ldp x21, x22, [sp, #32]
400345d0: a94363f7 ldp x23, x24, [sp, #48]
400345d4: a9446bf9 ldp x25, x26, [sp, #64]
400345d8: a94573fb ldp x27, x28, [sp, #80]
400345dc: a8c87bfd ldp x29, x30, [sp], #128
400345e0: d65f03c0 ret
...
0000000040033d00 <rtems_rfs_block_map_open>:
{
40033d00: a9bc7bfd stp x29, x30, [sp, #-64]!
40033d04: 910003fd mov x29, sp
40033d08: a90153f3 stp x19, x20, [sp, #16]
40033d0c: aa0203f3 mov x19, x2
40033d10: aa0103f4 mov x20, x1
40033d14: a9025bf5 stp x21, x22, [sp, #32]
40033d18: aa0003f6 mov x22, x0
40033d1c: a90363f7 stp x23, x24, [sp, #48]
handle->dirty = false;
40033d20: 91010058 add x24, x2, #0x40
40033d24: 91014057 add x23, x2, #0x50
map->dirty = false;
40033d28: 3900005f strb wzr, [x2]
* @param[in] size is a pointer to the block size.
*/
static inline void
rtems_rfs_block_set_size_zero (rtems_rfs_block_size* size)
{
size->count = 0;
40033d2c: a900fc5f stp xzr, xzr, [x2, #8]
bpos->bno = 0;
40033d30: f8018c5f str xzr, [x2, #24]!
bpos->block = 0;
40033d34: b900085f str wzr, [x2, #8]
40033d38: 3901027f strb wzr, [x19, #64]
handle->bnum = 0;
40033d3c: b900071f str wzr, [x24, #4]
handle->buffer = NULL;
40033d40: f900071f str xzr, [x24, #8]
handle->dirty = false;
40033d44: 3901427f strb wzr, [x19, #80]
handle->bnum = 0;
40033d48: b90006ff str wzr, [x23, #4]
handle->buffer = NULL;
40033d4c: f90006ff str xzr, [x23, #8]
rc = rtems_rfs_inode_load (fs, inode);
40033d50: 97ffd3cc bl 40028c80 <rtems_rfs_inode_load>
if (rc > 0)
40033d54: 7100001f cmp w0, #0x0
40033d58: 5400076c b.gt 40033e44 <rtems_rfs_block_map_open+0x144> <== NEVER TAKEN
map->inode = inode;
40033d5c: 9100b261 add x1, x19, #0x2c
40033d60: d2800004 mov x4, #0x0 // #0
40033d64: f9400e87 ldr x7, [x20, #24]
40033d68: f9000674 str x20, [x19, #8]
return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);
40033d6c: 8b0400e5 add x5, x7, x4
40033d70: 394070a8 ldrb w8, [x5, #28]
40033d74: 394074a6 ldrb w6, [x5, #29]
40033d78: 394078a2 ldrb w2, [x5, #30]
40033d7c: 39407ca3 ldrb w3, [x5, #31]
40033d80: aa062105 orr x5, x8, x6, lsl #8
40033d84: aa0240a2 orr x2, x5, x2, lsl #16
40033d88: aa036043 orr x3, x2, x3, lsl #24
40033d8c: 5ac00863 rev w3, w3
map->blocks[b] = rtems_rfs_inode_get_block (inode, b);
40033d90: b8246823 str w3, [x1, x4]
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
40033d94: 91001084 add x4, x4, #0x4
40033d98: f100509f cmp x4, #0x14
40033d9c: 54fffe81 b.ne 40033d6c <rtems_rfs_block_map_open+0x6c> // b.any
return rtems_rfs_read_u32 (&handle->node->block_count);
40033da0: 394030e6 ldrb w6, [x7, #12]
rc = rtems_rfs_inode_unload (fs, inode, false);
40033da4: aa1603e0 mov x0, x22
40033da8: 394034e5 ldrb w5, [x7, #13]
40033dac: aa1403e1 mov x1, x20
40033db0: 394038e4 ldrb w4, [x7, #14]
40033db4: 52800002 mov w2, #0x0 // #0
40033db8: 39403ce3 ldrb w3, [x7, #15]
40033dbc: aa0520c5 orr x5, x6, x5, lsl #8
40033dc0: aa0440a4 orr x4, x5, x4, lsl #16
40033dc4: aa036083 orr x3, x4, x3, lsl #24
40033dc8: 5ac00863 rev w3, w3
}
40033dcc: a9425bf5 ldp x21, x22, [sp, #32]
40033dd0: a94363f7 ldp x23, x24, [sp, #48]
map->size.count = rtems_rfs_inode_get_block_count (inode);
40033dd4: b9001263 str w3, [x19, #16]
map->size.offset = rtems_rfs_inode_get_block_offset (inode);
40033dd8: 394028e4 ldrb w4, [x7, #10]
40033ddc: 39402ce3 ldrb w3, [x7, #11]
40033de0: aa032083 orr x3, x4, x3, lsl #8
40033de4: 5ac00463 rev16 w3, w3
40033de8: 12003c63 and w3, w3, #0xffff
40033dec: b9001663 str w3, [x19, #20]
return rtems_rfs_read_u32 (&handle->node->last_map_block);
40033df0: 3940c0e6 ldrb w6, [x7, #48]
40033df4: 3940c4e5 ldrb w5, [x7, #49]
40033df8: 3940c8e4 ldrb w4, [x7, #50]
40033dfc: 3940cce3 ldrb w3, [x7, #51]
40033e00: aa0520c5 orr x5, x6, x5, lsl #8
40033e04: aa0440a4 orr x4, x5, x4, lsl #16
40033e08: aa036083 orr x3, x4, x3, lsl #24
40033e0c: 5ac00863 rev w3, w3
map->last_map_block = rtems_rfs_inode_get_last_map_block (inode);
40033e10: b9002663 str w3, [x19, #36]
return rtems_rfs_read_u32 (&handle->node->last_data_block);
40033e14: 3940d0e6 ldrb w6, [x7, #52]
40033e18: 3940d4e5 ldrb w5, [x7, #53]
40033e1c: 3940d8e4 ldrb w4, [x7, #54]
40033e20: 3940dce3 ldrb w3, [x7, #55]
40033e24: aa0520c5 orr x5, x6, x5, lsl #8
40033e28: aa0440a4 orr x4, x5, x4, lsl #16
40033e2c: aa036083 orr x3, x4, x3, lsl #24
40033e30: 5ac00863 rev w3, w3
map->last_data_block = rtems_rfs_inode_get_last_data_block (inode);
40033e34: b9002a63 str w3, [x19, #40]
}
40033e38: a94153f3 ldp x19, x20, [sp, #16]
40033e3c: a8c47bfd ldp x29, x30, [sp], #64
rc = rtems_rfs_inode_unload (fs, inode, false);
40033e40: 17ffd3f8 b 40028e20 <rtems_rfs_inode_unload>
40033e44: 2a0003f5 mov w21, w0 <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40033e48: aa1803e1 mov x1, x24 <== NOT EXECUTED
40033e4c: aa1603e0 mov x0, x22 <== NOT EXECUTED
40033e50: 97ffcd10 bl 40027290 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
40033e54: 3901027f strb wzr, [x19, #64] <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40033e58: aa1703e1 mov x1, x23 <== NOT EXECUTED
handle->bnum = 0;
40033e5c: b900071f str wzr, [x24, #4] <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40033e60: aa1603e0 mov x0, x22 <== NOT EXECUTED
handle->buffer = NULL;
40033e64: f900071f str xzr, [x24, #8] <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40033e68: 97ffcd0a bl 40027290 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
40033e6c: 3901427f strb wzr, [x19, #80] <== NOT EXECUTED
}
40033e70: 2a1503e0 mov w0, w21 <== NOT EXECUTED
40033e74: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40033e78: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
handle->bnum = 0;
40033e7c: b90006ff str wzr, [x23, #4] <== NOT EXECUTED
handle->buffer = NULL;
40033e80: f90006ff str xzr, [x23, #8] <== NOT EXECUTED
40033e84: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
40033e88: a8c47bfd ldp x29, x30, [sp], #64 <== NOT EXECUTED
40033e8c: d65f03c0 ret <== NOT EXECUTED
00000000400345f0 <rtems_rfs_block_map_shrink>:
int
rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks)
{
400345f0: a9b97bfd stp x29, x30, [sp, #-112]!
400345f4: 910003fd mov x29, sp
400345f8: a90153f3 stp x19, x20, [sp, #16]
400345fc: aa0203f3 mov x19, x2
40034600: a9046bf9 stp x25, x26, [sp, #64]
40034604: aa0103fa mov x26, x1
40034608: a90573fb stp x27, x28, [sp, #80]
4003460c: aa0003fb mov x27, x0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))
40034610: d2880000 mov x0, #0x4000 // #16384
40034614: 97ffd90f bl 4002aa50 <rtems_rfs_trace>
40034618: 72001c1f tst w0, #0xff
4003461c: 540012a1 b.ne 40034870 <rtems_rfs_block_map_shrink+0x280> // b.any <== NEVER TAKEN
printf ("rtems-rfs: block-map-shrink: entry: blocks=%zd count=%" PRIu32 "\n",
blocks, map->size.count);
if (map->size.count == 0)
40034620: b9401343 ldr w3, [x26, #16]
40034624: 340011a3 cbz w3, 40034858 <rtems_rfs_block_map_shrink+0x268>
return 0;
if (blocks > map->size.count)
40034628: 2a0303e1 mov w1, w3
4003462c: eb13003f cmp x1, x19
40034630: 9a939033 csel x19, x1, x19, ls // ls = plast
blocks = map->size.count;
while (blocks)
40034634: b40014f3 cbz x19, 400348d0 <rtems_rfs_block_map_shrink+0x2e0> <== NEVER TAKEN
rtems_rfs_block_no doubly_singly;
doubly = singly / fs->blocks_per_block;
doubly_singly = singly % fs->blocks_per_block;
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
40034638: 52800034 mov w20, #0x1 // #1
4003463c: a9025bf5 stp x21, x22, [sp, #32]
40034640: 91014356 add x22, x26, #0x50
doubly_singly);
/*
* Read the singly indirect table and get the block number.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
40034644: 91010355 add x21, x26, #0x40
40034648: a90363f7 stp x23, x24, [sp, #48]
4003464c: 14000011 b 40034690 <rtems_rfs_block_map_shrink+0xa0>
block_to_free = map->blocks[block];
40034650: 8b214b41 add x1, x26, w1, uxtw #2
40034654: b9402c3c ldr w28, [x1, #44]
map->blocks[block] = 0;
40034658: b9002c3f str wzr, [x1, #44]
{
rc = EIO;
break;
}
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
4003465c: 2a1c03e2 mov w2, w28
40034660: aa1b03e0 mov x0, x27
40034664: 52800001 mov w1, #0x0 // #0
40034668: 97ffd11e bl 40028ae0 <rtems_rfs_group_bitmap_free>
if (rc > 0)
4003466c: 7100001f cmp w0, #0x0
40034670: 540009ac b.gt 400347a4 <rtems_rfs_block_map_shrink+0x1b4> <== NEVER TAKEN
return rc;
map->size.count--;
40034674: b9401343 ldr w3, [x26, #16]
while (blocks)
40034678: f1000673 subs x19, x19, #0x1
map->size.offset = 0;
map->last_data_block = block_to_free;
map->dirty = true;
4003467c: 39000354 strb w20, [x26]
map->size.count--;
40034680: 51000463 sub w3, w3, #0x1
map->size.offset = 0;
40034684: 29027f43 stp w3, wzr, [x26, #16]
map->last_data_block = block_to_free;
40034688: b9002b5c str w28, [x26, #40]
while (blocks)
4003468c: 54000d20 b.eq 40034830 <rtems_rfs_block_map_shrink+0x240> // b.none
block = map->size.count - 1;
40034690: 51000461 sub w1, w3, #0x1
if (block < RTEMS_RFS_INODE_BLOCKS)
40034694: 7100103f cmp w1, #0x4
40034698: 54fffdc9 b.ls 40034650 <rtems_rfs_block_map_shrink+0x60> // b.plast
if (block < fs->block_map_singly_blocks)
4003469c: a9460377 ldp x23, x0, [x27, #96]
direct = block % fs->blocks_per_block;
400346a0: 9ad7083c udiv x28, x1, x23
if (block < fs->block_map_singly_blocks)
400346a4: eb00003f cmp x1, x0
direct = block % fs->blocks_per_block;
400346a8: 9b178798 msub x24, x28, x23, x1
if (block < fs->block_map_singly_blocks)
400346ac: 540008a3 b.cc 400347c0 <rtems_rfs_block_map_shrink+0x1d0> // b.lo, b.ul, b.last<== ALWAYS TAKEN
else if (block < fs->block_map_doubly_blocks)
400346b0: f9403b60 ldr x0, [x27, #112] <== NOT EXECUTED
400346b4: eb00003f cmp x1, x0 <== NOT EXECUTED
400346b8: 54000bc2 b.cs 40034830 <rtems_rfs_block_map_shrink+0x240> // b.hs, b.nlast<== NOT EXECUTED
doubly = singly / fs->blocks_per_block;
400346bc: 9ad70b99 udiv x25, x28, x23 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
400346c0: aa1603e1 mov x1, x22 <== NOT EXECUTED
400346c4: aa1b03e0 mov x0, x27 <== NOT EXECUTED
400346c8: 52800023 mov w3, #0x1 // #1 <== NOT EXECUTED
400346cc: 8b190b42 add x2, x26, x25, lsl #2 <== NOT EXECUTED
doubly_singly = singly % fs->blocks_per_block;
400346d0: 9b17f337 msub x23, x25, x23, x28 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
400346d4: b9402c42 ldr w2, [x2, #44] <== NOT EXECUTED
400346d8: 97ffca3e bl 40026fd0 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
400346dc: 7100001f cmp w0, #0x0 <== NOT EXECUTED
400346e0: 5400062c b.gt 400347a4 <rtems_rfs_block_map_shrink+0x1b4> <== NOT EXECUTED
singly = rtems_rfs_block_get_number (&map->doubly_buffer,
400346e4: f9402f44 ldr x4, [x26, #88] <== NOT EXECUTED
400346e8: d37ef6e2 lsl x2, x23, #2 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
400346ec: aa1503e1 mov x1, x21 <== NOT EXECUTED
400346f0: aa1b03e0 mov x0, x27 <== NOT EXECUTED
400346f4: 52800023 mov w3, #0x1 // #1 <== NOT EXECUTED
singly = rtems_rfs_block_get_number (&map->doubly_buffer,
400346f8: f9401c84 ldr x4, [x4, #56] <== NOT EXECUTED
400346fc: 8b020085 add x5, x4, x2 <== NOT EXECUTED
40034700: 38626882 ldrb w2, [x4, x2] <== NOT EXECUTED
40034704: 394008a6 ldrb w6, [x5, #2] <== NOT EXECUTED
40034708: 39400ca4 ldrb w4, [x5, #3] <== NOT EXECUTED
4003470c: 394004a5 ldrb w5, [x5, #1] <== NOT EXECUTED
40034710: 53185cc6 lsl w6, w6, #8 <== NOT EXECUTED
40034714: 2a026084 orr w4, w4, w2, lsl #24 <== NOT EXECUTED
40034718: 2a0540c2 orr w2, w6, w5, lsl #16 <== NOT EXECUTED
4003471c: 2a040042 orr w2, w2, w4 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
40034720: b9006fe2 str w2, [sp, #108] <== NOT EXECUTED
40034724: 97ffca2b bl 40026fd0 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
40034728: 7100001f cmp w0, #0x0 <== NOT EXECUTED
4003472c: 540003cc b.gt 400347a4 <rtems_rfs_block_map_shrink+0x1b4> <== NOT EXECUTED
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
40034730: f9402741 ldr x1, [x26, #72] <== NOT EXECUTED
40034734: d37ef700 lsl x0, x24, #2 <== NOT EXECUTED
if (direct == 0)
40034738: b9406fe2 ldr w2, [sp, #108] <== NOT EXECUTED
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
4003473c: f9401c21 ldr x1, [x1, #56] <== NOT EXECUTED
40034740: 8b000023 add x3, x1, x0 <== NOT EXECUTED
40034744: 38606820 ldrb w0, [x1, x0] <== NOT EXECUTED
40034748: 39400861 ldrb w1, [x3, #2] <== NOT EXECUTED
4003474c: 39400c64 ldrb w4, [x3, #3] <== NOT EXECUTED
40034750: 3940047c ldrb w28, [x3, #1] <== NOT EXECUTED
40034754: 53185c21 lsl w1, w1, #8 <== NOT EXECUTED
40034758: 2a006080 orr w0, w4, w0, lsl #24 <== NOT EXECUTED
4003475c: 2a1c403c orr w28, w1, w28, lsl #16 <== NOT EXECUTED
40034760: 2a00039c orr w28, w28, w0 <== NOT EXECUTED
if (direct == 0)
40034764: b5fff7d8 cbnz x24, 4003465c <rtems_rfs_block_map_shrink+0x6c> <== NOT EXECUTED
rc = rtems_rfs_group_bitmap_free (fs, false, singly);
40034768: aa1b03e0 mov x0, x27 <== NOT EXECUTED
4003476c: 52800001 mov w1, #0x0 // #0 <== NOT EXECUTED
40034770: b9006fe2 str w2, [sp, #108] <== NOT EXECUTED
40034774: 97ffd0db bl 40028ae0 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
if (rc > 0)
40034778: 7100001f cmp w0, #0x0 <== NOT EXECUTED
4003477c: 5400014c b.gt 400347a4 <rtems_rfs_block_map_shrink+0x1b4> <== NOT EXECUTED
map->last_map_block = singly;
40034780: b9406fe2 ldr w2, [sp, #108] <== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->doubly_buffer,
40034784: 2a1703e4 mov w4, w23 <== NOT EXECUTED
map->last_map_block = singly;
40034788: b9002742 str w2, [x26, #36] <== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->doubly_buffer,
4003478c: 2a1903e3 mov w3, w25 <== NOT EXECUTED
40034790: aa1a03e1 mov x1, x26 <== NOT EXECUTED
40034794: aa1b03e0 mov x0, x27 <== NOT EXECUTED
40034798: aa1603e2 mov x2, x22 <== NOT EXECUTED
4003479c: 97fffc6d bl 40033950 <rtems_rfs_block_map_indirect_shrink> <== NOT EXECUTED
if (rc)
400347a0: 34fff5e0 cbz w0, 4003465c <rtems_rfs_block_map_shrink+0x6c> <== NOT EXECUTED
*/
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
return 0;
}
400347a4: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
400347a8: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
400347ac: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
400347b0: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
400347b4: a94573fb ldp x27, x28, [sp, #80] <== NOT EXECUTED
400347b8: a8c77bfd ldp x29, x30, [sp], #112 <== NOT EXECUTED
400347bc: d65f03c0 ret <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
400347c0: 8b1c0b42 add x2, x26, x28, lsl #2
400347c4: aa1503e1 mov x1, x21
400347c8: aa1b03e0 mov x0, x27
400347cc: 52800023 mov w3, #0x1 // #1
400347d0: b9402c42 ldr w2, [x2, #44]
400347d4: 97ffc9ff bl 40026fd0 <rtems_rfs_buffer_handle_request>
if (rc > 0)
400347d8: 7100001f cmp w0, #0x0
400347dc: 54fffe4c b.gt 400347a4 <rtems_rfs_block_map_shrink+0x1b4> <== NEVER TAKEN
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
400347e0: f9402740 ldr x0, [x26, #72]
400347e4: d37ef705 lsl x5, x24, #2
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
400347e8: 2a1c03e3 mov w3, w28
400347ec: 2a1803e4 mov w4, w24
400347f0: aa1503e2 mov x2, x21
400347f4: aa1a03e1 mov x1, x26
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
400347f8: f9401c06 ldr x6, [x0, #56]
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
400347fc: aa1b03e0 mov x0, x27
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
40034800: 8b0500c7 add x7, x6, x5
40034804: 386568c5 ldrb w5, [x6, x5]
40034808: 39400ce8 ldrb w8, [x7, #3]
4003480c: 394008e6 ldrb w6, [x7, #2]
40034810: 394004fc ldrb w28, [x7, #1]
40034814: 2a056105 orr w5, w8, w5, lsl #24
40034818: 53185cc6 lsl w6, w6, #8
4003481c: 2a1c40dc orr w28, w6, w28, lsl #16
40034820: 2a05039c orr w28, w28, w5
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
40034824: 97fffc4b bl 40033950 <rtems_rfs_block_map_indirect_shrink>
if (rc)
40034828: 34fff1a0 cbz w0, 4003465c <rtems_rfs_block_map_shrink+0x6c> <== ALWAYS TAKEN
4003482c: 17ffffde b 400347a4 <rtems_rfs_block_map_shrink+0x1b4> <== NOT EXECUTED
if (map->size.count == 0)
40034830: 340002c3 cbz w3, 40034888 <rtems_rfs_block_map_shrink+0x298> <== ALWAYS TAKEN
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
40034834: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
40034838: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
4003483c: b9401b40 ldr w0, [x26, #24] <== NOT EXECUTED
40034840: 6b03001f cmp w0, w3 <== NOT EXECUTED
40034844: 54000422 b.cs 400348c8 <rtems_rfs_block_map_shrink+0x2d8> // b.hs, b.nlast<== NOT EXECUTED
40034848: 51000461 sub w1, w3, #0x1 <== NOT EXECUTED
4003484c: 6b00003f cmp w1, w0 <== NOT EXECUTED
40034850: 54000320 b.eq 400348b4 <rtems_rfs_block_map_shrink+0x2c4> // b.none<== NOT EXECUTED
40034854: d503201f nop <== NOT EXECUTED
return 0;
40034858: 52800000 mov w0, #0x0 // #0
}
4003485c: a94153f3 ldp x19, x20, [sp, #16]
40034860: a9446bf9 ldp x25, x26, [sp, #64]
40034864: a94573fb ldp x27, x28, [sp, #80]
40034868: a8c77bfd ldp x29, x30, [sp], #112
4003486c: d65f03c0 ret
printf ("rtems-rfs: block-map-shrink: entry: blocks=%zd count=%" PRIu32 "\n",
40034870: b9401342 ldr w2, [x26, #16] <== NOT EXECUTED
40034874: aa1303e1 mov x1, x19 <== NOT EXECUTED
40034878: d00000a0 adrp x0, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
4003487c: 9114e000 add x0, x0, #0x538 <== NOT EXECUTED
40034880: 97ffb6e4 bl 40022410 <__wrap_printf> <== NOT EXECUTED
40034884: 17ffff67 b 40034620 <rtems_rfs_block_map_shrink+0x30> <== NOT EXECUTED
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
40034888: b9401740 ldr w0, [x26, #20]
4003488c: a9425bf5 ldp x21, x22, [sp, #32]
40034890: a94363f7 ldp x23, x24, [sp, #48]
map->last_data_block = 0;
40034894: 2904ff5f stp wzr, wzr, [x26, #36]
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
40034898: 29030343 stp w3, w0, [x26, #24]
4003489c: b900235f str wzr, [x26, #32]
400348a0: 34fffdc0 cbz w0, 40034858 <rtems_rfs_block_map_shrink+0x268> <== ALWAYS TAKEN
400348a4: 51000463 sub w3, w3, #0x1 <== NOT EXECUTED
return 0;
400348a8: 52800000 mov w0, #0x0 // #0 <== NOT EXECUTED
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
400348ac: b9001b43 str w3, [x26, #24] <== NOT EXECUTED
400348b0: 17ffffeb b 4003485c <rtems_rfs_block_map_shrink+0x26c> <== NOT EXECUTED
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
400348b4: b9401740 ldr w0, [x26, #20] <== NOT EXECUTED
400348b8: b9401f41 ldr w1, [x26, #28] <== NOT EXECUTED
400348bc: 6b00003f cmp w1, w0 <== NOT EXECUTED
400348c0: 54fffcc9 b.ls 40034858 <rtems_rfs_block_map_shrink+0x268> // b.plast<== NOT EXECUTED
400348c4: 17fffff5 b 40034898 <rtems_rfs_block_map_shrink+0x2a8> <== NOT EXECUTED
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
400348c8: b9401740 ldr w0, [x26, #20] <== NOT EXECUTED
400348cc: 17fffff3 b 40034898 <rtems_rfs_block_map_shrink+0x2a8> <== NOT EXECUTED
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
400348d0: b9401b40 ldr w0, [x26, #24] <== NOT EXECUTED
400348d4: 17ffffdb b 40034840 <rtems_rfs_block_map_shrink+0x250> <== NOT EXECUTED
...
0000000040034940 <rtems_rfs_buffer_bdbuf_release>:
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
40034940: a9be7bfd stp x29, x30, [sp, #-32]!
40034944: 910003fd mov x29, sp
40034948: a90153f3 stp x19, x20, [sp, #16]
4003494c: 12001c34 and w20, w1, #0xff
40034950: aa0003f3 mov x19, x0
rtems_status_code sc;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
40034954: d2800800 mov x0, #0x40 // #64
40034958: 97ffd83e bl 4002aa50 <rtems_rfs_trace>
4003495c: 72001c1f tst w0, #0xff
40034960: 54000180 b.eq 40034990 <rtems_rfs_buffer_bdbuf_release+0x50> // b.none<== ALWAYS TAKEN
printf ("rtems-rfs: bdbuf-release: block=%" PRIuPTR " bdbuf=%" PRIu32 " %s\n",
40034964: b9403262 ldr w2, [x19, #48] <== NOT EXECUTED
40034968: 7100029f cmp w20, #0x0 <== NOT EXECUTED
4003496c: f9402e61 ldr x1, [x19, #88] <== NOT EXECUTED
40034970: d00000a4 adrp x4, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
40034974: 9115e084 add x4, x4, #0x578 <== NOT EXECUTED
40034978: f0000083 adrp x3, 40047000 <write+0xc0> <== NOT EXECUTED
4003497c: 912fa063 add x3, x3, #0xbe8 <== NOT EXECUTED
40034980: d00000a0 adrp x0, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
40034984: 9a831083 csel x3, x4, x3, ne // ne = any <== NOT EXECUTED
40034988: 91162000 add x0, x0, #0x588 <== NOT EXECUTED
4003498c: 97ffb6a1 bl 40022410 <__wrap_printf> <== NOT EXECUTED
((intptr_t) buffer->user),
buffer->block, modified ? "(modified)" : "");
if (modified)
sc = rtems_bdbuf_release_modified (buffer);
40034990: aa1303e0 mov x0, x19
if (modified)
40034994: 34000114 cbz w20, 400349b4 <rtems_rfs_buffer_bdbuf_release+0x74>
sc = rtems_bdbuf_release_modified (buffer);
40034998: 97fff452 bl 40031ae0 <rtems_bdbuf_release_modified>
#if RTEMS_RFS_BUFFER_ERRORS
printf ("rtems-rfs: buffer-release: bdbuf-%s: %s(%d)\n",
modified ? "modified" : "not-modified",
rtems_status_text (sc), sc);
#endif
rc = EIO;
4003499c: 7100001f cmp w0, #0x0
400349a0: 528000a0 mov w0, #0x5 // #5
}
return rc;
}
400349a4: 1a9f1000 csel w0, w0, wzr, ne // ne = any
400349a8: a94153f3 ldp x19, x20, [sp, #16]
400349ac: a8c27bfd ldp x29, x30, [sp], #32
400349b0: d65f03c0 ret
sc = rtems_bdbuf_release (buffer);
400349b4: 97fff40b bl 400319e0 <rtems_bdbuf_release>
rc = EIO;
400349b8: 7100001f cmp w0, #0x0
400349bc: 528000a0 mov w0, #0x5 // #5
}
400349c0: 1a9f1000 csel w0, w0, wzr, ne // ne = any
400349c4: a94153f3 ldp x19, x20, [sp, #16]
400349c8: a8c27bfd ldp x29, x30, [sp], #32
400349cc: d65f03c0 ret
00000000400276b0 <rtems_rfs_buffer_close>:
{
400276b0: a9be7bfd stp x29, x30, [sp, #-32]!
400276b4: 910003fd mov x29, sp
400276b8: a90153f3 stp x19, x20, [sp, #16]
400276bc: aa0003f3 mov x19, x0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
400276c0: d2800200 mov x0, #0x10 // #16
400276c4: 94000ce3 bl 4002aa50 <rtems_rfs_trace>
400276c8: 72001c1f tst w0, #0xff
400276cc: 54000581 b.ne 4002777c <rtems_rfs_buffer_close+0xcc> // b.any <== NEVER TAKEN
rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_media_block_size (fs));
400276d0: f9401261 ldr x1, [x19, #32]
400276d4: aa1303e0 mov x0, x19
400276d8: b9402c21 ldr w1, [x1, #44]
400276dc: 97ffffa9 bl 40027580 <rtems_rfs_buffer_setblksize>
400276e0: 2a0003f4 mov w20, w0
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
400276e4: 7100001f cmp w0, #0x0
400276e8: 5400010c b.gt 40027708 <rtems_rfs_buffer_close+0x58> <== NEVER TAKEN
if (close (fs->device) < 0)
400276ec: b9401a60 ldr w0, [x19, #24]
400276f0: 94002be4 bl 40032680 <close>
400276f4: 37f80260 tbnz w0, #31, 40027740 <rtems_rfs_buffer_close+0x90> <== NEVER TAKEN
}
400276f8: 2a1403e0 mov w0, w20
400276fc: a94153f3 ldp x19, x20, [sp, #16]
40027700: a8c27bfd ldp x29, x30, [sp], #32
40027704: d65f03c0 ret
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
40027708: d2800200 mov x0, #0x10 // #16 <== NOT EXECUTED
4002770c: 94000cd1 bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
40027710: 72001c1f tst w0, #0xff <== NOT EXECUTED
40027714: 54fffec0 b.eq 400276ec <rtems_rfs_buffer_close+0x3c> // b.none <== NOT EXECUTED
printf ("rtems-rfs: buffer-close: set media block size failed: %d: %s\n",
40027718: 2a1403e0 mov w0, w20 <== NOT EXECUTED
4002771c: 94005d40 bl 4003ec1c <strerror> <== NOT EXECUTED
40027720: b0000101 adrp x1, 40048000 <_Scheduler_Table+0x60> <== NOT EXECUTED
40027724: aa0003e2 mov x2, x0 <== NOT EXECUTED
40027728: 913a8020 add x0, x1, #0xea0 <== NOT EXECUTED
4002772c: 2a1403e1 mov w1, w20 <== NOT EXECUTED
40027730: 97ffeb38 bl 40022410 <__wrap_printf> <== NOT EXECUTED
if (close (fs->device) < 0)
40027734: b9401a60 ldr w0, [x19, #24] <== NOT EXECUTED
40027738: 94002bd2 bl 40032680 <close> <== NOT EXECUTED
4002773c: 36fffde0 tbz w0, #31, 400276f8 <rtems_rfs_buffer_close+0x48> <== NOT EXECUTED
rc = errno;
40027740: 94005853 bl 4003d88c <__errno> <== NOT EXECUTED
40027744: aa0003e1 mov x1, x0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
40027748: d2800200 mov x0, #0x10 // #16 <== NOT EXECUTED
rc = errno;
4002774c: b9400034 ldr w20, [x1] <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
40027750: 94000cc0 bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
40027754: 72001c1f tst w0, #0xff <== NOT EXECUTED
40027758: 54fffd00 b.eq 400276f8 <rtems_rfs_buffer_close+0x48> // b.none <== NOT EXECUTED
printf ("rtems-rfs: buffer-close: file close failed: %d: %s\n",
4002775c: 2a1403e0 mov w0, w20 <== NOT EXECUTED
40027760: 94005d2f bl 4003ec1c <strerror> <== NOT EXECUTED
40027764: b0000101 adrp x1, 40048000 <_Scheduler_Table+0x60> <== NOT EXECUTED
40027768: aa0003e2 mov x2, x0 <== NOT EXECUTED
4002776c: 913b8020 add x0, x1, #0xee0 <== NOT EXECUTED
40027770: 2a1403e1 mov w1, w20 <== NOT EXECUTED
40027774: 97ffeb27 bl 40022410 <__wrap_printf> <== NOT EXECUTED
return rc;
40027778: 17ffffe0 b 400276f8 <rtems_rfs_buffer_close+0x48> <== NOT EXECUTED
printf ("rtems-rfs: buffer-close: closing\n");
4002777c: b0000100 adrp x0, 40048000 <_Scheduler_Table+0x60> <== NOT EXECUTED
40027780: 9139e000 add x0, x0, #0xe78 <== NOT EXECUTED
40027784: 97ffeb47 bl 400224a0 <__wrap_puts> <== NOT EXECUTED
40027788: 17ffffd2 b 400276d0 <rtems_rfs_buffer_close+0x20> <== NOT EXECUTED
4002778c: 00000000 udf #0
0000000040026db0 <rtems_rfs_buffer_handle_release.part.0>:
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
40026db0: a9be7bfd stp x29, x30, [sp, #-32]! <== NOT EXECUTED
40026db4: 910003fd mov x29, sp <== NOT EXECUTED
40026db8: a90153f3 stp x19, x20, [sp, #16] <== NOT EXECUTED
40026dbc: aa0003f3 mov x19, x0 <== NOT EXECUTED
40026dc0: aa0103f4 mov x20, x1 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
40026dc4: d2804000 mov x0, #0x200 // #512 <== NOT EXECUTED
40026dc8: 94000f22 bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
40026dcc: 72001c1f tst w0, #0xff <== NOT EXECUTED
40026dd0: 54000240 b.eq 40026e18 <rtems_rfs_buffer_handle_release.part.0+0x68> // b.none<== NOT EXECUTED
printf ("rtems-rfs: buffer-release: block=%" PRIu32 " %s refs=%d %s\n",
40026dd4: f9400683 ldr x3, [x20, #8] <== NOT EXECUTED
40026dd8: b0000100 adrp x0, 40047000 <write+0xc0> <== NOT EXECUTED
40026ddc: 912fa000 add x0, x0, #0xbe8 <== NOT EXECUTED
40026de0: 39400281 ldrb w1, [x20] <== NOT EXECUTED
40026de4: d0000102 adrp x2, 40048000 <_Scheduler_Table+0x60> <== NOT EXECUTED
40026de8: 9129a042 add x2, x2, #0xa68 <== NOT EXECUTED
40026dec: b9405463 ldr w3, [x3, #84] <== NOT EXECUTED
40026df0: 7100003f cmp w1, #0x0 <== NOT EXECUTED
40026df4: b9400681 ldr w1, [x20, #4] <== NOT EXECUTED
40026df8: 9a801042 csel x2, x2, x0, ne // ne = any <== NOT EXECUTED
40026dfc: 7100007f cmp w3, #0x0 <== NOT EXECUTED
40026e00: d0000104 adrp x4, 40048000 <_Scheduler_Table+0x60> <== NOT EXECUTED
40026e04: 9129c084 add x4, x4, #0xa70 <== NOT EXECUTED
40026e08: 9a800084 csel x4, x4, x0, eq // eq = none <== NOT EXECUTED
40026e0c: d0000100 adrp x0, 40048000 <_Scheduler_Table+0x60> <== NOT EXECUTED
40026e10: 912a0000 add x0, x0, #0xa80 <== NOT EXECUTED
40026e14: 97ffed7f bl 40022410 <__wrap_printf> <== NOT EXECUTED
if (rtems_rfs_buffer_refs (handle) > 0)
40026e18: f9400682 ldr x2, [x20, #8] <== NOT EXECUTED
40026e1c: b9405440 ldr w0, [x2, #84] <== NOT EXECUTED
40026e20: 7100001f cmp w0, #0x0 <== NOT EXECUTED
40026e24: 5400006d b.le 40026e30 <rtems_rfs_buffer_handle_release.part.0+0x80><== NOT EXECUTED
rtems_rfs_buffer_refs_down (handle);
40026e28: 51000400 sub w0, w0, #0x1 <== NOT EXECUTED
40026e2c: b9005440 str w0, [x2, #84] <== NOT EXECUTED
if (rtems_rfs_buffer_refs (handle) == 0)
40026e30: 350003c0 cbnz w0, 40026ea8 <rtems_rfs_buffer_handle_release.part.0+0xf8><== NOT EXECUTED
previous = the_node->previous;
40026e34: a9400c44 ldp x4, x3, [x2] <== NOT EXECUTED
fs->buffers_count--;
40026e38: b9409a61 ldr w1, [x19, #152] <== NOT EXECUTED
if (rtems_rfs_fs_no_local_cache (fs))
40026e3c: b9400265 ldr w5, [x19] <== NOT EXECUTED
next->previous = previous;
40026e40: f9000483 str x3, [x4, #8] <== NOT EXECUTED
fs->buffers_count--;
40026e44: 51000421 sub w1, w1, #0x1 <== NOT EXECUTED
previous->next = next;
40026e48: f9000064 str x4, [x3] <== NOT EXECUTED
40026e4c: b9009a61 str w1, [x19, #152] <== NOT EXECUTED
if (rtems_rfs_fs_no_local_cache (fs))
40026e50: 37080505 tbnz w5, #1, 40026ef0 <rtems_rfs_buffer_handle_release.part.0+0x140><== NOT EXECUTED
if ((fs->release_count +
40026e54: b940ba61 ldr w1, [x19, #184] <== NOT EXECUTED
40026e58: b940da64 ldr w4, [x19, #216] <== NOT EXECUTED
40026e5c: b9407a63 ldr w3, [x19, #120] <== NOT EXECUTED
40026e60: 0b040021 add w1, w1, w4 <== NOT EXECUTED
40026e64: 6b03003f cmp w1, w3 <== NOT EXECUTED
40026e68: 54000542 b.cs 40026f10 <rtems_rfs_buffer_handle_release.part.0+0x160> // b.hs, b.nlast<== NOT EXECUTED
if (rtems_rfs_buffer_dirty (handle))
40026e6c: 39400281 ldrb w1, [x20] <== NOT EXECUTED
40026e70: 34000261 cbz w1, 40026ebc <rtems_rfs_buffer_handle_release.part.0+0x10c><== NOT EXECUTED
old_last = tail->previous;
40026e74: f9406a64 ldr x4, [x19, #208] <== NOT EXECUTED
40026e78: 91032263 add x3, x19, #0xc8 <== NOT EXECUTED
fs->release_modified_count++;
40026e7c: b940da61 ldr w1, [x19, #216] <== NOT EXECUTED
the_node->next = tail;
40026e80: f9000043 str x3, [x2] <== NOT EXECUTED
tail->previous = the_node;
40026e84: f9006a62 str x2, [x19, #208] <== NOT EXECUTED
40026e88: 11000421 add w1, w1, #0x1 <== NOT EXECUTED
old_last->next = the_node;
40026e8c: f9000082 str x2, [x4] <== NOT EXECUTED
the_node->previous = old_last;
40026e90: f9000444 str x4, [x2, #8] <== NOT EXECUTED
40026e94: b900da61 str w1, [x19, #216] <== NOT EXECUTED
handle->buffer = NULL;
40026e98: f900069f str xzr, [x20, #8] <== NOT EXECUTED
}
40026e9c: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40026ea0: a8c27bfd ldp x29, x30, [sp], #32 <== NOT EXECUTED
40026ea4: d65f03c0 ret <== NOT EXECUTED
handle->buffer = NULL;
40026ea8: f900069f str xzr, [x20, #8] <== NOT EXECUTED
int rc = 0;
40026eac: 52800000 mov w0, #0x0 // #0 <== NOT EXECUTED
}
40026eb0: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40026eb4: a8c27bfd ldp x29, x30, [sp], #32 <== NOT EXECUTED
40026eb8: d65f03c0 ret <== NOT EXECUTED
old_last = tail->previous;
40026ebc: f9405a64 ldr x4, [x19, #176] <== NOT EXECUTED
40026ec0: 9102a263 add x3, x19, #0xa8 <== NOT EXECUTED
fs->release_count++;
40026ec4: b940ba61 ldr w1, [x19, #184] <== NOT EXECUTED
the_node->next = tail;
40026ec8: f9000043 str x3, [x2] <== NOT EXECUTED
tail->previous = the_node;
40026ecc: f9005a62 str x2, [x19, #176] <== NOT EXECUTED
40026ed0: 11000421 add w1, w1, #0x1 <== NOT EXECUTED
old_last->next = the_node;
40026ed4: f9000082 str x2, [x4] <== NOT EXECUTED
the_node->previous = old_last;
40026ed8: f9000444 str x4, [x2, #8] <== NOT EXECUTED
40026edc: b900ba61 str w1, [x19, #184] <== NOT EXECUTED
handle->buffer = NULL;
40026ee0: f900069f str xzr, [x20, #8] <== NOT EXECUTED
}
40026ee4: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40026ee8: a8c27bfd ldp x29, x30, [sp], #32 <== NOT EXECUTED
40026eec: d65f03c0 ret <== NOT EXECUTED
rc = rtems_rfs_buffer_io_release (handle->buffer,
40026ef0: 39400281 ldrb w1, [x20] <== NOT EXECUTED
40026ef4: aa0203e0 mov x0, x2 <== NOT EXECUTED
handle->buffer->user = (void*) 0;
40026ef8: f9002c5f str xzr, [x2, #88] <== NOT EXECUTED
rc = rtems_rfs_buffer_io_release (handle->buffer,
40026efc: 94003691 bl 40034940 <rtems_rfs_buffer_bdbuf_release> <== NOT EXECUTED
handle->buffer = NULL;
40026f00: f900069f str xzr, [x20, #8] <== NOT EXECUTED
}
40026f04: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40026f08: a8c27bfd ldp x29, x30, [sp], #32 <== NOT EXECUTED
40026f0c: d65f03c0 ret <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
40026f10: d2804000 mov x0, #0x200 // #512 <== NOT EXECUTED
40026f14: 94000ecf bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
40026f18: 72001c1f tst w0, #0xff <== NOT EXECUTED
40026f1c: 54000481 b.ne 40026fac <rtems_rfs_buffer_handle_release.part.0+0x1fc> // b.any<== NOT EXECUTED
if (fs->release_count > fs->release_modified_count)
40026f20: b940ba62 ldr w2, [x19, #184] <== NOT EXECUTED
40026f24: b940da61 ldr w1, [x19, #216] <== NOT EXECUTED
40026f28: 6b01005f cmp w2, w1 <== NOT EXECUTED
40026f2c: 540001a9 b.ls 40026f60 <rtems_rfs_buffer_handle_release.part.0+0x1b0> // b.plast<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
40026f30: f9405260 ldr x0, [x19, #160] <== NOT EXECUTED
return &the_chain->Tail.Node;
40026f34: 9102a261 add x1, x19, #0xa8 <== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
40026f38: 91028263 add x3, x19, #0xa0 <== NOT EXECUTED
if ( !_Chain_Is_empty(the_chain))
40026f3c: eb01001f cmp x0, x1 <== NOT EXECUTED
40026f40: 540002e0 b.eq 40026f9c <rtems_rfs_buffer_handle_release.part.0+0x1ec> // b.none<== NOT EXECUTED
new_first = old_first->next;
40026f44: f9400001 ldr x1, [x0] <== NOT EXECUTED
head->next = new_first;
40026f48: f9005261 str x1, [x19, #160] <== NOT EXECUTED
new_first->previous = head;
40026f4c: f9000423 str x3, [x1, #8] <== NOT EXECUTED
fs->release_count--;
40026f50: 51000442 sub w2, w2, #0x1 <== NOT EXECUTED
modified = false;
40026f54: 52800001 mov w1, #0x0 // #0 <== NOT EXECUTED
fs->release_count--;
40026f58: b900ba62 str w2, [x19, #184] <== NOT EXECUTED
modified = false;
40026f5c: 1400000c b 40026f8c <rtems_rfs_buffer_handle_release.part.0+0x1dc> <== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
40026f60: f9406260 ldr x0, [x19, #192] <== NOT EXECUTED
return &the_chain->Tail.Node;
40026f64: 91032262 add x2, x19, #0xc8 <== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
40026f68: 91030263 add x3, x19, #0xc0 <== NOT EXECUTED
if ( !_Chain_Is_empty(the_chain))
40026f6c: eb02001f cmp x0, x2 <== NOT EXECUTED
40026f70: 540001a0 b.eq 40026fa4 <rtems_rfs_buffer_handle_release.part.0+0x1f4> // b.none<== NOT EXECUTED
new_first = old_first->next;
40026f74: f9400002 ldr x2, [x0] <== NOT EXECUTED
head->next = new_first;
40026f78: f9006262 str x2, [x19, #192] <== NOT EXECUTED
new_first->previous = head;
40026f7c: f9000443 str x3, [x2, #8] <== NOT EXECUTED
fs->release_modified_count--;
40026f80: 51000422 sub w2, w1, #0x1 <== NOT EXECUTED
modified = true;
40026f84: 52800021 mov w1, #0x1 // #1 <== NOT EXECUTED
fs->release_modified_count--;
40026f88: b900da62 str w2, [x19, #216] <== NOT EXECUTED
buffer->user = (void*) 0;
40026f8c: f9002c1f str xzr, [x0, #88] <== NOT EXECUTED
rc = rtems_rfs_buffer_io_release (buffer, modified);
40026f90: 9400366c bl 40034940 <rtems_rfs_buffer_bdbuf_release> <== NOT EXECUTED
rtems_rfs_buffer_link (handle));
40026f94: f9400682 ldr x2, [x20, #8] <== NOT EXECUTED
40026f98: 17ffffb5 b 40026e6c <rtems_rfs_buffer_handle_release.part.0+0xbc> <== NOT EXECUTED
return NULL;
40026f9c: d2800000 mov x0, #0x0 // #0 <== NOT EXECUTED
40026fa0: 17ffffec b 40026f50 <rtems_rfs_buffer_handle_release.part.0+0x1a0> <== NOT EXECUTED
40026fa4: d2800000 mov x0, #0x0 // #0 <== NOT EXECUTED
40026fa8: 17fffff6 b 40026f80 <rtems_rfs_buffer_handle_release.part.0+0x1d0> <== NOT EXECUTED
printf ("rtems-rfs: buffer-release: local cache overflow:"
40026fac: b940ba62 ldr w2, [x19, #184] <== NOT EXECUTED
40026fb0: d0000100 adrp x0, 40048000 <_Scheduler_Table+0x60> <== NOT EXECUTED
40026fb4: 912ae000 add x0, x0, #0xab8 <== NOT EXECUTED
40026fb8: b940da61 ldr w1, [x19, #216] <== NOT EXECUTED
40026fbc: 0b010041 add w1, w2, w1 <== NOT EXECUTED
40026fc0: 97ffed14 bl 40022410 <__wrap_printf> <== NOT EXECUTED
40026fc4: 17ffffd7 b 40026f20 <rtems_rfs_buffer_handle_release.part.0+0x170> <== NOT EXECUTED
...
0000000040026fd0 <rtems_rfs_buffer_handle_request>:
{
40026fd0: a9bb7bfd stp x29, x30, [sp, #-80]!
40026fd4: 910003fd mov x29, sp
40026fd8: a90153f3 stp x19, x20, [sp, #16]
40026fdc: aa0003f4 mov x20, x0
40026fe0: aa0103f3 mov x19, x1
if (rtems_rfs_buffer_handle_has_block (handle))
40026fe4: f9400420 ldr x0, [x1, #8]
{
40026fe8: a9025bf5 stp x21, x22, [sp, #32]
40026fec: 2a0203f5 mov w21, w2
40026ff0: f9001bf7 str x23, [sp, #48]
40026ff4: 12001c77 and w23, w3, #0xff
if (rtems_rfs_buffer_handle_has_block (handle))
40026ff8: b4000260 cbz x0, 40027044 <rtems_rfs_buffer_handle_request+0x74>
if (block && (rtems_rfs_buffer_bnum (handle) == block))
40026ffc: 34000082 cbz w2, 4002700c <rtems_rfs_buffer_handle_request+0x3c> <== NEVER TAKEN
40027000: b9400420 ldr w0, [x1, #4]
40027004: 6b02001f cmp w0, w2
40027008: 54000d60 b.eq 400271b4 <rtems_rfs_buffer_handle_request+0x1e4> // b.none
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
4002700c: d2802000 mov x0, #0x100 // #256
40027010: 94000e90 bl 4002aa50 <rtems_rfs_trace>
40027014: 72001c1f tst w0, #0xff
40027018: 54000c01 b.ne 40027198 <rtems_rfs_buffer_handle_request+0x1c8> // b.any<== NEVER TAKEN
if (rtems_rfs_buffer_handle_has_block (handle))
4002701c: f9400660 ldr x0, [x19, #8]
40027020: b40000e0 cbz x0, 4002703c <rtems_rfs_buffer_handle_request+0x6c> <== NEVER TAKEN
40027024: aa1303e1 mov x1, x19
40027028: aa1403e0 mov x0, x20
4002702c: 97ffff61 bl 40026db0 <rtems_rfs_buffer_handle_release.part.0>
40027030: 2a0003f6 mov w22, w0
if (rc > 0)
40027034: 7100001f cmp w0, #0x0
40027038: 540005cc b.gt 400270f0 <rtems_rfs_buffer_handle_request+0x120> <== NEVER TAKEN
handle->dirty = false;
4002703c: 3900027f strb wzr, [x19]
handle->bnum = 0;
40027040: b900067f str wzr, [x19, #4]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
40027044: d2802000 mov x0, #0x100 // #256
40027048: 94000e82 bl 4002aa50 <rtems_rfs_trace>
4002704c: 72001c1f tst w0, #0xff
40027050: 54000961 b.ne 4002717c <rtems_rfs_buffer_handle_request+0x1ac> // b.any<== NEVER TAKEN
if (fs->buffers_count)
40027054: b9409a80 ldr w0, [x20, #152]
40027058: 35000700 cbnz w0, 40027138 <rtems_rfs_buffer_handle_request+0x168>
if (!rtems_rfs_fs_no_local_cache (fs) &&
4002705c: b9400280 ldr w0, [x20]
!rtems_rfs_buffer_handle_has_block (handle))
40027060: f9400661 ldr x1, [x19, #8]
if (!rtems_rfs_fs_no_local_cache (fs) &&
40027064: 37080520 tbnz w0, #1, 40027108 <rtems_rfs_buffer_handle_request+0x138>
40027068: b4000b81 cbz x1, 400271d8 <rtems_rfs_buffer_handle_request+0x208>
rtems_rfs_buffer_refs_up (handle);
4002706c: b9405424 ldr w4, [x1, #84]
old_last = tail->previous;
40027070: 91022280 add x0, x20, #0x88
fs->buffers_count++;
40027074: b9409a83 ldr w3, [x20, #152]
handle->buffer->user = (void*) ((intptr_t) block);
40027078: 2a1503e2 mov w2, w21
rtems_rfs_buffer_refs_up (handle);
4002707c: 11000484 add w4, w4, #0x1
40027080: b9005424 str w4, [x1, #84]
40027084: f9404a84 ldr x4, [x20, #144]
the_node->next = tail;
40027088: f9000020 str x0, [x1]
tail->previous = the_node;
4002708c: f9004a81 str x1, [x20, #144]
fs->buffers_count++;
40027090: 11000463 add w3, w3, #0x1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
40027094: d2802000 mov x0, #0x100 // #256
old_last->next = the_node;
40027098: f9000081 str x1, [x4]
the_node->previous = old_last;
4002709c: f9000424 str x4, [x1, #8]
fs->buffers_count++;
400270a0: b9009a83 str w3, [x20, #152]
handle->buffer->user = (void*) ((intptr_t) block);
400270a4: f9002c22 str x2, [x1, #88]
handle->bnum = block;
400270a8: b9000675 str w21, [x19, #4]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
400270ac: 94000e69 bl 4002aa50 <rtems_rfs_trace>
400270b0: 72001c1f tst w0, #0xff
400270b4: 54000800 b.eq 400271b4 <rtems_rfs_buffer_handle_request+0x1e4> // b.none<== ALWAYS TAKEN
block, read ? "read" : "get", handle->buffer->block,
400270b8: f9400664 ldr x4, [x19, #8] <== NOT EXECUTED
printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
400270bc: 710002ff cmp w23, #0x0 <== NOT EXECUTED
400270c0: b0000100 adrp x0, 40048000 <_Scheduler_Table+0x60> <== NOT EXECUTED
400270c4: 912be000 add x0, x0, #0xaf8 <== NOT EXECUTED
400270c8: b0000102 adrp x2, 40048000 <_Scheduler_Table+0x60> <== NOT EXECUTED
400270cc: 912bc042 add x2, x2, #0xaf0 <== NOT EXECUTED
400270d0: b9403083 ldr w3, [x4, #48] <== NOT EXECUTED
400270d4: 9a801042 csel x2, x2, x0, ne // ne = any <== NOT EXECUTED
400270d8: b9405484 ldr w4, [x4, #84] <== NOT EXECUTED
400270dc: b0000100 adrp x0, 40048000 <_Scheduler_Table+0x60> <== NOT EXECUTED
400270e0: 2a1503e1 mov w1, w21 <== NOT EXECUTED
400270e4: 912f4000 add x0, x0, #0xbd0 <== NOT EXECUTED
return 0;
400270e8: 52800016 mov w22, #0x0 // #0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
400270ec: 97ffecc9 bl 40022410 <__wrap_printf> <== NOT EXECUTED
}
400270f0: 2a1603e0 mov w0, w22 <== NOT EXECUTED
400270f4: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
400270f8: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
400270fc: f9401bf7 ldr x23, [sp, #48] <== NOT EXECUTED
40027100: a8c57bfd ldp x29, x30, [sp], #80 <== NOT EXECUTED
40027104: d65f03c0 ret <== NOT EXECUTED
if (!rtems_rfs_buffer_handle_has_block (handle))
40027108: b5fffb21 cbnz x1, 4002706c <rtems_rfs_buffer_handle_request+0x9c> <== NEVER TAKEN
rc = rtems_rfs_buffer_io_request (fs, block, read, &handle->buffer);
4002710c: 91002263 add x3, x19, #0x8
40027110: 2a1703e2 mov w2, w23
40027114: 2a1503e1 mov w1, w21
40027118: aa1403e0 mov x0, x20
4002711c: 940035f5 bl 400348f0 <rtems_rfs_buffer_bdbuf_request>
40027120: 2a0003f6 mov w22, w0
if (rc > 0)
40027124: 7100001f cmp w0, #0x0
40027128: 5400076c b.gt 40027214 <rtems_rfs_buffer_handle_request+0x244> <== NEVER TAKEN
rtems_chain_set_off_chain (rtems_rfs_buffer_link(handle));
4002712c: f9400661 ldr x1, [x19, #8]
node->next = NULL;
40027130: f900003f str xzr, [x1]
RTEMS_INLINE_ROUTINE void rtems_chain_set_off_chain(
rtems_chain_node *node
)
{
_Chain_Set_off_chain( node );
}
40027134: 17ffffce b 4002706c <rtems_rfs_buffer_handle_request+0x9c>
handle->buffer = rtems_rfs_scan_chain (&fs->buffers,
40027138: 2a1503e2 mov w2, w21
4002713c: 91026281 add x1, x20, #0x98
40027140: 91020280 add x0, x20, #0x80
40027144: 97fffea3 bl 40026bd0 <rtems_rfs_scan_chain>
40027148: f9000660 str x0, [x19, #8]
if (rtems_rfs_buffer_handle_has_block (handle) &&
4002714c: b4000420 cbz x0, 400271d0 <rtems_rfs_buffer_handle_request+0x200>
rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
40027150: d2802000 mov x0, #0x100 // #256
40027154: 94000e3f bl 4002aa50 <rtems_rfs_trace>
if (rtems_rfs_buffer_handle_has_block (handle) &&
40027158: 72001c1f tst w0, #0xff
4002715c: 54fff800 b.eq 4002705c <rtems_rfs_buffer_handle_request+0x8c> // b.none<== ALWAYS TAKEN
rtems_rfs_buffer_refs (handle) + 1);
40027160: f9400661 ldr x1, [x19, #8] <== NOT EXECUTED
printf ("rtems-rfs: buffer-request: buffer shared: refs: %d\n",
40027164: b0000100 adrp x0, 40048000 <_Scheduler_Table+0x60> <== NOT EXECUTED
40027168: 912d8000 add x0, x0, #0xb60 <== NOT EXECUTED
4002716c: b9405421 ldr w1, [x1, #84] <== NOT EXECUTED
40027170: 11000421 add w1, w1, #0x1 <== NOT EXECUTED
40027174: 97ffeca7 bl 40022410 <__wrap_printf> <== NOT EXECUTED
40027178: 17ffffb9 b 4002705c <rtems_rfs_buffer_handle_request+0x8c> <== NOT EXECUTED
printf ("rtems-rfs: buffer-request: block=%" PRIu32 "\n", block);
4002717c: 2a1503e1 mov w1, w21 <== NOT EXECUTED
40027180: b0000100 adrp x0, 40048000 <_Scheduler_Table+0x60> <== NOT EXECUTED
40027184: 912ce000 add x0, x0, #0xb38 <== NOT EXECUTED
40027188: 97ffeca2 bl 40022410 <__wrap_printf> <== NOT EXECUTED
if (fs->buffers_count)
4002718c: b9409a80 ldr w0, [x20, #152] <== NOT EXECUTED
40027190: 34fff660 cbz w0, 4002705c <rtems_rfs_buffer_handle_request+0x8c> <== NOT EXECUTED
40027194: 17ffffe9 b 40027138 <rtems_rfs_buffer_handle_request+0x168> <== NOT EXECUTED
printf ("rtems-rfs: buffer-request: handle has buffer: %" PRIu32 "\n",
40027198: b9400661 ldr w1, [x19, #4] <== NOT EXECUTED
4002719c: b0000100 adrp x0, 40048000 <_Scheduler_Table+0x60> <== NOT EXECUTED
400271a0: 912c0000 add x0, x0, #0xb00 <== NOT EXECUTED
400271a4: 97ffec9b bl 40022410 <__wrap_printf> <== NOT EXECUTED
if (rtems_rfs_buffer_handle_has_block (handle))
400271a8: f9400660 ldr x0, [x19, #8] <== NOT EXECUTED
400271ac: b5fff3c0 cbnz x0, 40027024 <rtems_rfs_buffer_handle_request+0x54> <== NOT EXECUTED
400271b0: 17ffffa3 b 4002703c <rtems_rfs_buffer_handle_request+0x6c> <== NOT EXECUTED
return 0;
400271b4: 52800016 mov w22, #0x0 // #0
}
400271b8: 2a1603e0 mov w0, w22
400271bc: a94153f3 ldp x19, x20, [sp, #16]
400271c0: a9425bf5 ldp x21, x22, [sp, #32]
400271c4: f9401bf7 ldr x23, [sp, #48]
400271c8: a8c57bfd ldp x29, x30, [sp], #80
400271cc: d65f03c0 ret
if (!rtems_rfs_fs_no_local_cache (fs) &&
400271d0: b9400280 ldr w0, [x20]
400271d4: 370ff9c0 tbnz w0, #1, 4002710c <rtems_rfs_buffer_handle_request+0x13c>
if (fs->release_count)
400271d8: b940ba80 ldr w0, [x20, #184]
400271dc: 35000440 cbnz w0, 40027264 <rtems_rfs_buffer_handle_request+0x294>
if (!rtems_rfs_buffer_handle_has_block (handle) &&
400271e0: b940da80 ldr w0, [x20, #216]
400271e4: 34fff940 cbz w0, 4002710c <rtems_rfs_buffer_handle_request+0x13c>
handle->buffer = rtems_rfs_scan_chain (&fs->release_modified,
400271e8: 91036281 add x1, x20, #0xd8
400271ec: 2a1503e2 mov w2, w21
400271f0: 91030280 add x0, x20, #0xc0
400271f4: 97fffe77 bl 40026bd0 <rtems_rfs_scan_chain>
400271f8: f9000660 str x0, [x19, #8]
400271fc: aa0003e1 mov x1, x0
40027200: f90027e0 str x0, [sp, #72]
if (rtems_rfs_buffer_handle_has_block (handle))
40027204: b4fff840 cbz x0, 4002710c <rtems_rfs_buffer_handle_request+0x13c>
rtems_rfs_buffer_mark_dirty (handle);
40027208: 52800020 mov w0, #0x1 // #1
4002720c: 39000260 strb w0, [x19]
40027210: 17ffff97 b 4002706c <rtems_rfs_buffer_handle_request+0x9c>
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
40027214: d2802000 mov x0, #0x100 // #256 <== NOT EXECUTED
40027218: 94000e0e bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
4002721c: 72001c1f tst w0, #0xff <== NOT EXECUTED
40027220: 54fff680 b.eq 400270f0 <rtems_rfs_buffer_handle_request+0x120> // b.none<== NOT EXECUTED
printf ("rtems-rfs: buffer-request: block=%" PRIu32 ": bdbuf-%s: %d: %s\n",
40027224: 710002ff cmp w23, #0x0 <== NOT EXECUTED
40027228: b0000101 adrp x1, 40048000 <_Scheduler_Table+0x60> <== NOT EXECUTED
4002722c: 912be021 add x1, x1, #0xaf8 <== NOT EXECUTED
40027230: b0000113 adrp x19, 40048000 <_Scheduler_Table+0x60> <== NOT EXECUTED
40027234: 912bc273 add x19, x19, #0xaf0 <== NOT EXECUTED
40027238: 2a1603e0 mov w0, w22 <== NOT EXECUTED
4002723c: 9a811273 csel x19, x19, x1, ne // ne = any <== NOT EXECUTED
40027240: 94005e77 bl 4003ec1c <strerror> <== NOT EXECUTED
40027244: aa0003e4 mov x4, x0 <== NOT EXECUTED
40027248: aa1303e2 mov x2, x19 <== NOT EXECUTED
4002724c: 2a1503e1 mov w1, w21 <== NOT EXECUTED
40027250: 2a1603e3 mov w3, w22 <== NOT EXECUTED
40027254: b0000100 adrp x0, 40048000 <_Scheduler_Table+0x60> <== NOT EXECUTED
40027258: 912e6000 add x0, x0, #0xb98 <== NOT EXECUTED
4002725c: 97ffec6d bl 40022410 <__wrap_printf> <== NOT EXECUTED
40027260: 17ffffa4 b 400270f0 <rtems_rfs_buffer_handle_request+0x120> <== NOT EXECUTED
handle->buffer = rtems_rfs_scan_chain (&fs->release,
40027264: 9102e281 add x1, x20, #0xb8
40027268: 2a1503e2 mov w2, w21
4002726c: 91028280 add x0, x20, #0xa0
40027270: 97fffe58 bl 40026bd0 <rtems_rfs_scan_chain>
40027274: f9000660 str x0, [x19, #8]
40027278: aa0003e1 mov x1, x0
if (!rtems_rfs_buffer_handle_has_block (handle) &&
4002727c: b5ffef80 cbnz x0, 4002706c <rtems_rfs_buffer_handle_request+0x9c>
40027280: 17ffffd8 b 400271e0 <rtems_rfs_buffer_handle_request+0x210>
...
00000000400272b0 <rtems_rfs_buffer_open>:
{
400272b0: a9b67bfd stp x29, x30, [sp, #-160]!
400272b4: 910003fd mov x29, sp
400272b8: a90153f3 stp x19, x20, [sp, #16]
400272bc: aa0003f4 mov x20, x0
400272c0: aa0103f3 mov x19, x1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
400272c4: d2800400 mov x0, #0x20 // #32
{
400272c8: f90013f5 str x21, [sp, #32]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
400272cc: 94000de1 bl 4002aa50 <rtems_rfs_trace>
400272d0: 72001c1f tst w0, #0xff
400272d4: 540004e1 b.ne 40027370 <rtems_rfs_buffer_open+0xc0> // b.any <== NEVER TAKEN
fs->device = open (name, O_RDWR);
400272d8: aa1403e0 mov x0, x20
400272dc: 52800041 mov w1, #0x2 // #2
400272e0: 94002e84 bl 40032cf0 <open>
400272e4: b9001a60 str w0, [x19, #24]
if (fs->device < 0)
400272e8: 37f80560 tbnz w0, #31, 40027394 <rtems_rfs_buffer_open+0xe4> <== NEVER TAKEN
if (fstat (fs->device, &st) < 0)
400272ec: 9100e3e1 add x1, sp, #0x38
400272f0: 94002d40 bl 400327f0 <fstat>
400272f4: 37f80940 tbnz w0, #31, 4002741c <rtems_rfs_buffer_open+0x16c> <== NEVER TAKEN
if (!S_ISBLK (st.st_mode))
400272f8: b9404be0 ldr w0, [sp, #72]
400272fc: 12140c00 and w0, w0, #0xf000
40027300: 7140181f cmp w0, #0x6, lsl #12
40027304: 54000221 b.ne 40027348 <rtems_rfs_buffer_open+0x98> // b.any <== NEVER TAKEN
static inline int rtems_disk_fd_get_disk_device(
int fd,
rtems_disk_device **dd_ptr
)
{
return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);
40027308: b9401a60 ldr w0, [x19, #24]
4002730c: 91008262 add x2, x19, #0x20
40027310: d2884121 mov x1, #0x4209 // #16905
40027314: f2a80101 movk x1, #0x4008, lsl #16
40027318: 94002d96 bl 40032970 <ioctl>
4002731c: 2a0003f5 mov w21, w0
if (rv != 0)
40027320: 350006c0 cbnz w0, 400273f8 <rtems_rfs_buffer_open+0x148> <== NEVER TAKEN
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
40027324: d2800400 mov x0, #0x20 // #32
40027328: 94000dca bl 4002aa50 <rtems_rfs_trace>
4002732c: 72001c1f tst w0, #0xff
40027330: 54000501 b.ne 400273d0 <rtems_rfs_buffer_open+0x120> // b.any <== NEVER TAKEN
}
40027334: 2a1503e0 mov w0, w21
40027338: a94153f3 ldp x19, x20, [sp, #16]
4002733c: f94013f5 ldr x21, [sp, #32]
40027340: a8ca7bfd ldp x29, x30, [sp], #160
40027344: d65f03c0 ret
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
40027348: d2800100 mov x0, #0x8 // #8 <== NOT EXECUTED
4002734c: 94000dc1 bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
40027350: 72001c1f tst w0, #0xff <== NOT EXECUTED
40027354: 54000321 b.ne 400273b8 <rtems_rfs_buffer_open+0x108> // b.any <== NOT EXECUTED
return ENXIO;
40027358: 528000d5 mov w21, #0x6 // #6 <== NOT EXECUTED
}
4002735c: 2a1503e0 mov w0, w21 <== NOT EXECUTED
40027360: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40027364: f94013f5 ldr x21, [sp, #32] <== NOT EXECUTED
40027368: a8ca7bfd ldp x29, x30, [sp], #160 <== NOT EXECUTED
4002736c: d65f03c0 ret <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: opening: %s\n", name);
40027370: aa1403e1 mov x1, x20 <== NOT EXECUTED
40027374: b0000100 adrp x0, 40048000 <_Scheduler_Table+0x60> <== NOT EXECUTED
40027378: 91304000 add x0, x0, #0xc10 <== NOT EXECUTED
4002737c: 97ffec25 bl 40022410 <__wrap_printf> <== NOT EXECUTED
fs->device = open (name, O_RDWR);
40027380: aa1403e0 mov x0, x20 <== NOT EXECUTED
40027384: 52800041 mov w1, #0x2 // #2 <== NOT EXECUTED
40027388: 94002e5a bl 40032cf0 <open> <== NOT EXECUTED
4002738c: b9001a60 str w0, [x19, #24] <== NOT EXECUTED
if (fs->device < 0)
40027390: 36fffae0 tbz w0, #31, 400272ec <rtems_rfs_buffer_open+0x3c> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
40027394: d2800100 mov x0, #0x8 // #8 <== NOT EXECUTED
40027398: 94000dae bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
4002739c: 72001c1f tst w0, #0xff <== NOT EXECUTED
400273a0: 54fffdc0 b.eq 40027358 <rtems_rfs_buffer_open+0xa8> // b.none <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: cannot open file\n");
400273a4: b0000100 adrp x0, 40048000 <_Scheduler_Table+0x60> <== NOT EXECUTED
400273a8: 9130e000 add x0, x0, #0xc38 <== NOT EXECUTED
return ENXIO;
400273ac: 528000d5 mov w21, #0x6 // #6 <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: cannot open file\n");
400273b0: 97ffec3c bl 400224a0 <__wrap_puts> <== NOT EXECUTED
400273b4: 17ffffe0 b 40027334 <rtems_rfs_buffer_open+0x84> <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: '%s' is not a block device\n", name);
400273b8: aa1403e1 mov x1, x20 <== NOT EXECUTED
400273bc: b0000100 adrp x0, 40048000 <_Scheduler_Table+0x60> <== NOT EXECUTED
return ENXIO;
400273c0: 528000d5 mov w21, #0x6 // #6 <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: '%s' is not a block device\n", name);
400273c4: 91326000 add x0, x0, #0xc98 <== NOT EXECUTED
400273c8: 97ffec12 bl 40022410 <__wrap_printf> <== NOT EXECUTED
400273cc: 17ffffda b 40027334 <rtems_rfs_buffer_open+0x84> <== NOT EXECUTED
rtems_rfs_fs_media_blocks (fs),
400273d0: f9401262 ldr x2, [x19, #32] <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: blks=%" PRId32 ", blk-size=%" PRId32 "\n",
400273d4: b0000100 adrp x0, 40048000 <_Scheduler_Table+0x60> <== NOT EXECUTED
400273d8: 91340000 add x0, x0, #0xd00 <== NOT EXECUTED
400273dc: 29450841 ldp w1, w2, [x2, #40] <== NOT EXECUTED
400273e0: 97ffec0c bl 40022410 <__wrap_printf> <== NOT EXECUTED
}
400273e4: 2a1503e0 mov w0, w21 <== NOT EXECUTED
400273e8: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
400273ec: f94013f5 ldr x21, [sp, #32] <== NOT EXECUTED
400273f0: a8ca7bfd ldp x29, x30, [sp], #160 <== NOT EXECUTED
400273f4: d65f03c0 ret <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
400273f8: d2800100 mov x0, #0x8 // #8 <== NOT EXECUTED
400273fc: 94000d95 bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
40027400: 72001c1f tst w0, #0xff <== NOT EXECUTED
40027404: 54fffaa0 b.eq 40027358 <rtems_rfs_buffer_open+0xa8> // b.none <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: cannot obtain the disk\n");
40027408: b0000100 adrp x0, 40048000 <_Scheduler_Table+0x60> <== NOT EXECUTED
4002740c: 91334000 add x0, x0, #0xcd0 <== NOT EXECUTED
return ENXIO;
40027410: 528000d5 mov w21, #0x6 // #6 <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: cannot obtain the disk\n");
40027414: 97ffec23 bl 400224a0 <__wrap_puts> <== NOT EXECUTED
40027418: 17ffffc7 b 40027334 <rtems_rfs_buffer_open+0x84> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
4002741c: d2800100 mov x0, #0x8 // #8 <== NOT EXECUTED
40027420: 94000d8c bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
40027424: 72001c1f tst w0, #0xff <== NOT EXECUTED
40027428: 54fff980 b.eq 40027358 <rtems_rfs_buffer_open+0xa8> // b.none <== NOT EXECUTED
name, strerror (errno));
4002742c: 94005918 bl 4003d88c <__errno> <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n",
40027430: b9400000 ldr w0, [x0] <== NOT EXECUTED
return ENXIO;
40027434: 528000d5 mov w21, #0x6 // #6 <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n",
40027438: 94005df9 bl 4003ec1c <strerror> <== NOT EXECUTED
4002743c: aa0003e2 mov x2, x0 <== NOT EXECUTED
40027440: aa1403e1 mov x1, x20 <== NOT EXECUTED
40027444: b0000100 adrp x0, 40048000 <_Scheduler_Table+0x60> <== NOT EXECUTED
40027448: 9131a000 add x0, x0, #0xc68 <== NOT EXECUTED
4002744c: 97ffebf1 bl 40022410 <__wrap_printf> <== NOT EXECUTED
40027450: 17ffffb9 b 40027334 <rtems_rfs_buffer_open+0x84> <== NOT EXECUTED
...
0000000040027580 <rtems_rfs_buffer_setblksize>:
{
40027580: a9bd7bfd stp x29, x30, [sp, #-48]!
40027584: 910003fd mov x29, sp
40027588: a90153f3 stp x19, x20, [sp, #16]
4002758c: aa0003f3 mov x19, x0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
40027590: d2808000 mov x0, #0x400 // #1024
{
40027594: b9002fe1 str w1, [sp, #44]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
40027598: 94000d2e bl 4002aa50 <rtems_rfs_trace>
4002759c: 72001c1f tst w0, #0xff
400275a0: 540007a1 b.ne 40027694 <rtems_rfs_buffer_setblksize+0x114> // b.any<== NEVER TAKEN
rc = rtems_rfs_buffers_release (fs);
400275a4: aa1303e0 mov x0, x19
400275a8: 97ffffd6 bl 40027500 <rtems_rfs_buffers_release>
400275ac: 2a0003f4 mov w20, w0
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
400275b0: 7100001f cmp w0, #0x0
400275b4: 5400020c b.gt 400275f4 <rtems_rfs_buffer_setblksize+0x74> <== NEVER TAKEN
rc = rtems_rfs_buffer_sync (fs);
400275b8: aa1303e0 mov x0, x19
400275bc: 97ffffa9 bl 40027460 <rtems_rfs_buffer_sync>
400275c0: 2a0003f4 mov w20, w0
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
400275c4: 7100001f cmp w0, #0x0
400275c8: 5400038c b.gt 40027638 <rtems_rfs_buffer_setblksize+0xb8> <== NEVER TAKEN
rc = fs->disk->ioctl (fs->disk, RTEMS_BLKIO_SETBLKSIZE, &size);
400275cc: f9401260 ldr x0, [x19, #32]
400275d0: 52884081 mov w1, #0x4204 // #16900
400275d4: 72b00081 movk w1, #0x8004, lsl #16
400275d8: 9100b3e2 add x2, sp, #0x2c
400275dc: f9402403 ldr x3, [x0, #72]
400275e0: d63f0060 blr x3
if (rc < 0)
400275e4: 37f804e0 tbnz w0, #31, 40027680 <rtems_rfs_buffer_setblksize+0x100> <== NEVER TAKEN
}
400275e8: a94153f3 ldp x19, x20, [sp, #16]
400275ec: a8c37bfd ldp x29, x30, [sp], #48
400275f0: d65f03c0 ret
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
400275f4: d2808000 mov x0, #0x400 // #1024 <== NOT EXECUTED
400275f8: 94000d16 bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
400275fc: 72001c1f tst w0, #0xff <== NOT EXECUTED
40027600: 54fffdc0 b.eq 400275b8 <rtems_rfs_buffer_setblksize+0x38> // b.none<== NOT EXECUTED
printf ("rtems-rfs: buffer-setblksize: buffer release failed: %d: %s\n",
40027604: 2a1403e0 mov w0, w20 <== NOT EXECUTED
40027608: 94005d85 bl 4003ec1c <strerror> <== NOT EXECUTED
4002760c: 2a1403e1 mov w1, w20 <== NOT EXECUTED
40027610: aa0003e2 mov x2, x0 <== NOT EXECUTED
40027614: b0000100 adrp x0, 40048000 <_Scheduler_Table+0x60> <== NOT EXECUTED
40027618: 9137e000 add x0, x0, #0xdf8 <== NOT EXECUTED
4002761c: 97ffeb7d bl 40022410 <__wrap_printf> <== NOT EXECUTED
rc = rtems_rfs_buffer_sync (fs);
40027620: aa1303e0 mov x0, x19 <== NOT EXECUTED
40027624: 97ffff8f bl 40027460 <rtems_rfs_buffer_sync> <== NOT EXECUTED
40027628: 2a0003f4 mov w20, w0 <== NOT EXECUTED
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
4002762c: 7100001f cmp w0, #0x0 <== NOT EXECUTED
40027630: 54fffced b.le 400275cc <rtems_rfs_buffer_setblksize+0x4c> <== NOT EXECUTED
40027634: d503201f nop <== NOT EXECUTED
40027638: d2808000 mov x0, #0x400 // #1024 <== NOT EXECUTED
4002763c: 94000d05 bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
40027640: 72001c1f tst w0, #0xff <== NOT EXECUTED
40027644: 54fffc40 b.eq 400275cc <rtems_rfs_buffer_setblksize+0x4c> // b.none<== NOT EXECUTED
printf ("rtems-rfs: buffer-setblksize: device sync failed: %d: %s\n",
40027648: 2a1403e0 mov w0, w20 <== NOT EXECUTED
4002764c: 94005d74 bl 4003ec1c <strerror> <== NOT EXECUTED
40027650: 2a1403e1 mov w1, w20 <== NOT EXECUTED
40027654: aa0003e2 mov x2, x0 <== NOT EXECUTED
40027658: b0000100 adrp x0, 40048000 <_Scheduler_Table+0x60> <== NOT EXECUTED
4002765c: 9138e000 add x0, x0, #0xe38 <== NOT EXECUTED
40027660: 97ffeb6c bl 40022410 <__wrap_printf> <== NOT EXECUTED
rc = fs->disk->ioctl (fs->disk, RTEMS_BLKIO_SETBLKSIZE, &size);
40027664: f9401260 ldr x0, [x19, #32] <== NOT EXECUTED
40027668: 52884081 mov w1, #0x4204 // #16900 <== NOT EXECUTED
4002766c: 72b00081 movk w1, #0x8004, lsl #16 <== NOT EXECUTED
40027670: 9100b3e2 add x2, sp, #0x2c <== NOT EXECUTED
40027674: f9402403 ldr x3, [x0, #72] <== NOT EXECUTED
40027678: d63f0060 blr x3 <== NOT EXECUTED
if (rc < 0)
4002767c: 36fffb60 tbz w0, #31, 400275e8 <rtems_rfs_buffer_setblksize+0x68> <== NOT EXECUTED
rc = errno;
40027680: 94005883 bl 4003d88c <__errno> <== NOT EXECUTED
40027684: b9400000 ldr w0, [x0] <== NOT EXECUTED
}
40027688: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
4002768c: a8c37bfd ldp x29, x30, [sp], #48 <== NOT EXECUTED
40027690: d65f03c0 ret <== NOT EXECUTED
printf ("rtems-rfs: buffer-setblksize: block size: %" PRIu32 "\n", size);
40027694: b9402fe1 ldr w1, [sp, #44] <== NOT EXECUTED
40027698: b0000100 adrp x0, 40048000 <_Scheduler_Table+0x60> <== NOT EXECUTED
4002769c: 91372000 add x0, x0, #0xdc8 <== NOT EXECUTED
400276a0: 97ffeb5c bl 40022410 <__wrap_printf> <== NOT EXECUTED
400276a4: 17ffffc0 b 400275a4 <rtems_rfs_buffer_setblksize+0x24> <== NOT EXECUTED
...
0000000040027460 <rtems_rfs_buffer_sync>:
{
40027460: a9be7bfd stp x29, x30, [sp, #-32]!
40027464: 910003fd mov x29, sp
40027468: a90153f3 stp x19, x20, [sp, #16]
4002746c: aa0003f3 mov x19, x0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
40027470: d2800400 mov x0, #0x20 // #32
40027474: 94000d77 bl 4002aa50 <rtems_rfs_trace>
40027478: 72001c1f tst w0, #0xff
4002747c: 54000141 b.ne 400274a4 <rtems_rfs_buffer_sync+0x44> // b.any <== NEVER TAKEN
sc = rtems_bdbuf_syncdev (rtems_rfs_fs_device (fs));
40027480: f9401260 ldr x0, [x19, #32]
int result = 0;
40027484: 52800014 mov w20, #0x0 // #0
sc = rtems_bdbuf_syncdev (rtems_rfs_fs_device (fs));
40027488: 940029ba bl 40031b70 <rtems_bdbuf_syncdev>
4002748c: 2a0003f3 mov w19, w0
if (sc != RTEMS_SUCCESSFUL)
40027490: 350001a0 cbnz w0, 400274c4 <rtems_rfs_buffer_sync+0x64> <== NEVER TAKEN
}
40027494: 2a1403e0 mov w0, w20
40027498: a94153f3 ldp x19, x20, [sp, #16]
4002749c: a8c27bfd ldp x29, x30, [sp], #32
400274a0: d65f03c0 ret
printf ("rtems-rfs: buffer-sync: syncing\n");
400274a4: b0000100 adrp x0, 40048000 <_Scheduler_Table+0x60> <== NOT EXECUTED
400274a8: 9134c000 add x0, x0, #0xd30 <== NOT EXECUTED
400274ac: 97ffebfd bl 400224a0 <__wrap_puts> <== NOT EXECUTED
int result = 0;
400274b0: 52800014 mov w20, #0x0 // #0 <== NOT EXECUTED
sc = rtems_bdbuf_syncdev (rtems_rfs_fs_device (fs));
400274b4: f9401260 ldr x0, [x19, #32] <== NOT EXECUTED
400274b8: 940029ae bl 40031b70 <rtems_bdbuf_syncdev> <== NOT EXECUTED
400274bc: 2a0003f3 mov w19, w0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
400274c0: 34fffea0 cbz w0, 40027494 <rtems_rfs_buffer_sync+0x34> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
400274c4: d2800400 mov x0, #0x20 // #32 <== NOT EXECUTED
result = EIO;
400274c8: 528000b4 mov w20, #0x5 // #5 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
400274cc: 94000d61 bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
400274d0: 72001c1f tst w0, #0xff <== NOT EXECUTED
400274d4: 54fffe00 b.eq 40027494 <rtems_rfs_buffer_sync+0x34> // b.none <== NOT EXECUTED
printf ("rtems-rfs: buffer-sync: device sync failed: %s\n",
400274d8: 2a1303e0 mov w0, w19 <== NOT EXECUTED
400274dc: 94000d65 bl 4002aa70 <rtems_status_text> <== NOT EXECUTED
400274e0: b0000102 adrp x2, 40048000 <_Scheduler_Table+0x60> <== NOT EXECUTED
400274e4: aa0003e1 mov x1, x0 <== NOT EXECUTED
400274e8: 91354040 add x0, x2, #0xd50 <== NOT EXECUTED
400274ec: 97ffebc9 bl 40022410 <__wrap_printf> <== NOT EXECUTED
}
400274f0: 2a1403e0 mov w0, w20 <== NOT EXECUTED
400274f4: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
400274f8: a8c27bfd ldp x29, x30, [sp], #32 <== NOT EXECUTED
400274fc: d65f03c0 ret <== NOT EXECUTED
0000000040027500 <rtems_rfs_buffers_release>:
int
rtems_rfs_buffers_release (rtems_rfs_file_system* fs)
{
40027500: a9be7bfd stp x29, x30, [sp, #-32]!
40027504: 910003fd mov x29, sp
40027508: a90153f3 stp x19, x20, [sp, #16]
4002750c: aa0003f3 mov x19, x0
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
40027510: d2800800 mov x0, #0x40 // #64
40027514: 94000d4f bl 4002aa50 <rtems_rfs_trace>
40027518: 72001c1f tst w0, #0xff
4002751c: 54000241 b.ne 40027564 <rtems_rfs_buffers_release+0x64> // b.any <== NEVER TAKEN
printf ("rtems-rfs: buffers-release: active:%" PRIu32 " "
"release:%" PRIu32 " release-modified:%" PRIu32 "\n",
fs->buffers_count, fs->release_count, fs->release_modified_count);
rc = rtems_rfs_release_chain (&fs->release,
40027520: 9102e261 add x1, x19, #0xb8
40027524: 52800002 mov w2, #0x0 // #0
40027528: 91028260 add x0, x19, #0xa0
4002752c: 97fffdf5 bl 40026d00 <rtems_rfs_release_chain>
&fs->release_count,
false);
if ((rc > 0) && (rrc == 0))
rrc = rc;
rc = rtems_rfs_release_chain (&fs->release_modified,
40027530: 91036261 add x1, x19, #0xd8
rc = rtems_rfs_release_chain (&fs->release,
40027534: 2a0003f4 mov w20, w0
rc = rtems_rfs_release_chain (&fs->release_modified,
40027538: 52800022 mov w2, #0x1 // #1
4002753c: 91030260 add x0, x19, #0xc0
40027540: 97fffdf0 bl 40026d00 <rtems_rfs_release_chain>
&fs->release_modified_count,
true);
if ((rc > 0) && (rrc == 0))
40027544: 7100001f cmp w0, #0x0
40027548: 7a40ca80 ccmp w20, #0x0, #0x0, gt
4002754c: 5400006d b.le 40027558 <rtems_rfs_buffers_release+0x58> <== NEVER TAKEN
40027550: 7100029f cmp w20, #0x0
40027554: 1a9fa280 csel w0, w20, wzr, ge // ge = tcont
rrc = rc;
return rrc;
}
40027558: a94153f3 ldp x19, x20, [sp, #16]
4002755c: a8c27bfd ldp x29, x30, [sp], #32
40027560: d65f03c0 ret
printf ("rtems-rfs: buffers-release: active:%" PRIu32 " "
40027564: b9409a61 ldr w1, [x19, #152] <== NOT EXECUTED
40027568: b0000100 adrp x0, 40048000 <_Scheduler_Table+0x60> <== NOT EXECUTED
4002756c: 91360000 add x0, x0, #0xd80 <== NOT EXECUTED
40027570: b940ba62 ldr w2, [x19, #184] <== NOT EXECUTED
40027574: b940da63 ldr w3, [x19, #216] <== NOT EXECUTED
40027578: 97ffeba6 bl 40022410 <__wrap_printf> <== NOT EXECUTED
4002757c: 17ffffe9 b 40027520 <rtems_rfs_buffers_release+0x20> <== NOT EXECUTED
0000000040034f60 <rtems_rfs_dir_add_entry>:
rtems_rfs_dir_add_entry (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir,
const char* name,
size_t length,
rtems_rfs_ino ino)
{
40034f60: a9b17bfd stp x29, x30, [sp, #-240]!
40034f64: 910003fd mov x29, sp
40034f68: a90153f3 stp x19, x20, [sp, #16]
40034f6c: a9025bf5 stp x21, x22, [sp, #32]
40034f70: aa0103f5 mov x21, x1
40034f74: aa0303f6 mov x22, x3
40034f78: a90363f7 stp x23, x24, [sp, #48]
40034f7c: aa0203f7 mov x23, x2
40034f80: 2a0403f8 mov w24, w4
40034f84: a9046bf9 stp x25, x26, [sp, #64]
40034f88: aa0003fa mov x26, x0
rtems_rfs_block_map map;
rtems_rfs_block_pos bpos;
rtems_rfs_buffer_handle buffer;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
40034f8c: d2a40000 mov x0, #0x20000000 // #536870912
40034f90: 97ffd6b0 bl 4002aa50 <rtems_rfs_trace>
40034f94: 72001c1f tst w0, #0xff
40034f98: 54001481 b.ne 40035228 <rtems_rfs_dir_add_entry+0x2c8> // b.any <== NEVER TAKEN
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf (", len=%zd\n", length);
}
rc = rtems_rfs_block_map_open (fs, dir, &map);
40034f9c: aa1503e1 mov x1, x21
40034fa0: 910243e2 add x2, sp, #0x90
40034fa4: aa1a03e0 mov x0, x26
40034fa8: 97fffb56 bl 40033d00 <rtems_rfs_block_map_open>
40034fac: 2a0003f4 mov w20, w0
if (rc > 0)
40034fb0: 7100001f cmp w0, #0x0
40034fb4: 5400064c b.gt 4003507c <rtems_rfs_dir_add_entry+0x11c> <== NEVER TAKEN
handle->dirty = false;
40034fb8: a90573fb stp x27, x28, [sp, #80]
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
40034fbc: 529ffffc mov w28, #0xffff // #65535
bpos->boff = 0;
40034fc0: 290e7fff stp wzr, wzr, [sp, #112]
bpos->block = 0;
40034fc4: b9007bff str wzr, [sp, #120]
40034fc8: 390203ff strb wzr, [sp, #128]
handle->bnum = 0;
40034fcc: b90087ff str wzr, [sp, #132]
handle->buffer = NULL;
40034fd0: f90047ff str xzr, [sp, #136]
rc = rtems_rfs_block_map_find (fs, &map, &bpos, &block);
40034fd4: 9101b3e3 add x3, sp, #0x6c
40034fd8: 9101c3e2 add x2, sp, #0x70
40034fdc: 910243e1 add x1, sp, #0x90
40034fe0: aa1a03e0 mov x0, x26
40034fe4: 97fffc23 bl 40034070 <rtems_rfs_block_map_find>
40034fe8: 2a0003f4 mov w20, w0
if (rc > 0)
40034fec: 7100001f cmp w0, #0x0
40034ff0: 540013ed b.le 4003526c <rtems_rfs_dir_add_entry+0x30c>
if (rc != ENXIO)
40034ff4: 7100181f cmp w0, #0x6
40034ff8: 54001801 b.ne 400352f8 <rtems_rfs_dir_add_entry+0x398> // b.any <== NEVER TAKEN
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
40034ffc: 9101b3e3 add x3, sp, #0x6c
40035000: 910243e1 add x1, sp, #0x90
40035004: aa1a03e0 mov x0, x26
40035008: d2800022 mov x2, #0x1 // #1
4003500c: 97fffc89 bl 40034230 <rtems_rfs_block_map_grow>
40035010: 2a0003f4 mov w20, w0
if (rc > 0)
40035014: 7100001f cmp w0, #0x0
40035018: 5400154c b.gt 400352c0 <rtems_rfs_dir_add_entry+0x360> <== NEVER TAKEN
bpos.bno++;
4003501c: 294d93e2 ldp w2, w4, [sp, #108]
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
40035020: 910203e1 add x1, sp, #0x80
40035024: aa1a03e0 mov x0, x26
40035028: 52800003 mov w3, #0x0 // #0
bpos.bno++;
4003502c: 11000484 add w4, w4, #0x1
40035030: b90073e4 str w4, [sp, #112]
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
40035034: 97ffc7e7 bl 40026fd0 <rtems_rfs_buffer_handle_request>
40035038: 2a0003f4 mov w20, w0
if (rc > 0)
4003503c: 7100001f cmp w0, #0x0
40035040: 540002cd b.le 40035098 <rtems_rfs_dir_add_entry+0x138> <== ALWAYS TAKEN
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
40035044: d2a40000 mov x0, #0x20000000 // #536870912 <== NOT EXECUTED
40035048: 97ffd682 bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
4003504c: 72001c1f tst w0, #0xff <== NOT EXECUTED
40035050: 54001701 b.ne 40035330 <rtems_rfs_dir_add_entry+0x3d0> // b.any <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40035054: 910203e1 add x1, sp, #0x80 <== NOT EXECUTED
40035058: aa1a03e0 mov x0, x26 <== NOT EXECUTED
4003505c: 97ffc88d bl 40027290 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
40035060: 390203ff strb wzr, [sp, #128] <== NOT EXECUTED
offset += elength;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
40035064: 910243e1 add x1, sp, #0x90 <== NOT EXECUTED
40035068: aa1a03e0 mov x0, x26 <== NOT EXECUTED
handle->bnum = 0;
4003506c: b90087ff str wzr, [sp, #132] <== NOT EXECUTED
handle->buffer = NULL;
40035070: f90047ff str xzr, [sp, #136] <== NOT EXECUTED
40035074: 97fffb87 bl 40033e90 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
40035078: a94573fb ldp x27, x28, [sp, #80] <== NOT EXECUTED
}
4003507c: 2a1403e0 mov w0, w20 <== NOT EXECUTED
40035080: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40035084: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
40035088: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
4003508c: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
40035090: a8cf7bfd ldp x29, x30, [sp], #240 <== NOT EXECUTED
40035094: d65f03c0 ret <== NOT EXECUTED
entry = rtems_rfs_buffer_data (&buffer);
40035098: f94047e0 ldr x0, [sp, #136]
memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
4003509c: 52801fe1 mov w1, #0xff // #255
400350a0: f9400b42 ldr x2, [x26, #16]
entry = rtems_rfs_buffer_data (&buffer);
400350a4: f9401c13 ldr x19, [x0, #56]
memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
400350a8: aa1303e0 mov x0, x19
400350ac: 940023c0 bl 4003dfac <memset>
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
400350b0: f9400b47 ldr x7, [x26, #16]
400350b4: f10028e6 subs x6, x7, #0xa
400350b8: 54fff8e0 b.eq 40034fd4 <rtems_rfs_dir_add_entry+0x74> // b.none <== NEVER TAKEN
offset = 0;
400350bc: 5280001b mov w27, #0x0 // #0
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
400350c0: d2800004 mov x4, #0x0 // #0
400350c4: 1400000f b 40035100 <rtems_rfs_dir_add_entry+0x1a0>
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
400350c8: 71002b3f cmp w25, #0xa
400350cc: 5400082d b.le 400351d0 <rtems_rfs_dir_add_entry+0x270> <== NEVER TAKEN
400350d0: b9403340 ldr w0, [x26, #48]
entry += elength;
400350d4: 8b252273 add x19, x19, w5, uxth
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
400350d8: 6b19001f cmp w0, w25
400350dc: 540007a9 b.ls 400351d0 <rtems_rfs_dir_add_entry+0x270> // b.plast <== NEVER TAKEN
400350e0: 34000794 cbz w20, 400351d0 <rtems_rfs_dir_add_entry+0x270> <== NEVER TAKEN
400350e4: b9402b40 ldr w0, [x26, #40]
400350e8: 6b14001f cmp w0, w20
400350ec: 54000723 b.cc 400351d0 <rtems_rfs_dir_add_entry+0x270> // b.lo, b.ul, b.last<== NEVER TAKEN
offset += elength;
400350f0: 0b19037b add w27, w27, w25
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
400350f4: 93407f64 sxtw x4, w27
400350f8: eb0400df cmp x6, x4
400350fc: 54fff6c9 b.ls 40034fd4 <rtems_rfs_dir_add_entry+0x74> // b.plast <== NEVER TAKEN
entry += elength;
40035100: 39402262 ldrb w2, [x19, #8]
40035104: 39402665 ldrb w5, [x19, #9]
40035108: 39400260 ldrb w0, [x19]
4003510c: 39400661 ldrb w1, [x19, #1]
40035110: 39400a63 ldrb w3, [x19, #2]
40035114: aa052045 orr x5, x2, x5, lsl #8
40035118: 39400e74 ldrb w20, [x19, #3]
4003511c: 5ac004a5 rev16 w5, w5
40035120: aa012001 orr x1, x0, x1, lsl #8
40035124: 12003cb9 and w25, w5, #0xffff
eino = rtems_rfs_dir_entry_ino (entry);
40035128: aa034023 orr x3, x1, x3, lsl #16
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4003512c: 6b1c033f cmp w25, w28
40035130: aa146074 orr x20, x3, x20, lsl #24
40035134: 5ac00a94 rev w20, w20
40035138: 54fffc81 b.ne 400350c8 <rtems_rfs_dir_add_entry+0x168> // b.any
(rtems_rfs_fs_block_size (fs) - offset))
4003513c: cb0400e4 sub x4, x7, x4
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
40035140: 91002ac0 add x0, x22, #0xa
40035144: eb04001f cmp x0, x4
40035148: 54fff462 b.cs 40034fd4 <rtems_rfs_dir_add_entry+0x74> // b.hs, b.nlast<== NEVER TAKEN
hash = rtems_rfs_dir_hash (name, length);
4003514c: aa1603e1 mov x1, x22
40035150: aa1703e0 mov x0, x23
40035154: 940002eb bl 40035d00 <rtems_rfs_dir_hash>
40035158: 2a0003e3 mov w3, w0
rtems_rfs_dir_set_entry_length (entry,
4003515c: 11002ac4 add w4, w22, #0xa
rtems_rfs_dir_set_entry_hash (entry, hash);
40035160: 53187c08 lsr w8, w0, #24
40035164: 53107c07 lsr w7, w0, #16
40035168: 53087c06 lsr w6, w0, #8
rtems_rfs_dir_set_entry_length (entry,
4003516c: d3483c85 ubfx x5, x4, #8, #8
rtems_rfs_dir_set_entry_ino (entry, ino);
40035170: 53087f09 lsr w9, w24, #8
40035174: 53187f01 lsr w1, w24, #24
40035178: 53107f00 lsr w0, w24, #16
4003517c: 39000261 strb w1, [x19]
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
40035180: aa1603e2 mov x2, x22
rtems_rfs_dir_set_entry_ino (entry, ino);
40035184: 39000660 strb w0, [x19, #1]
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
40035188: aa1703e1 mov x1, x23
rtems_rfs_dir_set_entry_ino (entry, ino);
4003518c: 39000a69 strb w9, [x19, #2]
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
40035190: 91002a60 add x0, x19, #0xa
rtems_rfs_dir_set_entry_ino (entry, ino);
40035194: 39000e78 strb w24, [x19, #3]
return 0;
40035198: 52800014 mov w20, #0x0 // #0
rtems_rfs_dir_set_entry_hash (entry, hash);
4003519c: 39001268 strb w8, [x19, #4]
400351a0: 39001667 strb w7, [x19, #5]
400351a4: 39001a66 strb w6, [x19, #6]
400351a8: 39001e63 strb w3, [x19, #7]
rtems_rfs_dir_set_entry_length (entry,
400351ac: 39002265 strb w5, [x19, #8]
400351b0: 39002664 strb w4, [x19, #9]
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
400351b4: 94002328 bl 4003de54 <memcpy>
rtems_rfs_buffer_mark_dirty (&buffer);
400351b8: 52800022 mov w2, #0x1 // #1
rtems_rfs_buffer_handle_release (fs, handle);
400351bc: 910203e1 add x1, sp, #0x80
400351c0: aa1a03e0 mov x0, x26
400351c4: 390203e2 strb w2, [sp, #128]
400351c8: 97ffc832 bl 40027290 <rtems_rfs_buffer_handle_release>
handle->dirty = false;
400351cc: 14000009 b 400351f0 <rtems_rfs_dir_add_entry+0x290>
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
400351d0: d2a40000 mov x0, #0x20000000 // #536870912 <== NOT EXECUTED
400351d4: 97ffd61f bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
400351d8: 72001c1f tst w0, #0xff <== NOT EXECUTED
400351dc: 54000621 b.ne 400352a0 <rtems_rfs_dir_add_entry+0x340> // b.any <== NOT EXECUTED
return EIO;
400351e0: 528000b4 mov w20, #0x5 // #5 <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
400351e4: 910203e1 add x1, sp, #0x80 <== NOT EXECUTED
400351e8: aa1a03e0 mov x0, x26 <== NOT EXECUTED
400351ec: 97ffc829 bl 40027290 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
400351f0: 910243e1 add x1, sp, #0x90
400351f4: aa1a03e0 mov x0, x26
handle->dirty = false;
400351f8: 390203ff strb wzr, [sp, #128]
handle->bnum = 0;
400351fc: b90087ff str wzr, [sp, #132]
handle->buffer = NULL;
40035200: f90047ff str xzr, [sp, #136]
40035204: 97fffb23 bl 40033e90 <rtems_rfs_block_map_close>
}
40035208: 2a1403e0 mov w0, w20
4003520c: a94153f3 ldp x19, x20, [sp, #16]
40035210: a9425bf5 ldp x21, x22, [sp, #32]
40035214: a94363f7 ldp x23, x24, [sp, #48]
40035218: a9446bf9 ldp x25, x26, [sp, #64]
return EIO;
4003521c: a94573fb ldp x27, x28, [sp, #80]
}
40035220: a8cf7bfd ldp x29, x30, [sp], #240
40035224: d65f03c0 ret
printf ("rtems-rfs: dir-add-entry: dir=%" PRId32 ", name=",
40035228: b94012a1 ldr w1, [x21, #16] <== NOT EXECUTED
4003522c: b00000a0 adrp x0, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
40035230: 91220000 add x0, x0, #0x880 <== NOT EXECUTED
40035234: 97ffb477 bl 40022410 <__wrap_printf> <== NOT EXECUTED
for (c = 0; c < length; c++)
40035238: b4000116 cbz x22, 40035258 <rtems_rfs_dir_add_entry+0x2f8> <== NOT EXECUTED
4003523c: aa1703f3 mov x19, x23 <== NOT EXECUTED
40035240: 8b1602f4 add x20, x23, x22 <== NOT EXECUTED
40035244: d503201f nop <== NOT EXECUTED
printf ("%c", name[c]);
40035248: 38401660 ldrb w0, [x19], #1 <== NOT EXECUTED
4003524c: 9400236d bl 4003e000 <putchar> <== NOT EXECUTED
for (c = 0; c < length; c++)
40035250: eb14027f cmp x19, x20 <== NOT EXECUTED
40035254: 54ffffa1 b.ne 40035248 <rtems_rfs_dir_add_entry+0x2e8> // b.any <== NOT EXECUTED
printf (", len=%zd\n", length);
40035258: aa1603e1 mov x1, x22 <== NOT EXECUTED
4003525c: b00000a0 adrp x0, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
40035260: 9122a000 add x0, x0, #0x8a8 <== NOT EXECUTED
40035264: 97ffb46b bl 40022410 <__wrap_printf> <== NOT EXECUTED
40035268: 17ffff4d b 40034f9c <rtems_rfs_dir_add_entry+0x3c> <== NOT EXECUTED
bpos.bno++;
4003526c: 294d93e2 ldp w2, w4, [sp, #108]
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
40035270: 910203e1 add x1, sp, #0x80
40035274: aa1a03e0 mov x0, x26
40035278: 52800023 mov w3, #0x1 // #1
bpos.bno++;
4003527c: 11000484 add w4, w4, #0x1
40035280: b90073e4 str w4, [sp, #112]
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
40035284: 97ffc753 bl 40026fd0 <rtems_rfs_buffer_handle_request>
40035288: 2a0003f4 mov w20, w0
if (rc > 0)
4003528c: 7100001f cmp w0, #0x0
40035290: 54ffedac b.gt 40035044 <rtems_rfs_dir_add_entry+0xe4> <== NEVER TAKEN
entry = rtems_rfs_buffer_data (&buffer);
40035294: f94047e0 ldr x0, [sp, #136]
40035298: f9401c13 ldr x19, [x0, #56]
if (!read)
4003529c: 17ffff85 b 400350b0 <rtems_rfs_dir_add_entry+0x150>
printf ("rtems-rfs: dir-add-entry: "
400352a0: b94012a1 ldr w1, [x21, #16] <== NOT EXECUTED
400352a4: 2a1b03e4 mov w4, w27 <== NOT EXECUTED
400352a8: 2a1403e3 mov w3, w20 <== NOT EXECUTED
400352ac: 2a1903e2 mov w2, w25 <== NOT EXECUTED
400352b0: b00000a0 adrp x0, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
400352b4: 91264000 add x0, x0, #0x990 <== NOT EXECUTED
400352b8: 97ffb456 bl 40022410 <__wrap_printf> <== NOT EXECUTED
400352bc: 17ffffc9 b 400351e0 <rtems_rfs_dir_add_entry+0x280> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
400352c0: d2a40000 mov x0, #0x20000000 // #536870912 <== NOT EXECUTED
400352c4: 97ffd5e3 bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
400352c8: 72001c1f tst w0, #0xff <== NOT EXECUTED
400352cc: 54ffec40 b.eq 40035054 <rtems_rfs_dir_add_entry+0xf4> // b.none <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
400352d0: b94012b3 ldr w19, [x21, #16] <== NOT EXECUTED
400352d4: 2a1403e0 mov w0, w20 <== NOT EXECUTED
400352d8: 94002651 bl 4003ec1c <strerror> <== NOT EXECUTED
400352dc: aa0003e3 mov x3, x0 <== NOT EXECUTED
400352e0: 2a1303e1 mov w1, w19 <== NOT EXECUTED
400352e4: 2a1403e2 mov w2, w20 <== NOT EXECUTED
400352e8: b00000a0 adrp x0, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
400352ec: 91240000 add x0, x0, #0x900 <== NOT EXECUTED
400352f0: 97ffb448 bl 40022410 <__wrap_printf> <== NOT EXECUTED
400352f4: 17ffff58 b 40035054 <rtems_rfs_dir_add_entry+0xf4> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
400352f8: d2a40000 mov x0, #0x20000000 // #536870912 <== NOT EXECUTED
400352fc: 97ffd5d5 bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
40035300: 72001c1f tst w0, #0xff <== NOT EXECUTED
40035304: 54ffea80 b.eq 40035054 <rtems_rfs_dir_add_entry+0xf4> // b.none <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
40035308: b94012b3 ldr w19, [x21, #16] <== NOT EXECUTED
4003530c: 2a1403e0 mov w0, w20 <== NOT EXECUTED
40035310: 94002643 bl 4003ec1c <strerror> <== NOT EXECUTED
40035314: aa0003e3 mov x3, x0 <== NOT EXECUTED
40035318: 2a1303e1 mov w1, w19 <== NOT EXECUTED
4003531c: 2a1403e2 mov w2, w20 <== NOT EXECUTED
40035320: b00000a0 adrp x0, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
40035324: 9122e000 add x0, x0, #0x8b8 <== NOT EXECUTED
40035328: 97ffb43a bl 40022410 <__wrap_printf> <== NOT EXECUTED
4003532c: 17ffff4a b 40035054 <rtems_rfs_dir_add_entry+0xf4> <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
40035330: b94012b3 ldr w19, [x21, #16] <== NOT EXECUTED
40035334: 2a1403e0 mov w0, w20 <== NOT EXECUTED
40035338: 94002639 bl 4003ec1c <strerror> <== NOT EXECUTED
4003533c: aa0003e3 mov x3, x0 <== NOT EXECUTED
40035340: 2a1303e1 mov w1, w19 <== NOT EXECUTED
40035344: 2a1403e2 mov w2, w20 <== NOT EXECUTED
40035348: b00000a0 adrp x0, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
4003534c: 91252000 add x0, x0, #0x948 <== NOT EXECUTED
40035350: 97ffb430 bl 40022410 <__wrap_printf> <== NOT EXECUTED
40035354: 17ffff40 b 40035054 <rtems_rfs_dir_add_entry+0xf4> <== NOT EXECUTED
...
0000000040035360 <rtems_rfs_dir_del_entry>:
int
rtems_rfs_dir_del_entry (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir,
rtems_rfs_ino ino,
uint32_t offset)
{
40035360: a9b17bfd stp x29, x30, [sp, #-240]!
40035364: 910003fd mov x29, sp
40035368: a9025bf5 stp x21, x22, [sp, #32]
4003536c: aa0103f6 mov x22, x1
40035370: a9046bf9 stp x25, x26, [sp, #64]
40035374: aa0003f9 mov x25, x0
rtems_rfs_block_no block;
rtems_rfs_buffer_handle buffer;
bool search;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
40035378: d2a80000 mov x0, #0x40000000 // #1073741824
{
4003537c: a90573fb stp x27, x28, [sp, #80]
40035380: 2a0203fc mov w28, w2
40035384: 2a0303fb mov w27, w3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
40035388: 97ffd5b2 bl 4002aa50 <rtems_rfs_trace>
4003538c: 72001c1f tst w0, #0xff
40035390: 54000ec1 b.ne 40035568 <rtems_rfs_dir_del_entry+0x208> // b.any <== NEVER TAKEN
printf ("rtems-rfs: dir-del-entry: dir=%" PRId32 ", entry=%" PRId32 " offset=%" PRIu32 "\n",
rtems_rfs_inode_ino (dir), ino, offset);
rc = rtems_rfs_block_map_open (fs, dir, &map);
40035394: aa1603e1 mov x1, x22
40035398: 910243e2 add x2, sp, #0x90
4003539c: aa1903e0 mov x0, x25
400353a0: 97fffa58 bl 40033d00 <rtems_rfs_block_map_open>
400353a4: 2a0003fa mov w26, w0
if (rc > 0)
400353a8: 7100001f cmp w0, #0x0
400353ac: 540000ed b.le 400353c8 <rtems_rfs_dir_del_entry+0x68> <== ALWAYS TAKEN
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
400353b0: 2a1a03e0 mov w0, w26 <== NOT EXECUTED
400353b4: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
400353b8: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
400353bc: a94573fb ldp x27, x28, [sp, #80] <== NOT EXECUTED
400353c0: a8cf7bfd ldp x29, x30, [sp], #240 <== NOT EXECUTED
400353c4: d65f03c0 ret <== NOT EXECUTED
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
400353c8: 2a1b03e0 mov w0, w27
400353cc: 9101f3e3 add x3, sp, #0x7c
400353d0: aa0003e2 mov x2, x0
400353d4: 910243e1 add x1, sp, #0x90
400353d8: f90037e0 str x0, [sp, #104]
400353dc: aa1903e0 mov x0, x25
400353e0: 97fffb78 bl 400341c0 <rtems_rfs_block_map_seek>
400353e4: 2a0003fa mov w26, w0
if (rc > 0)
400353e8: 7100001f cmp w0, #0x0
400353ec: 54000dec b.gt 400355a8 <rtems_rfs_dir_del_entry+0x248> <== NEVER TAKEN
handle->dirty = false;
400353f0: a90153f3 stp x19, x20, [sp, #16]
400353f4: a90363f7 stp x23, x24, [sp, #48]
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
400353f8: 529ffff7 mov w23, #0xffff // #65535
400353fc: 390203ff strb wzr, [sp, #128]
handle->bnum = 0;
40035400: b90087ff str wzr, [sp, #132]
handle->buffer = NULL;
40035404: f90047ff str xzr, [sp, #136]
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
40035408: b9407fe2 ldr w2, [sp, #124]
4003540c: 910203e1 add x1, sp, #0x80
40035410: aa1903e0 mov x0, x25
40035414: 52800023 mov w3, #0x1 // #1
40035418: 97ffc6ee bl 40026fd0 <rtems_rfs_buffer_handle_request>
4003541c: 2a0003fa mov w26, w0
if (rc > 0)
40035420: 7100001f cmp w0, #0x0
40035424: 540018ec b.gt 40035740 <rtems_rfs_dir_del_entry+0x3e0> <== NEVER TAKEN
eoffset = offset % rtems_rfs_fs_block_size (fs);
40035428: f9400b23 ldr x3, [x25, #16]
if (search)
4003542c: 340006db cbz w27, 40035504 <rtems_rfs_dir_del_entry+0x1a4> <== NEVER TAKEN
eoffset = offset % rtems_rfs_fs_block_size (fs);
40035430: f94037e0 ldr x0, [sp, #104]
40035434: 9ac30813 udiv x19, x0, x3
40035438: 9b038273 msub x19, x19, x3, x0
4003543c: 2a1303f8 mov w24, w19
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
40035440: 93407e60 sxtw x0, w19
40035444: f94047e1 ldr x1, [sp, #136]
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
40035448: d1002862 sub x2, x3, #0xa
4003544c: eb00005f cmp x2, x0
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
40035450: f9401c33 ldr x19, [x1, #56]
40035454: 8b000273 add x19, x19, x0
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
40035458: 54000248 b.hi 400354a0 <rtems_rfs_dir_del_entry+0x140> // b.pmore <== ALWAYS TAKEN
4003545c: 14000020 b 400354dc <rtems_rfs_dir_del_entry+0x17c> <== NOT EXECUTED
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
40035460: 71002abf cmp w21, #0xa
40035464: 5400056d b.le 40035510 <rtems_rfs_dir_del_entry+0x1b0> <== NEVER TAKEN
40035468: b9403321 ldr w1, [x25, #48]
4003546c: 6b15003f cmp w1, w21
40035470: 54000509 b.ls 40035510 <rtems_rfs_dir_del_entry+0x1b0> // b.plast <== NEVER TAKEN
40035474: 340004f4 cbz w20, 40035510 <rtems_rfs_dir_del_entry+0x1b0> <== NEVER TAKEN
40035478: b9402b20 ldr w0, [x25, #40]
4003547c: 6b14001f cmp w0, w20
40035480: 54000483 b.cc 40035510 <rtems_rfs_dir_del_entry+0x1b0> // b.lo, b.ul, b.last<== NEVER TAKEN
if (ino == rtems_rfs_dir_entry_ino (entry))
40035484: 6b14039f cmp w28, w20
40035488: 54000a80 b.eq 400355d8 <rtems_rfs_dir_del_entry+0x278> // b.none <== ALWAYS TAKEN
eoffset += elength;
4003548c: 0b150318 add w24, w24, w21 <== NOT EXECUTED
if (!search)
40035490: 350014fb cbnz w27, 4003572c <rtems_rfs_dir_del_entry+0x3cc> <== NOT EXECUTED
entry += elength;
40035494: 8b242273 add x19, x19, w4, uxth <== NOT EXECUTED
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
40035498: eb38c05f cmp x2, w24, sxtw <== NOT EXECUTED
4003549c: 54000209 b.ls 400354dc <rtems_rfs_dir_del_entry+0x17c> // b.plast <== NOT EXECUTED
entry += elength;
400354a0: 39402267 ldrb w7, [x19, #8]
400354a4: 39402664 ldrb w4, [x19, #9]
400354a8: 39400266 ldrb w6, [x19]
400354ac: 39400665 ldrb w5, [x19, #1]
400354b0: 39400a61 ldrb w1, [x19, #2]
400354b4: aa0420e4 orr x4, x7, x4, lsl #8
400354b8: 39400e74 ldrb w20, [x19, #3]
400354bc: 5ac00484 rev16 w4, w4
400354c0: aa0520c5 orr x5, x6, x5, lsl #8
400354c4: 12003c95 and w21, w4, #0xffff
eino = rtems_rfs_dir_entry_ino (entry);
400354c8: aa0140a1 orr x1, x5, x1, lsl #16
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
400354cc: 6b1702bf cmp w21, w23
400354d0: aa146034 orr x20, x1, x20, lsl #24
400354d4: 5ac00a94 rev w20, w20
400354d8: 54fffc41 b.ne 40035460 <rtems_rfs_dir_del_entry+0x100> // b.any <== ALWAYS TAKEN
if (rc == 0)
400354dc: 3500025a cbnz w26, 40035524 <rtems_rfs_dir_del_entry+0x1c4> <== NOT EXECUTED
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
400354e0: 9101f3e2 add x2, sp, #0x7c <== NOT EXECUTED
400354e4: 910243e1 add x1, sp, #0x90 <== NOT EXECUTED
400354e8: aa1903e0 mov x0, x25 <== NOT EXECUTED
400354ec: 97fffb45 bl 40034200 <rtems_rfs_block_map_next_block> <== NOT EXECUTED
400354f0: 2a0003fa mov w26, w0 <== NOT EXECUTED
if (rc == ENXIO)
400354f4: 7100181f cmp w0, #0x6 <== NOT EXECUTED
400354f8: 54001400 b.eq 40035778 <rtems_rfs_dir_del_entry+0x418> // b.none <== NOT EXECUTED
while (rc == 0)
400354fc: 34fff860 cbz w0, 40035408 <rtems_rfs_dir_del_entry+0xa8> <== NOT EXECUTED
40035500: 14000009 b 40035524 <rtems_rfs_dir_del_entry+0x1c4> <== NOT EXECUTED
40035504: d2800000 mov x0, #0x0 // #0 <== NOT EXECUTED
eoffset = 0;
40035508: 52800018 mov w24, #0x0 // #0 <== NOT EXECUTED
4003550c: 17ffffce b 40035444 <rtems_rfs_dir_del_entry+0xe4> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
40035510: d2a80000 mov x0, #0x40000000 // #1073741824 <== NOT EXECUTED
rc = EIO;
40035514: 528000ba mov w26, #0x5 // #5 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
40035518: 97ffd54e bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
4003551c: 72001c1f tst w0, #0xff <== NOT EXECUTED
40035520: 54000321 b.ne 40035584 <rtems_rfs_dir_del_entry+0x224> // b.any <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40035524: 910203e1 add x1, sp, #0x80 <== NOT EXECUTED
40035528: aa1903e0 mov x0, x25 <== NOT EXECUTED
4003552c: 97ffc759 bl 40027290 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
40035530: 390203ff strb wzr, [sp, #128] <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
40035534: 910243e1 add x1, sp, #0x90 <== NOT EXECUTED
40035538: aa1903e0 mov x0, x25 <== NOT EXECUTED
handle->bnum = 0;
4003553c: b90087ff str wzr, [sp, #132] <== NOT EXECUTED
handle->buffer = NULL;
40035540: f90047ff str xzr, [sp, #136] <== NOT EXECUTED
40035544: 97fffa53 bl 40033e90 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
40035548: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
4003554c: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
}
40035550: 2a1a03e0 mov w0, w26
40035554: a9425bf5 ldp x21, x22, [sp, #32]
40035558: a9446bf9 ldp x25, x26, [sp, #64]
4003555c: a94573fb ldp x27, x28, [sp, #80]
40035560: a8cf7bfd ldp x29, x30, [sp], #240
40035564: d65f03c0 ret
printf ("rtems-rfs: dir-del-entry: dir=%" PRId32 ", entry=%" PRId32 " offset=%" PRIu32 "\n",
40035568: b94012c1 ldr w1, [x22, #16] <== NOT EXECUTED
4003556c: 2a1b03e3 mov w3, w27 <== NOT EXECUTED
40035570: 2a1c03e2 mov w2, w28 <== NOT EXECUTED
40035574: b00000a0 adrp x0, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
40035578: 91276000 add x0, x0, #0x9d8 <== NOT EXECUTED
4003557c: 97ffb3a5 bl 40022410 <__wrap_printf> <== NOT EXECUTED
40035580: 17ffff85 b 40035394 <rtems_rfs_dir_del_entry+0x34> <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
40035584: b94012c1 ldr w1, [x22, #16] <== NOT EXECUTED
40035588: 2a1803e5 mov w5, w24 <== NOT EXECUTED
4003558c: b9407fe4 ldr w4, [sp, #124] <== NOT EXECUTED
40035590: 2a1403e3 mov w3, w20 <== NOT EXECUTED
40035594: 2a1503e2 mov w2, w21 <== NOT EXECUTED
40035598: b00000a0 adrp x0, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
4003559c: 91296000 add x0, x0, #0xa58 <== NOT EXECUTED
400355a0: 97ffb39c bl 40022410 <__wrap_printf> <== NOT EXECUTED
while (rc == 0)
400355a4: 17ffffe0 b 40035524 <rtems_rfs_dir_del_entry+0x1c4> <== NOT EXECUTED
rc = ENOENT;
400355a8: 7100181f cmp w0, #0x6 <== NOT EXECUTED
400355ac: 52800042 mov w2, #0x2 // #2 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
400355b0: 910243e1 add x1, sp, #0x90 <== NOT EXECUTED
rc = ENOENT;
400355b4: 1a82135a csel w26, w26, w2, ne // ne = any <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
400355b8: aa1903e0 mov x0, x25 <== NOT EXECUTED
400355bc: 97fffa35 bl 40033e90 <rtems_rfs_block_map_close> <== NOT EXECUTED
}
400355c0: 2a1a03e0 mov w0, w26 <== NOT EXECUTED
400355c4: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
400355c8: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
400355cc: a94573fb ldp x27, x28, [sp, #80] <== NOT EXECUTED
400355d0: a8cf7bfd ldp x29, x30, [sp], #240 <== NOT EXECUTED
400355d4: d65f03c0 ret <== NOT EXECUTED
remaining = rtems_rfs_fs_block_size (fs) - (eoffset + elength);
400355d8: 0b150317 add w23, w24, w21
memmove (entry, entry + elength, remaining);
400355dc: 8b352261 add x1, x19, w21, uxth
400355e0: 4b170077 sub w23, w3, w23
400355e4: aa1303e0 mov x0, x19
400355e8: aa1703e2 mov x2, x23
400355ec: 92403eba and x26, x21, #0xffff
400355f0: 94002234 bl 4003dec0 <memmove>
memset (entry + remaining, 0xff, elength);
400355f4: aa1a03e2 mov x2, x26
400355f8: 8b170260 add x0, x19, x23
400355fc: 52801fe1 mov w1, #0xff // #255
40035600: 9400226b bl 4003dfac <memset>
elength = rtems_rfs_dir_entry_length (entry);
40035604: 39402261 ldrb w1, [x19, #8]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
40035608: d2a80000 mov x0, #0x40000000 // #1073741824
4003560c: 39402673 ldrb w19, [x19, #9]
40035610: aa132033 orr x19, x1, x19, lsl #8
40035614: 97ffd50f bl 4002aa50 <rtems_rfs_trace>
40035618: 5ac00673 rev16 w19, w19
4003561c: 72001c1f tst w0, #0xff
40035620: 12003e73 and w19, w19, #0xffff
40035624: 54000260 b.eq 40035670 <rtems_rfs_dir_del_entry+0x310> // b.none <== ALWAYS TAKEN
rtems_rfs_block_map_last (&map) ? "yes" : "no");
40035628: b940a3e0 ldr w0, [sp, #160] <== NOT EXECUTED
4003562c: b940abe2 ldr w2, [sp, #168] <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
40035630: b9407fe3 ldr w3, [sp, #124] <== NOT EXECUTED
rtems_rfs_block_map_last (&map) ? "yes" : "no");
40035634: 2a000041 orr w1, w2, w0 <== NOT EXECUTED
40035638: 340007e1 cbz w1, 40035734 <rtems_rfs_dir_del_entry+0x3d4> <== NOT EXECUTED
4003563c: 51000400 sub w0, w0, #0x1 <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
40035640: 900000a1 adrp x1, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40035644: 91252021 add x1, x1, #0x948 <== NOT EXECUTED
40035648: 6b00005f cmp w2, w0 <== NOT EXECUTED
4003564c: 900000a5 adrp x5, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40035650: 912500a5 add x5, x5, #0x940 <== NOT EXECUTED
40035654: 9a8100a5 csel x5, x5, x1, eq // eq = none <== NOT EXECUTED
40035658: b00000a0 adrp x0, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
4003565c: 2a1403e1 mov w1, w20 <== NOT EXECUTED
40035660: 2a1803e4 mov w4, w24 <== NOT EXECUTED
40035664: 912aa000 add x0, x0, #0xaa8 <== NOT EXECUTED
40035668: 2a1303e2 mov w2, w19 <== NOT EXECUTED
4003566c: 97ffb369 bl 40022410 <__wrap_printf> <== NOT EXECUTED
if ((elength == RTEMS_RFS_DIR_ENTRY_EMPTY) &&
40035670: 7100031f cmp w24, #0x0
40035674: 529fffe0 mov w0, #0xffff // #65535
40035678: 7a400260 ccmp w19, w0, #0x0, eq // eq = none
4003567c: 54000321 b.ne 400356e0 <rtems_rfs_dir_del_entry+0x380> // b.any <== ALWAYS TAKEN
(eoffset == 0) && rtems_rfs_block_map_last (&map))
40035680: b940a3e0 ldr w0, [sp, #160] <== NOT EXECUTED
40035684: b940abe1 ldr w1, [sp, #168] <== NOT EXECUTED
40035688: 2a000022 orr w2, w1, w0 <== NOT EXECUTED
4003568c: 35000482 cbnz w2, 4003571c <rtems_rfs_dir_del_entry+0x3bc> <== NOT EXECUTED
rc = rtems_rfs_block_map_shrink (fs, &map, 1);
40035690: 910243e1 add x1, sp, #0x90 <== NOT EXECUTED
40035694: aa1903e0 mov x0, x25 <== NOT EXECUTED
40035698: d2800022 mov x2, #0x1 // #1 <== NOT EXECUTED
4003569c: 97fffbd5 bl 400345f0 <rtems_rfs_block_map_shrink> <== NOT EXECUTED
400356a0: 2a0003f3 mov w19, w0 <== NOT EXECUTED
if (rc > 0)
400356a4: 7100001f cmp w0, #0x0 <== NOT EXECUTED
400356a8: 540001cd b.le 400356e0 <rtems_rfs_dir_del_entry+0x380> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
400356ac: d2a80000 mov x0, #0x40000000 // #1073741824 <== NOT EXECUTED
400356b0: 97ffd4e8 bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
400356b4: 72001c1f tst w0, #0xff <== NOT EXECUTED
400356b8: 54000140 b.eq 400356e0 <rtems_rfs_dir_del_entry+0x380> // b.none <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
400356bc: b94012d4 ldr w20, [x22, #16] <== NOT EXECUTED
400356c0: 2a1303e0 mov w0, w19 <== NOT EXECUTED
400356c4: 94002556 bl 4003ec1c <strerror> <== NOT EXECUTED
400356c8: aa0003e3 mov x3, x0 <== NOT EXECUTED
400356cc: 2a1403e1 mov w1, w20 <== NOT EXECUTED
400356d0: b00000a0 adrp x0, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
400356d4: 912c2000 add x0, x0, #0xb08 <== NOT EXECUTED
400356d8: 2a1303e2 mov w2, w19 <== NOT EXECUTED
400356dc: 97ffb34d bl 40022410 <__wrap_printf> <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&buffer);
400356e0: 52800022 mov w2, #0x1 // #1
rtems_rfs_buffer_handle_release (fs, handle);
400356e4: 910203e1 add x1, sp, #0x80
400356e8: aa1903e0 mov x0, x25
400356ec: 390203e2 strb w2, [sp, #128]
400356f0: 97ffc6e8 bl 40027290 <rtems_rfs_buffer_handle_release>
return 0;
400356f4: 5280001a mov w26, #0x0 // #0
rtems_rfs_block_map_close (fs, &map);
400356f8: 910243e1 add x1, sp, #0x90
400356fc: aa1903e0 mov x0, x25
handle->dirty = false;
40035700: 390203ff strb wzr, [sp, #128]
handle->bnum = 0;
40035704: b90087ff str wzr, [sp, #132]
handle->buffer = NULL;
40035708: f90047ff str xzr, [sp, #136]
rtems_rfs_block_map_close (fs, &map);
4003570c: 97fff9e1 bl 40033e90 <rtems_rfs_block_map_close>
return rc;
40035710: a94153f3 ldp x19, x20, [sp, #16]
40035714: a94363f7 ldp x23, x24, [sp, #48]
40035718: 17ffff8e b 40035550 <rtems_rfs_dir_del_entry+0x1f0>
(eoffset == 0) && rtems_rfs_block_map_last (&map))
4003571c: 51000400 sub w0, w0, #0x1 <== NOT EXECUTED
40035720: 6b00003f cmp w1, w0 <== NOT EXECUTED
40035724: 54fffde1 b.ne 400356e0 <rtems_rfs_dir_del_entry+0x380> // b.any <== NOT EXECUTED
40035728: 17ffffda b 40035690 <rtems_rfs_dir_del_entry+0x330> <== NOT EXECUTED
rc = EIO;
4003572c: 528000ba mov w26, #0x5 // #5 <== NOT EXECUTED
while (rc == 0)
40035730: 17ffff7d b 40035524 <rtems_rfs_dir_del_entry+0x1c4> <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
40035734: 900000a5 adrp x5, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40035738: 912500a5 add x5, x5, #0x940 <== NOT EXECUTED
4003573c: 17ffffc7 b 40035658 <rtems_rfs_dir_del_entry+0x2f8> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
40035740: d2a80000 mov x0, #0x40000000 // #1073741824 <== NOT EXECUTED
40035744: 97ffd4c3 bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
40035748: 72001c1f tst w0, #0xff <== NOT EXECUTED
4003574c: 54ffeec0 b.eq 40035524 <rtems_rfs_dir_del_entry+0x1c4> // b.none <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
40035750: b94012d3 ldr w19, [x22, #16] <== NOT EXECUTED
40035754: 2a1a03e0 mov w0, w26 <== NOT EXECUTED
40035758: 94002531 bl 4003ec1c <strerror> <== NOT EXECUTED
4003575c: aa0003e3 mov x3, x0 <== NOT EXECUTED
40035760: 2a1303e1 mov w1, w19 <== NOT EXECUTED
40035764: 2a1a03e2 mov w2, w26 <== NOT EXECUTED
40035768: b00000a0 adrp x0, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
4003576c: 91284000 add x0, x0, #0xa10 <== NOT EXECUTED
40035770: 97ffb328 bl 40022410 <__wrap_printf> <== NOT EXECUTED
40035774: 17ffff6c b 40035524 <rtems_rfs_dir_del_entry+0x1c4> <== NOT EXECUTED
rc = ENOENT;
40035778: 5280005a mov w26, #0x2 // #2 <== NOT EXECUTED
4003577c: 17ffff6a b 40035524 <rtems_rfs_dir_del_entry+0x1c4> <== NOT EXECUTED
0000000040035ab0 <rtems_rfs_dir_empty>:
int
rtems_rfs_dir_empty (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir)
{
40035ab0: a9b37bfd stp x29, x30, [sp, #-208]!
40035ab4: 910003fd mov x29, sp
40035ab8: a9025bf5 stp x21, x22, [sp, #32]
40035abc: aa0103f5 mov x21, x1
40035ac0: a90363f7 stp x23, x24, [sp, #48]
40035ac4: aa0003f8 mov x24, x0
rtems_rfs_buffer_handle buffer;
rtems_rfs_block_no block;
bool empty;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
40035ac8: d2b00000 mov x0, #0x80000000 // #2147483648
{
40035acc: a9046bf9 stp x25, x26, [sp, #64]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
40035ad0: 97ffd3e0 bl 4002aa50 <rtems_rfs_trace>
40035ad4: 72001c1f tst w0, #0xff
40035ad8: 54000f61 b.ne 40035cc4 <rtems_rfs_dir_empty+0x214> // b.any <== NEVER TAKEN
printf ("rtems-rfs: dir-empty: dir=%" PRId32 "\n", rtems_rfs_inode_ino (dir));
empty = true;
rc = rtems_rfs_block_map_open (fs, dir, &map);
40035adc: aa1503e1 mov x1, x21
40035ae0: 9101c3e2 add x2, sp, #0x70
40035ae4: aa1803e0 mov x0, x24
40035ae8: 97fff886 bl 40033d00 <rtems_rfs_block_map_open>
40035aec: 2a0003fa mov w26, w0
if (rc > 0)
40035af0: 7100001f cmp w0, #0x0
40035af4: 540000ed b.le 40035b10 <rtems_rfs_dir_empty+0x60> <== ALWAYS TAKEN
rc = ENOTEMPTY;
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
40035af8: 2a1a03e0 mov w0, w26 <== NOT EXECUTED
40035afc: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
40035b00: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
40035b04: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
40035b08: a8cd7bfd ldp x29, x30, [sp], #208 <== NOT EXECUTED
40035b0c: d65f03c0 ret <== NOT EXECUTED
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
40035b10: 910173e3 add x3, sp, #0x5c
40035b14: 9101c3e1 add x1, sp, #0x70
40035b18: aa1803e0 mov x0, x24
40035b1c: d2800002 mov x2, #0x0 // #0
40035b20: 97fff9a8 bl 400341c0 <rtems_rfs_block_map_seek>
40035b24: 2a0003fa mov w26, w0
if (rc > 0)
40035b28: 7100001f cmp w0, #0x0
40035b2c: 54000d6c b.gt 40035cd8 <rtems_rfs_dir_empty+0x228> <== NEVER TAKEN
printf ("rtems-rfs: dir-empty: "
40035b30: b00000b6 adrp x22, 4004a000 <status_code_text+0x38>
40035b34: 913142d6 add x22, x22, #0xc50
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
40035b38: 529ffff9 mov w25, #0xffff // #65535
40035b3c: a90153f3 stp x19, x20, [sp, #16]
handle->dirty = false;
40035b40: 390183ff strb wzr, [sp, #96]
handle->bnum = 0;
40035b44: b90067ff str wzr, [sp, #100]
handle->buffer = NULL;
40035b48: f90037ff str xzr, [sp, #104]
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
40035b4c: b9405fe2 ldr w2, [sp, #92]
40035b50: 910183e1 add x1, sp, #0x60
40035b54: aa1803e0 mov x0, x24
40035b58: 52800023 mov w3, #0x1 // #1
40035b5c: 97ffc51d bl 40026fd0 <rtems_rfs_buffer_handle_request>
40035b60: 2a0003fa mov w26, w0
if (rc > 0)
40035b64: 7100001f cmp w0, #0x0
40035b68: 5400068c b.gt 40035c38 <rtems_rfs_dir_empty+0x188> <== NEVER TAKEN
entry = rtems_rfs_buffer_data (&buffer);
40035b6c: f94037e0 ldr x0, [sp, #104]
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
40035b70: f9400b07 ldr x7, [x24, #16]
entry = rtems_rfs_buffer_data (&buffer);
40035b74: f9401c05 ldr x5, [x0, #56]
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
40035b78: f10028e7 subs x7, x7, #0xa
40035b7c: 54000920 b.eq 40035ca0 <rtems_rfs_dir_empty+0x1f0> // b.none <== NEVER TAKEN
offset = 0;
40035b80: 52800017 mov w23, #0x0 // #0
40035b84: 1400000d b 40035bb8 <rtems_rfs_dir_empty+0x108>
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.')) &&
40035b88: 7100329f cmp w20, #0xc
40035b8c: 54000501 b.ne 40035c2c <rtems_rfs_dir_empty+0x17c> // b.any
((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 2)) ||
40035b90: 394028a1 ldrb w1, [x5, #10]
40035b94: 7100b83f cmp w1, #0x2e
40035b98: 540004a1 b.ne 40035c2c <rtems_rfs_dir_empty+0x17c> // b.any <== NEVER TAKEN
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.') ||
40035b9c: 39402ca1 ldrb w1, [x5, #11]
40035ba0: 7100b83f cmp w1, #0x2e
40035ba4: 54000441 b.ne 40035c2c <rtems_rfs_dir_empty+0x17c> // b.any <== NEVER TAKEN
offset += elength;
40035ba8: 0b1402f7 add w23, w23, w20
entry += elength;
40035bac: 8b2620a5 add x5, x5, w6, uxth
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
40035bb0: eb37c0ff cmp x7, w23, sxtw
40035bb4: 54000769 b.ls 40035ca0 <rtems_rfs_dir_empty+0x1f0> // b.plast <== NEVER TAKEN
elength = rtems_rfs_dir_entry_length (entry);
40035bb8: 394020a4 ldrb w4, [x5, #8]
40035bbc: 394024a6 ldrb w6, [x5, #9]
40035bc0: 394000a2 ldrb w2, [x5]
40035bc4: 394004a1 ldrb w1, [x5, #1]
40035bc8: 394008a3 ldrb w3, [x5, #2]
40035bcc: aa062086 orr x6, x4, x6, lsl #8
40035bd0: 39400cb3 ldrb w19, [x5, #3]
40035bd4: 5ac004c6 rev16 w6, w6
40035bd8: aa012041 orr x1, x2, x1, lsl #8
40035bdc: 12003cd4 and w20, w6, #0xffff
eino = rtems_rfs_dir_entry_ino (entry);
40035be0: aa034023 orr x3, x1, x3, lsl #16
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
40035be4: 6b19029f cmp w20, w25
40035be8: aa136073 orr x19, x3, x19, lsl #24
40035bec: 5ac00a73 rev w19, w19
40035bf0: 54000580 b.eq 40035ca0 <rtems_rfs_dir_empty+0x1f0> // b.none
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
40035bf4: 71002a9f cmp w20, #0xa
40035bf8: 5400040d b.le 40035c78 <rtems_rfs_dir_empty+0x1c8> <== NEVER TAKEN
40035bfc: b9403301 ldr w1, [x24, #48]
40035c00: 6b14003f cmp w1, w20
40035c04: 540003a9 b.ls 40035c78 <rtems_rfs_dir_empty+0x1c8> // b.plast <== NEVER TAKEN
40035c08: 34000393 cbz w19, 40035c78 <rtems_rfs_dir_empty+0x1c8> <== NEVER TAKEN
40035c0c: b9402b01 ldr w1, [x24, #40]
40035c10: 6b13003f cmp w1, w19
40035c14: 54000323 b.cc 40035c78 <rtems_rfs_dir_empty+0x1c8> // b.lo, b.ul, b.last<== NEVER TAKEN
if (((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 1)) ||
40035c18: 71002e9f cmp w20, #0xb
40035c1c: 54fffb61 b.ne 40035b88 <rtems_rfs_dir_empty+0xd8> // b.any
40035c20: 394028a0 ldrb w0, [x5, #10]
40035c24: 7100b81f cmp w0, #0x2e
40035c28: 54fffc00 b.eq 40035ba8 <rtems_rfs_dir_empty+0xf8> // b.none <== ALWAYS TAKEN
rc = ENOTEMPTY;
40035c2c: 7100035f cmp w26, #0x0
40035c30: 52800b40 mov w0, #0x5a // #90
40035c34: 1a80135a csel w26, w26, w0, ne // ne = any
rtems_rfs_buffer_handle_release (fs, handle);
40035c38: 910183e1 add x1, sp, #0x60
40035c3c: aa1803e0 mov x0, x24
40035c40: 97ffc594 bl 40027290 <rtems_rfs_buffer_handle_release>
handle->dirty = false;
40035c44: 390183ff strb wzr, [sp, #96]
rtems_rfs_block_map_close (fs, &map);
40035c48: 9101c3e1 add x1, sp, #0x70
40035c4c: aa1803e0 mov x0, x24
handle->bnum = 0;
40035c50: b90067ff str wzr, [sp, #100]
handle->buffer = NULL;
40035c54: f90037ff str xzr, [sp, #104]
40035c58: 97fff88e bl 40033e90 <rtems_rfs_block_map_close>
}
40035c5c: 2a1a03e0 mov w0, w26
return rc;
40035c60: a94153f3 ldp x19, x20, [sp, #16]
}
40035c64: a9425bf5 ldp x21, x22, [sp, #32]
40035c68: a94363f7 ldp x23, x24, [sp, #48]
40035c6c: a9446bf9 ldp x25, x26, [sp, #64]
40035c70: a8cd7bfd ldp x29, x30, [sp], #208
40035c74: d65f03c0 ret
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY))
40035c78: d2c00020 mov x0, #0x100000000 // #4294967296 <== NOT EXECUTED
40035c7c: 97ffd375 bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
40035c80: 72001c1f tst w0, #0xff <== NOT EXECUTED
40035c84: 540000e0 b.eq 40035ca0 <rtems_rfs_dir_empty+0x1f0> // b.none <== NOT EXECUTED
printf ("rtems-rfs: dir-empty: "
40035c88: b94012a1 ldr w1, [x21, #16] <== NOT EXECUTED
40035c8c: 2a1703e4 mov w4, w23 <== NOT EXECUTED
40035c90: 2a1303e3 mov w3, w19 <== NOT EXECUTED
40035c94: 2a1403e2 mov w2, w20 <== NOT EXECUTED
40035c98: aa1603e0 mov x0, x22 <== NOT EXECUTED
40035c9c: 97ffb1dd bl 40022410 <__wrap_printf> <== NOT EXECUTED
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
40035ca0: 910173e2 add x2, sp, #0x5c
40035ca4: 9101c3e1 add x1, sp, #0x70
40035ca8: aa1803e0 mov x0, x24
40035cac: 97fff955 bl 40034200 <rtems_rfs_block_map_next_block>
if (rc > 0)
40035cb0: 7100001f cmp w0, #0x0
40035cb4: 54fff4cd b.le 40035b4c <rtems_rfs_dir_empty+0x9c> <== NEVER TAKEN
rc = 0;
40035cb8: 7100181f cmp w0, #0x6
40035cbc: 1a9f101a csel w26, w0, wzr, ne // ne = any
40035cc0: 17ffffde b 40035c38 <rtems_rfs_dir_empty+0x188>
printf ("rtems-rfs: dir-empty: dir=%" PRId32 "\n", rtems_rfs_inode_ino (dir));
40035cc4: b94012a1 ldr w1, [x21, #16] <== NOT EXECUTED
40035cc8: b00000a0 adrp x0, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
40035ccc: 9130c000 add x0, x0, #0xc30 <== NOT EXECUTED
40035cd0: 97ffb1d0 bl 40022410 <__wrap_printf> <== NOT EXECUTED
40035cd4: 17ffff82 b 40035adc <rtems_rfs_dir_empty+0x2c> <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
40035cd8: 9101c3e1 add x1, sp, #0x70 <== NOT EXECUTED
40035cdc: aa1803e0 mov x0, x24 <== NOT EXECUTED
40035ce0: 97fff86c bl 40033e90 <rtems_rfs_block_map_close> <== NOT EXECUTED
}
40035ce4: 2a1a03e0 mov w0, w26 <== NOT EXECUTED
40035ce8: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
40035cec: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
40035cf0: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
40035cf4: a8cd7bfd ldp x29, x30, [sp], #208 <== NOT EXECUTED
40035cf8: d65f03c0 ret <== NOT EXECUTED
40035cfc: 00000000 udf #0
0000000040035d00 <rtems_rfs_dir_hash>:
*/
#define initval (20010928)
uint32_t
rtems_rfs_dir_hash (const void *key, size_t length)
{
40035d00: aa0003e3 mov x3, x0
uint32_t a,b,c; /* internal state */
union { const void *ptr; size_t i; } u; /* needed for Mac Powerbook G4 */
/* Set up the internal state */
a = b = c = 0xdeadbeef + ((uint32_t)length) + initval;
40035d04: 5282d3e0 mov w0, #0x169f // #5791
40035d08: 72bbfbe0 movk w0, #0xdfdf, lsl #16
40035d0c: 0b000026 add w6, w1, w0
} else { /* need to read the key one byte at a time */
const uint8_t *k = (const uint8_t *)key;
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
40035d10: f100303f cmp x1, #0xc
a = b = c = 0xdeadbeef + ((uint32_t)length) + initval;
40035d14: 2a0603e7 mov w7, w6
40035d18: 2a0603eb mov w11, w6
while (length > 12)
40035d1c: 54000629 b.ls 40035de0 <rtems_rfs_dir_hash+0xe0> // b.plast <== ALWAYS TAKEN
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
40035d20: 39402864 ldrb w4, [x3, #10] <== NOT EXECUTED
c += ((uint32_t)k[11])<<24;
mix(a,b,c);
length -= 12;
40035d24: d1003021 sub x1, x1, #0xc <== NOT EXECUTED
c += k[8];
40035d28: 39402068 ldrb w8, [x3, #8] <== NOT EXECUTED
while (length > 12)
40035d2c: f100303f cmp x1, #0xc <== NOT EXECUTED
c += ((uint32_t)k[9])<<8;
40035d30: 39402462 ldrb w2, [x3, #9] <== NOT EXECUTED
c += ((uint32_t)k[11])<<24;
40035d34: 39402c60 ldrb w0, [x3, #11] <== NOT EXECUTED
c += ((uint32_t)k[10])<<16;
40035d38: 53103c84 lsl w4, w4, #16 <== NOT EXECUTED
a += ((uint32_t)k[2])<<16;
40035d3c: 3940086a ldrb w10, [x3, #2] <== NOT EXECUTED
a += ((uint32_t)k[1])<<8;
40035d40: 39400465 ldrb w5, [x3, #1] <== NOT EXECUTED
c += ((uint32_t)k[11])<<24;
40035d44: 0b022082 add w2, w4, w2, lsl #8 <== NOT EXECUTED
40035d48: 0b006100 add w0, w8, w0, lsl #24 <== NOT EXECUTED
b += ((uint32_t)k[6])<<16;
40035d4c: 39401869 ldrb w9, [x3, #6] <== NOT EXECUTED
c += ((uint32_t)k[11])<<24;
40035d50: 0b000040 add w0, w2, w0 <== NOT EXECUTED
a += ((uint32_t)k[2])<<16;
40035d54: 53103d4a lsl w10, w10, #16 <== NOT EXECUTED
c += ((uint32_t)k[11])<<24;
40035d58: 0b060000 add w0, w0, w6 <== NOT EXECUTED
b += ((uint32_t)k[5])<<8;
40035d5c: 39401464 ldrb w4, [x3, #5] <== NOT EXECUTED
b += ((uint32_t)k[7])<<24;
40035d60: 39401c68 ldrb w8, [x3, #7] <== NOT EXECUTED
mix(a,b,c);
40035d64: 0b052145 add w5, w10, w5, lsl #8 <== NOT EXECUTED
b += k[4];
40035d68: 3940106c ldrb w12, [x3, #4] <== NOT EXECUTED
b += ((uint32_t)k[6])<<16;
40035d6c: 53103d22 lsl w2, w9, #16 <== NOT EXECUTED
a += ((uint32_t)k[3])<<24;
40035d70: 39400c66 ldrb w6, [x3, #3] <== NOT EXECUTED
b += ((uint32_t)k[7])<<24;
40035d74: 0b042042 add w2, w2, w4, lsl #8 <== NOT EXECUTED
a += k[0];
40035d78: 3840c46a ldrb w10, [x3], #12 <== NOT EXECUTED
40035d7c: 4b0000e7 sub w7, w7, w0 <== NOT EXECUTED
b += ((uint32_t)k[7])<<24;
40035d80: 0b086188 add w8, w12, w8, lsl #24 <== NOT EXECUTED
40035d84: 0b080042 add w2, w2, w8 <== NOT EXECUTED
mix(a,b,c);
40035d88: 0b066146 add w6, w10, w6, lsl #24 <== NOT EXECUTED
b += ((uint32_t)k[7])<<24;
40035d8c: 0b0b0042 add w2, w2, w11 <== NOT EXECUTED
mix(a,b,c);
40035d90: 0b0600a5 add w5, w5, w6 <== NOT EXECUTED
40035d94: 0b000044 add w4, w2, w0 <== NOT EXECUTED
40035d98: 0b0700a5 add w5, w5, w7 <== NOT EXECUTED
40035d9c: 4ac070a0 eor w0, w5, w0, ror #28 <== NOT EXECUTED
40035da0: 4b000042 sub w2, w2, w0 <== NOT EXECUTED
40035da4: 0b040005 add w5, w0, w4 <== NOT EXECUTED
40035da8: 4ac06840 eor w0, w2, w0, ror #26 <== NOT EXECUTED
40035dac: 4b000082 sub w2, w4, w0 <== NOT EXECUTED
40035db0: 0b050004 add w4, w0, w5 <== NOT EXECUTED
40035db4: 4ac06040 eor w0, w2, w0, ror #24 <== NOT EXECUTED
40035db8: 4b0000a5 sub w5, w5, w0 <== NOT EXECUTED
40035dbc: 0b040002 add w2, w0, w4 <== NOT EXECUTED
40035dc0: 4ac040a0 eor w0, w5, w0, ror #16 <== NOT EXECUTED
40035dc4: 4b000084 sub w4, w4, w0 <== NOT EXECUTED
40035dc8: 0b020007 add w7, w0, w2 <== NOT EXECUTED
40035dcc: 4ac03480 eor w0, w4, w0, ror #13 <== NOT EXECUTED
40035dd0: 4b000042 sub w2, w2, w0 <== NOT EXECUTED
40035dd4: 0b07000b add w11, w0, w7 <== NOT EXECUTED
40035dd8: 4ac07046 eor w6, w2, w0, ror #28 <== NOT EXECUTED
while (length > 12)
40035ddc: 54fffa28 b.hi 40035d20 <rtems_rfs_dir_hash+0x20> // b.pmore <== NOT EXECUTED
k += 12;
}
/*-------------------------------- last block: affect all 32 bits of (c) */
switch(length) /* all the case statements fall through */
40035de0: f1001c3f cmp x1, #0x7
40035de4: 540007e0 b.eq 40035ee0 <rtems_rfs_dir_hash+0x1e0> // b.none <== NEVER TAKEN
40035de8: 540005c8 b.hi 40035ea0 <rtems_rfs_dir_hash+0x1a0> // b.pmore
40035dec: f100103f cmp x1, #0x4
40035df0: 54000520 b.eq 40035e94 <rtems_rfs_dir_hash+0x194> // b.none
40035df4: 54000448 b.hi 40035e7c <rtems_rfs_dir_hash+0x17c> // b.pmore <== NEVER TAKEN
40035df8: f100083f cmp x1, #0x2
40035dfc: 540000a0 b.eq 40035e10 <rtems_rfs_dir_hash+0x110> // b.none
40035e00: f1000c3f cmp x1, #0x3
40035e04: 54000741 b.ne 40035eec <rtems_rfs_dir_hash+0x1ec> // b.any <== ALWAYS TAKEN
case 8 : b+=((uint32_t)k[7])<<24;
case 7 : b+=((uint32_t)k[6])<<16;
case 6 : b+=((uint32_t)k[5])<<8;
case 5 : b+=k[4];
case 4 : a+=((uint32_t)k[3])<<24;
case 3 : a+=((uint32_t)k[2])<<16;
40035e08: 39400860 ldrb w0, [x3, #2]
40035e0c: 0b0040e7 add w7, w7, w0, lsl #16
case 2 : a+=((uint32_t)k[1])<<8;
40035e10: 39400460 ldrb w0, [x3, #1]
40035e14: 0b0020e7 add w7, w7, w0, lsl #8
break;
case 0 : return c;
}
}
final(a,b,c);
40035e18: 4a0b00c0 eor w0, w6, w11
case 1 : a+=k[0];
40035e1c: 39400061 ldrb w1, [x3]
final(a,b,c);
40035e20: 138b4966 ror w6, w11, #18
40035e24: 4b060006 sub w6, w0, w6
case 1 : a+=k[0];
40035e28: 0b070021 add w1, w1, w7
final(a,b,c);
40035e2c: 4a0100c1 eor w1, w6, w1
40035e30: 138654c0 ror w0, w6, #21
40035e34: 4b000021 sub w1, w1, w0
40035e38: 4a0b0020 eor w0, w1, w11
40035e3c: 13811c22 ror w2, w1, #7
40035e40: 4b020000 sub w0, w0, w2
40035e44: 4a0000c6 eor w6, w6, w0
40035e48: 13804002 ror w2, w0, #16
40035e4c: 4b0200c6 sub w6, w6, w2
40035e50: 4a060021 eor w1, w1, w6
40035e54: 138670c2 ror w2, w6, #28
40035e58: 4b020021 sub w1, w1, w2
40035e5c: 4a010000 eor w0, w0, w1
40035e60: 13814821 ror w1, w1, #18
40035e64: 4b010001 sub w1, w0, w1
40035e68: 4a0100c0 eor w0, w6, w1
40035e6c: 13812021 ror w1, w1, #8
40035e70: 4b010006 sub w6, w0, w1
return c; }
40035e74: 2a0603e0 mov w0, w6
40035e78: d65f03c0 ret
switch(length) /* all the case statements fall through */
40035e7c: f100143f cmp x1, #0x5 <== NOT EXECUTED
40035e80: 54000060 b.eq 40035e8c <rtems_rfs_dir_hash+0x18c> // b.none <== NOT EXECUTED
case 6 : b+=((uint32_t)k[5])<<8;
40035e84: 39401460 ldrb w0, [x3, #5]
40035e88: 0b00216b add w11, w11, w0, lsl #8
case 5 : b+=k[4];
40035e8c: 39401060 ldrb w0, [x3, #4]
40035e90: 0b00016b add w11, w11, w0
case 4 : a+=((uint32_t)k[3])<<24;
40035e94: 39400c60 ldrb w0, [x3, #3]
40035e98: 0b0060e7 add w7, w7, w0, lsl #24
40035e9c: 17ffffdb b 40035e08 <rtems_rfs_dir_hash+0x108>
switch(length) /* all the case statements fall through */
40035ea0: f100283f cmp x1, #0xa
40035ea4: 54000120 b.eq 40035ec8 <rtems_rfs_dir_hash+0x1c8> // b.none
40035ea8: 54000289 b.ls 40035ef8 <rtems_rfs_dir_hash+0x1f8> // b.plast <== ALWAYS TAKEN
40035eac: f1002c3f cmp x1, #0xb <== NOT EXECUTED
40035eb0: 54000080 b.eq 40035ec0 <rtems_rfs_dir_hash+0x1c0> // b.none <== NOT EXECUTED
case 12: c+=((uint32_t)k[11])<<24;
40035eb4: 39402c60 ldrb w0, [x3, #11] <== NOT EXECUTED
40035eb8: 0b0060c6 add w6, w6, w0, lsl #24 <== NOT EXECUTED
40035ebc: d503201f nop <== NOT EXECUTED
case 11: c+=((uint32_t)k[10])<<16;
40035ec0: 39402860 ldrb w0, [x3, #10] <== NOT EXECUTED
40035ec4: 0b0040c6 add w6, w6, w0, lsl #16 <== NOT EXECUTED
case 10: c+=((uint32_t)k[9])<<8;
40035ec8: 39402460 ldrb w0, [x3, #9]
40035ecc: 0b0020c6 add w6, w6, w0, lsl #8
case 9 : c+=k[8];
40035ed0: 39402060 ldrb w0, [x3, #8]
40035ed4: 0b0000c6 add w6, w6, w0
case 8 : b+=((uint32_t)k[7])<<24;
40035ed8: 39401c60 ldrb w0, [x3, #7]
40035edc: 0b00616b add w11, w11, w0, lsl #24
case 7 : b+=((uint32_t)k[6])<<16;
40035ee0: 39401860 ldrb w0, [x3, #6]
40035ee4: 0b00416b add w11, w11, w0, lsl #16
40035ee8: 17ffffe7 b 40035e84 <rtems_rfs_dir_hash+0x184>
switch(length) /* all the case statements fall through */
40035eec: f100043f cmp x1, #0x1
40035ef0: 54fff940 b.eq 40035e18 <rtems_rfs_dir_hash+0x118> // b.none <== ALWAYS TAKEN
40035ef4: 17ffffe0 b 40035e74 <rtems_rfs_dir_hash+0x174> <== NOT EXECUTED
40035ef8: f100203f cmp x1, #0x8
40035efc: 54fffee0 b.eq 40035ed8 <rtems_rfs_dir_hash+0x1d8> // b.none
40035f00: f100243f cmp x1, #0x9
40035f04: 54fffb81 b.ne 40035e74 <rtems_rfs_dir_hash+0x174> // b.any <== NEVER TAKEN
case 9 : c+=k[8];
40035f08: 39402060 ldrb w0, [x3, #8]
40035f0c: 0b0000c6 add w6, w6, w0
40035f10: 17fffff2 b 40035ed8 <rtems_rfs_dir_hash+0x1d8>
...
00000000400349d0 <rtems_rfs_dir_lookup_ino>:
rtems_rfs_inode_handle* inode,
const char* name,
int length,
rtems_rfs_ino* ino,
uint32_t* offset)
{
400349d0: a9b07bfd stp x29, x30, [sp, #-256]!
400349d4: 910003fd mov x29, sp
400349d8: a90153f3 stp x19, x20, [sp, #16]
400349dc: aa0403f4 mov x20, x4
400349e0: a9025bf5 stp x21, x22, [sp, #32]
400349e4: a90363f7 stp x23, x24, [sp, #48]
400349e8: aa0203f8 mov x24, x2
400349ec: 93407c77 sxtw x23, w3
400349f0: a9046bf9 stp x25, x26, [sp, #64]
400349f4: aa0003fa mov x26, x0
rtems_rfs_block_map map;
rtems_rfs_buffer_handle entries;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
400349f8: d2a08000 mov x0, #0x4000000 // #67108864
{
400349fc: f90033e1 str x1, [sp, #96]
40034a00: f9003be5 str x5, [sp, #112]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
40034a04: 97ffd813 bl 4002aa50 <rtems_rfs_trace>
40034a08: 72001c1f tst w0, #0xff
40034a0c: 54001d01 b.ne 40034dac <rtems_rfs_dir_lookup_ino+0x3dc> // b.any <== NEVER TAKEN
printf ("%c", name[c]);
printf (", len=%d\n", length);
}
*ino = RTEMS_RFS_EMPTY_INO;
*offset = 0;
40034a10: f9403be0 ldr x0, [sp, #112]
*ino = RTEMS_RFS_EMPTY_INO;
40034a14: b900029f str wzr, [x20]
rc = rtems_rfs_block_map_open (fs, inode, &map);
40034a18: f94033e1 ldr x1, [sp, #96]
40034a1c: 910283e2 add x2, sp, #0xa0
*offset = 0;
40034a20: b900001f str wzr, [x0]
rc = rtems_rfs_block_map_open (fs, inode, &map);
40034a24: aa1a03e0 mov x0, x26
40034a28: 97fffcb6 bl 40033d00 <rtems_rfs_block_map_open>
40034a2c: 2a0003f6 mov w22, w0
if (rc > 0)
40034a30: 7100001f cmp w0, #0x0
40034a34: 5400192c b.gt 40034d58 <rtems_rfs_dir_lookup_ino+0x388> <== NEVER TAKEN
uint32_t hash;
/*
* Calculate the hash of the look up string.
*/
hash = rtems_rfs_dir_hash (name, length);
40034a38: aa1703e1 mov x1, x23
40034a3c: aa1803e0 mov x0, x24
handle->dirty = false;
40034a40: 390243ff strb wzr, [sp, #144]
handle->bnum = 0;
40034a44: b90097ff str wzr, [sp, #148]
handle->buffer = NULL;
40034a48: f9004fff str xzr, [sp, #152]
40034a4c: 940004ad bl 40035d00 <rtems_rfs_dir_hash>
/*
* Locate the first block. The map points to the start after open so just
* seek 0. If an error the block will be 0.
*/
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
40034a50: 910233e3 add x3, sp, #0x8c
hash = rtems_rfs_dir_hash (name, length);
40034a54: 2a0003f5 mov w21, w0
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
40034a58: 910283e1 add x1, sp, #0xa0
40034a5c: aa1a03e0 mov x0, x26
40034a60: d2800002 mov x2, #0x0 // #0
40034a64: 97fffdd7 bl 400341c0 <rtems_rfs_block_map_seek>
40034a68: 2a0003f6 mov w22, w0
if (rc > 0)
40034a6c: 7100001f cmp w0, #0x0
40034a70: 54001c6c b.gt 40034dfc <rtems_rfs_dir_lookup_ino+0x42c> <== NEVER TAKEN
40034a74: a90573fb stp x27, x28, [sp, #80]
while ((rc == 0) && block)
{
uint8_t* entry;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n",
40034a78: d00000bc adrp x28, 4004a000 <status_code_text+0x38>
40034a7c: 911a2380 add x0, x28, #0x688
40034a80: f9003fe0 str x0, [sp, #120]
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
40034a84: d00000bb adrp x27, 4004a000 <status_code_text+0x38>
40034a88: 911d2360 add x0, x27, #0x748
40034a8c: f90037e0 str x0, [sp, #104]
while ((rc == 0) && block)
40034a90: 35000c96 cbnz w22, 40034c20 <rtems_rfs_dir_lookup_ino+0x250> <== NEVER TAKEN
40034a94: b9408fe0 ldr w0, [sp, #140]
40034a98: 34001fe0 cbz w0, 40034e94 <rtems_rfs_dir_lookup_ino+0x4c4> <== NEVER TAKEN
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
40034a9c: d2a08000 mov x0, #0x4000000 // #67108864
40034aa0: 97ffd7ec bl 4002aa50 <rtems_rfs_trace>
40034aa4: 72001c1f tst w0, #0xff
40034aa8: 540014c1 b.ne 40034d40 <rtems_rfs_dir_lookup_ino+0x370> // b.any <== NEVER TAKEN
rc = rtems_rfs_buffer_handle_request (fs, &entries, block, true);
40034aac: b9408fe2 ldr w2, [sp, #140]
40034ab0: 910243e1 add x1, sp, #0x90
40034ab4: aa1a03e0 mov x0, x26
40034ab8: 52800023 mov w3, #0x1 // #1
40034abc: 97ffc945 bl 40026fd0 <rtems_rfs_buffer_handle_request>
40034ac0: 2a0003f6 mov w22, w0
if (rc > 0)
40034ac4: 7100001f cmp w0, #0x0
40034ac8: 5400206c b.gt 40034ed4 <rtems_rfs_dir_lookup_ino+0x504> <== NEVER TAKEN
entry = rtems_rfs_buffer_data (&entries);
40034acc: f9404fe0 ldr x0, [sp, #152]
map.bpos.boff = 0;
40034ad0: b900bfff str wzr, [sp, #188]
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
40034ad4: f9400b45 ldr x5, [x26, #16]
entry = rtems_rfs_buffer_data (&entries);
40034ad8: f9401c13 ldr x19, [x0, #56]
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
40034adc: f10028bf cmp x5, #0xa
40034ae0: 540007c0 b.eq 40034bd8 <rtems_rfs_dir_lookup_ino+0x208> // b.none <== NEVER TAKEN
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
40034ae4: 529ffffb mov w27, #0xffff // #65535
40034ae8: 14000008 b 40034b08 <rtems_rfs_dir_lookup_ino+0x138>
rtems_rfs_block_map_close (fs, &map);
return 0;
}
}
map.bpos.boff += elength;
40034aec: b940bfe0 ldr w0, [sp, #188]
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
40034af0: d10028a1 sub x1, x5, #0xa
entry += elength;
40034af4: 8b392273 add x19, x19, w25, uxth
map.bpos.boff += elength;
40034af8: 0b000387 add w7, w28, w0
40034afc: b900bfe7 str w7, [sp, #188]
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
40034b00: eb27403f cmp x1, w7, uxtw
40034b04: 540006a9 b.ls 40034bd8 <rtems_rfs_dir_lookup_ino+0x208> // b.plast <== NEVER TAKEN
if (ehash == hash)
40034b08: 39400260 ldrb w0, [x19]
40034b0c: 39400666 ldrb w6, [x19, #1]
40034b10: 39400a64 ldrb w4, [x19, #2]
40034b14: 39401262 ldrb w2, [x19, #4]
40034b18: aa062006 orr x6, x0, x6, lsl #8
40034b1c: 39401663 ldrb w3, [x19, #5]
40034b20: 39400e61 ldrb w1, [x19, #3]
40034b24: aa0440c4 orr x4, x6, x4, lsl #16
40034b28: 39402267 ldrb w7, [x19, #8]
40034b2c: 39402666 ldrb w6, [x19, #9]
40034b30: aa032043 orr x3, x2, x3, lsl #8
40034b34: 39401a60 ldrb w0, [x19, #6]
40034b38: aa016081 orr x1, x4, x1, lsl #24
40034b3c: 39401e62 ldrb w2, [x19, #7]
40034b40: 5ac00821 rev w1, w1
40034b44: aa0620e6 orr x6, x7, x6, lsl #8
*ino = rtems_rfs_dir_entry_ino (entry);
40034b48: b9000281 str w1, [x20]
40034b4c: 5ac004d9 rev16 w25, w6
40034b50: aa004060 orr x0, x3, x0, lsl #16
40034b54: aa026002 orr x2, x0, x2, lsl #24
40034b58: 12003f3c and w28, w25, #0xffff
40034b5c: 5ac00842 rev w2, w2
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
40034b60: 6b1b039f cmp w28, w27
40034b64: 540003a0 b.eq 40034bd8 <rtems_rfs_dir_lookup_ino+0x208> // b.none
if (rtems_rfs_dir_entry_valid (fs, elength, *ino))
40034b68: 71002b9f cmp w28, #0xa
40034b6c: 5400050d b.le 40034c0c <rtems_rfs_dir_lookup_ino+0x23c> <== NEVER TAKEN
40034b70: b9403340 ldr w0, [x26, #48]
40034b74: 7100003f cmp w1, #0x0
40034b78: 7a5c1000 ccmp w0, w28, #0x0, ne // ne = any
40034b7c: 54000489 b.ls 40034c0c <rtems_rfs_dir_lookup_ino+0x23c> // b.plast <== NEVER TAKEN
40034b80: b9402b40 ldr w0, [x26, #40]
40034b84: 6b00003f cmp w1, w0
40034b88: 54000428 b.hi 40034c0c <rtems_rfs_dir_lookup_ino+0x23c> // b.pmore <== NEVER TAKEN
if (ehash == hash)
40034b8c: 6b0202bf cmp w21, w2
40034b90: 54fffae1 b.ne 40034aec <rtems_rfs_dir_lookup_ino+0x11c> // b.any
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
40034b94: d2a10000 mov x0, #0x8000000 // #134217728
40034b98: 97ffd7ae bl 4002aa50 <rtems_rfs_trace>
40034b9c: 72001c1f tst w0, #0xff
40034ba0: 54000761 b.ne 40034c8c <rtems_rfs_dir_lookup_ino+0x2bc> // b.any <== NEVER TAKEN
if (memcmp (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length) == 0)
40034ba4: aa1703e2 mov x2, x23
40034ba8: aa1803e1 mov x1, x24
40034bac: 91002a60 add x0, x19, #0xa
40034bb0: 94002485 bl 4003ddc4 <memcmp>
40034bb4: 34000900 cbz w0, 40034cd4 <rtems_rfs_dir_lookup_ino+0x304> <== ALWAYS TAKEN
map.bpos.boff += elength;
40034bb8: b940bfe0 ldr w0, [sp, #188] <== NOT EXECUTED
entry += elength;
40034bbc: 8b392273 add x19, x19, w25, uxth <== NOT EXECUTED
40034bc0: f9400b45 ldr x5, [x26, #16] <== NOT EXECUTED
map.bpos.boff += elength;
40034bc4: 0b000387 add w7, w28, w0 <== NOT EXECUTED
40034bc8: b900bfe7 str w7, [sp, #188] <== NOT EXECUTED
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
40034bcc: d10028a1 sub x1, x5, #0xa <== NOT EXECUTED
40034bd0: eb27403f cmp x1, w7, uxtw <== NOT EXECUTED
40034bd4: 54fff9a8 b.hi 40034b08 <rtems_rfs_dir_lookup_ino+0x138> // b.pmore <== NOT EXECUTED
}
if (rc == 0)
40034bd8: 35000256 cbnz w22, 40034c20 <rtems_rfs_dir_lookup_ino+0x250> <== NEVER TAKEN
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
40034bdc: 910233e2 add x2, sp, #0x8c
40034be0: 910283e1 add x1, sp, #0xa0
40034be4: aa1a03e0 mov x0, x26
40034be8: 97fffd86 bl 40034200 <rtems_rfs_block_map_next_block>
if ((rc > 0) && (rc != ENXIO))
40034bec: 7100001f cmp w0, #0x0
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
40034bf0: 2a0003f6 mov w22, w0
if ((rc > 0) && (rc != ENXIO))
40034bf4: 7a46c804 ccmp w0, #0x6, #0x4, gt
40034bf8: 54001301 b.ne 40034e58 <rtems_rfs_dir_lookup_ino+0x488> // b.any <== NEVER TAKEN
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: "
"block map next block failed in ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (inode), rc, strerror (rc));
}
if (rc == ENXIO)
40034bfc: 7100181f cmp w0, #0x6
40034c00: 54fff481 b.ne 40034a90 <rtems_rfs_dir_lookup_ino+0xc0> // b.any <== NEVER TAKEN
rc = ENOENT;
40034c04: 52800056 mov w22, #0x2 // #2
40034c08: 14000006 b 40034c20 <rtems_rfs_dir_lookup_ino+0x250>
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
40034c0c: d2a08000 mov x0, #0x4000000 // #67108864 <== NOT EXECUTED
40034c10: 97ffd790 bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
40034c14: 72001c1f tst w0, #0xff <== NOT EXECUTED
40034c18: 54000261 b.ne 40034c64 <rtems_rfs_dir_lookup_ino+0x294> // b.any <== NOT EXECUTED
rc = EIO;
40034c1c: 528000b6 mov w22, #0x5 // #5 <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40034c20: 910243e1 add x1, sp, #0x90
40034c24: aa1a03e0 mov x0, x26
40034c28: 97ffc99a bl 40027290 <rtems_rfs_buffer_handle_release>
handle->dirty = false;
40034c2c: 390243ff strb wzr, [sp, #144]
rtems_rfs_inode_ino (inode), rc, strerror (rc));
}
}
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
40034c30: 910283e1 add x1, sp, #0xa0
40034c34: aa1a03e0 mov x0, x26
handle->bnum = 0;
40034c38: b90097ff str wzr, [sp, #148]
handle->buffer = NULL;
40034c3c: f9004fff str xzr, [sp, #152]
40034c40: 97fffc94 bl 40033e90 <rtems_rfs_block_map_close>
return rc;
40034c44: a94573fb ldp x27, x28, [sp, #80]
}
40034c48: 2a1603e0 mov w0, w22
40034c4c: a94153f3 ldp x19, x20, [sp, #16]
40034c50: a9425bf5 ldp x21, x22, [sp, #32]
40034c54: a94363f7 ldp x23, x24, [sp, #48]
40034c58: a9446bf9 ldp x25, x26, [sp, #64]
40034c5c: a8d07bfd ldp x29, x30, [sp], #256
40034c60: d65f03c0 ret
printf ("rtems-rfs: dir-lookup-ino: "
40034c64: f94033e1 ldr x1, [sp, #96] <== NOT EXECUTED
40034c68: 2a1c03e2 mov w2, w28 <== NOT EXECUTED
40034c6c: b9400283 ldr w3, [x20] <== NOT EXECUTED
40034c70: d00000a0 adrp x0, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
40034c74: 911c0000 add x0, x0, #0x700 <== NOT EXECUTED
40034c78: b940bfe4 ldr w4, [sp, #188] <== NOT EXECUTED
40034c7c: b9401021 ldr w1, [x1, #16] <== NOT EXECUTED
rc = EIO;
40034c80: 528000b6 mov w22, #0x5 // #5 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
40034c84: 97ffb5e3 bl 40022410 <__wrap_printf> <== NOT EXECUTED
while ((rc == 0) && block)
40034c88: 17ffffe6 b 40034c20 <rtems_rfs_dir_lookup_ino+0x250> <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
40034c8c: 39400263 ldrb w3, [x19] <== NOT EXECUTED
40034c90: 2a1c03e4 mov w4, w28 <== NOT EXECUTED
40034c94: 39400661 ldrb w1, [x19, #1] <== NOT EXECUTED
40034c98: 39400a6a ldrb w10, [x19, #2] <== NOT EXECUTED
40034c9c: 39400e65 ldrb w5, [x19, #3] <== NOT EXECUTED
40034ca0: aa012061 orr x1, x3, x1, lsl #8 <== NOT EXECUTED
40034ca4: aa0a402a orr x10, x1, x10, lsl #16 <== NOT EXECUTED
40034ca8: a94603e1 ldp x1, x0, [sp, #96] <== NOT EXECUTED
40034cac: aa056145 orr x5, x10, x5, lsl #24 <== NOT EXECUTED
40034cb0: 29570fe2 ldp w2, w3, [sp, #184] <== NOT EXECUTED
40034cb4: 5ac008a5 rev w5, w5 <== NOT EXECUTED
40034cb8: b9401021 ldr w1, [x1, #16] <== NOT EXECUTED
40034cbc: 97ffb5d5 bl 40022410 <__wrap_printf> <== NOT EXECUTED
if (memcmp (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length) == 0)
40034cc0: aa1703e2 mov x2, x23 <== NOT EXECUTED
40034cc4: aa1803e1 mov x1, x24 <== NOT EXECUTED
40034cc8: 91002a60 add x0, x19, #0xa <== NOT EXECUTED
40034ccc: 9400243e bl 4003ddc4 <memcmp> <== NOT EXECUTED
40034cd0: 35fff740 cbnz w0, 40034bb8 <rtems_rfs_dir_lookup_ino+0x1e8> <== NOT EXECUTED
*offset = rtems_rfs_block_map_pos (fs, &map);
40034cd4: 9102e3e1 add x1, sp, #0xb8
40034cd8: aa1a03e0 mov x0, x26
40034cdc: 97fffbf9 bl 40033cc0 <rtems_rfs_block_get_pos>
40034ce0: f9403be1 ldr x1, [sp, #112]
40034ce4: b9000020 str w0, [x1]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND))
40034ce8: d2a20000 mov x0, #0x10000000 // #268435456
40034cec: 97ffd759 bl 4002aa50 <rtems_rfs_trace>
40034cf0: 72001c1f tst w0, #0xff
40034cf4: 54001221 b.ne 40034f38 <rtems_rfs_dir_lookup_ino+0x568> // b.any <== NEVER TAKEN
rtems_rfs_buffer_handle_release (fs, handle);
40034cf8: 910243e1 add x1, sp, #0x90
40034cfc: aa1a03e0 mov x0, x26
40034d00: 97ffc964 bl 40027290 <rtems_rfs_buffer_handle_release>
return 0;
40034d04: 52800016 mov w22, #0x0 // #0
rtems_rfs_block_map_close (fs, &map);
40034d08: 910283e1 add x1, sp, #0xa0
40034d0c: aa1a03e0 mov x0, x26
handle->dirty = false;
40034d10: 390243ff strb wzr, [sp, #144]
handle->bnum = 0;
40034d14: b90097ff str wzr, [sp, #148]
handle->buffer = NULL;
40034d18: f9004fff str xzr, [sp, #152]
40034d1c: 97fffc5d bl 40033e90 <rtems_rfs_block_map_close>
}
40034d20: 2a1603e0 mov w0, w22
40034d24: a94153f3 ldp x19, x20, [sp, #16]
40034d28: a9425bf5 ldp x21, x22, [sp, #32]
40034d2c: a94363f7 ldp x23, x24, [sp, #48]
40034d30: a9446bf9 ldp x25, x26, [sp, #64]
return 0;
40034d34: a94573fb ldp x27, x28, [sp, #80]
}
40034d38: a8d07bfd ldp x29, x30, [sp], #256
40034d3c: d65f03c0 ret
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n",
40034d40: f94033e1 ldr x1, [sp, #96] <== NOT EXECUTED
40034d44: b940bbe2 ldr w2, [sp, #184] <== NOT EXECUTED
40034d48: f9403fe0 ldr x0, [sp, #120] <== NOT EXECUTED
40034d4c: b9401021 ldr w1, [x1, #16] <== NOT EXECUTED
40034d50: 97ffb5b0 bl 40022410 <__wrap_printf> <== NOT EXECUTED
40034d54: 17ffff56 b 40034aac <rtems_rfs_dir_lookup_ino+0xdc> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
40034d58: d2a08000 mov x0, #0x4000000 // #67108864 <== NOT EXECUTED
40034d5c: 97ffd73d bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
40034d60: 72001c1f tst w0, #0xff <== NOT EXECUTED
40034d64: 54fff720 b.eq 40034c48 <rtems_rfs_dir_lookup_ino+0x278> // b.none <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: map open failed for ino %" PRIu32 ": %d: %s",
40034d68: f94033e0 ldr x0, [sp, #96] <== NOT EXECUTED
40034d6c: b9401013 ldr w19, [x0, #16] <== NOT EXECUTED
40034d70: 2a1603e0 mov w0, w22 <== NOT EXECUTED
40034d74: 940027aa bl 4003ec1c <strerror> <== NOT EXECUTED
40034d78: aa0003e3 mov x3, x0 <== NOT EXECUTED
40034d7c: 2a1303e1 mov w1, w19 <== NOT EXECUTED
40034d80: 2a1603e2 mov w2, w22 <== NOT EXECUTED
40034d84: d00000a0 adrp x0, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
40034d88: 91182000 add x0, x0, #0x608 <== NOT EXECUTED
40034d8c: 97ffb5a1 bl 40022410 <__wrap_printf> <== NOT EXECUTED
}
40034d90: 2a1603e0 mov w0, w22 <== NOT EXECUTED
40034d94: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40034d98: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
40034d9c: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
40034da0: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
40034da4: a8d07bfd ldp x29, x30, [sp], #256 <== NOT EXECUTED
40034da8: d65f03c0 ret <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: lookup ino: root=%" PRId32 ", path=",
40034dac: f94033e0 ldr x0, [sp, #96] <== NOT EXECUTED
40034db0: b9401001 ldr w1, [x0, #16] <== NOT EXECUTED
40034db4: d00000a0 adrp x0, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
40034db8: 91170000 add x0, x0, #0x5c0 <== NOT EXECUTED
40034dbc: 97ffb595 bl 40022410 <__wrap_printf> <== NOT EXECUTED
for (c = 0; c < length; c++)
40034dc0: 710002ff cmp w23, #0x0 <== NOT EXECUTED
40034dc4: 5400012d b.le 40034de8 <rtems_rfs_dir_lookup_ino+0x418> <== NOT EXECUTED
40034dc8: 510006f5 sub w21, w23, #0x1 <== NOT EXECUTED
40034dcc: 91000700 add x0, x24, #0x1 <== NOT EXECUTED
40034dd0: 8b0002b5 add x21, x21, x0 <== NOT EXECUTED
40034dd4: aa1803f3 mov x19, x24 <== NOT EXECUTED
printf ("%c", name[c]);
40034dd8: 38401660 ldrb w0, [x19], #1 <== NOT EXECUTED
40034ddc: 94002489 bl 4003e000 <putchar> <== NOT EXECUTED
for (c = 0; c < length; c++)
40034de0: eb1302bf cmp x21, x19 <== NOT EXECUTED
40034de4: 54ffffa1 b.ne 40034dd8 <rtems_rfs_dir_lookup_ino+0x408> // b.any <== NOT EXECUTED
printf (", len=%d\n", length);
40034de8: 2a1703e1 mov w1, w23 <== NOT EXECUTED
40034dec: d00000a0 adrp x0, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
40034df0: 9117e000 add x0, x0, #0x5f8 <== NOT EXECUTED
40034df4: 97ffb587 bl 40022410 <__wrap_printf> <== NOT EXECUTED
40034df8: 17ffff06 b 40034a10 <rtems_rfs_dir_lookup_ino+0x40> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
40034dfc: d2a08000 mov x0, #0x4000000 // #67108864 <== NOT EXECUTED
40034e00: 97ffd714 bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
40034e04: 72001c1f tst w0, #0xff <== NOT EXECUTED
40034e08: 54000881 b.ne 40034f18 <rtems_rfs_dir_lookup_ino+0x548> // b.any <== NOT EXECUTED
rc = ENOENT;
40034e0c: 71001adf cmp w22, #0x6 <== NOT EXECUTED
40034e10: 52800040 mov w0, #0x2 // #2 <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40034e14: 910243e1 add x1, sp, #0x90 <== NOT EXECUTED
40034e18: 1a8012d6 csel w22, w22, w0, ne // ne = any <== NOT EXECUTED
40034e1c: aa1a03e0 mov x0, x26 <== NOT EXECUTED
40034e20: 97ffc91c bl 40027290 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
40034e24: 390243ff strb wzr, [sp, #144] <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
40034e28: 910283e1 add x1, sp, #0xa0 <== NOT EXECUTED
40034e2c: aa1a03e0 mov x0, x26 <== NOT EXECUTED
handle->bnum = 0;
40034e30: b90097ff str wzr, [sp, #148] <== NOT EXECUTED
handle->buffer = NULL;
40034e34: f9004fff str xzr, [sp, #152] <== NOT EXECUTED
40034e38: 97fffc16 bl 40033e90 <rtems_rfs_block_map_close> <== NOT EXECUTED
}
40034e3c: 2a1603e0 mov w0, w22 <== NOT EXECUTED
40034e40: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40034e44: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
40034e48: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
40034e4c: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
40034e50: a8d07bfd ldp x29, x30, [sp], #256 <== NOT EXECUTED
40034e54: d65f03c0 ret <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
40034e58: d2a08000 mov x0, #0x4000000 // #67108864 <== NOT EXECUTED
40034e5c: 97ffd6fd bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
40034e60: 72001c1f tst w0, #0xff <== NOT EXECUTED
40034e64: 54ffe160 b.eq 40034a90 <rtems_rfs_dir_lookup_ino+0xc0> // b.none <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
40034e68: f94033e0 ldr x0, [sp, #96] <== NOT EXECUTED
40034e6c: b9401013 ldr w19, [x0, #16] <== NOT EXECUTED
40034e70: 2a1603e0 mov w0, w22 <== NOT EXECUTED
40034e74: 9400276a bl 4003ec1c <strerror> <== NOT EXECUTED
40034e78: aa0003e3 mov x3, x0 <== NOT EXECUTED
40034e7c: 2a1303e1 mov w1, w19 <== NOT EXECUTED
40034e80: 2a1603e2 mov w2, w22 <== NOT EXECUTED
40034e84: d00000a0 adrp x0, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
40034e88: 911fc000 add x0, x0, #0x7f0 <== NOT EXECUTED
40034e8c: 97ffb561 bl 40022410 <__wrap_printf> <== NOT EXECUTED
40034e90: 17ffff00 b 40034a90 <rtems_rfs_dir_lookup_ino+0xc0> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
40034e94: d2a08000 mov x0, #0x4000000 // #67108864 <== NOT EXECUTED
40034e98: 97ffd6ee bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
40034e9c: 72001c1f tst w0, #0xff <== NOT EXECUTED
40034ea0: 54ffebe0 b.eq 40034c1c <rtems_rfs_dir_lookup_ino+0x24c> // b.none <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block is 0 in ino %" PRIu32 ": %d: %s\n",
40034ea4: f94033e0 ldr x0, [sp, #96] <== NOT EXECUTED
40034ea8: b9401013 ldr w19, [x0, #16] <== NOT EXECUTED
40034eac: 528000a0 mov w0, #0x5 // #5 <== NOT EXECUTED
40034eb0: 9400275b bl 4003ec1c <strerror> <== NOT EXECUTED
40034eb4: aa0003e3 mov x3, x0 <== NOT EXECUTED
40034eb8: 528000a2 mov w2, #0x5 // #5 <== NOT EXECUTED
40034ebc: 2a1303e1 mov w1, w19 <== NOT EXECUTED
rc = EIO;
40034ec0: 2a0203f6 mov w22, w2 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block is 0 in ino %" PRIu32 ": %d: %s\n",
40034ec4: d00000a0 adrp x0, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
40034ec8: 91210000 add x0, x0, #0x840 <== NOT EXECUTED
40034ecc: 97ffb551 bl 40022410 <__wrap_printf> <== NOT EXECUTED
40034ed0: 17ffff54 b 40034c20 <rtems_rfs_dir_lookup_ino+0x250> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
40034ed4: d2a08000 mov x0, #0x4000000 // #67108864 <== NOT EXECUTED
40034ed8: 97ffd6de bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
40034edc: 72001c1f tst w0, #0xff <== NOT EXECUTED
40034ee0: 54ffea00 b.eq 40034c20 <rtems_rfs_dir_lookup_ino+0x250> // b.none <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " block=%" PRId32 ": %d: %s\n",
40034ee4: f94033e1 ldr x1, [sp, #96] <== NOT EXECUTED
40034ee8: 2a1603e0 mov w0, w22 <== NOT EXECUTED
40034eec: b9408ff4 ldr w20, [sp, #140] <== NOT EXECUTED
40034ef0: b9401033 ldr w19, [x1, #16] <== NOT EXECUTED
40034ef4: 9400274a bl 4003ec1c <strerror> <== NOT EXECUTED
40034ef8: 2a1403e2 mov w2, w20 <== NOT EXECUTED
40034efc: aa0003e4 mov x4, x0 <== NOT EXECUTED
40034f00: 2a1303e1 mov w1, w19 <== NOT EXECUTED
40034f04: 2a1603e3 mov w3, w22 <== NOT EXECUTED
40034f08: d00000a0 adrp x0, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
40034f0c: 911b0000 add x0, x0, #0x6c0 <== NOT EXECUTED
40034f10: 97ffb540 bl 40022410 <__wrap_printf> <== NOT EXECUTED
40034f14: 17ffff43 b 40034c20 <rtems_rfs_dir_lookup_ino+0x250> <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block map find failed: %d: %s\n",
40034f18: 2a1603e0 mov w0, w22 <== NOT EXECUTED
40034f1c: 94002740 bl 4003ec1c <strerror> <== NOT EXECUTED
40034f20: d00000a1 adrp x1, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
40034f24: aa0003e2 mov x2, x0 <== NOT EXECUTED
40034f28: 91192020 add x0, x1, #0x648 <== NOT EXECUTED
40034f2c: 2a1603e1 mov w1, w22 <== NOT EXECUTED
40034f30: 97ffb538 bl 40022410 <__wrap_printf> <== NOT EXECUTED
40034f34: 17ffffb6 b 40034e0c <rtems_rfs_dir_lookup_ino+0x43c> <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
40034f38: f94033e1 ldr x1, [sp, #96] <== NOT EXECUTED
40034f3c: f9403be0 ldr x0, [sp, #112] <== NOT EXECUTED
40034f40: b9400282 ldr w2, [x20] <== NOT EXECUTED
40034f44: b9401021 ldr w1, [x1, #16] <== NOT EXECUTED
40034f48: b9400003 ldr w3, [x0] <== NOT EXECUTED
40034f4c: d00000a0 adrp x0, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
40034f50: 911ea000 add x0, x0, #0x7a8 <== NOT EXECUTED
40034f54: 97ffb52f bl 40022410 <__wrap_printf> <== NOT EXECUTED
40034f58: 17ffff68 b 40034cf8 <rtems_rfs_dir_lookup_ino+0x328> <== NOT EXECUTED
40034f5c: 00000000 udf #0
0000000040035780 <rtems_rfs_dir_read>:
rtems_rfs_dir_read (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir,
rtems_rfs_pos_rel offset,
struct dirent* dirent,
size_t* length)
{
40035780: a9b27bfd stp x29, x30, [sp, #-224]!
40035784: 910003fd mov x29, sp
40035788: a90153f3 stp x19, x20, [sp, #16]
4003578c: a9025bf5 stp x21, x22, [sp, #32]
40035790: aa0003f5 mov x21, x0
40035794: aa0403f6 mov x22, x4
rtems_rfs_block_map map;
rtems_rfs_buffer_handle buffer;
rtems_rfs_block_no block;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
40035798: d2b00000 mov x0, #0x80000000 // #2147483648
{
4003579c: a90363f7 stp x23, x24, [sp, #48]
400357a0: aa0103f8 mov x24, x1
400357a4: aa0203f7 mov x23, x2
400357a8: a9046bf9 stp x25, x26, [sp, #64]
400357ac: aa0303fa mov x26, x3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
400357b0: 97ffd4a8 bl 4002aa50 <rtems_rfs_trace>
400357b4: 72001c1f tst w0, #0xff
400357b8: 54000d01 b.ne 40035958 <rtems_rfs_dir_read+0x1d8> // b.any <== NEVER TAKEN
printf ("rtems-rfs: dir-read: dir=%" PRId32 " offset=%" PRId64 "\n",
rtems_rfs_inode_ino (dir), offset);
*length = 0;
400357bc: f90002df str xzr, [x22]
rc = rtems_rfs_block_map_open (fs, dir, &map);
400357c0: 910203e2 add x2, sp, #0x80
400357c4: aa1803e1 mov x1, x24
400357c8: aa1503e0 mov x0, x21
400357cc: 97fff94d bl 40033d00 <rtems_rfs_block_map_open>
400357d0: 2a0003f3 mov w19, w0
if (rc > 0)
400357d4: 7100001f cmp w0, #0x0
400357d8: 5400098c b.gt 40035908 <rtems_rfs_dir_read+0x188> <== NEVER TAKEN
return rc;
if (((rtems_rfs_fs_block_size (fs) -
400357dc: f9400aa2 ldr x2, [x21, #16]
(offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
offset = (((offset / rtems_rfs_fs_block_size (fs)) + 1) *
rtems_rfs_fs_block_size (fs));
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
400357e0: 9101b3e3 add x3, sp, #0x6c
400357e4: 910203e1 add x1, sp, #0x80
400357e8: aa1503e0 mov x0, x21
(offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
400357ec: 9ac20ae4 udiv x4, x23, x2
400357f0: 9b02dc85 msub x5, x4, x2, x23
offset = (((offset / rtems_rfs_fs_block_size (fs)) + 1) *
400357f4: 9b020884 madd x4, x4, x2, x2
if (((rtems_rfs_fs_block_size (fs) -
400357f8: cb050042 sub x2, x2, x5
offset = (((offset / rtems_rfs_fs_block_size (fs)) + 1) *
400357fc: f1002c5f cmp x2, #0xb
40035800: 9a973097 csel x23, x4, x23, cc // cc = lo, ul, last
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
40035804: aa1703e2 mov x2, x23
40035808: 97fffa6e bl 400341c0 <rtems_rfs_block_map_seek>
4003580c: 2a0003f3 mov w19, w0
if (rc > 0)
40035810: 7100001f cmp w0, #0x0
40035814: 5400088c b.gt 40035924 <rtems_rfs_dir_read+0x1a4> <== NEVER TAKEN
entry += map.bpos.boff;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
40035818: 529ffff9 mov w25, #0xffff // #65535
4003581c: a90573fb stp x27, x28, [sp, #80]
}
*length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
40035820: b00000bb adrp x27, 4004a000 <status_code_text+0x38>
40035824: 912fe37b add x27, x27, #0xbf8
handle->dirty = false;
40035828: 3901c3ff strb wzr, [sp, #112]
handle->bnum = 0;
4003582c: b90077ff str wzr, [sp, #116]
handle->buffer = NULL;
40035830: f9003fff str xzr, [sp, #120]
while (rc == 0)
40035834: 14000009 b 40035858 <rtems_rfs_dir_read+0xd8>
offset, *length);
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
40035838: 9101b3e2 add x2, sp, #0x6c
4003583c: 910203e1 add x1, sp, #0x80
40035840: aa1503e0 mov x0, x21
40035844: 97fffa6f bl 40034200 <rtems_rfs_block_map_next_block>
40035848: 2a0003f3 mov w19, w0
if (rc == ENXIO)
4003584c: 7100181f cmp w0, #0x6
40035850: 54000460 b.eq 400358dc <rtems_rfs_dir_read+0x15c> // b.none <== ALWAYS TAKEN
while (rc == 0)
40035854: 35000460 cbnz w0, 400358e0 <rtems_rfs_dir_read+0x160> <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
40035858: b9406fe2 ldr w2, [sp, #108]
4003585c: 9101c3e1 add x1, sp, #0x70
40035860: aa1503e0 mov x0, x21
40035864: 52800023 mov w3, #0x1 // #1
40035868: 97ffc5da bl 40026fd0 <rtems_rfs_buffer_handle_request>
4003586c: 2a0003f3 mov w19, w0
if (rc > 0)
40035870: 7100027f cmp w19, #0x0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
40035874: d2b00000 mov x0, #0x80000000 // #2147483648
if (rc > 0)
40035878: 5400034c b.gt 400358e0 <rtems_rfs_dir_read+0x160> <== NEVER TAKEN
entry = rtems_rfs_buffer_data (&buffer);
4003587c: f9403fe1 ldr x1, [sp, #120]
entry += map.bpos.boff;
40035880: b9409fe3 ldr w3, [sp, #156]
entry = rtems_rfs_buffer_data (&buffer);
40035884: f9401c3c ldr x28, [x1, #56]
entry += map.bpos.boff;
40035888: 8b03039c add x28, x28, x3
elength = rtems_rfs_dir_entry_length (entry);
4003588c: 39402381 ldrb w1, [x28, #8]
40035890: 39402794 ldrb w20, [x28, #9]
40035894: aa142034 orr x20, x1, x20, lsl #8
40035898: 5ac00694 rev16 w20, w20
4003589c: 12003e94 and w20, w20, #0xffff
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
400358a0: 6b19029f cmp w20, w25
400358a4: 54000661 b.ne 40035970 <rtems_rfs_dir_read+0x1f0> // b.any
*length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;
400358a8: f9400aa2 ldr x2, [x21, #16]
400358ac: f94002c1 ldr x1, [x22]
400358b0: cb030042 sub x2, x2, x3
400358b4: 8b020021 add x1, x1, x2
400358b8: f90002c1 str x1, [x22]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
400358bc: 97ffd465 bl 4002aa50 <rtems_rfs_trace>
400358c0: 72001c1f tst w0, #0xff
400358c4: 54fffba0 b.eq 40035838 <rtems_rfs_dir_read+0xb8> // b.none <== ALWAYS TAKEN
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
400358c8: f94002c2 ldr x2, [x22] <== NOT EXECUTED
400358cc: aa1703e1 mov x1, x23 <== NOT EXECUTED
400358d0: aa1b03e0 mov x0, x27 <== NOT EXECUTED
400358d4: 97ffb2cf bl 40022410 <__wrap_printf> <== NOT EXECUTED
400358d8: 17ffffd8 b 40035838 <rtems_rfs_dir_read+0xb8> <== NOT EXECUTED
rc = ENOENT;
400358dc: 52800053 mov w19, #0x2 // #2
rtems_rfs_buffer_handle_release (fs, handle);
400358e0: 9101c3e1 add x1, sp, #0x70
400358e4: aa1503e0 mov x0, x21
400358e8: 97ffc66a bl 40027290 <rtems_rfs_buffer_handle_release>
handle->dirty = false;
400358ec: 3901c3ff strb wzr, [sp, #112]
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
400358f0: 910203e1 add x1, sp, #0x80
400358f4: aa1503e0 mov x0, x21
handle->bnum = 0;
400358f8: b90077ff str wzr, [sp, #116]
handle->buffer = NULL;
400358fc: f9003fff str xzr, [sp, #120]
40035900: 97fff964 bl 40033e90 <rtems_rfs_block_map_close>
40035904: a94573fb ldp x27, x28, [sp, #80]
return rc; }
40035908: 2a1303e0 mov w0, w19
4003590c: a94153f3 ldp x19, x20, [sp, #16]
40035910: a9425bf5 ldp x21, x22, [sp, #32]
40035914: a94363f7 ldp x23, x24, [sp, #48]
40035918: a9446bf9 ldp x25, x26, [sp, #64]
4003591c: a8ce7bfd ldp x29, x30, [sp], #224
40035920: d65f03c0 ret
rc = ENOENT;
40035924: 7100181f cmp w0, #0x6 <== NOT EXECUTED
40035928: 52800042 mov w2, #0x2 // #2 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
4003592c: 910203e1 add x1, sp, #0x80 <== NOT EXECUTED
rc = ENOENT;
40035930: 1a821273 csel w19, w19, w2, ne // ne = any <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
40035934: aa1503e0 mov x0, x21 <== NOT EXECUTED
40035938: 97fff956 bl 40033e90 <rtems_rfs_block_map_close> <== NOT EXECUTED
}
4003593c: 2a1303e0 mov w0, w19 <== NOT EXECUTED
40035940: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40035944: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
40035948: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
4003594c: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
40035950: a8ce7bfd ldp x29, x30, [sp], #224 <== NOT EXECUTED
40035954: d65f03c0 ret <== NOT EXECUTED
printf ("rtems-rfs: dir-read: dir=%" PRId32 " offset=%" PRId64 "\n",
40035958: b9401301 ldr w1, [x24, #16] <== NOT EXECUTED
4003595c: aa1703e2 mov x2, x23 <== NOT EXECUTED
40035960: b00000a0 adrp x0, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
40035964: 912d4000 add x0, x0, #0xb50 <== NOT EXECUTED
40035968: 97ffb2aa bl 40022410 <__wrap_printf> <== NOT EXECUTED
4003596c: 17ffff94 b 400357bc <rtems_rfs_dir_read+0x3c> <== NOT EXECUTED
40035970: 39400382 ldrb w2, [x28]
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
40035974: 71002a9f cmp w20, #0xa
40035978: 39400781 ldrb w1, [x28, #1]
4003597c: 39400b80 ldrb w0, [x28, #2]
40035980: 39400f97 ldrb w23, [x28, #3]
40035984: aa012041 orr x1, x2, x1, lsl #8
40035988: aa004020 orr x0, x1, x0, lsl #16
4003598c: aa176017 orr x23, x0, x23, lsl #24
40035990: 5ac00af7 rev w23, w23
40035994: 540000ad b.le 400359a8 <rtems_rfs_dir_read+0x228> <== NEVER TAKEN
40035998: b94032a0 ldr w0, [x21, #48]
4003599c: 710002ff cmp w23, #0x0
400359a0: 7a541000 ccmp w0, w20, #0x0, ne // ne = any
400359a4: 540001c8 b.hi 400359dc <rtems_rfs_dir_read+0x25c> // b.pmore <== ALWAYS TAKEN
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
400359a8: d2b00000 mov x0, #0x80000000 // #2147483648 <== NOT EXECUTED
rc = EIO;
400359ac: 528000b3 mov w19, #0x5 // #5 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
400359b0: 97ffd428 bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
400359b4: 72001c1f tst w0, #0xff <== NOT EXECUTED
400359b8: 54fff940 b.eq 400358e0 <rtems_rfs_dir_read+0x160> // b.none <== NOT EXECUTED
printf ("rtems-rfs: dir-read: "
400359bc: b9401301 ldr w1, [x24, #16] <== NOT EXECUTED
400359c0: 2a1703e3 mov w3, w23 <== NOT EXECUTED
400359c4: b9409fe4 ldr w4, [sp, #156] <== NOT EXECUTED
400359c8: 2a1403e2 mov w2, w20 <== NOT EXECUTED
400359cc: b00000a0 adrp x0, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
400359d0: 912de000 add x0, x0, #0xb78 <== NOT EXECUTED
400359d4: 97ffb28f bl 40022410 <__wrap_printf> <== NOT EXECUTED
400359d8: 17ffffc2 b 400358e0 <rtems_rfs_dir_read+0x160> <== NOT EXECUTED
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
400359dc: b9402aa0 ldr w0, [x21, #40]
400359e0: 6b17001f cmp w0, w23
400359e4: 54fffe23 b.cc 400359a8 <rtems_rfs_dir_read+0x228> // b.lo, b.ul, b.last<== NEVER TAKEN
memset (dirent, 0, sizeof (struct dirent));
400359e8: d2802318 mov x24, #0x118 // #280
400359ec: aa1803e2 mov x2, x24
400359f0: 52800001 mov w1, #0x0 // #0
400359f4: aa1a03e0 mov x0, x26
400359f8: 9400216d bl 4003dfac <memset>
memcpy (dirent->d_name, entry + RTEMS_RFS_DIR_ENTRY_SIZE, elength);
400359fc: 91005b57 add x23, x26, #0x16
dirent->d_off = rtems_rfs_block_get_pos (fs, &map.bpos);
40035a00: 910263e1 add x1, sp, #0x98
40035a04: aa1503e0 mov x0, x21
40035a08: 97fff8ae bl 40033cc0 <rtems_rfs_block_get_pos>
40035a0c: f9000740 str x0, [x26, #8]
dirent->d_reclen = sizeof (struct dirent);
40035a10: 79002358 strh w24, [x26, #16]
elength -= RTEMS_RFS_DIR_ENTRY_SIZE;
40035a14: 51002a84 sub w4, w20, #0xa
*length += elength;
40035a18: f94002c2 ldr x2, [x22]
40035a1c: 52801fe3 mov w3, #0xff // #255
remaining = rtems_rfs_fs_block_size (fs) - (map.bpos.boff + elength);
40035a20: b9409fe6 ldr w6, [sp, #156]
memcpy (dirent->d_name, entry + RTEMS_RFS_DIR_ENTRY_SIZE, elength);
40035a24: 91002b81 add x1, x28, #0xa
40035a28: aa1703e0 mov x0, x23
*length += elength;
40035a2c: 8b342045 add x5, x2, w20, uxth
40035a30: f90002c5 str x5, [x22]
remaining = rtems_rfs_fs_block_size (fs) - (map.bpos.boff + elength);
40035a34: f9400aa2 ldr x2, [x21, #16]
40035a38: 4b060042 sub w2, w2, w6
40035a3c: 4b140054 sub w20, w2, w20
*length += remaining;
40035a40: 71002e9f cmp w20, #0xb
40035a44: 8b34c0b4 add x20, x5, w20, sxtw
40035a48: 9a85b282 csel x2, x20, x5, lt // lt = tstop
40035a4c: 6b03009f cmp w4, w3
40035a50: 1a83d094 csel w20, w4, w3, le
40035a54: f90002c2 str x2, [x22]
memcpy (dirent->d_name, entry + RTEMS_RFS_DIR_ENTRY_SIZE, elength);
40035a58: 93407e82 sxtw x2, w20
40035a5c: 940020fe bl 4003de54 <memcpy>
dirent->d_ino = rtems_rfs_dir_entry_ino (entry);
40035a60: 39400383 ldrb w3, [x28]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
40035a64: d2b00000 mov x0, #0x80000000 // #2147483648
40035a68: 39400784 ldrb w4, [x28, #1]
40035a6c: 39400b82 ldrb w2, [x28, #2]
40035a70: 39400f81 ldrb w1, [x28, #3]
40035a74: aa042064 orr x4, x3, x4, lsl #8
dirent->d_namlen = elength;
40035a78: 79002b54 strh w20, [x26, #20]
40035a7c: aa024082 orr x2, x4, x2, lsl #16
40035a80: aa016041 orr x1, x2, x1, lsl #24
dirent->d_ino = rtems_rfs_dir_entry_ino (entry);
40035a84: 5ac00821 rev w1, w1
40035a88: f9000341 str x1, [x26]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
40035a8c: 97ffd3f1 bl 4002aa50 <rtems_rfs_trace>
40035a90: 72001c1f tst w0, #0xff
40035a94: 54fff260 b.eq 400358e0 <rtems_rfs_dir_read+0x160> // b.none <== ALWAYS TAKEN
printf ("rtems-rfs: dir-read: found off:%" PRIooff_t
40035a98: a9400742 ldp x2, x1, [x26] <== NOT EXECUTED
40035a9c: aa1703e3 mov x3, x23 <== NOT EXECUTED
40035aa0: b00000a0 adrp x0, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
40035aa4: 912f0000 add x0, x0, #0xbc0 <== NOT EXECUTED
40035aa8: 97ffb25a bl 40022410 <__wrap_printf> <== NOT EXECUTED
40035aac: 17ffff8d b 400358e0 <rtems_rfs_dir_read+0x160> <== NOT EXECUTED
0000000040036240 <rtems_rfs_file_close>:
{
40036240: a9bc7bfd stp x29, x30, [sp, #-64]!
40036244: 910003fd mov x29, sp
40036248: a90153f3 stp x19, x20, [sp, #16]
4003624c: aa0103f3 mov x19, x1
40036250: a9025bf5 stp x21, x22, [sp, #32]
40036254: aa0003f5 mov x21, x0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
40036258: d2c00200 mov x0, #0x1000000000 // #68719476736
4003625c: 97ffd1fd bl 4002aa50 <rtems_rfs_trace>
40036260: 72001c1f tst w0, #0xff
40036264: 54000e21 b.ne 40036428 <rtems_rfs_file_close+0x1e8> // b.any <== NEVER TAKEN
if (handle->shared->references > 0)
40036268: f9401660 ldr x0, [x19, #40]
4003626c: b9401014 ldr w20, [x0, #16]
40036270: 7100029f cmp w20, #0x0
40036274: 5400006d b.le 40036280 <rtems_rfs_file_close+0x40> <== NEVER TAKEN
handle->shared->references--;
40036278: 51000694 sub w20, w20, #0x1
4003627c: b9001014 str w20, [x0, #16]
rc = rtems_rfs_buffer_handle_close (fs, &handle->buffer);
40036280: 91002276 add x22, x19, #0x8
if (handle->shared->references == 0)
40036284: 34000194 cbz w20, 400362b4 <rtems_rfs_file_close+0x74> <== ALWAYS TAKEN
40036288: aa1603e1 mov x1, x22 <== NOT EXECUTED
4003628c: aa1503e0 mov x0, x21 <== NOT EXECUTED
40036290: 97ffc400 bl 40027290 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
rrc = 0;
40036294: 52800014 mov w20, #0x0 // #0 <== NOT EXECUTED
free (handle);
40036298: aa1303e0 mov x0, x19 <== NOT EXECUTED
4003629c: 97ffb145 bl 400227b0 <free> <== NOT EXECUTED
}
400362a0: 2a1403e0 mov w0, w20 <== NOT EXECUTED
400362a4: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
400362a8: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
400362ac: a8c47bfd ldp x29, x30, [sp], #64 <== NOT EXECUTED
400362b0: d65f03c0 ret <== NOT EXECUTED
if (!rtems_rfs_inode_is_loaded (&handle->shared->inode))
400362b4: f9401802 ldr x2, [x0, #48]
400362b8: a90363f7 stp x23, x24, [sp, #48]
400362bc: 91006001 add x1, x0, #0x18
400362c0: b4001162 cbz x2, 400364ec <rtems_rfs_file_close+0x2ac> <== ALWAYS TAKEN
rtems_rfs_inode_set_atime (&handle->shared->inode,
400362c4: b940c000 ldr w0, [x0, #192]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
400362c8: 52800023 mov w3, #0x1 // #1
rtems_rfs_write_u32 (&handle->node->atime, atime);
400362cc: 53187c04 lsr w4, w0, #24
400362d0: 39004044 strb w4, [x2, #16]
400362d4: 53107c05 lsr w5, w0, #16
400362d8: 53087c04 lsr w4, w0, #8
400362dc: f9400c22 ldr x2, [x1, #24]
400362e0: 39004445 strb w5, [x2, #17]
400362e4: f9400c22 ldr x2, [x1, #24]
400362e8: 39004844 strb w4, [x2, #18]
400362ec: f9400c22 ldr x2, [x1, #24]
400362f0: 39004c40 strb w0, [x2, #19]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
400362f4: 39008023 strb w3, [x1, #32]
rtems_rfs_inode_set_mtime (&handle->shared->inode,
400362f8: f9401661 ldr x1, [x19, #40]
rtems_rfs_write_u32 (&handle->node->mtime, mtime);
400362fc: 91006020 add x0, x1, #0x18
40036300: f9400c02 ldr x2, [x0, #24]
40036304: b940c421 ldr w1, [x1, #196]
40036308: 53187c26 lsr w6, w1, #24
4003630c: 39005046 strb w6, [x2, #20]
40036310: 53107c25 lsr w5, w1, #16
40036314: 53087c24 lsr w4, w1, #8
40036318: f9400c02 ldr x2, [x0, #24]
4003631c: 39005445 strb w5, [x2, #21]
40036320: f9400c02 ldr x2, [x0, #24]
40036324: 39005844 strb w4, [x2, #22]
40036328: f9400c02 ldr x2, [x0, #24]
4003632c: 39005c41 strb w1, [x2, #23]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40036330: 39008003 strb w3, [x0, #32]
rtems_rfs_inode_set_ctime (&handle->shared->inode,
40036334: f9401661 ldr x1, [x19, #40]
rtems_rfs_write_u32 (&handle->node->ctime, ctime);
40036338: 91006020 add x0, x1, #0x18
4003633c: f9400c02 ldr x2, [x0, #24]
40036340: b940c821 ldr w1, [x1, #200]
40036344: 53187c26 lsr w6, w1, #24
40036348: 39006046 strb w6, [x2, #24]
4003634c: 53107c25 lsr w5, w1, #16
40036350: 53087c24 lsr w4, w1, #8
40036354: f9400c02 ldr x2, [x0, #24]
40036358: 39006445 strb w5, [x2, #25]
4003635c: f9400c02 ldr x2, [x0, #24]
40036360: 39006844 strb w4, [x2, #26]
40036364: f9400c02 ldr x2, [x0, #24]
40036368: 39006c41 strb w1, [x2, #27]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4003636c: 39008003 strb w3, [x0, #32]
if (!rtems_rfs_block_size_equal (&handle->shared->size,
40036370: f9401662 ldr x2, [x19, #40]
40036374: 91016041 add x1, x2, #0x58
40036378: f9405c44 ldr x4, [x2, #184]
4003637c: f9403440 ldr x0, [x2, #104]
40036380: eb00009f cmp x4, x0
40036384: 54000080 b.eq 40036394 <rtems_rfs_file_close+0x154> // b.none <== ALWAYS TAKEN
*/
static inline void
rtems_rfs_block_map_set_size (rtems_rfs_block_map* map,
rtems_rfs_block_size* size)
{
rtems_rfs_block_copy_size (&map->size, size);
40036388: 29570044 ldp w4, w0, [x2, #184] <== NOT EXECUTED
4003638c: 29020024 stp w4, w0, [x1, #16] <== NOT EXECUTED
map->dirty = true;
40036390: 39016043 strb w3, [x2, #88] <== NOT EXECUTED
rc = rtems_rfs_block_map_close (fs, &handle->shared->map);
40036394: aa1503e0 mov x0, x21
40036398: 97fff6be bl 40033e90 <rtems_rfs_block_map_close>
4003639c: 2a0003f7 mov w23, w0
if (rc > 0)
400363a0: 7100001f cmp w0, #0x0
400363a4: 5400096c b.gt 400364d0 <rtems_rfs_file_close+0x290> <== NEVER TAKEN
rc = rtems_rfs_inode_close (fs, &handle->shared->inode);
400363a8: f9401661 ldr x1, [x19, #40]
400363ac: aa1503e0 mov x0, x21
400363b0: 91006021 add x1, x1, #0x18
400363b4: 97ffcadb bl 40028f20 <rtems_rfs_inode_close>
400363b8: 2a0003f7 mov w23, w0
if (rc > 0)
400363bc: 7100001f cmp w0, #0x0
400363c0: 5400040c b.gt 40036440 <rtems_rfs_file_close+0x200> <== NEVER TAKEN
rtems_chain_extract_unprotected (&handle->shared->link);
400363c4: f9401660 ldr x0, [x19, #40]
previous = the_node->previous;
400363c8: a9400402 ldp x2, x1, [x0]
next->previous = previous;
400363cc: f9000441 str x1, [x2, #8]
previous->next = next;
400363d0: f9000022 str x2, [x1]
free (handle->shared);
400363d4: 97ffb0f7 bl 400227b0 <free>
400363d8: aa1603e1 mov x1, x22
400363dc: aa1503e0 mov x0, x21
400363e0: 97ffc3ac bl 40027290 <rtems_rfs_buffer_handle_release>
handle->dirty = false;
400363e4: 3900227f strb wzr, [x19, #8]
handle->bnum = 0;
400363e8: b90006df str wzr, [x22, #4]
if (rrc > 0)
400363ec: 7100029f cmp w20, #0x0
handle->buffer = NULL;
400363f0: f90006df str xzr, [x22, #8]
400363f4: 540000ad b.le 40036408 <rtems_rfs_file_close+0x1c8> <== ALWAYS TAKEN
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
400363f8: d2c00200 mov x0, #0x1000000000 // #68719476736 <== NOT EXECUTED
400363fc: 97ffd195 bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
40036400: 72001c1f tst w0, #0xff <== NOT EXECUTED
40036404: 54000481 b.ne 40036494 <rtems_rfs_file_close+0x254> // b.any <== NOT EXECUTED
free (handle);
40036408: aa1303e0 mov x0, x19
4003640c: a94363f7 ldp x23, x24, [sp, #48]
40036410: 97ffb0e8 bl 400227b0 <free>
}
40036414: 2a1403e0 mov w0, w20
40036418: a94153f3 ldp x19, x20, [sp, #16]
4003641c: a9425bf5 ldp x21, x22, [sp, #32]
40036420: a8c47bfd ldp x29, x30, [sp], #64
40036424: d65f03c0 ret
printf ("rtems-rfs: file-close: entry: ino=%" PRId32 "\n",
40036428: f9401661 ldr x1, [x19, #40] <== NOT EXECUTED
4003642c: 900000a0 adrp x0, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
40036430: 91360000 add x0, x0, #0xd80 <== NOT EXECUTED
40036434: b9402821 ldr w1, [x1, #40] <== NOT EXECUTED
40036438: 97ffaff6 bl 40022410 <__wrap_printf> <== NOT EXECUTED
4003643c: 17ffff8b b 40036268 <rtems_rfs_file_close+0x28> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
40036440: d2c00200 mov x0, #0x1000000000 // #68719476736 <== NOT EXECUTED
40036444: 97ffd183 bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
40036448: 72001c1f tst w0, #0xff <== NOT EXECUTED
4003644c: 540005e1 b.ne 40036508 <rtems_rfs_file_close+0x2c8> // b.any <== NOT EXECUTED
rtems_chain_extract_unprotected (&handle->shared->link);
40036450: f9401660 ldr x0, [x19, #40] <== NOT EXECUTED
previous = the_node->previous;
40036454: a9400402 ldp x2, x1, [x0] <== NOT EXECUTED
if (rrc == 0)
40036458: 35fffbb4 cbnz w20, 400363cc <rtems_rfs_file_close+0x18c> <== NOT EXECUTED
next->previous = previous;
4003645c: f9000441 str x1, [x2, #8] <== NOT EXECUTED
40036460: 2a1703f4 mov w20, w23 <== NOT EXECUTED
previous->next = next;
40036464: f9000022 str x2, [x1] <== NOT EXECUTED
free (handle->shared);
40036468: 97ffb0d2 bl 400227b0 <free> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4003646c: aa1603e1 mov x1, x22 <== NOT EXECUTED
40036470: aa1503e0 mov x0, x21 <== NOT EXECUTED
40036474: 97ffc387 bl 40027290 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
40036478: 3900227f strb wzr, [x19, #8] <== NOT EXECUTED
handle->bnum = 0;
4003647c: b90006df str wzr, [x22, #4] <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
40036480: d2c00200 mov x0, #0x1000000000 // #68719476736 <== NOT EXECUTED
handle->buffer = NULL;
40036484: f90006df str xzr, [x22, #8] <== NOT EXECUTED
40036488: 97ffd172 bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
4003648c: 72001c1f tst w0, #0xff <== NOT EXECUTED
40036490: 54fffbc0 b.eq 40036408 <rtems_rfs_file_close+0x1c8> // b.none <== NOT EXECUTED
printf ("rtems-rfs: file-close: result: %d: %s\n", rrc, strerror (rrc));
40036494: 2a1403e0 mov w0, w20 <== NOT EXECUTED
40036498: 940021e1 bl 4003ec1c <strerror> <== NOT EXECUTED
4003649c: 900000a1 adrp x1, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
400364a0: aa0003e2 mov x2, x0 <== NOT EXECUTED
400364a4: 91388020 add x0, x1, #0xe20 <== NOT EXECUTED
400364a8: 2a1403e1 mov w1, w20 <== NOT EXECUTED
400364ac: 97ffafd9 bl 40022410 <__wrap_printf> <== NOT EXECUTED
free (handle);
400364b0: aa1303e0 mov x0, x19 <== NOT EXECUTED
400364b4: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
400364b8: 97ffb0be bl 400227b0 <free> <== NOT EXECUTED
}
400364bc: 2a1403e0 mov w0, w20 <== NOT EXECUTED
400364c0: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
400364c4: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
400364c8: a8c47bfd ldp x29, x30, [sp], #64 <== NOT EXECUTED
400364cc: d65f03c0 ret <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
400364d0: d2c00200 mov x0, #0x1000000000 // #68719476736 <== NOT EXECUTED
400364d4: 97ffd15f bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
400364d8: 72001c1f tst w0, #0xff <== NOT EXECUTED
400364dc: 540002c1 b.ne 40036534 <rtems_rfs_file_close+0x2f4> // b.any <== NOT EXECUTED
if (rrc == 0)
400364e0: 7100029f cmp w20, #0x0 <== NOT EXECUTED
400364e4: 1a971294 csel w20, w20, w23, ne // ne = any <== NOT EXECUTED
400364e8: 17ffffb0 b 400363a8 <rtems_rfs_file_close+0x168> <== NOT EXECUTED
rrc = rtems_rfs_inode_load (fs, &handle->shared->inode);
400364ec: aa1503e0 mov x0, x21
400364f0: 97ffc9e4 bl 40028c80 <rtems_rfs_inode_load>
if (rrc == 0)
400364f4: 34000360 cbz w0, 40036560 <rtems_rfs_file_close+0x320> <== ALWAYS TAKEN
rc = rtems_rfs_block_map_close (fs, &handle->shared->map);
400364f8: f9401662 ldr x2, [x19, #40] <== NOT EXECUTED
400364fc: 2a0003f4 mov w20, w0 <== NOT EXECUTED
40036500: 91016041 add x1, x2, #0x58 <== NOT EXECUTED
40036504: 17ffffa4 b 40036394 <rtems_rfs_file_close+0x154> <== NOT EXECUTED
printf ("rtems-rfs: file-close: inode close error: ino=%" PRId32 ": %d: %s\n",
40036508: f9401661 ldr x1, [x19, #40] <== NOT EXECUTED
4003650c: 2a1703e0 mov w0, w23 <== NOT EXECUTED
40036510: b9402838 ldr w24, [x1, #40] <== NOT EXECUTED
40036514: 940021c2 bl 4003ec1c <strerror> <== NOT EXECUTED
40036518: 900000a2 adrp x2, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
4003651c: aa0003e3 mov x3, x0 <== NOT EXECUTED
40036520: 2a1803e1 mov w1, w24 <== NOT EXECUTED
40036524: 91378040 add x0, x2, #0xde0 <== NOT EXECUTED
40036528: 2a1703e2 mov w2, w23 <== NOT EXECUTED
4003652c: 97ffafb9 bl 40022410 <__wrap_printf> <== NOT EXECUTED
40036530: 17ffffc8 b 40036450 <rtems_rfs_file_close+0x210> <== NOT EXECUTED
printf ("rtems-rfs: file-close: map close error: ino=%" PRId32 ": %d: %s\n",
40036534: f9401661 ldr x1, [x19, #40] <== NOT EXECUTED
40036538: 2a1703e0 mov w0, w23 <== NOT EXECUTED
4003653c: b9402838 ldr w24, [x1, #40] <== NOT EXECUTED
40036540: 940021b7 bl 4003ec1c <strerror> <== NOT EXECUTED
40036544: 900000a2 adrp x2, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
40036548: aa0003e3 mov x3, x0 <== NOT EXECUTED
4003654c: 2a1803e1 mov w1, w24 <== NOT EXECUTED
40036550: 9136a040 add x0, x2, #0xda8 <== NOT EXECUTED
40036554: 2a1703e2 mov w2, w23 <== NOT EXECUTED
40036558: 97ffafae bl 40022410 <__wrap_printf> <== NOT EXECUTED
4003655c: 17ffffe1 b 400364e0 <rtems_rfs_file_close+0x2a0> <== NOT EXECUTED
rtems_rfs_inode_set_atime (&handle->shared->inode,
40036560: f9401660 ldr x0, [x19, #40]
rtems_rfs_write_u32 (&handle->node->atime, atime);
40036564: 91006001 add x1, x0, #0x18
40036568: f9401802 ldr x2, [x0, #48]
4003656c: 17ffff56 b 400362c4 <rtems_rfs_file_close+0x84>
0000000040036e40 <rtems_rfs_file_get_shared>:
return &the_chain->Tail.Node;
40036e40: 9103a003 add x3, x0, #0xe8
return _Chain_Immutable_head( the_chain )->next;
40036e44: f9407000 ldr x0, [x0, #224]
while (!rtems_chain_is_tail (&fs->file_shares, node))
40036e48: eb03001f cmp x0, x3
40036e4c: 540000a1 b.ne 40036e60 <rtems_rfs_file_get_shared+0x20> // b.any
40036e50: 14000008 b 40036e70 <rtems_rfs_file_get_shared+0x30>
return the_node->next;
40036e54: f9400000 ldr x0, [x0] <== NOT EXECUTED
40036e58: eb03001f cmp x0, x3 <== NOT EXECUTED
40036e5c: 540000a0 b.eq 40036e70 <rtems_rfs_file_get_shared+0x30> // b.none <== NOT EXECUTED
if (shared->inode.ino == ino)
40036e60: b9402802 ldr w2, [x0, #40]
40036e64: 6b01005f cmp w2, w1
40036e68: 54ffff61 b.ne 40036e54 <rtems_rfs_file_get_shared+0x14> // b.any <== NEVER TAKEN
return shared;
node = rtems_chain_next (node);
}
return NULL;
}
40036e6c: d65f03c0 ret
return NULL;
40036e70: d2800000 mov x0, #0x0 // #0
}
40036e74: d65f03c0 ret
...
0000000040036810 <rtems_rfs_file_io_end>:
{
40036810: a9bb7bfd stp x29, x30, [sp, #-80]!
40036814: 910003fd mov x29, sp
40036818: a90153f3 stp x19, x20, [sp, #16]
4003681c: aa0003f3 mov x19, x0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
40036820: d2c00400 mov x0, #0x2000000000 // #137438953472
{
40036824: a9025bf5 stp x21, x22, [sp, #32]
40036828: aa0103f5 mov x21, x1
4003682c: 12001c56 and w22, w2, #0xff
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
40036830: 97ffd088 bl 4002aa50 <rtems_rfs_trace>
40036834: 72001c1f tst w0, #0xff
40036838: 54000160 b.eq 40036864 <rtems_rfs_file_io_end+0x54> // b.none <== ALWAYS TAKEN
printf ("rtems-rfs: file-io: end: %s size=%zu\n",
4003683c: 710002df cmp w22, #0x0 <== NOT EXECUTED
40036840: 900000a1 adrp x1, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
40036844: 91392021 add x1, x1, #0xe48 <== NOT EXECUTED
40036848: d0000082 adrp x2, 40048000 <_Scheduler_Table+0x60> <== NOT EXECUTED
4003684c: 912bc042 add x2, x2, #0xaf0 <== NOT EXECUTED
40036850: 900000a0 adrp x0, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
40036854: 9a811041 csel x1, x2, x1, ne // ne = any <== NOT EXECUTED
40036858: 913c2000 add x0, x0, #0xf08 <== NOT EXECUTED
4003685c: aa1503e2 mov x2, x21 <== NOT EXECUTED
40036860: 97ffaeec bl 40022410 <__wrap_printf> <== NOT EXECUTED
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
40036864: f9400a61 ldr x1, [x19, #16]
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
40036868: f9401662 ldr x2, [x19, #40]
4003686c: f9406840 ldr x0, [x2, #208]
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
40036870: b4000f01 cbz x1, 40036a50 <rtems_rfs_file_io_end+0x240> <== NEVER TAKEN
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
40036874: 91002261 add x1, x19, #0x8
if (!read)
40036878: 340008d6 cbz w22, 40036990 <rtems_rfs_file_io_end+0x180>
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
4003687c: 97ffc285 bl 40027290 <rtems_rfs_buffer_handle_release>
40036880: 2a0003f4 mov w20, w0
if (rc > 0)
40036884: 7100001f cmp w0, #0x0
40036888: 54000f2c b.gt 40036a6c <rtems_rfs_file_io_end+0x25c> <== NEVER TAKEN
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
4003688c: f9401662 ldr x2, [x19, #40]
40036890: a90363f7 stp x23, x24, [sp, #48]
40036894: f9406840 ldr x0, [x2, #208]
40036898: f90023f9 str x25, [sp, #64]
4003689c: f9400803 ldr x3, [x0, #16]
handle->bpos.boff += size;
400368a0: b9401e60 ldr w0, [x19, #28]
400368a4: 0b150001 add w1, w0, w21
400368a8: b9001e61 str w1, [x19, #28]
if (handle->bpos.boff >=
400368ac: eb21407f cmp x3, w1, uxtw
400368b0: 540000a8 b.hi 400368c4 <rtems_rfs_file_io_end+0xb4> // b.pmore
handle->bpos.bno++;
400368b4: b9401a60 ldr w0, [x19, #24]
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
400368b8: 4b030021 sub w1, w1, w3
handle->bpos.bno++;
400368bc: 11000400 add w0, w0, #0x1
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
400368c0: 29030660 stp w0, w1, [x19, #24]
mtime = !read;
400368c4: 520002c4 eor w4, w22, #0x1
length = false;
400368c8: 52800003 mov w3, #0x0 // #0
if (!read &&
400368cc: 35000156 cbnz w22, 400368f4 <rtems_rfs_file_io_end+0xe4>
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
400368d0: b9401a61 ldr w1, [x19, #24]
400368d4: b9406840 ldr w0, [x2, #104]
if (!read &&
400368d8: 34000881 cbz w1, 400369e8 <rtems_rfs_file_io_end+0x1d8>
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
400368dc: 35000860 cbnz w0, 400369e8 <rtems_rfs_file_io_end+0x1d8> <== ALWAYS TAKEN
400368e0: b9401e60 ldr w0, [x19, #28]
map->dirty = true;
400368e4: 52800021 mov w1, #0x1 // #1
length = true;
400368e8: 52800023 mov w3, #0x1 // #1
400368ec: 39016041 strb w1, [x2, #88]
map->size.offset = offset;
400368f0: b9006c40 str w0, [x2, #108]
atime = rtems_rfs_file_update_atime (handle);
400368f4: b9400261 ldr w1, [x19]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
400368f8: d2c00400 mov x0, #0x2000000000 // #137438953472
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
400368fc: d27f0037 eor x23, x1, #0x2
length = rtems_rfs_file_update_length (handle) && length;
40036900: d27e0038 eor x24, x1, #0x4
atime = rtems_rfs_file_update_atime (handle);
40036904: 12000035 and w21, w1, #0x1
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
40036908: d34106e1 ubfx x1, x23, #1, #1
length = rtems_rfs_file_update_length (handle) && length;
4003690c: 0a580878 and w24, w3, w24, lsr #2
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
40036910: 0a010097 and w23, w4, w1
40036914: 520002b9 eor w25, w21, #0x1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
40036918: 97ffd04e bl 4002aa50 <rtems_rfs_trace>
4003691c: 72001c1f tst w0, #0xff
40036920: 540001e0 b.eq 4003695c <rtems_rfs_file_io_end+0x14c> // b.none <== ALWAYS TAKEN
printf ("rtems-rfs: file-io: end: pos=%" PRIu32 ":%" PRIu32 " %c %c %c\n",
40036924: 710002bf cmp w21, #0x0 <== NOT EXECUTED
40036928: 528005a5 mov w5, #0x2d // #45 <== NOT EXECUTED
4003692c: 52800823 mov w3, #0x41 // #65 <== NOT EXECUTED
40036930: 1a850063 csel w3, w3, w5, eq // eq = none <== NOT EXECUTED
40036934: 29430a61 ldp w1, w2, [x19, #24] <== NOT EXECUTED
40036938: 710002ff cmp w23, #0x0 <== NOT EXECUTED
4003693c: 528009a4 mov w4, #0x4d // #77 <== NOT EXECUTED
40036940: 1a851084 csel w4, w4, w5, ne // ne = any <== NOT EXECUTED
40036944: 7100031f cmp w24, #0x0 <== NOT EXECUTED
40036948: 52800986 mov w6, #0x4c // #76 <== NOT EXECUTED
4003694c: 900000a0 adrp x0, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
40036950: 1a8510c5 csel w5, w6, w5, ne // ne = any <== NOT EXECUTED
40036954: 913de000 add x0, x0, #0xf78 <== NOT EXECUTED
40036958: 97ffaeae bl 40022410 <__wrap_printf> <== NOT EXECUTED
if (atime || mtime)
4003695c: 2a170320 orr w0, w25, w23
40036960: 350005a0 cbnz w0, 40036a14 <rtems_rfs_file_io_end+0x204> <== ALWAYS TAKEN
if (length)
40036964: 34000698 cbz w24, 40036a34 <rtems_rfs_file_io_end+0x224> <== ALWAYS TAKEN
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
40036968: f9401660 ldr x0, [x19, #40]
handle->shared->size.offset =
4003696c: a94363f7 ldp x23, x24, [sp, #48]
handle->shared->size.count =
40036970: f9403401 ldr x1, [x0, #104]
40036974: f94023f9 ldr x25, [sp, #64]
40036978: f9005c01 str x1, [x0, #184]
}
4003697c: 2a1403e0 mov w0, w20
40036980: a94153f3 ldp x19, x20, [sp, #16]
40036984: a9425bf5 ldp x21, x22, [sp, #32]
40036988: a8c57bfd ldp x29, x30, [sp], #80
4003698c: d65f03c0 ret
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
40036990: 52800022 mov w2, #0x1 // #1
40036994: 39002262 strb w2, [x19, #8]
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
40036998: 97ffc23e bl 40027290 <rtems_rfs_buffer_handle_release>
4003699c: 2a0003f4 mov w20, w0
if (rc > 0)
400369a0: 7100001f cmp w0, #0x0
400369a4: 54fff74d b.le 4003688c <rtems_rfs_file_io_end+0x7c> <== ALWAYS TAKEN
printf (
400369a8: 900000b3 adrp x19, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
400369ac: 91392273 add x19, x19, #0xe48 <== NOT EXECUTED
400369b0: 2a1403e0 mov w0, w20 <== NOT EXECUTED
400369b4: 9400209a bl 4003ec1c <strerror> <== NOT EXECUTED
400369b8: aa1503e2 mov x2, x21 <== NOT EXECUTED
400369bc: aa0003e4 mov x4, x0 <== NOT EXECUTED
400369c0: aa1303e1 mov x1, x19 <== NOT EXECUTED
400369c4: 2a1403e3 mov w3, w20 <== NOT EXECUTED
400369c8: 900000a0 adrp x0, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
400369cc: 913cc000 add x0, x0, #0xf30 <== NOT EXECUTED
400369d0: 97ffae90 bl 40022410 <__wrap_printf> <== NOT EXECUTED
}
400369d4: 2a1403e0 mov w0, w20 <== NOT EXECUTED
400369d8: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
400369dc: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
400369e0: a8c57bfd ldp x29, x30, [sp], #80 <== NOT EXECUTED
400369e4: d65f03c0 ret <== NOT EXECUTED
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
400369e8: 6b00003f cmp w1, w0
400369ec: 54fff7a2 b.cs 400368e0 <rtems_rfs_file_io_end+0xd0> // b.hs, b.nlast
400369f0: 51000400 sub w0, w0, #0x1
length = false;
400369f4: 52800003 mov w3, #0x0 // #0
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
400369f8: 6b00003f cmp w1, w0
400369fc: 54fff7c1 b.ne 400368f4 <rtems_rfs_file_io_end+0xe4> // b.any <== NEVER TAKEN
40036a00: b9406c41 ldr w1, [x2, #108]
40036a04: b9401e60 ldr w0, [x19, #28]
40036a08: 6b01001f cmp w0, w1
40036a0c: 54fff749 b.ls 400368f4 <rtems_rfs_file_io_end+0xe4> // b.plast <== NEVER TAKEN
40036a10: 17ffffb5 b 400368e4 <rtems_rfs_file_io_end+0xd4>
time_t now = time (NULL);
40036a14: d2800000 mov x0, #0x0 // #0
40036a18: 94002e7c bl 40042408 <time>
if (read && atime)
40036a1c: 6a1902df tst w22, w25
40036a20: 54000201 b.ne 40036a60 <rtems_rfs_file_io_end+0x250> // b.any
if (!read && mtime)
40036a24: 34fffa17 cbz w23, 40036964 <rtems_rfs_file_io_end+0x154> <== NEVER TAKEN
handle->shared->mtime = now;
40036a28: f9401661 ldr x1, [x19, #40]
40036a2c: b900c420 str w0, [x1, #196]
if (length)
40036a30: 35fff9d8 cbnz w24, 40036968 <rtems_rfs_file_io_end+0x158> <== ALWAYS TAKEN
}
40036a34: 2a1403e0 mov w0, w20
40036a38: a94153f3 ldp x19, x20, [sp, #16]
40036a3c: a9425bf5 ldp x21, x22, [sp, #32]
40036a40: a94363f7 ldp x23, x24, [sp, #48]
40036a44: f94023f9 ldr x25, [sp, #64]
40036a48: a8c57bfd ldp x29, x30, [sp], #80
40036a4c: d65f03c0 ret
int rc = 0;
40036a50: 52800014 mov w20, #0x0 // #0 <== NOT EXECUTED
40036a54: a90363f7 stp x23, x24, [sp, #48] <== NOT EXECUTED
40036a58: f90023f9 str x25, [sp, #64] <== NOT EXECUTED
40036a5c: 17ffff90 b 4003689c <rtems_rfs_file_io_end+0x8c> <== NOT EXECUTED
handle->shared->atime = now;
40036a60: f9401661 ldr x1, [x19, #40]
40036a64: b900c020 str w0, [x1, #192]
if (!read && mtime)
40036a68: 17ffffbf b 40036964 <rtems_rfs_file_io_end+0x154>
printf (
40036a6c: d0000093 adrp x19, 40048000 <_Scheduler_Table+0x60> <== NOT EXECUTED
40036a70: 912bc273 add x19, x19, #0xaf0 <== NOT EXECUTED
40036a74: 17ffffcf b 400369b0 <rtems_rfs_file_io_end+0x1a0> <== NOT EXECUTED
...
0000000040036570 <rtems_rfs_file_io_start>:
{
40036570: a9bb7bfd stp x29, x30, [sp, #-80]!
40036574: 910003fd mov x29, sp
40036578: a90153f3 stp x19, x20, [sp, #16]
4003657c: aa0003f3 mov x19, x0
40036580: aa0103f4 mov x20, x1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
40036584: d2c00400 mov x0, #0x2000000000 // #137438953472
{
40036588: a9025bf5 stp x21, x22, [sp, #32]
4003658c: 12001c56 and w22, w2, #0xff
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
40036590: 97ffd130 bl 4002aa50 <rtems_rfs_trace>
40036594: 72001c1f tst w0, #0xff
40036598: 54000160 b.eq 400365c4 <rtems_rfs_file_io_start+0x54> // b.none <== ALWAYS TAKEN
printf ("rtems-rfs: file-io: start: %s pos=%" PRIu32 ":%" PRIu32 "\n",
4003659c: 29430e62 ldp w2, w3, [x19, #24] <== NOT EXECUTED
400365a0: 710002df cmp w22, #0x0 <== NOT EXECUTED
400365a4: d0000084 adrp x4, 40048000 <_Scheduler_Table+0x60> <== NOT EXECUTED
400365a8: 912bc084 add x4, x4, #0xaf0 <== NOT EXECUTED
400365ac: 900000a1 adrp x1, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
400365b0: 91392021 add x1, x1, #0xe48 <== NOT EXECUTED
400365b4: 900000a0 adrp x0, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
400365b8: 9a811081 csel x1, x4, x1, ne // ne = any <== NOT EXECUTED
400365bc: 91394000 add x0, x0, #0xe50 <== NOT EXECUTED
400365c0: 97ffaf94 bl 40022410 <__wrap_printf> <== NOT EXECUTED
if (!rtems_rfs_buffer_handle_has_block (&handle->buffer))
400365c4: f9400a60 ldr x0, [x19, #16]
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
400365c8: f9401661 ldr x1, [x19, #40]
if (!rtems_rfs_buffer_handle_has_block (&handle->buffer))
400365cc: b40005c0 cbz x0, 40036684 <rtems_rfs_file_io_start+0x114> <== ALWAYS TAKEN
if (read
400365d0: 35000216 cbnz w22, 40036610 <rtems_rfs_file_io_start+0xa0> <== NOT EXECUTED
size = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
400365d4: f9406820 ldr x0, [x1, #208]
return 0;
400365d8: 52800015 mov w21, #0x0 // #0
*available = size - rtems_rfs_file_block_offset (handle);
400365dc: b9401e61 ldr w1, [x19, #28]
size = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
400365e0: f9400816 ldr x22, [x0, #16]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
400365e4: d2c00400 mov x0, #0x2000000000 // #137438953472
*available = size - rtems_rfs_file_block_offset (handle);
400365e8: cb0102c1 sub x1, x22, x1
400365ec: f9000281 str x1, [x20]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
400365f0: 97ffd118 bl 4002aa50 <rtems_rfs_trace>
400365f4: 72001c1f tst w0, #0xff
400365f8: 540002a1 b.ne 4003664c <rtems_rfs_file_io_start+0xdc> // b.any <== NEVER TAKEN
}
400365fc: 2a1503e0 mov w0, w21
40036600: a94153f3 ldp x19, x20, [sp, #16]
40036604: a9425bf5 ldp x21, x22, [sp, #32]
40036608: a8c57bfd ldp x29, x30, [sp], #80
4003660c: d65f03c0 ret
&& rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
40036610: b9406820 ldr w0, [x1, #104]
40036614: b9407022 ldr w2, [x1, #112]
40036618: 2a000043 orr w3, w2, w0
4003661c: 350002c3 cbnz w3, 40036674 <rtems_rfs_file_io_start+0x104> <== ALWAYS TAKEN
&& rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle)))
40036620: b9406c36 ldr w22, [x1, #108]
40036624: 34fffd96 cbz w22, 400365d4 <rtems_rfs_file_io_start+0x64> <== NEVER TAKEN
*available = size - rtems_rfs_file_block_offset (handle);
40036628: b9401e61 ldr w1, [x19, #28]
size = rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle));
4003662c: 2a1603f6 mov w22, w22
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
40036630: d2c00400 mov x0, #0x2000000000 // #137438953472
return 0;
40036634: 52800015 mov w21, #0x0 // #0
*available = size - rtems_rfs_file_block_offset (handle);
40036638: cb0102c1 sub x1, x22, x1
4003663c: f9000281 str x1, [x20]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
40036640: 97ffd104 bl 4002aa50 <rtems_rfs_trace>
40036644: 72001c1f tst w0, #0xff
40036648: 54fffda0 b.eq 400365fc <rtems_rfs_file_io_start+0x8c> // b.none <== ALWAYS TAKEN
printf ("rtems-rfs: file-io: start: available=%zu (%zu)\n",
4003664c: f9400281 ldr x1, [x20] <== NOT EXECUTED
40036650: aa1603e2 mov x2, x22 <== NOT EXECUTED
40036654: 900000a0 adrp x0, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
40036658: 913b6000 add x0, x0, #0xed8 <== NOT EXECUTED
4003665c: 97ffaf6d bl 40022410 <__wrap_printf> <== NOT EXECUTED
}
40036660: 2a1503e0 mov w0, w21 <== NOT EXECUTED
40036664: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40036668: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
4003666c: a8c57bfd ldp x29, x30, [sp], #80 <== NOT EXECUTED
40036670: d65f03c0 ret <== NOT EXECUTED
&& rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
40036674: 51000400 sub w0, w0, #0x1
40036678: 6b00005f cmp w2, w0
4003667c: 54fffac1 b.ne 400365d4 <rtems_rfs_file_io_start+0x64> // b.any <== NEVER TAKEN
40036680: 17ffffe8 b 40036620 <rtems_rfs_file_io_start+0xb0>
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
40036684: f9406820 ldr x0, [x1, #208]
40036688: 910133e3 add x3, sp, #0x4c
4003668c: 91006262 add x2, x19, #0x18
40036690: 91016021 add x1, x1, #0x58
40036694: f9001bf7 str x23, [sp, #48]
40036698: 97fff676 bl 40034070 <rtems_rfs_block_map_find>
4003669c: 2a0003f5 mov w21, w0
if (rc > 0)
400366a0: 7100001f cmp w0, #0x0
400366a4: 5400012d b.le 400366c8 <rtems_rfs_file_io_start+0x158>
if (read && (rc == ENXIO))
400366a8: 7100181f cmp w0, #0x6
400366ac: 1a9f17e0 cset w0, eq // eq = none
400366b0: 6a0002d7 ands w23, w22, w0
400366b4: 54000861 b.ne 400367c0 <rtems_rfs_file_io_start+0x250> // b.any <== NEVER TAKEN
if (rc != ENXIO)
400366b8: 71001abf cmp w21, #0x6
400366bc: 54000580 b.eq 4003676c <rtems_rfs_file_io_start+0x1fc> // b.none <== ALWAYS TAKEN
400366c0: f9401bf7 ldr x23, [sp, #48]
400366c4: 17ffffce b 400365fc <rtems_rfs_file_io_start+0x8c>
if (!read &&
400366c8: 34000316 cbz w22, 40036728 <rtems_rfs_file_io_start+0x1b8>
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
400366cc: d2c00400 mov x0, #0x2000000000 // #137438953472
400366d0: 97ffd0e0 bl 4002aa50 <rtems_rfs_trace>
400366d4: 72001c17 ands w23, w0, #0xff
400366d8: 540007c0 b.eq 400367d0 <rtems_rfs_file_io_start+0x260> // b.none <== ALWAYS TAKEN
printf ("rtems-rfs: file-io: start: block=%" PRIu32 " request-read=%s\n",
400366dc: b9404fe1 ldr w1, [sp, #76] <== NOT EXECUTED
400366e0: f0000082 adrp x2, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
400366e4: 91250042 add x2, x2, #0x940 <== NOT EXECUTED
400366e8: 900000a0 adrp x0, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
400366ec: 913a8000 add x0, x0, #0xea0 <== NOT EXECUTED
400366f0: 97ffaf48 bl 40022410 <__wrap_printf> <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
400366f4: f9401660 ldr x0, [x19, #40]
400366f8: 2a1703e3 mov w3, w23
400366fc: b9404fe2 ldr w2, [sp, #76]
40036700: 91002261 add x1, x19, #0x8
40036704: f9406800 ldr x0, [x0, #208]
40036708: 97ffc232 bl 40026fd0 <rtems_rfs_buffer_handle_request>
4003670c: 2a0003f5 mov w21, w0
if (rc > 0)
40036710: 7100001f cmp w0, #0x0
40036714: 54fffd6c b.gt 400366c0 <rtems_rfs_file_io_start+0x150> <== NEVER TAKEN
&& rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
40036718: f9401661 ldr x1, [x19, #40]
4003671c: f9401bf7 ldr x23, [sp, #48]
if (read
40036720: 34fff5b6 cbz w22, 400365d4 <rtems_rfs_file_io_start+0x64>
40036724: 17ffffbb b 40036610 <rtems_rfs_file_io_start+0xa0>
if (!read &&
40036728: b9401e60 ldr w0, [x19, #28]
4003672c: 35000560 cbnz w0, 400367d8 <rtems_rfs_file_io_start+0x268> <== ALWAYS TAKEN
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
40036730: f9401660 ldr x0, [x19, #40] <== NOT EXECUTED
(rtems_rfs_file_block_offset (handle) ||
40036734: f9400281 ldr x1, [x20] <== NOT EXECUTED
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
40036738: f9406800 ldr x0, [x0, #208] <== NOT EXECUTED
(rtems_rfs_file_block_offset (handle) ||
4003673c: f9400800 ldr x0, [x0, #16] <== NOT EXECUTED
40036740: eb00003f cmp x1, x0 <== NOT EXECUTED
40036744: 540004a3 b.cc 400367d8 <rtems_rfs_file_io_start+0x268> // b.lo, b.ul, b.last<== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
40036748: d2c00400 mov x0, #0x2000000000 // #137438953472 <== NOT EXECUTED
4003674c: 97ffd0c1 bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
40036750: 72001c1f tst w0, #0xff <== NOT EXECUTED
40036754: 54000520 b.eq 400367f8 <rtems_rfs_file_io_start+0x288> // b.none <== NOT EXECUTED
printf ("rtems-rfs: file-io: start: block=%" PRIu32 " request-read=%s\n",
40036758: f0000082 adrp x2, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
4003675c: 91252042 add x2, x2, #0x948 <== NOT EXECUTED
40036760: b9404fe1 ldr w1, [sp, #76] <== NOT EXECUTED
40036764: 52800017 mov w23, #0x0 // #0 <== NOT EXECUTED
40036768: 17ffffe0 b 400366e8 <rtems_rfs_file_io_start+0x178> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4003676c: d2c00400 mov x0, #0x2000000000 // #137438953472
40036770: 97ffd0b8 bl 4002aa50 <rtems_rfs_trace>
40036774: 72001c1f tst w0, #0xff
40036778: 54000441 b.ne 40036800 <rtems_rfs_file_io_start+0x290> // b.any <== NEVER TAKEN
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
4003677c: f9401660 ldr x0, [x19, #40]
40036780: 910133e3 add x3, sp, #0x4c
40036784: d2800022 mov x2, #0x1 // #1
40036788: 91016001 add x1, x0, #0x58
4003678c: f9406800 ldr x0, [x0, #208]
40036790: 97fff6a8 bl 40034230 <rtems_rfs_block_map_grow>
40036794: 2a0003f5 mov w21, w0
if (rc > 0)
40036798: 7100001f cmp w0, #0x0
4003679c: 54fff92c b.gt 400366c0 <rtems_rfs_file_io_start+0x150>
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
400367a0: d2c00400 mov x0, #0x2000000000 // #137438953472
400367a4: 97ffd0ab bl 4002aa50 <rtems_rfs_trace>
400367a8: 72001c1f tst w0, #0xff
400367ac: 54000260 b.eq 400367f8 <rtems_rfs_file_io_start+0x288> // b.none <== ALWAYS TAKEN
printf ("rtems-rfs: file-io: start: block=%" PRIu32 " request-read=%s\n",
400367b0: f0000082 adrp x2, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
400367b4: 91252042 add x2, x2, #0x948 <== NOT EXECUTED
400367b8: b9404fe1 ldr w1, [sp, #76] <== NOT EXECUTED
400367bc: 17ffffcb b 400366e8 <rtems_rfs_file_io_start+0x178> <== NOT EXECUTED
return 0;
400367c0: 52800015 mov w21, #0x0 // #0 <== NOT EXECUTED
400367c4: f9401bf7 ldr x23, [sp, #48] <== NOT EXECUTED
*available = 0;
400367c8: f900029f str xzr, [x20] <== NOT EXECUTED
return 0;
400367cc: 17ffff8c b 400365fc <rtems_rfs_file_io_start+0x8c> <== NOT EXECUTED
request_read = true;
400367d0: 52800037 mov w23, #0x1 // #1
400367d4: 17ffffc8 b 400366f4 <rtems_rfs_file_io_start+0x184>
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
400367d8: d2c00400 mov x0, #0x2000000000 // #137438953472
400367dc: 97ffd09d bl 4002aa50 <rtems_rfs_trace>
400367e0: 72001c17 ands w23, w0, #0xff
400367e4: 54ffff60 b.eq 400367d0 <rtems_rfs_file_io_start+0x260> // b.none <== ALWAYS TAKEN
printf ("rtems-rfs: file-io: start: block=%" PRIu32 " request-read=%s\n",
400367e8: f0000082 adrp x2, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
400367ec: 91250042 add x2, x2, #0x940 <== NOT EXECUTED
400367f0: b9404fe1 ldr w1, [sp, #76] <== NOT EXECUTED
400367f4: 17ffffbd b 400366e8 <rtems_rfs_file_io_start+0x178> <== NOT EXECUTED
request_read = false;
400367f8: 52800017 mov w23, #0x0 // #0
400367fc: 17ffffbe b 400366f4 <rtems_rfs_file_io_start+0x184>
printf ("rtems-rfs: file-io: start: grow\n");
40036800: 900000a0 adrp x0, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
40036804: 913a0000 add x0, x0, #0xe80 <== NOT EXECUTED
40036808: 97ffaf26 bl 400224a0 <__wrap_puts> <== NOT EXECUTED
4003680c: 17ffffdc b 4003677c <rtems_rfs_file_io_start+0x20c> <== NOT EXECUTED
0000000040035f20 <rtems_rfs_file_open>:
int
rtems_rfs_file_open (rtems_rfs_file_system* fs,
rtems_rfs_ino ino,
int oflag,
rtems_rfs_file_handle** file)
{
40035f20: a9ba7bfd stp x29, x30, [sp, #-96]!
40035f24: 910003fd mov x29, sp
40035f28: a90153f3 stp x19, x20, [sp, #16]
40035f2c: 2a0103f4 mov w20, w1
40035f30: a9025bf5 stp x21, x22, [sp, #32]
40035f34: aa0003f6 mov x22, x0
rtems_rfs_file_handle* handle;
rtems_rfs_file_shared* shared;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
40035f38: d2c00100 mov x0, #0x800000000 // #34359738368
{
40035f3c: a90363f7 stp x23, x24, [sp, #48]
40035f40: aa0303f7 mov x23, x3
40035f44: a9046bf9 stp x25, x26, [sp, #64]
40035f48: 2a0203f9 mov w25, w2
40035f4c: a90573fb stp x27, x28, [sp, #80]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
40035f50: 97ffd2c0 bl 4002aa50 <rtems_rfs_trace>
40035f54: 72001c1f tst w0, #0xff
40035f58: 54000541 b.ne 40036000 <rtems_rfs_file_open+0xe0> // b.any <== NEVER TAKEN
printf ("rtems-rfs: file-open: ino=%" PRId32 "\n", ino);
*file = NULL;
40035f5c: f90002ff str xzr, [x23]
/* * Allocate a new handle and initialise it. Do this before we deal with the * shared node data so we do not have to be concerned with reference * counting. */ handle = malloc (sizeof (rtems_rfs_file_handle));
40035f60: d2800021 mov x1, #0x1 // #1
40035f64: d2800600 mov x0, #0x30 // #48
40035f68: 97fff19e bl 400325e0 <calloc>
40035f6c: aa0003fc mov x28, x0
if (!handle)
40035f70: b4001540 cbz x0, 40036218 <rtems_rfs_file_open+0x2f8> <== NEVER TAKEN
return _Chain_Immutable_head( the_chain )->next;
40035f74: f94072d3 ldr x19, [x22, #224]
return &the_chain->Tail.Node;
40035f78: 9103a2d5 add x21, x22, #0xe8
rtems_rfs_file_get_shared (rtems_rfs_file_system* fs,
rtems_rfs_ino ino)
{
rtems_chain_node* node;
node = rtems_chain_first (&fs->file_shares);
while (!rtems_chain_is_tail (&fs->file_shares, node))
40035f7c: eb15027f cmp x19, x21
40035f80: 540000a1 b.ne 40035f94 <rtems_rfs_file_open+0x74> // b.any <== NEVER TAKEN
40035f84: 14000024 b 40036014 <rtems_rfs_file_open+0xf4>
return the_node->next;
40035f88: f9400273 ldr x19, [x19] <== NOT EXECUTED
40035f8c: eb15027f cmp x19, x21 <== NOT EXECUTED
40035f90: 54000420 b.eq 40036014 <rtems_rfs_file_open+0xf4> // b.none <== NOT EXECUTED
{
rtems_rfs_file_shared* shared;
shared = (rtems_rfs_file_shared*) node;
if (shared->inode.ino == ino)
40035f94: b9402a64 ldr w4, [x19, #40] <== NOT EXECUTED
40035f98: 6b04029f cmp w20, w4 <== NOT EXECUTED
40035f9c: 54ffff61 b.ne 40035f88 <rtems_rfs_file_open+0x68> // b.any <== NOT EXECUTED
shared->references++;
40035fa0: b9401261 ldr w1, [x19, #16] <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
40035fa4: d2c00100 mov x0, #0x800000000 // #34359738368 <== NOT EXECUTED
shared->references++;
40035fa8: 11000421 add w1, w1, #0x1 <== NOT EXECUTED
40035fac: b9001261 str w1, [x19, #16] <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
40035fb0: 97ffd2a8 bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
40035fb4: 72001c1f tst w0, #0xff <== NOT EXECUTED
40035fb8: 540001a1 b.ne 40035fec <rtems_rfs_file_open+0xcc> // b.any <== NOT EXECUTED
return 0;
40035fbc: 52800018 mov w24, #0x0 // #0
*file = handle;
40035fc0: f90002fc str x28, [x23]
handle->flags = oflag;
40035fc4: b9000399 str w25, [x28]
handle->shared = shared;
40035fc8: f9001793 str x19, [x28, #40]
}
40035fcc: 2a1803e0 mov w0, w24
40035fd0: a94153f3 ldp x19, x20, [sp, #16]
40035fd4: a9425bf5 ldp x21, x22, [sp, #32]
40035fd8: a94363f7 ldp x23, x24, [sp, #48]
40035fdc: a9446bf9 ldp x25, x26, [sp, #64]
40035fe0: a94573fb ldp x27, x28, [sp, #80]
40035fe4: a8c67bfd ldp x29, x30, [sp], #96
40035fe8: d65f03c0 ret
printf ("rtems-rfs: file-open: ino=%" PRId32 " shared\n", ino);
40035fec: 2a1403e1 mov w1, w20 <== NOT EXECUTED
40035ff0: b00000a0 adrp x0, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
40035ff4: 9132e000 add x0, x0, #0xcb8 <== NOT EXECUTED
40035ff8: 97ffb106 bl 40022410 <__wrap_printf> <== NOT EXECUTED
40035ffc: 17fffff0 b 40035fbc <rtems_rfs_file_open+0x9c> <== NOT EXECUTED
printf ("rtems-rfs: file-open: ino=%" PRId32 "\n", ino);
40036000: 2a1403e1 mov w1, w20 <== NOT EXECUTED
40036004: 900000a0 adrp x0, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
40036008: 91326000 add x0, x0, #0xc98 <== NOT EXECUTED
4003600c: 97ffb101 bl 40022410 <__wrap_printf> <== NOT EXECUTED
40036010: 17ffffd3 b 40035f5c <rtems_rfs_file_open+0x3c> <== NOT EXECUTED
shared = malloc (sizeof (rtems_rfs_file_shared));
40036014: d2800021 mov x1, #0x1 // #1
40036018: d2801b00 mov x0, #0xd8 // #216
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
4003601c: 9100239a add x26, x28, #0x8
shared = malloc (sizeof (rtems_rfs_file_shared));
40036020: 97fff170 bl 400325e0 <calloc>
40036024: aa0003f3 mov x19, x0
if (!shared)
40036028: b4000fc0 cbz x0, 40036220 <rtems_rfs_file_open+0x300> <== NEVER TAKEN
rc = rtems_rfs_inode_open (fs, ino, &shared->inode, true);
4003602c: 9100627b add x27, x19, #0x18
40036030: 2a1403e1 mov w1, w20
40036034: aa1b03e2 mov x2, x27
40036038: aa1603e0 mov x0, x22
4003603c: 52800023 mov w3, #0x1 // #1
40036040: 97ffcb3c bl 40028d30 <rtems_rfs_inode_open>
40036044: 2a0003f8 mov w24, w0
if (rc > 0)
40036048: 7100001f cmp w0, #0x0
4003604c: 5400090c b.gt 4003616c <rtems_rfs_file_open+0x24c> <== NEVER TAKEN
rc = rtems_rfs_block_map_open (fs, &shared->inode, &shared->map);
40036050: 91016262 add x2, x19, #0x58
40036054: aa1b03e1 mov x1, x27
40036058: aa1603e0 mov x0, x22
4003605c: 97fff729 bl 40033d00 <rtems_rfs_block_map_open>
40036060: 2a0003f8 mov w24, w0
if (rc > 0)
40036064: 7100001f cmp w0, #0x0
40036068: 54000a8c b.gt 400361b8 <rtems_rfs_file_open+0x298> <== NEVER TAKEN
shared->references = 1;
4003606c: f9401a63 ldr x3, [x19, #48]
40036070: 52800020 mov w0, #0x1 // #1
40036074: b9001260 str w0, [x19, #16]
rtems_rfs_inode_unload (fs, &shared->inode, false);
40036078: aa1b03e1 mov x1, x27
old_last = tail->previous;
4003607c: f94006a5 ldr x5, [x21, #8]
40036080: 52800002 mov w2, #0x0 // #0
40036084: 39403068 ldrb w8, [x3, #12]
40036088: aa1603e0 mov x0, x22
4003608c: 39403467 ldrb w7, [x3, #13]
40036090: 39403866 ldrb w6, [x3, #14]
40036094: 39403c64 ldrb w4, [x3, #15]
40036098: aa072107 orr x7, x8, x7, lsl #8
4003609c: aa0640e6 orr x6, x7, x6, lsl #16
400360a0: aa0460c4 orr x4, x6, x4, lsl #24
400360a4: 5ac00884 rev w4, w4
shared->size.count = rtems_rfs_inode_get_block_count (&shared->inode);
400360a8: b900ba64 str w4, [x19, #184]
shared->size.offset = rtems_rfs_inode_get_block_offset (&shared->inode);
400360ac: 39402866 ldrb w6, [x3, #10]
400360b0: 39402c64 ldrb w4, [x3, #11]
400360b4: aa0420c4 orr x4, x6, x4, lsl #8
400360b8: 5ac00484 rev16 w4, w4
400360bc: 12003c84 and w4, w4, #0xffff
400360c0: b900be64 str w4, [x19, #188]
return rtems_rfs_read_u32 (&handle->node->atime);
400360c4: 39404068 ldrb w8, [x3, #16]
400360c8: 39404467 ldrb w7, [x3, #17]
400360cc: 39404866 ldrb w6, [x3, #18]
400360d0: 39404c64 ldrb w4, [x3, #19]
400360d4: aa072107 orr x7, x8, x7, lsl #8
400360d8: aa0640e6 orr x6, x7, x6, lsl #16
400360dc: aa0460c4 orr x4, x6, x4, lsl #24
400360e0: 5ac00884 rev w4, w4
shared->atime = rtems_rfs_inode_get_atime (&shared->inode);
400360e4: b900c264 str w4, [x19, #192]
return rtems_rfs_read_u32 (&handle->node->mtime);
400360e8: 39405068 ldrb w8, [x3, #20]
400360ec: 39405467 ldrb w7, [x3, #21]
400360f0: 39405866 ldrb w6, [x3, #22]
400360f4: 39405c64 ldrb w4, [x3, #23]
400360f8: aa072107 orr x7, x8, x7, lsl #8
400360fc: aa0640e6 orr x6, x7, x6, lsl #16
40036100: aa0460c4 orr x4, x6, x4, lsl #24
40036104: 5ac00884 rev w4, w4
shared->mtime = rtems_rfs_inode_get_mtime (&shared->inode);
40036108: b900c664 str w4, [x19, #196]
return rtems_rfs_read_u32 (&handle->node->ctime);
4003610c: 39406067 ldrb w7, [x3, #24]
40036110: 39406466 ldrb w6, [x3, #25]
40036114: 39406864 ldrb w4, [x3, #26]
40036118: 39406c63 ldrb w3, [x3, #27]
4003611c: aa0620e6 orr x6, x7, x6, lsl #8
the_node->next = tail;
40036120: f9000275 str x21, [x19]
40036124: aa0440c4 orr x4, x6, x4, lsl #16
tail->previous = the_node;
40036128: f90006b3 str x19, [x21, #8]
4003612c: aa036083 orr x3, x4, x3, lsl #24
shared->fs = fs;
40036130: f9006a76 str x22, [x19, #208]
40036134: 5ac00863 rev w3, w3
shared->ctime = rtems_rfs_inode_get_ctime (&shared->inode);
40036138: b900ca63 str w3, [x19, #200]
old_last->next = the_node;
4003613c: f90000b3 str x19, [x5]
the_node->previous = old_last;
40036140: f9000665 str x5, [x19, #8]
rtems_rfs_inode_unload (fs, &shared->inode, false);
40036144: 97ffcb37 bl 40028e20 <rtems_rfs_inode_unload>
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
40036148: d2c00100 mov x0, #0x800000000 // #34359738368
4003614c: 97ffd241 bl 4002aa50 <rtems_rfs_trace>
40036150: 72001c1f tst w0, #0xff
40036154: 54fff340 b.eq 40035fbc <rtems_rfs_file_open+0x9c> // b.none <== ALWAYS TAKEN
printf ("rtems-rfs: file-open: ino=%" PRId32 " share created\n", ino);
40036158: 2a1403e1 mov w1, w20 <== NOT EXECUTED
4003615c: 900000a0 adrp x0, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
40036160: 91354000 add x0, x0, #0xd50 <== NOT EXECUTED
40036164: 97ffb0ab bl 40022410 <__wrap_printf> <== NOT EXECUTED
40036168: 17ffff95 b 40035fbc <rtems_rfs_file_open+0x9c> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
4003616c: d2c00100 mov x0, #0x800000000 // #34359738368 <== NOT EXECUTED
40036170: 97ffd238 bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
40036174: 72001c1f tst w0, #0xff <== NOT EXECUTED
40036178: 54000401 b.ne 400361f8 <rtems_rfs_file_open+0x2d8> // b.any <== NOT EXECUTED
free (shared);
4003617c: aa1303e0 mov x0, x19 <== NOT EXECUTED
40036180: 97ffb18c bl 400227b0 <free> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40036184: aa1a03e1 mov x1, x26 <== NOT EXECUTED
40036188: aa1603e0 mov x0, x22 <== NOT EXECUTED
4003618c: 97ffc441 bl 40027290 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
free (handle);
40036190: aa1c03e0 mov x0, x28 <== NOT EXECUTED
40036194: 97ffb187 bl 400227b0 <free> <== NOT EXECUTED
}
40036198: 2a1803e0 mov w0, w24 <== NOT EXECUTED
4003619c: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
400361a0: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
400361a4: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
400361a8: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
400361ac: a94573fb ldp x27, x28, [sp, #80] <== NOT EXECUTED
400361b0: a8c67bfd ldp x29, x30, [sp], #96 <== NOT EXECUTED
400361b4: d65f03c0 ret <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
400361b8: d2c00100 mov x0, #0x800000000 // #34359738368 <== NOT EXECUTED
400361bc: 97ffd225 bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
400361c0: 72001c1f tst w0, #0xff <== NOT EXECUTED
400361c4: 540000a1 b.ne 400361d8 <rtems_rfs_file_open+0x2b8> // b.any <== NOT EXECUTED
rtems_rfs_inode_close (fs, &shared->inode);
400361c8: aa1b03e1 mov x1, x27 <== NOT EXECUTED
400361cc: aa1603e0 mov x0, x22 <== NOT EXECUTED
400361d0: 97ffcb54 bl 40028f20 <rtems_rfs_inode_close> <== NOT EXECUTED
400361d4: 17ffffea b 4003617c <rtems_rfs_file_open+0x25c> <== NOT EXECUTED
printf ("rtems-rfs: file-open: block map open failed: %d: %s\n",
400361d8: 2a1803e0 mov w0, w24 <== NOT EXECUTED
400361dc: 94002290 bl 4003ec1c <strerror> <== NOT EXECUTED
400361e0: 900000a1 adrp x1, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
400361e4: aa0003e2 mov x2, x0 <== NOT EXECUTED
400361e8: 91346020 add x0, x1, #0xd18 <== NOT EXECUTED
400361ec: 2a1803e1 mov w1, w24 <== NOT EXECUTED
400361f0: 97ffb088 bl 40022410 <__wrap_printf> <== NOT EXECUTED
400361f4: 17fffff5 b 400361c8 <rtems_rfs_file_open+0x2a8> <== NOT EXECUTED
printf ("rtems-rfs: file-open: inode open failed: %d: %s\n",
400361f8: 2a1803e0 mov w0, w24 <== NOT EXECUTED
400361fc: 94002288 bl 4003ec1c <strerror> <== NOT EXECUTED
40036200: 900000a1 adrp x1, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
40036204: aa0003e2 mov x2, x0 <== NOT EXECUTED
40036208: 91338020 add x0, x1, #0xce0 <== NOT EXECUTED
4003620c: 2a1803e1 mov w1, w24 <== NOT EXECUTED
40036210: 97ffb080 bl 40022410 <__wrap_printf> <== NOT EXECUTED
free (shared);
40036214: 17ffffda b 4003617c <rtems_rfs_file_open+0x25c> <== NOT EXECUTED
return ENOMEM;
40036218: 52800198 mov w24, #0xc // #12 <== NOT EXECUTED
4003621c: 17ffff6c b 40035fcc <rtems_rfs_file_open+0xac> <== NOT EXECUTED
40036220: aa1a03e1 mov x1, x26 <== NOT EXECUTED
40036224: aa1603e0 mov x0, x22 <== NOT EXECUTED
40036228: 97ffc41a bl 40027290 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
return ENOMEM;
4003622c: 52800198 mov w24, #0xc // #12 <== NOT EXECUTED
free (handle);
40036230: aa1c03e0 mov x0, x28 <== NOT EXECUTED
40036234: 97ffb15f bl 400227b0 <free> <== NOT EXECUTED
return ENOMEM;
40036238: 17ffff65 b 40035fcc <rtems_rfs_file_open+0xac> <== NOT EXECUTED
4003623c: 00000000 udf #0
0000000040036a80 <rtems_rfs_file_seek>:
{
40036a80: a9bc7bfd stp x29, x30, [sp, #-64]!
40036a84: 910003fd mov x29, sp
40036a88: a90153f3 stp x19, x20, [sp, #16]
40036a8c: aa0003f3 mov x19, x0
40036a90: aa0103f4 mov x20, x1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
40036a94: d2c00400 mov x0, #0x2000000000 // #137438953472
{
40036a98: a9025bf5 stp x21, x22, [sp, #32]
40036a9c: aa0203f5 mov x21, x2
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
40036aa0: 97ffcfec bl 4002aa50 <rtems_rfs_trace>
40036aa4: 72001c1f tst w0, #0xff
40036aa8: 54000541 b.ne 40036b50 <rtems_rfs_file_seek+0xd0> // b.any <== NEVER TAKEN
if (pos <= rtems_rfs_file_shared_get_size (rtems_rfs_file_fs (handle),
40036aac: f9401660 ldr x0, [x19, #40]
40036ab0: 9102e001 add x1, x0, #0xb8
40036ab4: f9406800 ldr x0, [x0, #208]
40036ab8: 97fff486 bl 40033cd0 <rtems_rfs_block_get_size>
40036abc: eb00029f cmp x20, x0
40036ac0: 540001e9 b.ls 40036afc <rtems_rfs_file_seek+0x7c> // b.plast <== ALWAYS TAKEN
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
40036ac4: f9400a60 ldr x0, [x19, #16] <== NOT EXECUTED
40036ac8: b40000e0 cbz x0, 40036ae4 <rtems_rfs_file_seek+0x64> <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
40036acc: f9401660 ldr x0, [x19, #40] <== NOT EXECUTED
40036ad0: 91002261 add x1, x19, #0x8 <== NOT EXECUTED
40036ad4: f9406800 ldr x0, [x0, #208] <== NOT EXECUTED
40036ad8: 97ffc1ee bl 40027290 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
if (rc > 0)
40036adc: 7100001f cmp w0, #0x0 <== NOT EXECUTED
40036ae0: 5400006c b.gt 40036aec <rtems_rfs_file_seek+0x6c> <== NOT EXECUTED
return 0;
40036ae4: 52800000 mov w0, #0x0 // #0
*new_pos = pos;
40036ae8: f90002b4 str x20, [x21]
}
40036aec: a94153f3 ldp x19, x20, [sp, #16]
40036af0: a9425bf5 ldp x21, x22, [sp, #32]
40036af4: a8c47bfd ldp x29, x30, [sp], #64
40036af8: d65f03c0 ret
rtems_rfs_file_set_bpos (handle, pos);
40036afc: f9401660 ldr x0, [x19, #40]
40036b00: 91006276 add x22, x19, #0x18
40036b04: aa1603e2 mov x2, x22
40036b08: aa1403e1 mov x1, x20
40036b0c: f9406800 ldr x0, [x0, #208]
40036b10: 97fff464 bl 40033ca0 <rtems_rfs_block_get_bpos>
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
40036b14: f9400a60 ldr x0, [x19, #16]
40036b18: b4fffe60 cbz x0, 40036ae4 <rtems_rfs_file_seek+0x64> <== ALWAYS TAKEN
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
40036b1c: f9401660 ldr x0, [x19, #40] <== NOT EXECUTED
40036b20: aa1603e2 mov x2, x22 <== NOT EXECUTED
40036b24: 9100f3e3 add x3, sp, #0x3c <== NOT EXECUTED
40036b28: 91016001 add x1, x0, #0x58 <== NOT EXECUTED
40036b2c: f9406800 ldr x0, [x0, #208] <== NOT EXECUTED
40036b30: 97fff550 bl 40034070 <rtems_rfs_block_map_find> <== NOT EXECUTED
if (rc > 0)
40036b34: 7100001f cmp w0, #0x0 <== NOT EXECUTED
40036b38: 54fffdac b.gt 40036aec <rtems_rfs_file_seek+0x6c> <== NOT EXECUTED
if (rtems_rfs_buffer_bnum (&handle->buffer) != block)
40036b3c: b9400e61 ldr w1, [x19, #12] <== NOT EXECUTED
40036b40: b9403fe0 ldr w0, [sp, #60] <== NOT EXECUTED
40036b44: 6b00003f cmp w1, w0 <== NOT EXECUTED
40036b48: 54fffce0 b.eq 40036ae4 <rtems_rfs_file_seek+0x64> // b.none <== NOT EXECUTED
40036b4c: 17ffffe0 b 40036acc <rtems_rfs_file_seek+0x4c> <== NOT EXECUTED
printf ("rtems-rfs: file-seek: new=%" PRIu64 "\n", pos);
40036b50: aa1403e1 mov x1, x20 <== NOT EXECUTED
40036b54: 900000a0 adrp x0, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
40036b58: 913ea000 add x0, x0, #0xfa8 <== NOT EXECUTED
40036b5c: 97ffae2d bl 40022410 <__wrap_printf> <== NOT EXECUTED
40036b60: 17ffffd3 b 40036aac <rtems_rfs_file_seek+0x2c> <== NOT EXECUTED
...
0000000040036b70 <rtems_rfs_file_set_size>:
{
40036b70: a9b97bfd stp x29, x30, [sp, #-112]! <== NOT EXECUTED
40036b74: 910003fd mov x29, sp <== NOT EXECUTED
40036b78: a9046bf9 stp x25, x26, [sp, #64] <== NOT EXECUTED
40036b7c: aa0003f9 mov x25, x0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
40036b80: d2c00400 mov x0, #0x2000000000 // #137438953472 <== NOT EXECUTED
{
40036b84: a90153f3 stp x19, x20, [sp, #16] <== NOT EXECUTED
40036b88: aa0103f3 mov x19, x1 <== NOT EXECUTED
40036b8c: a9025bf5 stp x21, x22, [sp, #32] <== NOT EXECUTED
rtems_rfs_block_map* map = rtems_rfs_file_map (handle);
40036b90: f9401736 ldr x22, [x25, #40] <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
40036b94: 97ffcfaf bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
40036b98: 72001c1f tst w0, #0xff <== NOT EXECUTED
40036b9c: 54000e81 b.ne 40036d6c <rtems_rfs_file_set_size+0x1fc> // b.any <== NOT EXECUTED
size = rtems_rfs_file_size (handle);
40036ba0: f9401720 ldr x0, [x25, #40] <== NOT EXECUTED
40036ba4: 9102e001 add x1, x0, #0xb8 <== NOT EXECUTED
40036ba8: f9406800 ldr x0, [x0, #208] <== NOT EXECUTED
40036bac: 97fff449 bl 40033cd0 <rtems_rfs_block_get_size> <== NOT EXECUTED
40036bb0: aa0003f4 mov x20, x0 <== NOT EXECUTED
if (size != new_size)
40036bb4: eb00027f cmp x19, x0 <== NOT EXECUTED
40036bb8: 54000b20 b.eq 40036d1c <rtems_rfs_file_set_size+0x1ac> // b.none <== NOT EXECUTED
rc = rtems_rfs_block_map_free_all (rtems_rfs_file_fs (handle), map);
40036bbc: f9401721 ldr x1, [x25, #40] <== NOT EXECUTED
rtems_rfs_block_map* map = rtems_rfs_file_map (handle);
40036bc0: 910162da add x26, x22, #0x58 <== NOT EXECUTED
rc = rtems_rfs_block_map_free_all (rtems_rfs_file_fs (handle), map);
40036bc4: f9406820 ldr x0, [x1, #208] <== NOT EXECUTED
if (new_size == 0)
40036bc8: b4000993 cbz x19, 40036cf8 <rtems_rfs_file_set_size+0x188> <== NOT EXECUTED
rtems_rfs_block_map_count (map) -
40036bcc: b9401345 ldr w5, [x26, #16] <== NOT EXECUTED
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
40036bd0: f9400815 ldr x21, [x0, #16] <== NOT EXECUTED
if (size < new_size)
40036bd4: 54000d69 b.ls 40036d80 <rtems_rfs_file_set_size+0x210> // b.plast <== NOT EXECUTED
count = new_size - size;
40036bd8: cb140274 sub x20, x19, x20 <== NOT EXECUTED
map->dirty = true;
40036bdc: 52800036 mov w22, #0x1 // #1 <== NOT EXECUTED
40036be0: a90363f7 stp x23, x24, [sp, #48] <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
40036be4: 91002337 add x23, x25, #0x8 <== NOT EXECUTED
read_block = false;
40036be8: 52800018 mov w24, #0x0 // #0 <== NOT EXECUTED
40036bec: 14000024 b 40036c7c <rtems_rfs_file_set_size+0x10c> <== NOT EXECUTED
length = count + bpos.boff;
40036bf0: 0b140015 add w21, w0, w20 <== NOT EXECUTED
read_block = true;
40036bf4: 52800038 mov w24, #0x1 // #1 <== NOT EXECUTED
40036bf8: 39000356 strb w22, [x26] <== NOT EXECUTED
map->size.offset = offset;
40036bfc: b9001755 str w21, [x26, #20] <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
40036c00: f9401720 ldr x0, [x25, #40] <== NOT EXECUTED
40036c04: 2a1803e3 mov w3, w24 <== NOT EXECUTED
40036c08: b9405fe2 ldr w2, [sp, #92] <== NOT EXECUTED
40036c0c: aa1703e1 mov x1, x23 <== NOT EXECUTED
40036c10: f9406800 ldr x0, [x0, #208] <== NOT EXECUTED
40036c14: 97ffc0ef bl 40026fd0 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
40036c18: 2a0003f3 mov w19, w0 <== NOT EXECUTED
if (rc > 0)
40036c1c: 7100001f cmp w0, #0x0 <== NOT EXECUTED
40036c20: 54000fac b.gt 40036e14 <rtems_rfs_file_set_size+0x2a4> <== NOT EXECUTED
dst = rtems_rfs_buffer_data (&handle->buffer);
40036c24: f9400b22 ldr x2, [x25, #16] <== NOT EXECUTED
memset (dst + bpos.boff, 0, length - bpos.boff);
40036c28: 52800001 mov w1, #0x0 // #0 <== NOT EXECUTED
40036c2c: b94067e0 ldr w0, [sp, #100] <== NOT EXECUTED
40036c30: f9401c43 ldr x3, [x2, #56] <== NOT EXECUTED
40036c34: 4b0002a2 sub w2, w21, w0 <== NOT EXECUTED
40036c38: 8b204060 add x0, x3, w0, uxtw <== NOT EXECUTED
40036c3c: 94001cdc bl 4003dfac <memset> <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
40036c40: f9401720 ldr x0, [x25, #40] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
40036c44: 39002336 strb w22, [x25, #8] <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
40036c48: aa1703e1 mov x1, x23 <== NOT EXECUTED
40036c4c: f9406800 ldr x0, [x0, #208] <== NOT EXECUTED
40036c50: 97ffc190 bl 40027290 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
40036c54: 2a0003f3 mov w19, w0 <== NOT EXECUTED
if (rc > 0)
40036c58: 7100001f cmp w0, #0x0 <== NOT EXECUTED
40036c5c: 54000dcc b.gt 40036e14 <rtems_rfs_file_set_size+0x2a4> <== NOT EXECUTED
count -= length - bpos.boff;
40036c60: b94067e0 ldr w0, [sp, #100] <== NOT EXECUTED
handle->shared->size.count = rtems_rfs_block_map_count (map);
40036c64: b9401345 ldr w5, [x26, #16] <== NOT EXECUTED
count -= length - bpos.boff;
40036c68: 4b0002a0 sub w0, w21, w0 <== NOT EXECUTED
while (count)
40036c6c: eb000294 subs x20, x20, x0 <== NOT EXECUTED
handle->shared->size.count = rtems_rfs_block_map_count (map);
40036c70: f9401721 ldr x1, [x25, #40] <== NOT EXECUTED
while (count)
40036c74: 54000de0 b.eq 40036e30 <rtems_rfs_file_set_size+0x2c0> // b.none <== NOT EXECUTED
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
40036c78: f9406820 ldr x0, [x1, #208] <== NOT EXECUTED
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map), &bpos);
40036c7c: 510004a4 sub w4, w5, #0x1 <== NOT EXECUTED
40036c80: b9401746 ldr w6, [x26, #20] <== NOT EXECUTED
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
40036c84: 910173e3 add x3, sp, #0x5c <== NOT EXECUTED
40036c88: 910183e2 add x2, sp, #0x60 <== NOT EXECUTED
40036c8c: aa1a03e1 mov x1, x26 <== NOT EXECUTED
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map), &bpos);
40036c90: 710000df cmp w6, #0x0 <== NOT EXECUTED
40036c94: b9006bff str wzr, [sp, #104] <== NOT EXECUTED
40036c98: 1a851084 csel w4, w4, w5, ne // ne = any <== NOT EXECUTED
40036c9c: 290c1be4 stp w4, w6, [sp, #96] <== NOT EXECUTED
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
40036ca0: 97fff4f4 bl 40034070 <rtems_rfs_block_map_find> <== NOT EXECUTED
40036ca4: 2a0003f3 mov w19, w0 <== NOT EXECUTED
if (rc > 0)
40036ca8: 7100001f cmp w0, #0x0 <== NOT EXECUTED
40036cac: 5400018d b.le 40036cdc <rtems_rfs_file_set_size+0x16c> <== NOT EXECUTED
if (rc != ENXIO)
40036cb0: 7100181f cmp w0, #0x6 <== NOT EXECUTED
40036cb4: 54000b01 b.ne 40036e14 <rtems_rfs_file_set_size+0x2a4> // b.any <== NOT EXECUTED
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
40036cb8: f9401720 ldr x0, [x25, #40] <== NOT EXECUTED
40036cbc: 910173e3 add x3, sp, #0x5c <== NOT EXECUTED
40036cc0: aa1a03e1 mov x1, x26 <== NOT EXECUTED
40036cc4: d2800022 mov x2, #0x1 // #1 <== NOT EXECUTED
40036cc8: f9406800 ldr x0, [x0, #208] <== NOT EXECUTED
40036ccc: 97fff559 bl 40034230 <rtems_rfs_block_map_grow> <== NOT EXECUTED
40036cd0: 2a0003f3 mov w19, w0 <== NOT EXECUTED
if (rc > 0)
40036cd4: 7100001f cmp w0, #0x0 <== NOT EXECUTED
40036cd8: 540009ec b.gt 40036e14 <rtems_rfs_file_set_size+0x2a4> <== NOT EXECUTED
if (count < (length - bpos.boff))
40036cdc: b94067e0 ldr w0, [sp, #100] <== NOT EXECUTED
40036ce0: 4b0002a1 sub w1, w21, w0 <== NOT EXECUTED
40036ce4: eb14003f cmp x1, x20 <== NOT EXECUTED
40036ce8: 54fff848 b.hi 40036bf0 <rtems_rfs_file_set_size+0x80> // b.pmore <== NOT EXECUTED
map->dirty = true;
40036cec: 39000356 strb w22, [x26] <== NOT EXECUTED
map->size.offset = offset;
40036cf0: b900175f str wzr, [x26, #20] <== NOT EXECUTED
}
40036cf4: 17ffffc3 b 40036c00 <rtems_rfs_file_set_size+0x90> <== NOT EXECUTED
rc = rtems_rfs_block_map_free_all (rtems_rfs_file_fs (handle), map);
40036cf8: aa1a03e1 mov x1, x26 <== NOT EXECUTED
40036cfc: 97fff6f9 bl 400348e0 <rtems_rfs_block_map_free_all> <== NOT EXECUTED
40036d00: 2a0003f3 mov w19, w0 <== NOT EXECUTED
if (rc > 0)
40036d04: 7100001f cmp w0, #0x0 <== NOT EXECUTED
40036d08: 5400012c b.gt 40036d2c <rtems_rfs_file_set_size+0x1bc> <== NOT EXECUTED
handle->shared->size.count = rtems_rfs_block_map_count (map);
40036d0c: b9401345 ldr w5, [x26, #16] <== NOT EXECUTED
40036d10: f9401721 ldr x1, [x25, #40] <== NOT EXECUTED
handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
40036d14: b9401740 ldr w0, [x26, #20] <== NOT EXECUTED
40036d18: 29170025 stp w5, w0, [x1, #184] <== NOT EXECUTED
if (rtems_rfs_file_update_mtime (handle))
40036d1c: b9400320 ldr w0, [x25] <== NOT EXECUTED
40036d20: 121f0013 and w19, w0, #0x2 <== NOT EXECUTED
40036d24: 36080100 tbz w0, #1, 40036d44 <rtems_rfs_file_set_size+0x1d4> <== NOT EXECUTED
return 0;
40036d28: 52800013 mov w19, #0x0 // #0 <== NOT EXECUTED
}
40036d2c: 2a1303e0 mov w0, w19 <== NOT EXECUTED
40036d30: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40036d34: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
40036d38: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
40036d3c: a8c77bfd ldp x29, x30, [sp], #112 <== NOT EXECUTED
40036d40: d65f03c0 ret <== NOT EXECUTED
handle->shared->mtime = time (NULL);
40036d44: d2800000 mov x0, #0x0 // #0 <== NOT EXECUTED
40036d48: 94002db0 bl 40042408 <time> <== NOT EXECUTED
40036d4c: f9401721 ldr x1, [x25, #40] <== NOT EXECUTED
}
40036d50: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
handle->shared->mtime = time (NULL);
40036d54: b900c420 str w0, [x1, #196] <== NOT EXECUTED
}
40036d58: 2a1303e0 mov w0, w19 <== NOT EXECUTED
40036d5c: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40036d60: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
40036d64: a8c77bfd ldp x29, x30, [sp], #112 <== NOT EXECUTED
40036d68: d65f03c0 ret <== NOT EXECUTED
printf ("rtems-rfs: file-set-size: size=%" PRIu64 "\n", new_size);
40036d6c: aa1303e1 mov x1, x19 <== NOT EXECUTED
40036d70: 900000a0 adrp x0, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
40036d74: 913f2000 add x0, x0, #0xfc8 <== NOT EXECUTED
40036d78: 97ffada6 bl 40022410 <__wrap_printf> <== NOT EXECUTED
40036d7c: 17ffff89 b 40036ba0 <rtems_rfs_file_set_size+0x30> <== NOT EXECUTED
(((new_size - 1) /
40036d80: d1000663 sub x3, x19, #0x1 <== NOT EXECUTED
blocks =
40036d84: 510004a2 sub w2, w5, #0x1 <== NOT EXECUTED
new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
40036d88: 9ad50a74 udiv x20, x19, x21 <== NOT EXECUTED
(((new_size - 1) /
40036d8c: 9ad50863 udiv x3, x3, x21 <== NOT EXECUTED
new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
40036d90: 9b15ce95 msub x21, x20, x21, x19 <== NOT EXECUTED
if (blocks)
40036d94: 6b030042 subs w2, w2, w3 <== NOT EXECUTED
40036d98: 540002c1 b.ne 40036df0 <rtems_rfs_file_set_size+0x280> // b.any <== NOT EXECUTED
if (rtems_rfs_block_pos_past_end (rtems_rfs_file_bpos (handle),
40036d9c: b9401b20 ldr w0, [x25, #24] <== NOT EXECUTED
map->dirty = true;
40036da0: 52800022 mov w2, #0x1 // #1 <== NOT EXECUTED
map->size.offset = offset;
40036da4: b9001755 str w21, [x26, #20] <== NOT EXECUTED
map->dirty = true;
40036da8: 390162c2 strb w2, [x22, #88] <== NOT EXECUTED
40036dac: 34000040 cbz w0, 40036db4 <rtems_rfs_file_set_size+0x244> <== NOT EXECUTED
40036db0: 34000145 cbz w5, 40036dd8 <rtems_rfs_file_set_size+0x268> <== NOT EXECUTED
40036db4: 6b05001f cmp w0, w5 <== NOT EXECUTED
40036db8: 54000102 b.cs 40036dd8 <rtems_rfs_file_set_size+0x268> // b.hs, b.nlast<== NOT EXECUTED
40036dbc: 510004a2 sub w2, w5, #0x1 <== NOT EXECUTED
40036dc0: 6b02001f cmp w0, w2 <== NOT EXECUTED
40036dc4: 54fffa81 b.ne 40036d14 <rtems_rfs_file_set_size+0x1a4> // b.any <== NOT EXECUTED
40036dc8: b9401f20 ldr w0, [x25, #28] <== NOT EXECUTED
40036dcc: 6b15001f cmp w0, w21 <== NOT EXECUTED
40036dd0: 54fffa29 b.ls 40036d14 <rtems_rfs_file_set_size+0x1a4> // b.plast <== NOT EXECUTED
40036dd4: d503201f nop <== NOT EXECUTED
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map),
40036dd8: 710002bf cmp w21, #0x0 <== NOT EXECUTED
40036ddc: 510004a0 sub w0, w5, #0x1 <== NOT EXECUTED
40036de0: 1a851000 csel w0, w0, w5, ne // ne = any <== NOT EXECUTED
40036de4: 29035720 stp w0, w21, [x25, #24] <== NOT EXECUTED
40036de8: b900233f str wzr, [x25, #32] <== NOT EXECUTED
40036dec: 17ffffca b 40036d14 <rtems_rfs_file_set_size+0x1a4> <== NOT EXECUTED
rc = rtems_rfs_block_map_shrink (rtems_rfs_file_fs (handle),
40036df0: 2a0203e2 mov w2, w2 <== NOT EXECUTED
40036df4: 91016021 add x1, x1, #0x58 <== NOT EXECUTED
40036df8: 97fff5fe bl 400345f0 <rtems_rfs_block_map_shrink> <== NOT EXECUTED
40036dfc: 2a0003f3 mov w19, w0 <== NOT EXECUTED
if (rc > 0)
40036e00: 7100001f cmp w0, #0x0 <== NOT EXECUTED
40036e04: 54fff94c b.gt 40036d2c <rtems_rfs_file_set_size+0x1bc> <== NOT EXECUTED
if (rtems_rfs_block_pos_past_end (rtems_rfs_file_bpos (handle),
40036e08: b9401345 ldr w5, [x26, #16] <== NOT EXECUTED
40036e0c: f9401721 ldr x1, [x25, #40] <== NOT EXECUTED
40036e10: 17ffffe3 b 40036d9c <rtems_rfs_file_set_size+0x22c> <== NOT EXECUTED
}
40036e14: 2a1303e0 mov w0, w19 <== NOT EXECUTED
40036e18: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40036e1c: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
40036e20: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
40036e24: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
40036e28: a8c77bfd ldp x29, x30, [sp], #112 <== NOT EXECUTED
40036e2c: d65f03c0 ret <== NOT EXECUTED
40036e30: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
40036e34: 17ffffb8 b 40036d14 <rtems_rfs_file_set_size+0x1a4> <== NOT EXECUTED
...
0000000040027790 <rtems_rfs_format>:
return 0;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
{
40027790: a9a37bfd stp x29, x30, [sp, #-464]!
40027794: 910003fd mov x29, sp
40027798: f90033e0 str x0, [sp, #96]
rtems_rfs_file_system fs;
int group;
int rc;
if (config->verbose)
4002779c: 3940a420 ldrb w0, [x1, #41]
{
400277a0: a90153f3 stp x19, x20, [sp, #16]
400277a4: a90363f7 stp x23, x24, [sp, #48]
400277a8: aa0103f7 mov x23, x1
if (config->verbose)
400277ac: 35004b80 cbnz w0, 4002811c <rtems_rfs_format+0x98c> <== NEVER TAKEN
printf ("rtems-rfs: format: %s\n", name);
memset (&fs, 0, sizeof (rtems_rfs_file_system));
400277b0: d2802002 mov x2, #0x100 // #256
400277b4: 52800001 mov w1, #0x0 // #0
400277b8: 910343e0 add x0, sp, #0xd0
400277bc: 940059fc bl 4003dfac <memset>
fs.flags = RTEMS_RFS_FS_NO_LOCAL_CACHE;
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
400277c0: f94033e0 ldr x0, [sp, #96]
head->next = tail;
400277c4: 910563e9 add x9, sp, #0x158
tail->previous = head;
400277c8: 910543e8 add x8, sp, #0x150
head->next = tail;
400277cc: 9105e3e7 add x7, sp, #0x178
tail->previous = head;
400277d0: 9105c3e6 add x6, sp, #0x170
head->next = tail;
400277d4: 910663e5 add x5, sp, #0x198
tail->previous = head;
400277d8: 910643e4 add x4, sp, #0x190
head->next = tail;
400277dc: 9106e3e3 add x3, sp, #0x1b8
tail->previous = head;
400277e0: 9106c3e2 add x2, sp, #0x1b0
fs.max_held_buffers = RTEMS_RFS_FS_MAX_HELD_BUFFERS;
400277e4: 528000aa mov w10, #0x5 // #5
fs.flags = RTEMS_RFS_FS_NO_LOCAL_CACHE;
400277e8: 5280004b mov w11, #0x2 // #2
rc = rtems_rfs_buffer_open (name, &fs);
400277ec: 910343e1 add x1, sp, #0xd0
fs.flags = RTEMS_RFS_FS_NO_LOCAL_CACHE;
400277f0: b900d3eb str w11, [sp, #208]
fs.max_held_buffers = RTEMS_RFS_FS_MAX_HELD_BUFFERS;
400277f4: b9014bea str w10, [sp, #328]
head->next = tail;
400277f8: f900abe9 str x9, [sp, #336]
tail->previous = head;
400277fc: f900b3e8 str x8, [sp, #352]
head->next = tail;
40027800: f900bbe7 str x7, [sp, #368]
tail->previous = head;
40027804: f900c3e6 str x6, [sp, #384]
head->next = tail;
40027808: f900cbe5 str x5, [sp, #400]
tail->previous = head;
4002780c: f900d3e4 str x4, [sp, #416]
head->next = tail;
40027810: f900dbe3 str x3, [sp, #432]
tail->previous = head;
40027814: f900e3e2 str x2, [sp, #448]
rc = rtems_rfs_buffer_open (name, &fs);
40027818: 97fffea6 bl 400272b0 <rtems_rfs_buffer_open>
4002781c: 2a0003f3 mov w19, w0
if (rc != 0)
40027820: 350067c0 cbnz w0, 40028518 <rtems_rfs_format+0xd88> <== NEVER TAKEN
}
/*
* Check the media.
*/
if (rtems_rfs_fs_media_block_size (&fs) == 0)
40027824: f9407be0 ldr x0, [sp, #240]
40027828: b9402c02 ldr w2, [x0, #44]
4002782c: 34006502 cbz w2, 400284cc <rtems_rfs_format+0xd3c> <== NEVER TAKEN
fs->block_size = config->block_size;
40027830: f94002e1 ldr x1, [x23]
40027834: f90073e1 str x1, [sp, #224]
if (!fs->block_size)
40027838: b40047c1 cbz x1, 40028130 <rtems_rfs_format+0x9a0>
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
4002783c: 2a0203e3 mov w3, w2
40027840: 9ac30820 udiv x0, x1, x3
40027844: 9b038400 msub x0, x0, x3, x1
40027848: b5004b00 cbnz x0, 400281a8 <rtems_rfs_format+0xa18> <== NEVER TAKEN
fs->group_blocks = config->group_blocks;
4002784c: f94006e0 ldr x0, [x23, #8]
40027850: f9008fe0 str x0, [sp, #280]
fs->group_blocks = rtems_rfs_bitmap_numof_bits (fs->block_size);
40027854: d37df021 lsl x1, x1, #3
if (!fs->group_blocks)
40027858: b5002960 cbnz x0, 40027d84 <rtems_rfs_format+0x5f4> <== NEVER TAKEN
fs->group_blocks = rtems_rfs_bitmap_numof_bits (fs->block_size);
4002785c: f9008fe1 str x1, [sp, #280]
fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;
40027860: 910343e0 add x0, sp, #0xd0
40027864: 94003d8b bl 40036e90 <rtems_rfs_fs_media_size>
40027868: f94073e3 ldr x3, [sp, #224]
return 1;
4002786c: 52800025 mov w5, #0x1 // #1
return rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs));
40027870: 2a0303e1 mov w1, w3
fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;
40027874: 9ac30800 udiv x0, x0, x3
40027878: f9006fe0 str x0, [sp, #216]
if (dividend == 0)
4002787c: 340000a0 cbz w0, 40027890 <rtems_rfs_format+0x100> <== NEVER TAKEN
return ((dividend - 1) / divisor) + 1;
40027880: 51000405 sub w5, w0, #0x1
return rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs));
40027884: 531d7062 lsl w2, w3, #3
return ((dividend - 1) / divisor) + 1;
40027888: 1ac208a5 udiv w5, w5, w2
4002788c: 110004a5 add w5, w5, #0x1
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
40027890: d343fc64 lsr x4, x3, #3
40027894: d2849266 mov x6, #0x2493 // #9363
40027898: f2b24926 movk x6, #0x9249, lsl #16
fs->group_count = rtems_rfs_rup_quotient (rtems_rfs_fs_blocks (fs),
4002789c: b90113e5 str w5, [sp, #272]
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
400278a0: f2c92486 movk x6, #0x4924, lsl #32
400278a4: f2e49246 movk x6, #0x2492, lsl #48
fs->group_inodes = config->group_inodes;
400278a8: f9400ae2 ldr x2, [x23, #16]
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
400278ac: 9bc67c84 umulh x4, x4, x6
400278b0: 2a0403e7 mov w7, w4
if (!fs->group_inodes)
400278b4: b50002e2 cbnz x2, 40027910 <rtems_rfs_format+0x180> <== NEVER TAKEN
if (config->inode_overhead)
400278b8: b9401ae6 ldr w6, [x23, #24]
400278bc: 52800028 mov w8, #0x1 // #1
blocks = ((rtems_rfs_fs_blocks (fs) -
400278c0: d1000400 sub x0, x0, #0x1
RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;
400278c4: d29eb869 mov x9, #0xf5c3 // #62915
400278c8: f2ab8509 movk x9, #0x5c28, lsl #16
if (config->inode_overhead)
400278cc: 710000df cmp w6, #0x0
400278d0: 1a8810c6 csel w6, w6, w8, ne // ne = any
RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;
400278d4: f2d851e9 movk x9, #0xc28f, lsl #32
400278d8: f2e51ea9 movk x9, #0x28f5, lsl #48
400278dc: 2a0803e2 mov w2, w8
400278e0: 93407cc6 sxtw x6, w6
400278e4: 9b067c00 mul x0, x0, x6
400278e8: d342fc00 lsr x0, x0, #2
400278ec: 9bc97c00 umulh x0, x0, x9
if (dividend == 0)
400278f0: f27e7c1f tst x0, #0x3fffffffc
RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;
400278f4: d342fc00 lsr x0, x0, #2
if (dividend == 0)
400278f8: 54000080 b.eq 40027908 <rtems_rfs_format+0x178> // b.none
return ((dividend - 1) / divisor) + 1;
400278fc: 51000400 sub w0, w0, #0x1
40027900: 1ac50800 udiv w0, w0, w5
40027904: 0b080002 add w2, w0, w8
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
40027908: 1b077c42 mul w2, w2, w7
fs->group_inodes = rtems_rfs_inodes_from_percent (fs, inode_overhead);
4002790c: 93407c42 sxtw x2, w2
fs->inodes_per_block = rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE;
40027910: f90097e4 str x4, [sp, #296]
if (dividend == 0)
40027914: 340000c2 cbz w2, 4002792c <rtems_rfs_format+0x19c> <== NEVER TAKEN
return ((dividend - 1) / divisor) + 1;
40027918: 51000440 sub w0, w2, #0x1
4002791c: 1ac70800 udiv w0, w0, w7
40027920: 11000400 add w0, w0, #0x1
rtems_rfs_rup_quotient (fs->group_inodes,
40027924: 93407c00 sxtw x0, w0
fs->inodes_per_block) * fs->inodes_per_block;
40027928: 9b007c84 mul x4, x4, x0
fs->max_name_length = config->max_name_length;
4002792c: f94012e0 ldr x0, [x23, #32]
if (fs->group_inodes > rtems_rfs_bitmap_numof_bits (fs->block_size))
40027930: d37df063 lsl x3, x3, #3
fs->group_inodes =
40027934: eb04007f cmp x3, x4
{
errno = EINVAL;
return -1;
}
if (config->verbose)
40027938: 3940a6e2 ldrb w2, [x23, #41]
fs->group_inodes =
4002793c: 9a843063 csel x3, x3, x4, cc // cc = lo, ul, last
fs->max_name_length = 512;
40027940: 7100001f cmp w0, #0x0
40027944: 52804004 mov w4, #0x200 // #512
40027948: 1a841000 csel w0, w0, w4, ne // ne = any
4002794c: b90103e0 str w0, [sp, #256]
fs->group_inodes =
40027950: f90093e3 str x3, [sp, #288]
if (config->verbose)
40027954: 35004322 cbnz w2, 400281b8 <rtems_rfs_format+0xa28> <== NEVER TAKEN
printf ("rtems-rfs: format: groups = %u\n", fs.group_count);
printf ("rtems-rfs: format: group blocks = %zu\n", fs.group_blocks);
printf ("rtems-rfs: format: group inodes = %zu\n", fs.group_inodes);
}
rc = rtems_rfs_buffer_setblksize (&fs, rtems_rfs_fs_block_size (&fs));
40027958: 910343e0 add x0, sp, #0xd0
4002795c: 97ffff09 bl 40027580 <rtems_rfs_buffer_setblksize>
40027960: 2a0003f3 mov w19, w0
if (rc != 0)
40027964: 35005c60 cbnz w0, 400284f0 <rtems_rfs_format+0xd60> <== NEVER TAKEN
rc = rtems_rfs_buffer_handle_request (fs, &handle, 0, false);
40027968: 910243e1 add x1, sp, #0x90
4002796c: 910343e0 add x0, sp, #0xd0
40027970: 52800003 mov w3, #0x0 // #0
40027974: 52800002 mov w2, #0x0 // #0
40027978: 390243ff strb wzr, [sp, #144]
handle->bnum = 0;
4002797c: b90097ff str wzr, [sp, #148]
handle->buffer = NULL;
40027980: f9004fff str xzr, [sp, #152]
40027984: 97fffd93 bl 40026fd0 <rtems_rfs_buffer_handle_request>
40027988: 2a0003f4 mov w20, w0
if (rc > 0)
4002798c: 7100001f cmp w0, #0x0
40027990: 540037cc b.gt 40028088 <rtems_rfs_format+0x8f8> <== NEVER TAKEN
sb = rtems_rfs_buffer_data (&handle);
40027994: f9404fe0 ldr x0, [sp, #152]
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
40027998: 52801fe1 mov w1, #0xff // #255
4002799c: f94073e2 ldr x2, [sp, #224]
sb = rtems_rfs_buffer_data (&handle);
400279a0: f9401c03 ldr x3, [x0, #56]
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
400279a4: aa0303e0 mov x0, x3
400279a8: 94005981 bl 4003dfac <memset>
400279ac: aa0003e3 mov x3, x0
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
400279b0: 52800024 mov w4, #0x1 // #1
400279b4: 52800502 mov w2, #0x28 // #40
400279b8: 52800121 mov w1, #0x9 // #9
400279bc: 52800400 mov w0, #0x20 // #32
400279c0: 39000062 strb w2, [x3]
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
400279c4: 52800705 mov w5, #0x38 // #56
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
400279c8: 39000461 strb w1, [x3, #1]
rc = rtems_rfs_buffer_handle_release (fs, &handle);
400279cc: 910243e1 add x1, sp, #0x90
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
400279d0: 39000860 strb w0, [x3, #2]
rc = rtems_rfs_buffer_handle_release (fs, &handle);
400279d4: 910343e0 add x0, sp, #0xd0
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
400279d8: 39000c64 strb w4, [x3, #3]
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
400279dc: 3900107f strb wzr, [x3, #4]
400279e0: 3900147f strb wzr, [x3, #5]
400279e4: 3900187f strb wzr, [x3, #6]
400279e8: 39001c7f strb wzr, [x3, #7]
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
400279ec: 39436fe2 ldrb w2, [sp, #219]
400279f0: 39003062 strb w2, [x3, #12]
400279f4: 7941b7e2 ldrh w2, [sp, #218]
400279f8: 39003462 strb w2, [x3, #13]
400279fc: f9406fe2 ldr x2, [sp, #216]
40027a00: 53087c42 lsr w2, w2, #8
40027a04: 39003862 strb w2, [x3, #14]
40027a08: f9406fe2 ldr x2, [sp, #216]
40027a0c: 39003c62 strb w2, [x3, #15]
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
40027a10: 39438fe2 ldrb w2, [sp, #227]
40027a14: 39002062 strb w2, [x3, #8]
40027a18: 7941c7e2 ldrh w2, [sp, #226]
40027a1c: 39002462 strb w2, [x3, #9]
40027a20: f94073e2 ldr x2, [sp, #224]
40027a24: 53087c42 lsr w2, w2, #8
40027a28: 39002862 strb w2, [x3, #10]
40027a2c: f94073e2 ldr x2, [sp, #224]
40027a30: 39002c62 strb w2, [x3, #11]
write_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS, fs->bad_blocks);
40027a34: 3943ffe2 ldrb w2, [sp, #255]
40027a38: 39004062 strb w2, [x3, #16]
40027a3c: 7941ffe2 ldrh w2, [sp, #254]
40027a40: 39004462 strb w2, [x3, #17]
40027a44: b940ffe2 ldr w2, [sp, #252]
40027a48: 53087c42 lsr w2, w2, #8
40027a4c: 39004862 strb w2, [x3, #18]
40027a50: b940ffe2 ldr w2, [sp, #252]
40027a54: 39004c62 strb w2, [x3, #19]
write_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH, fs->max_name_length);
40027a58: 39440fe2 ldrb w2, [sp, #259]
40027a5c: 39005062 strb w2, [x3, #20]
40027a60: 794207e2 ldrh w2, [sp, #258]
40027a64: 39005462 strb w2, [x3, #21]
40027a68: b94103e2 ldr w2, [sp, #256]
40027a6c: 53087c42 lsr w2, w2, #8
40027a70: 39005862 strb w2, [x3, #22]
40027a74: b94103e2 ldr w2, [sp, #256]
40027a78: 39005c62 strb w2, [x3, #23]
write_sb (RTEMS_RFS_SB_OFFSET_GROUPS, fs->group_count);
40027a7c: 39444fe2 ldrb w2, [sp, #275]
40027a80: 39006062 strb w2, [x3, #24]
40027a84: 794227e2 ldrh w2, [sp, #274]
40027a88: 39006462 strb w2, [x3, #25]
40027a8c: b94113e2 ldr w2, [sp, #272]
40027a90: 53087c42 lsr w2, w2, #8
40027a94: 39006862 strb w2, [x3, #26]
40027a98: b94113e2 ldr w2, [sp, #272]
40027a9c: 39006c62 strb w2, [x3, #27]
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS, fs->group_blocks);
40027aa0: 39446fe2 ldrb w2, [sp, #283]
40027aa4: 39007062 strb w2, [x3, #28]
40027aa8: 794237e2 ldrh w2, [sp, #282]
40027aac: 39007462 strb w2, [x3, #29]
40027ab0: f9408fe2 ldr x2, [sp, #280]
40027ab4: 53087c42 lsr w2, w2, #8
40027ab8: 39007862 strb w2, [x3, #30]
40027abc: f9408fe2 ldr x2, [sp, #280]
40027ac0: 39007c62 strb w2, [x3, #31]
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);
40027ac4: 39448fe2 ldrb w2, [sp, #291]
40027ac8: 39008062 strb w2, [x3, #32]
40027acc: 794247e2 ldrh w2, [sp, #290]
40027ad0: 39008462 strb w2, [x3, #33]
40027ad4: f94093e2 ldr x2, [sp, #288]
40027ad8: 53087c42 lsr w2, w2, #8
40027adc: 39008862 strb w2, [x3, #34]
40027ae0: f94093e2 ldr x2, [sp, #288]
40027ae4: 39008c62 strb w2, [x3, #35]
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
40027ae8: 3900907f strb wzr, [x3, #36]
40027aec: 3900947f strb wzr, [x3, #37]
40027af0: 3900987f strb wzr, [x3, #38]
40027af4: 39009c65 strb w5, [x3, #39]
rtems_rfs_buffer_mark_dirty (&handle);
40027af8: 390243e4 strb w4, [sp, #144]
rc = rtems_rfs_buffer_handle_release (fs, &handle);
40027afc: 97fffde5 bl 40027290 <rtems_rfs_buffer_handle_release>
40027b00: 2a0003f4 mov w20, w0
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
40027b04: 910243e1 add x1, sp, #0x90
40027b08: 910343e0 add x0, sp, #0xd0
if (rc > 0)
40027b0c: 7100029f cmp w20, #0x0
40027b10: 54003fac b.gt 40028304 <rtems_rfs_format+0xb74> <== NEVER TAKEN
40027b14: 97fffddf bl 40027290 <rtems_rfs_buffer_handle_release>
errno = EIO;
return -1;
}
for (group = 0; group < fs.group_count; group++)
40027b18: b94113e0 ldr w0, [sp, #272]
40027b1c: 7100001f cmp w0, #0x0
40027b20: 540015ad b.le 40027dd4 <rtems_rfs_format+0x644> <== NEVER TAKEN
40027b24: a90573fb stp x27, x28, [sp, #80]
printf ("\rrtems-rfs: format: group %3d: base = %" PRId32 ", size = %zd",
40027b28: d000011c adrp x28, 40049000 <IMFS_node_control_sym_link+0x640>
40027b2c: 910be39c add x28, x28, #0x2f8
printf (", blocks");
40027b30: d000011b adrp x27, 40049000 <IMFS_node_control_sym_link+0x640>
40027b34: 910cc37b add x27, x27, #0x330
40027b38: a9025bf5 stp x21, x22, [sp, #32]
40027b3c: a9046bf9 stp x25, x26, [sp, #64]
group_base = rtems_rfs_fs_block (fs, group, 0);
40027b40: f9408ff4 ldr x20, [sp, #280]
if (group_base > rtems_rfs_fs_blocks (fs))
40027b44: f9406fe0 ldr x0, [sp, #216]
group_base = rtems_rfs_fs_block (fs, group, 0);
40027b48: 1b147e75 mul w21, w19, w20
if (group_base > rtems_rfs_fs_blocks (fs))
40027b4c: 110006a1 add w1, w21, #0x1
group_base = rtems_rfs_fs_block (fs, group, 0);
40027b50: 110006b6 add w22, w21, #0x1
if (group_base > rtems_rfs_fs_blocks (fs))
40027b54: eb00003f cmp x1, x0
40027b58: 54002148 b.hi 40027f80 <rtems_rfs_format+0x7f0> // b.pmore <== NEVER TAKEN
if (!rtems_rfs_write_group (&fs, group,
40027b5c: 3940a6f8 ldrb w24, [x23, #41]
if ((group_base + group_size) > rtems_rfs_fs_blocks (fs))
40027b60: 8b010282 add x2, x20, x1
group_size = rtems_rfs_fs_blocks (fs) - group_base;
40027b64: eb02001f cmp x0, x2
40027b68: cb010000 sub x0, x0, x1
if (!rtems_rfs_write_group (&fs, group,
40027b6c: 3940a2f9 ldrb w25, [x23, #40]
group_size = rtems_rfs_fs_blocks (fs) - group_base;
40027b70: 9a943014 csel x20, x0, x20, cc // cc = lo, ul, last
if (verbose)
40027b74: 35001f18 cbnz w24, 40027f54 <rtems_rfs_format+0x7c4> <== NEVER TAKEN
handle->dirty = false;
40027b78: 390203ff strb wzr, [sp, #128]
handle->bnum = 0;
40027b7c: b90087ff str wzr, [sp, #132]
handle->buffer = NULL;
40027b80: f90047ff str xzr, [sp, #136]
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
40027b84: 2a1603e4 mov w4, w22
40027b88: aa1403e3 mov x3, x20
40027b8c: 910203e2 add x2, sp, #0x80
40027b90: 910343e1 add x1, sp, #0xd0
40027b94: 910243e0 add x0, sp, #0x90
40027b98: 97fffbee bl 40026b50 <rtems_rfs_bitmap_open>
40027b9c: 2a0003f6 mov w22, w0
if (rc > 0)
40027ba0: 7100001f cmp w0, #0x0
40027ba4: 54001a4c b.gt 40027eec <rtems_rfs_format+0x75c> <== NEVER TAKEN
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
40027ba8: f94047e0 ldr x0, [sp, #136]
40027bac: 52801fe1 mov w1, #0xff // #255
40027bb0: f94073e2 ldr x2, [sp, #224]
40027bb4: f9401c00 ldr x0, [x0, #56]
40027bb8: 940058fd bl 4003dfac <memset>
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
40027bbc: 910243e0 add x0, sp, #0x90
40027bc0: 97fffb20 bl 40026840 <rtems_rfs_bitmap_map_clear_all>
40027bc4: 2a0003f6 mov w22, w0
if (rc > 0)
40027bc8: 7100001f cmp w0, #0x0
40027bcc: 54001e4c b.gt 40027f94 <rtems_rfs_format+0x804> <== NEVER TAKEN
rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
40027bd0: 52800001 mov w1, #0x0 // #0
40027bd4: 910243e0 add x0, sp, #0x90
40027bd8: 97fffa52 bl 40026520 <rtems_rfs_bitmap_map_set>
rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
40027bdc: 910243e0 add x0, sp, #0x90
40027be0: 52800021 mov w1, #0x1 // #1
40027be4: 97fffa4f bl 40026520 <rtems_rfs_bitmap_map_set>
blocks = rtems_rfs_rup_quotient (fs->group_inodes, fs->inodes_per_block);
40027be8: f94093e0 ldr x0, [sp, #288]
if (dividend == 0)
40027bec: 34001f60 cbz w0, 40027fd8 <rtems_rfs_format+0x848> <== NEVER TAKEN
blocks = rtems_rfs_rup_quotient (fs->group_inodes, fs->inodes_per_block);
40027bf0: f94097e1 ldr x1, [sp, #296]
return ((dividend - 1) / divisor) + 1;
40027bf4: 51000416 sub w22, w0, #0x1
40027bf8: 1ac10ad6 udiv w22, w22, w1
40027bfc: 110006c0 add w0, w22, #0x1
40027c00: b9006fe0 str w0, [sp, #108]
for (b = 0; b < blocks; b++)
40027c04: 7100001f cmp w0, #0x0
40027c08: 5400014d b.le 40027c30 <rtems_rfs_format+0x4a0> <== NEVER TAKEN
40027c0c: 11000ed6 add w22, w22, #0x3
40027c10: 5280005a mov w26, #0x2 // #2
40027c14: d503201f nop
rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
40027c18: 2a1a03e1 mov w1, w26
40027c1c: 910243e0 add x0, sp, #0x90
for (b = 0; b < blocks; b++)
40027c20: 1100075a add w26, w26, #0x1
rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
40027c24: 97fffa3f bl 40026520 <rtems_rfs_bitmap_map_set>
for (b = 0; b < blocks; b++)
40027c28: 6b1a02df cmp w22, w26
40027c2c: 54ffff61 b.ne 40027c18 <rtems_rfs_format+0x488> // b.any
rc = rtems_rfs_bitmap_close (&bitmap);
40027c30: 910243e0 add x0, sp, #0x90
40027c34: 97fffbdf bl 40026bb0 <rtems_rfs_bitmap_close>
40027c38: 2a0003f6 mov w22, w0
if (rc > 0)
40027c3c: 7100001f cmp w0, #0x0
40027c40: 54001e0c b.gt 40028000 <rtems_rfs_format+0x870> <== NEVER TAKEN
rtems_rfs_buffer_mark_dirty (&handle);
40027c44: 52800020 mov w0, #0x1 // #1
40027c48: 390203e0 strb w0, [sp, #128]
if (verbose)
40027c4c: 35002178 cbnz w24, 40028078 <rtems_rfs_format+0x8e8> <== NEVER TAKEN
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
40027c50: aa1403e3 mov x3, x20
40027c54: 11000aa4 add w4, w21, #0x2
40027c58: 910203e2 add x2, sp, #0x80
40027c5c: 910343e1 add x1, sp, #0xd0
40027c60: 910243e0 add x0, sp, #0x90
40027c64: 97fffbbb bl 40026b50 <rtems_rfs_bitmap_open>
40027c68: 2a0003f4 mov w20, w0
if (rc > 0)
40027c6c: 7100001f cmp w0, #0x0
40027c70: 54001e6c b.gt 4002803c <rtems_rfs_format+0x8ac> <== NEVER TAKEN
memset (rtems_rfs_buffer_data (&handle), 0x00, rtems_rfs_fs_block_size (fs));
40027c74: f94047e0 ldr x0, [sp, #136]
40027c78: 52800001 mov w1, #0x0 // #0
40027c7c: f94073e2 ldr x2, [sp, #224]
40027c80: f9401c00 ldr x0, [x0, #56]
40027c84: 940058ca bl 4003dfac <memset>
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
40027c88: 910243e0 add x0, sp, #0x90
40027c8c: 97fffaed bl 40026840 <rtems_rfs_bitmap_map_clear_all>
40027c90: 2a0003f4 mov w20, w0
rtems_rfs_bitmap_close (&bitmap);
40027c94: 910243e0 add x0, sp, #0x90
if (rc > 0)
40027c98: 7100029f cmp w20, #0x0
40027c9c: 5400220c b.gt 400280dc <rtems_rfs_format+0x94c> <== NEVER TAKEN
rc = rtems_rfs_bitmap_close (&bitmap);
40027ca0: 97fffbc4 bl 40026bb0 <rtems_rfs_bitmap_close>
40027ca4: 2a0003f4 mov w20, w0
if (rc > 0)
40027ca8: 7100001f cmp w0, #0x0
40027cac: 5400396c b.gt 400283d8 <rtems_rfs_format+0xc48> <== NEVER TAKEN
rtems_rfs_buffer_mark_dirty (&handle);
40027cb0: 52800034 mov w20, #0x1 // #1
40027cb4: 390203f4 strb w20, [sp, #128]
if (initialise_inodes)
40027cb8: 340007b9 cbz w25, 40027dac <rtems_rfs_format+0x61c> <== ALWAYS TAKEN
for (b = 0; b < blocks; b++)
40027cbc: b9406fe0 ldr w0, [sp, #108] <== NOT EXECUTED
40027cc0: 7100001f cmp w0, #0x0 <== NOT EXECUTED
40027cc4: 5400074d b.le 40027dac <rtems_rfs_format+0x61c> <== NOT EXECUTED
40027cc8: 11000eb5 add w21, w21, #0x3 <== NOT EXECUTED
40027ccc: 0b150018 add w24, w0, w21 <== NOT EXECUTED
40027cd0: 14000009 b 40027cf4 <rtems_rfs_format+0x564> <== NOT EXECUTED
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
40027cd4: f94047e0 ldr x0, [sp, #136] <== NOT EXECUTED
for (b = 0; b < blocks; b++)
40027cd8: 110006b5 add w21, w21, #0x1 <== NOT EXECUTED
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
40027cdc: f94073e2 ldr x2, [sp, #224] <== NOT EXECUTED
40027ce0: f9401c00 ldr x0, [x0, #56] <== NOT EXECUTED
40027ce4: 940058b2 bl 4003dfac <memset> <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle);
40027ce8: 390203f4 strb w20, [sp, #128] <== NOT EXECUTED
for (b = 0; b < blocks; b++)
40027cec: 6b15031f cmp w24, w21 <== NOT EXECUTED
40027cf0: 540005e0 b.eq 40027dac <rtems_rfs_format+0x61c> // b.none <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &handle,
40027cf4: 910203e1 add x1, sp, #0x80 <== NOT EXECUTED
40027cf8: 2a1503e2 mov w2, w21 <== NOT EXECUTED
40027cfc: 910343e0 add x0, sp, #0xd0 <== NOT EXECUTED
40027d00: 52800003 mov w3, #0x0 // #0 <== NOT EXECUTED
40027d04: 97fffcb3 bl 40026fd0 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
40027d08: 2a0003f6 mov w22, w0 <== NOT EXECUTED
if (rc > 0)
40027d0c: 7100001f cmp w0, #0x0 <== NOT EXECUTED
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
40027d10: 52801fe1 mov w1, #0xff // #255 <== NOT EXECUTED
if (rc > 0)
40027d14: 54fffe0d b.le 40027cd4 <rtems_rfs_format+0x544> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40027d18: 910203e1 add x1, sp, #0x80 <== NOT EXECUTED
40027d1c: 910343e0 add x0, sp, #0xd0 <== NOT EXECUTED
40027d20: 97fffd5c bl 40027290 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
40027d24: 390203ff strb wzr, [sp, #128] <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: block %" PRId32 " request failed: %d: %s\n",
40027d28: 2a1603e0 mov w0, w22 <== NOT EXECUTED
handle->bnum = 0;
40027d2c: b90087ff str wzr, [sp, #132] <== NOT EXECUTED
handle->buffer = NULL;
40027d30: f90047ff str xzr, [sp, #136] <== NOT EXECUTED
40027d34: 94005bba bl 4003ec1c <strerror> <== NOT EXECUTED
40027d38: 2a1603e3 mov w3, w22 <== NOT EXECUTED
40027d3c: aa0003e4 mov x4, x0 <== NOT EXECUTED
40027d40: 2a1503e2 mov w2, w21 <== NOT EXECUTED
40027d44: 2a1303e1 mov w1, w19 <== NOT EXECUTED
40027d48: d0000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40027d4c: 91144000 add x0, x0, #0x510 <== NOT EXECUTED
40027d50: 97ffe9b0 bl 40022410 <__wrap_printf> <== NOT EXECUTED
config->initialise_inodes, config->verbose))
{
errno = EIO;
return -1;
40027d54: 12800014 mov w20, #0xffffffff // #-1 <== NOT EXECUTED
errno = EIO;
40027d58: 940056cd bl 4003d88c <__errno> <== NOT EXECUTED
40027d5c: 528000a1 mov w1, #0x5 // #5 <== NOT EXECUTED
return -1;
40027d60: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
40027d64: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
40027d68: a94573fb ldp x27, x28, [sp, #80] <== NOT EXECUTED
errno = EIO;
40027d6c: b9000001 str w1, [x0] <== NOT EXECUTED
errno = rc;
return -1;
}
return 0;
}
40027d70: 2a1403e0 mov w0, w20
40027d74: a94153f3 ldp x19, x20, [sp, #16]
40027d78: a94363f7 ldp x23, x24, [sp, #48]
40027d7c: a8dd7bfd ldp x29, x30, [sp], #464
40027d80: d65f03c0 ret
if (fs->group_blocks > rtems_rfs_bitmap_numof_bits (fs->block_size))
40027d84: eb01001f cmp x0, x1 <== NOT EXECUTED
40027d88: 54ffd6c9 b.ls 40027860 <rtems_rfs_format+0xd0> // b.plast <== NOT EXECUTED
printf ("group block count is higher than bits in block\n");
40027d8c: b0000100 adrp x0, 40048000 <_Scheduler_Table+0x60> <== NOT EXECUTED
40027d90: 913f2000 add x0, x0, #0xfc8 <== NOT EXECUTED
40027d94: 97ffe9c3 bl 400224a0 <__wrap_puts> <== NOT EXECUTED
errno = EINVAL;
40027d98: 940056bd bl 4003d88c <__errno> <== NOT EXECUTED
return -1;
40027d9c: 12800014 mov w20, #0xffffffff // #-1 <== NOT EXECUTED
errno = EINVAL;
40027da0: 528002c1 mov w1, #0x16 // #22 <== NOT EXECUTED
40027da4: b9000001 str w1, [x0] <== NOT EXECUTED
return -1;
40027da8: 17fffff2 b 40027d70 <rtems_rfs_format+0x5e0> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40027dac: 910203e1 add x1, sp, #0x80
40027db0: 910343e0 add x0, sp, #0xd0
40027db4: 97fffd37 bl 40027290 <rtems_rfs_buffer_handle_release>
for (group = 0; group < fs.group_count; group++)
40027db8: 11000673 add w19, w19, #0x1
40027dbc: b94113e0 ldr w0, [sp, #272]
40027dc0: 6b13001f cmp w0, w19
40027dc4: 54ffebec b.gt 40027b40 <rtems_rfs_format+0x3b0> <== NEVER TAKEN
40027dc8: a9425bf5 ldp x21, x22, [sp, #32]
40027dcc: a9446bf9 ldp x25, x26, [sp, #64]
40027dd0: a94573fb ldp x27, x28, [sp, #80]
if (config->verbose)
40027dd4: 3940a6e0 ldrb w0, [x23, #41]
40027dd8: 35002fa0 cbnz w0, 400283cc <rtems_rfs_format+0xc3c> <== NEVER TAKEN
rc = rtems_rfs_buffer_close (&fs);
40027ddc: 910343e0 add x0, sp, #0xd0
40027de0: 97fffe34 bl 400276b0 <rtems_rfs_buffer_close>
40027de4: 2a0003f3 mov w19, w0
if (rc != 0)
40027de8: 35003ac0 cbnz w0, 40028540 <rtems_rfs_format+0xdb0> <== NEVER TAKEN
rc = rtems_rfs_fs_open (name, NULL,
40027dec: f94033e0 ldr x0, [sp, #96]
40027df0: 910203e4 add x4, sp, #0x80
40027df4: 52800003 mov w3, #0x0 // #0
40027df8: 528000c2 mov w2, #0x6 // #6
40027dfc: d2800001 mov x1, #0x0 // #0
40027e00: 94003c28 bl 40036ea0 <rtems_rfs_fs_open>
if (rc != 0)
40027e04: 35002ce0 cbnz w0, 400283a0 <rtems_rfs_format+0xc10> <== NEVER TAKEN
rc = rtems_rfs_inode_alloc (fs, RTEMS_RFS_ROOT_INO, &ino);
40027e08: f94043e0 ldr x0, [sp, #128]
40027e0c: 9101f3e2 add x2, sp, #0x7c
40027e10: 52800021 mov w1, #0x1 // #1
40027e14: 9400038f bl 40028c50 <rtems_rfs_inode_alloc>
40027e18: 2a0003f4 mov w20, w0
if (rc != 0)
40027e1c: 35002fc0 cbnz w0, 40028414 <rtems_rfs_format+0xc84> <== NEVER TAKEN
if (ino != RTEMS_RFS_ROOT_INO)
40027e20: b9407ff3 ldr w19, [sp, #124]
40027e24: 7100067f cmp w19, #0x1
40027e28: 54002981 b.ne 40028358 <rtems_rfs_format+0xbc8> // b.any <== NEVER TAKEN
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
40027e2c: f94043e0 ldr x0, [sp, #128]
40027e30: 2a1303e3 mov w3, w19
40027e34: 910243e2 add x2, sp, #0x90
40027e38: 2a1303e1 mov w1, w19
40027e3c: 940003bd bl 40028d30 <rtems_rfs_inode_open>
40027e40: 2a0003f4 mov w20, w0
if (rc != 0)
40027e44: 35003000 cbnz w0, 40028444 <rtems_rfs_format+0xcb4> <== NEVER TAKEN
rc = rtems_rfs_inode_initialise (&inode, 0,
40027e48: 910243e0 add x0, sp, #0x90
40027e4c: 52800004 mov w4, #0x0 // #0
40027e50: 52800003 mov w3, #0x0 // #0
40027e54: 52883922 mov w2, #0x41c9 // #16841
40027e58: 52800001 mov w1, #0x0 // #0
40027e5c: 940004e1 bl 400291e0 <rtems_rfs_inode_initialise>
40027e60: 2a0003f3 mov w19, w0
if (rc != 0)
40027e64: 35003260 cbnz w0, 400284b0 <rtems_rfs_format+0xd20> <== NEVER TAKEN
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, ino);
40027e68: b9407fe4 ldr w4, [sp, #124]
40027e6c: 910243e1 add x1, sp, #0x90
40027e70: f94043e0 ldr x0, [sp, #128]
40027e74: b0000102 adrp x2, 40048000 <_Scheduler_Table+0x60>
40027e78: 910a8042 add x2, x2, #0x2a0
40027e7c: d2800023 mov x3, #0x1 // #1
40027e80: 94003438 bl 40034f60 <rtems_rfs_dir_add_entry>
40027e84: 2a0003f3 mov w19, w0
if (rc != 0)
40027e88: 35003060 cbnz w0, 40028494 <rtems_rfs_format+0xd04> <== NEVER TAKEN
rc = rtems_rfs_inode_close (fs, &inode);
40027e8c: f94043e0 ldr x0, [sp, #128]
40027e90: 910243e1 add x1, sp, #0x90
40027e94: 94000423 bl 40028f20 <rtems_rfs_inode_close>
40027e98: 2a0003f3 mov w19, w0
if (rc != 0)
40027e9c: 35002ee0 cbnz w0, 40028478 <rtems_rfs_format+0xce8> <== NEVER TAKEN
rc = rtems_rfs_fs_close (fs);
40027ea0: f94043e0 ldr x0, [sp, #128]
40027ea4: 94003de3 bl 40037630 <rtems_rfs_fs_close>
40027ea8: 2a0003f4 mov w20, w0
if (rc != 0)
40027eac: 34fff620 cbz w0, 40027d70 <rtems_rfs_format+0x5e0> <== ALWAYS TAKEN
rc = errno;
40027eb0: 94005677 bl 4003d88c <__errno> <== NOT EXECUTED
40027eb4: b9400014 ldr w20, [x0] <== NOT EXECUTED
printf ("rtems-rfs: format: file system close failed: %d: %s\n",
40027eb8: 2a1403e0 mov w0, w20 <== NOT EXECUTED
40027ebc: 94005b58 bl 4003ec1c <strerror> <== NOT EXECUTED
40027ec0: 2a1403e1 mov w1, w20 <== NOT EXECUTED
40027ec4: aa0003e2 mov x2, x0 <== NOT EXECUTED
40027ec8: d0000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40027ecc: 911c0000 add x0, x0, #0x700 <== NOT EXECUTED
40027ed0: 97ffe950 bl 40022410 <__wrap_printf> <== NOT EXECUTED
if (rc != 0)
40027ed4: 35002514 cbnz w20, 40028374 <rtems_rfs_format+0xbe4> <== NOT EXECUTED
}
40027ed8: 2a1403e0 mov w0, w20 <== NOT EXECUTED
40027edc: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40027ee0: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
40027ee4: a8dd7bfd ldp x29, x30, [sp], #464 <== NOT EXECUTED
40027ee8: d65f03c0 ret <== NOT EXECUTED
40027eec: 910203e1 add x1, sp, #0x80 <== NOT EXECUTED
40027ef0: 910343e0 add x0, sp, #0xd0 <== NOT EXECUTED
40027ef4: 97fffce7 bl 40027290 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
40027ef8: 390203ff strb wzr, [sp, #128] <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: open block bitmap failed: %d: %s\n",
40027efc: 2a1603e0 mov w0, w22 <== NOT EXECUTED
handle->bnum = 0;
40027f00: b90087ff str wzr, [sp, #132] <== NOT EXECUTED
handle->buffer = NULL;
40027f04: f90047ff str xzr, [sp, #136] <== NOT EXECUTED
40027f08: 94005b45 bl 4003ec1c <strerror> <== NOT EXECUTED
40027f0c: 2a1603e2 mov w2, w22 <== NOT EXECUTED
40027f10: aa0003e3 mov x3, x0 <== NOT EXECUTED
40027f14: 2a1303e1 mov w1, w19 <== NOT EXECUTED
40027f18: d0000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40027f1c: 910d0000 add x0, x0, #0x340 <== NOT EXECUTED
40027f20: 97ffe93c bl 40022410 <__wrap_printf> <== NOT EXECUTED
errno = EIO;
40027f24: 9400565a bl 4003d88c <__errno> <== NOT EXECUTED
return -1;
40027f28: 12800014 mov w20, #0xffffffff // #-1 <== NOT EXECUTED
errno = EIO;
40027f2c: 528000a1 mov w1, #0x5 // #5 <== NOT EXECUTED
return -1;
40027f30: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
40027f34: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
40027f38: a94573fb ldp x27, x28, [sp, #80] <== NOT EXECUTED
errno = EIO;
40027f3c: b9000001 str w1, [x0] <== NOT EXECUTED
}
40027f40: 2a1403e0 mov w0, w20 <== NOT EXECUTED
40027f44: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40027f48: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
40027f4c: a8dd7bfd ldp x29, x30, [sp], #464 <== NOT EXECUTED
40027f50: d65f03c0 ret <== NOT EXECUTED
printf ("\rrtems-rfs: format: group %3d: base = %" PRId32 ", size = %zd",
40027f54: aa1403e3 mov x3, x20 <== NOT EXECUTED
40027f58: 2a1603e2 mov w2, w22 <== NOT EXECUTED
40027f5c: 2a1303e1 mov w1, w19 <== NOT EXECUTED
40027f60: aa1c03e0 mov x0, x28 <== NOT EXECUTED
40027f64: 97ffe92b bl 40022410 <__wrap_printf> <== NOT EXECUTED
handle->dirty = false;
40027f68: 390203ff strb wzr, [sp, #128] <== NOT EXECUTED
printf (", blocks");
40027f6c: aa1b03e0 mov x0, x27 <== NOT EXECUTED
handle->bnum = 0;
40027f70: b90087ff str wzr, [sp, #132] <== NOT EXECUTED
handle->buffer = NULL;
40027f74: f90047ff str xzr, [sp, #136] <== NOT EXECUTED
40027f78: 97ffe926 bl 40022410 <__wrap_printf> <== NOT EXECUTED
40027f7c: 17ffff02 b 40027b84 <rtems_rfs_format+0x3f4> <== NOT EXECUTED
printf ("rtems-rfs: write-group: group %d base beyond disk limit\n",
40027f80: 2a1303e1 mov w1, w19 <== NOT EXECUTED
40027f84: d0000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40027f88: 910ae000 add x0, x0, #0x2b8 <== NOT EXECUTED
40027f8c: 97ffe921 bl 40022410 <__wrap_printf> <== NOT EXECUTED
return false;
40027f90: 17ffffe5 b 40027f24 <rtems_rfs_format+0x794> <== NOT EXECUTED
rtems_rfs_bitmap_close (&bitmap);
40027f94: 910243e0 add x0, sp, #0x90 <== NOT EXECUTED
40027f98: 97fffb06 bl 40026bb0 <rtems_rfs_bitmap_close> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40027f9c: 910203e1 add x1, sp, #0x80 <== NOT EXECUTED
40027fa0: 910343e0 add x0, sp, #0xd0 <== NOT EXECUTED
40027fa4: 97fffcbb bl 40027290 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
40027fa8: 390203ff strb wzr, [sp, #128] <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: block bitmap clear all failed: %d: %s\n",
40027fac: 2a1603e0 mov w0, w22 <== NOT EXECUTED
handle->bnum = 0;
40027fb0: b90087ff str wzr, [sp, #132] <== NOT EXECUTED
handle->buffer = NULL;
40027fb4: f90047ff str xzr, [sp, #136] <== NOT EXECUTED
40027fb8: 94005b19 bl 4003ec1c <strerror> <== NOT EXECUTED
40027fbc: 2a1603e2 mov w2, w22 <== NOT EXECUTED
40027fc0: aa0003e3 mov x3, x0 <== NOT EXECUTED
40027fc4: 2a1303e1 mov w1, w19 <== NOT EXECUTED
40027fc8: d0000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40027fcc: 910e2000 add x0, x0, #0x388 <== NOT EXECUTED
40027fd0: 97ffe910 bl 40022410 <__wrap_printf> <== NOT EXECUTED
return false;
40027fd4: 17ffffd4 b 40027f24 <rtems_rfs_format+0x794> <== NOT EXECUTED
return 1;
40027fd8: 52800022 mov w2, #0x1 // #1 <== NOT EXECUTED
rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
40027fdc: 52800041 mov w1, #0x2 // #2 <== NOT EXECUTED
40027fe0: 910243e0 add x0, sp, #0x90 <== NOT EXECUTED
return 1;
40027fe4: b9006fe2 str w2, [sp, #108] <== NOT EXECUTED
rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
40027fe8: 97fff94e bl 40026520 <rtems_rfs_bitmap_map_set> <== NOT EXECUTED
rc = rtems_rfs_bitmap_close (&bitmap);
40027fec: 910243e0 add x0, sp, #0x90 <== NOT EXECUTED
40027ff0: 97fffaf0 bl 40026bb0 <rtems_rfs_bitmap_close> <== NOT EXECUTED
40027ff4: 2a0003f6 mov w22, w0 <== NOT EXECUTED
if (rc > 0)
40027ff8: 7100001f cmp w0, #0x0 <== NOT EXECUTED
40027ffc: 54ffe24d b.le 40027c44 <rtems_rfs_format+0x4b4> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40028000: 910203e1 add x1, sp, #0x80 <== NOT EXECUTED
40028004: 910343e0 add x0, sp, #0xd0 <== NOT EXECUTED
40028008: 97fffca2 bl 40027290 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
4002800c: 390203ff strb wzr, [sp, #128] <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: close block bitmap failed: %d: %s\n",
40028010: 2a1603e0 mov w0, w22 <== NOT EXECUTED
handle->bnum = 0;
40028014: b90087ff str wzr, [sp, #132] <== NOT EXECUTED
handle->buffer = NULL;
40028018: f90047ff str xzr, [sp, #136] <== NOT EXECUTED
4002801c: 94005b00 bl 4003ec1c <strerror> <== NOT EXECUTED
40028020: 2a1603e2 mov w2, w22 <== NOT EXECUTED
40028024: aa0003e3 mov x3, x0 <== NOT EXECUTED
40028028: 2a1303e1 mov w1, w19 <== NOT EXECUTED
4002802c: b0000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40028030: 910f6000 add x0, x0, #0x3d8 <== NOT EXECUTED
40028034: 97ffe8f7 bl 40022410 <__wrap_printf> <== NOT EXECUTED
return false;
40028038: 17ffffbb b 40027f24 <rtems_rfs_format+0x794> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4002803c: 910203e1 add x1, sp, #0x80 <== NOT EXECUTED
40028040: 910343e0 add x0, sp, #0xd0 <== NOT EXECUTED
40028044: 97fffc93 bl 40027290 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
40028048: 390203ff strb wzr, [sp, #128] <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: open inode bitmap failed: %d: %s\n",
4002804c: 2a1403e0 mov w0, w20 <== NOT EXECUTED
handle->bnum = 0;
40028050: b90087ff str wzr, [sp, #132] <== NOT EXECUTED
handle->buffer = NULL;
40028054: f90047ff str xzr, [sp, #136] <== NOT EXECUTED
40028058: 94005af1 bl 4003ec1c <strerror> <== NOT EXECUTED
4002805c: 2a1403e2 mov w2, w20 <== NOT EXECUTED
40028060: aa0003e3 mov x3, x0 <== NOT EXECUTED
40028064: 2a1303e1 mov w1, w19 <== NOT EXECUTED
40028068: b0000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
4002806c: 9110c000 add x0, x0, #0x430 <== NOT EXECUTED
40028070: 97ffe8e8 bl 40022410 <__wrap_printf> <== NOT EXECUTED
return false;
40028074: 17ffffac b 40027f24 <rtems_rfs_format+0x794> <== NOT EXECUTED
printf (", inodes");
40028078: b0000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
4002807c: 91108000 add x0, x0, #0x420 <== NOT EXECUTED
40028080: 97ffe8e4 bl 40022410 <__wrap_printf> <== NOT EXECUTED
40028084: 17fffef3 b 40027c50 <rtems_rfs_format+0x4c0> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40028088: 910243e1 add x1, sp, #0x90 <== NOT EXECUTED
4002808c: 910343e0 add x0, sp, #0xd0 <== NOT EXECUTED
40028090: 97fffc80 bl 40027290 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
40028094: 390243ff strb wzr, [sp, #144] <== NOT EXECUTED
printf ("rtems-rfs: write-superblock: request failed: %d: %s\n",
40028098: 2a1403e0 mov w0, w20 <== NOT EXECUTED
handle->bnum = 0;
4002809c: b90097ff str wzr, [sp, #148] <== NOT EXECUTED
handle->buffer = NULL;
400280a0: f9004fff str xzr, [sp, #152] <== NOT EXECUTED
400280a4: 94005ade bl 4003ec1c <strerror> <== NOT EXECUTED
400280a8: 2a1403e1 mov w1, w20 <== NOT EXECUTED
400280ac: aa0003e2 mov x2, x0 <== NOT EXECUTED
400280b0: b0000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
400280b4: 91084000 add x0, x0, #0x210 <== NOT EXECUTED
400280b8: 97ffe8d6 bl 40022410 <__wrap_printf> <== NOT EXECUTED
printf ("rtems-rfs: format: superblock write failed\n");
400280bc: b0000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
400280c0: 910a2000 add x0, x0, #0x288 <== NOT EXECUTED
400280c4: 97ffe8f7 bl 400224a0 <__wrap_puts> <== NOT EXECUTED
return -1;
400280c8: 12800014 mov w20, #0xffffffff // #-1 <== NOT EXECUTED
errno = EIO;
400280cc: 940055f0 bl 4003d88c <__errno> <== NOT EXECUTED
400280d0: 528000a1 mov w1, #0x5 // #5 <== NOT EXECUTED
400280d4: b9000001 str w1, [x0] <== NOT EXECUTED
return -1;
400280d8: 17ffff26 b 40027d70 <rtems_rfs_format+0x5e0> <== NOT EXECUTED
rtems_rfs_bitmap_close (&bitmap);
400280dc: 97fffab5 bl 40026bb0 <rtems_rfs_bitmap_close> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
400280e0: 910203e1 add x1, sp, #0x80 <== NOT EXECUTED
400280e4: 910343e0 add x0, sp, #0xd0 <== NOT EXECUTED
400280e8: 97fffc6a bl 40027290 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
400280ec: 390203ff strb wzr, [sp, #128] <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: inode bitmap" \
400280f0: 2a1403e0 mov w0, w20 <== NOT EXECUTED
handle->bnum = 0;
400280f4: b90087ff str wzr, [sp, #132] <== NOT EXECUTED
handle->buffer = NULL;
400280f8: f90047ff str xzr, [sp, #136] <== NOT EXECUTED
400280fc: 94005ac8 bl 4003ec1c <strerror> <== NOT EXECUTED
40028100: 2a1403e2 mov w2, w20 <== NOT EXECUTED
40028104: aa0003e3 mov x3, x0 <== NOT EXECUTED
40028108: 2a1303e1 mov w1, w19 <== NOT EXECUTED
4002810c: b0000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40028110: 9111e000 add x0, x0, #0x478 <== NOT EXECUTED
40028114: 97ffe8bf bl 40022410 <__wrap_printf> <== NOT EXECUTED
return false;
40028118: 17ffff83 b 40027f24 <rtems_rfs_format+0x794> <== NOT EXECUTED
printf ("rtems-rfs: format: %s\n", name);
4002811c: f94033e1 ldr x1, [sp, #96] <== NOT EXECUTED
40028120: 90000100 adrp x0, 40048000 <_Scheduler_Table+0x60> <== NOT EXECUTED
40028124: 913c6000 add x0, x0, #0xf18 <== NOT EXECUTED
40028128: 97ffe8ba bl 40022410 <__wrap_printf> <== NOT EXECUTED
4002812c: 17fffda1 b 400277b0 <rtems_rfs_format+0x20> <== NOT EXECUTED
uint64_t total_size = rtems_rfs_fs_media_size (fs);
40028130: 910343e0 add x0, sp, #0xd0
40028134: 94003b57 bl 40036e90 <rtems_rfs_fs_media_size>
if (total_size >= GIGS (1))
40028138: b2404fe1 mov x1, #0xfffff // #1048575
4002813c: eb01001f cmp x0, x1
40028140: 54000fa9 b.ls 40028334 <rtems_rfs_format+0xba4> // b.plast <== ALWAYS TAKEN
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
40028144: 91440002 add x2, x0, #0x100, lsl #12 <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
40028148: 52800023 mov w3, #0x1 // #1 <== NOT EXECUTED
for (b = 31; b > 0; b--)
4002814c: 528003e0 mov w0, #0x1f // #31 <== NOT EXECUTED
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
40028150: d354cc42 ubfx x2, x2, #20, #32 <== NOT EXECUTED
for (b = 31; b > 0; b--)
40028154: 14000003 b 40028160 <rtems_rfs_format+0x9d0> <== NOT EXECUTED
40028158: 71000400 subs w0, w0, #0x1 <== NOT EXECUTED
4002815c: 540016e0 b.eq 40028438 <rtems_rfs_format+0xca8> // b.none <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
40028160: 1ac02061 lsl w1, w3, w0 <== NOT EXECUTED
40028164: 6a02003f tst w1, w2 <== NOT EXECUTED
40028168: 54ffff80 b.eq 40028158 <rtems_rfs_format+0x9c8> // b.none <== NOT EXECUTED
fs->block_size = 1 << b;
4002816c: 93407c21 sxtw x1, w1 <== NOT EXECUTED
40028170: f90073e1 str x1, [sp, #224] <== NOT EXECUTED
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
40028174: f9407be0 ldr x0, [sp, #240] <== NOT EXECUTED
if (fs->block_size < 512)
40028178: f107fc3f cmp x1, #0x1ff <== NOT EXECUTED
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
4002817c: b9402c02 ldr w2, [x0, #44] <== NOT EXECUTED
if (fs->block_size < 512)
40028180: 54000e49 b.ls 40028348 <rtems_rfs_format+0xbb8> // b.plast <== NOT EXECUTED
if (fs->block_size > (4 * 1024))
40028184: f140043f cmp x1, #0x1, lsl #12 <== NOT EXECUTED
40028188: 54ffb5a9 b.ls 4002783c <rtems_rfs_format+0xac> // b.plast <== NOT EXECUTED
fs->block_size = (4 * 1024);
4002818c: d2820000 mov x0, #0x1000 // #4096 <== NOT EXECUTED
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
40028190: 2a0203e3 mov w3, w2 <== NOT EXECUTED
fs->block_size = (4 * 1024);
40028194: aa0003e1 mov x1, x0 <== NOT EXECUTED
40028198: f90073e0 str x0, [sp, #224] <== NOT EXECUTED
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
4002819c: 9ac30820 udiv x0, x1, x3 <== NOT EXECUTED
400281a0: 9b038400 msub x0, x0, x3, x1 <== NOT EXECUTED
400281a4: b4ffb540 cbz x0, 4002784c <rtems_rfs_format+0xbc> <== NOT EXECUTED
printf ("block size (%zd) is not a multiple of media block size (%" PRId32 ")\n",
400281a8: 90000100 adrp x0, 40048000 <_Scheduler_Table+0x60> <== NOT EXECUTED
400281ac: 913e2000 add x0, x0, #0xf88 <== NOT EXECUTED
400281b0: 97ffe898 bl 40022410 <__wrap_printf> <== NOT EXECUTED
return false;
400281b4: 17fffef9 b 40027d98 <rtems_rfs_format+0x608> <== NOT EXECUTED
printf ("rtems-rfs: format: media size = %" PRIu64 "\n",
400281b8: 910343e0 add x0, sp, #0xd0 <== NOT EXECUTED
400281bc: 94003b35 bl 40036e90 <rtems_rfs_fs_media_size> <== NOT EXECUTED
400281c0: 90000102 adrp x2, 40048000 <_Scheduler_Table+0x60> <== NOT EXECUTED
400281c4: aa0003e1 mov x1, x0 <== NOT EXECUTED
400281c8: 913fe040 add x0, x2, #0xff8 <== NOT EXECUTED
400281cc: 97ffe891 bl 40022410 <__wrap_printf> <== NOT EXECUTED
printf ("rtems-rfs: format: media blocks = %" PRIu32 "\n",
400281d0: f9407be1 ldr x1, [sp, #240] <== NOT EXECUTED
400281d4: b0000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
400281d8: 91008000 add x0, x0, #0x20 <== NOT EXECUTED
400281dc: b9402821 ldr w1, [x1, #40] <== NOT EXECUTED
400281e0: 97ffe88c bl 40022410 <__wrap_printf> <== NOT EXECUTED
printf ("rtems-rfs: format: media block size = %" PRIu32 "\n",
400281e4: f9407be1 ldr x1, [sp, #240] <== NOT EXECUTED
400281e8: b0000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
400281ec: 91012000 add x0, x0, #0x48 <== NOT EXECUTED
400281f0: b9402c21 ldr w1, [x1, #44] <== NOT EXECUTED
400281f4: 97ffe887 bl 40022410 <__wrap_printf> <== NOT EXECUTED
printf ("rtems-rfs: format: size = %" PRIu64 "\n",
400281f8: 910343e0 add x0, sp, #0xd0 <== NOT EXECUTED
400281fc: 94003b21 bl 40036e80 <rtems_rfs_fs_size> <== NOT EXECUTED
40028200: aa0003e1 mov x1, x0 <== NOT EXECUTED
40028204: b0000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40028208: 9101e000 add x0, x0, #0x78 <== NOT EXECUTED
4002820c: 97ffe881 bl 40022410 <__wrap_printf> <== NOT EXECUTED
printf ("rtems-rfs: format: blocks = %zu\n",
40028210: f9406fe1 ldr x1, [sp, #216] <== NOT EXECUTED
40028214: b0000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40028218: 91026000 add x0, x0, #0x98 <== NOT EXECUTED
4002821c: 97ffe87d bl 40022410 <__wrap_printf> <== NOT EXECUTED
printf ("rtems-rfs: format: block size = %zu\n",
40028220: f94073e1 ldr x1, [sp, #224] <== NOT EXECUTED
40028224: b0000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40028228: 91030000 add x0, x0, #0xc0 <== NOT EXECUTED
4002822c: 97ffe879 bl 40022410 <__wrap_printf> <== NOT EXECUTED
return rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs));
40028230: f94073e1 ldr x1, [sp, #224] <== NOT EXECUTED
printf ("rtems-rfs: format: bits per block = %u\n",
40028234: b0000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40028238: 9103a000 add x0, x0, #0xe8 <== NOT EXECUTED
4002823c: 531d7021 lsl w1, w1, #3 <== NOT EXECUTED
40028240: 97ffe874 bl 40022410 <__wrap_printf> <== NOT EXECUTED
printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
40028244: d2800701 mov x1, #0x38 // #56 <== NOT EXECUTED
40028248: b0000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
4002824c: 91044000 add x0, x0, #0x110 <== NOT EXECUTED
40028250: 97ffe870 bl 40022410 <__wrap_printf> <== NOT EXECUTED
fs.group_inodes * fs.group_count,
40028254: f94093e2 ldr x2, [sp, #288] <== NOT EXECUTED
blocks = rtems_rfs_rup_quotient(fs->group_inodes * RTEMS_RFS_INODE_SIZE,
40028258: 52800700 mov w0, #0x38 // #56 <== NOT EXECUTED
fs.group_inodes * fs.group_count,
4002825c: b98113e1 ldrsw x1, [sp, #272] <== NOT EXECUTED
40028260: 5280fa03 mov w3, #0x7d0 // #2000 <== NOT EXECUTED
blocks = rtems_rfs_rup_quotient(fs->group_inodes * RTEMS_RFS_INODE_SIZE,
40028264: f94073e4 ldr x4, [sp, #224] <== NOT EXECUTED
40028268: 1b007c40 mul w0, w2, w0 <== NOT EXECUTED
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
4002826c: 9b027c21 mul x1, x1, x2 <== NOT EXECUTED
if (dividend == 0)
40028270: 340000c0 cbz w0, 40028288 <rtems_rfs_format+0xaf8> <== NOT EXECUTED
return ((dividend - 1) / divisor) + 1;
40028274: 51000400 sub w0, w0, #0x1 <== NOT EXECUTED
return ((blocks + 1) * 100 * 10) / bits_per_block;
40028278: 52807d03 mov w3, #0x3e8 // #1000 <== NOT EXECUTED
return ((dividend - 1) / divisor) + 1;
4002827c: 1ac40800 udiv w0, w0, w4 <== NOT EXECUTED
return ((blocks + 1) * 100 * 10) / bits_per_block;
40028280: 11000800 add w0, w0, #0x2 <== NOT EXECUTED
40028284: 1b037c03 mul w3, w0, w3 <== NOT EXECUTED
if (bits_per_block > (rtems_rfs_fs_blocks (fs) - RTEMS_RFS_SUPERBLOCK_SIZE))
40028288: f9406fe0 ldr x0, [sp, #216] <== NOT EXECUTED
return rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs));
4002828c: 531d7084 lsl w4, w4, #3 <== NOT EXECUTED
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
40028290: 528ccce2 mov w2, #0x6667 // #26215 <== NOT EXECUTED
40028294: 72acccc2 movk w2, #0x6666, lsl #16 <== NOT EXECUTED
if (bits_per_block > (rtems_rfs_fs_blocks (fs) - RTEMS_RFS_SUPERBLOCK_SIZE))
40028298: d1000406 sub x6, x0, #0x1 <== NOT EXECUTED
bits_per_block = rtems_rfs_fs_blocks (fs) - RTEMS_RFS_SUPERBLOCK_SIZE;
4002829c: 51000400 sub w0, w0, #0x1 <== NOT EXECUTED
400282a0: eb24c0df cmp x6, w4, sxtw <== NOT EXECUTED
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
400282a4: 52800145 mov w5, #0xa // #10 <== NOT EXECUTED
bits_per_block = rtems_rfs_fs_blocks (fs) - RTEMS_RFS_SUPERBLOCK_SIZE;
400282a8: 1a802084 csel w4, w4, w0, cs // cs = hs, nlast <== NOT EXECUTED
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
400282ac: b0000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
400282b0: 9104e000 add x0, x0, #0x138 <== NOT EXECUTED
return ((blocks + 1) * 100 * 10) / bits_per_block;
400282b4: 1ac40c63 sdiv w3, w3, w4 <== NOT EXECUTED
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
400282b8: 9b227c62 smull x2, w3, w2 <== NOT EXECUTED
400282bc: 9362fc42 asr x2, x2, #34 <== NOT EXECUTED
400282c0: 4b837c42 sub w2, w2, w3, asr #31 <== NOT EXECUTED
400282c4: 1b058c43 msub w3, w2, w5, w3 <== NOT EXECUTED
400282c8: 97ffe852 bl 40022410 <__wrap_printf> <== NOT EXECUTED
printf ("rtems-rfs: format: groups = %u\n", fs.group_count);
400282cc: b94113e1 ldr w1, [sp, #272] <== NOT EXECUTED
400282d0: b0000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
400282d4: 9105a000 add x0, x0, #0x168 <== NOT EXECUTED
400282d8: 97ffe84e bl 40022410 <__wrap_printf> <== NOT EXECUTED
printf ("rtems-rfs: format: group blocks = %zu\n", fs.group_blocks);
400282dc: f9408fe1 ldr x1, [sp, #280] <== NOT EXECUTED
400282e0: b0000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
400282e4: 91062000 add x0, x0, #0x188 <== NOT EXECUTED
400282e8: 97ffe84a bl 40022410 <__wrap_printf> <== NOT EXECUTED
printf ("rtems-rfs: format: group inodes = %zu\n", fs.group_inodes);
400282ec: f94093e1 ldr x1, [sp, #288] <== NOT EXECUTED
400282f0: b0000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
400282f4: 9106c000 add x0, x0, #0x1b0 <== NOT EXECUTED
400282f8: 97ffe846 bl 40022410 <__wrap_printf> <== NOT EXECUTED
rc = rtems_rfs_buffer_setblksize (&fs, rtems_rfs_fs_block_size (&fs));
400282fc: b940e3e1 ldr w1, [sp, #224] <== NOT EXECUTED
40028300: 17fffd96 b 40027958 <rtems_rfs_format+0x1c8> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40028304: 97fffbe3 bl 40027290 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
40028308: 390243ff strb wzr, [sp, #144] <== NOT EXECUTED
printf ("rtems-rfs: write-superblock: buffer release failed: %d: %s\n",
4002830c: 2a1403e0 mov w0, w20 <== NOT EXECUTED
handle->bnum = 0;
40028310: b90097ff str wzr, [sp, #148] <== NOT EXECUTED
handle->buffer = NULL;
40028314: f9004fff str xzr, [sp, #152] <== NOT EXECUTED
40028318: 94005a41 bl 4003ec1c <strerror> <== NOT EXECUTED
4002831c: 2a1403e1 mov w1, w20 <== NOT EXECUTED
40028320: aa0003e2 mov x2, x0 <== NOT EXECUTED
40028324: b0000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40028328: 91092000 add x0, x0, #0x248 <== NOT EXECUTED
4002832c: 97ffe839 bl 40022410 <__wrap_printf> <== NOT EXECUTED
return false;
40028330: 17ffff63 b 400280bc <rtems_rfs_format+0x92c> <== NOT EXECUTED
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
40028334: f9407be0 ldr x0, [sp, #240]
if (fs->block_size < 512)
40028338: f94073e1 ldr x1, [sp, #224]
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
4002833c: b9402c02 ldr w2, [x0, #44]
if (fs->block_size < 512)
40028340: f107fc3f cmp x1, #0x1ff
40028344: 54fff208 b.hi 40028184 <rtems_rfs_format+0x9f4> // b.pmore <== NEVER TAKEN
fs->block_size = 512;
40028348: d2804000 mov x0, #0x200 // #512
4002834c: aa0003e1 mov x1, x0
40028350: f90073e0 str x0, [sp, #224]
if (fs->block_size > (4 * 1024))
40028354: 17fffd3a b 4002783c <rtems_rfs_format+0xac>
printf ("rtems-rfs: format: allocated inode not root ino: %" PRId32 "\n", ino);
40028358: 2a1303e1 mov w1, w19 <== NOT EXECUTED
4002835c: b0000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40028360: 9117e000 add x0, x0, #0x5f8 <== NOT EXECUTED
40028364: 97ffe82b bl 40022410 <__wrap_printf> <== NOT EXECUTED
rtems_rfs_fs_close (fs);
40028368: f94043e0 ldr x0, [sp, #128] <== NOT EXECUTED
return EINVAL;
4002836c: 528002d4 mov w20, #0x16 // #22 <== NOT EXECUTED
rtems_rfs_fs_close (fs);
40028370: 94003cb0 bl 40037630 <rtems_rfs_fs_close> <== NOT EXECUTED
printf ("rtems-rfs: format: writing root dir failed: %d: %s\n",
40028374: 2a1403e0 mov w0, w20 <== NOT EXECUTED
40028378: 94005a29 bl 4003ec1c <strerror> <== NOT EXECUTED
4002837c: 2a1403e1 mov w1, w20 <== NOT EXECUTED
40028380: aa0003e2 mov x2, x0 <== NOT EXECUTED
40028384: b0000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40028388: 911ce000 add x0, x0, #0x738 <== NOT EXECUTED
4002838c: 97ffe821 bl 40022410 <__wrap_printf> <== NOT EXECUTED
errno = rc;
40028390: 9400553f bl 4003d88c <__errno> <== NOT EXECUTED
40028394: b9000014 str w20, [x0] <== NOT EXECUTED
return -1;
40028398: 12800014 mov w20, #0xffffffff // #-1 <== NOT EXECUTED
4002839c: 17fffe75 b 40027d70 <rtems_rfs_format+0x5e0> <== NOT EXECUTED
rc = errno;
400283a0: 9400553b bl 4003d88c <__errno> <== NOT EXECUTED
400283a4: b9400014 ldr w20, [x0] <== NOT EXECUTED
printf ("rtems-rfs: format: file system open failed: %d: %s\n",
400283a8: 2a1403e0 mov w0, w20 <== NOT EXECUTED
400283ac: 94005a1c bl 4003ec1c <strerror> <== NOT EXECUTED
400283b0: 2a1403e1 mov w1, w20 <== NOT EXECUTED
400283b4: aa0003e2 mov x2, x0 <== NOT EXECUTED
400283b8: b0000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
400283bc: 91162000 add x0, x0, #0x588 <== NOT EXECUTED
400283c0: 97ffe814 bl 40022410 <__wrap_printf> <== NOT EXECUTED
if (rc != 0)
400283c4: 34ffd8b4 cbz w20, 40027ed8 <rtems_rfs_format+0x748> <== NOT EXECUTED
400283c8: 17ffffeb b 40028374 <rtems_rfs_format+0xbe4> <== NOT EXECUTED
printf ("\n");
400283cc: 52800140 mov w0, #0xa // #10 <== NOT EXECUTED
400283d0: 9400570c bl 4003e000 <putchar> <== NOT EXECUTED
400283d4: 17fffe82 b 40027ddc <rtems_rfs_format+0x64c> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
400283d8: 910203e1 add x1, sp, #0x80 <== NOT EXECUTED
400283dc: 910343e0 add x0, sp, #0xd0 <== NOT EXECUTED
400283e0: 97fffbac bl 40027290 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
400283e4: 390203ff strb wzr, [sp, #128] <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: close inode" \
400283e8: 2a1403e0 mov w0, w20 <== NOT EXECUTED
handle->bnum = 0;
400283ec: b90087ff str wzr, [sp, #132] <== NOT EXECUTED
handle->buffer = NULL;
400283f0: f90047ff str xzr, [sp, #136] <== NOT EXECUTED
400283f4: 94005a0a bl 4003ec1c <strerror> <== NOT EXECUTED
400283f8: 2a1403e2 mov w2, w20 <== NOT EXECUTED
400283fc: aa0003e3 mov x3, x0 <== NOT EXECUTED
40028400: 2a1303e1 mov w1, w19 <== NOT EXECUTED
40028404: b0000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40028408: 91132000 add x0, x0, #0x4c8 <== NOT EXECUTED
4002840c: 97ffe801 bl 40022410 <__wrap_printf> <== NOT EXECUTED
return false;
40028410: 17fffec5 b 40027f24 <rtems_rfs_format+0x794> <== NOT EXECUTED
printf ("rtems-rfs: format: inode allocation failed: %d: %s\n",
40028414: 94005a02 bl 4003ec1c <strerror> <== NOT EXECUTED
40028418: aa0003e2 mov x2, x0 <== NOT EXECUTED
4002841c: 2a1403e1 mov w1, w20 <== NOT EXECUTED
40028420: b0000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40028424: 91170000 add x0, x0, #0x5c0 <== NOT EXECUTED
40028428: 97ffe7fa bl 40022410 <__wrap_printf> <== NOT EXECUTED
rtems_rfs_fs_close (fs);
4002842c: f94043e0 ldr x0, [sp, #128] <== NOT EXECUTED
40028430: 94003c80 bl 40037630 <rtems_rfs_fs_close> <== NOT EXECUTED
return rc;
40028434: 17ffffd0 b 40028374 <rtems_rfs_format+0xbe4> <== NOT EXECUTED
40028438: d2800021 mov x1, #0x1 // #1 <== NOT EXECUTED
fs->block_size = 1 << b;
4002843c: f90073e1 str x1, [sp, #224] <== NOT EXECUTED
40028440: 17ffff4d b 40028174 <rtems_rfs_format+0x9e4> <== NOT EXECUTED
printf ("rtems-rfs: format: inode open failed: %d: %s\n",
40028444: 940059f6 bl 4003ec1c <strerror> <== NOT EXECUTED
40028448: aa0003e2 mov x2, x0 <== NOT EXECUTED
4002844c: 2a1403e1 mov w1, w20 <== NOT EXECUTED
40028450: b0000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40028454: 9118c000 add x0, x0, #0x630 <== NOT EXECUTED
40028458: 97ffe7ee bl 40022410 <__wrap_printf> <== NOT EXECUTED
rtems_rfs_group_bitmap_free (fs, true, ino);
4002845c: b9407fe2 ldr w2, [sp, #124] <== NOT EXECUTED
40028460: 2a1303e1 mov w1, w19 <== NOT EXECUTED
40028464: f94043e0 ldr x0, [sp, #128] <== NOT EXECUTED
40028468: 9400019e bl 40028ae0 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
rtems_rfs_fs_close (fs);
4002846c: f94043e0 ldr x0, [sp, #128] <== NOT EXECUTED
40028470: 94003c70 bl 40037630 <rtems_rfs_fs_close> <== NOT EXECUTED
return rc;
40028474: 17ffffc0 b 40028374 <rtems_rfs_format+0xbe4> <== NOT EXECUTED
printf ("rtems-rfs: format: inode close failed: %d: %s\n",
40028478: 940059e9 bl 4003ec1c <strerror> <== NOT EXECUTED
4002847c: aa0003e2 mov x2, x0 <== NOT EXECUTED
40028480: 2a1303e1 mov w1, w19 <== NOT EXECUTED
40028484: b0000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40028488: 911b4000 add x0, x0, #0x6d0 <== NOT EXECUTED
4002848c: 97ffe7e1 bl 40022410 <__wrap_printf> <== NOT EXECUTED
40028490: 17fffe84 b 40027ea0 <rtems_rfs_format+0x710> <== NOT EXECUTED
printf ("rtems-rfs: format: directory add failed: %d: %s\n",
40028494: 940059e2 bl 4003ec1c <strerror> <== NOT EXECUTED
40028498: aa0003e2 mov x2, x0 <== NOT EXECUTED
4002849c: 2a1303e1 mov w1, w19 <== NOT EXECUTED
400284a0: b0000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
400284a4: 911a6000 add x0, x0, #0x698 <== NOT EXECUTED
400284a8: 97ffe7da bl 40022410 <__wrap_printf> <== NOT EXECUTED
400284ac: 17fffe78 b 40027e8c <rtems_rfs_format+0x6fc> <== NOT EXECUTED
printf ("rtems-rfs: format: inode initialise failed: %d: %s\n",
400284b0: 940059db bl 4003ec1c <strerror> <== NOT EXECUTED
400284b4: aa0003e2 mov x2, x0 <== NOT EXECUTED
400284b8: 2a1303e1 mov w1, w19 <== NOT EXECUTED
400284bc: b0000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
400284c0: 91198000 add x0, x0, #0x660 <== NOT EXECUTED
400284c4: 97ffe7d3 bl 40022410 <__wrap_printf> <== NOT EXECUTED
400284c8: 17fffe68 b 40027e68 <rtems_rfs_format+0x6d8> <== NOT EXECUTED
printf ("rtems-rfs: media block is invalid: %" PRIu32 "\n",
400284cc: 52800001 mov w1, #0x0 // #0 <== NOT EXECUTED
400284d0: 90000100 adrp x0, 40048000 <_Scheduler_Table+0x60> <== NOT EXECUTED
400284d4: 913d8000 add x0, x0, #0xf60 <== NOT EXECUTED
400284d8: 97ffe7ce bl 40022410 <__wrap_printf> <== NOT EXECUTED
errno = EINVAL;
400284dc: 940054ec bl 4003d88c <__errno> <== NOT EXECUTED
return -1;
400284e0: 12800014 mov w20, #0xffffffff // #-1 <== NOT EXECUTED
errno = EINVAL;
400284e4: 528002c1 mov w1, #0x16 // #22 <== NOT EXECUTED
400284e8: b9000001 str w1, [x0] <== NOT EXECUTED
return -1;
400284ec: 17fffe21 b 40027d70 <rtems_rfs_format+0x5e0> <== NOT EXECUTED
printf ("rtems-rfs: format: setting block size failed: %d: %s\n",
400284f0: 940059cb bl 4003ec1c <strerror> <== NOT EXECUTED
400284f4: aa0003e2 mov x2, x0 <== NOT EXECUTED
400284f8: 2a1303e1 mov w1, w19 <== NOT EXECUTED
400284fc: b0000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40028500: 91076000 add x0, x0, #0x1d8 <== NOT EXECUTED
40028504: 97ffe7c3 bl 40022410 <__wrap_printf> <== NOT EXECUTED
return -1;
40028508: 12800014 mov w20, #0xffffffff // #-1 <== NOT EXECUTED
errno = rc;
4002850c: 940054e0 bl 4003d88c <__errno> <== NOT EXECUTED
40028510: b9000013 str w19, [x0] <== NOT EXECUTED
return -1;
40028514: 17fffe17 b 40027d70 <rtems_rfs_format+0x5e0> <== NOT EXECUTED
printf ("rtems-rfs: format: buffer open failed: %d: %s\n",
40028518: 940059c1 bl 4003ec1c <strerror> <== NOT EXECUTED
4002851c: aa0003e2 mov x2, x0 <== NOT EXECUTED
40028520: 2a1303e1 mov w1, w19 <== NOT EXECUTED
40028524: 90000100 adrp x0, 40048000 <_Scheduler_Table+0x60> <== NOT EXECUTED
40028528: 913cc000 add x0, x0, #0xf30 <== NOT EXECUTED
4002852c: 97ffe7b9 bl 40022410 <__wrap_printf> <== NOT EXECUTED
return -1;
40028530: 12800014 mov w20, #0xffffffff // #-1 <== NOT EXECUTED
errno = rc;
40028534: 940054d6 bl 4003d88c <__errno> <== NOT EXECUTED
40028538: b9000013 str w19, [x0] <== NOT EXECUTED
return -1;
4002853c: 17fffe0d b 40027d70 <rtems_rfs_format+0x5e0> <== NOT EXECUTED
printf ("rtems-rfs: format: buffer close failed: %d: %s\n",
40028540: 940059b7 bl 4003ec1c <strerror> <== NOT EXECUTED
40028544: aa0003e2 mov x2, x0 <== NOT EXECUTED
40028548: 2a1303e1 mov w1, w19 <== NOT EXECUTED
4002854c: b0000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40028550: 91156000 add x0, x0, #0x558 <== NOT EXECUTED
40028554: 97ffe7af bl 40022410 <__wrap_printf> <== NOT EXECUTED
return -1;
40028558: 12800014 mov w20, #0xffffffff // #-1 <== NOT EXECUTED
errno = rc;
4002855c: 940054cc bl 4003d88c <__errno> <== NOT EXECUTED
40028560: b9000013 str w19, [x0] <== NOT EXECUTED
return -1;
40028564: 17fffe03 b 40027d70 <rtems_rfs_format+0x5e0> <== NOT EXECUTED
...
0000000040037630 <rtems_rfs_fs_close>:
int
rtems_rfs_fs_close (rtems_rfs_file_system* fs)
{
40037630: a9bd7bfd stp x29, x30, [sp, #-48]!
40037634: 910003fd mov x29, sp
40037638: a90153f3 stp x19, x20, [sp, #16]
4003763c: aa0003f3 mov x19, x0
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
40037640: d2800040 mov x0, #0x2 // #2
40037644: 97ffcd03 bl 4002aa50 <rtems_rfs_trace>
40037648: 72001c1f tst w0, #0xff
4003764c: 54000321 b.ne 400376b0 <rtems_rfs_fs_close+0x80> // b.any <== NEVER TAKEN
printf ("rtems-rfs: close\n");
for (group = 0; group < fs->group_count; group++)
40037650: b9404260 ldr w0, [x19, #64]
40037654: 7100001f cmp w0, #0x0
40037658: 540001cd b.le 40037690 <rtems_rfs_fs_close+0x60> <== NEVER TAKEN
4003765c: 52800014 mov w20, #0x0 // #0
40037660: f90013f5 str x21, [sp, #32]
40037664: d2800015 mov x21, #0x0 // #0
rtems_rfs_group_close (fs, &fs->groups[group]);
40037668: f9401e61 ldr x1, [x19, #56]
4003766c: aa1303e0 mov x0, x19
for (group = 0; group < fs->group_count; group++)
40037670: 11000694 add w20, w20, #0x1
rtems_rfs_group_close (fs, &fs->groups[group]);
40037674: 8b150021 add x1, x1, x21
40037678: 97ffc456 bl 400287d0 <rtems_rfs_group_close>
for (group = 0; group < fs->group_count; group++)
4003767c: b9404260 ldr w0, [x19, #64]
40037680: 910242b5 add x21, x21, #0x90
40037684: 6b14001f cmp w0, w20
40037688: 54ffff0c b.gt 40037668 <rtems_rfs_fs_close+0x38> <== NEVER TAKEN
4003768c: f94013f5 ldr x21, [sp, #32]
rtems_rfs_buffer_close (fs);
40037690: aa1303e0 mov x0, x19
40037694: 97ffc007 bl 400276b0 <rtems_rfs_buffer_close>
free (fs);
40037698: aa1303e0 mov x0, x19
4003769c: 97ffac45 bl 400227b0 <free>
return 0; }
400376a0: 52800000 mov w0, #0x0 // #0
400376a4: a94153f3 ldp x19, x20, [sp, #16]
400376a8: a8c37bfd ldp x29, x30, [sp], #48
400376ac: d65f03c0 ret
printf ("rtems-rfs: close\n");
400376b0: 900000a0 adrp x0, 4004b000 <IMFS_LIMITS_AND_OPTIONS+0xbb8> <== NOT EXECUTED
400376b4: 910cc000 add x0, x0, #0x330 <== NOT EXECUTED
400376b8: 97ffab7a bl 400224a0 <__wrap_puts> <== NOT EXECUTED
400376bc: 17ffffe5 b 40037650 <rtems_rfs_fs_close+0x20> <== NOT EXECUTED
0000000040036ea0 <rtems_rfs_fs_open>:
rtems_rfs_fs_open (const char* name,
void* user,
uint32_t flags,
uint32_t max_held_buffers,
rtems_rfs_file_system** fs)
{
40036ea0: a9b87bfd stp x29, x30, [sp, #-128]!
40036ea4: 910003fd mov x29, sp
40036ea8: a90153f3 stp x19, x20, [sp, #16]
40036eac: aa0003f3 mov x19, x0
40036eb0: 2a0303f4 mov w20, w3
#endif
rtems_rfs_inode_handle inode;
uint16_t mode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
40036eb4: d2800020 mov x0, #0x1 // #1
{
40036eb8: a9025bf5 stp x21, x22, [sp, #32]
40036ebc: 2a0203f6 mov w22, w2
40036ec0: aa0403f5 mov x21, x4
40036ec4: f9001bf7 str x23, [sp, #48]
40036ec8: aa0103f7 mov x23, x1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
40036ecc: 97ffcee1 bl 4002aa50 <rtems_rfs_trace>
40036ed0: 72001c1f tst w0, #0xff
40036ed4: 54001c01 b.ne 40037254 <rtems_rfs_fs_open+0x3b4> // b.any <== NEVER TAKEN
printf ("rtems-rfs: open: %s\n", name);
*fs = malloc (sizeof (rtems_rfs_file_system));
40036ed8: d2800021 mov x1, #0x1 // #1
40036edc: d2802000 mov x0, #0x100 // #256
40036ee0: 97ffedc0 bl 400325e0 <calloc>
40036ee4: f90002a0 str x0, [x21]
40036ee8: aa0003e1 mov x1, x0
if (!*fs)
40036eec: b40035e0 cbz x0, 400375a8 <rtems_rfs_fs_open+0x708> <== NEVER TAKEN
return &the_chain->Tail.Node;
40036ef0: 91022004 add x4, x0, #0x88
40036ef4: 9102a006 add x6, x0, #0xa8
head->next = tail;
40036ef8: 91020000 add x0, x0, #0x80
return &the_chain->Tail.Node;
40036efc: 91032025 add x5, x1, #0xc8
head->next = tail;
40036f00: 91038022 add x2, x1, #0xe0
40036f04: f9004024 str x4, [x1, #128]
return &the_chain->Tail.Node;
40036f08: 9103a024 add x4, x1, #0xe8
tail->previous = head;
40036f0c: f9004820 str x0, [x1, #144]
head->next = tail;
40036f10: 91028020 add x0, x1, #0xa0
(*fs)->max_held_buffers = max_held_buffers;
(*fs)->buffers_count = 0;
(*fs)->release_count = 0;
(*fs)->release_modified_count = 0;
(*fs)->flags = flags;
40036f14: b9000036 str w22, [x1]
(*fs)->max_held_buffers = max_held_buffers;
40036f18: b9007834 str w20, [x1, #120]
40036f1c: f9005026 str x6, [x1, #160]
tail->previous = head;
40036f20: f9005820 str x0, [x1, #176]
head->next = tail;
40036f24: 91030020 add x0, x1, #0xc0
40036f28: f9006025 str x5, [x1, #192]
tail->previous = head;
40036f2c: f9006820 str x0, [x1, #208]
#endif
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, *fs);
40036f30: aa1303e0 mov x0, x19
head->next = tail;
40036f34: f9007024 str x4, [x1, #224]
(*fs)->user = user;
40036f38: a90f5c22 stp x2, x23, [x1, #240]
rc = rtems_rfs_buffer_open (name, *fs);
40036f3c: 97ffc0dd bl 400272b0 <rtems_rfs_buffer_open>
40036f40: 2a0003f3 mov w19, w0
if (rc > 0)
40036f44: 7100001f cmp w0, #0x0
40036f48: 54002a2c b.gt 4003748c <rtems_rfs_fs_open+0x5ec> <== NEVER TAKEN
rc, strerror (rc));
errno = rc;
return -1;
}
rc = rtems_rfs_fs_read_superblock (*fs);
40036f4c: f94002b3 ldr x19, [x21]
rc = rtems_rfs_buffer_handle_request (fs, &handle, 0, true);
40036f50: 910103e1 add x1, sp, #0x40
40036f54: 52800023 mov w3, #0x1 // #1
40036f58: 52800002 mov w2, #0x0 // #0
40036f5c: aa1303e0 mov x0, x19
handle->dirty = false;
40036f60: 390103ff strb wzr, [sp, #64]
handle->bnum = 0;
40036f64: b90047ff str wzr, [sp, #68]
handle->buffer = NULL;
40036f68: f90027ff str xzr, [sp, #72]
40036f6c: 97ffc019 bl 40026fd0 <rtems_rfs_buffer_handle_request>
40036f70: 2a0003f4 mov w20, w0
if (rc > 0)
40036f74: 7100001f cmp w0, #0x0
40036f78: 5400178c b.gt 40037268 <rtems_rfs_fs_open+0x3c8> <== NEVER TAKEN
sb = rtems_rfs_buffer_data (&handle);
40036f7c: f94027e0 ldr x0, [sp, #72]
if (read_sb (RTEMS_RFS_SB_OFFSET_MAGIC) != RTEMS_RFS_SB_MAGIC)
40036f80: 52840023 mov w3, #0x2001 // #8193
40036f84: 72a50123 movk w3, #0x2809, lsl #16
sb = rtems_rfs_buffer_data (&handle);
40036f88: f9401c14 ldr x20, [x0, #56]
if (read_sb (RTEMS_RFS_SB_OFFSET_MAGIC) != RTEMS_RFS_SB_MAGIC)
40036f8c: 39400284 ldrb w4, [x20]
40036f90: 39400682 ldrb w2, [x20, #1]
40036f94: 39400a81 ldrb w1, [x20, #2]
40036f98: 39400e80 ldrb w0, [x20, #3]
40036f9c: aa022082 orr x2, x4, x2, lsl #8
40036fa0: aa014041 orr x1, x2, x1, lsl #16
40036fa4: aa006020 orr x0, x1, x0, lsl #24
40036fa8: 5ac00800 rev w0, w0
40036fac: 6b03001f cmp w0, w3
40036fb0: 54001f81 b.ne 400373a0 <rtems_rfs_fs_open+0x500> // b.any <== NEVER TAKEN
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
40036fb4: 39403283 ldrb w3, [x20, #12]
40036fb8: 39403682 ldrb w2, [x20, #13]
40036fbc: 39403a81 ldrb w1, [x20, #14]
40036fc0: 39403e80 ldrb w0, [x20, #15]
40036fc4: aa022062 orr x2, x3, x2, lsl #8
40036fc8: aa014041 orr x1, x2, x1, lsl #16
40036fcc: aa006020 orr x0, x1, x0, lsl #24
40036fd0: 5ac00801 rev w1, w0
40036fd4: f9000661 str x1, [x19, #8]
uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
40036fd8: f9401265 ldr x5, [x19, #32]
40036fdc: 5ac00801 rev w1, w0
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
40036fe0: 39402282 ldrb w2, [x20, #8]
40036fe4: 39402684 ldrb w4, [x20, #9]
40036fe8: 39402a83 ldrb w3, [x20, #10]
40036fec: 39402e80 ldrb w0, [x20, #11]
40036ff0: aa042044 orr x4, x2, x4, lsl #8
40036ff4: aa034083 orr x3, x4, x3, lsl #16
40036ff8: aa006060 orr x0, x3, x0, lsl #24
return media_blocks * media_block_size;
40036ffc: 294510a2 ldp w2, w4, [x5, #40]
40037000: 5ac00803 rev w3, w0
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
40037004: 5ac00800 rev w0, w0
40037008: f9000a60 str x0, [x19, #16]
return blocks * block_size;
4003700c: 9ba37c21 umull x1, w1, w3
return media_blocks * media_block_size;
40037010: 9ba47c42 umull x2, w2, w4
if (rtems_rfs_fs_size(fs) > rtems_rfs_fs_media_size (fs))
40037014: eb02003f cmp x1, x2
40037018: 54001f08 b.hi 400373f8 <rtems_rfs_fs_open+0x558> // b.pmore <== NEVER TAKEN
if (read_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE) != RTEMS_RFS_INODE_SIZE)
4003701c: 39409284 ldrb w4, [x20, #36]
40037020: 39409683 ldrb w3, [x20, #37]
40037024: 39409a82 ldrb w2, [x20, #38]
40037028: 39409e81 ldrb w1, [x20, #39]
4003702c: aa032083 orr x3, x4, x3, lsl #8
40037030: aa024062 orr x2, x3, x2, lsl #16
40037034: aa016041 orr x1, x2, x1, lsl #24
40037038: 5ac00821 rev w1, w1
4003703c: 7100e03f cmp w1, #0x38
40037040: 540015a1 b.ne 400372f4 <rtems_rfs_fs_open+0x454> // b.any <== NEVER TAKEN
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
40037044: 39404288 ldrb w8, [x20, #16]
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
40037048: d343fc07 lsr x7, x0, #3
4003704c: 39404685 ldrb w5, [x20, #17]
40037050: d2849266 mov x6, #0x2493 // #9363
40037054: f2b24926 movk x6, #0x9249, lsl #16
40037058: 39404a82 ldrb w2, [x20, #18]
4003705c: 39404e81 ldrb w1, [x20, #19]
40037060: f2c92486 movk x6, #0x4924, lsl #32
40037064: f2e49246 movk x6, #0x2492, lsl #48
40037068: aa052105 orr x5, x8, x5, lsl #8
4003706c: aa0240a2 orr x2, x5, x2, lsl #16
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
40037070: d342fc03 lsr x3, x0, #2
40037074: aa016041 orr x1, x2, x1, lsl #24
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
40037078: 9bc67ce6 umulh x6, x7, x6
4003707c: 5ac00821 rev w1, w1
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
40037080: b9002e61 str w1, [x19, #44]
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
40037084: 9b037c64 mul x4, x3, x3
fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
40037088: 8b030868 add x8, x3, x3, lsl #2
4003708c: 39405287 ldrb w7, [x20, #20]
40037090: 39405685 ldrb w5, [x20, #21]
40037094: 39405a82 ldrb w2, [x20, #22]
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
40037098: 8b040884 add x4, x4, x4, lsl #2
4003709c: 39405e81 ldrb w1, [x20, #23]
400370a0: aa0520e5 orr x5, x7, x5, lsl #8
400370a4: aa0240a2 orr x2, x5, x2, lsl #16
400370a8: aa016041 orr x1, x2, x1, lsl #24
400370ac: 5ac00821 rev w1, w1
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
400370b0: b9003261 str w1, [x19, #48]
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
400370b4: 39406287 ldrb w7, [x20, #24]
400370b8: 39406685 ldrb w5, [x20, #25]
400370bc: 39406a82 ldrb w2, [x20, #26]
400370c0: 39406e81 ldrb w1, [x20, #27]
400370c4: aa0520e5 orr x5, x7, x5, lsl #8
400370c8: aa0240a2 orr x2, x5, x2, lsl #16
400370cc: aa016041 orr x1, x2, x1, lsl #24
400370d0: 5ac00821 rev w1, w1
400370d4: b9004261 str w1, [x19, #64]
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
400370d8: 39407289 ldrb w9, [x20, #28]
400370dc: 39407687 ldrb w7, [x20, #29]
400370e0: 39407a85 ldrb w5, [x20, #30]
400370e4: 39407e82 ldrb w2, [x20, #31]
400370e8: aa072127 orr x7, x9, x7, lsl #8
400370ec: aa0540e5 orr x5, x7, x5, lsl #16
400370f0: aa0260a2 orr x2, x5, x2, lsl #24
400370f4: 5ac00842 rev w2, w2
400370f8: f9002662 str x2, [x19, #72]
if (fs->group_blocks >
400370fc: eb000c5f cmp x2, x0, lsl #3
40037100: 39408287 ldrb w7, [x20, #32]
40037104: 39408685 ldrb w5, [x20, #33]
40037108: 39408a82 ldrb w2, [x20, #34]
4003710c: 39408e80 ldrb w0, [x20, #35]
40037110: aa0520e5 orr x5, x7, x5, lsl #8
fs->block_map_singly_blocks =
40037114: a9062263 stp x3, x8, [x19, #96]
40037118: aa0240a2 orr x2, x5, x2, lsl #16
4003711c: aa006040 orr x0, x2, x0, lsl #24
fs->block_map_doubly_blocks =
40037120: f9003a64 str x4, [x19, #112]
if (fs->group_blocks >
40037124: 5ac00802 rev w2, w0
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
40037128: 5ac00800 rev w0, w0
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
4003712c: a9051a60 stp x0, x6, [x19, #80]
rtems_rfs_buffer_handle_release (fs, handle);
40037130: aa1303e0 mov x0, x19
fs->inodes = fs->group_count * fs->group_inodes;
40037134: 1b017c41 mul w1, w2, w1
40037138: b9002a61 str w1, [x19, #40]
4003713c: 910103e1 add x1, sp, #0x40
if (fs->group_blocks >
40037140: 54001408 b.hi 400373c0 <rtems_rfs_fs_open+0x520> // b.pmore <== NEVER TAKEN
40037144: 97ffc053 bl 40027290 <rtems_rfs_buffer_handle_release>
handle->dirty = false;
40037148: 390103ff strb wzr, [sp, #64]
rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_block_size (fs));
4003714c: b9401261 ldr w1, [x19, #16]
40037150: aa1303e0 mov x0, x19
handle->bnum = 0;
40037154: b90047ff str wzr, [sp, #68]
handle->buffer = NULL;
40037158: f90027ff str xzr, [sp, #72]
4003715c: 97ffc109 bl 40027580 <rtems_rfs_buffer_setblksize>
40037160: 2a0003f4 mov w20, w0
if (rc > 0)
40037164: 7100001f cmp w0, #0x0
40037168: 5400098c b.gt 40037298 <rtems_rfs_fs_open+0x3f8> <== NEVER TAKEN
fs->groups = calloc (fs->group_count, sizeof (rtems_rfs_group));
4003716c: b9404274 ldr w20, [x19, #64]
40037170: d2801201 mov x1, #0x90 // #144
40037174: 93407e80 sxtw x0, w20
40037178: 97ffed1a bl 400325e0 <calloc>
4003717c: f9001e60 str x0, [x19, #56]
40037180: aa0003e4 mov x4, x0
if (!fs->groups)
40037184: b40022e0 cbz x0, 400375e0 <rtems_rfs_fs_open+0x740> <== NEVER TAKEN
for (group = 0; group < fs->group_count; group++)
40037188: 7100029f cmp w20, #0x0
4003718c: d2800017 mov x23, #0x0 // #0
40037190: 52800016 mov w22, #0x0 // #0
40037194: 540000ec b.gt 400371b0 <rtems_rfs_fs_open+0x310> <== ALWAYS TAKEN
40037198: 14000060 b 40037318 <rtems_rfs_fs_open+0x478> <== NOT EXECUTED
4003719c: b9404260 ldr w0, [x19, #64]
400371a0: 110006d6 add w22, w22, #0x1
400371a4: 6b0002df cmp w22, w0
400371a8: 54000b8a b.ge 40037318 <rtems_rfs_fs_open+0x478> // b.tcont <== ALWAYS TAKEN
&fs->groups[group]);
400371ac: f9401e64 ldr x4, [x19, #56] <== NOT EXECUTED
rc = rtems_rfs_group_open (fs,
400371b0: 8b170084 add x4, x4, x23
400371b4: a9448e62 ldp x2, x3, [x19, #72]
400371b8: aa1303e0 mov x0, x19
for (group = 0; group < fs->group_count; group++)
400371bc: 910242f7 add x23, x23, #0x90
rc = rtems_rfs_group_open (fs,
400371c0: 1b027ec1 mul w1, w22, w2
400371c4: 11000421 add w1, w1, #0x1
400371c8: 97ffc4ea bl 40028570 <rtems_rfs_group_open>
400371cc: 2a0003f4 mov w20, w0
if (rc > 0)
400371d0: 7100001f cmp w0, #0x0
400371d4: 54fffe4d b.le 4003719c <rtems_rfs_fs_open+0x2fc> <== ALWAYS TAKEN
for (g = 0; g < group; g++)
400371d8: 340001b6 cbz w22, 4003720c <rtems_rfs_fs_open+0x36c> <== NOT EXECUTED
400371dc: 510006d6 sub w22, w22, #0x1 <== NOT EXECUTED
400371e0: d2801200 mov x0, #0x90 // #144 <== NOT EXECUTED
400371e4: d2800017 mov x23, #0x0 // #0 <== NOT EXECUTED
400371e8: 9b0002d6 madd x22, x22, x0, x0 <== NOT EXECUTED
400371ec: d503201f nop <== NOT EXECUTED
rtems_rfs_group_close (fs, &fs->groups[g]);
400371f0: f9401e61 ldr x1, [x19, #56] <== NOT EXECUTED
400371f4: aa1303e0 mov x0, x19 <== NOT EXECUTED
400371f8: 8b170021 add x1, x1, x23 <== NOT EXECUTED
for (g = 0; g < group; g++)
400371fc: 910242f7 add x23, x23, #0x90 <== NOT EXECUTED
rtems_rfs_group_close (fs, &fs->groups[g]);
40037200: 97ffc574 bl 400287d0 <rtems_rfs_group_close> <== NOT EXECUTED
for (g = 0; g < group; g++)
40037204: eb1602ff cmp x23, x22 <== NOT EXECUTED
40037208: 54ffff41 b.ne 400371f0 <rtems_rfs_fs_open+0x350> // b.any <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4003720c: 910103e1 add x1, sp, #0x40 <== NOT EXECUTED
40037210: aa1303e0 mov x0, x19 <== NOT EXECUTED
40037214: 97ffc01f bl 40027290 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
40037218: 390103ff strb wzr, [sp, #64] <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4003721c: d2800020 mov x0, #0x1 // #1 <== NOT EXECUTED
handle->bnum = 0;
40037220: b90047ff str wzr, [sp, #68] <== NOT EXECUTED
handle->buffer = NULL;
40037224: f90027ff str xzr, [sp, #72] <== NOT EXECUTED
40037228: 97ffce0a bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
4003722c: 72001c1f tst w0, #0xff <== NOT EXECUTED
40037230: 54000480 b.eq 400372c0 <rtems_rfs_fs_open+0x420> // b.none <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table%d: %s\n",
40037234: 2a1403e0 mov w0, w20 <== NOT EXECUTED
40037238: 94001e79 bl 4003ec1c <strerror> <== NOT EXECUTED
4003723c: 900000a1 adrp x1, 4004b000 <IMFS_LIMITS_AND_OPTIONS+0xbb8> <== NOT EXECUTED
40037240: aa0003e2 mov x2, x0 <== NOT EXECUTED
40037244: 9108c020 add x0, x1, #0x230 <== NOT EXECUTED
40037248: 2a1403e1 mov w1, w20 <== NOT EXECUTED
4003724c: 97ffac71 bl 40022410 <__wrap_printf> <== NOT EXECUTED
40037250: 1400001c b 400372c0 <rtems_rfs_fs_open+0x420> <== NOT EXECUTED
printf ("rtems-rfs: open: %s\n", name);
40037254: aa1303e1 mov x1, x19 <== NOT EXECUTED
40037258: f0000080 adrp x0, 4004a000 <status_code_text+0x38> <== NOT EXECUTED
4003725c: 913fc000 add x0, x0, #0xff0 <== NOT EXECUTED
40037260: 97ffac6c bl 40022410 <__wrap_printf> <== NOT EXECUTED
40037264: 17ffff1d b 40036ed8 <rtems_rfs_fs_open+0x38> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
40037268: d2800020 mov x0, #0x1 // #1 <== NOT EXECUTED
4003726c: 97ffcdf9 bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
40037270: 72001c1f tst w0, #0xff <== NOT EXECUTED
40037274: 54000260 b.eq 400372c0 <rtems_rfs_fs_open+0x420> // b.none <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: request failed%d: %s\n",
40037278: 2a1403e0 mov w0, w20 <== NOT EXECUTED
4003727c: 94001e68 bl 4003ec1c <strerror> <== NOT EXECUTED
40037280: 900000a1 adrp x1, 4004b000 <IMFS_LIMITS_AND_OPTIONS+0xbb8> <== NOT EXECUTED
40037284: aa0003e2 mov x2, x0 <== NOT EXECUTED
40037288: 9101a020 add x0, x1, #0x68 <== NOT EXECUTED
4003728c: 2a1403e1 mov w1, w20 <== NOT EXECUTED
40037290: 97ffac60 bl 40022410 <__wrap_printf> <== NOT EXECUTED
40037294: 1400000b b 400372c0 <rtems_rfs_fs_open+0x420> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40037298: 910103e1 add x1, sp, #0x40 <== NOT EXECUTED
4003729c: aa1303e0 mov x0, x19 <== NOT EXECUTED
400372a0: 97ffbffc bl 40027290 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
400372a4: 390103ff strb wzr, [sp, #64] <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
400372a8: d2800020 mov x0, #0x1 // #1 <== NOT EXECUTED
handle->bnum = 0;
400372ac: b90047ff str wzr, [sp, #68] <== NOT EXECUTED
handle->buffer = NULL;
400372b0: f90027ff str xzr, [sp, #72] <== NOT EXECUTED
400372b4: 97ffcde7 bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
400372b8: 72001c1f tst w0, #0xff <== NOT EXECUTED
400372bc: 54000be1 b.ne 40037438 <rtems_rfs_fs_open+0x598> // b.any <== NOT EXECUTED
if (rc > 0)
{
rtems_rfs_buffer_close (*fs);
400372c0: f94002a0 ldr x0, [x21] <== NOT EXECUTED
400372c4: 97ffc0fb bl 400276b0 <rtems_rfs_buffer_close> <== NOT EXECUTED
free (*fs);
400372c8: f94002a0 ldr x0, [x21] <== NOT EXECUTED
400372cc: 97ffad39 bl 400227b0 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
400372d0: d2800020 mov x0, #0x1 // #1 <== NOT EXECUTED
400372d4: 97ffcddf bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
400372d8: 72001c1f tst w0, #0xff <== NOT EXECUTED
400372dc: 540009e1 b.ne 40037418 <rtems_rfs_fs_open+0x578> // b.any <== NOT EXECUTED
printf ("rtems-rfs: open: reading superblock: %d: %s\n",
rc, strerror (rc));
errno = rc;
400372e0: 9400196b bl 4003d88c <__errno> <== NOT EXECUTED
400372e4: aa0003e1 mov x1, x0 <== NOT EXECUTED
return -1;
400372e8: 12800000 mov w0, #0xffffffff // #-1 <== NOT EXECUTED
errno = rc;
400372ec: b9000034 str w20, [x1] <== NOT EXECUTED
return -1;
400372f0: 14000027 b 4003738c <rtems_rfs_fs_open+0x4ec> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
400372f4: d2800020 mov x0, #0x1 // #1 <== NOT EXECUTED
400372f8: 97ffcdd6 bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
400372fc: 72001c1f tst w0, #0xff <== NOT EXECUTED
40037300: 54000ac1 b.ne 40037458 <rtems_rfs_fs_open+0x5b8> // b.any <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40037304: 910103e1 add x1, sp, #0x40 <== NOT EXECUTED
40037308: aa1303e0 mov x0, x19 <== NOT EXECUTED
return EIO;
4003730c: 528000b4 mov w20, #0x5 // #5 <== NOT EXECUTED
40037310: 97ffbfe0 bl 40027290 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
if (rc > 0)
40037314: 17ffffeb b 400372c0 <rtems_rfs_fs_open+0x420> <== NOT EXECUTED
}
rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);
40037318: f94002a0 ldr x0, [x21]
4003731c: 910103e2 add x2, sp, #0x40
40037320: 52800023 mov w3, #0x1 // #1
40037324: 52800021 mov w1, #0x1 // #1
40037328: 97ffc682 bl 40028d30 <rtems_rfs_inode_open>
4003732c: 2a0003f3 mov w19, w0
if (rc > 0)
40037330: 7100001f cmp w0, #0x0
40037334: 54000e2c b.gt 400374f8 <rtems_rfs_fs_open+0x658> <== NEVER TAKEN
rc, strerror (rc));
errno = rc;
return -1;
}
if (((*fs)->flags & RTEMS_RFS_FS_FORCE_OPEN) == 0)
40037338: f94002a0 ldr x0, [x21]
4003733c: b9400001 ldr w1, [x0]
40037340: 371001a1 tbnz w1, #2, 40037374 <rtems_rfs_fs_open+0x4d4>
return rtems_rfs_read_u16 (&handle->node->mode);
40037344: f9402fe2 ldr x2, [sp, #88]
{
mode = rtems_rfs_inode_get_mode (&inode);
if ((mode == 0xffff) || !RTEMS_RFS_S_ISDIR (mode))
40037348: 529fffe3 mov w3, #0xffff // #65535
4003734c: 39400844 ldrb w4, [x2, #2]
40037350: 39400c41 ldrb w1, [x2, #3]
40037354: aa012081 orr x1, x4, x1, lsl #8
40037358: 5ac00421 rev16 w1, w1
4003735c: 12003c21 and w1, w1, #0xffff
40037360: 6b03003f cmp w1, w3
40037364: 54000aa0 b.eq 400374b8 <rtems_rfs_fs_open+0x618> // b.none <== NEVER TAKEN
40037368: 12140c21 and w1, w1, #0xf000
4003736c: 7140103f cmp w1, #0x4, lsl #12
40037370: 54000a41 b.ne 400374b8 <rtems_rfs_fs_open+0x618> // b.any <== NEVER TAKEN
errno = EIO;
return -1;
}
}
rc = rtems_rfs_inode_close (*fs, &inode);
40037374: 910103e1 add x1, sp, #0x40
40037378: 97ffc6ea bl 40028f20 <rtems_rfs_inode_close>
4003737c: 2a0003f3 mov w19, w0
printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
errno = rc;
return -1;
}
return 0;
40037380: 52800000 mov w0, #0x0 // #0
if (rc > 0)
40037384: 7100027f cmp w19, #0x0
40037388: 54000d8c b.gt 40037538 <rtems_rfs_fs_open+0x698> <== NEVER TAKEN
}
4003738c: a94153f3 ldp x19, x20, [sp, #16]
40037390: a9425bf5 ldp x21, x22, [sp, #32]
40037394: f9401bf7 ldr x23, [sp, #48]
40037398: a8c87bfd ldp x29, x30, [sp], #128
4003739c: d65f03c0 ret
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
400373a0: d2800020 mov x0, #0x1 // #1 <== NOT EXECUTED
400373a4: 97ffcdab bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
400373a8: 72001c1f tst w0, #0xff <== NOT EXECUTED
400373ac: 54fffac0 b.eq 40037304 <rtems_rfs_fs_open+0x464> // b.none <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock, bad magic\n");
400373b0: 900000a0 adrp x0, 4004b000 <IMFS_LIMITS_AND_OPTIONS+0xbb8> <== NOT EXECUTED
400373b4: 91028000 add x0, x0, #0xa0 <== NOT EXECUTED
400373b8: 97ffac3a bl 400224a0 <__wrap_puts> <== NOT EXECUTED
400373bc: 17ffffd2 b 40037304 <rtems_rfs_fs_open+0x464> <== NOT EXECUTED
400373c0: 97ffbfb4 bl 40027290 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
return EIO;
400373c4: 528000b4 mov w20, #0x5 // #5 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
400373c8: d2800020 mov x0, #0x1 // #1 <== NOT EXECUTED
handle->dirty = false;
400373cc: 390103ff strb wzr, [sp, #64] <== NOT EXECUTED
handle->bnum = 0;
400373d0: b90047ff str wzr, [sp, #68] <== NOT EXECUTED
handle->buffer = NULL;
400373d4: f90027ff str xzr, [sp, #72] <== NOT EXECUTED
400373d8: 97ffcd9e bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
400373dc: 72001c1f tst w0, #0xff <== NOT EXECUTED
400373e0: 54fff700 b.eq 400372c0 <rtems_rfs_fs_open+0x420> // b.none <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: groups blocks larger than block bits\n");
400373e4: 900000a0 adrp x0, 4004b000 <IMFS_LIMITS_AND_OPTIONS+0xbb8> <== NOT EXECUTED
400373e8: 9105a000 add x0, x0, #0x168 <== NOT EXECUTED
return EIO;
400373ec: 528000b4 mov w20, #0x5 // #5 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: groups blocks larger than block bits\n");
400373f0: 97ffac2c bl 400224a0 <__wrap_puts> <== NOT EXECUTED
if (rc > 0)
400373f4: 17ffffb3 b 400372c0 <rtems_rfs_fs_open+0x420> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
400373f8: d2800020 mov x0, #0x1 // #1 <== NOT EXECUTED
400373fc: 97ffcd95 bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
40037400: 72001c1f tst w0, #0xff <== NOT EXECUTED
40037404: 54fff800 b.eq 40037304 <rtems_rfs_fs_open+0x464> // b.none <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block/size count\n");
40037408: 900000a0 adrp x0, 4004b000 <IMFS_LIMITS_AND_OPTIONS+0xbb8> <== NOT EXECUTED
4003740c: 91038000 add x0, x0, #0xe0 <== NOT EXECUTED
40037410: 97ffac24 bl 400224a0 <__wrap_puts> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40037414: 17ffffbc b 40037304 <rtems_rfs_fs_open+0x464> <== NOT EXECUTED
printf ("rtems-rfs: open: reading superblock: %d: %s\n",
40037418: 2a1403e0 mov w0, w20 <== NOT EXECUTED
4003741c: 94001e00 bl 4003ec1c <strerror> <== NOT EXECUTED
40037420: 900000a1 adrp x1, 4004b000 <IMFS_LIMITS_AND_OPTIONS+0xbb8> <== NOT EXECUTED
40037424: aa0003e2 mov x2, x0 <== NOT EXECUTED
40037428: 9109c020 add x0, x1, #0x270 <== NOT EXECUTED
4003742c: 2a1403e1 mov w1, w20 <== NOT EXECUTED
40037430: 97ffabf8 bl 40022410 <__wrap_printf> <== NOT EXECUTED
40037434: 17ffffab b 400372e0 <rtems_rfs_fs_open+0x440> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block size%d: %s\n",
40037438: 2a1403e0 mov w0, w20 <== NOT EXECUTED
4003743c: 94001df8 bl 4003ec1c <strerror> <== NOT EXECUTED
40037440: 900000a1 adrp x1, 4004b000 <IMFS_LIMITS_AND_OPTIONS+0xbb8> <== NOT EXECUTED
40037444: aa0003e2 mov x2, x0 <== NOT EXECUTED
40037448: 9106c020 add x0, x1, #0x1b0 <== NOT EXECUTED
4003744c: 2a1403e1 mov w1, w20 <== NOT EXECUTED
40037450: 97ffabf0 bl 40022410 <__wrap_printf> <== NOT EXECUTED
40037454: 17ffff9b b 400372c0 <rtems_rfs_fs_open+0x420> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: inode size mismatch: fs:%" PRId32 " target:%" PRId32 "\n",
40037458: 39401285 ldrb w5, [x20, #4] <== NOT EXECUTED
4003745c: 900000a0 adrp x0, 4004b000 <IMFS_LIMITS_AND_OPTIONS+0xbb8> <== NOT EXECUTED
40037460: 39401684 ldrb w4, [x20, #5] <== NOT EXECUTED
40037464: 52800002 mov w2, #0x0 // #0 <== NOT EXECUTED
40037468: 39401a83 ldrb w3, [x20, #6] <== NOT EXECUTED
4003746c: 91048000 add x0, x0, #0x120 <== NOT EXECUTED
40037470: 39401e81 ldrb w1, [x20, #7] <== NOT EXECUTED
40037474: aa0420a4 orr x4, x5, x4, lsl #8 <== NOT EXECUTED
40037478: aa034083 orr x3, x4, x3, lsl #16 <== NOT EXECUTED
4003747c: aa016061 orr x1, x3, x1, lsl #24 <== NOT EXECUTED
40037480: 5ac00821 rev w1, w1 <== NOT EXECUTED
40037484: 97ffabe3 bl 40022410 <__wrap_printf> <== NOT EXECUTED
40037488: 17ffff9f b 40037304 <rtems_rfs_fs_open+0x464> <== NOT EXECUTED
free (*fs);
4003748c: f94002a0 ldr x0, [x21] <== NOT EXECUTED
40037490: 97ffacc8 bl 400227b0 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
40037494: d2800020 mov x0, #0x1 // #1 <== NOT EXECUTED
40037498: 97ffcd6e bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
4003749c: 72001c1f tst w0, #0xff <== NOT EXECUTED
400374a0: 540006c1 b.ne 40037578 <rtems_rfs_fs_open+0x6d8> // b.any <== NOT EXECUTED
errno = rc;
400374a4: 940018fa bl 4003d88c <__errno> <== NOT EXECUTED
400374a8: aa0003e1 mov x1, x0 <== NOT EXECUTED
return -1;
400374ac: 12800000 mov w0, #0xffffffff // #-1 <== NOT EXECUTED
errno = rc;
400374b0: b9000033 str w19, [x1] <== NOT EXECUTED
return -1;
400374b4: 17ffffb6 b 4003738c <rtems_rfs_fs_open+0x4ec> <== NOT EXECUTED
rtems_rfs_inode_close (*fs, &inode);
400374b8: 910103e1 add x1, sp, #0x40 <== NOT EXECUTED
400374bc: 97ffc699 bl 40028f20 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_buffer_close (*fs);
400374c0: f94002a0 ldr x0, [x21] <== NOT EXECUTED
400374c4: 97ffc07b bl 400276b0 <rtems_rfs_buffer_close> <== NOT EXECUTED
free (*fs);
400374c8: f94002a0 ldr x0, [x21] <== NOT EXECUTED
400374cc: 97ffacb9 bl 400227b0 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
400374d0: d2800020 mov x0, #0x1 // #1 <== NOT EXECUTED
400374d4: 97ffcd5f bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
400374d8: 72001c1f tst w0, #0xff <== NOT EXECUTED
400374dc: 540005e1 b.ne 40037598 <rtems_rfs_fs_open+0x6f8> // b.any <== NOT EXECUTED
errno = EIO;
400374e0: 940018eb bl 4003d88c <__errno> <== NOT EXECUTED
400374e4: aa0003e1 mov x1, x0 <== NOT EXECUTED
400374e8: 528000a2 mov w2, #0x5 // #5 <== NOT EXECUTED
return -1;
400374ec: 12800000 mov w0, #0xffffffff // #-1 <== NOT EXECUTED
errno = EIO;
400374f0: b9000022 str w2, [x1] <== NOT EXECUTED
return -1;
400374f4: 17ffffa6 b 4003738c <rtems_rfs_fs_open+0x4ec> <== NOT EXECUTED
rtems_rfs_buffer_close (*fs);
400374f8: f94002a0 ldr x0, [x21] <== NOT EXECUTED
400374fc: 97ffc06d bl 400276b0 <rtems_rfs_buffer_close> <== NOT EXECUTED
free (*fs);
40037500: f94002a0 ldr x0, [x21] <== NOT EXECUTED
40037504: 97ffacab bl 400227b0 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
40037508: d2800020 mov x0, #0x1 // #1 <== NOT EXECUTED
4003750c: 97ffcd51 bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
40037510: 72001c1f tst w0, #0xff <== NOT EXECUTED
40037514: 54fffc80 b.eq 400374a4 <rtems_rfs_fs_open+0x604> // b.none <== NOT EXECUTED
printf ("rtems-rfs: open: reading root inode: %d: %s\n",
40037518: 2a1303e0 mov w0, w19 <== NOT EXECUTED
4003751c: 94001dc0 bl 4003ec1c <strerror> <== NOT EXECUTED
40037520: 900000a1 adrp x1, 4004b000 <IMFS_LIMITS_AND_OPTIONS+0xbb8> <== NOT EXECUTED
40037524: aa0003e2 mov x2, x0 <== NOT EXECUTED
40037528: 910a8020 add x0, x1, #0x2a0 <== NOT EXECUTED
4003752c: 2a1303e1 mov w1, w19 <== NOT EXECUTED
40037530: 97ffabb8 bl 40022410 <__wrap_printf> <== NOT EXECUTED
40037534: 17ffffdc b 400374a4 <rtems_rfs_fs_open+0x604> <== NOT EXECUTED
rtems_rfs_buffer_close (*fs);
40037538: f94002a0 ldr x0, [x21] <== NOT EXECUTED
4003753c: 97ffc05d bl 400276b0 <rtems_rfs_buffer_close> <== NOT EXECUTED
free (*fs);
40037540: f94002a0 ldr x0, [x21] <== NOT EXECUTED
40037544: 97ffac9b bl 400227b0 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
40037548: d2800020 mov x0, #0x1 // #1 <== NOT EXECUTED
4003754c: 97ffcd41 bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
40037550: 72001c1f tst w0, #0xff <== NOT EXECUTED
40037554: 54fffa80 b.eq 400374a4 <rtems_rfs_fs_open+0x604> // b.none <== NOT EXECUTED
printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
40037558: 2a1303e0 mov w0, w19 <== NOT EXECUTED
4003755c: 94001db0 bl 4003ec1c <strerror> <== NOT EXECUTED
40037560: 900000a1 adrp x1, 4004b000 <IMFS_LIMITS_AND_OPTIONS+0xbb8> <== NOT EXECUTED
40037564: aa0003e2 mov x2, x0 <== NOT EXECUTED
40037568: 910c0020 add x0, x1, #0x300 <== NOT EXECUTED
4003756c: 2a1303e1 mov w1, w19 <== NOT EXECUTED
40037570: 97ffaba8 bl 40022410 <__wrap_printf> <== NOT EXECUTED
40037574: 17ffffcc b 400374a4 <rtems_rfs_fs_open+0x604> <== NOT EXECUTED
printf ("rtems-rfs: open: buffer open failed: %d: %s\n",
40037578: 2a1303e0 mov w0, w19 <== NOT EXECUTED
4003757c: 94001da8 bl 4003ec1c <strerror> <== NOT EXECUTED
40037580: 900000a1 adrp x1, 4004b000 <IMFS_LIMITS_AND_OPTIONS+0xbb8> <== NOT EXECUTED
40037584: aa0003e2 mov x2, x0 <== NOT EXECUTED
40037588: 9100e020 add x0, x1, #0x38 <== NOT EXECUTED
4003758c: 2a1303e1 mov w1, w19 <== NOT EXECUTED
40037590: 97ffaba0 bl 40022410 <__wrap_printf> <== NOT EXECUTED
40037594: 17ffffc4 b 400374a4 <rtems_rfs_fs_open+0x604> <== NOT EXECUTED
printf ("rtems-rfs: open: invalid root inode mode\n");
40037598: 900000a0 adrp x0, 4004b000 <IMFS_LIMITS_AND_OPTIONS+0xbb8> <== NOT EXECUTED
4003759c: 910b4000 add x0, x0, #0x2d0 <== NOT EXECUTED
400375a0: 97ffabc0 bl 400224a0 <__wrap_puts> <== NOT EXECUTED
400375a4: 17ffffcf b 400374e0 <rtems_rfs_fs_open+0x640> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
400375a8: d2800020 mov x0, #0x1 // #1 <== NOT EXECUTED
400375ac: 97ffcd29 bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
400375b0: 72001c1f tst w0, #0xff <== NOT EXECUTED
400375b4: 540000e1 b.ne 400375d0 <rtems_rfs_fs_open+0x730> // b.any <== NOT EXECUTED
errno = ENOMEM;
400375b8: 940018b5 bl 4003d88c <__errno> <== NOT EXECUTED
400375bc: aa0003e1 mov x1, x0 <== NOT EXECUTED
400375c0: 52800182 mov w2, #0xc // #12 <== NOT EXECUTED
return -1;
400375c4: 12800000 mov w0, #0xffffffff // #-1 <== NOT EXECUTED
errno = ENOMEM;
400375c8: b9000022 str w2, [x1] <== NOT EXECUTED
return -1;
400375cc: 17ffff70 b 4003738c <rtems_rfs_fs_open+0x4ec> <== NOT EXECUTED
printf ("rtems-rfs: open: no memory for file system data\n");
400375d0: 900000a0 adrp x0, 4004b000 <IMFS_LIMITS_AND_OPTIONS+0xbb8> <== NOT EXECUTED
400375d4: 91002000 add x0, x0, #0x8 <== NOT EXECUTED
400375d8: 97ffabb2 bl 400224a0 <__wrap_puts> <== NOT EXECUTED
400375dc: 17fffff7 b 400375b8 <rtems_rfs_fs_open+0x718> <== NOT EXECUTED
400375e0: 910103e1 add x1, sp, #0x40 <== NOT EXECUTED
400375e4: aa1303e0 mov x0, x19 <== NOT EXECUTED
400375e8: 97ffbf2a bl 40027290 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
400375ec: 390103ff strb wzr, [sp, #64] <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
400375f0: d2800020 mov x0, #0x1 // #1 <== NOT EXECUTED
handle->bnum = 0;
400375f4: b90047ff str wzr, [sp, #68] <== NOT EXECUTED
handle->buffer = NULL;
400375f8: f90027ff str xzr, [sp, #72] <== NOT EXECUTED
400375fc: 97ffcd15 bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
40037600: 72001c1f tst w0, #0xff <== NOT EXECUTED
40037604: 54000061 b.ne 40037610 <rtems_rfs_fs_open+0x770> // b.any <== NOT EXECUTED
return ENOMEM;
40037608: 52800194 mov w20, #0xc // #12 <== NOT EXECUTED
4003760c: 17ffff2d b 400372c0 <rtems_rfs_fs_open+0x420> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table\n");
40037610: 900000a0 adrp x0, 4004b000 <IMFS_LIMITS_AND_OPTIONS+0xbb8> <== NOT EXECUTED
40037614: 9107e000 add x0, x0, #0x1f8 <== NOT EXECUTED
return ENOMEM;
40037618: 52800194 mov w20, #0xc // #12 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table\n");
4003761c: 97ffaba1 bl 400224a0 <__wrap_puts> <== NOT EXECUTED
if (rc > 0)
40037620: 17ffff28 b 400372c0 <rtems_rfs_fs_open+0x420> <== NOT EXECUTED
...
0000000040036e80 <rtems_rfs_fs_size>:
uint64_t
rtems_rfs_fs_size (rtems_rfs_file_system* fs)
{
uint64_t blocks = rtems_rfs_fs_blocks (fs);
uint64_t block_size = rtems_rfs_fs_block_size (fs);
return blocks * block_size;
40036e80: a9408001 ldp x1, x0, [x0, #8] <== NOT EXECUTED
}
40036e84: 9b007c20 mul x0, x1, x0 <== NOT EXECUTED
40036e88: d65f03c0 ret <== NOT EXECUTED
40036e8c: 00000000 udf #0
0000000040028880 <rtems_rfs_group_bitmap_alloc>:
int
rtems_rfs_group_bitmap_alloc (rtems_rfs_file_system* fs,
rtems_rfs_bitmap_bit goal,
bool inode,
rtems_rfs_bitmap_bit* result)
{
40028880: a9b87bfd stp x29, x30, [sp, #-128]!
40028884: 910003fd mov x29, sp
40028888: a90153f3 stp x19, x20, [sp, #16]
4002888c: a9025bf5 stp x21, x22, [sp, #32]
40028890: a90363f7 stp x23, x24, [sp, #48]
40028894: aa0003f7 mov x23, x0
rtems_rfs_bitmap_bit bit;
int offset;
bool updown;
int direction;
if (inode)
40028898: 72001c40 ands w0, w2, #0xff
{
4002889c: a9046bf9 stp x25, x26, [sp, #64]
400288a0: a90573fb stp x27, x28, [sp, #80]
if (inode)
400288a4: b90063e0 str w0, [sp, #96]
{
400288a8: f90037e3 str x3, [sp, #104]
if (inode)
400288ac: 54000900 b.eq 400289cc <rtems_rfs_group_bitmap_alloc+0x14c> // b.none
{
size = fs->group_inodes;
400288b0: f9402afc ldr x28, [x23, #80]
goal -= RTEMS_RFS_ROOT_INO;
400288b4: 51000421 sub w1, w1, #0x1
*/
if (goal >= RTEMS_RFS_ROOT_INO)
goal -= RTEMS_RFS_ROOT_INO;
}
group_start = goal / size;
400288b8: 93407c21 sxtw x1, w1
bit = (rtems_rfs_bitmap_bit) (goal % size); offset = 0; updown = true; direction = 1;
400288bc: 52800039 mov w25, #0x1 // #1
updown = true;
400288c0: 2a1903fb mov w27, w25
*/
while (true)
{
rtems_rfs_bitmap_control* bitmap;
int group;
bool allocated = false;
400288c4: 52800018 mov w24, #0x0 // #0
updown = false;
continue;
}
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
400288c8: 52801216 mov w22, #0x90 // #144
bool allocated = false;
400288cc: 3901efff strb wzr, [sp, #123]
group_start = goal / size;
400288d0: 9adc0833 udiv x19, x1, x28
bit = (rtems_rfs_bitmap_bit) (goal % size);
400288d4: 9b1c8661 msub x1, x19, x28, x1
group_start = goal / size;
400288d8: 2a1303fa mov w26, w19
bit = (rtems_rfs_bitmap_bit) (goal % size);
400288dc: b9007fe1 str w1, [sp, #124]
group = group_start + (direction * offset);
400288e0: 0b180345 add w5, w26, w24
if ((group < 0) || (group >= fs->group_count))
400288e4: 37f80493 tbnz w19, #31, 40028974 <rtems_rfs_group_bitmap_alloc+0xf4>
400288e8: b94042e0 ldr w0, [x23, #64]
bitmap = &fs->groups[group].inode_bitmap;
400288ec: 9b367e75 smull x21, w19, w22
else
bitmap = &fs->groups[group].block_bitmap;
rc = rtems_rfs_bitmap_map_alloc (bitmap, bit, &allocated, &bit);
400288f0: 9101f3e3 add x3, sp, #0x7c
400288f4: 9101efe2 add x2, sp, #0x7b
if ((group < 0) || (group >= fs->group_count))
400288f8: 6b13001f cmp w0, w19
400288fc: 540003cd b.le 40028974 <rtems_rfs_group_bitmap_alloc+0xf4>
bitmap = &fs->groups[group].inode_bitmap;
40028900: f9401ee4 ldr x4, [x23, #56]
40028904: b90067e5 str w5, [sp, #100]
40028908: b94063e0 ldr w0, [sp, #96]
4002890c: 8b150084 add x4, x4, x21
rc = rtems_rfs_bitmap_map_alloc (bitmap, bit, &allocated, &bit);
40028910: b9407fe1 ldr w1, [sp, #124]
bitmap = &fs->groups[group].inode_bitmap;
40028914: 7100001f cmp w0, #0x0
40028918: 91014094 add x20, x4, #0x50
4002891c: 91004084 add x4, x4, #0x10
40028920: 9a940094 csel x20, x4, x20, eq // eq = none
rc = rtems_rfs_bitmap_map_alloc (bitmap, bit, &allocated, &bit);
40028924: aa1403e0 mov x0, x20
40028928: 97fff7fe bl 40026920 <rtems_rfs_bitmap_map_alloc>
if (rc > 0)
4002892c: 7100001f cmp w0, #0x0
40028930: 5400040c b.gt 400289b0 <rtems_rfs_group_bitmap_alloc+0x130> <== NEVER TAKEN
return rc;
if (rtems_rfs_fs_release_bitmaps (fs))
40028934: b94002e0 ldr w0, [x23]
40028938: b94067e5 ldr w5, [sp, #100]
4002893c: 36000780 tbz w0, #0, 40028a2c <rtems_rfs_group_bitmap_alloc+0x1ac> <== ALWAYS TAKEN
rtems_rfs_bitmap_release_buffer (fs, bitmap);
if (allocated)
40028940: 3941efe0 ldrb w0, [sp, #123]
* Otherwise we are marching through the groups, so just
* increment the offset.
*/
if (updown)
{
direction = direction > 0 ? -1 : 1;
40028944: 7100073f cmp w25, #0x1
if (allocated)
40028948: 350008a0 cbnz w0, 40028a5c <rtems_rfs_group_bitmap_alloc+0x1dc>
if (updown)
4002894c: 340004bb cbz w27, 400289e0 <rtems_rfs_group_bitmap_alloc+0x160> <== NEVER TAKEN
direction = direction > 0 ? -1 : 1;
40028950: 540007a1 b.ne 40028a44 <rtems_rfs_group_bitmap_alloc+0x1c4> // b.any<== NEVER TAKEN
if ( direction == -1 )
offset++;
40028954: 11000718 add w24, w24, #0x1
direction = direction > 0 ? -1 : 1;
40028958: 12800019 mov w25, #0xffffffff // #-1
4002895c: 4b180353 sub w19, w26, w24
bool allocated = false;
40028960: 3901efff strb wzr, [sp, #123]
bit = direction > 0 ? 0 : size - 1;
40028964: 51000780 sub w0, w28, #0x1
40028968: b9007fe0 str w0, [sp, #124]
group = group_start + (direction * offset);
4002896c: 0b180345 add w5, w26, w24
40028970: 17ffffdd b 400288e4 <rtems_rfs_group_bitmap_alloc+0x64>
if (!updown)
40028974: 3400015b cbz w27, 4002899c <rtems_rfs_group_bitmap_alloc+0x11c>
bool allocated = false;
40028978: 3901efff strb wzr, [sp, #123]
direction = direction > 0 ? -1 : 1;
4002897c: 7100073f cmp w25, #0x1
40028980: 54000481 b.ne 40028a10 <rtems_rfs_group_bitmap_alloc+0x190> // b.any<== ALWAYS TAKEN
group = group_start + (direction * offset);
40028984: 4b180353 sub w19, w26, w24 <== NOT EXECUTED
direction = direction > 0 ? -1 : 1;
40028988: 12800019 mov w25, #0xffffffff // #-1 <== NOT EXECUTED
if (offset)
4002898c: 5280001b mov w27, #0x0 // #0 <== NOT EXECUTED
40028990: 34fffa98 cbz w24, 400288e0 <rtems_rfs_group_bitmap_alloc+0x60> <== NOT EXECUTED
bit = direction > 0 ? 0 : size - 1;
40028994: 51000780 sub w0, w28, #0x1 <== NOT EXECUTED
40028998: 17fffff4 b 40028968 <rtems_rfs_group_bitmap_alloc+0xe8> <== NOT EXECUTED
offset++;
}
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
4002899c: d2a00040 mov x0, #0x20000 // #131072
400289a0: 9400082c bl 4002aa50 <rtems_rfs_trace>
400289a4: 72001c1f tst w0, #0xff
400289a8: 540002a1 b.ne 400289fc <rtems_rfs_group_bitmap_alloc+0x17c> // b.any<== NEVER TAKEN
printf ("rtems-rfs: group-bitmap-alloc: no blocks available\n");
return ENOSPC;
400289ac: 52800380 mov w0, #0x1c // #28
}
400289b0: a94153f3 ldp x19, x20, [sp, #16]
400289b4: a9425bf5 ldp x21, x22, [sp, #32]
400289b8: a94363f7 ldp x23, x24, [sp, #48]
400289bc: a9446bf9 ldp x25, x26, [sp, #64]
400289c0: a94573fb ldp x27, x28, [sp, #80]
400289c4: a8c87bfd ldp x29, x30, [sp], #128
400289c8: d65f03c0 ret
goal -= RTEMS_RFS_ROOT_INO;
400289cc: 7100003f cmp w1, #0x0
400289d0: 1a9fd7e0 cset w0, gt
400289d4: 4b000021 sub w1, w1, w0
size = fs->group_blocks;
400289d8: f94026fc ldr x28, [x23, #72]
if (goal >= RTEMS_RFS_ROOT_INO)
400289dc: 17ffffb7 b 400288b8 <rtems_rfs_group_bitmap_alloc+0x38>
offset++;
400289e0: 11000718 add w24, w24, #0x1 <== NOT EXECUTED
bool allocated = false;
400289e4: 3901efff strb wzr, [sp, #123] <== NOT EXECUTED
group = group_start + (direction * offset);
400289e8: 1b196b13 madd w19, w24, w25, w26 <== NOT EXECUTED
bit = direction > 0 ? 0 : size - 1;
400289ec: 54fffbc1 b.ne 40028964 <rtems_rfs_group_bitmap_alloc+0xe4> // b.any<== NOT EXECUTED
400289f0: 52800000 mov w0, #0x0 // #0 <== NOT EXECUTED
400289f4: b9007fe0 str w0, [sp, #124] <== NOT EXECUTED
400289f8: 17ffffdd b 4002896c <rtems_rfs_group_bitmap_alloc+0xec> <== NOT EXECUTED
printf ("rtems-rfs: group-bitmap-alloc: no blocks available\n");
400289fc: b0000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40028a00: 91236000 add x0, x0, #0x8d8 <== NOT EXECUTED
40028a04: 97ffe6a7 bl 400224a0 <__wrap_puts> <== NOT EXECUTED
return ENOSPC;
40028a08: 52800380 mov w0, #0x1c // #28 <== NOT EXECUTED
40028a0c: 17ffffe9 b 400289b0 <rtems_rfs_group_bitmap_alloc+0x130> <== NOT EXECUTED
group = group_start + (direction * offset);
40028a10: 0b180353 add w19, w26, w24
if (offset)
40028a14: 52800039 mov w25, #0x1 // #1
40028a18: 5280001b mov w27, #0x0 // #0
bit = direction > 0 ? 0 : size - 1;
40028a1c: 52800000 mov w0, #0x0 // #0
if (offset)
40028a20: 34fff618 cbz w24, 400288e0 <rtems_rfs_group_bitmap_alloc+0x60> <== NEVER TAKEN
bit = direction > 0 ? 0 : size - 1;
40028a24: b9007fe0 str w0, [sp, #124]
40028a28: 17ffffd1 b 4002896c <rtems_rfs_group_bitmap_alloc+0xec>
rtems_rfs_bitmap_release_buffer (fs, bitmap);
40028a2c: f9400281 ldr x1, [x20]
40028a30: aa1703e0 mov x0, x23
40028a34: b90067e5 str w5, [sp, #100]
40028a38: 97fffa16 bl 40027290 <rtems_rfs_buffer_handle_release>
40028a3c: b94067e5 ldr w5, [sp, #100]
40028a40: 17ffffc0 b 40028940 <rtems_rfs_group_bitmap_alloc+0xc0>
bool allocated = false;
40028a44: 3901efff strb wzr, [sp, #123] <== NOT EXECUTED
group = group_start + (direction * offset);
40028a48: 2a0503f3 mov w19, w5 <== NOT EXECUTED
if (offset)
40028a4c: 52800039 mov w25, #0x1 // #1 <== NOT EXECUTED
40028a50: 34fff4b8 cbz w24, 400288e4 <rtems_rfs_group_bitmap_alloc+0x64> <== NOT EXECUTED
bit = direction > 0 ? 0 : size - 1;
40028a54: 52800000 mov w0, #0x0 // #0 <== NOT EXECUTED
40028a58: 17ffffe7 b 400289f4 <rtems_rfs_group_bitmap_alloc+0x174> <== NOT EXECUTED
if (inode)
40028a5c: b94063e0 ldr w0, [sp, #96]
*result = rtems_rfs_group_inode (fs, group, bit);
40028a60: b9407fe1 ldr w1, [sp, #124]
if (inode)
40028a64: 34000260 cbz w0, 40028ab0 <rtems_rfs_group_bitmap_alloc+0x230>
*result = rtems_rfs_group_inode (fs, group, bit);
40028a68: f9402ae2 ldr x2, [x23, #80]
40028a6c: 11000421 add w1, w1, #0x1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
40028a70: d2a00040 mov x0, #0x20000 // #131072
*result = rtems_rfs_group_inode (fs, group, bit);
40028a74: 1b020673 madd w19, w19, w2, w1
40028a78: f94037e1 ldr x1, [sp, #104]
40028a7c: b9000033 str w19, [x1]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
40028a80: 940007f4 bl 4002aa50 <rtems_rfs_trace>
40028a84: 72001c1f tst w0, #0xff
40028a88: 54000100 b.eq 40028aa8 <rtems_rfs_group_bitmap_alloc+0x228> // b.none<== ALWAYS TAKEN
printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
40028a8c: b0000101 adrp x1, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40028a90: 91224021 add x1, x1, #0x890 <== NOT EXECUTED
40028a94: f94037e0 ldr x0, [sp, #104] <== NOT EXECUTED
40028a98: b9400002 ldr w2, [x0] <== NOT EXECUTED
40028a9c: b0000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40028aa0: 91228000 add x0, x0, #0x8a0 <== NOT EXECUTED
40028aa4: 97ffe65b bl 40022410 <__wrap_printf> <== NOT EXECUTED
return 0;
40028aa8: 52800000 mov w0, #0x0 // #0
40028aac: 17ffffc1 b 400289b0 <rtems_rfs_group_bitmap_alloc+0x130>
*result = rtems_rfs_group_block (&fs->groups[group], bit);
40028ab0: f9401ee2 ldr x2, [x23, #56]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
40028ab4: d2a00040 mov x0, #0x20000 // #131072
*result = rtems_rfs_group_block (&fs->groups[group], bit);
40028ab8: b8756842 ldr w2, [x2, x21]
40028abc: 0b010041 add w1, w2, w1
40028ac0: f94037e2 ldr x2, [sp, #104]
40028ac4: b9000041 str w1, [x2]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
40028ac8: 940007e2 bl 4002aa50 <rtems_rfs_trace>
40028acc: 72001c1f tst w0, #0xff
40028ad0: 54fffec0 b.eq 40028aa8 <rtems_rfs_group_bitmap_alloc+0x228> // b.none<== ALWAYS TAKEN
printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
40028ad4: b0000101 adrp x1, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40028ad8: 91226021 add x1, x1, #0x898 <== NOT EXECUTED
40028adc: 17ffffee b 40028a94 <rtems_rfs_group_bitmap_alloc+0x214> <== NOT EXECUTED
0000000040028ae0 <rtems_rfs_group_bitmap_free>:
int
rtems_rfs_group_bitmap_free (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no)
{
40028ae0: a9bd7bfd stp x29, x30, [sp, #-48]!
40028ae4: 910003fd mov x29, sp
40028ae8: a90153f3 stp x19, x20, [sp, #16]
40028aec: aa0003f4 mov x20, x0
40028af0: 2a0203f3 mov w19, w2
unsigned int group;
rtems_rfs_bitmap_bit bit;
size_t size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
40028af4: d2a00040 mov x0, #0x20000 // #131072
{
40028af8: f90013f5 str x21, [sp, #32]
40028afc: 12001c35 and w21, w1, #0xff
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
40028b00: 940007d4 bl 4002aa50 <rtems_rfs_trace>
40028b04: 72001c1f tst w0, #0xff
40028b08: 54000160 b.eq 40028b34 <rtems_rfs_group_bitmap_free+0x54> // b.none<== ALWAYS TAKEN
printf ("rtems-rfs: group-bitmap-free: %s free: %" PRId32 "\n",
40028b0c: 710002bf cmp w21, #0x0 <== NOT EXECUTED
40028b10: b0000101 adrp x1, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40028b14: 91226021 add x1, x1, #0x898 <== NOT EXECUTED
40028b18: b0000102 adrp x2, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40028b1c: 91224042 add x2, x2, #0x890 <== NOT EXECUTED
40028b20: b0000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40028b24: 9a811041 csel x1, x2, x1, ne // ne = any <== NOT EXECUTED
40028b28: 91244000 add x0, x0, #0x910 <== NOT EXECUTED
40028b2c: 2a1303e2 mov w2, w19 <== NOT EXECUTED
40028b30: 97ffe638 bl 40022410 <__wrap_printf> <== NOT EXECUTED
inode ? "inode" : "block", no);
if (inode)
{
no -= RTEMS_RFS_ROOT_INO;
40028b34: 51000662 sub w2, w19, #0x1
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
40028b38: f9401e80 ldr x0, [x20, #56]
group = no / size;
40028b3c: 93407c42 sxtw x2, w2
if (inode)
40028b40: 34000275 cbz w21, 40028b8c <rtems_rfs_group_bitmap_free+0xac>
size = fs->group_inodes;
40028b44: f9402a81 ldr x1, [x20, #80]
bitmap = &fs->groups[group].inode_bitmap;
40028b48: d2801204 mov x4, #0x90 // #144
bit = (rtems_rfs_bitmap_bit) (no % size);
40028b4c: 9ac10843 udiv x3, x2, x1
bitmap = &fs->groups[group].inode_bitmap;
40028b50: 92407c73 and x19, x3, #0xffffffff
bit = (rtems_rfs_bitmap_bit) (no % size);
40028b54: 1b018861 msub w1, w3, w1, w2
bitmap = &fs->groups[group].inode_bitmap;
40028b58: 9b040273 madd x19, x19, x4, x0
40028b5c: 91014273 add x19, x19, #0x50
else
bitmap = &fs->groups[group].block_bitmap;
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
40028b60: aa1303e0 mov x0, x19
40028b64: 97fff6a7 bl 40026600 <rtems_rfs_bitmap_map_clear>
rtems_rfs_bitmap_release_buffer (fs, bitmap);
40028b68: f9400261 ldr x1, [x19]
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
40028b6c: 2a0003f3 mov w19, w0
rtems_rfs_bitmap_release_buffer (fs, bitmap);
40028b70: aa1403e0 mov x0, x20
40028b74: 97fff9c7 bl 40027290 <rtems_rfs_buffer_handle_release>
return rc;
}
40028b78: 2a1303e0 mov w0, w19
40028b7c: a94153f3 ldp x19, x20, [sp, #16]
40028b80: f94013f5 ldr x21, [sp, #32]
40028b84: a8c37bfd ldp x29, x30, [sp], #48
40028b88: d65f03c0 ret
size = fs->group_blocks;
40028b8c: f9402681 ldr x1, [x20, #72]
bitmap = &fs->groups[group].block_bitmap;
40028b90: d2801204 mov x4, #0x90 // #144
bit = (rtems_rfs_bitmap_bit) (no % size);
40028b94: 9ac10843 udiv x3, x2, x1
bitmap = &fs->groups[group].block_bitmap;
40028b98: 92407c73 and x19, x3, #0xffffffff
bit = (rtems_rfs_bitmap_bit) (no % size);
40028b9c: 1b018861 msub w1, w3, w1, w2
bitmap = &fs->groups[group].block_bitmap;
40028ba0: 9b040273 madd x19, x19, x4, x0
40028ba4: 91004273 add x19, x19, #0x10
40028ba8: 17ffffee b 40028b60 <rtems_rfs_group_bitmap_free+0x80>
40028bac: 00000000 udf #0
00000000400287d0 <rtems_rfs_group_close>:
int
rtems_rfs_group_close (rtems_rfs_file_system* fs, rtems_rfs_group* group)
{
400287d0: a9bd7bfd stp x29, x30, [sp, #-48]!
400287d4: 910003fd mov x29, sp
400287d8: a90153f3 stp x19, x20, [sp, #16]
400287dc: aa0103f3 mov x19, x1
400287e0: a9025bf5 stp x21, x22, [sp, #32]
400287e4: aa0003f5 mov x21, x0
int result = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_CLOSE))
400287e8: d2a00020 mov x0, #0x10000 // #65536
400287ec: 94000899 bl 4002aa50 <rtems_rfs_trace>
400287f0: 72001c1f tst w0, #0xff
400287f4: 540003c1 b.ne 4002886c <rtems_rfs_group_close+0x9c> // b.any <== NEVER TAKEN
* we cannot OR the errors together so this is a reasonable compromise.
*/
rc = rtems_rfs_bitmap_close (&group->inode_bitmap);
if (rc > 0)
result = rc;
rc = rtems_rfs_buffer_handle_close (fs, &group->inode_bitmap_buffer);
400287f8: 91020274 add x20, x19, #0x80
rc = rtems_rfs_bitmap_close (&group->inode_bitmap);
400287fc: 91014260 add x0, x19, #0x50
40028800: 97fff8ec bl 40026bb0 <rtems_rfs_bitmap_close>
40028804: 2a0003f6 mov w22, w0
rtems_rfs_buffer_handle_release (fs, handle);
40028808: aa1403e1 mov x1, x20
4002880c: aa1503e0 mov x0, x21
40028810: 97fffaa0 bl 40027290 <rtems_rfs_buffer_handle_release>
handle->dirty = false;
40028814: 3902027f strb wzr, [x19, #128]
handle->bnum = 0;
40028818: b900867f str wzr, [x19, #132]
if (rc > 0)
result = rc;
rc = rtems_rfs_bitmap_close (&group->block_bitmap);
4002881c: 91004260 add x0, x19, #0x10
handle->buffer = NULL;
40028820: f900467f str xzr, [x19, #136]
40028824: 97fff8e3 bl 40026bb0 <rtems_rfs_bitmap_close>
40028828: 2a0003f4 mov w20, w0
if (rc > 0)
4002882c: 7100001f cmp w0, #0x0
40028830: 5400006c b.gt 4002883c <rtems_rfs_group_close+0x6c> <== NEVER TAKEN
40028834: 710002df cmp w22, #0x0
40028838: 1a9fa2d4 csel w20, w22, wzr, ge // ge = tcont
result = rc;
rc = rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);
4002883c: 91010276 add x22, x19, #0x40
rtems_rfs_buffer_handle_release (fs, handle);
40028840: aa1503e0 mov x0, x21
40028844: aa1603e1 mov x1, x22
40028848: 97fffa92 bl 40027290 <rtems_rfs_buffer_handle_release>
handle->dirty = false;
4002884c: 3901027f strb wzr, [x19, #64]
if (rc > 0)
result = rc;
return result;
}
40028850: 2a1403e0 mov w0, w20
40028854: a9425bf5 ldp x21, x22, [sp, #32]
handle->bnum = 0;
40028858: b900467f str wzr, [x19, #68]
handle->buffer = NULL;
4002885c: f900267f str xzr, [x19, #72]
40028860: a94153f3 ldp x19, x20, [sp, #16]
40028864: a8c37bfd ldp x29, x30, [sp], #48
40028868: d65f03c0 ret
printf ("rtems-rfs: group-close: base=%" PRId32 "\n", group->base);
4002886c: b9400261 ldr w1, [x19] <== NOT EXECUTED
40028870: b0000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40028874: 9121a000 add x0, x0, #0x868 <== NOT EXECUTED
40028878: 97ffe6e6 bl 40022410 <__wrap_printf> <== NOT EXECUTED
4002887c: 17ffffdf b 400287f8 <rtems_rfs_group_close+0x28> <== NOT EXECUTED
0000000040028570 <rtems_rfs_group_open>:
rtems_rfs_group_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_block base,
size_t size,
size_t inodes,
rtems_rfs_group* group)
{
40028570: a9bb7bfd stp x29, x30, [sp, #-80]!
40028574: 910003fd mov x29, sp
40028578: a9025bf5 stp x21, x22, [sp, #32]
4002857c: aa0003f5 mov x21, x0
40028580: 2a0103e0 mov w0, w1
40028584: a90153f3 stp x19, x20, [sp, #16]
int rc;
if (base >= rtems_rfs_fs_blocks (fs))
40028588: f94006a5 ldr x5, [x21, #8]
4002858c: eb05001f cmp x0, x5
40028590: 54001002 b.cs 40028790 <rtems_rfs_group_open+0x220> // b.hs, b.nlast<== NEVER TAKEN
printf ("rtems-rfs: group-open: base outside file system range: %d: %s\n",
EIO, strerror (EIO));
return EIO;
}
if ((base + size) >= rtems_rfs_fs_blocks (fs))
40028594: aa0203f4 mov x20, x2
40028598: 8b020002 add x2, x0, x2
size = rtems_rfs_fs_blocks (fs) - base;
4002859c: cb0000a1 sub x1, x5, x0
400285a0: eb0200bf cmp x5, x2
400285a4: 9a949034 csel x20, x1, x20, ls // ls = plast
* Limit the inodes to the same size as the blocks. This is what the * format does and if this is not done the accounting of inodes does * not work. If we are so pushed for inodes that this makes a difference * the format configuration needs reviewing. */ if (inodes > size)
400285a8: aa0003f6 mov x22, x0
400285ac: eb03029f cmp x20, x3
400285b0: aa0403f3 mov x19, x4
inodes = size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
400285b4: d2900000 mov x0, #0x8000 // #32768
400285b8: a90363f7 stp x23, x24, [sp, #48]
400285bc: 9a839298 csel x24, x20, x3, ls // ls = plast
400285c0: f90023f9 str x25, [sp, #64]
400285c4: 94000923 bl 4002aa50 <rtems_rfs_trace>
400285c8: 72001c1f tst w0, #0xff
400285cc: 54000821 b.ne 400286d0 <rtems_rfs_group_open+0x160> // b.any <== NEVER TAKEN
base, size, inodes);
group->base = base;
group->size = size;
rc = rtems_rfs_buffer_handle_open (fs, &group->block_bitmap_buffer);
400285d0: 91010277 add x23, x19, #0x40
group->base = base;
400285d4: b9000276 str w22, [x19]
group->size = size;
400285d8: f9000674 str x20, [x19, #8]
printf ("rtems-rfs: group-open: could not open block bitmap handle: %d: %s\n",
rc, strerror (rc));
return rc;
}
rc = rtems_rfs_bitmap_open (&group->block_bitmap, fs,
400285dc: 91004279 add x25, x19, #0x10
handle->dirty = false;
400285e0: 3901027f strb wzr, [x19, #64]
400285e4: aa1403e3 mov x3, x20
handle->bnum = 0;
400285e8: b90006ff str wzr, [x23, #4]
400285ec: 2a1603e4 mov w4, w22
handle->buffer = NULL;
400285f0: f90006ff str xzr, [x23, #8]
400285f4: aa1703e2 mov x2, x23
400285f8: aa1903e0 mov x0, x25
400285fc: aa1503e1 mov x1, x21
40028600: 97fff954 bl 40026b50 <rtems_rfs_bitmap_open>
40028604: 2a0003f4 mov w20, w0
&group->block_bitmap_buffer, size,
group->base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
40028608: 7100001f cmp w0, #0x0
4002860c: 5400032c b.gt 40028670 <rtems_rfs_group_open+0x100> <== NEVER TAKEN
printf ("rtems-rfs: group-open: could not open inode bitmap handle: %d: %s\n",
rc, strerror (rc));
return rc;
}
rc = rtems_rfs_bitmap_open (&group->inode_bitmap, fs,
40028610: aa1303e0 mov x0, x19
handle->dirty = false;
40028614: 3902027f strb wzr, [x19, #128]
rc = rtems_rfs_buffer_handle_open (fs, &group->inode_bitmap_buffer);
40028618: 91020276 add x22, x19, #0x80
rc = rtems_rfs_bitmap_open (&group->inode_bitmap, fs,
4002861c: aa1803e3 mov x3, x24
40028620: aa1603e2 mov x2, x22
40028624: aa1503e1 mov x1, x21
40028628: b8450404 ldr w4, [x0], #80
handle->bnum = 0;
4002862c: b900867f str wzr, [x19, #132]
handle->buffer = NULL;
40028630: f900467f str xzr, [x19, #136]
40028634: 11000484 add w4, w4, #0x1
40028638: 97fff946 bl 40026b50 <rtems_rfs_bitmap_open>
4002863c: 2a0003f4 mov w20, w0
&group->inode_bitmap_buffer, inodes,
group->base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
40028640: 7100001f cmp w0, #0x0
40028644: 5400054c b.gt 400286ec <rtems_rfs_group_open+0x17c> <== NEVER TAKEN
printf ("rtems-rfs: group-open: could not open inode bitmap: %d: %s\n",
rc, strerror (rc));
return rc;
}
if (rtems_rfs_fs_release_bitmaps (fs))
40028648: b94002a0 ldr w0, [x21]
{
rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);
rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);
}
return 0;
4002864c: 52800014 mov w20, #0x0 // #0
if (rtems_rfs_fs_release_bitmaps (fs))
40028650: 36000860 tbz w0, #0, 4002875c <rtems_rfs_group_open+0x1ec> <== ALWAYS TAKEN
40028654: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
40028658: f94023f9 ldr x25, [sp, #64] <== NOT EXECUTED
}
4002865c: 2a1403e0 mov w0, w20 <== NOT EXECUTED
40028660: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40028664: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
40028668: a8c57bfd ldp x29, x30, [sp], #80 <== NOT EXECUTED
4002866c: d65f03c0 ret <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40028670: aa1703e1 mov x1, x23 <== NOT EXECUTED
40028674: aa1503e0 mov x0, x21 <== NOT EXECUTED
40028678: 97fffb06 bl 40027290 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
4002867c: 3901027f strb wzr, [x19, #64] <== NOT EXECUTED
handle->bnum = 0;
40028680: b90006ff str wzr, [x23, #4] <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
40028684: d2900000 mov x0, #0x8000 // #32768 <== NOT EXECUTED
handle->buffer = NULL;
40028688: f90006ff str xzr, [x23, #8] <== NOT EXECUTED
4002868c: 940008f1 bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
40028690: 72001c1f tst w0, #0xff <== NOT EXECUTED
40028694: 54fffe00 b.eq 40028654 <rtems_rfs_group_open+0xe4> // b.none <== NOT EXECUTED
printf ("rtems-rfs: group-open: could not open block bitmap: %d: %s\n",
40028698: 2a1403e0 mov w0, w20 <== NOT EXECUTED
4002869c: 94005960 bl 4003ec1c <strerror> <== NOT EXECUTED
400286a0: b0000101 adrp x1, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
400286a4: aa0003e2 mov x2, x0 <== NOT EXECUTED
400286a8: 911fa020 add x0, x1, #0x7e8 <== NOT EXECUTED
400286ac: 2a1403e1 mov w1, w20 <== NOT EXECUTED
400286b0: 97ffe758 bl 40022410 <__wrap_printf> <== NOT EXECUTED
}
400286b4: 2a1403e0 mov w0, w20 <== NOT EXECUTED
400286b8: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
400286bc: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
400286c0: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
400286c4: f94023f9 ldr x25, [sp, #64] <== NOT EXECUTED
400286c8: a8c57bfd ldp x29, x30, [sp], #80 <== NOT EXECUTED
400286cc: d65f03c0 ret <== NOT EXECUTED
printf ("rtems-rfs: group-open: base=%" PRId32 ", blocks=%zd inodes=%zd\n",
400286d0: aa1803e3 mov x3, x24 <== NOT EXECUTED
400286d4: aa1403e2 mov x2, x20 <== NOT EXECUTED
400286d8: 2a1603e1 mov w1, w22 <== NOT EXECUTED
400286dc: b0000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
400286e0: 911ec000 add x0, x0, #0x7b0 <== NOT EXECUTED
400286e4: 97ffe74b bl 40022410 <__wrap_printf> <== NOT EXECUTED
400286e8: 17ffffba b 400285d0 <rtems_rfs_group_open+0x60> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
400286ec: aa1603e1 mov x1, x22 <== NOT EXECUTED
400286f0: aa1503e0 mov x0, x21 <== NOT EXECUTED
400286f4: 97fffae7 bl 40027290 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
400286f8: 3902027f strb wzr, [x19, #128] <== NOT EXECUTED
handle->bnum = 0;
400286fc: b900867f str wzr, [x19, #132] <== NOT EXECUTED
rtems_rfs_bitmap_close (&group->block_bitmap);
40028700: aa1903e0 mov x0, x25 <== NOT EXECUTED
handle->buffer = NULL;
40028704: f900467f str xzr, [x19, #136] <== NOT EXECUTED
40028708: 97fff92a bl 40026bb0 <rtems_rfs_bitmap_close> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
4002870c: aa1703e1 mov x1, x23 <== NOT EXECUTED
40028710: aa1503e0 mov x0, x21 <== NOT EXECUTED
40028714: 97fffadf bl 40027290 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
40028718: 3901027f strb wzr, [x19, #64] <== NOT EXECUTED
handle->bnum = 0;
4002871c: b90006ff str wzr, [x23, #4] <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
40028720: d2900000 mov x0, #0x8000 // #32768 <== NOT EXECUTED
handle->buffer = NULL;
40028724: f90006ff str xzr, [x23, #8] <== NOT EXECUTED
40028728: 940008ca bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
4002872c: 72001c1f tst w0, #0xff <== NOT EXECUTED
40028730: 54fff920 b.eq 40028654 <rtems_rfs_group_open+0xe4> // b.none <== NOT EXECUTED
printf ("rtems-rfs: group-open: could not open inode bitmap: %d: %s\n",
40028734: 2a1403e0 mov w0, w20 <== NOT EXECUTED
40028738: 94005939 bl 4003ec1c <strerror> <== NOT EXECUTED
4002873c: b0000101 adrp x1, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40028740: aa0003e2 mov x2, x0 <== NOT EXECUTED
40028744: 9120a020 add x0, x1, #0x828 <== NOT EXECUTED
40028748: 2a1403e1 mov w1, w20 <== NOT EXECUTED
4002874c: 97ffe731 bl 40022410 <__wrap_printf> <== NOT EXECUTED
40028750: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
40028754: f94023f9 ldr x25, [sp, #64] <== NOT EXECUTED
40028758: 17ffffc1 b 4002865c <rtems_rfs_group_open+0xec> <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);
4002875c: f9400a61 ldr x1, [x19, #16]
40028760: aa1503e0 mov x0, x21
40028764: 97fffacb bl 40027290 <rtems_rfs_buffer_handle_release>
rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);
40028768: f9402a61 ldr x1, [x19, #80]
4002876c: aa1503e0 mov x0, x21
40028770: 97fffac8 bl 40027290 <rtems_rfs_buffer_handle_release>
}
40028774: 2a1403e0 mov w0, w20
40028778: a94153f3 ldp x19, x20, [sp, #16]
4002877c: a9425bf5 ldp x21, x22, [sp, #32]
rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);
40028780: a94363f7 ldp x23, x24, [sp, #48]
40028784: f94023f9 ldr x25, [sp, #64]
}
40028788: a8c57bfd ldp x29, x30, [sp], #80
4002878c: d65f03c0 ret
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
40028790: d2900000 mov x0, #0x8000 // #32768 <== NOT EXECUTED
return EIO;
40028794: 528000b4 mov w20, #0x5 // #5 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
40028798: 940008ae bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
4002879c: 72001c1f tst w0, #0xff <== NOT EXECUTED
400287a0: 54fff5e0 b.eq 4002865c <rtems_rfs_group_open+0xec> // b.none <== NOT EXECUTED
printf ("rtems-rfs: group-open: base outside file system range: %d: %s\n",
400287a4: 2a1403e0 mov w0, w20 <== NOT EXECUTED
400287a8: 9400591d bl 4003ec1c <strerror> <== NOT EXECUTED
400287ac: b0000101 adrp x1, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
400287b0: aa0003e2 mov x2, x0 <== NOT EXECUTED
400287b4: 911dc020 add x0, x1, #0x770 <== NOT EXECUTED
400287b8: 2a1403e1 mov w1, w20 <== NOT EXECUTED
400287bc: 97ffe715 bl 40022410 <__wrap_printf> <== NOT EXECUTED
400287c0: 17ffffa7 b 4002865c <rtems_rfs_group_open+0xec> <== NOT EXECUTED
...
0000000040028bb0 <rtems_rfs_group_usage>:
int g;
*blocks = 0;
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
40028bb0: b9404007 ldr w7, [x0, #64] <== NOT EXECUTED
*blocks = 0;
40028bb4: f900003f str xzr, [x1] <== NOT EXECUTED
*inodes = 0;
40028bb8: f900005f str xzr, [x2] <== NOT EXECUTED
for (g = 0; g < fs->group_count; g++)
40028bbc: 710000ff cmp w7, #0x0 <== NOT EXECUTED
40028bc0: 540003ad b.le 40028c34 <rtems_rfs_group_usage+0x84> <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
40028bc4: f9401c03 ldr x3, [x0, #56] <== NOT EXECUTED
40028bc8: 510004e7 sub w7, w7, #0x1 <== NOT EXECUTED
40028bcc: 52801205 mov w5, #0x90 // #144 <== NOT EXECUTED
40028bd0: 9102e064 add x4, x3, #0xb8 <== NOT EXECUTED
40028bd4: 9100a063 add x3, x3, #0x28 <== NOT EXECUTED
40028bd8: 9ba510e7 umaddl x7, w7, w5, x4 <== NOT EXECUTED
40028bdc: d503201f nop <== NOT EXECUTED
*blocks +=
40028be0: a9401466 ldp x6, x5, [x3] <== NOT EXECUTED
40028be4: f9400024 ldr x4, [x1] <== NOT EXECUTED
40028be8: 8b060084 add x4, x4, x6 <== NOT EXECUTED
40028bec: cb050084 sub x4, x4, x5 <== NOT EXECUTED
40028bf0: f9000024 str x4, [x1] <== NOT EXECUTED
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
rtems_rfs_bitmap_map_free (&group->block_bitmap);
*inodes +=
40028bf4: a9441466 ldp x6, x5, [x3, #64] <== NOT EXECUTED
for (g = 0; g < fs->group_count; g++)
40028bf8: 91024063 add x3, x3, #0x90 <== NOT EXECUTED
*inodes +=
40028bfc: f9400044 ldr x4, [x2] <== NOT EXECUTED
for (g = 0; g < fs->group_count; g++)
40028c00: eb07007f cmp x3, x7 <== NOT EXECUTED
*inodes +=
40028c04: 8b060084 add x4, x4, x6 <== NOT EXECUTED
40028c08: cb050084 sub x4, x4, x5 <== NOT EXECUTED
40028c0c: f9000044 str x4, [x2] <== NOT EXECUTED
for (g = 0; g < fs->group_count; g++)
40028c10: 54fffe81 b.ne 40028be0 <rtems_rfs_group_usage+0x30> // b.any <== NOT EXECUTED
rtems_rfs_bitmap_map_size (&group->inode_bitmap) -
rtems_rfs_bitmap_map_free (&group->inode_bitmap);
}
if (*blocks > rtems_rfs_fs_blocks (fs))
40028c14: f9400025 ldr x5, [x1] <== NOT EXECUTED
40028c18: f9400403 ldr x3, [x0, #8] <== NOT EXECUTED
40028c1c: eb0300bf cmp x5, x3 <== NOT EXECUTED
40028c20: 540000e8 b.hi 40028c3c <rtems_rfs_group_usage+0x8c> // b.pmore <== NOT EXECUTED
*blocks = rtems_rfs_fs_blocks (fs);
if (*inodes > rtems_rfs_fs_inodes (fs))
40028c24: b9402800 ldr w0, [x0, #40] <== NOT EXECUTED
40028c28: eb04001f cmp x0, x4 <== NOT EXECUTED
40028c2c: 54000042 b.cs 40028c34 <rtems_rfs_group_usage+0x84> // b.hs, b.nlast<== NOT EXECUTED
*inodes = rtems_rfs_fs_inodes (fs);
40028c30: f9000040 str x0, [x2] <== NOT EXECUTED
return 0;
}
40028c34: 52800000 mov w0, #0x0 // #0 <== NOT EXECUTED
40028c38: d65f03c0 ret <== NOT EXECUTED
*blocks = rtems_rfs_fs_blocks (fs);
40028c3c: f9000023 str x3, [x1] <== NOT EXECUTED
if (*inodes > rtems_rfs_fs_inodes (fs))
40028c40: f9400044 ldr x4, [x2] <== NOT EXECUTED
40028c44: 17fffff8 b 40028c24 <rtems_rfs_group_usage+0x74> <== NOT EXECUTED
...
0000000040028f20 <rtems_rfs_inode_close>:
{
40028f20: a9be7bfd stp x29, x30, [sp, #-32]!
40028f24: 910003fd mov x29, sp
40028f28: a90153f3 stp x19, x20, [sp, #16]
40028f2c: aa0003f4 mov x20, x0
40028f30: aa0103f3 mov x19, x1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
40028f34: d2a00100 mov x0, #0x80000 // #524288
40028f38: 940006c6 bl 4002aa50 <rtems_rfs_trace>
40028f3c: 72001c1f tst w0, #0xff
40028f40: 54000321 b.ne 40028fa4 <rtems_rfs_inode_close+0x84> // b.any <== NEVER TAKEN
rc = rtems_rfs_inode_unload (fs, handle, true);
40028f44: aa1403e0 mov x0, x20
40028f48: aa1303e1 mov x1, x19
40028f4c: 52800022 mov w2, #0x1 // #1
40028f50: 97ffffb4 bl 40028e20 <rtems_rfs_inode_unload>
40028f54: 2a0003f4 mov w20, w0
if ((rc == 0) && (handle->loads > 0))
40028f58: 35000080 cbnz w0, 40028f68 <rtems_rfs_inode_close+0x48> <== NEVER TAKEN
40028f5c: b9403a60 ldr w0, [x19, #56]
40028f60: 7100001f cmp w0, #0x0
40028f64: 540000cc b.gt 40028f7c <rtems_rfs_inode_close+0x5c> <== NEVER TAKEN
handle->ino = 0;
40028f68: b900127f str wzr, [x19, #16]
}
40028f6c: 2a1403e0 mov w0, w20
40028f70: a94153f3 ldp x19, x20, [sp, #16]
40028f74: a8c27bfd ldp x29, x30, [sp], #32
40028f78: d65f03c0 ret
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
40028f7c: d2a00100 mov x0, #0x80000 // #524288 <== NOT EXECUTED
rc = EIO;
40028f80: 528000b4 mov w20, #0x5 // #5 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
40028f84: 940006b3 bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
40028f88: 72001c1f tst w0, #0xff <== NOT EXECUTED
40028f8c: 54fffee0 b.eq 40028f68 <rtems_rfs_inode_close+0x48> // b.none <== NOT EXECUTED
printf ("rtems-rfs: inode-close: bad loads number: %d\n",
40028f90: b9403a61 ldr w1, [x19, #56] <== NOT EXECUTED
40028f94: b0000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40028f98: 91282000 add x0, x0, #0xa08 <== NOT EXECUTED
40028f9c: 97ffe51d bl 40022410 <__wrap_printf> <== NOT EXECUTED
40028fa0: 17fffff2 b 40028f68 <rtems_rfs_inode_close+0x48> <== NOT EXECUTED
printf ("rtems-rfs: inode-close: ino: %" PRIu32 "\n", handle->ino);
40028fa4: b9401261 ldr w1, [x19, #16] <== NOT EXECUTED
40028fa8: b0000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40028fac: 91278000 add x0, x0, #0x9e0 <== NOT EXECUTED
40028fb0: 97ffe518 bl 40022410 <__wrap_printf> <== NOT EXECUTED
40028fb4: 17ffffe4 b 40028f44 <rtems_rfs_inode_close+0x24> <== NOT EXECUTED
...
0000000040029310 <rtems_rfs_inode_create>:
{
40029310: a9b17bfd stp x29, x30, [sp, #-240]!
40029314: 910003fd mov x29, sp
40029318: a9025bf5 stp x21, x22, [sp, #32]
4002931c: aa0003f6 mov x22, x0
40029320: 12003ca0 and w0, w5, #0xffff
40029324: 12003c95 and w21, w4, #0xffff
40029328: b9006be0 str w0, [sp, #104]
4002932c: 12003ce0 and w0, w7, #0xffff
40029330: a90153f3 stp x19, x20, [sp, #16]
40029334: 12140eb4 and w20, w21, #0xf000
40029338: a90363f7 stp x23, x24, [sp, #48]
4002933c: 2a0103f7 mov w23, w1
40029340: aa0203f8 mov x24, x2
40029344: a9046bf9 stp x25, x26, [sp, #64]
40029348: aa0303f9 mov x25, x3
4002934c: a90573fb stp x27, x28, [sp, #80]
40029350: 12003cdc and w28, w6, #0xffff
40029354: b9006fe0 str w0, [sp, #108]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
40029358: d2a00800 mov x0, #0x400000 // #4194304
4002935c: 940005bd bl 4002aa50 <rtems_rfs_trace>
40029360: 72001c1f tst w0, #0xff
40029364: 54000460 b.eq 400293f0 <rtems_rfs_inode_create+0xe0> // b.none <== ALWAYS TAKEN
if (RTEMS_RFS_S_ISDIR (mode))
40029368: 7140129f cmp w20, #0x4, lsl #12 <== NOT EXECUTED
4002936c: 540001c0 b.eq 400293a4 <rtems_rfs_inode_create+0x94> // b.none <== NOT EXECUTED
else if (RTEMS_RFS_S_ISCHR (mode))
40029370: 71400a9f cmp w20, #0x2, lsl #12 <== NOT EXECUTED
40029374: 54001400 b.eq 400295f4 <rtems_rfs_inode_create+0x2e4> // b.none <== NOT EXECUTED
else if (RTEMS_RFS_S_ISBLK (mode))
40029378: 71401a9f cmp w20, #0x6, lsl #12 <== NOT EXECUTED
4002937c: 54000f00 b.eq 4002955c <rtems_rfs_inode_create+0x24c> // b.none <== NOT EXECUTED
else if (RTEMS_RFS_S_ISREG (mode))
40029380: 7140229f cmp w20, #0x8, lsl #12 <== NOT EXECUTED
40029384: 540013e0 b.eq 40029600 <rtems_rfs_inode_create+0x2f0> // b.none <== NOT EXECUTED
const char* type = "unknown";
40029388: 71402a9f cmp w20, #0xa, lsl #12 <== NOT EXECUTED
4002938c: 90000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40029390: 912a2000 add x0, x0, #0xa88 <== NOT EXECUTED
40029394: 9000011a adrp x26, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40029398: 912a035a add x26, x26, #0xa80 <== NOT EXECUTED
4002939c: 9a80035a csel x26, x26, x0, eq // eq = none <== NOT EXECUTED
400293a0: 14000003 b 400293ac <rtems_rfs_inode_create+0x9c> <== NOT EXECUTED
type = "dir";
400293a4: 9000011a adrp x26, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
400293a8: 9129a35a add x26, x26, #0xa68 <== NOT EXECUTED
printf("rtems-rfs: inode-create: parent:%" PRIu32 " name:", parent);
400293ac: 2a1703e1 mov w1, w23 <== NOT EXECUTED
400293b0: 90000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
400293b4: aa1803fb mov x27, x24 <== NOT EXECUTED
400293b8: 912a4000 add x0, x0, #0xa90 <== NOT EXECUTED
400293bc: 8b180333 add x19, x25, x24 <== NOT EXECUTED
400293c0: 97ffe414 bl 40022410 <__wrap_printf> <== NOT EXECUTED
for (c = 0; c < length; c++)
400293c4: b40000b9 cbz x25, 400293d8 <rtems_rfs_inode_create+0xc8> <== NOT EXECUTED
printf ("%c", name[c]);
400293c8: 38401760 ldrb w0, [x27], #1 <== NOT EXECUTED
400293cc: 9400530d bl 4003e000 <putchar> <== NOT EXECUTED
for (c = 0; c < length; c++)
400293d0: eb1b027f cmp x19, x27 <== NOT EXECUTED
400293d4: 54ffffa1 b.ne 400293c8 <rtems_rfs_inode_create+0xb8> // b.any <== NOT EXECUTED
printf (" type:%s mode:%04x (%03o)\n", type, mode, mode & ((1 << 10) - 1));
400293d8: 90000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
400293dc: aa1a03e1 mov x1, x26 <== NOT EXECUTED
400293e0: 120026a3 and w3, w21, #0x3ff <== NOT EXECUTED
400293e4: 912b0000 add x0, x0, #0xac0 <== NOT EXECUTED
400293e8: 2a1503e2 mov w2, w21 <== NOT EXECUTED
400293ec: 97ffe409 bl 40022410 <__wrap_printf> <== NOT EXECUTED
switch (mode & RTEMS_RFS_S_IFMT)
400293f0: 71401a9f cmp w20, #0x6, lsl #12
400293f4: 54000280 b.eq 40029444 <rtems_rfs_inode_create+0x134> // b.none <== NEVER TAKEN
400293f8: 540001c9 b.ls 40029430 <rtems_rfs_inode_create+0x120> // b.plast
400293fc: 1285ffe0 mov w0, #0xffffd000 // #-12288
40029400: 0a0002a0 and w0, w21, w0
40029404: 7140201f cmp w0, #0x8, lsl #12
40029408: 528002d3 mov w19, #0x16 // #22
4002940c: 540001c0 b.eq 40029444 <rtems_rfs_inode_create+0x134> // b.none <== ALWAYS TAKEN
}
40029410: 2a1303e0 mov w0, w19
40029414: a94153f3 ldp x19, x20, [sp, #16]
40029418: a9425bf5 ldp x21, x22, [sp, #32]
4002941c: a94363f7 ldp x23, x24, [sp, #48]
40029420: a9446bf9 ldp x25, x26, [sp, #64]
40029424: a94573fb ldp x27, x28, [sp, #80]
40029428: a8cf7bfd ldp x29, x30, [sp], #240
4002942c: d65f03c0 ret
switch (mode & RTEMS_RFS_S_IFMT)
40029430: 51400a80 sub w0, w20, #0x2, lsl #12
40029434: 529a0001 mov w1, #0xd000 // #53248
40029438: 528002d3 mov w19, #0x16 // #22
4002943c: 6a01001f tst w0, w1
40029440: 54fffe81 b.ne 40029410 <rtems_rfs_inode_create+0x100> // b.any <== NEVER TAKEN
rc = rtems_rfs_group_bitmap_alloc (fs, goal, true, &bit);
40029444: 2a1703e1 mov w1, w23
40029448: 52800022 mov w2, #0x1 // #1
4002944c: 9102c3e3 add x3, sp, #0xb0
40029450: aa1603e0 mov x0, x22
40029454: 97fffd0b bl 40028880 <rtems_rfs_group_bitmap_alloc>
40029458: 2a0003f3 mov w19, w0
*ino = bit;
4002945c: f9407be2 ldr x2, [sp, #240]
if (rc > 0)
40029460: 7100001f cmp w0, #0x0
*ino = bit;
40029464: b940b3e1 ldr w1, [sp, #176]
40029468: b9000041 str w1, [x2]
if (rc > 0)
4002946c: 54fffd2c b.gt 40029410 <rtems_rfs_inode_create+0x100>
rc = rtems_rfs_inode_open (fs, *ino, &inode, true);
40029470: 9102c3e2 add x2, sp, #0xb0
40029474: aa1603e0 mov x0, x22
40029478: 52800023 mov w3, #0x1 // #1
4002947c: 97fffe2d bl 40028d30 <rtems_rfs_inode_open>
40029480: 2a0003f3 mov w19, w0
if (rc > 0)
40029484: 7100001f cmp w0, #0x0
40029488: 540009cc b.gt 400295c0 <rtems_rfs_inode_create+0x2b0> <== NEVER TAKEN
rc = rtems_rfs_inode_initialise (&inode, links, mode, uid, gid);
4002948c: 7940dbe4 ldrh w4, [sp, #108]
40029490: 2a1c03e3 mov w3, w28
40029494: 7940d3e1 ldrh w1, [sp, #104]
40029498: 2a1503e2 mov w2, w21
4002949c: 9102c3e0 add x0, sp, #0xb0
400294a0: 97ffff50 bl 400291e0 <rtems_rfs_inode_initialise>
400294a4: 2a0003f3 mov w19, w0
if (rc > 0)
400294a8: 7100001f cmp w0, #0x0
400294ac: 5400084c b.gt 400295b4 <rtems_rfs_inode_create+0x2a4> <== NEVER TAKEN
if (RTEMS_RFS_S_ISDIR (mode))
400294b0: 7140129f cmp w20, #0x4, lsl #12
400294b4: 540005a0 b.eq 40029568 <rtems_rfs_inode_create+0x258> // b.none
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
400294b8: 2a1703e1 mov w1, w23
400294bc: 9101c3e2 add x2, sp, #0x70
400294c0: aa1603e0 mov x0, x22
400294c4: 52800023 mov w3, #0x1 // #1
400294c8: 97fffe1a bl 40028d30 <rtems_rfs_inode_open>
400294cc: 2a0003f3 mov w19, w0
if (rc > 0)
400294d0: 7100001f cmp w0, #0x0
400294d4: 5400062c b.gt 40029598 <rtems_rfs_inode_create+0x288> <== NEVER TAKEN
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, *ino);
400294d8: f9407be0 ldr x0, [sp, #240]
400294dc: aa1903e3 mov x3, x25
400294e0: aa1803e2 mov x2, x24
400294e4: 9101c3e1 add x1, sp, #0x70
400294e8: b9400004 ldr w4, [x0]
400294ec: aa1603e0 mov x0, x22
400294f0: 94002e9c bl 40034f60 <rtems_rfs_dir_add_entry>
400294f4: 2a0003f3 mov w19, w0
if (rc > 0)
400294f8: 7100001f cmp w0, #0x0
400294fc: 5400088c b.gt 4002960c <rtems_rfs_inode_create+0x2fc> <== NEVER TAKEN
if (RTEMS_RFS_S_ISDIR (mode))
40029500: 7140129f cmp w20, #0x4, lsl #12
40029504: 54000980 b.eq 40029634 <rtems_rfs_inode_create+0x324> // b.none
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
40029508: 52800022 mov w2, #0x1 // #1
4002950c: 9101c3e0 add x0, sp, #0x70
40029510: 2a0203e1 mov w1, w2
40029514: 97fffefb bl 40029100 <rtems_rfs_inode_time_stamp_now>
40029518: 2a0003f3 mov w19, w0
if (rc > 0)
4002951c: 7100001f cmp w0, #0x0
40029520: 540003cc b.gt 40029598 <rtems_rfs_inode_create+0x288> <== NEVER TAKEN
rc = rtems_rfs_inode_close (fs, &parent_inode);
40029524: 9101c3e1 add x1, sp, #0x70
40029528: aa1603e0 mov x0, x22
4002952c: 97fffe7d bl 40028f20 <rtems_rfs_inode_close>
40029530: 2a0003f3 mov w19, w0
rtems_rfs_inode_delete (fs, &inode);
40029534: 9102c3e1 add x1, sp, #0xb0
40029538: aa1603e0 mov x0, x22
if (rc > 0)
4002953c: 7100027f cmp w19, #0x0
40029540: 54000b0c b.gt 400296a0 <rtems_rfs_inode_create+0x390> <== NEVER TAKEN
rc = rtems_rfs_inode_close (fs, &inode);
40029544: 97fffe77 bl 40028f20 <rtems_rfs_inode_close>
40029548: 2a0003f3 mov w19, w0
if (rc > 0)
4002954c: 7100001f cmp w0, #0x0
40029550: 5400038c b.gt 400295c0 <rtems_rfs_inode_create+0x2b0> <== NEVER TAKEN
return 0;
40029554: 52800013 mov w19, #0x0 // #0
40029558: 17ffffae b 40029410 <rtems_rfs_inode_create+0x100>
type = "block";
4002955c: 9000011a adrp x26, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40029560: 9122635a add x26, x26, #0x898 <== NOT EXECUTED
40029564: 17ffff92 b 400293ac <rtems_rfs_inode_create+0x9c> <== NOT EXECUTED
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, *ino);
40029568: f9407be0 ldr x0, [sp, #240]
4002956c: 9102c3e1 add x1, sp, #0xb0
40029570: f00000e2 adrp x2, 40048000 <_Scheduler_Table+0x60>
40029574: d2800023 mov x3, #0x1 // #1
40029578: 910a8042 add x2, x2, #0x2a0
4002957c: b9400004 ldr w4, [x0]
40029580: aa1603e0 mov x0, x22
40029584: 94002e77 bl 40034f60 <rtems_rfs_dir_add_entry>
40029588: 2a0003f3 mov w19, w0
if (rc == 0)
4002958c: 34000780 cbz w0, 4002967c <rtems_rfs_inode_create+0x36c> <== ALWAYS TAKEN
if (rc > 0)
40029590: 7100027f cmp w19, #0x0
40029594: 54fff92d b.le 400294b8 <rtems_rfs_inode_create+0x1a8> <== ALWAYS TAKEN
rtems_rfs_inode_delete (fs, &inode);
40029598: 9102c3e1 add x1, sp, #0xb0 <== NOT EXECUTED
4002959c: aa1603e0 mov x0, x22 <== NOT EXECUTED
400295a0: 97fffe88 bl 40028fc0 <rtems_rfs_inode_delete> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
400295a4: 9102c3e1 add x1, sp, #0xb0 <== NOT EXECUTED
400295a8: aa1603e0 mov x0, x22 <== NOT EXECUTED
400295ac: 97fffe5d bl 40028f20 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
400295b0: 17ffff98 b 40029410 <rtems_rfs_inode_create+0x100> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
400295b4: 9102c3e1 add x1, sp, #0xb0 <== NOT EXECUTED
400295b8: aa1603e0 mov x0, x22 <== NOT EXECUTED
400295bc: 97fffe59 bl 40028f20 <rtems_rfs_inode_close> <== NOT EXECUTED
return rtems_rfs_group_bitmap_free (fs, true, bit);
400295c0: f9407be0 ldr x0, [sp, #240] <== NOT EXECUTED
400295c4: 52800021 mov w1, #0x1 // #1 <== NOT EXECUTED
400295c8: b9400002 ldr w2, [x0] <== NOT EXECUTED
400295cc: aa1603e0 mov x0, x22 <== NOT EXECUTED
400295d0: 97fffd44 bl 40028ae0 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
}
400295d4: 2a1303e0 mov w0, w19 <== NOT EXECUTED
400295d8: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
400295dc: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
400295e0: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
400295e4: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
400295e8: a94573fb ldp x27, x28, [sp, #80] <== NOT EXECUTED
400295ec: a8cf7bfd ldp x29, x30, [sp], #240 <== NOT EXECUTED
400295f0: d65f03c0 ret <== NOT EXECUTED
type = "char";
400295f4: 9000011a adrp x26, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
400295f8: 9129e35a add x26, x26, #0xa78 <== NOT EXECUTED
400295fc: 17ffff6c b 400293ac <rtems_rfs_inode_create+0x9c> <== NOT EXECUTED
type = "file";
40029600: 9000011a adrp x26, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40029604: 9129c35a add x26, x26, #0xa70 <== NOT EXECUTED
40029608: 17ffff69 b 400293ac <rtems_rfs_inode_create+0x9c> <== NOT EXECUTED
rtems_rfs_inode_delete (fs, &inode);
4002960c: 9102c3e1 add x1, sp, #0xb0 <== NOT EXECUTED
40029610: aa1603e0 mov x0, x22 <== NOT EXECUTED
40029614: 97fffe6b bl 40028fc0 <rtems_rfs_inode_delete> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
40029618: 9102c3e1 add x1, sp, #0xb0 <== NOT EXECUTED
4002961c: aa1603e0 mov x0, x22 <== NOT EXECUTED
40029620: 97fffe40 bl 40028f20 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
40029624: 9101c3e1 add x1, sp, #0x70 <== NOT EXECUTED
40029628: aa1603e0 mov x0, x22 <== NOT EXECUTED
4002962c: 97fffe3d bl 40028f20 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
40029630: 17ffff78 b 40029410 <rtems_rfs_inode_create+0x100> <== NOT EXECUTED
links = rtems_rfs_read_u16 (&handle->node->links);
40029634: f94047e1 ldr x1, [sp, #136]
if (links == 0xffff)
40029638: 529fffe2 mov w2, #0xffff // #65535
4002963c: 39400023 ldrb w3, [x1]
40029640: 39400420 ldrb w0, [x1, #1]
40029644: aa002060 orr x0, x3, x0, lsl #8
40029648: 5ac00400 rev16 w0, w0
4002964c: 12003c00 and w0, w0, #0xffff
40029650: 6b02001f cmp w0, w2
40029654: 54000300 b.eq 400296b4 <rtems_rfs_inode_create+0x3a4> // b.none <== NEVER TAKEN
rtems_rfs_inode_set_links (&parent_inode,
40029658: 11000400 add w0, w0, #0x1
rtems_rfs_write_u16 (&handle->node->links, links);
4002965c: 12001c02 and w2, w0, #0xff
40029660: d3483c00 ubfx x0, x0, #8, #8
40029664: 39000020 strb w0, [x1]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40029668: 52800020 mov w0, #0x1 // #1
rtems_rfs_write_u16 (&handle->node->links, links);
4002966c: f94047e1 ldr x1, [sp, #136]
40029670: 39000422 strb w2, [x1, #1]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40029674: 390243e0 strb w0, [sp, #144]
}
40029678: 17ffffa4 b 40029508 <rtems_rfs_inode_create+0x1f8>
rc = rtems_rfs_dir_add_entry (fs, &inode, "..", 2, parent);
4002967c: 2a1703e4 mov w4, w23
40029680: 9102c3e1 add x1, sp, #0xb0
40029684: aa1603e0 mov x0, x22
40029688: 90000102 adrp x2, 40049000 <IMFS_node_control_sym_link+0x640>
4002968c: d2800043 mov x3, #0x2 // #2
40029690: 912b8042 add x2, x2, #0xae0
40029694: 94002e33 bl 40034f60 <rtems_rfs_dir_add_entry>
40029698: 2a0003f3 mov w19, w0
4002969c: 17ffffbd b 40029590 <rtems_rfs_inode_create+0x280>
rtems_rfs_inode_delete (fs, &inode);
400296a0: 97fffe48 bl 40028fc0 <rtems_rfs_inode_delete> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
400296a4: 9102c3e1 add x1, sp, #0xb0 <== NOT EXECUTED
400296a8: aa1603e0 mov x0, x22 <== NOT EXECUTED
400296ac: 97fffe1d bl 40028f20 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
400296b0: 17ffff58 b 40029410 <rtems_rfs_inode_create+0x100> <== NOT EXECUTED
400296b4: 52800022 mov w2, #0x1 // #1 <== NOT EXECUTED
400296b8: 52800000 mov w0, #0x0 // #0 <== NOT EXECUTED
400296bc: 17ffffea b 40029664 <rtems_rfs_inode_create+0x354> <== NOT EXECUTED
0000000040028fc0 <rtems_rfs_inode_delete>:
}
int
rtems_rfs_inode_delete (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
40028fc0: a9b67bfd stp x29, x30, [sp, #-160]!
40028fc4: 910003fd mov x29, sp
40028fc8: a90153f3 stp x19, x20, [sp, #16]
40028fcc: aa0103f3 mov x19, x1
40028fd0: a9025bf5 stp x21, x22, [sp, #32]
40028fd4: aa0003f5 mov x21, x0
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_DELETE))
40028fd8: d2a01000 mov x0, #0x800000 // #8388608
40028fdc: 9400069d bl 4002aa50 <rtems_rfs_trace>
40028fe0: 72001c1f tst w0, #0xff
40028fe4: 54000180 b.eq 40029014 <rtems_rfs_inode_delete+0x54> // b.none <== ALWAYS TAKEN
printf("rtems-rfs: inode-delete: ino:%" PRIu32 " loaded:%s\n",
40028fe8: f9400e60 ldr x0, [x19, #24] <== NOT EXECUTED
40028fec: b0000103 adrp x3, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40028ff0: 91250063 add x3, x3, #0x940 <== NOT EXECUTED
40028ff4: b9401261 ldr w1, [x19, #16] <== NOT EXECUTED
40028ff8: f100001f cmp x0, #0x0 <== NOT EXECUTED
40028ffc: b0000102 adrp x2, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40029000: 91252042 add x2, x2, #0x948 <== NOT EXECUTED
40029004: 90000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40029008: 9a821062 csel x2, x3, x2, ne // ne = any <== NOT EXECUTED
4002900c: 9128e000 add x0, x0, #0xa38 <== NOT EXECUTED
40029010: 97ffe500 bl 40022410 <__wrap_printf> <== NOT EXECUTED
rtems_rfs_inode_ino (handle),
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
40029014: f9400e60 ldr x0, [x19, #24]
int rc = 0;
40029018: 52800014 mov w20, #0x0 // #0
if (rtems_rfs_inode_is_loaded (handle))
4002901c: b4000100 cbz x0, 4002903c <rtems_rfs_inode_delete+0x7c> <== NEVER TAKEN
return rtems_rfs_group_bitmap_free (fs, true, bit);
40029020: b9401262 ldr w2, [x19, #16]
40029024: aa1503e0 mov x0, x21
40029028: 52800021 mov w1, #0x1 // #1
4002902c: 97fffead bl 40028ae0 <rtems_rfs_group_bitmap_free>
40029030: 2a0003f4 mov w20, w0
/*
* Free the ino number.
*/
rc = rtems_rfs_inode_free (fs, handle->ino);
if (rc > 0)
40029034: 7100001f cmp w0, #0x0
40029038: 540000cd b.le 40029050 <rtems_rfs_inode_delete+0x90> <== ALWAYS TAKEN
if (rrc > 0)
rc = rrc;
}
}
return rc;
}
4002903c: 2a1403e0 mov w0, w20
40029040: a94153f3 ldp x19, x20, [sp, #16]
40029044: a9425bf5 ldp x21, x22, [sp, #32]
40029048: a8ca7bfd ldp x29, x30, [sp], #160
4002904c: d65f03c0 ret
rc = rtems_rfs_block_map_open (fs, handle, &map);
40029050: aa1303e1 mov x1, x19
40029054: 910103e2 add x2, sp, #0x40
40029058: aa1503e0 mov x0, x21
4002905c: 94002b29 bl 40033d00 <rtems_rfs_block_map_open>
40029060: 2a0003f4 mov w20, w0
if (rc == 0)
40029064: 35fffec0 cbnz w0, 4002903c <rtems_rfs_inode_delete+0x7c> <== NEVER TAKEN
rrc = rtems_rfs_block_map_free_all (fs, &map);
40029068: 910103e1 add x1, sp, #0x40
4002906c: aa1503e0 mov x0, x21
40029070: f9001bf7 str x23, [sp, #48]
40029074: 94002e1b bl 400348e0 <rtems_rfs_block_map_free_all>
rc = rtems_rfs_block_map_close (fs, &map);
40029078: 910103e1 add x1, sp, #0x40
rrc = rtems_rfs_block_map_free_all (fs, &map);
4002907c: 2a0003f6 mov w22, w0
rc = rtems_rfs_block_map_close (fs, &map);
40029080: aa1503e0 mov x0, x21
40029084: 94002b83 bl 40033e90 <rtems_rfs_block_map_close>
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
40029088: 91008277 add x23, x19, #0x20
rc = rtems_rfs_block_map_close (fs, &map);
4002908c: 2a0003f4 mov w20, w0
if (rc > 0)
40029090: 7100001f cmp w0, #0x0
memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE);
40029094: d2800702 mov x2, #0x38 // #56
40029098: 52801fe1 mov w1, #0xff // #255
4002909c: f9400e60 ldr x0, [x19, #24]
if (rc > 0)
400290a0: 5400016d b.le 400290cc <rtems_rfs_inode_delete+0x10c> <== ALWAYS TAKEN
memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE);
400290a4: 940053c2 bl 4003dfac <memset> <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
400290a8: 52800020 mov w0, #0x1 // #1 <== NOT EXECUTED
400290ac: 39008260 strb w0, [x19, #32] <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
400290b0: aa1703e1 mov x1, x23 <== NOT EXECUTED
400290b4: aa1503e0 mov x0, x21 <== NOT EXECUTED
400290b8: 97fff876 bl 40027290 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->loads = 0;
400290bc: f9401bf7 ldr x23, [sp, #48] <== NOT EXECUTED
handle->node = NULL;
400290c0: f9000e7f str xzr, [x19, #24] <== NOT EXECUTED
handle->loads = 0;
400290c4: b9003a7f str wzr, [x19, #56] <== NOT EXECUTED
if (rrc > 0)
400290c8: 17ffffdd b 4002903c <rtems_rfs_inode_delete+0x7c> <== NOT EXECUTED
memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE);
400290cc: 940053b8 bl 4003dfac <memset>
rtems_rfs_buffer_mark_dirty (&handle->buffer);
400290d0: 52800020 mov w0, #0x1 // #1
400290d4: 39008260 strb w0, [x19, #32]
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
400290d8: aa1703e1 mov x1, x23
400290dc: aa1503e0 mov x0, x21
400290e0: 97fff86c bl 40027290 <rtems_rfs_buffer_handle_release>
handle->loads = 0;
400290e4: 710002df cmp w22, #0x0
400290e8: 1a96d014 csel w20, w0, w22, le
400290ec: f9401bf7 ldr x23, [sp, #48]
handle->node = NULL;
400290f0: f9000e7f str xzr, [x19, #24]
handle->loads = 0;
400290f4: b9003a7f str wzr, [x19, #56]
if (rrc > 0)
400290f8: 17ffffd1 b 4002903c <rtems_rfs_inode_delete+0x7c>
400290fc: 00000000 udf #0
0000000040028c80 <rtems_rfs_inode_load>:
}
int
rtems_rfs_inode_load (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
40028c80: a9be7bfd stp x29, x30, [sp, #-32]!
40028c84: 910003fd mov x29, sp
40028c88: a90153f3 stp x19, x20, [sp, #16]
40028c8c: aa0003f4 mov x20, x0
40028c90: aa0103f3 mov x19, x1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_LOAD))
40028c94: d2a00200 mov x0, #0x100000 // #1048576
40028c98: 9400076e bl 4002aa50 <rtems_rfs_trace>
40028c9c: 72001c1f tst w0, #0xff
40028ca0: 540001a0 b.eq 40028cd4 <rtems_rfs_inode_load+0x54> // b.none <== ALWAYS TAKEN
printf ("rtems-rfs: inode-load: ino=%" PRIu32 " loads=%i loaded=%s\n",
40028ca4: f9400e60 ldr x0, [x19, #24] <== NOT EXECUTED
40028ca8: b0000104 adrp x4, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40028cac: 91250084 add x4, x4, #0x940 <== NOT EXECUTED
40028cb0: b9401261 ldr w1, [x19, #16] <== NOT EXECUTED
40028cb4: b9403a62 ldr w2, [x19, #56] <== NOT EXECUTED
40028cb8: f100001f cmp x0, #0x0 <== NOT EXECUTED
40028cbc: b0000103 adrp x3, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40028cc0: 91252063 add x3, x3, #0x948 <== NOT EXECUTED
40028cc4: b0000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40028cc8: 91254000 add x0, x0, #0x950 <== NOT EXECUTED
40028ccc: 9a831083 csel x3, x4, x3, ne // ne = any <== NOT EXECUTED
40028cd0: 97ffe5d0 bl 40022410 <__wrap_printf> <== NOT EXECUTED
/*
* An inode does not move so once loaded no need to do again.
*/
if (!rtems_rfs_inode_is_loaded (handle))
40028cd4: f9400e61 ldr x1, [x19, #24]
40028cd8: b4000101 cbz x1, 40028cf8 <rtems_rfs_inode_load+0x78>
handle->node = rtems_rfs_buffer_data (&handle->buffer);
handle->node += handle->offset;
}
handle->loads++;
40028cdc: b9403a61 ldr w1, [x19, #56]
return 0;
40028ce0: 52800000 mov w0, #0x0 // #0
handle->loads++;
40028ce4: 11000421 add w1, w1, #0x1
40028ce8: b9003a61 str w1, [x19, #56]
}
40028cec: a94153f3 ldp x19, x20, [sp, #16]
40028cf0: a8c27bfd ldp x29, x30, [sp], #32
40028cf4: d65f03c0 ret
rc = rtems_rfs_buffer_handle_request (fs,&handle->buffer,
40028cf8: b9403262 ldr w2, [x19, #48]
40028cfc: aa1403e0 mov x0, x20
40028d00: 91008261 add x1, x19, #0x20
40028d04: 52800023 mov w3, #0x1 // #1
40028d08: 97fff8b2 bl 40026fd0 <rtems_rfs_buffer_handle_request>
if (rc > 0)
40028d0c: 7100001f cmp w0, #0x0
40028d10: 54fffeec b.gt 40028cec <rtems_rfs_inode_load+0x6c> <== NEVER TAKEN
handle->node = rtems_rfs_buffer_data (&handle->buffer);
40028d14: f9401661 ldr x1, [x19, #40]
handle->node += handle->offset;
40028d18: 52800702 mov w2, #0x38 // #56
40028d1c: b9403660 ldr w0, [x19, #52]
40028d20: f9401c21 ldr x1, [x1, #56]
40028d24: 9b220400 smaddl x0, w0, w2, x1
40028d28: f9000e60 str x0, [x19, #24]
40028d2c: 17ffffec b 40028cdc <rtems_rfs_inode_load+0x5c>
0000000040028d30 <rtems_rfs_inode_open>:
{
40028d30: a9bd7bfd stp x29, x30, [sp, #-48]!
40028d34: 910003fd mov x29, sp
40028d38: a90153f3 stp x19, x20, [sp, #16]
40028d3c: 2a0103f4 mov w20, w1
40028d40: aa0203f3 mov x19, x2
40028d44: a9025bf5 stp x21, x22, [sp, #32]
40028d48: aa0003f6 mov x22, x0
40028d4c: 12001c75 and w21, w3, #0xff
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_OPEN))
40028d50: d2a00080 mov x0, #0x40000 // #262144
40028d54: 9400073f bl 4002aa50 <rtems_rfs_trace>
40028d58: 72001c1f tst w0, #0xff
40028d5c: 54000421 b.ne 40028de0 <rtems_rfs_inode_open+0xb0> // b.any <== NEVER TAKEN
if (ino == RTEMS_RFS_EMPTY_INO)
40028d60: 340004b4 cbz w20, 40028df4 <rtems_rfs_inode_open+0xc4> <== NEVER TAKEN
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
40028d64: b9402ac0 ldr w0, [x22, #40]
40028d68: 51000682 sub w2, w20, #0x1
40028d6c: 6b00005f cmp w2, w0
40028d70: 54000428 b.hi 40028df4 <rtems_rfs_inode_open+0xc4> // b.pmore <== NEVER TAKEN
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
40028d74: a94512c1 ldp x1, x4, [x22, #80]
group = gino / fs->group_inodes;
40028d78: 93407c42 sxtw x2, w2
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
40028d7c: 52801207 mov w7, #0x90 // #144
handle->dirty = false;
40028d80: 91008263 add x3, x19, #0x20
40028d84: f9401ec6 ldr x6, [x22, #56]
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
40028d88: 52800000 mov w0, #0x0 // #0
gino = gino % fs->group_inodes;
40028d8c: 9ac10845 udiv x5, x2, x1
40028d90: 9b0188a1 msub x1, x5, x1, x2
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
40028d94: 9b277ca5 smull x5, w5, w7
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
40028d98: 93407c21 sxtw x1, w1
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
40028d9c: b86568c5 ldr w5, [x6, x5]
handle->offset = gino % fs->inodes_per_block;
40028da0: 9ac40822 udiv x2, x1, x4
handle->ino = ino;
40028da4: b9001274 str w20, [x19, #16]
handle->node = NULL;
40028da8: f9000e7f str xzr, [x19, #24]
40028dac: 3900827f strb wzr, [x19, #32]
handle->loads = 0;
40028db0: b9003a7f str wzr, [x19, #56]
handle->offset = gino % fs->inodes_per_block;
40028db4: 9b048441 msub x1, x2, x4, x1
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
40028db8: 11000842 add w2, w2, #0x2
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
40028dbc: 0b0200a2 add w2, w5, w2
handle->offset = gino % fs->inodes_per_block;
40028dc0: 29060662 stp w2, w1, [x19, #48]
handle->bnum = 0;
40028dc4: b900047f str wzr, [x3, #4]
handle->buffer = NULL;
40028dc8: f900047f str xzr, [x3, #8]
if ((rc == 0) && load)
40028dcc: 350001f5 cbnz w21, 40028e08 <rtems_rfs_inode_open+0xd8> <== ALWAYS TAKEN
}
40028dd0: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40028dd4: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
40028dd8: a8c37bfd ldp x29, x30, [sp], #48 <== NOT EXECUTED
40028ddc: d65f03c0 ret <== NOT EXECUTED
printf ("rtems-rfs: inode-open: ino: %" PRIu32 "\n", ino);
40028de0: b0000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40028de4: 2a1403e1 mov w1, w20 <== NOT EXECUTED
40028de8: 91262000 add x0, x0, #0x988 <== NOT EXECUTED
40028dec: 97ffe589 bl 40022410 <__wrap_printf> <== NOT EXECUTED
if (ino == RTEMS_RFS_EMPTY_INO)
40028df0: 35fffbb4 cbnz w20, 40028d64 <rtems_rfs_inode_open+0x34> <== NOT EXECUTED
return EINVAL;
40028df4: 528002c0 mov w0, #0x16 // #22 <== NOT EXECUTED
}
40028df8: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40028dfc: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
40028e00: a8c37bfd ldp x29, x30, [sp], #48 <== NOT EXECUTED
40028e04: d65f03c0 ret <== NOT EXECUTED
rc = rtems_rfs_inode_load (fs, handle);
40028e08: aa1303e1 mov x1, x19
40028e0c: aa1603e0 mov x0, x22
}
40028e10: a94153f3 ldp x19, x20, [sp, #16]
40028e14: a9425bf5 ldp x21, x22, [sp, #32]
40028e18: a8c37bfd ldp x29, x30, [sp], #48
rc = rtems_rfs_inode_load (fs, handle);
40028e1c: 17ffff99 b 40028c80 <rtems_rfs_inode_load>
0000000040029100 <rtems_rfs_inode_time_stamp_now>:
int
rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,
bool atime,
bool mtime)
{
40029100: a9bd7bfd stp x29, x30, [sp, #-48]!
40029104: 910003fd mov x29, sp
40029108: a90153f3 stp x19, x20, [sp, #16]
4002910c: aa0003f3 mov x19, x0
time_t now; if (!rtems_rfs_inode_is_loaded (handle))
40029110: f9400c00 ldr x0, [x0, #24]
40029114: b40005c0 cbz x0, 400291cc <rtems_rfs_inode_time_stamp_now+0xcc> <== NEVER TAKEN
return ENXIO;
now = time (NULL);
40029118: 12001c54 and w20, w2, #0xff
4002911c: d2800000 mov x0, #0x0 // #0
40029120: f90013f5 str x21, [sp, #32]
40029124: 12001c35 and w21, w1, #0xff
40029128: 940064b8 bl 40042408 <time>
4002912c: aa0003e3 mov x3, x0
if (atime)
40029130: 350000f5 cbnz w21, 4002914c <rtems_rfs_inode_time_stamp_now+0x4c> <== ALWAYS TAKEN
rtems_rfs_inode_set_atime (handle, now);
if (mtime)
rtems_rfs_inode_set_mtime (handle, now);
return 0;
40029134: 52800000 mov w0, #0x0 // #0 <== NOT EXECUTED
if (mtime)
40029138: 35000294 cbnz w20, 40029188 <rtems_rfs_inode_time_stamp_now+0x88> <== NOT EXECUTED
}
4002913c: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40029140: f94013f5 ldr x21, [sp, #32] <== NOT EXECUTED
40029144: a8c37bfd ldp x29, x30, [sp], #48 <== NOT EXECUTED
40029148: d65f03c0 ret <== NOT EXECUTED
rtems_rfs_write_u32 (&handle->node->atime, atime);
4002914c: f9400e65 ldr x5, [x19, #24]
40029150: 53187c02 lsr w2, w0, #24
40029154: 53107c01 lsr w1, w0, #16
40029158: 53087c00 lsr w0, w0, #8
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4002915c: 52800024 mov w4, #0x1 // #1
rtems_rfs_write_u32 (&handle->node->atime, atime);
40029160: 390040a2 strb w2, [x5, #16]
40029164: f9400e62 ldr x2, [x19, #24]
40029168: 39004441 strb w1, [x2, #17]
4002916c: f9400e61 ldr x1, [x19, #24]
40029170: 39004820 strb w0, [x1, #18]
40029174: f9400e60 ldr x0, [x19, #24]
40029178: 39004c03 strb w3, [x0, #19]
return 0;
4002917c: 52800000 mov w0, #0x0 // #0
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40029180: 39008264 strb w4, [x19, #32]
if (mtime)
40029184: 34fffdd4 cbz w20, 4002913c <rtems_rfs_inode_time_stamp_now+0x3c> <== NEVER TAKEN
rtems_rfs_write_u32 (&handle->node->mtime, mtime);
40029188: f9400e62 ldr x2, [x19, #24]
4002918c: 53187c66 lsr w6, w3, #24
40029190: 53107c65 lsr w5, w3, #16
40029194: 53087c64 lsr w4, w3, #8
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40029198: 52800021 mov w1, #0x1 // #1
rtems_rfs_write_u32 (&handle->node->mtime, mtime);
4002919c: 39005046 strb w6, [x2, #20]
400291a0: f9400e62 ldr x2, [x19, #24]
400291a4: 39005445 strb w5, [x2, #21]
400291a8: f9400e62 ldr x2, [x19, #24]
400291ac: 39005844 strb w4, [x2, #22]
400291b0: f9400e62 ldr x2, [x19, #24]
400291b4: 39005c43 strb w3, [x2, #23]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
400291b8: 39008261 strb w1, [x19, #32]
}
400291bc: a94153f3 ldp x19, x20, [sp, #16]
}
400291c0: f94013f5 ldr x21, [sp, #32]
400291c4: a8c37bfd ldp x29, x30, [sp], #48
400291c8: d65f03c0 ret
return ENXIO;
400291cc: 528000c0 mov w0, #0x6 // #6 <== NOT EXECUTED
}
400291d0: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
400291d4: a8c37bfd ldp x29, x30, [sp], #48 <== NOT EXECUTED
400291d8: d65f03c0 ret <== NOT EXECUTED
400291dc: 00000000 udf #0
0000000040028e20 <rtems_rfs_inode_unload>:
int
rtems_rfs_inode_unload (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle,
bool update_ctime)
{
40028e20: a9bd7bfd stp x29, x30, [sp, #-48]!
40028e24: 910003fd mov x29, sp
40028e28: a90153f3 stp x19, x20, [sp, #16]
40028e2c: aa0003f4 mov x20, x0
40028e30: aa0103f3 mov x19, x1
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD))
40028e34: d2a00400 mov x0, #0x200000 // #2097152
{
40028e38: f90013f5 str x21, [sp, #32]
40028e3c: 12001c55 and w21, w2, #0xff
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD))
40028e40: 94000704 bl 4002aa50 <rtems_rfs_trace>
40028e44: 72001c1f tst w0, #0xff
40028e48: 540001a0 b.eq 40028e7c <rtems_rfs_inode_unload+0x5c> // b.none <== ALWAYS TAKEN
printf ("rtems-rfs: inode-unload: ino=%" PRIu32 " loads=%i loaded=%s\n",
40028e4c: f9400e63 ldr x3, [x19, #24] <== NOT EXECUTED
40028e50: b0000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40028e54: 91252000 add x0, x0, #0x948 <== NOT EXECUTED
40028e58: b9401261 ldr w1, [x19, #16] <== NOT EXECUTED
40028e5c: b9403a62 ldr w2, [x19, #56] <== NOT EXECUTED
40028e60: f100007f cmp x3, #0x0 <== NOT EXECUTED
40028e64: b0000103 adrp x3, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40028e68: 91250063 add x3, x3, #0x940 <== NOT EXECUTED
40028e6c: 9a801063 csel x3, x3, x0, ne // ne = any <== NOT EXECUTED
40028e70: b0000100 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
40028e74: 9126a000 add x0, x0, #0x9a8 <== NOT EXECUTED
40028e78: 97ffe566 bl 40022410 <__wrap_printf> <== NOT EXECUTED
handle->ino, handle->loads,
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
40028e7c: f9400e60 ldr x0, [x19, #24]
40028e80: b4000240 cbz x0, 40028ec8 <rtems_rfs_inode_unload+0xa8>
{
if (handle->loads == 0)
40028e84: b9403a61 ldr w1, [x19, #56]
return EIO;
40028e88: 528000a0 mov w0, #0x5 // #5
if (handle->loads == 0)
40028e8c: 34000201 cbz w1, 40028ecc <rtems_rfs_inode_unload+0xac> <== NEVER TAKEN
handle->loads--;
40028e90: 51000421 sub w1, w1, #0x1
40028e94: b9003a61 str w1, [x19, #56]
if (handle->loads == 0)
40028e98: 35000181 cbnz w1, 40028ec8 <rtems_rfs_inode_unload+0xa8>
{
/*
* If the buffer is dirty it will be release. Also set the ctime.
*/
if (rtems_rfs_buffer_dirty (&handle->buffer) && update_ctime)
40028e9c: 39408260 ldrb w0, [x19, #32]
40028ea0: 6a0002bf tst w21, w0
40028ea4: 540001c1 b.ne 40028edc <rtems_rfs_inode_unload+0xbc> // b.any
rtems_rfs_inode_set_ctime (handle, time (NULL));
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
40028ea8: 91008261 add x1, x19, #0x20
40028eac: aa1403e0 mov x0, x20
40028eb0: 97fff8f8 bl 40027290 <rtems_rfs_buffer_handle_release>
handle->node = NULL;
40028eb4: f9000e7f str xzr, [x19, #24]
}
}
return rc;
}
40028eb8: a94153f3 ldp x19, x20, [sp, #16]
40028ebc: f94013f5 ldr x21, [sp, #32]
40028ec0: a8c37bfd ldp x29, x30, [sp], #48
40028ec4: d65f03c0 ret
int rc = 0;
40028ec8: 52800000 mov w0, #0x0 // #0
}
40028ecc: a94153f3 ldp x19, x20, [sp, #16]
40028ed0: f94013f5 ldr x21, [sp, #32]
40028ed4: a8c37bfd ldp x29, x30, [sp], #48
40028ed8: d65f03c0 ret
rtems_rfs_inode_set_ctime (handle, time (NULL));
40028edc: d2800000 mov x0, #0x0 // #0
40028ee0: 9400654a bl 40042408 <time>
*/
static inline void
rtems_rfs_inode_set_ctime (rtems_rfs_inode_handle* handle,
rtems_rfs_time ctime)
{
rtems_rfs_write_u32 (&handle->node->ctime, ctime);
40028ee4: f9400e62 ldr x2, [x19, #24]
40028ee8: 53187c03 lsr w3, w0, #24
40028eec: 53107c04 lsr w4, w0, #16
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40028ef0: 52800021 mov w1, #0x1 // #1
rtems_rfs_write_u32 (&handle->node->ctime, ctime);
40028ef4: 39006043 strb w3, [x2, #24]
40028ef8: 53087c03 lsr w3, w0, #8
40028efc: f9400e62 ldr x2, [x19, #24]
40028f00: 39006444 strb w4, [x2, #25]
40028f04: f9400e62 ldr x2, [x19, #24]
40028f08: 39006843 strb w3, [x2, #26]
40028f0c: f9400e62 ldr x2, [x19, #24]
40028f10: 39006c40 strb w0, [x2, #27]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40028f14: 39008261 strb w1, [x19, #32]
}
40028f18: 17ffffe4 b 40028ea8 <rtems_rfs_inode_unload+0x88>
40028f1c: 00000000 udf #0
00000000400376c0 <rtems_rfs_link>:
const char* name,
int length,
rtems_rfs_ino parent,
rtems_rfs_ino target,
bool link_dir)
{
400376c0: a9b37bfd stp x29, x30, [sp, #-208]! <== NOT EXECUTED
400376c4: 910003fd mov x29, sp <== NOT EXECUTED
400376c8: a90153f3 stp x19, x20, [sp, #16] <== NOT EXECUTED
400376cc: aa0003f4 mov x20, x0 <== NOT EXECUTED
rtems_rfs_inode_handle parent_inode;
rtems_rfs_inode_handle target_inode;
uint16_t links;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_LINK))
400376d0: d2a02000 mov x0, #0x1000000 // #16777216 <== NOT EXECUTED
{
400376d4: a9025bf5 stp x21, x22, [sp, #32] <== NOT EXECUTED
400376d8: 2a0403f5 mov w21, w4 <== NOT EXECUTED
400376dc: a90363f7 stp x23, x24, [sp, #48] <== NOT EXECUTED
400376e0: aa0103f8 mov x24, x1 <== NOT EXECUTED
400376e4: 2a0203f7 mov w23, w2 <== NOT EXECUTED
400376e8: a9046bf9 stp x25, x26, [sp, #64] <== NOT EXECUTED
400376ec: 2a0303f9 mov w25, w3 <== NOT EXECUTED
400376f0: 12001cba and w26, w5, #0xff <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_LINK))
400376f4: 97ffccd7 bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
400376f8: 72001c1f tst w0, #0xff <== NOT EXECUTED
400376fc: 54000a81 b.ne 4003784c <rtems_rfs_link+0x18c> // b.any <== NOT EXECUTED
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf ("(%" PRIu32 ")\n", target);
}
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
40037700: 910243e2 add x2, sp, #0x90 <== NOT EXECUTED
40037704: 2a1503e1 mov w1, w21 <== NOT EXECUTED
40037708: aa1403e0 mov x0, x20 <== NOT EXECUTED
4003770c: 52800023 mov w3, #0x1 // #1 <== NOT EXECUTED
40037710: 97ffc588 bl 40028d30 <rtems_rfs_inode_open> <== NOT EXECUTED
40037714: 2a0003f3 mov w19, w0 <== NOT EXECUTED
if (rc)
40037718: 35000760 cbnz w0, 40037804 <rtems_rfs_link+0x144> <== NOT EXECUTED
/*
* If the target inode is a directory and we cannot link directories
* return a not supported error code.
*/
if (!link_dir && S_ISDIR (rtems_rfs_inode_get_mode (&target_inode)))
4003771c: 3500013a cbnz w26, 40037740 <rtems_rfs_link+0x80> <== NOT EXECUTED
40037720: f94057e1 ldr x1, [sp, #168] <== NOT EXECUTED
40037724: 39400822 ldrb w2, [x1, #2] <== NOT EXECUTED
40037728: 39400c20 ldrb w0, [x1, #3] <== NOT EXECUTED
4003772c: aa002040 orr x0, x2, x0, lsl #8 <== NOT EXECUTED
40037730: 5ac00400 rev16 w0, w0 <== NOT EXECUTED
40037734: 12140c00 and w0, w0, #0xf000 <== NOT EXECUTED
40037738: 7140101f cmp w0, #0x4, lsl #12 <== NOT EXECUTED
4003773c: 54000d00 b.eq 400378dc <rtems_rfs_link+0x21c> // b.none <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &target_inode);
return ENOTSUP;
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
40037740: 2a1903e1 mov w1, w25 <== NOT EXECUTED
40037744: 910143e2 add x2, sp, #0x50 <== NOT EXECUTED
40037748: aa1403e0 mov x0, x20 <== NOT EXECUTED
4003774c: 52800023 mov w3, #0x1 // #1 <== NOT EXECUTED
40037750: 97ffc578 bl 40028d30 <rtems_rfs_inode_open> <== NOT EXECUTED
40037754: 2a0003f3 mov w19, w0 <== NOT EXECUTED
if (rc)
40037758: 35000660 cbnz w0, 40037824 <rtems_rfs_link+0x164> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, target);
4003775c: 2a1503e4 mov w4, w21 <== NOT EXECUTED
40037760: 93407ee3 sxtw x3, w23 <== NOT EXECUTED
40037764: aa1803e2 mov x2, x24 <== NOT EXECUTED
40037768: 910143e1 add x1, sp, #0x50 <== NOT EXECUTED
4003776c: aa1403e0 mov x0, x20 <== NOT EXECUTED
40037770: 97fff5fc bl 40034f60 <rtems_rfs_dir_add_entry> <== NOT EXECUTED
40037774: 2a0003f3 mov w19, w0 <== NOT EXECUTED
if (rc > 0)
40037778: 7100001f cmp w0, #0x0 <== NOT EXECUTED
4003777c: 5400090c b.gt 4003789c <rtems_rfs_link+0x1dc> <== NOT EXECUTED
links = rtems_rfs_read_u16 (&handle->node->links);
40037780: f94057e1 ldr x1, [sp, #168] <== NOT EXECUTED
if (links == 0xffff)
40037784: 529fffe2 mov w2, #0xffff // #65535 <== NOT EXECUTED
40037788: 39400023 ldrb w3, [x1] <== NOT EXECUTED
4003778c: 39400420 ldrb w0, [x1, #1] <== NOT EXECUTED
40037790: aa002060 orr x0, x3, x0, lsl #8 <== NOT EXECUTED
40037794: 5ac00400 rev16 w0, w0 <== NOT EXECUTED
40037798: 12003c00 and w0, w0, #0xffff <== NOT EXECUTED
4003779c: 6b02001f cmp w0, w2 <== NOT EXECUTED
400377a0: 54000980 b.eq 400378d0 <rtems_rfs_link+0x210> // b.none <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
links = rtems_rfs_inode_get_links (&target_inode) + 1;
400377a4: 11000400 add w0, w0, #0x1 <== NOT EXECUTED
rtems_rfs_write_u16 (&handle->node->links, links);
400377a8: 12001c04 and w4, w0, #0xff <== NOT EXECUTED
400377ac: d3483c00 ubfx x0, x0, #8, #8 <== NOT EXECUTED
400377b0: 39000020 strb w0, [x1] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
400377b4: 52800022 mov w2, #0x1 // #1 <== NOT EXECUTED
rtems_rfs_inode_set_links (&target_inode, links);
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
400377b8: 910143e0 add x0, sp, #0x50 <== NOT EXECUTED
400377bc: 2a0203e1 mov w1, w2 <== NOT EXECUTED
rtems_rfs_write_u16 (&handle->node->links, links);
400377c0: f94057e3 ldr x3, [sp, #168] <== NOT EXECUTED
400377c4: 39000464 strb w4, [x3, #1] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
400377c8: 3902c3e2 strb w2, [sp, #176] <== NOT EXECUTED
400377cc: 97ffc64d bl 40029100 <rtems_rfs_inode_time_stamp_now> <== NOT EXECUTED
400377d0: 2a0003f3 mov w19, w0 <== NOT EXECUTED
if (rc > 0)
{
rtems_rfs_inode_close (fs, &parent_inode);
400377d4: 910143e1 add x1, sp, #0x50 <== NOT EXECUTED
400377d8: aa1403e0 mov x0, x20 <== NOT EXECUTED
if (rc > 0)
400377dc: 7100027f cmp w19, #0x0 <== NOT EXECUTED
400377e0: 5400020c b.gt 40037820 <rtems_rfs_link+0x160> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &parent_inode);
400377e4: 97ffc5cf bl 40028f20 <rtems_rfs_inode_close> <== NOT EXECUTED
400377e8: 2a0003f3 mov w19, w0 <== NOT EXECUTED
if (rc > 0)
{
rtems_rfs_inode_close (fs, &target_inode);
400377ec: 910243e1 add x1, sp, #0x90 <== NOT EXECUTED
400377f0: aa1403e0 mov x0, x20 <== NOT EXECUTED
if (rc > 0)
400377f4: 7100027f cmp w19, #0x0 <== NOT EXECUTED
400377f8: 540001ac b.gt 4003782c <rtems_rfs_link+0x16c> <== NOT EXECUTED
return rc;
}
rc = rtems_rfs_inode_close (fs, &target_inode);
400377fc: 97ffc5c9 bl 40028f20 <rtems_rfs_inode_close> <== NOT EXECUTED
40037800: 2a0003f3 mov w19, w0 <== NOT EXECUTED
return rc;
}
40037804: 2a1303e0 mov w0, w19 <== NOT EXECUTED
40037808: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
4003780c: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
40037810: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
40037814: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
40037818: a8cd7bfd ldp x29, x30, [sp], #208 <== NOT EXECUTED
4003781c: d65f03c0 ret <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
40037820: 97ffc5c0 bl 40028f20 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
40037824: 910243e1 add x1, sp, #0x90 <== NOT EXECUTED
40037828: aa1403e0 mov x0, x20 <== NOT EXECUTED
4003782c: 97ffc5bd bl 40028f20 <rtems_rfs_inode_close> <== NOT EXECUTED
}
40037830: 2a1303e0 mov w0, w19 <== NOT EXECUTED
40037834: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40037838: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
4003783c: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
40037840: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
40037844: a8cd7bfd ldp x29, x30, [sp], #208 <== NOT EXECUTED
40037848: d65f03c0 ret <== NOT EXECUTED
printf ("rtems-rfs: link: parent(%" PRIu32 ") -> ", parent);
4003784c: 2a1903e1 mov w1, w25 <== NOT EXECUTED
40037850: 900000a0 adrp x0, 4004b000 <IMFS_LIMITS_AND_OPTIONS+0xbb8> <== NOT EXECUTED
40037854: 910d2000 add x0, x0, #0x348 <== NOT EXECUTED
40037858: 97ffaaee bl 40022410 <__wrap_printf> <== NOT EXECUTED
for (c = 0; c < length; c++)
4003785c: 710002ff cmp w23, #0x0 <== NOT EXECUTED
40037860: 5400014d b.le 40037888 <rtems_rfs_link+0x1c8> <== NOT EXECUTED
40037864: 510006f6 sub w22, w23, #0x1 <== NOT EXECUTED
40037868: 91000700 add x0, x24, #0x1 <== NOT EXECUTED
4003786c: 8b0002d6 add x22, x22, x0 <== NOT EXECUTED
40037870: aa1803f3 mov x19, x24 <== NOT EXECUTED
40037874: d503201f nop <== NOT EXECUTED
printf ("%c", name[c]);
40037878: 38401660 ldrb w0, [x19], #1 <== NOT EXECUTED
4003787c: 940019e1 bl 4003e000 <putchar> <== NOT EXECUTED
for (c = 0; c < length; c++)
40037880: eb16027f cmp x19, x22 <== NOT EXECUTED
40037884: 54ffffa1 b.ne 40037878 <rtems_rfs_link+0x1b8> // b.any <== NOT EXECUTED
printf ("(%" PRIu32 ")\n", target);
40037888: 2a1503e1 mov w1, w21 <== NOT EXECUTED
4003788c: 900000a0 adrp x0, 4004b000 <IMFS_LIMITS_AND_OPTIONS+0xbb8> <== NOT EXECUTED
40037890: 910da000 add x0, x0, #0x368 <== NOT EXECUTED
40037894: 97ffaadf bl 40022410 <__wrap_printf> <== NOT EXECUTED
40037898: 17ffff9a b 40037700 <rtems_rfs_link+0x40> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
4003789c: 910143e1 add x1, sp, #0x50 <== NOT EXECUTED
400378a0: aa1403e0 mov x0, x20 <== NOT EXECUTED
400378a4: 97ffc59f bl 40028f20 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
400378a8: 910243e1 add x1, sp, #0x90 <== NOT EXECUTED
400378ac: aa1403e0 mov x0, x20 <== NOT EXECUTED
400378b0: 97ffc59c bl 40028f20 <rtems_rfs_inode_close> <== NOT EXECUTED
}
400378b4: 2a1303e0 mov w0, w19 <== NOT EXECUTED
400378b8: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
400378bc: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
400378c0: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
400378c4: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
400378c8: a8cd7bfd ldp x29, x30, [sp], #208 <== NOT EXECUTED
400378cc: d65f03c0 ret <== NOT EXECUTED
400378d0: 52800024 mov w4, #0x1 // #1 <== NOT EXECUTED
400378d4: 52800000 mov w0, #0x0 // #0 <== NOT EXECUTED
400378d8: 17ffffb6 b 400377b0 <rtems_rfs_link+0xf0> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
400378dc: 910243e1 add x1, sp, #0x90 <== NOT EXECUTED
400378e0: aa1403e0 mov x0, x20 <== NOT EXECUTED
return ENOTSUP;
400378e4: 528010d3 mov w19, #0x86 // #134 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
400378e8: 97ffc58e bl 40028f20 <rtems_rfs_inode_close> <== NOT EXECUTED
return ENOTSUP;
400378ec: 17ffffc6 b 40037804 <rtems_rfs_link+0x144> <== NOT EXECUTED
000000004002a4a0 <rtems_rfs_rtems_fdatasync>:
{
4002a4a0: a9be7bfd stp x29, x30, [sp, #-32]! <== NOT EXECUTED
4002a4a4: 910003fd mov x29, sp <== NOT EXECUTED
rc = rtems_rfs_buffer_sync (rtems_rfs_rtems_pathloc_dev (&iop->pathinfo));
4002a4a8: f9401c00 ldr x0, [x0, #56] <== NOT EXECUTED
4002a4ac: f9400800 ldr x0, [x0, #16] <== NOT EXECUTED
{
4002a4b0: f9000bf3 str x19, [sp, #16] <== NOT EXECUTED
rc = rtems_rfs_buffer_sync (rtems_rfs_rtems_pathloc_dev (&iop->pathinfo));
4002a4b4: 97fff3eb bl 40027460 <rtems_rfs_buffer_sync> <== NOT EXECUTED
4002a4b8: 2a0003f3 mov w19, w0 <== NOT EXECUTED
if (rc)
4002a4bc: 350000a0 cbnz w0, 4002a4d0 <rtems_rfs_rtems_fdatasync+0x30> <== NOT EXECUTED
}
4002a4c0: 2a1303e0 mov w0, w19 <== NOT EXECUTED
4002a4c4: f9400bf3 ldr x19, [sp, #16] <== NOT EXECUTED
4002a4c8: a8c27bfd ldp x29, x30, [sp], #32 <== NOT EXECUTED
4002a4cc: d65f03c0 ret <== NOT EXECUTED
return rtems_rfs_rtems_error ("fdatasync: sync", rc);
4002a4d0: 94004cef bl 4003d88c <__errno> <== NOT EXECUTED
4002a4d4: b9000013 str w19, [x0] <== NOT EXECUTED
4002a4d8: 12800013 mov w19, #0xffffffff // #-1 <== NOT EXECUTED
4002a4dc: 17fffff9 b 4002a4c0 <rtems_rfs_rtems_fdatasync+0x20> <== NOT EXECUTED
0000000040029f80 <rtems_rfs_rtems_fstat>:
{
40029f80: a9b97bfd stp x29, x30, [sp, #-112]!
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
40029f84: 52800023 mov w3, #0x1 // #1
{
40029f88: 910003fd mov x29, sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
40029f8c: f9401404 ldr x4, [x0, #40]
{
40029f90: a90153f3 stp x19, x20, [sp, #16]
40029f94: aa0103f3 mov x19, x1
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
40029f98: b9401001 ldr w1, [x0, #16]
40029f9c: 9100c3e2 add x2, sp, #0x30
{
40029fa0: f90013f5 str x21, [sp, #32]
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
40029fa4: f9400895 ldr x21, [x4, #16]
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
40029fa8: aa1503e0 mov x0, x21
40029fac: 97fffb61 bl 40028d30 <rtems_rfs_inode_open>
40029fb0: 2a0003f4 mov w20, w0
if (rc)
40029fb4: 35001340 cbnz w0, 4002a21c <rtems_rfs_rtems_fstat+0x29c> <== NEVER TAKEN
return rtems_rfs_read_u16 (&handle->node->mode);
40029fb8: f94027e2 ldr x2, [sp, #72]
if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK (mode))
40029fbc: 1289ffe3 mov w3, #0xffffb000 // #-20480
40029fc0: 39400840 ldrb w0, [x2, #2]
40029fc4: 39400c41 ldrb w1, [x2, #3]
40029fc8: aa012001 orr x1, x0, x1, lsl #8
40029fcc: 5ac00421 rev16 w1, w1
40029fd0: 12003c20 and w0, w1, #0xffff
40029fd4: 0a030001 and w1, w0, w3
40029fd8: 7140083f cmp w1, #0x2, lsl #12
40029fdc: 540007a0 b.eq 4002a0d0 <rtems_rfs_rtems_fstat+0x150> // b.none <== NEVER TAKEN
buf->st_ino = rtems_rfs_inode_ino (&inode);
40029fe0: b94043e1 ldr w1, [sp, #64]
buf->st_dev = (dev_t) (uintptr_t)rtems_rfs_fs_device (fs);
40029fe4: f94012a2 ldr x2, [x21, #32]
buf->st_ino = rtems_rfs_inode_ino (&inode);
40029fe8: a9000662 stp x2, x1, [x19]
buf->st_mode = rtems_rfs_rtems_mode (mode);
40029fec: 94000295 bl 4002aa40 <rtems_rfs_rtems_mode>
40029ff0: b9001260 str w0, [x19, #16]
links = rtems_rfs_read_u16 (&handle->node->links);
40029ff4: f94027e3 ldr x3, [sp, #72]
if (links == 0xffff)
40029ff8: 529fffe4 mov w4, #0xffff // #65535
shared = rtems_rfs_file_get_shared (fs, rtems_rfs_inode_ino (&inode));
40029ffc: b94043e1 ldr w1, [sp, #64]
4002a000: aa1503e0 mov x0, x21
4002a004: 39400065 ldrb w5, [x3]
4002a008: 39400462 ldrb w2, [x3, #1]
4002a00c: aa0220a2 orr x2, x5, x2, lsl #8
4002a010: 5ac00442 rev16 w2, w2
4002a014: 12003c42 and w2, w2, #0xffff
links = 0;
4002a018: 6b04005f cmp w2, w4
4002a01c: 1a9f1042 csel w2, w2, wzr, ne // ne = any
buf->st_nlink = rtems_rfs_inode_get_links (&inode);
4002a020: 79002a62 strh w2, [x19, #20]
buf->st_uid = rtems_rfs_inode_get_uid (&inode);
4002a024: 39401864 ldrb w4, [x3, #6]
4002a028: 39401c62 ldrb w2, [x3, #7]
4002a02c: aa022082 orr x2, x4, x2, lsl #8
4002a030: 5ac00442 rev16 w2, w2
4002a034: 79002e62 strh w2, [x19, #22]
return (rtems_rfs_read_u32 (&handle->node->owner) >> 16) & 0xffff;
4002a038: 39401066 ldrb w6, [x3, #4]
4002a03c: 39401465 ldrb w5, [x3, #5]
4002a040: 39401864 ldrb w4, [x3, #6]
4002a044: 39401c62 ldrb w2, [x3, #7]
4002a048: aa0520c3 orr x3, x6, x5, lsl #8
4002a04c: aa044063 orr x3, x3, x4, lsl #16
4002a050: aa026062 orr x2, x3, x2, lsl #24
4002a054: 5ac00842 rev w2, w2
4002a058: 53107c42 lsr w2, w2, #16
4002a05c: 79003262 strh w2, [x19, #24]
shared = rtems_rfs_file_get_shared (fs, rtems_rfs_inode_ino (&inode));
4002a060: 94003378 bl 40036e40 <rtems_rfs_file_get_shared>
if (shared)
4002a064: b40006a0 cbz x0, 4002a138 <rtems_rfs_rtems_fstat+0x1b8>
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
4002a068: b940b802 ldr w2, [x0, #184]
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
4002a06c: 29581005 ldp w5, w4, [x0, #192]
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
4002a070: b940c803 ldr w3, [x0, #200]
if (S_ISLNK (buf->st_mode))
4002a074: b9401261 ldr w1, [x19, #16]
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
4002a078: f9001a65 str x5, [x19, #48]
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
4002a07c: f9002264 str x4, [x19, #64]
if (S_ISLNK (buf->st_mode))
4002a080: 12140c21 and w1, w1, #0xf000
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
4002a084: f9002a63 str x3, [x19, #80]
if (S_ISLNK (buf->st_mode))
4002a088: 7140283f cmp w1, #0xa, lsl #12
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
4002a08c: b9006662 str w2, [x19, #100]
if (S_ISLNK (buf->st_mode))
4002a090: 540004a1 b.ne 4002a124 <rtems_rfs_rtems_fstat+0x1a4> // b.any <== ALWAYS TAKEN
buf->st_size = rtems_rfs_file_shared_get_block_offset (shared);
4002a094: 79417800 ldrh w0, [x0, #188] <== NOT EXECUTED
4002a098: f9001660 str x0, [x19, #40] <== NOT EXECUTED
buf->st_blksize = rtems_rfs_fs_block_size (fs);
4002a09c: f9400aa0 ldr x0, [x21, #16]
4002a0a0: b9006260 str w0, [x19, #96]
rc = rtems_rfs_inode_close (fs, &inode);
4002a0a4: 9100c3e1 add x1, sp, #0x30
4002a0a8: aa1503e0 mov x0, x21
4002a0ac: 97fffb9d bl 40028f20 <rtems_rfs_inode_close>
4002a0b0: 2a0003f3 mov w19, w0
if (rc > 0)
4002a0b4: 7100001f cmp w0, #0x0
4002a0b8: 54000aac b.gt 4002a20c <rtems_rfs_rtems_fstat+0x28c> <== NEVER TAKEN
}
4002a0bc: 2a1403e0 mov w0, w20
4002a0c0: a94153f3 ldp x19, x20, [sp, #16]
4002a0c4: f94013f5 ldr x21, [sp, #32]
4002a0c8: a8c77bfd ldp x29, x30, [sp], #112
4002a0cc: d65f03c0 ret
return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);
4002a0d0: 39407041 ldrb w1, [x2, #28] <== NOT EXECUTED
temp.__overlay.major = _major;
4002a0d4: d2800004 mov x4, #0x0 // #0 <== NOT EXECUTED
4002a0d8: 39407445 ldrb w5, [x2, #29] <== NOT EXECUTED
4002a0dc: 39407847 ldrb w7, [x2, #30] <== NOT EXECUTED
4002a0e0: 39407c43 ldrb w3, [x2, #31] <== NOT EXECUTED
4002a0e4: 39408048 ldrb w8, [x2, #32] <== NOT EXECUTED
4002a0e8: aa052025 orr x5, x1, x5, lsl #8 <== NOT EXECUTED
4002a0ec: 39408446 ldrb w6, [x2, #33] <== NOT EXECUTED
4002a0f0: aa0740a7 orr x7, x5, x7, lsl #16 <== NOT EXECUTED
4002a0f4: 39408845 ldrb w5, [x2, #34] <== NOT EXECUTED
4002a0f8: aa0360e3 orr x3, x7, x3, lsl #24 <== NOT EXECUTED
4002a0fc: 39408c41 ldrb w1, [x2, #35] <== NOT EXECUTED
4002a100: 5ac00862 rev w2, w3 <== NOT EXECUTED
4002a104: aa062103 orr x3, x8, x6, lsl #8 <== NOT EXECUTED
4002a108: aa054063 orr x3, x3, x5, lsl #16 <== NOT EXECUTED
4002a10c: b3407c44 bfxil x4, x2, #0, #32 <== NOT EXECUTED
4002a110: aa016061 orr x1, x3, x1, lsl #24 <== NOT EXECUTED
4002a114: 5ac00821 rev w1, w1 <== NOT EXECUTED
temp.__overlay.minor = _minor;
4002a118: b3607c24 bfi x4, x1, #32, #32 <== NOT EXECUTED
buf->st_rdev =
4002a11c: f9001264 str x4, [x19, #32] <== NOT EXECUTED
4002a120: 17ffffb0 b 40029fe0 <rtems_rfs_rtems_fstat+0x60> <== NOT EXECUTED
*/
static inline rtems_rfs_pos
rtems_rfs_file_shared_get_size (rtems_rfs_file_system* fs,
rtems_rfs_file_shared* shared)
{
return rtems_rfs_block_get_size (fs, &shared->size);
4002a124: 9102e001 add x1, x0, #0xb8
4002a128: aa1503e0 mov x0, x21
4002a12c: 940026e9 bl 40033cd0 <rtems_rfs_block_get_size>
buf->st_size = rtems_rfs_file_shared_get_size (fs, shared);
4002a130: f9001660 str x0, [x19, #40]
4002a134: 17ffffda b 4002a09c <rtems_rfs_rtems_fstat+0x11c>
buf->st_atime = rtems_rfs_inode_get_atime (&inode);
4002a138: f94027e0 ldr x0, [sp, #72]
if (S_ISLNK (buf->st_mode))
4002a13c: b9401264 ldr w4, [x19, #16]
4002a140: 39404005 ldrb w5, [x0, #16]
4002a144: 12140c84 and w4, w4, #0xf000
4002a148: 39404403 ldrb w3, [x0, #17]
4002a14c: 7140289f cmp w4, #0xa, lsl #12
4002a150: 39404802 ldrb w2, [x0, #18]
4002a154: 39404c01 ldrb w1, [x0, #19]
4002a158: aa0320a3 orr x3, x5, x3, lsl #8
4002a15c: aa024062 orr x2, x3, x2, lsl #16
4002a160: aa016041 orr x1, x2, x1, lsl #24
buf->st_atime = rtems_rfs_inode_get_atime (&inode);
4002a164: 5ac00821 rev w1, w1
4002a168: f9001a61 str x1, [x19, #48]
return rtems_rfs_read_u32 (&handle->node->mtime);
4002a16c: 39405004 ldrb w4, [x0, #20]
4002a170: 39405403 ldrb w3, [x0, #21]
4002a174: 39405802 ldrb w2, [x0, #22]
4002a178: 39405c01 ldrb w1, [x0, #23]
4002a17c: aa032083 orr x3, x4, x3, lsl #8
4002a180: aa024062 orr x2, x3, x2, lsl #16
4002a184: aa016041 orr x1, x2, x1, lsl #24
buf->st_mtime = rtems_rfs_inode_get_mtime (&inode);
4002a188: 5ac00821 rev w1, w1
4002a18c: f9002261 str x1, [x19, #64]
return rtems_rfs_read_u32 (&handle->node->ctime);
4002a190: 39406004 ldrb w4, [x0, #24]
4002a194: 39406403 ldrb w3, [x0, #25]
4002a198: 39406802 ldrb w2, [x0, #26]
4002a19c: 39406c01 ldrb w1, [x0, #27]
4002a1a0: aa032083 orr x3, x4, x3, lsl #8
4002a1a4: aa024062 orr x2, x3, x2, lsl #16
4002a1a8: aa016041 orr x1, x2, x1, lsl #24
buf->st_ctime = rtems_rfs_inode_get_ctime (&inode);
4002a1ac: 5ac00821 rev w1, w1
4002a1b0: f9002a61 str x1, [x19, #80]
return rtems_rfs_read_u32 (&handle->node->block_count);
4002a1b4: 39403004 ldrb w4, [x0, #12]
4002a1b8: 39403403 ldrb w3, [x0, #13]
4002a1bc: 39403802 ldrb w2, [x0, #14]
4002a1c0: 39403c01 ldrb w1, [x0, #15]
4002a1c4: aa032083 orr x3, x4, x3, lsl #8
4002a1c8: aa024062 orr x2, x3, x2, lsl #16
4002a1cc: aa016041 orr x1, x2, x1, lsl #24
4002a1d0: 5ac00821 rev w1, w1
buf->st_blocks = rtems_rfs_inode_get_block_count (&inode);
4002a1d4: b9006661 str w1, [x19, #100]
if (S_ISLNK (buf->st_mode))
4002a1d8: 54000101 b.ne 4002a1f8 <rtems_rfs_rtems_fstat+0x278> // b.any <== ALWAYS TAKEN
buf->st_size = rtems_rfs_inode_get_block_offset (&inode);
4002a1dc: 39402801 ldrb w1, [x0, #10] <== NOT EXECUTED
4002a1e0: 39402c00 ldrb w0, [x0, #11] <== NOT EXECUTED
4002a1e4: aa002020 orr x0, x1, x0, lsl #8 <== NOT EXECUTED
4002a1e8: 5ac00400 rev16 w0, w0 <== NOT EXECUTED
4002a1ec: 92403c00 and x0, x0, #0xffff <== NOT EXECUTED
4002a1f0: f9001660 str x0, [x19, #40] <== NOT EXECUTED
4002a1f4: 17ffffaa b 4002a09c <rtems_rfs_rtems_fstat+0x11c> <== NOT EXECUTED
buf->st_size = rtems_rfs_inode_get_size (fs, &inode);
4002a1f8: 9100c3e1 add x1, sp, #0x30
4002a1fc: aa1503e0 mov x0, x21
4002a200: 97fffd30 bl 400296c0 <rtems_rfs_inode_get_size>
4002a204: f9001660 str x0, [x19, #40]
4002a208: 17ffffa5 b 4002a09c <rtems_rfs_rtems_fstat+0x11c>
return rtems_rfs_rtems_error ("stat: closing inode", rc);
4002a20c: 94004da0 bl 4003d88c <__errno> <== NOT EXECUTED
4002a210: 12800014 mov w20, #0xffffffff // #-1 <== NOT EXECUTED
4002a214: b9000013 str w19, [x0] <== NOT EXECUTED
4002a218: 17ffffa9 b 4002a0bc <rtems_rfs_rtems_fstat+0x13c> <== NOT EXECUTED
return rtems_rfs_rtems_error ("stat: opening inode", rc);
4002a21c: 94004d9c bl 4003d88c <__errno> <== NOT EXECUTED
4002a220: b9000014 str w20, [x0] <== NOT EXECUTED
4002a224: 12800014 mov w20, #0xffffffff // #-1 <== NOT EXECUTED
4002a228: 17ffffa5 b 4002a0bc <rtems_rfs_rtems_fstat+0x13c> <== NOT EXECUTED
4002a22c: 00000000 udf #0
000000004002a4e0 <rtems_rfs_rtems_initialise>:
{
4002a4e0: a9ba7bfd stp x29, x30, [sp, #-96]!
4002a4e4: 910003fd mov x29, sp
4002a4e8: a90153f3 stp x19, x20, [sp, #16]
4002a4ec: a9025bf5 stp x21, x22, [sp, #32]
4002a4f0: a90363f7 stp x23, x24, [sp, #48]
4002a4f4: a9046bf9 stp x25, x26, [sp, #64]
4002a4f8: aa0003f9 mov x25, x0
while (options)
4002a4fc: b4000ee1 cbz x1, 4002a6d8 <rtems_rfs_rtems_initialise+0x1f8> <== ALWAYS TAKEN
4002a500: f00000f6 adrp x22, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
4002a504: 912ba2d6 add x22, x22, #0xae8 <== NOT EXECUTED
4002a508: f00000f5 adrp x21, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
4002a50c: 912be2b5 add x21, x21, #0xaf8 <== NOT EXECUTED
else if (strncmp (options, "no-local-cache",
4002a510: f00000f8 adrp x24, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
4002a514: 912c2318 add x24, x24, #0xb08 <== NOT EXECUTED
else if (strncmp (options, "max-held-bufs",
4002a518: f00000fa adrp x26, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
4002a51c: 912c635a add x26, x26, #0xb18 <== NOT EXECUTED
4002a520: aa0103f3 mov x19, x1 <== NOT EXECUTED
uint32_t max_held_buffers = RTEMS_RFS_FS_MAX_HELD_BUFFERS;
4002a524: 528000b7 mov w23, #0x5 // #5 <== NOT EXECUTED
uint32_t flags = 0;
4002a528: 52800014 mov w20, #0x0 // #0 <== NOT EXECUTED
4002a52c: d503201f nop <== NOT EXECUTED
printf ("options=%s\n", options);
4002a530: aa1303e1 mov x1, x19 <== NOT EXECUTED
4002a534: aa1603e0 mov x0, x22 <== NOT EXECUTED
4002a538: 97ffdfb6 bl 40022410 <__wrap_printf> <== NOT EXECUTED
if (strncmp (options, "hold-bitmaps",
4002a53c: aa1503e1 mov x1, x21 <== NOT EXECUTED
4002a540: aa1303e0 mov x0, x19 <== NOT EXECUTED
4002a544: d2800182 mov x2, #0xc // #12 <== NOT EXECUTED
4002a548: 940051fd bl 4003ed3c <strncmp> <== NOT EXECUTED
4002a54c: 35000620 cbnz w0, 4002a610 <rtems_rfs_rtems_initialise+0x130> <== NOT EXECUTED
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
4002a550: 32000294 orr w20, w20, #0x1 <== NOT EXECUTED
options = strchr (options, ',');
4002a554: aa1303e0 mov x0, x19 <== NOT EXECUTED
4002a558: 52800581 mov w1, #0x2c // #44 <== NOT EXECUTED
4002a55c: 94004fff bl 4003e558 <strchr> <== NOT EXECUTED
if (options)
4002a560: b4000080 cbz x0, 4002a570 <rtems_rfs_rtems_initialise+0x90> <== NOT EXECUTED
++options;
4002a564: 91000413 add x19, x0, #0x1 <== NOT EXECUTED
if (*options == '\0')
4002a568: 39400400 ldrb w0, [x0, #1] <== NOT EXECUTED
4002a56c: 35fffe20 cbnz w0, 4002a530 <rtems_rfs_rtems_initialise+0x50> <== NOT EXECUTED
rtems = malloc (sizeof (rtems_rfs_rtems_private));
4002a570: d2800021 mov x1, #0x1 // #1
4002a574: d2800500 mov x0, #0x28 // #40
4002a578: 9400201a bl 400325e0 <calloc>
4002a57c: aa0003f3 mov x19, x0
if (!rtems)
4002a580: b4000bc0 cbz x0, 4002a6f8 <rtems_rfs_rtems_initialise+0x218> <== NEVER TAKEN
rc = rtems_rfs_mutex_create (&rtems->access);
4002a584: 9400372f bl 40038240 <rtems_rfs_mutex_create>
4002a588: 2a0003f5 mov w21, w0
if (rc > 0)
4002a58c: 710002bf cmp w21, #0x0
free (rtems);
4002a590: aa1303e0 mov x0, x19
if (rc > 0)
4002a594: 54000a8c b.gt 4002a6e4 <rtems_rfs_rtems_initialise+0x204> <== NEVER TAKEN
_Mutex_recursive_Acquire( mutex );
4002a598: 94000922 bl 4002ca20 <_Mutex_recursive_Acquire>
rc = rtems_rfs_fs_open (mt_entry->dev, rtems, flags, max_held_buffers, &fs);
4002a59c: f9403b20 ldr x0, [x25, #112]
4002a5a0: 2a1403e2 mov w2, w20
4002a5a4: 2a1703e3 mov w3, w23
4002a5a8: 910163e4 add x4, sp, #0x58
4002a5ac: aa1303e1 mov x1, x19
4002a5b0: 9400323c bl 40036ea0 <rtems_rfs_fs_open>
4002a5b4: 2a0003f4 mov w20, w0
if (rc)
4002a5b8: 35000520 cbnz w0, 4002a65c <rtems_rfs_rtems_initialise+0x17c> <== NEVER TAKEN
mt_entry->fs_info = fs;
4002a5bc: f9402fe0 ldr x0, [sp, #88]
mt_entry->ops = &rtems_rfs_ops;
4002a5c0: f00000e1 adrp x1, 40049000 <IMFS_node_control_sym_link+0x640>
4002a5c4: 912ca021 add x1, x1, #0xb28
mt_entry->mt_fs_root->location.node_access = (void*) RTEMS_RFS_ROOT_INO;
4002a5c8: d2800023 mov x3, #0x1 // #1
4002a5cc: f9402722 ldr x2, [x25, #72]
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
4002a5d0: f9407c13 ldr x19, [x0, #248]
mt_entry->ops = &rtems_rfs_ops;
4002a5d4: a9010720 stp x0, x1, [x25, #16]
mt_entry->mt_fs_root->location.handlers = &rtems_rfs_rtems_dir_handlers;
4002a5d8: f00000e1 adrp x1, 40049000 <IMFS_node_control_sym_link+0x640>
4002a5dc: 91314021 add x1, x1, #0xc50
mt_entry->mt_fs_root->location.node_access = (void*) RTEMS_RFS_ROOT_INO;
4002a5e0: f9000843 str x3, [x2, #16]
mt_entry->mt_fs_root->location.handlers = &rtems_rfs_rtems_dir_handlers;
4002a5e4: f9001041 str x1, [x2, #32]
rtems_rfs_buffers_release (fs);
4002a5e8: 97fff3c6 bl 40027500 <rtems_rfs_buffers_release>
_Mutex_recursive_Release( mutex );
4002a5ec: aa1303e0 mov x0, x19
4002a5f0: 94000930 bl 4002cab0 <_Mutex_recursive_Release>
}
4002a5f4: 2a1403e0 mov w0, w20
4002a5f8: a94153f3 ldp x19, x20, [sp, #16]
4002a5fc: a9425bf5 ldp x21, x22, [sp, #32]
4002a600: a94363f7 ldp x23, x24, [sp, #48]
4002a604: a9446bf9 ldp x25, x26, [sp, #64]
4002a608: a8c67bfd ldp x29, x30, [sp], #96
4002a60c: d65f03c0 ret
else if (strncmp (options, "no-local-cache",
4002a610: aa1803e1 mov x1, x24 <== NOT EXECUTED
4002a614: aa1303e0 mov x0, x19 <== NOT EXECUTED
4002a618: d28001c2 mov x2, #0xe // #14 <== NOT EXECUTED
4002a61c: 940051c8 bl 4003ed3c <strncmp> <== NOT EXECUTED
4002a620: 35000060 cbnz w0, 4002a62c <rtems_rfs_rtems_initialise+0x14c> <== NOT EXECUTED
flags |= RTEMS_RFS_FS_NO_LOCAL_CACHE;
4002a624: 321f0294 orr w20, w20, #0x2 <== NOT EXECUTED
4002a628: 17ffffcb b 4002a554 <rtems_rfs_rtems_initialise+0x74> <== NOT EXECUTED
else if (strncmp (options, "max-held-bufs",
4002a62c: aa1a03e1 mov x1, x26 <== NOT EXECUTED
4002a630: d28001a2 mov x2, #0xd // #13 <== NOT EXECUTED
4002a634: aa1303e0 mov x0, x19 <== NOT EXECUTED
4002a638: 940051c1 bl 4003ed3c <strncmp> <== NOT EXECUTED
max_held_buffers = strtoul (options + sizeof ("max-held-bufs"), 0, 0);
4002a63c: 52800002 mov w2, #0x0 // #0 <== NOT EXECUTED
else if (strncmp (options, "max-held-bufs",
4002a640: 2a0003e3 mov w3, w0 <== NOT EXECUTED
max_held_buffers = strtoul (options + sizeof ("max-held-bufs"), 0, 0);
4002a644: d2800001 mov x1, #0x0 // #0 <== NOT EXECUTED
4002a648: 91003a60 add x0, x19, #0xe <== NOT EXECUTED
else if (strncmp (options, "max-held-bufs",
4002a64c: 35000303 cbnz w3, 4002a6ac <rtems_rfs_rtems_initialise+0x1cc> <== NOT EXECUTED
max_held_buffers = strtoul (options + sizeof ("max-held-bufs"), 0, 0);
4002a650: 94005287 bl 4003f06c <strtoul> <== NOT EXECUTED
4002a654: 2a0003f7 mov w23, w0 <== NOT EXECUTED
4002a658: 17ffffbf b 4002a554 <rtems_rfs_rtems_initialise+0x74> <== NOT EXECUTED
4002a65c: aa1303e0 mov x0, x19 <== NOT EXECUTED
4002a660: 94000914 bl 4002cab0 <_Mutex_recursive_Release> <== NOT EXECUTED
rtems_rfs_mutex_destroy (&rtems->access);
4002a664: aa1303e0 mov x0, x19 <== NOT EXECUTED
4002a668: 940036fe bl 40038260 <rtems_rfs_mutex_destroy> <== NOT EXECUTED
free (rtems);
4002a66c: aa1303e0 mov x0, x19 <== NOT EXECUTED
4002a670: 97ffe050 bl 400227b0 <free> <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: open", errno);
4002a674: 94004c86 bl 4003d88c <__errno> <== NOT EXECUTED
4002a678: aa0003f3 mov x19, x0 <== NOT EXECUTED
4002a67c: 94004c84 bl 4003d88c <__errno> <== NOT EXECUTED
}
4002a680: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: open", errno);
4002a684: b9400261 ldr w1, [x19] <== NOT EXECUTED
4002a688: b9000001 str w1, [x0] <== NOT EXECUTED
4002a68c: 7100003f cmp w1, #0x0 <== NOT EXECUTED
4002a690: 5a9f03f4 csetm w20, ne // ne = any <== NOT EXECUTED
}
4002a694: 2a1403e0 mov w0, w20 <== NOT EXECUTED
4002a698: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
4002a69c: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
4002a6a0: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
4002a6a4: a8c67bfd ldp x29, x30, [sp], #96 <== NOT EXECUTED
4002a6a8: d65f03c0 ret <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: invalid option", EINVAL);
4002a6ac: 94004c78 bl 4003d88c <__errno> <== NOT EXECUTED
4002a6b0: 12800014 mov w20, #0xffffffff // #-1 <== NOT EXECUTED
4002a6b4: 528002c1 mov w1, #0x16 // #22 <== NOT EXECUTED
4002a6b8: b9000001 str w1, [x0] <== NOT EXECUTED
}
4002a6bc: 2a1403e0 mov w0, w20 <== NOT EXECUTED
4002a6c0: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
4002a6c4: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
4002a6c8: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
4002a6cc: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
4002a6d0: a8c67bfd ldp x29, x30, [sp], #96 <== NOT EXECUTED
4002a6d4: d65f03c0 ret <== NOT EXECUTED
uint32_t max_held_buffers = RTEMS_RFS_FS_MAX_HELD_BUFFERS;
4002a6d8: 528000b7 mov w23, #0x5 // #5
uint32_t flags = 0;
4002a6dc: 52800014 mov w20, #0x0 // #0
4002a6e0: 17ffffa4 b 4002a570 <rtems_rfs_rtems_initialise+0x90>
free (rtems);
4002a6e4: 97ffe033 bl 400227b0 <free> <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: cannot create mutex", rc);
4002a6e8: 12800014 mov w20, #0xffffffff // #-1 <== NOT EXECUTED
4002a6ec: 94004c68 bl 4003d88c <__errno> <== NOT EXECUTED
4002a6f0: b9000015 str w21, [x0] <== NOT EXECUTED
4002a6f4: 17ffffc0 b 4002a5f4 <rtems_rfs_rtems_initialise+0x114> <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: local data", ENOMEM);
4002a6f8: 94004c65 bl 4003d88c <__errno> <== NOT EXECUTED
4002a6fc: 12800014 mov w20, #0xffffffff // #-1 <== NOT EXECUTED
4002a700: 52800181 mov w1, #0xc // #12 <== NOT EXECUTED
4002a704: b9000001 str w1, [x0] <== NOT EXECUTED
4002a708: 17ffffbb b 4002a5f4 <rtems_rfs_rtems_initialise+0x114> <== NOT EXECUTED
4002a70c: 00000000 udf #0
000000004002a970 <rtems_rfs_rtems_set_handlers>:
*/
bool
rtems_rfs_rtems_set_handlers (rtems_filesystem_location_info_t* loc,
rtems_rfs_inode_handle* inode)
{
4002a970: aa0003e2 mov x2, x0
4002a974: f9400c20 ldr x0, [x1, #24]
4002a978: 39400803 ldrb w3, [x0, #2]
4002a97c: 39400c01 ldrb w1, [x0, #3]
uint16_t mode = rtems_rfs_inode_get_mode (inode); loc->handlers = NULL;
4002a980: f900105f str xzr, [x2, #32]
4002a984: aa012061 orr x1, x3, x1, lsl #8
4002a988: 5ac00421 rev16 w1, w1
4002a98c: 12140c23 and w3, w1, #0xf000
if (RTEMS_RFS_S_ISDIR (mode))
4002a990: 7140107f cmp w3, #0x4, lsl #12
4002a994: 54000280 b.eq 4002a9e4 <rtems_rfs_rtems_set_handlers+0x74> // b.none
loc->handlers = rtems_rfs_rtems_handlers (dir);
else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))
4002a998: 12003c21 and w1, w1, #0xffff
4002a99c: 1289ffe0 mov w0, #0xffffb000 // #-20480
4002a9a0: 0a000020 and w0, w1, w0
4002a9a4: 7140081f cmp w0, #0x2, lsl #12
4002a9a8: 54000140 b.eq 4002a9d0 <rtems_rfs_rtems_set_handlers+0x60> // b.none<== NEVER TAKEN
loc->handlers = rtems_rfs_rtems_handlers (device);
else if (RTEMS_RFS_S_ISLNK (mode))
4002a9ac: 7140287f cmp w3, #0xa, lsl #12
4002a9b0: 54000340 b.eq 4002aa18 <rtems_rfs_rtems_set_handlers+0xa8> // b.none<== NEVER TAKEN
loc->handlers = rtems_rfs_rtems_handlers (link);
else if (RTEMS_RFS_S_ISREG (mode))
4002a9b4: 7140207f cmp w3, #0x8, lsl #12
4002a9b8: 54000201 b.ne 4002a9f8 <rtems_rfs_rtems_set_handlers+0x88> // b.any<== NEVER TAKEN
loc->handlers = rtems_rfs_rtems_handlers (file);
4002a9bc: b0000101 adrp x1, 4004b000 <IMFS_LIMITS_AND_OPTIONS+0xbb8>
4002a9c0: 91186021 add x1, x1, #0x618
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
return false;
}
return true;
4002a9c4: 52800020 mov w0, #0x1 // #1
loc->handlers = rtems_rfs_rtems_handlers (file);
4002a9c8: f9001041 str x1, [x2, #32]
}
4002a9cc: d65f03c0 ret
loc->handlers = rtems_rfs_rtems_handlers (device);
4002a9d0: b0000101 adrp x1, 4004b000 <IMFS_LIMITS_AND_OPTIONS+0xbb8> <== NOT EXECUTED
4002a9d4: 91166021 add x1, x1, #0x598 <== NOT EXECUTED
return true;
4002a9d8: 52800020 mov w0, #0x1 // #1 <== NOT EXECUTED
loc->handlers = rtems_rfs_rtems_handlers (device);
4002a9dc: f9001041 str x1, [x2, #32] <== NOT EXECUTED
4002a9e0: d65f03c0 ret <== NOT EXECUTED
loc->handlers = rtems_rfs_rtems_handlers (dir);
4002a9e4: f00000e1 adrp x1, 40049000 <IMFS_node_control_sym_link+0x640>
4002a9e8: 91314021 add x1, x1, #0xc50
return true;
4002a9ec: 52800020 mov w0, #0x1 // #1
loc->handlers = rtems_rfs_rtems_handlers (dir);
4002a9f0: f9001041 str x1, [x2, #32]
4002a9f4: d65f03c0 ret
{
4002a9f8: a9bf7bfd stp x29, x30, [sp, #-16]! <== NOT EXECUTED
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
4002a9fc: f00000e0 adrp x0, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
4002aa00: 91334000 add x0, x0, #0xcd0 <== NOT EXECUTED
{
4002aa04: 910003fd mov x29, sp <== NOT EXECUTED
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
4002aa08: 97ffde82 bl 40022410 <__wrap_printf> <== NOT EXECUTED
return false;
4002aa0c: 52800000 mov w0, #0x0 // #0 <== NOT EXECUTED
}
4002aa10: a8c17bfd ldp x29, x30, [sp], #16 <== NOT EXECUTED
4002aa14: d65f03c0 ret <== NOT EXECUTED
loc->handlers = rtems_rfs_rtems_handlers (link);
4002aa18: f00000e1 adrp x1, 40049000 <IMFS_node_control_sym_link+0x640> <== NOT EXECUTED
4002aa1c: 912f4021 add x1, x1, #0xbd0 <== NOT EXECUTED
return true;
4002aa20: 52800020 mov w0, #0x1 // #1 <== NOT EXECUTED
loc->handlers = rtems_rfs_rtems_handlers (link);
4002aa24: f9001041 str x1, [x2, #32] <== NOT EXECUTED
4002aa28: d65f03c0 ret <== NOT EXECUTED
4002aa2c: 00000000 udf #0
0000000040037d60 <rtems_rfs_symlink>:
const char* link,
int link_length,
uid_t uid,
gid_t gid,
rtems_rfs_ino parent)
{
40037d60: d104c3ff sub sp, sp, #0x130 <== NOT EXECUTED
40037d64: a9017bfd stp x29, x30, [sp, #16] <== NOT EXECUTED
40037d68: 910043fd add x29, sp, #0x10 <== NOT EXECUTED
40037d6c: a90253f3 stp x19, x20, [sp, #32] <== NOT EXECUTED
40037d70: aa0003f4 mov x20, x0 <== NOT EXECUTED
rtems_rfs_inode_handle inode;
rtems_rfs_ino ino;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
40037d74: d2c00040 mov x0, #0x200000000 // #8589934592 <== NOT EXECUTED
{
40037d78: a9035bf5 stp x21, x22, [sp, #48] <== NOT EXECUTED
40037d7c: aa0103f6 mov x22, x1 <== NOT EXECUTED
40037d80: 2a0403f5 mov w21, w4 <== NOT EXECUTED
40037d84: a90463f7 stp x23, x24, [sp, #64] <== NOT EXECUTED
40037d88: aa0303f8 mov x24, x3 <== NOT EXECUTED
40037d8c: 2a0703f7 mov w23, w7 <== NOT EXECUTED
40037d90: a9056bf9 stp x25, x26, [sp, #80] <== NOT EXECUTED
40037d94: 12003cb9 and w25, w5, #0xffff <== NOT EXECUTED
40037d98: 12003cda and w26, w6, #0xffff <== NOT EXECUTED
40037d9c: f90033fb str x27, [sp, #96] <== NOT EXECUTED
40037da0: 2a0203fb mov w27, w2 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
40037da4: 97ffcb2b bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
40037da8: 72001c1f tst w0, #0xff <== NOT EXECUTED
40037dac: 540008e1 b.ne 40037ec8 <rtems_rfs_symlink+0x168> // b.any <== NOT EXECUTED
printf (" link:");
for (c = 0; c < link_length; c++)
printf ("%c", link[c]);
}
if (link_length >= rtems_rfs_fs_block_size (fs))
40037db0: f9400a80 ldr x0, [x20, #16] <== NOT EXECUTED
40037db4: 93407ebb sxtw x27, w21 <== NOT EXECUTED
return ENAMETOOLONG;
40037db8: 52800b73 mov w19, #0x5b // #91 <== NOT EXECUTED
if (link_length >= rtems_rfs_fs_block_size (fs))
40037dbc: eb00037f cmp x27, x0 <== NOT EXECUTED
40037dc0: 54000222 b.cs 40037e04 <rtems_rfs_symlink+0xa4> // b.hs, b.nlast <== NOT EXECUTED
rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),
40037dc4: aa1603e0 mov x0, x22 <== NOT EXECUTED
40037dc8: 94001bcc bl 4003ecf8 <strlen> <== NOT EXECUTED
40037dcc: 9101e3e1 add x1, sp, #0x78 <== NOT EXECUTED
40037dd0: f90003e1 str x1, [sp] <== NOT EXECUTED
40037dd4: aa0003e3 mov x3, x0 <== NOT EXECUTED
40037dd8: 2a1a03e7 mov w7, w26 <== NOT EXECUTED
40037ddc: 2a1903e6 mov w6, w25 <== NOT EXECUTED
40037de0: aa1603e2 mov x2, x22 <== NOT EXECUTED
40037de4: aa1403e0 mov x0, x20 <== NOT EXECUTED
40037de8: 2a1703e1 mov w1, w23 <== NOT EXECUTED
40037dec: 52800025 mov w5, #0x1 // #1 <== NOT EXECUTED
40037df0: 128bc004 mov w4, #0xffffa1ff // #-24065 <== NOT EXECUTED
40037df4: 97ffc547 bl 40029310 <rtems_rfs_inode_create> <== NOT EXECUTED
40037df8: 2a0003f3 mov w19, w0 <== NOT EXECUTED
RTEMS_RFS_S_SYMLINK,
1, uid, gid, &ino);
if (rc > 0)
40037dfc: 7100001f cmp w0, #0x0 <== NOT EXECUTED
40037e00: 5400014d b.le 40037e28 <rtems_rfs_symlink+0xc8> <== NOT EXECUTED
rtems_rfs_inode_set_block_offset (&inode, link_length);
rc = rtems_rfs_inode_close (fs, &inode);
return rc;
}
40037e04: 2a1303e0 mov w0, w19 <== NOT EXECUTED
40037e08: a9417bfd ldp x29, x30, [sp, #16] <== NOT EXECUTED
40037e0c: a94253f3 ldp x19, x20, [sp, #32] <== NOT EXECUTED
40037e10: a9435bf5 ldp x21, x22, [sp, #48] <== NOT EXECUTED
40037e14: a94463f7 ldp x23, x24, [sp, #64] <== NOT EXECUTED
40037e18: a9456bf9 ldp x25, x26, [sp, #80] <== NOT EXECUTED
40037e1c: f94033fb ldr x27, [sp, #96] <== NOT EXECUTED
40037e20: 9104c3ff add sp, sp, #0x130 <== NOT EXECUTED
40037e24: d65f03c0 ret <== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
40037e28: b9407be1 ldr w1, [sp, #120] <== NOT EXECUTED
40037e2c: 910243e2 add x2, sp, #0x90 <== NOT EXECUTED
40037e30: aa1403e0 mov x0, x20 <== NOT EXECUTED
40037e34: 52800023 mov w3, #0x1 // #1 <== NOT EXECUTED
40037e38: 97ffc3be bl 40028d30 <rtems_rfs_inode_open> <== NOT EXECUTED
40037e3c: 2a0003f3 mov w19, w0 <== NOT EXECUTED
if (rc > 0)
40037e40: 7100001f cmp w0, #0x0 <== NOT EXECUTED
40037e44: 54fffe0c b.gt 40037e04 <rtems_rfs_symlink+0xa4> <== NOT EXECUTED
if (link_length < RTEMS_RFS_INODE_DATA_NAME_SIZE)
40037e48: 71004ebf cmp w21, #0x13 <== NOT EXECUTED
40037e4c: 54000788 b.hi 40037f3c <rtems_rfs_symlink+0x1dc> // b.pmore <== NOT EXECUTED
memset (inode.node->data.name, 0, RTEMS_RFS_INODE_DATA_NAME_SIZE);
40037e50: f94057e0 ldr x0, [sp, #168] <== NOT EXECUTED
40037e54: d2800282 mov x2, #0x14 // #20 <== NOT EXECUTED
40037e58: 52800001 mov w1, #0x0 // #0 <== NOT EXECUTED
40037e5c: 91007000 add x0, x0, #0x1c <== NOT EXECUTED
40037e60: 94001853 bl 4003dfac <memset> <== NOT EXECUTED
memcpy (inode.node->data.name, link, link_length);
40037e64: f94057e0 ldr x0, [sp, #168] <== NOT EXECUTED
40037e68: aa1b03e2 mov x2, x27 <== NOT EXECUTED
40037e6c: aa1803e1 mov x1, x24 <== NOT EXECUTED
40037e70: 91007000 add x0, x0, #0x1c <== NOT EXECUTED
40037e74: 940017f8 bl 4003de54 <memcpy> <== NOT EXECUTED
rtems_rfs_write_u32 (&handle->node->block_count, block_count);
40037e78: f94057e0 ldr x0, [sp, #168] <== NOT EXECUTED
40037e7c: 3900301f strb wzr, [x0, #12] <== NOT EXECUTED
40037e80: f94057e0 ldr x0, [sp, #168] <== NOT EXECUTED
40037e84: 3900341f strb wzr, [x0, #13] <== NOT EXECUTED
40037e88: f94057e0 ldr x0, [sp, #168] <== NOT EXECUTED
40037e8c: 3900381f strb wzr, [x0, #14] <== NOT EXECUTED
40037e90: f94057e0 ldr x0, [sp, #168] <== NOT EXECUTED
40037e94: 39003c1f strb wzr, [x0, #15] <== NOT EXECUTED
rtems_rfs_write_u16 (&handle->node->block_offset, block_offset);
40037e98: f94057e3 ldr x3, [sp, #168] <== NOT EXECUTED
40037e9c: d3483ea4 ubfx x4, x21, #8, #8 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40037ea0: 52800022 mov w2, #0x1 // #1 <== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &inode);
40037ea4: 910243e1 add x1, sp, #0x90 <== NOT EXECUTED
40037ea8: aa1403e0 mov x0, x20 <== NOT EXECUTED
rtems_rfs_write_u16 (&handle->node->block_offset, block_offset);
40037eac: 39002864 strb w4, [x3, #10] <== NOT EXECUTED
40037eb0: f94057e3 ldr x3, [sp, #168] <== NOT EXECUTED
40037eb4: 39002c75 strb w21, [x3, #11] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40037eb8: 3902c3e2 strb w2, [sp, #176] <== NOT EXECUTED
40037ebc: 97ffc419 bl 40028f20 <rtems_rfs_inode_close> <== NOT EXECUTED
40037ec0: 2a0003f3 mov w19, w0 <== NOT EXECUTED
return rc;
40037ec4: 17ffffd0 b 40037e04 <rtems_rfs_symlink+0xa4> <== NOT EXECUTED
printf ("rtems-rfs: symlink: parent:%" PRIu32 " name:", parent);
40037ec8: 2a1703e1 mov w1, w23 <== NOT EXECUTED
40037ecc: 900000a0 adrp x0, 4004b000 <IMFS_LIMITS_AND_OPTIONS+0xbb8> <== NOT EXECUTED
40037ed0: 91150000 add x0, x0, #0x540 <== NOT EXECUTED
40037ed4: 97ffa94f bl 40022410 <__wrap_printf> <== NOT EXECUTED
for (c = 0; c < length; c++)
40037ed8: 7100037f cmp w27, #0x0 <== NOT EXECUTED
40037edc: 5400012d b.le 40037f00 <rtems_rfs_symlink+0x1a0> <== NOT EXECUTED
40037ee0: 5100077b sub w27, w27, #0x1 <== NOT EXECUTED
40037ee4: 910006c0 add x0, x22, #0x1 <== NOT EXECUTED
40037ee8: 8b00037b add x27, x27, x0 <== NOT EXECUTED
40037eec: aa1603f3 mov x19, x22 <== NOT EXECUTED
printf ("%c", name[c]);
40037ef0: 38401660 ldrb w0, [x19], #1 <== NOT EXECUTED
40037ef4: 94001843 bl 4003e000 <putchar> <== NOT EXECUTED
for (c = 0; c < length; c++)
40037ef8: eb1b027f cmp x19, x27 <== NOT EXECUTED
40037efc: 54ffffa1 b.ne 40037ef0 <rtems_rfs_symlink+0x190> // b.any <== NOT EXECUTED
printf (" link:");
40037f00: 900000a0 adrp x0, 4004b000 <IMFS_LIMITS_AND_OPTIONS+0xbb8> <== NOT EXECUTED
40037f04: 9115a000 add x0, x0, #0x568 <== NOT EXECUTED
40037f08: 97ffa942 bl 40022410 <__wrap_printf> <== NOT EXECUTED
for (c = 0; c < link_length; c++)
40037f0c: 710002bf cmp w21, #0x0 <== NOT EXECUTED
40037f10: 54fff50d b.le 40037db0 <rtems_rfs_symlink+0x50> <== NOT EXECUTED
40037f14: 510006bb sub w27, w21, #0x1 <== NOT EXECUTED
40037f18: 91000700 add x0, x24, #0x1 <== NOT EXECUTED
40037f1c: 8b00037b add x27, x27, x0 <== NOT EXECUTED
40037f20: aa1803f3 mov x19, x24 <== NOT EXECUTED
40037f24: d503201f nop <== NOT EXECUTED
printf ("%c", link[c]);
40037f28: 38401660 ldrb w0, [x19], #1 <== NOT EXECUTED
40037f2c: 94001835 bl 4003e000 <putchar> <== NOT EXECUTED
for (c = 0; c < link_length; c++)
40037f30: eb13037f cmp x27, x19 <== NOT EXECUTED
40037f34: 54ffffa1 b.ne 40037f28 <rtems_rfs_symlink+0x1c8> // b.any <== NOT EXECUTED
40037f38: 17ffff9e b 40037db0 <rtems_rfs_symlink+0x50> <== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, &inode, &map);
40037f3c: 910243e1 add x1, sp, #0x90 <== NOT EXECUTED
40037f40: 910343e2 add x2, sp, #0xd0 <== NOT EXECUTED
40037f44: aa1403e0 mov x0, x20 <== NOT EXECUTED
40037f48: 97ffef6e bl 40033d00 <rtems_rfs_block_map_open> <== NOT EXECUTED
40037f4c: 2a0003f3 mov w19, w0 <== NOT EXECUTED
if (rc > 0)
40037f50: 7100001f cmp w0, #0x0 <== NOT EXECUTED
40037f54: 5400052c b.gt 40037ff8 <rtems_rfs_symlink+0x298> <== NOT EXECUTED
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
40037f58: 9101f3e3 add x3, sp, #0x7c <== NOT EXECUTED
40037f5c: 910343e1 add x1, sp, #0xd0 <== NOT EXECUTED
40037f60: aa1403e0 mov x0, x20 <== NOT EXECUTED
40037f64: d2800022 mov x2, #0x1 // #1 <== NOT EXECUTED
40037f68: 97fff0b2 bl 40034230 <rtems_rfs_block_map_grow> <== NOT EXECUTED
40037f6c: 2a0003f3 mov w19, w0 <== NOT EXECUTED
if (rc > 0)
40037f70: 7100001f cmp w0, #0x0 <== NOT EXECUTED
40037f74: 540004ac b.gt 40038008 <rtems_rfs_symlink+0x2a8> <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false);
40037f78: b9407fe2 ldr w2, [sp, #124] <== NOT EXECUTED
40037f7c: 910203e1 add x1, sp, #0x80 <== NOT EXECUTED
40037f80: aa1403e0 mov x0, x20 <== NOT EXECUTED
40037f84: 52800003 mov w3, #0x0 // #0 <== NOT EXECUTED
handle->dirty = false;
40037f88: 390203ff strb wzr, [sp, #128] <== NOT EXECUTED
handle->bnum = 0;
40037f8c: b90087ff str wzr, [sp, #132] <== NOT EXECUTED
handle->buffer = NULL;
40037f90: f90047ff str xzr, [sp, #136] <== NOT EXECUTED
40037f94: 97ffbc0f bl 40026fd0 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
40037f98: 2a0003f3 mov w19, w0 <== NOT EXECUTED
if (rc > 0)
40037f9c: 7100001f cmp w0, #0x0 <== NOT EXECUTED
40037fa0: 5400034c b.gt 40038008 <rtems_rfs_symlink+0x2a8> <== NOT EXECUTED
data = rtems_rfs_buffer_data (&buffer);
40037fa4: f94047e0 ldr x0, [sp, #136] <== NOT EXECUTED
memset (data, 0xff, rtems_rfs_fs_block_size (fs));
40037fa8: 52801fe1 mov w1, #0xff // #255 <== NOT EXECUTED
40037fac: f9400a82 ldr x2, [x20, #16] <== NOT EXECUTED
data = rtems_rfs_buffer_data (&buffer);
40037fb0: f9401c03 ldr x3, [x0, #56] <== NOT EXECUTED
memset (data, 0xff, rtems_rfs_fs_block_size (fs));
40037fb4: aa0303e0 mov x0, x3 <== NOT EXECUTED
40037fb8: 940017fd bl 4003dfac <memset> <== NOT EXECUTED
memcpy (data, link, link_length);
40037fbc: aa1b03e2 mov x2, x27 <== NOT EXECUTED
40037fc0: aa1803e1 mov x1, x24 <== NOT EXECUTED
40037fc4: 940017a4 bl 4003de54 <memcpy> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40037fc8: 910203e1 add x1, sp, #0x80 <== NOT EXECUTED
40037fcc: aa1403e0 mov x0, x20 <== NOT EXECUTED
40037fd0: 97ffbcb0 bl 40027290 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
40037fd4: 390203ff strb wzr, [sp, #128] <== NOT EXECUTED
rc = rtems_rfs_block_map_close (fs, &map);
40037fd8: 910343e1 add x1, sp, #0xd0 <== NOT EXECUTED
40037fdc: aa1403e0 mov x0, x20 <== NOT EXECUTED
handle->bnum = 0;
40037fe0: b90087ff str wzr, [sp, #132] <== NOT EXECUTED
handle->buffer = NULL;
40037fe4: f90047ff str xzr, [sp, #136] <== NOT EXECUTED
40037fe8: 97ffefaa bl 40033e90 <rtems_rfs_block_map_close> <== NOT EXECUTED
40037fec: 2a0003f3 mov w19, w0 <== NOT EXECUTED
if (rc > 0)
40037ff0: 7100001f cmp w0, #0x0 <== NOT EXECUTED
40037ff4: 54fff52d b.le 40037e98 <rtems_rfs_symlink+0x138> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
40037ff8: 910243e1 add x1, sp, #0x90 <== NOT EXECUTED
40037ffc: aa1403e0 mov x0, x20 <== NOT EXECUTED
40038000: 97ffc3c8 bl 40028f20 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
40038004: 17ffff80 b 40037e04 <rtems_rfs_symlink+0xa4> <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
40038008: 910343e1 add x1, sp, #0xd0 <== NOT EXECUTED
4003800c: aa1403e0 mov x0, x20 <== NOT EXECUTED
40038010: 97ffefa0 bl 40033e90 <rtems_rfs_block_map_close> <== NOT EXECUTED
40038014: 17fffff9 b 40037ff8 <rtems_rfs_symlink+0x298> <== NOT EXECUTED
...
0000000040038020 <rtems_rfs_symlink_read>:
rtems_rfs_symlink_read (rtems_rfs_file_system* fs,
rtems_rfs_ino link,
char* path,
size_t size,
size_t* length)
{
40038020: a9b07bfd stp x29, x30, [sp, #-256]! <== NOT EXECUTED
40038024: 910003fd mov x29, sp <== NOT EXECUTED
40038028: a90153f3 stp x19, x20, [sp, #16] <== NOT EXECUTED
4003802c: aa0003f4 mov x20, x0 <== NOT EXECUTED
40038030: 2a0103f3 mov w19, w1 <== NOT EXECUTED
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))
40038034: d2c00080 mov x0, #0x400000000 // #17179869184 <== NOT EXECUTED
{
40038038: a9025bf5 stp x21, x22, [sp, #32] <== NOT EXECUTED
4003803c: aa0203f6 mov x22, x2 <== NOT EXECUTED
40038040: aa0403f5 mov x21, x4 <== NOT EXECUTED
40038044: f9001bf7 str x23, [sp, #48] <== NOT EXECUTED
40038048: aa0303f7 mov x23, x3 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))
4003804c: 97ffca81 bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
40038050: 72001c1f tst w0, #0xff <== NOT EXECUTED
40038054: 54000c41 b.ne 400381dc <rtems_rfs_symlink_read+0x1bc> // b.any <== NOT EXECUTED
printf ("rtems-rfs: symlink-read: link:%" PRIu32 "\n", link);
rc = rtems_rfs_inode_open (fs, link, &inode, true);
40038058: 2a1303e1 mov w1, w19 <== NOT EXECUTED
4003805c: 910183e2 add x2, sp, #0x60 <== NOT EXECUTED
40038060: aa1403e0 mov x0, x20 <== NOT EXECUTED
40038064: 52800023 mov w3, #0x1 // #1 <== NOT EXECUTED
40038068: 97ffc332 bl 40028d30 <rtems_rfs_inode_open> <== NOT EXECUTED
4003806c: 2a0003f3 mov w19, w0 <== NOT EXECUTED
if (rc)
40038070: 35000400 cbnz w0, 400380f0 <rtems_rfs_symlink_read+0xd0> <== NOT EXECUTED
return rtems_rfs_read_u16 (&handle->node->mode);
40038074: f9403fe1 ldr x1, [sp, #120] <== NOT EXECUTED
return rc;
if (!RTEMS_RFS_S_ISLNK (rtems_rfs_inode_get_mode (&inode)))
40038078: 39400822 ldrb w2, [x1, #2] <== NOT EXECUTED
4003807c: 39400c20 ldrb w0, [x1, #3] <== NOT EXECUTED
40038080: aa002040 orr x0, x2, x0, lsl #8 <== NOT EXECUTED
40038084: 5ac00400 rev16 w0, w0 <== NOT EXECUTED
40038088: 12140c00 and w0, w0, #0xf000 <== NOT EXECUTED
4003808c: 7140281f cmp w0, #0xa, lsl #12 <== NOT EXECUTED
40038090: 54000be1 b.ne 4003820c <rtems_rfs_symlink_read+0x1ec> // b.any <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
return EINVAL;
}
*length = rtems_rfs_inode_get_block_offset (&inode);
40038094: 39402822 ldrb w2, [x1, #10] <== NOT EXECUTED
40038098: 39402c25 ldrb w5, [x1, #11] <== NOT EXECUTED
4003809c: aa052045 orr x5, x2, x5, lsl #8 <== NOT EXECUTED
400380a0: 5ac004a5 rev16 w5, w5 <== NOT EXECUTED
400380a4: 92403ca5 and x5, x5, #0xffff <== NOT EXECUTED
400380a8: eb1700bf cmp x5, x23 <== NOT EXECUTED
400380ac: 9a9790a2 csel x2, x5, x23, ls // ls = plast <== NOT EXECUTED
400380b0: f90002a2 str x2, [x21] <== NOT EXECUTED
return rtems_rfs_read_u32 (&handle->node->block_count);
400380b4: 39403025 ldrb w5, [x1, #12] <== NOT EXECUTED
400380b8: 39403424 ldrb w4, [x1, #13] <== NOT EXECUTED
400380bc: 39403823 ldrb w3, [x1, #14] <== NOT EXECUTED
400380c0: 39403c20 ldrb w0, [x1, #15] <== NOT EXECUTED
400380c4: aa0420a4 orr x4, x5, x4, lsl #8 <== NOT EXECUTED
400380c8: aa034083 orr x3, x4, x3, lsl #16 <== NOT EXECUTED
400380cc: aa006060 orr x0, x3, x0, lsl #24 <== NOT EXECUTED
if (size < *length)
{
*length = size;
}
if (rtems_rfs_inode_get_block_count (&inode) == 0)
400380d0: b50001c0 cbnz x0, 40038108 <rtems_rfs_symlink_read+0xe8> <== NOT EXECUTED
{
memcpy (path, inode.node->data.name, *length);
400380d4: 91007021 add x1, x1, #0x1c <== NOT EXECUTED
400380d8: aa1603e0 mov x0, x22 <== NOT EXECUTED
400380dc: 9400175e bl 4003de54 <memcpy> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
return rc;
}
}
rc = rtems_rfs_inode_close (fs, &inode);
400380e0: 910183e1 add x1, sp, #0x60 <== NOT EXECUTED
400380e4: aa1403e0 mov x0, x20 <== NOT EXECUTED
400380e8: 97ffc38e bl 40028f20 <rtems_rfs_inode_close> <== NOT EXECUTED
400380ec: 2a0003f3 mov w19, w0 <== NOT EXECUTED
return rc;
}
400380f0: 2a1303e0 mov w0, w19 <== NOT EXECUTED
400380f4: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
400380f8: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
400380fc: f9401bf7 ldr x23, [sp, #48] <== NOT EXECUTED
40038100: a8d07bfd ldp x29, x30, [sp], #256 <== NOT EXECUTED
40038104: d65f03c0 ret <== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, &inode, &map);
40038108: 910183e1 add x1, sp, #0x60 <== NOT EXECUTED
4003810c: 910283e2 add x2, sp, #0xa0 <== NOT EXECUTED
40038110: aa1403e0 mov x0, x20 <== NOT EXECUTED
40038114: 97ffeefb bl 40033d00 <rtems_rfs_block_map_open> <== NOT EXECUTED
40038118: 2a0003f3 mov w19, w0 <== NOT EXECUTED
if (rc > 0)
4003811c: 7100001f cmp w0, #0x0 <== NOT EXECUTED
40038120: 540004cc b.gt 400381b8 <rtems_rfs_symlink_read+0x198> <== NOT EXECUTED
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
40038124: 910133e3 add x3, sp, #0x4c <== NOT EXECUTED
40038128: 910283e1 add x1, sp, #0xa0 <== NOT EXECUTED
4003812c: aa1403e0 mov x0, x20 <== NOT EXECUTED
40038130: d2800002 mov x2, #0x0 // #0 <== NOT EXECUTED
40038134: 97fff023 bl 400341c0 <rtems_rfs_block_map_seek> <== NOT EXECUTED
40038138: 2a0003f3 mov w19, w0 <== NOT EXECUTED
if (rc > 0)
4003813c: 7100001f cmp w0, #0x0 <== NOT EXECUTED
40038140: 5400058c b.gt 400381f0 <rtems_rfs_symlink_read+0x1d0> <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false);
40038144: b9404fe2 ldr w2, [sp, #76] <== NOT EXECUTED
40038148: 910143e1 add x1, sp, #0x50 <== NOT EXECUTED
4003814c: aa1403e0 mov x0, x20 <== NOT EXECUTED
40038150: 52800003 mov w3, #0x0 // #0 <== NOT EXECUTED
handle->dirty = false;
40038154: 390143ff strb wzr, [sp, #80] <== NOT EXECUTED
handle->bnum = 0;
40038158: b90057ff str wzr, [sp, #84] <== NOT EXECUTED
handle->buffer = NULL;
4003815c: f9002fff str xzr, [sp, #88] <== NOT EXECUTED
40038160: 97ffbb9c bl 40026fd0 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
40038164: 2a0003f3 mov w19, w0 <== NOT EXECUTED
if (rc > 0)
40038168: 7100001f cmp w0, #0x0 <== NOT EXECUTED
4003816c: 5400042c b.gt 400381f0 <rtems_rfs_symlink_read+0x1d0> <== NOT EXECUTED
data = rtems_rfs_buffer_data (&buffer);
40038170: f9402fe1 ldr x1, [sp, #88] <== NOT EXECUTED
memcpy (path, data, *length);
40038174: aa1603e0 mov x0, x22 <== NOT EXECUTED
40038178: f94002a2 ldr x2, [x21] <== NOT EXECUTED
4003817c: f9401c21 ldr x1, [x1, #56] <== NOT EXECUTED
40038180: 94001735 bl 4003de54 <memcpy> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
40038184: 910143e1 add x1, sp, #0x50 <== NOT EXECUTED
40038188: aa1403e0 mov x0, x20 <== NOT EXECUTED
4003818c: 97ffbc41 bl 40027290 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
40038190: 390143ff strb wzr, [sp, #80] <== NOT EXECUTED
rc = rtems_rfs_block_map_close (fs, &map);
40038194: 910283e1 add x1, sp, #0xa0 <== NOT EXECUTED
40038198: aa1403e0 mov x0, x20 <== NOT EXECUTED
handle->bnum = 0;
4003819c: b90057ff str wzr, [sp, #84] <== NOT EXECUTED
handle->buffer = NULL;
400381a0: f9002fff str xzr, [sp, #88] <== NOT EXECUTED
400381a4: 97ffef3b bl 40033e90 <rtems_rfs_block_map_close> <== NOT EXECUTED
400381a8: 2a0003f3 mov w19, w0 <== NOT EXECUTED
if (rc > 0)
400381ac: 7100001f cmp w0, #0x0 <== NOT EXECUTED
400381b0: 54fff98d b.le 400380e0 <rtems_rfs_symlink_read+0xc0> <== NOT EXECUTED
400381b4: d503201f nop <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
400381b8: 910183e1 add x1, sp, #0x60 <== NOT EXECUTED
400381bc: aa1403e0 mov x0, x20 <== NOT EXECUTED
400381c0: 97ffc358 bl 40028f20 <rtems_rfs_inode_close> <== NOT EXECUTED
}
400381c4: 2a1303e0 mov w0, w19 <== NOT EXECUTED
400381c8: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
400381cc: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
400381d0: f9401bf7 ldr x23, [sp, #48] <== NOT EXECUTED
400381d4: a8d07bfd ldp x29, x30, [sp], #256 <== NOT EXECUTED
400381d8: d65f03c0 ret <== NOT EXECUTED
printf ("rtems-rfs: symlink-read: link:%" PRIu32 "\n", link);
400381dc: 2a1303e1 mov w1, w19 <== NOT EXECUTED
400381e0: f0000080 adrp x0, 4004b000 <IMFS_LIMITS_AND_OPTIONS+0xbb8> <== NOT EXECUTED
400381e4: 9115c000 add x0, x0, #0x570 <== NOT EXECUTED
400381e8: 97ffa88a bl 40022410 <__wrap_printf> <== NOT EXECUTED
400381ec: 17ffff9b b 40038058 <rtems_rfs_symlink_read+0x38> <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
400381f0: 910283e1 add x1, sp, #0xa0 <== NOT EXECUTED
400381f4: aa1403e0 mov x0, x20 <== NOT EXECUTED
400381f8: 97ffef26 bl 40033e90 <rtems_rfs_block_map_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
400381fc: 910183e1 add x1, sp, #0x60 <== NOT EXECUTED
40038200: aa1403e0 mov x0, x20 <== NOT EXECUTED
40038204: 97ffc347 bl 40028f20 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
40038208: 17ffffef b 400381c4 <rtems_rfs_symlink_read+0x1a4> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
4003820c: 910183e1 add x1, sp, #0x60 <== NOT EXECUTED
40038210: aa1403e0 mov x0, x20 <== NOT EXECUTED
return EINVAL;
40038214: 528002d3 mov w19, #0x16 // #22 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
40038218: 97ffc342 bl 40028f20 <rtems_rfs_inode_close> <== NOT EXECUTED
}
4003821c: 2a1303e0 mov w0, w19 <== NOT EXECUTED
40038220: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40038224: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
40038228: f9401bf7 ldr x23, [sp, #48] <== NOT EXECUTED
4003822c: a8d07bfd ldp x29, x30, [sp], #256 <== NOT EXECUTED
40038230: d65f03c0 ret <== NOT EXECUTED
...
00000000400378f0 <rtems_rfs_unlink>:
rtems_rfs_unlink (rtems_rfs_file_system* fs,
rtems_rfs_ino parent,
rtems_rfs_ino target,
uint32_t doff,
rtems_rfs_unlink_dir dir_mode)
{
400378f0: a9b37bfd stp x29, x30, [sp, #-208]!
400378f4: 910003fd mov x29, sp
400378f8: a90153f3 stp x19, x20, [sp, #16]
400378fc: aa0003f4 mov x20, x0
rtems_rfs_inode_handle target_inode;
uint16_t links;
bool dir;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
40037900: d2a04000 mov x0, #0x2000000 // #33554432
{
40037904: a9025bf5 stp x21, x22, [sp, #32]
40037908: 2a0203f6 mov w22, w2
4003790c: a90363f7 stp x23, x24, [sp, #48]
40037910: 2a0103f7 mov w23, w1
40037914: 2a0403f8 mov w24, w4
40037918: f90023f9 str x25, [sp, #64]
4003791c: 2a0303f9 mov w25, w3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
40037920: 97ffcc4c bl 4002aa50 <rtems_rfs_trace>
40037924: 72001c1f tst w0, #0xff
40037928: 54000a61 b.ne 40037a74 <rtems_rfs_unlink+0x184> // b.any <== NEVER TAKEN
printf ("rtems-rfs: unlink: parent(%" PRIu32 ") -X-> (%" PRIu32 ")\n", parent, target);
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
4003792c: 910243e2 add x2, sp, #0x90
40037930: 2a1603e1 mov w1, w22
40037934: aa1403e0 mov x0, x20
40037938: 52800023 mov w3, #0x1 // #1
4003793c: 97ffc4fd bl 40028d30 <rtems_rfs_inode_open>
40037940: 2a0003f3 mov w19, w0
if (rc)
40037944: 350008a0 cbnz w0, 40037a58 <rtems_rfs_unlink+0x168> <== NEVER TAKEN
return rtems_rfs_read_u16 (&handle->node->mode);
40037948: f94057e0 ldr x0, [sp, #168]
4003794c: 39400801 ldrb w1, [x0, #2]
40037950: 39400c15 ldrb w21, [x0, #3]
40037954: aa152035 orr x21, x1, x21, lsl #8
40037958: 5ac006b5 rev16 w21, w21
4003795c: 12140eb5 and w21, w21, #0xf000
/*
* If a directory process the unlink mode.
*/
dir = RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&target_inode));
if (dir)
40037960: 714012bf cmp w21, #0x4, lsl #12
40037964: 54000081 b.ne 40037974 <rtems_rfs_unlink+0x84> // b.any
{
switch (dir_mode)
40037968: 34001118 cbz w24, 40037b88 <rtems_rfs_unlink+0x298> <== NEVER TAKEN
4003796c: 7100071f cmp w24, #0x1
40037970: 54000aa0 b.eq 40037ac4 <rtems_rfs_unlink+0x1d4> // b.none <== ALWAYS TAKEN
default:
break;
}
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
40037974: 2a1703e1 mov w1, w23
40037978: 910143e2 add x2, sp, #0x50
4003797c: aa1403e0 mov x0, x20
40037980: 52800023 mov w3, #0x1 // #1
40037984: 97ffc4eb bl 40028d30 <rtems_rfs_inode_open>
40037988: 2a0003f3 mov w19, w0
if (rc)
4003798c: 35000800 cbnz w0, 40037a8c <rtems_rfs_unlink+0x19c> <== NEVER TAKEN
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_dir_del_entry (fs, &parent_inode, target, doff);
40037990: 2a1903e3 mov w3, w25
40037994: 2a1603e2 mov w2, w22
40037998: 910143e1 add x1, sp, #0x50
4003799c: aa1403e0 mov x0, x20
400379a0: 97fff670 bl 40035360 <rtems_rfs_dir_del_entry>
400379a4: 2a0003f3 mov w19, w0
if (rc > 0)
400379a8: 7100001f cmp w0, #0x0
400379ac: 540012ec b.gt 40037c08 <rtems_rfs_unlink+0x318> <== NEVER TAKEN
links = rtems_rfs_read_u16 (&handle->node->links);
400379b0: f94057e0 ldr x0, [sp, #168]
if (links == 0xffff)
400379b4: 529fffe1 mov w1, #0xffff // #65535
400379b8: 39400002 ldrb w2, [x0]
400379bc: 39400413 ldrb w19, [x0, #1]
return rc;
}
links = rtems_rfs_inode_get_links (&target_inode);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
400379c0: d2a04000 mov x0, #0x2000000 // #33554432
400379c4: aa132053 orr x19, x2, x19, lsl #8
400379c8: 5ac00673 rev16 w19, w19
400379cc: 12003e73 and w19, w19, #0xffff
400379d0: 6b01027f cmp w19, w1
400379d4: 540009c0 b.eq 40037b0c <rtems_rfs_unlink+0x21c> // b.none <== NEVER TAKEN
400379d8: 97ffcc1e bl 4002aa50 <rtems_rfs_trace>
400379dc: 72001c1f tst w0, #0xff
400379e0: 54001541 b.ne 40037c88 <rtems_rfs_unlink+0x398> // b.any <== NEVER TAKEN
printf ("rtems-rfs: unlink: target:%" PRIu32 " links:%u\n", target, links);
if (links > 1)
400379e4: 7100067f cmp w19, #0x1
400379e8: 54000989 b.ls 40037b18 <rtems_rfs_unlink+0x228> // b.plast <== ALWAYS TAKEN
rtems_rfs_write_u16 (&handle->node->links, links);
400379ec: f94057e1 ldr x1, [sp, #168] <== NOT EXECUTED
{
links--;
400379f0: 51000673 sub w19, w19, #0x1 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
400379f4: 52800020 mov w0, #0x1 // #1 <== NOT EXECUTED
rtems_rfs_write_u16 (&handle->node->links, links);
400379f8: d3483e62 ubfx x2, x19, #8, #8 <== NOT EXECUTED
400379fc: 39000022 strb w2, [x1] <== NOT EXECUTED
40037a00: f94057e1 ldr x1, [sp, #168] <== NOT EXECUTED
40037a04: 39000433 strb w19, [x1, #1] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40037a08: 3902c3e0 strb w0, [sp, #176] <== NOT EXECUTED
links--;
rtems_rfs_inode_set_links (&parent_inode, links);
}
}
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
40037a0c: 52800022 mov w2, #0x1 // #1
40037a10: 910143e0 add x0, sp, #0x50
40037a14: 2a0203e1 mov w1, w2
40037a18: 97ffc5ba bl 40029100 <rtems_rfs_inode_time_stamp_now>
40037a1c: 2a0003f3 mov w19, w0
if (rc > 0)
40037a20: 7100001f cmp w0, #0x0
40037a24: 54000d0c b.gt 40037bc4 <rtems_rfs_unlink+0x2d4> <== NEVER TAKEN
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &parent_inode);
40037a28: 910143e1 add x1, sp, #0x50
40037a2c: aa1403e0 mov x0, x20
40037a30: 97ffc53c bl 40028f20 <rtems_rfs_inode_close>
40037a34: 2a0003f3 mov w19, w0
if (rc > 0)
40037a38: 7100001f cmp w0, #0x0
40037a3c: 540010ec b.gt 40037c58 <rtems_rfs_unlink+0x368> <== NEVER TAKEN
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &target_inode);
40037a40: 910243e1 add x1, sp, #0x90
40037a44: aa1403e0 mov x0, x20
40037a48: 97ffc536 bl 40028f20 <rtems_rfs_inode_close>
40037a4c: 2a0003f3 mov w19, w0
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
40037a50: 7100001f cmp w0, #0x0
40037a54: 5400126c b.gt 40037ca0 <rtems_rfs_unlink+0x3b0> <== NEVER TAKEN
printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",
rc, strerror (rc));
return rc;
}
40037a58: 2a1303e0 mov w0, w19
40037a5c: a94153f3 ldp x19, x20, [sp, #16]
40037a60: a9425bf5 ldp x21, x22, [sp, #32]
40037a64: a94363f7 ldp x23, x24, [sp, #48]
40037a68: f94023f9 ldr x25, [sp, #64]
40037a6c: a8cd7bfd ldp x29, x30, [sp], #208
40037a70: d65f03c0 ret
printf ("rtems-rfs: unlink: parent(%" PRIu32 ") -X-> (%" PRIu32 ")\n", parent, target);
40037a74: 2a1603e2 mov w2, w22 <== NOT EXECUTED
40037a78: 2a1703e1 mov w1, w23 <== NOT EXECUTED
40037a7c: 900000a0 adrp x0, 4004b000 <IMFS_LIMITS_AND_OPTIONS+0xbb8> <== NOT EXECUTED
40037a80: 910dc000 add x0, x0, #0x370 <== NOT EXECUTED
40037a84: 97ffaa63 bl 40022410 <__wrap_printf> <== NOT EXECUTED
40037a88: 17ffffa9 b 4003792c <rtems_rfs_unlink+0x3c> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
40037a8c: d2a04000 mov x0, #0x2000000 // #33554432 <== NOT EXECUTED
40037a90: 97ffcbf0 bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
40037a94: 72001c1f tst w0, #0xff <== NOT EXECUTED
40037a98: 54000d01 b.ne 40037c38 <rtems_rfs_unlink+0x348> // b.any <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
40037a9c: 910243e1 add x1, sp, #0x90
40037aa0: aa1403e0 mov x0, x20
40037aa4: 97ffc51f bl 40028f20 <rtems_rfs_inode_close>
}
40037aa8: 2a1303e0 mov w0, w19
40037aac: a94153f3 ldp x19, x20, [sp, #16]
40037ab0: a9425bf5 ldp x21, x22, [sp, #32]
40037ab4: a94363f7 ldp x23, x24, [sp, #48]
40037ab8: f94023f9 ldr x25, [sp, #64]
40037abc: a8cd7bfd ldp x29, x30, [sp], #208
40037ac0: d65f03c0 ret
rc = rtems_rfs_dir_empty (fs, &target_inode);
40037ac4: 910243e1 add x1, sp, #0x90
40037ac8: aa1403e0 mov x0, x20
40037acc: 97fff7f9 bl 40035ab0 <rtems_rfs_dir_empty>
40037ad0: 2a0003f3 mov w19, w0
if (rc > 0)
40037ad4: 7100001f cmp w0, #0x0
40037ad8: 54fff4ed b.le 40037974 <rtems_rfs_unlink+0x84>
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
40037adc: d2a04000 mov x0, #0x2000000 // #33554432
40037ae0: 97ffcbdc bl 4002aa50 <rtems_rfs_trace>
40037ae4: 72001c1f tst w0, #0xff
40037ae8: 54fffda0 b.eq 40037a9c <rtems_rfs_unlink+0x1ac> // b.none <== ALWAYS TAKEN
printf ("rtems-rfs: dir-empty: %d: %s\n", rc, strerror (rc));
40037aec: 2a1303e0 mov w0, w19 <== NOT EXECUTED
40037af0: 94001c4b bl 4003ec1c <strerror> <== NOT EXECUTED
40037af4: 900000a1 adrp x1, 4004b000 <IMFS_LIMITS_AND_OPTIONS+0xbb8> <== NOT EXECUTED
40037af8: aa0003e2 mov x2, x0 <== NOT EXECUTED
40037afc: 910f0020 add x0, x1, #0x3c0 <== NOT EXECUTED
40037b00: 2a1303e1 mov w1, w19 <== NOT EXECUTED
40037b04: 97ffaa43 bl 40022410 <__wrap_printf> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
40037b08: 17ffffe5 b 40037a9c <rtems_rfs_unlink+0x1ac> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
40037b0c: 97ffcbd1 bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
40037b10: 72001c1f tst w0, #0xff <== NOT EXECUTED
40037b14: 540010e1 b.ne 40037d30 <rtems_rfs_unlink+0x440> // b.any <== NOT EXECUTED
rc = rtems_rfs_inode_delete (fs, &target_inode);
40037b18: 910243e1 add x1, sp, #0x90
40037b1c: aa1403e0 mov x0, x20
40037b20: 97ffc528 bl 40028fc0 <rtems_rfs_inode_delete>
40037b24: 2a0003f3 mov w19, w0
if (rc > 0)
40037b28: 7100001f cmp w0, #0x0
40037b2c: 54000d2c b.gt 40037cd0 <rtems_rfs_unlink+0x3e0> <== NEVER TAKEN
if (dir)
40037b30: 714012bf cmp w21, #0x4, lsl #12
40037b34: 54fff6c1 b.ne 40037a0c <rtems_rfs_unlink+0x11c> // b.any
links = rtems_rfs_read_u16 (&handle->node->links);
40037b38: f94037e1 ldr x1, [sp, #104]
if (links == 0xffff)
40037b3c: 529fffe2 mov w2, #0xffff // #65535
40037b40: 39400023 ldrb w3, [x1]
40037b44: 39400420 ldrb w0, [x1, #1]
40037b48: aa002060 orr x0, x3, x0, lsl #8
40037b4c: 5ac00400 rev16 w0, w0
40037b50: 12003c00 and w0, w0, #0xffff
40037b54: 6b02001f cmp w0, w2
40037b58: 54000f80 b.eq 40037d48 <rtems_rfs_unlink+0x458> // b.none <== NEVER TAKEN
if (links > 1)
40037b5c: 7100041f cmp w0, #0x1
40037b60: 54000fa9 b.ls 40037d54 <rtems_rfs_unlink+0x464> // b.plast <== NEVER TAKEN
links--;
40037b64: 51000400 sub w0, w0, #0x1
rtems_rfs_write_u16 (&handle->node->links, links);
40037b68: 12001c02 and w2, w0, #0xff
40037b6c: d3483c00 ubfx x0, x0, #8, #8
40037b70: 39000020 strb w0, [x1]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40037b74: 52800020 mov w0, #0x1 // #1
rtems_rfs_write_u16 (&handle->node->links, links);
40037b78: f94037e1 ldr x1, [sp, #104]
40037b7c: 39000422 strb w2, [x1, #1]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40037b80: 3901c3e0 strb w0, [sp, #112]
}
40037b84: 17ffffa2 b 40037a0c <rtems_rfs_unlink+0x11c>
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
40037b88: d2a04000 mov x0, #0x2000000 // #33554432 <== NOT EXECUTED
40037b8c: 97ffcbb1 bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
40037b90: 72001c1f tst w0, #0xff <== NOT EXECUTED
40037b94: 54000b61 b.ne 40037d00 <rtems_rfs_unlink+0x410> // b.any <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
40037b98: 910243e1 add x1, sp, #0x90 <== NOT EXECUTED
40037b9c: aa1403e0 mov x0, x20 <== NOT EXECUTED
return EISDIR;
40037ba0: 528002b3 mov w19, #0x15 // #21 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
40037ba4: 97ffc4df bl 40028f20 <rtems_rfs_inode_close> <== NOT EXECUTED
}
40037ba8: 2a1303e0 mov w0, w19 <== NOT EXECUTED
40037bac: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40037bb0: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
40037bb4: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
40037bb8: f94023f9 ldr x25, [sp, #64] <== NOT EXECUTED
40037bbc: a8cd7bfd ldp x29, x30, [sp], #208 <== NOT EXECUTED
40037bc0: d65f03c0 ret <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
40037bc4: d2a04000 mov x0, #0x2000000 // #33554432 <== NOT EXECUTED
40037bc8: 97ffcba2 bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
40037bcc: 72001c1f tst w0, #0xff <== NOT EXECUTED
40037bd0: 54000a01 b.ne 40037d10 <rtems_rfs_unlink+0x420> // b.any <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
40037bd4: 910143e1 add x1, sp, #0x50 <== NOT EXECUTED
40037bd8: aa1403e0 mov x0, x20 <== NOT EXECUTED
40037bdc: 97ffc4d1 bl 40028f20 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
40037be0: 910243e1 add x1, sp, #0x90 <== NOT EXECUTED
40037be4: aa1403e0 mov x0, x20 <== NOT EXECUTED
40037be8: 97ffc4ce bl 40028f20 <rtems_rfs_inode_close> <== NOT EXECUTED
}
40037bec: 2a1303e0 mov w0, w19 <== NOT EXECUTED
40037bf0: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40037bf4: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
40037bf8: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
40037bfc: f94023f9 ldr x25, [sp, #64] <== NOT EXECUTED
40037c00: a8cd7bfd ldp x29, x30, [sp], #208 <== NOT EXECUTED
40037c04: d65f03c0 ret <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
40037c08: d2a04000 mov x0, #0x2000000 // #33554432 <== NOT EXECUTED
40037c0c: 97ffcb91 bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
40037c10: 72001c1f tst w0, #0xff <== NOT EXECUTED
40037c14: 54fffe00 b.eq 40037bd4 <rtems_rfs_unlink+0x2e4> // b.none <== NOT EXECUTED
printf ("rtems-rfs: unlink: dir-del failed: %d: %s\n",
40037c18: 2a1303e0 mov w0, w19 <== NOT EXECUTED
40037c1c: 94001c00 bl 4003ec1c <strerror> <== NOT EXECUTED
40037c20: 900000a1 adrp x1, 4004b000 <IMFS_LIMITS_AND_OPTIONS+0xbb8> <== NOT EXECUTED
40037c24: aa0003e2 mov x2, x0 <== NOT EXECUTED
40037c28: 91104020 add x0, x1, #0x410 <== NOT EXECUTED
40037c2c: 2a1303e1 mov w1, w19 <== NOT EXECUTED
40037c30: 97ffa9f8 bl 40022410 <__wrap_printf> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
40037c34: 17ffffe8 b 40037bd4 <rtems_rfs_unlink+0x2e4> <== NOT EXECUTED
printf ("rtems-rfs: link: inode-open failed: %d: %s\n",
40037c38: 2a1303e0 mov w0, w19 <== NOT EXECUTED
40037c3c: 94001bf8 bl 4003ec1c <strerror> <== NOT EXECUTED
40037c40: 900000a1 adrp x1, 4004b000 <IMFS_LIMITS_AND_OPTIONS+0xbb8> <== NOT EXECUTED
40037c44: aa0003e2 mov x2, x0 <== NOT EXECUTED
40037c48: 910f8020 add x0, x1, #0x3e0 <== NOT EXECUTED
40037c4c: 2a1303e1 mov w1, w19 <== NOT EXECUTED
40037c50: 97ffa9f0 bl 40022410 <__wrap_printf> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
40037c54: 17ffff92 b 40037a9c <rtems_rfs_unlink+0x1ac> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
40037c58: d2a04000 mov x0, #0x2000000 // #33554432 <== NOT EXECUTED
40037c5c: 97ffcb7d bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
40037c60: 72001c1f tst w0, #0xff <== NOT EXECUTED
40037c64: 54fff1c0 b.eq 40037a9c <rtems_rfs_unlink+0x1ac> // b.none <== NOT EXECUTED
printf ("rtems-rfs: link: parent inode-close failed: %d: %s\n",
40037c68: 2a1303e0 mov w0, w19 <== NOT EXECUTED
40037c6c: 94001bec bl 4003ec1c <strerror> <== NOT EXECUTED
40037c70: 900000a1 adrp x1, 4004b000 <IMFS_LIMITS_AND_OPTIONS+0xbb8> <== NOT EXECUTED
40037c74: aa0003e2 mov x2, x0 <== NOT EXECUTED
40037c78: 91134020 add x0, x1, #0x4d0 <== NOT EXECUTED
40037c7c: 2a1303e1 mov w1, w19 <== NOT EXECUTED
40037c80: 97ffa9e4 bl 40022410 <__wrap_printf> <== NOT EXECUTED
40037c84: 17ffff86 b 40037a9c <rtems_rfs_unlink+0x1ac> <== NOT EXECUTED
printf ("rtems-rfs: unlink: target:%" PRIu32 " links:%u\n", target, links);
40037c88: 2a1603e1 mov w1, w22 <== NOT EXECUTED
40037c8c: 2a1303e2 mov w2, w19 <== NOT EXECUTED
40037c90: 900000a0 adrp x0, 4004b000 <IMFS_LIMITS_AND_OPTIONS+0xbb8> <== NOT EXECUTED
40037c94: 91110000 add x0, x0, #0x440 <== NOT EXECUTED
40037c98: 97ffa9de bl 40022410 <__wrap_printf> <== NOT EXECUTED
40037c9c: 17ffff52 b 400379e4 <rtems_rfs_unlink+0xf4> <== NOT EXECUTED
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
40037ca0: d2a04000 mov x0, #0x2000000 // #33554432 <== NOT EXECUTED
40037ca4: 97ffcb6b bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
40037ca8: 72001c1f tst w0, #0xff <== NOT EXECUTED
40037cac: 54ffed60 b.eq 40037a58 <rtems_rfs_unlink+0x168> // b.none <== NOT EXECUTED
printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",
40037cb0: 2a1303e0 mov w0, w19 <== NOT EXECUTED
40037cb4: 94001bda bl 4003ec1c <strerror> <== NOT EXECUTED
40037cb8: 900000a1 adrp x1, 4004b000 <IMFS_LIMITS_AND_OPTIONS+0xbb8> <== NOT EXECUTED
40037cbc: aa0003e2 mov x2, x0 <== NOT EXECUTED
40037cc0: 91142020 add x0, x1, #0x508 <== NOT EXECUTED
40037cc4: 2a1303e1 mov w1, w19 <== NOT EXECUTED
40037cc8: 97ffa9d2 bl 40022410 <__wrap_printf> <== NOT EXECUTED
40037ccc: 17ffff63 b 40037a58 <rtems_rfs_unlink+0x168> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
40037cd0: d2a04000 mov x0, #0x2000000 // #33554432 <== NOT EXECUTED
40037cd4: 97ffcb5f bl 4002aa50 <rtems_rfs_trace> <== NOT EXECUTED
40037cd8: 72001c1f tst w0, #0xff <== NOT EXECUTED
40037cdc: 54fff7c0 b.eq 40037bd4 <rtems_rfs_unlink+0x2e4> // b.none <== NOT EXECUTED
printf ("rtems-rfs: unlink: inode-del failed: %d: %s\n",
40037ce0: 2a1303e0 mov w0, w19 <== NOT EXECUTED
40037ce4: 94001bce bl 4003ec1c <strerror> <== NOT EXECUTED
40037ce8: 900000a1 adrp x1, 4004b000 <IMFS_LIMITS_AND_OPTIONS+0xbb8> <== NOT EXECUTED
40037cec: aa0003e2 mov x2, x0 <== NOT EXECUTED
40037cf0: 9111a020 add x0, x1, #0x468 <== NOT EXECUTED
40037cf4: 2a1303e1 mov w1, w19 <== NOT EXECUTED
40037cf8: 97ffa9c6 bl 40022410 <__wrap_printf> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
40037cfc: 17ffffb6 b 40037bd4 <rtems_rfs_unlink+0x2e4> <== NOT EXECUTED
printf ("rtems-rfs: link is a directory\n");
40037d00: 900000a0 adrp x0, 4004b000 <IMFS_LIMITS_AND_OPTIONS+0xbb8> <== NOT EXECUTED
40037d04: 910e8000 add x0, x0, #0x3a0 <== NOT EXECUTED
40037d08: 97ffa9e6 bl 400224a0 <__wrap_puts> <== NOT EXECUTED
40037d0c: 17ffffa3 b 40037b98 <rtems_rfs_unlink+0x2a8> <== NOT EXECUTED
printf ("rtems-rfs: link: inode-time-stamp failed: %d: %s\n",
40037d10: 2a1303e0 mov w0, w19 <== NOT EXECUTED
40037d14: 94001bc2 bl 4003ec1c <strerror> <== NOT EXECUTED
40037d18: 900000a1 adrp x1, 4004b000 <IMFS_LIMITS_AND_OPTIONS+0xbb8> <== NOT EXECUTED
40037d1c: aa0003e2 mov x2, x0 <== NOT EXECUTED
40037d20: 91126020 add x0, x1, #0x498 <== NOT EXECUTED
40037d24: 2a1303e1 mov w1, w19 <== NOT EXECUTED
40037d28: 97ffa9ba bl 40022410 <__wrap_printf> <== NOT EXECUTED
40037d2c: 17ffffaa b 40037bd4 <rtems_rfs_unlink+0x2e4> <== NOT EXECUTED
printf ("rtems-rfs: unlink: target:%" PRIu32 " links:%u\n", target, links);
40037d30: 2a1603e1 mov w1, w22 <== NOT EXECUTED
40037d34: 900000a0 adrp x0, 4004b000 <IMFS_LIMITS_AND_OPTIONS+0xbb8> <== NOT EXECUTED
40037d38: 52800002 mov w2, #0x0 // #0 <== NOT EXECUTED
40037d3c: 91110000 add x0, x0, #0x440 <== NOT EXECUTED
40037d40: 97ffa9b4 bl 40022410 <__wrap_printf> <== NOT EXECUTED
if (links > 1)
40037d44: 17ffff75 b 40037b18 <rtems_rfs_unlink+0x228> <== NOT EXECUTED
40037d48: 52800002 mov w2, #0x0 // #0 <== NOT EXECUTED
40037d4c: 52800000 mov w0, #0x0 // #0 <== NOT EXECUTED
40037d50: 17ffff88 b 40037b70 <rtems_rfs_unlink+0x280> <== NOT EXECUTED
rtems_rfs_write_u16 (&handle->node->links, links);
40037d54: 12001c02 and w2, w0, #0xff <== NOT EXECUTED
40037d58: 52800000 mov w0, #0x0 // #0 <== NOT EXECUTED
40037d5c: 17ffff85 b 40037b70 <rtems_rfs_unlink+0x280> <== NOT EXECUTED