RTEMS-6
Annotated Report
librfs
Sun Feb 28 23:42:17 2021
00108254 <rtems_rfs_bitmap_create_search>:
if (!control->buffer)
108254: 6801 ldr r1, [r0, #0]
108256: 2900 cmp r1, #0
108258: d049 beq.n 1082ee <rtems_rfs_bitmap_create_search+0x9a>
int
rtems_rfs_bitmap_create_search (rtems_rfs_bitmap_control* control)
{
10825a: e92d 41f0 stmdb sp!, {r4, r5, r6, r7, r8, lr}
rc = rtems_rfs_buffer_handle_request (control->fs,
10825e: 2301 movs r3, #1
108260: 4605 mov r5, r0
108262: e9d0 0201 ldrd r0, r2, [r0, #4]
108266: f000 f999 bl 10859c <rtems_rfs_buffer_handle_request>
if (rc)
10826a: 2800 cmp r0, #0
10826c: d13c bne.n 1082e8 <rtems_rfs_bitmap_create_search+0x94> <== ALWAYS TAKEN
*map = rtems_rfs_buffer_data (control->buffer);
10826e: 682b ldr r3, [r5, #0]
108270: 689b ldr r3, [r3, #8]
108272: 69db ldr r3, [r3, #28]
if (rc > 0)
return rc;
control->free = 0;
search_map = control->search_bits;
size = control->size;
108274: 68ec ldr r4, [r5, #12]
control->free = 0;
108276: 2600 movs r6, #0
search_map = control->search_bits;
108278: f8d5 8014 ldr.w r8, [r5, #20]
bit = 0;
rtems_rfs_bitmap_check(control, search_map);
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
10827c: f04f 37ff mov.w r7, #4294967295 ; 0xffffffff
control->free = 0;
108280: 612e str r6, [r5, #16]
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
108282: f8c8 7000 str.w r7, [r8]
while (size)
108286: b16c cbz r4, 1082a4 <rtems_rfs_bitmap_create_search+0x50>
108288: 469c mov ip, r3
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
10828a: f04f 0e01 mov.w lr, #1
{
rtems_rfs_bitmap_element bits;
int available;
if (size < rtems_rfs_bitmap_element_bits ())
10828e: 2c1f cmp r4, #31
{
bits = rtems_rfs_bitmap_merge (*map,
108290: f85c 1b04 ldr.w r1, [ip], #4
if (size < rtems_rfs_bitmap_element_bits ())
108294: d809 bhi.n 1082aa <rtems_rfs_bitmap_create_search+0x56>
mask >>= (rtems_rfs_bitmap_element_bits () - size);
108296: f1c4 0320 rsb r3, r4, #32
RTEMS_RFS_BITMAP_ELEMENT_SET,
rtems_rfs_bitmap_mask_section (0, size));
available = size;
10829a: 4620 mov r0, r4
mask >>= (rtems_rfs_bitmap_element_bits () - size);
10829c: fa27 f303 lsr.w r3, r7, r3
{
bits = *map;
available = rtems_rfs_bitmap_element_bits ();
}
if (rtems_rfs_bitmap_match (bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
1082a0: 4019 ands r1, r3
1082a2: d11f bne.n 1082e4 <rtems_rfs_bitmap_create_search+0x90>
else
bit++;
map++;
}
return 0;
1082a4: 2000 movs r0, #0
}
1082a6: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
available = rtems_rfs_bitmap_element_bits ();
1082aa: 3c20 subs r4, #32
if (rtems_rfs_bitmap_match (bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
1082ac: b969 cbnz r1, 1082ca <rtems_rfs_bitmap_create_search+0x76>
if (bit == (rtems_rfs_bitmap_element_bits () - 1))
1082ae: 2e1f cmp r6, #31
1082b0: d003 beq.n 1082ba <rtems_rfs_bitmap_create_search+0x66>
bit++;
1082b2: 3601 adds r6, #1
while (size)
1082b4: 2c00 cmp r4, #0
1082b6: d1ea bne.n 10828e <rtems_rfs_bitmap_create_search+0x3a>
1082b8: e7f4 b.n 1082a4 <rtems_rfs_bitmap_create_search+0x50>
if (size > 0)
1082ba: 2c00 cmp r4, #0
1082bc: d0f2 beq.n 1082a4 <rtems_rfs_bitmap_create_search+0x50>
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
1082be: f8c8 7004 str.w r7, [r8, #4]
bit = 0;
1082c2: 2600 movs r6, #0
search_map++;
1082c4: f108 0804 add.w r8, r8, #4
1082c8: e7e1 b.n 10828e <rtems_rfs_bitmap_create_search+0x3a>
available = rtems_rfs_bitmap_element_bits ();
1082ca: 2020 movs r0, #32
for (b = 0; b < available; b++)
1082cc: 2300 movs r3, #0
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
1082ce: fa0e f203 lsl.w r2, lr, r3
if (!rtems_rfs_bitmap_test (bits, b))
1082d2: 3301 adds r3, #1
1082d4: 420a tst r2, r1
control->free++;
1082d6: bf1e ittt ne
1082d8: 692a ldrne r2, [r5, #16]
1082da: 3201 addne r2, #1
1082dc: 612a strne r2, [r5, #16]
for (b = 0; b < available; b++)
1082de: 4298 cmp r0, r3
1082e0: d1f5 bne.n 1082ce <rtems_rfs_bitmap_create_search+0x7a>
1082e2: e7e4 b.n 1082ae <rtems_rfs_bitmap_create_search+0x5a>
if (rtems_rfs_bitmap_match (bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
1082e4: 2400 movs r4, #0
1082e6: e7f1 b.n 1082cc <rtems_rfs_bitmap_create_search+0x78>
if (rc > 0)
1082e8: dcdd bgt.n 1082a6 <rtems_rfs_bitmap_create_search+0x52> <== NOT EXECUTED
*map = NULL;
1082ea: 2300 movs r3, #0 <== NOT EXECUTED
1082ec: e7c2 b.n 108274 <rtems_rfs_bitmap_create_search+0x20> <== NOT EXECUTED
return ENXIO;
1082ee: 2006 movs r0, #6
}
1082f0: 4770 bx lr
1082f2: bf00 nop
001081d0 <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)
{
1081d0: e92d 41f0 stmdb sp!, {r4, r5, r6, r7, r8, lr}
1081d4: 460c mov r4, r1
1081d6: 4606 mov r6, r0
1081d8: 4698 mov r8, r3
* 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;
1081da: 460d mov r5, r1
{
1081dc: 4617 mov r7, r2
*allocated = false;
1081de: 2200 movs r2, #0
1081e0: 703a strb r2, [r7, #0]
* 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))
1081e2: 2c00 cmp r4, #0
1081e4: db17 blt.n 108216 <rtems_rfs_bitmap_map_alloc+0x46> <== ALWAYS TAKEN
1081e6: 68f3 ldr r3, [r6, #12]
1081e8: 42a3 cmp r3, r4
1081ea: d914 bls.n 108216 <rtems_rfs_bitmap_map_alloc+0x46>
* Search up first so bits allocated in succession are grouped together.
*/
if (upper_seed < control->size)
{
*bit = upper_seed;
rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
1081ec: 2301 movs r3, #1
1081ee: 463a mov r2, r7
1081f0: 4641 mov r1, r8
1081f2: 4630 mov r0, r6
*bit = upper_seed;
1081f4: f8c8 4000 str.w r4, [r8]
rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
1081f8: f7ff fe18 bl 107e2c <rtems_rfs_search_map_for_clear_bit.constprop.0>
window, 1);
if ((rc > 0) || *allocated)
1081fc: 2800 cmp r0, #0
1081fe: dc26 bgt.n 10824e <rtems_rfs_bitmap_map_alloc+0x7e> <== ALWAYS TAKEN
108200: 783b ldrb r3, [r7, #0]
108202: bb23 cbnz r3, 10824e <rtems_rfs_bitmap_map_alloc+0x7e>
break;
}
if (lower_seed >= 0)
108204: 2d00 cmp r5, #0
108206: da0d bge.n 108224 <rtems_rfs_bitmap_map_alloc+0x54>
/*
* 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)
108208: 68f3 ldr r3, [r6, #12]
10820a: 429c cmp r4, r3
upper_seed += window;
10820c: bf38 it cc
10820e: f504 6400 addcc.w r4, r4, #2048 ; 0x800
while (((upper_seed >= 0) && (upper_seed < control->size))
108212: 2c00 cmp r4, #0
108214: dae7 bge.n 1081e6 <rtems_rfs_bitmap_map_alloc+0x16> <== NEVER TAKEN
|| ((lower_seed >= 0) && (lower_seed < control->size)))
108216: 2d00 cmp r5, #0
108218: db19 blt.n 10824e <rtems_rfs_bitmap_map_alloc+0x7e>
10821a: 68f0 ldr r0, [r6, #12]
10821c: 42a8 cmp r0, r5
10821e: d916 bls.n 10824e <rtems_rfs_bitmap_map_alloc+0x7e>
if (upper_seed < control->size)
108220: 4284 cmp r4, r0
108222: d3e3 bcc.n 1081ec <rtems_rfs_bitmap_map_alloc+0x1c> <== ALWAYS TAKEN
rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
108224: f04f 33ff mov.w r3, #4294967295 ; 0xffffffff
108228: 463a mov r2, r7
10822a: 4641 mov r1, r8
10822c: 4630 mov r0, r6
*bit = lower_seed;
10822e: f8c8 5000 str.w r5, [r8]
rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
108232: f7ff fdfb bl 107e2c <rtems_rfs_search_map_for_clear_bit.constprop.0>
if ((rc > 0) || *allocated)
108236: 2800 cmp r0, #0
108238: dc09 bgt.n 10824e <rtems_rfs_bitmap_map_alloc+0x7e> <== ALWAYS TAKEN
10823a: 783b ldrb r3, [r7, #0]
10823c: b93b cbnz r3, 10824e <rtems_rfs_bitmap_map_alloc+0x7e>
if (upper_seed < control->size)
10823e: 68f3 ldr r3, [r6, #12]
if (lower_seed >= 0)
lower_seed -= window;
108240: f5a5 6500 sub.w r5, r5, #2048 ; 0x800
if (upper_seed < control->size)
108244: 429c cmp r4, r3
upper_seed += window;
108246: bf38 it cc
108248: f504 6400 addcc.w r4, r4, #2048 ; 0x800
lower_seed -= window;
10824c: e7c9 b.n 1081e2 <rtems_rfs_bitmap_map_alloc+0x12>
}
return 0;
}
10824e: 2000 movs r0, #0
108250: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
00108048 <rtems_rfs_bitmap_map_clear>:
{
108048: b5f8 push {r3, r4, r5, r6, r7, lr}
10804a: 460d mov r5, r1
if (!control->buffer)
10804c: 6801 ldr r1, [r0, #0]
10804e: b399 cbz r1, 1080b8 <rtems_rfs_bitmap_map_clear+0x70>
rc = rtems_rfs_buffer_handle_request (control->fs,
108050: 4604 mov r4, r0
108052: 2301 movs r3, #1
108054: e9d0 0201 ldrd r0, r2, [r0, #4]
108058: f000 faa0 bl 10859c <rtems_rfs_buffer_handle_request>
if (rc)
10805c: 2800 cmp r0, #0
10805e: d128 bne.n 1080b2 <rtems_rfs_bitmap_map_clear+0x6a> <== ALWAYS TAKEN
*map = rtems_rfs_buffer_data (control->buffer);
108060: 6823 ldr r3, [r4, #0]
108062: 689b ldr r3, [r3, #8]
108064: 69d8 ldr r0, [r3, #28]
if (bit >= control->size)
108066: 68e3 ldr r3, [r4, #12]
108068: 42ab cmp r3, r5
return EINVAL;
10806a: bf98 it ls
10806c: 2016 movls r0, #22
if (bit >= control->size)
10806e: d91f bls.n 1080b0 <rtems_rfs_bitmap_map_clear+0x68> <== ALWAYS TAKEN
index = rtems_rfs_bitmap_map_index (bit);
108070: 116a asrs r2, r5, #5
offset = rtems_rfs_bitmap_map_offset (bit);
108072: f005 031f and.w r3, r5, #31
map[index] = rtems_rfs_bitmap_clear (element, 1 << offset);
108076: 2101 movs r1, #1
search_map = control->search_bits;
108078: 6966 ldr r6, [r4, #20]
element = map[index];
10807a: f850 7022 ldr.w r7, [r0, r2, lsl #2]
map[index] = rtems_rfs_bitmap_clear (element, 1 << offset);
10807e: fa01 f303 lsl.w r3, r1, r3
return RTEMS_RFS_BITMAP_CLEAR_BITS (target, bits);
108082: 433b orrs r3, r7
if (rtems_rfs_bitmap_match(element, map[index]))
108084: 429f cmp r7, r3
map[index] = rtems_rfs_bitmap_clear (element, 1 << offset);
108086: f840 3022 str.w r3, [r0, r2, lsl #2]
return 0;
10808a: bf08 it eq
10808c: 2000 moveq r0, #0
if (rtems_rfs_bitmap_match(element, map[index]))
10808e: d00f beq.n 1080b0 <rtems_rfs_bitmap_map_clear+0x68> <== ALWAYS TAKEN
index = rtems_rfs_bitmap_map_index (bit);
108090: 12ad asrs r5, r5, #10
offset = rtems_rfs_bitmap_map_offset(bit);
108092: f002 021f and.w r2, r2, #31
search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset);
108096: fa01 f202 lsl.w r2, r1, r2
rtems_rfs_buffer_mark_dirty (control->buffer);
10809a: 6820 ldr r0, [r4, #0]
return RTEMS_RFS_BITMAP_CLEAR_BITS (target, bits);
10809c: f856 3025 ldr.w r3, [r6, r5, lsl #2]
1080a0: 431a orrs r2, r3
search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset);
1080a2: f846 2025 str.w r2, [r6, r5, lsl #2]
control->free++;
1080a6: 6923 ldr r3, [r4, #16]
rtems_rfs_buffer_mark_dirty (control->buffer);
1080a8: 7001 strb r1, [r0, #0]
return 0;
1080aa: 2000 movs r0, #0
control->free++;
1080ac: 440b add r3, r1
1080ae: 6123 str r3, [r4, #16]
}
1080b0: bdf8 pop {r3, r4, r5, r6, r7, pc}
if (rc > 0)
1080b2: dcfd bgt.n 1080b0 <rtems_rfs_bitmap_map_clear+0x68> <== NOT EXECUTED
*map = NULL;
1080b4: 2000 movs r0, #0 <== NOT EXECUTED
1080b6: e7d6 b.n 108066 <rtems_rfs_bitmap_map_clear+0x1e> <== NOT EXECUTED
return ENXIO;
1080b8: 2006 movs r0, #6
}
1080ba: bdf8 pop {r3, r4, r5, r6, r7, pc}
00108160 <rtems_rfs_bitmap_map_clear_all>:
if (!control->buffer)
108160: 6801 ldr r1, [r0, #0]
108162: b391 cbz r1, 1081ca <rtems_rfs_bitmap_map_clear_all+0x6a>
{
108164: b5f8 push {r3, r4, r5, r6, r7, lr}
108166: 4604 mov r4, r0
rc = rtems_rfs_buffer_handle_request (control->fs,
108168: 2301 movs r3, #1
10816a: e9d0 0201 ldrd r0, r2, [r0, #4]
10816e: f000 fa15 bl 10859c <rtems_rfs_buffer_handle_request>
if (rc)
108172: 2800 cmp r0, #0
108174: d125 bne.n 1081c2 <rtems_rfs_bitmap_map_clear_all+0x62> <== ALWAYS TAKEN
*map = rtems_rfs_buffer_data (control->buffer);
108176: 6827 ldr r7, [r4, #0]
108178: 68bb ldr r3, [r7, #8]
10817a: 69d8 ldr r0, [r3, #28]
elements = rtems_rfs_bitmap_elements (control->size);
10817c: 68e3 ldr r3, [r4, #12]
map[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
10817e: 21ff movs r1, #255 ; 0xff
elements = rtems_rfs_bitmap_elements (control->size);
108180: 1e5e subs r6, r3, #1
control->free = control->size;
108182: 6123 str r3, [r4, #16]
elements = rtems_rfs_bitmap_elements (control->size);
108184: 0975 lsrs r5, r6, #5
108186: 3501 adds r5, #1
map[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
108188: 00aa lsls r2, r5, #2
10818a: f00e fd45 bl 116c18 <memset>
if (last_search_bit == 0)
10818e: f015 051f ands.w r5, r5, #31
mask >>= (rtems_rfs_bitmap_element_bits () - size);
108192: bf1d ittte ne
108194: f04f 33ff movne.w r3, #4294967295 ; 0xffffffff
108198: f1c5 0520 rsbne r5, r5, #32
10819c: fa23 f505 lsrne.w r5, r3, r5
1081a0: f04f 35ff moveq.w r5, #4294967295 ; 0xffffffff
for (e = 0; e < (elements - 1); e++)
1081a4: 0ab6 lsrs r6, r6, #10
control->search_bits[elements - 1] =
1081a6: 6963 ldr r3, [r4, #20]
for (e = 0; e < (elements - 1); e++)
1081a8: d005 beq.n 1081b6 <rtems_rfs_bitmap_map_clear_all+0x56> <== NEVER TAKEN
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
1081aa: 4618 mov r0, r3 <== NOT EXECUTED
1081ac: 00b2 lsls r2, r6, #2 <== NOT EXECUTED
1081ae: 21ff movs r1, #255 ; 0xff <== NOT EXECUTED
1081b0: f00e fd32 bl 116c18 <memset> <== NOT EXECUTED
1081b4: 4603 mov r3, r0 <== NOT EXECUTED
return 0;
1081b6: 2000 movs r0, #0
rtems_rfs_buffer_mark_dirty (control->buffer);
1081b8: 2201 movs r2, #1
control->search_bits[elements - 1] =
1081ba: f843 5026 str.w r5, [r3, r6, lsl #2]
rtems_rfs_buffer_mark_dirty (control->buffer);
1081be: 703a strb r2, [r7, #0]
}
1081c0: bdf8 pop {r3, r4, r5, r6, r7, pc}
if (rc > 0)
1081c2: dcfd bgt.n 1081c0 <rtems_rfs_bitmap_map_clear_all+0x60> <== NOT EXECUTED
*map = rtems_rfs_buffer_data (control->buffer);
1081c4: 6827 ldr r7, [r4, #0] <== NOT EXECUTED
*map = NULL;
1081c6: 2000 movs r0, #0 <== NOT EXECUTED
1081c8: e7d8 b.n 10817c <rtems_rfs_bitmap_map_clear_all+0x1c> <== NOT EXECUTED
return ENXIO;
1081ca: 2006 movs r0, #6
}
1081cc: 4770 bx lr
1081ce: bf00 nop
00107fc4 <rtems_rfs_bitmap_map_set>:
{
107fc4: b570 push {r4, r5, r6, lr}
107fc6: 460d mov r5, r1
if (!control->buffer)
107fc8: 6801 ldr r1, [r0, #0]
107fca: 2900 cmp r1, #0
107fcc: d039 beq.n 108042 <rtems_rfs_bitmap_map_set+0x7e>
rc = rtems_rfs_buffer_handle_request (control->fs,
107fce: 4604 mov r4, r0
107fd0: 2301 movs r3, #1
107fd2: e9d0 0201 ldrd r0, r2, [r0, #4]
107fd6: f000 fae1 bl 10859c <rtems_rfs_buffer_handle_request>
if (rc)
107fda: 2800 cmp r0, #0
107fdc: d12e bne.n 10803c <rtems_rfs_bitmap_map_set+0x78> <== ALWAYS TAKEN
*map = rtems_rfs_buffer_data (control->buffer);
107fde: 6823 ldr r3, [r4, #0]
107fe0: 689b ldr r3, [r3, #8]
107fe2: 69d9 ldr r1, [r3, #28]
if (bit >= control->size)
107fe4: 68e3 ldr r3, [r4, #12]
107fe6: 42ab cmp r3, r5
return EINVAL;
107fe8: bf98 it ls
107fea: 2016 movls r0, #22
if (bit >= control->size)
107fec: d923 bls.n 108036 <rtems_rfs_bitmap_map_set+0x72> <== ALWAYS TAKEN
index = rtems_rfs_bitmap_map_index (bit);
107fee: 116a asrs r2, r5, #5
offset = rtems_rfs_bitmap_map_offset (bit);
107ff0: f005 031f and.w r3, r5, #31
map[index] = rtems_rfs_bitmap_set (element, 1 << offset);
107ff4: f04f 0c01 mov.w ip, #1
search_map = control->search_bits;
107ff8: 6966 ldr r6, [r4, #20]
element = map[index];
107ffa: f851 0022 ldr.w r0, [r1, r2, lsl #2]
map[index] = rtems_rfs_bitmap_set (element, 1 << offset);
107ffe: fa0c f303 lsl.w r3, ip, r3
return RTEMS_RFS_BITMAP_SET_BITS (target, bits);
108002: ea20 0303 bic.w r3, r0, r3
if (rtems_rfs_bitmap_match(element, map[index]))
108006: 4298 cmp r0, r3
map[index] = rtems_rfs_bitmap_set (element, 1 << offset);
108008: f841 3022 str.w r3, [r1, r2, lsl #2]
if (rtems_rfs_bitmap_match(element, map[index]))
10800c: d014 beq.n 108038 <rtems_rfs_bitmap_map_set+0x74> <== ALWAYS TAKEN
control->free--;
10800e: 6923 ldr r3, [r4, #16]
108010: 3b01 subs r3, #1
108012: 6123 str r3, [r4, #16]
if (rtems_rfs_bitmap_match(map[index], RTEMS_RFS_BITMAP_ELEMENT_SET))
108014: f851 0022 ldr.w r0, [r1, r2, lsl #2]
rtems_rfs_buffer_mark_dirty (control->buffer);
108018: 6823 ldr r3, [r4, #0]
10801a: f883 c000 strb.w ip, [r3]
if (rtems_rfs_bitmap_match(map[index], RTEMS_RFS_BITMAP_ELEMENT_SET))
10801e: b958 cbnz r0, 108038 <rtems_rfs_bitmap_map_set+0x74>
index = rtems_rfs_bitmap_map_index (bit);
108020: 12ad asrs r5, r5, #10 <== NOT EXECUTED
offset = rtems_rfs_bitmap_map_offset (bit);
108022: f002 021f and.w r2, r2, #31 <== NOT EXECUTED
search_map[index] = rtems_rfs_bitmap_set (search_map[index], 1 << offset);
108026: fa0c f202 lsl.w r2, ip, r2 <== NOT EXECUTED
return RTEMS_RFS_BITMAP_SET_BITS (target, bits);
10802a: f856 3025 ldr.w r3, [r6, r5, lsl #2] <== NOT EXECUTED
10802e: ea23 0202 bic.w r2, r3, r2 <== NOT EXECUTED
search_map[index] = rtems_rfs_bitmap_set (search_map[index], 1 << offset);
108032: f846 2025 str.w r2, [r6, r5, lsl #2] <== NOT EXECUTED
}
108036: bd70 pop {r4, r5, r6, pc} <== NOT EXECUTED
return 0;
108038: 2000 movs r0, #0
}
10803a: bd70 pop {r4, r5, r6, pc}
if (rc > 0)
10803c: dcfb bgt.n 108036 <rtems_rfs_bitmap_map_set+0x72> <== NOT EXECUTED
*map = NULL;
10803e: 2100 movs r1, #0 <== NOT EXECUTED
108040: e7d0 b.n 107fe4 <rtems_rfs_bitmap_map_set+0x20> <== NOT EXECUTED
return ENXIO;
108042: 2006 movs r0, #6
}
108044: bd70 pop {r4, r5, r6, pc}
108046: bf00 nop
0010810c <rtems_rfs_bitmap_map_set_all>:
if (!control->buffer)
10810c: 6801 ldr r1, [r0, #0]
10810e: b321 cbz r1, 10815a <rtems_rfs_bitmap_map_set_all+0x4e>
{
108110: b5f8 push {r3, r4, r5, r6, r7, lr}
108112: 4604 mov r4, r0
rc = rtems_rfs_buffer_handle_request (control->fs,
108114: 2301 movs r3, #1
108116: e9d0 0201 ldrd r0, r2, [r0, #4]
10811a: f000 fa3f bl 10859c <rtems_rfs_buffer_handle_request>
if (rc)
10811e: 2800 cmp r0, #0
108120: d117 bne.n 108152 <rtems_rfs_bitmap_map_set_all+0x46> <== ALWAYS TAKEN
*map = rtems_rfs_buffer_data (control->buffer);
108122: 6827 ldr r7, [r4, #0]
108124: 68bb ldr r3, [r7, #8]
108126: 69d8 ldr r0, [r3, #28]
elements = rtems_rfs_bitmap_elements (control->size);
108128: 68e6 ldr r6, [r4, #12]
control->free = 0;
10812a: 2500 movs r5, #0
map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
10812c: 4629 mov r1, r5
control->free = 0;
10812e: 6125 str r5, [r4, #16]
elements = rtems_rfs_bitmap_elements (control->size);
108130: 3e01 subs r6, #1
108132: 0972 lsrs r2, r6, #5
108134: 3201 adds r2, #1
map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
108136: 0092 lsls r2, r2, #2
108138: f00e fd6e bl 116c18 <memset>
elements = rtems_rfs_bitmap_elements (elements);
10813c: 0ab2 lsrs r2, r6, #10
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
10813e: 6960 ldr r0, [r4, #20]
108140: 4629 mov r1, r5
elements = rtems_rfs_bitmap_elements (elements);
108142: 3201 adds r2, #1
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
108144: 0092 lsls r2, r2, #2
108146: f00e fd67 bl 116c18 <memset>
return 0;
10814a: 4628 mov r0, r5
rtems_rfs_buffer_mark_dirty (control->buffer);
10814c: 2301 movs r3, #1
10814e: 703b strb r3, [r7, #0]
}
108150: bdf8 pop {r3, r4, r5, r6, r7, pc}
if (rc > 0)
108152: dcfd bgt.n 108150 <rtems_rfs_bitmap_map_set_all+0x44> <== NOT EXECUTED
*map = rtems_rfs_buffer_data (control->buffer);
108154: 6827 ldr r7, [r4, #0] <== NOT EXECUTED
*map = NULL;
108156: 2000 movs r0, #0 <== NOT EXECUTED
108158: e7e6 b.n 108128 <rtems_rfs_bitmap_map_set_all+0x1c> <== NOT EXECUTED
return ENXIO;
10815a: 2006 movs r0, #6
}
10815c: 4770 bx lr
10815e: bf00 nop
001080bc <rtems_rfs_bitmap_map_test>:
{
1080bc: b570 push {r4, r5, r6, lr}
1080be: 4604 mov r4, r0
if (!control->buffer)
1080c0: 6800 ldr r0, [r0, #0]
1080c2: b300 cbz r0, 108106 <rtems_rfs_bitmap_map_test+0x4a>
rc = rtems_rfs_buffer_handle_request (control->fs,
1080c4: 460d mov r5, r1
1080c6: 4616 mov r6, r2
1080c8: 4601 mov r1, r0
1080ca: 2301 movs r3, #1
1080cc: e9d4 0201 ldrd r0, r2, [r4, #4]
1080d0: f000 fa64 bl 10859c <rtems_rfs_buffer_handle_request>
if (rc)
1080d4: 2800 cmp r0, #0
1080d6: d113 bne.n 108100 <rtems_rfs_bitmap_map_test+0x44> <== ALWAYS TAKEN
*map = rtems_rfs_buffer_data (control->buffer);
1080d8: 6823 ldr r3, [r4, #0]
1080da: 689b ldr r3, [r3, #8]
1080dc: 69da ldr r2, [r3, #28]
if (bit >= control->size)
1080de: 68e3 ldr r3, [r4, #12]
1080e0: 42ab cmp r3, r5
return EINVAL;
1080e2: bf98 it ls
1080e4: 2016 movls r0, #22
if (bit >= control->size)
1080e6: d90a bls.n 1080fe <rtems_rfs_bitmap_map_test+0x42> <== ALWAYS TAKEN
index = rtems_rfs_bitmap_map_index (bit);
1080e8: 116b asrs r3, r5, #5
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
1080ea: 2101 movs r1, #1
1080ec: 40a9 lsls r1, r5
return 0;
1080ee: 2000 movs r0, #0
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
1080f0: f852 3023 ldr.w r3, [r2, r3, lsl #2]
1080f4: 4219 tst r1, r3
1080f6: bf0c ite eq
1080f8: 2301 moveq r3, #1
1080fa: 4603 movne r3, r0
1080fc: 7033 strb r3, [r6, #0]
}
1080fe: bd70 pop {r4, r5, r6, pc}
if (rc > 0)
108100: dcfd bgt.n 1080fe <rtems_rfs_bitmap_map_test+0x42> <== NOT EXECUTED
*map = NULL;
108102: 2200 movs r2, #0 <== NOT EXECUTED
108104: e7eb b.n 1080de <rtems_rfs_bitmap_map_test+0x22> <== NOT EXECUTED
return ENXIO;
108106: 2006 movs r0, #6
}
108108: bd70 pop {r4, r5, r6, pc}
10810a: bf00 nop
00110930 <rtems_rfs_block_map_close>:
{
110930: e92d 41f0 stmdb sp!, {r4, r5, r6, r7, r8, lr}
110934: 460c mov r4, r1
if (map->dirty && map->inode)
110936: 780e ldrb r6, [r1, #0]
{
110938: 4607 mov r7, r0
if (map->dirty && map->inode)
11093a: b12e cbz r6, 110948 <rtems_rfs_block_map_close+0x18>
11093c: 6849 ldr r1, [r1, #4]
11093e: b1d9 cbz r1, 110978 <rtems_rfs_block_map_close+0x48>
brc = rtems_rfs_inode_load (fs, map->inode);
110940: f7f8 ffce bl 1098e0 <rtems_rfs_inode_load>
if (brc > 0)
110944: 1e06 subs r6, r0, #0
110946: dd19 ble.n 11097c <rtems_rfs_block_map_close+0x4c> <== NEVER TAKEN
110948: f104 0838 add.w r8, r4, #56 ; 0x38
map->inode = NULL;
11094c: 2500 movs r5, #0
rtems_rfs_buffer_handle_release (fs, handle);
11094e: 4641 mov r1, r8
110950: 4638 mov r0, r7
110952: 6065 str r5, [r4, #4]
110954: f7f7 ff0e bl 108774 <rtems_rfs_buffer_handle_release>
110958: f104 0144 add.w r1, r4, #68 ; 0x44
11095c: 4638 mov r0, r7
handle->dirty = false;
11095e: f884 5038 strb.w r5, [r4, #56] ; 0x38
handle->buffer = NULL;
110962: e9c4 550f strd r5, r5, [r4, #60] ; 0x3c
rtems_rfs_buffer_handle_release (fs, handle);
110966: f7f7 ff05 bl 108774 <rtems_rfs_buffer_handle_release>
}
11096a: 4630 mov r0, r6
handle->dirty = false;
11096c: f884 5044 strb.w r5, [r4, #68] ; 0x44
handle->buffer = NULL;
110970: e9c4 5512 strd r5, r5, [r4, #72] ; 0x48
110974: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
int rc = 0;
110978: 460e mov r6, r1 <== NOT EXECUTED
11097a: e7e5 b.n 110948 <rtems_rfs_block_map_close+0x18> <== NOT EXECUTED
11097c: f64f 7cf4 movw ip, #65524 ; 0xfff4
110980: f104 0024 add.w r0, r4, #36 ; 0x24
110984: f6cf 7cff movt ip, #65535 ; 0xffff
110988: f104 0838 add.w r8, r4, #56 ; 0x38
11098c: ebac 0c04 sub.w ip, ip, r4
rtems_rfs_buffer_mark_dirty (&handle->buffer);
110990: 2601 movs r6, #1
rtems_rfs_inode_set_block (map->inode, b, map->blocks[b]);
110992: f850 2b04 ldr.w r2, [r0], #4
110996: 6863 ldr r3, [r4, #4]
rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);
110998: eb0c 0100 add.w r1, ip, r0
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
11099c: 4580 cmp r8, r0
11099e: 68dd ldr r5, [r3, #12]
1109a0: ea4f 6e12 mov.w lr, r2, lsr #24
1109a4: f805 e001 strb.w lr, [r5, r1]
1109a8: ea4f 4e12 mov.w lr, r2, lsr #16
1109ac: 68dd ldr r5, [r3, #12]
1109ae: 440d add r5, r1
1109b0: f885 e001 strb.w lr, [r5, #1]
1109b4: ea4f 2e12 mov.w lr, r2, lsr #8
1109b8: 68dd ldr r5, [r3, #12]
1109ba: 440d add r5, r1
1109bc: f885 e002 strb.w lr, [r5, #2]
1109c0: 68dd ldr r5, [r3, #12]
1109c2: 4429 add r1, r5
1109c4: 70ca strb r2, [r1, #3]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
1109c6: 741e strb r6, [r3, #16]
1109c8: d1e3 bne.n 110992 <rtems_rfs_block_map_close+0x62>
rtems_rfs_inode_set_block_count (map->inode, map->size.count);
1109ca: e9d4 3501 ldrd r3, r5, [r4, #4]
brc = rtems_rfs_inode_unload (fs, map->inode, true);
1109ce: 2201 movs r2, #1
1109d0: 4638 mov r0, r7
rtems_rfs_write_u32 (&handle->node->block_count, block_count);
1109d2: 68d9 ldr r1, [r3, #12]
1109d4: ea4f 6c15 mov.w ip, r5, lsr #24
1109d8: f881 c00c strb.w ip, [r1, #12]
1109dc: ea4f 4c15 mov.w ip, r5, lsr #16
1109e0: 68d9 ldr r1, [r3, #12]
1109e2: f881 c00d strb.w ip, [r1, #13]
1109e6: ea4f 2c15 mov.w ip, r5, lsr #8
1109ea: 68d9 ldr r1, [r3, #12]
1109ec: f881 c00e strb.w ip, [r1, #14]
1109f0: 68d9 ldr r1, [r3, #12]
1109f2: 73cd strb r5, [r1, #15]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
1109f4: 741e strb r6, [r3, #16]
rtems_rfs_inode_set_block_offset (map->inode, map->size.offset);
1109f6: 6863 ldr r3, [r4, #4]
1109f8: 68e5 ldr r5, [r4, #12]
rtems_rfs_write_u16 (&handle->node->block_offset, block_offset);
1109fa: 68d9 ldr r1, [r3, #12]
1109fc: f3c5 2c07 ubfx ip, r5, #8, #8
110a00: f881 c00a strb.w ip, [r1, #10]
110a04: 68d9 ldr r1, [r3, #12]
110a06: 72cd strb r5, [r1, #11]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
110a08: 741e strb r6, [r3, #16]
rtems_rfs_inode_set_last_map_block (map->inode, map->last_map_block);
110a0a: 69e5 ldr r5, [r4, #28]
110a0c: 6863 ldr r3, [r4, #4]
rtems_rfs_write_u32 (&handle->node->last_map_block, last_map_block);
110a0e: 68d9 ldr r1, [r3, #12]
110a10: ea4f 6c15 mov.w ip, r5, lsr #24
110a14: f881 c030 strb.w ip, [r1, #48] ; 0x30
110a18: ea4f 4c15 mov.w ip, r5, lsr #16
110a1c: 68d9 ldr r1, [r3, #12]
110a1e: f881 c031 strb.w ip, [r1, #49] ; 0x31
110a22: ea4f 2c15 mov.w ip, r5, lsr #8
110a26: 68d9 ldr r1, [r3, #12]
110a28: f881 c032 strb.w ip, [r1, #50] ; 0x32
110a2c: 68d9 ldr r1, [r3, #12]
110a2e: f881 5033 strb.w r5, [r1, #51] ; 0x33
rtems_rfs_buffer_mark_dirty (&handle->buffer);
110a32: 741e strb r6, [r3, #16]
rtems_rfs_inode_set_last_data_block (map->inode, map->last_data_block);
110a34: 6a25 ldr r5, [r4, #32]
110a36: 6863 ldr r3, [r4, #4]
rtems_rfs_write_u32 (&handle->node->last_data_block, last_data_block);
110a38: 68d9 ldr r1, [r3, #12]
110a3a: ea4f 6c15 mov.w ip, r5, lsr #24
110a3e: f881 c034 strb.w ip, [r1, #52] ; 0x34
110a42: ea4f 4c15 mov.w ip, r5, lsr #16
110a46: 68d9 ldr r1, [r3, #12]
110a48: f881 c035 strb.w ip, [r1, #53] ; 0x35
110a4c: ea4f 2c15 mov.w ip, r5, lsr #8
110a50: 68d9 ldr r1, [r3, #12]
110a52: f881 c036 strb.w ip, [r1, #54] ; 0x36
110a56: 68d9 ldr r1, [r3, #12]
110a58: f881 5037 strb.w r5, [r1, #55] ; 0x37
rtems_rfs_buffer_mark_dirty (&handle->buffer);
110a5c: 741e strb r6, [r3, #16]
brc = rtems_rfs_inode_unload (fs, map->inode, true);
110a5e: 6861 ldr r1, [r4, #4]
110a60: f7f8 ffb8 bl 1099d4 <rtems_rfs_inode_unload>
map->dirty = false;
110a64: 2300 movs r3, #0
110a66: ea20 76e0 bic.w r6, r0, r0, asr #31
110a6a: 7023 strb r3, [r4, #0]
110a6c: e76e b.n 11094c <rtems_rfs_block_map_close+0x1c>
110a6e: bf00 nop
00110a70 <rtems_rfs_block_map_find>:
{
110a70: e92d 47f0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, lr}
110a74: 461e mov r6, r3
*block = 0;
110a76: 2300 movs r3, #0
{
110a78: b084 sub sp, #16
110a7a: 4615 mov r5, r2
110a7c: 4607 mov r7, r0
*block = 0;
110a7e: 6033 str r3, [r6, #0]
{
110a80: 460c mov r4, r1
if (rtems_rfs_block_pos_block_past_end (bpos, &map->size))
110a82: 6813 ldr r3, [r2, #0]
110a84: f8d1 8008 ldr.w r8, [r1, #8]
110a88: b113 cbz r3, 110a90 <rtems_rfs_block_map_find+0x20>
110a8a: f1b8 0f00 cmp.w r8, #0
110a8e: d046 beq.n 110b1e <rtems_rfs_block_map_find+0xae> <== ALWAYS TAKEN
110a90: 4543 cmp r3, r8
110a92: d244 bcs.n 110b1e <rtems_rfs_block_map_find+0xae>
if ((bpos->bno == map->bpos.bno) && (map->bpos.block != 0))
110a94: 6922 ldr r2, [r4, #16]
110a96: 4293 cmp r3, r2
110a98: d03c beq.n 110b14 <rtems_rfs_block_map_find+0xa4>
if (map->size.count <= RTEMS_RFS_INODE_BLOCKS)
110a9a: f1b8 0f05 cmp.w r8, #5
110a9e: d80f bhi.n 110ac0 <rtems_rfs_block_map_find+0x50>
*block = map->blocks[bpos->bno];
110aa0: eb04 0383 add.w r3, r4, r3, lsl #2
110aa4: 6a5b ldr r3, [r3, #36] ; 0x24
110aa6: 6033 str r3, [r6, #0]
rtems_rfs_block_copy_bpos (&map->bpos, bpos);
110aa8: 68ab ldr r3, [r5, #8]
map->bpos.block = *block;
110aaa: 2000 movs r0, #0
rtems_rfs_block_copy_bpos (&map->bpos, bpos);
110aac: e9d5 1200 ldrd r1, r2, [r5]
110ab0: 61a3 str r3, [r4, #24]
110ab2: e9c4 1204 strd r1, r2, [r4, #16]
map->bpos.block = *block;
110ab6: 6833 ldr r3, [r6, #0]
110ab8: 61a3 str r3, [r4, #24]
}
110aba: b004 add sp, #16
110abc: e8bd 87f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, pc}
direct = bpos->bno % fs->blocks_per_block;
110ac0: f8d7 a034 ldr.w sl, [r7, #52] ; 0x34
110ac4: 4618 mov r0, r3
110ac6: 4651 mov r1, sl
110ac8: f005 f91c bl 115d04 <__aeabi_uidivmod>
if (map->size.count <= fs->block_map_singly_blocks)
110acc: 6bbb ldr r3, [r7, #56] ; 0x38
110ace: 4689 mov r9, r1
singly = bpos->bno / fs->blocks_per_block;
110ad0: 9003 str r0, [sp, #12]
if (map->size.count <= fs->block_map_singly_blocks)
110ad2: 4543 cmp r3, r8
110ad4: d227 bcs.n 110b26 <rtems_rfs_block_map_find+0xb6>
singly %= fs->blocks_per_block;
110ad6: 4651 mov r1, sl
110ad8: f005 f914 bl 115d04 <__aeabi_uidivmod>
if (map->size.count < fs->block_map_doubly_blocks)
110adc: 6bfa ldr r2, [r7, #60] ; 0x3c
singly %= fs->blocks_per_block;
110ade: 9103 str r1, [sp, #12]
if (map->size.count < fs->block_map_doubly_blocks)
110ae0: 4542 cmp r2, r8
110ae2: d91c bls.n 110b1e <rtems_rfs_block_map_find+0xae> <== ALWAYS TAKEN
rc = rtems_rfs_block_find_indirect (fs,
110ae4: eb04 0080 add.w r0, r4, r0, lsl #2
110ae8: 460b mov r3, r1
110aea: a903 add r1, sp, #12
110aec: 6a42 ldr r2, [r0, #36] ; 0x24
110aee: 4638 mov r0, r7
110af0: 9100 str r1, [sp, #0]
110af2: f104 0144 add.w r1, r4, #68 ; 0x44
110af6: f7ff fe69 bl 1107cc <rtems_rfs_block_find_indirect>
if (rc == 0)
110afa: 2800 cmp r0, #0
110afc: d1dd bne.n 110aba <rtems_rfs_block_map_find+0x4a> <== ALWAYS TAKEN
rc = rtems_rfs_block_find_indirect (fs,
110afe: 9a03 ldr r2, [sp, #12]
110b00: 464b mov r3, r9
110b02: 4638 mov r0, r7
110b04: f104 0138 add.w r1, r4, #56 ; 0x38
110b08: 9600 str r6, [sp, #0]
110b0a: f7ff fe5f bl 1107cc <rtems_rfs_block_find_indirect>
if (rc == 0)
110b0e: 2800 cmp r0, #0
110b10: d0ca beq.n 110aa8 <rtems_rfs_block_map_find+0x38> <== NEVER TAKEN
110b12: e7d2 b.n 110aba <rtems_rfs_block_map_find+0x4a> <== NOT EXECUTED
if ((bpos->bno == map->bpos.bno) && (map->bpos.block != 0))
110b14: 69a2 ldr r2, [r4, #24]
110b16: 2a00 cmp r2, #0
110b18: d0bf beq.n 110a9a <rtems_rfs_block_map_find+0x2a>
*block = map->bpos.block;
110b1a: 6032 str r2, [r6, #0]
if (rc == 0)
110b1c: e7c4 b.n 110aa8 <rtems_rfs_block_map_find+0x38>
return ENXIO;
110b1e: 2006 movs r0, #6
}
110b20: b004 add sp, #16
110b22: e8bd 87f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, pc}
rc = rtems_rfs_block_find_indirect (fs,
110b26: eb04 0280 add.w r2, r4, r0, lsl #2
110b2a: 460b mov r3, r1
110b2c: 9600 str r6, [sp, #0]
110b2e: 4638 mov r0, r7
110b30: 6a52 ldr r2, [r2, #36] ; 0x24
110b32: f104 0138 add.w r1, r4, #56 ; 0x38
110b36: f7ff fe49 bl 1107cc <rtems_rfs_block_find_indirect>
if (rc == 0)
110b3a: 2800 cmp r0, #0
110b3c: d0b4 beq.n 110aa8 <rtems_rfs_block_map_find+0x38> <== NEVER TAKEN
110b3e: e7bc b.n 110aba <rtems_rfs_block_map_find+0x4a> <== NOT EXECUTED
00110b98 <rtems_rfs_block_map_grow>:
{
110b98: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
110b9c: 4607 mov r7, r0
110b9e: b089 sub sp, #36 ; 0x24
110ba0: 460c mov r4, r1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
110ba2: f44f 5000 mov.w r0, #8192 ; 0x2000
110ba6: 2100 movs r1, #0
{
110ba8: 4693 mov fp, r2
110baa: 9304 str r3, [sp, #16]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
110bac: f7f9 fee6 bl 10a97c <rtems_rfs_trace>
110bb0: 2800 cmp r0, #0
110bb2: f040 811a bne.w 110dea <rtems_rfs_block_map_grow+0x252> <== ALWAYS TAKEN
if ((map->size.count + blocks) >= rtems_rfs_fs_max_block_map_blocks (fs))
110bb6: 68a3 ldr r3, [r4, #8]
110bb8: 6bfa ldr r2, [r7, #60] ; 0x3c
110bba: 445b add r3, fp
110bbc: 4293 cmp r3, r2
110bbe: f080 8122 bcs.w 110e06 <rtems_rfs_block_map_grow+0x26e> <== ALWAYS TAKEN
for (b = 0; b < blocks; b++)
110bc2: f1bb 0f00 cmp.w fp, #0
110bc6: f000 8123 beq.w 110e10 <rtems_rfs_block_map_grow+0x278> <== ALWAYS TAKEN
rc = rtems_rfs_buffer_handle_request (fs,
110bca: f104 0344 add.w r3, r4, #68 ; 0x44
rc = rtems_rfs_group_bitmap_alloc (fs, map->last_data_block,
110bce: 6a21 ldr r1, [r4, #32]
for (b = 0; b < blocks; b++)
110bd0: 2500 movs r5, #0
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
110bd2: f04f 0801 mov.w r8, #1
rc = rtems_rfs_buffer_handle_request (fs,
110bd6: 9305 str r3, [sp, #20]
110bd8: f8cd b008 str.w fp, [sp, #8]
110bdc: e013 b.n 110c06 <rtems_rfs_block_map_grow+0x6e>
map->blocks[map->size.count] = block;
110bde: 9906 ldr r1, [sp, #24]
110be0: eb04 038b add.w r3, r4, fp, lsl #2
110be4: 6259 str r1, [r3, #36] ; 0x24
map->size.count++;
110be6: f10b 0301 add.w r3, fp, #1
map->size.offset = 0;
110bea: 2200 movs r2, #0
map->size.count++;
110bec: e9c4 3202 strd r3, r2, [r4, #8]
if (b == 0)
110bf0: b90d cbnz r5, 110bf6 <rtems_rfs_block_map_grow+0x5e>
*new_block = block;
110bf2: 9b04 ldr r3, [sp, #16]
110bf4: 6019 str r1, [r3, #0]
for (b = 0; b < blocks; b++)
110bf6: 9b02 ldr r3, [sp, #8]
110bf8: 3501 adds r5, #1
map->last_data_block = block;
110bfa: 6221 str r1, [r4, #32]
map->dirty = true;
110bfc: f884 8000 strb.w r8, [r4]
for (b = 0; b < blocks; b++)
110c00: 429d cmp r5, r3
110c02: f000 8105 beq.w 110e10 <rtems_rfs_block_map_grow+0x278> <== NEVER TAKEN
rc = rtems_rfs_group_bitmap_alloc (fs, map->last_data_block,
110c06: ab06 add r3, sp, #24
110c08: 2200 movs r2, #0
110c0a: 4638 mov r0, r7
110c0c: f7f8 fd28 bl 109660 <rtems_rfs_group_bitmap_alloc>
if (rc > 0)
110c10: 2800 cmp r0, #0
110c12: f300 8102 bgt.w 110e1a <rtems_rfs_block_map_grow+0x282>
if (map->size.count < RTEMS_RFS_INODE_BLOCKS)
110c16: f8d4 b008 ldr.w fp, [r4, #8]
110c1a: f1bb 0f04 cmp.w fp, #4
110c1e: d9de bls.n 110bde <rtems_rfs_block_map_grow+0x46>
direct = map->size.count % fs->blocks_per_block;
110c20: f8d7 a034 ldr.w sl, [r7, #52] ; 0x34
110c24: 4658 mov r0, fp
110c26: 4651 mov r1, sl
110c28: f005 f86c bl 115d04 <__aeabi_uidivmod>
if (map->size.count < fs->block_map_singly_blocks)
110c2c: 6bbb ldr r3, [r7, #56] ; 0x38
110c2e: 4681 mov r9, r0
110c30: 460e mov r6, r1
110c32: 459b cmp fp, r3
110c34: d23b bcs.n 110cae <rtems_rfs_block_map_grow+0x116>
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
110c36: f104 0238 add.w r2, r4, #56 ; 0x38
if ((direct == 0) ||
110c3a: b149 cbz r1, 110c50 <rtems_rfs_block_map_grow+0xb8>
110c3c: 45d3 cmp fp, sl
110c3e: bf2c ite cs
110c40: 2300 movcs r3, #0
110c42: 2301 movcc r3, #1
110c44: 2905 cmp r1, #5
110c46: bf18 it ne
110c48: 2300 movne r3, #0
110c4a: 2b00 cmp r3, #0
110c4c: f000 80b2 beq.w 110db4 <rtems_rfs_block_map_grow+0x21c>
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
110c50: f1ab 0105 sub.w r1, fp, #5
&map->blocks[singly],
110c54: f109 0309 add.w r3, r9, #9
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
110c58: fab1 f181 clz r1, r1
110c5c: eb04 0383 add.w r3, r4, r3, lsl #2
110c60: 0949 lsrs r1, r1, #5
110c62: 4638 mov r0, r7
110c64: 9100 str r1, [sp, #0]
110c66: 4621 mov r1, r4
110c68: f7ff fd40 bl 1106ec <rtems_rfs_block_map_indirect_alloc>
if (rc > 0)
110c6c: 2800 cmp r0, #0
110c6e: f300 8096 bgt.w 110d9e <rtems_rfs_block_map_grow+0x206> <== ALWAYS TAKEN
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
110c72: 6c23 ldr r3, [r4, #64] ; 0x40
110c74: 00b2 lsls r2, r6, #2
110c76: f89d 101b ldrb.w r1, [sp, #27]
110c7a: 69db ldr r3, [r3, #28]
110c7c: f803 1026 strb.w r1, [r3, r6, lsl #2]
110c80: 6c23 ldr r3, [r4, #64] ; 0x40
110c82: f8bd 101a ldrh.w r1, [sp, #26]
110c86: 69db ldr r3, [r3, #28]
110c88: 4413 add r3, r2
110c8a: 7059 strb r1, [r3, #1]
110c8c: 6c23 ldr r3, [r4, #64] ; 0x40
110c8e: 9906 ldr r1, [sp, #24]
110c90: 69db ldr r3, [r3, #28]
110c92: 0a09 lsrs r1, r1, #8
110c94: 4413 add r3, r2
110c96: 7099 strb r1, [r3, #2]
110c98: 6c23 ldr r3, [r4, #64] ; 0x40
110c9a: 9906 ldr r1, [sp, #24]
110c9c: 69db ldr r3, [r3, #28]
110c9e: 4413 add r3, r2
110ca0: 70d9 strb r1, [r3, #3]
*new_block = block;
110ca2: 9906 ldr r1, [sp, #24]
map->size.count++;
110ca4: f8d4 b008 ldr.w fp, [r4, #8]
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
110ca8: f884 8038 strb.w r8, [r4, #56] ; 0x38
110cac: e79b b.n 110be6 <rtems_rfs_block_map_grow+0x4e>
doubly = singly / fs->blocks_per_block;
110cae: 4651 mov r1, sl
110cb0: f005 f828 bl 115d04 <__aeabi_uidivmod>
110cb4: 468b mov fp, r1
if (direct == 0)
110cb6: 9003 str r0, [sp, #12]
110cb8: 2e00 cmp r6, #0
110cba: d149 bne.n 110d50 <rtems_rfs_block_map_grow+0x1b8>
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
110cbc: ab07 add r3, sp, #28
110cbe: f104 0238 add.w r2, r4, #56 ; 0x38
110cc2: 4621 mov r1, r4
110cc4: 4638 mov r0, r7
110cc6: 9600 str r6, [sp, #0]
110cc8: f7ff fd10 bl 1106ec <rtems_rfs_block_map_indirect_alloc>
if (rc > 0)
110ccc: 2800 cmp r0, #0
110cce: dc66 bgt.n 110d9e <rtems_rfs_block_map_grow+0x206> <== ALWAYS TAKEN
&map->blocks[doubly],
110cd0: 9b03 ldr r3, [sp, #12]
if ((singly == 0) ||
110cd2: f1bb 0f00 cmp.w fp, #0
110cd6: d00d beq.n 110cf4 <rtems_rfs_block_map_grow+0x15c> <== ALWAYS TAKEN
110cd8: 45ca cmp sl, r9
110cda: bf94 ite ls
110cdc: f04f 0900 movls.w r9, #0
110ce0: f04f 0901 movhi.w r9, #1
110ce4: f1bb 0f05 cmp.w fp, #5
110ce8: bf18 it ne
110cea: f04f 0900 movne.w r9, #0
110cee: f1b9 0f00 cmp.w r9, #0
110cf2: d069 beq.n 110dc8 <rtems_rfs_block_map_grow+0x230>
upping = map->size.count == fs->block_map_singly_blocks;
110cf4: 6bb9 ldr r1, [r7, #56] ; 0x38
&map->blocks[doubly],
110cf6: 3309 adds r3, #9
upping = map->size.count == fs->block_map_singly_blocks;
110cf8: 68a2 ldr r2, [r4, #8]
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
110cfa: eb04 0383 add.w r3, r4, r3, lsl #2
110cfe: 4638 mov r0, r7
110d00: 1a52 subs r2, r2, r1
110d02: 4621 mov r1, r4
110d04: fab2 f282 clz r2, r2
110d08: 0952 lsrs r2, r2, #5
110d0a: 9200 str r2, [sp, #0]
110d0c: 9a05 ldr r2, [sp, #20]
110d0e: f7ff fced bl 1106ec <rtems_rfs_block_map_indirect_alloc>
if (rc > 0)
110d12: 2800 cmp r0, #0
110d14: dc62 bgt.n 110ddc <rtems_rfs_block_map_grow+0x244> <== ALWAYS TAKEN
rtems_rfs_block_set_number (&map->doubly_buffer,
110d16: 6ce3 ldr r3, [r4, #76] ; 0x4c
110d18: f89d 201f ldrb.w r2, [sp, #31]
110d1c: 69db ldr r3, [r3, #28]
110d1e: f803 202b strb.w r2, [r3, fp, lsl #2]
110d22: ea4f 0b8b mov.w fp, fp, lsl #2
110d26: 6ce3 ldr r3, [r4, #76] ; 0x4c
110d28: f8bd 201e ldrh.w r2, [sp, #30]
110d2c: 69db ldr r3, [r3, #28]
110d2e: 445b add r3, fp
110d30: 705a strb r2, [r3, #1]
110d32: 6ce3 ldr r3, [r4, #76] ; 0x4c
110d34: 9a07 ldr r2, [sp, #28]
110d36: 69db ldr r3, [r3, #28]
110d38: 0a12 lsrs r2, r2, #8
110d3a: 445b add r3, fp
110d3c: 709a strb r2, [r3, #2]
110d3e: 6ce3 ldr r3, [r4, #76] ; 0x4c
110d40: 69db ldr r3, [r3, #28]
110d42: 449b add fp, r3
110d44: 9b07 ldr r3, [sp, #28]
110d46: f88b 3003 strb.w r3, [fp, #3]
110d4a: f884 8044 strb.w r8, [r4, #68] ; 0x44
110d4e: e790 b.n 110c72 <rtems_rfs_block_map_grow+0xda>
rc = rtems_rfs_buffer_handle_request (fs,
110d50: 9b03 ldr r3, [sp, #12]
110d52: 4638 mov r0, r7
110d54: 9905 ldr r1, [sp, #20]
110d56: eb04 0383 add.w r3, r4, r3, lsl #2
110d5a: 6a5a ldr r2, [r3, #36] ; 0x24
110d5c: 2301 movs r3, #1
110d5e: f7f7 fc1d bl 10859c <rtems_rfs_buffer_handle_request>
if (rc > 0)
110d62: 2800 cmp r0, #0
110d64: dc1b bgt.n 110d9e <rtems_rfs_block_map_grow+0x206> <== ALWAYS TAKEN
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
110d66: 6ce3 ldr r3, [r4, #76] ; 0x4c
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
110d68: f104 0138 add.w r1, r4, #56 ; 0x38
110d6c: 4638 mov r0, r7
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
110d6e: 69da ldr r2, [r3, #28]
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
110d70: 2301 movs r3, #1
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
110d72: f812 c02b ldrb.w ip, [r2, fp, lsl #2]
110d76: eb02 0b8b add.w fp, r2, fp, lsl #2
110d7a: f89b 2003 ldrb.w r2, [fp, #3]
110d7e: ea42 620c orr.w r2, r2, ip, lsl #24
110d82: f89b c001 ldrb.w ip, [fp, #1]
110d86: ea42 420c orr.w r2, r2, ip, lsl #16
110d8a: f89b c002 ldrb.w ip, [fp, #2]
110d8e: ea42 220c orr.w r2, r2, ip, lsl #8
110d92: 9207 str r2, [sp, #28]
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
110d94: f7f7 fc02 bl 10859c <rtems_rfs_buffer_handle_request>
if (rc > 0)
110d98: 2800 cmp r0, #0
110d9a: f77f af6a ble.w 110c72 <rtems_rfs_block_map_grow+0xda> <== NEVER TAKEN
rtems_rfs_group_bitmap_free (fs, false, block);
110d9e: 9002 str r0, [sp, #8] <== NOT EXECUTED
110da0: 9a06 ldr r2, [sp, #24] <== NOT EXECUTED
110da2: 2100 movs r1, #0 <== NOT EXECUTED
110da4: 4638 mov r0, r7 <== NOT EXECUTED
110da6: f7f8 fd27 bl 1097f8 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
return rc;
110daa: 9b02 ldr r3, [sp, #8] <== NOT EXECUTED
}
110dac: 4618 mov r0, r3 <== NOT EXECUTED
110dae: b009 add sp, #36 ; 0x24 <== NOT EXECUTED
110db0: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
110db4: eb04 0980 add.w r9, r4, r0, lsl #2
110db8: 4611 mov r1, r2
110dba: 2301 movs r3, #1
110dbc: f8d9 2024 ldr.w r2, [r9, #36] ; 0x24
110dc0: 4638 mov r0, r7
110dc2: f7f7 fbeb bl 10859c <rtems_rfs_buffer_handle_request>
110dc6: e751 b.n 110c6c <rtems_rfs_block_map_grow+0xd4>
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
110dc8: eb04 0383 add.w r3, r4, r3, lsl #2
110dcc: 9905 ldr r1, [sp, #20]
110dce: 4638 mov r0, r7
110dd0: 6a5a ldr r2, [r3, #36] ; 0x24
110dd2: 2301 movs r3, #1
110dd4: f7f7 fbe2 bl 10859c <rtems_rfs_buffer_handle_request>
if (rc > 0)
110dd8: 2800 cmp r0, #0
110dda: dd9c ble.n 110d16 <rtems_rfs_block_map_grow+0x17e> <== NEVER TAKEN
rtems_rfs_group_bitmap_free (fs, false, singly_block);
110ddc: 9002 str r0, [sp, #8] <== NOT EXECUTED
110dde: 2100 movs r1, #0 <== NOT EXECUTED
110de0: 9a07 ldr r2, [sp, #28] <== NOT EXECUTED
110de2: 4638 mov r0, r7 <== NOT EXECUTED
110de4: f7f8 fd08 bl 1097f8 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
rtems_rfs_group_bitmap_free (fs, false, block);
110de8: e7da b.n 110da0 <rtems_rfs_block_map_grow+0x208> <== NOT EXECUTED
printf ("rtems-rfs: block-map-grow: entry: blocks=%zd count=%" PRIu32 "\n",
110dea: f64a 5058 movw r0, #44376 ; 0xad58 <== NOT EXECUTED
110dee: 68a2 ldr r2, [r4, #8] <== NOT EXECUTED
110df0: f2c0 0011 movt r0, #17 <== NOT EXECUTED
110df4: 4659 mov r1, fp <== NOT EXECUTED
110df6: f7f4 fe8f bl 105b18 <__wrap_printf> <== NOT EXECUTED
if ((map->size.count + blocks) >= rtems_rfs_fs_max_block_map_blocks (fs))
110dfa: 68a3 ldr r3, [r4, #8] <== NOT EXECUTED
110dfc: 6bfa ldr r2, [r7, #60] ; 0x3c <== NOT EXECUTED
110dfe: 445b add r3, fp <== NOT EXECUTED
110e00: 4293 cmp r3, r2 <== NOT EXECUTED
110e02: f4ff aede bcc.w 110bc2 <rtems_rfs_block_map_grow+0x2a> <== NOT EXECUTED
return EFBIG;
110e06: 231b movs r3, #27 <== NOT EXECUTED
}
110e08: 4618 mov r0, r3 <== NOT EXECUTED
110e0a: b009 add sp, #36 ; 0x24 <== NOT EXECUTED
110e0c: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
return 0;
110e10: 2300 movs r3, #0
}
110e12: 4618 mov r0, r3
110e14: b009 add sp, #36 ; 0x24
110e16: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
110e1a: 4603 mov r3, r0
110e1c: 4618 mov r0, r3
110e1e: b009 add sp, #36 ; 0x24
110e20: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
0011088c <rtems_rfs_block_map_open>:
{
11088c: e92d 41f0 stmdb sp!, {r4, r5, r6, r7, r8, lr}
map->dirty = false;
110890: 2500 movs r5, #0
110892: 7015 strb r5, [r2, #0]
{
110894: 4614 mov r4, r2
110896: 4680 mov r8, r0
110898: 460e mov r6, r1
* @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;
11089a: e9c2 5501 strd r5, r5, [r2, #4]
bpos->bno = 0;
11089e: e9c2 5503 strd r5, r5, [r2, #12]
bpos->block = 0;
1108a2: e9c2 5505 strd r5, r5, [r2, #20]
handle->dirty = false;
1108a6: f882 5038 strb.w r5, [r2, #56] ; 0x38
handle->buffer = NULL;
1108aa: e9c2 550f strd r5, r5, [r2, #60] ; 0x3c
handle->dirty = false;
1108ae: f882 5044 strb.w r5, [r2, #68] ; 0x44
handle->buffer = NULL;
1108b2: e9c2 5512 strd r5, r5, [r2, #72] ; 0x48
rc = rtems_rfs_inode_load (fs, inode);
1108b6: f7f9 f813 bl 1098e0 <rtems_rfs_inode_load>
if (rc > 0)
1108ba: 1e07 subs r7, r0, #0
1108bc: dc22 bgt.n 110904 <rtems_rfs_block_map_open+0x78> <== ALWAYS TAKEN
map->inode = inode;
1108be: 68f7 ldr r7, [r6, #12]
1108c0: f104 0224 add.w r2, r4, #36 ; 0x24
1108c4: f104 0138 add.w r1, r4, #56 ; 0x38
1108c8: 6066 str r6, [r4, #4]
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
1108ca: f107 051c add.w r5, r7, #28
return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);
1108ce: f855 3b04 ldr.w r3, [r5], #4
1108d2: ba1b rev r3, r3
map->blocks[b] = rtems_rfs_inode_get_block (inode, b);
1108d4: f842 3b04 str.w r3, [r2], #4
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
1108d8: 4291 cmp r1, r2
1108da: d1f8 bne.n 1108ce <rtems_rfs_block_map_open+0x42>
return rtems_rfs_read_u32 (&handle->node->block_count);
1108dc: 68fb ldr r3, [r7, #12]
rc = rtems_rfs_inode_unload (fs, inode, false);
1108de: 4631 mov r1, r6
1108e0: 4640 mov r0, r8
1108e2: 2200 movs r2, #0
1108e4: ba1b rev r3, r3
map->size.count = rtems_rfs_inode_get_block_count (inode);
1108e6: 60a3 str r3, [r4, #8]
map->size.offset = rtems_rfs_inode_get_block_offset (inode);
1108e8: 897b ldrh r3, [r7, #10]
1108ea: ba5b rev16 r3, r3
1108ec: b29b uxth r3, r3
1108ee: 60e3 str r3, [r4, #12]
return rtems_rfs_read_u32 (&handle->node->last_map_block);
1108f0: 6b3b ldr r3, [r7, #48] ; 0x30
1108f2: ba1b rev r3, r3
map->last_map_block = rtems_rfs_inode_get_last_map_block (inode);
1108f4: 61e3 str r3, [r4, #28]
return rtems_rfs_read_u32 (&handle->node->last_data_block);
1108f6: 6b7b ldr r3, [r7, #52] ; 0x34
1108f8: ba1b rev r3, r3
map->last_data_block = rtems_rfs_inode_get_last_data_block (inode);
1108fa: 6223 str r3, [r4, #32]
}
1108fc: e8bd 41f0 ldmia.w sp!, {r4, r5, r6, r7, r8, lr}
rc = rtems_rfs_inode_unload (fs, inode, false);
110900: f7f9 b868 b.w 1099d4 <rtems_rfs_inode_unload>
rtems_rfs_buffer_handle_release (fs, handle);
110904: f104 0138 add.w r1, r4, #56 ; 0x38 <== NOT EXECUTED
110908: 4640 mov r0, r8 <== NOT EXECUTED
11090a: f7f7 ff33 bl 108774 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
11090e: f104 0144 add.w r1, r4, #68 ; 0x44 <== NOT EXECUTED
110912: 4640 mov r0, r8 <== NOT EXECUTED
handle->dirty = false;
110914: f884 5038 strb.w r5, [r4, #56] ; 0x38 <== NOT EXECUTED
handle->buffer = NULL;
110918: e9c4 550f strd r5, r5, [r4, #60] ; 0x3c <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
11091c: f7f7 ff2a bl 108774 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
}
110920: 4638 mov r0, r7 <== NOT EXECUTED
handle->dirty = false;
110922: f884 5044 strb.w r5, [r4, #68] ; 0x44 <== NOT EXECUTED
handle->buffer = NULL;
110926: e9c4 5512 strd r5, r5, [r4, #72] ; 0x48 <== NOT EXECUTED
11092a: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
11092e: bf00 nop
00110e24 <rtems_rfs_block_map_shrink>:
int
rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks)
{
110e24: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
110e28: 4606 mov r6, r0
110e2a: b085 sub sp, #20
110e2c: 460c mov r4, r1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))
110e2e: f44f 4080 mov.w r0, #16384 ; 0x4000
110e32: 2100 movs r1, #0
{
110e34: 4617 mov r7, r2
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))
110e36: f7f9 fda1 bl 10a97c <rtems_rfs_trace>
110e3a: 2800 cmp r0, #0
110e3c: f040 80c1 bne.w 110fc2 <rtems_rfs_block_map_shrink+0x19e> <== ALWAYS TAKEN
printf ("rtems-rfs: block-map-shrink: entry: blocks=%zd count=%" PRIu32 "\n",
blocks, map->size.count);
if (map->size.count == 0)
110e40: 68a5 ldr r5, [r4, #8]
110e42: 2d00 cmp r5, #0
110e44: f000 80b9 beq.w 110fba <rtems_rfs_block_map_shrink+0x196>
return 0;
if (blocks > map->size.count)
110e48: 42af cmp r7, r5
110e4a: bf28 it cs
110e4c: 462f movcs r7, r5
blocks = map->size.count;
while (blocks)
110e4e: 2f00 cmp r7, #0
110e50: f000 80ab beq.w 110faa <rtems_rfs_block_map_shrink+0x186> <== ALWAYS 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,
110e54: f104 0344 add.w r3, r4, #68 ; 0x44
doubly_singly);
/*
* Read the singly indirect table and get the block number.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
110e58: f104 0b38 add.w fp, r4, #56 ; 0x38
110e5c: 46b8 mov r8, r7
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
110e5e: 9303 str r3, [sp, #12]
110e60: e019 b.n 110e96 <rtems_rfs_block_map_shrink+0x72>
block_to_free = map->blocks[block];
110e62: eb04 0385 add.w r3, r4, r5, lsl #2
map->blocks[block] = 0;
110e66: 2200 movs r2, #0
block_to_free = map->blocks[block];
110e68: 6a1d ldr r5, [r3, #32]
map->blocks[block] = 0;
110e6a: 621a str r2, [r3, #32]
{
rc = EIO;
break;
}
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
110e6c: 462a mov r2, r5
110e6e: 2100 movs r1, #0
110e70: 4630 mov r0, r6
110e72: f7f8 fcc1 bl 1097f8 <rtems_rfs_group_bitmap_free>
if (rc > 0)
110e76: 2800 cmp r0, #0
110e78: dc6c bgt.n 110f54 <rtems_rfs_block_map_shrink+0x130> <== ALWAYS TAKEN
return rc;
map->size.count--;
110e7a: 68a3 ldr r3, [r4, #8]
map->size.offset = 0;
110e7c: 2200 movs r2, #0
while (blocks)
110e7e: f1b8 0801 subs.w r8, r8, #1
map->size.offset = 0;
110e82: 60e2 str r2, [r4, #12]
map->last_data_block = block_to_free;
110e84: 6225 str r5, [r4, #32]
map->dirty = true;
110e86: f04f 0201 mov.w r2, #1
map->size.count--;
110e8a: f103 35ff add.w r5, r3, #4294967295 ; 0xffffffff
map->dirty = true;
110e8e: 7022 strb r2, [r4, #0]
map->size.count--;
110e90: 60a5 str r5, [r4, #8]
while (blocks)
110e92: f000 8089 beq.w 110fa8 <rtems_rfs_block_map_shrink+0x184>
block = map->size.count - 1;
110e96: f105 3aff add.w sl, r5, #4294967295 ; 0xffffffff
if (block < RTEMS_RFS_INODE_BLOCKS)
110e9a: f1ba 0f04 cmp.w sl, #4
110e9e: d9e0 bls.n 110e62 <rtems_rfs_block_map_shrink+0x3e>
direct = block % fs->blocks_per_block;
110ea0: 6b73 ldr r3, [r6, #52] ; 0x34
110ea2: 4650 mov r0, sl
110ea4: 4619 mov r1, r3
110ea6: 9302 str r3, [sp, #8]
110ea8: f004 ff2c bl 115d04 <__aeabi_uidivmod>
if (block < fs->block_map_singly_blocks)
110eac: 6bb2 ldr r2, [r6, #56] ; 0x38
110eae: 4681 mov r9, r0
110eb0: 9b02 ldr r3, [sp, #8]
110eb2: 460f mov r7, r1
110eb4: 4552 cmp r2, sl
110eb6: d850 bhi.n 110f5a <rtems_rfs_block_map_shrink+0x136> <== NEVER TAKEN
else if (block < fs->block_map_doubly_blocks)
110eb8: 6bf2 ldr r2, [r6, #60] ; 0x3c <== NOT EXECUTED
110eba: 4552 cmp r2, sl <== NOT EXECUTED
110ebc: d974 bls.n 110fa8 <rtems_rfs_block_map_shrink+0x184> <== NOT EXECUTED
doubly = singly / fs->blocks_per_block;
110ebe: 4619 mov r1, r3 <== NOT EXECUTED
110ec0: f004 ff20 bl 115d04 <__aeabi_uidivmod> <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
110ec4: eb04 0280 add.w r2, r4, r0, lsl #2 <== NOT EXECUTED
110ec8: 4682 mov sl, r0 <== NOT EXECUTED
110eca: 2301 movs r3, #1 <== NOT EXECUTED
110ecc: 6a52 ldr r2, [r2, #36] ; 0x24 <== NOT EXECUTED
110ece: 4689 mov r9, r1 <== NOT EXECUTED
110ed0: 4630 mov r0, r6 <== NOT EXECUTED
110ed2: 9903 ldr r1, [sp, #12] <== NOT EXECUTED
110ed4: f7f7 fb62 bl 10859c <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
110ed8: 2800 cmp r0, #0 <== NOT EXECUTED
110eda: dc3b bgt.n 110f54 <rtems_rfs_block_map_shrink+0x130> <== NOT EXECUTED
singly = rtems_rfs_block_get_number (&map->doubly_buffer,
110edc: 6ce3 ldr r3, [r4, #76] ; 0x4c <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
110ede: 4659 mov r1, fp <== NOT EXECUTED
110ee0: 4630 mov r0, r6 <== NOT EXECUTED
singly = rtems_rfs_block_get_number (&map->doubly_buffer,
110ee2: 69dd ldr r5, [r3, #28] <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
110ee4: 2301 movs r3, #1 <== NOT EXECUTED
singly = rtems_rfs_block_get_number (&map->doubly_buffer,
110ee6: f815 c029 ldrb.w ip, [r5, r9, lsl #2] <== NOT EXECUTED
110eea: eb05 0589 add.w r5, r5, r9, lsl #2 <== NOT EXECUTED
110eee: 78ea ldrb r2, [r5, #3] <== NOT EXECUTED
110ef0: ea42 620c orr.w r2, r2, ip, lsl #24 <== NOT EXECUTED
110ef4: f895 c001 ldrb.w ip, [r5, #1] <== NOT EXECUTED
110ef8: 78ad ldrb r5, [r5, #2] <== NOT EXECUTED
110efa: ea42 420c orr.w r2, r2, ip, lsl #16 <== NOT EXECUTED
110efe: ea42 2205 orr.w r2, r2, r5, lsl #8 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
110f02: 9202 str r2, [sp, #8] <== NOT EXECUTED
110f04: f7f7 fb4a bl 10859c <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
110f08: 2800 cmp r0, #0 <== NOT EXECUTED
110f0a: dc23 bgt.n 110f54 <rtems_rfs_block_map_shrink+0x130> <== NOT EXECUTED
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
110f0c: 6c23 ldr r3, [r4, #64] ; 0x40 <== NOT EXECUTED
if (direct == 0)
110f0e: 9a02 ldr r2, [sp, #8] <== NOT EXECUTED
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
110f10: 69db ldr r3, [r3, #28] <== NOT EXECUTED
110f12: f813 1027 ldrb.w r1, [r3, r7, lsl #2] <== NOT EXECUTED
110f16: eb03 0387 add.w r3, r3, r7, lsl #2 <== NOT EXECUTED
110f1a: 78dd ldrb r5, [r3, #3] <== NOT EXECUTED
110f1c: ea45 6501 orr.w r5, r5, r1, lsl #24 <== NOT EXECUTED
110f20: 7859 ldrb r1, [r3, #1] <== NOT EXECUTED
110f22: 789b ldrb r3, [r3, #2] <== NOT EXECUTED
110f24: ea45 4501 orr.w r5, r5, r1, lsl #16 <== NOT EXECUTED
110f28: ea45 2503 orr.w r5, r5, r3, lsl #8 <== NOT EXECUTED
if (direct == 0)
110f2c: 2f00 cmp r7, #0 <== NOT EXECUTED
110f2e: d19d bne.n 110e6c <rtems_rfs_block_map_shrink+0x48> <== NOT EXECUTED
rc = rtems_rfs_group_bitmap_free (fs, false, singly);
110f30: 4639 mov r1, r7 <== NOT EXECUTED
110f32: 4630 mov r0, r6 <== NOT EXECUTED
110f34: f7f8 fc60 bl 1097f8 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
if (rc > 0)
110f38: 2800 cmp r0, #0 <== NOT EXECUTED
110f3a: dc0b bgt.n 110f54 <rtems_rfs_block_map_shrink+0x130> <== NOT EXECUTED
map->last_map_block = singly;
110f3c: 9a02 ldr r2, [sp, #8] <== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->doubly_buffer,
110f3e: 4653 mov r3, sl <== NOT EXECUTED
110f40: 4621 mov r1, r4 <== NOT EXECUTED
110f42: 4630 mov r0, r6 <== NOT EXECUTED
map->last_map_block = singly;
110f44: 61e2 str r2, [r4, #28] <== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->doubly_buffer,
110f46: 9a03 ldr r2, [sp, #12] <== NOT EXECUTED
110f48: f8cd 9000 str.w r9, [sp] <== NOT EXECUTED
110f4c: f7ff fb9c bl 110688 <rtems_rfs_block_map_indirect_shrink> <== NOT EXECUTED
if (rc)
110f50: 2800 cmp r0, #0 <== NOT EXECUTED
110f52: d08b beq.n 110e6c <rtems_rfs_block_map_shrink+0x48> <== 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;
}
110f54: b005 add sp, #20 <== NOT EXECUTED
110f56: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
110f5a: eb04 0380 add.w r3, r4, r0, lsl #2
110f5e: 4659 mov r1, fp
110f60: 4630 mov r0, r6
110f62: 6a5a ldr r2, [r3, #36] ; 0x24
110f64: 2301 movs r3, #1
110f66: f7f7 fb19 bl 10859c <rtems_rfs_buffer_handle_request>
if (rc > 0)
110f6a: 2800 cmp r0, #0
110f6c: dcf2 bgt.n 110f54 <rtems_rfs_block_map_shrink+0x130> <== ALWAYS TAKEN
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
110f6e: 6c22 ldr r2, [r4, #64] ; 0x40
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
110f70: 464b mov r3, r9
110f72: 4621 mov r1, r4
110f74: 4630 mov r0, r6
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
110f76: 69d5 ldr r5, [r2, #28]
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
110f78: 465a mov r2, fp
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
110f7a: f815 e027 ldrb.w lr, [r5, r7, lsl #2]
110f7e: eb05 0c87 add.w ip, r5, r7, lsl #2
110f82: f89c 5003 ldrb.w r5, [ip, #3]
110f86: ea45 650e orr.w r5, r5, lr, lsl #24
110f8a: f89c e001 ldrb.w lr, [ip, #1]
110f8e: f89c c002 ldrb.w ip, [ip, #2]
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
110f92: 9700 str r7, [sp, #0]
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
110f94: ea45 450e orr.w r5, r5, lr, lsl #16
110f98: ea45 250c orr.w r5, r5, ip, lsl #8
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
110f9c: f7ff fb74 bl 110688 <rtems_rfs_block_map_indirect_shrink>
if (rc)
110fa0: 2800 cmp r0, #0
110fa2: f43f af63 beq.w 110e6c <rtems_rfs_block_map_shrink+0x48> <== NEVER TAKEN
110fa6: e7d5 b.n 110f54 <rtems_rfs_block_map_shrink+0x130> <== NOT EXECUTED
if (map->size.count == 0)
110fa8: b1a5 cbz r5, 110fd4 <rtems_rfs_block_map_shrink+0x1b0>
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
110faa: 6923 ldr r3, [r4, #16]
110fac: 42ab cmp r3, r5
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
110fae: bf28 it cs
110fb0: 68e3 ldrcs r3, [r4, #12]
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
110fb2: d212 bcs.n 110fda <rtems_rfs_block_map_shrink+0x1b6> <== ALWAYS TAKEN
110fb4: 1e6a subs r2, r5, #1
110fb6: 4293 cmp r3, r2
110fb8: d018 beq.n 110fec <rtems_rfs_block_map_shrink+0x1c8> <== NEVER TAKEN
return 0;
110fba: 2000 movs r0, #0
}
110fbc: b005 add sp, #20
110fbe: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
printf ("rtems-rfs: block-map-shrink: entry: blocks=%zd count=%" PRIu32 "\n",
110fc2: f64a 5090 movw r0, #44432 ; 0xad90 <== NOT EXECUTED
110fc6: 68a2 ldr r2, [r4, #8] <== NOT EXECUTED
110fc8: 4639 mov r1, r7 <== NOT EXECUTED
110fca: f2c0 0011 movt r0, #17 <== NOT EXECUTED
110fce: f7f4 fda3 bl 105b18 <__wrap_printf> <== NOT EXECUTED
110fd2: e735 b.n 110e40 <rtems_rfs_block_map_shrink+0x1c> <== NOT EXECUTED
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
110fd4: 68e3 ldr r3, [r4, #12]
map->last_data_block = 0;
110fd6: e9c4 5507 strd r5, r5, [r4, #28]
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
110fda: 2000 movs r0, #0
110fdc: e9c4 5304 strd r5, r3, [r4, #16]
110fe0: 61a0 str r0, [r4, #24]
110fe2: 2b00 cmp r3, #0
110fe4: d0e9 beq.n 110fba <rtems_rfs_block_map_shrink+0x196> <== NEVER TAKEN
110fe6: 3d01 subs r5, #1 <== NOT EXECUTED
110fe8: 6125 str r5, [r4, #16] <== NOT EXECUTED
110fea: e7b3 b.n 110f54 <rtems_rfs_block_map_shrink+0x130> <== NOT EXECUTED
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
110fec: 68e3 ldr r3, [r4, #12]
110fee: 6962 ldr r2, [r4, #20]
110ff0: 429a cmp r2, r3
110ff2: d9e2 bls.n 110fba <rtems_rfs_block_map_shrink+0x196> <== ALWAYS TAKEN
110ff4: e7f1 b.n 110fda <rtems_rfs_block_map_shrink+0x1b6>
110ff6: bf00 nop
00111028 <rtems_rfs_buffer_bdbuf_release>:
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
111028: b538 push {r3, r4, r5, lr}
11102a: 4604 mov r4, r0
11102c: 460d mov r5, r1
rtems_status_code sc;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
11102e: 2040 movs r0, #64 ; 0x40
111030: 2100 movs r1, #0
111032: f7f9 fca3 bl 10a97c <rtems_rfs_trace>
111036: b190 cbz r0, 11105e <rtems_rfs_buffer_bdbuf_release+0x36>
printf ("rtems-rfs: bdbuf-release: block=%" PRIuPTR " bdbuf=%" PRIu32 " %s\n",
111038: f64a 51cc movw r1, #44492 ; 0xadcc <== NOT EXECUTED
11103c: f649 33b8 movw r3, #39864 ; 0x9bb8 <== NOT EXECUTED
111040: f2c0 0111 movt r1, #17 <== NOT EXECUTED
111044: f2c0 0311 movt r3, #17 <== NOT EXECUTED
111048: f64a 50d8 movw r0, #44504 ; 0xadd8 <== NOT EXECUTED
11104c: 2d00 cmp r5, #0 <== NOT EXECUTED
11104e: bf18 it ne <== NOT EXECUTED
111050: 460b movne r3, r1 <== NOT EXECUTED
111052: 69a2 ldr r2, [r4, #24] <== NOT EXECUTED
111054: f2c0 0011 movt r0, #17 <== NOT EXECUTED
111058: 6b61 ldr r1, [r4, #52] ; 0x34 <== NOT EXECUTED
11105a: f7f4 fd5d bl 105b18 <__wrap_printf> <== NOT EXECUTED
((intptr_t) buffer->user),
buffer->block, modified ? "(modified)" : "");
if (modified)
sc = rtems_bdbuf_release_modified (buffer);
11105e: 4620 mov r0, r4
if (modified)
111060: b135 cbz r5, 111070 <rtems_rfs_buffer_bdbuf_release+0x48>
sc = rtems_bdbuf_release_modified (buffer);
111062: f7fe fa27 bl 10f4b4 <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;
111066: 2800 cmp r0, #0
}
return rc;
}
111068: bf14 ite ne
11106a: 2005 movne r0, #5
11106c: 2000 moveq r0, #0
11106e: bd38 pop {r3, r4, r5, pc}
sc = rtems_bdbuf_release (buffer);
111070: f7fe f9d2 bl 10f418 <rtems_bdbuf_release>
rc = EIO;
111074: 2800 cmp r0, #0
}
111076: bf14 ite ne
111078: 2005 movne r0, #5
11107a: 2000 moveq r0, #0
11107c: bd38 pop {r3, r4, r5, pc}
11107e: bf00 nop
001089e4 <rtems_rfs_buffer_close>:
{
1089e4: b538 push {r3, r4, r5, lr}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
1089e6: 2100 movs r1, #0
{
1089e8: 4604 mov r4, r0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
1089ea: 2010 movs r0, #16
1089ec: f001 ffc6 bl 10a97c <rtems_rfs_trace>
1089f0: 2800 cmp r0, #0
1089f2: d139 bne.n 108a68 <rtems_rfs_buffer_close+0x84> <== ALWAYS TAKEN
rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_media_block_size (fs));
1089f4: 6923 ldr r3, [r4, #16]
1089f6: 4620 mov r0, r4
1089f8: 6a19 ldr r1, [r3, #32]
1089fa: f7ff ff9b bl 108934 <rtems_rfs_buffer_setblksize>
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
1089fe: 1e05 subs r5, r0, #0
108a00: dc06 bgt.n 108a10 <rtems_rfs_buffer_close+0x2c> <== ALWAYS TAKEN
if (close (fs->device) < 0)
108a02: 68e0 ldr r0, [r4, #12]
108a04: f007 f88c bl 10fb20 <close>
108a08: 2800 cmp r0, #0
108a0a: db17 blt.n 108a3c <rtems_rfs_buffer_close+0x58> <== ALWAYS TAKEN
}
108a0c: 4628 mov r0, r5
108a0e: bd38 pop {r3, r4, r5, pc}
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
108a10: 2010 movs r0, #16 <== NOT EXECUTED
108a12: 2100 movs r1, #0 <== NOT EXECUTED
108a14: f001 ffb2 bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
108a18: 2800 cmp r0, #0 <== NOT EXECUTED
108a1a: d0f2 beq.n 108a02 <rtems_rfs_buffer_close+0x1e> <== NOT EXECUTED
printf ("rtems-rfs: buffer-close: set media block size failed: %d: %s\n",
108a1c: 4628 mov r0, r5 <== NOT EXECUTED
108a1e: f00e fea7 bl 117770 <strerror> <== NOT EXECUTED
108a22: 4602 mov r2, r0 <== NOT EXECUTED
108a24: f649 2098 movw r0, #39576 ; 0x9a98 <== NOT EXECUTED
108a28: 4629 mov r1, r5 <== NOT EXECUTED
108a2a: f2c0 0011 movt r0, #17 <== NOT EXECUTED
108a2e: f7fd f873 bl 105b18 <__wrap_printf> <== NOT EXECUTED
if (close (fs->device) < 0)
108a32: 68e0 ldr r0, [r4, #12] <== NOT EXECUTED
108a34: f007 f874 bl 10fb20 <close> <== NOT EXECUTED
108a38: 2800 cmp r0, #0 <== NOT EXECUTED
108a3a: dae7 bge.n 108a0c <rtems_rfs_buffer_close+0x28> <== NOT EXECUTED
rc = errno;
108a3c: f00d fcc4 bl 1163c8 <__errno> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
108a40: 2100 movs r1, #0 <== NOT EXECUTED
rc = errno;
108a42: 4603 mov r3, r0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
108a44: 2010 movs r0, #16 <== NOT EXECUTED
rc = errno;
108a46: 681d ldr r5, [r3, #0] <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
108a48: f001 ff98 bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
108a4c: 2800 cmp r0, #0 <== NOT EXECUTED
108a4e: d0dd beq.n 108a0c <rtems_rfs_buffer_close+0x28> <== NOT EXECUTED
printf ("rtems-rfs: buffer-close: file close failed: %d: %s\n",
108a50: 4628 mov r0, r5 <== NOT EXECUTED
108a52: f00e fe8d bl 117770 <strerror> <== NOT EXECUTED
108a56: 4602 mov r2, r0 <== NOT EXECUTED
108a58: f649 20d8 movw r0, #39640 ; 0x9ad8 <== NOT EXECUTED
108a5c: 4629 mov r1, r5 <== NOT EXECUTED
108a5e: f2c0 0011 movt r0, #17 <== NOT EXECUTED
108a62: f7fd f859 bl 105b18 <__wrap_printf> <== NOT EXECUTED
return rc;
108a66: e7d1 b.n 108a0c <rtems_rfs_buffer_close+0x28> <== NOT EXECUTED
printf ("rtems-rfs: buffer-close: closing\n");
108a68: f649 2074 movw r0, #39540 ; 0x9a74 <== NOT EXECUTED
108a6c: f2c0 0011 movt r0, #17 <== NOT EXECUTED
108a70: f7fd f864 bl 105b3c <__wrap_puts> <== NOT EXECUTED
108a74: e7be b.n 1089f4 <rtems_rfs_buffer_close+0x10> <== NOT EXECUTED
108a76: bf00 nop
00108454 <rtems_rfs_buffer_handle_release.part.0>:
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
108454: b570 push {r4, r5, r6, lr} <== NOT EXECUTED
108456: 4604 mov r4, r0 <== NOT EXECUTED
108458: b082 sub sp, #8 <== NOT EXECUTED
10845a: 460d mov r5, r1 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
10845c: f44f 7000 mov.w r0, #512 ; 0x200 <== NOT EXECUTED
108460: 2100 movs r1, #0 <== NOT EXECUTED
108462: f002 fa8b bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
108466: b1e8 cbz r0, 1084a4 <rtems_rfs_buffer_handle_release.part.0+0x50> <== NOT EXECUTED
printf ("rtems-rfs: buffer-release: block=%" PRIu32 " %s refs=%d %s\n",
108468: 68a9 ldr r1, [r5, #8] <== NOT EXECUTED
10846a: f649 30b8 movw r0, #39864 ; 0x9bb8 <== NOT EXECUTED
10846e: 782a ldrb r2, [r5, #0] <== NOT EXECUTED
108470: f249 6384 movw r3, #38532 ; 0x9684 <== NOT EXECUTED
108474: f2c0 0011 movt r0, #17 <== NOT EXECUTED
108478: f2c0 0311 movt r3, #17 <== NOT EXECUTED
10847c: 2a00 cmp r2, #0 <== NOT EXECUTED
10847e: bf14 ite ne <== NOT EXECUTED
108480: 461a movne r2, r3 <== NOT EXECUTED
108482: 4602 moveq r2, r0 <== NOT EXECUTED
108484: 6b0b ldr r3, [r1, #48] ; 0x30 <== NOT EXECUTED
108486: f249 618c movw r1, #38540 ; 0x968c <== NOT EXECUTED
10848a: f2c0 0111 movt r1, #17 <== NOT EXECUTED
10848e: 2b00 cmp r3, #0 <== NOT EXECUTED
108490: bf18 it ne <== NOT EXECUTED
108492: 4601 movne r1, r0 <== NOT EXECUTED
108494: f249 609c movw r0, #38556 ; 0x969c <== NOT EXECUTED
108498: 9100 str r1, [sp, #0] <== NOT EXECUTED
10849a: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10849e: 6869 ldr r1, [r5, #4] <== NOT EXECUTED
1084a0: f7fd fb3a bl 105b18 <__wrap_printf> <== NOT EXECUTED
if (rtems_rfs_buffer_refs (handle) > 0)
1084a4: 68ab ldr r3, [r5, #8] <== NOT EXECUTED
1084a6: 6b18 ldr r0, [r3, #48] ; 0x30 <== NOT EXECUTED
1084a8: 2800 cmp r0, #0 <== NOT EXECUTED
rtems_rfs_buffer_refs_down (handle);
1084aa: bfc4 itt gt <== NOT EXECUTED
1084ac: f100 30ff addgt.w r0, r0, #4294967295 ; 0xffffffff <== NOT EXECUTED
1084b0: 6318 strgt r0, [r3, #48] ; 0x30 <== NOT EXECUTED
if (rtems_rfs_buffer_refs (handle) == 0)
1084b2: b9f8 cbnz r0, 1084f4 <rtems_rfs_buffer_handle_release.part.0+0xa0> <== NOT EXECUTED
fs->buffers_count--;
1084b4: 6d22 ldr r2, [r4, #80] ; 0x50 <== NOT EXECUTED
next = the_node->next;
1084b6: 681e ldr r6, [r3, #0] <== NOT EXECUTED
previous = the_node->previous;
1084b8: 6859 ldr r1, [r3, #4] <== NOT EXECUTED
1084ba: 3a01 subs r2, #1 <== NOT EXECUTED
next->previous = previous;
1084bc: 6071 str r1, [r6, #4] <== NOT EXECUTED
previous->next = next;
1084be: 600e str r6, [r1, #0] <== NOT EXECUTED
1084c0: 6522 str r2, [r4, #80] ; 0x50 <== NOT EXECUTED
if (rtems_rfs_fs_no_local_cache (fs))
1084c2: 6822 ldr r2, [r4, #0] <== NOT EXECUTED
1084c4: 0792 lsls r2, r2, #30 <== NOT EXECUTED
1084c6: d428 bmi.n 10851a <rtems_rfs_buffer_handle_release.part.0+0xc6> <== NOT EXECUTED
if ((fs->release_count +
1084c8: 6f21 ldr r1, [r4, #112] ; 0x70 <== NOT EXECUTED
1084ca: 6e22 ldr r2, [r4, #96] ; 0x60 <== NOT EXECUTED
1084cc: 440a add r2, r1 <== NOT EXECUTED
1084ce: 6c21 ldr r1, [r4, #64] ; 0x40 <== NOT EXECUTED
1084d0: 428a cmp r2, r1 <== NOT EXECUTED
1084d2: d22b bcs.n 10852c <rtems_rfs_buffer_handle_release.part.0+0xd8> <== NOT EXECUTED
if (rtems_rfs_buffer_dirty (handle))
1084d4: 782a ldrb r2, [r5, #0] <== NOT EXECUTED
1084d6: b192 cbz r2, 1084fe <rtems_rfs_buffer_handle_release.part.0+0xaa> <== NOT EXECUTED
fs->release_modified_count++;
1084d8: e9d4 121b ldrd r1, r2, [r4, #108] ; 0x6c <== NOT EXECUTED
return &the_chain->Tail.Node;
1084dc: f104 0668 add.w r6, r4, #104 ; 0x68 <== NOT EXECUTED
the_node->next = tail;
1084e0: 601e str r6, [r3, #0] <== NOT EXECUTED
tail->previous = the_node;
1084e2: 66e3 str r3, [r4, #108] ; 0x6c <== NOT EXECUTED
1084e4: 3201 adds r2, #1 <== NOT EXECUTED
old_last->next = the_node;
1084e6: 600b str r3, [r1, #0] <== NOT EXECUTED
the_node->previous = old_last;
1084e8: 6059 str r1, [r3, #4] <== NOT EXECUTED
handle->buffer = NULL;
1084ea: 2300 movs r3, #0 <== NOT EXECUTED
fs->release_modified_count++;
1084ec: 6722 str r2, [r4, #112] ; 0x70 <== NOT EXECUTED
handle->buffer = NULL;
1084ee: 60ab str r3, [r5, #8] <== NOT EXECUTED
}
1084f0: b002 add sp, #8 <== NOT EXECUTED
1084f2: bd70 pop {r4, r5, r6, pc} <== NOT EXECUTED
handle->buffer = NULL;
1084f4: 2300 movs r3, #0 <== NOT EXECUTED
int rc = 0;
1084f6: 2000 movs r0, #0 <== NOT EXECUTED
handle->buffer = NULL;
1084f8: 60ab str r3, [r5, #8] <== NOT EXECUTED
}
1084fa: b002 add sp, #8 <== NOT EXECUTED
1084fc: bd70 pop {r4, r5, r6, pc} <== NOT EXECUTED
fs->release_count++;
1084fe: e9d4 1217 ldrd r1, r2, [r4, #92] ; 0x5c <== NOT EXECUTED
return &the_chain->Tail.Node;
108502: f104 0658 add.w r6, r4, #88 ; 0x58 <== NOT EXECUTED
the_node->next = tail;
108506: 601e str r6, [r3, #0] <== NOT EXECUTED
tail->previous = the_node;
108508: 65e3 str r3, [r4, #92] ; 0x5c <== NOT EXECUTED
10850a: 3201 adds r2, #1 <== NOT EXECUTED
old_last->next = the_node;
10850c: 600b str r3, [r1, #0] <== NOT EXECUTED
the_node->previous = old_last;
10850e: 6059 str r1, [r3, #4] <== NOT EXECUTED
handle->buffer = NULL;
108510: 2300 movs r3, #0 <== NOT EXECUTED
fs->release_count++;
108512: 6622 str r2, [r4, #96] ; 0x60 <== NOT EXECUTED
handle->buffer = NULL;
108514: 60ab str r3, [r5, #8] <== NOT EXECUTED
}
108516: b002 add sp, #8 <== NOT EXECUTED
108518: bd70 pop {r4, r5, r6, pc} <== NOT EXECUTED
handle->buffer->user = (void*) 0;
10851a: 6358 str r0, [r3, #52] ; 0x34 <== NOT EXECUTED
rc = rtems_rfs_buffer_io_release (handle->buffer,
10851c: 4618 mov r0, r3 <== NOT EXECUTED
10851e: 7829 ldrb r1, [r5, #0] <== NOT EXECUTED
108520: f008 fd82 bl 111028 <rtems_rfs_buffer_bdbuf_release> <== NOT EXECUTED
handle->buffer = NULL;
108524: 2300 movs r3, #0 <== NOT EXECUTED
108526: 60ab str r3, [r5, #8] <== NOT EXECUTED
}
108528: b002 add sp, #8 <== NOT EXECUTED
10852a: bd70 pop {r4, r5, r6, pc} <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
10852c: f44f 7000 mov.w r0, #512 ; 0x200 <== NOT EXECUTED
108530: 2100 movs r1, #0 <== NOT EXECUTED
108532: f002 fa23 bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
108536: bb30 cbnz r0, 108586 <rtems_rfs_buffer_handle_release.part.0+0x132> <== NOT EXECUTED
if (fs->release_count > fs->release_modified_count)
108538: 6e22 ldr r2, [r4, #96] ; 0x60 <== NOT EXECUTED
10853a: 6f23 ldr r3, [r4, #112] ; 0x70 <== NOT EXECUTED
10853c: 429a cmp r2, r3 <== NOT EXECUTED
10853e: d913 bls.n 108568 <rtems_rfs_buffer_handle_release.part.0+0x114> <== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
108540: 4623 mov r3, r4 <== NOT EXECUTED
return &the_chain->Tail.Node;
108542: f104 0158 add.w r1, r4, #88 ; 0x58 <== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
108546: f853 0f54 ldr.w r0, [r3, #84]! <== NOT EXECUTED
fs->release_count--;
10854a: 3a01 subs r2, #1 <== NOT EXECUTED
if ( !_Chain_Is_empty(the_chain))
10854c: 4288 cmp r0, r1 <== NOT EXECUTED
new_first = old_first->next;
10854e: bf17 itett ne <== NOT EXECUTED
108550: 6801 ldrne r1, [r0, #0] <== NOT EXECUTED
return NULL;
108552: 2000 moveq r0, #0 <== NOT EXECUTED
head->next = new_first;
108554: 6561 strne r1, [r4, #84] ; 0x54 <== NOT EXECUTED
new_first->previous = head;
108556: 604b strne r3, [r1, #4] <== NOT EXECUTED
modified = false;
108558: 2100 movs r1, #0 <== NOT EXECUTED
fs->release_count--;
10855a: 6622 str r2, [r4, #96] ; 0x60 <== NOT EXECUTED
buffer->user = (void*) 0;
10855c: 2300 movs r3, #0 <== NOT EXECUTED
10855e: 6343 str r3, [r0, #52] ; 0x34 <== NOT EXECUTED
rc = rtems_rfs_buffer_io_release (buffer, modified);
108560: f008 fd62 bl 111028 <rtems_rfs_buffer_bdbuf_release> <== NOT EXECUTED
rtems_rfs_buffer_link (handle));
108564: 68ab ldr r3, [r5, #8] <== NOT EXECUTED
108566: e7b5 b.n 1084d4 <rtems_rfs_buffer_handle_release.part.0+0x80> <== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
108568: 4622 mov r2, r4 <== NOT EXECUTED
return &the_chain->Tail.Node;
10856a: f104 0168 add.w r1, r4, #104 ; 0x68 <== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
10856e: f852 0f64 ldr.w r0, [r2, #100]! <== NOT EXECUTED
fs->release_modified_count--;
108572: 3b01 subs r3, #1 <== NOT EXECUTED
if ( !_Chain_Is_empty(the_chain))
108574: 4288 cmp r0, r1 <== NOT EXECUTED
new_first = old_first->next;
108576: bf17 itett ne <== NOT EXECUTED
108578: 6801 ldrne r1, [r0, #0] <== NOT EXECUTED
return NULL;
10857a: 2000 moveq r0, #0 <== NOT EXECUTED
head->next = new_first;
10857c: 6661 strne r1, [r4, #100] ; 0x64 <== NOT EXECUTED
new_first->previous = head;
10857e: 604a strne r2, [r1, #4] <== NOT EXECUTED
modified = true;
108580: 2101 movs r1, #1 <== NOT EXECUTED
fs->release_modified_count--;
108582: 6723 str r3, [r4, #112] ; 0x70 <== NOT EXECUTED
modified = true;
108584: e7ea b.n 10855c <rtems_rfs_buffer_handle_release.part.0+0x108> <== NOT EXECUTED
printf ("rtems-rfs: buffer-release: local cache overflow:"
108586: 6e21 ldr r1, [r4, #96] ; 0x60 <== NOT EXECUTED
108588: f249 60d0 movw r0, #38608 ; 0x96d0 <== NOT EXECUTED
10858c: 6f23 ldr r3, [r4, #112] ; 0x70 <== NOT EXECUTED
10858e: f2c0 0011 movt r0, #17 <== NOT EXECUTED
108592: 4419 add r1, r3 <== NOT EXECUTED
108594: f7fd fac0 bl 105b18 <__wrap_printf> <== NOT EXECUTED
108598: e7ce b.n 108538 <rtems_rfs_buffer_handle_release.part.0+0xe4> <== NOT EXECUTED
10859a: bf00 nop
0010859c <rtems_rfs_buffer_handle_request>:
{
10859c: e92d 41f0 stmdb sp!, {r4, r5, r6, r7, r8, lr}
1085a0: 460c mov r4, r1
if (rtems_rfs_buffer_handle_has_block (handle))
1085a2: 6889 ldr r1, [r1, #8]
{
1085a4: b082 sub sp, #8
1085a6: 4605 mov r5, r0
1085a8: 4616 mov r6, r2
1085aa: 4698 mov r8, r3
if (rtems_rfs_buffer_handle_has_block (handle))
1085ac: b1b9 cbz r1, 1085de <rtems_rfs_buffer_handle_request+0x42>
if (block && (rtems_rfs_buffer_bnum (handle) == block))
1085ae: b11a cbz r2, 1085b8 <rtems_rfs_buffer_handle_request+0x1c>
1085b0: 6863 ldr r3, [r4, #4]
1085b2: 4293 cmp r3, r2
1085b4: f000 8095 beq.w 1086e2 <rtems_rfs_buffer_handle_request+0x146>
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
1085b8: f44f 7080 mov.w r0, #256 ; 0x100
1085bc: 2100 movs r1, #0
1085be: f002 f9dd bl 10a97c <rtems_rfs_trace>
1085c2: 2800 cmp r0, #0
1085c4: f040 8081 bne.w 1086ca <rtems_rfs_buffer_handle_request+0x12e> <== ALWAYS TAKEN
if (rtems_rfs_buffer_handle_has_block (handle))
1085c8: 68a3 ldr r3, [r4, #8]
1085ca: b12b cbz r3, 1085d8 <rtems_rfs_buffer_handle_request+0x3c>
1085cc: 4621 mov r1, r4
1085ce: 4628 mov r0, r5
1085d0: f7ff ff40 bl 108454 <rtems_rfs_buffer_handle_release.part.0>
if (rc > 0)
1085d4: 1e07 subs r7, r0, #0
1085d6: dc40 bgt.n 10865a <rtems_rfs_buffer_handle_request+0xbe> <== ALWAYS TAKEN
handle->dirty = false;
1085d8: 2300 movs r3, #0
1085da: 7023 strb r3, [r4, #0]
handle->bnum = 0;
1085dc: 6063 str r3, [r4, #4]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
1085de: f44f 7080 mov.w r0, #256 ; 0x100
1085e2: 2100 movs r1, #0
1085e4: f002 f9ca bl 10a97c <rtems_rfs_trace>
1085e8: 2800 cmp r0, #0
1085ea: d163 bne.n 1086b4 <rtems_rfs_buffer_handle_request+0x118> <== ALWAYS TAKEN
if (fs->buffers_count)
1085ec: 6d2b ldr r3, [r5, #80] ; 0x50
1085ee: 2b00 cmp r3, #0
1085f0: d146 bne.n 108680 <rtems_rfs_buffer_handle_request+0xe4>
if (!rtems_rfs_fs_no_local_cache (fs) &&
1085f2: 682b ldr r3, [r5, #0]
!rtems_rfs_buffer_handle_has_block (handle))
1085f4: 68a0 ldr r0, [r4, #8]
if (!rtems_rfs_fs_no_local_cache (fs) &&
1085f6: 079a lsls r2, r3, #30
1085f8: d433 bmi.n 108662 <rtems_rfs_buffer_handle_request+0xc6>
1085fa: 2800 cmp r0, #0
1085fc: d079 beq.n 1086f2 <rtems_rfs_buffer_handle_request+0x156>
rtems_rfs_buffer_refs_up (handle);
1085fe: 6b03 ldr r3, [r0, #48] ; 0x30
return &the_chain->Tail.Node;
108600: f105 0148 add.w r1, r5, #72 ; 0x48
old_last = tail->previous;
108604: 6cea ldr r2, [r5, #76] ; 0x4c
108606: 3301 adds r3, #1
108608: 6303 str r3, [r0, #48] ; 0x30
fs->buffers_count++;
10860a: 6d2b ldr r3, [r5, #80] ; 0x50
the_node->next = tail;
10860c: 6001 str r1, [r0, #0]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
10860e: 2100 movs r1, #0
tail->previous = the_node;
108610: 64e8 str r0, [r5, #76] ; 0x4c
fs->buffers_count++;
108612: 3301 adds r3, #1
old_last->next = the_node;
108614: 6010 str r0, [r2, #0]
the_node->previous = old_last;
108616: 6042 str r2, [r0, #4]
108618: 652b str r3, [r5, #80] ; 0x50
handle->buffer->user = (void*) ((intptr_t) block);
10861a: 6346 str r6, [r0, #52] ; 0x34
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
10861c: f44f 7080 mov.w r0, #256 ; 0x100
handle->bnum = block;
108620: 6066 str r6, [r4, #4]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
108622: f002 f9ab bl 10a97c <rtems_rfs_trace>
108626: 2800 cmp r0, #0
108628: d05b beq.n 1086e2 <rtems_rfs_buffer_handle_request+0x146> <== NEVER TAKEN
block, read ? "read" : "get", handle->buffer->block,
10862a: 68a4 ldr r4, [r4, #8] <== NOT EXECUTED
printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
10862c: f249 7208 movw r2, #38664 ; 0x9708 <== NOT EXECUTED
108630: f249 7310 movw r3, #38672 ; 0x9710 <== NOT EXECUTED
108634: f2c0 0211 movt r2, #17 <== NOT EXECUTED
108638: f2c0 0311 movt r3, #17 <== NOT EXECUTED
10863c: f249 70dc movw r0, #38876 ; 0x97dc <== NOT EXECUTED
108640: f1b8 0f00 cmp.w r8, #0 <== NOT EXECUTED
108644: bf08 it eq <== NOT EXECUTED
108646: 461a moveq r2, r3 <== NOT EXECUTED
108648: 69a3 ldr r3, [r4, #24] <== NOT EXECUTED
10864a: 6b24 ldr r4, [r4, #48] ; 0x30 <== NOT EXECUTED
10864c: 4631 mov r1, r6 <== NOT EXECUTED
10864e: f2c0 0011 movt r0, #17 <== NOT EXECUTED
return 0;
108652: 2700 movs r7, #0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
108654: 9400 str r4, [sp, #0] <== NOT EXECUTED
108656: f7fd fa5f bl 105b18 <__wrap_printf> <== NOT EXECUTED
}
10865a: 4638 mov r0, r7 <== NOT EXECUTED
10865c: b002 add sp, #8 <== NOT EXECUTED
10865e: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
if (!rtems_rfs_buffer_handle_has_block (handle))
108662: 2800 cmp r0, #0
108664: d1cb bne.n 1085fe <rtems_rfs_buffer_handle_request+0x62> <== ALWAYS TAKEN
rc = rtems_rfs_buffer_io_request (fs, block, read, &handle->buffer);
108666: f104 0308 add.w r3, r4, #8
10866a: 4642 mov r2, r8
10866c: 4631 mov r1, r6
10866e: 4628 mov r0, r5
108670: f008 fcc6 bl 111000 <rtems_rfs_buffer_bdbuf_request>
if (rc > 0)
108674: 1e07 subs r7, r0, #0
108676: dc4e bgt.n 108716 <rtems_rfs_buffer_handle_request+0x17a> <== ALWAYS TAKEN
rtems_chain_set_off_chain (rtems_rfs_buffer_link(handle));
108678: 68a0 ldr r0, [r4, #8]
node->next = NULL;
10867a: 2300 movs r3, #0
10867c: 6003 str r3, [r0, #0]
RTEMS_INLINE_ROUTINE void rtems_chain_set_off_chain(
rtems_chain_node *node
)
{
_Chain_Set_off_chain( node );
}
10867e: e7be b.n 1085fe <rtems_rfs_buffer_handle_request+0x62>
handle->buffer = rtems_rfs_scan_chain (&fs->buffers,
108680: 4632 mov r2, r6
108682: f105 0150 add.w r1, r5, #80 ; 0x50
108686: f105 0044 add.w r0, r5, #68 ; 0x44
10868a: f7ff fe4f bl 10832c <rtems_rfs_scan_chain>
10868e: 60a0 str r0, [r4, #8]
if (rtems_rfs_buffer_handle_has_block (handle) &&
108690: b360 cbz r0, 1086ec <rtems_rfs_buffer_handle_request+0x150>
rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
108692: f44f 7080 mov.w r0, #256 ; 0x100
108696: 2100 movs r1, #0
108698: f002 f970 bl 10a97c <rtems_rfs_trace>
if (rtems_rfs_buffer_handle_has_block (handle) &&
10869c: 2800 cmp r0, #0
10869e: d0a8 beq.n 1085f2 <rtems_rfs_buffer_handle_request+0x56> <== NEVER TAKEN
rtems_rfs_buffer_refs (handle) + 1);
1086a0: 68a3 ldr r3, [r4, #8] <== NOT EXECUTED
printf ("rtems-rfs: buffer-request: buffer shared: refs: %d\n",
1086a2: f249 7070 movw r0, #38768 ; 0x9770 <== NOT EXECUTED
1086a6: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1086aa: 6b19 ldr r1, [r3, #48] ; 0x30 <== NOT EXECUTED
1086ac: 3101 adds r1, #1 <== NOT EXECUTED
1086ae: f7fd fa33 bl 105b18 <__wrap_printf> <== NOT EXECUTED
1086b2: e79e b.n 1085f2 <rtems_rfs_buffer_handle_request+0x56> <== NOT EXECUTED
printf ("rtems-rfs: buffer-request: block=%" PRIu32 "\n", block);
1086b4: f249 7048 movw r0, #38728 ; 0x9748 <== NOT EXECUTED
1086b8: 4631 mov r1, r6 <== NOT EXECUTED
1086ba: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1086be: f7fd fa2b bl 105b18 <__wrap_printf> <== NOT EXECUTED
if (fs->buffers_count)
1086c2: 6d2b ldr r3, [r5, #80] ; 0x50 <== NOT EXECUTED
1086c4: 2b00 cmp r3, #0 <== NOT EXECUTED
1086c6: d094 beq.n 1085f2 <rtems_rfs_buffer_handle_request+0x56> <== NOT EXECUTED
1086c8: e7da b.n 108680 <rtems_rfs_buffer_handle_request+0xe4> <== NOT EXECUTED
printf ("rtems-rfs: buffer-request: handle has buffer: %" PRIu32 "\n",
1086ca: f249 7014 movw r0, #38676 ; 0x9714 <== NOT EXECUTED
1086ce: 6861 ldr r1, [r4, #4] <== NOT EXECUTED
1086d0: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1086d4: f7fd fa20 bl 105b18 <__wrap_printf> <== NOT EXECUTED
if (rtems_rfs_buffer_handle_has_block (handle))
1086d8: 68a3 ldr r3, [r4, #8] <== NOT EXECUTED
1086da: 2b00 cmp r3, #0 <== NOT EXECUTED
1086dc: f47f af76 bne.w 1085cc <rtems_rfs_buffer_handle_request+0x30> <== NOT EXECUTED
1086e0: e77a b.n 1085d8 <rtems_rfs_buffer_handle_request+0x3c> <== NOT EXECUTED
return 0;
1086e2: 2700 movs r7, #0
}
1086e4: 4638 mov r0, r7
1086e6: b002 add sp, #8
1086e8: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
if (!rtems_rfs_fs_no_local_cache (fs) &&
1086ec: 682b ldr r3, [r5, #0]
1086ee: 079b lsls r3, r3, #30
1086f0: d4b9 bmi.n 108666 <rtems_rfs_buffer_handle_request+0xca>
if (fs->release_count)
1086f2: 6e2b ldr r3, [r5, #96] ; 0x60
1086f4: bb8b cbnz r3, 10875a <rtems_rfs_buffer_handle_request+0x1be>
if (!rtems_rfs_buffer_handle_has_block (handle) &&
1086f6: 6f2b ldr r3, [r5, #112] ; 0x70
1086f8: 2b00 cmp r3, #0
1086fa: d0b4 beq.n 108666 <rtems_rfs_buffer_handle_request+0xca>
handle->buffer = rtems_rfs_scan_chain (&fs->release_modified,
1086fc: 4632 mov r2, r6
1086fe: f105 0170 add.w r1, r5, #112 ; 0x70
108702: f105 0064 add.w r0, r5, #100 ; 0x64
108706: f7ff fe11 bl 10832c <rtems_rfs_scan_chain>
10870a: 60a0 str r0, [r4, #8]
if (rtems_rfs_buffer_handle_has_block (handle))
10870c: 2800 cmp r0, #0
10870e: d0aa beq.n 108666 <rtems_rfs_buffer_handle_request+0xca>
rtems_rfs_buffer_mark_dirty (handle);
108710: 2301 movs r3, #1
108712: 7023 strb r3, [r4, #0]
108714: e773 b.n 1085fe <rtems_rfs_buffer_handle_request+0x62>
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
108716: f44f 7080 mov.w r0, #256 ; 0x100 <== NOT EXECUTED
10871a: 2100 movs r1, #0 <== NOT EXECUTED
10871c: f002 f92e bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
108720: 2800 cmp r0, #0 <== NOT EXECUTED
108722: d09a beq.n 10865a <rtems_rfs_buffer_handle_request+0xbe> <== NOT EXECUTED
printf ("rtems-rfs: buffer-request: block=%" PRIu32 ": bdbuf-%s: %d: %s\n",
108724: f249 7208 movw r2, #38664 ; 0x9708 <== NOT EXECUTED
108728: f249 7410 movw r4, #38672 ; 0x9710 <== NOT EXECUTED
10872c: f2c0 0211 movt r2, #17 <== NOT EXECUTED
108730: 4638 mov r0, r7 <== NOT EXECUTED
108732: f2c0 0411 movt r4, #17 <== NOT EXECUTED
108736: f1b8 0f00 cmp.w r8, #0 <== NOT EXECUTED
10873a: bf18 it ne <== NOT EXECUTED
10873c: 4614 movne r4, r2 <== NOT EXECUTED
10873e: f00f f817 bl 117770 <strerror> <== NOT EXECUTED
108742: 4605 mov r5, r0 <== NOT EXECUTED
108744: f249 70a4 movw r0, #38820 ; 0x97a4 <== NOT EXECUTED
108748: 463b mov r3, r7 <== NOT EXECUTED
10874a: 4622 mov r2, r4 <== NOT EXECUTED
10874c: 4631 mov r1, r6 <== NOT EXECUTED
10874e: 9500 str r5, [sp, #0] <== NOT EXECUTED
108750: f2c0 0011 movt r0, #17 <== NOT EXECUTED
108754: f7fd f9e0 bl 105b18 <__wrap_printf> <== NOT EXECUTED
108758: e77f b.n 10865a <rtems_rfs_buffer_handle_request+0xbe> <== NOT EXECUTED
handle->buffer = rtems_rfs_scan_chain (&fs->release,
10875a: 4632 mov r2, r6
10875c: f105 0160 add.w r1, r5, #96 ; 0x60
108760: f105 0054 add.w r0, r5, #84 ; 0x54
108764: f7ff fde2 bl 10832c <rtems_rfs_scan_chain>
108768: 60a0 str r0, [r4, #8]
if (!rtems_rfs_buffer_handle_has_block (handle) &&
10876a: 2800 cmp r0, #0
10876c: f47f af47 bne.w 1085fe <rtems_rfs_buffer_handle_request+0x62>
108770: e7c1 b.n 1086f6 <rtems_rfs_buffer_handle_request+0x15a>
108772: bf00 nop
00108780 <rtems_rfs_buffer_open>:
{
108780: b570 push {r4, r5, r6, lr}
108782: 4605 mov r5, r0
108784: b09a sub sp, #104 ; 0x68
108786: 460c mov r4, r1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
108788: 2020 movs r0, #32
10878a: 2100 movs r1, #0
10878c: f002 f8f6 bl 10a97c <rtems_rfs_trace>
108790: bb70 cbnz r0, 1087f0 <rtems_rfs_buffer_open+0x70>
fs->device = open (name, O_RDWR);
108792: 2102 movs r1, #2
108794: 4628 mov r0, r5
108796: f007 fbab bl 10fef0 <open>
if (fs->device < 0)
10879a: 2800 cmp r0, #0
fs->device = open (name, O_RDWR);
10879c: 60e0 str r0, [r4, #12]
if (fs->device < 0)
10879e: db38 blt.n 108812 <rtems_rfs_buffer_open+0x92> <== ALWAYS TAKEN
if (fstat (fs->device, &st) < 0)
1087a0: 4669 mov r1, sp
1087a2: f007 fa23 bl 10fbec <fstat>
1087a6: 2800 cmp r0, #0
1087a8: db5b blt.n 108862 <rtems_rfs_buffer_open+0xe2> <== ALWAYS TAKEN
if (!S_ISBLK (st.st_mode))
1087aa: 9b04 ldr r3, [sp, #16]
1087ac: f403 4370 and.w r3, r3, #61440 ; 0xf000
1087b0: f5b3 4fc0 cmp.w r3, #24576 ; 0x6000
1087b4: d113 bne.n 1087de <rtems_rfs_buffer_open+0x5e> <== ALWAYS 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);
1087b6: f244 2109 movw r1, #16905 ; 0x4209
1087ba: 68e0 ldr r0, [r4, #12]
1087bc: f104 0210 add.w r2, r4, #16
1087c0: f2c4 0104 movt r1, #16388 ; 0x4004
1087c4: f007 fa7a bl 10fcbc <ioctl>
if (rv != 0)
1087c8: 4606 mov r6, r0
1087ca: 2800 cmp r0, #0
1087cc: d13b bne.n 108846 <rtems_rfs_buffer_open+0xc6> <== ALWAYS TAKEN
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
1087ce: 2020 movs r0, #32
1087d0: 2100 movs r1, #0
1087d2: f002 f8d3 bl 10a97c <rtems_rfs_trace>
1087d6: bb50 cbnz r0, 10882e <rtems_rfs_buffer_open+0xae>
}
1087d8: 4630 mov r0, r6
1087da: b01a add sp, #104 ; 0x68
1087dc: bd70 pop {r4, r5, r6, pc}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
1087de: 2008 movs r0, #8 <== NOT EXECUTED
1087e0: 2100 movs r1, #0 <== NOT EXECUTED
1087e2: f002 f8cb bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
1087e6: b958 cbnz r0, 108800 <rtems_rfs_buffer_open+0x80> <== NOT EXECUTED
return ENXIO;
1087e8: 2606 movs r6, #6 <== NOT EXECUTED
}
1087ea: 4630 mov r0, r6 <== NOT EXECUTED
1087ec: b01a add sp, #104 ; 0x68 <== NOT EXECUTED
1087ee: bd70 pop {r4, r5, r6, pc} <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: opening: %s\n", name);
1087f0: f649 0018 movw r0, #38936 ; 0x9818 <== NOT EXECUTED
1087f4: 4629 mov r1, r5 <== NOT EXECUTED
1087f6: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1087fa: f7fd f98d bl 105b18 <__wrap_printf> <== NOT EXECUTED
1087fe: e7c8 b.n 108792 <rtems_rfs_buffer_open+0x12> <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: '%s' is not a block device\n", name);
108800: f649 009c movw r0, #39068 ; 0x989c <== NOT EXECUTED
108804: 4629 mov r1, r5 <== NOT EXECUTED
108806: f2c0 0011 movt r0, #17 <== NOT EXECUTED
return ENXIO;
10880a: 2606 movs r6, #6 <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: '%s' is not a block device\n", name);
10880c: f7fd f984 bl 105b18 <__wrap_printf> <== NOT EXECUTED
108810: e7e2 b.n 1087d8 <rtems_rfs_buffer_open+0x58> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
108812: 2008 movs r0, #8 <== NOT EXECUTED
108814: 2100 movs r1, #0 <== NOT EXECUTED
108816: f002 f8b1 bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
10881a: 2800 cmp r0, #0 <== NOT EXECUTED
10881c: d0e4 beq.n 1087e8 <rtems_rfs_buffer_open+0x68> <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: cannot open file\n");
10881e: f649 0040 movw r0, #38976 ; 0x9840 <== NOT EXECUTED
return ENXIO;
108822: 2606 movs r6, #6 <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: cannot open file\n");
108824: f2c0 0011 movt r0, #17 <== NOT EXECUTED
108828: f7fd f988 bl 105b3c <__wrap_puts> <== NOT EXECUTED
10882c: e7d4 b.n 1087d8 <rtems_rfs_buffer_open+0x58> <== NOT EXECUTED
rtems_rfs_fs_media_blocks (fs),
10882e: 6923 ldr r3, [r4, #16] <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: blks=%" PRId32 ", blk-size=%" PRId32 "\n",
108830: f649 1000 movw r0, #39168 ; 0x9900 <== NOT EXECUTED
108834: f2c0 0011 movt r0, #17 <== NOT EXECUTED
108838: e9d3 1207 ldrd r1, r2, [r3, #28] <== NOT EXECUTED
10883c: f7fd f96c bl 105b18 <__wrap_printf> <== NOT EXECUTED
}
108840: 4630 mov r0, r6 <== NOT EXECUTED
108842: b01a add sp, #104 ; 0x68 <== NOT EXECUTED
108844: bd70 pop {r4, r5, r6, pc} <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
108846: 2008 movs r0, #8 <== NOT EXECUTED
108848: 2100 movs r1, #0 <== NOT EXECUTED
10884a: f002 f897 bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
10884e: 2800 cmp r0, #0 <== NOT EXECUTED
108850: d0ca beq.n 1087e8 <rtems_rfs_buffer_open+0x68> <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: cannot obtain the disk\n");
108852: f649 00d0 movw r0, #39120 ; 0x98d0 <== NOT EXECUTED
return ENXIO;
108856: 2606 movs r6, #6 <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: cannot obtain the disk\n");
108858: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10885c: f7fd f96e bl 105b3c <__wrap_puts> <== NOT EXECUTED
108860: e7ba b.n 1087d8 <rtems_rfs_buffer_open+0x58> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
108862: 2008 movs r0, #8 <== NOT EXECUTED
108864: 2100 movs r1, #0 <== NOT EXECUTED
108866: f002 f889 bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
10886a: 2800 cmp r0, #0 <== NOT EXECUTED
10886c: d0bc beq.n 1087e8 <rtems_rfs_buffer_open+0x68> <== NOT EXECUTED
name, strerror (errno));
10886e: f00d fdab bl 1163c8 <__errno> <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n",
108872: 6800 ldr r0, [r0, #0] <== NOT EXECUTED
return ENXIO;
108874: 2606 movs r6, #6 <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n",
108876: f00e ff7b bl 117770 <strerror> <== NOT EXECUTED
10887a: 4602 mov r2, r0 <== NOT EXECUTED
10887c: f649 006c movw r0, #39020 ; 0x986c <== NOT EXECUTED
108880: 4629 mov r1, r5 <== NOT EXECUTED
108882: f2c0 0011 movt r0, #17 <== NOT EXECUTED
108886: f7fd f947 bl 105b18 <__wrap_printf> <== NOT EXECUTED
10888a: e7a5 b.n 1087d8 <rtems_rfs_buffer_open+0x58> <== NOT EXECUTED
00108934 <rtems_rfs_buffer_setblksize>:
{
108934: b530 push {r4, r5, lr}
108936: b083 sub sp, #12
108938: 4604 mov r4, r0
10893a: 9101 str r1, [sp, #4]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
10893c: f44f 6080 mov.w r0, #1024 ; 0x400
108940: 2100 movs r1, #0
108942: f002 f81b bl 10a97c <rtems_rfs_trace>
108946: 2800 cmp r0, #0
108948: d13f bne.n 1089ca <rtems_rfs_buffer_setblksize+0x96> <== ALWAYS TAKEN
rc = rtems_rfs_buffers_release (fs);
10894a: 4620 mov r0, r4
10894c: f7ff ffc6 bl 1088dc <rtems_rfs_buffers_release>
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
108950: 1e05 subs r5, r0, #0
108952: dc10 bgt.n 108976 <rtems_rfs_buffer_setblksize+0x42> <== ALWAYS TAKEN
rc = rtems_rfs_buffer_sync (fs);
108954: 4620 mov r0, r4
108956: f7ff ff99 bl 10888c <rtems_rfs_buffer_sync>
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
10895a: 1e05 subs r5, r0, #0
10895c: dc22 bgt.n 1089a4 <rtems_rfs_buffer_setblksize+0x70> <== ALWAYS TAKEN
rc = fs->disk->ioctl (fs->disk, RTEMS_BLKIO_SETBLKSIZE, &size);
10895e: 6920 ldr r0, [r4, #16]
108960: f244 2104 movw r1, #16900 ; 0x4204
108964: aa01 add r2, sp, #4
108966: f2c8 0104 movt r1, #32772 ; 0x8004
10896a: 6b83 ldr r3, [r0, #56] ; 0x38
10896c: 4798 blx r3
if (rc < 0)
10896e: 2800 cmp r0, #0
108970: db33 blt.n 1089da <rtems_rfs_buffer_setblksize+0xa6> <== ALWAYS TAKEN
}
108972: b003 add sp, #12
108974: bd30 pop {r4, r5, pc}
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
108976: f44f 6080 mov.w r0, #1024 ; 0x400 <== NOT EXECUTED
10897a: 2100 movs r1, #0 <== NOT EXECUTED
10897c: f001 fffe bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
108980: 2800 cmp r0, #0 <== NOT EXECUTED
108982: d0e7 beq.n 108954 <rtems_rfs_buffer_setblksize+0x20> <== NOT EXECUTED
printf ("rtems-rfs: buffer-setblksize: buffer release failed: %d: %s\n",
108984: 4628 mov r0, r5 <== NOT EXECUTED
108986: f00e fef3 bl 117770 <strerror> <== NOT EXECUTED
10898a: 4602 mov r2, r0 <== NOT EXECUTED
10898c: f649 10f8 movw r0, #39416 ; 0x99f8 <== NOT EXECUTED
108990: 4629 mov r1, r5 <== NOT EXECUTED
108992: f2c0 0011 movt r0, #17 <== NOT EXECUTED
108996: f7fd f8bf bl 105b18 <__wrap_printf> <== NOT EXECUTED
rc = rtems_rfs_buffer_sync (fs);
10899a: 4620 mov r0, r4 <== NOT EXECUTED
10899c: f7ff ff76 bl 10888c <rtems_rfs_buffer_sync> <== NOT EXECUTED
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
1089a0: 1e05 subs r5, r0, #0 <== NOT EXECUTED
1089a2: dddc ble.n 10895e <rtems_rfs_buffer_setblksize+0x2a> <== NOT EXECUTED
1089a4: f44f 6080 mov.w r0, #1024 ; 0x400 <== NOT EXECUTED
1089a8: 2100 movs r1, #0 <== NOT EXECUTED
1089aa: f001 ffe7 bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
1089ae: 2800 cmp r0, #0 <== NOT EXECUTED
1089b0: d0d5 beq.n 10895e <rtems_rfs_buffer_setblksize+0x2a> <== NOT EXECUTED
printf ("rtems-rfs: buffer-setblksize: device sync failed: %d: %s\n",
1089b2: 4628 mov r0, r5 <== NOT EXECUTED
1089b4: f00e fedc bl 117770 <strerror> <== NOT EXECUTED
1089b8: 4602 mov r2, r0 <== NOT EXECUTED
1089ba: f649 2038 movw r0, #39480 ; 0x9a38 <== NOT EXECUTED
1089be: 4629 mov r1, r5 <== NOT EXECUTED
1089c0: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1089c4: f7fd f8a8 bl 105b18 <__wrap_printf> <== NOT EXECUTED
1089c8: e7c9 b.n 10895e <rtems_rfs_buffer_setblksize+0x2a> <== NOT EXECUTED
printf ("rtems-rfs: buffer-setblksize: block size: %" PRIu32 "\n", size);
1089ca: f649 10c8 movw r0, #39368 ; 0x99c8 <== NOT EXECUTED
1089ce: 9901 ldr r1, [sp, #4] <== NOT EXECUTED
1089d0: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1089d4: f7fd f8a0 bl 105b18 <__wrap_printf> <== NOT EXECUTED
1089d8: e7b7 b.n 10894a <rtems_rfs_buffer_setblksize+0x16> <== NOT EXECUTED
rc = errno;
1089da: f00d fcf5 bl 1163c8 <__errno> <== NOT EXECUTED
1089de: 6800 ldr r0, [r0, #0] <== NOT EXECUTED
}
1089e0: b003 add sp, #12 <== NOT EXECUTED
1089e2: bd30 pop {r4, r5, pc} <== NOT EXECUTED
0010888c <rtems_rfs_buffer_sync>:
{
10888c: b510 push {r4, lr}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
10888e: 2100 movs r1, #0
{
108890: 4604 mov r4, r0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
108892: 2020 movs r0, #32
108894: f002 f872 bl 10a97c <rtems_rfs_trace>
108898: b960 cbnz r0, 1088b4 <rtems_rfs_buffer_sync+0x28>
sc = rtems_bdbuf_syncdev (rtems_rfs_fs_device (fs));
10889a: 6920 ldr r0, [r4, #16]
10889c: f006 fe2e bl 10f4fc <rtems_bdbuf_syncdev>
if (sc != RTEMS_SUCCESSFUL)
1088a0: 4604 mov r4, r0
1088a2: b900 cbnz r0, 1088a6 <rtems_rfs_buffer_sync+0x1a>
}
1088a4: bd10 pop {r4, pc}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
1088a6: 2020 movs r0, #32 <== NOT EXECUTED
1088a8: 2100 movs r1, #0 <== NOT EXECUTED
1088aa: f002 f867 bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
1088ae: b940 cbnz r0, 1088c2 <rtems_rfs_buffer_sync+0x36> <== NOT EXECUTED
result = EIO;
1088b0: 2005 movs r0, #5 <== NOT EXECUTED
}
1088b2: bd10 pop {r4, pc} <== NOT EXECUTED
printf ("rtems-rfs: buffer-sync: syncing\n");
1088b4: f649 1030 movw r0, #39216 ; 0x9930 <== NOT EXECUTED
1088b8: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1088bc: f7fd f93e bl 105b3c <__wrap_puts> <== NOT EXECUTED
1088c0: e7eb b.n 10889a <rtems_rfs_buffer_sync+0xe> <== NOT EXECUTED
printf ("rtems-rfs: buffer-sync: device sync failed: %s\n",
1088c2: 4620 mov r0, r4 <== NOT EXECUTED
1088c4: f002 f868 bl 10a998 <rtems_status_text> <== NOT EXECUTED
1088c8: 4601 mov r1, r0 <== NOT EXECUTED
1088ca: f649 1050 movw r0, #39248 ; 0x9950 <== NOT EXECUTED
1088ce: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1088d2: f7fd f921 bl 105b18 <__wrap_printf> <== NOT EXECUTED
result = EIO;
1088d6: 2005 movs r0, #5 <== NOT EXECUTED
}
1088d8: bd10 pop {r4, pc} <== NOT EXECUTED
1088da: bf00 nop
001088dc <rtems_rfs_buffers_release>:
int
rtems_rfs_buffers_release (rtems_rfs_file_system* fs)
{
1088dc: b510 push {r4, lr}
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
1088de: 2100 movs r1, #0
{
1088e0: 4604 mov r4, r0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
1088e2: 2040 movs r0, #64 ; 0x40
1088e4: f002 f84a bl 10a97c <rtems_rfs_trace>
1088e8: b9d0 cbnz r0, 108920 <rtems_rfs_buffers_release+0x44>
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,
1088ea: f104 0160 add.w r1, r4, #96 ; 0x60
1088ee: 2200 movs r2, #0
1088f0: f104 0054 add.w r0, r4, #84 ; 0x54
1088f4: f7ff fd76 bl 1083e4 <rtems_rfs_release_chain>
&fs->release_count,
false);
if ((rc > 0) && (rrc == 0))
rrc = rc;
rc = rtems_rfs_release_chain (&fs->release_modified,
1088f8: f104 0170 add.w r1, r4, #112 ; 0x70
rc = rtems_rfs_release_chain (&fs->release,
1088fc: 4603 mov r3, r0
rc = rtems_rfs_release_chain (&fs->release_modified,
1088fe: 2201 movs r2, #1
108900: f104 0064 add.w r0, r4, #100 ; 0x64
rc = rtems_rfs_release_chain (&fs->release,
108904: 461c mov r4, r3
rc = rtems_rfs_release_chain (&fs->release_modified,
108906: f7ff fd6d bl 1083e4 <rtems_rfs_release_chain>
&fs->release_modified_count,
true);
if ((rc > 0) && (rrc == 0))
10890a: 2800 cmp r0, #0
10890c: bfcc ite gt
10890e: 2301 movgt r3, #1
108910: 2300 movle r3, #0
108912: 2c00 cmp r4, #0
108914: bfc8 it gt
108916: 2300 movgt r3, #0
108918: b90b cbnz r3, 10891e <rtems_rfs_buffers_release+0x42>
10891a: ea24 70e4 bic.w r0, r4, r4, asr #31
rrc = rc;
return rrc;
}
10891e: bd10 pop {r4, pc}
printf ("rtems-rfs: buffers-release: active:%" PRIu32 " "
108920: f649 1080 movw r0, #39296 ; 0x9980 <== NOT EXECUTED
108924: 6f23 ldr r3, [r4, #112] ; 0x70 <== NOT EXECUTED
108926: 6e22 ldr r2, [r4, #96] ; 0x60 <== NOT EXECUTED
108928: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10892c: 6d21 ldr r1, [r4, #80] ; 0x50 <== NOT EXECUTED
10892e: f7fd f8f3 bl 105b18 <__wrap_printf> <== NOT EXECUTED
108932: e7da b.n 1088ea <rtems_rfs_buffers_release+0xe> <== NOT EXECUTED
001113d8 <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)
{
1113d8: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
1113dc: 4607 mov r7, r0
1113de: b09f sub sp, #124 ; 0x7c
1113e0: 4688 mov r8, r1
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))
1113e2: f04f 5000 mov.w r0, #536870912 ; 0x20000000
1113e6: 2100 movs r1, #0
{
1113e8: 4692 mov sl, r2
1113ea: 4699 mov r9, r3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
1113ec: f7f9 fac6 bl 10a97c <rtems_rfs_trace>
1113f0: 2800 cmp r0, #0
1113f2: f040 80bf bne.w 111574 <rtems_rfs_dir_add_entry+0x19c> <== ALWAYS 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);
1113f6: 4641 mov r1, r8
1113f8: aa0a add r2, sp, #40 ; 0x28
1113fa: 4638 mov r0, r7
1113fc: f7ff fa46 bl 11088c <rtems_rfs_block_map_open>
if (rc > 0)
111400: 1e04 subs r4, r0, #0
111402: dc3c bgt.n 11147e <rtems_rfs_dir_add_entry+0xa6> <== ALWAYS TAKEN
handle->dirty = false;
111404: 2300 movs r3, #0
111406: f88d 301c strb.w r3, [sp, #28]
handle->buffer = NULL;
11140a: e9cd 3308 strd r3, r3, [sp, #32]
bpos->boff = 0;
11140e: e9cd 3304 strd r3, r3, [sp, #16]
bpos->block = 0;
111412: 9306 str r3, [sp, #24]
/*
* Locate the first block. If an error the block will be 0. If the map is
* empty which happens when creating a directory and adding the first entry
* the seek will return ENXIO. In this case we need to grow the directory.
*/
rc = rtems_rfs_block_map_find (fs, &map, &bpos, &block);
111414: ab03 add r3, sp, #12
111416: aa04 add r2, sp, #16
111418: a90a add r1, sp, #40 ; 0x28
11141a: 4638 mov r0, r7
11141c: f7ff fb28 bl 110a70 <rtems_rfs_block_map_find>
if (rc > 0)
111420: 1e04 subs r4, r0, #0
111422: f340 80c5 ble.w 1115b0 <rtems_rfs_dir_add_entry+0x1d8>
{
if (rc != ENXIO)
111426: 2c06 cmp r4, #6
111428: f040 80f5 bne.w 111616 <rtems_rfs_dir_add_entry+0x23e> <== ALWAYS TAKEN
}
/*
* We have reached the end of the directory so add a block.
*/
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
11142c: ab03 add r3, sp, #12
11142e: 2201 movs r2, #1
111430: a90a add r1, sp, #40 ; 0x28
111432: 4638 mov r0, r7
111434: f7ff fbb0 bl 110b98 <rtems_rfs_block_map_grow>
if (rc > 0)
111438: 1e04 subs r4, r0, #0
11143a: f300 80d5 bgt.w 1115e8 <rtems_rfs_dir_add_entry+0x210> <== ALWAYS TAKEN
}
read = false;
}
bpos.bno++;
11143e: 9b04 ldr r3, [sp, #16]
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
111440: a907 add r1, sp, #28
111442: 9a03 ldr r2, [sp, #12]
111444: 4638 mov r0, r7
bpos.bno++;
111446: 3301 adds r3, #1
111448: 9304 str r3, [sp, #16]
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
11144a: 2300 movs r3, #0
11144c: f7f7 f8a6 bl 10859c <rtems_rfs_buffer_handle_request>
if (rc > 0)
111450: 1e04 subs r4, r0, #0
111452: dd18 ble.n 111486 <rtems_rfs_dir_add_entry+0xae> <== NEVER TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
111454: f04f 5000 mov.w r0, #536870912 ; 0x20000000 <== NOT EXECUTED
111458: 2100 movs r1, #0 <== NOT EXECUTED
11145a: f7f9 fa8f bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
11145e: 2800 cmp r0, #0 <== NOT EXECUTED
111460: f040 80f0 bne.w 111644 <rtems_rfs_dir_add_entry+0x26c> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
111464: a907 add r1, sp, #28 <== NOT EXECUTED
111466: 4638 mov r0, r7 <== NOT EXECUTED
111468: f7f7 f984 bl 108774 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
11146c: 2300 movs r3, #0 <== NOT EXECUTED
offset += elength;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
11146e: a90a add r1, sp, #40 ; 0x28 <== NOT EXECUTED
111470: 4638 mov r0, r7 <== NOT EXECUTED
111472: f88d 301c strb.w r3, [sp, #28] <== NOT EXECUTED
handle->buffer = NULL;
111476: e9cd 3308 strd r3, r3, [sp, #32] <== NOT EXECUTED
11147a: f7ff fa59 bl 110930 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
}
11147e: 4620 mov r0, r4
111480: b01f add sp, #124 ; 0x7c
111482: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
entry = rtems_rfs_buffer_data (&buffer);
111486: 9b09 ldr r3, [sp, #36] ; 0x24
memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
111488: 21ff movs r1, #255 ; 0xff
11148a: 68ba ldr r2, [r7, #8]
entry = rtems_rfs_buffer_data (&buffer);
11148c: 69de ldr r6, [r3, #28]
memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
11148e: 4630 mov r0, r6
111490: f005 fbc2 bl 116c18 <memset>
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
111494: 68ba ldr r2, [r7, #8]
111496: f1b2 000a subs.w r0, r2, #10
11149a: d0bb beq.n 111414 <rtems_rfs_dir_add_entry+0x3c> <== ALWAYS TAKEN
offset = 0;
11149c: f04f 0b00 mov.w fp, #0
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
1114a0: f64f 71ff movw r1, #65535 ; 0xffff
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
1114a4: 465b mov r3, fp
1114a6: e00e b.n 1114c6 <rtems_rfs_dir_add_entry+0xee>
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
1114a8: 2c0a cmp r4, #10
entry += elength;
1114aa: 4426 add r6, r4
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
1114ac: dd49 ble.n 111542 <rtems_rfs_dir_add_entry+0x16a> <== ALWAYS TAKEN
1114ae: 69fb ldr r3, [r7, #28]
1114b0: 42a3 cmp r3, r4
1114b2: d946 bls.n 111542 <rtems_rfs_dir_add_entry+0x16a> <== ALWAYS TAKEN
1114b4: 2d00 cmp r5, #0
1114b6: d044 beq.n 111542 <rtems_rfs_dir_add_entry+0x16a> <== ALWAYS TAKEN
1114b8: 697b ldr r3, [r7, #20]
1114ba: 42ab cmp r3, r5
1114bc: d341 bcc.n 111542 <rtems_rfs_dir_add_entry+0x16a> <== ALWAYS TAKEN
offset += elength;
1114be: 44a3 add fp, r4
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
1114c0: 4558 cmp r0, fp
1114c2: 465b mov r3, fp
1114c4: d9a6 bls.n 111414 <rtems_rfs_dir_add_entry+0x3c> <== ALWAYS TAKEN
entry += elength;
1114c6: 8934 ldrh r4, [r6, #8]
1114c8: 6835 ldr r5, [r6, #0]
1114ca: ba64 rev16 r4, r4
1114cc: b2a4 uxth r4, r4
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
1114ce: ba2d rev r5, r5
1114d0: 428c cmp r4, r1
1114d2: d1e9 bne.n 1114a8 <rtems_rfs_dir_add_entry+0xd0>
(rtems_rfs_fs_block_size (fs) - offset))
1114d4: 1ad3 subs r3, r2, r3
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
1114d6: f109 040a add.w r4, r9, #10
1114da: 429c cmp r4, r3
1114dc: d29a bcs.n 111414 <rtems_rfs_dir_add_entry+0x3c> <== ALWAYS TAKEN
hash = rtems_rfs_dir_hash (name, length);
1114de: 4649 mov r1, r9
1114e0: 4650 mov r0, sl
1114e2: f000 fbbd bl 111c60 <rtems_rfs_dir_hash>
1114e6: 4603 mov r3, r0
rtems_rfs_dir_set_entry_hash (entry, hash);
1114e8: 71f0 strb r0, [r6, #7]
rtems_rfs_dir_set_entry_ino (entry, ino);
1114ea: 9828 ldr r0, [sp, #160] ; 0xa0
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
1114ec: 464a mov r2, r9
rtems_rfs_dir_set_entry_length (entry,
1114ee: 7274 strb r4, [r6, #9]
1114f0: f3c4 2407 ubfx r4, r4, #8, #8
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
1114f4: 4651 mov r1, sl
rtems_rfs_dir_set_entry_length (entry,
1114f6: 7234 strb r4, [r6, #8]
rtems_rfs_dir_set_entry_ino (entry, ino);
1114f8: 70f0 strb r0, [r6, #3]
rtems_rfs_dir_set_entry_hash (entry, hash);
1114fa: 0e18 lsrs r0, r3, #24
handle->dirty = false;
1114fc: 2400 movs r4, #0
1114fe: 7130 strb r0, [r6, #4]
111500: 0c18 lsrs r0, r3, #16
111502: 0a1b lsrs r3, r3, #8
111504: 7170 strb r0, [r6, #5]
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
111506: f106 000a add.w r0, r6, #10
rtems_rfs_dir_set_entry_hash (entry, hash);
11150a: 71b3 strb r3, [r6, #6]
rtems_rfs_dir_set_entry_ino (entry, ino);
11150c: 9b28 ldr r3, [sp, #160] ; 0xa0
11150e: 0e1b lsrs r3, r3, #24
111510: 7033 strb r3, [r6, #0]
111512: 9b28 ldr r3, [sp, #160] ; 0xa0
111514: 0c1b lsrs r3, r3, #16
111516: 7073 strb r3, [r6, #1]
111518: 9b28 ldr r3, [sp, #160] ; 0xa0
11151a: 0a1b lsrs r3, r3, #8
11151c: 70b3 strb r3, [r6, #2]
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
11151e: f005 e890 blx 116640 <memcpy>
rtems_rfs_buffer_handle_release (fs, handle);
111522: a907 add r1, sp, #28
rtems_rfs_buffer_mark_dirty (&buffer);
111524: 2301 movs r3, #1
111526: 4638 mov r0, r7
111528: f88d 301c strb.w r3, [sp, #28]
11152c: f7f7 f922 bl 108774 <rtems_rfs_buffer_handle_release>
rtems_rfs_block_map_close (fs, &map);
111530: a90a add r1, sp, #40 ; 0x28
111532: 4638 mov r0, r7
handle->dirty = false;
111534: f88d 401c strb.w r4, [sp, #28]
handle->buffer = NULL;
111538: e9cd 4408 strd r4, r4, [sp, #32]
11153c: f7ff f9f8 bl 110930 <rtems_rfs_block_map_close>
return 0;
111540: e79d b.n 11147e <rtems_rfs_dir_add_entry+0xa6>
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
111542: f04f 5000 mov.w r0, #536870912 ; 0x20000000 <== NOT EXECUTED
111546: 2100 movs r1, #0 <== NOT EXECUTED
111548: f7f9 fa18 bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
11154c: 2800 cmp r0, #0 <== NOT EXECUTED
11154e: d13e bne.n 1115ce <rtems_rfs_dir_add_entry+0x1f6> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
111550: a907 add r1, sp, #28 <== NOT EXECUTED
111552: 4638 mov r0, r7 <== NOT EXECUTED
111554: f7f7 f90e bl 108774 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
return EIO;
111558: 2405 movs r4, #5 <== NOT EXECUTED
handle->dirty = false;
11155a: 2300 movs r3, #0 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
11155c: a90a add r1, sp, #40 ; 0x28 <== NOT EXECUTED
11155e: 4638 mov r0, r7 <== NOT EXECUTED
111560: f88d 301c strb.w r3, [sp, #28] <== NOT EXECUTED
handle->buffer = NULL;
111564: e9cd 3308 strd r3, r3, [sp, #32] <== NOT EXECUTED
111568: f7ff f9e2 bl 110930 <rtems_rfs_block_map_close> <== NOT EXECUTED
}
11156c: 4620 mov r0, r4 <== NOT EXECUTED
11156e: b01f add sp, #124 ; 0x7c <== NOT EXECUTED
111570: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: dir=%" PRId32 ", name=",
111574: f24b 00b0 movw r0, #45232 ; 0xb0b0 <== NOT EXECUTED
111578: f8d8 1008 ldr.w r1, [r8, #8] <== NOT EXECUTED
11157c: f2c0 0011 movt r0, #17 <== NOT EXECUTED
111580: f7f4 faca bl 105b18 <__wrap_printf> <== NOT EXECUTED
for (c = 0; c < length; c++)
111584: f1b9 0f00 cmp.w r9, #0 <== NOT EXECUTED
111588: d00a beq.n 1115a0 <rtems_rfs_dir_add_entry+0x1c8> <== NOT EXECUTED
11158a: eb0a 0509 add.w r5, sl, r9 <== NOT EXECUTED
11158e: f10a 34ff add.w r4, sl, #4294967295 ; 0xffffffff <== NOT EXECUTED
111592: 3d01 subs r5, #1 <== NOT EXECUTED
printf ("%c", name[c]);
111594: f814 0f01 ldrb.w r0, [r4, #1]! <== NOT EXECUTED
111598: f005 fb90 bl 116cbc <putchar> <== NOT EXECUTED
for (c = 0; c < length; c++)
11159c: 42ac cmp r4, r5 <== NOT EXECUTED
11159e: d1f9 bne.n 111594 <rtems_rfs_dir_add_entry+0x1bc> <== NOT EXECUTED
printf (", len=%zd\n", length);
1115a0: f24b 00d8 movw r0, #45272 ; 0xb0d8 <== NOT EXECUTED
1115a4: 4649 mov r1, r9 <== NOT EXECUTED
1115a6: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1115aa: f7f4 fab5 bl 105b18 <__wrap_printf> <== NOT EXECUTED
1115ae: e722 b.n 1113f6 <rtems_rfs_dir_add_entry+0x1e> <== NOT EXECUTED
bpos.bno++;
1115b0: 9b04 ldr r3, [sp, #16]
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
1115b2: a907 add r1, sp, #28
1115b4: 9a03 ldr r2, [sp, #12]
1115b6: 4638 mov r0, r7
bpos.bno++;
1115b8: 3301 adds r3, #1
1115ba: 9304 str r3, [sp, #16]
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
1115bc: 2301 movs r3, #1
1115be: f7f6 ffed bl 10859c <rtems_rfs_buffer_handle_request>
if (rc > 0)
1115c2: 1e04 subs r4, r0, #0
1115c4: f73f af46 bgt.w 111454 <rtems_rfs_dir_add_entry+0x7c> <== ALWAYS TAKEN
entry = rtems_rfs_buffer_data (&buffer);
1115c8: 9b09 ldr r3, [sp, #36] ; 0x24
1115ca: 69de ldr r6, [r3, #28]
if (!read)
1115cc: e762 b.n 111494 <rtems_rfs_dir_add_entry+0xbc>
printf ("rtems-rfs: dir-add-entry: "
1115ce: f24b 10b4 movw r0, #45492 ; 0xb1b4 <== NOT EXECUTED
1115d2: f8cd b000 str.w fp, [sp] <== NOT EXECUTED
1115d6: 462b mov r3, r5 <== NOT EXECUTED
1115d8: f8d8 1008 ldr.w r1, [r8, #8] <== NOT EXECUTED
1115dc: 4622 mov r2, r4 <== NOT EXECUTED
1115de: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1115e2: f7f4 fa99 bl 105b18 <__wrap_printf> <== NOT EXECUTED
1115e6: e7b3 b.n 111550 <rtems_rfs_dir_add_entry+0x178> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
1115e8: f04f 5000 mov.w r0, #536870912 ; 0x20000000 <== NOT EXECUTED
1115ec: 2100 movs r1, #0 <== NOT EXECUTED
1115ee: f7f9 f9c5 bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
1115f2: 2800 cmp r0, #0 <== NOT EXECUTED
1115f4: f43f af36 beq.w 111464 <rtems_rfs_dir_add_entry+0x8c> <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
1115f8: f8d8 5008 ldr.w r5, [r8, #8] <== NOT EXECUTED
1115fc: 4620 mov r0, r4 <== NOT EXECUTED
1115fe: f006 f8b7 bl 117770 <strerror> <== NOT EXECUTED
111602: 4603 mov r3, r0 <== NOT EXECUTED
111604: f24b 1028 movw r0, #45352 ; 0xb128 <== NOT EXECUTED
111608: 4622 mov r2, r4 <== NOT EXECUTED
11160a: 4629 mov r1, r5 <== NOT EXECUTED
11160c: f2c0 0011 movt r0, #17 <== NOT EXECUTED
111610: f7f4 fa82 bl 105b18 <__wrap_printf> <== NOT EXECUTED
111614: e726 b.n 111464 <rtems_rfs_dir_add_entry+0x8c> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
111616: f04f 5000 mov.w r0, #536870912 ; 0x20000000 <== NOT EXECUTED
11161a: 2100 movs r1, #0 <== NOT EXECUTED
11161c: f7f9 f9ae bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
111620: 2800 cmp r0, #0 <== NOT EXECUTED
111622: f43f af1f beq.w 111464 <rtems_rfs_dir_add_entry+0x8c> <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
111626: f8d8 5008 ldr.w r5, [r8, #8] <== NOT EXECUTED
11162a: 4620 mov r0, r4 <== NOT EXECUTED
11162c: f006 f8a0 bl 117770 <strerror> <== NOT EXECUTED
111630: 4603 mov r3, r0 <== NOT EXECUTED
111632: f24b 00e4 movw r0, #45284 ; 0xb0e4 <== NOT EXECUTED
111636: 4622 mov r2, r4 <== NOT EXECUTED
111638: 4629 mov r1, r5 <== NOT EXECUTED
11163a: f2c0 0011 movt r0, #17 <== NOT EXECUTED
11163e: f7f4 fa6b bl 105b18 <__wrap_printf> <== NOT EXECUTED
111642: e70f b.n 111464 <rtems_rfs_dir_add_entry+0x8c> <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
111644: f8d8 5008 ldr.w r5, [r8, #8] <== NOT EXECUTED
111648: 4620 mov r0, r4 <== NOT EXECUTED
11164a: f006 f891 bl 117770 <strerror> <== NOT EXECUTED
11164e: 4603 mov r3, r0 <== NOT EXECUTED
111650: f24b 106c movw r0, #45420 ; 0xb16c <== NOT EXECUTED
111654: 4622 mov r2, r4 <== NOT EXECUTED
111656: 4629 mov r1, r5 <== NOT EXECUTED
111658: f2c0 0011 movt r0, #17 <== NOT EXECUTED
11165c: f7f4 fa5c bl 105b18 <__wrap_printf> <== NOT EXECUTED
111660: e700 b.n 111464 <rtems_rfs_dir_add_entry+0x8c> <== NOT EXECUTED
111662: bf00 nop
00111664 <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)
{
111664: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
111668: b09f sub sp, #124 ; 0x7c
11166a: 4680 mov r8, r0
11166c: 9103 str r1, [sp, #12]
rtems_rfs_block_no block;
rtems_rfs_buffer_handle buffer;
bool search;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
11166e: f04f 4080 mov.w r0, #1073741824 ; 0x40000000
111672: 2100 movs r1, #0
{
111674: 4692 mov sl, r2
111676: 4699 mov r9, r3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
111678: f7f9 f980 bl 10a97c <rtems_rfs_trace>
11167c: 2800 cmp r0, #0
11167e: d17b bne.n 111778 <rtems_rfs_dir_del_entry+0x114> <== ALWAYS 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);
111680: aa0a add r2, sp, #40 ; 0x28
111682: 9903 ldr r1, [sp, #12]
111684: 4640 mov r0, r8
111686: f7ff f901 bl 11088c <rtems_rfs_block_map_open>
if (rc > 0)
11168a: 1e02 subs r2, r0, #0
11168c: dd03 ble.n 111696 <rtems_rfs_dir_del_entry+0x32> <== NEVER TAKEN
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
11168e: 4610 mov r0, r2 <== NOT EXECUTED
111690: b01f add sp, #124 ; 0x7c <== NOT EXECUTED
111692: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
111696: ab06 add r3, sp, #24
111698: 2400 movs r4, #0
11169a: 464a mov r2, r9
11169c: 9300 str r3, [sp, #0]
11169e: a90a add r1, sp, #40 ; 0x28
1116a0: 4623 mov r3, r4
1116a2: 4640 mov r0, r8
1116a4: f7ff fa4c bl 110b40 <rtems_rfs_block_map_seek>
if (rc > 0)
1116a8: 1e02 subs r2, r0, #0
1116aa: dc7f bgt.n 1117ac <rtems_rfs_dir_del_entry+0x148> <== ALWAYS TAKEN
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
1116ac: f64f 7bff movw fp, #65535 ; 0xffff
handle->dirty = false;
1116b0: f88d 401c strb.w r4, [sp, #28]
handle->buffer = NULL;
1116b4: e9cd 4408 strd r4, r4, [sp, #32]
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
1116b8: 9a06 ldr r2, [sp, #24]
1116ba: 2301 movs r3, #1
1116bc: a907 add r1, sp, #28
1116be: 4640 mov r0, r8
1116c0: f7f6 ff6c bl 10859c <rtems_rfs_buffer_handle_request>
if (rc > 0)
1116c4: 1e02 subs r2, r0, #0
1116c6: f300 80f8 bgt.w 1118ba <rtems_rfs_dir_del_entry+0x256> <== ALWAYS TAKEN
eoffset = offset % rtems_rfs_fs_block_size (fs);
1116ca: f8d8 3008 ldr.w r3, [r8, #8]
1116ce: 4649 mov r1, r9
eoffset = 0;
1116d0: 464f mov r7, r9
if (search)
1116d2: f1b9 0f00 cmp.w r9, #0
1116d6: d008 beq.n 1116ea <rtems_rfs_dir_del_entry+0x86> <== ALWAYS TAKEN
eoffset = offset % rtems_rfs_fs_block_size (fs);
1116d8: 4619 mov r1, r3
1116da: 4648 mov r0, r9
1116dc: 9205 str r2, [sp, #20]
1116de: 9304 str r3, [sp, #16]
1116e0: f004 fb10 bl 115d04 <__aeabi_uidivmod>
1116e4: e9dd 3204 ldrd r3, r2, [sp, #16]
1116e8: 460f mov r7, r1
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
1116ea: 9809 ldr r0, [sp, #36] ; 0x24
1116ec: 69c6 ldr r6, [r0, #28]
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
1116ee: f1a3 000a sub.w r0, r3, #10
1116f2: 4288 cmp r0, r1
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
1116f4: 440e add r6, r1
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
1116f6: d814 bhi.n 111722 <rtems_rfs_dir_del_entry+0xbe> <== NEVER TAKEN
1116f8: e01a b.n 111730 <rtems_rfs_dir_del_entry+0xcc> <== NOT EXECUTED
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
1116fa: 2c0a cmp r4, #10
1116fc: dd25 ble.n 11174a <rtems_rfs_dir_del_entry+0xe6> <== ALWAYS TAKEN
1116fe: f8d8 101c ldr.w r1, [r8, #28]
111702: 42a1 cmp r1, r4
111704: d921 bls.n 11174a <rtems_rfs_dir_del_entry+0xe6> <== ALWAYS TAKEN
111706: b305 cbz r5, 11174a <rtems_rfs_dir_del_entry+0xe6>
111708: f8d8 1014 ldr.w r1, [r8, #20]
11170c: 42a9 cmp r1, r5
11170e: d31c bcc.n 11174a <rtems_rfs_dir_del_entry+0xe6> <== ALWAYS TAKEN
if (ino == rtems_rfs_dir_entry_ino (entry))
111710: 45aa cmp sl, r5
111712: d058 beq.n 1117c6 <rtems_rfs_dir_del_entry+0x162> <== NEVER TAKEN
eoffset += elength;
111714: 4427 add r7, r4 <== NOT EXECUTED
entry += elength;
111716: 4426 add r6, r4 <== NOT EXECUTED
if (!search)
111718: f1b9 0f00 cmp.w r9, #0 <== NOT EXECUTED
11171c: d11b bne.n 111756 <rtems_rfs_dir_del_entry+0xf2> <== NOT EXECUTED
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
11171e: 42b8 cmp r0, r7 <== NOT EXECUTED
111720: d906 bls.n 111730 <rtems_rfs_dir_del_entry+0xcc> <== NOT EXECUTED
entry += elength;
111722: 8934 ldrh r4, [r6, #8]
111724: 6835 ldr r5, [r6, #0]
111726: ba64 rev16 r4, r4
111728: b2a4 uxth r4, r4
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
11172a: ba2d rev r5, r5
11172c: 455c cmp r4, fp
11172e: d1e4 bne.n 1116fa <rtems_rfs_dir_del_entry+0x96> <== NEVER TAKEN
if (rc == 0)
111730: b992 cbnz r2, 111758 <rtems_rfs_dir_del_entry+0xf4> <== NOT EXECUTED
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
111732: aa06 add r2, sp, #24 <== NOT EXECUTED
111734: a90a add r1, sp, #40 ; 0x28 <== NOT EXECUTED
111736: 4640 mov r0, r8 <== NOT EXECUTED
111738: f7ff fa20 bl 110b7c <rtems_rfs_block_map_next_block> <== NOT EXECUTED
if (rc == ENXIO)
11173c: 2806 cmp r0, #6 <== NOT EXECUTED
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
11173e: 4602 mov r2, r0 <== NOT EXECUTED
if (rc == ENXIO)
111740: f000 80d6 beq.w 1118f0 <rtems_rfs_dir_del_entry+0x28c> <== NOT EXECUTED
while (rc == 0)
111744: 2800 cmp r0, #0 <== NOT EXECUTED
111746: d0b7 beq.n 1116b8 <rtems_rfs_dir_del_entry+0x54> <== NOT EXECUTED
111748: e006 b.n 111758 <rtems_rfs_dir_del_entry+0xf4> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
11174a: f04f 4080 mov.w r0, #1073741824 ; 0x40000000 <== NOT EXECUTED
11174e: 2100 movs r1, #0 <== NOT EXECUTED
111750: f7f9 f914 bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
111754: b9d8 cbnz r0, 11178e <rtems_rfs_dir_del_entry+0x12a> <== NOT EXECUTED
rc = EIO;
111756: 2205 movs r2, #5 <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
111758: a907 add r1, sp, #28 <== NOT EXECUTED
11175a: 4640 mov r0, r8 <== NOT EXECUTED
11175c: 9203 str r2, [sp, #12] <== NOT EXECUTED
11175e: f7f7 f809 bl 108774 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
111762: 2300 movs r3, #0 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
111764: a90a add r1, sp, #40 ; 0x28 <== NOT EXECUTED
111766: 4640 mov r0, r8 <== NOT EXECUTED
111768: f88d 301c strb.w r3, [sp, #28] <== NOT EXECUTED
handle->buffer = NULL;
11176c: e9cd 3308 strd r3, r3, [sp, #32] <== NOT EXECUTED
111770: f7ff f8de bl 110930 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
111774: 9a03 ldr r2, [sp, #12] <== NOT EXECUTED
111776: e78a b.n 11168e <rtems_rfs_dir_del_entry+0x2a> <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: dir=%" PRId32 ", entry=%" PRId32 " offset=%" PRIu32 "\n",
111778: 9a03 ldr r2, [sp, #12] <== NOT EXECUTED
11177a: f24b 10fc movw r0, #45564 ; 0xb1fc <== NOT EXECUTED
11177e: 464b mov r3, r9 <== NOT EXECUTED
111780: f2c0 0011 movt r0, #17 <== NOT EXECUTED
111784: 6891 ldr r1, [r2, #8] <== NOT EXECUTED
111786: 4652 mov r2, sl <== NOT EXECUTED
111788: f7f4 f9c6 bl 105b18 <__wrap_printf> <== NOT EXECUTED
11178c: e778 b.n 111680 <rtems_rfs_dir_del_entry+0x1c> <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
11178e: 9b03 ldr r3, [sp, #12] <== NOT EXECUTED
111790: 4622 mov r2, r4 <== NOT EXECUTED
111792: 9806 ldr r0, [sp, #24] <== NOT EXECUTED
111794: 9701 str r7, [sp, #4] <== NOT EXECUTED
111796: 6899 ldr r1, [r3, #8] <== NOT EXECUTED
111798: 462b mov r3, r5 <== NOT EXECUTED
11179a: 9000 str r0, [sp, #0] <== NOT EXECUTED
11179c: f24b 207c movw r0, #45692 ; 0xb27c <== NOT EXECUTED
1117a0: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1117a4: f7f4 f9b8 bl 105b18 <__wrap_printf> <== NOT EXECUTED
rc = EIO;
1117a8: 2205 movs r2, #5 <== NOT EXECUTED
1117aa: e7d5 b.n 111758 <rtems_rfs_dir_del_entry+0xf4> <== NOT EXECUTED
rc = ENOENT;
1117ac: 2a06 cmp r2, #6 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
1117ae: a90a add r1, sp, #40 ; 0x28 <== NOT EXECUTED
rc = ENOENT;
1117b0: bf08 it eq <== NOT EXECUTED
1117b2: 2202 moveq r2, #2 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
1117b4: 4640 mov r0, r8 <== NOT EXECUTED
rc = ENOENT;
1117b6: 9203 str r2, [sp, #12] <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
1117b8: f7ff f8ba bl 110930 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
1117bc: 9a03 ldr r2, [sp, #12] <== NOT EXECUTED
}
1117be: 4610 mov r0, r2 <== NOT EXECUTED
1117c0: b01f add sp, #124 ; 0x7c <== NOT EXECUTED
1117c2: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
remaining = rtems_rfs_fs_block_size (fs) - (eoffset + elength);
1117c6: eb07 0904 add.w r9, r7, r4
memmove (entry, entry + elength, remaining);
1117ca: 1931 adds r1, r6, r4
remaining = rtems_rfs_fs_block_size (fs) - (eoffset + elength);
1117cc: eba3 0909 sub.w r9, r3, r9
memmove (entry, entry + elength, remaining);
1117d0: 4630 mov r0, r6
1117d2: 464a mov r2, r9
1117d4: f005 f9a4 bl 116b20 <memmove>
memset (entry + remaining, 0xff, elength);
1117d8: 4622 mov r2, r4
1117da: 21ff movs r1, #255 ; 0xff
1117dc: eb06 0009 add.w r0, r6, r9
1117e0: f005 fa1a bl 116c18 <memset>
elength = rtems_rfs_dir_entry_length (entry);
1117e4: 8934 ldrh r4, [r6, #8]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
1117e6: f04f 4080 mov.w r0, #1073741824 ; 0x40000000
1117ea: 2100 movs r1, #0
1117ec: ba64 rev16 r4, r4
1117ee: b2a4 uxth r4, r4
1117f0: f7f9 f8c4 bl 10a97c <rtems_rfs_trace>
1117f4: b1a0 cbz r0, 111820 <rtems_rfs_dir_del_entry+0x1bc>
rtems_rfs_block_map_last (&map) ? "yes" : "no");
1117f6: 9e0e ldr r6, [sp, #56] ; 0x38 <== NOT EXECUTED
1117f8: 990c ldr r1, [sp, #48] ; 0x30 <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
1117fa: 9b06 ldr r3, [sp, #24] <== NOT EXECUTED
rtems_rfs_block_map_last (&map) ? "yes" : "no");
1117fc: ea56 0201 orrs.w r2, r6, r1 <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
111800: bf04 itt eq <== NOT EXECUTED
111802: f24a 42e0 movweq r2, #42208 ; 0xa4e0 <== NOT EXECUTED
111806: f2c0 0211 movteq r2, #17 <== NOT EXECUTED
rtems_rfs_block_map_last (&map) ? "yes" : "no");
11180a: d149 bne.n 1118a0 <rtems_rfs_dir_del_entry+0x23c> <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
11180c: f24b 20c8 movw r0, #45768 ; 0xb2c8 <== NOT EXECUTED
111810: 9201 str r2, [sp, #4] <== NOT EXECUTED
111812: 4629 mov r1, r5 <== NOT EXECUTED
111814: f2c0 0011 movt r0, #17 <== NOT EXECUTED
111818: 4622 mov r2, r4 <== NOT EXECUTED
11181a: 9700 str r7, [sp, #0] <== NOT EXECUTED
11181c: f7f4 f97c bl 105b18 <__wrap_printf> <== NOT EXECUTED
if ((elength == RTEMS_RFS_DIR_ENTRY_EMPTY) &&
111820: f64f 73ff movw r3, #65535 ; 0xffff
111824: 429c cmp r4, r3
111826: bf08 it eq
111828: 2f00 cmpeq r7, #0
11182a: d11f bne.n 11186c <rtems_rfs_dir_del_entry+0x208> <== NEVER TAKEN
(eoffset == 0) && rtems_rfs_block_map_last (&map))
11182c: 9a0e ldr r2, [sp, #56] ; 0x38 <== NOT EXECUTED
11182e: 9b0c ldr r3, [sp, #48] ; 0x30 <== NOT EXECUTED
111830: ea52 0103 orrs.w r1, r2, r3 <== NOT EXECUTED
111834: d130 bne.n 111898 <rtems_rfs_dir_del_entry+0x234> <== NOT EXECUTED
rc = rtems_rfs_block_map_shrink (fs, &map, 1);
111836: 2201 movs r2, #1 <== NOT EXECUTED
111838: a90a add r1, sp, #40 ; 0x28 <== NOT EXECUTED
11183a: 4640 mov r0, r8 <== NOT EXECUTED
11183c: f7ff faf2 bl 110e24 <rtems_rfs_block_map_shrink> <== NOT EXECUTED
if (rc > 0)
111840: 1e04 subs r4, r0, #0 <== NOT EXECUTED
111842: dd13 ble.n 11186c <rtems_rfs_dir_del_entry+0x208> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
111844: f04f 4080 mov.w r0, #1073741824 ; 0x40000000 <== NOT EXECUTED
111848: 2100 movs r1, #0 <== NOT EXECUTED
11184a: f7f9 f897 bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
11184e: b168 cbz r0, 11186c <rtems_rfs_dir_del_entry+0x208> <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
111850: 9b03 ldr r3, [sp, #12] <== NOT EXECUTED
111852: 4620 mov r0, r4 <== NOT EXECUTED
111854: 689d ldr r5, [r3, #8] <== NOT EXECUTED
111856: f005 ff8b bl 117770 <strerror> <== NOT EXECUTED
11185a: 4603 mov r3, r0 <== NOT EXECUTED
11185c: f24b 3028 movw r0, #45864 ; 0xb328 <== NOT EXECUTED
111860: 4622 mov r2, r4 <== NOT EXECUTED
111862: 4629 mov r1, r5 <== NOT EXECUTED
111864: f2c0 0011 movt r0, #17 <== NOT EXECUTED
111868: f7f4 f956 bl 105b18 <__wrap_printf> <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&buffer);
11186c: 2301 movs r3, #1
rtems_rfs_buffer_handle_release (fs, handle);
11186e: a907 add r1, sp, #28
111870: 4640 mov r0, r8
111872: f88d 301c strb.w r3, [sp, #28]
111876: f7f6 ff7d bl 108774 <rtems_rfs_buffer_handle_release>
handle->dirty = false;
11187a: 2200 movs r2, #0
rtems_rfs_block_map_close (fs, &map);
11187c: a90a add r1, sp, #40 ; 0x28
11187e: 4640 mov r0, r8
111880: f88d 201c strb.w r2, [sp, #28]
handle->buffer = NULL;
111884: e9cd 2208 strd r2, r2, [sp, #32]
return 0;
111888: 9203 str r2, [sp, #12]
rtems_rfs_block_map_close (fs, &map);
11188a: f7ff f851 bl 110930 <rtems_rfs_block_map_close>
return 0;
11188e: 9a03 ldr r2, [sp, #12]
}
111890: 4610 mov r0, r2
111892: b01f add sp, #124 ; 0x7c
111894: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
(eoffset == 0) && rtems_rfs_block_map_last (&map))
111898: 3b01 subs r3, #1 <== NOT EXECUTED
11189a: 429a cmp r2, r3 <== NOT EXECUTED
11189c: d1e6 bne.n 11186c <rtems_rfs_dir_del_entry+0x208> <== NOT EXECUTED
11189e: e7ca b.n 111836 <rtems_rfs_dir_del_entry+0x1d2> <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
1118a0: f24a 42e0 movw r2, #42208 ; 0xa4e0 <== NOT EXECUTED
1118a4: f24a 40e4 movw r0, #42212 ; 0xa4e4 <== NOT EXECUTED
rtems_rfs_block_map_last (&map) ? "yes" : "no");
1118a8: 3901 subs r1, #1 <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
1118aa: f2c0 0211 movt r2, #17 <== NOT EXECUTED
1118ae: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1118b2: 428e cmp r6, r1 <== NOT EXECUTED
1118b4: bf18 it ne <== NOT EXECUTED
1118b6: 4602 movne r2, r0 <== NOT EXECUTED
1118b8: e7a8 b.n 11180c <rtems_rfs_dir_del_entry+0x1a8> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
1118ba: f04f 4080 mov.w r0, #1073741824 ; 0x40000000 <== NOT EXECUTED
1118be: 2100 movs r1, #0 <== NOT EXECUTED
1118c0: 9204 str r2, [sp, #16] <== NOT EXECUTED
1118c2: f7f9 f85b bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
1118c6: 9a04 ldr r2, [sp, #16] <== NOT EXECUTED
1118c8: 2800 cmp r0, #0 <== NOT EXECUTED
1118ca: f43f af45 beq.w 111758 <rtems_rfs_dir_del_entry+0xf4> <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
1118ce: 9b03 ldr r3, [sp, #12] <== NOT EXECUTED
1118d0: 4610 mov r0, r2 <== NOT EXECUTED
1118d2: 9203 str r2, [sp, #12] <== NOT EXECUTED
1118d4: 689c ldr r4, [r3, #8] <== NOT EXECUTED
1118d6: f005 ff4b bl 117770 <strerror> <== NOT EXECUTED
1118da: 4603 mov r3, r0 <== NOT EXECUTED
1118dc: f24b 2034 movw r0, #45620 ; 0xb234 <== NOT EXECUTED
1118e0: 9a03 ldr r2, [sp, #12] <== NOT EXECUTED
1118e2: 4621 mov r1, r4 <== NOT EXECUTED
1118e4: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1118e8: f7f4 f916 bl 105b18 <__wrap_printf> <== NOT EXECUTED
1118ec: 9a03 ldr r2, [sp, #12] <== NOT EXECUTED
1118ee: e733 b.n 111758 <rtems_rfs_dir_del_entry+0xf4> <== NOT EXECUTED
rc = ENOENT;
1118f0: 2202 movs r2, #2 <== NOT EXECUTED
1118f2: e731 b.n 111758 <rtems_rfs_dir_del_entry+0xf4> <== NOT EXECUTED
00111b18 <rtems_rfs_dir_empty>:
int
rtems_rfs_dir_empty (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir)
{
111b18: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
111b1c: 4606 mov r6, r0
111b1e: b09b sub sp, #108 ; 0x6c
111b20: 460f mov r7, r1
rtems_rfs_buffer_handle buffer;
rtems_rfs_block_no block;
bool empty;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
111b22: f04f 4000 mov.w r0, #2147483648 ; 0x80000000
111b26: 2100 movs r1, #0
111b28: f7f8 ff28 bl 10a97c <rtems_rfs_trace>
111b2c: 2800 cmp r0, #0
111b2e: f040 8087 bne.w 111c40 <rtems_rfs_dir_empty+0x128> <== ALWAYS 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);
111b32: 4639 mov r1, r7
111b34: aa06 add r2, sp, #24
111b36: 4630 mov r0, r6
111b38: f7fe fea8 bl 11088c <rtems_rfs_block_map_open>
if (rc > 0)
111b3c: f1b0 0b00 subs.w fp, r0, #0
111b40: dd03 ble.n 111b4a <rtems_rfs_dir_empty+0x32> <== NEVER TAKEN
rc = ENOTEMPTY;
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
111b42: 4658 mov r0, fp <== NOT EXECUTED
111b44: b01b add sp, #108 ; 0x6c <== NOT EXECUTED
111b46: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
111b4a: f10d 0908 add.w r9, sp, #8
111b4e: 2200 movs r2, #0
111b50: 2300 movs r3, #0
111b52: a906 add r1, sp, #24
111b54: 4630 mov r0, r6
111b56: f8cd 9000 str.w r9, [sp]
111b5a: f7fe fff1 bl 110b40 <rtems_rfs_block_map_seek>
if (rc > 0)
111b5e: f1b0 0b00 subs.w fp, r0, #0
111b62: dc75 bgt.n 111c50 <rtems_rfs_dir_empty+0x138> <== ALWAYS TAKEN
printf ("rtems-rfs: dir-empty: "
111b64: f24b 4870 movw r8, #46192 ; 0xb470
handle->dirty = false;
111b68: 2300 movs r3, #0
111b6a: f2c0 0811 movt r8, #17
111b6e: f88d 300c strb.w r3, [sp, #12]
handle->buffer = NULL;
111b72: e9cd 3304 strd r3, r3, [sp, #16]
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
111b76: 9a02 ldr r2, [sp, #8]
111b78: 2301 movs r3, #1
111b7a: a903 add r1, sp, #12
111b7c: 4630 mov r0, r6
111b7e: f7f6 fd0d bl 10859c <rtems_rfs_buffer_handle_request>
if (rc > 0)
111b82: f1b0 0b00 subs.w fp, r0, #0
111b86: dc2f bgt.n 111be8 <rtems_rfs_dir_empty+0xd0> <== ALWAYS TAKEN
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
111b88: 68b1 ldr r1, [r6, #8]
entry = rtems_rfs_buffer_data (&buffer);
111b8a: 9b05 ldr r3, [sp, #20]
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
111b8c: 390a subs r1, #10
entry = rtems_rfs_buffer_data (&buffer);
111b8e: 69da ldr r2, [r3, #28]
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
111b90: d048 beq.n 111c24 <rtems_rfs_dir_empty+0x10c> <== ALWAYS TAKEN
offset = 0;
111b92: f04f 0a00 mov.w sl, #0
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
111b96: f64f 70ff movw r0, #65535 ; 0xffff
111b9a: e00b b.n 111bb4 <rtems_rfs_dir_empty+0x9c>
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.')) &&
111b9c: 2c0c cmp r4, #12
111b9e: d11e bne.n 111bde <rtems_rfs_dir_empty+0xc6>
((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 2)) ||
111ba0: 7a93 ldrb r3, [r2, #10]
111ba2: 2b2e cmp r3, #46 ; 0x2e
111ba4: d11b bne.n 111bde <rtems_rfs_dir_empty+0xc6> <== ALWAYS TAKEN
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.') ||
111ba6: 7ad3 ldrb r3, [r2, #11]
111ba8: 2b2e cmp r3, #46 ; 0x2e
111baa: d118 bne.n 111bde <rtems_rfs_dir_empty+0xc6> <== ALWAYS TAKEN
offset += elength;
111bac: 44a2 add sl, r4
entry += elength;
111bae: 4422 add r2, r4
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
111bb0: 458a cmp sl, r1
111bb2: d237 bcs.n 111c24 <rtems_rfs_dir_empty+0x10c> <== ALWAYS TAKEN
elength = rtems_rfs_dir_entry_length (entry);
111bb4: 8914 ldrh r4, [r2, #8]
111bb6: 6815 ldr r5, [r2, #0]
111bb8: ba64 rev16 r4, r4
111bba: b2a4 uxth r4, r4
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
111bbc: ba2d rev r5, r5
111bbe: 4284 cmp r4, r0
111bc0: d030 beq.n 111c24 <rtems_rfs_dir_empty+0x10c>
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
111bc2: 2c0a cmp r4, #10
111bc4: dd21 ble.n 111c0a <rtems_rfs_dir_empty+0xf2> <== ALWAYS TAKEN
111bc6: 69f3 ldr r3, [r6, #28]
111bc8: 42a3 cmp r3, r4
111bca: d91e bls.n 111c0a <rtems_rfs_dir_empty+0xf2> <== ALWAYS TAKEN
111bcc: b1ed cbz r5, 111c0a <rtems_rfs_dir_empty+0xf2>
111bce: 6973 ldr r3, [r6, #20]
111bd0: 42ab cmp r3, r5
111bd2: d31a bcc.n 111c0a <rtems_rfs_dir_empty+0xf2> <== ALWAYS TAKEN
if (((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 1)) ||
111bd4: 2c0b cmp r4, #11
111bd6: d1e1 bne.n 111b9c <rtems_rfs_dir_empty+0x84>
111bd8: 7a93 ldrb r3, [r2, #10]
111bda: 2b2e cmp r3, #46 ; 0x2e
111bdc: d0e6 beq.n 111bac <rtems_rfs_dir_empty+0x94> <== NEVER TAKEN
rc = ENOTEMPTY;
111bde: f1bb 0f00 cmp.w fp, #0
111be2: bf08 it eq
111be4: f04f 0b5a moveq.w fp, #90 ; 0x5a
rtems_rfs_buffer_handle_release (fs, handle);
111be8: a903 add r1, sp, #12
111bea: 4630 mov r0, r6
111bec: f7f6 fdc2 bl 108774 <rtems_rfs_buffer_handle_release>
handle->dirty = false;
111bf0: 2300 movs r3, #0
rtems_rfs_block_map_close (fs, &map);
111bf2: a906 add r1, sp, #24
111bf4: 4630 mov r0, r6
111bf6: f88d 300c strb.w r3, [sp, #12]
handle->buffer = NULL;
111bfa: e9cd 3304 strd r3, r3, [sp, #16]
111bfe: f7fe fe97 bl 110930 <rtems_rfs_block_map_close>
}
111c02: 4658 mov r0, fp
111c04: b01b add sp, #108 ; 0x6c
111c06: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY))
111c0a: 2000 movs r0, #0 <== NOT EXECUTED
111c0c: 2101 movs r1, #1 <== NOT EXECUTED
111c0e: f7f8 feb5 bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
111c12: b138 cbz r0, 111c24 <rtems_rfs_dir_empty+0x10c> <== NOT EXECUTED
printf ("rtems-rfs: dir-empty: "
111c14: f8cd a000 str.w sl, [sp] <== NOT EXECUTED
111c18: 462b mov r3, r5 <== NOT EXECUTED
111c1a: 68b9 ldr r1, [r7, #8] <== NOT EXECUTED
111c1c: 4622 mov r2, r4 <== NOT EXECUTED
111c1e: 4640 mov r0, r8 <== NOT EXECUTED
111c20: f7f3 ff7a bl 105b18 <__wrap_printf> <== NOT EXECUTED
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
111c24: 464a mov r2, r9
111c26: a906 add r1, sp, #24
111c28: 4630 mov r0, r6
111c2a: f7fe ffa7 bl 110b7c <rtems_rfs_block_map_next_block>
if (rc > 0)
111c2e: f1b0 0b00 subs.w fp, r0, #0
111c32: dda0 ble.n 111b76 <rtems_rfs_dir_empty+0x5e> <== ALWAYS TAKEN
rc = 0;
111c34: f1bb 0f06 cmp.w fp, #6
111c38: bf08 it eq
111c3a: f04f 0b00 moveq.w fp, #0
111c3e: e7d3 b.n 111be8 <rtems_rfs_dir_empty+0xd0>
printf ("rtems-rfs: dir-empty: dir=%" PRId32 "\n", rtems_rfs_inode_ino (dir));
111c40: f24b 4050 movw r0, #46160 ; 0xb450 <== NOT EXECUTED
111c44: 68b9 ldr r1, [r7, #8] <== NOT EXECUTED
111c46: f2c0 0011 movt r0, #17 <== NOT EXECUTED
111c4a: f7f3 ff65 bl 105b18 <__wrap_printf> <== NOT EXECUTED
111c4e: e770 b.n 111b32 <rtems_rfs_dir_empty+0x1a> <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
111c50: a906 add r1, sp, #24 <== NOT EXECUTED
111c52: 4630 mov r0, r6 <== NOT EXECUTED
111c54: f7fe fe6c bl 110930 <rtems_rfs_block_map_close> <== NOT EXECUTED
}
111c58: 4658 mov r0, fp <== NOT EXECUTED
111c5a: b01b add sp, #108 ; 0x6c <== NOT EXECUTED
111c5c: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
00111c60 <rtems_rfs_dir_hash>:
*/
#define initval (20010928)
uint32_t
rtems_rfs_dir_hash (const void *key, size_t length)
{
111c60: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
} 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)
111c64: 290c cmp r1, #12
a = b = c = 0xdeadbeef + ((uint32_t)length) + initval;
111c66: f241 669f movw r6, #5791 ; 0x169f
111c6a: f6cd 76df movt r6, #57311 ; 0xdfdf
111c6e: 440e add r6, r1
while (length > 12)
111c70: f240 80a1 bls.w 111db6 <rtems_rfs_dir_hash+0x156>
111c74: f100 0e0c add.w lr, r0, #12
a = b = c = 0xdeadbeef + ((uint32_t)length) + initval;
111c78: 4635 mov r5, r6
111c7a: 4634 mov r4, r6
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;
111c7c: f81e 3c02 ldrb.w r3, [lr, #-2]
c += ((uint32_t)k[11])<<24;
mix(a,b,c);
length -= 12;
111c80: 390c subs r1, #12
a += ((uint32_t)k[2])<<16;
111c82: f81e 2c0a ldrb.w r2, [lr, #-10]
while (length > 12)
111c86: 290c cmp r1, #12
c += ((uint32_t)k[9])<<8;
111c88: f81e bc03 ldrb.w fp, [lr, #-3]
111c8c: 4670 mov r0, lr
a += ((uint32_t)k[1])<<8;
111c8e: f81e 9c0b ldrb.w r9, [lr, #-11]
while (length > 12)
111c92: f10e 0e0c add.w lr, lr, #12
c += ((uint32_t)k[10])<<16;
111c96: ea4f 4303 mov.w r3, r3, lsl #16
c += k[8];
111c9a: f81e 7c10 ldrb.w r7, [lr, #-16]
b += ((uint32_t)k[6])<<16;
111c9e: f81e cc12 ldrb.w ip, [lr, #-18]
a += ((uint32_t)k[2])<<16;
111ca2: ea4f 4202 mov.w r2, r2, lsl #16
c += ((uint32_t)k[11])<<24;
111ca6: f81e ac0d ldrb.w sl, [lr, #-13]
111caa: eb03 230b add.w r3, r3, fp, lsl #8
b += ((uint32_t)k[5])<<8;
111cae: f81e 8c13 ldrb.w r8, [lr, #-19]
mix(a,b,c);
111cb2: eb02 2209 add.w r2, r2, r9, lsl #8
c += ((uint32_t)k[11])<<24;
111cb6: 443b add r3, r7
a += k[0];
111cb8: f81e 9c18 ldrb.w r9, [lr, #-24]
a += ((uint32_t)k[3])<<24;
111cbc: f81e 7c15 ldrb.w r7, [lr, #-21]
b += ((uint32_t)k[6])<<16;
111cc0: ea4f 4c0c mov.w ip, ip, lsl #16
c += ((uint32_t)k[11])<<24;
111cc4: eb03 630a add.w r3, r3, sl, lsl #24
b += ((uint32_t)k[7])<<24;
111cc8: eb0c 2c08 add.w ip, ip, r8, lsl #8
mix(a,b,c);
111ccc: 444a add r2, r9
c += ((uint32_t)k[11])<<24;
111cce: 4433 add r3, r6
b += k[4];
111cd0: f81e 8c14 ldrb.w r8, [lr, #-20]
b += ((uint32_t)k[7])<<24;
111cd4: f81e 6c11 ldrb.w r6, [lr, #-17]
mix(a,b,c);
111cd8: eb02 6207 add.w r2, r2, r7, lsl #24
b += ((uint32_t)k[7])<<24;
111cdc: 44c4 add ip, r8
mix(a,b,c);
111cde: eba2 0203 sub.w r2, r2, r3
111ce2: 442a add r2, r5
b += ((uint32_t)k[7])<<24;
111ce4: eb0c 6c06 add.w ip, ip, r6, lsl #24
mix(a,b,c);
111ce8: ea82 7233 eor.w r2, r2, r3, ror #28
b += ((uint32_t)k[7])<<24;
111cec: 44a4 add ip, r4
mix(a,b,c);
111cee: ebac 0502 sub.w r5, ip, r2
111cf2: 449c add ip, r3
111cf4: ea85 65b2 eor.w r5, r5, r2, ror #26
111cf8: 4462 add r2, ip
111cfa: ebac 0305 sub.w r3, ip, r5
111cfe: eb05 0402 add.w r4, r5, r2
111d02: ea83 6335 eor.w r3, r3, r5, ror #24
111d06: eba2 0203 sub.w r2, r2, r3
111d0a: eb03 0604 add.w r6, r3, r4
111d0e: ea82 4333 eor.w r3, r2, r3, ror #16
111d12: eba4 0403 sub.w r4, r4, r3
111d16: eb03 0506 add.w r5, r3, r6
111d1a: ea84 3373 eor.w r3, r4, r3, ror #13
111d1e: eba6 0603 sub.w r6, r6, r3
111d22: eb03 0405 add.w r4, r3, r5
111d26: ea86 7633 eor.w r6, r6, r3, ror #28
while (length > 12)
111d2a: d8a7 bhi.n 111c7c <rtems_rfs_dir_hash+0x1c>
k += 12;
}
/*-------------------------------- last block: affect all 32 bits of (c) */
switch(length) /* all the case statements fall through */
111d2c: 3901 subs r1, #1
111d2e: 290b cmp r1, #11
111d30: d83e bhi.n 111db0 <rtems_rfs_dir_hash+0x150> <== ALWAYS TAKEN
111d32: e8df f001 tbb [pc, r1]
111d36: 2225 .short 0x2225
111d38: 171a1c1f .word 0x171a1c1f
111d3c: 0c0f1114 .word 0x0c0f1114
111d40: 0609 .short 0x0609
{
case 12: c+=((uint32_t)k[11])<<24;
111d42: 7ac3 ldrb r3, [r0, #11]
111d44: eb06 6603 add.w r6, r6, r3, lsl #24
case 11: c+=((uint32_t)k[10])<<16;
111d48: 7a83 ldrb r3, [r0, #10]
111d4a: eb06 4603 add.w r6, r6, r3, lsl #16
case 10: c+=((uint32_t)k[9])<<8;
111d4e: 7a43 ldrb r3, [r0, #9]
111d50: eb06 2603 add.w r6, r6, r3, lsl #8
case 9 : c+=k[8];
111d54: 7a03 ldrb r3, [r0, #8]
111d56: 441e add r6, r3
case 8 : b+=((uint32_t)k[7])<<24;
111d58: 79c3 ldrb r3, [r0, #7]
111d5a: eb04 6403 add.w r4, r4, r3, lsl #24
case 7 : b+=((uint32_t)k[6])<<16;
111d5e: 7983 ldrb r3, [r0, #6]
111d60: eb04 4403 add.w r4, r4, r3, lsl #16
case 6 : b+=((uint32_t)k[5])<<8;
111d64: 7943 ldrb r3, [r0, #5]
111d66: eb04 2403 add.w r4, r4, r3, lsl #8
case 5 : b+=k[4];
111d6a: 7903 ldrb r3, [r0, #4]
111d6c: 441c add r4, r3
case 4 : a+=((uint32_t)k[3])<<24;
111d6e: 78c3 ldrb r3, [r0, #3]
111d70: eb05 6503 add.w r5, r5, r3, lsl #24
case 3 : a+=((uint32_t)k[2])<<16;
111d74: 7883 ldrb r3, [r0, #2]
111d76: eb05 4503 add.w r5, r5, r3, lsl #16
case 2 : a+=((uint32_t)k[1])<<8;
111d7a: 7843 ldrb r3, [r0, #1]
111d7c: eb05 2503 add.w r5, r5, r3, lsl #8
case 1 : a+=k[0];
111d80: 7802 ldrb r2, [r0, #0]
break;
case 0 : return c;
}
}
final(a,b,c);
111d82: ea86 0304 eor.w r3, r6, r4
111d86: eba3 43b4 sub.w r3, r3, r4, ror #18
case 1 : a+=k[0];
111d8a: 442a add r2, r5
final(a,b,c);
111d8c: 405a eors r2, r3
111d8e: eba2 5273 sub.w r2, r2, r3, ror #21
111d92: 4054 eors r4, r2
111d94: eba4 14f2 sub.w r4, r4, r2, ror #7
111d98: 4063 eors r3, r4
111d9a: eba3 4334 sub.w r3, r3, r4, ror #16
111d9e: 405a eors r2, r3
111da0: eba2 7633 sub.w r6, r2, r3, ror #28
111da4: 4074 eors r4, r6
111da6: eba4 44b6 sub.w r4, r4, r6, ror #18
111daa: 4063 eors r3, r4
111dac: eba3 2634 sub.w r6, r3, r4, ror #8
return c;
}
111db0: 4630 mov r0, r6
111db2: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
a = b = c = 0xdeadbeef + ((uint32_t)length) + initval;
111db6: 4635 mov r5, r6
111db8: 4634 mov r4, r6
111dba: e7b7 b.n 111d2c <rtems_rfs_dir_hash+0xcc>
00111080 <rtems_rfs_dir_lookup_ino>:
rtems_rfs_inode_handle* inode,
const char* name,
int length,
rtems_rfs_ino* ino,
uint32_t* offset)
{
111080: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
111084: b09f sub sp, #124 ; 0x7c
111086: 4606 mov r6, r0
111088: 9103 str r1, [sp, #12]
rtems_rfs_block_map map;
rtems_rfs_buffer_handle entries;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
11108a: f04f 6080 mov.w r0, #67108864 ; 0x4000000
11108e: 2100 movs r1, #0
{
111090: f8dd 80a0 ldr.w r8, [sp, #160] ; 0xa0
111094: 4617 mov r7, r2
111096: 469b mov fp, r3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
111098: f7f9 fc70 bl 10a97c <rtems_rfs_trace>
11109c: 2800 cmp r0, #0
11109e: f040 810d bne.w 1112bc <rtems_rfs_dir_lookup_ino+0x23c> <== ALWAYS TAKEN
printf ("%c", name[c]);
printf (", len=%d\n", length);
}
*ino = RTEMS_RFS_EMPTY_INO;
*offset = 0;
1110a2: 9b29 ldr r3, [sp, #164] ; 0xa4
*ino = RTEMS_RFS_EMPTY_INO;
1110a4: 2400 movs r4, #0
1110a6: f8c8 4000 str.w r4, [r8]
rc = rtems_rfs_block_map_open (fs, inode, &map);
1110aa: aa0a add r2, sp, #40 ; 0x28
1110ac: 9903 ldr r1, [sp, #12]
1110ae: 4630 mov r0, r6
*offset = 0;
1110b0: 601c str r4, [r3, #0]
rc = rtems_rfs_block_map_open (fs, inode, &map);
1110b2: f7ff fbeb bl 11088c <rtems_rfs_block_map_open>
if (rc > 0)
1110b6: f1b0 0900 subs.w r9, r0, #0
1110ba: f300 80e6 bgt.w 11128a <rtems_rfs_dir_lookup_ino+0x20a> <== ALWAYS TAKEN
uint32_t hash;
/*
* Calculate the hash of the look up string.
*/
hash = rtems_rfs_dir_hash (name, length);
1110be: 4659 mov r1, fp
1110c0: 4638 mov r0, r7
handle->dirty = false;
1110c2: f88d 401c strb.w r4, [sp, #28]
handle->buffer = NULL;
1110c6: e9cd 4408 strd r4, r4, [sp, #32]
1110ca: f000 fdc9 bl 111c60 <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);
1110ce: ab06 add r3, sp, #24
hash = rtems_rfs_dir_hash (name, length);
1110d0: 4682 mov sl, r0
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
1110d2: 9300 str r3, [sp, #0]
1110d4: a90a add r1, sp, #40 ; 0x28
1110d6: 4630 mov r0, r6
1110d8: 2200 movs r2, #0
1110da: 2300 movs r3, #0
1110dc: f7ff fd30 bl 110b40 <rtems_rfs_block_map_seek>
if (rc > 0)
1110e0: f1b0 0900 subs.w r9, r0, #0
1110e4: f300 8106 bgt.w 1112f4 <rtems_rfs_dir_lookup_ino+0x274> <== ALWAYS TAKEN
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",
1110e8: f64a 63c8 movw r3, #44744 ; 0xaec8
1110ec: f8cd 9008 str.w r9, [sp, #8]
1110f0: f2c0 0311 movt r3, #17
1110f4: 46b9 mov r9, r7
1110f6: 9305 str r3, [sp, #20]
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
1110f8: f64a 7388 movw r3, #44936 ; 0xaf88
1110fc: f2c0 0311 movt r3, #17
111100: 9304 str r3, [sp, #16]
while ((rc == 0) && block)
111102: 9b02 ldr r3, [sp, #8]
111104: 2b00 cmp r3, #0
111106: f040 809c bne.w 111242 <rtems_rfs_dir_lookup_ino+0x1c2> <== ALWAYS TAKEN
11110a: 9b06 ldr r3, [sp, #24]
11110c: 2b00 cmp r3, #0
11110e: f000 8118 beq.w 111342 <rtems_rfs_dir_lookup_ino+0x2c2> <== ALWAYS TAKEN
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
111112: f04f 6080 mov.w r0, #67108864 ; 0x4000000
111116: 2100 movs r1, #0
111118: f7f9 fc30 bl 10a97c <rtems_rfs_trace>
11111c: 2800 cmp r0, #0
11111e: f040 8087 bne.w 111230 <rtems_rfs_dir_lookup_ino+0x1b0> <== ALWAYS TAKEN
rc = rtems_rfs_buffer_handle_request (fs, &entries, block, true);
111122: 2301 movs r3, #1
111124: 9a06 ldr r2, [sp, #24]
111126: a907 add r1, sp, #28
111128: 4630 mov r0, r6
11112a: f7f7 fa37 bl 10859c <rtems_rfs_buffer_handle_request>
if (rc > 0)
11112e: 1e03 subs r3, r0, #0
111130: 9302 str r3, [sp, #8]
111132: f300 811d bgt.w 111370 <rtems_rfs_dir_lookup_ino+0x2f0> <== ALWAYS TAKEN
entry = rtems_rfs_buffer_data (&entries);
111136: 9b09 ldr r3, [sp, #36] ; 0x24
map.bpos.boff = 0;
111138: 2200 movs r2, #0
11113a: 920f str r2, [sp, #60] ; 0x3c
entry = rtems_rfs_buffer_data (&entries);
11113c: 69dd ldr r5, [r3, #28]
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
11113e: 68b3 ldr r3, [r6, #8]
111140: 2b0a cmp r3, #10
111142: d07c beq.n 11123e <rtems_rfs_dir_lookup_ino+0x1be> <== ALWAYS TAKEN
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
111144: f64f 77ff movw r7, #65535 ; 0xffff
111148: e007 b.n 11115a <rtems_rfs_dir_lookup_ino+0xda>
rtems_rfs_block_map_close (fs, &map);
return 0;
}
}
map.bpos.boff += elength;
11114a: 9b0f ldr r3, [sp, #60] ; 0x3c
entry += elength;
11114c: 4425 add r5, r4
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
11114e: 68b2 ldr r2, [r6, #8]
map.bpos.boff += elength;
111150: 441c add r4, r3
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
111152: 3a0a subs r2, #10
map.bpos.boff += elength;
111154: 940f str r4, [sp, #60] ; 0x3c
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
111156: 4294 cmp r4, r2
111158: d271 bcs.n 11123e <rtems_rfs_dir_lookup_ino+0x1be> <== ALWAYS TAKEN
if (ehash == hash)
11115a: 892c ldrh r4, [r5, #8]
11115c: 682b ldr r3, [r5, #0]
11115e: 686a ldr r2, [r5, #4]
111160: ba64 rev16 r4, r4
111162: b2a4 uxth r4, r4
111164: ba1b rev r3, r3
111166: ba12 rev r2, r2
*ino = rtems_rfs_dir_entry_ino (entry);
111168: f8c8 3000 str.w r3, [r8]
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
11116c: 42bc cmp r4, r7
11116e: d066 beq.n 11123e <rtems_rfs_dir_lookup_ino+0x1be>
if (rtems_rfs_dir_entry_valid (fs, elength, *ino))
111170: 2c0a cmp r4, #10
111172: dd38 ble.n 1111e6 <rtems_rfs_dir_lookup_ino+0x166> <== ALWAYS TAKEN
111174: 69f1 ldr r1, [r6, #28]
111176: 2b00 cmp r3, #0
111178: bf18 it ne
11117a: 42a1 cmpne r1, r4
11117c: d933 bls.n 1111e6 <rtems_rfs_dir_lookup_ino+0x166> <== ALWAYS TAKEN
11117e: 6971 ldr r1, [r6, #20]
111180: 428b cmp r3, r1
111182: d830 bhi.n 1111e6 <rtems_rfs_dir_lookup_ino+0x166> <== ALWAYS TAKEN
if (ehash == hash)
111184: 4592 cmp sl, r2
111186: d1e0 bne.n 11114a <rtems_rfs_dir_lookup_ino+0xca>
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
111188: f04f 6000 mov.w r0, #134217728 ; 0x8000000
11118c: 2100 movs r1, #0
11118e: f7f9 fbf5 bl 10a97c <rtems_rfs_trace>
111192: 2800 cmp r0, #0
111194: d140 bne.n 111218 <rtems_rfs_dir_lookup_ino+0x198> <== ALWAYS TAKEN
if (memcmp (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length) == 0)
111196: f105 000a add.w r0, r5, #10
11119a: 465a mov r2, fp
11119c: 4649 mov r1, r9
11119e: f005 fa09 bl 1165b4 <memcmp>
1111a2: 2800 cmp r0, #0
1111a4: d1d1 bne.n 11114a <rtems_rfs_dir_lookup_ino+0xca> <== ALWAYS TAKEN
*offset = rtems_rfs_block_map_pos (fs, &map);
1111a6: a90e add r1, sp, #56 ; 0x38
1111a8: 4630 mov r0, r6
1111aa: f7ff fb57 bl 11085c <rtems_rfs_block_get_pos>
1111ae: 9b29 ldr r3, [sp, #164] ; 0xa4
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND))
1111b0: 2100 movs r1, #0
*offset = rtems_rfs_block_map_pos (fs, &map);
1111b2: 6018 str r0, [r3, #0]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND))
1111b4: f04f 5080 mov.w r0, #268435456 ; 0x10000000
1111b8: f7f9 fbe0 bl 10a97c <rtems_rfs_trace>
1111bc: 2800 cmp r0, #0
1111be: f040 80fd bne.w 1113bc <rtems_rfs_dir_lookup_ino+0x33c> <== ALWAYS TAKEN
rtems_rfs_buffer_handle_release (fs, handle);
1111c2: a907 add r1, sp, #28
1111c4: 4630 mov r0, r6
1111c6: f7f7 fad5 bl 108774 <rtems_rfs_buffer_handle_release>
handle->dirty = false;
1111ca: 2300 movs r3, #0
rtems_rfs_block_map_close (fs, &map);
1111cc: a90a add r1, sp, #40 ; 0x28
return 0;
1111ce: 4699 mov r9, r3
rtems_rfs_block_map_close (fs, &map);
1111d0: 4630 mov r0, r6
1111d2: f88d 301c strb.w r3, [sp, #28]
handle->buffer = NULL;
1111d6: e9cd 3308 strd r3, r3, [sp, #32]
1111da: f7ff fba9 bl 110930 <rtems_rfs_block_map_close>
}
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
1111de: 4648 mov r0, r9
1111e0: b01f add sp, #124 ; 0x7c
1111e2: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
1111e6: f04f 6080 mov.w r0, #67108864 ; 0x4000000 <== NOT EXECUTED
1111ea: 2100 movs r1, #0 <== NOT EXECUTED
1111ec: f7f9 fbc6 bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
1111f0: bb50 cbnz r0, 111248 <rtems_rfs_dir_lookup_ino+0x1c8> <== NOT EXECUTED
rc = EIO;
1111f2: f04f 0905 mov.w r9, #5 <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
1111f6: a907 add r1, sp, #28
1111f8: 4630 mov r0, r6
1111fa: f7f7 fabb bl 108774 <rtems_rfs_buffer_handle_release>
handle->dirty = false;
1111fe: 2300 movs r3, #0
rtems_rfs_block_map_close (fs, &map);
111200: a90a add r1, sp, #40 ; 0x28
111202: 4630 mov r0, r6
111204: f88d 301c strb.w r3, [sp, #28]
handle->buffer = NULL;
111208: e9cd 3308 strd r3, r3, [sp, #32]
11120c: f7ff fb90 bl 110930 <rtems_rfs_block_map_close>
}
111210: 4648 mov r0, r9
111212: b01f add sp, #124 ; 0x7c
111214: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
printf ("rtems-rfs: dir-lookup-ino: "
111218: 682b ldr r3, [r5, #0] <== NOT EXECUTED
11121a: 9903 ldr r1, [sp, #12] <== NOT EXECUTED
11121c: 9400 str r4, [sp, #0] <== NOT EXECUTED
11121e: ba1b rev r3, r3 <== NOT EXECUTED
111220: 9804 ldr r0, [sp, #16] <== NOT EXECUTED
111222: 9301 str r3, [sp, #4] <== NOT EXECUTED
111224: e9dd 230e ldrd r2, r3, [sp, #56] ; 0x38 <== NOT EXECUTED
111228: 6889 ldr r1, [r1, #8] <== NOT EXECUTED
11122a: f7f4 fc75 bl 105b18 <__wrap_printf> <== NOT EXECUTED
11122e: e7b2 b.n 111196 <rtems_rfs_dir_lookup_ino+0x116> <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n",
111230: 9b03 ldr r3, [sp, #12] <== NOT EXECUTED
111232: 9a0e ldr r2, [sp, #56] ; 0x38 <== NOT EXECUTED
111234: 9805 ldr r0, [sp, #20] <== NOT EXECUTED
111236: 6899 ldr r1, [r3, #8] <== NOT EXECUTED
111238: f7f4 fc6e bl 105b18 <__wrap_printf> <== NOT EXECUTED
11123c: e771 b.n 111122 <rtems_rfs_dir_lookup_ino+0xa2> <== NOT EXECUTED
if (rc == 0)
11123e: 9b02 ldr r3, [sp, #8]
111240: b193 cbz r3, 111268 <rtems_rfs_dir_lookup_ino+0x1e8>
111242: f8dd 9008 ldr.w r9, [sp, #8] <== NOT EXECUTED
111246: e7d6 b.n 1111f6 <rtems_rfs_dir_lookup_ino+0x176> <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
111248: 9a03 ldr r2, [sp, #12] <== NOT EXECUTED
rc = EIO;
11124a: f04f 0905 mov.w r9, #5 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
11124e: 980f ldr r0, [sp, #60] ; 0x3c <== NOT EXECUTED
111250: f8d8 3000 ldr.w r3, [r8] <== NOT EXECUTED
111254: 6891 ldr r1, [r2, #8] <== NOT EXECUTED
111256: 4622 mov r2, r4 <== NOT EXECUTED
111258: 9000 str r0, [sp, #0] <== NOT EXECUTED
11125a: f64a 7040 movw r0, #44864 ; 0xaf40 <== NOT EXECUTED
11125e: f2c0 0011 movt r0, #17 <== NOT EXECUTED
111262: f7f4 fc59 bl 105b18 <__wrap_printf> <== NOT EXECUTED
while ((rc == 0) && block)
111266: e7c6 b.n 1111f6 <rtems_rfs_dir_lookup_ino+0x176> <== NOT EXECUTED
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
111268: aa06 add r2, sp, #24
11126a: a90a add r1, sp, #40 ; 0x28
11126c: 4630 mov r0, r6
11126e: f7ff fc85 bl 110b7c <rtems_rfs_block_map_next_block>
if ((rc > 0) && (rc != ENXIO))
111272: 2806 cmp r0, #6
111274: bf18 it ne
111276: 2800 cmpne r0, #0
111278: 9002 str r0, [sp, #8]
11127a: dc4a bgt.n 111312 <rtems_rfs_dir_lookup_ino+0x292> <== ALWAYS TAKEN
if (rc == ENXIO)
11127c: 9b02 ldr r3, [sp, #8]
11127e: 2b06 cmp r3, #6
111280: f47f af3f bne.w 111102 <rtems_rfs_dir_lookup_ino+0x82> <== ALWAYS TAKEN
rc = ENOENT;
111284: f04f 0902 mov.w r9, #2
111288: e7b5 b.n 1111f6 <rtems_rfs_dir_lookup_ino+0x176>
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
11128a: f04f 6080 mov.w r0, #67108864 ; 0x4000000 <== NOT EXECUTED
11128e: 2100 movs r1, #0 <== NOT EXECUTED
111290: f7f9 fb74 bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
111294: 2800 cmp r0, #0 <== NOT EXECUTED
111296: d0bb beq.n 111210 <rtems_rfs_dir_lookup_ino+0x190> <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: map open failed for ino %" PRIu32 ": %d: %s",
111298: 9b03 ldr r3, [sp, #12] <== NOT EXECUTED
11129a: 4648 mov r0, r9 <== NOT EXECUTED
11129c: 689c ldr r4, [r3, #8] <== NOT EXECUTED
11129e: f006 fa67 bl 117770 <strerror> <== NOT EXECUTED
1112a2: 4603 mov r3, r0 <== NOT EXECUTED
1112a4: f64a 604c movw r0, #44620 ; 0xae4c <== NOT EXECUTED
1112a8: 464a mov r2, r9 <== NOT EXECUTED
1112aa: 4621 mov r1, r4 <== NOT EXECUTED
1112ac: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1112b0: f7f4 fc32 bl 105b18 <__wrap_printf> <== NOT EXECUTED
}
1112b4: 4648 mov r0, r9 <== NOT EXECUTED
1112b6: b01f add sp, #124 ; 0x7c <== NOT EXECUTED
1112b8: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: lookup ino: root=%" PRId32 ", path=",
1112bc: 9b03 ldr r3, [sp, #12] <== NOT EXECUTED
1112be: f64a 6008 movw r0, #44552 ; 0xae08 <== NOT EXECUTED
1112c2: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1112c6: 6899 ldr r1, [r3, #8] <== NOT EXECUTED
1112c8: f7f4 fc26 bl 105b18 <__wrap_printf> <== NOT EXECUTED
for (c = 0; c < length; c++)
1112cc: f1bb 0f00 cmp.w fp, #0 <== NOT EXECUTED
1112d0: dd08 ble.n 1112e4 <rtems_rfs_dir_lookup_ino+0x264> <== NOT EXECUTED
1112d2: 1e7c subs r4, r7, #1 <== NOT EXECUTED
1112d4: eb04 050b add.w r5, r4, fp <== NOT EXECUTED
printf ("%c", name[c]);
1112d8: f814 0f01 ldrb.w r0, [r4, #1]! <== NOT EXECUTED
1112dc: f005 fcee bl 116cbc <putchar> <== NOT EXECUTED
for (c = 0; c < length; c++)
1112e0: 42a5 cmp r5, r4 <== NOT EXECUTED
1112e2: d1f9 bne.n 1112d8 <rtems_rfs_dir_lookup_ino+0x258> <== NOT EXECUTED
printf (", len=%d\n", length);
1112e4: f64a 6040 movw r0, #44608 ; 0xae40 <== NOT EXECUTED
1112e8: 4659 mov r1, fp <== NOT EXECUTED
1112ea: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1112ee: f7f4 fc13 bl 105b18 <__wrap_printf> <== NOT EXECUTED
1112f2: e6d6 b.n 1110a2 <rtems_rfs_dir_lookup_ino+0x22> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
1112f4: f04f 6080 mov.w r0, #67108864 ; 0x4000000 <== NOT EXECUTED
1112f8: 2100 movs r1, #0 <== NOT EXECUTED
1112fa: f7f9 fb3f bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
1112fe: 2800 cmp r0, #0 <== NOT EXECUTED
111300: d150 bne.n 1113a4 <rtems_rfs_dir_lookup_ino+0x324> <== NOT EXECUTED
rc = ENOENT;
111302: f1b9 0f06 cmp.w r9, #6 <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
111306: a907 add r1, sp, #28 <== NOT EXECUTED
111308: 4630 mov r0, r6 <== NOT EXECUTED
11130a: bf08 it eq <== NOT EXECUTED
11130c: f04f 0902 moveq.w r9, #2 <== NOT EXECUTED
111310: e773 b.n 1111fa <rtems_rfs_dir_lookup_ino+0x17a> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
111312: f04f 6080 mov.w r0, #67108864 ; 0x4000000 <== NOT EXECUTED
111316: 2100 movs r1, #0 <== NOT EXECUTED
111318: f7f9 fb30 bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
11131c: 2800 cmp r0, #0 <== NOT EXECUTED
11131e: f43f aef0 beq.w 111102 <rtems_rfs_dir_lookup_ino+0x82> <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
111322: 9b03 ldr r3, [sp, #12] <== NOT EXECUTED
111324: 9d02 ldr r5, [sp, #8] <== NOT EXECUTED
111326: 689c ldr r4, [r3, #8] <== NOT EXECUTED
111328: 4628 mov r0, r5 <== NOT EXECUTED
11132a: f006 fa21 bl 117770 <strerror> <== NOT EXECUTED
11132e: 4603 mov r3, r0 <== NOT EXECUTED
111330: f24b 0028 movw r0, #45096 ; 0xb028 <== NOT EXECUTED
111334: 462a mov r2, r5 <== NOT EXECUTED
111336: 4621 mov r1, r4 <== NOT EXECUTED
111338: f2c0 0011 movt r0, #17 <== NOT EXECUTED
11133c: f7f4 fbec bl 105b18 <__wrap_printf> <== NOT EXECUTED
111340: e6df b.n 111102 <rtems_rfs_dir_lookup_ino+0x82> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
111342: f04f 6080 mov.w r0, #67108864 ; 0x4000000 <== NOT EXECUTED
111346: 2100 movs r1, #0 <== NOT EXECUTED
111348: f7f9 fb18 bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
11134c: 2800 cmp r0, #0 <== NOT EXECUTED
11134e: f43f af50 beq.w 1111f2 <rtems_rfs_dir_lookup_ino+0x172> <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block is 0 in ino %" PRIu32 ": %d: %s\n",
111352: 9b03 ldr r3, [sp, #12] <== NOT EXECUTED
111354: 2005 movs r0, #5 <== NOT EXECUTED
111356: 689c ldr r4, [r3, #8] <== NOT EXECUTED
111358: f006 fa0a bl 117770 <strerror> <== NOT EXECUTED
11135c: 4603 mov r3, r0 <== NOT EXECUTED
11135e: f24b 0074 movw r0, #45172 ; 0xb074 <== NOT EXECUTED
111362: 4621 mov r1, r4 <== NOT EXECUTED
111364: 2205 movs r2, #5 <== NOT EXECUTED
111366: f2c0 0011 movt r0, #17 <== NOT EXECUTED
11136a: f7f4 fbd5 bl 105b18 <__wrap_printf> <== NOT EXECUTED
11136e: e740 b.n 1111f2 <rtems_rfs_dir_lookup_ino+0x172> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
111370: f04f 6080 mov.w r0, #67108864 ; 0x4000000 <== NOT EXECUTED
111374: 2100 movs r1, #0 <== NOT EXECUTED
111376: 4699 mov r9, r3 <== NOT EXECUTED
111378: f7f9 fb00 bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
11137c: 2800 cmp r0, #0 <== NOT EXECUTED
11137e: f43f af3a beq.w 1111f6 <rtems_rfs_dir_lookup_ino+0x176> <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " block=%" PRId32 ": %d: %s\n",
111382: 9b03 ldr r3, [sp, #12] <== NOT EXECUTED
111384: 4648 mov r0, r9 <== NOT EXECUTED
111386: 9d06 ldr r5, [sp, #24] <== NOT EXECUTED
111388: 689c ldr r4, [r3, #8] <== NOT EXECUTED
11138a: f006 f9f1 bl 117770 <strerror> <== NOT EXECUTED
11138e: 9000 str r0, [sp, #0] <== NOT EXECUTED
111390: f64a 7000 movw r0, #44800 ; 0xaf00 <== NOT EXECUTED
111394: 462a mov r2, r5 <== NOT EXECUTED
111396: 4621 mov r1, r4 <== NOT EXECUTED
111398: 464b mov r3, r9 <== NOT EXECUTED
11139a: f2c0 0011 movt r0, #17 <== NOT EXECUTED
11139e: f7f4 fbbb bl 105b18 <__wrap_printf> <== NOT EXECUTED
1113a2: e728 b.n 1111f6 <rtems_rfs_dir_lookup_ino+0x176> <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block map find failed: %d: %s\n",
1113a4: 4648 mov r0, r9 <== NOT EXECUTED
1113a6: f006 f9e3 bl 117770 <strerror> <== NOT EXECUTED
1113aa: 4602 mov r2, r0 <== NOT EXECUTED
1113ac: f64a 608c movw r0, #44684 ; 0xae8c <== NOT EXECUTED
1113b0: 4649 mov r1, r9 <== NOT EXECUTED
1113b2: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1113b6: f7f4 fbaf bl 105b18 <__wrap_printf> <== NOT EXECUTED
1113ba: e7a2 b.n 111302 <rtems_rfs_dir_lookup_ino+0x282> <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
1113bc: 9b29 ldr r3, [sp, #164] ; 0xa4 <== NOT EXECUTED
1113be: f64a 70e4 movw r0, #45028 ; 0xafe4 <== NOT EXECUTED
1113c2: 9903 ldr r1, [sp, #12] <== NOT EXECUTED
1113c4: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1113c8: f8d8 2000 ldr.w r2, [r8] <== NOT EXECUTED
1113cc: 681b ldr r3, [r3, #0] <== NOT EXECUTED
1113ce: 6889 ldr r1, [r1, #8] <== NOT EXECUTED
1113d0: f7f4 fba2 bl 105b18 <__wrap_printf> <== NOT EXECUTED
1113d4: e6f5 b.n 1111c2 <rtems_rfs_dir_lookup_ino+0x142> <== NOT EXECUTED
1113d6: bf00 nop
001118f4 <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)
{
1118f4: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
1118f8: 4606 mov r6, r0
1118fa: b09f sub sp, #124 ; 0x7c
1118fc: 468a mov sl, r1
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))
1118fe: f04f 4000 mov.w r0, #2147483648 ; 0x80000000
111902: 2100 movs r1, #0
{
111904: 9f29 ldr r7, [sp, #164] ; 0xa4
111906: 4691 mov r9, r2
111908: 4698 mov r8, r3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
11190a: f7f9 f837 bl 10a97c <rtems_rfs_trace>
11190e: 2800 cmp r0, #0
111910: f040 8084 bne.w 111a1c <rtems_rfs_dir_read+0x128> <== ALWAYS TAKEN
printf ("rtems-rfs: dir-read: dir=%" PRId32 " offset=%" PRId64 "\n",
rtems_rfs_inode_ino (dir), offset);
*length = 0;
111914: 2500 movs r5, #0
rc = rtems_rfs_block_map_open (fs, dir, &map);
111916: aa0a add r2, sp, #40 ; 0x28
111918: 4651 mov r1, sl
11191a: 4630 mov r0, r6
*length = 0;
11191c: 603d str r5, [r7, #0]
rc = rtems_rfs_block_map_open (fs, dir, &map);
11191e: f7fe ffb5 bl 11088c <rtems_rfs_block_map_open>
if (rc > 0)
111922: 1e04 subs r4, r0, #0
111924: dc6b bgt.n 1119fe <rtems_rfs_dir_read+0x10a> <== ALWAYS TAKEN
return rc;
if (((rtems_rfs_fs_block_size (fs) -
111926: 68b4 ldr r4, [r6, #8]
111928: 462b mov r3, r5
11192a: 4648 mov r0, r9
11192c: 4641 mov r1, r8
11192e: 4622 mov r2, r4
111930: f004 fb50 bl 115fd4 <__aeabi_ldivmod>
111934: 1aa2 subs r2, r4, r2
111936: eb65 0303 sbc.w r3, r5, r3
11193a: 2a0b cmp r2, #11
11193c: f173 0300 sbcs.w r3, r3, #0
111940: da06 bge.n 111950 <rtems_rfs_dir_read+0x5c> <== NEVER TAKEN
(offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
offset = (((offset / rtems_rfs_fs_block_size (fs)) + 1) *
111942: 3001 adds r0, #1 <== NOT EXECUTED
111944: fba0 9804 umull r9, r8, r0, r4 <== NOT EXECUTED
111948: f141 0100 adc.w r1, r1, #0 <== NOT EXECUTED
11194c: fb04 8801 mla r8, r4, r1, r8 <== NOT EXECUTED
rtems_rfs_fs_block_size (fs));
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
111950: f10d 0b18 add.w fp, sp, #24
111954: 464a mov r2, r9
111956: 4643 mov r3, r8
111958: a90a add r1, sp, #40 ; 0x28
11195a: 4630 mov r0, r6
11195c: f8cd b000 str.w fp, [sp]
111960: f7ff f8ee bl 110b40 <rtems_rfs_block_map_seek>
if (rc > 0)
111964: 1e04 subs r4, r0, #0
111966: dc4e bgt.n 111a06 <rtems_rfs_dir_read+0x112> <== ALWAYS TAKEN
}
*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",
111968: f24b 4318 movw r3, #46104 ; 0xb418
11196c: f2c0 0311 movt r3, #17
111970: 9305 str r3, [sp, #20]
handle->dirty = false;
111972: 2300 movs r3, #0
111974: f88d 301c strb.w r3, [sp, #28]
handle->buffer = NULL;
111978: e9cd 3308 strd r3, r3, [sp, #32]
while (rc == 0)
11197c: e008 b.n 111990 <rtems_rfs_dir_read+0x9c>
offset, *length);
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
11197e: 465a mov r2, fp
111980: a90a add r1, sp, #40 ; 0x28
111982: 4630 mov r0, r6
111984: f7ff f8fa bl 110b7c <rtems_rfs_block_map_next_block>
if (rc == ENXIO)
111988: 2806 cmp r0, #6
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
11198a: 4604 mov r4, r0
if (rc == ENXIO)
11198c: d029 beq.n 1119e2 <rtems_rfs_dir_read+0xee> <== NEVER TAKEN
while (rc == 0)
11198e: bb48 cbnz r0, 1119e4 <rtems_rfs_dir_read+0xf0> <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
111990: a907 add r1, sp, #28
111992: 9a06 ldr r2, [sp, #24]
111994: 2301 movs r3, #1
111996: 4630 mov r0, r6
111998: f7f6 fe00 bl 10859c <rtems_rfs_buffer_handle_request>
11199c: 4604 mov r4, r0
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
11199e: f64f 7cff movw ip, #65535 ; 0xffff
if (rc > 0)
1119a2: 2c00 cmp r4, #0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
1119a4: f04f 4000 mov.w r0, #2147483648 ; 0x80000000
1119a8: f04f 0100 mov.w r1, #0
if (rc > 0)
1119ac: dc1a bgt.n 1119e4 <rtems_rfs_dir_read+0xf0> <== ALWAYS TAKEN
entry = rtems_rfs_buffer_data (&buffer);
1119ae: 9b09 ldr r3, [sp, #36] ; 0x24
entry += map.bpos.boff;
1119b0: 9a0f ldr r2, [sp, #60] ; 0x3c
entry = rtems_rfs_buffer_data (&buffer);
1119b2: 69db ldr r3, [r3, #28]
entry += map.bpos.boff;
1119b4: 4413 add r3, r2
elength = rtems_rfs_dir_entry_length (entry);
1119b6: 891d ldrh r5, [r3, #8]
1119b8: ba6d rev16 r5, r5
1119ba: b2ad uxth r5, r5
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
1119bc: 4565 cmp r5, ip
1119be: d138 bne.n 111a32 <rtems_rfs_dir_read+0x13e>
*length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;
1119c0: 68b3 ldr r3, [r6, #8]
1119c2: 1a9a subs r2, r3, r2
1119c4: 683b ldr r3, [r7, #0]
1119c6: 4413 add r3, r2
1119c8: 603b str r3, [r7, #0]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
1119ca: f7f8 ffd7 bl 10a97c <rtems_rfs_trace>
1119ce: 2800 cmp r0, #0
1119d0: d0d5 beq.n 11197e <rtems_rfs_dir_read+0x8a> <== NEVER TAKEN
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
1119d2: 683b ldr r3, [r7, #0] <== NOT EXECUTED
1119d4: 464a mov r2, r9 <== NOT EXECUTED
1119d6: 9805 ldr r0, [sp, #20] <== NOT EXECUTED
1119d8: 9300 str r3, [sp, #0] <== NOT EXECUTED
1119da: 4643 mov r3, r8 <== NOT EXECUTED
1119dc: f7f4 f89c bl 105b18 <__wrap_printf> <== NOT EXECUTED
1119e0: e7cd b.n 11197e <rtems_rfs_dir_read+0x8a> <== NOT EXECUTED
rc = ENOENT;
1119e2: 2402 movs r4, #2
rtems_rfs_buffer_handle_release (fs, handle);
1119e4: a907 add r1, sp, #28
1119e6: 4630 mov r0, r6
1119e8: f7f6 fec4 bl 108774 <rtems_rfs_buffer_handle_release>
handle->dirty = false;
1119ec: 2300 movs r3, #0
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
1119ee: a90a add r1, sp, #40 ; 0x28
1119f0: 4630 mov r0, r6
1119f2: f88d 301c strb.w r3, [sp, #28]
handle->buffer = NULL;
1119f6: e9cd 3308 strd r3, r3, [sp, #32]
1119fa: f7fe ff99 bl 110930 <rtems_rfs_block_map_close>
return rc;
}
1119fe: 4620 mov r0, r4
111a00: b01f add sp, #124 ; 0x7c
111a02: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
rc = ENOENT;
111a06: 2c06 cmp r4, #6 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
111a08: a90a add r1, sp, #40 ; 0x28 <== NOT EXECUTED
rc = ENOENT;
111a0a: bf08 it eq <== NOT EXECUTED
111a0c: 2402 moveq r4, #2 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
111a0e: 4630 mov r0, r6 <== NOT EXECUTED
111a10: f7fe ff8e bl 110930 <rtems_rfs_block_map_close> <== NOT EXECUTED
}
111a14: 4620 mov r0, r4 <== NOT EXECUTED
111a16: b01f add sp, #124 ; 0x7c <== NOT EXECUTED
111a18: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
printf ("rtems-rfs: dir-read: dir=%" PRId32 " offset=%" PRId64 "\n",
111a1c: f24b 3070 movw r0, #45936 ; 0xb370 <== NOT EXECUTED
111a20: f8da 1008 ldr.w r1, [sl, #8] <== NOT EXECUTED
111a24: 464a mov r2, r9 <== NOT EXECUTED
111a26: 4643 mov r3, r8 <== NOT EXECUTED
111a28: f2c0 0011 movt r0, #17 <== NOT EXECUTED
111a2c: f7f4 f874 bl 105b18 <__wrap_printf> <== NOT EXECUTED
111a30: e770 b.n 111914 <rtems_rfs_dir_read+0x20> <== NOT EXECUTED
111a32: f8d3 8000 ldr.w r8, [r3]
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
111a36: 2d0a cmp r5, #10
111a38: fa98 f888 rev.w r8, r8
111a3c: dd08 ble.n 111a50 <rtems_rfs_dir_read+0x15c> <== ALWAYS TAKEN
111a3e: 69f1 ldr r1, [r6, #28]
111a40: f1b8 0f00 cmp.w r8, #0
111a44: bf18 it ne
111a46: 42a9 cmpne r1, r5
111a48: bf94 ite ls
111a4a: 2101 movls r1, #1
111a4c: 2100 movhi r1, #0
111a4e: d815 bhi.n 111a7c <rtems_rfs_dir_read+0x188> <== NEVER TAKEN
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
111a50: f04f 4000 mov.w r0, #2147483648 ; 0x80000000 <== NOT EXECUTED
111a54: 2100 movs r1, #0 <== NOT EXECUTED
rc = EIO;
111a56: 2405 movs r4, #5 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
111a58: f7f8 ff90 bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
111a5c: 2800 cmp r0, #0 <== NOT EXECUTED
111a5e: d0c1 beq.n 1119e4 <rtems_rfs_dir_read+0xf0> <== NOT EXECUTED
printf ("rtems-rfs: dir-read: "
111a60: 980f ldr r0, [sp, #60] ; 0x3c <== NOT EXECUTED
111a62: 4643 mov r3, r8 <== NOT EXECUTED
111a64: f8da 1008 ldr.w r1, [sl, #8] <== NOT EXECUTED
111a68: 462a mov r2, r5 <== NOT EXECUTED
rc = EIO;
111a6a: 2405 movs r4, #5 <== NOT EXECUTED
printf ("rtems-rfs: dir-read: "
111a6c: 9000 str r0, [sp, #0] <== NOT EXECUTED
111a6e: f24b 309c movw r0, #45980 ; 0xb39c <== NOT EXECUTED
111a72: f2c0 0011 movt r0, #17 <== NOT EXECUTED
111a76: f7f4 f84f bl 105b18 <__wrap_printf> <== NOT EXECUTED
111a7a: e7b3 b.n 1119e4 <rtems_rfs_dir_read+0xf0> <== NOT EXECUTED
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
111a7c: 6972 ldr r2, [r6, #20]
111a7e: 4542 cmp r2, r8
111a80: d3e6 bcc.n 111a50 <rtems_rfs_dir_read+0x15c> <== ALWAYS TAKEN
memset (dirent, 0, sizeof (struct dirent));
111a82: f44f 788c mov.w r8, #280 ; 0x118
111a86: 9828 ldr r0, [sp, #160] ; 0xa0
111a88: 4642 mov r2, r8
111a8a: 9305 str r3, [sp, #20]
111a8c: f005 f8c4 bl 116c18 <memset>
dirent->d_off = rtems_rfs_block_get_pos (fs, &map.bpos);
111a90: a90e add r1, sp, #56 ; 0x38
111a92: 4630 mov r0, r6
111a94: f7fe fee2 bl 11085c <rtems_rfs_block_get_pos>
*length += elength;
111a98: 683a ldr r2, [r7, #0]
dirent->d_off = rtems_rfs_block_get_pos (fs, &map.bpos);
111a9a: 9b28 ldr r3, [sp, #160] ; 0xa0
111a9c: e9c3 0102 strd r0, r1, [r3, #8]
*length += elength;
111aa0: 18a9 adds r1, r5, r2
dirent->d_reclen = sizeof (struct dirent);
111aa2: f8a3 8010 strh.w r8, [r3, #16]
*length += elength;
111aa6: 980f ldr r0, [sp, #60] ; 0x3c
111aa8: 6039 str r1, [r7, #0]
remaining = rtems_rfs_fs_block_size (fs) - (map.bpos.boff + elength);
111aaa: 68b1 ldr r1, [r6, #8]
if (remaining <= RTEMS_RFS_DIR_ENTRY_SIZE)
111aac: 9b05 ldr r3, [sp, #20]
111aae: 1a09 subs r1, r1, r0
remaining = rtems_rfs_fs_block_size (fs) - (map.bpos.boff + elength);
111ab0: 1b48 subs r0, r1, r5
elength -= RTEMS_RFS_DIR_ENTRY_SIZE;
111ab2: 3d0a subs r5, #10
if (remaining <= RTEMS_RFS_DIR_ENTRY_SIZE)
111ab4: 280a cmp r0, #10
memcpy (dirent->d_name, entry + RTEMS_RFS_DIR_ENTRY_SIZE, elength);
111ab6: 9305 str r3, [sp, #20]
*length += remaining;
111ab8: bfd8 it le
111aba: 1852 addle r2, r2, r1
memcpy (dirent->d_name, entry + RTEMS_RFS_DIR_ENTRY_SIZE, elength);
111abc: f103 010a add.w r1, r3, #10
*length += remaining;
111ac0: bfd8 it le
111ac2: 603a strle r2, [r7, #0]
111ac4: 2dff cmp r5, #255 ; 0xff
memcpy (dirent->d_name, entry + RTEMS_RFS_DIR_ENTRY_SIZE, elength);
111ac6: 9a28 ldr r2, [sp, #160] ; 0xa0
111ac8: bfa8 it ge
111aca: 25ff movge r5, #255 ; 0xff
111acc: f102 0716 add.w r7, r2, #22
111ad0: 462a mov r2, r5
111ad2: 4638 mov r0, r7
111ad4: f004 edb4 blx 116640 <memcpy>
dirent->d_ino = rtems_rfs_dir_entry_ino (entry);
111ad8: 9b05 ldr r3, [sp, #20]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
111ada: f04f 4000 mov.w r0, #2147483648 ; 0x80000000
dirent->d_namlen = elength;
111ade: 9a28 ldr r2, [sp, #160] ; 0xa0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
111ae0: 2100 movs r1, #0
111ae2: 681b ldr r3, [r3, #0]
dirent->d_namlen = elength;
111ae4: 8295 strh r5, [r2, #20]
111ae6: ba1b rev r3, r3
dirent->d_ino = rtems_rfs_dir_entry_ino (entry);
111ae8: 6013 str r3, [r2, #0]
111aea: 2300 movs r3, #0
111aec: 6053 str r3, [r2, #4]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
111aee: f7f8 ff45 bl 10a97c <rtems_rfs_trace>
111af2: 2800 cmp r0, #0
111af4: f43f af76 beq.w 1119e4 <rtems_rfs_dir_read+0xf0> <== NEVER TAKEN
printf ("rtems-rfs: dir-read: found off:%" PRIooff_t
111af8: 9b28 ldr r3, [sp, #160] ; 0xa0 <== NOT EXECUTED
111afa: f24b 30e0 movw r0, #46048 ; 0xb3e0 <== NOT EXECUTED
111afe: 9702 str r7, [sp, #8] <== NOT EXECUTED
111b00: f2c0 0011 movt r0, #17 <== NOT EXECUTED
111b04: e9d3 2300 ldrd r2, r3, [r3] <== NOT EXECUTED
111b08: e9cd 2300 strd r2, r3, [sp] <== NOT EXECUTED
111b0c: 9b28 ldr r3, [sp, #160] ; 0xa0 <== NOT EXECUTED
111b0e: e9d3 2302 ldrd r2, r3, [r3, #8] <== NOT EXECUTED
111b12: f7f4 f801 bl 105b18 <__wrap_printf> <== NOT EXECUTED
111b16: e765 b.n 1119e4 <rtems_rfs_dir_read+0xf0> <== NOT EXECUTED
00111f88 <rtems_rfs_file_close>:
{
111f88: e92d 43f8 stmdb sp!, {r3, r4, r5, r6, r7, r8, r9, lr}
111f8c: 4606 mov r6, r0
111f8e: 460c mov r4, r1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
111f90: 2000 movs r0, #0
111f92: 2110 movs r1, #16
111f94: f7f8 fcf2 bl 10a97c <rtems_rfs_trace>
111f98: 2800 cmp r0, #0
111f9a: f040 809b bne.w 1120d4 <rtems_rfs_file_close+0x14c> <== ALWAYS TAKEN
if (handle->shared->references > 0)
111f9e: 69e1 ldr r1, [r4, #28]
rc = rtems_rfs_buffer_handle_close (fs, &handle->buffer);
111fa0: 1d27 adds r7, r4, #4
if (handle->shared->references > 0)
111fa2: 688d ldr r5, [r1, #8]
111fa4: 2d00 cmp r5, #0
handle->shared->references--;
111fa6: bfc4 itt gt
111fa8: f105 35ff addgt.w r5, r5, #4294967295 ; 0xffffffff
111fac: 608d strgt r5, [r1, #8]
if (handle->shared->references == 0)
111fae: b155 cbz r5, 111fc6 <rtems_rfs_file_close+0x3e>
111fb0: 4639 mov r1, r7 <== NOT EXECUTED
111fb2: 4630 mov r0, r6 <== NOT EXECUTED
rrc = 0;
111fb4: 2500 movs r5, #0 <== NOT EXECUTED
111fb6: f7f6 fbdd bl 108774 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
free (handle);
111fba: 4620 mov r0, r4
111fbc: f7f3 fea8 bl 105d10 <free>
}
111fc0: 4628 mov r0, r5
111fc2: e8bd 83f8 ldmia.w sp!, {r3, r4, r5, r6, r7, r8, r9, pc}
if (!rtems_rfs_inode_is_loaded (&handle->shared->inode))
111fc6: 698a ldr r2, [r1, #24]
111fc8: 2a00 cmp r2, #0
111fca: f000 80ac beq.w 112126 <rtems_rfs_file_close+0x19e> <== NEVER TAKEN
rtems_rfs_inode_set_atime (&handle->shared->inode,
111fce: f8d1 308c ldr.w r3, [r1, #140] ; 0x8c
rtems_rfs_buffer_mark_dirty (&handle->buffer);
111fd2: 2001 movs r0, #1
rtems_rfs_write_u32 (&handle->node->atime, atime);
111fd4: ea4f 6c13 mov.w ip, r3, lsr #24
111fd8: f882 c010 strb.w ip, [r2, #16]
111fdc: ea4f 4c13 mov.w ip, r3, lsr #16
111fe0: 698a ldr r2, [r1, #24]
111fe2: f882 c011 strb.w ip, [r2, #17]
111fe6: ea4f 2c13 mov.w ip, r3, lsr #8
111fea: 698a ldr r2, [r1, #24]
111fec: f882 c012 strb.w ip, [r2, #18]
111ff0: 698a ldr r2, [r1, #24]
111ff2: 74d3 strb r3, [r2, #19]
rtems_rfs_inode_set_mtime (&handle->shared->inode,
111ff4: 69e3 ldr r3, [r4, #28]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
111ff6: 7708 strb r0, [r1, #28]
111ff8: f8d3 2090 ldr.w r2, [r3, #144] ; 0x90
rtems_rfs_write_u32 (&handle->node->mtime, mtime);
111ffc: 6999 ldr r1, [r3, #24]
111ffe: ea4f 6c12 mov.w ip, r2, lsr #24
112002: f881 c014 strb.w ip, [r1, #20]
112006: ea4f 4c12 mov.w ip, r2, lsr #16
11200a: 6999 ldr r1, [r3, #24]
11200c: f881 c015 strb.w ip, [r1, #21]
112010: ea4f 2c12 mov.w ip, r2, lsr #8
112014: 6999 ldr r1, [r3, #24]
112016: f881 c016 strb.w ip, [r1, #22]
11201a: 6999 ldr r1, [r3, #24]
11201c: 75ca strb r2, [r1, #23]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
11201e: 7718 strb r0, [r3, #28]
rtems_rfs_inode_set_ctime (&handle->shared->inode,
112020: 69e3 ldr r3, [r4, #28]
112022: f8d3 2094 ldr.w r2, [r3, #148] ; 0x94
rtems_rfs_write_u32 (&handle->node->ctime, ctime);
112026: 6999 ldr r1, [r3, #24]
112028: ea4f 6c12 mov.w ip, r2, lsr #24
11202c: f881 c018 strb.w ip, [r1, #24]
112030: ea4f 4c12 mov.w ip, r2, lsr #16
112034: 6999 ldr r1, [r3, #24]
112036: f881 c019 strb.w ip, [r1, #25]
11203a: ea4f 2c12 mov.w ip, r2, lsr #8
11203e: 6999 ldr r1, [r3, #24]
112040: f881 c01a strb.w ip, [r1, #26]
112044: 6999 ldr r1, [r3, #24]
112046: 76ca strb r2, [r1, #27]
if (!rtems_rfs_block_size_equal (&handle->shared->size,
112048: 69e1 ldr r1, [r4, #28]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
11204a: 7718 strb r0, [r3, #28]
11204c: f8d1 3084 ldr.w r3, [r1, #132] ; 0x84
112050: 6bca ldr r2, [r1, #60] ; 0x3c
112052: 4293 cmp r3, r2
112054: f8d1 2088 ldr.w r2, [r1, #136] ; 0x88
112058: f000 808d beq.w 112176 <rtems_rfs_file_close+0x1ee> <== NEVER 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);
11205c: e9c1 320f strd r3, r2, [r1, #60] ; 0x3c <== NOT EXECUTED
map->dirty = true;
112060: 2301 movs r3, #1 <== NOT EXECUTED
112062: f881 3034 strb.w r3, [r1, #52] ; 0x34 <== NOT EXECUTED
rc = rtems_rfs_block_map_close (fs, &handle->shared->map);
112066: 3134 adds r1, #52 ; 0x34
112068: 4630 mov r0, r6
11206a: f7fe fc61 bl 110930 <rtems_rfs_block_map_close>
if (rc > 0)
11206e: f1b0 0800 subs.w r8, r0, #0
112072: dc4f bgt.n 112114 <rtems_rfs_file_close+0x18c> <== ALWAYS TAKEN
rc = rtems_rfs_inode_close (fs, &handle->shared->inode);
112074: 69e1 ldr r1, [r4, #28]
112076: 4630 mov r0, r6
112078: 310c adds r1, #12
11207a: f7f7 fcef bl 109a5c <rtems_rfs_inode_close>
if (rc > 0)
11207e: f1b0 0800 subs.w r8, r0, #0
112082: dc30 bgt.n 1120e6 <rtems_rfs_file_close+0x15e> <== ALWAYS TAKEN
rtems_chain_extract_unprotected (&handle->shared->link);
112084: 69e0 ldr r0, [r4, #28]
previous = the_node->previous;
112086: e9d0 2300 ldrd r2, r3, [r0]
next->previous = previous;
11208a: 6053 str r3, [r2, #4]
previous->next = next;
11208c: 601a str r2, [r3, #0]
free (handle->shared);
11208e: f7f3 fe3f bl 105d10 <free>
112092: 4639 mov r1, r7
112094: 4630 mov r0, r6
112096: f7f6 fb6d bl 108774 <rtems_rfs_buffer_handle_release>
handle->dirty = false;
11209a: 2300 movs r3, #0
if (rrc > 0)
11209c: 429d cmp r5, r3
11209e: 7123 strb r3, [r4, #4]
handle->buffer = NULL;
1120a0: e9c4 3302 strd r3, r3, [r4, #8]
1120a4: dd89 ble.n 111fba <rtems_rfs_file_close+0x32> <== NEVER TAKEN
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
1120a6: 2000 movs r0, #0 <== NOT EXECUTED
1120a8: 2110 movs r1, #16 <== NOT EXECUTED
1120aa: f7f8 fc67 bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
1120ae: 2800 cmp r0, #0 <== NOT EXECUTED
1120b0: d083 beq.n 111fba <rtems_rfs_file_close+0x32> <== NOT EXECUTED
printf ("rtems-rfs: file-close: result: %d: %s\n", rrc, strerror (rrc));
1120b2: 4628 mov r0, r5 <== NOT EXECUTED
1120b4: f005 fb5c bl 117770 <strerror> <== NOT EXECUTED
1120b8: 4602 mov r2, r0 <== NOT EXECUTED
1120ba: f24b 6030 movw r0, #46640 ; 0xb630 <== NOT EXECUTED
1120be: 4629 mov r1, r5 <== NOT EXECUTED
1120c0: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1120c4: f7f3 fd28 bl 105b18 <__wrap_printf> <== NOT EXECUTED
free (handle);
1120c8: 4620 mov r0, r4 <== NOT EXECUTED
1120ca: f7f3 fe21 bl 105d10 <free> <== NOT EXECUTED
}
1120ce: 4628 mov r0, r5 <== NOT EXECUTED
1120d0: e8bd 83f8 ldmia.w sp!, {r3, r4, r5, r6, r7, r8, r9, pc} <== NOT EXECUTED
printf ("rtems-rfs: file-close: entry: ino=%" PRId32 "\n",
1120d4: 69e3 ldr r3, [r4, #28] <== NOT EXECUTED
1120d6: f24b 5094 movw r0, #46484 ; 0xb594 <== NOT EXECUTED
1120da: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1120de: 6959 ldr r1, [r3, #20] <== NOT EXECUTED
1120e0: f7f3 fd1a bl 105b18 <__wrap_printf> <== NOT EXECUTED
1120e4: e75b b.n 111f9e <rtems_rfs_file_close+0x16> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
1120e6: 2000 movs r0, #0 <== NOT EXECUTED
1120e8: 2110 movs r1, #16 <== NOT EXECUTED
1120ea: f7f8 fc47 bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
1120ee: bb10 cbnz r0, 112136 <rtems_rfs_file_close+0x1ae> <== NOT EXECUTED
rtems_chain_extract_unprotected (&handle->shared->link);
1120f0: 69e0 ldr r0, [r4, #28] <== NOT EXECUTED
previous = the_node->previous;
1120f2: e9d0 2300 ldrd r2, r3, [r0] <== NOT EXECUTED
if (rrc == 0)
1120f6: 2d00 cmp r5, #0 <== NOT EXECUTED
1120f8: d1c7 bne.n 11208a <rtems_rfs_file_close+0x102> <== NOT EXECUTED
next->previous = previous;
1120fa: 6053 str r3, [r2, #4] <== NOT EXECUTED
previous->next = next;
1120fc: 601a str r2, [r3, #0] <== NOT EXECUTED
free (handle->shared);
1120fe: f7f3 fe07 bl 105d10 <free> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
112102: 4639 mov r1, r7 <== NOT EXECUTED
112104: 4630 mov r0, r6 <== NOT EXECUTED
112106: f7f6 fb35 bl 108774 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
11210a: 7125 strb r5, [r4, #4] <== NOT EXECUTED
handle->buffer = NULL;
11210c: e9c4 5502 strd r5, r5, [r4, #8] <== NOT EXECUTED
112110: 4645 mov r5, r8 <== NOT EXECUTED
112112: e7c8 b.n 1120a6 <rtems_rfs_file_close+0x11e> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
112114: 2000 movs r0, #0 <== NOT EXECUTED
112116: 2110 movs r1, #16 <== NOT EXECUTED
112118: f7f8 fc30 bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
11211c: b9d8 cbnz r0, 112156 <rtems_rfs_file_close+0x1ce> <== NOT EXECUTED
if (rrc == 0)
11211e: 2d00 cmp r5, #0 <== NOT EXECUTED
112120: bf08 it eq <== NOT EXECUTED
112122: 4645 moveq r5, r8 <== NOT EXECUTED
112124: e7a6 b.n 112074 <rtems_rfs_file_close+0xec> <== NOT EXECUTED
rrc = rtems_rfs_inode_load (fs, &handle->shared->inode);
112126: 310c adds r1, #12
112128: 4630 mov r0, r6
11212a: f7f7 fbd9 bl 1098e0 <rtems_rfs_inode_load>
rtems_rfs_inode_set_atime (&handle->shared->inode,
11212e: 69e1 ldr r1, [r4, #28]
if (rrc == 0)
112130: b330 cbz r0, 112180 <rtems_rfs_file_close+0x1f8>
rc = rtems_rfs_block_map_close (fs, &handle->shared->map);
112132: 4605 mov r5, r0 <== NOT EXECUTED
112134: e797 b.n 112066 <rtems_rfs_file_close+0xde> <== NOT EXECUTED
printf ("rtems-rfs: file-close: inode close error: ino=%" PRId32 ": %d: %s\n",
112136: 69e3 ldr r3, [r4, #28] <== NOT EXECUTED
112138: 4640 mov r0, r8 <== NOT EXECUTED
11213a: f8d3 9014 ldr.w r9, [r3, #20] <== NOT EXECUTED
11213e: f005 fb17 bl 117770 <strerror> <== NOT EXECUTED
112142: 4603 mov r3, r0 <== NOT EXECUTED
112144: f24b 50f4 movw r0, #46580 ; 0xb5f4 <== NOT EXECUTED
112148: 4642 mov r2, r8 <== NOT EXECUTED
11214a: 4649 mov r1, r9 <== NOT EXECUTED
11214c: f2c0 0011 movt r0, #17 <== NOT EXECUTED
112150: f7f3 fce2 bl 105b18 <__wrap_printf> <== NOT EXECUTED
112154: e7cc b.n 1120f0 <rtems_rfs_file_close+0x168> <== NOT EXECUTED
printf ("rtems-rfs: file-close: map close error: ino=%" PRId32 ": %d: %s\n",
112156: 69e3 ldr r3, [r4, #28] <== NOT EXECUTED
112158: 4640 mov r0, r8 <== NOT EXECUTED
11215a: f8d3 9014 ldr.w r9, [r3, #20] <== NOT EXECUTED
11215e: f005 fb07 bl 117770 <strerror> <== NOT EXECUTED
112162: 4603 mov r3, r0 <== NOT EXECUTED
112164: f24b 50bc movw r0, #46524 ; 0xb5bc <== NOT EXECUTED
112168: 4642 mov r2, r8 <== NOT EXECUTED
11216a: 4649 mov r1, r9 <== NOT EXECUTED
11216c: f2c0 0011 movt r0, #17 <== NOT EXECUTED
112170: f7f3 fcd2 bl 105b18 <__wrap_printf> <== NOT EXECUTED
112174: e7d3 b.n 11211e <rtems_rfs_file_close+0x196> <== NOT EXECUTED
if (!rtems_rfs_block_size_equal (&handle->shared->size,
112176: 6c08 ldr r0, [r1, #64] ; 0x40
112178: 4282 cmp r2, r0
11217a: f47f af6f bne.w 11205c <rtems_rfs_file_close+0xd4> <== ALWAYS TAKEN
11217e: e772 b.n 112066 <rtems_rfs_file_close+0xde>
rtems_rfs_write_u32 (&handle->node->atime, atime);
112180: 698a ldr r2, [r1, #24]
112182: e724 b.n 111fce <rtems_rfs_file_close+0x46>
00112758 <rtems_rfs_file_get_shared>:
{
112758: 4602 mov r2, r0
return _Chain_Immutable_head( the_chain )->next;
11275a: 6f40 ldr r0, [r0, #116] ; 0x74
return &the_chain->Tail.Node;
11275c: 3278 adds r2, #120 ; 0x78
while (!rtems_chain_is_tail (&fs->file_shares, node))
11275e: 4290 cmp r0, r2
112760: d103 bne.n 11276a <rtems_rfs_file_get_shared+0x12>
112762: e006 b.n 112772 <rtems_rfs_file_get_shared+0x1a>
return the_node->next;
112764: 6800 ldr r0, [r0, #0] <== NOT EXECUTED
112766: 4290 cmp r0, r2 <== NOT EXECUTED
112768: d003 beq.n 112772 <rtems_rfs_file_get_shared+0x1a> <== NOT EXECUTED
if (shared->inode.ino == ino)
11276a: 6943 ldr r3, [r0, #20]
11276c: 428b cmp r3, r1
11276e: d1f9 bne.n 112764 <rtems_rfs_file_get_shared+0xc> <== ALWAYS TAKEN
return shared;
node = rtems_chain_next (node);
}
return NULL;
}
112770: 4770 bx lr
return NULL;
112772: 2000 movs r0, #0
}
112774: 4770 bx lr
112776: bf00 nop
00112304 <rtems_rfs_file_io_end>:
{
112304: e92d 47f0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, lr}
112308: 4604 mov r4, r0
11230a: b082 sub sp, #8
11230c: 460d mov r5, r1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
11230e: 2000 movs r0, #0
112310: 2120 movs r1, #32
{
112312: 4617 mov r7, r2
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
112314: f7f8 fb32 bl 10a97c <rtems_rfs_trace>
112318: b188 cbz r0, 11233e <rtems_rfs_file_io_end+0x3a>
printf ("rtems-rfs: file-io: end: %s size=%zu\n",
11231a: f249 7108 movw r1, #38664 ; 0x9708 <== NOT EXECUTED
11231e: f24b 6358 movw r3, #46680 ; 0xb658 <== NOT EXECUTED
112322: f2c0 0111 movt r1, #17 <== NOT EXECUTED
112326: f2c0 0311 movt r3, #17 <== NOT EXECUTED
11232a: f24b 7014 movw r0, #46868 ; 0xb714 <== NOT EXECUTED
11232e: 2f00 cmp r7, #0 <== NOT EXECUTED
112330: bf08 it eq <== NOT EXECUTED
112332: 4619 moveq r1, r3 <== NOT EXECUTED
112334: f2c0 0011 movt r0, #17 <== NOT EXECUTED
112338: 462a mov r2, r5 <== NOT EXECUTED
11233a: f7f3 fbed bl 105b18 <__wrap_printf> <== NOT EXECUTED
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
11233e: 68e6 ldr r6, [r4, #12]
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
112340: 69e3 ldr r3, [r4, #28]
112342: f8d3 0098 ldr.w r0, [r3, #152] ; 0x98
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
112346: 2e00 cmp r6, #0
112348: f000 808f beq.w 11246a <rtems_rfs_file_io_end+0x166> <== ALWAYS TAKEN
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
11234c: 1d21 adds r1, r4, #4
if (!read)
11234e: 2f00 cmp r7, #0
112350: d164 bne.n 11241c <rtems_rfs_file_io_end+0x118>
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
112352: f04f 0801 mov.w r8, #1
112356: f884 8004 strb.w r8, [r4, #4]
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
11235a: f7f6 fa0b bl 108774 <rtems_rfs_buffer_handle_release>
if (rc > 0)
11235e: 1e06 subs r6, r0, #0
printf (
112360: bfc4 itt gt
112362: f24b 6458 movwgt r4, #46680 ; 0xb658
112366: f2c0 0411 movtgt r4, #17
if (rc > 0)
11236a: f300 808b bgt.w 112484 <rtems_rfs_file_io_end+0x180> <== ALWAYS TAKEN
handle->bpos.boff += size;
11236e: 6962 ldr r2, [r4, #20]
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
112370: 69e3 ldr r3, [r4, #28]
handle->bpos.boff += size;
112372: 4415 add r5, r2
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
112374: f8d3 2098 ldr.w r2, [r3, #152] ; 0x98
handle->bpos.boff += size;
112378: 6165 str r5, [r4, #20]
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
11237a: 6892 ldr r2, [r2, #8]
if (handle->bpos.boff >=
11237c: 42aa cmp r2, r5
11237e: d806 bhi.n 11238e <rtems_rfs_file_io_end+0x8a>
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
112380: 1aad subs r5, r5, r2
handle->bpos.bno++;
112382: 6922 ldr r2, [r4, #16]
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
112384: 6165 str r5, [r4, #20]
handle->bpos.bno++;
112386: 3201 adds r2, #1
112388: 6122 str r2, [r4, #16]
if (!read &&
11238a: 2f00 cmp r7, #0
11238c: d16a bne.n 112464 <rtems_rfs_file_io_end+0x160>
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
11238e: 6921 ldr r1, [r4, #16]
112390: 6bda ldr r2, [r3, #60] ; 0x3c
if (!read &&
112392: 2900 cmp r1, #0
112394: d061 beq.n 11245a <rtems_rfs_file_io_end+0x156>
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
112396: 2a00 cmp r2, #0
112398: d15f bne.n 11245a <rtems_rfs_file_io_end+0x156> <== NEVER TAKEN
11239a: 6962 ldr r2, [r4, #20]
map->dirty = true;
11239c: f04f 0901 mov.w r9, #1
map->size.offset = offset;
1123a0: 641a str r2, [r3, #64] ; 0x40
map->dirty = true;
1123a2: f883 9034 strb.w r9, [r3, #52] ; 0x34
atime = rtems_rfs_file_update_atime (handle);
1123a6: 6825 ldr r5, [r4, #0]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
1123a8: 2000 movs r0, #0
1123aa: 2120 movs r1, #32
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
1123ac: f085 0202 eor.w r2, r5, #2
1123b0: f3c2 0240 ubfx r2, r2, #1, #1
1123b4: ea08 0802 and.w r8, r8, r2
length = rtems_rfs_file_update_length (handle) && length;
1123b8: f085 0204 eor.w r2, r5, #4
atime = rtems_rfs_file_update_atime (handle);
1123bc: f005 0501 and.w r5, r5, #1
length = rtems_rfs_file_update_length (handle) && length;
1123c0: ea09 0992 and.w r9, r9, r2, lsr #2
1123c4: f085 0a01 eor.w sl, r5, #1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
1123c8: f7f8 fad8 bl 10a97c <rtems_rfs_trace>
1123cc: b1b8 cbz r0, 1123fe <rtems_rfs_file_io_end+0xfa>
printf ("rtems-rfs: file-io: end: pos=%" PRIu32 ":%" PRIu32 " %c %c %c\n",
1123ce: 2d00 cmp r5, #0 <== NOT EXECUTED
1123d0: f24b 7080 movw r0, #46976 ; 0xb780 <== NOT EXECUTED
1123d4: bf0c ite eq <== NOT EXECUTED
1123d6: 2341 moveq r3, #65 ; 0x41 <== NOT EXECUTED
1123d8: 232d movne r3, #45 ; 0x2d <== NOT EXECUTED
1123da: f1b8 0f00 cmp.w r8, #0 <== NOT EXECUTED
1123de: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1123e2: bf14 ite ne <== NOT EXECUTED
1123e4: 224d movne r2, #77 ; 0x4d <== NOT EXECUTED
1123e6: 222d moveq r2, #45 ; 0x2d <== NOT EXECUTED
1123e8: f1b9 0f00 cmp.w r9, #0 <== NOT EXECUTED
1123ec: 9200 str r2, [sp, #0] <== NOT EXECUTED
1123ee: bf14 ite ne <== NOT EXECUTED
1123f0: 224c movne r2, #76 ; 0x4c <== NOT EXECUTED
1123f2: 222d moveq r2, #45 ; 0x2d <== NOT EXECUTED
1123f4: 9201 str r2, [sp, #4] <== NOT EXECUTED
1123f6: e9d4 1204 ldrd r1, r2, [r4, #16] <== NOT EXECUTED
1123fa: f7f3 fb8d bl 105b18 <__wrap_printf> <== NOT EXECUTED
if (atime || mtime)
1123fe: ea5a 0308 orrs.w r3, sl, r8
112402: d11d bne.n 112440 <rtems_rfs_file_io_end+0x13c> <== NEVER TAKEN
if (length)
112404: f1b9 0f00 cmp.w r9, #0
112408: d004 beq.n 112414 <rtems_rfs_file_io_end+0x110>
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
11240a: 69e3 ldr r3, [r4, #28]
handle->shared->size.offset =
11240c: e9d3 120f ldrd r1, r2, [r3, #60] ; 0x3c
112410: e9c3 1221 strd r1, r2, [r3, #132] ; 0x84
}
112414: 4630 mov r0, r6
112416: b002 add sp, #8
112418: e8bd 87f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, pc}
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
11241c: f7f6 f9aa bl 108774 <rtems_rfs_buffer_handle_release>
if (rc > 0)
112420: 1e06 subs r6, r0, #0
112422: dc2b bgt.n 11247c <rtems_rfs_file_io_end+0x178> <== ALWAYS TAKEN
handle->bpos.boff += size;
112424: 6963 ldr r3, [r4, #20]
if (handle->bpos.boff >=
112426: f04f 0800 mov.w r8, #0
handle->bpos.boff += size;
11242a: 441d add r5, r3
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
11242c: 69e3 ldr r3, [r4, #28]
handle->bpos.boff += size;
11242e: 6165 str r5, [r4, #20]
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
112430: f8d3 2098 ldr.w r2, [r3, #152] ; 0x98
112434: 6892 ldr r2, [r2, #8]
if (handle->bpos.boff >=
112436: 4295 cmp r5, r2
length = false;
112438: bf38 it cc
11243a: 46c1 movcc r9, r8
if (handle->bpos.boff >=
11243c: d3b3 bcc.n 1123a6 <rtems_rfs_file_io_end+0xa2>
11243e: e79f b.n 112380 <rtems_rfs_file_io_end+0x7c>
time_t now = time (NULL);
112440: 2000 movs r0, #0
112442: f005 fb33 bl 117aac <time>
if (read && atime)
112446: ea17 0f0a tst.w r7, sl
11244a: d12d bne.n 1124a8 <rtems_rfs_file_io_end+0x1a4>
if (!read && mtime)
11244c: f1b8 0f00 cmp.w r8, #0
112450: d0d8 beq.n 112404 <rtems_rfs_file_io_end+0x100> <== ALWAYS TAKEN
handle->shared->mtime = now;
112452: 69e3 ldr r3, [r4, #28]
112454: f8c3 0090 str.w r0, [r3, #144] ; 0x90
112458: e7d4 b.n 112404 <rtems_rfs_file_io_end+0x100>
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
11245a: 4291 cmp r1, r2
11245c: d29d bcs.n 11239a <rtems_rfs_file_io_end+0x96>
11245e: 3a01 subs r2, #1
112460: 4291 cmp r1, r2
112462: d025 beq.n 1124b0 <rtems_rfs_file_io_end+0x1ac>
length = false;
112464: f04f 0900 mov.w r9, #0
112468: e79d b.n 1123a6 <rtems_rfs_file_io_end+0xa2>
handle->bpos.boff += size;
11246a: 6961 ldr r1, [r4, #20] <== NOT EXECUTED
mtime = !read;
11246c: f087 0801 eor.w r8, r7, #1 <== NOT EXECUTED
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
112470: 6882 ldr r2, [r0, #8] <== NOT EXECUTED
handle->bpos.boff += size;
112472: 440d add r5, r1 <== NOT EXECUTED
if (handle->bpos.boff >=
112474: 4295 cmp r5, r2 <== NOT EXECUTED
handle->bpos.boff += size;
112476: 6165 str r5, [r4, #20] <== NOT EXECUTED
if (handle->bpos.boff >=
112478: d387 bcc.n 11238a <rtems_rfs_file_io_end+0x86> <== NOT EXECUTED
11247a: e781 b.n 112380 <rtems_rfs_file_io_end+0x7c> <== NOT EXECUTED
printf (
11247c: f249 7408 movw r4, #38664 ; 0x9708 <== NOT EXECUTED
112480: f2c0 0411 movt r4, #17 <== NOT EXECUTED
112484: 4630 mov r0, r6 <== NOT EXECUTED
112486: f005 f973 bl 117770 <strerror> <== NOT EXECUTED
11248a: 4607 mov r7, r0 <== NOT EXECUTED
11248c: f24b 703c movw r0, #46908 ; 0xb73c <== NOT EXECUTED
112490: 4633 mov r3, r6 <== NOT EXECUTED
112492: 462a mov r2, r5 <== NOT EXECUTED
112494: 4621 mov r1, r4 <== NOT EXECUTED
112496: 9700 str r7, [sp, #0] <== NOT EXECUTED
112498: f2c0 0011 movt r0, #17 <== NOT EXECUTED
11249c: f7f3 fb3c bl 105b18 <__wrap_printf> <== NOT EXECUTED
}
1124a0: 4630 mov r0, r6 <== NOT EXECUTED
1124a2: b002 add sp, #8 <== NOT EXECUTED
1124a4: e8bd 87f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
handle->shared->atime = now;
1124a8: 69e3 ldr r3, [r4, #28]
1124aa: f8c3 008c str.w r0, [r3, #140] ; 0x8c
if (!read && mtime)
1124ae: e7a9 b.n 112404 <rtems_rfs_file_io_end+0x100>
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
1124b0: 6962 ldr r2, [r4, #20]
1124b2: 6c19 ldr r1, [r3, #64] ; 0x40
1124b4: 428a cmp r2, r1
1124b6: d9d5 bls.n 112464 <rtems_rfs_file_io_end+0x160>
1124b8: e770 b.n 11239c <rtems_rfs_file_io_end+0x98>
1124ba: bf00 nop
00112184 <rtems_rfs_file_io_start>:
{
112184: e92d 41f0 stmdb sp!, {r4, r5, r6, r7, r8, lr}
112188: 4604 mov r4, r0
11218a: b082 sub sp, #8
11218c: 460d mov r5, r1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
11218e: 2000 movs r0, #0
112190: 2120 movs r1, #32
{
112192: 4616 mov r6, r2
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
112194: f7f8 fbf2 bl 10a97c <rtems_rfs_trace>
112198: b190 cbz r0, 1121c0 <rtems_rfs_file_io_start+0x3c>
printf ("rtems-rfs: file-io: start: %s pos=%" PRIu32 ":%" PRIu32 "\n",
11219a: f249 7108 movw r1, #38664 ; 0x9708 <== NOT EXECUTED
11219e: f24b 6358 movw r3, #46680 ; 0xb658 <== NOT EXECUTED
1121a2: f2c0 0311 movt r3, #17 <== NOT EXECUTED
1121a6: f2c0 0111 movt r1, #17 <== NOT EXECUTED
1121aa: f24b 6060 movw r0, #46688 ; 0xb660 <== NOT EXECUTED
1121ae: 2e00 cmp r6, #0 <== NOT EXECUTED
1121b0: bf08 it eq <== NOT EXECUTED
1121b2: 4619 moveq r1, r3 <== NOT EXECUTED
1121b4: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1121b8: e9d4 2304 ldrd r2, r3, [r4, #16] <== NOT EXECUTED
1121bc: f7f3 fcac bl 105b18 <__wrap_printf> <== NOT EXECUTED
if (!rtems_rfs_buffer_handle_has_block (&handle->buffer))
1121c0: 68e7 ldr r7, [r4, #12]
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
1121c2: 69e1 ldr r1, [r4, #28]
if (!rtems_rfs_buffer_handle_has_block (&handle->buffer))
1121c4: b33f cbz r7, 112216 <rtems_rfs_file_io_start+0x92>
if (read
1121c6: b96e cbnz r6, 1121e4 <rtems_rfs_file_io_start+0x60>
size = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
1121c8: f8d1 3098 ldr.w r3, [r1, #152] ; 0x98
1121cc: 689e ldr r6, [r3, #8]
*available = size - rtems_rfs_file_block_offset (handle);
1121ce: 6963 ldr r3, [r4, #20]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
1121d0: 2000 movs r0, #0
1121d2: 2120 movs r1, #32
*available = size - rtems_rfs_file_block_offset (handle);
1121d4: 1af3 subs r3, r6, r3
1121d6: 602b str r3, [r5, #0]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
1121d8: f7f8 fbd0 bl 10a97c <rtems_rfs_trace>
1121dc: b978 cbnz r0, 1121fe <rtems_rfs_file_io_start+0x7a>
}
1121de: b002 add sp, #8
1121e0: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
&& rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
1121e4: 6c4a ldr r2, [r1, #68] ; 0x44
1121e6: 6bcb ldr r3, [r1, #60] ; 0x3c
1121e8: ea52 0003 orrs.w r0, r2, r3
1121ec: d103 bne.n 1121f6 <rtems_rfs_file_io_start+0x72> <== NEVER TAKEN
&& rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle)))
1121ee: 6c0e ldr r6, [r1, #64] ; 0x40
1121f0: 2e00 cmp r6, #0
1121f2: d1ec bne.n 1121ce <rtems_rfs_file_io_start+0x4a>
1121f4: e7e8 b.n 1121c8 <rtems_rfs_file_io_start+0x44>
&& rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
1121f6: 3b01 subs r3, #1
1121f8: 429a cmp r2, r3
1121fa: d1e5 bne.n 1121c8 <rtems_rfs_file_io_start+0x44>
1121fc: e7f7 b.n 1121ee <rtems_rfs_file_io_start+0x6a>
printf ("rtems-rfs: file-io: start: available=%zu (%zu)\n",
1121fe: f24b 60e4 movw r0, #46820 ; 0xb6e4 <== NOT EXECUTED
112202: 6829 ldr r1, [r5, #0] <== NOT EXECUTED
112204: 4632 mov r2, r6 <== NOT EXECUTED
112206: f2c0 0011 movt r0, #17 <== NOT EXECUTED
11220a: f7f3 fc85 bl 105b18 <__wrap_printf> <== NOT EXECUTED
return 0;
11220e: 2000 movs r0, #0 <== NOT EXECUTED
}
112210: b002 add sp, #8 <== NOT EXECUTED
112212: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
112216: f8d1 0098 ldr.w r0, [r1, #152] ; 0x98
11221a: ab01 add r3, sp, #4
11221c: 3134 adds r1, #52 ; 0x34
11221e: f104 0210 add.w r2, r4, #16
112222: f7fe fc25 bl 110a70 <rtems_rfs_block_map_find>
if (rc > 0)
112226: 2800 cmp r0, #0
112228: dd26 ble.n 112278 <rtems_rfs_file_io_start+0xf4>
if (read && (rc == ENXIO))
11222a: 2806 cmp r0, #6
11222c: bf14 ite ne
11222e: f04f 0800 movne.w r8, #0
112232: f006 0801 andeq.w r8, r6, #1
112236: f1b8 0f00 cmp.w r8, #0
11223a: d153 bne.n 1122e4 <rtems_rfs_file_io_start+0x160> <== ALWAYS TAKEN
if (rc != ENXIO)
11223c: 2806 cmp r0, #6
11223e: d1ce bne.n 1121de <rtems_rfs_file_io_start+0x5a> <== ALWAYS TAKEN
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
112240: 2000 movs r0, #0
112242: 2120 movs r1, #32
112244: f7f8 fb9a bl 10a97c <rtems_rfs_trace>
112248: 2800 cmp r0, #0
11224a: d154 bne.n 1122f6 <rtems_rfs_file_io_start+0x172> <== ALWAYS TAKEN
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
11224c: 69e1 ldr r1, [r4, #28]
11224e: ab01 add r3, sp, #4
112250: 2201 movs r2, #1
112252: f8d1 0098 ldr.w r0, [r1, #152] ; 0x98
112256: 3134 adds r1, #52 ; 0x34
112258: f7fe fc9e bl 110b98 <rtems_rfs_block_map_grow>
if (rc > 0)
11225c: 2800 cmp r0, #0
11225e: dcbe bgt.n 1121de <rtems_rfs_file_io_start+0x5a>
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
112260: 2000 movs r0, #0
112262: 2120 movs r1, #32
112264: f7f8 fb8a bl 10a97c <rtems_rfs_trace>
112268: 2800 cmp r0, #0
11226a: d041 beq.n 1122f0 <rtems_rfs_file_io_start+0x16c> <== NEVER TAKEN
printf ("rtems-rfs: file-io: start: block=%" PRIu32 " request-read=%s\n",
11226c: f24a 42e4 movw r2, #42212 ; 0xa4e4 <== NOT EXECUTED
112270: 9901 ldr r1, [sp, #4] <== NOT EXECUTED
112272: f2c0 0211 movt r2, #17 <== NOT EXECUTED
112276: e00b b.n 112290 <rtems_rfs_file_io_start+0x10c> <== NOT EXECUTED
if (!read &&
112278: b1f6 cbz r6, 1122b8 <rtems_rfs_file_io_start+0x134>
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
11227a: 2000 movs r0, #0
11227c: 2120 movs r1, #32
11227e: f7f8 fb7d bl 10a97c <rtems_rfs_trace>
112282: 4680 mov r8, r0
112284: b388 cbz r0, 1122ea <rtems_rfs_file_io_start+0x166>
printf ("rtems-rfs: file-io: start: block=%" PRIu32 " request-read=%s\n",
112286: 9901 ldr r1, [sp, #4] <== NOT EXECUTED
112288: f24a 42e0 movw r2, #42208 ; 0xa4e0 <== NOT EXECUTED
11228c: f2c0 0211 movt r2, #17 <== NOT EXECUTED
112290: f24b 60ac movw r0, #46764 ; 0xb6ac <== NOT EXECUTED
112294: f2c0 0011 movt r0, #17 <== NOT EXECUTED
112298: f7f3 fc3e bl 105b18 <__wrap_printf> <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
11229c: 69e2 ldr r2, [r4, #28]
11229e: 4643 mov r3, r8
1122a0: 1d21 adds r1, r4, #4
1122a2: f8d2 0098 ldr.w r0, [r2, #152] ; 0x98
1122a6: 9a01 ldr r2, [sp, #4]
1122a8: f7f6 f978 bl 10859c <rtems_rfs_buffer_handle_request>
if (rc > 0)
1122ac: 2800 cmp r0, #0
1122ae: dc96 bgt.n 1121de <rtems_rfs_file_io_start+0x5a> <== ALWAYS TAKEN
&& rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
1122b0: 69e1 ldr r1, [r4, #28]
if (read
1122b2: 2e00 cmp r6, #0
1122b4: d088 beq.n 1121c8 <rtems_rfs_file_io_start+0x44>
1122b6: e795 b.n 1121e4 <rtems_rfs_file_io_start+0x60>
if (!read &&
1122b8: 6963 ldr r3, [r4, #20]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
1122ba: 2000 movs r0, #0
1122bc: 2120 movs r1, #32
if (!read &&
1122be: 2b00 cmp r3, #0
1122c0: d1dd bne.n 11227e <rtems_rfs_file_io_start+0xfa>
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
1122c2: 69e3 ldr r3, [r4, #28]
(rtems_rfs_file_block_offset (handle) ||
1122c4: 682a ldr r2, [r5, #0]
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
1122c6: f8d3 3098 ldr.w r3, [r3, #152] ; 0x98
(rtems_rfs_file_block_offset (handle) ||
1122ca: 689b ldr r3, [r3, #8]
1122cc: 429a cmp r2, r3
1122ce: d3d6 bcc.n 11227e <rtems_rfs_file_io_start+0xfa> <== NEVER TAKEN
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
1122d0: f7f8 fb54 bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
1122d4: b160 cbz r0, 1122f0 <rtems_rfs_file_io_start+0x16c> <== NOT EXECUTED
printf ("rtems-rfs: file-io: start: block=%" PRIu32 " request-read=%s\n",
1122d6: f24a 42e4 movw r2, #42212 ; 0xa4e4 <== NOT EXECUTED
1122da: 9901 ldr r1, [sp, #4] <== NOT EXECUTED
1122dc: 46b0 mov r8, r6 <== NOT EXECUTED
1122de: f2c0 0211 movt r2, #17 <== NOT EXECUTED
1122e2: e7d5 b.n 112290 <rtems_rfs_file_io_start+0x10c> <== NOT EXECUTED
return 0;
1122e4: 4638 mov r0, r7 <== NOT EXECUTED
*available = 0;
1122e6: 602f str r7, [r5, #0] <== NOT EXECUTED
return 0;
1122e8: e779 b.n 1121de <rtems_rfs_file_io_start+0x5a> <== NOT EXECUTED
request_read = true;
1122ea: f04f 0801 mov.w r8, #1
1122ee: e7d5 b.n 11229c <rtems_rfs_file_io_start+0x118>
request_read = false;
1122f0: f04f 0800 mov.w r8, #0
1122f4: e7d2 b.n 11229c <rtems_rfs_file_io_start+0x118>
printf ("rtems-rfs: file-io: start: grow\n");
1122f6: f24b 608c movw r0, #46732 ; 0xb68c <== NOT EXECUTED
1122fa: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1122fe: f7f3 fc1d bl 105b3c <__wrap_puts> <== NOT EXECUTED
112302: e7a3 b.n 11224c <rtems_rfs_file_io_start+0xc8> <== NOT EXECUTED
00111dbc <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)
{
111dbc: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
111dc0: 4680 mov r8, r0
111dc2: b083 sub sp, #12
111dc4: 460d mov r5, r1
rtems_rfs_file_handle* handle;
rtems_rfs_file_shared* shared;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
111dc6: 2000 movs r0, #0
111dc8: 2108 movs r1, #8
{
111dca: 4692 mov sl, r2
111dcc: 4699 mov r9, r3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
111dce: f7f8 fdd5 bl 10a97c <rtems_rfs_trace>
111dd2: bb88 cbnz r0, 111e38 <rtems_rfs_file_open+0x7c>
printf ("rtems-rfs: file-open: ino=%" PRId32 "\n", ino);
*file = NULL;
111dd4: 2300 movs r3, #0
/*
* 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));
111dd6: 2101 movs r1, #1
111dd8: 2020 movs r0, #32
*file = NULL;
111dda: f8c9 3000 str.w r3, [r9]
handle = malloc (sizeof (rtems_rfs_file_handle));
111dde: f7fd fe7b bl 10fad8 <calloc>
if (!handle)
111de2: 4607 mov r7, r0
111de4: 2800 cmp r0, #0
111de6: f000 80c1 beq.w 111f6c <rtems_rfs_file_open+0x1b0> <== ALWAYS TAKEN
return _Chain_Immutable_head( the_chain )->next;
111dea: f8d8 4074 ldr.w r4, [r8, #116] ; 0x74
return &the_chain->Tail.Node;
111dee: f108 0678 add.w r6, r8, #120 ; 0x78
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))
111df2: 42b4 cmp r4, r6
111df4: d103 bne.n 111dfe <rtems_rfs_file_open+0x42> <== ALWAYS TAKEN
111df6: e027 b.n 111e48 <rtems_rfs_file_open+0x8c>
return the_node->next;
111df8: 6824 ldr r4, [r4, #0] <== NOT EXECUTED
111dfa: 42b4 cmp r4, r6 <== NOT EXECUTED
111dfc: d024 beq.n 111e48 <rtems_rfs_file_open+0x8c> <== NOT EXECUTED
{
rtems_rfs_file_shared* shared;
shared = (rtems_rfs_file_shared*) node;
if (shared->inode.ino == ino)
111dfe: 6963 ldr r3, [r4, #20] <== NOT EXECUTED
111e00: 429d cmp r5, r3 <== NOT EXECUTED
111e02: d1f9 bne.n 111df8 <rtems_rfs_file_open+0x3c> <== NOT EXECUTED
shared->references++;
111e04: 68a3 ldr r3, [r4, #8] <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
111e06: 2000 movs r0, #0 <== NOT EXECUTED
111e08: 2108 movs r1, #8 <== NOT EXECUTED
shared->references++;
111e0a: 3301 adds r3, #1 <== NOT EXECUTED
111e0c: 60a3 str r3, [r4, #8] <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
111e0e: f7f8 fdb5 bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
111e12: b948 cbnz r0, 111e28 <rtems_rfs_file_open+0x6c> <== NOT EXECUTED
return 0;
111e14: 2300 movs r3, #0
handle->flags = oflag;
111e16: f8c7 a000 str.w sl, [r7]
handle->shared = shared;
111e1a: 61fc str r4, [r7, #28]
*file = handle;
111e1c: f8c9 7000 str.w r7, [r9]
}
111e20: 4618 mov r0, r3
111e22: b003 add sp, #12
111e24: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
printf ("rtems-rfs: file-open: ino=%" PRId32 " shared\n", ino);
111e28: f24b 40d4 movw r0, #46292 ; 0xb4d4 <== NOT EXECUTED
111e2c: 4629 mov r1, r5 <== NOT EXECUTED
111e2e: f2c0 0011 movt r0, #17 <== NOT EXECUTED
111e32: f7f3 fe71 bl 105b18 <__wrap_printf> <== NOT EXECUTED
111e36: e7ed b.n 111e14 <rtems_rfs_file_open+0x58> <== NOT EXECUTED
printf ("rtems-rfs: file-open: ino=%" PRId32 "\n", ino);
111e38: f24b 40b4 movw r0, #46260 ; 0xb4b4 <== NOT EXECUTED
111e3c: 4629 mov r1, r5 <== NOT EXECUTED
111e3e: f2c0 0011 movt r0, #17 <== NOT EXECUTED
111e42: f7f3 fe69 bl 105b18 <__wrap_printf> <== NOT EXECUTED
111e46: e7c5 b.n 111dd4 <rtems_rfs_file_open+0x18> <== NOT EXECUTED
shared = malloc (sizeof (rtems_rfs_file_shared));
111e48: 2101 movs r1, #1
111e4a: 209c movs r0, #156 ; 0x9c
111e4c: f7fd fe44 bl 10fad8 <calloc>
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
111e50: 1d3b adds r3, r7, #4
if (!shared)
111e52: 4604 mov r4, r0
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
111e54: 9301 str r3, [sp, #4]
if (!shared)
111e56: 2800 cmp r0, #0
111e58: f000 808a beq.w 111f70 <rtems_rfs_file_open+0x1b4> <== ALWAYS TAKEN
rc = rtems_rfs_inode_open (fs, ino, &shared->inode, true);
111e5c: f104 0b0c add.w fp, r4, #12
111e60: 2301 movs r3, #1
111e62: 465a mov r2, fp
111e64: 4629 mov r1, r5
111e66: 4640 mov r0, r8
111e68: f7f7 fd70 bl 10994c <rtems_rfs_inode_open>
if (rc > 0)
111e6c: 1e03 subs r3, r0, #0
111e6e: 9301 str r3, [sp, #4]
111e70: dc3e bgt.n 111ef0 <rtems_rfs_file_open+0x134> <== ALWAYS TAKEN
rc = rtems_rfs_block_map_open (fs, &shared->inode, &shared->map);
111e72: f104 0234 add.w r2, r4, #52 ; 0x34
111e76: 4659 mov r1, fp
111e78: 4640 mov r0, r8
111e7a: f7fe fd07 bl 11088c <rtems_rfs_block_map_open>
if (rc > 0)
111e7e: 1e03 subs r3, r0, #0
111e80: 9301 str r3, [sp, #4]
111e82: dc4b bgt.n 111f1c <rtems_rfs_file_open+0x160> <== ALWAYS TAKEN
shared->references = 1;
111e84: 69a2 ldr r2, [r4, #24]
111e86: 2301 movs r3, #1
111e88: 60a3 str r3, [r4, #8]
rtems_rfs_inode_unload (fs, &shared->inode, false);
111e8a: 4659 mov r1, fp
old_last = tail->previous;
111e8c: f8d8 c07c ldr.w ip, [r8, #124] ; 0x7c
111e90: 4640 mov r0, r8
111e92: 68d3 ldr r3, [r2, #12]
111e94: ba1b rev r3, r3
shared->size.count = rtems_rfs_inode_get_block_count (&shared->inode);
111e96: f8c4 3084 str.w r3, [r4, #132] ; 0x84
shared->size.offset = rtems_rfs_inode_get_block_offset (&shared->inode);
111e9a: 8953 ldrh r3, [r2, #10]
111e9c: ba5b rev16 r3, r3
111e9e: b29b uxth r3, r3
111ea0: f8c4 3088 str.w r3, [r4, #136] ; 0x88
return rtems_rfs_read_u32 (&handle->node->atime);
111ea4: 6913 ldr r3, [r2, #16]
111ea6: ba1b rev r3, r3
shared->atime = rtems_rfs_inode_get_atime (&shared->inode);
111ea8: f8c4 308c str.w r3, [r4, #140] ; 0x8c
return rtems_rfs_read_u32 (&handle->node->mtime);
111eac: 6953 ldr r3, [r2, #20]
111eae: ba1b rev r3, r3
shared->mtime = rtems_rfs_inode_get_mtime (&shared->inode);
111eb0: f8c4 3090 str.w r3, [r4, #144] ; 0x90
return rtems_rfs_read_u32 (&handle->node->ctime);
111eb4: 6993 ldr r3, [r2, #24]
rtems_rfs_inode_unload (fs, &shared->inode, false);
111eb6: 2200 movs r2, #0
the_node->next = tail;
111eb8: 6026 str r6, [r4, #0]
shared->fs = fs;
111eba: f8c4 8098 str.w r8, [r4, #152] ; 0x98
111ebe: ba1b rev r3, r3
tail->previous = the_node;
111ec0: f8c8 407c str.w r4, [r8, #124] ; 0x7c
shared->ctime = rtems_rfs_inode_get_ctime (&shared->inode);
111ec4: f8c4 3094 str.w r3, [r4, #148] ; 0x94
old_last->next = the_node;
111ec8: f8cc 4000 str.w r4, [ip]
the_node->previous = old_last;
111ecc: f8c4 c004 str.w ip, [r4, #4]
rtems_rfs_inode_unload (fs, &shared->inode, false);
111ed0: f7f7 fd80 bl 1099d4 <rtems_rfs_inode_unload>
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
111ed4: 2000 movs r0, #0
111ed6: 2108 movs r1, #8
111ed8: f7f8 fd50 bl 10a97c <rtems_rfs_trace>
111edc: 2800 cmp r0, #0
111ede: d099 beq.n 111e14 <rtems_rfs_file_open+0x58> <== NEVER TAKEN
printf ("rtems-rfs: file-open: ino=%" PRId32 " share created\n", ino);
111ee0: f24b 5068 movw r0, #46440 ; 0xb568 <== NOT EXECUTED
111ee4: 4629 mov r1, r5 <== NOT EXECUTED
111ee6: f2c0 0011 movt r0, #17 <== NOT EXECUTED
111eea: f7f3 fe15 bl 105b18 <__wrap_printf> <== NOT EXECUTED
111eee: e791 b.n 111e14 <rtems_rfs_file_open+0x58> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
111ef0: 2000 movs r0, #0 <== NOT EXECUTED
111ef2: 2108 movs r1, #8 <== NOT EXECUTED
111ef4: f7f8 fd42 bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
111ef8: 9b01 ldr r3, [sp, #4] <== NOT EXECUTED
111efa: bb48 cbnz r0, 111f50 <rtems_rfs_file_open+0x194> <== NOT EXECUTED
111efc: 9301 str r3, [sp, #4] <== NOT EXECUTED
free (shared);
111efe: 4620 mov r0, r4 <== NOT EXECUTED
111f00: f7f3 ff06 bl 105d10 <free> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
111f04: 1d39 adds r1, r7, #4 <== NOT EXECUTED
111f06: 4640 mov r0, r8 <== NOT EXECUTED
111f08: f7f6 fc34 bl 108774 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
free (handle);
111f0c: 4638 mov r0, r7 <== NOT EXECUTED
111f0e: f7f3 feff bl 105d10 <free> <== NOT EXECUTED
return rc;
111f12: 9b01 ldr r3, [sp, #4] <== NOT EXECUTED
}
111f14: 4618 mov r0, r3 <== NOT EXECUTED
111f16: b003 add sp, #12 <== NOT EXECUTED
111f18: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
111f1c: 2000 movs r0, #0 <== NOT EXECUTED
111f1e: 2108 movs r1, #8 <== NOT EXECUTED
111f20: f7f8 fd2c bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
111f24: 9b01 ldr r3, [sp, #4] <== NOT EXECUTED
111f26: b928 cbnz r0, 111f34 <rtems_rfs_file_open+0x178> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &shared->inode);
111f28: 4659 mov r1, fp <== NOT EXECUTED
111f2a: 4640 mov r0, r8 <== NOT EXECUTED
111f2c: 9301 str r3, [sp, #4] <== NOT EXECUTED
111f2e: f7f7 fd95 bl 109a5c <rtems_rfs_inode_close> <== NOT EXECUTED
111f32: e7e4 b.n 111efe <rtems_rfs_file_open+0x142> <== NOT EXECUTED
printf ("rtems-rfs: file-open: block map open failed: %d: %s\n",
111f34: 4618 mov r0, r3 <== NOT EXECUTED
111f36: f005 fc1b bl 117770 <strerror> <== NOT EXECUTED
111f3a: 9b01 ldr r3, [sp, #4] <== NOT EXECUTED
111f3c: 4602 mov r2, r0 <== NOT EXECUTED
111f3e: f24b 5030 movw r0, #46384 ; 0xb530 <== NOT EXECUTED
111f42: f2c0 0011 movt r0, #17 <== NOT EXECUTED
111f46: 4619 mov r1, r3 <== NOT EXECUTED
111f48: f7f3 fde6 bl 105b18 <__wrap_printf> <== NOT EXECUTED
111f4c: 9b01 ldr r3, [sp, #4] <== NOT EXECUTED
111f4e: e7eb b.n 111f28 <rtems_rfs_file_open+0x16c> <== NOT EXECUTED
printf ("rtems-rfs: file-open: inode open failed: %d: %s\n",
111f50: 4618 mov r0, r3 <== NOT EXECUTED
111f52: f005 fc0d bl 117770 <strerror> <== NOT EXECUTED
111f56: 9b01 ldr r3, [sp, #4] <== NOT EXECUTED
111f58: 4602 mov r2, r0 <== NOT EXECUTED
111f5a: f24b 40fc movw r0, #46332 ; 0xb4fc <== NOT EXECUTED
111f5e: f2c0 0011 movt r0, #17 <== NOT EXECUTED
111f62: 4619 mov r1, r3 <== NOT EXECUTED
111f64: f7f3 fdd8 bl 105b18 <__wrap_printf> <== NOT EXECUTED
111f68: 9b01 ldr r3, [sp, #4] <== NOT EXECUTED
111f6a: e7c7 b.n 111efc <rtems_rfs_file_open+0x140> <== NOT EXECUTED
return ENOMEM;
111f6c: 230c movs r3, #12 <== NOT EXECUTED
111f6e: e757 b.n 111e20 <rtems_rfs_file_open+0x64> <== NOT EXECUTED
111f70: 1d39 adds r1, r7, #4 <== NOT EXECUTED
111f72: 4640 mov r0, r8 <== NOT EXECUTED
111f74: f7f6 fbfe bl 108774 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
return ENOMEM;
111f78: 230c movs r3, #12 <== NOT EXECUTED
free (handle);
111f7a: 4638 mov r0, r7 <== NOT EXECUTED
return ENOMEM;
111f7c: 9301 str r3, [sp, #4] <== NOT EXECUTED
free (handle);
111f7e: f7f3 fec7 bl 105d10 <free> <== NOT EXECUTED
return ENOMEM;
111f82: 9b01 ldr r3, [sp, #4] <== NOT EXECUTED
111f84: e74c b.n 111e20 <rtems_rfs_file_open+0x64> <== NOT EXECUTED
111f86: bf00 nop
001124bc <rtems_rfs_file_seek>:
{
1124bc: e92d 41f0 stmdb sp!, {r4, r5, r6, r7, r8, lr}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
1124c0: 2120 movs r1, #32
{
1124c2: b084 sub sp, #16
1124c4: 4604 mov r4, r0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
1124c6: 2000 movs r0, #0
{
1124c8: 4616 mov r6, r2
1124ca: 9f0a ldr r7, [sp, #40] ; 0x28
1124cc: 461d mov r5, r3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
1124ce: f7f8 fa55 bl 10a97c <rtems_rfs_trace>
1124d2: 2800 cmp r0, #0
1124d4: d136 bne.n 112544 <rtems_rfs_file_seek+0x88> <== ALWAYS TAKEN
if (pos <= rtems_rfs_file_shared_get_size (rtems_rfs_file_fs (handle),
1124d6: 69e1 ldr r1, [r4, #28]
1124d8: f8d1 0098 ldr.w r0, [r1, #152] ; 0x98
1124dc: 3184 adds r1, #132 ; 0x84
1124de: f7fe f9c5 bl 11086c <rtems_rfs_block_get_size>
1124e2: 42b0 cmp r0, r6
1124e4: eb71 0305 sbcs.w r3, r1, r5
1124e8: d20f bcs.n 11250a <rtems_rfs_file_seek+0x4e>
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
1124ea: 68e3 ldr r3, [r4, #12]
1124ec: b13b cbz r3, 1124fe <rtems_rfs_file_seek+0x42>
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
1124ee: 69e3 ldr r3, [r4, #28] <== NOT EXECUTED
1124f0: 1d21 adds r1, r4, #4 <== NOT EXECUTED
1124f2: f8d3 0098 ldr.w r0, [r3, #152] ; 0x98 <== NOT EXECUTED
1124f6: f7f6 f93d bl 108774 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
if (rc > 0)
1124fa: 2800 cmp r0, #0 <== NOT EXECUTED
1124fc: dc02 bgt.n 112504 <rtems_rfs_file_seek+0x48> <== NOT EXECUTED
return 0;
1124fe: 2000 movs r0, #0
*new_pos = pos;
112500: e9c7 6500 strd r6, r5, [r7]
}
112504: b004 add sp, #16
112506: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
rtems_rfs_file_set_bpos (handle, pos);
11250a: 69e3 ldr r3, [r4, #28]
11250c: f104 0810 add.w r8, r4, #16
112510: 4632 mov r2, r6
112512: f8d3 0098 ldr.w r0, [r3, #152] ; 0x98
112516: 462b mov r3, r5
112518: f8cd 8000 str.w r8, [sp]
11251c: f7fe f990 bl 110840 <rtems_rfs_block_get_bpos>
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
112520: 68e3 ldr r3, [r4, #12]
112522: 2b00 cmp r3, #0
112524: d0eb beq.n 1124fe <rtems_rfs_file_seek+0x42>
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
112526: 69e1 ldr r1, [r4, #28]
112528: 4642 mov r2, r8
11252a: ab03 add r3, sp, #12
11252c: f8d1 0098 ldr.w r0, [r1, #152] ; 0x98
112530: 3134 adds r1, #52 ; 0x34
112532: f7fe fa9d bl 110a70 <rtems_rfs_block_map_find>
if (rc > 0)
112536: 2800 cmp r0, #0
112538: dce4 bgt.n 112504 <rtems_rfs_file_seek+0x48> <== ALWAYS TAKEN
if (rtems_rfs_buffer_bnum (&handle->buffer) != block)
11253a: 68a2 ldr r2, [r4, #8]
11253c: 9b03 ldr r3, [sp, #12]
11253e: 429a cmp r2, r3
112540: d0dd beq.n 1124fe <rtems_rfs_file_seek+0x42> <== NEVER TAKEN
112542: e7d4 b.n 1124ee <rtems_rfs_file_seek+0x32> <== NOT EXECUTED
printf ("rtems-rfs: file-seek: new=%" PRIu64 "\n", pos);
112544: f24b 70b0 movw r0, #47024 ; 0xb7b0 <== NOT EXECUTED
112548: 4632 mov r2, r6 <== NOT EXECUTED
11254a: 462b mov r3, r5 <== NOT EXECUTED
11254c: f2c0 0011 movt r0, #17 <== NOT EXECUTED
112550: f7f3 fae2 bl 105b18 <__wrap_printf> <== NOT EXECUTED
112554: e7bf b.n 1124d6 <rtems_rfs_file_seek+0x1a> <== NOT EXECUTED
112556: bf00 nop
00112558 <rtems_rfs_file_set_size>:
{
112558: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
11255c: 2120 movs r1, #32
rtems_rfs_block_map* map = rtems_rfs_file_map (handle);
11255e: 69c5 ldr r5, [r0, #28]
{
112560: b087 sub sp, #28
112562: 4604 mov r4, r0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
112564: 2000 movs r0, #0
{
112566: 4691 mov r9, r2
112568: 469a mov sl, r3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
11256a: f7f8 fa07 bl 10a97c <rtems_rfs_trace>
11256e: 2800 cmp r0, #0
112570: f040 80a4 bne.w 1126bc <rtems_rfs_file_set_size+0x164> <== ALWAYS TAKEN
size = rtems_rfs_file_size (handle);
112574: 69e1 ldr r1, [r4, #28]
112576: f8d1 0098 ldr.w r0, [r1, #152] ; 0x98
11257a: 3184 adds r1, #132 ; 0x84
11257c: f7fe f976 bl 11086c <rtems_rfs_block_get_size>
if (size != new_size)
112580: 458a cmp sl, r1
112582: bf08 it eq
112584: 4581 cmpeq r9, r0
112586: f000 8084 beq.w 112692 <rtems_rfs_file_set_size+0x13a>
rc = rtems_rfs_block_map_free_all (rtems_rfs_file_fs (handle), map);
11258a: 69e3 ldr r3, [r4, #28]
rtems_rfs_block_map* map = rtems_rfs_file_map (handle);
11258c: f105 0834 add.w r8, r5, #52 ; 0x34
rc = rtems_rfs_block_map_free_all (rtems_rfs_file_fs (handle), map);
112590: f8d3 b098 ldr.w fp, [r3, #152] ; 0x98
112594: 9301 str r3, [sp, #4]
if (new_size == 0)
112596: ea59 030a orrs.w r3, r9, sl
11259a: d06e beq.n 11267a <rtems_rfs_file_set_size+0x122>
if (size < new_size)
11259c: 4548 cmp r0, r9
rtems_rfs_block_map_count (map) -
11259e: 6bef ldr r7, [r5, #60] ; 0x3c
if (size < new_size)
1125a0: eb71 030a sbcs.w r3, r1, sl
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
1125a4: f8db 6008 ldr.w r6, [fp, #8]
if (size < new_size)
1125a8: f080 8091 bcs.w 1126ce <rtems_rfs_file_set_size+0x176>
count = new_size - size;
1125ac: ebb9 0900 subs.w r9, r9, r0
read_block = false;
1125b0: f04f 0300 mov.w r3, #0
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
1125b4: 4658 mov r0, fp
count = new_size - size;
1125b6: eb6a 0a01 sbc.w sl, sl, r1
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
1125ba: 469b mov fp, r3
1125bc: e035 b.n 11262a <rtems_rfs_file_set_size+0xd2>
read_block = true;
1125be: f04f 0b01 mov.w fp, #1
length = count + bpos.boff;
1125c2: eb03 0609 add.w r6, r3, r9
1125c6: f04f 0301 mov.w r3, #1
map->size.offset = offset;
1125ca: 642e str r6, [r5, #64] ; 0x40
map->dirty = true;
1125cc: f885 3034 strb.w r3, [r5, #52] ; 0x34
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
1125d0: 69e3 ldr r3, [r4, #28]
1125d2: 1d27 adds r7, r4, #4
1125d4: 9a02 ldr r2, [sp, #8]
1125d6: 4639 mov r1, r7
1125d8: f8d3 0098 ldr.w r0, [r3, #152] ; 0x98
1125dc: 465b mov r3, fp
1125de: f7f5 ffdd bl 10859c <rtems_rfs_buffer_handle_request>
if (rc > 0)
1125e2: 2800 cmp r0, #0
1125e4: f300 80ae bgt.w 112744 <rtems_rfs_file_set_size+0x1ec> <== ALWAYS TAKEN
dst = rtems_rfs_buffer_data (&handle->buffer);
1125e8: 68e3 ldr r3, [r4, #12]
memset (dst + bpos.boff, 0, length - bpos.boff);
1125ea: 2100 movs r1, #0
1125ec: 9a04 ldr r2, [sp, #16]
1125ee: 69d8 ldr r0, [r3, #28]
1125f0: 4410 add r0, r2
1125f2: 1ab2 subs r2, r6, r2
1125f4: f004 fb10 bl 116c18 <memset>
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
1125f8: f04f 0301 mov.w r3, #1
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
1125fc: 4639 mov r1, r7
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
1125fe: 7123 strb r3, [r4, #4]
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
112600: 69e3 ldr r3, [r4, #28]
112602: f8d3 0098 ldr.w r0, [r3, #152] ; 0x98
112606: f7f6 f8b5 bl 108774 <rtems_rfs_buffer_handle_release>
if (rc > 0)
11260a: 2800 cmp r0, #0
11260c: f300 809a bgt.w 112744 <rtems_rfs_file_set_size+0x1ec> <== ALWAYS TAKEN
count -= length - bpos.boff;
112610: 9b04 ldr r3, [sp, #16]
handle->shared->size.count = rtems_rfs_block_map_count (map);
112612: 6bef ldr r7, [r5, #60] ; 0x3c
count -= length - bpos.boff;
112614: 1af3 subs r3, r6, r3
112616: ebb9 0903 subs.w r9, r9, r3
handle->shared->size.count = rtems_rfs_block_map_count (map);
11261a: 69e3 ldr r3, [r4, #28]
count -= length - bpos.boff;
11261c: f16a 0a00 sbc.w sl, sl, #0
while (count)
112620: ea59 020a orrs.w r2, r9, sl
112624: d032 beq.n 11268c <rtems_rfs_file_set_size+0x134>
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
112626: f8d3 0098 ldr.w r0, [r3, #152] ; 0x98
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map), &bpos);
11262a: 2300 movs r3, #0
11262c: 9703 str r7, [sp, #12]
11262e: 9305 str r3, [sp, #20]
112630: 6c2b ldr r3, [r5, #64] ; 0x40
112632: 9304 str r3, [sp, #16]
112634: b10b cbz r3, 11263a <rtems_rfs_file_set_size+0xe2>
112636: 3f01 subs r7, #1
112638: 9703 str r7, [sp, #12]
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
11263a: ab02 add r3, sp, #8
11263c: aa03 add r2, sp, #12
11263e: 4641 mov r1, r8
112640: f7fe fa16 bl 110a70 <rtems_rfs_block_map_find>
if (rc > 0)
112644: 2800 cmp r0, #0
112646: dd0b ble.n 112660 <rtems_rfs_file_set_size+0x108>
if (rc != ENXIO)
112648: 2806 cmp r0, #6
11264a: d17b bne.n 112744 <rtems_rfs_file_set_size+0x1ec> <== ALWAYS TAKEN
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
11264c: 69e3 ldr r3, [r4, #28]
11264e: 2201 movs r2, #1
112650: 4641 mov r1, r8
112652: f8d3 0098 ldr.w r0, [r3, #152] ; 0x98
112656: ab02 add r3, sp, #8
112658: f7fe fa9e bl 110b98 <rtems_rfs_block_map_grow>
if (rc > 0)
11265c: 2800 cmp r0, #0
11265e: dc71 bgt.n 112744 <rtems_rfs_file_set_size+0x1ec> <== ALWAYS TAKEN
if (count < (length - bpos.boff))
112660: 9b04 ldr r3, [sp, #16]
112662: 1af2 subs r2, r6, r3
112664: 4591 cmp r9, r2
112666: f17a 0200 sbcs.w r2, sl, #0
11266a: d3a8 bcc.n 1125be <rtems_rfs_file_set_size+0x66>
map->size.offset = offset;
11266c: 2300 movs r3, #0
11266e: 642b str r3, [r5, #64] ; 0x40
map->dirty = true;
112670: f04f 0301 mov.w r3, #1
112674: f885 3034 strb.w r3, [r5, #52] ; 0x34
}
112678: e7aa b.n 1125d0 <rtems_rfs_file_set_size+0x78>
rc = rtems_rfs_block_map_free_all (rtems_rfs_file_fs (handle), map);
11267a: 4658 mov r0, fp
11267c: 4641 mov r1, r8
11267e: f7fe fcbb bl 110ff8 <rtems_rfs_block_map_free_all>
if (rc > 0)
112682: f1b0 0b00 subs.w fp, r0, #0
112686: dc0b bgt.n 1126a0 <rtems_rfs_file_set_size+0x148> <== ALWAYS TAKEN
handle->shared->size.count = rtems_rfs_block_map_count (map);
112688: 69e3 ldr r3, [r4, #28]
11268a: 6bef ldr r7, [r5, #60] ; 0x3c
handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
11268c: 6c2a ldr r2, [r5, #64] ; 0x40
11268e: e9c3 7221 strd r7, r2, [r3, #132] ; 0x84
if (rtems_rfs_file_update_mtime (handle))
112692: 6820 ldr r0, [r4, #0]
112694: f010 0b02 ands.w fp, r0, #2
return 0;
112698: bf18 it ne
11269a: f04f 0b00 movne.w fp, #0
if (rtems_rfs_file_update_mtime (handle))
11269e: d003 beq.n 1126a8 <rtems_rfs_file_set_size+0x150> <== NEVER TAKEN
}
1126a0: 4658 mov r0, fp <== NOT EXECUTED
1126a2: b007 add sp, #28 <== NOT EXECUTED
1126a4: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
handle->shared->mtime = time (NULL);
1126a8: 4658 mov r0, fp
1126aa: f005 f9ff bl 117aac <time>
1126ae: 69e3 ldr r3, [r4, #28]
1126b0: f8c3 0090 str.w r0, [r3, #144] ; 0x90
}
1126b4: 4658 mov r0, fp
1126b6: b007 add sp, #28
1126b8: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
printf ("rtems-rfs: file-set-size: size=%" PRIu64 "\n", new_size);
1126bc: f24b 70d0 movw r0, #47056 ; 0xb7d0 <== NOT EXECUTED
1126c0: 464a mov r2, r9 <== NOT EXECUTED
1126c2: 4653 mov r3, sl <== NOT EXECUTED
1126c4: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1126c8: f7f3 fa26 bl 105b18 <__wrap_printf> <== NOT EXECUTED
1126cc: e752 b.n 112574 <rtems_rfs_file_set_size+0x1c> <== NOT EXECUTED
(((new_size - 1) /
1126ce: f119 30ff adds.w r0, r9, #4294967295 ; 0xffffffff
1126d2: 4632 mov r2, r6
1126d4: f04f 0300 mov.w r3, #0
1126d8: f16a 0100 sbc.w r1, sl, #0
1126dc: f003 fcca bl 116074 <__aeabi_uldivmod>
new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
1126e0: 4632 mov r2, r6
(((new_size - 1) /
1126e2: 4603 mov r3, r0
blocks =
1126e4: 1e7e subs r6, r7, #1
new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
1126e6: 4648 mov r0, r9
blocks =
1126e8: 1af6 subs r6, r6, r3
new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
1126ea: 4651 mov r1, sl
1126ec: 2300 movs r3, #0
1126ee: f003 fcc1 bl 116074 <__aeabi_uldivmod>
1126f2: 4691 mov r9, r2
if (blocks)
1126f4: b996 cbnz r6, 11271c <rtems_rfs_file_set_size+0x1c4>
if (rtems_rfs_block_pos_past_end (rtems_rfs_file_bpos (handle),
1126f6: 6923 ldr r3, [r4, #16]
map->dirty = true;
1126f8: 2201 movs r2, #1
map->size.offset = offset;
1126fa: f8c5 9040 str.w r9, [r5, #64] ; 0x40
map->dirty = true;
1126fe: f885 2034 strb.w r2, [r5, #52] ; 0x34
112702: b1c3 cbz r3, 112736 <rtems_rfs_file_set_size+0x1de>
112704: b9bf cbnz r7, 112736 <rtems_rfs_file_set_size+0x1de>
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map),
112706: 2200 movs r2, #0
handle->shared->size.count = rtems_rfs_block_map_count (map);
112708: 9b01 ldr r3, [sp, #4]
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map),
11270a: e9c4 7904 strd r7, r9, [r4, #16]
11270e: 61a2 str r2, [r4, #24]
112710: f1b9 0f00 cmp.w r9, #0
112714: d0ba beq.n 11268c <rtems_rfs_file_set_size+0x134> <== ALWAYS TAKEN
112716: 1e7a subs r2, r7, #1
112718: 6122 str r2, [r4, #16]
11271a: e7b7 b.n 11268c <rtems_rfs_file_set_size+0x134>
rc = rtems_rfs_block_map_shrink (rtems_rfs_file_fs (handle),
11271c: 9901 ldr r1, [sp, #4]
11271e: 4658 mov r0, fp
112720: 4632 mov r2, r6
112722: 3134 adds r1, #52 ; 0x34
112724: f7fe fb7e bl 110e24 <rtems_rfs_block_map_shrink>
if (rc > 0)
112728: f1b0 0b00 subs.w fp, r0, #0
11272c: dcb8 bgt.n 1126a0 <rtems_rfs_file_set_size+0x148> <== ALWAYS TAKEN
11272e: 69e3 ldr r3, [r4, #28]
if (rtems_rfs_block_pos_past_end (rtems_rfs_file_bpos (handle),
112730: 6bef ldr r7, [r5, #60] ; 0x3c
112732: 9301 str r3, [sp, #4]
112734: e7df b.n 1126f6 <rtems_rfs_file_set_size+0x19e>
112736: 42bb cmp r3, r7
112738: d2e5 bcs.n 112706 <rtems_rfs_file_set_size+0x1ae> <== ALWAYS TAKEN
11273a: 1e7a subs r2, r7, #1
11273c: 4293 cmp r3, r2
11273e: d006 beq.n 11274e <rtems_rfs_file_set_size+0x1f6> <== NEVER TAKEN
handle->shared->size.count = rtems_rfs_block_map_count (map);
112740: 9b01 ldr r3, [sp, #4]
112742: e7a3 b.n 11268c <rtems_rfs_file_set_size+0x134>
112744: 4683 mov fp, r0 <== NOT EXECUTED
}
112746: 4658 mov r0, fp <== NOT EXECUTED
112748: b007 add sp, #28 <== NOT EXECUTED
11274a: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
if (rtems_rfs_block_pos_past_end (rtems_rfs_file_bpos (handle),
11274e: 6963 ldr r3, [r4, #20]
112750: 454b cmp r3, r9
112752: d8d8 bhi.n 112706 <rtems_rfs_file_set_size+0x1ae>
112754: e7f4 b.n 112740 <rtems_rfs_file_set_size+0x1e8>
112756: bf00 nop
00108a78 <rtems_rfs_format>:
{
rtems_rfs_file_system fs;
int group;
int rc;
if (config->verbose)
108a78: 7d4b ldrb r3, [r1, #21]
{
108a7a: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
108a7e: b0b9 sub sp, #228 ; 0xe4
108a80: 4689 mov r9, r1
108a82: 9003 str r0, [sp, #12]
if (config->verbose)
108a84: 2b00 cmp r3, #0
108a86: f040 83d5 bne.w 109234 <rtems_rfs_format+0x7bc> <== ALWAYS TAKEN
printf ("rtems-rfs: format: %s\n", name);
memset (&fs, 0, sizeof (rtems_rfs_file_system));
108a8a: 2280 movs r2, #128 ; 0x80
108a8c: 2100 movs r1, #0
108a8e: a818 add r0, sp, #96 ; 0x60
108a90: f00e f8c2 bl 116c18 <memset>
head->next = tail;
108a94: aa29 add r2, sp, #164 ; 0xa4
tail->previous = head;
108a96: ab28 add r3, sp, #160 ; 0xa0
head->next = tail;
108a98: 9228 str r2, [sp, #160] ; 0xa0
108a9a: aa2d add r2, sp, #180 ; 0xb4
tail->previous = head;
108a9c: 932a str r3, [sp, #168] ; 0xa8
108a9e: ab2c add r3, sp, #176 ; 0xb0
head->next = tail;
108aa0: 922c str r2, [sp, #176] ; 0xb0
108aa2: aa31 add r2, sp, #196 ; 0xc4
tail->previous = head;
108aa4: 932e str r3, [sp, #184] ; 0xb8
108aa6: ab30 add r3, sp, #192 ; 0xc0
head->next = tail;
108aa8: 9230 str r2, [sp, #192] ; 0xc0
108aaa: aa35 add r2, sp, #212 ; 0xd4
tail->previous = head;
108aac: 9332 str r3, [sp, #200] ; 0xc8
108aae: ab34 add r3, sp, #208 ; 0xd0
head->next = tail;
108ab0: 9234 str r2, [sp, #208] ; 0xd0
fs.flags = RTEMS_RFS_FS_NO_LOCAL_CACHE;
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
108ab2: a917 add r1, sp, #92 ; 0x5c
fs.max_held_buffers = RTEMS_RFS_FS_MAX_HELD_BUFFERS;
108ab4: 2205 movs r2, #5
tail->previous = head;
108ab6: 9336 str r3, [sp, #216] ; 0xd8
rc = rtems_rfs_buffer_open (name, &fs);
108ab8: 9803 ldr r0, [sp, #12]
fs.flags = RTEMS_RFS_FS_NO_LOCAL_CACHE;
108aba: 2302 movs r3, #2
fs.max_held_buffers = RTEMS_RFS_FS_MAX_HELD_BUFFERS;
108abc: 9227 str r2, [sp, #156] ; 0x9c
fs.flags = RTEMS_RFS_FS_NO_LOCAL_CACHE;
108abe: 9317 str r3, [sp, #92] ; 0x5c
rc = rtems_rfs_buffer_open (name, &fs);
108ac0: f7ff fe5e bl 108780 <rtems_rfs_buffer_open>
if (rc != 0)
108ac4: 4604 mov r4, r0
108ac6: 2800 cmp r0, #0
108ac8: f040 84b7 bne.w 10943a <rtems_rfs_format+0x9c2> <== ALWAYS TAKEN
}
/*
* Check the media.
*/
if (rtems_rfs_fs_media_block_size (&fs) == 0)
108acc: 9b1b ldr r3, [sp, #108] ; 0x6c
108ace: 6a1d ldr r5, [r3, #32]
108ad0: 2d00 cmp r5, #0
108ad2: f000 8494 beq.w 1093fe <rtems_rfs_format+0x986> <== ALWAYS TAKEN
fs->block_size = config->block_size;
108ad6: f8d9 4000 ldr.w r4, [r9]
108ada: 9419 str r4, [sp, #100] ; 0x64
if (!fs->block_size)
108adc: 2c00 cmp r4, #0
108ade: f000 83b1 beq.w 109244 <rtems_rfs_format+0x7cc>
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
108ae2: 4629 mov r1, r5
108ae4: 4620 mov r0, r4
108ae6: f00d f90d bl 115d04 <__aeabi_uidivmod>
108aea: 2900 cmp r1, #0
108aec: f040 83f2 bne.w 1092d4 <rtems_rfs_format+0x85c> <== ALWAYS TAKEN
fs->group_blocks = config->group_blocks;
108af0: f8d9 3004 ldr.w r3, [r9, #4]
fs->group_blocks = rtems_rfs_bitmap_numof_bits (fs->block_size);
108af4: 00e4 lsls r4, r4, #3
fs->group_blocks = config->group_blocks;
108af6: 9321 str r3, [sp, #132] ; 0x84
if (!fs->group_blocks)
108af8: 2b00 cmp r3, #0
108afa: f040 81b0 bne.w 108e5e <rtems_rfs_format+0x3e6> <== ALWAYS TAKEN
fs->group_blocks = rtems_rfs_bitmap_numof_bits (fs->block_size);
108afe: 9421 str r4, [sp, #132] ; 0x84
fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;
108b00: a817 add r0, sp, #92 ; 0x5c
108b02: f009 fe3f bl 112784 <rtems_rfs_fs_media_size>
108b06: 9f19 ldr r7, [sp, #100] ; 0x64
108b08: 2300 movs r3, #0
108b0a: 463a mov r2, r7
108b0c: f00d fab2 bl 116074 <__aeabi_uldivmod>
108b10: 4604 mov r4, r0
return rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs));
108b12: 00fe lsls r6, r7, #3
return 1;
108b14: 2101 movs r1, #1
fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;
108b16: 9018 str r0, [sp, #96] ; 0x60
if (dividend == 0)
108b18: b124 cbz r4, 108b24 <rtems_rfs_format+0xac>
return ((dividend - 1) / divisor) + 1;
108b1a: 4631 mov r1, r6
108b1c: 1e60 subs r0, r4, #1
108b1e: f00c ffc3 bl 115aa8 <__udivsi3>
108b22: 1c41 adds r1, r0, #1
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
108b24: 08fd lsrs r5, r7, #3
108b26: f644 1325 movw r3, #18725 ; 0x4925
108b2a: f2c2 4392 movt r3, #9362 ; 0x2492
fs->group_inodes = config->group_inodes;
108b2e: f8d9 0008 ldr.w r0, [r9, #8]
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
108b32: fba3 3505 umull r3, r5, r3, r5
fs->group_count = rtems_rfs_rup_quotient (rtems_rfs_fs_blocks (fs),
108b36: 9120 str r1, [sp, #128] ; 0x80
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
108b38: 46a8 mov r8, r5
if (!fs->group_inodes)
108b3a: 2800 cmp r0, #0
108b3c: f040 819f bne.w 108e7e <rtems_rfs_format+0x406> <== ALWAYS TAKEN
if (config->inode_overhead)
108b40: f8d9 200c ldr.w r2, [r9, #12]
blocks = ((rtems_rfs_fs_blocks (fs) -
108b44: 1e63 subs r3, r4, #1
if (config->inode_overhead)
108b46: 2a00 cmp r2, #0
108b48: bf08 it eq
108b4a: 2201 moveq r2, #1
RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;
108b4c: fb02 f303 mul.w r3, r2, r3
if (dividend == 0)
108b50: 2b63 cmp r3, #99 ; 0x63
108b52: bf98 it ls
108b54: 4628 movls r0, r5
108b56: d90b bls.n 108b70 <rtems_rfs_format+0xf8>
RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;
108b58: f248 501f movw r0, #34079 ; 0x851f
108b5c: f2c5 10eb movt r0, #20971 ; 0x51eb
108b60: fba0 2303 umull r2, r3, r0, r3
108b64: 0958 lsrs r0, r3, #5
return ((dividend - 1) / divisor) + 1;
108b66: 3801 subs r0, #1
108b68: f00c ff9e bl 115aa8 <__udivsi3>
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
108b6c: fb00 5005 mla r0, r0, r5, r5
fs->inodes_per_block = rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE;
108b70: 9523 str r5, [sp, #140] ; 0x8c
if (dividend == 0)
108b72: 2800 cmp r0, #0
108b74: f040 8184 bne.w 108e80 <rtems_rfs_format+0x408> <== NEVER TAKEN
fs->max_name_length = config->max_name_length;
108b78: f8d9 3010 ldr.w r3, [r9, #16] <== NOT EXECUTED
fs->group_inodes =
108b7c: 4546 cmp r6, r8 <== NOT EXECUTED
108b7e: bf28 it cs <== NOT EXECUTED
108b80: 4646 movcs r6, r8 <== NOT EXECUTED
108b82: 9622 str r6, [sp, #136] ; 0x88 <== NOT EXECUTED
if (!fs->max_name_length)
108b84: 2b00 cmp r3, #0 <== NOT EXECUTED
108b86: f040 818a bne.w 108e9e <rtems_rfs_format+0x426> <== NOT EXECUTED
fs->max_name_length = 512;
108b8a: f44f 7300 mov.w r3, #512 ; 0x200
108b8e: 931e str r3, [sp, #120] ; 0x78
{
errno = EINVAL;
return -1;
}
if (config->verbose)
108b90: f899 3015 ldrb.w r3, [r9, #21]
108b94: 2b00 cmp r3, #0
108b96: f040 8188 bne.w 108eaa <rtems_rfs_format+0x432> <== ALWAYS 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));
108b9a: 4639 mov r1, r7
108b9c: a817 add r0, sp, #92 ; 0x5c
108b9e: f7ff fec9 bl 108934 <rtems_rfs_buffer_setblksize>
if (rc != 0)
108ba2: 4604 mov r4, r0
108ba4: 2800 cmp r0, #0
108ba6: f040 8438 bne.w 10941a <rtems_rfs_format+0x9a2> <== ALWAYS TAKEN
rc = rtems_rfs_buffer_handle_request (fs, &handle, 0, false);
108baa: 4603 mov r3, r0
108bac: 4602 mov r2, r0
handle->dirty = false;
108bae: f88d 0034 strb.w r0, [sp, #52] ; 0x34
108bb2: a90d add r1, sp, #52 ; 0x34
handle->buffer = NULL;
108bb4: e9cd 000e strd r0, r0, [sp, #56] ; 0x38
108bb8: a817 add r0, sp, #92 ; 0x5c
108bba: f7ff fcef bl 10859c <rtems_rfs_buffer_handle_request>
if (rc > 0)
108bbe: 1e05 subs r5, r0, #0
108bc0: f300 8300 bgt.w 1091c4 <rtems_rfs_format+0x74c> <== ALWAYS TAKEN
sb = rtems_rfs_buffer_data (&handle);
108bc4: 9b0f ldr r3, [sp, #60] ; 0x3c
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
108bc6: 21ff movs r1, #255 ; 0xff
108bc8: 9a19 ldr r2, [sp, #100] ; 0x64
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
108bca: 2501 movs r5, #1
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
108bcc: 2638 movs r6, #56 ; 0x38
sb = rtems_rfs_buffer_data (&handle);
108bce: 69db ldr r3, [r3, #28]
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
108bd0: 4618 mov r0, r3
108bd2: f00e f821 bl 116c18 <memset>
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
108bd6: 2228 movs r2, #40 ; 0x28
108bd8: 70c5 strb r5, [r0, #3]
108bda: 7002 strb r2, [r0, #0]
108bdc: 2209 movs r2, #9
108bde: 7042 strb r2, [r0, #1]
108be0: 2220 movs r2, #32
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
108be2: 7104 strb r4, [r0, #4]
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
108be4: 4603 mov r3, r0
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
108be6: 7144 strb r4, [r0, #5]
rc = rtems_rfs_buffer_handle_release (fs, &handle);
108be8: a90d add r1, sp, #52 ; 0x34
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
108bea: 7184 strb r4, [r0, #6]
108bec: 71c4 strb r4, [r0, #7]
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
108bee: 7082 strb r2, [r0, #2]
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
108bf0: 9a18 ldr r2, [sp, #96] ; 0x60
108bf2: 73c2 strb r2, [r0, #15]
108bf4: 0e10 lsrs r0, r2, #24
108bf6: 7318 strb r0, [r3, #12]
108bf8: 0c10 lsrs r0, r2, #16
108bfa: 0a12 lsrs r2, r2, #8
108bfc: 7358 strb r0, [r3, #13]
rc = rtems_rfs_buffer_handle_release (fs, &handle);
108bfe: a817 add r0, sp, #92 ; 0x5c
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
108c00: 739a strb r2, [r3, #14]
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
108c02: f89d 2067 ldrb.w r2, [sp, #103] ; 0x67
108c06: 721a strb r2, [r3, #8]
108c08: f8bd 2066 ldrh.w r2, [sp, #102] ; 0x66
108c0c: 725a strb r2, [r3, #9]
108c0e: 9a19 ldr r2, [sp, #100] ; 0x64
108c10: 0a12 lsrs r2, r2, #8
108c12: 729a strb r2, [r3, #10]
108c14: 9a19 ldr r2, [sp, #100] ; 0x64
108c16: 72da strb r2, [r3, #11]
write_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS, fs->bad_blocks);
108c18: f89d 2077 ldrb.w r2, [sp, #119] ; 0x77
108c1c: 741a strb r2, [r3, #16]
108c1e: f8bd 2076 ldrh.w r2, [sp, #118] ; 0x76
108c22: 745a strb r2, [r3, #17]
108c24: 9a1d ldr r2, [sp, #116] ; 0x74
108c26: 0a12 lsrs r2, r2, #8
108c28: 749a strb r2, [r3, #18]
108c2a: 9a1d ldr r2, [sp, #116] ; 0x74
108c2c: 74da strb r2, [r3, #19]
write_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH, fs->max_name_length);
108c2e: f89d 207b ldrb.w r2, [sp, #123] ; 0x7b
108c32: 751a strb r2, [r3, #20]
108c34: f8bd 207a ldrh.w r2, [sp, #122] ; 0x7a
108c38: 755a strb r2, [r3, #21]
108c3a: 9a1e ldr r2, [sp, #120] ; 0x78
108c3c: 0a12 lsrs r2, r2, #8
108c3e: 759a strb r2, [r3, #22]
108c40: 9a1e ldr r2, [sp, #120] ; 0x78
108c42: 75da strb r2, [r3, #23]
write_sb (RTEMS_RFS_SB_OFFSET_GROUPS, fs->group_count);
108c44: f89d 2083 ldrb.w r2, [sp, #131] ; 0x83
108c48: 761a strb r2, [r3, #24]
108c4a: f8bd 2082 ldrh.w r2, [sp, #130] ; 0x82
108c4e: 765a strb r2, [r3, #25]
108c50: 9a20 ldr r2, [sp, #128] ; 0x80
108c52: 0a12 lsrs r2, r2, #8
108c54: 769a strb r2, [r3, #26]
108c56: 9a20 ldr r2, [sp, #128] ; 0x80
108c58: 76da strb r2, [r3, #27]
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS, fs->group_blocks);
108c5a: f89d 2087 ldrb.w r2, [sp, #135] ; 0x87
108c5e: 771a strb r2, [r3, #28]
108c60: f8bd 2086 ldrh.w r2, [sp, #134] ; 0x86
108c64: 775a strb r2, [r3, #29]
108c66: 9a21 ldr r2, [sp, #132] ; 0x84
108c68: 0a12 lsrs r2, r2, #8
108c6a: 779a strb r2, [r3, #30]
108c6c: 9a21 ldr r2, [sp, #132] ; 0x84
108c6e: 77da strb r2, [r3, #31]
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);
108c70: f89d 208b ldrb.w r2, [sp, #139] ; 0x8b
108c74: f883 2020 strb.w r2, [r3, #32]
108c78: f8bd 208a ldrh.w r2, [sp, #138] ; 0x8a
108c7c: f883 2021 strb.w r2, [r3, #33] ; 0x21
108c80: 9a22 ldr r2, [sp, #136] ; 0x88
108c82: 0a12 lsrs r2, r2, #8
108c84: f883 2022 strb.w r2, [r3, #34] ; 0x22
108c88: 9a22 ldr r2, [sp, #136] ; 0x88
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
108c8a: f883 6027 strb.w r6, [r3, #39] ; 0x27
108c8e: f883 4024 strb.w r4, [r3, #36] ; 0x24
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);
108c92: f883 2023 strb.w r2, [r3, #35] ; 0x23
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
108c96: f883 4025 strb.w r4, [r3, #37] ; 0x25
108c9a: f883 4026 strb.w r4, [r3, #38] ; 0x26
rtems_rfs_buffer_mark_dirty (&handle);
108c9e: f88d 5034 strb.w r5, [sp, #52] ; 0x34
rc = rtems_rfs_buffer_handle_release (fs, &handle);
108ca2: f7ff fd67 bl 108774 <rtems_rfs_buffer_handle_release>
if (rc > 0)
108ca6: 1e05 subs r5, r0, #0
*/
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);
108ca8: a90d add r1, sp, #52 ; 0x34
108caa: a817 add r0, sp, #92 ; 0x5c
108cac: f300 82e7 bgt.w 10927e <rtems_rfs_format+0x806> <== ALWAYS TAKEN
108cb0: f7ff fd60 bl 108774 <rtems_rfs_buffer_handle_release>
errno = EIO;
return -1;
}
for (group = 0; group < fs.group_count; group++)
108cb4: 9b20 ldr r3, [sp, #128] ; 0x80
108cb6: 2b00 cmp r3, #0
108cb8: f340 818c ble.w 108fd4 <rtems_rfs_format+0x55c> <== ALWAYS TAKEN
printf ("\rrtems-rfs: format: group %3d: base = %" PRId32 ", size = %zd",
108cbc: f649 63d4 movw r3, #40660 ; 0x9ed4
108cc0: f2c0 0311 movt r3, #17
108cc4: 9304 str r3, [sp, #16]
printf (", blocks");
108cc6: f649 730c movw r3, #40716 ; 0x9f0c
108cca: f2c0 0311 movt r3, #17
108cce: 9305 str r3, [sp, #20]
printf (", inodes");
108cd0: f649 73f4 movw r3, #40948 ; 0x9ff4
108cd4: f2c0 0311 movt r3, #17
108cd8: 9307 str r3, [sp, #28]
group_base = rtems_rfs_fs_block (fs, group, 0);
108cda: 9d21 ldr r5, [sp, #132] ; 0x84
if (group_base > rtems_rfs_fs_blocks (fs))
108cdc: 9b18 ldr r3, [sp, #96] ; 0x60
group_base = rtems_rfs_fs_block (fs, group, 0);
108cde: fb05 f704 mul.w r7, r5, r4
108ce2: f107 0801 add.w r8, r7, #1
if (group_base > rtems_rfs_fs_blocks (fs))
108ce6: 4598 cmp r8, r3
108ce8: f200 820e bhi.w 109108 <rtems_rfs_format+0x690> <== ALWAYS TAKEN
if (!rtems_rfs_write_group (&fs, group,
108cec: f899 6015 ldrb.w r6, [r9, #21]
if ((group_base + group_size) > rtems_rfs_fs_blocks (fs))
108cf0: eb05 0208 add.w r2, r5, r8
108cf4: 4293 cmp r3, r2
if (!rtems_rfs_write_group (&fs, group,
108cf6: f899 a014 ldrb.w sl, [r9, #20]
group_size = rtems_rfs_fs_blocks (fs) - group_base;
108cfa: bf38 it cc
108cfc: eba3 0508 subcc.w r5, r3, r8
if (verbose)
108d00: 2e00 cmp r6, #0
108d02: f040 81f2 bne.w 1090ea <rtems_rfs_format+0x672> <== ALWAYS TAKEN
handle->dirty = false;
108d06: f88d 6028 strb.w r6, [sp, #40] ; 0x28
handle->buffer = NULL;
108d0a: e9cd 660b strd r6, r6, [sp, #44] ; 0x2c
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
108d0e: f8cd 8000 str.w r8, [sp]
108d12: 462b mov r3, r5
108d14: aa0a add r2, sp, #40 ; 0x28
108d16: a917 add r1, sp, #92 ; 0x5c
108d18: a80d add r0, sp, #52 ; 0x34
108d1a: f7ff faeb bl 1082f4 <rtems_rfs_bitmap_open>
if (rc > 0)
108d1e: f1b0 0800 subs.w r8, r0, #0
108d22: f300 81c3 bgt.w 1090ac <rtems_rfs_format+0x634> <== ALWAYS TAKEN
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
108d26: 9b0c ldr r3, [sp, #48] ; 0x30
108d28: 21ff movs r1, #255 ; 0xff
108d2a: 9a19 ldr r2, [sp, #100] ; 0x64
108d2c: 69d8 ldr r0, [r3, #28]
108d2e: f00d ff73 bl 116c18 <memset>
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
108d32: a80d add r0, sp, #52 ; 0x34
108d34: f7ff fa14 bl 108160 <rtems_rfs_bitmap_map_clear_all>
if (rc > 0)
108d38: f1b0 0800 subs.w r8, r0, #0
108d3c: f300 81ec bgt.w 109118 <rtems_rfs_format+0x6a0> <== ALWAYS TAKEN
rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
108d40: 2100 movs r1, #0
108d42: a80d add r0, sp, #52 ; 0x34
108d44: f7ff f93e bl 107fc4 <rtems_rfs_bitmap_map_set>
rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
108d48: 2101 movs r1, #1
108d4a: a80d add r0, sp, #52 ; 0x34
108d4c: f7ff f93a bl 107fc4 <rtems_rfs_bitmap_map_set>
blocks = rtems_rfs_rup_quotient (fs->group_inodes, fs->inodes_per_block);
108d50: 9822 ldr r0, [sp, #136] ; 0x88
if (dividend == 0)
108d52: 2800 cmp r0, #0
108d54: f000 81f9 beq.w 10914a <rtems_rfs_format+0x6d2> <== ALWAYS TAKEN
return ((dividend - 1) / divisor) + 1;
108d58: 9923 ldr r1, [sp, #140] ; 0x8c
108d5a: 3801 subs r0, #1
108d5c: f00c fea4 bl 115aa8 <__udivsi3>
108d60: 1c43 adds r3, r0, #1
for (b = 0; b < blocks; b++)
108d62: 2b00 cmp r3, #0
return ((dividend - 1) / divisor) + 1;
108d64: 9306 str r3, [sp, #24]
for (b = 0; b < blocks; b++)
108d66: dd0b ble.n 108d80 <rtems_rfs_format+0x308> <== ALWAYS TAKEN
108d68: f100 0803 add.w r8, r0, #3
108d6c: f04f 0b02 mov.w fp, #2
rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
108d70: 4659 mov r1, fp
108d72: a80d add r0, sp, #52 ; 0x34
for (b = 0; b < blocks; b++)
108d74: f10b 0b01 add.w fp, fp, #1
rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
108d78: f7ff f924 bl 107fc4 <rtems_rfs_bitmap_map_set>
for (b = 0; b < blocks; b++)
108d7c: 45c3 cmp fp, r8
108d7e: d1f7 bne.n 108d70 <rtems_rfs_format+0x2f8>
rc = rtems_rfs_bitmap_close (&bitmap);
108d80: a80d add r0, sp, #52 ; 0x34
108d82: f7ff facd bl 108320 <rtems_rfs_bitmap_close>
if (rc > 0)
108d86: f1b0 0800 subs.w r8, r0, #0
108d8a: f300 81eb bgt.w 109164 <rtems_rfs_format+0x6ec> <== ALWAYS TAKEN
rtems_rfs_buffer_mark_dirty (&handle);
108d8e: 2301 movs r3, #1
108d90: f88d 3028 strb.w r3, [sp, #40] ; 0x28
if (verbose)
108d94: 2e00 cmp r6, #0
108d96: f040 8211 bne.w 1091bc <rtems_rfs_format+0x744> <== ALWAYS TAKEN
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
108d9a: 1cba adds r2, r7, #2
108d9c: 462b mov r3, r5
108d9e: 9200 str r2, [sp, #0]
108da0: a917 add r1, sp, #92 ; 0x5c
108da2: aa0a add r2, sp, #40 ; 0x28
108da4: a80d add r0, sp, #52 ; 0x34
108da6: f7ff faa5 bl 1082f4 <rtems_rfs_bitmap_open>
if (rc > 0)
108daa: 1e05 subs r5, r0, #0
108dac: f300 81f0 bgt.w 109190 <rtems_rfs_format+0x718> <== ALWAYS TAKEN
memset (rtems_rfs_buffer_data (&handle), 0x00, rtems_rfs_fs_block_size (fs));
108db0: 9b0c ldr r3, [sp, #48] ; 0x30
108db2: 2100 movs r1, #0
108db4: 9a19 ldr r2, [sp, #100] ; 0x64
108db6: 69d8 ldr r0, [r3, #28]
108db8: f00d ff2e bl 116c18 <memset>
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
108dbc: a80d add r0, sp, #52 ; 0x34
108dbe: f7ff f9cf bl 108160 <rtems_rfs_bitmap_map_clear_all>
if (rc > 0)
108dc2: 1e05 subs r5, r0, #0
rtems_rfs_bitmap_close (&bitmap);
108dc4: a80d add r0, sp, #52 ; 0x34
if (rc > 0)
108dc6: f300 821d bgt.w 109204 <rtems_rfs_format+0x78c> <== ALWAYS TAKEN
rc = rtems_rfs_bitmap_close (&bitmap);
108dca: f7ff faa9 bl 108320 <rtems_rfs_bitmap_close>
if (rc > 0)
108dce: 1e05 subs r5, r0, #0
108dd0: f300 82bb bgt.w 10934a <rtems_rfs_format+0x8d2> <== ALWAYS TAKEN
rtems_rfs_buffer_mark_dirty (&handle);
108dd4: 2501 movs r5, #1
108dd6: f88d 5028 strb.w r5, [sp, #40] ; 0x28
if (initialise_inodes)
108dda: f1ba 0f00 cmp.w sl, #0
108dde: f000 80f0 beq.w 108fc2 <rtems_rfs_format+0x54a> <== NEVER TAKEN
for (b = 0; b < blocks; b++)
108de2: 9b06 ldr r3, [sp, #24] <== NOT EXECUTED
108de4: 2b00 cmp r3, #0 <== NOT EXECUTED
108de6: f340 80ec ble.w 108fc2 <rtems_rfs_format+0x54a> <== NOT EXECUTED
108dea: 3703 adds r7, #3 <== NOT EXECUTED
108dec: 443b add r3, r7 <== NOT EXECUTED
108dee: 469b mov fp, r3 <== NOT EXECUTED
108df0: e00a b.n 108e08 <rtems_rfs_format+0x390> <== NOT EXECUTED
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
108df2: 9b0c ldr r3, [sp, #48] ; 0x30 <== NOT EXECUTED
for (b = 0; b < blocks; b++)
108df4: 3701 adds r7, #1 <== NOT EXECUTED
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
108df6: 9a19 ldr r2, [sp, #100] ; 0x64 <== NOT EXECUTED
108df8: 69d8 ldr r0, [r3, #28] <== NOT EXECUTED
108dfa: f00d ff0d bl 116c18 <memset> <== NOT EXECUTED
for (b = 0; b < blocks; b++)
108dfe: 45bb cmp fp, r7 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle);
108e00: f88d 5028 strb.w r5, [sp, #40] ; 0x28 <== NOT EXECUTED
for (b = 0; b < blocks; b++)
108e04: f000 80dd beq.w 108fc2 <rtems_rfs_format+0x54a> <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &handle,
108e08: a90a add r1, sp, #40 ; 0x28 <== NOT EXECUTED
108e0a: 463a mov r2, r7 <== NOT EXECUTED
108e0c: 2300 movs r3, #0 <== NOT EXECUTED
108e0e: a817 add r0, sp, #92 ; 0x5c <== NOT EXECUTED
108e10: f7ff fbc4 bl 10859c <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
108e14: 2800 cmp r0, #0 <== NOT EXECUTED
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
108e16: f04f 01ff mov.w r1, #255 ; 0xff <== NOT EXECUTED
if (rc > 0)
108e1a: ddea ble.n 108df2 <rtems_rfs_format+0x37a> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
108e1c: 4606 mov r6, r0 <== NOT EXECUTED
108e1e: a90a add r1, sp, #40 ; 0x28 <== NOT EXECUTED
108e20: a817 add r0, sp, #92 ; 0x5c <== NOT EXECUTED
config->initialise_inodes, config->verbose))
{
errno = EIO;
return -1;
108e22: f04f 35ff mov.w r5, #4294967295 ; 0xffffffff <== NOT EXECUTED
108e26: f7ff fca5 bl 108774 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
108e2a: 2300 movs r3, #0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: block %" PRId32 " request failed: %d: %s\n",
108e2c: 4630 mov r0, r6 <== NOT EXECUTED
108e2e: f88d 3028 strb.w r3, [sp, #40] ; 0x28 <== NOT EXECUTED
handle->bnum = 0;
handle->buffer = NULL;
108e32: e9cd 330b strd r3, r3, [sp, #44] ; 0x2c <== NOT EXECUTED
108e36: f00e fc9b bl 117770 <strerror> <== NOT EXECUTED
108e3a: 9000 str r0, [sp, #0] <== NOT EXECUTED
108e3c: f24a 00dc movw r0, #41180 ; 0xa0dc <== NOT EXECUTED
108e40: 4633 mov r3, r6 <== NOT EXECUTED
108e42: 463a mov r2, r7 <== NOT EXECUTED
108e44: 4621 mov r1, r4 <== NOT EXECUTED
108e46: f2c0 0011 movt r0, #17 <== NOT EXECUTED
108e4a: f7fc fe65 bl 105b18 <__wrap_printf> <== NOT EXECUTED
errno = EIO;
108e4e: f00d fabb bl 1163c8 <__errno> <== NOT EXECUTED
108e52: 2305 movs r3, #5 <== NOT EXECUTED
108e54: 6003 str r3, [r0, #0] <== NOT EXECUTED
errno = rc;
return -1;
}
return 0;
}
108e56: 4628 mov r0, r5
108e58: b039 add sp, #228 ; 0xe4
108e5a: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
if (fs->group_blocks > rtems_rfs_bitmap_numof_bits (fs->block_size))
108e5e: 42a3 cmp r3, r4 <== NOT EXECUTED
108e60: f67f ae4e bls.w 108b00 <rtems_rfs_format+0x88> <== NOT EXECUTED
printf ("group block count is higher than bits in block\n");
108e64: f649 30bc movw r0, #39868 ; 0x9bbc <== NOT EXECUTED
108e68: f2c0 0011 movt r0, #17 <== NOT EXECUTED
108e6c: f7fc fe66 bl 105b3c <__wrap_puts> <== NOT EXECUTED
errno = EINVAL;
108e70: f00d faaa bl 1163c8 <__errno> <== NOT EXECUTED
108e74: 2316 movs r3, #22 <== NOT EXECUTED
return -1;
108e76: f04f 35ff mov.w r5, #4294967295 ; 0xffffffff <== NOT EXECUTED
errno = EINVAL;
108e7a: 6003 str r3, [r0, #0] <== NOT EXECUTED
return -1;
108e7c: e7eb b.n 108e56 <rtems_rfs_format+0x3de> <== NOT EXECUTED
fs->inodes_per_block = rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE;
108e7e: 9523 str r5, [sp, #140] ; 0x8c <== NOT EXECUTED
return ((dividend - 1) / divisor) + 1;
108e80: 3801 subs r0, #1
108e82: 4629 mov r1, r5
108e84: f00c fe10 bl 115aa8 <__udivsi3>
fs->inodes_per_block) * fs->inodes_per_block;
108e88: fb00 5805 mla r8, r0, r5, r5
fs->max_name_length = config->max_name_length;
108e8c: f8d9 3010 ldr.w r3, [r9, #16]
fs->group_inodes =
108e90: 4546 cmp r6, r8
108e92: bf28 it cs
108e94: 4646 movcs r6, r8
108e96: 9622 str r6, [sp, #136] ; 0x88
if (!fs->max_name_length)
108e98: 2b00 cmp r3, #0
108e9a: f43f ae76 beq.w 108b8a <rtems_rfs_format+0x112> <== NEVER TAKEN
fs->max_name_length = config->max_name_length;
108e9e: 931e str r3, [sp, #120] ; 0x78 <== NOT EXECUTED
if (config->verbose)
108ea0: f899 3015 ldrb.w r3, [r9, #21] <== NOT EXECUTED
108ea4: 2b00 cmp r3, #0 <== NOT EXECUTED
108ea6: f43f ae78 beq.w 108b9a <rtems_rfs_format+0x122> <== NOT EXECUTED
printf ("rtems-rfs: format: media size = %" PRIu64 "\n",
108eaa: a817 add r0, sp, #92 ; 0x5c <== NOT EXECUTED
108eac: f009 fc6a bl 112784 <rtems_rfs_fs_media_size> <== NOT EXECUTED
108eb0: 4602 mov r2, r0 <== NOT EXECUTED
108eb2: f649 30ec movw r0, #39916 ; 0x9bec <== NOT EXECUTED
108eb6: 460b mov r3, r1 <== NOT EXECUTED
108eb8: f2c0 0011 movt r0, #17 <== NOT EXECUTED
108ebc: f7fc fe2c bl 105b18 <__wrap_printf> <== NOT EXECUTED
printf ("rtems-rfs: format: media blocks = %" PRIu32 "\n",
108ec0: 9b1b ldr r3, [sp, #108] ; 0x6c <== NOT EXECUTED
108ec2: f649 4014 movw r0, #39956 ; 0x9c14 <== NOT EXECUTED
108ec6: f2c0 0011 movt r0, #17 <== NOT EXECUTED
108eca: 69d9 ldr r1, [r3, #28] <== NOT EXECUTED
108ecc: f7fc fe24 bl 105b18 <__wrap_printf> <== NOT EXECUTED
printf ("rtems-rfs: format: media block size = %" PRIu32 "\n",
108ed0: 9b1b ldr r3, [sp, #108] ; 0x6c <== NOT EXECUTED
108ed2: f649 403c movw r0, #39996 ; 0x9c3c <== NOT EXECUTED
108ed6: f2c0 0011 movt r0, #17 <== NOT EXECUTED
108eda: 6a19 ldr r1, [r3, #32] <== NOT EXECUTED
108edc: f7fc fe1c bl 105b18 <__wrap_printf> <== NOT EXECUTED
printf ("rtems-rfs: format: size = %" PRIu64 "\n",
108ee0: a817 add r0, sp, #92 ; 0x5c <== NOT EXECUTED
108ee2: f009 fc49 bl 112778 <rtems_rfs_fs_size> <== NOT EXECUTED
108ee6: 4602 mov r2, r0 <== NOT EXECUTED
108ee8: f649 4068 movw r0, #40040 ; 0x9c68 <== NOT EXECUTED
108eec: 460b mov r3, r1 <== NOT EXECUTED
108eee: f2c0 0011 movt r0, #17 <== NOT EXECUTED
108ef2: f7fc fe11 bl 105b18 <__wrap_printf> <== NOT EXECUTED
printf ("rtems-rfs: format: blocks = %zu\n",
108ef6: f649 4088 movw r0, #40072 ; 0x9c88 <== NOT EXECUTED
108efa: 9918 ldr r1, [sp, #96] ; 0x60 <== NOT EXECUTED
108efc: f2c0 0011 movt r0, #17 <== NOT EXECUTED
108f00: f7fc fe0a bl 105b18 <__wrap_printf> <== NOT EXECUTED
printf ("rtems-rfs: format: block size = %zu\n",
108f04: f649 40ac movw r0, #40108 ; 0x9cac <== NOT EXECUTED
108f08: 9919 ldr r1, [sp, #100] ; 0x64 <== NOT EXECUTED
108f0a: f2c0 0011 movt r0, #17 <== NOT EXECUTED
108f0e: f7fc fe03 bl 105b18 <__wrap_printf> <== NOT EXECUTED
return rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs));
108f12: 9919 ldr r1, [sp, #100] ; 0x64 <== NOT EXECUTED
printf ("rtems-rfs: format: bits per block = %u\n",
108f14: f649 40d4 movw r0, #40148 ; 0x9cd4 <== NOT EXECUTED
108f18: f2c0 0011 movt r0, #17 <== NOT EXECUTED
108f1c: 00c9 lsls r1, r1, #3 <== NOT EXECUTED
108f1e: f7fc fdfb bl 105b18 <__wrap_printf> <== NOT EXECUTED
printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
108f22: f649 40fc movw r0, #40188 ; 0x9cfc <== NOT EXECUTED
108f26: 2138 movs r1, #56 ; 0x38 <== NOT EXECUTED
108f28: f2c0 0011 movt r0, #17 <== NOT EXECUTED
108f2c: f7fc fdf4 bl 105b18 <__wrap_printf> <== NOT EXECUTED
fs.group_inodes * fs.group_count,
108f30: 9b22 ldr r3, [sp, #136] ; 0x88 <== NOT EXECUTED
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
108f32: 9c20 ldr r4, [sp, #128] ; 0x80 <== NOT EXECUTED
blocks = rtems_rfs_rup_quotient(fs->group_inodes * RTEMS_RFS_INODE_SIZE,
108f34: 9d19 ldr r5, [sp, #100] ; 0x64 <== NOT EXECUTED
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
108f36: fb03 f404 mul.w r4, r3, r4 <== NOT EXECUTED
blocks = rtems_rfs_rup_quotient(fs->group_inodes * RTEMS_RFS_INODE_SIZE,
108f3a: ebc3 03c3 rsb r3, r3, r3, lsl #3 <== NOT EXECUTED
if (dividend == 0)
108f3e: 00db lsls r3, r3, #3 <== NOT EXECUTED
108f40: bf08 it eq <== NOT EXECUTED
108f42: f44f 60fa moveq.w r0, #2000 ; 0x7d0 <== NOT EXECUTED
108f46: d008 beq.n 108f5a <rtems_rfs_format+0x4e2> <== NOT EXECUTED
return ((dividend - 1) / divisor) + 1;
108f48: 1e58 subs r0, r3, #1 <== NOT EXECUTED
108f4a: 4629 mov r1, r5 <== NOT EXECUTED
108f4c: f00c fdac bl 115aa8 <__udivsi3> <== NOT EXECUTED
return ((blocks + 1) * 100 * 10) / bits_per_block;
108f50: f44f 737a mov.w r3, #1000 ; 0x3e8 <== NOT EXECUTED
108f54: 3002 adds r0, #2 <== NOT EXECUTED
108f56: fb03 f000 mul.w r0, r3, r0 <== NOT EXECUTED
if (bits_per_block > (rtems_rfs_fs_blocks (fs) - RTEMS_RFS_SUPERBLOCK_SIZE))
108f5a: 9b18 ldr r3, [sp, #96] ; 0x60 <== NOT EXECUTED
return rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs));
108f5c: 00ed lsls r5, r5, #3 <== NOT EXECUTED
if (bits_per_block > (rtems_rfs_fs_blocks (fs) - RTEMS_RFS_SUPERBLOCK_SIZE))
108f5e: 1e59 subs r1, r3, #1 <== NOT EXECUTED
return ((blocks + 1) * 100 * 10) / bits_per_block;
108f60: 42a9 cmp r1, r5 <== NOT EXECUTED
108f62: bf28 it cs <== NOT EXECUTED
108f64: 4629 movcs r1, r5 <== NOT EXECUTED
108f66: f00c fedb bl 115d20 <__divsi3> <== NOT EXECUTED
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
108f6a: f246 6267 movw r2, #26215 ; 0x6667 <== NOT EXECUTED
return ((blocks + 1) * 100 * 10) / bits_per_block;
108f6e: 4603 mov r3, r0 <== NOT EXECUTED
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
108f70: f2c6 6266 movt r2, #26214 ; 0x6666 <== NOT EXECUTED
108f74: 4621 mov r1, r4 <== NOT EXECUTED
108f76: fb82 2000 smull r2, r0, r2, r0 <== NOT EXECUTED
108f7a: 17da asrs r2, r3, #31 <== NOT EXECUTED
108f7c: ebc2 02a0 rsb r2, r2, r0, asr #2 <== NOT EXECUTED
108f80: f649 5024 movw r0, #40228 ; 0x9d24 <== NOT EXECUTED
108f84: f2c0 0011 movt r0, #17 <== NOT EXECUTED
108f88: eb02 0482 add.w r4, r2, r2, lsl #2 <== NOT EXECUTED
108f8c: eba3 0344 sub.w r3, r3, r4, lsl #1 <== NOT EXECUTED
108f90: f7fc fdc2 bl 105b18 <__wrap_printf> <== NOT EXECUTED
printf ("rtems-rfs: format: groups = %u\n", fs.group_count);
108f94: f649 5050 movw r0, #40272 ; 0x9d50 <== NOT EXECUTED
108f98: 9920 ldr r1, [sp, #128] ; 0x80 <== NOT EXECUTED
108f9a: f2c0 0011 movt r0, #17 <== NOT EXECUTED
108f9e: f7fc fdbb bl 105b18 <__wrap_printf> <== NOT EXECUTED
printf ("rtems-rfs: format: group blocks = %zu\n", fs.group_blocks);
108fa2: f649 5070 movw r0, #40304 ; 0x9d70 <== NOT EXECUTED
108fa6: 9921 ldr r1, [sp, #132] ; 0x84 <== NOT EXECUTED
108fa8: f2c0 0011 movt r0, #17 <== NOT EXECUTED
108fac: f7fc fdb4 bl 105b18 <__wrap_printf> <== NOT EXECUTED
printf ("rtems-rfs: format: group inodes = %zu\n", fs.group_inodes);
108fb0: f649 5098 movw r0, #40344 ; 0x9d98 <== NOT EXECUTED
108fb4: 9922 ldr r1, [sp, #136] ; 0x88 <== NOT EXECUTED
108fb6: f2c0 0011 movt r0, #17 <== NOT EXECUTED
108fba: f7fc fdad bl 105b18 <__wrap_printf> <== NOT EXECUTED
rc = rtems_rfs_buffer_setblksize (&fs, rtems_rfs_fs_block_size (&fs));
108fbe: 9f19 ldr r7, [sp, #100] ; 0x64 <== NOT EXECUTED
108fc0: e5eb b.n 108b9a <rtems_rfs_format+0x122> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
108fc2: a90a add r1, sp, #40 ; 0x28
108fc4: a817 add r0, sp, #92 ; 0x5c
108fc6: f7ff fbd5 bl 108774 <rtems_rfs_buffer_handle_release>
for (group = 0; group < fs.group_count; group++)
108fca: 9b20 ldr r3, [sp, #128] ; 0x80
108fcc: 3401 adds r4, #1
108fce: 42a3 cmp r3, r4
108fd0: f73f ae83 bgt.w 108cda <rtems_rfs_format+0x262> <== ALWAYS TAKEN
if (config->verbose)
108fd4: f899 3015 ldrb.w r3, [r9, #21]
108fd8: 2b00 cmp r3, #0
108fda: f040 81b2 bne.w 109342 <rtems_rfs_format+0x8ca> <== ALWAYS TAKEN
rc = rtems_rfs_buffer_close (&fs);
108fde: a817 add r0, sp, #92 ; 0x5c
108fe0: f7ff fd00 bl 1089e4 <rtems_rfs_buffer_close>
108fe4: 4603 mov r3, r0
if (rc != 0)
108fe6: 2800 cmp r0, #0
108fe8: f040 8237 bne.w 10945a <rtems_rfs_format+0x9e2> <== ALWAYS TAKEN
rc = rtems_rfs_fs_open (name, NULL,
108fec: aa09 add r2, sp, #36 ; 0x24
108fee: 4601 mov r1, r0
108ff0: 9200 str r2, [sp, #0]
108ff2: 2206 movs r2, #6
108ff4: 9803 ldr r0, [sp, #12]
108ff6: f009 fbcb bl 112790 <rtems_rfs_fs_open>
if (rc != 0)
108ffa: 2800 cmp r0, #0
108ffc: f040 818f bne.w 10931e <rtems_rfs_format+0x8a6> <== ALWAYS TAKEN
rc = rtems_rfs_inode_alloc (fs, RTEMS_RFS_ROOT_INO, &ino);
109000: 9809 ldr r0, [sp, #36] ; 0x24
109002: aa0a add r2, sp, #40 ; 0x28
109004: 2101 movs r1, #1
109006: f000 fc5f bl 1098c8 <rtems_rfs_inode_alloc>
if (rc != 0)
10900a: 4605 mov r5, r0
10900c: 2800 cmp r0, #0
10900e: f040 81b2 bne.w 109376 <rtems_rfs_format+0x8fe> <== ALWAYS TAKEN
if (ino != RTEMS_RFS_ROOT_INO)
109012: 9c0a ldr r4, [sp, #40] ; 0x28
109014: 2c01 cmp r4, #1
109016: f040 8166 bne.w 1092e6 <rtems_rfs_format+0x86e> <== ALWAYS TAKEN
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
10901a: 9809 ldr r0, [sp, #36] ; 0x24
10901c: 4623 mov r3, r4
10901e: aa0d add r2, sp, #52 ; 0x34
109020: 4621 mov r1, r4
109022: f000 fc93 bl 10994c <rtems_rfs_inode_open>
if (rc != 0)
109026: 4605 mov r5, r0
109028: 2800 cmp r0, #0
10902a: f040 81b4 bne.w 109396 <rtems_rfs_format+0x91e> <== ALWAYS TAKEN
rc = rtems_rfs_inode_initialise (&inode, 0,
10902e: 4603 mov r3, r0
109030: 4601 mov r1, r0
109032: 9000 str r0, [sp, #0]
109034: f244 12c9 movw r2, #16841 ; 0x41c9
109038: a80d add r0, sp, #52 ; 0x34
10903a: f000 fdcf bl 109bdc <rtems_rfs_inode_initialise>
if (rc != 0)
10903e: 4604 mov r4, r0
109040: 2800 cmp r0, #0
109042: f040 81d1 bne.w 1093e8 <rtems_rfs_format+0x970> <== ALWAYS TAKEN
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, ino);
109046: 990a ldr r1, [sp, #40] ; 0x28
109048: f249 128c movw r2, #37260 ; 0x918c
10904c: 9809 ldr r0, [sp, #36] ; 0x24
10904e: 2301 movs r3, #1
109050: f2c0 0211 movt r2, #17
109054: 9100 str r1, [sp, #0]
109056: a90d add r1, sp, #52 ; 0x34
109058: f008 f9be bl 1113d8 <rtems_rfs_dir_add_entry>
if (rc != 0)
10905c: 4604 mov r4, r0
10905e: 2800 cmp r0, #0
109060: f040 81b7 bne.w 1093d2 <rtems_rfs_format+0x95a> <== ALWAYS TAKEN
rc = rtems_rfs_inode_close (fs, &inode);
109064: 9809 ldr r0, [sp, #36] ; 0x24
109066: a90d add r1, sp, #52 ; 0x34
109068: f000 fcf8 bl 109a5c <rtems_rfs_inode_close>
if (rc != 0)
10906c: 4604 mov r4, r0
10906e: 2800 cmp r0, #0
109070: f040 81a4 bne.w 1093bc <rtems_rfs_format+0x944> <== ALWAYS TAKEN
rc = rtems_rfs_fs_close (fs);
109074: 9809 ldr r0, [sp, #36] ; 0x24
109076: f009 fdd1 bl 112c1c <rtems_rfs_fs_close>
if (rc != 0)
10907a: 4605 mov r5, r0
10907c: 2800 cmp r0, #0
10907e: f43f aeea beq.w 108e56 <rtems_rfs_format+0x3de> <== NEVER TAKEN
rc = errno;
109082: f00d f9a1 bl 1163c8 <__errno> <== NOT EXECUTED
109086: 6805 ldr r5, [r0, #0] <== NOT EXECUTED
printf ("rtems-rfs: format: file system close failed: %d: %s\n",
109088: 4628 mov r0, r5 <== NOT EXECUTED
10908a: f00e fb71 bl 117770 <strerror> <== NOT EXECUTED
10908e: 4602 mov r2, r0 <== NOT EXECUTED
109090: f24a 20bc movw r0, #41660 ; 0xa2bc <== NOT EXECUTED
109094: 4629 mov r1, r5 <== NOT EXECUTED
109096: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10909a: f7fc fd3d bl 105b18 <__wrap_printf> <== NOT EXECUTED
if (rc != 0)
10909e: 2d00 cmp r5, #0 <== NOT EXECUTED
1090a0: f040 812c bne.w 1092fc <rtems_rfs_format+0x884> <== NOT EXECUTED
}
1090a4: 4628 mov r0, r5 <== NOT EXECUTED
1090a6: b039 add sp, #228 ; 0xe4 <== NOT EXECUTED
1090a8: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
1090ac: a90a add r1, sp, #40 ; 0x28 <== NOT EXECUTED
1090ae: a817 add r0, sp, #92 ; 0x5c <== NOT EXECUTED
1090b0: f7ff fb60 bl 108774 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
1090b4: 2300 movs r3, #0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: open block bitmap failed: %d: %s\n",
1090b6: 4640 mov r0, r8 <== NOT EXECUTED
1090b8: f88d 3028 strb.w r3, [sp, #40] ; 0x28 <== NOT EXECUTED
handle->buffer = NULL;
1090bc: e9cd 330b strd r3, r3, [sp, #44] ; 0x2c <== NOT EXECUTED
1090c0: f00e fb56 bl 117770 <strerror> <== NOT EXECUTED
1090c4: 4603 mov r3, r0 <== NOT EXECUTED
1090c6: f649 7018 movw r0, #40728 ; 0x9f18 <== NOT EXECUTED
1090ca: 4642 mov r2, r8 <== NOT EXECUTED
1090cc: 4621 mov r1, r4 <== NOT EXECUTED
1090ce: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1090d2: f7fc fd21 bl 105b18 <__wrap_printf> <== NOT EXECUTED
errno = EIO;
1090d6: f00d f977 bl 1163c8 <__errno> <== NOT EXECUTED
return -1;
1090da: f04f 35ff mov.w r5, #4294967295 ; 0xffffffff <== NOT EXECUTED
errno = EIO;
1090de: 2305 movs r3, #5 <== NOT EXECUTED
1090e0: 6003 str r3, [r0, #0] <== NOT EXECUTED
}
1090e2: 4628 mov r0, r5 <== NOT EXECUTED
1090e4: b039 add sp, #228 ; 0xe4 <== NOT EXECUTED
1090e6: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
printf ("\rrtems-rfs: format: group %3d: base = %" PRId32 ", size = %zd",
1090ea: 462b mov r3, r5 <== NOT EXECUTED
1090ec: 9804 ldr r0, [sp, #16] <== NOT EXECUTED
1090ee: 4642 mov r2, r8 <== NOT EXECUTED
1090f0: 4621 mov r1, r4 <== NOT EXECUTED
1090f2: f7fc fd11 bl 105b18 <__wrap_printf> <== NOT EXECUTED
handle->dirty = false;
1090f6: 2300 movs r3, #0 <== NOT EXECUTED
printf (", blocks");
1090f8: 9805 ldr r0, [sp, #20] <== NOT EXECUTED
1090fa: f88d 3028 strb.w r3, [sp, #40] ; 0x28 <== NOT EXECUTED
handle->buffer = NULL;
1090fe: e9cd 330b strd r3, r3, [sp, #44] ; 0x2c <== NOT EXECUTED
109102: f7fc fd09 bl 105b18 <__wrap_printf> <== NOT EXECUTED
109106: e602 b.n 108d0e <rtems_rfs_format+0x296> <== NOT EXECUTED
printf ("rtems-rfs: write-group: group %d base beyond disk limit\n",
109108: f649 6098 movw r0, #40600 ; 0x9e98 <== NOT EXECUTED
10910c: 4621 mov r1, r4 <== NOT EXECUTED
10910e: f2c0 0011 movt r0, #17 <== NOT EXECUTED
109112: f7fc fd01 bl 105b18 <__wrap_printf> <== NOT EXECUTED
return false;
109116: e7de b.n 1090d6 <rtems_rfs_format+0x65e> <== NOT EXECUTED
rtems_rfs_bitmap_close (&bitmap);
109118: a80d add r0, sp, #52 ; 0x34 <== NOT EXECUTED
10911a: f7ff f901 bl 108320 <rtems_rfs_bitmap_close> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
10911e: a90a add r1, sp, #40 ; 0x28 <== NOT EXECUTED
109120: a817 add r0, sp, #92 ; 0x5c <== NOT EXECUTED
109122: f7ff fb27 bl 108774 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
109126: 2300 movs r3, #0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: block bitmap clear all failed: %d: %s\n",
109128: 4640 mov r0, r8 <== NOT EXECUTED
10912a: f88d 3028 strb.w r3, [sp, #40] ; 0x28 <== NOT EXECUTED
handle->buffer = NULL;
10912e: e9cd 330b strd r3, r3, [sp, #44] ; 0x2c <== NOT EXECUTED
109132: f00e fb1d bl 117770 <strerror> <== NOT EXECUTED
109136: 4603 mov r3, r0 <== NOT EXECUTED
109138: f649 7060 movw r0, #40800 ; 0x9f60 <== NOT EXECUTED
10913c: 4642 mov r2, r8 <== NOT EXECUTED
10913e: 4621 mov r1, r4 <== NOT EXECUTED
109140: f2c0 0011 movt r0, #17 <== NOT EXECUTED
109144: f7fc fce8 bl 105b18 <__wrap_printf> <== NOT EXECUTED
return false;
109148: e7c5 b.n 1090d6 <rtems_rfs_format+0x65e> <== NOT EXECUTED
rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
10914a: 2102 movs r1, #2 <== NOT EXECUTED
10914c: a80d add r0, sp, #52 ; 0x34 <== NOT EXECUTED
10914e: f7fe ff39 bl 107fc4 <rtems_rfs_bitmap_map_set> <== NOT EXECUTED
return 1;
109152: 2301 movs r3, #1 <== NOT EXECUTED
rc = rtems_rfs_bitmap_close (&bitmap);
109154: a80d add r0, sp, #52 ; 0x34 <== NOT EXECUTED
return 1;
109156: 9306 str r3, [sp, #24] <== NOT EXECUTED
rc = rtems_rfs_bitmap_close (&bitmap);
109158: f7ff f8e2 bl 108320 <rtems_rfs_bitmap_close> <== NOT EXECUTED
if (rc > 0)
10915c: f1b0 0800 subs.w r8, r0, #0 <== NOT EXECUTED
109160: f77f ae15 ble.w 108d8e <rtems_rfs_format+0x316> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
109164: a90a add r1, sp, #40 ; 0x28 <== NOT EXECUTED
109166: a817 add r0, sp, #92 ; 0x5c <== NOT EXECUTED
109168: f7ff fb04 bl 108774 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
10916c: 2300 movs r3, #0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: close block bitmap failed: %d: %s\n",
10916e: 4640 mov r0, r8 <== NOT EXECUTED
109170: f88d 3028 strb.w r3, [sp, #40] ; 0x28 <== NOT EXECUTED
handle->buffer = NULL;
109174: e9cd 330b strd r3, r3, [sp, #44] ; 0x2c <== NOT EXECUTED
109178: f00e fafa bl 117770 <strerror> <== NOT EXECUTED
10917c: 4603 mov r3, r0 <== NOT EXECUTED
10917e: f649 70ac movw r0, #40876 ; 0x9fac <== NOT EXECUTED
109182: 4642 mov r2, r8 <== NOT EXECUTED
109184: 4621 mov r1, r4 <== NOT EXECUTED
109186: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10918a: f7fc fcc5 bl 105b18 <__wrap_printf> <== NOT EXECUTED
return false;
10918e: e7a2 b.n 1090d6 <rtems_rfs_format+0x65e> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
109190: a90a add r1, sp, #40 ; 0x28 <== NOT EXECUTED
109192: a817 add r0, sp, #92 ; 0x5c <== NOT EXECUTED
109194: f7ff faee bl 108774 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
109198: 2300 movs r3, #0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: open inode bitmap failed: %d: %s\n",
10919a: 4628 mov r0, r5 <== NOT EXECUTED
10919c: f88d 3028 strb.w r3, [sp, #40] ; 0x28 <== NOT EXECUTED
handle->buffer = NULL;
1091a0: e9cd 330b strd r3, r3, [sp, #44] ; 0x2c <== NOT EXECUTED
1091a4: f00e fae4 bl 117770 <strerror> <== NOT EXECUTED
1091a8: 4603 mov r3, r0 <== NOT EXECUTED
1091aa: f24a 0000 movw r0, #40960 ; 0xa000 <== NOT EXECUTED
1091ae: 462a mov r2, r5 <== NOT EXECUTED
1091b0: 4621 mov r1, r4 <== NOT EXECUTED
1091b2: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1091b6: f7fc fcaf bl 105b18 <__wrap_printf> <== NOT EXECUTED
return false;
1091ba: e78c b.n 1090d6 <rtems_rfs_format+0x65e> <== NOT EXECUTED
printf (", inodes");
1091bc: 9807 ldr r0, [sp, #28] <== NOT EXECUTED
1091be: f7fc fcab bl 105b18 <__wrap_printf> <== NOT EXECUTED
1091c2: e5ea b.n 108d9a <rtems_rfs_format+0x322> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
1091c4: a90d add r1, sp, #52 ; 0x34 <== NOT EXECUTED
1091c6: a817 add r0, sp, #92 ; 0x5c <== NOT EXECUTED
1091c8: f7ff fad4 bl 108774 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
printf ("rtems-rfs: write-superblock: request failed: %d: %s\n",
1091cc: 4628 mov r0, r5 <== NOT EXECUTED
handle->dirty = false;
1091ce: f88d 4034 strb.w r4, [sp, #52] ; 0x34 <== NOT EXECUTED
handle->buffer = NULL;
1091d2: e9cd 440e strd r4, r4, [sp, #56] ; 0x38 <== NOT EXECUTED
1091d6: f00e facb bl 117770 <strerror> <== NOT EXECUTED
1091da: 4602 mov r2, r0 <== NOT EXECUTED
1091dc: f649 50f8 movw r0, #40440 ; 0x9df8 <== NOT EXECUTED
1091e0: 4629 mov r1, r5 <== NOT EXECUTED
1091e2: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1091e6: f7fc fc97 bl 105b18 <__wrap_printf> <== NOT EXECUTED
printf ("rtems-rfs: format: superblock write failed\n");
1091ea: f649 606c movw r0, #40556 ; 0x9e6c <== NOT EXECUTED
return -1;
1091ee: f04f 35ff mov.w r5, #4294967295 ; 0xffffffff <== NOT EXECUTED
printf ("rtems-rfs: format: superblock write failed\n");
1091f2: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1091f6: f7fc fca1 bl 105b3c <__wrap_puts> <== NOT EXECUTED
errno = EIO;
1091fa: f00d f8e5 bl 1163c8 <__errno> <== NOT EXECUTED
1091fe: 2305 movs r3, #5 <== NOT EXECUTED
109200: 6003 str r3, [r0, #0] <== NOT EXECUTED
return -1;
109202: e628 b.n 108e56 <rtems_rfs_format+0x3de> <== NOT EXECUTED
rtems_rfs_bitmap_close (&bitmap);
109204: f7ff f88c bl 108320 <rtems_rfs_bitmap_close> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
109208: a90a add r1, sp, #40 ; 0x28 <== NOT EXECUTED
10920a: a817 add r0, sp, #92 ; 0x5c <== NOT EXECUTED
10920c: f7ff fab2 bl 108774 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
109210: 2300 movs r3, #0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: inode bitmap" \
109212: 4628 mov r0, r5 <== NOT EXECUTED
109214: f88d 3028 strb.w r3, [sp, #40] ; 0x28 <== NOT EXECUTED
handle->buffer = NULL;
109218: e9cd 330b strd r3, r3, [sp, #44] ; 0x2c <== NOT EXECUTED
10921c: f00e faa8 bl 117770 <strerror> <== NOT EXECUTED
109220: 4603 mov r3, r0 <== NOT EXECUTED
109222: f24a 0048 movw r0, #41032 ; 0xa048 <== NOT EXECUTED
109226: 462a mov r2, r5 <== NOT EXECUTED
109228: 4621 mov r1, r4 <== NOT EXECUTED
10922a: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10922e: f7fc fc73 bl 105b18 <__wrap_printf> <== NOT EXECUTED
return false;
109232: e750 b.n 1090d6 <rtems_rfs_format+0x65e> <== NOT EXECUTED
printf ("rtems-rfs: format: %s\n", name);
109234: f649 300c movw r0, #39692 ; 0x9b0c <== NOT EXECUTED
109238: 9903 ldr r1, [sp, #12] <== NOT EXECUTED
10923a: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10923e: f7fc fc6b bl 105b18 <__wrap_printf> <== NOT EXECUTED
109242: e422 b.n 108a8a <rtems_rfs_format+0x12> <== NOT EXECUTED
uint64_t total_size = rtems_rfs_fs_media_size (fs);
109244: a817 add r0, sp, #92 ; 0x5c
109246: f009 fa9d bl 112784 <rtems_rfs_fs_media_size>
if (total_size >= GIGS (1))
10924a: f5b0 1f80 cmp.w r0, #1048576 ; 0x100000
10924e: f171 0300 sbcs.w r3, r1, #0
109252: d326 bcc.n 1092a2 <rtems_rfs_format+0x82a> <== NEVER TAKEN
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
109254: f510 1280 adds.w r2, r0, #1048576 ; 0x100000 <== NOT EXECUTED
for (b = 31; b > 0; b--)
109258: f04f 031f mov.w r3, #31 <== NOT EXECUTED
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
10925c: ea4f 5212 mov.w r2, r2, lsr #20 <== NOT EXECUTED
109260: f141 0100 adc.w r1, r1, #0 <== NOT EXECUTED
109264: ea42 3201 orr.w r2, r2, r1, lsl #12 <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
109268: 2101 movs r1, #1 <== NOT EXECUTED
10926a: e002 b.n 109272 <rtems_rfs_format+0x7fa> <== NOT EXECUTED
for (b = 31; b > 0; b--)
10926c: 3b01 subs r3, #1 <== NOT EXECUTED
10926e: f000 8090 beq.w 109392 <rtems_rfs_format+0x91a> <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
109272: fa01 f403 lsl.w r4, r1, r3 <== NOT EXECUTED
109276: 4222 tst r2, r4 <== NOT EXECUTED
109278: d0f8 beq.n 10926c <rtems_rfs_format+0x7f4> <== NOT EXECUTED
fs->block_size = 1 << b;
10927a: 9419 str r4, [sp, #100] ; 0x64 <== NOT EXECUTED
10927c: e012 b.n 1092a4 <rtems_rfs_format+0x82c> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
10927e: f7ff fa79 bl 108774 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
printf ("rtems-rfs: write-superblock: buffer release failed: %d: %s\n",
109282: 4628 mov r0, r5 <== NOT EXECUTED
handle->dirty = false;
109284: f88d 4034 strb.w r4, [sp, #52] ; 0x34 <== NOT EXECUTED
handle->buffer = NULL;
109288: e9cd 440e strd r4, r4, [sp, #56] ; 0x38 <== NOT EXECUTED
10928c: f00e fa70 bl 117770 <strerror> <== NOT EXECUTED
109290: 4602 mov r2, r0 <== NOT EXECUTED
109292: f649 6030 movw r0, #40496 ; 0x9e30 <== NOT EXECUTED
109296: 4629 mov r1, r5 <== NOT EXECUTED
109298: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10929c: f7fc fc3c bl 105b18 <__wrap_printf> <== NOT EXECUTED
return false;
1092a0: e7a3 b.n 1091ea <rtems_rfs_format+0x772> <== NOT EXECUTED
if (fs->block_size < 512)
1092a2: 9c19 ldr r4, [sp, #100] ; 0x64
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
1092a4: 9b1b ldr r3, [sp, #108] ; 0x6c
if (fs->block_size < 512)
1092a6: f5b4 7f00 cmp.w r4, #512 ; 0x200
fs->block_size = 512;
1092aa: bf3c itt cc
1092ac: f44f 7400 movcc.w r4, #512 ; 0x200
1092b0: 9419 strcc r4, [sp, #100] ; 0x64
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
1092b2: 6a1d ldr r5, [r3, #32]
if (fs->block_size < 512)
1092b4: f4ff ac15 bcc.w 108ae2 <rtems_rfs_format+0x6a> <== NEVER TAKEN
if (fs->block_size > (4 * 1024))
1092b8: f5b4 5f80 cmp.w r4, #4096 ; 0x1000 <== NOT EXECUTED
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
1092bc: 4629 mov r1, r5 <== NOT EXECUTED
fs->block_size = (4 * 1024);
1092be: bf88 it hi <== NOT EXECUTED
1092c0: f44f 5480 movhi.w r4, #4096 ; 0x1000 <== NOT EXECUTED
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
1092c4: 4620 mov r0, r4 <== NOT EXECUTED
fs->block_size = (4 * 1024);
1092c6: bf88 it hi <== NOT EXECUTED
1092c8: 9419 strhi r4, [sp, #100] ; 0x64 <== NOT EXECUTED
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
1092ca: f00c fd1b bl 115d04 <__aeabi_uidivmod> <== NOT EXECUTED
1092ce: 2900 cmp r1, #0 <== NOT EXECUTED
1092d0: f43f ac0e beq.w 108af0 <rtems_rfs_format+0x78> <== NOT EXECUTED
printf ("block size (%zd) is not a multiple of media block size (%" PRId32 ")\n",
1092d4: f649 307c movw r0, #39804 ; 0x9b7c <== NOT EXECUTED
1092d8: 462a mov r2, r5 <== NOT EXECUTED
1092da: 4621 mov r1, r4 <== NOT EXECUTED
1092dc: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1092e0: f7fc fc1a bl 105b18 <__wrap_printf> <== NOT EXECUTED
return false;
1092e4: e5c4 b.n 108e70 <rtems_rfs_format+0x3f8> <== NOT EXECUTED
printf ("rtems-rfs: format: allocated inode not root ino: %" PRId32 "\n", ino);
1092e6: f24a 10bc movw r0, #41404 ; 0xa1bc <== NOT EXECUTED
1092ea: 4621 mov r1, r4 <== NOT EXECUTED
1092ec: f2c0 0011 movt r0, #17 <== NOT EXECUTED
return EINVAL;
1092f0: 2516 movs r5, #22 <== NOT EXECUTED
printf ("rtems-rfs: format: allocated inode not root ino: %" PRId32 "\n", ino);
1092f2: f7fc fc11 bl 105b18 <__wrap_printf> <== NOT EXECUTED
rtems_rfs_fs_close (fs);
1092f6: 9809 ldr r0, [sp, #36] ; 0x24 <== NOT EXECUTED
1092f8: f009 fc90 bl 112c1c <rtems_rfs_fs_close> <== NOT EXECUTED
printf ("rtems-rfs: format: writing root dir failed: %d: %s\n",
1092fc: 4628 mov r0, r5 <== NOT EXECUTED
1092fe: f00e fa37 bl 117770 <strerror> <== NOT EXECUTED
109302: 4602 mov r2, r0 <== NOT EXECUTED
109304: f24a 20f4 movw r0, #41716 ; 0xa2f4 <== NOT EXECUTED
109308: 4629 mov r1, r5 <== NOT EXECUTED
10930a: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10930e: f7fc fc03 bl 105b18 <__wrap_printf> <== NOT EXECUTED
errno = rc;
109312: f00d f859 bl 1163c8 <__errno> <== NOT EXECUTED
109316: 6005 str r5, [r0, #0] <== NOT EXECUTED
return -1;
109318: f04f 35ff mov.w r5, #4294967295 ; 0xffffffff <== NOT EXECUTED
10931c: e59b b.n 108e56 <rtems_rfs_format+0x3de> <== NOT EXECUTED
rc = errno;
10931e: f00d f853 bl 1163c8 <__errno> <== NOT EXECUTED
109322: 6805 ldr r5, [r0, #0] <== NOT EXECUTED
printf ("rtems-rfs: format: file system open failed: %d: %s\n",
109324: 4628 mov r0, r5 <== NOT EXECUTED
109326: f00e fa23 bl 117770 <strerror> <== NOT EXECUTED
10932a: 4602 mov r2, r0 <== NOT EXECUTED
10932c: f24a 1054 movw r0, #41300 ; 0xa154 <== NOT EXECUTED
109330: 4629 mov r1, r5 <== NOT EXECUTED
109332: f2c0 0011 movt r0, #17 <== NOT EXECUTED
109336: f7fc fbef bl 105b18 <__wrap_printf> <== NOT EXECUTED
if (rc != 0)
10933a: 2d00 cmp r5, #0 <== NOT EXECUTED
10933c: f43f aeb2 beq.w 1090a4 <rtems_rfs_format+0x62c> <== NOT EXECUTED
109340: e7dc b.n 1092fc <rtems_rfs_format+0x884> <== NOT EXECUTED
printf ("\n");
109342: 200a movs r0, #10 <== NOT EXECUTED
109344: f00d fcba bl 116cbc <putchar> <== NOT EXECUTED
109348: e649 b.n 108fde <rtems_rfs_format+0x566> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
10934a: a90a add r1, sp, #40 ; 0x28 <== NOT EXECUTED
10934c: a817 add r0, sp, #92 ; 0x5c <== NOT EXECUTED
10934e: f7ff fa11 bl 108774 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
109352: 2300 movs r3, #0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: close inode" \
109354: 4628 mov r0, r5 <== NOT EXECUTED
109356: f88d 3028 strb.w r3, [sp, #40] ; 0x28 <== NOT EXECUTED
handle->buffer = NULL;
10935a: e9cd 330b strd r3, r3, [sp, #44] ; 0x2c <== NOT EXECUTED
10935e: f00e fa07 bl 117770 <strerror> <== NOT EXECUTED
109362: 4603 mov r3, r0 <== NOT EXECUTED
109364: f24a 0094 movw r0, #41108 ; 0xa094 <== NOT EXECUTED
109368: 462a mov r2, r5 <== NOT EXECUTED
10936a: 4621 mov r1, r4 <== NOT EXECUTED
10936c: f2c0 0011 movt r0, #17 <== NOT EXECUTED
109370: f7fc fbd2 bl 105b18 <__wrap_printf> <== NOT EXECUTED
return false;
109374: e6af b.n 1090d6 <rtems_rfs_format+0x65e> <== NOT EXECUTED
printf ("rtems-rfs: format: inode allocation failed: %d: %s\n",
109376: f00e f9fb bl 117770 <strerror> <== NOT EXECUTED
10937a: 4602 mov r2, r0 <== NOT EXECUTED
10937c: f24a 1088 movw r0, #41352 ; 0xa188 <== NOT EXECUTED
109380: 4629 mov r1, r5 <== NOT EXECUTED
109382: f2c0 0011 movt r0, #17 <== NOT EXECUTED
109386: f7fc fbc7 bl 105b18 <__wrap_printf> <== NOT EXECUTED
rtems_rfs_fs_close (fs);
10938a: 9809 ldr r0, [sp, #36] ; 0x24 <== NOT EXECUTED
10938c: f009 fc46 bl 112c1c <rtems_rfs_fs_close> <== NOT EXECUTED
return rc;
109390: e7b4 b.n 1092fc <rtems_rfs_format+0x884> <== NOT EXECUTED
109392: 2401 movs r4, #1 <== NOT EXECUTED
109394: e771 b.n 10927a <rtems_rfs_format+0x802> <== NOT EXECUTED
printf ("rtems-rfs: format: inode open failed: %d: %s\n",
109396: f00e f9eb bl 117770 <strerror> <== NOT EXECUTED
10939a: 4602 mov r2, r0 <== NOT EXECUTED
10939c: f24a 10f4 movw r0, #41460 ; 0xa1f4 <== NOT EXECUTED
1093a0: 4629 mov r1, r5 <== NOT EXECUTED
1093a2: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1093a6: f7fc fbb7 bl 105b18 <__wrap_printf> <== NOT EXECUTED
rtems_rfs_group_bitmap_free (fs, true, ino);
1093aa: e9dd 0209 ldrd r0, r2, [sp, #36] ; 0x24 <== NOT EXECUTED
1093ae: 4621 mov r1, r4 <== NOT EXECUTED
1093b0: f000 fa22 bl 1097f8 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
rtems_rfs_fs_close (fs);
1093b4: 9809 ldr r0, [sp, #36] ; 0x24 <== NOT EXECUTED
1093b6: f009 fc31 bl 112c1c <rtems_rfs_fs_close> <== NOT EXECUTED
return rc;
1093ba: e79f b.n 1092fc <rtems_rfs_format+0x884> <== NOT EXECUTED
printf ("rtems-rfs: format: inode close failed: %d: %s\n",
1093bc: f00e f9d8 bl 117770 <strerror> <== NOT EXECUTED
1093c0: 4602 mov r2, r0 <== NOT EXECUTED
1093c2: f24a 208c movw r0, #41612 ; 0xa28c <== NOT EXECUTED
1093c6: 4621 mov r1, r4 <== NOT EXECUTED
1093c8: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1093cc: f7fc fba4 bl 105b18 <__wrap_printf> <== NOT EXECUTED
1093d0: e650 b.n 109074 <rtems_rfs_format+0x5fc> <== NOT EXECUTED
printf ("rtems-rfs: format: directory add failed: %d: %s\n",
1093d2: f00e f9cd bl 117770 <strerror> <== NOT EXECUTED
1093d6: 4602 mov r2, r0 <== NOT EXECUTED
1093d8: f24a 2058 movw r0, #41560 ; 0xa258 <== NOT EXECUTED
1093dc: 4621 mov r1, r4 <== NOT EXECUTED
1093de: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1093e2: f7fc fb99 bl 105b18 <__wrap_printf> <== NOT EXECUTED
1093e6: e63d b.n 109064 <rtems_rfs_format+0x5ec> <== NOT EXECUTED
printf ("rtems-rfs: format: inode initialise failed: %d: %s\n",
1093e8: f00e f9c2 bl 117770 <strerror> <== NOT EXECUTED
1093ec: 4602 mov r2, r0 <== NOT EXECUTED
1093ee: f24a 2024 movw r0, #41508 ; 0xa224 <== NOT EXECUTED
1093f2: 4621 mov r1, r4 <== NOT EXECUTED
1093f4: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1093f8: f7fc fb8e bl 105b18 <__wrap_printf> <== NOT EXECUTED
1093fc: e623 b.n 109046 <rtems_rfs_format+0x5ce> <== NOT EXECUTED
printf ("rtems-rfs: media block is invalid: %" PRIu32 "\n",
1093fe: f649 3054 movw r0, #39764 ; 0x9b54 <== NOT EXECUTED
109402: 4629 mov r1, r5 <== NOT EXECUTED
109404: f2c0 0011 movt r0, #17 <== NOT EXECUTED
return -1;
109408: f04f 35ff mov.w r5, #4294967295 ; 0xffffffff <== NOT EXECUTED
printf ("rtems-rfs: media block is invalid: %" PRIu32 "\n",
10940c: f7fc fb84 bl 105b18 <__wrap_printf> <== NOT EXECUTED
errno = EINVAL;
109410: f00c ffda bl 1163c8 <__errno> <== NOT EXECUTED
109414: 2316 movs r3, #22 <== NOT EXECUTED
109416: 6003 str r3, [r0, #0] <== NOT EXECUTED
return -1;
109418: e51d b.n 108e56 <rtems_rfs_format+0x3de> <== NOT EXECUTED
printf ("rtems-rfs: format: setting block size failed: %d: %s\n",
10941a: f00e f9a9 bl 117770 <strerror> <== NOT EXECUTED
10941e: 4602 mov r2, r0 <== NOT EXECUTED
109420: f649 50c0 movw r0, #40384 ; 0x9dc0 <== NOT EXECUTED
109424: 4621 mov r1, r4 <== NOT EXECUTED
109426: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10942a: f7fc fb75 bl 105b18 <__wrap_printf> <== NOT EXECUTED
return -1;
10942e: f04f 35ff mov.w r5, #4294967295 ; 0xffffffff <== NOT EXECUTED
errno = rc;
109432: f00c ffc9 bl 1163c8 <__errno> <== NOT EXECUTED
109436: 6004 str r4, [r0, #0] <== NOT EXECUTED
return -1;
109438: e50d b.n 108e56 <rtems_rfs_format+0x3de> <== NOT EXECUTED
printf ("rtems-rfs: format: buffer open failed: %d: %s\n",
10943a: f00e f999 bl 117770 <strerror> <== NOT EXECUTED
10943e: 4602 mov r2, r0 <== NOT EXECUTED
109440: f649 3024 movw r0, #39716 ; 0x9b24 <== NOT EXECUTED
109444: 4621 mov r1, r4 <== NOT EXECUTED
109446: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10944a: f7fc fb65 bl 105b18 <__wrap_printf> <== NOT EXECUTED
return -1;
10944e: f04f 35ff mov.w r5, #4294967295 ; 0xffffffff <== NOT EXECUTED
errno = rc;
109452: f00c ffb9 bl 1163c8 <__errno> <== NOT EXECUTED
109456: 6004 str r4, [r0, #0] <== NOT EXECUTED
return -1;
109458: e4fd b.n 108e56 <rtems_rfs_format+0x3de> <== NOT EXECUTED
printf ("rtems-rfs: format: buffer close failed: %d: %s\n",
10945a: 9003 str r0, [sp, #12] <== NOT EXECUTED
return -1;
10945c: f04f 35ff mov.w r5, #4294967295 ; 0xffffffff <== NOT EXECUTED
printf ("rtems-rfs: format: buffer close failed: %d: %s\n",
109460: f00e f986 bl 117770 <strerror> <== NOT EXECUTED
109464: 9b03 ldr r3, [sp, #12] <== NOT EXECUTED
109466: 4602 mov r2, r0 <== NOT EXECUTED
109468: f24a 1024 movw r0, #41252 ; 0xa124 <== NOT EXECUTED
10946c: f2c0 0011 movt r0, #17 <== NOT EXECUTED
109470: 4619 mov r1, r3 <== NOT EXECUTED
109472: f7fc fb51 bl 105b18 <__wrap_printf> <== NOT EXECUTED
errno = rc;
109476: f00c ffa7 bl 1163c8 <__errno> <== NOT EXECUTED
10947a: 9b03 ldr r3, [sp, #12] <== NOT EXECUTED
10947c: 6003 str r3, [r0, #0] <== NOT EXECUTED
return -1;
10947e: e4ea b.n 108e56 <rtems_rfs_format+0x3de> <== NOT EXECUTED
00112c1c <rtems_rfs_fs_close>:
int
rtems_rfs_fs_close (rtems_rfs_file_system* fs)
{
112c1c: b570 push {r4, r5, r6, lr}
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
112c1e: 2100 movs r1, #0
{
112c20: 4604 mov r4, r0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
112c22: 2002 movs r0, #2
112c24: f7f7 feaa bl 10a97c <rtems_rfs_trace>
112c28: b9b0 cbnz r0, 112c58 <rtems_rfs_fs_close+0x3c>
printf ("rtems-rfs: close\n");
for (group = 0; group < fs->group_count; group++)
112c2a: 6a63 ldr r3, [r4, #36] ; 0x24
112c2c: 2b00 cmp r3, #0
112c2e: dd0b ble.n 112c48 <rtems_rfs_fs_close+0x2c> <== ALWAYS TAKEN
112c30: 2500 movs r5, #0
112c32: 462e mov r6, r5
rtems_rfs_group_close (fs, &fs->groups[group]);
112c34: 6a21 ldr r1, [r4, #32]
112c36: 4620 mov r0, r4
for (group = 0; group < fs->group_count; group++)
112c38: 3601 adds r6, #1
rtems_rfs_group_close (fs, &fs->groups[group]);
112c3a: 4429 add r1, r5
for (group = 0; group < fs->group_count; group++)
112c3c: 3550 adds r5, #80 ; 0x50
rtems_rfs_group_close (fs, &fs->groups[group]);
112c3e: f7f6 fcdb bl 1095f8 <rtems_rfs_group_close>
for (group = 0; group < fs->group_count; group++)
112c42: 6a63 ldr r3, [r4, #36] ; 0x24
112c44: 42b3 cmp r3, r6
112c46: dcf5 bgt.n 112c34 <rtems_rfs_fs_close+0x18> <== ALWAYS TAKEN
rtems_rfs_buffer_close (fs);
112c48: 4620 mov r0, r4
112c4a: f7f5 fecb bl 1089e4 <rtems_rfs_buffer_close>
free (fs);
112c4e: 4620 mov r0, r4
112c50: f7f3 f85e bl 105d10 <free>
return 0;
}
112c54: 2000 movs r0, #0
112c56: bd70 pop {r4, r5, r6, pc}
printf ("rtems-rfs: close\n");
112c58: f64b 3020 movw r0, #47904 ; 0xbb20 <== NOT EXECUTED
112c5c: f2c0 0011 movt r0, #17 <== NOT EXECUTED
112c60: f7f2 ff6c bl 105b3c <__wrap_puts> <== NOT EXECUTED
112c64: e7e1 b.n 112c2a <rtems_rfs_fs_close+0xe> <== NOT EXECUTED
112c66: bf00 nop
00112790 <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)
{
112790: e92d 43f0 stmdb sp!, {r4, r5, r6, r7, r8, r9, lr}
112794: 4606 mov r6, r0
112796: b08d sub sp, #52 ; 0x34
112798: 4689 mov r9, r1
#endif
rtems_rfs_inode_handle inode;
uint16_t mode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
11279a: 2001 movs r0, #1
11279c: 2100 movs r1, #0
{
11279e: 9f14 ldr r7, [sp, #80] ; 0x50
1127a0: 4690 mov r8, r2
1127a2: 461d mov r5, r3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
1127a4: f7f8 f8ea bl 10a97c <rtems_rfs_trace>
1127a8: 2800 cmp r0, #0
1127aa: f040 80e5 bne.w 112978 <rtems_rfs_fs_open+0x1e8> <== ALWAYS TAKEN
printf ("rtems-rfs: open: %s\n", name);
*fs = malloc (sizeof (rtems_rfs_file_system));
1127ae: 2084 movs r0, #132 ; 0x84
1127b0: f7f3 fb04 bl 105dbc <malloc>
1127b4: 4604 mov r4, r0
1127b6: 6038 str r0, [r7, #0]
if (!*fs)
1127b8: 2800 cmp r0, #0
1127ba: f000 8203 beq.w 112bc4 <rtems_rfs_fs_open+0x434> <== ALWAYS TAKEN
printf ("rtems-rfs: open: no memory for file system data\n");
errno = ENOMEM;
return -1;
}
memset (*fs, 0, sizeof (rtems_rfs_file_system));
1127be: 2280 movs r2, #128 ; 0x80
1127c0: 2100 movs r1, #0
1127c2: 3004 adds r0, #4
1127c4: f004 fa28 bl 116c18 <memset>
return &the_chain->Tail.Node;
1127c8: f104 0344 add.w r3, r4, #68 ; 0x44
#endif
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, *fs);
1127cc: 4621 mov r1, r4
tail->previous = head;
1127ce: 64e3 str r3, [r4, #76] ; 0x4c
return &the_chain->Tail.Node;
1127d0: f104 0354 add.w r3, r4, #84 ; 0x54
tail->previous = head;
1127d4: 65e3 str r3, [r4, #92] ; 0x5c
return &the_chain->Tail.Node;
1127d6: f104 0364 add.w r3, r4, #100 ; 0x64
tail->previous = head;
1127da: 66e3 str r3, [r4, #108] ; 0x6c
return &the_chain->Tail.Node;
1127dc: f104 0374 add.w r3, r4, #116 ; 0x74
tail->previous = head;
1127e0: 67e3 str r3, [r4, #124] ; 0x7c
return &the_chain->Tail.Node;
1127e2: f104 0348 add.w r3, r4, #72 ; 0x48
head->next = tail;
1127e6: 6463 str r3, [r4, #68] ; 0x44
return &the_chain->Tail.Node;
1127e8: f104 0358 add.w r3, r4, #88 ; 0x58
head->next = tail;
1127ec: 6563 str r3, [r4, #84] ; 0x54
return &the_chain->Tail.Node;
1127ee: f104 0368 add.w r3, r4, #104 ; 0x68
head->next = tail;
1127f2: 6663 str r3, [r4, #100] ; 0x64
return &the_chain->Tail.Node;
1127f4: f104 0378 add.w r3, r4, #120 ; 0x78
(*fs)->user = user;
1127f8: f8c4 9080 str.w r9, [r4, #128] ; 0x80
rc = rtems_rfs_buffer_open (name, *fs);
1127fc: 4630 mov r0, r6
(*fs)->max_held_buffers = max_held_buffers;
1127fe: 6425 str r5, [r4, #64] ; 0x40
(*fs)->flags = flags;
112800: f8c4 8000 str.w r8, [r4]
head->next = tail;
112804: 6763 str r3, [r4, #116] ; 0x74
rc = rtems_rfs_buffer_open (name, *fs);
112806: f7f5 ffbb bl 108780 <rtems_rfs_buffer_open>
if (rc > 0)
11280a: 1e04 subs r4, r0, #0
11280c: f300 8170 bgt.w 112af0 <rtems_rfs_fs_open+0x360> <== ALWAYS TAKEN
rc, strerror (rc));
errno = rc;
return -1;
}
rc = rtems_rfs_fs_read_superblock (*fs);
112810: 683c ldr r4, [r7, #0]
handle->dirty = false;
112812: 2500 movs r5, #0
rc = rtems_rfs_buffer_handle_request (fs, &handle, 0, true);
112814: 2301 movs r3, #1
112816: 462a mov r2, r5
112818: a902 add r1, sp, #8
11281a: f88d 5008 strb.w r5, [sp, #8]
11281e: 4620 mov r0, r4
handle->buffer = NULL;
112820: e9cd 5503 strd r5, r5, [sp, #12]
112824: f7f5 feba bl 10859c <rtems_rfs_buffer_handle_request>
if (rc > 0)
112828: 1e06 subs r6, r0, #0
11282a: f300 80ad bgt.w 112988 <rtems_rfs_fs_open+0x1f8> <== ALWAYS TAKEN
sb = rtems_rfs_buffer_data (&handle);
11282e: 9b04 ldr r3, [sp, #16]
112830: 69de ldr r6, [r3, #28]
if (read_sb (RTEMS_RFS_SB_OFFSET_MAGIC) != RTEMS_RFS_SB_MAGIC)
112832: f640 1328 movw r3, #2344 ; 0x928
112836: f2c0 1320 movt r3, #288 ; 0x120
11283a: 6832 ldr r2, [r6, #0]
11283c: 429a cmp r2, r3
11283e: f040 8106 bne.w 112a4e <rtems_rfs_fs_open+0x2be> <== ALWAYS TAKEN
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
112842: 68f3 ldr r3, [r6, #12]
uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
112844: 6921 ldr r1, [r4, #16]
112846: ba1b rev r3, r3
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
112848: 6063 str r3, [r4, #4]
return media_blocks * media_block_size;
11284a: e9d1 0107 ldrd r0, r1, [r1, #28]
11284e: 68b2 ldr r2, [r6, #8]
112850: ba12 rev r2, r2
112852: fba0 0101 umull r0, r1, r0, r1
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
112856: 60a2 str r2, [r4, #8]
return blocks * block_size;
112858: fba3 3c02 umull r3, ip, r3, r2
if (rtems_rfs_fs_size(fs) > rtems_rfs_fs_media_size (fs))
11285c: 4298 cmp r0, r3
11285e: eb71 030c sbcs.w r3, r1, ip
112862: f0c0 8116 bcc.w 112a92 <rtems_rfs_fs_open+0x302> <== ALWAYS TAKEN
if (read_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE) != RTEMS_RFS_INODE_SIZE)
112866: 6a73 ldr r3, [r6, #36] ; 0x24
112868: f1b3 5f60 cmp.w r3, #939524096 ; 0x38000000
11286c: f040 80be bne.w 1129ec <rtems_rfs_fs_open+0x25c> <== ALWAYS TAKEN
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
112870: 6933 ldr r3, [r6, #16]
112872: ba1b rev r3, r3
112874: 61a3 str r3, [r4, #24]
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
112876: 6973 ldr r3, [r6, #20]
112878: ba1b rev r3, r3
11287a: 61e3 str r3, [r4, #28]
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
11287c: 69b3 ldr r3, [r6, #24]
11287e: ba1b rev r3, r3
112880: 6263 str r3, [r4, #36] ; 0x24
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
112882: 69f1 ldr r1, [r6, #28]
112884: ba09 rev r1, r1
112886: 62a1 str r1, [r4, #40] ; 0x28
if (fs->group_blocks >
112888: ebb1 0fc2 cmp.w r1, r2, lsl #3
11288c: 6a30 ldr r0, [r6, #32]
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
11288e: f644 1625 movw r6, #18725 ; 0x4925
112892: f2c2 4692 movt r6, #9362 ; 0x2492
rtems_rfs_buffer_handle_release (fs, handle);
112896: a902 add r1, sp, #8
112898: ba00 rev r0, r0
fs->inodes = fs->group_count * fs->group_inodes;
11289a: fb00 f303 mul.w r3, r0, r3
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
11289e: 62e0 str r0, [r4, #44] ; 0x2c
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
1128a0: ea4f 00d2 mov.w r0, r2, lsr #3
1128a4: fba6 6000 umull r6, r0, r6, r0
fs->inodes = fs->group_count * fs->group_inodes;
1128a8: 6163 str r3, [r4, #20]
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
1128aa: ea4f 0392 mov.w r3, r2, lsr #2
fs->blocks_per_block =
1128ae: 6363 str r3, [r4, #52] ; 0x34
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
1128b0: 6320 str r0, [r4, #48] ; 0x30
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
1128b2: fb03 f003 mul.w r0, r3, r3
fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
1128b6: eb03 0383 add.w r3, r3, r3, lsl #2
fs->block_map_singly_blocks =
1128ba: 63a3 str r3, [r4, #56] ; 0x38
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
1128bc: eb00 0080 add.w r0, r0, r0, lsl #2
fs->block_map_doubly_blocks =
1128c0: 63e0 str r0, [r4, #60] ; 0x3c
1128c2: 4620 mov r0, r4
if (fs->group_blocks >
1128c4: f200 80d0 bhi.w 112a68 <rtems_rfs_fs_open+0x2d8> <== ALWAYS TAKEN
1128c8: f7f5 ff54 bl 108774 <rtems_rfs_buffer_handle_release>
rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_block_size (fs));
1128cc: 68a1 ldr r1, [r4, #8]
1128ce: 4620 mov r0, r4
handle->dirty = false;
1128d0: f88d 5008 strb.w r5, [sp, #8]
handle->buffer = NULL;
1128d4: e9cd 5503 strd r5, r5, [sp, #12]
1128d8: f7f6 f82c bl 108934 <rtems_rfs_buffer_setblksize>
if (rc > 0)
1128dc: 1e06 subs r6, r0, #0
1128de: dc64 bgt.n 1129aa <rtems_rfs_fs_open+0x21a> <== ALWAYS TAKEN
fs->groups = calloc (fs->group_count, sizeof (rtems_rfs_group));
1128e0: 6a65 ldr r5, [r4, #36] ; 0x24
1128e2: 2150 movs r1, #80 ; 0x50
1128e4: 4628 mov r0, r5
1128e6: f7fd f8f7 bl 10fad8 <calloc>
1128ea: 4606 mov r6, r0
1128ec: 6220 str r0, [r4, #32]
if (!fs->groups)
1128ee: 2800 cmp r0, #0
1128f0: f000 817c beq.w 112bec <rtems_rfs_fs_open+0x45c> <== ALWAYS TAKEN
for (group = 0; group < fs->group_count; group++)
1128f4: 2d00 cmp r5, #0
1128f6: bfc8 it gt
1128f8: 2500 movgt r5, #0
1128fa: dc05 bgt.n 112908 <rtems_rfs_fs_open+0x178> <== NEVER TAKEN
1128fc: e082 b.n 112a04 <rtems_rfs_fs_open+0x274> <== NOT EXECUTED
1128fe: 6a63 ldr r3, [r4, #36] ; 0x24
112900: 3501 adds r5, #1
112902: 429d cmp r5, r3
112904: da7e bge.n 112a04 <rtems_rfs_fs_open+0x274> <== NEVER TAKEN
&fs->groups[group]);
112906: 6a26 ldr r6, [r4, #32] <== NOT EXECUTED
rtems_rfs_fs_block (fs, group, 0),
112908: 6aa2 ldr r2, [r4, #40] ; 0x28
rc = rtems_rfs_group_open (fs,
11290a: eb05 0185 add.w r1, r5, r5, lsl #2
11290e: 6ae3 ldr r3, [r4, #44] ; 0x2c
112910: 4620 mov r0, r4
112912: eb06 1601 add.w r6, r6, r1, lsl #4
rtems_rfs_fs_block (fs, group, 0),
112916: fb02 f105 mul.w r1, r2, r5
rc = rtems_rfs_group_open (fs,
11291a: 9600 str r6, [sp, #0]
11291c: 3101 adds r1, #1
11291e: f7f6 fdaf bl 109480 <rtems_rfs_group_open>
if (rc > 0)
112922: 1e06 subs r6, r0, #0
112924: ddeb ble.n 1128fe <rtems_rfs_fs_open+0x16e> <== NEVER TAKEN
for (g = 0; g < group; g++)
112926: f04f 0800 mov.w r8, #0 <== NOT EXECUTED
11292a: 46c1 mov r9, r8 <== NOT EXECUTED
11292c: b155 cbz r5, 112944 <rtems_rfs_fs_open+0x1b4> <== NOT EXECUTED
rtems_rfs_group_close (fs, &fs->groups[g]);
11292e: 6a21 ldr r1, [r4, #32] <== NOT EXECUTED
for (g = 0; g < group; g++)
112930: f109 0901 add.w r9, r9, #1 <== NOT EXECUTED
rtems_rfs_group_close (fs, &fs->groups[g]);
112934: 4620 mov r0, r4 <== NOT EXECUTED
112936: 4441 add r1, r8 <== NOT EXECUTED
for (g = 0; g < group; g++)
112938: f108 0850 add.w r8, r8, #80 ; 0x50 <== NOT EXECUTED
rtems_rfs_group_close (fs, &fs->groups[g]);
11293c: f7f6 fe5c bl 1095f8 <rtems_rfs_group_close> <== NOT EXECUTED
for (g = 0; g < group; g++)
112940: 45a9 cmp r9, r5 <== NOT EXECUTED
112942: d1f4 bne.n 11292e <rtems_rfs_fs_open+0x19e> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
112944: a902 add r1, sp, #8 <== NOT EXECUTED
112946: 4620 mov r0, r4 <== NOT EXECUTED
112948: f7f5 ff14 bl 108774 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
11294c: 2300 movs r3, #0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
11294e: 2001 movs r0, #1 <== NOT EXECUTED
112950: 2100 movs r1, #0 <== NOT EXECUTED
112952: f88d 3008 strb.w r3, [sp, #8] <== NOT EXECUTED
handle->buffer = NULL;
112956: e9cd 3303 strd r3, r3, [sp, #12] <== NOT EXECUTED
11295a: f7f8 f80f bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
11295e: b390 cbz r0, 1129c6 <rtems_rfs_fs_open+0x236> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table%d: %s\n",
112960: 4630 mov r0, r6 <== NOT EXECUTED
112962: f004 ff05 bl 117770 <strerror> <== NOT EXECUTED
112966: 4602 mov r2, r0 <== NOT EXECUTED
112968: f64b 2024 movw r0, #47652 ; 0xba24 <== NOT EXECUTED
11296c: 4631 mov r1, r6 <== NOT EXECUTED
11296e: f2c0 0011 movt r0, #17 <== NOT EXECUTED
112972: f7f3 f8d1 bl 105b18 <__wrap_printf> <== NOT EXECUTED
112976: e026 b.n 1129c6 <rtems_rfs_fs_open+0x236> <== NOT EXECUTED
printf ("rtems-rfs: open: %s\n", name);
112978: f24b 70f8 movw r0, #47096 ; 0xb7f8 <== NOT EXECUTED
11297c: 4631 mov r1, r6 <== NOT EXECUTED
11297e: f2c0 0011 movt r0, #17 <== NOT EXECUTED
112982: f7f3 f8c9 bl 105b18 <__wrap_printf> <== NOT EXECUTED
112986: e712 b.n 1127ae <rtems_rfs_fs_open+0x1e> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
112988: 2001 movs r0, #1 <== NOT EXECUTED
11298a: 2100 movs r1, #0 <== NOT EXECUTED
11298c: f7f7 fff6 bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
112990: b1c8 cbz r0, 1129c6 <rtems_rfs_fs_open+0x236> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: request failed%d: %s\n",
112992: 4630 mov r0, r6 <== NOT EXECUTED
112994: f004 feec bl 117770 <strerror> <== NOT EXECUTED
112998: 4602 mov r2, r0 <== NOT EXECUTED
11299a: f64b 0070 movw r0, #47216 ; 0xb870 <== NOT EXECUTED
11299e: 4631 mov r1, r6 <== NOT EXECUTED
1129a0: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1129a4: f7f3 f8b8 bl 105b18 <__wrap_printf> <== NOT EXECUTED
1129a8: e00d b.n 1129c6 <rtems_rfs_fs_open+0x236> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
1129aa: a902 add r1, sp, #8 <== NOT EXECUTED
1129ac: 4620 mov r0, r4 <== NOT EXECUTED
1129ae: f7f5 fee1 bl 108774 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
1129b2: 2001 movs r0, #1 <== NOT EXECUTED
1129b4: 2100 movs r1, #0 <== NOT EXECUTED
handle->dirty = false;
1129b6: f88d 5008 strb.w r5, [sp, #8] <== NOT EXECUTED
handle->buffer = NULL;
1129ba: e9cd 5503 strd r5, r5, [sp, #12] <== NOT EXECUTED
1129be: f7f7 ffdd bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
1129c2: 2800 cmp r0, #0 <== NOT EXECUTED
1129c4: d17e bne.n 112ac4 <rtems_rfs_fs_open+0x334> <== NOT EXECUTED
if (rc > 0)
{
rtems_rfs_buffer_close (*fs);
1129c6: 6838 ldr r0, [r7, #0] <== NOT EXECUTED
1129c8: f7f6 f80c bl 1089e4 <rtems_rfs_buffer_close> <== NOT EXECUTED
free (*fs);
1129cc: 6838 ldr r0, [r7, #0] <== NOT EXECUTED
1129ce: f7f3 f99f bl 105d10 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
1129d2: 2001 movs r0, #1 <== NOT EXECUTED
1129d4: 2100 movs r1, #0 <== NOT EXECUTED
1129d6: f7f7 ffd1 bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
1129da: 2800 cmp r0, #0 <== NOT EXECUTED
1129dc: d166 bne.n 112aac <rtems_rfs_fs_open+0x31c> <== NOT EXECUTED
printf ("rtems-rfs: open: reading superblock: %d: %s\n",
rc, strerror (rc));
errno = rc;
1129de: f003 fcf3 bl 1163c8 <__errno> <== NOT EXECUTED
1129e2: 4603 mov r3, r0 <== NOT EXECUTED
return -1;
1129e4: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff <== NOT EXECUTED
errno = rc;
1129e8: 601e str r6, [r3, #0] <== NOT EXECUTED
return -1;
1129ea: e02d b.n 112a48 <rtems_rfs_fs_open+0x2b8> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
1129ec: 2001 movs r0, #1 <== NOT EXECUTED
1129ee: 2100 movs r1, #0 <== NOT EXECUTED
1129f0: f7f7 ffc4 bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
1129f4: 2800 cmp r0, #0 <== NOT EXECUTED
1129f6: d171 bne.n 112adc <rtems_rfs_fs_open+0x34c> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
1129f8: a902 add r1, sp, #8 <== NOT EXECUTED
1129fa: 4620 mov r0, r4 <== NOT EXECUTED
return EIO;
1129fc: 2605 movs r6, #5 <== NOT EXECUTED
1129fe: f7f5 feb9 bl 108774 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
if (rc > 0)
112a02: e7e0 b.n 1129c6 <rtems_rfs_fs_open+0x236> <== NOT EXECUTED
}
rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);
112a04: 2301 movs r3, #1
112a06: 6838 ldr r0, [r7, #0]
112a08: aa02 add r2, sp, #8
112a0a: 4619 mov r1, r3
112a0c: f7f6 ff9e bl 10994c <rtems_rfs_inode_open>
if (rc > 0)
112a10: 1e04 subs r4, r0, #0
112a12: f300 8094 bgt.w 112b3e <rtems_rfs_fs_open+0x3ae> <== ALWAYS TAKEN
rc, strerror (rc));
errno = rc;
return -1;
}
if (((*fs)->flags & RTEMS_RFS_FS_FORCE_OPEN) == 0)
112a16: 6838 ldr r0, [r7, #0]
112a18: 6803 ldr r3, [r0, #0]
112a1a: 075b lsls r3, r3, #29
112a1c: d40c bmi.n 112a38 <rtems_rfs_fs_open+0x2a8>
return rtems_rfs_read_u16 (&handle->node->mode);
112a1e: 9b05 ldr r3, [sp, #20]
{
mode = rtems_rfs_inode_get_mode (&inode);
if ((mode == 0xffff) || !RTEMS_RFS_S_ISDIR (mode))
112a20: f64f 72ff movw r2, #65535 ; 0xffff
112a24: 885b ldrh r3, [r3, #2]
112a26: ba5b rev16 r3, r3
112a28: b29b uxth r3, r3
112a2a: 4293 cmp r3, r2
112a2c: d070 beq.n 112b10 <rtems_rfs_fs_open+0x380> <== ALWAYS TAKEN
112a2e: f403 4370 and.w r3, r3, #61440 ; 0xf000
112a32: f5b3 4f80 cmp.w r3, #16384 ; 0x4000
112a36: d16b bne.n 112b10 <rtems_rfs_fs_open+0x380> <== ALWAYS TAKEN
errno = EIO;
return -1;
}
}
rc = rtems_rfs_inode_close (*fs, &inode);
112a38: a902 add r1, sp, #8
112a3a: f7f7 f80f bl 109a5c <rtems_rfs_inode_close>
if (rc > 0)
112a3e: 1e04 subs r4, r0, #0
printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
errno = rc;
return -1;
}
return 0;
112a40: bfd8 it le
112a42: 2000 movle r0, #0
if (rc > 0)
112a44: f300 8093 bgt.w 112b6e <rtems_rfs_fs_open+0x3de> <== ALWAYS TAKEN
}
112a48: b00d add sp, #52 ; 0x34
112a4a: e8bd 83f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, pc}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
112a4e: 2001 movs r0, #1 <== NOT EXECUTED
112a50: 2100 movs r1, #0 <== NOT EXECUTED
112a52: f7f7 ff93 bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
112a56: 2800 cmp r0, #0 <== NOT EXECUTED
112a58: d0ce beq.n 1129f8 <rtems_rfs_fs_open+0x268> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock, bad magic\n");
112a5a: f64b 00a4 movw r0, #47268 ; 0xb8a4 <== NOT EXECUTED
112a5e: f2c0 0011 movt r0, #17 <== NOT EXECUTED
112a62: f7f3 f86b bl 105b3c <__wrap_puts> <== NOT EXECUTED
112a66: e7c7 b.n 1129f8 <rtems_rfs_fs_open+0x268> <== NOT EXECUTED
112a68: f7f5 fe84 bl 108774 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
112a6c: 2001 movs r0, #1 <== NOT EXECUTED
112a6e: 2100 movs r1, #0 <== NOT EXECUTED
handle->dirty = false;
112a70: f88d 5008 strb.w r5, [sp, #8] <== NOT EXECUTED
return EIO;
112a74: 2605 movs r6, #5 <== NOT EXECUTED
handle->buffer = NULL;
112a76: e9cd 5503 strd r5, r5, [sp, #12] <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
112a7a: f7f7 ff7f bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
112a7e: 2800 cmp r0, #0 <== NOT EXECUTED
112a80: d0a1 beq.n 1129c6 <rtems_rfs_fs_open+0x236> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: groups blocks larger than block bits\n");
112a82: f64b 1064 movw r0, #47460 ; 0xb964 <== NOT EXECUTED
return EIO;
112a86: 2605 movs r6, #5 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: groups blocks larger than block bits\n");
112a88: f2c0 0011 movt r0, #17 <== NOT EXECUTED
112a8c: f7f3 f856 bl 105b3c <__wrap_puts> <== NOT EXECUTED
if (rc > 0)
112a90: e799 b.n 1129c6 <rtems_rfs_fs_open+0x236> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
112a92: 2001 movs r0, #1 <== NOT EXECUTED
112a94: 2100 movs r1, #0 <== NOT EXECUTED
112a96: f7f7 ff71 bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
112a9a: 2800 cmp r0, #0 <== NOT EXECUTED
112a9c: d0ac beq.n 1129f8 <rtems_rfs_fs_open+0x268> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block/size count\n");
112a9e: f64b 00e0 movw r0, #47328 ; 0xb8e0 <== NOT EXECUTED
112aa2: f2c0 0011 movt r0, #17 <== NOT EXECUTED
112aa6: f7f3 f849 bl 105b3c <__wrap_puts> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
112aaa: e7a5 b.n 1129f8 <rtems_rfs_fs_open+0x268> <== NOT EXECUTED
printf ("rtems-rfs: open: reading superblock: %d: %s\n",
112aac: 4630 mov r0, r6 <== NOT EXECUTED
112aae: f004 fe5f bl 117770 <strerror> <== NOT EXECUTED
112ab2: 4602 mov r2, r0 <== NOT EXECUTED
112ab4: f64b 2064 movw r0, #47716 ; 0xba64 <== NOT EXECUTED
112ab8: 4631 mov r1, r6 <== NOT EXECUTED
112aba: f2c0 0011 movt r0, #17 <== NOT EXECUTED
112abe: f7f3 f82b bl 105b18 <__wrap_printf> <== NOT EXECUTED
112ac2: e78c b.n 1129de <rtems_rfs_fs_open+0x24e> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block size%d: %s\n",
112ac4: 4630 mov r0, r6 <== NOT EXECUTED
112ac6: f004 fe53 bl 117770 <strerror> <== NOT EXECUTED
112aca: 4602 mov r2, r0 <== NOT EXECUTED
112acc: f64b 10a8 movw r0, #47528 ; 0xb9a8 <== NOT EXECUTED
112ad0: 4631 mov r1, r6 <== NOT EXECUTED
112ad2: f2c0 0011 movt r0, #17 <== NOT EXECUTED
112ad6: f7f3 f81f bl 105b18 <__wrap_printf> <== NOT EXECUTED
112ada: e774 b.n 1129c6 <rtems_rfs_fs_open+0x236> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: inode size mismatch: fs:%" PRId32 " target:%" PRId32 "\n",
112adc: 6871 ldr r1, [r6, #4] <== NOT EXECUTED
112ade: f64b 1020 movw r0, #47392 ; 0xb920 <== NOT EXECUTED
112ae2: 462a mov r2, r5 <== NOT EXECUTED
112ae4: f2c0 0011 movt r0, #17 <== NOT EXECUTED
112ae8: ba09 rev r1, r1 <== NOT EXECUTED
112aea: f7f3 f815 bl 105b18 <__wrap_printf> <== NOT EXECUTED
112aee: e783 b.n 1129f8 <rtems_rfs_fs_open+0x268> <== NOT EXECUTED
free (*fs);
112af0: 6838 ldr r0, [r7, #0] <== NOT EXECUTED
112af2: f7f3 f90d bl 105d10 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
112af6: 2001 movs r0, #1 <== NOT EXECUTED
112af8: 2100 movs r1, #0 <== NOT EXECUTED
112afa: f7f7 ff3f bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
112afe: 2800 cmp r0, #0 <== NOT EXECUTED
112b00: d14d bne.n 112b9e <rtems_rfs_fs_open+0x40e> <== NOT EXECUTED
errno = rc;
112b02: f003 fc61 bl 1163c8 <__errno> <== NOT EXECUTED
112b06: 4603 mov r3, r0 <== NOT EXECUTED
return -1;
112b08: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff <== NOT EXECUTED
errno = rc;
112b0c: 601c str r4, [r3, #0] <== NOT EXECUTED
return -1;
112b0e: e79b b.n 112a48 <rtems_rfs_fs_open+0x2b8> <== NOT EXECUTED
rtems_rfs_inode_close (*fs, &inode);
112b10: a902 add r1, sp, #8 <== NOT EXECUTED
112b12: f7f6 ffa3 bl 109a5c <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_buffer_close (*fs);
112b16: 6838 ldr r0, [r7, #0] <== NOT EXECUTED
112b18: f7f5 ff64 bl 1089e4 <rtems_rfs_buffer_close> <== NOT EXECUTED
free (*fs);
112b1c: 6838 ldr r0, [r7, #0] <== NOT EXECUTED
112b1e: f7f3 f8f7 bl 105d10 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
112b22: 2001 movs r0, #1 <== NOT EXECUTED
112b24: 2100 movs r1, #0 <== NOT EXECUTED
112b26: f7f7 ff29 bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
112b2a: 2800 cmp r0, #0 <== NOT EXECUTED
112b2c: d143 bne.n 112bb6 <rtems_rfs_fs_open+0x426> <== NOT EXECUTED
errno = EIO;
112b2e: f003 fc4b bl 1163c8 <__errno> <== NOT EXECUTED
112b32: 2205 movs r2, #5 <== NOT EXECUTED
112b34: 4603 mov r3, r0 <== NOT EXECUTED
112b36: 601a str r2, [r3, #0] <== NOT EXECUTED
return -1;
112b38: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff <== NOT EXECUTED
112b3c: e784 b.n 112a48 <rtems_rfs_fs_open+0x2b8> <== NOT EXECUTED
rtems_rfs_buffer_close (*fs);
112b3e: 6838 ldr r0, [r7, #0] <== NOT EXECUTED
112b40: f7f5 ff50 bl 1089e4 <rtems_rfs_buffer_close> <== NOT EXECUTED
free (*fs);
112b44: 6838 ldr r0, [r7, #0] <== NOT EXECUTED
112b46: f7f3 f8e3 bl 105d10 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
112b4a: 2001 movs r0, #1 <== NOT EXECUTED
112b4c: 2100 movs r1, #0 <== NOT EXECUTED
112b4e: f7f7 ff15 bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
112b52: 2800 cmp r0, #0 <== NOT EXECUTED
112b54: d0d5 beq.n 112b02 <rtems_rfs_fs_open+0x372> <== NOT EXECUTED
printf ("rtems-rfs: open: reading root inode: %d: %s\n",
112b56: 4620 mov r0, r4 <== NOT EXECUTED
112b58: f004 fe0a bl 117770 <strerror> <== NOT EXECUTED
112b5c: 4602 mov r2, r0 <== NOT EXECUTED
112b5e: f64b 2094 movw r0, #47764 ; 0xba94 <== NOT EXECUTED
112b62: 4621 mov r1, r4 <== NOT EXECUTED
112b64: f2c0 0011 movt r0, #17 <== NOT EXECUTED
112b68: f7f2 ffd6 bl 105b18 <__wrap_printf> <== NOT EXECUTED
112b6c: e7c9 b.n 112b02 <rtems_rfs_fs_open+0x372> <== NOT EXECUTED
rtems_rfs_buffer_close (*fs);
112b6e: 6838 ldr r0, [r7, #0] <== NOT EXECUTED
112b70: f7f5 ff38 bl 1089e4 <rtems_rfs_buffer_close> <== NOT EXECUTED
free (*fs);
112b74: 6838 ldr r0, [r7, #0] <== NOT EXECUTED
112b76: f7f3 f8cb bl 105d10 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
112b7a: 2001 movs r0, #1 <== NOT EXECUTED
112b7c: 2100 movs r1, #0 <== NOT EXECUTED
112b7e: f7f7 fefd bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
112b82: 2800 cmp r0, #0 <== NOT EXECUTED
112b84: d0bd beq.n 112b02 <rtems_rfs_fs_open+0x372> <== NOT EXECUTED
printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
112b86: 4620 mov r0, r4 <== NOT EXECUTED
112b88: f004 fdf2 bl 117770 <strerror> <== NOT EXECUTED
112b8c: 4602 mov r2, r0 <== NOT EXECUTED
112b8e: f64b 20f0 movw r0, #47856 ; 0xbaf0 <== NOT EXECUTED
112b92: 4621 mov r1, r4 <== NOT EXECUTED
112b94: f2c0 0011 movt r0, #17 <== NOT EXECUTED
112b98: f7f2 ffbe bl 105b18 <__wrap_printf> <== NOT EXECUTED
112b9c: e7b1 b.n 112b02 <rtems_rfs_fs_open+0x372> <== NOT EXECUTED
printf ("rtems-rfs: open: buffer open failed: %d: %s\n",
112b9e: 4620 mov r0, r4 <== NOT EXECUTED
112ba0: f004 fde6 bl 117770 <strerror> <== NOT EXECUTED
112ba4: 4602 mov r2, r0 <== NOT EXECUTED
112ba6: f64b 0040 movw r0, #47168 ; 0xb840 <== NOT EXECUTED
112baa: 4621 mov r1, r4 <== NOT EXECUTED
112bac: f2c0 0011 movt r0, #17 <== NOT EXECUTED
112bb0: f7f2 ffb2 bl 105b18 <__wrap_printf> <== NOT EXECUTED
112bb4: e7a5 b.n 112b02 <rtems_rfs_fs_open+0x372> <== NOT EXECUTED
printf ("rtems-rfs: open: invalid root inode mode\n");
112bb6: f64b 20c4 movw r0, #47812 ; 0xbac4 <== NOT EXECUTED
112bba: f2c0 0011 movt r0, #17 <== NOT EXECUTED
112bbe: f7f2 ffbd bl 105b3c <__wrap_puts> <== NOT EXECUTED
112bc2: e7b4 b.n 112b2e <rtems_rfs_fs_open+0x39e> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
112bc4: 2001 movs r0, #1 <== NOT EXECUTED
112bc6: 2100 movs r1, #0 <== NOT EXECUTED
112bc8: f7f7 fed8 bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
112bcc: b938 cbnz r0, 112bde <rtems_rfs_fs_open+0x44e> <== NOT EXECUTED
errno = ENOMEM;
112bce: f003 fbfb bl 1163c8 <__errno> <== NOT EXECUTED
112bd2: 220c movs r2, #12 <== NOT EXECUTED
112bd4: 4603 mov r3, r0 <== NOT EXECUTED
112bd6: 601a str r2, [r3, #0] <== NOT EXECUTED
return -1;
112bd8: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff <== NOT EXECUTED
112bdc: e734 b.n 112a48 <rtems_rfs_fs_open+0x2b8> <== NOT EXECUTED
printf ("rtems-rfs: open: no memory for file system data\n");
112bde: f64b 0010 movw r0, #47120 ; 0xb810 <== NOT EXECUTED
112be2: f2c0 0011 movt r0, #17 <== NOT EXECUTED
112be6: f7f2 ffa9 bl 105b3c <__wrap_puts> <== NOT EXECUTED
112bea: e7f0 b.n 112bce <rtems_rfs_fs_open+0x43e> <== NOT EXECUTED
112bec: a902 add r1, sp, #8 <== NOT EXECUTED
112bee: 4620 mov r0, r4 <== NOT EXECUTED
112bf0: f7f5 fdc0 bl 108774 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
112bf4: 2001 movs r0, #1 <== NOT EXECUTED
112bf6: 2100 movs r1, #0 <== NOT EXECUTED
handle->dirty = false;
112bf8: f88d 6008 strb.w r6, [sp, #8] <== NOT EXECUTED
handle->buffer = NULL;
112bfc: e9cd 6603 strd r6, r6, [sp, #12] <== NOT EXECUTED
112c00: f7f7 febc bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
112c04: b908 cbnz r0, 112c0a <rtems_rfs_fs_open+0x47a> <== NOT EXECUTED
return ENOMEM;
112c06: 260c movs r6, #12 <== NOT EXECUTED
112c08: e6dd b.n 1129c6 <rtems_rfs_fs_open+0x236> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table\n");
112c0a: f64b 10ec movw r0, #47596 ; 0xb9ec <== NOT EXECUTED
return ENOMEM;
112c0e: 260c movs r6, #12 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table\n");
112c10: f2c0 0011 movt r0, #17 <== NOT EXECUTED
112c14: f7f2 ff92 bl 105b3c <__wrap_puts> <== NOT EXECUTED
if (rc > 0)
112c18: e6d5 b.n 1129c6 <rtems_rfs_fs_open+0x236> <== NOT EXECUTED
112c1a: bf00 nop
00112778 <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;
112778: e9d0 1001 ldrd r1, r0, [r0, #4] <== NOT EXECUTED
}
11277c: fba1 0100 umull r0, r1, r1, r0 <== NOT EXECUTED
112780: 4770 bx lr <== NOT EXECUTED
112782: bf00 nop
00109660 <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)
{
109660: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
109664: b087 sub sp, #28
109666: 4607 mov r7, r0
rtems_rfs_bitmap_bit bit;
int offset;
bool updown;
int direction;
if (inode)
109668: e9cd 2301 strd r2, r3, [sp, #4]
{
10966c: 4608 mov r0, r1
if (inode)
10966e: 2a00 cmp r2, #0
109670: d05e beq.n 109730 <rtems_rfs_group_bitmap_alloc+0xd0>
{
size = fs->group_inodes;
109672: f8d7 a02c ldr.w sl, [r7, #44] ; 0x2c
goal -= RTEMS_RFS_ROOT_INO;
109676: 1e48 subs r0, r1, #1
*/
if (goal >= RTEMS_RFS_ROOT_INO)
goal -= RTEMS_RFS_ROOT_INO;
}
group_start = goal / size;
109678: 4651 mov r1, sl
bit = (rtems_rfs_bitmap_bit) (goal % size);
offset = 0;
updown = true;
direction = 1;
10967a: f04f 0901 mov.w r9, #1
10967e: f00c fb41 bl 115d04 <__aeabi_uidivmod>
updown = true;
109682: 46c8 mov r8, r9
109684: 4606 mov r6, r0
/*
* We can start at any location and we move out from that point in each
* direction. The offset grows until we find a free bit or we hit an end.
*/
group = group_start + (direction * offset);
109686: 4605 mov r5, r0
bool allocated = false;
109688: 2400 movs r4, #0
bit = (rtems_rfs_bitmap_bit) (goal % size);
10968a: 9105 str r1, [sp, #20]
bool allocated = false;
10968c: f88d 4013 strb.w r4, [sp, #19]
group = group_start + (direction * offset);
109690: eb06 0b04 add.w fp, r6, r4
/*
* If we are still looking up and down and if the group is out of range we
* have reached one end. Stopping looking up and down and just move in the
* one direction one group at a time.
*/
if ((group < 0) || (group >= fs->group_count))
109694: 2d00 cmp r5, #0
109696: db2e blt.n 1096f6 <rtems_rfs_group_bitmap_alloc+0x96>
109698: 6a7b ldr r3, [r7, #36] ; 0x24
10969a: 42ab cmp r3, r5
10969c: dd2b ble.n 1096f6 <rtems_rfs_group_bitmap_alloc+0x96>
updown = false;
continue;
}
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
10969e: eb05 0385 add.w r3, r5, r5, lsl #2
1096a2: 011b lsls r3, r3, #4
1096a4: 461a mov r2, r3
1096a6: 9303 str r3, [sp, #12]
1096a8: 6a3b ldr r3, [r7, #32]
1096aa: 4413 add r3, r2
if (inode)
1096ac: 9a01 ldr r2, [sp, #4]
1096ae: 2a00 cmp r2, #0
1096b0: d145 bne.n 10973e <rtems_rfs_group_bitmap_alloc+0xde>
else
bitmap = &fs->groups[group].block_bitmap;
1096b2: 3308 adds r3, #8
1096b4: 9300 str r3, [sp, #0]
rc = rtems_rfs_bitmap_map_alloc (bitmap, bit, &allocated, &bit);
1096b6: 9905 ldr r1, [sp, #20]
1096b8: ab05 add r3, sp, #20
1096ba: 9800 ldr r0, [sp, #0]
1096bc: f10d 0213 add.w r2, sp, #19
1096c0: f7fe fd86 bl 1081d0 <rtems_rfs_bitmap_map_alloc>
if (rc > 0)
1096c4: 2800 cmp r0, #0
1096c6: dc30 bgt.n 10972a <rtems_rfs_group_bitmap_alloc+0xca> <== ALWAYS TAKEN
return rc;
if (rtems_rfs_fs_release_bitmaps (fs))
1096c8: 683b ldr r3, [r7, #0]
1096ca: 07db lsls r3, r3, #31
1096cc: d554 bpl.n 109778 <rtems_rfs_group_bitmap_alloc+0x118> <== NEVER TAKEN
rtems_rfs_bitmap_release_buffer (fs, bitmap);
if (allocated)
1096ce: f89d 3013 ldrb.w r3, [sp, #19]
1096d2: 2b00 cmp r3, #0
1096d4: d160 bne.n 109798 <rtems_rfs_group_bitmap_alloc+0x138>
* group_start, then alternate the direction and
* increment the offset on every other iteration.
* Otherwise we are marching through the groups, so just
* increment the offset.
*/
if (updown)
1096d6: f1b8 0f00 cmp.w r8, #0
1096da: d03b beq.n 109754 <rtems_rfs_group_bitmap_alloc+0xf4> <== ALWAYS TAKEN
{
direction = direction > 0 ? -1 : 1;
1096dc: f1b9 0f01 cmp.w r9, #1
bool allocated = false;
1096e0: f88d 3013 strb.w r3, [sp, #19]
direction = direction > 0 ? -1 : 1;
1096e4: d14e bne.n 109784 <rtems_rfs_group_bitmap_alloc+0x124> <== ALWAYS TAKEN
if ( direction == -1 )
offset++;
1096e6: 3401 adds r4, #1
direction = direction > 0 ? -1 : 1;
1096e8: f04f 39ff mov.w r9, #4294967295 ; 0xffffffff
1096ec: 1b35 subs r5, r6, r4
bit = direction > 0 ? 0 : size - 1;
1096ee: f10a 33ff add.w r3, sl, #4294967295 ; 0xffffffff
1096f2: 9305 str r3, [sp, #20]
1096f4: e7cc b.n 109690 <rtems_rfs_group_bitmap_alloc+0x30>
if (!updown)
1096f6: f1b8 0f00 cmp.w r8, #0
1096fa: d00f beq.n 10971c <rtems_rfs_group_bitmap_alloc+0xbc>
direction = direction > 0 ? -1 : 1;
1096fc: f1b9 0f01 cmp.w r9, #1
bool allocated = false;
109700: f04f 0300 mov.w r3, #0
109704: f88d 3013 strb.w r3, [sp, #19]
direction = direction > 0 ? -1 : 1;
109708: d11c bne.n 109744 <rtems_rfs_group_bitmap_alloc+0xe4> <== NEVER TAKEN
group = group_start + (direction * offset);
10970a: 1b35 subs r5, r6, r4 <== NOT EXECUTED
direction = direction > 0 ? -1 : 1;
10970c: f04f 39ff mov.w r9, #4294967295 ; 0xffffffff <== NOT EXECUTED
if (offset)
109710: f04f 0800 mov.w r8, #0 <== NOT EXECUTED
109714: 2c00 cmp r4, #0 <== NOT EXECUTED
109716: d1ea bne.n 1096ee <rtems_rfs_group_bitmap_alloc+0x8e> <== NOT EXECUTED
109718: 46a0 mov r8, r4 <== NOT EXECUTED
10971a: e7b9 b.n 109690 <rtems_rfs_group_bitmap_alloc+0x30> <== NOT EXECUTED
offset++;
}
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
10971c: f44f 3000 mov.w r0, #131072 ; 0x20000
109720: 2100 movs r1, #0
109722: f001 f92b bl 10a97c <rtems_rfs_trace>
109726: bb00 cbnz r0, 10976a <rtems_rfs_group_bitmap_alloc+0x10a>
printf ("rtems-rfs: group-bitmap-alloc: no blocks available\n");
return ENOSPC;
109728: 201c movs r0, #28
}
10972a: b007 add sp, #28
10972c: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
if (goal >= RTEMS_RFS_ROOT_INO)
109730: 2900 cmp r1, #0
size = fs->group_blocks;
109732: f8d7 a028 ldr.w sl, [r7, #40] ; 0x28
goal -= RTEMS_RFS_ROOT_INO;
109736: bfc8 it gt
109738: f101 30ff addgt.w r0, r1, #4294967295 ; 0xffffffff
10973c: e79c b.n 109678 <rtems_rfs_group_bitmap_alloc+0x18>
bitmap = &fs->groups[group].inode_bitmap;
10973e: 332c adds r3, #44 ; 0x2c
109740: 9300 str r3, [sp, #0]
109742: e7b8 b.n 1096b6 <rtems_rfs_group_bitmap_alloc+0x56>
group = group_start + (direction * offset);
109744: 1935 adds r5, r6, r4
if (offset)
109746: f04f 0800 mov.w r8, #0
10974a: f04f 0901 mov.w r9, #1
10974e: b1fc cbz r4, 109790 <rtems_rfs_group_bitmap_alloc+0x130>
bit = direction > 0 ? 0 : size - 1;
109750: 4643 mov r3, r8
109752: e7ce b.n 1096f2 <rtems_rfs_group_bitmap_alloc+0x92>
109754: f1b9 0f01 cmp.w r9, #1 <== NOT EXECUTED
offset++;
109758: f104 0401 add.w r4, r4, #1 <== NOT EXECUTED
group = group_start + (direction * offset);
10975c: fb09 6504 mla r5, r9, r4, r6 <== NOT EXECUTED
bool allocated = false;
109760: f88d 8013 strb.w r8, [sp, #19] <== NOT EXECUTED
bit = direction > 0 ? 0 : size - 1;
109764: d1c3 bne.n 1096ee <rtems_rfs_group_bitmap_alloc+0x8e> <== NOT EXECUTED
109766: 4643 mov r3, r8 <== NOT EXECUTED
109768: e7c3 b.n 1096f2 <rtems_rfs_group_bitmap_alloc+0x92> <== NOT EXECUTED
printf ("rtems-rfs: group-bitmap-alloc: no blocks available\n");
10976a: f24a 4080 movw r0, #42112 ; 0xa480 <== NOT EXECUTED
10976e: f2c0 0011 movt r0, #17 <== NOT EXECUTED
109772: f7fc f9e3 bl 105b3c <__wrap_puts> <== NOT EXECUTED
109776: e7d7 b.n 109728 <rtems_rfs_group_bitmap_alloc+0xc8> <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
109778: 9b00 ldr r3, [sp, #0]
10977a: 4638 mov r0, r7
10977c: 6819 ldr r1, [r3, #0]
10977e: f7fe fff9 bl 108774 <rtems_rfs_buffer_handle_release>
109782: e7a4 b.n 1096ce <rtems_rfs_group_bitmap_alloc+0x6e>
group = group_start + (direction * offset);
109784: 465d mov r5, fp <== NOT EXECUTED
if (offset)
109786: f04f 0901 mov.w r9, #1 <== NOT EXECUTED
10978a: 2c00 cmp r4, #0 <== NOT EXECUTED
10978c: d1b1 bne.n 1096f2 <rtems_rfs_group_bitmap_alloc+0x92> <== NOT EXECUTED
10978e: e781 b.n 109694 <rtems_rfs_group_bitmap_alloc+0x34> <== NOT EXECUTED
direction = direction > 0 ? -1 : 1;
109790: f04f 0901 mov.w r9, #1 <== NOT EXECUTED
if (offset)
109794: 46a0 mov r8, r4 <== NOT EXECUTED
109796: e77b b.n 109690 <rtems_rfs_group_bitmap_alloc+0x30> <== NOT EXECUTED
if (inode)
109798: 9a01 ldr r2, [sp, #4]
*result = rtems_rfs_group_inode (fs, group, bit);
10979a: 9b05 ldr r3, [sp, #20]
if (inode)
10979c: b1ca cbz r2, 1097d2 <rtems_rfs_group_bitmap_alloc+0x172>
*result = rtems_rfs_group_inode (fs, group, bit);
10979e: 6afa ldr r2, [r7, #44] ; 0x2c
1097a0: 3301 adds r3, #1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
1097a2: f44f 3000 mov.w r0, #131072 ; 0x20000
1097a6: 2100 movs r1, #0
*result = rtems_rfs_group_inode (fs, group, bit);
1097a8: fb02 3505 mla r5, r2, r5, r3
1097ac: 9b02 ldr r3, [sp, #8]
1097ae: 601d str r5, [r3, #0]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
1097b0: f001 f8e4 bl 10a97c <rtems_rfs_trace>
1097b4: b158 cbz r0, 1097ce <rtems_rfs_group_bitmap_alloc+0x16e>
printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
1097b6: f24a 413c movw r1, #42044 ; 0xa43c <== NOT EXECUTED
1097ba: f2c0 0111 movt r1, #17 <== NOT EXECUTED
1097be: 9b02 ldr r3, [sp, #8] <== NOT EXECUTED
1097c0: f24a 404c movw r0, #42060 ; 0xa44c <== NOT EXECUTED
1097c4: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1097c8: 681a ldr r2, [r3, #0] <== NOT EXECUTED
1097ca: f7fc f9a5 bl 105b18 <__wrap_printf> <== NOT EXECUTED
return 0;
1097ce: 2000 movs r0, #0
1097d0: e7ab b.n 10972a <rtems_rfs_group_bitmap_alloc+0xca>
*result = rtems_rfs_group_block (&fs->groups[group], bit);
1097d2: 6a3a ldr r2, [r7, #32]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
1097d4: f44f 3000 mov.w r0, #131072 ; 0x20000
*result = rtems_rfs_group_block (&fs->groups[group], bit);
1097d8: 9903 ldr r1, [sp, #12]
1097da: 5852 ldr r2, [r2, r1]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
1097dc: 2100 movs r1, #0
*result = rtems_rfs_group_block (&fs->groups[group], bit);
1097de: 4413 add r3, r2
1097e0: 9a02 ldr r2, [sp, #8]
1097e2: 6013 str r3, [r2, #0]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
1097e4: f001 f8ca bl 10a97c <rtems_rfs_trace>
printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
1097e8: f24a 4144 movw r1, #42052 ; 0xa444
1097ec: f2c0 0111 movt r1, #17
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
1097f0: 2800 cmp r0, #0
1097f2: d1e4 bne.n 1097be <rtems_rfs_group_bitmap_alloc+0x15e> <== ALWAYS TAKEN
1097f4: e7eb b.n 1097ce <rtems_rfs_group_bitmap_alloc+0x16e>
1097f6: bf00 nop
001097f8 <rtems_rfs_group_bitmap_free>:
int
rtems_rfs_group_bitmap_free (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no)
{
1097f8: b5f8 push {r3, r4, r5, r6, r7, lr}
1097fa: 4605 mov r5, r0
1097fc: 460f mov r7, r1
unsigned int group;
rtems_rfs_bitmap_bit bit;
size_t size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
1097fe: f44f 3000 mov.w r0, #131072 ; 0x20000
109802: 2100 movs r1, #0
{
109804: 4614 mov r4, r2
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
109806: f001 f8b9 bl 10a97c <rtems_rfs_trace>
10980a: b188 cbz r0, 109830 <rtems_rfs_group_bitmap_free+0x38>
printf ("rtems-rfs: group-bitmap-free: %s free: %" PRId32 "\n",
10980c: f24a 413c movw r1, #42044 ; 0xa43c <== NOT EXECUTED
109810: f24a 4344 movw r3, #42052 ; 0xa444 <== NOT EXECUTED
109814: f2c0 0111 movt r1, #17 <== NOT EXECUTED
109818: f2c0 0311 movt r3, #17 <== NOT EXECUTED
10981c: f24a 40b4 movw r0, #42164 ; 0xa4b4 <== NOT EXECUTED
109820: 2f00 cmp r7, #0 <== NOT EXECUTED
109822: bf08 it eq <== NOT EXECUTED
109824: 4619 moveq r1, r3 <== NOT EXECUTED
109826: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10982a: 4622 mov r2, r4 <== NOT EXECUTED
10982c: f7fc f974 bl 105b18 <__wrap_printf> <== NOT EXECUTED
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
109830: 6a2e ldr r6, [r5, #32]
no -= RTEMS_RFS_ROOT_INO;
109832: 1e60 subs r0, r4, #1
if (inode)
109834: b197 cbz r7, 10985c <rtems_rfs_group_bitmap_free+0x64>
group = no / size;
109836: 6ae9 ldr r1, [r5, #44] ; 0x2c
109838: f00c fa64 bl 115d04 <__aeabi_uidivmod>
bitmap = &fs->groups[group].inode_bitmap;
10983c: eb00 0080 add.w r0, r0, r0, lsl #2
109840: eb06 1000 add.w r0, r6, r0, lsl #4
109844: f100 042c add.w r4, r0, #44 ; 0x2c
else
bitmap = &fs->groups[group].block_bitmap;
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
109848: 4620 mov r0, r4
10984a: f7fe fbfd bl 108048 <rtems_rfs_bitmap_map_clear>
rtems_rfs_bitmap_release_buffer (fs, bitmap);
10984e: 6821 ldr r1, [r4, #0]
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
109850: 4604 mov r4, r0
rtems_rfs_bitmap_release_buffer (fs, bitmap);
109852: 4628 mov r0, r5
109854: f7fe ff8e bl 108774 <rtems_rfs_buffer_handle_release>
return rc;
}
109858: 4620 mov r0, r4
10985a: bdf8 pop {r3, r4, r5, r6, r7, pc}
group = no / size;
10985c: 6aa9 ldr r1, [r5, #40] ; 0x28
10985e: f00c fa51 bl 115d04 <__aeabi_uidivmod>
bitmap = &fs->groups[group].block_bitmap;
109862: eb00 0480 add.w r4, r0, r0, lsl #2
109866: eb06 1404 add.w r4, r6, r4, lsl #4
10986a: 3408 adds r4, #8
10986c: e7ec b.n 109848 <rtems_rfs_group_bitmap_free+0x50>
10986e: bf00 nop
0012cd2c <rtems_rfs_group_bitmap_test>:
int
rtems_rfs_group_bitmap_test (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no,
bool* state)
{
12cd2c: b5f8 push {r3, r4, r5, r6, r7, lr} <== NOT EXECUTED
12cd2e: 4605 mov r5, r0 <== NOT EXECUTED
12cd30: 460f mov r7, r1 <== NOT EXECUTED
unsigned int group;
rtems_rfs_bitmap_bit bit;
size_t size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
12cd32: f44f 3000 mov.w r0, #131072 ; 0x20000 <== NOT EXECUTED
12cd36: 2100 movs r1, #0 <== NOT EXECUTED
{
12cd38: 4614 mov r4, r2 <== NOT EXECUTED
12cd3a: 461e mov r6, r3 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
12cd3c: f001 ffc6 bl 12eccc <rtems_rfs_trace> <== NOT EXECUTED
12cd40: b188 cbz r0, 12cd66 <rtems_rfs_group_bitmap_test+0x3a> <== NOT EXECUTED
printf ("rtems-rfs: group-bitmap-test: %s test: %" PRId32 "\n",
12cd42: f648 013c movw r1, #34876 ; 0x883c <== NOT EXECUTED
12cd46: f648 0344 movw r3, #34884 ; 0x8844 <== NOT EXECUTED
12cd4a: f2c0 0115 movt r1, #21 <== NOT EXECUTED
12cd4e: f2c0 0315 movt r3, #21 <== NOT EXECUTED
12cd52: f648 00e0 movw r0, #35040 ; 0x88e0 <== NOT EXECUTED
12cd56: 2f00 cmp r7, #0 <== NOT EXECUTED
12cd58: bf08 it eq <== NOT EXECUTED
12cd5a: 4619 moveq r1, r3 <== NOT EXECUTED
12cd5c: f2c0 0015 movt r0, #21 <== NOT EXECUTED
12cd60: 4622 mov r2, r4 <== NOT EXECUTED
12cd62: f00e fe35 bl 13b9d0 <__wrap_printf> <== NOT EXECUTED
inode ? "inode" : "block", no);
if (inode)
12cd66: b1ef cbz r7, 12cda4 <rtems_rfs_group_bitmap_test+0x78> <== NOT EXECUTED
{
if ((no < RTEMS_RFS_ROOT_INO) || (no > rtems_rfs_fs_inodes (fs)))
12cd68: 2c00 cmp r4, #0 <== NOT EXECUTED
12cd6a: dd18 ble.n 12cd9e <rtems_rfs_group_bitmap_test+0x72> <== NOT EXECUTED
12cd6c: 696b ldr r3, [r5, #20] <== NOT EXECUTED
12cd6e: 42a3 cmp r3, r4 <== NOT EXECUTED
12cd70: d315 bcc.n 12cd9e <rtems_rfs_group_bitmap_test+0x72> <== NOT EXECUTED
return EINVAL;
no -= RTEMS_RFS_ROOT_INO;
size = fs->group_blocks;
}
group = no / size;
12cd72: 1e60 subs r0, r4, #1 <== NOT EXECUTED
12cd74: 6ae9 ldr r1, [r5, #44] ; 0x2c <== NOT EXECUTED
12cd76: f00e ff75 bl 13bc64 <__aeabi_uidivmod> <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
12cd7a: 6a2c ldr r4, [r5, #32] <== NOT EXECUTED
12cd7c: eb00 0080 add.w r0, r0, r0, lsl #2 <== NOT EXECUTED
12cd80: eb04 1400 add.w r4, r4, r0, lsl #4 <== NOT EXECUTED
12cd84: 342c adds r4, #44 ; 0x2c <== NOT EXECUTED
else
bitmap = &fs->groups[group].block_bitmap;
rc = rtems_rfs_bitmap_map_test (bitmap, bit, state);
12cd86: 4632 mov r2, r6 <== NOT EXECUTED
12cd88: 4620 mov r0, r4 <== NOT EXECUTED
12cd8a: f00a fee1 bl 137b50 <rtems_rfs_bitmap_map_test> <== NOT EXECUTED
12cd8e: 4603 mov r3, r0 <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
12cd90: 6821 ldr r1, [r4, #0] <== NOT EXECUTED
12cd92: 4628 mov r0, r5 <== NOT EXECUTED
rc = rtems_rfs_bitmap_map_test (bitmap, bit, state);
12cd94: 461c mov r4, r3 <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
12cd96: f7fd fe5b bl 12aa50 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
return rc;
}
12cd9a: 4620 mov r0, r4 <== NOT EXECUTED
12cd9c: bdf8 pop {r3, r4, r5, r6, r7, pc} <== NOT EXECUTED
return EINVAL;
12cd9e: 2416 movs r4, #22 <== NOT EXECUTED
}
12cda0: 4620 mov r0, r4 <== NOT EXECUTED
12cda2: bdf8 pop {r3, r4, r5, r6, r7, pc} <== NOT EXECUTED
if ((no < RTEMS_RFS_ROOT_INO) || (no >= rtems_rfs_fs_blocks (fs)))
12cda4: 2c00 cmp r4, #0 <== NOT EXECUTED
12cda6: ddfa ble.n 12cd9e <rtems_rfs_group_bitmap_test+0x72> <== NOT EXECUTED
12cda8: 686b ldr r3, [r5, #4] <== NOT EXECUTED
12cdaa: 42a3 cmp r3, r4 <== NOT EXECUTED
12cdac: d9f7 bls.n 12cd9e <rtems_rfs_group_bitmap_test+0x72> <== NOT EXECUTED
group = no / size;
12cdae: 1e60 subs r0, r4, #1 <== NOT EXECUTED
12cdb0: 6aa9 ldr r1, [r5, #40] ; 0x28 <== NOT EXECUTED
12cdb2: f00e ff57 bl 13bc64 <__aeabi_uidivmod> <== NOT EXECUTED
bitmap = &fs->groups[group].block_bitmap;
12cdb6: 6a2c ldr r4, [r5, #32] <== NOT EXECUTED
12cdb8: eb00 0080 add.w r0, r0, r0, lsl #2 <== NOT EXECUTED
12cdbc: eb04 1400 add.w r4, r4, r0, lsl #4 <== NOT EXECUTED
12cdc0: 3408 adds r4, #8 <== NOT EXECUTED
12cdc2: e7e0 b.n 12cd86 <rtems_rfs_group_bitmap_test+0x5a> <== NOT EXECUTED
001095f8 <rtems_rfs_group_close>:
int
rtems_rfs_group_close (rtems_rfs_file_system* fs, rtems_rfs_group* group)
{
1095f8: b5f8 push {r3, r4, r5, r6, r7, lr}
1095fa: 4606 mov r6, r0
1095fc: 460c mov r4, r1
int result = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_CLOSE))
1095fe: f44f 3080 mov.w r0, #65536 ; 0x10000
109602: 2100 movs r1, #0
109604: f001 f9ba bl 10a97c <rtems_rfs_trace>
109608: bb10 cbnz r0, 109650 <rtems_rfs_group_close+0x58>
/*
* We need to close as much as possible and also return any error if one
* occurs but this may result in one even more important error being lost but
* we cannot OR the errors together so this is a reasonable compromise.
*/
rc = rtems_rfs_bitmap_close (&group->inode_bitmap);
10960a: f104 002c add.w r0, r4, #44 ; 0x2c
10960e: f7fe fe87 bl 108320 <rtems_rfs_bitmap_close>
rtems_rfs_buffer_handle_release (fs, handle);
109612: f104 0144 add.w r1, r4, #68 ; 0x44
109616: 4607 mov r7, r0
109618: 4630 mov r0, r6
10961a: f7ff f8ab bl 108774 <rtems_rfs_buffer_handle_release>
handle->dirty = false;
10961e: 2300 movs r3, #0
if (rc > 0)
result = rc;
rc = rtems_rfs_buffer_handle_close (fs, &group->inode_bitmap_buffer);
if (rc > 0)
result = rc;
rc = rtems_rfs_bitmap_close (&group->block_bitmap);
109620: f104 0008 add.w r0, r4, #8
109624: f884 3044 strb.w r3, [r4, #68] ; 0x44
handle->buffer = NULL;
109628: e9c4 3312 strd r3, r3, [r4, #72] ; 0x48
10962c: f7fe fe78 bl 108320 <rtems_rfs_bitmap_close>
if (rc > 0)
109630: 1e05 subs r5, r0, #0
rtems_rfs_buffer_handle_release (fs, handle);
109632: f104 0120 add.w r1, r4, #32
109636: bfd8 it le
109638: ea27 75e7 bicle.w r5, r7, r7, asr #31
10963c: 4630 mov r0, r6
10963e: f7ff f899 bl 108774 <rtems_rfs_buffer_handle_release>
handle->dirty = false;
109642: 2300 movs r3, #0
rc = rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);
if (rc > 0)
result = rc;
return result;
}
109644: 4628 mov r0, r5
109646: f884 3020 strb.w r3, [r4, #32]
handle->buffer = NULL;
10964a: e9c4 3309 strd r3, r3, [r4, #36] ; 0x24
10964e: bdf8 pop {r3, r4, r5, r6, r7, pc}
printf ("rtems-rfs: group-close: base=%" PRId32 "\n", group->base);
109650: f24a 4018 movw r0, #42008 ; 0xa418 <== NOT EXECUTED
109654: 6821 ldr r1, [r4, #0] <== NOT EXECUTED
109656: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10965a: f7fc fa5d bl 105b18 <__wrap_printf> <== NOT EXECUTED
10965e: e7d4 b.n 10960a <rtems_rfs_group_close+0x12> <== NOT EXECUTED
00109480 <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)
{
109480: e92d 47f0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, lr}
109484: b082 sub sp, #8
int rc;
if (base >= rtems_rfs_fs_blocks (fs))
109486: 6845 ldr r5, [r0, #4]
{
109488: 9c0a ldr r4, [sp, #40] ; 0x28
if (base >= rtems_rfs_fs_blocks (fs))
10948a: 428d cmp r5, r1
10948c: f240 809e bls.w 1095cc <rtems_rfs_group_open+0x14c> <== ALWAYS TAKEN
109490: 4690 mov r8, r2
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))
109492: 188a adds r2, r1, r2
109494: 4295 cmp r5, r2
size = rtems_rfs_fs_blocks (fs) - base;
109496: 4607 mov r7, r0
109498: bf98 it ls
10949a: eba5 0801 subls.w r8, r5, r1
* 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)
10949e: 460e mov r6, r1
1094a0: 4543 cmp r3, r8
inodes = size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
1094a2: f44f 4000 mov.w r0, #32768 ; 0x8000
1094a6: bf28 it cs
1094a8: 4643 movcs r3, r8
1094aa: 2100 movs r1, #0
1094ac: 4699 mov r9, r3
1094ae: f001 fa65 bl 10a97c <rtems_rfs_trace>
1094b2: 2800 cmp r0, #0
1094b4: d14e bne.n 109554 <rtems_rfs_group_open+0xd4> <== ALWAYS TAKEN
printf ("rtems-rfs: group-open: base=%" PRId32 ", blocks=%zd inodes=%zd\n",
base, size, inodes);
group->base = base;
1094b6: 6026 str r6, [r4, #0]
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,
1094b8: 4643 mov r3, r8
1094ba: 9600 str r6, [sp, #0]
1094bc: f104 0a08 add.w sl, r4, #8
handle->dirty = false;
1094c0: 2600 movs r6, #0
group->size = size;
1094c2: f8c4 8004 str.w r8, [r4, #4]
rc = rtems_rfs_buffer_handle_open (fs, &group->block_bitmap_buffer);
1094c6: f104 0820 add.w r8, r4, #32
rc = rtems_rfs_bitmap_open (&group->block_bitmap, fs,
1094ca: 4639 mov r1, r7
1094cc: 4642 mov r2, r8
1094ce: 4650 mov r0, sl
1094d0: f884 6020 strb.w r6, [r4, #32]
handle->buffer = NULL;
1094d4: e9c4 6609 strd r6, r6, [r4, #36] ; 0x24
1094d8: f7fe ff0c bl 1082f4 <rtems_rfs_bitmap_open>
&group->block_bitmap_buffer, size,
group->base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
1094dc: 1e05 subs r5, r0, #0
1094de: dc1b bgt.n 109518 <rtems_rfs_group_open+0x98> <== ALWAYS 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,
1094e0: 4620 mov r0, r4
1094e2: 464b mov r3, r9
1094e4: f850 1b2c ldr.w r1, [r0], #44
rc = rtems_rfs_buffer_handle_open (fs, &group->inode_bitmap_buffer);
1094e8: f104 0944 add.w r9, r4, #68 ; 0x44
handle->dirty = false;
1094ec: f884 6044 strb.w r6, [r4, #68] ; 0x44
rc = rtems_rfs_bitmap_open (&group->inode_bitmap, fs,
1094f0: 464a mov r2, r9
handle->buffer = NULL;
1094f2: e9c4 6612 strd r6, r6, [r4, #72] ; 0x48
1094f6: 3101 adds r1, #1
1094f8: 9100 str r1, [sp, #0]
1094fa: 4639 mov r1, r7
1094fc: f7fe fefa bl 1082f4 <rtems_rfs_bitmap_open>
&group->inode_bitmap_buffer, inodes,
group->base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
109500: 1e05 subs r5, r0, #0
109502: dc31 bgt.n 109568 <rtems_rfs_group_open+0xe8> <== ALWAYS 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))
109504: 683d ldr r5, [r7, #0]
109506: f015 0501 ands.w r5, r5, #1
{
rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);
rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);
}
return 0;
10950a: bf18 it ne
10950c: 4635 movne r5, r6
if (rtems_rfs_fs_release_bitmaps (fs))
10950e: d051 beq.n 1095b4 <rtems_rfs_group_open+0x134> <== NEVER TAKEN
}
109510: 4628 mov r0, r5 <== NOT EXECUTED
109512: b002 add sp, #8 <== NOT EXECUTED
109514: e8bd 87f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
109518: 4641 mov r1, r8 <== NOT EXECUTED
10951a: 4638 mov r0, r7 <== NOT EXECUTED
10951c: f7ff f92a bl 108774 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
109520: f44f 4000 mov.w r0, #32768 ; 0x8000 <== NOT EXECUTED
109524: 2100 movs r1, #0 <== NOT EXECUTED
handle->dirty = false;
109526: f884 6020 strb.w r6, [r4, #32] <== NOT EXECUTED
handle->buffer = NULL;
10952a: e9c4 6609 strd r6, r6, [r4, #36] ; 0x24 <== NOT EXECUTED
10952e: f001 fa25 bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
109532: 2800 cmp r0, #0 <== NOT EXECUTED
109534: d0ec beq.n 109510 <rtems_rfs_group_open+0x90> <== NOT EXECUTED
printf ("rtems-rfs: group-open: could not open block bitmap: %d: %s\n",
109536: 4628 mov r0, r5 <== NOT EXECUTED
109538: f00e f91a bl 117770 <strerror> <== NOT EXECUTED
10953c: 4602 mov r2, r0 <== NOT EXECUTED
10953e: f24a 30a0 movw r0, #41888 ; 0xa3a0 <== NOT EXECUTED
109542: 4629 mov r1, r5 <== NOT EXECUTED
109544: f2c0 0011 movt r0, #17 <== NOT EXECUTED
109548: f7fc fae6 bl 105b18 <__wrap_printf> <== NOT EXECUTED
}
10954c: 4628 mov r0, r5 <== NOT EXECUTED
10954e: b002 add sp, #8 <== NOT EXECUTED
109550: e8bd 87f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
printf ("rtems-rfs: group-open: base=%" PRId32 ", blocks=%zd inodes=%zd\n",
109554: f24a 3068 movw r0, #41832 ; 0xa368 <== NOT EXECUTED
109558: 464b mov r3, r9 <== NOT EXECUTED
10955a: 4642 mov r2, r8 <== NOT EXECUTED
10955c: 4631 mov r1, r6 <== NOT EXECUTED
10955e: f2c0 0011 movt r0, #17 <== NOT EXECUTED
109562: f7fc fad9 bl 105b18 <__wrap_printf> <== NOT EXECUTED
109566: e7a6 b.n 1094b6 <rtems_rfs_group_open+0x36> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
109568: 4649 mov r1, r9 <== NOT EXECUTED
10956a: 4638 mov r0, r7 <== NOT EXECUTED
10956c: f7ff f902 bl 108774 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
rtems_rfs_bitmap_close (&group->block_bitmap);
109570: 4650 mov r0, sl <== NOT EXECUTED
handle->dirty = false;
109572: f884 6044 strb.w r6, [r4, #68] ; 0x44 <== NOT EXECUTED
handle->buffer = NULL;
109576: e9c4 6612 strd r6, r6, [r4, #72] ; 0x48 <== NOT EXECUTED
10957a: f7fe fed1 bl 108320 <rtems_rfs_bitmap_close> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
10957e: 4641 mov r1, r8 <== NOT EXECUTED
109580: 4638 mov r0, r7 <== NOT EXECUTED
109582: f7ff f8f7 bl 108774 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
109586: f44f 4000 mov.w r0, #32768 ; 0x8000 <== NOT EXECUTED
10958a: 2100 movs r1, #0 <== NOT EXECUTED
handle->dirty = false;
10958c: f884 6020 strb.w r6, [r4, #32] <== NOT EXECUTED
handle->buffer = NULL;
109590: e9c4 6609 strd r6, r6, [r4, #36] ; 0x24 <== NOT EXECUTED
109594: f001 f9f2 bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
109598: 2800 cmp r0, #0 <== NOT EXECUTED
10959a: d0b9 beq.n 109510 <rtems_rfs_group_open+0x90> <== NOT EXECUTED
printf ("rtems-rfs: group-open: could not open inode bitmap: %d: %s\n",
10959c: 4628 mov r0, r5 <== NOT EXECUTED
10959e: f00e f8e7 bl 117770 <strerror> <== NOT EXECUTED
1095a2: 4602 mov r2, r0 <== NOT EXECUTED
1095a4: f24a 30dc movw r0, #41948 ; 0xa3dc <== NOT EXECUTED
1095a8: 4629 mov r1, r5 <== NOT EXECUTED
1095aa: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1095ae: f7fc fab3 bl 105b18 <__wrap_printf> <== NOT EXECUTED
1095b2: e7ad b.n 109510 <rtems_rfs_group_open+0x90> <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);
1095b4: 68a1 ldr r1, [r4, #8]
1095b6: 4638 mov r0, r7
1095b8: f7ff f8dc bl 108774 <rtems_rfs_buffer_handle_release>
rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);
1095bc: 6ae1 ldr r1, [r4, #44] ; 0x2c
1095be: 4638 mov r0, r7
1095c0: f7ff f8d8 bl 108774 <rtems_rfs_buffer_handle_release>
}
1095c4: 4628 mov r0, r5
1095c6: b002 add sp, #8
1095c8: e8bd 87f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, pc}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
1095cc: f44f 4000 mov.w r0, #32768 ; 0x8000 <== NOT EXECUTED
1095d0: 2100 movs r1, #0 <== NOT EXECUTED
return EIO;
1095d2: 2505 movs r5, #5 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
1095d4: f001 f9d2 bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
1095d8: 2800 cmp r0, #0 <== NOT EXECUTED
1095da: d099 beq.n 109510 <rtems_rfs_group_open+0x90> <== NOT EXECUTED
printf ("rtems-rfs: group-open: base outside file system range: %d: %s\n",
1095dc: 2005 movs r0, #5 <== NOT EXECUTED
return EIO;
1095de: 4605 mov r5, r0 <== NOT EXECUTED
printf ("rtems-rfs: group-open: base outside file system range: %d: %s\n",
1095e0: f00e f8c6 bl 117770 <strerror> <== NOT EXECUTED
1095e4: 4602 mov r2, r0 <== NOT EXECUTED
1095e6: f24a 3028 movw r0, #41768 ; 0xa328 <== NOT EXECUTED
1095ea: 4629 mov r1, r5 <== NOT EXECUTED
1095ec: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1095f0: f7fc fa92 bl 105b18 <__wrap_printf> <== NOT EXECUTED
1095f4: e78c b.n 109510 <rtems_rfs_group_open+0x90> <== NOT EXECUTED
1095f6: bf00 nop
00109870 <rtems_rfs_group_usage>:
size_t* blocks,
size_t* inodes)
{
int g;
*blocks = 0;
109870: 2300 movs r3, #0 <== NOT EXECUTED
{
109872: b470 push {r4, r5, r6} <== NOT EXECUTED
*blocks = 0;
109874: 600b str r3, [r1, #0] <== NOT EXECUTED
*inodes = 0;
109876: 6013 str r3, [r2, #0] <== NOT EXECUTED
for (g = 0; g < fs->group_count; g++)
109878: 6a44 ldr r4, [r0, #36] ; 0x24 <== NOT EXECUTED
10987a: 429c cmp r4, r3 <== NOT EXECUTED
10987c: dd20 ble.n 1098c0 <rtems_rfs_group_usage+0x50> <== NOT EXECUTED
10987e: 6a04 ldr r4, [r0, #32] <== NOT EXECUTED
109880: 469c mov ip, r3 <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
109882: 6966 ldr r6, [r4, #20] <== NOT EXECUTED
for (g = 0; g < fs->group_count; g++)
109884: 3450 adds r4, #80 ; 0x50 <== NOT EXECUTED
*blocks +=
109886: 680b ldr r3, [r1, #0] <== NOT EXECUTED
for (g = 0; g < fs->group_count; g++)
109888: f10c 0c01 add.w ip, ip, #1 <== NOT EXECUTED
*blocks +=
10988c: f854 5c38 ldr.w r5, [r4, #-56] <== NOT EXECUTED
109890: 4433 add r3, r6 <== NOT EXECUTED
109892: 1b5b subs r3, r3, r5 <== NOT EXECUTED
109894: 600b str r3, [r1, #0] <== NOT EXECUTED
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
rtems_rfs_bitmap_map_free (&group->block_bitmap);
*inodes +=
109896: 6815 ldr r5, [r2, #0] <== NOT EXECUTED
109898: f854 3c18 ldr.w r3, [r4, #-24] <== NOT EXECUTED
10989c: 442b add r3, r5 <== NOT EXECUTED
10989e: f854 5c14 ldr.w r5, [r4, #-20] <== NOT EXECUTED
1098a2: 1b5b subs r3, r3, r5 <== NOT EXECUTED
1098a4: 6013 str r3, [r2, #0] <== NOT EXECUTED
for (g = 0; g < fs->group_count; g++)
1098a6: 6a45 ldr r5, [r0, #36] ; 0x24 <== NOT EXECUTED
1098a8: 4565 cmp r5, ip <== NOT EXECUTED
1098aa: dcea bgt.n 109882 <rtems_rfs_group_usage+0x12> <== 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))
1098ac: 680d ldr r5, [r1, #0] <== NOT EXECUTED
1098ae: 6844 ldr r4, [r0, #4] <== NOT EXECUTED
1098b0: 42a5 cmp r5, r4 <== NOT EXECUTED
*blocks = rtems_rfs_fs_blocks (fs);
1098b2: bf84 itt hi <== NOT EXECUTED
1098b4: 600c strhi r4, [r1, #0] <== NOT EXECUTED
if (*inodes > rtems_rfs_fs_inodes (fs))
1098b6: 6813 ldrhi r3, [r2, #0] <== NOT EXECUTED
1098b8: 6941 ldr r1, [r0, #20] <== NOT EXECUTED
1098ba: 4299 cmp r1, r3 <== NOT EXECUTED
*inodes = rtems_rfs_fs_inodes (fs);
1098bc: bf38 it cc <== NOT EXECUTED
1098be: 6011 strcc r1, [r2, #0] <== NOT EXECUTED
return 0;
}
1098c0: 2000 movs r0, #0 <== NOT EXECUTED
1098c2: bc70 pop {r4, r5, r6} <== NOT EXECUTED
1098c4: 4770 bx lr <== NOT EXECUTED
1098c6: bf00 nop
00109a5c <rtems_rfs_inode_close>:
{
109a5c: b538 push {r3, r4, r5, lr}
109a5e: 4605 mov r5, r0
109a60: 460c mov r4, r1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
109a62: f44f 2000 mov.w r0, #524288 ; 0x80000
109a66: 2100 movs r1, #0
109a68: f000 ff88 bl 10a97c <rtems_rfs_trace>
109a6c: b9a8 cbnz r0, 109a9a <rtems_rfs_inode_close+0x3e>
rc = rtems_rfs_inode_unload (fs, handle, true);
109a6e: 2201 movs r2, #1
109a70: 4621 mov r1, r4
109a72: 4628 mov r0, r5
109a74: f7ff ffae bl 1099d4 <rtems_rfs_inode_unload>
if ((rc == 0) && (handle->loads > 0))
109a78: b910 cbnz r0, 109a80 <rtems_rfs_inode_close+0x24>
109a7a: 6a63 ldr r3, [r4, #36] ; 0x24
109a7c: 2b00 cmp r3, #0
109a7e: dc02 bgt.n 109a86 <rtems_rfs_inode_close+0x2a> <== ALWAYS TAKEN
handle->ino = 0;
109a80: 2300 movs r3, #0
109a82: 60a3 str r3, [r4, #8]
}
109a84: bd38 pop {r3, r4, r5, pc}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
109a86: f44f 2000 mov.w r0, #524288 ; 0x80000 <== NOT EXECUTED
109a8a: 2100 movs r1, #0 <== NOT EXECUTED
109a8c: f000 ff76 bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
109a90: b958 cbnz r0, 109aaa <rtems_rfs_inode_close+0x4e> <== NOT EXECUTED
handle->ino = 0;
109a92: 2300 movs r3, #0 <== NOT EXECUTED
rc = EIO;
109a94: 2005 movs r0, #5 <== NOT EXECUTED
handle->ino = 0;
109a96: 60a3 str r3, [r4, #8] <== NOT EXECUTED
}
109a98: bd38 pop {r3, r4, r5, pc} <== NOT EXECUTED
printf ("rtems-rfs: inode-close: ino: %" PRIu32 "\n", handle->ino);
109a9a: f24a 5070 movw r0, #42352 ; 0xa570 <== NOT EXECUTED
109a9e: 68a1 ldr r1, [r4, #8] <== NOT EXECUTED
109aa0: f2c0 0011 movt r0, #17 <== NOT EXECUTED
109aa4: f7fc f838 bl 105b18 <__wrap_printf> <== NOT EXECUTED
109aa8: e7e1 b.n 109a6e <rtems_rfs_inode_close+0x12> <== NOT EXECUTED
printf ("rtems-rfs: inode-close: bad loads number: %d\n",
109aaa: f24a 5094 movw r0, #42388 ; 0xa594 <== NOT EXECUTED
109aae: 6a61 ldr r1, [r4, #36] ; 0x24 <== NOT EXECUTED
109ab0: f2c0 0011 movt r0, #17 <== NOT EXECUTED
109ab4: f7fc f830 bl 105b18 <__wrap_printf> <== NOT EXECUTED
rc = EIO;
109ab8: 2005 movs r0, #5 <== NOT EXECUTED
109aba: e7e1 b.n 109a80 <rtems_rfs_inode_close+0x24> <== NOT EXECUTED
00109cac <rtems_rfs_inode_create>:
{
109cac: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
109cb0: b09b sub sp, #108 ; 0x6c
109cb2: 9302 str r3, [sp, #8]
109cb4: 4607 mov r7, r0
109cb6: 4688 mov r8, r1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
109cb8: f44f 0080 mov.w r0, #4194304 ; 0x400000
{
109cbc: f8bd 3094 ldrh.w r3, [sp, #148] ; 0x94
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
109cc0: 2100 movs r1, #0
{
109cc2: f8bd 6090 ldrh.w r6, [sp, #144] ; 0x90
109cc6: 4692 mov sl, r2
109cc8: 9303 str r3, [sp, #12]
109cca: f8bd 3098 ldrh.w r3, [sp, #152] ; 0x98
109cce: f406 4570 and.w r5, r6, #61440 ; 0xf000
109cd2: 9304 str r3, [sp, #16]
109cd4: f8bd 309c ldrh.w r3, [sp, #156] ; 0x9c
109cd8: 9305 str r3, [sp, #20]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
109cda: f000 fe4f bl 10a97c <rtems_rfs_trace>
109cde: 2800 cmp r0, #0
109ce0: d03e beq.n 109d60 <rtems_rfs_inode_create+0xb4> <== NEVER TAKEN
if (RTEMS_RFS_S_ISDIR (mode))
109ce2: f5b5 4f80 cmp.w r5, #16384 ; 0x4000 <== NOT EXECUTED
109ce6: d018 beq.n 109d1a <rtems_rfs_inode_create+0x6e> <== NOT EXECUTED
else if (RTEMS_RFS_S_ISCHR (mode))
109ce8: f5b5 5f00 cmp.w r5, #8192 ; 0x2000 <== NOT EXECUTED
109cec: f000 80d2 beq.w 109e94 <rtems_rfs_inode_create+0x1e8> <== NOT EXECUTED
else if (RTEMS_RFS_S_ISBLK (mode))
109cf0: f5b5 4fc0 cmp.w r5, #24576 ; 0x6000 <== NOT EXECUTED
109cf4: f000 80b0 beq.w 109e58 <rtems_rfs_inode_create+0x1ac> <== NOT EXECUTED
else if (RTEMS_RFS_S_ISREG (mode))
109cf8: f5b5 4f00 cmp.w r5, #32768 ; 0x8000 <== NOT EXECUTED
109cfc: f000 80cf beq.w 109e9e <rtems_rfs_inode_create+0x1f2> <== NOT EXECUTED
const char* type = "unknown";
109d00: f24a 5bfc movw fp, #42492 ; 0xa5fc <== NOT EXECUTED
109d04: f24a 6304 movw r3, #42500 ; 0xa604 <== NOT EXECUTED
109d08: f2c0 0b11 movt fp, #17 <== NOT EXECUTED
109d0c: f2c0 0311 movt r3, #17 <== NOT EXECUTED
109d10: f5b5 4f20 cmp.w r5, #40960 ; 0xa000 <== NOT EXECUTED
109d14: bf18 it ne <== NOT EXECUTED
109d16: 469b movne fp, r3 <== NOT EXECUTED
109d18: e003 b.n 109d22 <rtems_rfs_inode_create+0x76> <== NOT EXECUTED
type = "dir";
109d1a: f24a 5bf0 movw fp, #42480 ; 0xa5f0 <== NOT EXECUTED
109d1e: f2c0 0b11 movt fp, #17 <== NOT EXECUTED
printf("rtems-rfs: inode-create: parent:%" PRIu32 " name:", parent);
109d22: f24a 600c movw r0, #42508 ; 0xa60c <== NOT EXECUTED
109d26: 4641 mov r1, r8 <== NOT EXECUTED
109d28: f2c0 0011 movt r0, #17 <== NOT EXECUTED
109d2c: f7fb fef4 bl 105b18 <__wrap_printf> <== NOT EXECUTED
for (c = 0; c < length; c++)
109d30: 9b02 ldr r3, [sp, #8] <== NOT EXECUTED
109d32: b15b cbz r3, 109d4c <rtems_rfs_inode_create+0xa0> <== NOT EXECUTED
109d34: 9b02 ldr r3, [sp, #8] <== NOT EXECUTED
109d36: f10a 39ff add.w r9, sl, #4294967295 ; 0xffffffff <== NOT EXECUTED
109d3a: eb0a 0403 add.w r4, sl, r3 <== NOT EXECUTED
109d3e: 3c01 subs r4, #1 <== NOT EXECUTED
printf ("%c", name[c]);
109d40: f819 0f01 ldrb.w r0, [r9, #1]! <== NOT EXECUTED
109d44: f00c ffba bl 116cbc <putchar> <== NOT EXECUTED
for (c = 0; c < length; c++)
109d48: 454c cmp r4, r9 <== NOT EXECUTED
109d4a: d1f9 bne.n 109d40 <rtems_rfs_inode_create+0x94> <== NOT EXECUTED
printf (" type:%s mode:%04x (%03o)\n", type, mode, mode & ((1 << 10) - 1));
109d4c: f24a 6038 movw r0, #42552 ; 0xa638 <== NOT EXECUTED
109d50: 4659 mov r1, fp <== NOT EXECUTED
109d52: f2c0 0011 movt r0, #17 <== NOT EXECUTED
109d56: f3c6 0309 ubfx r3, r6, #0, #10 <== NOT EXECUTED
109d5a: 4632 mov r2, r6 <== NOT EXECUTED
109d5c: f7fb fedc bl 105b18 <__wrap_printf> <== NOT EXECUTED
switch (mode & RTEMS_RFS_S_IFMT)
109d60: f5b5 4fc0 cmp.w r5, #24576 ; 0x6000
109d64: d00f beq.n 109d86 <rtems_rfs_inode_create+0xda> <== ALWAYS TAKEN
109d66: d909 bls.n 109d7c <rtems_rfs_inode_create+0xd0>
109d68: f406 4350 and.w r3, r6, #53248 ; 0xd000
109d6c: f5b3 4f00 cmp.w r3, #32768 ; 0x8000
109d70: d009 beq.n 109d86 <rtems_rfs_inode_create+0xda> <== NEVER TAKEN
109d72: 2416 movs r4, #22 <== NOT EXECUTED
}
109d74: 4620 mov r0, r4
109d76: b01b add sp, #108 ; 0x6c
109d78: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
switch (mode & RTEMS_RFS_S_IFMT)
109d7c: f5a5 5300 sub.w r3, r5, #8192 ; 0x2000
109d80: f413 4f50 tst.w r3, #53248 ; 0xd000
109d84: d1f5 bne.n 109d72 <rtems_rfs_inode_create+0xc6> <== ALWAYS TAKEN
rc = rtems_rfs_group_bitmap_alloc (fs, goal, true, &bit);
109d86: ab10 add r3, sp, #64 ; 0x40
109d88: 4641 mov r1, r8
109d8a: 2201 movs r2, #1
109d8c: 4638 mov r0, r7
109d8e: f7ff fc67 bl 109660 <rtems_rfs_group_bitmap_alloc>
*ino = bit;
109d92: 9910 ldr r1, [sp, #64] ; 0x40
if (rc > 0)
109d94: 1e04 subs r4, r0, #0
*ino = bit;
109d96: 9b28 ldr r3, [sp, #160] ; 0xa0
109d98: 6019 str r1, [r3, #0]
if (rc > 0)
109d9a: dceb bgt.n 109d74 <rtems_rfs_inode_create+0xc8>
rc = rtems_rfs_inode_open (fs, *ino, &inode, true);
109d9c: 2301 movs r3, #1
109d9e: aa10 add r2, sp, #64 ; 0x40
109da0: 4638 mov r0, r7
109da2: f7ff fdd3 bl 10994c <rtems_rfs_inode_open>
if (rc > 0)
109da6: 1e04 subs r4, r0, #0
109da8: dc4c bgt.n 109e44 <rtems_rfs_inode_create+0x198> <== ALWAYS TAKEN
rc = rtems_rfs_inode_initialise (&inode, links, mode, uid, gid);
109daa: 9b05 ldr r3, [sp, #20]
109dac: 4632 mov r2, r6
109dae: 9903 ldr r1, [sp, #12]
109db0: a810 add r0, sp, #64 ; 0x40
109db2: 9300 str r3, [sp, #0]
109db4: 9b04 ldr r3, [sp, #16]
109db6: f7ff ff11 bl 109bdc <rtems_rfs_inode_initialise>
if (rc > 0)
109dba: 1e04 subs r4, r0, #0
109dbc: dc74 bgt.n 109ea8 <rtems_rfs_inode_create+0x1fc> <== ALWAYS TAKEN
if (RTEMS_RFS_S_ISDIR (mode))
109dbe: f5b5 4f80 cmp.w r5, #16384 ; 0x4000
109dc2: d04e beq.n 109e62 <rtems_rfs_inode_create+0x1b6>
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
109dc4: 4641 mov r1, r8
109dc6: 2301 movs r3, #1
109dc8: aa06 add r2, sp, #24
109dca: 4638 mov r0, r7
109dcc: f7ff fdbe bl 10994c <rtems_rfs_inode_open>
if (rc > 0)
109dd0: 1e04 subs r4, r0, #0
109dd2: dc56 bgt.n 109e82 <rtems_rfs_inode_create+0x1d6> <== ALWAYS TAKEN
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, *ino);
109dd4: 9928 ldr r1, [sp, #160] ; 0xa0
109dd6: 4652 mov r2, sl
109dd8: 9b02 ldr r3, [sp, #8]
109dda: 4638 mov r0, r7
109ddc: 6809 ldr r1, [r1, #0]
109dde: 9100 str r1, [sp, #0]
109de0: a906 add r1, sp, #24
109de2: f007 faf9 bl 1113d8 <rtems_rfs_dir_add_entry>
if (rc > 0)
109de6: 1e04 subs r4, r0, #0
109de8: dc63 bgt.n 109eb2 <rtems_rfs_inode_create+0x206> <== ALWAYS TAKEN
if (RTEMS_RFS_S_ISDIR (mode))
109dea: f5b5 4f80 cmp.w r5, #16384 ; 0x4000
109dee: d114 bne.n 109e1a <rtems_rfs_inode_create+0x16e>
links = rtems_rfs_read_u16 (&handle->node->links);
109df0: 9a09 ldr r2, [sp, #36] ; 0x24
if (links == 0xffff)
109df2: f64f 71ff movw r1, #65535 ; 0xffff
109df6: 8813 ldrh r3, [r2, #0]
109df8: ba5b rev16 r3, r3
109dfa: b29b uxth r3, r3
109dfc: 428b cmp r3, r1
rtems_rfs_inode_set_links (&parent_inode,
109dfe: bf15 itete ne
109e00: 3301 addne r3, #1
109e02: 2100 moveq r1, #0
109e04: b29b uxthne r3, r3
109e06: 2301 moveq r3, #1
rtems_rfs_write_u16 (&handle->node->links, links);
109e08: bf1c itt ne
109e0a: 0a19 lsrne r1, r3, #8
109e0c: b2db uxtbne r3, r3
109e0e: 7011 strb r1, [r2, #0]
109e10: 9a09 ldr r2, [sp, #36] ; 0x24
109e12: 7053 strb r3, [r2, #1]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
109e14: 2301 movs r3, #1
109e16: f88d 3028 strb.w r3, [sp, #40] ; 0x28
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
109e1a: 2201 movs r2, #1
109e1c: a806 add r0, sp, #24
109e1e: 4611 mov r1, r2
109e20: f7ff feae bl 109b80 <rtems_rfs_inode_time_stamp_now>
if (rc > 0)
109e24: 1e04 subs r4, r0, #0
109e26: dc2c bgt.n 109e82 <rtems_rfs_inode_create+0x1d6> <== ALWAYS TAKEN
rc = rtems_rfs_inode_close (fs, &parent_inode);
109e28: a906 add r1, sp, #24
109e2a: 4638 mov r0, r7
109e2c: f7ff fe16 bl 109a5c <rtems_rfs_inode_close>
if (rc > 0)
109e30: 1e04 subs r4, r0, #0
rtems_rfs_inode_delete (fs, &inode);
109e32: a910 add r1, sp, #64 ; 0x40
109e34: 4638 mov r0, r7
if (rc > 0)
109e36: dc56 bgt.n 109ee6 <rtems_rfs_inode_create+0x23a> <== ALWAYS TAKEN
rc = rtems_rfs_inode_close (fs, &inode);
109e38: f7ff fe10 bl 109a5c <rtems_rfs_inode_close>
if (rc > 0)
109e3c: 1e04 subs r4, r0, #0
return 0;
109e3e: bfd8 it le
109e40: 2400 movle r4, #0
if (rc > 0)
109e42: dd97 ble.n 109d74 <rtems_rfs_inode_create+0xc8> <== NEVER TAKEN
return rtems_rfs_group_bitmap_free (fs, true, bit);
109e44: 9b28 ldr r3, [sp, #160] ; 0xa0 <== NOT EXECUTED
109e46: 2101 movs r1, #1 <== NOT EXECUTED
109e48: 4638 mov r0, r7 <== NOT EXECUTED
109e4a: 681a ldr r2, [r3, #0] <== NOT EXECUTED
109e4c: f7ff fcd4 bl 1097f8 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
}
109e50: 4620 mov r0, r4 <== NOT EXECUTED
109e52: b01b add sp, #108 ; 0x6c <== NOT EXECUTED
109e54: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
type = "block";
109e58: f24a 4b44 movw fp, #42052 ; 0xa444 <== NOT EXECUTED
109e5c: f2c0 0b11 movt fp, #17 <== NOT EXECUTED
109e60: e75f b.n 109d22 <rtems_rfs_inode_create+0x76> <== NOT EXECUTED
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, *ino);
109e62: 9b28 ldr r3, [sp, #160] ; 0xa0
109e64: f249 128c movw r2, #37260 ; 0x918c
109e68: f2c0 0211 movt r2, #17
109e6c: a910 add r1, sp, #64 ; 0x40
109e6e: 4638 mov r0, r7
109e70: 681b ldr r3, [r3, #0]
109e72: 9300 str r3, [sp, #0]
109e74: 2301 movs r3, #1
109e76: f007 faaf bl 1113d8 <rtems_rfs_dir_add_entry>
if (rc == 0)
109e7a: 4604 mov r4, r0
109e7c: b330 cbz r0, 109ecc <rtems_rfs_inode_create+0x220>
if (rc > 0)
109e7e: 2c00 cmp r4, #0
109e80: dda0 ble.n 109dc4 <rtems_rfs_inode_create+0x118> <== NEVER TAKEN
rtems_rfs_inode_delete (fs, &inode);
109e82: a910 add r1, sp, #64 ; 0x40 <== NOT EXECUTED
109e84: 4638 mov r0, r7 <== NOT EXECUTED
109e86: f7ff fe19 bl 109abc <rtems_rfs_inode_delete> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
109e8a: a910 add r1, sp, #64 ; 0x40 <== NOT EXECUTED
109e8c: 4638 mov r0, r7 <== NOT EXECUTED
109e8e: f7ff fde5 bl 109a5c <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
109e92: e76f b.n 109d74 <rtems_rfs_inode_create+0xc8> <== NOT EXECUTED
type = "char";
109e94: f24a 5bf4 movw fp, #42484 ; 0xa5f4 <== NOT EXECUTED
109e98: f2c0 0b11 movt fp, #17 <== NOT EXECUTED
109e9c: e741 b.n 109d22 <rtems_rfs_inode_create+0x76> <== NOT EXECUTED
type = "file";
109e9e: f649 0b64 movw fp, #39012 ; 0x9864 <== NOT EXECUTED
109ea2: f2c0 0b11 movt fp, #17 <== NOT EXECUTED
109ea6: e73c b.n 109d22 <rtems_rfs_inode_create+0x76> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
109ea8: a910 add r1, sp, #64 ; 0x40 <== NOT EXECUTED
109eaa: 4638 mov r0, r7 <== NOT EXECUTED
109eac: f7ff fdd6 bl 109a5c <rtems_rfs_inode_close> <== NOT EXECUTED
return rtems_rfs_group_bitmap_free (fs, true, bit);
109eb0: e7c8 b.n 109e44 <rtems_rfs_inode_create+0x198> <== NOT EXECUTED
rtems_rfs_inode_delete (fs, &inode);
109eb2: a910 add r1, sp, #64 ; 0x40 <== NOT EXECUTED
109eb4: 4638 mov r0, r7 <== NOT EXECUTED
109eb6: f7ff fe01 bl 109abc <rtems_rfs_inode_delete> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
109eba: a910 add r1, sp, #64 ; 0x40 <== NOT EXECUTED
109ebc: 4638 mov r0, r7 <== NOT EXECUTED
109ebe: f7ff fdcd bl 109a5c <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
109ec2: a906 add r1, sp, #24 <== NOT EXECUTED
109ec4: 4638 mov r0, r7 <== NOT EXECUTED
109ec6: f7ff fdc9 bl 109a5c <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
109eca: e753 b.n 109d74 <rtems_rfs_inode_create+0xc8> <== NOT EXECUTED
rc = rtems_rfs_dir_add_entry (fs, &inode, "..", 2, parent);
109ecc: f24a 6254 movw r2, #42580 ; 0xa654
109ed0: 2302 movs r3, #2
109ed2: f2c0 0211 movt r2, #17
109ed6: a910 add r1, sp, #64 ; 0x40
109ed8: 4638 mov r0, r7
109eda: f8cd 8000 str.w r8, [sp]
109ede: f007 fa7b bl 1113d8 <rtems_rfs_dir_add_entry>
109ee2: 4604 mov r4, r0
109ee4: e7cb b.n 109e7e <rtems_rfs_inode_create+0x1d2>
rtems_rfs_inode_delete (fs, &inode);
109ee6: f7ff fde9 bl 109abc <rtems_rfs_inode_delete> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
109eea: a910 add r1, sp, #64 ; 0x40 <== NOT EXECUTED
109eec: 4638 mov r0, r7 <== NOT EXECUTED
109eee: f7ff fdb5 bl 109a5c <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
109ef2: e73f b.n 109d74 <rtems_rfs_inode_create+0xc8> <== NOT EXECUTED
00109abc <rtems_rfs_inode_delete>:
}
int
rtems_rfs_inode_delete (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
109abc: e92d 41f0 stmdb sp!, {r4, r5, r6, r7, r8, lr}
109ac0: 4606 mov r6, r0
109ac2: b094 sub sp, #80 ; 0x50
109ac4: 460d mov r5, r1
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_DELETE))
109ac6: f44f 0000 mov.w r0, #8388608 ; 0x800000
109aca: 2100 movs r1, #0
109acc: f000 ff56 bl 10a97c <rtems_rfs_trace>
109ad0: b190 cbz r0, 109af8 <rtems_rfs_inode_delete+0x3c>
printf("rtems-rfs: inode-delete: ino:%" PRIu32 " loaded:%s\n",
109ad2: 68e9 ldr r1, [r5, #12] <== NOT EXECUTED
109ad4: f24a 42e0 movw r2, #42208 ; 0xa4e0 <== NOT EXECUTED
109ad8: f24a 43e4 movw r3, #42212 ; 0xa4e4 <== NOT EXECUTED
109adc: f2c0 0211 movt r2, #17 <== NOT EXECUTED
109ae0: f2c0 0311 movt r3, #17 <== NOT EXECUTED
109ae4: f24a 50c4 movw r0, #42436 ; 0xa5c4 <== NOT EXECUTED
109ae8: 2900 cmp r1, #0 <== NOT EXECUTED
109aea: bf08 it eq <== NOT EXECUTED
109aec: 461a moveq r2, r3 <== NOT EXECUTED
109aee: f2c0 0011 movt r0, #17 <== NOT EXECUTED
109af2: 68a9 ldr r1, [r5, #8] <== NOT EXECUTED
109af4: f7fc f810 bl 105b18 <__wrap_printf> <== NOT EXECUTED
rtems_rfs_inode_ino (handle),
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
109af8: 68ec ldr r4, [r5, #12]
109afa: b134 cbz r4, 109b0a <rtems_rfs_inode_delete+0x4e>
return rtems_rfs_group_bitmap_free (fs, true, bit);
109afc: 68aa ldr r2, [r5, #8]
109afe: 2101 movs r1, #1
109b00: 4630 mov r0, r6
109b02: f7ff fe79 bl 1097f8 <rtems_rfs_group_bitmap_free>
/*
* Free the ino number.
*/
rc = rtems_rfs_inode_free (fs, handle->ino);
if (rc > 0)
109b06: 1e04 subs r4, r0, #0
109b08: dd03 ble.n 109b12 <rtems_rfs_inode_delete+0x56> <== NEVER TAKEN
if (rrc > 0)
rc = rrc;
}
}
return rc;
}
109b0a: 4620 mov r0, r4
109b0c: b014 add sp, #80 ; 0x50
109b0e: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
rc = rtems_rfs_block_map_open (fs, handle, &map);
109b12: 4629 mov r1, r5
109b14: 466a mov r2, sp
109b16: 4630 mov r0, r6
109b18: f006 feb8 bl 11088c <rtems_rfs_block_map_open>
if (rc == 0)
109b1c: 4604 mov r4, r0
109b1e: 2800 cmp r0, #0
109b20: d1f3 bne.n 109b0a <rtems_rfs_inode_delete+0x4e> <== ALWAYS TAKEN
rrc = rtems_rfs_block_map_free_all (fs, &map);
109b22: 4669 mov r1, sp
109b24: 4630 mov r0, r6
109b26: f007 fa67 bl 110ff8 <rtems_rfs_block_map_free_all>
rc = rtems_rfs_block_map_close (fs, &map);
109b2a: 4669 mov r1, sp
rrc = rtems_rfs_block_map_free_all (fs, &map);
109b2c: 4607 mov r7, r0
rc = rtems_rfs_block_map_close (fs, &map);
109b2e: 4630 mov r0, r6
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
109b30: f105 0810 add.w r8, r5, #16
rc = rtems_rfs_block_map_close (fs, &map);
109b34: f006 fefc bl 110930 <rtems_rfs_block_map_close>
if (rc > 0)
109b38: 1e04 subs r4, r0, #0
memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE);
109b3a: f04f 0238 mov.w r2, #56 ; 0x38
109b3e: 68e8 ldr r0, [r5, #12]
109b40: f04f 01ff mov.w r1, #255 ; 0xff
if (rc > 0)
109b44: dd0b ble.n 109b5e <rtems_rfs_inode_delete+0xa2> <== NEVER TAKEN
memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE);
109b46: f00d f867 bl 116c18 <memset> <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
109b4a: 2301 movs r3, #1 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
109b4c: 4641 mov r1, r8 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
109b4e: 742b strb r3, [r5, #16] <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
109b50: 4630 mov r0, r6 <== NOT EXECUTED
109b52: f7fe fe0f bl 108774 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->loads = 0;
109b56: 2300 movs r3, #0 <== NOT EXECUTED
109b58: 626b str r3, [r5, #36] ; 0x24 <== NOT EXECUTED
handle->node = NULL;
109b5a: 60eb str r3, [r5, #12] <== NOT EXECUTED
if (rrc > 0)
109b5c: e7d5 b.n 109b0a <rtems_rfs_inode_delete+0x4e> <== NOT EXECUTED
memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE);
109b5e: f00d f85b bl 116c18 <memset>
rtems_rfs_buffer_mark_dirty (&handle->buffer);
109b62: 2301 movs r3, #1
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
109b64: 4641 mov r1, r8
rtems_rfs_buffer_mark_dirty (&handle->buffer);
109b66: 742b strb r3, [r5, #16]
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
109b68: 4630 mov r0, r6
109b6a: f7fe fe03 bl 108774 <rtems_rfs_buffer_handle_release>
handle->loads = 0;
109b6e: 2300 movs r3, #0
109b70: 429f cmp r7, r3
109b72: bfcc ite gt
109b74: 463c movgt r4, r7
109b76: 4604 movle r4, r0
109b78: 626b str r3, [r5, #36] ; 0x24
handle->node = NULL;
109b7a: 60eb str r3, [r5, #12]
if (rrc > 0)
109b7c: e7c5 b.n 109b0a <rtems_rfs_inode_delete+0x4e>
109b7e: bf00 nop
001098e0 <rtems_rfs_inode_load>:
}
int
rtems_rfs_inode_load (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
1098e0: b538 push {r3, r4, r5, lr}
1098e2: 4605 mov r5, r0
1098e4: 460c mov r4, r1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_LOAD))
1098e6: f44f 1080 mov.w r0, #1048576 ; 0x100000
1098ea: 2100 movs r1, #0
1098ec: f001 f846 bl 10a97c <rtems_rfs_trace>
1098f0: b198 cbz r0, 10991a <rtems_rfs_inode_load+0x3a>
printf ("rtems-rfs: inode-load: ino=%" PRIu32 " loads=%i loaded=%s\n",
1098f2: 68e1 ldr r1, [r4, #12] <== NOT EXECUTED
1098f4: f24a 43e0 movw r3, #42208 ; 0xa4e0 <== NOT EXECUTED
1098f8: f24a 42e4 movw r2, #42212 ; 0xa4e4 <== NOT EXECUTED
1098fc: f2c0 0311 movt r3, #17 <== NOT EXECUTED
109900: f2c0 0211 movt r2, #17 <== NOT EXECUTED
109904: f24a 40e8 movw r0, #42216 ; 0xa4e8 <== NOT EXECUTED
109908: 2900 cmp r1, #0 <== NOT EXECUTED
10990a: bf08 it eq <== NOT EXECUTED
10990c: 4613 moveq r3, r2 <== NOT EXECUTED
10990e: f2c0 0011 movt r0, #17 <== NOT EXECUTED
109912: 6a62 ldr r2, [r4, #36] ; 0x24 <== NOT EXECUTED
109914: 68a1 ldr r1, [r4, #8] <== NOT EXECUTED
109916: f7fc f8ff bl 105b18 <__wrap_printf> <== NOT EXECUTED
/*
* An inode does not move so once loaded no need to do again.
*/
if (!rtems_rfs_inode_is_loaded (handle))
10991a: 68e3 ldr r3, [r4, #12]
10991c: b123 cbz r3, 109928 <rtems_rfs_inode_load+0x48>
handle->node = rtems_rfs_buffer_data (&handle->buffer);
handle->node += handle->offset;
}
handle->loads++;
10991e: 6a63 ldr r3, [r4, #36] ; 0x24
return 0;
109920: 2000 movs r0, #0
handle->loads++;
109922: 3301 adds r3, #1
109924: 6263 str r3, [r4, #36] ; 0x24
}
109926: bd38 pop {r3, r4, r5, pc}
rc = rtems_rfs_buffer_handle_request (fs,&handle->buffer,
109928: 69e2 ldr r2, [r4, #28]
10992a: 2301 movs r3, #1
10992c: f104 0110 add.w r1, r4, #16
109930: 4628 mov r0, r5
109932: f7fe fe33 bl 10859c <rtems_rfs_buffer_handle_request>
if (rc > 0)
109936: 2800 cmp r0, #0
109938: dcf5 bgt.n 109926 <rtems_rfs_inode_load+0x46> <== ALWAYS TAKEN
handle->node = rtems_rfs_buffer_data (&handle->buffer);
10993a: 69a2 ldr r2, [r4, #24]
handle->node += handle->offset;
10993c: 6a23 ldr r3, [r4, #32]
10993e: 69d2 ldr r2, [r2, #28]
109940: ebc3 03c3 rsb r3, r3, r3, lsl #3
109944: eb02 03c3 add.w r3, r2, r3, lsl #3
109948: 60e3 str r3, [r4, #12]
10994a: e7e8 b.n 10991e <rtems_rfs_inode_load+0x3e>
0010994c <rtems_rfs_inode_open>:
{
10994c: e92d 41f0 stmdb sp!, {r4, r5, r6, r7, r8, lr}
109950: 4605 mov r5, r0
109952: 460e mov r6, r1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_OPEN))
109954: f44f 2080 mov.w r0, #262144 ; 0x40000
109958: 2100 movs r1, #0
{
10995a: 4614 mov r4, r2
10995c: 461f mov r7, r3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_OPEN))
10995e: f001 f80d bl 10a97c <rtems_rfs_trace>
109962: bb20 cbnz r0, 1099ae <rtems_rfs_inode_open+0x62>
if (ino == RTEMS_RFS_EMPTY_INO)
109964: b366 cbz r6, 1099c0 <rtems_rfs_inode_open+0x74>
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
109966: 696b ldr r3, [r5, #20]
109968: 1e70 subs r0, r6, #1
10996a: 4298 cmp r0, r3
10996c: d828 bhi.n 1099c0 <rtems_rfs_inode_open+0x74> <== ALWAYS TAKEN
handle->node = NULL;
10996e: f04f 0800 mov.w r8, #0
109972: 6ae9 ldr r1, [r5, #44] ; 0x2c
handle->ino = ino;
109974: 60a6 str r6, [r4, #8]
handle->node = NULL;
109976: f8c4 800c str.w r8, [r4, #12]
handle->loads = 0;
10997a: f8c4 8024 str.w r8, [r4, #36] ; 0x24
group = gino / fs->group_inodes;
10997e: f00c f9c1 bl 115d04 <__aeabi_uidivmod>
109982: 4606 mov r6, r0
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
109984: 4608 mov r0, r1
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
109986: eb06 0686 add.w r6, r6, r6, lsl #2
10998a: 6b29 ldr r1, [r5, #48] ; 0x30
10998c: f00c f9ba bl 115d04 <__aeabi_uidivmod>
109990: 6a2a ldr r2, [r5, #32]
109992: 0136 lsls r6, r6, #4
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
109994: 1c83 adds r3, r0, #2
handle->offset = gino % fs->inodes_per_block;
109996: 6221 str r1, [r4, #32]
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
109998: 5990 ldr r0, [r2, r6]
handle->dirty = false;
10999a: f884 8010 strb.w r8, [r4, #16]
handle->buffer = NULL;
10999e: e9c4 8805 strd r8, r8, [r4, #20]
1099a2: 4418 add r0, r3
1099a4: 61e0 str r0, [r4, #28]
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
1099a6: 4638 mov r0, r7
if ((rc == 0) && load)
1099a8: b96f cbnz r7, 1099c6 <rtems_rfs_inode_open+0x7a>
}
1099aa: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
printf ("rtems-rfs: inode-open: ino: %" PRIu32 "\n", ino);
1099ae: f24a 501c movw r0, #42268 ; 0xa51c <== NOT EXECUTED
1099b2: 4631 mov r1, r6 <== NOT EXECUTED
1099b4: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1099b8: f7fc f8ae bl 105b18 <__wrap_printf> <== NOT EXECUTED
if (ino == RTEMS_RFS_EMPTY_INO)
1099bc: 2e00 cmp r6, #0 <== NOT EXECUTED
1099be: d1d2 bne.n 109966 <rtems_rfs_inode_open+0x1a> <== NOT EXECUTED
return EINVAL;
1099c0: 2016 movs r0, #22 <== NOT EXECUTED
}
1099c2: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
rc = rtems_rfs_inode_load (fs, handle);
1099c6: 4621 mov r1, r4
1099c8: 4628 mov r0, r5
}
1099ca: e8bd 41f0 ldmia.w sp!, {r4, r5, r6, r7, r8, lr}
rc = rtems_rfs_inode_load (fs, handle);
1099ce: f7ff bf87 b.w 1098e0 <rtems_rfs_inode_load>
1099d2: bf00 nop
00109b80 <rtems_rfs_inode_time_stamp_now>:
rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,
bool atime,
bool mtime)
{
time_t now;
if (!rtems_rfs_inode_is_loaded (handle))
109b80: 68c3 ldr r3, [r0, #12]
109b82: b343 cbz r3, 109bd6 <rtems_rfs_inode_time_stamp_now+0x56>
{
109b84: b570 push {r4, r5, r6, lr}
109b86: 460e mov r6, r1
109b88: 4604 mov r4, r0
return ENXIO;
now = time (NULL);
109b8a: 2000 movs r0, #0
109b8c: 4615 mov r5, r2
109b8e: f00d ff8d bl 117aac <time>
if (atime)
109b92: b916 cbnz r6, 109b9a <rtems_rfs_inode_time_stamp_now+0x1a>
rtems_rfs_inode_set_atime (handle, now);
if (mtime)
109b94: b985 cbnz r5, 109bb8 <rtems_rfs_inode_time_stamp_now+0x38> <== NOT EXECUTED
rtems_rfs_inode_set_mtime (handle, now);
return 0;
109b96: 4628 mov r0, r5 <== NOT EXECUTED
}
109b98: bd70 pop {r4, r5, r6, pc} <== NOT EXECUTED
rtems_rfs_write_u32 (&handle->node->atime, atime);
109b9a: 68e3 ldr r3, [r4, #12]
109b9c: 0e02 lsrs r2, r0, #24
109b9e: 741a strb r2, [r3, #16]
109ba0: 0c02 lsrs r2, r0, #16
109ba2: 68e3 ldr r3, [r4, #12]
109ba4: 745a strb r2, [r3, #17]
109ba6: 0a02 lsrs r2, r0, #8
109ba8: 68e3 ldr r3, [r4, #12]
109baa: 749a strb r2, [r3, #18]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
109bac: 2301 movs r3, #1
rtems_rfs_write_u32 (&handle->node->atime, atime);
109bae: 68e2 ldr r2, [r4, #12]
109bb0: 74d0 strb r0, [r2, #19]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
109bb2: 7423 strb r3, [r4, #16]
if (mtime)
109bb4: 2d00 cmp r5, #0
109bb6: d0ee beq.n 109b96 <rtems_rfs_inode_time_stamp_now+0x16> <== ALWAYS TAKEN
rtems_rfs_write_u32 (&handle->node->mtime, mtime);
109bb8: 68e3 ldr r3, [r4, #12]
109bba: 0e01 lsrs r1, r0, #24
109bbc: 0c02 lsrs r2, r0, #16
109bbe: 7519 strb r1, [r3, #20]
109bc0: 0a01 lsrs r1, r0, #8
109bc2: 68e3 ldr r3, [r4, #12]
109bc4: 755a strb r2, [r3, #21]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
109bc6: 2301 movs r3, #1
rtems_rfs_write_u32 (&handle->node->mtime, mtime);
109bc8: 68e2 ldr r2, [r4, #12]
109bca: 7591 strb r1, [r2, #22]
109bcc: 68e2 ldr r2, [r4, #12]
109bce: 75d0 strb r0, [r2, #23]
return 0;
109bd0: 2000 movs r0, #0
rtems_rfs_buffer_mark_dirty (&handle->buffer);
109bd2: 7423 strb r3, [r4, #16]
}
109bd4: bd70 pop {r4, r5, r6, pc}
return ENXIO;
109bd6: 2006 movs r0, #6 <== NOT EXECUTED
}
109bd8: 4770 bx lr <== NOT EXECUTED
109bda: bf00 nop
001099d4 <rtems_rfs_inode_unload>:
int
rtems_rfs_inode_unload (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle,
bool update_ctime)
{
1099d4: b570 push {r4, r5, r6, lr}
1099d6: 4605 mov r5, r0
1099d8: 460c mov r4, r1
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD))
1099da: f44f 1000 mov.w r0, #2097152 ; 0x200000
1099de: 2100 movs r1, #0
{
1099e0: 4616 mov r6, r2
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD))
1099e2: f000 ffcb bl 10a97c <rtems_rfs_trace>
1099e6: b198 cbz r0, 109a10 <rtems_rfs_inode_unload+0x3c>
printf ("rtems-rfs: inode-unload: ino=%" PRIu32 " loads=%i loaded=%s\n",
1099e8: 68e1 ldr r1, [r4, #12] <== NOT EXECUTED
1099ea: f24a 43e0 movw r3, #42208 ; 0xa4e0 <== NOT EXECUTED
1099ee: f24a 42e4 movw r2, #42212 ; 0xa4e4 <== NOT EXECUTED
1099f2: f2c0 0311 movt r3, #17 <== NOT EXECUTED
1099f6: f2c0 0211 movt r2, #17 <== NOT EXECUTED
1099fa: f24a 503c movw r0, #42300 ; 0xa53c <== NOT EXECUTED
1099fe: 2900 cmp r1, #0 <== NOT EXECUTED
109a00: bf08 it eq <== NOT EXECUTED
109a02: 4613 moveq r3, r2 <== NOT EXECUTED
109a04: f2c0 0011 movt r0, #17 <== NOT EXECUTED
109a08: 6a62 ldr r2, [r4, #36] ; 0x24 <== NOT EXECUTED
109a0a: 68a1 ldr r1, [r4, #8] <== NOT EXECUTED
109a0c: f7fc f884 bl 105b18 <__wrap_printf> <== NOT EXECUTED
handle->ino, handle->loads,
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
109a10: 68e3 ldr r3, [r4, #12]
109a12: b17b cbz r3, 109a34 <rtems_rfs_inode_unload+0x60>
{
if (handle->loads == 0)
109a14: 6a60 ldr r0, [r4, #36] ; 0x24
109a16: b178 cbz r0, 109a38 <rtems_rfs_inode_unload+0x64>
return EIO;
handle->loads--;
109a18: 3801 subs r0, #1
109a1a: 6260 str r0, [r4, #36] ; 0x24
if (handle->loads == 0)
109a1c: b950 cbnz r0, 109a34 <rtems_rfs_inode_unload+0x60>
{
/*
* If the buffer is dirty it will be release. Also set the ctime.
*/
if (rtems_rfs_buffer_dirty (&handle->buffer) && update_ctime)
109a1e: 7c22 ldrb r2, [r4, #16]
109a20: 4216 tst r6, r2
109a22: d10b bne.n 109a3c <rtems_rfs_inode_unload+0x68>
rtems_rfs_inode_set_ctime (handle, time (NULL));
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
109a24: f104 0110 add.w r1, r4, #16
109a28: 4628 mov r0, r5
109a2a: f7fe fea3 bl 108774 <rtems_rfs_buffer_handle_release>
handle->node = NULL;
109a2e: 2300 movs r3, #0
109a30: 60e3 str r3, [r4, #12]
}
}
return rc;
}
109a32: bd70 pop {r4, r5, r6, pc}
int rc = 0;
109a34: 2000 movs r0, #0
}
109a36: bd70 pop {r4, r5, r6, pc}
return EIO;
109a38: 2005 movs r0, #5 <== NOT EXECUTED
}
109a3a: bd70 pop {r4, r5, r6, pc} <== NOT EXECUTED
rtems_rfs_inode_set_ctime (handle, time (NULL));
109a3c: f00e f836 bl 117aac <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);
109a40: 68e3 ldr r3, [r4, #12]
109a42: 0e02 lsrs r2, r0, #24
109a44: 761a strb r2, [r3, #24]
109a46: 0c02 lsrs r2, r0, #16
109a48: 68e3 ldr r3, [r4, #12]
109a4a: 765a strb r2, [r3, #25]
109a4c: 0a02 lsrs r2, r0, #8
109a4e: 68e3 ldr r3, [r4, #12]
109a50: 769a strb r2, [r3, #26]
109a52: 68e3 ldr r3, [r4, #12]
109a54: 76d8 strb r0, [r3, #27]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
109a56: 2301 movs r3, #1
109a58: 7423 strb r3, [r4, #16]
}
109a5a: e7e3 b.n 109a24 <rtems_rfs_inode_unload+0x50>
00112c68 <rtems_rfs_link>:
const char* name,
int length,
rtems_rfs_ino parent,
rtems_rfs_ino target,
bool link_dir)
{
112c68: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
112c6c: 4605 mov r5, r0
112c6e: b097 sub sp, #92 ; 0x5c
112c70: 4688 mov r8, r1
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))
112c72: f04f 7080 mov.w r0, #16777216 ; 0x1000000
112c76: 2100 movs r1, #0
{
112c78: f8dd 9080 ldr.w r9, [sp, #128] ; 0x80
112c7c: 4616 mov r6, r2
112c7e: f89d a084 ldrb.w sl, [sp, #132] ; 0x84
112c82: 461f mov r7, r3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_LINK))
112c84: f7f7 fe7a bl 10a97c <rtems_rfs_trace>
112c88: 2800 cmp r0, #0
112c8a: d15a bne.n 112d42 <rtems_rfs_link+0xda> <== ALWAYS TAKEN
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf ("(%" PRIu32 ")\n", target);
}
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
112c8c: 2301 movs r3, #1
112c8e: aa0c add r2, sp, #48 ; 0x30
112c90: 4649 mov r1, r9
112c92: 4628 mov r0, r5
112c94: f7f6 fe5a bl 10994c <rtems_rfs_inode_open>
if (rc)
112c98: 4604 mov r4, r0
112c9a: 2800 cmp r0, #0
112c9c: d143 bne.n 112d26 <rtems_rfs_link+0xbe> <== ALWAYS TAKEN
/*
* 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)))
112c9e: f1ba 0f00 cmp.w sl, #0
112ca2: d107 bne.n 112cb4 <rtems_rfs_link+0x4c>
112ca4: 9b0f ldr r3, [sp, #60] ; 0x3c
112ca6: 885b ldrh r3, [r3, #2]
112ca8: ba5b rev16 r3, r3
112caa: f403 4370 and.w r3, r3, #61440 ; 0xf000
112cae: f5b3 4f80 cmp.w r3, #16384 ; 0x4000
112cb2: d06e beq.n 112d92 <rtems_rfs_link+0x12a> <== ALWAYS TAKEN
{
rtems_rfs_inode_close (fs, &target_inode);
return ENOTSUP;
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
112cb4: 4639 mov r1, r7
112cb6: 2301 movs r3, #1
112cb8: aa02 add r2, sp, #8
112cba: 4628 mov r0, r5
112cbc: f7f6 fe46 bl 10994c <rtems_rfs_inode_open>
if (rc)
112cc0: 4604 mov r4, r0
112cc2: 2800 cmp r0, #0
112cc4: d135 bne.n 112d32 <rtems_rfs_link+0xca> <== ALWAYS TAKEN
{
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, target);
112cc6: 4633 mov r3, r6
112cc8: 4642 mov r2, r8
112cca: a902 add r1, sp, #8
112ccc: 4628 mov r0, r5
112cce: f8cd 9000 str.w r9, [sp]
112cd2: f7fe fb81 bl 1113d8 <rtems_rfs_dir_add_entry>
if (rc > 0)
112cd6: 1e04 subs r4, r0, #0
112cd8: dc4f bgt.n 112d7a <rtems_rfs_link+0x112> <== ALWAYS TAKEN
links = rtems_rfs_read_u16 (&handle->node->links);
112cda: 9a0f ldr r2, [sp, #60] ; 0x3c
if (links == 0xffff)
112cdc: f64f 71ff movw r1, #65535 ; 0xffff
}
links = rtems_rfs_inode_get_links (&target_inode) + 1;
rtems_rfs_inode_set_links (&target_inode, links);
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
112ce0: a802 add r0, sp, #8
112ce2: 8813 ldrh r3, [r2, #0]
112ce4: ba5b rev16 r3, r3
112ce6: b29b uxth r3, r3
112ce8: 428b cmp r3, r1
links = rtems_rfs_inode_get_links (&target_inode) + 1;
112cea: bf15 itete ne
112cec: 3301 addne r3, #1
112cee: 2100 moveq r1, #0
112cf0: b29b uxthne r3, r3
112cf2: 2301 moveq r3, #1
rtems_rfs_write_u16 (&handle->node->links, links);
112cf4: bf1c itt ne
112cf6: 0a19 lsrne r1, r3, #8
112cf8: b2db uxtbne r3, r3
112cfa: 7011 strb r1, [r2, #0]
112cfc: 9a0f ldr r2, [sp, #60] ; 0x3c
112cfe: 7053 strb r3, [r2, #1]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
112d00: 2201 movs r2, #1
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
112d02: 4611 mov r1, r2
112d04: f88d 2040 strb.w r2, [sp, #64] ; 0x40
112d08: f7f6 ff3a bl 109b80 <rtems_rfs_inode_time_stamp_now>
if (rc > 0)
112d0c: 1e04 subs r4, r0, #0
{
rtems_rfs_inode_close (fs, &parent_inode);
112d0e: a902 add r1, sp, #8
112d10: 4628 mov r0, r5
if (rc > 0)
112d12: dc0c bgt.n 112d2e <rtems_rfs_link+0xc6> <== ALWAYS TAKEN
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &parent_inode);
112d14: f7f6 fea2 bl 109a5c <rtems_rfs_inode_close>
if (rc > 0)
112d18: 1e04 subs r4, r0, #0
{
rtems_rfs_inode_close (fs, &target_inode);
112d1a: a90c add r1, sp, #48 ; 0x30
112d1c: 4628 mov r0, r5
if (rc > 0)
112d1e: dc0a bgt.n 112d36 <rtems_rfs_link+0xce> <== ALWAYS TAKEN
return rc;
}
rc = rtems_rfs_inode_close (fs, &target_inode);
112d20: f7f6 fe9c bl 109a5c <rtems_rfs_inode_close>
112d24: 4604 mov r4, r0
return rc;
}
112d26: 4620 mov r0, r4
112d28: b017 add sp, #92 ; 0x5c
112d2a: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
rtems_rfs_inode_close (fs, &parent_inode);
112d2e: f7f6 fe95 bl 109a5c <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
112d32: a90c add r1, sp, #48 ; 0x30 <== NOT EXECUTED
112d34: 4628 mov r0, r5 <== NOT EXECUTED
112d36: f7f6 fe91 bl 109a5c <rtems_rfs_inode_close> <== NOT EXECUTED
}
112d3a: 4620 mov r0, r4 <== NOT EXECUTED
112d3c: b017 add sp, #92 ; 0x5c <== NOT EXECUTED
112d3e: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
printf ("rtems-rfs: link: parent(%" PRIu32 ") -> ", parent);
112d42: f64b 3034 movw r0, #47924 ; 0xbb34 <== NOT EXECUTED
112d46: 4639 mov r1, r7 <== NOT EXECUTED
112d48: f2c0 0011 movt r0, #17 <== NOT EXECUTED
112d4c: f7f2 fee4 bl 105b18 <__wrap_printf> <== NOT EXECUTED
for (c = 0; c < length; c++)
112d50: 2e00 cmp r6, #0 <== NOT EXECUTED
112d52: bfc4 itt gt <== NOT EXECUTED
112d54: f108 34ff addgt.w r4, r8, #4294967295 ; 0xffffffff <== NOT EXECUTED
112d58: eb04 0b06 addgt.w fp, r4, r6 <== NOT EXECUTED
112d5c: dd05 ble.n 112d6a <rtems_rfs_link+0x102> <== NOT EXECUTED
printf ("%c", name[c]);
112d5e: f814 0f01 ldrb.w r0, [r4, #1]! <== NOT EXECUTED
112d62: f003 ffab bl 116cbc <putchar> <== NOT EXECUTED
for (c = 0; c < length; c++)
112d66: 455c cmp r4, fp <== NOT EXECUTED
112d68: d1f9 bne.n 112d5e <rtems_rfs_link+0xf6> <== NOT EXECUTED
printf ("(%" PRIu32 ")\n", target);
112d6a: f64b 3054 movw r0, #47956 ; 0xbb54 <== NOT EXECUTED
112d6e: 4649 mov r1, r9 <== NOT EXECUTED
112d70: f2c0 0011 movt r0, #17 <== NOT EXECUTED
112d74: f7f2 fed0 bl 105b18 <__wrap_printf> <== NOT EXECUTED
112d78: e788 b.n 112c8c <rtems_rfs_link+0x24> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
112d7a: a902 add r1, sp, #8 <== NOT EXECUTED
112d7c: 4628 mov r0, r5 <== NOT EXECUTED
112d7e: f7f6 fe6d bl 109a5c <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
112d82: a90c add r1, sp, #48 ; 0x30 <== NOT EXECUTED
112d84: 4628 mov r0, r5 <== NOT EXECUTED
112d86: f7f6 fe69 bl 109a5c <rtems_rfs_inode_close> <== NOT EXECUTED
}
112d8a: 4620 mov r0, r4 <== NOT EXECUTED
112d8c: b017 add sp, #92 ; 0x5c <== NOT EXECUTED
112d8e: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
112d92: a90c add r1, sp, #48 ; 0x30 <== NOT EXECUTED
112d94: 4628 mov r0, r5 <== NOT EXECUTED
return ENOTSUP;
112d96: 2486 movs r4, #134 ; 0x86 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
112d98: f7f6 fe60 bl 109a5c <rtems_rfs_inode_close> <== NOT EXECUTED
return ENOTSUP;
112d9c: e7c3 b.n 112d26 <rtems_rfs_link+0xbe> <== NOT EXECUTED
112d9e: bf00 nop
0010a604 <rtems_rfs_rtems_fdatasync>:
rc = rtems_rfs_buffer_sync (rtems_rfs_rtems_pathloc_dev (&iop->pathinfo));
10a604: 6a43 ldr r3, [r0, #36] ; 0x24 <== NOT EXECUTED
{
10a606: b510 push {r4, lr} <== NOT EXECUTED
rc = rtems_rfs_buffer_sync (rtems_rfs_rtems_pathloc_dev (&iop->pathinfo));
10a608: 6898 ldr r0, [r3, #8] <== NOT EXECUTED
10a60a: f7fe f93f bl 10888c <rtems_rfs_buffer_sync> <== NOT EXECUTED
if (rc)
10a60e: 4604 mov r4, r0 <== NOT EXECUTED
10a610: b908 cbnz r0, 10a616 <rtems_rfs_rtems_fdatasync+0x12> <== NOT EXECUTED
}
10a612: 4620 mov r0, r4 <== NOT EXECUTED
10a614: bd10 pop {r4, pc} <== NOT EXECUTED
return rtems_rfs_rtems_error ("fdatasync: sync", rc);
10a616: f00b fed7 bl 1163c8 <__errno> <== NOT EXECUTED
10a61a: 6004 str r4, [r0, #0] <== NOT EXECUTED
10a61c: f04f 34ff mov.w r4, #4294967295 ; 0xffffffff <== NOT EXECUTED
10a620: e7f7 b.n 10a612 <rtems_rfs_rtems_fdatasync+0xe> <== NOT EXECUTED
10a622: bf00 nop
0010a380 <rtems_rfs_rtems_fstat>:
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
10a380: 6942 ldr r2, [r0, #20]
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
10a382: 2301 movs r3, #1
{
10a384: b5f0 push {r4, r5, r6, r7, lr}
10a386: b08b sub sp, #44 ; 0x2c
10a388: 460c mov r4, r1
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
10a38a: 6881 ldr r1, [r0, #8]
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
10a38c: 6895 ldr r5, [r2, #8]
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
10a38e: 466a mov r2, sp
10a390: 4628 mov r0, r5
10a392: f7ff fadb bl 10994c <rtems_rfs_inode_open>
if (rc)
10a396: 4606 mov r6, r0
10a398: 2800 cmp r0, #0
10a39a: f040 8085 bne.w 10a4a8 <rtems_rfs_rtems_fstat+0x128> <== ALWAYS TAKEN
return rtems_rfs_read_u16 (&handle->node->mode);
10a39e: 9a03 ldr r2, [sp, #12]
10a3a0: 8853 ldrh r3, [r2, #2]
10a3a2: ba5b rev16 r3, r3
if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK (mode))
10a3a4: f403 4130 and.w r1, r3, #45056 ; 0xb000
10a3a8: b298 uxth r0, r3
10a3aa: f5b1 5f00 cmp.w r1, #8192 ; 0x2000
10a3ae: d043 beq.n 10a438 <rtems_rfs_rtems_fstat+0xb8> <== ALWAYS TAKEN
buf->st_dev = (dev_t) (uintptr_t)rtems_rfs_fs_device (fs);
10a3b0: 692b ldr r3, [r5, #16]
10a3b2: 2700 movs r7, #0
10a3b4: 6067 str r7, [r4, #4]
buf->st_ino = rtems_rfs_inode_ino (&inode);
10a3b6: 60e7 str r7, [r4, #12]
buf->st_dev = (dev_t) (uintptr_t)rtems_rfs_fs_device (fs);
10a3b8: 6023 str r3, [r4, #0]
buf->st_ino = rtems_rfs_inode_ino (&inode);
10a3ba: 9b02 ldr r3, [sp, #8]
10a3bc: 60a3 str r3, [r4, #8]
buf->st_mode = rtems_rfs_rtems_mode (mode);
10a3be: f000 fadb bl 10a978 <rtems_rfs_rtems_mode>
links = rtems_rfs_read_u16 (&handle->node->links);
10a3c2: 9a03 ldr r2, [sp, #12]
if (links == 0xffff)
10a3c4: f64f 7cff movw ip, #65535 ; 0xffff
10a3c8: 6120 str r0, [r4, #16]
shared = rtems_rfs_file_get_shared (fs, rtems_rfs_inode_ino (&inode));
10a3ca: 4628 mov r0, r5
10a3cc: 9902 ldr r1, [sp, #8]
10a3ce: 8813 ldrh r3, [r2, #0]
10a3d0: ba5b rev16 r3, r3
10a3d2: b29b uxth r3, r3
links = 0;
10a3d4: 4563 cmp r3, ip
10a3d6: bf08 it eq
10a3d8: 463b moveq r3, r7
buf->st_nlink = rtems_rfs_inode_get_links (&inode);
10a3da: 82a3 strh r3, [r4, #20]
buf->st_uid = rtems_rfs_inode_get_uid (&inode);
10a3dc: 88d3 ldrh r3, [r2, #6]
10a3de: ba5b rev16 r3, r3
10a3e0: 82e3 strh r3, [r4, #22]
return (rtems_rfs_read_u32 (&handle->node->owner) >> 16) & 0xffff;
10a3e2: 6853 ldr r3, [r2, #4]
10a3e4: ba1b rev r3, r3
10a3e6: 0c1b lsrs r3, r3, #16
10a3e8: 8323 strh r3, [r4, #24]
shared = rtems_rfs_file_get_shared (fs, rtems_rfs_inode_ino (&inode));
10a3ea: f008 f9b5 bl 112758 <rtems_rfs_file_get_shared>
if (shared)
10a3ee: b390 cbz r0, 10a456 <rtems_rfs_rtems_fstat+0xd6>
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
10a3f0: f8d0 208c ldr.w r2, [r0, #140] ; 0x8c
if (S_ISLNK (buf->st_mode))
10a3f4: 6923 ldr r3, [r4, #16]
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
10a3f6: e9c4 270c strd r2, r7, [r4, #48] ; 0x30
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
10a3fa: f8d0 2090 ldr.w r2, [r0, #144] ; 0x90
if (S_ISLNK (buf->st_mode))
10a3fe: f403 4370 and.w r3, r3, #61440 ; 0xf000
10a402: f5b3 4f20 cmp.w r3, #40960 ; 0xa000
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
10a406: e9c4 2710 strd r2, r7, [r4, #64] ; 0x40
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
10a40a: f8d0 2094 ldr.w r2, [r0, #148] ; 0x94
10a40e: e9c4 2714 strd r2, r7, [r4, #80] ; 0x50
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
10a412: f8d0 2084 ldr.w r2, [r0, #132] ; 0x84
10a416: 6662 str r2, [r4, #100] ; 0x64
if (S_ISLNK (buf->st_mode))
10a418: d115 bne.n 10a446 <rtems_rfs_rtems_fstat+0xc6> <== NEVER TAKEN
buf->st_size = rtems_rfs_file_shared_get_block_offset (shared);
10a41a: f8b0 3088 ldrh.w r3, [r0, #136] ; 0x88 <== NOT EXECUTED
10a41e: e9c4 370a strd r3, r7, [r4, #40] ; 0x28 <== NOT EXECUTED
buf->st_blksize = rtems_rfs_fs_block_size (fs);
10a422: 68ab ldr r3, [r5, #8]
rc = rtems_rfs_inode_close (fs, &inode);
10a424: 4669 mov r1, sp
10a426: 4628 mov r0, r5
buf->st_blksize = rtems_rfs_fs_block_size (fs);
10a428: 6623 str r3, [r4, #96] ; 0x60
rc = rtems_rfs_inode_close (fs, &inode);
10a42a: f7ff fb17 bl 109a5c <rtems_rfs_inode_close>
if (rc > 0)
10a42e: 1e04 subs r4, r0, #0
10a430: dc34 bgt.n 10a49c <rtems_rfs_rtems_fstat+0x11c> <== ALWAYS TAKEN
}
10a432: 4630 mov r0, r6
10a434: b00b add sp, #44 ; 0x2c
10a436: bdf0 pop {r4, r5, r6, r7, pc}
return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);
10a438: 69d1 ldr r1, [r2, #28] <== NOT EXECUTED
10a43a: 6a13 ldr r3, [r2, #32] <== NOT EXECUTED
10a43c: ba09 rev r1, r1 <== NOT EXECUTED
10a43e: ba1b rev r3, r3 <== NOT EXECUTED
buf->st_rdev =
10a440: 6221 str r1, [r4, #32] <== NOT EXECUTED
10a442: 6263 str r3, [r4, #36] ; 0x24 <== NOT EXECUTED
10a444: e7b4 b.n 10a3b0 <rtems_rfs_rtems_fstat+0x30> <== 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);
10a446: f100 0184 add.w r1, r0, #132 ; 0x84
10a44a: 4628 mov r0, r5
10a44c: f006 fa0e bl 11086c <rtems_rfs_block_get_size>
buf->st_size = rtems_rfs_file_shared_get_size (fs, shared);
10a450: e9c4 010a strd r0, r1, [r4, #40] ; 0x28
10a454: e7e5 b.n 10a422 <rtems_rfs_rtems_fstat+0xa2>
buf->st_atime = rtems_rfs_inode_get_atime (&inode);
10a456: 9b03 ldr r3, [sp, #12]
if (S_ISLNK (buf->st_mode))
10a458: 6922 ldr r2, [r4, #16]
10a45a: 6919 ldr r1, [r3, #16]
buf->st_atime = rtems_rfs_inode_get_atime (&inode);
10a45c: 6360 str r0, [r4, #52] ; 0x34
if (S_ISLNK (buf->st_mode))
10a45e: f402 4270 and.w r2, r2, #61440 ; 0xf000
10a462: f5b2 4f20 cmp.w r2, #40960 ; 0xa000
10a466: ba09 rev r1, r1
buf->st_atime = rtems_rfs_inode_get_atime (&inode);
10a468: 6321 str r1, [r4, #48] ; 0x30
10a46a: 6959 ldr r1, [r3, #20]
buf->st_mtime = rtems_rfs_inode_get_mtime (&inode);
10a46c: 6460 str r0, [r4, #68] ; 0x44
10a46e: ba09 rev r1, r1
10a470: 6421 str r1, [r4, #64] ; 0x40
10a472: 6999 ldr r1, [r3, #24]
buf->st_ctime = rtems_rfs_inode_get_ctime (&inode);
10a474: 6560 str r0, [r4, #84] ; 0x54
10a476: ba09 rev r1, r1
10a478: 6521 str r1, [r4, #80] ; 0x50
10a47a: 68d9 ldr r1, [r3, #12]
10a47c: ba09 rev r1, r1
buf->st_blocks = rtems_rfs_inode_get_block_count (&inode);
10a47e: 6661 str r1, [r4, #100] ; 0x64
if (S_ISLNK (buf->st_mode))
10a480: d105 bne.n 10a48e <rtems_rfs_rtems_fstat+0x10e>
buf->st_size = rtems_rfs_inode_get_block_offset (&inode);
10a482: 895b ldrh r3, [r3, #10]
10a484: 62e0 str r0, [r4, #44] ; 0x2c
10a486: ba5b rev16 r3, r3
10a488: b29b uxth r3, r3
10a48a: 62a3 str r3, [r4, #40] ; 0x28
10a48c: e7c9 b.n 10a422 <rtems_rfs_rtems_fstat+0xa2>
buf->st_size = rtems_rfs_inode_get_size (fs, &inode);
10a48e: 4669 mov r1, sp
10a490: 4628 mov r0, r5
10a492: f7ff fd2f bl 109ef4 <rtems_rfs_inode_get_size>
10a496: e9c4 010a strd r0, r1, [r4, #40] ; 0x28
10a49a: e7c2 b.n 10a422 <rtems_rfs_rtems_fstat+0xa2>
return rtems_rfs_rtems_error ("stat: closing inode", rc);
10a49c: f00b ff94 bl 1163c8 <__errno> <== NOT EXECUTED
10a4a0: f04f 36ff mov.w r6, #4294967295 ; 0xffffffff <== NOT EXECUTED
10a4a4: 6004 str r4, [r0, #0] <== NOT EXECUTED
10a4a6: e7c4 b.n 10a432 <rtems_rfs_rtems_fstat+0xb2> <== NOT EXECUTED
return rtems_rfs_rtems_error ("stat: opening inode", rc);
10a4a8: f00b ff8e bl 1163c8 <__errno> <== NOT EXECUTED
10a4ac: 6006 str r6, [r0, #0] <== NOT EXECUTED
10a4ae: f04f 36ff mov.w r6, #4294967295 ; 0xffffffff <== NOT EXECUTED
10a4b2: e7be b.n 10a432 <rtems_rfs_rtems_fstat+0xb2> <== NOT EXECUTED
0010a624 <rtems_rfs_rtems_initialise>:
{
10a624: e92d 47f0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, lr}
10a628: 4682 mov sl, r0
10a62a: b084 sub sp, #16
while (options)
10a62c: 460c mov r4, r1
10a62e: 2900 cmp r1, #0
10a630: f000 8097 beq.w 10a762 <rtems_rfs_rtems_initialise+0x13e> <== NEVER TAKEN
printf ("options=%s\n", options);
10a634: f24a 6858 movw r8, #42584 ; 0xa658 <== NOT EXECUTED
if (strncmp (options, "hold-bitmaps",
10a638: f24a 6764 movw r7, #42596 ; 0xa664 <== NOT EXECUTED
else if (strncmp (options, "no-local-cache",
10a63c: f24a 6674 movw r6, #42612 ; 0xa674 <== NOT EXECUTED
uint32_t max_held_buffers = RTEMS_RFS_FS_MAX_HELD_BUFFERS;
10a640: f04f 0905 mov.w r9, #5 <== NOT EXECUTED
printf ("options=%s\n", options);
10a644: f2c0 0811 movt r8, #17 <== NOT EXECUTED
if (strncmp (options, "hold-bitmaps",
10a648: f2c0 0711 movt r7, #17 <== NOT EXECUTED
else if (strncmp (options, "no-local-cache",
10a64c: f2c0 0611 movt r6, #17 <== NOT EXECUTED
uint32_t flags = 0;
10a650: 2500 movs r5, #0 <== NOT EXECUTED
printf ("options=%s\n", options);
10a652: 4621 mov r1, r4 <== NOT EXECUTED
10a654: 4640 mov r0, r8 <== NOT EXECUTED
10a656: f7fb fa5f bl 105b18 <__wrap_printf> <== NOT EXECUTED
if (strncmp (options, "hold-bitmaps",
10a65a: 4639 mov r1, r7 <== NOT EXECUTED
10a65c: 220c movs r2, #12 <== NOT EXECUTED
10a65e: 4620 mov r0, r4 <== NOT EXECUTED
10a660: f00d f93c bl 1178dc <strncmp> <== NOT EXECUTED
10a664: 4603 mov r3, r0 <== NOT EXECUTED
else if (strncmp (options, "no-local-cache",
10a666: 4631 mov r1, r6 <== NOT EXECUTED
10a668: 220e movs r2, #14 <== NOT EXECUTED
10a66a: 4620 mov r0, r4 <== NOT EXECUTED
if (strncmp (options, "hold-bitmaps",
10a66c: 2b00 cmp r3, #0 <== NOT EXECUTED
10a66e: d13e bne.n 10a6ee <rtems_rfs_rtems_initialise+0xca> <== NOT EXECUTED
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
10a670: f045 0501 orr.w r5, r5, #1 <== NOT EXECUTED
options = strchr (options, ',');
10a674: 4620 mov r0, r4 <== NOT EXECUTED
10a676: 212c movs r1, #44 ; 0x2c <== NOT EXECUTED
10a678: f00c fc0a bl 116e90 <strchr> <== NOT EXECUTED
if (options)
10a67c: b118 cbz r0, 10a686 <rtems_rfs_rtems_initialise+0x62> <== NOT EXECUTED
if (*options == '\0')
10a67e: 7843 ldrb r3, [r0, #1] <== NOT EXECUTED
++options;
10a680: 1c44 adds r4, r0, #1 <== NOT EXECUTED
if (*options == '\0')
10a682: 2b00 cmp r3, #0 <== NOT EXECUTED
10a684: d1e5 bne.n 10a652 <rtems_rfs_rtems_initialise+0x2e> <== NOT EXECUTED
rtems = malloc (sizeof (rtems_rfs_rtems_private));
10a686: 2101 movs r1, #1
10a688: 2018 movs r0, #24
10a68a: f005 fa25 bl 10fad8 <calloc>
if (!rtems)
10a68e: 4604 mov r4, r0
10a690: 2800 cmp r0, #0
10a692: d072 beq.n 10a77a <rtems_rfs_rtems_initialise+0x156> <== ALWAYS TAKEN
rc = rtems_rfs_mutex_create (&rtems->access);
10a694: f008 fe44 bl 113320 <rtems_rfs_mutex_create>
if (rc > 0)
10a698: 1e06 subs r6, r0, #0
free (rtems);
10a69a: 4620 mov r0, r4
if (rc > 0)
10a69c: dc65 bgt.n 10a76a <rtems_rfs_rtems_initialise+0x146> <== ALWAYS TAKEN
_Mutex_recursive_Acquire( mutex );
10a69e: f001 fc4b bl 10bf38 <_Mutex_recursive_Acquire>
rc = rtems_rfs_fs_open (mt_entry->dev, rtems, flags, max_held_buffers, &fs);
10a6a2: a903 add r1, sp, #12
10a6a4: 462a mov r2, r5
10a6a6: 9100 str r1, [sp, #0]
10a6a8: 464b mov r3, r9
10a6aa: f8da 0038 ldr.w r0, [sl, #56] ; 0x38
10a6ae: 4621 mov r1, r4
10a6b0: f008 f86e bl 112790 <rtems_rfs_fs_open>
if (rc)
10a6b4: 4605 mov r5, r0
10a6b6: bb90 cbnz r0, 10a71e <rtems_rfs_rtems_initialise+0xfa>
mt_entry->fs_info = fs;
10a6b8: 9803 ldr r0, [sp, #12]
mt_entry->ops = &rtems_rfs_ops;
10a6ba: f24a 6394 movw r3, #42644 ; 0xa694
mt_entry->mt_fs_root->location.node_access = (void*) RTEMS_RFS_ROOT_INO;
10a6be: f8da 2024 ldr.w r2, [sl, #36] ; 0x24
mt_entry->ops = &rtems_rfs_ops;
10a6c2: f2c0 0311 movt r3, #17
mt_entry->mt_fs_root->location.node_access = (void*) RTEMS_RFS_ROOT_INO;
10a6c6: 2101 movs r1, #1
mt_entry->ops = &rtems_rfs_ops;
10a6c8: e9ca 0302 strd r0, r3, [sl, #8]
mt_entry->mt_fs_root->location.handlers = &rtems_rfs_rtems_dir_handlers;
10a6cc: f24a 7328 movw r3, #42792 ; 0xa728
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
10a6d0: f8d0 4080 ldr.w r4, [r0, #128] ; 0x80
10a6d4: f2c0 0311 movt r3, #17
mt_entry->mt_fs_root->location.node_access = (void*) RTEMS_RFS_ROOT_INO;
10a6d8: 6091 str r1, [r2, #8]
mt_entry->mt_fs_root->location.handlers = &rtems_rfs_rtems_dir_handlers;
10a6da: 6113 str r3, [r2, #16]
rtems_rfs_buffers_release (fs);
10a6dc: f7fe f8fe bl 1088dc <rtems_rfs_buffers_release>
_Mutex_recursive_Release( mutex );
10a6e0: 4620 mov r0, r4
10a6e2: f001 fc5b bl 10bf9c <_Mutex_recursive_Release>
}
10a6e6: 4628 mov r0, r5
10a6e8: b004 add sp, #16
10a6ea: e8bd 87f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, pc}
else if (strncmp (options, "no-local-cache",
10a6ee: f00d f8f5 bl 1178dc <strncmp> <== NOT EXECUTED
10a6f2: 4603 mov r3, r0 <== NOT EXECUTED
else if (strncmp (options, "max-held-bufs",
10a6f4: f24a 6184 movw r1, #42628 ; 0xa684 <== NOT EXECUTED
10a6f8: 220d movs r2, #13 <== NOT EXECUTED
10a6fa: f2c0 0111 movt r1, #17 <== NOT EXECUTED
10a6fe: 4620 mov r0, r4 <== NOT EXECUTED
else if (strncmp (options, "no-local-cache",
10a700: b913 cbnz r3, 10a708 <rtems_rfs_rtems_initialise+0xe4> <== NOT EXECUTED
flags |= RTEMS_RFS_FS_NO_LOCAL_CACHE;
10a702: f045 0502 orr.w r5, r5, #2 <== NOT EXECUTED
10a706: e7b5 b.n 10a674 <rtems_rfs_rtems_initialise+0x50> <== NOT EXECUTED
else if (strncmp (options, "max-held-bufs",
10a708: f00d f8e8 bl 1178dc <strncmp> <== NOT EXECUTED
10a70c: 4602 mov r2, r0 <== NOT EXECUTED
max_held_buffers = strtoul (options + sizeof ("max-held-bufs"), 0, 0);
10a70e: f104 000e add.w r0, r4, #14 <== NOT EXECUTED
10a712: 4611 mov r1, r2 <== NOT EXECUTED
else if (strncmp (options, "max-held-bufs",
10a714: b9da cbnz r2, 10a74e <rtems_rfs_rtems_initialise+0x12a> <== NOT EXECUTED
max_held_buffers = strtoul (options + sizeof ("max-held-bufs"), 0, 0);
10a716: f00d f9bb bl 117a90 <strtoul> <== NOT EXECUTED
10a71a: 4681 mov r9, r0 <== NOT EXECUTED
10a71c: e7aa b.n 10a674 <rtems_rfs_rtems_initialise+0x50> <== NOT EXECUTED
10a71e: 4620 mov r0, r4 <== NOT EXECUTED
10a720: f001 fc3c bl 10bf9c <_Mutex_recursive_Release> <== NOT EXECUTED
rtems_rfs_mutex_destroy (&rtems->access);
10a724: 4620 mov r0, r4 <== NOT EXECUTED
10a726: f008 fe09 bl 11333c <rtems_rfs_mutex_destroy> <== NOT EXECUTED
free (rtems);
10a72a: 4620 mov r0, r4 <== NOT EXECUTED
10a72c: f7fb faf0 bl 105d10 <free> <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: open", errno);
10a730: f00b fe4a bl 1163c8 <__errno> <== NOT EXECUTED
10a734: 4604 mov r4, r0 <== NOT EXECUTED
10a736: f00b fe47 bl 1163c8 <__errno> <== NOT EXECUTED
10a73a: 6823 ldr r3, [r4, #0] <== NOT EXECUTED
10a73c: 1e1d subs r5, r3, #0 <== NOT EXECUTED
10a73e: 6003 str r3, [r0, #0] <== NOT EXECUTED
10a740: bf18 it ne <== NOT EXECUTED
10a742: 2501 movne r5, #1 <== NOT EXECUTED
10a744: 426d negs r5, r5 <== NOT EXECUTED
}
10a746: 4628 mov r0, r5 <== NOT EXECUTED
10a748: b004 add sp, #16 <== NOT EXECUTED
10a74a: e8bd 87f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: invalid option", EINVAL);
10a74e: f00b fe3b bl 1163c8 <__errno> <== NOT EXECUTED
10a752: f04f 35ff mov.w r5, #4294967295 ; 0xffffffff <== NOT EXECUTED
10a756: 2316 movs r3, #22 <== NOT EXECUTED
10a758: 6003 str r3, [r0, #0] <== NOT EXECUTED
}
10a75a: 4628 mov r0, r5 <== NOT EXECUTED
10a75c: b004 add sp, #16 <== NOT EXECUTED
10a75e: e8bd 87f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
uint32_t max_held_buffers = RTEMS_RFS_FS_MAX_HELD_BUFFERS;
10a762: f04f 0905 mov.w r9, #5
uint32_t flags = 0;
10a766: 460d mov r5, r1
10a768: e78d b.n 10a686 <rtems_rfs_rtems_initialise+0x62>
free (rtems);
10a76a: f7fb fad1 bl 105d10 <free> <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: cannot create mutex", rc);
10a76e: f04f 35ff mov.w r5, #4294967295 ; 0xffffffff <== NOT EXECUTED
10a772: f00b fe29 bl 1163c8 <__errno> <== NOT EXECUTED
10a776: 6006 str r6, [r0, #0] <== NOT EXECUTED
10a778: e7b5 b.n 10a6e6 <rtems_rfs_rtems_initialise+0xc2> <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: local data", ENOMEM);
10a77a: f00b fe25 bl 1163c8 <__errno> <== NOT EXECUTED
10a77e: 230c movs r3, #12 <== NOT EXECUTED
10a780: f04f 35ff mov.w r5, #4294967295 ; 0xffffffff <== NOT EXECUTED
10a784: 6003 str r3, [r0, #0] <== NOT EXECUTED
10a786: e7ae b.n 10a6e6 <rtems_rfs_rtems_initialise+0xc2> <== NOT EXECUTED
0010a8fc <rtems_rfs_rtems_set_handlers>:
return rtems_rfs_read_u16 (&handle->node->mode);
10a8fc: 68ca ldr r2, [r1, #12]
*/
bool
rtems_rfs_rtems_set_handlers (rtems_filesystem_location_info_t* loc,
rtems_rfs_inode_handle* inode)
{
10a8fe: 4603 mov r3, r0
10a900: b510 push {r4, lr}
uint16_t mode = rtems_rfs_inode_get_mode (inode);
loc->handlers = NULL;
10a902: 2400 movs r4, #0
10a904: 8851 ldrh r1, [r2, #2]
10a906: 6104 str r4, [r0, #16]
10a908: ba49 rev16 r1, r1
10a90a: f401 4270 and.w r2, r1, #61440 ; 0xf000
if (RTEMS_RFS_S_ISDIR (mode))
10a90e: f5b2 4f80 cmp.w r2, #16384 ; 0x4000
10a912: d019 beq.n 10a948 <rtems_rfs_rtems_set_handlers+0x4c>
loc->handlers = rtems_rfs_rtems_handlers (dir);
else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))
10a914: b289 uxth r1, r1
10a916: f401 4030 and.w r0, r1, #45056 ; 0xb000
10a91a: f5b0 5f00 cmp.w r0, #8192 ; 0x2000
10a91e: d00c beq.n 10a93a <rtems_rfs_rtems_set_handlers+0x3e> <== ALWAYS TAKEN
loc->handlers = rtems_rfs_rtems_handlers (device);
else if (RTEMS_RFS_S_ISLNK (mode))
10a920: f5b2 4f20 cmp.w r2, #40960 ; 0xa000
10a924: d01f beq.n 10a966 <rtems_rfs_rtems_set_handlers+0x6a>
loc->handlers = rtems_rfs_rtems_handlers (link);
else if (RTEMS_RFS_S_ISREG (mode))
10a926: f5b2 4f00 cmp.w r2, #32768 ; 0x8000
10a92a: d114 bne.n 10a956 <rtems_rfs_rtems_set_handlers+0x5a> <== ALWAYS TAKEN
loc->handlers = rtems_rfs_rtems_handlers (file);
10a92c: f64b 52a4 movw r2, #48548 ; 0xbda4
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
return false;
}
return true;
10a930: 2001 movs r0, #1
loc->handlers = rtems_rfs_rtems_handlers (file);
10a932: f2c0 0211 movt r2, #17
10a936: 611a str r2, [r3, #16]
}
10a938: bd10 pop {r4, pc}
loc->handlers = rtems_rfs_rtems_handlers (device);
10a93a: f64b 5264 movw r2, #48484 ; 0xbd64 <== NOT EXECUTED
return true;
10a93e: 2001 movs r0, #1 <== NOT EXECUTED
loc->handlers = rtems_rfs_rtems_handlers (device);
10a940: f2c0 0211 movt r2, #17 <== NOT EXECUTED
10a944: 611a str r2, [r3, #16] <== NOT EXECUTED
}
10a946: bd10 pop {r4, pc} <== NOT EXECUTED
loc->handlers = rtems_rfs_rtems_handlers (dir);
10a948: f24a 7228 movw r2, #42792 ; 0xa728
return true;
10a94c: 2001 movs r0, #1
loc->handlers = rtems_rfs_rtems_handlers (dir);
10a94e: f2c0 0211 movt r2, #17
10a952: 611a str r2, [r3, #16]
}
10a954: bd10 pop {r4, pc}
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
10a956: f24a 7068 movw r0, #42856 ; 0xa768 <== NOT EXECUTED
10a95a: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10a95e: f7fb f8db bl 105b18 <__wrap_printf> <== NOT EXECUTED
return false;
10a962: 4620 mov r0, r4 <== NOT EXECUTED
}
10a964: bd10 pop {r4, pc} <== NOT EXECUTED
loc->handlers = rtems_rfs_rtems_handlers (link);
10a966: f24a 62e8 movw r2, #42728 ; 0xa6e8
return true;
10a96a: 2001 movs r0, #1
loc->handlers = rtems_rfs_rtems_handlers (link);
10a96c: f2c0 0211 movt r2, #17
10a970: 611a str r2, [r3, #16]
}
10a972: bd10 pop {r4, pc}
00113078 <rtems_rfs_symlink>:
const char* link,
int link_length,
uid_t uid,
gid_t gid,
rtems_rfs_ino parent)
{
113078: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
11307c: 4605 mov r5, r0
11307e: b0ab sub sp, #172 ; 0xac
113080: 4688 mov r8, r1
rtems_rfs_inode_handle inode;
rtems_rfs_ino ino;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
113082: 2000 movs r0, #0
113084: 2102 movs r1, #2
{
113086: 9f34 ldr r7, [sp, #208] ; 0xd0
113088: 4693 mov fp, r2
11308a: f8bd 90d4 ldrh.w r9, [sp, #212] ; 0xd4
11308e: 461e mov r6, r3
113090: f8bd a0d8 ldrh.w sl, [sp, #216] ; 0xd8
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
113094: f7f7 fc72 bl 10a97c <rtems_rfs_trace>
113098: 2800 cmp r0, #0
11309a: d151 bne.n 113140 <rtems_rfs_symlink+0xc8> <== ALWAYS TAKEN
printf (" link:");
for (c = 0; c < link_length; c++)
printf ("%c", link[c]);
}
if (link_length >= rtems_rfs_fs_block_size (fs))
11309c: 68ab ldr r3, [r5, #8]
11309e: 42bb cmp r3, r7
return ENAMETOOLONG;
1130a0: bf98 it ls
1130a2: 245b movls r4, #91 ; 0x5b
if (link_length >= rtems_rfs_fs_block_size (fs))
1130a4: d914 bls.n 1130d0 <rtems_rfs_symlink+0x58> <== ALWAYS TAKEN
rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),
1130a6: 4640 mov r0, r8
1130a8: f004 fbaa bl 117800 <strlen>
1130ac: a907 add r1, sp, #28
1130ae: 4642 mov r2, r8
1130b0: 9104 str r1, [sp, #16]
1130b2: f04f 0801 mov.w r8, #1
1130b6: f24a 11ff movw r1, #41471 ; 0xa1ff
1130ba: 4603 mov r3, r0
1130bc: e9cd 1800 strd r1, r8, [sp]
1130c0: 4628 mov r0, r5
1130c2: 9937 ldr r1, [sp, #220] ; 0xdc
1130c4: e9cd 9a02 strd r9, sl, [sp, #8]
1130c8: f7f6 fdf0 bl 109cac <rtems_rfs_inode_create>
RTEMS_RFS_S_SYMLINK,
1, uid, gid, &ino);
if (rc > 0)
1130cc: 1e04 subs r4, r0, #0
1130ce: dd03 ble.n 1130d8 <rtems_rfs_symlink+0x60> <== NEVER TAKEN
rtems_rfs_inode_set_block_offset (&inode, link_length);
rc = rtems_rfs_inode_close (fs, &inode);
return rc;
}
1130d0: 4620 mov r0, r4
1130d2: b02b add sp, #172 ; 0xac
1130d4: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
1130d8: 9907 ldr r1, [sp, #28]
1130da: 4643 mov r3, r8
1130dc: aa0c add r2, sp, #48 ; 0x30
1130de: 4628 mov r0, r5
1130e0: f7f6 fc34 bl 10994c <rtems_rfs_inode_open>
if (rc > 0)
1130e4: 1e04 subs r4, r0, #0
1130e6: dcf3 bgt.n 1130d0 <rtems_rfs_symlink+0x58> <== ALWAYS TAKEN
if (link_length < RTEMS_RFS_INODE_DATA_NAME_SIZE)
1130e8: 2f13 cmp r7, #19
1130ea: d84e bhi.n 11318a <rtems_rfs_symlink+0x112> <== ALWAYS TAKEN
memset (inode.node->data.name, 0, RTEMS_RFS_INODE_DATA_NAME_SIZE);
1130ec: f8dd 803c ldr.w r8, [sp, #60] ; 0x3c
1130f0: 2400 movs r4, #0
memcpy (inode.node->data.name, link, link_length);
1130f2: 4631 mov r1, r6
1130f4: 463a mov r2, r7
1130f6: f108 001c add.w r0, r8, #28
memset (inode.node->data.name, 0, RTEMS_RFS_INODE_DATA_NAME_SIZE);
1130fa: f8c8 401c str.w r4, [r8, #28]
1130fe: f8c8 4020 str.w r4, [r8, #32]
113102: f8c8 4024 str.w r4, [r8, #36] ; 0x24
113106: f8c8 4028 str.w r4, [r8, #40] ; 0x28
11310a: f8c8 402c str.w r4, [r8, #44] ; 0x2c
memcpy (inode.node->data.name, link, link_length);
11310e: f003 ea98 blx 116640 <memcpy>
rtems_rfs_write_u32 (&handle->node->block_count, block_count);
113112: f888 400c strb.w r4, [r8, #12]
113116: 9b0f ldr r3, [sp, #60] ; 0x3c
113118: 735c strb r4, [r3, #13]
11311a: 9b0f ldr r3, [sp, #60] ; 0x3c
11311c: 739c strb r4, [r3, #14]
11311e: 9b0f ldr r3, [sp, #60] ; 0x3c
113120: 73dc strb r4, [r3, #15]
rtems_rfs_write_u16 (&handle->node->block_offset, block_offset);
113122: 9b0f ldr r3, [sp, #60] ; 0x3c
113124: f3c7 2207 ubfx r2, r7, #8, #8
rc = rtems_rfs_inode_close (fs, &inode);
113128: a90c add r1, sp, #48 ; 0x30
11312a: 4628 mov r0, r5
11312c: 729a strb r2, [r3, #10]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
11312e: 2301 movs r3, #1
rtems_rfs_write_u16 (&handle->node->block_offset, block_offset);
113130: 9a0f ldr r2, [sp, #60] ; 0x3c
113132: 72d7 strb r7, [r2, #11]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
113134: f88d 3040 strb.w r3, [sp, #64] ; 0x40
113138: f7f6 fc90 bl 109a5c <rtems_rfs_inode_close>
11313c: 4604 mov r4, r0
return rc;
11313e: e7c7 b.n 1130d0 <rtems_rfs_symlink+0x58>
printf ("rtems-rfs: symlink: parent:%" PRIu32 " name:", parent);
113140: f64b 5014 movw r0, #48404 ; 0xbd14 <== NOT EXECUTED
113144: 9937 ldr r1, [sp, #220] ; 0xdc <== NOT EXECUTED
113146: f2c0 0011 movt r0, #17 <== NOT EXECUTED
11314a: f7f2 fce5 bl 105b18 <__wrap_printf> <== NOT EXECUTED
for (c = 0; c < length; c++)
11314e: f1bb 0f00 cmp.w fp, #0 <== NOT EXECUTED
113152: dd08 ble.n 113166 <rtems_rfs_symlink+0xee> <== NOT EXECUTED
113154: f108 34ff add.w r4, r8, #4294967295 ; 0xffffffff <== NOT EXECUTED
113158: 44a3 add fp, r4 <== NOT EXECUTED
printf ("%c", name[c]);
11315a: f814 0f01 ldrb.w r0, [r4, #1]! <== NOT EXECUTED
11315e: f003 fdad bl 116cbc <putchar> <== NOT EXECUTED
for (c = 0; c < length; c++)
113162: 45a3 cmp fp, r4 <== NOT EXECUTED
113164: d1f9 bne.n 11315a <rtems_rfs_symlink+0xe2> <== NOT EXECUTED
printf (" link:");
113166: f64b 5038 movw r0, #48440 ; 0xbd38 <== NOT EXECUTED
11316a: f2c0 0011 movt r0, #17 <== NOT EXECUTED
11316e: f7f2 fcd3 bl 105b18 <__wrap_printf> <== NOT EXECUTED
for (c = 0; c < link_length; c++)
113172: 2f00 cmp r7, #0 <== NOT EXECUTED
113174: dd92 ble.n 11309c <rtems_rfs_symlink+0x24> <== NOT EXECUTED
113176: 1e74 subs r4, r6, #1 <== NOT EXECUTED
113178: eb04 0b07 add.w fp, r4, r7 <== NOT EXECUTED
printf ("%c", link[c]);
11317c: f814 0f01 ldrb.w r0, [r4, #1]! <== NOT EXECUTED
113180: f003 fd9c bl 116cbc <putchar> <== NOT EXECUTED
for (c = 0; c < link_length; c++)
113184: 45a3 cmp fp, r4 <== NOT EXECUTED
113186: d1f9 bne.n 11317c <rtems_rfs_symlink+0x104> <== NOT EXECUTED
113188: e788 b.n 11309c <rtems_rfs_symlink+0x24> <== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, &inode, &map);
11318a: a90c add r1, sp, #48 ; 0x30 <== NOT EXECUTED
11318c: aa16 add r2, sp, #88 ; 0x58 <== NOT EXECUTED
11318e: 4628 mov r0, r5 <== NOT EXECUTED
113190: f7fd fb7c bl 11088c <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc > 0)
113194: 1e04 subs r4, r0, #0 <== NOT EXECUTED
113196: dc2e bgt.n 1131f6 <rtems_rfs_symlink+0x17e> <== NOT EXECUTED
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
113198: 4642 mov r2, r8 <== NOT EXECUTED
11319a: ab08 add r3, sp, #32 <== NOT EXECUTED
11319c: a916 add r1, sp, #88 ; 0x58 <== NOT EXECUTED
11319e: 4628 mov r0, r5 <== NOT EXECUTED
1131a0: f7fd fcfa bl 110b98 <rtems_rfs_block_map_grow> <== NOT EXECUTED
if (rc > 0)
1131a4: 1e04 subs r4, r0, #0 <== NOT EXECUTED
1131a6: dc2b bgt.n 113200 <rtems_rfs_symlink+0x188> <== NOT EXECUTED
handle->dirty = false;
1131a8: f04f 0800 mov.w r8, #0 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false);
1131ac: 9a08 ldr r2, [sp, #32] <== NOT EXECUTED
1131ae: 4643 mov r3, r8 <== NOT EXECUTED
1131b0: a909 add r1, sp, #36 ; 0x24 <== NOT EXECUTED
1131b2: 4628 mov r0, r5 <== NOT EXECUTED
1131b4: f88d 8024 strb.w r8, [sp, #36] ; 0x24 <== NOT EXECUTED
handle->buffer = NULL;
1131b8: e9cd 880a strd r8, r8, [sp, #40] ; 0x28 <== NOT EXECUTED
1131bc: f7f5 f9ee bl 10859c <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
1131c0: 1e04 subs r4, r0, #0 <== NOT EXECUTED
1131c2: dc1d bgt.n 113200 <rtems_rfs_symlink+0x188> <== NOT EXECUTED
data = rtems_rfs_buffer_data (&buffer);
1131c4: 9b0b ldr r3, [sp, #44] ; 0x2c <== NOT EXECUTED
memset (data, 0xff, rtems_rfs_fs_block_size (fs));
1131c6: 21ff movs r1, #255 ; 0xff <== NOT EXECUTED
1131c8: 68aa ldr r2, [r5, #8] <== NOT EXECUTED
data = rtems_rfs_buffer_data (&buffer);
1131ca: 69db ldr r3, [r3, #28] <== NOT EXECUTED
memset (data, 0xff, rtems_rfs_fs_block_size (fs));
1131cc: 4618 mov r0, r3 <== NOT EXECUTED
1131ce: f003 fd23 bl 116c18 <memset> <== NOT EXECUTED
memcpy (data, link, link_length);
1131d2: 463a mov r2, r7 <== NOT EXECUTED
1131d4: 4631 mov r1, r6 <== NOT EXECUTED
1131d6: f003 ea34 blx 116640 <memcpy> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
1131da: a909 add r1, sp, #36 ; 0x24 <== NOT EXECUTED
1131dc: 4628 mov r0, r5 <== NOT EXECUTED
1131de: f7f5 fac9 bl 108774 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
rc = rtems_rfs_block_map_close (fs, &map);
1131e2: a916 add r1, sp, #88 ; 0x58 <== NOT EXECUTED
1131e4: 4628 mov r0, r5 <== NOT EXECUTED
handle->dirty = false;
1131e6: f88d 8024 strb.w r8, [sp, #36] ; 0x24 <== NOT EXECUTED
handle->buffer = NULL;
1131ea: e9cd 880a strd r8, r8, [sp, #40] ; 0x28 <== NOT EXECUTED
1131ee: f7fd fb9f bl 110930 <rtems_rfs_block_map_close> <== NOT EXECUTED
if (rc > 0)
1131f2: 1e04 subs r4, r0, #0 <== NOT EXECUTED
1131f4: dd95 ble.n 113122 <rtems_rfs_symlink+0xaa> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
1131f6: a90c add r1, sp, #48 ; 0x30 <== NOT EXECUTED
1131f8: 4628 mov r0, r5 <== NOT EXECUTED
1131fa: f7f6 fc2f bl 109a5c <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
1131fe: e767 b.n 1130d0 <rtems_rfs_symlink+0x58> <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
113200: a916 add r1, sp, #88 ; 0x58 <== NOT EXECUTED
113202: 4628 mov r0, r5 <== NOT EXECUTED
113204: f7fd fb94 bl 110930 <rtems_rfs_block_map_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
113208: a90c add r1, sp, #48 ; 0x30 <== NOT EXECUTED
11320a: 4628 mov r0, r5 <== NOT EXECUTED
11320c: f7f6 fc26 bl 109a5c <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
113210: e75e b.n 1130d0 <rtems_rfs_symlink+0x58> <== NOT EXECUTED
113212: bf00 nop
00113214 <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)
{
113214: b5f0 push {r4, r5, r6, r7, lr}
113216: 4605 mov r5, r0
113218: b0a5 sub sp, #148 ; 0x94
11321a: 460c mov r4, r1
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))
11321c: 2000 movs r0, #0
11321e: 2104 movs r1, #4
{
113220: 4616 mov r6, r2
113222: 461f mov r7, r3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))
113224: f7f7 fbaa bl 10a97c <rtems_rfs_trace>
113228: 2800 cmp r0, #0
11322a: d15f bne.n 1132ec <rtems_rfs_symlink_read+0xd8> <== ALWAYS TAKEN
printf ("rtems-rfs: symlink-read: link:%" PRIu32 "\n", link);
rc = rtems_rfs_inode_open (fs, link, &inode, true);
11322c: 4621 mov r1, r4
11322e: 2301 movs r3, #1
113230: aa06 add r2, sp, #24
113232: 4628 mov r0, r5
113234: f7f6 fb8a bl 10994c <rtems_rfs_inode_open>
if (rc)
113238: 4604 mov r4, r0
11323a: b9d0 cbnz r0, 113272 <rtems_rfs_symlink_read+0x5e>
return rtems_rfs_read_u16 (&handle->node->mode);
11323c: 9909 ldr r1, [sp, #36] ; 0x24
return rc;
if (!RTEMS_RFS_S_ISLNK (rtems_rfs_inode_get_mode (&inode)))
11323e: 884b ldrh r3, [r1, #2]
113240: ba5b rev16 r3, r3
113242: f403 4370 and.w r3, r3, #61440 ; 0xf000
113246: f5b3 4f20 cmp.w r3, #40960 ; 0xa000
11324a: d160 bne.n 11330e <rtems_rfs_symlink_read+0xfa> <== ALWAYS TAKEN
{
rtems_rfs_inode_close (fs, &inode);
return EINVAL;
}
*length = rtems_rfs_inode_get_block_offset (&inode);
11324c: 894a ldrh r2, [r1, #10]
11324e: 9b2a ldr r3, [sp, #168] ; 0xa8
113250: ba52 rev16 r2, r2
113252: b292 uxth r2, r2
113254: 42ba cmp r2, r7
113256: bf28 it cs
113258: 463a movcs r2, r7
11325a: 601a str r2, [r3, #0]
return rtems_rfs_read_u32 (&handle->node->block_count);
11325c: 68cb ldr r3, [r1, #12]
if (size < *length)
{
*length = size;
}
if (rtems_rfs_inode_get_block_count (&inode) == 0)
11325e: b95b cbnz r3, 113278 <rtems_rfs_symlink_read+0x64>
{
memcpy (path, inode.node->data.name, *length);
113260: 311c adds r1, #28
113262: 4630 mov r0, r6
113264: f003 e9ec blx 116640 <memcpy>
rtems_rfs_inode_close (fs, &inode);
return rc;
}
}
rc = rtems_rfs_inode_close (fs, &inode);
113268: a906 add r1, sp, #24
11326a: 4628 mov r0, r5
11326c: f7f6 fbf6 bl 109a5c <rtems_rfs_inode_close>
113270: 4604 mov r4, r0
return rc;
}
113272: 4620 mov r0, r4
113274: b025 add sp, #148 ; 0x94
113276: bdf0 pop {r4, r5, r6, r7, pc}
rc = rtems_rfs_block_map_open (fs, &inode, &map);
113278: aa10 add r2, sp, #64 ; 0x40 <== NOT EXECUTED
11327a: a906 add r1, sp, #24 <== NOT EXECUTED
11327c: 4628 mov r0, r5 <== NOT EXECUTED
11327e: f7fd fb05 bl 11088c <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc > 0)
113282: 1e04 subs r4, r0, #0 <== NOT EXECUTED
113284: dc2b bgt.n 1132de <rtems_rfs_symlink_read+0xca> <== NOT EXECUTED
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
113286: ab02 add r3, sp, #8 <== NOT EXECUTED
113288: 2200 movs r2, #0 <== NOT EXECUTED
11328a: 9300 str r3, [sp, #0] <== NOT EXECUTED
11328c: a910 add r1, sp, #64 ; 0x40 <== NOT EXECUTED
11328e: 2300 movs r3, #0 <== NOT EXECUTED
113290: 4628 mov r0, r5 <== NOT EXECUTED
113292: f7fd fc55 bl 110b40 <rtems_rfs_block_map_seek> <== NOT EXECUTED
if (rc > 0)
113296: 1e04 subs r4, r0, #0 <== NOT EXECUTED
113298: dc30 bgt.n 1132fc <rtems_rfs_symlink_read+0xe8> <== NOT EXECUTED
handle->dirty = false;
11329a: 2700 movs r7, #0 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false);
11329c: 9a02 ldr r2, [sp, #8] <== NOT EXECUTED
11329e: 463b mov r3, r7 <== NOT EXECUTED
1132a0: a903 add r1, sp, #12 <== NOT EXECUTED
1132a2: 4628 mov r0, r5 <== NOT EXECUTED
1132a4: f88d 700c strb.w r7, [sp, #12] <== NOT EXECUTED
handle->buffer = NULL;
1132a8: e9cd 7704 strd r7, r7, [sp, #16] <== NOT EXECUTED
1132ac: f7f5 f976 bl 10859c <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
1132b0: 1e04 subs r4, r0, #0 <== NOT EXECUTED
1132b2: dc23 bgt.n 1132fc <rtems_rfs_symlink_read+0xe8> <== NOT EXECUTED
data = rtems_rfs_buffer_data (&buffer);
1132b4: 9b05 ldr r3, [sp, #20] <== NOT EXECUTED
memcpy (path, data, *length);
1132b6: 4630 mov r0, r6 <== NOT EXECUTED
1132b8: 69d9 ldr r1, [r3, #28] <== NOT EXECUTED
1132ba: 9b2a ldr r3, [sp, #168] ; 0xa8 <== NOT EXECUTED
1132bc: 681a ldr r2, [r3, #0] <== NOT EXECUTED
1132be: f003 e9c0 blx 116640 <memcpy> <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
1132c2: a903 add r1, sp, #12 <== NOT EXECUTED
1132c4: 4628 mov r0, r5 <== NOT EXECUTED
1132c6: f7f5 fa55 bl 108774 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
rc = rtems_rfs_block_map_close (fs, &map);
1132ca: a910 add r1, sp, #64 ; 0x40 <== NOT EXECUTED
1132cc: 4628 mov r0, r5 <== NOT EXECUTED
handle->dirty = false;
1132ce: f88d 700c strb.w r7, [sp, #12] <== NOT EXECUTED
handle->buffer = NULL;
1132d2: e9cd 7704 strd r7, r7, [sp, #16] <== NOT EXECUTED
1132d6: f7fd fb2b bl 110930 <rtems_rfs_block_map_close> <== NOT EXECUTED
if (rc > 0)
1132da: 1e04 subs r4, r0, #0 <== NOT EXECUTED
1132dc: ddc4 ble.n 113268 <rtems_rfs_symlink_read+0x54> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
1132de: a906 add r1, sp, #24 <== NOT EXECUTED
1132e0: 4628 mov r0, r5 <== NOT EXECUTED
1132e2: f7f6 fbbb bl 109a5c <rtems_rfs_inode_close> <== NOT EXECUTED
}
1132e6: 4620 mov r0, r4 <== NOT EXECUTED
1132e8: b025 add sp, #148 ; 0x94 <== NOT EXECUTED
1132ea: bdf0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
printf ("rtems-rfs: symlink-read: link:%" PRIu32 "\n", link);
1132ec: f64b 5040 movw r0, #48448 ; 0xbd40 <== NOT EXECUTED
1132f0: 4621 mov r1, r4 <== NOT EXECUTED
1132f2: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1132f6: f7f2 fc0f bl 105b18 <__wrap_printf> <== NOT EXECUTED
1132fa: e797 b.n 11322c <rtems_rfs_symlink_read+0x18> <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
1132fc: a910 add r1, sp, #64 ; 0x40 <== NOT EXECUTED
1132fe: 4628 mov r0, r5 <== NOT EXECUTED
113300: f7fd fb16 bl 110930 <rtems_rfs_block_map_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
113304: a906 add r1, sp, #24 <== NOT EXECUTED
113306: 4628 mov r0, r5 <== NOT EXECUTED
113308: f7f6 fba8 bl 109a5c <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
11330c: e7eb b.n 1132e6 <rtems_rfs_symlink_read+0xd2> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
11330e: a906 add r1, sp, #24 <== NOT EXECUTED
113310: 4628 mov r0, r5 <== NOT EXECUTED
return EINVAL;
113312: 2416 movs r4, #22 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
113314: f7f6 fba2 bl 109a5c <rtems_rfs_inode_close> <== NOT EXECUTED
}
113318: 4620 mov r0, r4 <== NOT EXECUTED
11331a: b025 add sp, #148 ; 0x94 <== NOT EXECUTED
11331c: bdf0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
11331e: bf00 nop
00112da0 <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)
{
112da0: e92d 43f0 stmdb sp!, {r4, r5, r6, r7, r8, r9, lr}
112da4: 4605 mov r5, r0
112da6: b095 sub sp, #84 ; 0x54
112da8: 4688 mov r8, r1
rtems_rfs_inode_handle target_inode;
uint16_t links;
bool dir;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
112daa: f04f 7000 mov.w r0, #33554432 ; 0x2000000
112dae: 2100 movs r1, #0
{
112db0: 4616 mov r6, r2
112db2: 4699 mov r9, r3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
112db4: f7f7 fde2 bl 10a97c <rtems_rfs_trace>
112db8: 2800 cmp r0, #0
112dba: d15d bne.n 112e78 <rtems_rfs_unlink+0xd8> <== ALWAYS TAKEN
printf ("rtems-rfs: unlink: parent(%" PRIu32 ") -X-> (%" PRIu32 ")\n", parent, target);
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
112dbc: 2301 movs r3, #1
112dbe: aa0a add r2, sp, #40 ; 0x28
112dc0: 4631 mov r1, r6
112dc2: 4628 mov r0, r5
112dc4: f7f6 fdc2 bl 10994c <rtems_rfs_inode_open>
if (rc)
112dc8: 4604 mov r4, r0
112dca: 2800 cmp r0, #0
112dcc: d150 bne.n 112e70 <rtems_rfs_unlink+0xd0> <== ALWAYS TAKEN
return rtems_rfs_read_u16 (&handle->node->mode);
112dce: 9b0d ldr r3, [sp, #52] ; 0x34
112dd0: 885f ldrh r7, [r3, #2]
112dd2: ba7f rev16 r7, r7
112dd4: f407 4770 and.w r7, r7, #61440 ; 0xf000
/*
* If a directory process the unlink mode.
*/
dir = RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&target_inode));
if (dir)
112dd8: f5b7 4f80 cmp.w r7, #16384 ; 0x4000
112ddc: d105 bne.n 112dea <rtems_rfs_unlink+0x4a>
{
switch (dir_mode)
112dde: 9b1c ldr r3, [sp, #112] ; 0x70
112de0: 2b00 cmp r3, #0
112de2: f000 80a3 beq.w 112f2c <rtems_rfs_unlink+0x18c> <== ALWAYS TAKEN
112de6: 2b01 cmp r3, #1
112de8: d05e beq.n 112ea8 <rtems_rfs_unlink+0x108>
default:
break;
}
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
112dea: 4641 mov r1, r8
112dec: 2301 movs r3, #1
112dee: 466a mov r2, sp
112df0: 4628 mov r0, r5
112df2: f7f6 fdab bl 10994c <rtems_rfs_inode_open>
if (rc)
112df6: 4604 mov r4, r0
112df8: 2800 cmp r0, #0
112dfa: d146 bne.n 112e8a <rtems_rfs_unlink+0xea> <== ALWAYS TAKEN
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_dir_del_entry (fs, &parent_inode, target, doff);
112dfc: 464b mov r3, r9
112dfe: 4632 mov r2, r6
112e00: 4669 mov r1, sp
112e02: 4628 mov r0, r5
112e04: f7fe fc2e bl 111664 <rtems_rfs_dir_del_entry>
if (rc > 0)
112e08: 1e04 subs r4, r0, #0
112e0a: f300 80b2 bgt.w 112f72 <rtems_rfs_unlink+0x1d2> <== ALWAYS TAKEN
links = rtems_rfs_read_u16 (&handle->node->links);
112e0e: 9b0d ldr r3, [sp, #52] ; 0x34
return rc;
}
links = rtems_rfs_inode_get_links (&target_inode);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
112e10: f04f 7000 mov.w r0, #33554432 ; 0x2000000
112e14: 2100 movs r1, #0
112e16: 881c ldrh r4, [r3, #0]
if (links == 0xffff)
112e18: f64f 73ff movw r3, #65535 ; 0xffff
112e1c: ba64 rev16 r4, r4
112e1e: b2a4 uxth r4, r4
112e20: 429c cmp r4, r3
112e22: d05a beq.n 112eda <rtems_rfs_unlink+0x13a> <== ALWAYS TAKEN
112e24: f7f7 fdaa bl 10a97c <rtems_rfs_trace>
112e28: 2800 cmp r0, #0
112e2a: f040 80d5 bne.w 112fd8 <rtems_rfs_unlink+0x238> <== ALWAYS TAKEN
printf ("rtems-rfs: unlink: target:%" PRIu32 " links:%u\n", target, links);
if (links > 1)
112e2e: 2c01 cmp r4, #1
112e30: d958 bls.n 112ee4 <rtems_rfs_unlink+0x144>
{
links--;
112e32: 3c01 subs r4, #1
rtems_rfs_write_u16 (&handle->node->links, links);
112e34: 9a0d ldr r2, [sp, #52] ; 0x34
112e36: b2a4 uxth r4, r4
rtems_rfs_buffer_mark_dirty (&handle->buffer);
112e38: 2301 movs r3, #1
rtems_rfs_write_u16 (&handle->node->links, links);
112e3a: 0a21 lsrs r1, r4, #8
112e3c: 7011 strb r1, [r2, #0]
112e3e: 9a0d ldr r2, [sp, #52] ; 0x34
112e40: 7054 strb r4, [r2, #1]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
112e42: f88d 3038 strb.w r3, [sp, #56] ; 0x38
links--;
rtems_rfs_inode_set_links (&parent_inode, links);
}
}
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
112e46: 2201 movs r2, #1
112e48: 4668 mov r0, sp
112e4a: 4611 mov r1, r2
112e4c: f7f6 fe98 bl 109b80 <rtems_rfs_inode_time_stamp_now>
if (rc > 0)
112e50: 1e04 subs r4, r0, #0
112e52: dc7b bgt.n 112f4c <rtems_rfs_unlink+0x1ac> <== ALWAYS 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);
112e54: 4669 mov r1, sp
112e56: 4628 mov r0, r5
112e58: f7f6 fe00 bl 109a5c <rtems_rfs_inode_close>
if (rc > 0)
112e5c: 1e04 subs r4, r0, #0
112e5e: f300 80a7 bgt.w 112fb0 <rtems_rfs_unlink+0x210> <== ALWAYS TAKEN
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &target_inode);
112e62: a90a add r1, sp, #40 ; 0x28
112e64: 4628 mov r0, r5
112e66: f7f6 fdf9 bl 109a5c <rtems_rfs_inode_close>
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
112e6a: 1e04 subs r4, r0, #0
112e6c: f300 80bd bgt.w 112fea <rtems_rfs_unlink+0x24a> <== ALWAYS TAKEN
printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",
rc, strerror (rc));
return rc;
}
112e70: 4620 mov r0, r4
112e72: b015 add sp, #84 ; 0x54
112e74: e8bd 83f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, pc}
printf ("rtems-rfs: unlink: parent(%" PRIu32 ") -X-> (%" PRIu32 ")\n", parent, target);
112e78: f64b 305c movw r0, #47964 ; 0xbb5c <== NOT EXECUTED
112e7c: 4632 mov r2, r6 <== NOT EXECUTED
112e7e: 4641 mov r1, r8 <== NOT EXECUTED
112e80: f2c0 0011 movt r0, #17 <== NOT EXECUTED
112e84: f7f2 fe48 bl 105b18 <__wrap_printf> <== NOT EXECUTED
112e88: e798 b.n 112dbc <rtems_rfs_unlink+0x1c> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
112e8a: f04f 7000 mov.w r0, #33554432 ; 0x2000000 <== NOT EXECUTED
112e8e: 2100 movs r1, #0 <== NOT EXECUTED
112e90: f7f7 fd74 bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
112e94: 2800 cmp r0, #0 <== NOT EXECUTED
112e96: d17f bne.n 112f98 <rtems_rfs_unlink+0x1f8> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
112e98: a90a add r1, sp, #40 ; 0x28
112e9a: 4628 mov r0, r5
112e9c: f7f6 fdde bl 109a5c <rtems_rfs_inode_close>
}
112ea0: 4620 mov r0, r4
112ea2: b015 add sp, #84 ; 0x54
112ea4: e8bd 83f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, pc}
rc = rtems_rfs_dir_empty (fs, &target_inode);
112ea8: a90a add r1, sp, #40 ; 0x28
112eaa: 4628 mov r0, r5
112eac: f7fe fe34 bl 111b18 <rtems_rfs_dir_empty>
if (rc > 0)
112eb0: 1e04 subs r4, r0, #0
112eb2: dd9a ble.n 112dea <rtems_rfs_unlink+0x4a>
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
112eb4: f04f 7000 mov.w r0, #33554432 ; 0x2000000
112eb8: 2100 movs r1, #0
112eba: f7f7 fd5f bl 10a97c <rtems_rfs_trace>
112ebe: 2800 cmp r0, #0
112ec0: d0ea beq.n 112e98 <rtems_rfs_unlink+0xf8> <== NEVER TAKEN
printf ("rtems-rfs: dir-empty: %d: %s\n", rc, strerror (rc));
112ec2: 4620 mov r0, r4 <== NOT EXECUTED
112ec4: f004 fc54 bl 117770 <strerror> <== NOT EXECUTED
112ec8: 4602 mov r2, r0 <== NOT EXECUTED
112eca: f64b 30a8 movw r0, #48040 ; 0xbba8 <== NOT EXECUTED
112ece: 4621 mov r1, r4 <== NOT EXECUTED
112ed0: f2c0 0011 movt r0, #17 <== NOT EXECUTED
112ed4: f7f2 fe20 bl 105b18 <__wrap_printf> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
112ed8: e7de b.n 112e98 <rtems_rfs_unlink+0xf8> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
112eda: f7f7 fd4f bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
112ede: 2800 cmp r0, #0 <== NOT EXECUTED
112ee0: f040 80bd bne.w 11305e <rtems_rfs_unlink+0x2be> <== NOT EXECUTED
rc = rtems_rfs_inode_delete (fs, &target_inode);
112ee4: a90a add r1, sp, #40 ; 0x28
112ee6: 4628 mov r0, r5
112ee8: f7f6 fde8 bl 109abc <rtems_rfs_inode_delete>
if (rc > 0)
112eec: 1e04 subs r4, r0, #0
112eee: f300 8090 bgt.w 113012 <rtems_rfs_unlink+0x272> <== ALWAYS TAKEN
if (dir)
112ef2: f5b7 4f80 cmp.w r7, #16384 ; 0x4000
112ef6: d1a6 bne.n 112e46 <rtems_rfs_unlink+0xa6>
links = rtems_rfs_read_u16 (&handle->node->links);
112ef8: 9a03 ldr r2, [sp, #12]
if (links == 0xffff)
112efa: f64f 71ff movw r1, #65535 ; 0xffff
112efe: 8813 ldrh r3, [r2, #0]
112f00: ba5b rev16 r3, r3
112f02: b29b uxth r3, r3
112f04: 428b cmp r3, r1
112f06: f000 80b3 beq.w 113070 <rtems_rfs_unlink+0x2d0> <== ALWAYS TAKEN
if (links > 1)
112f0a: 2b01 cmp r3, #1
links--;
112f0c: bf8b itete hi
112f0e: f103 33ff addhi.w r3, r3, #4294967295 ; 0xffffffff
rtems_rfs_write_u16 (&handle->node->links, links);
112f12: b2db uxtbls r3, r3
112f14: b29b uxthhi r3, r3
112f16: 2100 movls r1, #0
112f18: bf84 itt hi
112f1a: 0a19 lsrhi r1, r3, #8
112f1c: b2db uxtbhi r3, r3
112f1e: 7011 strb r1, [r2, #0]
112f20: 9a03 ldr r2, [sp, #12]
112f22: 7053 strb r3, [r2, #1]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
112f24: 2301 movs r3, #1
112f26: f88d 3010 strb.w r3, [sp, #16]
}
112f2a: e78c b.n 112e46 <rtems_rfs_unlink+0xa6>
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
112f2c: f04f 7000 mov.w r0, #33554432 ; 0x2000000 <== NOT EXECUTED
112f30: 2100 movs r1, #0 <== NOT EXECUTED
112f32: f7f7 fd23 bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
112f36: 2800 cmp r0, #0 <== NOT EXECUTED
112f38: d17e bne.n 113038 <rtems_rfs_unlink+0x298> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
112f3a: a90a add r1, sp, #40 ; 0x28 <== NOT EXECUTED
112f3c: 4628 mov r0, r5 <== NOT EXECUTED
return EISDIR;
112f3e: 2415 movs r4, #21 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
112f40: f7f6 fd8c bl 109a5c <rtems_rfs_inode_close> <== NOT EXECUTED
}
112f44: 4620 mov r0, r4 <== NOT EXECUTED
112f46: b015 add sp, #84 ; 0x54 <== NOT EXECUTED
112f48: e8bd 83f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, pc} <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
112f4c: f04f 7000 mov.w r0, #33554432 ; 0x2000000 <== NOT EXECUTED
112f50: 2100 movs r1, #0 <== NOT EXECUTED
112f52: f7f7 fd13 bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
112f56: 2800 cmp r0, #0 <== NOT EXECUTED
112f58: d175 bne.n 113046 <rtems_rfs_unlink+0x2a6> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
112f5a: 4669 mov r1, sp <== NOT EXECUTED
112f5c: 4628 mov r0, r5 <== NOT EXECUTED
112f5e: f7f6 fd7d bl 109a5c <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
112f62: a90a add r1, sp, #40 ; 0x28 <== NOT EXECUTED
112f64: 4628 mov r0, r5 <== NOT EXECUTED
112f66: f7f6 fd79 bl 109a5c <rtems_rfs_inode_close> <== NOT EXECUTED
}
112f6a: 4620 mov r0, r4 <== NOT EXECUTED
112f6c: b015 add sp, #84 ; 0x54 <== NOT EXECUTED
112f6e: e8bd 83f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, pc} <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
112f72: f04f 7000 mov.w r0, #33554432 ; 0x2000000 <== NOT EXECUTED
112f76: 2100 movs r1, #0 <== NOT EXECUTED
112f78: f7f7 fd00 bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
112f7c: 2800 cmp r0, #0 <== NOT EXECUTED
112f7e: d0ec beq.n 112f5a <rtems_rfs_unlink+0x1ba> <== NOT EXECUTED
printf ("rtems-rfs: unlink: dir-del failed: %d: %s\n",
112f80: 4620 mov r0, r4 <== NOT EXECUTED
112f82: f004 fbf5 bl 117770 <strerror> <== NOT EXECUTED
112f86: 4602 mov r2, r0 <== NOT EXECUTED
112f88: f64b 30f4 movw r0, #48116 ; 0xbbf4 <== NOT EXECUTED
112f8c: 4621 mov r1, r4 <== NOT EXECUTED
112f8e: f2c0 0011 movt r0, #17 <== NOT EXECUTED
112f92: f7f2 fdc1 bl 105b18 <__wrap_printf> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
112f96: e7e0 b.n 112f5a <rtems_rfs_unlink+0x1ba> <== NOT EXECUTED
printf ("rtems-rfs: link: inode-open failed: %d: %s\n",
112f98: 4620 mov r0, r4 <== NOT EXECUTED
112f9a: f004 fbe9 bl 117770 <strerror> <== NOT EXECUTED
112f9e: 4602 mov r2, r0 <== NOT EXECUTED
112fa0: f64b 30c8 movw r0, #48072 ; 0xbbc8 <== NOT EXECUTED
112fa4: 4621 mov r1, r4 <== NOT EXECUTED
112fa6: f2c0 0011 movt r0, #17 <== NOT EXECUTED
112faa: f7f2 fdb5 bl 105b18 <__wrap_printf> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
112fae: e773 b.n 112e98 <rtems_rfs_unlink+0xf8> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
112fb0: f04f 7000 mov.w r0, #33554432 ; 0x2000000 <== NOT EXECUTED
112fb4: 2100 movs r1, #0 <== NOT EXECUTED
112fb6: f7f7 fce1 bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
112fba: 2800 cmp r0, #0 <== NOT EXECUTED
112fbc: f43f af6c beq.w 112e98 <rtems_rfs_unlink+0xf8> <== NOT EXECUTED
printf ("rtems-rfs: link: parent inode-close failed: %d: %s\n",
112fc0: 4620 mov r0, r4 <== NOT EXECUTED
112fc2: f004 fbd5 bl 117770 <strerror> <== NOT EXECUTED
112fc6: 4602 mov r2, r0 <== NOT EXECUTED
112fc8: f64b 40ac movw r0, #48300 ; 0xbcac <== NOT EXECUTED
112fcc: 4621 mov r1, r4 <== NOT EXECUTED
112fce: f2c0 0011 movt r0, #17 <== NOT EXECUTED
112fd2: f7f2 fda1 bl 105b18 <__wrap_printf> <== NOT EXECUTED
112fd6: e75f b.n 112e98 <rtems_rfs_unlink+0xf8> <== NOT EXECUTED
printf ("rtems-rfs: unlink: target:%" PRIu32 " links:%u\n", target, links);
112fd8: f64b 4020 movw r0, #48160 ; 0xbc20 <== NOT EXECUTED
112fdc: 4631 mov r1, r6 <== NOT EXECUTED
112fde: 4622 mov r2, r4 <== NOT EXECUTED
112fe0: f2c0 0011 movt r0, #17 <== NOT EXECUTED
112fe4: f7f2 fd98 bl 105b18 <__wrap_printf> <== NOT EXECUTED
112fe8: e721 b.n 112e2e <rtems_rfs_unlink+0x8e> <== NOT EXECUTED
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
112fea: f04f 7000 mov.w r0, #33554432 ; 0x2000000 <== NOT EXECUTED
112fee: 2100 movs r1, #0 <== NOT EXECUTED
112ff0: f7f7 fcc4 bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
112ff4: 2800 cmp r0, #0 <== NOT EXECUTED
112ff6: f43f af3b beq.w 112e70 <rtems_rfs_unlink+0xd0> <== NOT EXECUTED
printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",
112ffa: 4620 mov r0, r4 <== NOT EXECUTED
112ffc: f004 fbb8 bl 117770 <strerror> <== NOT EXECUTED
113000: 4602 mov r2, r0 <== NOT EXECUTED
113002: f64b 40e0 movw r0, #48352 ; 0xbce0 <== NOT EXECUTED
113006: 4621 mov r1, r4 <== NOT EXECUTED
113008: f2c0 0011 movt r0, #17 <== NOT EXECUTED
11300c: f7f2 fd84 bl 105b18 <__wrap_printf> <== NOT EXECUTED
113010: e72e b.n 112e70 <rtems_rfs_unlink+0xd0> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
113012: f04f 7000 mov.w r0, #33554432 ; 0x2000000 <== NOT EXECUTED
113016: 2100 movs r1, #0 <== NOT EXECUTED
113018: f7f7 fcb0 bl 10a97c <rtems_rfs_trace> <== NOT EXECUTED
11301c: 2800 cmp r0, #0 <== NOT EXECUTED
11301e: d09c beq.n 112f5a <rtems_rfs_unlink+0x1ba> <== NOT EXECUTED
printf ("rtems-rfs: unlink: inode-del failed: %d: %s\n",
113020: 4620 mov r0, r4 <== NOT EXECUTED
113022: f004 fba5 bl 117770 <strerror> <== NOT EXECUTED
113026: 4602 mov r2, r0 <== NOT EXECUTED
113028: f64b 4048 movw r0, #48200 ; 0xbc48 <== NOT EXECUTED
11302c: 4621 mov r1, r4 <== NOT EXECUTED
11302e: f2c0 0011 movt r0, #17 <== NOT EXECUTED
113032: f7f2 fd71 bl 105b18 <__wrap_printf> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
113036: e790 b.n 112f5a <rtems_rfs_unlink+0x1ba> <== NOT EXECUTED
printf ("rtems-rfs: link is a directory\n");
113038: f64b 3088 movw r0, #48008 ; 0xbb88 <== NOT EXECUTED
11303c: f2c0 0011 movt r0, #17 <== NOT EXECUTED
113040: f7f2 fd7c bl 105b3c <__wrap_puts> <== NOT EXECUTED
113044: e779 b.n 112f3a <rtems_rfs_unlink+0x19a> <== NOT EXECUTED
printf ("rtems-rfs: link: inode-time-stamp failed: %d: %s\n",
113046: 4620 mov r0, r4 <== NOT EXECUTED
113048: f004 fb92 bl 117770 <strerror> <== NOT EXECUTED
11304c: 4602 mov r2, r0 <== NOT EXECUTED
11304e: f64b 4078 movw r0, #48248 ; 0xbc78 <== NOT EXECUTED
113052: 4621 mov r1, r4 <== NOT EXECUTED
113054: f2c0 0011 movt r0, #17 <== NOT EXECUTED
113058: f7f2 fd5e bl 105b18 <__wrap_printf> <== NOT EXECUTED
11305c: e77d b.n 112f5a <rtems_rfs_unlink+0x1ba> <== NOT EXECUTED
printf ("rtems-rfs: unlink: target:%" PRIu32 " links:%u\n", target, links);
11305e: f64b 4020 movw r0, #48160 ; 0xbc20 <== NOT EXECUTED
113062: 4631 mov r1, r6 <== NOT EXECUTED
113064: 2200 movs r2, #0 <== NOT EXECUTED
113066: f2c0 0011 movt r0, #17 <== NOT EXECUTED
11306a: f7f2 fd55 bl 105b18 <__wrap_printf> <== NOT EXECUTED
if (links > 1)
11306e: e739 b.n 112ee4 <rtems_rfs_unlink+0x144> <== NOT EXECUTED
113070: 2300 movs r3, #0 <== NOT EXECUTED
113072: 4619 mov r1, r3 <== NOT EXECUTED
113074: e753 b.n 112f1e <rtems_rfs_unlink+0x17e> <== NOT EXECUTED
113076: bf00 nop
0012e974 <rtems_shell_debugrfs>:
}
int
rtems_shell_debugrfs (int argc, char *argv[])
{
const rtems_rfs_shell_cmd table[] =
12e974: f249 5cf8 movw ip, #38392 ; 0x95f8 <== NOT EXECUTED
{
12e978: e92d 43f0 stmdb sp!, {r4, r5, r6, r7, r8, r9, lr} <== NOT EXECUTED
const rtems_rfs_shell_cmd table[] =
12e97c: f2c0 0c15 movt ip, #21 <== NOT EXECUTED
{
12e980: 4606 mov r6, r0 <== NOT EXECUTED
12e982: 460f mov r7, r1 <== NOT EXECUTED
12e984: b0ad sub sp, #180 ; 0xb4 <== NOT EXECUTED
const rtems_rfs_shell_cmd table[] =
12e986: e8bc 000f ldmia.w ip!, {r0, r1, r2, r3} <== NOT EXECUTED
12e98a: f10d 0e74 add.w lr, sp, #116 ; 0x74 <== NOT EXECUTED
};
int arg;
int t;
for (arg = 1; arg < argc; arg++)
12e98e: 2e01 cmp r6, #1 <== NOT EXECUTED
const rtems_rfs_shell_cmd table[] =
12e990: e8ae 000f stmia.w lr!, {r0, r1, r2, r3} <== NOT EXECUTED
12e994: e8bc 000f ldmia.w ip!, {r0, r1, r2, r3} <== NOT EXECUTED
12e998: e8ae 000f stmia.w lr!, {r0, r1, r2, r3} <== NOT EXECUTED
12e99c: e8bc 000f ldmia.w ip!, {r0, r1, r2, r3} <== NOT EXECUTED
12e9a0: e8ae 000f stmia.w lr!, {r0, r1, r2, r3} <== NOT EXECUTED
12e9a4: e89c 0007 ldmia.w ip, {r0, r1, r2} <== NOT EXECUTED
12e9a8: e88e 0007 stmia.w lr, {r0, r1, r2} <== NOT EXECUTED
for (arg = 1; arg < argc; arg++)
12e9ac: dd55 ble.n 12ea5a <rtems_shell_debugrfs+0xe6> <== NOT EXECUTED
{
if (argv[arg][0] != '-')
12e9ae: 687c ldr r4, [r7, #4] <== NOT EXECUTED
12e9b0: 7823 ldrb r3, [r4, #0] <== NOT EXECUTED
12e9b2: 2b2d cmp r3, #45 ; 0x2d <== NOT EXECUTED
12e9b4: d035 beq.n 12ea22 <rtems_shell_debugrfs+0xae> <== NOT EXECUTED
printf ("error: unknown option: %s\n", argv[arg]);
return 1;
}
}
if ((argc - arg) < 2)
12e9b6: 2e02 cmp r6, #2 <== NOT EXECUTED
12e9b8: d04f beq.n 12ea5a <rtems_shell_debugrfs+0xe6> <== NOT EXECUTED
rc = statvfs (path, &sb);
12e9ba: 4669 mov r1, sp <== NOT EXECUTED
12e9bc: 4620 mov r0, r4 <== NOT EXECUTED
12e9be: f7f6 ffe1 bl 125984 <statvfs> <== NOT EXECUTED
if (rc < 0)
12e9c2: 1e05 subs r5, r0, #0 <== NOT EXECUTED
12e9c4: f2c0 80a8 blt.w 12eb18 <rtems_shell_debugrfs+0x1a4> <== NOT EXECUTED
if (sb.f_fsid != RTEMS_RFS_SB_MAGIC)
12e9c8: 9a0b ldr r2, [sp, #44] ; 0x2c <== NOT EXECUTED
12e9ca: f242 0301 movw r3, #8193 ; 0x2001 <== NOT EXECUTED
12e9ce: f6c2 0309 movt r3, #10249 ; 0x2809 <== NOT EXECUTED
12e9d2: 429a cmp r2, r3 <== NOT EXECUTED
12e9d4: f040 8097 bne.w 12eb06 <rtems_shell_debugrfs+0x192> <== NOT EXECUTED
rtems_filesystem_eval_path_start (&ctx, path, eval_flags);
12e9d8: 4621 mov r1, r4 <== NOT EXECUTED
12e9da: 2218 movs r2, #24 <== NOT EXECUTED
12e9dc: a80f add r0, sp, #60 ; 0x3c <== NOT EXECUTED
12e9de: f7da ff9f bl 109920 <rtems_filesystem_eval_path_start> <== NOT EXECUTED
*fs = rtems_rfs_rtems_pathloc_dev (currentloc);
12e9e2: 6943 ldr r3, [r0, #20] <== NOT EXECUTED
rtems_filesystem_eval_path_cleanup (&ctx);
12e9e4: a80f add r0, sp, #60 ; 0x3c <== NOT EXECUTED
*fs = rtems_rfs_rtems_pathloc_dev (currentloc);
12e9e6: f8d3 9008 ldr.w r9, [r3, #8] <== NOT EXECUTED
rtems_filesystem_eval_path_cleanup (&ctx);
12e9ea: f7db f81d bl 109a28 <rtems_filesystem_eval_path_cleanup> <== NOT EXECUTED
printf ("error: you need at least a path and command, try %s -h\n", argv[0]);
else
{
rtems_rfs_file_system* fs;
if (rtems_rfs_get_fs (argv[arg], &fs) == 0)
12e9ee: 2d00 cmp r5, #0 <== NOT EXECUTED
12e9f0: d13e bne.n 12ea70 <rtems_shell_debugrfs+0xfc> <== NOT EXECUTED
{
for (t = 0; t < (sizeof (table) / sizeof (const rtems_rfs_shell_cmd)); t++)
if (strcmp (argv[arg + 1], table[t].name) == 0)
12e9f2: f8d7 8008 ldr.w r8, [r7, #8] <== NOT EXECUTED
12e9f6: ac1d add r4, sp, #116 ; 0x74 <== NOT EXECUTED
12e9f8: 6821 ldr r1, [r4, #0] <== NOT EXECUTED
12e9fa: 4640 mov r0, r8 <== NOT EXECUTED
for (t = 0; t < (sizeof (table) / sizeof (const rtems_rfs_shell_cmd)); t++)
12e9fc: 340c adds r4, #12 <== NOT EXECUTED
if (strcmp (argv[arg + 1], table[t].name) == 0)
12e9fe: f014 f8a3 bl 142b48 <strcmp> <== NOT EXECUTED
12ea02: 2800 cmp r0, #0 <== NOT EXECUTED
12ea04: d070 beq.n 12eae8 <rtems_shell_debugrfs+0x174> <== NOT EXECUTED
for (t = 0; t < (sizeof (table) / sizeof (const rtems_rfs_shell_cmd)); t++)
12ea06: 3501 adds r5, #1 <== NOT EXECUTED
12ea08: 2d05 cmp r5, #5 <== NOT EXECUTED
12ea0a: d1f5 bne.n 12e9f8 <rtems_shell_debugrfs+0x84> <== NOT EXECUTED
return table[t].handler (fs, argc - 2, argv + 2);
printf ("error: command not found: %s\n", argv[arg + 1]);
12ea0c: f249 40e8 movw r0, #38120 ; 0x94e8 <== NOT EXECUTED
12ea10: 4641 mov r1, r8 <== NOT EXECUTED
12ea12: f2c0 0015 movt r0, #21 <== NOT EXECUTED
12ea16: f00c ffdb bl 13b9d0 <__wrap_printf> <== NOT EXECUTED
}
}
return 1;
12ea1a: 2001 movs r0, #1 <== NOT EXECUTED
}
12ea1c: b02d add sp, #180 ; 0xb4 <== NOT EXECUTED
12ea1e: e8bd 83f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, pc} <== NOT EXECUTED
switch (argv[arg][1])
12ea22: 7863 ldrb r3, [r4, #1] <== NOT EXECUTED
12ea24: 2b68 cmp r3, #104 ; 0x68 <== NOT EXECUTED
12ea26: d030 beq.n 12ea8a <rtems_shell_debugrfs+0x116> <== NOT EXECUTED
12ea28: 2b6c cmp r3, #108 ; 0x6c <== NOT EXECUTED
12ea2a: d125 bne.n 12ea78 <rtems_shell_debugrfs+0x104> <== NOT EXECUTED
printf ("%s: commands are:\n", argv[0]);
12ea2c: f245 404c movw r0, #21580 ; 0x544c <== NOT EXECUTED
printf (" %s\t\t%s\n", table[t].name, table[t].help);
12ea30: f249 4548 movw r5, #37960 ; 0x9448 <== NOT EXECUTED
printf ("%s: commands are:\n", argv[0]);
12ea34: 6839 ldr r1, [r7, #0] <== NOT EXECUTED
12ea36: f2c0 0015 movt r0, #21 <== NOT EXECUTED
12ea3a: ac1d add r4, sp, #116 ; 0x74 <== NOT EXECUTED
12ea3c: ae2c add r6, sp, #176 ; 0xb0 <== NOT EXECUTED
printf (" %s\t\t%s\n", table[t].name, table[t].help);
12ea3e: f2c0 0515 movt r5, #21 <== NOT EXECUTED
printf ("%s: commands are:\n", argv[0]);
12ea42: f00c ffc5 bl 13b9d0 <__wrap_printf> <== NOT EXECUTED
printf (" %s\t\t%s\n", table[t].name, table[t].help);
12ea46: 68a2 ldr r2, [r4, #8] <== NOT EXECUTED
12ea48: 4628 mov r0, r5 <== NOT EXECUTED
12ea4a: f854 1b0c ldr.w r1, [r4], #12 <== NOT EXECUTED
12ea4e: f00c ffbf bl 13b9d0 <__wrap_printf> <== NOT EXECUTED
for (t = 0; t < (sizeof (table) / sizeof (const rtems_rfs_shell_cmd)); t++)
12ea52: 42a6 cmp r6, r4 <== NOT EXECUTED
12ea54: d1f7 bne.n 12ea46 <rtems_shell_debugrfs+0xd2> <== NOT EXECUTED
return 0;
12ea56: 2000 movs r0, #0 <== NOT EXECUTED
12ea58: e007 b.n 12ea6a <rtems_shell_debugrfs+0xf6> <== NOT EXECUTED
printf ("error: you need at least a path and command, try %s -h\n", argv[0]);
12ea5a: f249 4054 movw r0, #37972 ; 0x9454 <== NOT EXECUTED
12ea5e: 6839 ldr r1, [r7, #0] <== NOT EXECUTED
12ea60: f2c0 0015 movt r0, #21 <== NOT EXECUTED
12ea64: f00c ffb4 bl 13b9d0 <__wrap_printf> <== NOT EXECUTED
return 1;
12ea68: 2001 movs r0, #1 <== NOT EXECUTED
}
12ea6a: b02d add sp, #180 ; 0xb4 <== NOT EXECUTED
12ea6c: e8bd 83f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, pc} <== NOT EXECUTED
return 1;
12ea70: 2001 movs r0, #1 <== NOT EXECUTED
}
12ea72: b02d add sp, #180 ; 0xb4 <== NOT EXECUTED
12ea74: e8bd 83f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, pc} <== NOT EXECUTED
printf ("error: unknown option: %s\n", argv[arg]);
12ea78: f245 406c movw r0, #21612 ; 0x546c <== NOT EXECUTED
12ea7c: 4621 mov r1, r4 <== NOT EXECUTED
12ea7e: f2c0 0015 movt r0, #21 <== NOT EXECUTED
12ea82: f00c ffa5 bl 13b9d0 <__wrap_printf> <== NOT EXECUTED
return 1;
12ea86: 2001 movs r0, #1 <== NOT EXECUTED
12ea88: e7ef b.n 12ea6a <rtems_shell_debugrfs+0xf6> <== NOT EXECUTED
rtems_rfs_shell_usage (argv[0]);
12ea8a: 683c ldr r4, [r7, #0] <== NOT EXECUTED
printf ("%s: RFS debugger\n", arg);
12ea8c: f249 3074 movw r0, #37748 ; 0x9374 <== NOT EXECUTED
12ea90: f2c0 0015 movt r0, #21 <== NOT EXECUTED
12ea94: 4621 mov r1, r4 <== NOT EXECUTED
12ea96: f00c ff9b bl 13b9d0 <__wrap_printf> <== NOT EXECUTED
printf (" %s [-hl] <path> <command>\n", arg);
12ea9a: f249 3088 movw r0, #37768 ; 0x9388 <== NOT EXECUTED
12ea9e: 4621 mov r1, r4 <== NOT EXECUTED
12eaa0: f2c0 0015 movt r0, #21 <== NOT EXECUTED
12eaa4: f00c ff94 bl 13b9d0 <__wrap_printf> <== NOT EXECUTED
printf (" where:\n");
12eaa8: f245 30c8 movw r0, #21448 ; 0x53c8 <== NOT EXECUTED
12eaac: f2c0 0015 movt r0, #21 <== NOT EXECUTED
12eab0: f00c ffa0 bl 13b9f4 <__wrap_puts> <== NOT EXECUTED
printf (" path: Path to the mounted RFS file system\n");
12eab4: f249 30a8 movw r0, #37800 ; 0x93a8 <== NOT EXECUTED
12eab8: f2c0 0015 movt r0, #21 <== NOT EXECUTED
12eabc: f00c ff9a bl 13b9f4 <__wrap_puts> <== NOT EXECUTED
printf (" command: A debugger command. See -l for a list plus help.\n");
12eac0: f249 30dc movw r0, #37852 ; 0x93dc <== NOT EXECUTED
12eac4: f2c0 0015 movt r0, #21 <== NOT EXECUTED
12eac8: f00c ff94 bl 13b9f4 <__wrap_puts> <== NOT EXECUTED
printf (" -h: This help\n");
12eacc: f245 4014 movw r0, #21524 ; 0x5414 <== NOT EXECUTED
12ead0: f2c0 0015 movt r0, #21 <== NOT EXECUTED
12ead4: f00c ff8e bl 13b9f4 <__wrap_puts> <== NOT EXECUTED
printf (" -l: The debugger command list.\n");
12ead8: f249 401c movw r0, #37916 ; 0x941c <== NOT EXECUTED
12eadc: f2c0 0015 movt r0, #21 <== NOT EXECUTED
12eae0: f00c ff88 bl 13b9f4 <__wrap_puts> <== NOT EXECUTED
return 0;
12eae4: 2000 movs r0, #0 <== NOT EXECUTED
}
12eae6: e7c0 b.n 12ea6a <rtems_shell_debugrfs+0xf6> <== NOT EXECUTED
return table[t].handler (fs, argc - 2, argv + 2);
12eae8: eb05 0545 add.w r5, r5, r5, lsl #1 <== NOT EXECUTED
12eaec: ab2c add r3, sp, #176 ; 0xb0 <== NOT EXECUTED
12eaee: f107 0208 add.w r2, r7, #8 <== NOT EXECUTED
12eaf2: eb03 0585 add.w r5, r3, r5, lsl #2 <== NOT EXECUTED
12eaf6: 1eb1 subs r1, r6, #2 <== NOT EXECUTED
12eaf8: 4648 mov r0, r9 <== NOT EXECUTED
12eafa: f855 3c38 ldr.w r3, [r5, #-56] <== NOT EXECUTED
}
12eafe: b02d add sp, #180 ; 0xb4 <== NOT EXECUTED
12eb00: e8bd 43f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, lr} <== NOT EXECUTED
return table[t].handler (fs, argc - 2, argv + 2);
12eb04: 4718 bx r3 <== NOT EXECUTED
printf ("error: path '%s' is not on an RFS file system\n", path);
12eb06: f249 40b8 movw r0, #38072 ; 0x94b8 <== NOT EXECUTED
12eb0a: 4621 mov r1, r4 <== NOT EXECUTED
12eb0c: f2c0 0015 movt r0, #21 <== NOT EXECUTED
12eb10: f00c ff5e bl 13b9d0 <__wrap_printf> <== NOT EXECUTED
return 1;
12eb14: 2001 movs r0, #1 <== NOT EXECUTED
12eb16: e7a8 b.n 12ea6a <rtems_shell_debugrfs+0xf6> <== NOT EXECUTED
path, errno, strerror (errno));
12eb18: f00f fc1c bl 13e354 <__errno> <== NOT EXECUTED
printf ("error: cannot statvfs path: %s: (%d) %s\n",
12eb1c: 6805 ldr r5, [r0, #0] <== NOT EXECUTED
path, errno, strerror (errno));
12eb1e: f00f fc19 bl 13e354 <__errno> <== NOT EXECUTED
printf ("error: cannot statvfs path: %s: (%d) %s\n",
12eb22: 6800 ldr r0, [r0, #0] <== NOT EXECUTED
12eb24: f014 fc50 bl 1433c8 <strerror> <== NOT EXECUTED
12eb28: 4603 mov r3, r0 <== NOT EXECUTED
12eb2a: f249 408c movw r0, #38028 ; 0x948c <== NOT EXECUTED
12eb2e: 462a mov r2, r5 <== NOT EXECUTED
12eb30: 4621 mov r1, r4 <== NOT EXECUTED
12eb32: f2c0 0015 movt r0, #21 <== NOT EXECUTED
12eb36: f00c ff4b bl 13b9d0 <__wrap_printf> <== NOT EXECUTED
return 1;
12eb3a: 2001 movs r0, #1 <== NOT EXECUTED
12eb3c: e795 b.n 12ea6a <rtems_shell_debugrfs+0xf6> <== NOT EXECUTED
12eb3e: bf00 nop
0012eb40 <rtems_shell_rfs_format>:
const char* driver = NULL;
int arg;
memset (&config, 0, sizeof (rtems_rfs_format_config));
for (arg = 1; arg < argc; arg++)
12eb40: 2801 cmp r0, #1 <== NOT EXECUTED
{
12eb42: e92d 41f0 stmdb sp!, {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
memset (&config, 0, sizeof (rtems_rfs_format_config));
12eb46: f04f 0500 mov.w r5, #0 <== NOT EXECUTED
{
12eb4a: b086 sub sp, #24 <== NOT EXECUTED
memset (&config, 0, sizeof (rtems_rfs_format_config));
12eb4c: e9cd 5500 strd r5, r5, [sp] <== NOT EXECUTED
12eb50: e9cd 5502 strd r5, r5, [sp, #8] <== NOT EXECUTED
12eb54: e9cd 5504 strd r5, r5, [sp, #16] <== NOT EXECUTED
for (arg = 1; arg < argc; arg++)
12eb58: f340 808f ble.w 12ec7a <rtems_shell_rfs_format+0x13a> <== NOT EXECUTED
12eb5c: 2401 movs r4, #1 <== NOT EXECUTED
12eb5e: 4606 mov r6, r0 <== NOT EXECUTED
12eb60: 4688 mov r8, r1 <== NOT EXECUTED
}
config.group_inodes = strtoul (argv[arg], 0, 0);
break;
case 'I':
config.initialise_inodes = true;
12eb62: 4627 mov r7, r4 <== NOT EXECUTED
12eb64: e005 b.n 12eb72 <rtems_shell_rfs_format+0x32> <== NOT EXECUTED
return 1;
}
}
else
{
if (!driver)
12eb66: 2d00 cmp r5, #0 <== NOT EXECUTED
12eb68: d17d bne.n 12ec66 <rtems_shell_rfs_format+0x126> <== NOT EXECUTED
12eb6a: 460d mov r5, r1 <== NOT EXECUTED
for (arg = 1; arg < argc; arg++)
12eb6c: 3401 adds r4, #1 <== NOT EXECUTED
12eb6e: 42a6 cmp r6, r4 <== NOT EXECUTED
12eb70: dd31 ble.n 12ebd6 <rtems_shell_rfs_format+0x96> <== NOT EXECUTED
if (argv[arg][0] == '-')
12eb72: f858 1024 ldr.w r1, [r8, r4, lsl #2] <== NOT EXECUTED
12eb76: 00a2 lsls r2, r4, #2 <== NOT EXECUTED
12eb78: 780b ldrb r3, [r1, #0] <== NOT EXECUTED
12eb7a: 2b2d cmp r3, #45 ; 0x2d <== NOT EXECUTED
12eb7c: d1f3 bne.n 12eb66 <rtems_shell_rfs_format+0x26> <== NOT EXECUTED
switch (argv[arg][1])
12eb7e: 784b ldrb r3, [r1, #1] <== NOT EXECUTED
12eb80: 3b49 subs r3, #73 ; 0x49 <== NOT EXECUTED
12eb82: 2b2d cmp r3, #45 ; 0x2d <== NOT EXECUTED
12eb84: d818 bhi.n 12ebb8 <rtems_shell_rfs_format+0x78> <== NOT EXECUTED
12eb86: e8df f003 tbb [pc, r3] <== NOT EXECUTED
12eb8a: 176b .short 0x176b <== NOT EXECUTED
12eb8c: 17171717 .word 0x17171717 <== NOT EXECUTED
12eb90: 17171717 .word 0x17171717 <== NOT EXECUTED
12eb94: 17171717 .word 0x17171717 <== NOT EXECUTED
12eb98: 17171717 .word 0x17171717 <== NOT EXECUTED
12eb9c: 17171717 .word 0x17171717 <== NOT EXECUTED
12eba0: 60171717 .word 0x60171717 <== NOT EXECUTED
12eba4: 17171717 .word 0x17171717 <== NOT EXECUTED
12eba8: 17551717 .word 0x17551717 <== NOT EXECUTED
12ebac: 17171717 .word 0x17171717 <== NOT EXECUTED
12ebb0: 1717174a .word 0x1717174a <== NOT EXECUTED
12ebb4: 2117173f .word 0x2117173f <== NOT EXECUTED
printf ("error: invalid option: %s\n", argv[arg]);
12ebb8: f640 0048 movw r0, #2120 ; 0x848 <== NOT EXECUTED
12ebbc: f2c0 0015 movt r0, #21 <== NOT EXECUTED
12ebc0: f00c ff06 bl 13b9d0 <__wrap_printf> <== NOT EXECUTED
return 1;
12ebc4: 2001 movs r0, #1 <== NOT EXECUTED
driver, strerror (errno));
return 1;
}
return 0;
}
12ebc6: b006 add sp, #24 <== NOT EXECUTED
12ebc8: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
for (arg = 1; arg < argc; arg++)
12ebcc: 3401 adds r4, #1 <== NOT EXECUTED
config.verbose = true;
12ebce: f88d 7015 strb.w r7, [sp, #21] <== NOT EXECUTED
for (arg = 1; arg < argc; arg++)
12ebd2: 42a6 cmp r6, r4 <== NOT EXECUTED
12ebd4: dccd bgt.n 12eb72 <rtems_shell_rfs_format+0x32> <== NOT EXECUTED
if (!driver) {
12ebd6: 2d00 cmp r5, #0 <== NOT EXECUTED
12ebd8: d04f beq.n 12ec7a <rtems_shell_rfs_format+0x13a> <== NOT EXECUTED
if (rtems_rfs_format (driver, &config) < 0)
12ebda: 4669 mov r1, sp <== NOT EXECUTED
12ebdc: 4628 mov r0, r5 <== NOT EXECUTED
12ebde: f009 f905 bl 137dec <rtems_rfs_format> <== NOT EXECUTED
12ebe2: 2800 cmp r0, #0 <== NOT EXECUTED
return 0;
12ebe4: bfa8 it ge <== NOT EXECUTED
12ebe6: 2000 movge r0, #0 <== NOT EXECUTED
if (rtems_rfs_format (driver, &config) < 0)
12ebe8: daed bge.n 12ebc6 <rtems_shell_rfs_format+0x86> <== NOT EXECUTED
driver, strerror (errno));
12ebea: f00f fbb3 bl 13e354 <__errno> <== NOT EXECUTED
printf ("error: format of %s failed: %s\n",
12ebee: 6800 ldr r0, [r0, #0] <== NOT EXECUTED
12ebf0: f014 fbea bl 1433c8 <strerror> <== NOT EXECUTED
12ebf4: 4602 mov r2, r0 <== NOT EXECUTED
12ebf6: f249 50d8 movw r0, #38360 ; 0x95d8 <== NOT EXECUTED
12ebfa: 4629 mov r1, r5 <== NOT EXECUTED
12ebfc: f2c0 0015 movt r0, #21 <== NOT EXECUTED
12ec00: f00c fee6 bl 13b9d0 <__wrap_printf> <== NOT EXECUTED
return 1;
12ec04: 2001 movs r0, #1 <== NOT EXECUTED
12ec06: e7de b.n 12ebc6 <rtems_shell_rfs_format+0x86> <== NOT EXECUTED
arg++;
12ec08: 3401 adds r4, #1 <== NOT EXECUTED
if (arg >= argc)
12ec0a: 42a6 cmp r6, r4 <== NOT EXECUTED
12ec0c: dd45 ble.n 12ec9a <rtems_shell_rfs_format+0x15a> <== NOT EXECUTED
config.block_size = strtoul (argv[arg], 0, 0);
12ec0e: 4442 add r2, r8 <== NOT EXECUTED
12ec10: 6850 ldr r0, [r2, #4] <== NOT EXECUTED
12ec12: 2200 movs r2, #0 <== NOT EXECUTED
12ec14: 4611 mov r1, r2 <== NOT EXECUTED
12ec16: f015 ff89 bl 144b2c <strtoul> <== NOT EXECUTED
12ec1a: 9000 str r0, [sp, #0] <== NOT EXECUTED
break;
12ec1c: e7a6 b.n 12eb6c <rtems_shell_rfs_format+0x2c> <== NOT EXECUTED
arg++;
12ec1e: 3401 adds r4, #1 <== NOT EXECUTED
if (arg >= argc)
12ec20: 42a6 cmp r6, r4 <== NOT EXECUTED
12ec22: dd4a ble.n 12ecba <rtems_shell_rfs_format+0x17a> <== NOT EXECUTED
config.inode_overhead = strtoul (argv[arg], 0, 0);
12ec24: 4442 add r2, r8 <== NOT EXECUTED
12ec26: 6850 ldr r0, [r2, #4] <== NOT EXECUTED
12ec28: 2200 movs r2, #0 <== NOT EXECUTED
12ec2a: 4611 mov r1, r2 <== NOT EXECUTED
12ec2c: f015 ff7e bl 144b2c <strtoul> <== NOT EXECUTED
12ec30: 9003 str r0, [sp, #12] <== NOT EXECUTED
break;
12ec32: e79b b.n 12eb6c <rtems_shell_rfs_format+0x2c> <== NOT EXECUTED
arg++;
12ec34: 3401 adds r4, #1 <== NOT EXECUTED
if (arg >= argc)
12ec36: 42a6 cmp r6, r4 <== NOT EXECUTED
12ec38: dd37 ble.n 12ecaa <rtems_shell_rfs_format+0x16a> <== NOT EXECUTED
config.group_inodes = strtoul (argv[arg], 0, 0);
12ec3a: 4442 add r2, r8 <== NOT EXECUTED
12ec3c: 6850 ldr r0, [r2, #4] <== NOT EXECUTED
12ec3e: 2200 movs r2, #0 <== NOT EXECUTED
12ec40: 4611 mov r1, r2 <== NOT EXECUTED
12ec42: f015 ff73 bl 144b2c <strtoul> <== NOT EXECUTED
12ec46: 9002 str r0, [sp, #8] <== NOT EXECUTED
break;
12ec48: e790 b.n 12eb6c <rtems_shell_rfs_format+0x2c> <== NOT EXECUTED
arg++;
12ec4a: 3401 adds r4, #1 <== NOT EXECUTED
if (arg >= argc)
12ec4c: 42a6 cmp r6, r4 <== NOT EXECUTED
12ec4e: dd1c ble.n 12ec8a <rtems_shell_rfs_format+0x14a> <== NOT EXECUTED
config.group_blocks = strtoul (argv[arg], 0, 0);
12ec50: 4442 add r2, r8 <== NOT EXECUTED
12ec52: 6850 ldr r0, [r2, #4] <== NOT EXECUTED
12ec54: 2200 movs r2, #0 <== NOT EXECUTED
12ec56: 4611 mov r1, r2 <== NOT EXECUTED
12ec58: f015 ff68 bl 144b2c <strtoul> <== NOT EXECUTED
12ec5c: 9001 str r0, [sp, #4] <== NOT EXECUTED
break;
12ec5e: e785 b.n 12eb6c <rtems_shell_rfs_format+0x2c> <== NOT EXECUTED
config.initialise_inodes = true;
12ec60: f88d 7014 strb.w r7, [sp, #20] <== NOT EXECUTED
break;
12ec64: e782 b.n 12eb6c <rtems_shell_rfs_format+0x2c> <== NOT EXECUTED
printf ("error: only one driver name allowed: %s\n", argv[arg]);
12ec66: f640 0064 movw r0, #2148 ; 0x864 <== NOT EXECUTED
12ec6a: f2c0 0015 movt r0, #21 <== NOT EXECUTED
12ec6e: f00c feaf bl 13b9d0 <__wrap_printf> <== NOT EXECUTED
return 1;
12ec72: 2001 movs r0, #1 <== NOT EXECUTED
}
12ec74: b006 add sp, #24 <== NOT EXECUTED
12ec76: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
printf ("error: no driver name provided\n");
12ec7a: f249 50b8 movw r0, #38328 ; 0x95b8 <== NOT EXECUTED
12ec7e: f2c0 0015 movt r0, #21 <== NOT EXECUTED
12ec82: f00c feb7 bl 13b9f4 <__wrap_puts> <== NOT EXECUTED
return 1;
12ec86: 2001 movs r0, #1 <== NOT EXECUTED
12ec88: e79d b.n 12ebc6 <rtems_shell_rfs_format+0x86> <== NOT EXECUTED
printf ("error: group block count needs an argument\n");
12ec8a: f249 502c movw r0, #38188 ; 0x952c <== NOT EXECUTED
12ec8e: f2c0 0015 movt r0, #21 <== NOT EXECUTED
12ec92: f00c feaf bl 13b9f4 <__wrap_puts> <== NOT EXECUTED
return 1;
12ec96: 2001 movs r0, #1 <== NOT EXECUTED
12ec98: e795 b.n 12ebc6 <rtems_shell_rfs_format+0x86> <== NOT EXECUTED
printf ("error: block size needs an argument\n");
12ec9a: f249 5008 movw r0, #38152 ; 0x9508 <== NOT EXECUTED
12ec9e: f2c0 0015 movt r0, #21 <== NOT EXECUTED
12eca2: f00c fea7 bl 13b9f4 <__wrap_puts> <== NOT EXECUTED
return 1;
12eca6: 2001 movs r0, #1 <== NOT EXECUTED
12eca8: e78d b.n 12ebc6 <rtems_shell_rfs_format+0x86> <== NOT EXECUTED
printf ("error: group inode count needs an argument\n");
12ecaa: f249 5058 movw r0, #38232 ; 0x9558 <== NOT EXECUTED
12ecae: f2c0 0015 movt r0, #21 <== NOT EXECUTED
12ecb2: f00c fe9f bl 13b9f4 <__wrap_puts> <== NOT EXECUTED
return 1;
12ecb6: 2001 movs r0, #1 <== NOT EXECUTED
12ecb8: e785 b.n 12ebc6 <rtems_shell_rfs_format+0x86> <== NOT EXECUTED
printf ("error: inode percentage overhead needs an argument\n");
12ecba: f249 5084 movw r0, #38276 ; 0x9584 <== NOT EXECUTED
12ecbe: f2c0 0015 movt r0, #21 <== NOT EXECUTED
12ecc2: f00c fe97 bl 13b9f4 <__wrap_puts> <== NOT EXECUTED
return 1;
12ecc6: 2001 movs r0, #1 <== NOT EXECUTED
12ecc8: e77d b.n 12ebc6 <rtems_shell_rfs_format+0x86> <== NOT EXECUTED
12ecca: bf00 nop