RTEMS-6
Annotated Report
libcsupport
Sun Feb 28 23:48:16 2021
0010dbac <RTEMS_Malloc_Initialize>:
heap = &_Malloc_Heap;
RTEMS_Malloc_Heap = heap;
init_or_extend = _Heap_Initialize;
page_size = CPU_HEAP_ALIGNMENT;
for (i = 0; i < _Memory_Get_count( mem ); ++i) {
10dbac: 6802 ldr r2, [r0, #0]
RTEMS_Malloc_Heap = heap;
10dbae: f242 7338 movw r3, #10040 ; 0x2738
{
10dbb2: e92d 47f0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, lr}
RTEMS_Malloc_Heap = heap;
10dbb6: f642 1838 movw r8, #10552 ; 0x2938
10dbba: f2c0 0320 movt r3, #32
10dbbe: f2c0 0820 movt r8, #32
10dbc2: f8c3 8000 str.w r8, [r3]
for (i = 0; i < _Memory_Get_count( mem ); ++i) {
10dbc6: b312 cbz r2, 10dc0e <RTEMS_Malloc_Initialize+0x62>
init_or_extend = _Heap_Initialize;
10dbc8: f648 6a8d movw sl, #36493 ; 0x8e8d
10dbcc: 4606 mov r6, r0
10dbce: f2c0 0a10 movt sl, #16
10dbd2: 4689 mov r9, r1
for (i = 0; i < _Memory_Get_count( mem ); ++i) {
10dbd4: 2500 movs r5, #0
init_or_extend = _Heap_Initialize;
10dbd6: 4657 mov r7, sl
return &information->areas[ index ];
10dbd8: 6872 ldr r2, [r6, #4]
10dbda: eb05 0445 add.w r4, r5, r5, lsl #1
Memory_Area *area;
uintptr_t space_available;
area = _Memory_Get_area( mem, i );
space_available = ( *init_or_extend )(
10dbde: 2308 movs r3, #8
10dbe0: 4640 mov r0, r8
10dbe2: eb02 0484 add.w r4, r2, r4, lsl #2
return (uintptr_t) area->end - (uintptr_t) area->free;
10dbe6: e9d4 1201 ldrd r1, r2, [r4, #4]
10dbea: 1a52 subs r2, r2, r1
10dbec: 47b8 blx r7
_Memory_Get_free_begin( area ),
_Memory_Get_free_size( area ),
page_size
);
if ( space_available > 0 ) {
10dbee: b110 cbz r0, 10dbf6 <RTEMS_Malloc_Initialize+0x4a>
area->free = (char *) area->free + consume;
10dbf0: 68a3 ldr r3, [r4, #8]
_Memory_Consume( area, _Memory_Get_free_size( area ) );
init_or_extend = extend;
10dbf2: 464f mov r7, r9
10dbf4: 6063 str r3, [r4, #4]
for (i = 0; i < _Memory_Get_count( mem ); ++i) {
10dbf6: 6833 ldr r3, [r6, #0]
10dbf8: 3501 adds r5, #1
10dbfa: 429d cmp r5, r3
10dbfc: d3ec bcc.n 10dbd8 <RTEMS_Malloc_Initialize+0x2c> <== ALWAYS TAKEN
}
}
if ( init_or_extend == _Heap_Initialize ) {
10dbfe: 4557 cmp r7, sl
10dc00: d005 beq.n 10dc0e <RTEMS_Malloc_Initialize+0x62>
_Internal_error( INTERNAL_ERROR_NO_MEMORY_FOR_HEAP );
}
return heap;
}
10dc02: f642 1038 movw r0, #10552 ; 0x2938
10dc06: f2c0 0020 movt r0, #32
10dc0a: e8bd 87f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, pc}
_Internal_error( INTERNAL_ERROR_NO_MEMORY_FOR_HEAP );
10dc0e: 2017 movs r0, #23
10dc10: f7fb fa9a bl 109148 <_Internal_error>
001061cc <_Console_simple_Read>:
ssize_t _Console_simple_Read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
1061cc: b570 push {r4, r5, r6, lr} <== NOT EXECUTED
ssize_t n;
buf = buffer;
n = (ssize_t) count;
for ( i = 0; i < n; ++i ) {
1061ce: 1e16 subs r6, r2, #0 <== NOT EXECUTED
1061d0: dd0f ble.n 1061f2 <_Console_simple_Read+0x26> <== NOT EXECUTED
1061d2: 1e75 subs r5, r6, #1 <== NOT EXECUTED
1061d4: 1e4c subs r4, r1, #1 <== NOT EXECUTED
1061d6: 440d add r5, r1 <== NOT EXECUTED
1061d8: e001 b.n 1061de <_Console_simple_Read+0x12> <== NOT EXECUTED
c = getchark();
if ( c != -1 ) {
break;
}
(void) rtems_task_wake_after( 1 );
1061da: f002 fc23 bl 108a24 <rtems_task_wake_after> <== NOT EXECUTED
c = getchark();
1061de: f000 f8b3 bl 106348 <getchark> <== NOT EXECUTED
1061e2: 4603 mov r3, r0 <== NOT EXECUTED
(void) rtems_task_wake_after( 1 );
1061e4: 2001 movs r0, #1 <== NOT EXECUTED
if ( c != -1 ) {
1061e6: 1c5a adds r2, r3, #1 <== NOT EXECUTED
1061e8: d0f7 beq.n 1061da <_Console_simple_Read+0xe> <== NOT EXECUTED
}
buf[ i ] = (char) c;
1061ea: f804 3f01 strb.w r3, [r4, #1]! <== NOT EXECUTED
for ( i = 0; i < n; ++i ) {
1061ee: 42ac cmp r4, r5 <== NOT EXECUTED
1061f0: d1f5 bne.n 1061de <_Console_simple_Read+0x12> <== NOT EXECUTED
}
return n;
}
1061f2: 4630 mov r0, r6 <== NOT EXECUTED
1061f4: bd70 pop {r4, r5, r6, pc} <== NOT EXECUTED
1061f6: bf00 nop
00106248 <_Malloc_Process_deferred_frees>:
{
106248: b538 push {r3, r4, r5, lr} <== NOT EXECUTED
__asm__ volatile (
10624a: f3ef 8300 mrs r3, CPSR <== NOT EXECUTED
10624e: f043 0280 orr.w r2, r3, #128 ; 0x80 <== NOT EXECUTED
106252: f382 8900 msr CPSR_fc, r2 <== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
106256: f240 04f0 movw r4, #240 ; 0xf0 <== NOT EXECUTED
10625a: f2c0 0420 movt r4, #32 <== NOT EXECUTED
10625e: 4625 mov r5, r4 <== NOT EXECUTED
106260: f855 0b04 ldr.w r0, [r5], #4 <== NOT EXECUTED
if ( !_Chain_Is_empty(the_chain))
106264: 42a8 cmp r0, r5 <== NOT EXECUTED
106266: d00f beq.n 106288 <_Malloc_Process_deferred_frees+0x40> <== NOT EXECUTED
new_first = old_first->next;
106268: 6802 ldr r2, [r0, #0] <== NOT EXECUTED
head->next = new_first;
10626a: 6022 str r2, [r4, #0] <== NOT EXECUTED
new_first->previous = head;
10626c: 6054 str r4, [r2, #4] <== NOT EXECUTED
__asm__ volatile (
10626e: f383 8900 msr CPSR_fc, r3 <== NOT EXECUTED
free( to_be_freed );
106272: f7ff ffc1 bl 1061f8 <free> <== NOT EXECUTED
__asm__ volatile (
106276: f3ef 8300 mrs r3, CPSR <== NOT EXECUTED
10627a: f043 0280 orr.w r2, r3, #128 ; 0x80 <== NOT EXECUTED
10627e: f382 8900 msr CPSR_fc, r2 <== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
106282: 6820 ldr r0, [r4, #0] <== NOT EXECUTED
if ( !_Chain_Is_empty(the_chain))
106284: 42a8 cmp r0, r5 <== NOT EXECUTED
106286: d1ef bne.n 106268 <_Malloc_Process_deferred_frees+0x20> <== NOT EXECUTED
__asm__ volatile (
106288: f383 8900 msr CPSR_fc, r3 <== NOT EXECUTED
}
10628c: bd38 pop {r3, r4, r5, pc} <== NOT EXECUTED
10628e: bf00 nop
00117238 <_gettimeofday_r>:
int _gettimeofday_r(
struct _reent *ignored_reentrancy_stuff RTEMS_UNUSED,
struct timeval *tp,
void *__tz
)
{
117238: b508 push {r3, lr}
if ( !tp )
11723a: b121 cbz r1, 117246 <_gettimeofday_r+0xe>
11723c: 4608 mov r0, r1
*/
RTEMS_INLINE_ROUTINE void _TOD_Get_timeval(
struct timeval *time
)
{
_Timecounter_Microtime( time );
11723e: f7f2 fcff bl 109c40 <_Timecounter_Microtime>
return 0;
117242: 2000 movs r0, #0
struct timezone *tzp = __tz;
return gettimeofday( tp, tzp );
}
117244: bd08 pop {r3, pc}
rtems_set_errno_and_return_minus_one( EFAULT );
117246: f7f9 fa71 bl 11072c <__errno> <== NOT EXECUTED
11724a: 220e movs r2, #14 <== NOT EXECUTED
11724c: 4603 mov r3, r0 <== NOT EXECUTED
11724e: 601a str r2, [r3, #0] <== NOT EXECUTED
117250: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff <== NOT EXECUTED
}
117254: bd08 pop {r3, pc} <== NOT EXECUTED
117256: bf00 nop
00106950 <_libcsupport_scangr>:
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
106950: b570 push {r4, r5, r6, lr}
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
106952: 2500 movs r5, #0
{
106954: b086 sub sp, #24
106956: 4604 mov r4, r0
106958: 460e mov r6, r1
10695a: e9cd 3202 strd r3, r2, [sp, #8]
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
10695e: ab02 add r3, sp, #8
106960: aa03 add r2, sp, #12
106962: 9500 str r5, [sp, #0]
106964: f7ff fed4 bl 106710 <scanString>
106968: b910 cbnz r0, 106970 <_libcsupport_scangr+0x20>
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
|| !scanInt(fp, &grgid)
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
return 0;
10696a: 2000 movs r0, #0
}
}
grp->gr_mem[memcount] = NULL;
return 1;
}
10696c: b006 add sp, #24
10696e: bd70 pop {r4, r5, r6, pc}
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
106970: ab02 add r3, sp, #8
106972: aa03 add r2, sp, #12
106974: 1d31 adds r1, r6, #4
106976: 4620 mov r0, r4
106978: 9500 str r5, [sp, #0]
10697a: f7ff fec9 bl 106710 <scanString>
10697e: 2800 cmp r0, #0
106980: d0f3 beq.n 10696a <_libcsupport_scangr+0x1a> <== ALWAYS TAKEN
|| !scanInt(fp, &grgid)
106982: a904 add r1, sp, #16
106984: 4620 mov r0, r4
106986: f7ff fe7f bl 106688 <scanInt>
10698a: 2800 cmp r0, #0
10698c: d0ed beq.n 10696a <_libcsupport_scangr+0x1a> <== ALWAYS TAKEN
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
10698e: 2501 movs r5, #1
106990: ab02 add r3, sp, #8
106992: aa03 add r2, sp, #12
106994: 4620 mov r0, r4
106996: a905 add r1, sp, #20
106998: 9500 str r5, [sp, #0]
10699a: f7ff feb9 bl 106710 <scanString>
10699e: 2800 cmp r0, #0
1069a0: d0e3 beq.n 10696a <_libcsupport_scangr+0x1a> <== ALWAYS TAKEN
if (grmem[0] == '\0') {
1069a2: e9dd 3404 ldrd r3, r4, [sp, #16]
1069a6: 2113 movs r1, #19
grp->gr_gid = grgid;
1069a8: 8133 strh r3, [r6, #8]
if (grmem[0] == '\0') {
1069aa: 7823 ldrb r3, [r4, #0]
1069ac: bb2b cbnz r3, 1069fa <_libcsupport_scangr+0xaa>
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
1069ae: 9b02 ldr r3, [sp, #8]
1069b0: 428b cmp r3, r1
1069b2: d3da bcc.n 10696a <_libcsupport_scangr+0x1a> <== ALWAYS TAKEN
grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15);
1069b4: 9903 ldr r1, [sp, #12]
1069b6: 310f adds r1, #15
1069b8: f021 010f bic.w r1, r1, #15
1069bc: 60f1 str r1, [r6, #12]
if (grmem[0] == '\0') {
1069be: 7823 ldrb r3, [r4, #0]
1069c0: b1bb cbz r3, 1069f2 <_libcsupport_scangr+0xa2>
grp->gr_mem[0] = grmem;
1069c2: 600c str r4, [r1, #0]
grp->gr_mem[memcount] = NULL;
1069c4: 3104 adds r1, #4
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
1069c6: 9a05 ldr r2, [sp, #20]
1069c8: 7813 ldrb r3, [r2, #0]
1069ca: b193 cbz r3, 1069f2 <_libcsupport_scangr+0xa2>
1069cc: 3201 adds r2, #1
1069ce: 2101 movs r1, #1
*cp = '\0';
1069d0: 2400 movs r4, #0
if(*cp == ',') {
1069d2: 2b2c cmp r3, #44 ; 0x2c
grp->gr_mem[memcount++] = cp + 1;
1069d4: ea4f 0081 mov.w r0, r1, lsl #2
if(*cp == ',') {
1069d8: d105 bne.n 1069e6 <_libcsupport_scangr+0x96>
*cp = '\0';
1069da: f802 4c01 strb.w r4, [r2, #-1]
grp->gr_mem[memcount++] = cp + 1;
1069de: 3101 adds r1, #1
1069e0: 68f3 ldr r3, [r6, #12]
1069e2: 501a str r2, [r3, r0]
grp->gr_mem[memcount] = NULL;
1069e4: 3004 adds r0, #4
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
1069e6: f812 3b01 ldrb.w r3, [r2], #1
1069ea: 2b00 cmp r3, #0
1069ec: d1f1 bne.n 1069d2 <_libcsupport_scangr+0x82>
grp->gr_mem[memcount] = NULL;
1069ee: 68f1 ldr r1, [r6, #12]
1069f0: 4401 add r1, r0
1069f2: 2300 movs r3, #0
return 1;
1069f4: 2001 movs r0, #1
grp->gr_mem[memcount] = NULL;
1069f6: 600b str r3, [r1, #0]
return 1;
1069f8: e7b8 b.n 10696c <_libcsupport_scangr+0x1c>
1069fa: 4620 mov r0, r4
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
1069fc: 462a mov r2, r5
if(*cp == ',')
1069fe: 2b2c cmp r3, #44 ; 0x2c
memcount++;
106a00: f102 0101 add.w r1, r2, #1
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
106a04: bf02 ittt eq
106a06: 1c93 addeq r3, r2, #2
memcount++;
106a08: 460a moveq r2, r1
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
106a0a: 4619 moveq r1, r3
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
106a0c: f810 3f01 ldrb.w r3, [r0, #1]!
106a10: 2b00 cmp r3, #0
106a12: d1f4 bne.n 1069fe <_libcsupport_scangr+0xae>
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
106a14: 0089 lsls r1, r1, #2
106a16: 310f adds r1, #15
106a18: e7c9 b.n 1069ae <_libcsupport_scangr+0x5e>
106a1a: bf00 nop
001067f0 <_libcsupport_scanpw>:
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
1067f0: b570 push {r4, r5, r6, lr}
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
1067f2: 2400 movs r4, #0
{
1067f4: b086 sub sp, #24
1067f6: 4606 mov r6, r0
1067f8: 460d mov r5, r1
1067fa: e9cd 3202 strd r3, r2, [sp, #8]
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
1067fe: ab02 add r3, sp, #8
106800: aa03 add r2, sp, #12
106802: 9400 str r4, [sp, #0]
106804: f7ff ff84 bl 106710 <scanString>
106808: b910 cbnz r0, 106810 <_libcsupport_scanpw+0x20>
|| !scanInt(fp, &pwgid)
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
return 0;
10680a: 2000 movs r0, #0
pwd->pw_uid = pwuid;
pwd->pw_gid = pwgid;
return 1;
}
10680c: b006 add sp, #24
10680e: bd70 pop {r4, r5, r6, pc}
|| !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0)
106810: ab02 add r3, sp, #8
106812: aa03 add r2, sp, #12
106814: 1d29 adds r1, r5, #4
106816: 4630 mov r0, r6
106818: 9400 str r4, [sp, #0]
10681a: f7ff ff79 bl 106710 <scanString>
10681e: 2800 cmp r0, #0
106820: d0f3 beq.n 10680a <_libcsupport_scanpw+0x1a> <== ALWAYS TAKEN
|| !scanInt(fp, &pwuid)
106822: a904 add r1, sp, #16
106824: 4630 mov r0, r6
106826: f7ff ff2f bl 106688 <scanInt>
10682a: 2800 cmp r0, #0
10682c: d0ed beq.n 10680a <_libcsupport_scanpw+0x1a>
|| !scanInt(fp, &pwgid)
10682e: a905 add r1, sp, #20
106830: 4630 mov r0, r6
106832: f7ff ff29 bl 106688 <scanInt>
106836: 2800 cmp r0, #0
106838: d0e7 beq.n 10680a <_libcsupport_scanpw+0x1a>
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
10683a: ab02 add r3, sp, #8
10683c: aa03 add r2, sp, #12
10683e: f105 010c add.w r1, r5, #12
106842: 4630 mov r0, r6
106844: 9400 str r4, [sp, #0]
106846: f7ff ff63 bl 106710 <scanString>
10684a: 2800 cmp r0, #0
10684c: d0dd beq.n 10680a <_libcsupport_scanpw+0x1a> <== ALWAYS TAKEN
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
10684e: ab02 add r3, sp, #8
106850: aa03 add r2, sp, #12
106852: f105 0110 add.w r1, r5, #16
106856: 4630 mov r0, r6
106858: 9400 str r4, [sp, #0]
10685a: f7ff ff59 bl 106710 <scanString>
10685e: 2800 cmp r0, #0
106860: d0d3 beq.n 10680a <_libcsupport_scanpw+0x1a> <== ALWAYS TAKEN
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
106862: ab02 add r3, sp, #8
106864: aa03 add r2, sp, #12
106866: f105 0114 add.w r1, r5, #20
10686a: 4630 mov r0, r6
10686c: 9400 str r4, [sp, #0]
10686e: f7ff ff4f bl 106710 <scanString>
106872: 2800 cmp r0, #0
106874: d0c9 beq.n 10680a <_libcsupport_scanpw+0x1a> <== ALWAYS TAKEN
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
106876: 2401 movs r4, #1
106878: ab02 add r3, sp, #8
10687a: aa03 add r2, sp, #12
10687c: 4630 mov r0, r6
10687e: f105 0118 add.w r1, r5, #24
106882: 9400 str r4, [sp, #0]
106884: f7ff ff44 bl 106710 <scanString>
106888: 2800 cmp r0, #0
10688a: d0be beq.n 10680a <_libcsupport_scanpw+0x1a>
pwd->pw_gid = pwgid;
10688c: e9dd 2304 ldrd r2, r3, [sp, #16]
return 1;
106890: 4620 mov r0, r4
pwd->pw_uid = pwuid;
106892: 812a strh r2, [r5, #8]
pwd->pw_gid = pwgid;
106894: 816b strh r3, [r5, #10]
return 1;
106896: e7b9 b.n 10680c <_libcsupport_scanpw+0x1c>
00106d88 <_read_r>:
struct _reent *ptr RTEMS_UNUSED,
int fd,
void *buf,
size_t nbytes
)
{
106d88: b508 push {r3, lr}
rtems_libio_check_buffer( buffer );
106d8a: b1c2 cbz r2, 106dbe <_read_r+0x36>
rtems_libio_check_count( count );
106d8c: b16b cbz r3, 106daa <_read_r+0x22>
106d8e: 4608 mov r0, r1
106d90: 4611 mov r1, r2
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_READ, EBADF );
106d92: f647 1230 movw r2, #31024 ; 0x7930
106d96: f2c0 0211 movt r2, #17
106d9a: 6812 ldr r2, [r2, #0]
106d9c: 4290 cmp r0, r2
106d9e: d206 bcs.n 106dae <_read_r+0x26> <== ALWAYS TAKEN
106da0: 461a mov r2, r3
return read( fd, buf, nbytes );
}
106da2: e8bd 4008 ldmia.w sp!, {r3, lr}
106da6: f7ff bf91 b.w 106ccc <read.part.0>
rtems_libio_check_count( count );
106daa: 4618 mov r0, r3 <== NOT EXECUTED
}
106dac: bd08 pop {r3, pc} <== NOT EXECUTED
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_READ, EBADF );
106dae: f009 fcbd bl 11072c <__errno> <== NOT EXECUTED
106db2: 2209 movs r2, #9 <== NOT EXECUTED
106db4: 4603 mov r3, r0 <== NOT EXECUTED
106db6: 601a str r2, [r3, #0] <== NOT EXECUTED
106db8: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff <== NOT EXECUTED
}
106dbc: bd08 pop {r3, pc} <== NOT EXECUTED
rtems_libio_check_buffer( buffer );
106dbe: f009 fcb5 bl 11072c <__errno> <== NOT EXECUTED
106dc2: 2216 movs r2, #22 <== NOT EXECUTED
106dc4: 4603 mov r3, r0 <== NOT EXECUTED
106dc6: 601a str r2, [r3, #0] <== NOT EXECUTED
106dc8: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff <== NOT EXECUTED
}
106dcc: bd08 pop {r3, pc} <== NOT EXECUTED
106dce: bf00 nop
0010c71c <chroot>:
#include <unistd.h>
#include <rtems/libio_.h>
int chroot( const char *path )
{
10c71c: b530 push {r4, r5, lr}
10c71e: b0b3 sub sp, #204 ; 0xcc
10c720: 4604 mov r4, r0
/*
* We use the global environment for path evaluation. This makes it possible
* to escape from a chroot environment referencing an unmounted file system.
*/
rtems_filesystem_eval_path_start_with_root_and_current(
10c722: f008 ffed bl 115700 <strlen>
10c726: f241 13e0 movw r3, #4576 ; 0x11e0
10c72a: 4602 mov r2, r0
10c72c: f2c0 0322 movt r3, #34 ; 0x22
10c730: 4621 mov r1, r4
10c732: 1d18 adds r0, r3, #4
&rtems_global_user_env.current_directory
);
rtems_filesystem_eval_path_extract_currentloc( &ctx, &loc );
new_current_loc = rtems_filesystem_location_transform_to_global( &loc );
if ( !rtems_filesystem_global_location_is_null( new_current_loc ) ) {
10c734: f249 64f8 movw r4, #38648 ; 0x96f8
rtems_filesystem_eval_path_start_with_root_and_current(
10c738: e9cd 0300 strd r0, r3, [sp]
10c73c: 2319 movs r3, #25
10c73e: a80a add r0, sp, #40 ; 0x28
if ( !rtems_filesystem_global_location_is_null( new_current_loc ) ) {
10c740: f2c0 0411 movt r4, #17
rtems_filesystem_eval_path_start_with_root_and_current(
10c744: f001 f80c bl 10d760 <rtems_filesystem_eval_path_start_with_root_and_current>
rtems_filesystem_location_copy_and_detach(
10c748: a910 add r1, sp, #64 ; 0x40
10c74a: a804 add r0, sp, #16
10c74c: f001 fb4c bl 10dde8 <rtems_filesystem_location_copy_and_detach>
new_current_loc = rtems_filesystem_location_transform_to_global( &loc );
10c750: a804 add r0, sp, #16
10c752: f001 fb83 bl 10de5c <rtems_filesystem_location_transform_to_global>
if ( !rtems_filesystem_global_location_is_null( new_current_loc ) ) {
10c756: 6903 ldr r3, [r0, #16]
new_current_loc = rtems_filesystem_location_transform_to_global( &loc );
10c758: 9003 str r0, [sp, #12]
if ( !rtems_filesystem_global_location_is_null( new_current_loc ) ) {
10c75a: 42a3 cmp r3, r4
10c75c: d041 beq.n 10c7e2 <chroot+0xc6>
rtems_filesystem_global_location_t *new_root_loc =
rtems_filesystem_global_location_obtain( &new_current_loc );
10c75e: a803 add r0, sp, #12
10c760: f001 fabe bl 10dce0 <rtems_filesystem_global_location_obtain>
const rtems_filesystem_location_info_t *loc
)
{
struct stat st;
st.st_mode = 0;
10c764: 2300 movs r3, #0
(void) ( *loc->handlers->fstat_h )( loc, &st );
10c766: a918 add r1, sp, #96 ; 0x60
st.st_mode = 0;
10c768: 931c str r3, [sp, #112] ; 0x70
10c76a: 4605 mov r5, r0
(void) ( *loc->handlers->fstat_h )( loc, &st );
10c76c: 6903 ldr r3, [r0, #16]
10c76e: 699b ldr r3, [r3, #24]
10c770: 4798 blx r3
return st.st_mode;
10c772: 9b1c ldr r3, [sp, #112] ; 0x70
mode_t type = rtems_filesystem_location_type( &new_root_loc->location );
if ( S_ISDIR( type ) ) {
10c774: f403 4370 and.w r3, r3, #61440 ; 0xf000
10c778: f5b3 4f80 cmp.w r3, #16384 ; 0x4000
10c77c: d114 bne.n 10c7a8 <chroot+0x8c>
sc = rtems_libio_set_private_env();
10c77e: f000 fdc9 bl 10d314 <rtems_libio_set_private_env>
if (sc == RTEMS_SUCCESSFUL) {
10c782: 4604 mov r4, r0
10c784: bb30 cbnz r0, 10c7d4 <chroot+0xb8>
rtems_filesystem_global_location_assign(
&rtems_filesystem_root,
10c786: f001 fcc1 bl 10e10c <rtems_current_user_env_get>
rtems_filesystem_global_location_assign(
10c78a: 4629 mov r1, r5
10c78c: 3004 adds r0, #4
10c78e: f001 fa27 bl 10dbe0 <rtems_filesystem_global_location_assign>
new_root_loc
);
rtems_filesystem_global_location_assign(
&rtems_filesystem_current,
10c792: f001 fcbb bl 10e10c <rtems_current_user_env_get>
rtems_filesystem_global_location_assign(
10c796: 9903 ldr r1, [sp, #12]
10c798: f001 fa22 bl 10dbe0 <rtems_filesystem_global_location_assign>
}
} else {
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
10c79c: a80a add r0, sp, #40 ; 0x28
10c79e: f001 f8ab bl 10d8f8 <rtems_filesystem_eval_path_cleanup>
int rv = 0;
10c7a2: 4620 mov r0, r4
if ( rv != 0 ) {
rtems_filesystem_global_location_release( new_current_loc, false );
}
return rv;
}
10c7a4: b033 add sp, #204 ; 0xcc
10c7a6: bd30 pop {r4, r5, pc}
if ( !rtems_filesystem_location_is_null( loc ) ) {
10c7a8: 692b ldr r3, [r5, #16]
10c7aa: 42a3 cmp r3, r4
10c7ac: d003 beq.n 10c7b6 <chroot+0x9a> <== ALWAYS TAKEN
errno = eno;
10c7ae: f008 fa0b bl 114bc8 <__errno>
10c7b2: 2314 movs r3, #20
10c7b4: 6003 str r3, [r0, #0]
rtems_filesystem_global_location_release( new_root_loc, true );
10c7b6: 4628 mov r0, r5
10c7b8: 2101 movs r1, #1
10c7ba: f001 fac9 bl 10dd50 <rtems_filesystem_global_location_release>
rtems_filesystem_eval_path_cleanup( &ctx );
10c7be: a80a add r0, sp, #40 ; 0x28
10c7c0: f001 f89a bl 10d8f8 <rtems_filesystem_eval_path_cleanup>
rtems_filesystem_global_location_release( new_current_loc, false );
10c7c4: 9803 ldr r0, [sp, #12]
10c7c6: 2100 movs r1, #0
10c7c8: f001 fac2 bl 10dd50 <rtems_filesystem_global_location_release>
10c7cc: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff
}
10c7d0: b033 add sp, #204 ; 0xcc
10c7d2: bd30 pop {r4, r5, pc}
if (sc != RTEMS_UNSATISFIED) {
10c7d4: 280d cmp r0, #13
10c7d6: d0ee beq.n 10c7b6 <chroot+0x9a> <== ALWAYS TAKEN
errno = ENOMEM;
10c7d8: f008 f9f6 bl 114bc8 <__errno>
10c7dc: 230c movs r3, #12
10c7de: 6003 str r3, [r0, #0]
10c7e0: e7e9 b.n 10c7b6 <chroot+0x9a>
rtems_filesystem_eval_path_cleanup( &ctx );
10c7e2: a80a add r0, sp, #40 ; 0x28
10c7e4: f001 f888 bl 10d8f8 <rtems_filesystem_eval_path_cleanup>
if ( rv != 0 ) {
10c7e8: e7ec b.n 10c7c4 <chroot+0xa8>
10c7ea: bf00 nop
00104da8 <endpwent>:
void endpwent(void)
{
if (passwd_fp != NULL)
104da8: f641 43f0 movw r3, #7408 ; 0x1cf0
104dac: f2c0 0320 movt r3, #32
104db0: 6818 ldr r0, [r3, #0]
104db2: b108 cbz r0, 104db8 <endpwent+0x10>
fclose(passwd_fp);
104db4: f008 bb86 b.w 10d4c4 <fclose>
}
104db8: 4770 bx lr <== NOT EXECUTED
104dba: bf00 nop
00105704 <fcntl>:
int fcntl(
int fd,
int cmd,
...
)
{
105704: b40e push {r1, r2, r3}
LIBIO_GET_IOP( fd, iop );
105706: f243 2274 movw r2, #12916 ; 0x3274
10570a: f2c0 0211 movt r2, #17
{
10570e: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
105712: b086 sub sp, #24
105714: ab0f add r3, sp, #60 ; 0x3c
LIBIO_GET_IOP( fd, iop );
105716: 6811 ldr r1, [r2, #0]
{
105718: f853 8b04 ldr.w r8, [r3], #4
LIBIO_GET_IOP( fd, iop );
10571c: 4288 cmp r0, r1
int ret;
va_list ap;
va_start( ap, cmd );
10571e: 9305 str r3, [sp, #20]
LIBIO_GET_IOP( fd, iop );
105720: f080 8163 bcs.w 1059ea <fcntl+0x2e6>
return &rtems_libio_iops[ fd ];
105724: 0047 lsls r7, r0, #1
105726: f242 0430 movw r4, #8240 ; 0x2030
10572a: f2c0 0420 movt r4, #32
10572e: 183d adds r5, r7, r0
105730: 4606 mov r6, r0
105732: 012d lsls r5, r5, #4
105734: eb04 0905 add.w r9, r4, r5
__asm__ volatile (
105738: f3ef 8000 mrs r0, CPSR
10573c: f040 0180 orr.w r1, r0, #128 ; 0x80
105740: f381 8900 msr CPSR_fc, r1
val = *obj;
105744: 5961 ldr r1, [r4, r5]
*obj = val + arg;
105746: f501 5c80 add.w ip, r1, #4096 ; 0x1000
10574a: f844 c005 str.w ip, [r4, r5]
__asm__ volatile (
10574e: f380 8900 msr CPSR_fc, r0
105752: 05c9 lsls r1, r1, #23
105754: f140 813d bpl.w 1059d2 <fcntl+0x2ce>
switch ( cmd ) {
105758: f1b8 0f14 cmp.w r8, #20
10575c: d82e bhi.n 1057bc <fcntl+0xb8> <== ALWAYS TAKEN
10575e: e8df f018 tbh [pc, r8, lsl #1]
105762: 0034 .short 0x0034
105764: 008d0079 .word 0x008d0079
105768: 010200a2 .word 0x010200a2
10576c: 00150015 .word 0x00150015
105770: 00150015 .word 0x00150015
105774: 002d0015 .word 0x002d0015
105778: 002d002d .word 0x002d002d
10577c: 002d002d .word 0x002d002d
105780: 002d002d .word 0x002d002d
105784: 002d002d .word 0x002d002d
105788: 00ab002d .word 0x00ab002d
ret = -1;
10578c: f04f 3bff mov.w fp, #4294967295 ; 0xffffffff
errno = ENOTSUP;
105790: f008 fdfe bl 10e390 <__errno>
105794: 2386 movs r3, #134 ; 0x86
105796: 6003 str r3, [r0, #0]
__asm__ volatile (
105798: f3ef 8200 mrs r2, CPSR
10579c: f042 0380 orr.w r3, r2, #128 ; 0x80
1057a0: f383 8900 msr CPSR_fc, r3
*obj = val - arg;
1057a4: 5963 ldr r3, [r4, r5]
1057a6: f5a3 5380 sub.w r3, r3, #4096 ; 0x1000
1057aa: 5163 str r3, [r4, r5]
__asm__ volatile (
1057ac: f382 8900 msr CPSR_fc, r2
ret = vfcntl(fd,cmd,ap);
va_end(ap);
return ret;
}
1057b0: 4658 mov r0, fp
1057b2: b006 add sp, #24
1057b4: e8bd 4ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
1057b8: b003 add sp, #12
1057ba: 4770 bx lr
errno = EINVAL;
1057bc: f008 fde8 bl 10e390 <__errno>
1057c0: 2316 movs r3, #22
ret = -1;
1057c2: f04f 3bff mov.w fp, #4294967295 ; 0xffffffff
errno = EINVAL;
1057c6: 6003 str r3, [r0, #0]
if (ret >= 0) {
1057c8: e7e6 b.n 105798 <fcntl+0x94>
val = *obj;
1057ca: 5960 ldr r0, [r4, r5]
oflag = rtems_libio_to_fcntl_flags( rtems_libio_iop_flags( iop ) );
1057cc: f000 fad2 bl 105d74 <rtems_libio_to_fcntl_flags>
1057d0: 9001 str r0, [sp, #4]
diop = rtems_libio_allocate();
1057d2: f000 fae5 bl 105da0 <rtems_libio_allocate>
if (diop != NULL) {
1057d6: 4682 mov sl, r0
1057d8: 2800 cmp r0, #0
1057da: f000 810d beq.w 1059f8 <fcntl+0x2f4> <== ALWAYS TAKEN
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
1057de: f8d9 0024 ldr.w r0, [r9, #36] ; 0x24
(*mt_entry->ops->lock_h)( mt_entry );
1057e2: 68c3 ldr r3, [r0, #12]
1057e4: 681b ldr r3, [r3, #0]
1057e6: 4798 blx r3
rtems_filesystem_location_clone( &diop->pathinfo, &iop->pathinfo );
1057e8: f105 0110 add.w r1, r5, #16
1057ec: f10a 0010 add.w r0, sl, #16
1057f0: 4421 add r1, r4
1057f2: f005 fe59 bl 10b4a8 <rtems_filesystem_location_clone>
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
1057f6: f8d9 0024 ldr.w r0, [r9, #36] ; 0x24
(*mt_entry->ops->unlock_h)( mt_entry );
1057fa: 68c3 ldr r3, [r0, #12]
1057fc: 685b ldr r3, [r3, #4]
1057fe: 4798 blx r3
rv = (*diop->pathinfo.handlers->open_h)( diop, NULL, oflag, 0 );
105800: f8da 3020 ldr.w r3, [sl, #32]
105804: 4650 mov r0, sl
105806: 9a01 ldr r2, [sp, #4]
105808: f8d3 b000 ldr.w fp, [r3]
10580c: 2300 movs r3, #0
10580e: 4619 mov r1, r3
105810: 47d8 blx fp
if ( rv == 0 ) {
105812: 4683 mov fp, r0
105814: 2800 cmp r0, #0
105816: f040 80d5 bne.w 1059c4 <fcntl+0x2c0> <== ALWAYS TAKEN
LIBIO_FLAGS_OPEN | rtems_libio_fcntl_flags( oflag )
10581a: 9801 ldr r0, [sp, #4]
10581c: f000 fa94 bl 105d48 <rtems_libio_fcntl_flags>
__asm__ volatile (
105820: f3ef 8200 mrs r2, CPSR
105824: f042 0380 orr.w r3, r2, #128 ; 0x80
105828: f383 8900 msr CPSR_fc, r3
*obj = val | arg;
10582c: f8da 3000 ldr.w r3, [sl]
105830: 4303 orrs r3, r0
105832: f443 7380 orr.w r3, r3, #256 ; 0x100
105836: f8ca 3000 str.w r3, [sl]
__asm__ volatile (
10583a: f382 8900 msr CPSR_fc, r2
rv = rtems_libio_iop_to_descriptor( diop );
10583e: ebaa 0b04 sub.w fp, sl, r4
105842: f64a 20ab movw r0, #43691 ; 0xaaab
105846: ea4f 1b2b mov.w fp, fp, asr #4
10584a: f6ca 20aa movt r0, #43690 ; 0xaaaa
10584e: fb00 fb0b mul.w fp, r0, fp
105852: e02c b.n 1058ae <fcntl+0x1aa>
val = *obj;
105854: 5960 ldr r0, [r4, r5]
ret = ((rtems_libio_iop_flags(iop) & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0);
105856: f3c0 2bc0 ubfx fp, r0, #11, #1
int err = (*iop->pathinfo.handlers->fcntl_h)( iop, cmd );
10585a: 4437 add r7, r6
10585c: 4641 mov r1, r8
10585e: eb04 1707 add.w r7, r4, r7, lsl #4
105862: 4648 mov r0, r9
105864: 6a3b ldr r3, [r7, #32]
105866: 6a9b ldr r3, [r3, #40] ; 0x28
105868: 4798 blx r3
if (err) {
10586a: 4606 mov r6, r0
10586c: 2800 cmp r0, #0
10586e: d093 beq.n 105798 <fcntl+0x94> <== NEVER TAKEN
errno = err;
105870: f008 fd8e bl 10e390 <__errno> <== NOT EXECUTED
ret = -1;
105874: f04f 3bff mov.w fp, #4294967295 ; 0xffffffff <== NOT EXECUTED
errno = err;
105878: 6006 str r6, [r0, #0] <== NOT EXECUTED
ret = -1;
10587a: e78d b.n 105798 <fcntl+0x94> <== NOT EXECUTED
if ( va_arg( ap, int ) )
10587c: f8d3 b000 ldr.w fp, [r3]
105880: f1bb 0f00 cmp.w fp, #0
105884: f000 8091 beq.w 1059aa <fcntl+0x2a6>
__asm__ volatile (
105888: f3ef 8200 mrs r2, CPSR
10588c: f042 0380 orr.w r3, r2, #128 ; 0x80
105890: f383 8900 msr CPSR_fc, r3
*obj = val | arg;
105894: 5963 ldr r3, [r4, r5]
105896: f443 6300 orr.w r3, r3, #2048 ; 0x800
10589a: 5163 str r3, [r4, r5]
__asm__ volatile (
10589c: f382 8900 msr CPSR_fc, r2
int ret = 0;
1058a0: f04f 0b00 mov.w fp, #0
return _Atomic_Fetch_or_uint( &iop->flags, set, ATOMIC_ORDER_RELAXED );
1058a4: e7d9 b.n 10585a <fcntl+0x156>
val = *obj;
1058a6: 5960 ldr r0, [r4, r5]
ret = rtems_libio_to_fcntl_flags( rtems_libio_iop_flags( iop ) );
1058a8: f000 fa64 bl 105d74 <rtems_libio_to_fcntl_flags>
1058ac: 4683 mov fp, r0
if (ret >= 0) {
1058ae: f1bb 0f00 cmp.w fp, #0
1058b2: f6ff af71 blt.w 105798 <fcntl+0x94> <== ALWAYS TAKEN
1058b6: e7d0 b.n 10585a <fcntl+0x156>
fd2 = va_arg( ap, int );
1058b8: f8d3 a000 ldr.w sl, [r3]
if ( (uint32_t) fd2 >= rtems_libio_number_iops ) {
1058bc: 6813 ldr r3, [r2, #0]
1058be: 459a cmp sl, r3
1058c0: f080 809d bcs.w 1059fe <fcntl+0x2fa> <== ALWAYS TAKEN
return &rtems_libio_iops[ fd ];
1058c4: ea4f 034a mov.w r3, sl, lsl #1
1058c8: eb03 010a add.w r1, r3, sl
1058cc: 9301 str r3, [sp, #4]
1058ce: 0109 lsls r1, r1, #4
1058d0: 1863 adds r3, r4, r1
if (iop != iop2)
1058d2: 4599 cmp r9, r3
1058d4: d07a beq.n 1059cc <fcntl+0x2c8> <== ALWAYS TAKEN
1058d6: 5860 ldr r0, [r4, r1]
if ((rtems_libio_iop_flags( iop2 ) & LIBIO_FLAGS_OPEN) != 0) {
1058d8: 05c2 lsls r2, r0, #23
1058da: d50b bpl.n 1058f4 <fcntl+0x1f0> <== ALWAYS TAKEN
rv = (*iop2->pathinfo.handlers->close_h)( iop2 );
1058dc: 6a18 ldr r0, [r3, #32]
1058de: 9103 str r1, [sp, #12]
1058e0: 9302 str r3, [sp, #8]
1058e2: f8d0 b004 ldr.w fp, [r0, #4]
1058e6: 4618 mov r0, r3
1058e8: 47d8 blx fp
if (rv == 0) {
1058ea: e9dd 3102 ldrd r3, r1, [sp, #8]
1058ee: 4683 mov fp, r0
1058f0: 2800 cmp r0, #0
1058f2: d1dc bne.n 1058ae <fcntl+0x1aa> <== ALWAYS TAKEN
1058f4: 5960 ldr r0, [r4, r5]
RTEMS_COMPILER_MEMORY_BARRIER();
1058f6: e9cd 1302 strd r1, r3, [sp, #8]
oflag = rtems_libio_to_fcntl_flags( rtems_libio_iop_flags( iop ) );
1058fa: f000 fa3b bl 105d74 <rtems_libio_to_fcntl_flags>
1058fe: 4683 mov fp, r0
rtems_libio_iop_flags_set( iop2, rtems_libio_fcntl_flags( oflag ) );
105900: f000 fa22 bl 105d48 <rtems_libio_fcntl_flags>
__asm__ volatile (
105904: f3ef 8c00 mrs ip, CPSR
105908: f04c 0e80 orr.w lr, ip, #128 ; 0x80
10590c: f38e 8900 msr CPSR_fc, lr
*obj = val | arg;
105910: 9902 ldr r1, [sp, #8]
105912: 5863 ldr r3, [r4, r1]
105914: 4318 orrs r0, r3
105916: 5060 str r0, [r4, r1]
__asm__ volatile (
105918: f38c 8900 msr CPSR_fc, ip
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
10591c: f8d9 0024 ldr.w r0, [r9, #36] ; 0x24
(*mt_entry->ops->lock_h)( mt_entry );
105920: 68c2 ldr r2, [r0, #12]
105922: 6812 ldr r2, [r2, #0]
105924: 4790 blx r2
rtems_filesystem_location_clone( &iop2->pathinfo, &iop->pathinfo );
105926: 9902 ldr r1, [sp, #8]
105928: f101 0010 add.w r0, r1, #16
10592c: f105 0110 add.w r1, r5, #16
105930: 4420 add r0, r4
105932: 4421 add r1, r4
105934: f005 fdb8 bl 10b4a8 <rtems_filesystem_location_clone>
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
105938: f8d9 0024 ldr.w r0, [r9, #36] ; 0x24
(*mt_entry->ops->unlock_h)( mt_entry );
10593c: 68c1 ldr r1, [r0, #12]
10593e: 6849 ldr r1, [r1, #4]
105940: 4788 blx r1
rv = (*iop2->pathinfo.handlers->open_h)( iop2, NULL, oflag, 0 );
105942: 9b01 ldr r3, [sp, #4]
105944: 465a mov r2, fp
105946: 4453 add r3, sl
105948: eb04 1103 add.w r1, r4, r3, lsl #4
10594c: 9b03 ldr r3, [sp, #12]
10594e: 4618 mov r0, r3
105950: 6a0b ldr r3, [r1, #32]
105952: f8d3 b000 ldr.w fp, [r3]
105956: 2300 movs r3, #0
105958: 4619 mov r1, r3
10595a: 47d8 blx fp
rv = fd2;
10595c: 2800 cmp r0, #0
10595e: bf14 ite ne
105960: 4683 movne fp, r0
105962: 46d3 moveq fp, sl
105964: e7a3 b.n 1058ae <fcntl+0x1aa>
flags = rtems_libio_fcntl_flags( va_arg( ap, int ) );
105966: 6818 ldr r0, [r3, #0]
105968: f000 f9ee bl 105d48 <rtems_libio_fcntl_flags>
__asm__ volatile (
10596c: f3ef 8200 mrs r2, CPSR
105970: f042 0380 orr.w r3, r2, #128 ; 0x80
105974: f383 8900 msr CPSR_fc, r3
*obj = val & arg;
105978: 5963 ldr r3, [r4, r5]
10597a: f423 7300 bic.w r3, r3, #512 ; 0x200
10597e: f023 0301 bic.w r3, r3, #1
105982: 5163 str r3, [r4, r5]
__asm__ volatile (
105984: f382 8900 msr CPSR_fc, r2
__asm__ volatile (
105988: f3ef 8200 mrs r2, CPSR
10598c: f042 0380 orr.w r3, r2, #128 ; 0x80
105990: f383 8900 msr CPSR_fc, r3
*obj = val | arg;
105994: 5963 ldr r3, [r4, r5]
rtems_libio_iop_flags_set( iop, flags & mask );
105996: f240 2101 movw r1, #513 ; 0x201
10599a: 4008 ands r0, r1
10599c: 4303 orrs r3, r0
10599e: 5163 str r3, [r4, r5]
__asm__ volatile (
1059a0: f382 8900 msr CPSR_fc, r2
int ret = 0;
1059a4: f04f 0b00 mov.w fp, #0
return _Atomic_Fetch_or_uint( &iop->flags, set, ATOMIC_ORDER_RELAXED );
1059a8: e757 b.n 10585a <fcntl+0x156>
__asm__ volatile (
1059aa: f3ef 8200 mrs r2, CPSR
1059ae: f042 0380 orr.w r3, r2, #128 ; 0x80
1059b2: f383 8900 msr CPSR_fc, r3
*obj = val & arg;
1059b6: 5963 ldr r3, [r4, r5]
1059b8: f423 6300 bic.w r3, r3, #2048 ; 0x800
1059bc: 5163 str r3, [r4, r5]
__asm__ volatile (
1059be: f382 8900 msr CPSR_fc, r2
return _Atomic_Fetch_and_uint( &iop->flags, ~clear, ATOMIC_ORDER_RELAXED );
1059c2: e74a b.n 10585a <fcntl+0x156>
rtems_libio_free( diop );
1059c4: 4650 mov r0, sl <== NOT EXECUTED
1059c6: f000 fa05 bl 105dd4 <rtems_libio_free> <== NOT EXECUTED
1059ca: e770 b.n 1058ae <fcntl+0x1aa> <== NOT EXECUTED
int rv = 0;
1059cc: f04f 0b00 mov.w fp, #0 <== NOT EXECUTED
1059d0: e743 b.n 10585a <fcntl+0x156> <== NOT EXECUTED
__asm__ volatile (
1059d2: f3ef 8200 mrs r2, CPSR
1059d6: f042 0380 orr.w r3, r2, #128 ; 0x80
1059da: f383 8900 msr CPSR_fc, r3
*obj = val - arg;
1059de: 5963 ldr r3, [r4, r5]
1059e0: f5a3 5380 sub.w r3, r3, #4096 ; 0x1000
1059e4: 5163 str r3, [r4, r5]
__asm__ volatile (
1059e6: f382 8900 msr CPSR_fc, r2
LIBIO_GET_IOP( fd, iop );
1059ea: f008 fcd1 bl 10e390 <__errno>
1059ee: 2309 movs r3, #9
1059f0: f04f 3bff mov.w fp, #4294967295 ; 0xffffffff
1059f4: 6003 str r3, [r0, #0]
1059f6: e6db b.n 1057b0 <fcntl+0xac>
rv = -1;
1059f8: f04f 3bff mov.w fp, #4294967295 ; 0xffffffff <== NOT EXECUTED
1059fc: e6cc b.n 105798 <fcntl+0x94> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EBADF );
1059fe: f008 fcc7 bl 10e390 <__errno> <== NOT EXECUTED
105a02: 2309 movs r3, #9 <== NOT EXECUTED
105a04: f04f 3bff mov.w fp, #4294967295 ; 0xffffffff <== NOT EXECUTED
105a08: 6003 str r3, [r0, #0] <== NOT EXECUTED
if (ret >= 0) {
105a0a: e6c5 b.n 105798 <fcntl+0x94> <== NOT EXECUTED
001083b0 <fpathconf>:
*/
long fpathconf(
int fd,
int name
)
{
1083b0: b538 push {r3, r4, r5, lr}
long return_value;
rtems_libio_t *iop;
const rtems_filesystem_limits_and_options_t *the_limits;
LIBIO_GET_IOP( fd, iop );
1083b2: f24d 63dc movw r3, #55004 ; 0xd6dc
1083b6: f2c0 0310 movt r3, #16
1083ba: 681b ldr r3, [r3, #0]
1083bc: 4298 cmp r0, r3
1083be: d251 bcs.n 108464 <fpathconf+0xb4>
1083c0: eb00 0040 add.w r0, r0, r0, lsl #1
1083c4: f641 1588 movw r5, #6536 ; 0x1988
1083c8: f2c0 0520 movt r5, #32
1083cc: 0104 lsls r4, r0, #4
__asm__ volatile (
1083ce: f3ef 8200 mrs r2, CPSR
1083d2: f042 0380 orr.w r3, r2, #128 ; 0x80
1083d6: f383 8900 msr CPSR_fc, r3
val = *obj;
1083da: 5963 ldr r3, [r4, r5]
*obj = val + arg;
1083dc: f503 5080 add.w r0, r3, #4096 ; 0x1000
1083e0: 5160 str r0, [r4, r5]
__asm__ volatile (
1083e2: f382 8900 msr CPSR_fc, r2
1083e6: 05db lsls r3, r3, #23
1083e8: d530 bpl.n 10844c <fpathconf+0x9c> <== ALWAYS TAKEN
/*
* Now process the information request.
*/
the_limits = iop->pathinfo.mt_entry->pathconf_limits_and_options;
1083ea: 192b adds r3, r5, r4
1083ec: 6a5b ldr r3, [r3, #36] ; 0x24
1083ee: 6adb ldr r3, [r3, #44] ; 0x2c
switch ( name ) {
1083f0: 290b cmp r1, #11
1083f2: d83f bhi.n 108474 <fpathconf+0xc4>
1083f4: e8df f001 tbb [pc, r1]
1083f8: 1a181614 .word 0x1a181614
1083fc: 22201e1c .word 0x22201e1c
108400: 06282624 .word 0x06282624
break;
case _PC_PRIO_IO:
return_value = the_limits->posix_prio_io;
break;
case _PC_SYNC_IO:
return_value = the_limits->posix_sync_io;
108404: 6a98 ldr r0, [r3, #40] ; 0x28
__asm__ volatile (
108406: f3ef 8200 mrs r2, CPSR
10840a: f042 0380 orr.w r3, r2, #128 ; 0x80
10840e: f383 8900 msr CPSR_fc, r3
*obj = val - arg;
108412: 5963 ldr r3, [r4, r5]
108414: f5a3 5380 sub.w r3, r3, #4096 ; 0x1000
108418: 5163 str r3, [r4, r5]
__asm__ volatile (
10841a: f382 8900 msr CPSR_fc, r2
break;
}
rtems_libio_iop_drop( iop );
return return_value;
}
10841e: bd38 pop {r3, r4, r5, pc}
return_value = the_limits->link_max;
108420: 6818 ldr r0, [r3, #0]
break;
108422: e7f0 b.n 108406 <fpathconf+0x56>
return_value = the_limits->max_canon;
108424: 6858 ldr r0, [r3, #4]
break;
108426: e7ee b.n 108406 <fpathconf+0x56>
return_value = the_limits->max_input;
108428: 6898 ldr r0, [r3, #8]
break;
10842a: e7ec b.n 108406 <fpathconf+0x56>
return_value = the_limits->name_max;
10842c: 68d8 ldr r0, [r3, #12]
break;
10842e: e7ea b.n 108406 <fpathconf+0x56>
return_value = the_limits->path_max;
108430: 6918 ldr r0, [r3, #16]
break;
108432: e7e8 b.n 108406 <fpathconf+0x56>
return_value = the_limits->pipe_buf;
108434: 6958 ldr r0, [r3, #20]
break;
108436: e7e6 b.n 108406 <fpathconf+0x56>
return_value = the_limits->posix_chown_restrictions;
108438: 69d8 ldr r0, [r3, #28]
break;
10843a: e7e4 b.n 108406 <fpathconf+0x56>
return_value = the_limits->posix_no_trunc;
10843c: 6a18 ldr r0, [r3, #32]
break;
10843e: e7e2 b.n 108406 <fpathconf+0x56>
return_value = the_limits->posix_vdisable;
108440: 6ad8 ldr r0, [r3, #44] ; 0x2c
break;
108442: e7e0 b.n 108406 <fpathconf+0x56>
return_value = the_limits->posix_async_io;
108444: 6998 ldr r0, [r3, #24]
break;
108446: e7de b.n 108406 <fpathconf+0x56>
return_value = the_limits->posix_prio_io;
108448: 6a58 ldr r0, [r3, #36] ; 0x24
break;
10844a: e7dc b.n 108406 <fpathconf+0x56>
__asm__ volatile (
10844c: f3ef 8200 mrs r2, CPSR <== NOT EXECUTED
108450: f042 0380 orr.w r3, r2, #128 ; 0x80 <== NOT EXECUTED
108454: f383 8900 msr CPSR_fc, r3 <== NOT EXECUTED
108458: 5963 ldr r3, [r4, r5] <== NOT EXECUTED
10845a: f5a3 5380 sub.w r3, r3, #4096 ; 0x1000 <== NOT EXECUTED
10845e: 5163 str r3, [r4, r5] <== NOT EXECUTED
__asm__ volatile (
108460: f382 8900 msr CPSR_fc, r2 <== NOT EXECUTED
LIBIO_GET_IOP( fd, iop );
108464: f003 fd3e bl 10bee4 <__errno>
108468: 2209 movs r2, #9
10846a: 4603 mov r3, r0
10846c: 601a str r2, [r3, #0]
10846e: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff
}
108472: bd38 pop {r3, r4, r5, pc}
errno = EINVAL;
108474: f003 fd36 bl 10bee4 <__errno>
108478: 2216 movs r2, #22
10847a: 4603 mov r3, r0
10847c: 601a str r2, [r3, #0]
return_value = -1;
10847e: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff
break;
108482: e7c0 b.n 108406 <fpathconf+0x56>
00106290 <fstat>:
int fstat(
int fd,
struct stat *sbuf
)
{
106290: b538 push {r3, r4, r5, lr}
int rv;
/*
* Check to see if we were passed a valid pointer.
*/
if ( !sbuf )
106292: 2900 cmp r1, #0
106294: d04b beq.n 10632e <fstat+0x9e> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EFAULT );
/*
* Now process the stat() request.
*/
LIBIO_GET_IOP( fd, iop );
106296: f647 1230 movw r2, #31024 ; 0x7930
10629a: f2c0 0211 movt r2, #17
10629e: 6812 ldr r2, [r2, #0]
1062a0: 4290 cmp r0, r2
1062a2: d23c bcs.n 10631e <fstat+0x8e>
1062a4: eb00 0040 add.w r0, r0, r0, lsl #1
1062a8: f242 45c0 movw r5, #9408 ; 0x24c0
1062ac: 460b mov r3, r1
1062ae: 0104 lsls r4, r0, #4
1062b0: f2c0 0520 movt r5, #32
__asm__ volatile (
1062b4: f3ef 8100 mrs r1, CPSR
1062b8: f041 0280 orr.w r2, r1, #128 ; 0x80
1062bc: f382 8900 msr CPSR_fc, r2
val = *obj;
1062c0: 5962 ldr r2, [r4, r5]
*obj = val + arg;
1062c2: f502 5080 add.w r0, r2, #4096 ; 0x1000
1062c6: 5160 str r0, [r4, r5]
__asm__ volatile (
1062c8: f381 8900 msr CPSR_fc, r1
1062cc: 05d2 lsls r2, r2, #23
1062ce: d51a bpl.n 106306 <fstat+0x76>
/*
* Zero out the stat structure so the various support
* versions of stat don't have to.
*/
memset( sbuf, 0, sizeof(struct stat) );
1062d0: 2268 movs r2, #104 ; 0x68
1062d2: 2100 movs r1, #0
1062d4: 4618 mov r0, r3
1062d6: f00a fe63 bl 110fa0 <memset>
rv = (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, sbuf );
1062da: 192a adds r2, r5, r4
memset( sbuf, 0, sizeof(struct stat) );
1062dc: 4603 mov r3, r0
rv = (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, sbuf );
1062de: 6a12 ldr r2, [r2, #32]
1062e0: f104 0010 add.w r0, r4, #16
1062e4: 4619 mov r1, r3
1062e6: 4428 add r0, r5
1062e8: 6993 ldr r3, [r2, #24]
1062ea: 4798 blx r3
__asm__ volatile (
1062ec: f3ef 8200 mrs r2, CPSR
1062f0: f042 0380 orr.w r3, r2, #128 ; 0x80
1062f4: f383 8900 msr CPSR_fc, r3
*obj = val - arg;
1062f8: 5963 ldr r3, [r4, r5]
1062fa: f5a3 5380 sub.w r3, r3, #4096 ; 0x1000
1062fe: 5163 str r3, [r4, r5]
__asm__ volatile (
106300: f382 8900 msr CPSR_fc, r2
rtems_libio_iop_drop( iop );
return rv;
}
106304: bd38 pop {r3, r4, r5, pc}
__asm__ volatile (
106306: f3ef 8200 mrs r2, CPSR
10630a: f042 0380 orr.w r3, r2, #128 ; 0x80
10630e: f383 8900 msr CPSR_fc, r3
106312: 5963 ldr r3, [r4, r5]
106314: f5a3 5380 sub.w r3, r3, #4096 ; 0x1000
106318: 5163 str r3, [r4, r5]
__asm__ volatile (
10631a: f382 8900 msr CPSR_fc, r2
LIBIO_GET_IOP( fd, iop );
10631e: f00a fa05 bl 11072c <__errno>
106322: 2209 movs r2, #9
106324: 4603 mov r3, r0
106326: 601a str r2, [r3, #0]
106328: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff
}
10632c: bd38 pop {r3, r4, r5, pc}
rtems_set_errno_and_return_minus_one( EFAULT );
10632e: f00a f9fd bl 11072c <__errno> <== NOT EXECUTED
106332: 220e movs r2, #14 <== NOT EXECUTED
106334: 4603 mov r3, r0 <== NOT EXECUTED
106336: 601a str r2, [r3, #0] <== NOT EXECUTED
106338: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff <== NOT EXECUTED
}
10633c: bd38 pop {r3, r4, r5, pc} <== NOT EXECUTED
10633e: bf00 nop
00105928 <getgroups>:
*/
int getgroups(
int gidsetsize,
gid_t grouplist[]
)
{
105928: e92d 47f0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, lr}
10592c: b0ca sub sp, #296 ; 0x128
10592e: 468a mov sl, r1
105930: 4680 mov r8, r0
char buf[256];
gid_t gid;
const char *user;
struct group *grp;
rv = getpwuid_r(getuid(), &pwd, &buf[0], sizeof(buf), &pwd_res);
105932: f000 f875 bl 105a20 <getuid>
105936: ab02 add r3, sp, #8
105938: aa0a add r2, sp, #40 ; 0x28
10593a: 9300 str r3, [sp, #0]
10593c: a903 add r1, sp, #12
10593e: f44f 7380 mov.w r3, #256 ; 0x100
105942: f000 fff5 bl 106930 <getpwuid_r>
if (rv != 0) {
105946: 4606 mov r6, r0
105948: b118 cbz r0, 105952 <getgroups+0x2a>
if (gidsetsize == 0 || rv <= gidsetsize) {
return rv;
} else {
rtems_set_errno_and_return_minus_one(EINVAL);
}
}
10594a: 4630 mov r0, r6
10594c: b04a add sp, #296 ; 0x128
10594e: e8bd 87f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, pc}
gid = pwd.pw_gid;
105952: f8bd 9016 ldrh.w r9, [sp, #22]
user = pwd.pw_name;
105956: 9d03 ldr r5, [sp, #12]
setgrent();
105958: f7ff ff5e bl 105818 <setgrent>
while ((grp = getgrent()) != NULL) {
10595c: f7ff ff38 bl 1057d0 <getgrent>
105960: b1c0 cbz r0, 105994 <getgroups+0x6c>
if (grp->gr_gid == gid) {
105962: 8907 ldrh r7, [r0, #8]
105964: 454f cmp r7, r9
105966: d0f9 beq.n 10595c <getgroups+0x34>
char **mem = &grp->gr_mem[0];
105968: 68c4 ldr r4, [r0, #12]
while (*mem != NULL) {
10596a: 6820 ldr r0, [r4, #0]
10596c: b920 cbnz r0, 105978 <getgroups+0x50>
10596e: e7f5 b.n 10595c <getgroups+0x34> <== NOT EXECUTED
105970: f854 0f04 ldr.w r0, [r4, #4]!
105974: 2800 cmp r0, #0
105976: d0f1 beq.n 10595c <getgroups+0x34>
if (strcmp(*mem, user) == 0) {
105978: 4629 mov r1, r5
10597a: f037 fd05 bl 13d388 <strcmp>
10597e: 2800 cmp r0, #0
105980: d1f6 bne.n 105970 <getgroups+0x48>
if (rv < gidsetsize) {
105982: 4546 cmp r6, r8
grouplist[rv] = grp->gr_gid;
105984: bfb8 it lt
105986: f82a 7016 strhlt.w r7, [sl, r6, lsl #1]
++rv;
10598a: 3601 adds r6, #1
while ((grp = getgrent()) != NULL) {
10598c: f7ff ff20 bl 1057d0 <getgrent>
105990: 2800 cmp r0, #0
105992: d1e6 bne.n 105962 <getgroups+0x3a>
endgrent();
105994: f7ff ff7a bl 10588c <endgrent>
if (gidsetsize == 0 || rv <= gidsetsize) {
105998: f1b8 0f00 cmp.w r8, #0
10599c: bf18 it ne
10599e: 4546 cmpne r6, r8
1059a0: ddd3 ble.n 10594a <getgroups+0x22>
rtems_set_errno_and_return_minus_one(EINVAL);
1059a2: f02c ff81 bl 1328a8 <__errno>
1059a6: 2316 movs r3, #22
1059a8: f04f 36ff mov.w r6, #4294967295 ; 0xffffffff
1059ac: 6003 str r3, [r0, #0]
1059ae: e7cc b.n 10594a <getgroups+0x22>
00104d7c <getlogin_r>:
if ( !name )
104d7c: b1d8 cbz r0, 104db6 <getlogin_r+0x3a>
if ( namesize < LOGIN_NAME_MAX )
104d7e: 2908 cmp r1, #8
104d80: d90d bls.n 104d9e <getlogin_r+0x22> <== NEVER TAKEN
{
104d82: b510 push {r4, lr} <== NOT EXECUTED
104d84: 4604 mov r4, r0 <== NOT EXECUTED
pw = getpwuid(getuid());
104d86: f000 f83b bl 104e00 <getuid> <== NOT EXECUTED
104d8a: f000 f823 bl 104dd4 <getpwuid> <== NOT EXECUTED
if ( pw )
104d8e: b140 cbz r0, 104da2 <getlogin_r+0x26> <== NOT EXECUTED
pname = pw->pw_name;
104d90: 6801 ldr r1, [r0, #0] <== NOT EXECUTED
strncpy( name, pname, LOGIN_NAME_MAX );
104d92: 2209 movs r2, #9 <== NOT EXECUTED
104d94: 4620 mov r0, r4 <== NOT EXECUTED
104d96: f009 fde1 bl 10e95c <strncpy> <== NOT EXECUTED
104d9a: 2000 movs r0, #0 <== NOT EXECUTED
return 0;
}
104d9c: bd10 pop {r4, pc} <== NOT EXECUTED
return ERANGE;
104d9e: 2022 movs r0, #34 ; 0x22
}
104da0: 4770 bx lr
pname = "";
104da2: f64e 6148 movw r1, #61000 ; 0xee48 <== NOT EXECUTED
strncpy( name, pname, LOGIN_NAME_MAX );
104da6: 2209 movs r2, #9 <== NOT EXECUTED
pname = "";
104da8: f2c0 0110 movt r1, #16 <== NOT EXECUTED
strncpy( name, pname, LOGIN_NAME_MAX );
104dac: 4620 mov r0, r4 <== NOT EXECUTED
104dae: f009 fdd5 bl 10e95c <strncpy> <== NOT EXECUTED
104db2: 2000 movs r0, #0 <== NOT EXECUTED
}
104db4: bd10 pop {r4, pc} <== NOT EXECUTED
return EFAULT;
104db6: 200e movs r0, #14
104db8: 4770 bx lr
104dba: bf00 nop
00106770 <mount>:
const void *data
)
{
int rv = 0;
if (
106770: 2b01 cmp r3, #1
{
106772: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
106776: b097 sub sp, #92 ; 0x5c
if (
106778: f200 80f7 bhi.w 10696a <mount+0x1fa>
options == RTEMS_FILESYSTEM_READ_ONLY
|| options == RTEMS_FILESYSTEM_READ_WRITE
) {
rtems_filesystem_fsmount_me_t fsmount_me_h =
10677c: 4680 mov r8, r0
rtems_filesystem_get_mount_handler( filesystemtype );
10677e: 4610 mov r0, r2
106780: 461d mov r5, r3
106782: 460e mov r6, r1
106784: 4617 mov r7, r2
106786: f000 f90b bl 1069a0 <rtems_filesystem_get_mount_handler>
if ( fsmount_me_h != NULL ) {
10678a: 4681 mov r9, r0
10678c: 2800 cmp r0, #0
10678e: f000 80ec beq.w 10696a <mount+0x1fa>
const char *target = target_or_null != NULL ? target_or_null : "/";
106792: 2e00 cmp r6, #0
106794: f000 8098 beq.w 1068c8 <mount+0x158>
size_t target_size = strlen( target ) + 1;
106798: 4630 mov r0, r6
10679a: 46b3 mov fp, r6
10679c: f00a ff70 bl 111680 <strlen>
1067a0: f100 0a01 add.w sl, r0, #1
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
1067a4: 4638 mov r0, r7
1067a6: f00a ff6b bl 111680 <strlen>
1067aa: 1c42 adds r2, r0, #1
size_t source_size = source_or_null != NULL ?
1067ac: f100 0465 add.w r4, r0, #101 ; 0x65
1067b0: 9200 str r2, [sp, #0]
strlen( source_or_null ) + 1 : 0;
1067b2: f1b8 0f00 cmp.w r8, #0
1067b6: d073 beq.n 1068a0 <mount+0x130>
1067b8: 4640 mov r0, r8
1067ba: f00a ff61 bl 111680 <strlen>
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
1067be: eb04 010a add.w r1, r4, sl
strlen( source_or_null ) + 1 : 0;
1067c2: 1c43 adds r3, r0, #1
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
1067c4: 4419 add r1, r3
1067c6: 2001 movs r0, #1
strlen( source_or_null ) + 1 : 0;
1067c8: 9301 str r3, [sp, #4]
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
1067ca: f7ff fc85 bl 1060d8 <calloc>
if ( mt_entry != NULL ) {
1067ce: 9a00 ldr r2, [sp, #0]
1067d0: 4604 mov r4, r0
1067d2: 2800 cmp r0, #0
1067d4: f000 8094 beq.w 106900 <mount+0x190> <== ALWAYS TAKEN
char *str = (char *) mt_fs_root + sizeof( *mt_fs_root );
1067d8: f100 0364 add.w r3, r0, #100 ; 0x64
memcpy( str, filesystemtype, filesystemtype_size );
1067dc: 4639 mov r1, r7
1067de: 4618 mov r0, r3
str += filesystemtype_size;
1067e0: 189f adds r7, r3, r2
memcpy( str, filesystemtype, filesystemtype_size );
1067e2: f00a e96e blx 110ac0 <memcpy>
memcpy( str, source_or_null, source_size );
1067e6: 9a01 ldr r2, [sp, #4]
1067e8: 4641 mov r1, r8
mt_entry->type = str;
1067ea: 6360 str r0, [r4, #52] ; 0x34
memcpy( str, source_or_null, source_size );
1067ec: 4638 mov r0, r7
str += source_size;
1067ee: eb07 0802 add.w r8, r7, r2
memcpy( str, source_or_null, source_size );
1067f2: f00a e966 blx 110ac0 <memcpy>
mt_entry->dev = str;
1067f6: 63a7 str r7, [r4, #56] ; 0x38
rtems_filesystem_global_location_t *mt_fs_root =
1067f8: f104 0740 add.w r7, r4, #64 ; 0x40
memcpy( str, target, target_size );
1067fc: 4652 mov r2, sl
1067fe: 4659 mov r1, fp
106800: 4640 mov r0, r8
106802: f00a e95e blx 110ac0 <memcpy>
mt_entry->pathconf_limits_and_options = &rtems_filesystem_default_pathconf;
106806: f647 53dc movw r3, #32220 ; 0x7ddc
void *starting_address,
size_t number_nodes,
size_t node_size
)
{
_Chain_Initialize(
10680a: 4639 mov r1, r7
10680c: f2c0 0311 movt r3, #17
mt_entry->mt_fs_root = mt_fs_root;
106810: 6267 str r7, [r4, #36] ; 0x24
mt_entry->mounted = true;
106812: 2701 movs r7, #1
106814: f104 0014 add.w r0, r4, #20
106818: 463a mov r2, r7
filesystemtype,
&target_length
);
if ( mt_entry != NULL ) {
mt_entry->writeable = options == RTEMS_FILESYSTEM_READ_WRITE;
10681a: 403d ands r5, r7
mt_entry->pathconf_limits_and_options = &rtems_filesystem_default_pathconf;
10681c: 62e3 str r3, [r4, #44] ; 0x2c
10681e: 2324 movs r3, #36 ; 0x24
mt_entry->target = str;
106820: f8c4 8030 str.w r8, [r4, #48] ; 0x30
mt_fs_root->location.mt_entry = mt_entry;
106824: 6564 str r4, [r4, #84] ; 0x54
mt_entry->mounted = true;
106826: f884 7028 strb.w r7, [r4, #40] ; 0x28
mt_fs_root->reference_count = 1;
10682a: 65a7 str r7, [r4, #88] ; 0x58
10682c: f002 f9a0 bl 108b70 <_Chain_Initialize>
mt_entry->writeable = options == RTEMS_FILESYSTEM_READ_WRITE;
106830: f884 5029 strb.w r5, [r4, #41] ; 0x29
rv = (*fsmount_me_h)( mt_entry, data );
106834: 4620 mov r0, r4
106836: 9920 ldr r1, [sp, #128] ; 0x80
106838: 47c8 blx r9
if ( rv == 0 ) {
10683a: 4605 mov r5, r0
10683c: bb48 cbnz r0, 106892 <mount+0x122>
if ( target != NULL ) {
10683e: 2e00 cmp r6, #0
106840: d068 beq.n 106914 <mount+0x1a4>
rtems_filesystem_eval_path_start( &ctx, target, eval_flags );
106842: 221f movs r2, #31
106844: 4631 mov r1, r6
106846: a808 add r0, sp, #32
106848: f000 fc5e bl 107108 <rtems_filesystem_eval_path_start>
static inline bool rtems_filesystem_location_is_instance_root(
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
10684c: 6943 ldr r3, [r0, #20]
return (*mt_entry->ops->are_nodes_equal_h)(
10684e: 68da ldr r2, [r3, #12]
106850: 6a59 ldr r1, [r3, #36] ; 0x24
106852: 6913 ldr r3, [r2, #16]
106854: 4798 blx r3
if ( !rtems_filesystem_location_is_instance_root( currentloc ) ) {
106856: 2800 cmp r0, #0
106858: f040 808e bne.w 106978 <mount+0x208>
static inline void rtems_filesystem_eval_path_extract_currentloc(
rtems_filesystem_eval_path_context_t *ctx,
rtems_filesystem_location_info_t *get
)
{
rtems_filesystem_location_copy_and_detach(
10685c: a90e add r1, sp, #56 ; 0x38
10685e: a802 add r0, sp, #8
106860: f000 feb0 bl 1075c4 <rtems_filesystem_location_copy_and_detach>
mt_point_node = rtems_filesystem_location_transform_to_global( &targetloc );
106864: a802 add r0, sp, #8
106866: f000 fee7 bl 107638 <rtems_filesystem_location_transform_to_global>
rv = (*mt_point_node->location.mt_entry->ops->mount_h)( mt_entry );
10686a: 6943 ldr r3, [r0, #20]
mt_point_node = rtems_filesystem_location_transform_to_global( &targetloc );
10686c: 4606 mov r6, r0
mt_entry->mt_point_node = mt_point_node;
10686e: 6220 str r0, [r4, #32]
rv = (*mt_point_node->location.mt_entry->ops->mount_h)( mt_entry );
106870: 4620 mov r0, r4
106872: 68db ldr r3, [r3, #12]
106874: 6adb ldr r3, [r3, #44] ; 0x2c
106876: 4798 blx r3
if ( rv == 0 ) {
106878: 4605 mov r5, r0
10687a: b360 cbz r0, 1068d6 <mount+0x166>
rtems_filesystem_global_location_release( mt_point_node, true );
10687c: 4630 mov r0, r6
10687e: 4639 mov r1, r7
106880: f000 fe54 bl 10752c <rtems_filesystem_global_location_release>
rtems_filesystem_eval_path_cleanup( &ctx );
106884: a808 add r0, sp, #32
106886: f000 fcc3 bl 107210 <rtems_filesystem_eval_path_cleanup>
} else {
rv = register_root_file_system( mt_entry );
}
if ( rv != 0 ) {
(*mt_entry->ops->fsunmount_me_h)( mt_entry );
10688a: 68e3 ldr r3, [r4, #12]
10688c: 4620 mov r0, r4
10688e: 6b5b ldr r3, [r3, #52] ; 0x34
106890: 4798 blx r3
}
}
if ( rv != 0 ) {
free( mt_entry );
106892: 4620 mov r0, r4
106894: f7ff fcb0 bl 1061f8 <free>
errno = EINVAL;
rv = -1;
}
return rv;
}
106898: 4628 mov r0, r5
10689a: b017 add sp, #92 ; 0x5c
10689c: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
1068a0: eb04 010a add.w r1, r4, sl
1068a4: 2001 movs r0, #1
1068a6: f7ff fc17 bl 1060d8 <calloc>
if ( mt_entry != NULL ) {
1068aa: 9a00 ldr r2, [sp, #0]
1068ac: 4604 mov r4, r0
1068ae: b338 cbz r0, 106900 <mount+0x190>
char *str = (char *) mt_fs_root + sizeof( *mt_fs_root );
1068b0: f104 0364 add.w r3, r4, #100 ; 0x64
memcpy( str, filesystemtype, filesystemtype_size );
1068b4: 4639 mov r1, r7
1068b6: 4618 mov r0, r3
str += filesystemtype_size;
1068b8: eb03 0802 add.w r8, r3, r2
rtems_filesystem_global_location_t *mt_fs_root =
1068bc: f104 0740 add.w r7, r4, #64 ; 0x40
memcpy( str, filesystemtype, filesystemtype_size );
1068c0: f00a e8fe blx 110ac0 <memcpy>
mt_entry->type = str;
1068c4: 6360 str r0, [r4, #52] ; 0x34
1068c6: e799 b.n 1067fc <mount+0x8c>
const char *target = target_or_null != NULL ? target_or_null : "/";
1068c8: f247 6b44 movw fp, #30276 ; 0x7644
1068cc: f04f 0a02 mov.w sl, #2
1068d0: f2c0 0b11 movt fp, #17
1068d4: e766 b.n 1067a4 <mount+0x34>
rtems_libio_lock();
1068d6: f7ff fe0f bl 1064f8 <rtems_libio_lock>
old_last = tail->previous;
1068da: f240 131c movw r3, #284 ; 0x11c
1068de: f2c0 0320 movt r3, #32
1068e2: 689a ldr r2, [r3, #8]
the_node->next = tail;
1068e4: 3304 adds r3, #4
tail->previous = the_node;
1068e6: 605c str r4, [r3, #4]
the_node->next = tail;
1068e8: 6023 str r3, [r4, #0]
old_last->next = the_node;
1068ea: 6014 str r4, [r2, #0]
the_node->previous = old_last;
1068ec: 6062 str r2, [r4, #4]
rtems_libio_unlock();
1068ee: f7ff fe09 bl 106504 <rtems_libio_unlock>
rtems_filesystem_eval_path_cleanup( &ctx );
1068f2: a808 add r0, sp, #32
1068f4: f000 fc8c bl 107210 <rtems_filesystem_eval_path_cleanup>
}
1068f8: 4628 mov r0, r5
1068fa: b017 add sp, #92 ; 0x5c
1068fc: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
errno = ENOMEM;
106900: f009 ff14 bl 11072c <__errno> <== NOT EXECUTED
rv = -1;
106904: f04f 35ff mov.w r5, #4294967295 ; 0xffffffff <== NOT EXECUTED
errno = ENOMEM;
106908: 230c movs r3, #12 <== NOT EXECUTED
10690a: 6003 str r3, [r0, #0] <== NOT EXECUTED
}
10690c: 4628 mov r0, r5 <== NOT EXECUTED
10690e: b017 add sp, #92 ; 0x5c <== NOT EXECUTED
106910: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
rtems_libio_lock();
106914: f7ff fdf0 bl 1064f8 <rtems_libio_lock>
return _Chain_Immutable_head( the_chain )->next;
106918: f240 131c movw r3, #284 ; 0x11c
10691c: f2c0 0320 movt r3, #32
if ( rtems_chain_is_empty( &rtems_filesystem_mount_table ) ) {
106920: 461a mov r2, r3
106922: f852 1b04 ldr.w r1, [r2], #4
106926: 4291 cmp r1, r2
106928: d130 bne.n 10698c <mount+0x21c> <== ALWAYS TAKEN
old_last = tail->previous;
10692a: 689a ldr r2, [r3, #8]
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
10692c: f104 0724 add.w r7, r4, #36 ; 0x24
tail->previous = the_node;
106930: 609c str r4, [r3, #8]
the_node->next = tail;
106932: 6021 str r1, [r4, #0]
old_last->next = the_node;
106934: 6014 str r4, [r2, #0]
the_node->previous = old_last;
106936: 6062 str r2, [r4, #4]
rtems_libio_unlock();
106938: f7ff fde4 bl 106504 <rtems_libio_unlock>
10693c: 4638 mov r0, r7
10693e: f000 fdbd bl 1074bc <rtems_filesystem_global_location_obtain>
106942: 4606 mov r6, r0
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
106944: 4638 mov r0, r7
106946: f000 fdb9 bl 1074bc <rtems_filesystem_global_location_obtain>
10694a: 4604 mov r4, r0
&rtems_filesystem_root,
10694c: f000 ff14 bl 107778 <rtems_current_user_env_get>
rtems_filesystem_global_location_assign(
106950: 4631 mov r1, r6
106952: 3004 adds r0, #4
106954: f000 fd32 bl 1073bc <rtems_filesystem_global_location_assign>
&rtems_filesystem_current,
106958: f000 ff0e bl 107778 <rtems_current_user_env_get>
rtems_filesystem_global_location_assign(
10695c: 4621 mov r1, r4
10695e: f000 fd2d bl 1073bc <rtems_filesystem_global_location_assign>
}
106962: 4628 mov r0, r5
106964: b017 add sp, #92 ; 0x5c
106966: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
errno = EINVAL;
10696a: f009 fedf bl 11072c <__errno>
10696e: 2316 movs r3, #22
rv = -1;
106970: f04f 35ff mov.w r5, #4294967295 ; 0xffffffff
errno = EINVAL;
106974: 6003 str r3, [r0, #0]
return rv;
106976: e78f b.n 106898 <mount+0x128>
rtems_filesystem_eval_path_error( &ctx, EBUSY );
106978: a808 add r0, sp, #32
10697a: 2110 movs r1, #16
10697c: f000 fc28 bl 1071d0 <rtems_filesystem_eval_path_error>
rtems_filesystem_eval_path_cleanup( &ctx );
106980: a808 add r0, sp, #32
rv = -1;
106982: f04f 35ff mov.w r5, #4294967295 ; 0xffffffff
rtems_filesystem_eval_path_cleanup( &ctx );
106986: f000 fc43 bl 107210 <rtems_filesystem_eval_path_cleanup>
if ( rv != 0 ) {
10698a: e77e b.n 10688a <mount+0x11a>
errno = EINVAL;
10698c: f009 fece bl 11072c <__errno> <== NOT EXECUTED
106990: 2316 movs r3, #22 <== NOT EXECUTED
rv = -1;
106992: f04f 35ff mov.w r5, #4294967295 ; 0xffffffff <== NOT EXECUTED
errno = EINVAL;
106996: 6003 str r3, [r0, #0] <== NOT EXECUTED
106998: f7ff fdb4 bl 106504 <rtems_libio_unlock> <== NOT EXECUTED
if ( rv != 0 ) {
10699c: e775 b.n 10688a <mount+0x11a> <== NOT EXECUTED
10699e: bf00 nop
00106a00 <newlib_create_hook>:
bool newlib_create_hook(
rtems_tcb *current_task RTEMS_UNUSED,
rtems_tcb *creating_task
)
{
106a00: b538 push {r3, r4, r5, lr}
106a02: 460c mov r4, r1
_REENT_INIT_PTR((creating_task->libc_reent)); /* GCC extension: structure constants */
106a04: f8d4 0158 ldr.w r0, [r4, #344] ; 0x158
106a08: f44f 72ac mov.w r2, #344 ; 0x158
106a0c: 2100 movs r1, #0
106a0e: f00a fac7 bl 110fa0 <memset>
106a12: f8d4 3158 ldr.w r3, [r4, #344] ; 0x158
106a16: f243 0260 movw r2, #12384 ; 0x3060
106a1a: eddf 0b11 vldr d16, [pc, #68] ; 106a60 <newlib_create_hook+0x60>
106a1e: f243 340e movw r4, #13070 ; 0x330e
106a22: f2c0 0220 movt r2, #32
106a26: f6ca 34cd movt r4, #43981 ; 0xabcd
106a2a: f241 2034 movw r0, #4660 ; 0x1234
106a2e: f64d 61ec movw r1, #57068 ; 0xdeec
106a32: f102 0580 add.w r5, r2, #128 ; 0x80
106a36: f2ce 606d movt r0, #58989 ; 0xe66d
106a3a: f2c0 0105 movt r1, #5
106a3e: f8c3 40b0 str.w r4, [r3, #176] ; 0xb0
106a42: 605a str r2, [r3, #4]
106a44: 240b movs r4, #11
106a46: f502 7280 add.w r2, r2, #256 ; 0x100
106a4a: e9c3 012d strd r0, r1, [r3, #180] ; 0xb4
106a4e: 609d str r5, [r3, #8]
return true;
}
106a50: 2001 movs r0, #1
_REENT_INIT_PTR((creating_task->libc_reent)); /* GCC extension: structure constants */
106a52: 60da str r2, [r3, #12]
106a54: f8a3 40bc strh.w r4, [r3, #188] ; 0xbc
106a58: edc3 0b2a vstr d16, [r3, #168] ; 0xa8
}
106a5c: bd38 pop {r3, r4, r5, pc}
106a5e: bf00 nop
106a60: 00000001 .word 0x00000001
106a64: 00000000 .word 0x00000000
00106a70 <open>:
/**
* POSIX 1003.1 5.3.1 - Open a File
*/
int open( const char *path, int oflag, ... )
{
106a70: b40e push {r1, r2, r3}
106a72: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
106a76: b0ac sub sp, #176 ; 0xb0
106a78: ab35 add r3, sp, #212 ; 0xd4
106a7a: 4605 mov r5, r0
106a7c: f853 6b04 ldr.w r6, [r3], #4
mode_t mode = 0;
rtems_libio_t *iop = NULL;
va_start( ap, oflag );
mode = va_arg( ap, mode_t );
106a80: 9f36 ldr r7, [sp, #216] ; 0xd8
106a82: 3304 adds r3, #4
106a84: 9303 str r3, [sp, #12]
iop = rtems_libio_allocate();
106a86: f7ff fccb bl 106420 <rtems_libio_allocate>
if ( iop != NULL ) {
106a8a: 2800 cmp r0, #0
106a8c: f000 80c5 beq.w 106c1a <open+0x1aa>
int follow = (oflag & O_NOFOLLOW) == O_NOFOLLOW ? 0 : RTEMS_FS_FOLLOW_LINK;
106a90: f416 1f80 tst.w r6, #1048576 ; 0x100000
int rwflag = oflag + 1;
106a94: f106 0301 add.w r3, r6, #1
int follow = (oflag & O_NOFOLLOW) == O_NOFOLLOW ? 0 : RTEMS_FS_FOLLOW_LINK;
106a98: bf14 ite ne
106a9a: 2200 movne r2, #0
106a9c: 2218 moveq r2, #24
bool write_access = (rwflag & _FWRITE) == _FWRITE;
106a9e: f003 0802 and.w r8, r3, #2
| (read_access ? RTEMS_FS_PERMS_READ : 0)
106aa2: 07db lsls r3, r3, #31
106aa4: 4604 mov r4, r0
bool exclusive = (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL);
106aa6: f406 6120 and.w r1, r6, #2560 ; 0xa00
bool make = (oflag & O_CREAT) == O_CREAT;
106aaa: f406 7000 and.w r0, r6, #512 ; 0x200
| (read_access ? RTEMS_FS_PERMS_READ : 0)
106aae: bf48 it mi
106ab0: f042 0204 orrmi.w r2, r2, #4
| (write_access ? RTEMS_FS_PERMS_WRITE : 0)
106ab4: f1b8 0f00 cmp.w r8, #0
106ab8: d001 beq.n 106abe <open+0x4e>
106aba: f042 0202 orr.w r2, r2, #2
| (make ? RTEMS_FS_MAKE : 0)
106abe: 2800 cmp r0, #0
106ac0: d17e bne.n 106bc0 <open+0x150>
| (exclusive ? RTEMS_FS_EXCLUSIVE : 0);
106ac2: f5b1 6f20 cmp.w r1, #2560 ; 0xa00
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
106ac6: a804 add r0, sp, #16
int eval_flags = follow
106ac8: bf08 it eq
106aca: f042 0240 orreq.w r2, r2, #64 ; 0x40
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
106ace: 4629 mov r1, r5
106ad0: f000 fb1a bl 107108 <rtems_filesystem_eval_path_start>
return ctx->tokenlen > 0;
106ad4: f8dd a01c ldr.w sl, [sp, #28]
106ad8: f10d 0928 add.w r9, sp, #40 ; 0x28
if ( rtems_filesystem_eval_path_has_token( &ctx ) ) {
106adc: f1ba 0f00 cmp.w sl, #0
106ae0: d171 bne.n 106bc6 <open+0x156>
open_dir = ( oflag & O_DIRECTORY ) == O_DIRECTORY;
106ae2: f406 1a00 and.w sl, r6, #2097152 ; 0x200000
if ( write_access || open_dir ) {
106ae6: ea58 030a orrs.w r3, r8, sl
106aea: d017 beq.n 106b1c <open+0xac>
)
{
struct stat st;
st.st_mode = 0;
(void) ( *loc->handlers->fstat_h )( loc, &st );
106aec: 9b0e ldr r3, [sp, #56] ; 0x38
st.st_mode = 0;
106aee: 2200 movs r2, #0
(void) ( *loc->handlers->fstat_h )( loc, &st );
106af0: a912 add r1, sp, #72 ; 0x48
106af2: 4648 mov r0, r9
st.st_mode = 0;
106af4: 9216 str r2, [sp, #88] ; 0x58
(void) ( *loc->handlers->fstat_h )( loc, &st );
106af6: 699b ldr r3, [r3, #24]
106af8: 4798 blx r3
return st.st_mode;
106afa: 9b16 ldr r3, [sp, #88] ; 0x58
if ( write_access && S_ISDIR( type ) ) {
106afc: f1b8 0f00 cmp.w r8, #0
106b00: d078 beq.n 106bf4 <open+0x184>
106b02: f403 4370 and.w r3, r3, #61440 ; 0xf000
106b06: f5b3 4f80 cmp.w r3, #16384 ; 0x4000
106b0a: f000 8081 beq.w 106c10 <open+0x1a0>
if ( open_dir && !S_ISDIR( type ) ) {
106b0e: f1ba 0f00 cmp.w sl, #0
106b12: d003 beq.n 106b1c <open+0xac> <== NEVER TAKEN
rtems_filesystem_eval_path_error( &ctx, ENOTDIR );
106b14: 2114 movs r1, #20
106b16: a804 add r0, sp, #16
106b18: f000 fb5a bl 1071d0 <rtems_filesystem_eval_path_error>
rtems_filesystem_location_copy_and_detach(
106b1c: 4649 mov r1, r9
106b1e: f104 0010 add.w r0, r4, #16
106b22: f000 fd4f bl 1075c4 <rtems_filesystem_location_copy_and_detach>
rtems_filesystem_eval_path_cleanup( &ctx );
106b26: a804 add r0, sp, #16
106b28: f000 fb72 bl 107210 <rtems_filesystem_eval_path_cleanup>
rtems_libio_iop_flags_set( iop, rtems_libio_fcntl_flags( oflag ) );
106b2c: 4630 mov r0, r6
106b2e: f7ff fc61 bl 1063f4 <rtems_libio_fcntl_flags>
__asm__ volatile (
106b32: f3ef 8200 mrs r2, CPSR
106b36: f042 0380 orr.w r3, r2, #128 ; 0x80
106b3a: f383 8900 msr CPSR_fc, r3
*obj = val | arg;
106b3e: 6823 ldr r3, [r4, #0]
106b40: 4303 orrs r3, r0
106b42: 6023 str r3, [r4, #0]
__asm__ volatile (
106b44: f382 8900 msr CPSR_fc, r2
rv = (*iop->pathinfo.handlers->open_h)( iop, path, oflag, mode );
106b48: 6a22 ldr r2, [r4, #32]
106b4a: 4629 mov r1, r5
106b4c: 463b mov r3, r7
106b4e: 4620 mov r0, r4
106b50: 6815 ldr r5, [r2, #0]
106b52: 4632 mov r2, r6
106b54: 47a8 blx r5
if ( rv == 0 ) {
106b56: 4605 mov r5, r0
106b58: b138 cbz r0, 106b6a <open+0xfa>
if ( rv < 0 ) {
106b5a: 2d00 cmp r5, #0
106b5c: db2c blt.n 106bb8 <open+0x148>
}
va_end( ap );
return rv;
}
106b5e: 4628 mov r0, r5
106b60: b02c add sp, #176 ; 0xb0
106b62: e8bd 4ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
106b66: b003 add sp, #12
106b68: 4770 bx lr
int fd = rtems_libio_iop_to_descriptor( iop );
106b6a: f242 43c0 movw r3, #9408 ; 0x24c0
106b6e: f64a 20ab movw r0, #43691 ; 0xaaab
106b72: f2c0 0320 movt r3, #32
106b76: f6ca 20aa movt r0, #43690 ; 0xaaaa
106b7a: 1ae5 subs r5, r4, r3
106b7c: 112d asrs r5, r5, #4
106b7e: fb00 f505 mul.w r5, r0, r5
__asm__ volatile (
106b82: f3ef 8200 mrs r2, CPSR
106b86: f042 0380 orr.w r3, r2, #128 ; 0x80
106b8a: f383 8900 msr CPSR_fc, r3
106b8e: 6823 ldr r3, [r4, #0]
106b90: f443 7380 orr.w r3, r3, #256 ; 0x100
106b94: 6023 str r3, [r4, #0]
__asm__ volatile (
106b96: f382 8900 msr CPSR_fc, r2
if ( truncate ) {
106b9a: 0573 lsls r3, r6, #21
106b9c: d5dd bpl.n 106b5a <open+0xea>
rv = ftruncate( fd, 0 );
106b9e: 2200 movs r2, #0
106ba0: 2300 movs r3, #0
106ba2: 4628 mov r0, r5
106ba4: f006 ff8e bl 10dac4 <ftruncate>
if ( rv != 0 ) {
106ba8: 2800 cmp r0, #0
106baa: d0d6 beq.n 106b5a <open+0xea>
(*iop->pathinfo.handlers->close_h)( iop );
106bac: 6a23 ldr r3, [r4, #32]
106bae: 4620 mov r0, r4
rv = -1;
106bb0: f04f 35ff mov.w r5, #4294967295 ; 0xffffffff
(*iop->pathinfo.handlers->close_h)( iop );
106bb4: 685b ldr r3, [r3, #4]
106bb6: 4798 blx r3
rtems_libio_free( iop );
106bb8: 4620 mov r0, r4
106bba: f7ff fc4b bl 106454 <rtems_libio_free>
return rv;
106bbe: e7ce b.n 106b5e <open+0xee>
| (make ? RTEMS_FS_MAKE : 0)
106bc0: f042 0220 orr.w r2, r2, #32
106bc4: e77d b.n 106ac2 <open+0x52>
return ctx->token;
106bc6: f8dd b018 ldr.w fp, [sp, #24]
rv = rtems_filesystem_mknod(
106bca: f10d 0928 add.w r9, sp, #40 ; 0x28
106bce: efc0 0010 vmov.i32 d16, #0 ; 0x00000000
106bd2: f447 4300 orr.w r3, r7, #32768 ; 0x8000
106bd6: 4652 mov r2, sl
106bd8: 4648 mov r0, r9
106bda: 4659 mov r1, fp
106bdc: edcd 0b00 vstr d16, [sp]
106be0: f7ff fd74 bl 1066cc <rtems_filesystem_mknod>
if ( rv == 0 ) {
106be4: b978 cbnz r0, 106c06 <open+0x196>
ctx->flags = flags;
106be6: 9008 str r0, [sp, #32]
rtems_filesystem_eval_path_continue( ctx );
106be8: a804 add r0, sp, #16
ctx->pathlen = pathlen;
106bea: e9cd ba04 strd fp, sl, [sp, #16]
106bee: f000 f9f7 bl 106fe0 <rtems_filesystem_eval_path_continue>
106bf2: e776 b.n 106ae2 <open+0x72>
if ( open_dir && !S_ISDIR( type ) ) {
106bf4: f1ba 0f00 cmp.w sl, #0
106bf8: d090 beq.n 106b1c <open+0xac> <== ALWAYS TAKEN
106bfa: f403 4370 and.w r3, r3, #61440 ; 0xf000
106bfe: f5b3 4f80 cmp.w r3, #16384 ; 0x4000
106c02: d08b beq.n 106b1c <open+0xac>
106c04: e786 b.n 106b14 <open+0xa4>
rtems_filesystem_eval_path_error( ctx, 0 );
106c06: 2100 movs r1, #0
106c08: a804 add r0, sp, #16
106c0a: f000 fae1 bl 1071d0 <rtems_filesystem_eval_path_error>
106c0e: e768 b.n 106ae2 <open+0x72>
rtems_filesystem_eval_path_error( &ctx, EISDIR );
106c10: 2115 movs r1, #21
106c12: a804 add r0, sp, #16
106c14: f000 fadc bl 1071d0 <rtems_filesystem_eval_path_error>
if ( open_dir && !S_ISDIR( type ) ) {
106c18: e780 b.n 106b1c <open+0xac>
errno = ENFILE;
106c1a: f009 fd87 bl 11072c <__errno>
106c1e: 2317 movs r3, #23
rv = -1;
106c20: f04f 35ff mov.w r5, #4294967295 ; 0xffffffff
errno = ENFILE;
106c24: 6003 str r3, [r0, #0]
return rv;
106c26: e79a b.n 106b5e <open+0xee>
00106ccc <read.part.0>:
return &rtems_libio_iops[ fd ];
106ccc: eb00 0040 add.w r0, r0, r0, lsl #1
#endif
#if __POSIX_VISIBLE >= 200809 || __XSI_VISIBLE >= 500
ssize_t pread (int __fd, void *__buf, size_t __nbytes, off_t __offset);
ssize_t pwrite (int __fd, const void *__buf, size_t __nbytes, off_t __offset);
#endif
_READ_WRITE_RETURN_TYPE read (int __fd, void *__buf, size_t __nbyte);
106cd0: b570 push {r4, r5, r6, lr}
106cd2: f242 45c0 movw r5, #9408 ; 0x24c0
106cd6: 0104 lsls r4, r0, #4
106cd8: f2c0 0520 movt r5, #32
106cdc: 1960 adds r0, r4, r5
__asm__ volatile (
106cde: f3ef 8c00 mrs ip, CPSR
106ce2: f04c 0380 orr.w r3, ip, #128 ; 0x80
106ce6: f383 8900 msr CPSR_fc, r3
val = *obj;
106cea: 5963 ldr r3, [r4, r5]
*obj = val + arg;
106cec: f503 5680 add.w r6, r3, #4096 ; 0x1000
106cf0: 5166 str r6, [r4, r5]
__asm__ volatile (
106cf2: f38c 8900 msr CPSR_fc, ip
ssize_t n;
rtems_libio_check_buffer( buffer );
rtems_libio_check_count( count );
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_READ, EBADF );
106cf6: f403 7381 and.w r3, r3, #258 ; 0x102
106cfa: f5b3 7f81 cmp.w r3, #258 ; 0x102
106cfe: d10f bne.n 106d20 <read.part.0+0x54> <== ALWAYS TAKEN
/*
* Now process the read().
*/
n = (*iop->pathinfo.handlers->read_h)( iop, buffer, count );
106d00: 6a03 ldr r3, [r0, #32]
106d02: 689b ldr r3, [r3, #8]
106d04: 4798 blx r3
__asm__ volatile (
106d06: f3ef 8200 mrs r2, CPSR
106d0a: f042 0380 orr.w r3, r2, #128 ; 0x80
106d0e: f383 8900 msr CPSR_fc, r3
*obj = val - arg;
106d12: 5963 ldr r3, [r4, r5]
106d14: f5a3 5380 sub.w r3, r3, #4096 ; 0x1000
106d18: 5163 str r3, [r4, r5]
__asm__ volatile (
106d1a: f382 8900 msr CPSR_fc, r2
rtems_libio_iop_drop( iop );
return n;
}
106d1e: bd70 pop {r4, r5, r6, pc}
__asm__ volatile (
106d20: f3ef 8200 mrs r2, CPSR <== NOT EXECUTED
106d24: f042 0380 orr.w r3, r2, #128 ; 0x80 <== NOT EXECUTED
106d28: f383 8900 msr CPSR_fc, r3 <== NOT EXECUTED
106d2c: 5963 ldr r3, [r4, r5] <== NOT EXECUTED
106d2e: f5a3 5380 sub.w r3, r3, #4096 ; 0x1000 <== NOT EXECUTED
106d32: 5163 str r3, [r4, r5] <== NOT EXECUTED
__asm__ volatile (
106d34: f382 8900 msr CPSR_fc, r2 <== NOT EXECUTED
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_READ, EBADF );
106d38: f009 fcf8 bl 11072c <__errno> <== NOT EXECUTED
106d3c: 2209 movs r2, #9 <== NOT EXECUTED
106d3e: 4603 mov r3, r0 <== NOT EXECUTED
106d40: 601a str r2, [r3, #0] <== NOT EXECUTED
106d42: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff <== NOT EXECUTED
}
106d46: bd70 pop {r4, r5, r6, pc} <== NOT EXECUTED
0011727c <realloc>:
return new_ptr;
}
void *realloc( void *ptr, size_t size )
{
11727c: b5f0 push {r4, r5, r6, r7, lr}
Heap_Control *heap;
Heap_Resize_status status;
uintptr_t old_size;
uintptr_t avail_size;
if ( size == 0 ) {
11727e: 460c mov r4, r1
{
117280: b085 sub sp, #20
if ( size == 0 ) {
117282: 2900 cmp r1, #0
117284: d050 beq.n 117328 <realloc+0xac> <== ALWAYS TAKEN
free( ptr );
return NULL;
}
if ( ptr == NULL ) {
117286: 4605 mov r5, r0
117288: 2800 cmp r0, #0
11728a: d047 beq.n 11731c <realloc+0xa0>
return malloc( size );
}
heap = RTEMS_Malloc_Heap;
11728c: f242 7338 movw r3, #10040 ; 0x2738
117290: f2c0 0320 movt r3, #32
117294: 681e ldr r6, [r3, #0]
switch ( _Malloc_System_state() ) {
117296: f7ef f997 bl 1065c8 <_Malloc_System_state>
11729a: b310 cbz r0, 1172e2 <realloc+0x66>
11729c: 2801 cmp r0, #1
11729e: bf18 it ne
1172a0: 2600 movne r6, #0
1172a2: d11b bne.n 1172dc <realloc+0x60> <== ALWAYS TAKEN
_Malloc_Process_deferred_frees();
status = _Heap_Resize_block( heap, ptr, size, &old_size, &avail_size );
_RTEMS_Unlock_allocator();
break;
case MALLOC_SYSTEM_STATE_NO_PROTECTION:
status = _Heap_Resize_block( heap, ptr, size, &old_size, &avail_size );
1172a4: aa03 add r2, sp, #12
1172a6: 4630 mov r0, r6
1172a8: 9200 str r2, [sp, #0]
1172aa: ab02 add r3, sp, #8
1172ac: 4622 mov r2, r4
1172ae: 4629 mov r1, r5
1172b0: f000 f890 bl 1173d4 <_Heap_Resize_block>
1172b4: 4606 mov r6, r0
break;
default:
return NULL;
}
switch ( status ) {
1172b6: b32e cbz r6, 117304 <realloc+0x88>
1172b8: 2e01 cmp r6, #1
1172ba: d127 bne.n 11730c <realloc+0x90>
new_ptr = malloc( new_size );
1172bc: 4620 mov r0, r4
case HEAP_RESIZE_SUCCESSFUL:
return ptr;
case HEAP_RESIZE_UNSATISFIED:
return new_alloc( ptr, size, old_size );
1172be: 9f02 ldr r7, [sp, #8]
new_ptr = malloc( new_size );
1172c0: f7ef f972 bl 1065a8 <malloc>
if ( new_ptr == NULL ) {
1172c4: 4606 mov r6, r0
1172c6: b148 cbz r0, 1172dc <realloc+0x60>
memcpy( new_ptr, old_ptr, ( new_size < old_size ) ? new_size : old_size );
1172c8: 42a7 cmp r7, r4
1172ca: 463a mov r2, r7
1172cc: 4629 mov r1, r5
1172ce: bf28 it cs
1172d0: 4622 movcs r2, r4
1172d2: f7f9 ebf6 blx 110ac0 <memcpy>
free( old_ptr );
1172d6: 4628 mov r0, r5
1172d8: f7ee ff8e bl 1061f8 <free>
default:
errno = EINVAL;
return NULL;
}
}
1172dc: 4630 mov r0, r6
1172de: b005 add sp, #20
1172e0: bdf0 pop {r4, r5, r6, r7, pc}
_RTEMS_Lock_allocator();
1172e2: f7f1 fc1f bl 108b24 <_RTEMS_Lock_allocator>
_Malloc_Process_deferred_frees();
1172e6: f7ee ffaf bl 106248 <_Malloc_Process_deferred_frees>
status = _Heap_Resize_block( heap, ptr, size, &old_size, &avail_size );
1172ea: aa03 add r2, sp, #12
1172ec: 4630 mov r0, r6
1172ee: 9200 str r2, [sp, #0]
1172f0: ab02 add r3, sp, #8
1172f2: 4622 mov r2, r4
1172f4: 4629 mov r1, r5
1172f6: f000 f86d bl 1173d4 <_Heap_Resize_block>
1172fa: 4606 mov r6, r0
_RTEMS_Unlock_allocator();
1172fc: f7f1 fc18 bl 108b30 <_RTEMS_Unlock_allocator>
switch ( status ) {
117300: 2e00 cmp r6, #0
117302: d1d9 bne.n 1172b8 <realloc+0x3c>
117304: 462e mov r6, r5
}
117306: 4630 mov r0, r6
117308: b005 add sp, #20
11730a: bdf0 pop {r4, r5, r6, r7, pc}
errno = EINVAL;
11730c: f7f9 fa0e bl 11072c <__errno>
return NULL;
117310: 2600 movs r6, #0
errno = EINVAL;
117312: 2316 movs r3, #22
117314: 6003 str r3, [r0, #0]
}
117316: 4630 mov r0, r6
117318: b005 add sp, #20
11731a: bdf0 pop {r4, r5, r6, r7, pc}
return malloc( size );
11731c: 4608 mov r0, r1
}
11731e: b005 add sp, #20
117320: e8bd 40f0 ldmia.w sp!, {r4, r5, r6, r7, lr}
return malloc( size );
117324: f7ef b940 b.w 1065a8 <malloc>
return NULL;
117328: 460e mov r6, r1 <== NOT EXECUTED
free( ptr );
11732a: f7ee ff65 bl 1061f8 <free> <== NOT EXECUTED
return NULL;
11732e: e7d5 b.n 1172dc <realloc+0x60> <== NOT EXECUTED
00106d08 <realpath>:
* components. Returns (resolved) on success, or (NULL) on failure,
* in which case the path which caused trouble is left in (resolved).
*/
char *
realpath(const char * __restrict path, char * __restrict resolved)
{
106d08: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
size_t left_len, resolved_len;
unsigned symlinks;
int m, slen;
char left[PATH_MAX], next_token[PATH_MAX], symlink[PATH_MAX];
if (path == NULL) {
106d0c: 4607 mov r7, r0 <== NOT EXECUTED
{
106d0e: f5ad 7d5d sub.w sp, sp, #884 ; 0x374 <== NOT EXECUTED
if (path == NULL) {
106d12: 2800 cmp r0, #0 <== NOT EXECUTED
106d14: f000 814e beq.w 106fb4 <realpath+0x2ac> <== NOT EXECUTED
errno = EINVAL;
return (NULL);
}
if (path[0] == '\0') {
106d18: 7806 ldrb r6, [r0, #0] <== NOT EXECUTED
106d1a: 2e00 cmp r6, #0 <== NOT EXECUTED
106d1c: f000 8137 beq.w 106f8e <realpath+0x286> <== NOT EXECUTED
errno = ENOENT;
return (NULL);
}
if (resolved == NULL) {
106d20: 460d mov r5, r1 <== NOT EXECUTED
106d22: 2900 cmp r1, #0 <== NOT EXECUTED
106d24: f000 8127 beq.w 106f76 <realpath+0x26e> <== NOT EXECUTED
resolved = malloc(PATH_MAX);
if (resolved == NULL)
return (NULL);
m = 1;
} else
m = 0;
106d28: 2300 movs r3, #0 <== NOT EXECUTED
106d2a: 9300 str r3, [sp, #0] <== NOT EXECUTED
symlinks = 0;
if (path[0] == '/') {
106d2c: 2e2f cmp r6, #47 ; 0x2f <== NOT EXECUTED
106d2e: d17d bne.n 106e2c <realpath+0x124> <== NOT EXECUTED
resolved[0] = '/';
resolved[1] = '\0';
if (path[1] == '\0')
106d30: 787b ldrb r3, [r7, #1] <== NOT EXECUTED
resolved[1] = '\0';
106d32: 2400 movs r4, #0 <== NOT EXECUTED
resolved[0] = '/';
106d34: 702e strb r6, [r5, #0] <== NOT EXECUTED
resolved[1] = '\0';
106d36: 706c strb r4, [r5, #1] <== NOT EXECUTED
if (path[1] == '\0')
106d38: 2b00 cmp r3, #0 <== NOT EXECUTED
106d3a: d071 beq.n 106e20 <realpath+0x118> <== NOT EXECUTED
return (resolved);
resolved_len = 1;
left_len = strlcpy(left, path + 1, sizeof(left));
106d3c: f10d 0870 add.w r8, sp, #112 ; 0x70 <== NOT EXECUTED
106d40: 1c79 adds r1, r7, #1 <== NOT EXECUTED
106d42: 22ff movs r2, #255 ; 0xff <== NOT EXECUTED
106d44: 4640 mov r0, r8 <== NOT EXECUTED
106d46: f036 ff81 bl 13dc4c <strlcpy> <== NOT EXECUTED
106d4a: 4623 mov r3, r4 <== NOT EXECUTED
106d4c: 4607 mov r7, r0 <== NOT EXECUTED
resolved_len = 1;
106d4e: 2401 movs r4, #1 <== NOT EXECUTED
return (NULL);
}
resolved_len = strlen(resolved);
left_len = strlcpy(left, path, sizeof(left));
}
if (left_len >= sizeof(left) || resolved_len >= PATH_MAX) {
106d50: 2ffe cmp r7, #254 ; 0xfe <== NOT EXECUTED
106d52: bf88 it hi <== NOT EXECUTED
106d54: f043 0301 orrhi.w r3, r3, #1 <== NOT EXECUTED
106d58: 2b00 cmp r3, #0 <== NOT EXECUTED
106d5a: f040 8100 bne.w 106f5e <realpath+0x256> <== NOT EXECUTED
}
/*
* Iterate over path components in `left'.
*/
while (left_len != 0) {
106d5e: 2f00 cmp r7, #0 <== NOT EXECUTED
106d60: d054 beq.n 106e0c <realpath+0x104> <== NOT EXECUTED
/*
* Extract the next path component and adjust `left'
* and its length.
*/
p = strchr(left, '/');
106d62: f04f 0a2f mov.w sl, #47 ; 0x2f <== NOT EXECUTED
free(resolved);
errno = ENAMETOOLONG;
return (NULL);
}
memcpy(next_token, left, s - left);
next_token[s - left] = '\0';
106d66: 4699 mov r9, r3 <== NOT EXECUTED
symlinks = 0;
106d68: 9301 str r3, [sp, #4] <== NOT EXECUTED
p = strchr(left, '/');
106d6a: 212f movs r1, #47 ; 0x2f <== NOT EXECUTED
106d6c: 4640 mov r0, r8 <== NOT EXECUTED
106d6e: f036 fa95 bl 13d29c <strchr> <== NOT EXECUTED
s = p ? p : left + left_len;
106d72: 4606 mov r6, r0 <== NOT EXECUTED
106d74: 2800 cmp r0, #0 <== NOT EXECUTED
106d76: f000 808d beq.w 106e94 <realpath+0x18c> <== NOT EXECUTED
if (s - left >= sizeof(next_token)) {
106d7a: eba0 0b08 sub.w fp, r0, r8 <== NOT EXECUTED
106d7e: f1bb 0ffe cmp.w fp, #254 ; 0xfe <== NOT EXECUTED
106d82: f200 80ec bhi.w 106f5e <realpath+0x256> <== NOT EXECUTED
memcpy(next_token, left, s - left);
106d86: 465a mov r2, fp <== NOT EXECUTED
106d88: 4641 mov r1, r8 <== NOT EXECUTED
106d8a: a85c add r0, sp, #368 ; 0x170 <== NOT EXECUTED
left_len -= s - left;
106d8c: eba7 070b sub.w r7, r7, fp <== NOT EXECUTED
memcpy(next_token, left, s - left);
106d90: f02f e976 blx 136080 <memcpy> <== NOT EXECUTED
next_token[s - left] = '\0';
106d94: ab5c add r3, sp, #368 ; 0x170 <== NOT EXECUTED
if (p != NULL)
memmove(left, s + 1, left_len + 1);
106d96: 1c7a adds r2, r7, #1 <== NOT EXECUTED
106d98: 1c71 adds r1, r6, #1 <== NOT EXECUTED
106d9a: 4640 mov r0, r8 <== NOT EXECUTED
next_token[s - left] = '\0';
106d9c: f803 900b strb.w r9, [r3, fp] <== NOT EXECUTED
memmove(left, s + 1, left_len + 1);
106da0: f02f fbde bl 136560 <memmove> <== NOT EXECUTED
if (resolved[resolved_len - 1] != '/') {
106da4: 192b adds r3, r5, r4 <== NOT EXECUTED
106da6: f813 3c01 ldrb.w r3, [r3, #-1] <== NOT EXECUTED
106daa: 2b2f cmp r3, #47 ; 0x2f <== NOT EXECUTED
106dac: d008 beq.n 106dc0 <realpath+0xb8> <== NOT EXECUTED
if (resolved_len + 1 >= PATH_MAX) {
106dae: 1c63 adds r3, r4, #1 <== NOT EXECUTED
106db0: 2bfe cmp r3, #254 ; 0xfe <== NOT EXECUTED
106db2: f200 80d4 bhi.w 106f5e <realpath+0x256> <== NOT EXECUTED
if (m)
free(resolved);
errno = ENAMETOOLONG;
return (NULL);
}
resolved[resolved_len++] = '/';
106db6: f805 a004 strb.w sl, [r5, r4] <== NOT EXECUTED
resolved[resolved_len] = '\0';
106dba: 461c mov r4, r3 <== NOT EXECUTED
106dbc: f805 9003 strb.w r9, [r5, r3] <== NOT EXECUTED
}
if (next_token[0] == '\0') {
106dc0: f89d b170 ldrb.w fp, [sp, #368] ; 0x170 <== NOT EXECUTED
106dc4: f1bb 0f00 cmp.w fp, #0 <== NOT EXECUTED
106dc8: d049 beq.n 106e5e <realpath+0x156> <== NOT EXECUTED
errno = ENOTDIR;
return (NULL);
}
continue;
}
else if (strcmp(next_token, ".") == 0)
106dca: f8bd 3170 ldrh.w r3, [sp, #368] ; 0x170 <== NOT EXECUTED
106dce: 2b2e cmp r3, #46 ; 0x2e <== NOT EXECUTED
106dd0: d01a beq.n 106e08 <realpath+0x100> <== NOT EXECUTED
continue;
else if (strcmp(next_token, "..") == 0) {
106dd2: f642 622e movw r2, #11822 ; 0x2e2e <== NOT EXECUTED
106dd6: 4293 cmp r3, r2 <== NOT EXECUTED
106dd8: d067 beq.n 106eaa <realpath+0x1a2> <== NOT EXECUTED
}
/*
* Append the next path component and lstat() it.
*/
resolved_len = strlcat(resolved, next_token, PATH_MAX);
106dda: 22ff movs r2, #255 ; 0xff <== NOT EXECUTED
106ddc: a95c add r1, sp, #368 ; 0x170 <== NOT EXECUTED
106dde: 4628 mov r0, r5 <== NOT EXECUTED
106de0: f036 ff02 bl 13dbe8 <strlcat> <== NOT EXECUTED
if (resolved_len >= PATH_MAX) {
106de4: 28fe cmp r0, #254 ; 0xfe <== NOT EXECUTED
resolved_len = strlcat(resolved, next_token, PATH_MAX);
106de6: 4604 mov r4, r0 <== NOT EXECUTED
if (resolved_len >= PATH_MAX) {
106de8: f200 80b9 bhi.w 106f5e <realpath+0x256> <== NOT EXECUTED
if (m)
free(resolved);
errno = ENAMETOOLONG;
return (NULL);
}
if (lstat(resolved, &sb) != 0) {
106dec: 4628 mov r0, r5 <== NOT EXECUTED
106dee: a902 add r1, sp, #8 <== NOT EXECUTED
106df0: f7fe ff90 bl 105d14 <lstat> <== NOT EXECUTED
106df4: 4683 mov fp, r0 <== NOT EXECUTED
106df6: 2800 cmp r0, #0 <== NOT EXECUTED
106df8: f040 80e2 bne.w 106fc0 <realpath+0x2b8> <== NOT EXECUTED
if (m)
free(resolved);
return (NULL);
}
if (S_ISLNK(sb.st_mode)) {
106dfc: 9b06 ldr r3, [sp, #24] <== NOT EXECUTED
106dfe: f403 4370 and.w r3, r3, #61440 ; 0xf000 <== NOT EXECUTED
106e02: f5b3 4f20 cmp.w r3, #40960 ; 0xa000 <== NOT EXECUTED
106e06: d064 beq.n 106ed2 <realpath+0x1ca> <== NOT EXECUTED
while (left_len != 0) {
106e08: 2f00 cmp r7, #0 <== NOT EXECUTED
106e0a: d1ae bne.n 106d6a <realpath+0x62> <== NOT EXECUTED
/*
* Remove trailing slash except when the resolved pathname
* is a single "/".
*/
if (resolved_len > 1 && resolved[resolved_len - 1] == '/')
106e0c: 2c01 cmp r4, #1 <== NOT EXECUTED
106e0e: d907 bls.n 106e20 <realpath+0x118> <== NOT EXECUTED
106e10: 3c01 subs r4, #1 <== NOT EXECUTED
106e12: 5d2b ldrb r3, [r5, r4] <== NOT EXECUTED
106e14: 2b2f cmp r3, #47 ; 0x2f <== NOT EXECUTED
resolved[resolved_len - 1] = '\0';
106e16: bf02 ittt eq <== NOT EXECUTED
106e18: 2300 moveq r3, #0 <== NOT EXECUTED
106e1a: 462e moveq r6, r5 <== NOT EXECUTED
106e1c: 552b strbeq r3, [r5, r4] <== NOT EXECUTED
if (resolved_len > 1 && resolved[resolved_len - 1] == '/')
106e1e: d034 beq.n 106e8a <realpath+0x182> <== NOT EXECUTED
106e20: 462e mov r6, r5 <== NOT EXECUTED
return (resolved);
}
106e22: 4630 mov r0, r6 <== NOT EXECUTED
106e24: f50d 7d5d add.w sp, sp, #884 ; 0x374 <== NOT EXECUTED
106e28: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
if (getcwd(resolved, PATH_MAX) == NULL) {
106e2c: 21ff movs r1, #255 ; 0xff <== NOT EXECUTED
106e2e: 4628 mov r0, r5 <== NOT EXECUTED
106e30: f02d ff0e bl 134c50 <getcwd> <== NOT EXECUTED
106e34: 4606 mov r6, r0 <== NOT EXECUTED
106e36: 2800 cmp r0, #0 <== NOT EXECUTED
106e38: f000 80ae beq.w 106f98 <realpath+0x290> <== NOT EXECUTED
resolved_len = strlen(resolved);
106e3c: 4628 mov r0, r5 <== NOT EXECUTED
left_len = strlcpy(left, path, sizeof(left));
106e3e: f10d 0870 add.w r8, sp, #112 ; 0x70 <== NOT EXECUTED
resolved_len = strlen(resolved);
106e42: f036 ff3d bl 13dcc0 <strlen> <== NOT EXECUTED
left_len = strlcpy(left, path, sizeof(left));
106e46: 4639 mov r1, r7 <== NOT EXECUTED
resolved_len = strlen(resolved);
106e48: 4604 mov r4, r0 <== NOT EXECUTED
left_len = strlcpy(left, path, sizeof(left));
106e4a: 22ff movs r2, #255 ; 0xff <== NOT EXECUTED
106e4c: 4640 mov r0, r8 <== NOT EXECUTED
106e4e: f036 fefd bl 13dc4c <strlcpy> <== NOT EXECUTED
if (left_len >= sizeof(left) || resolved_len >= PATH_MAX) {
106e52: 2cfe cmp r4, #254 ; 0xfe <== NOT EXECUTED
left_len = strlcpy(left, path, sizeof(left));
106e54: 4607 mov r7, r0 <== NOT EXECUTED
if (left_len >= sizeof(left) || resolved_len >= PATH_MAX) {
106e56: bf94 ite ls <== NOT EXECUTED
106e58: 2300 movls r3, #0 <== NOT EXECUTED
106e5a: 2301 movhi r3, #1 <== NOT EXECUTED
106e5c: e778 b.n 106d50 <realpath+0x48> <== NOT EXECUTED
if (lstat(resolved, &sb) != 0) {
106e5e: 4628 mov r0, r5 <== NOT EXECUTED
106e60: a902 add r1, sp, #8 <== NOT EXECUTED
106e62: f7fe ff57 bl 105d14 <lstat> <== NOT EXECUTED
106e66: 2800 cmp r0, #0 <== NOT EXECUTED
106e68: f040 80ae bne.w 106fc8 <realpath+0x2c0> <== NOT EXECUTED
if (!S_ISDIR(sb.st_mode)) {
106e6c: 9b06 ldr r3, [sp, #24] <== NOT EXECUTED
106e6e: f403 4370 and.w r3, r3, #61440 ; 0xf000 <== NOT EXECUTED
106e72: f5b3 4f80 cmp.w r3, #16384 ; 0x4000 <== NOT EXECUTED
106e76: d0c7 beq.n 106e08 <realpath+0x100> <== NOT EXECUTED
if (m)
106e78: 9b00 ldr r3, [sp, #0] <== NOT EXECUTED
106e7a: 2b00 cmp r3, #0 <== NOT EXECUTED
106e7c: f040 8083 bne.w 106f86 <realpath+0x27e> <== NOT EXECUTED
return (NULL);
106e80: 2600 movs r6, #0 <== NOT EXECUTED
errno = ENOTDIR;
106e82: f02b fd11 bl 1328a8 <__errno> <== NOT EXECUTED
106e86: 2314 movs r3, #20 <== NOT EXECUTED
106e88: 6003 str r3, [r0, #0] <== NOT EXECUTED
}
106e8a: 4630 mov r0, r6 <== NOT EXECUTED
106e8c: f50d 7d5d add.w sp, sp, #884 ; 0x374 <== NOT EXECUTED
106e90: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
if (s - left >= sizeof(next_token)) {
106e94: 2ffe cmp r7, #254 ; 0xfe <== NOT EXECUTED
106e96: d862 bhi.n 106f5e <realpath+0x256> <== NOT EXECUTED
memcpy(next_token, left, s - left);
106e98: 463a mov r2, r7 <== NOT EXECUTED
106e9a: 4641 mov r1, r8 <== NOT EXECUTED
106e9c: a85c add r0, sp, #368 ; 0x170 <== NOT EXECUTED
106e9e: f02f e8f0 blx 136080 <memcpy> <== NOT EXECUTED
next_token[s - left] = '\0';
106ea2: ab5c add r3, sp, #368 ; 0x170 <== NOT EXECUTED
106ea4: 55de strb r6, [r3, r7] <== NOT EXECUTED
left_len -= s - left;
106ea6: 4637 mov r7, r6 <== NOT EXECUTED
106ea8: e77c b.n 106da4 <realpath+0x9c> <== NOT EXECUTED
else if (strcmp(next_token, "..") == 0) {
106eaa: f89d 3172 ldrb.w r3, [sp, #370] ; 0x172 <== NOT EXECUTED
106eae: 2b00 cmp r3, #0 <== NOT EXECUTED
106eb0: d193 bne.n 106dda <realpath+0xd2> <== NOT EXECUTED
if (resolved_len > 1) {
106eb2: 2c01 cmp r4, #1 <== NOT EXECUTED
106eb4: d9a8 bls.n 106e08 <realpath+0x100> <== NOT EXECUTED
resolved[resolved_len - 1] = '\0';
106eb6: 442c add r4, r5 <== NOT EXECUTED
q = strrchr(resolved, '/') + 1;
106eb8: 212f movs r1, #47 ; 0x2f <== NOT EXECUTED
resolved[resolved_len - 1] = '\0';
106eba: f804 9c01 strb.w r9, [r4, #-1] <== NOT EXECUTED
q = strrchr(resolved, '/') + 1;
106ebe: 4628 mov r0, r5 <== NOT EXECUTED
106ec0: f037 fda2 bl 13ea08 <strrchr> <== NOT EXECUTED
*q = '\0';
106ec4: f800 9f01 strb.w r9, [r0, #1]! <== NOT EXECUTED
resolved_len = q - resolved;
106ec8: 1b44 subs r4, r0, r5 <== NOT EXECUTED
while (left_len != 0) {
106eca: 2f00 cmp r7, #0 <== NOT EXECUTED
106ecc: f47f af4d bne.w 106d6a <realpath+0x62> <== NOT EXECUTED
106ed0: e79c b.n 106e0c <realpath+0x104> <== NOT EXECUTED
if (symlinks++ > MAXSYMLINKS) {
106ed2: 9b01 ldr r3, [sp, #4] <== NOT EXECUTED
106ed4: 2b20 cmp r3, #32 <== NOT EXECUTED
106ed6: f103 0701 add.w r7, r3, #1 <== NOT EXECUTED
106eda: d87d bhi.n 106fd8 <realpath+0x2d0> <== NOT EXECUTED
slen = readlink(resolved, symlink, sizeof(symlink) - 1);
106edc: 22fe movs r2, #254 ; 0xfe <== NOT EXECUTED
106ede: a99c add r1, sp, #624 ; 0x270 <== NOT EXECUTED
106ee0: 4628 mov r0, r5 <== NOT EXECUTED
106ee2: f7ff fe87 bl 106bf4 <readlink> <== NOT EXECUTED
if (slen < 0) {
106ee6: 1e03 subs r3, r0, #0 <== NOT EXECUTED
106ee8: db6e blt.n 106fc8 <realpath+0x2c0> <== NOT EXECUTED
symlink[slen] = '\0';
106eea: aa9c add r2, sp, #624 ; 0x270 <== NOT EXECUTED
106eec: f802 b003 strb.w fp, [r2, r3] <== NOT EXECUTED
if (symlink[0] == '/') {
106ef0: f89d 2270 ldrb.w r2, [sp, #624] ; 0x270 <== NOT EXECUTED
106ef4: 2a2f cmp r2, #47 ; 0x2f <== NOT EXECUTED
resolved_len = 1;
106ef6: bf04 itt eq <== NOT EXECUTED
106ef8: 2401 moveq r4, #1 <== NOT EXECUTED
resolved[1] = 0;
106efa: f885 b001 strbeq.w fp, [r5, #1] <== NOT EXECUTED
if (symlink[0] == '/') {
106efe: d00d beq.n 106f1c <realpath+0x214> <== NOT EXECUTED
} else if (resolved_len > 1) {
106f00: 2c01 cmp r4, #1 <== NOT EXECUTED
106f02: d90b bls.n 106f1c <realpath+0x214> <== NOT EXECUTED
resolved[resolved_len - 1] = '\0';
106f04: 442c add r4, r5 <== NOT EXECUTED
q = strrchr(resolved, '/') + 1;
106f06: 212f movs r1, #47 ; 0x2f <== NOT EXECUTED
resolved[resolved_len - 1] = '\0';
106f08: f804 bc01 strb.w fp, [r4, #-1] <== NOT EXECUTED
q = strrchr(resolved, '/') + 1;
106f0c: 4628 mov r0, r5 <== NOT EXECUTED
106f0e: 9301 str r3, [sp, #4] <== NOT EXECUTED
106f10: f037 fd7a bl 13ea08 <strrchr> <== NOT EXECUTED
resolved_len = q - resolved;
106f14: 9b01 ldr r3, [sp, #4] <== NOT EXECUTED
*q = '\0';
106f16: f800 bf01 strb.w fp, [r0, #1]! <== NOT EXECUTED
resolved_len = q - resolved;
106f1a: 1b44 subs r4, r0, r5 <== NOT EXECUTED
if (p != NULL) {
106f1c: b1a6 cbz r6, 106f48 <realpath+0x240> <== NOT EXECUTED
if (symlink[slen - 1] != '/') {
106f1e: aa9c add r2, sp, #624 ; 0x270 <== NOT EXECUTED
106f20: 441a add r2, r3 <== NOT EXECUTED
106f22: f812 2c01 ldrb.w r2, [r2, #-1] <== NOT EXECUTED
106f26: 2a2f cmp r2, #47 ; 0x2f <== NOT EXECUTED
106f28: d007 beq.n 106f3a <realpath+0x232> <== NOT EXECUTED
if (slen + 1 >= sizeof(symlink)) {
106f2a: 1c5a adds r2, r3, #1 <== NOT EXECUTED
106f2c: 2afe cmp r2, #254 ; 0xfe <== NOT EXECUTED
106f2e: dc16 bgt.n 106f5e <realpath+0x256> <== NOT EXECUTED
symlink[slen] = '/';
106f30: a99c add r1, sp, #624 ; 0x270 <== NOT EXECUTED
106f32: f801 a003 strb.w sl, [r1, r3] <== NOT EXECUTED
symlink[slen + 1] = 0;
106f36: f801 9002 strb.w r9, [r1, r2] <== NOT EXECUTED
left_len = strlcat(symlink, left,
106f3a: 22ff movs r2, #255 ; 0xff <== NOT EXECUTED
106f3c: 4641 mov r1, r8 <== NOT EXECUTED
106f3e: a89c add r0, sp, #624 ; 0x270 <== NOT EXECUTED
106f40: f036 fe52 bl 13dbe8 <strlcat> <== NOT EXECUTED
if (left_len >= sizeof(left)) {
106f44: 28fe cmp r0, #254 ; 0xfe <== NOT EXECUTED
106f46: d80a bhi.n 106f5e <realpath+0x256> <== NOT EXECUTED
left_len = strlcpy(left, symlink, sizeof(left));
106f48: a99c add r1, sp, #624 ; 0x270 <== NOT EXECUTED
106f4a: 22ff movs r2, #255 ; 0xff <== NOT EXECUTED
106f4c: 4640 mov r0, r8 <== NOT EXECUTED
if (symlinks++ > MAXSYMLINKS) {
106f4e: 9701 str r7, [sp, #4] <== NOT EXECUTED
left_len = strlcpy(left, symlink, sizeof(left));
106f50: f036 fe7c bl 13dc4c <strlcpy> <== NOT EXECUTED
106f54: 4607 mov r7, r0 <== NOT EXECUTED
while (left_len != 0) {
106f56: 2f00 cmp r7, #0 <== NOT EXECUTED
106f58: f47f af07 bne.w 106d6a <realpath+0x62> <== NOT EXECUTED
106f5c: e756 b.n 106e0c <realpath+0x104> <== NOT EXECUTED
if (m)
106f5e: 9b00 ldr r3, [sp, #0] <== NOT EXECUTED
106f60: bb03 cbnz r3, 106fa4 <realpath+0x29c> <== NOT EXECUTED
errno = ENAMETOOLONG;
106f62: f02b fca1 bl 1328a8 <__errno> <== NOT EXECUTED
return (NULL);
106f66: 2600 movs r6, #0 <== NOT EXECUTED
errno = ENAMETOOLONG;
106f68: 235b movs r3, #91 ; 0x5b <== NOT EXECUTED
106f6a: 6003 str r3, [r0, #0] <== NOT EXECUTED
}
106f6c: 4630 mov r0, r6 <== NOT EXECUTED
106f6e: f50d 7d5d add.w sp, sp, #884 ; 0x374 <== NOT EXECUTED
106f72: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
resolved = malloc(PATH_MAX);
106f76: 20ff movs r0, #255 ; 0xff <== NOT EXECUTED
106f78: f7fe fee6 bl 105d48 <malloc> <== NOT EXECUTED
if (resolved == NULL)
106f7c: 4605 mov r5, r0 <== NOT EXECUTED
106f7e: b308 cbz r0, 106fc4 <realpath+0x2bc> <== NOT EXECUTED
m = 1;
106f80: 2301 movs r3, #1 <== NOT EXECUTED
106f82: 9300 str r3, [sp, #0] <== NOT EXECUTED
106f84: e6d2 b.n 106d2c <realpath+0x24> <== NOT EXECUTED
free(resolved);
106f86: 4628 mov r0, r5 <== NOT EXECUTED
106f88: f7fe fa7a bl 105480 <free> <== NOT EXECUTED
106f8c: e778 b.n 106e80 <realpath+0x178> <== NOT EXECUTED
errno = ENOENT;
106f8e: f02b fc8b bl 1328a8 <__errno> <== NOT EXECUTED
106f92: 2302 movs r3, #2 <== NOT EXECUTED
106f94: 6003 str r3, [r0, #0] <== NOT EXECUTED
return (NULL);
106f96: e778 b.n 106e8a <realpath+0x182> <== NOT EXECUTED
if (m)
106f98: 9b00 ldr r3, [sp, #0] <== NOT EXECUTED
106f9a: b93b cbnz r3, 106fac <realpath+0x2a4> <== NOT EXECUTED
resolved[0] = '.';
106f9c: 232e movs r3, #46 ; 0x2e <== NOT EXECUTED
resolved[1] = '\0';
106f9e: 7068 strb r0, [r5, #1] <== NOT EXECUTED
resolved[0] = '.';
106fa0: 702b strb r3, [r5, #0] <== NOT EXECUTED
resolved[1] = '\0';
106fa2: e772 b.n 106e8a <realpath+0x182> <== NOT EXECUTED
free(resolved);
106fa4: 4628 mov r0, r5 <== NOT EXECUTED
106fa6: f7fe fa6b bl 105480 <free> <== NOT EXECUTED
106faa: e7da b.n 106f62 <realpath+0x25a> <== NOT EXECUTED
free(resolved);
106fac: 4628 mov r0, r5 <== NOT EXECUTED
106fae: f7fe fa67 bl 105480 <free> <== NOT EXECUTED
106fb2: e76a b.n 106e8a <realpath+0x182> <== NOT EXECUTED
errno = EINVAL;
106fb4: f02b fc78 bl 1328a8 <__errno> <== NOT EXECUTED
106fb8: 2316 movs r3, #22 <== NOT EXECUTED
return (NULL);
106fba: 463e mov r6, r7 <== NOT EXECUTED
errno = EINVAL;
106fbc: 6003 str r3, [r0, #0] <== NOT EXECUTED
return (NULL);
106fbe: e764 b.n 106e8a <realpath+0x182> <== NOT EXECUTED
if (m)
106fc0: 9b00 ldr r3, [sp, #0] <== NOT EXECUTED
106fc2: b923 cbnz r3, 106fce <realpath+0x2c6> <== NOT EXECUTED
return (NULL);
106fc4: 2600 movs r6, #0 <== NOT EXECUTED
106fc6: e760 b.n 106e8a <realpath+0x182> <== NOT EXECUTED
if (m)
106fc8: 9a00 ldr r2, [sp, #0] <== NOT EXECUTED
106fca: 2a00 cmp r2, #0 <== NOT EXECUTED
106fcc: d0fa beq.n 106fc4 <realpath+0x2bc> <== NOT EXECUTED
free(resolved);
106fce: 4628 mov r0, r5 <== NOT EXECUTED
return (NULL);
106fd0: 2600 movs r6, #0 <== NOT EXECUTED
free(resolved);
106fd2: f7fe fa55 bl 105480 <free> <== NOT EXECUTED
106fd6: e758 b.n 106e8a <realpath+0x182> <== NOT EXECUTED
if (m)
106fd8: 9b00 ldr r3, [sp, #0] <== NOT EXECUTED
106fda: b92b cbnz r3, 106fe8 <realpath+0x2e0> <== NOT EXECUTED
errno = ELOOP;
106fdc: f02b fc64 bl 1328a8 <__errno> <== NOT EXECUTED
106fe0: 235c movs r3, #92 ; 0x5c <== NOT EXECUTED
return (NULL);
106fe2: 2600 movs r6, #0 <== NOT EXECUTED
errno = ELOOP;
106fe4: 6003 str r3, [r0, #0] <== NOT EXECUTED
return (NULL);
106fe6: e750 b.n 106e8a <realpath+0x182> <== NOT EXECUTED
free(resolved);
106fe8: 4628 mov r0, r5 <== NOT EXECUTED
106fea: f7fe fa49 bl 105480 <free> <== NOT EXECUTED
106fee: e7f5 b.n 106fdc <realpath+0x2d4> <== NOT EXECUTED
00111bf4 <rtems_assoc_32_to_string>:
const rtems_assoc_32_pair *pairs,
size_t pair_count,
const char *separator,
const char *fallback
)
{
111bf4: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
111bf8: b083 sub sp, #12
111bfa: 4616 mov r6, r2
111bfc: f8dd 8030 ldr.w r8, [sp, #48] ; 0x30
size_t len;
size_t i;
len = 0;
for ( i = 0; i < pair_count ; ++i ) {
111c00: f04f 0b00 mov.w fp, #0
{
111c04: 4689 mov r9, r1
111c06: e9dd a20d ldrd sl, r2, [sp, #52] ; 0x34
111c0a: 4607 mov r7, r0
111c0c: 1d1c adds r4, r3, #4
len = 0;
111c0e: 465d mov r5, fp
{
111c10: 9201 str r2, [sp, #4]
for ( i = 0; i < pair_count ; ++i ) {
111c12: f1b8 0f00 cmp.w r8, #0
111c16: d023 beq.n 111c60 <rtems_assoc_32_to_string+0x6c> <== ALWAYS TAKEN
const rtems_assoc_32_pair *p;
p = &pairs[ i ];
if ( ( value & p->bits ) != 0 ) {
111c18: f854 2c04 ldr.w r2, [r4, #-4]
111c1c: 4217 tst r7, r2
111c1e: d015 beq.n 111c4c <rtems_assoc_32_to_string+0x58>
if ( len > 0 ) {
111c20: 4648 mov r0, r9
111c22: b15d cbz r5, 111c3c <rtems_assoc_32_to_string+0x48>
if ( len < buffer_size ) {
111c24: 42ae cmp r6, r5
len += strlcpy( &buffer[ len ], separator, space( buffer_size, len ) );
111c26: eb09 0005 add.w r0, r9, r5
return buffer_size - len;
111c2a: bf8c ite hi
111c2c: 1b72 subhi r2, r6, r5
return 0;
111c2e: 2200 movls r2, #0
len += strlcpy( &buffer[ len ], separator, space( buffer_size, len ) );
111c30: 4651 mov r1, sl
111c32: f001 fa79 bl 113128 <strlcpy>
111c36: 4405 add r5, r0
}
len += strlcpy( &buffer[ len ], p->name, space( buffer_size, len ) );
111c38: eb09 0005 add.w r0, r9, r5
if ( len < buffer_size ) {
111c3c: 42b5 cmp r5, r6
len += strlcpy( &buffer[ len ], p->name, space( buffer_size, len ) );
111c3e: 6821 ldr r1, [r4, #0]
return buffer_size - len;
111c40: bf34 ite cc
111c42: 1b72 subcc r2, r6, r5
return 0;
111c44: 2200 movcs r2, #0
len += strlcpy( &buffer[ len ], p->name, space( buffer_size, len ) );
111c46: f001 fa6f bl 113128 <strlcpy>
111c4a: 4405 add r5, r0
for ( i = 0; i < pair_count ; ++i ) {
111c4c: f10b 0b01 add.w fp, fp, #1
111c50: 3408 adds r4, #8
111c52: 45d8 cmp r8, fp
111c54: d1e0 bne.n 111c18 <rtems_assoc_32_to_string+0x24>
}
}
if ( len == 0 ) {
111c56: b11d cbz r5, 111c60 <rtems_assoc_32_to_string+0x6c>
len += strlcpy( buffer, fallback, buffer_size );
}
return len;
}
111c58: 4628 mov r0, r5
111c5a: b003 add sp, #12
111c5c: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
len += strlcpy( buffer, fallback, buffer_size );
111c60: 9901 ldr r1, [sp, #4]
111c62: 4632 mov r2, r6
111c64: 4648 mov r0, r9
}
111c66: b003 add sp, #12
111c68: e8bd 4ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
len += strlcpy( buffer, fallback, buffer_size );
111c6c: f001 ba5c b.w 113128 <strlcpy>
0010d9d0 <rtems_assoc_local_by_remote_bitfield>:
uint32_t rtems_assoc_local_by_remote_bitfield(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
10d9d0: e92d 41f0 stmdb sp!, {r4, r5, r6, r7, r8, lr}
10d9d4: 4680 mov r8, r0
10d9d6: 460e mov r6, r1
10d9d8: 2520 movs r5, #32
uint32_t b;
uint32_t local_value = 0;
10d9da: 2700 movs r7, #0
for (b = 1; b; b <<= 1) {
10d9dc: 2401 movs r4, #1
10d9de: e003 b.n 10d9e8 <rtems_assoc_local_by_remote_bitfield+0x18>
10d9e0: 3d01 subs r5, #1
10d9e2: ea4f 0444 mov.w r4, r4, lsl #1
10d9e6: d00b beq.n 10da00 <rtems_assoc_local_by_remote_bitfield+0x30>
if (b & remote_value)
10d9e8: 4226 tst r6, r4
10d9ea: d0f9 beq.n 10d9e0 <rtems_assoc_local_by_remote_bitfield+0x10>
local_value |= rtems_assoc_local_by_remote(ap, b);
10d9ec: 4621 mov r1, r4
10d9ee: 4640 mov r0, r8
10d9f0: f000 f80a bl 10da08 <rtems_assoc_local_by_remote>
for (b = 1; b; b <<= 1) {
10d9f4: 3d01 subs r5, #1
10d9f6: ea4f 0444 mov.w r4, r4, lsl #1
local_value |= rtems_assoc_local_by_remote(ap, b);
10d9fa: ea47 0700 orr.w r7, r7, r0
for (b = 1; b; b <<= 1) {
10d9fe: d1f3 bne.n 10d9e8 <rtems_assoc_local_by_remote_bitfield+0x18> <== NEVER TAKEN
}
return local_value;
}
10da00: 4638 mov r0, r7
10da02: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
10da06: bf00 nop
0010ec58 <rtems_assoc_ptr_by_local>:
const rtems_assoc_t *rtems_assoc_ptr_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
10ec58: b538 push {r3, r4, r5, lr}
10ec5a: 4605 mov r5, r0
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
10ec5c: 6800 ldr r0, [r0, #0]
10ec5e: b198 cbz r0, 10ec88 <rtems_assoc_ptr_by_local+0x30>
10ec60: 460c mov r4, r1
10ec62: f240 3168 movw r1, #872 ; 0x368
10ec66: f2c0 0111 movt r1, #17
10ec6a: f000 fbbd bl 10f3e8 <strcmp>
10ec6e: b960 cbnz r0, 10ec8a <rtems_assoc_ptr_by_local+0x32>
default_ap = ap++;
for ( ; ap->name; ap++)
10ec70: 68ea ldr r2, [r5, #12]
default_ap = ap++;
10ec72: f105 030c add.w r3, r5, #12
for ( ; ap->name; ap++)
10ec76: b912 cbnz r2, 10ec7e <rtems_assoc_ptr_by_local+0x26>
10ec78: e00a b.n 10ec90 <rtems_assoc_ptr_by_local+0x38> <== NOT EXECUTED
10ec7a: 68c2 ldr r2, [r0, #12]
10ec7c: b142 cbz r2, 10ec90 <rtems_assoc_ptr_by_local+0x38>
if (ap->local_value == local_value)
10ec7e: 685a ldr r2, [r3, #4]
10ec80: 4618 mov r0, r3
for ( ; ap->name; ap++)
10ec82: 330c adds r3, #12
if (ap->local_value == local_value)
10ec84: 42a2 cmp r2, r4
10ec86: d1f8 bne.n 10ec7a <rtems_assoc_ptr_by_local+0x22>
return ap;
return default_ap;
}
10ec88: bd38 pop {r3, r4, r5, pc}
10ec8a: 462b mov r3, r5
const rtems_assoc_t *default_ap = 0;
10ec8c: 2500 movs r5, #0
10ec8e: e7f6 b.n 10ec7e <rtems_assoc_ptr_by_local+0x26>
for ( ; ap->name; ap++)
10ec90: 4628 mov r0, r5
}
10ec92: bd38 pop {r3, r4, r5, pc}
001051bc <rtems_assoc_ptr_by_name>:
const rtems_assoc_t *rtems_assoc_ptr_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
1051bc: b570 push {r4, r5, r6, lr}
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
1051be: 6804 ldr r4, [r0, #0]
1051c0: b1cc cbz r4, 1051f6 <rtems_assoc_ptr_by_name+0x3a>
1051c2: 460d mov r5, r1
1051c4: f24e 2190 movw r1, #58000 ; 0xe290
1051c8: 4606 mov r6, r0
1051ca: f2c0 0110 movt r1, #16
1051ce: 4620 mov r0, r4
1051d0: f008 f9aa bl 10d528 <strcmp>
1051d4: b988 cbnz r0, 1051fa <rtems_assoc_ptr_by_name+0x3e>
default_ap = ap++;
for ( ; ap->name; ap++)
1051d6: 68f4 ldr r4, [r6, #12]
default_ap = ap++;
1051d8: f106 030c add.w r3, r6, #12
for ( ; ap->name; ap++)
1051dc: b914 cbnz r4, 1051e4 <rtems_assoc_ptr_by_name+0x28>
1051de: e00f b.n 105200 <rtems_assoc_ptr_by_name+0x44> <== NOT EXECUTED
1051e0: 68e4 ldr r4, [r4, #12]
1051e2: b16c cbz r4, 105200 <rtems_assoc_ptr_by_name+0x44>
if (strcmp(ap->name, name) == 0)
1051e4: 4620 mov r0, r4
1051e6: 4629 mov r1, r5
1051e8: 461c mov r4, r3
1051ea: f008 f99d bl 10d528 <strcmp>
for ( ; ap->name; ap++)
1051ee: f104 030c add.w r3, r4, #12
if (strcmp(ap->name, name) == 0)
1051f2: 2800 cmp r0, #0
1051f4: d1f4 bne.n 1051e0 <rtems_assoc_ptr_by_name+0x24>
return ap;
return default_ap;
}
1051f6: 4620 mov r0, r4
1051f8: bd70 pop {r4, r5, r6, pc}
1051fa: 4633 mov r3, r6
const rtems_assoc_t *default_ap = 0;
1051fc: 2600 movs r6, #0
1051fe: e7f1 b.n 1051e4 <rtems_assoc_ptr_by_name+0x28>
for ( ; ap->name; ap++)
105200: 4634 mov r4, r6
}
105202: 4620 mov r0, r4
105204: bd70 pop {r4, r5, r6, pc}
105206: bf00 nop
0010da14 <rtems_assoc_ptr_by_remote>:
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
10da14: b538 push {r3, r4, r5, lr}
10da16: 4605 mov r5, r0
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
10da18: 6800 ldr r0, [r0, #0]
10da1a: b198 cbz r0, 10da44 <rtems_assoc_ptr_by_remote+0x30>
10da1c: 460c mov r4, r1
10da1e: f248 2130 movw r1, #33328 ; 0x8230
10da22: f2c0 0111 movt r1, #17
10da26: f003 fc2f bl 111288 <strcmp>
10da2a: b960 cbnz r0, 10da46 <rtems_assoc_ptr_by_remote+0x32>
default_ap = ap++;
for ( ; ap->name; ap++)
10da2c: 68ea ldr r2, [r5, #12]
default_ap = ap++;
10da2e: f105 030c add.w r3, r5, #12
for ( ; ap->name; ap++)
10da32: b912 cbnz r2, 10da3a <rtems_assoc_ptr_by_remote+0x26>
10da34: e00a b.n 10da4c <rtems_assoc_ptr_by_remote+0x38> <== NOT EXECUTED
10da36: 68c2 ldr r2, [r0, #12]
10da38: b142 cbz r2, 10da4c <rtems_assoc_ptr_by_remote+0x38>
if (ap->remote_value == remote_value)
10da3a: 689a ldr r2, [r3, #8]
10da3c: 4618 mov r0, r3
for ( ; ap->name; ap++)
10da3e: 330c adds r3, #12
if (ap->remote_value == remote_value)
10da40: 42a2 cmp r2, r4
10da42: d1f8 bne.n 10da36 <rtems_assoc_ptr_by_remote+0x22>
return ap;
return default_ap;
}
10da44: bd38 pop {r3, r4, r5, pc}
10da46: 462b mov r3, r5
const rtems_assoc_t *default_ap = 0;
10da48: 2500 movs r5, #0
10da4a: e7f6 b.n 10da3a <rtems_assoc_ptr_by_remote+0x26>
for ( ; ap->name; ap++)
10da4c: 4628 mov r0, r5
}
10da4e: bd38 pop {r3, r4, r5, pc}
00105244 <rtems_assoc_remote_by_local_bitfield>:
uint32_t rtems_assoc_remote_by_local_bitfield(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
105244: e92d 41f0 stmdb sp!, {r4, r5, r6, r7, r8, lr}
105248: 4680 mov r8, r0
10524a: 460e mov r6, r1
10524c: 2520 movs r5, #32
uint32_t b;
uint32_t remote_value = 0;
10524e: 2700 movs r7, #0
for (b = 1; b; b <<= 1)
105250: 2401 movs r4, #1
105252: e003 b.n 10525c <rtems_assoc_remote_by_local_bitfield+0x18>
105254: 3d01 subs r5, #1
105256: ea4f 0444 mov.w r4, r4, lsl #1
10525a: d00b beq.n 105274 <rtems_assoc_remote_by_local_bitfield+0x30>
if (b & local_value)
10525c: 4226 tst r6, r4
10525e: d0f9 beq.n 105254 <rtems_assoc_remote_by_local_bitfield+0x10>
remote_value |= rtems_assoc_remote_by_local(ap, b);
105260: 4621 mov r1, r4
105262: 4640 mov r0, r8
105264: f000 f80a bl 10527c <rtems_assoc_remote_by_local>
for (b = 1; b; b <<= 1)
105268: 3d01 subs r5, #1
10526a: ea4f 0444 mov.w r4, r4, lsl #1
remote_value |= rtems_assoc_remote_by_local(ap, b);
10526e: ea47 0700 orr.w r7, r7, r0
for (b = 1; b; b <<= 1)
105272: d1f3 bne.n 10525c <rtems_assoc_remote_by_local_bitfield+0x18> <== NEVER TAKEN
return remote_value;
}
105274: 4638 mov r0, r7
105276: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
10527a: bf00 nop
00110514 <rtems_cache_coherent_add_area>:
110514: f242 7350 movw r3, #10064 ; 0x2750
void rtems_cache_coherent_add_area(
void *area_begin,
uintptr_t area_size
)
{
110518: e92d 41f0 stmdb sp!, {r4, r5, r6, r7, r8, lr}
11051c: f2c0 0320 movt r3, #32
110520: 4604 mov r4, r0
110522: 460d mov r5, r1
Heap_Control *heap = cache_coherent_heap;
110524: f642 76f0 movw r6, #12272 ; 0x2ff0
if ( _System_state_Is_up( _System_state_Get()) ) {
110528: 681b ldr r3, [r3, #0]
11052a: 2b02 cmp r3, #2
11052c: d00a beq.n 110544 <rtems_cache_coherent_add_area+0x30>
Heap_Control *heap = cache_coherent_heap;
11052e: f2c0 0620 movt r6, #32
110532: 6830 ldr r0, [r6, #0]
if ( heap == NULL ) {
110534: b1a8 cbz r0, 110562 <rtems_cache_coherent_add_area+0x4e>
_Heap_Extend( heap, area_begin, area_size, 0 );
110536: 460a mov r2, r1
110538: 2300 movs r3, #0
11053a: 4621 mov r1, r4
_RTEMS_Unlock_allocator();
} else {
add_area( area_begin, area_size );
}
}
11053c: e8bd 41f0 ldmia.w sp!, {r4, r5, r6, r7, r8, lr}
_Heap_Extend( heap, area_begin, area_size, 0 );
110540: f7fd bfc6 b.w 10e4d0 <_Heap_Extend>
Heap_Control *heap = cache_coherent_heap;
110544: f2c0 0620 movt r6, #32
_RTEMS_Lock_allocator();
110548: f7f8 faec bl 108b24 <_RTEMS_Lock_allocator>
Heap_Control *heap = cache_coherent_heap;
11054c: 6830 ldr r0, [r6, #0]
if ( heap == NULL ) {
11054e: b1b0 cbz r0, 11057e <rtems_cache_coherent_add_area+0x6a>
_Heap_Extend( heap, area_begin, area_size, 0 );
110550: 2300 movs r3, #0
110552: 462a mov r2, r5
110554: 4621 mov r1, r4
110556: f7fd ffbb bl 10e4d0 <_Heap_Extend>
}
11055a: e8bd 41f0 ldmia.w sp!, {r4, r5, r6, r7, r8, lr}
_RTEMS_Unlock_allocator();
11055e: f7f8 bae7 b.w 108b30 <_RTEMS_Unlock_allocator>
ok = _Heap_Initialize( heap, area_begin, area_size, 0 );
110562: f642 77f8 movw r7, #12280 ; 0x2ff8
110566: 4603 mov r3, r0
110568: f2c0 0720 movt r7, #32
11056c: 460a mov r2, r1
11056e: 4638 mov r0, r7
110570: 4621 mov r1, r4
110572: f7f8 fc8b bl 108e8c <_Heap_Initialize>
if ( ok ) {
110576: b100 cbz r0, 11057a <rtems_cache_coherent_add_area+0x66>
cache_coherent_heap = heap;
110578: 6037 str r7, [r6, #0]
}
11057a: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
ok = _Heap_Initialize( heap, area_begin, area_size, 0 );
11057e: f642 77f8 movw r7, #12280 ; 0x2ff8 <== NOT EXECUTED
110582: 4603 mov r3, r0 <== NOT EXECUTED
110584: f2c0 0720 movt r7, #32 <== NOT EXECUTED
110588: 462a mov r2, r5 <== NOT EXECUTED
11058a: 4621 mov r1, r4 <== NOT EXECUTED
11058c: 4638 mov r0, r7 <== NOT EXECUTED
11058e: f7f8 fc7d bl 108e8c <_Heap_Initialize> <== NOT EXECUTED
if ( ok ) {
110592: 2800 cmp r0, #0 <== NOT EXECUTED
110594: d0e1 beq.n 11055a <rtems_cache_coherent_add_area+0x46> <== NOT EXECUTED
cache_coherent_heap = heap;
110596: 6037 str r7, [r6, #0] <== NOT EXECUTED
110598: e7df b.n 11055a <rtems_cache_coherent_add_area+0x46> <== NOT EXECUTED
11059a: bf00 nop
00105660 <rtems_cache_coherent_allocate>:
void *rtems_cache_coherent_allocate(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
105660: b570 push {r4, r5, r6, lr}
105662: 4604 mov r4, r0
105664: 460d mov r5, r1
105666: 4616 mov r6, r2
void *ptr;
Heap_Control *heap;
_RTEMS_Lock_allocator();
105668: f002 f824 bl 1076b4 <_RTEMS_Lock_allocator>
heap = cache_coherent_heap;
10566c: f642 6330 movw r3, #11824 ; 0x2e30
105670: f2c0 0320 movt r3, #32
105674: 6818 ldr r0, [r3, #0]
if ( heap == NULL ) {
105676: b148 cbz r0, 10568c <rtems_cache_coherent_allocate+0x2c>
heap = RTEMS_Malloc_Heap;
}
ptr = _Heap_Allocate_aligned_with_boundary(
105678: 4621 mov r1, r4
10567a: 4633 mov r3, r6
10567c: 462a mov r2, r5
10567e: f002 f857 bl 107730 <_Heap_Allocate_aligned_with_boundary>
105682: 4604 mov r4, r0
size,
alignment,
boundary
);
_RTEMS_Unlock_allocator();
105684: f002 f81c bl 1076c0 <_RTEMS_Unlock_allocator>
return ptr;
}
105688: 4620 mov r0, r4
10568a: bd70 pop {r4, r5, r6, pc}
heap = RTEMS_Malloc_Heap;
10568c: f642 63a4 movw r3, #11940 ; 0x2ea4 <== NOT EXECUTED
105690: f2c0 0320 movt r3, #32 <== NOT EXECUTED
105694: 6818 ldr r0, [r3, #0] <== NOT EXECUTED
105696: e7ef b.n 105678 <rtems_cache_coherent_allocate+0x18> <== NOT EXECUTED
00105698 <rtems_cache_coherent_free>:
void rtems_cache_coherent_free( void *ptr )
{
105698: b510 push {r4, lr}
10569a: 4604 mov r4, r0
Heap_Control *heap;
_RTEMS_Lock_allocator();
10569c: f002 f80a bl 1076b4 <_RTEMS_Lock_allocator>
heap = cache_coherent_heap;
1056a0: f642 6330 movw r3, #11824 ; 0x2e30
1056a4: f2c0 0320 movt r3, #32
1056a8: 6818 ldr r0, [r3, #0]
if ( heap != NULL ) {
1056aa: b138 cbz r0, 1056bc <rtems_cache_coherent_free+0x24>
if ( _Heap_Free( heap, ptr ) ) {
1056ac: 4621 mov r1, r4
1056ae: f002 fb9f bl 107df0 <_Heap_Free>
1056b2: b118 cbz r0, 1056bc <rtems_cache_coherent_free+0x24>
if ( heap != NULL ) {
_Heap_Free( heap, ptr );
}
_RTEMS_Unlock_allocator();
}
1056b4: e8bd 4010 ldmia.w sp!, {r4, lr}
_RTEMS_Unlock_allocator();
1056b8: f002 b802 b.w 1076c0 <_RTEMS_Unlock_allocator>
heap = RTEMS_Malloc_Heap;
1056bc: f642 63a4 movw r3, #11940 ; 0x2ea4 <== NOT EXECUTED
1056c0: f2c0 0320 movt r3, #32 <== NOT EXECUTED
1056c4: 6818 ldr r0, [r3, #0] <== NOT EXECUTED
if ( heap != NULL ) {
1056c6: 2800 cmp r0, #0 <== NOT EXECUTED
1056c8: d0f4 beq.n 1056b4 <rtems_cache_coherent_free+0x1c> <== NOT EXECUTED
_Heap_Free( heap, ptr );
1056ca: 4621 mov r1, r4 <== NOT EXECUTED
1056cc: f002 fb90 bl 107df0 <_Heap_Free> <== NOT EXECUTED
}
1056d0: e8bd 4010 ldmia.w sp!, {r4, lr} <== NOT EXECUTED
_RTEMS_Unlock_allocator();
1056d4: f001 bff4 b.w 1076c0 <_RTEMS_Unlock_allocator> <== NOT EXECUTED
00107404 <rtems_filesystem_do_unmount>:
}
void rtems_filesystem_do_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
107404: b510 push {r4, lr}
107406: 4604 mov r4, r0
rtems_libio_lock();
107408: f7ff f876 bl 1064f8 <rtems_libio_lock>
previous = the_node->previous;
10740c: e9d4 2300 ldrd r2, r3, [r4]
next->previous = previous;
107410: 6053 str r3, [r2, #4]
previous->next = next;
107412: 601a str r2, [r3, #0]
rtems_libio_unlock();
107414: f7ff f876 bl 106504 <rtems_libio_unlock>
release_with_count(global_loc, 1);
107418: 6a20 ldr r0, [r4, #32]
10741a: 2101 movs r1, #1
10741c: f000 f816 bl 10744c <release_with_count>
rtems_filesystem_mt_lock();
rtems_chain_extract_unprotected(&mt_entry->mt_node);
rtems_filesystem_mt_unlock();
rtems_filesystem_global_location_release(mt_entry->mt_point_node, false);
(*mt_entry->ops->fsunmount_me_h)(mt_entry);
107420: 68e3 ldr r3, [r4, #12]
107422: 4620 mov r0, r4
107424: 6b5b ldr r3, [r3, #52] ; 0x34
107426: 4798 blx r3
if (mt_entry->unmount_task != 0) {
107428: 6be0 ldr r0, [r4, #60] ; 0x3c
10742a: b120 cbz r0, 107436 <rtems_filesystem_do_unmount+0x32>
*
* @param id is the identifier of the task to receive the transient event.
*/
static inline rtems_status_code rtems_event_transient_send( rtems_id id )
{
return rtems_event_system_send( id, RTEMS_EVENT_SYSTEM_TRANSIENT );
10742c: f04f 4100 mov.w r1, #2147483648 ; 0x80000000
107430: f001 faa4 bl 10897c <rtems_event_system_send>
rtems_status_code sc =
rtems_event_transient_send(mt_entry->unmount_task);
if (sc != RTEMS_SUCCESSFUL) {
107434: b920 cbnz r0, 107440 <rtems_filesystem_do_unmount+0x3c>
rtems_fatal_error_occurred(0xdeadbeef);
}
}
free(mt_entry);
107436: 4620 mov r0, r4
}
107438: e8bd 4010 ldmia.w sp!, {r4, lr}
free(mt_entry);
10743c: f7fe bedc b.w 1061f8 <free>
rtems_fatal_error_occurred(0xdeadbeef);
107440: f64b 60ef movw r0, #48879 ; 0xbeef <== NOT EXECUTED
107444: f6cd 60ad movt r0, #57005 ; 0xdead <== NOT EXECUTED
107448: f001 fb2a bl 108aa0 <rtems_fatal_error_occurred> <== NOT EXECUTED
00106fe0 <rtems_filesystem_eval_path_continue>:
while (ctx->pathlen > 0) {
106fe0: 6843 ldr r3, [r0, #4]
{
106fe2: b510 push {r4, lr}
106fe4: 4604 mov r4, r0
while (ctx->pathlen > 0) {
106fe6: b13b cbz r3, 106ff8 <rtems_filesystem_eval_path_continue+0x18>
(*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);
106fe8: 6ae3 ldr r3, [r4, #44] ; 0x2c
106fea: 4620 mov r0, r4
106fec: 68db ldr r3, [r3, #12]
106fee: 689b ldr r3, [r3, #8]
106ff0: 4798 blx r3
while (ctx->pathlen > 0) {
106ff2: 6863 ldr r3, [r4, #4]
106ff4: 2b00 cmp r3, #0
106ff6: d1f7 bne.n 106fe8 <rtems_filesystem_eval_path_continue+0x8>
return ctx->flags;
106ff8: e9d4 3103 ldrd r3, r1, [r4, #12]
if (rtems_filesystem_eval_path_has_token(ctx)) {
106ffc: b143 cbz r3, 107010 <rtems_filesystem_eval_path_continue+0x30>
if (make) {
106ffe: f011 0120 ands.w r1, r1, #32
107002: d021 beq.n 107048 <rtems_filesystem_eval_path_continue+0x68>
check_access(ctx, RTEMS_FS_PERMS_WRITE);
107004: 4620 mov r0, r4
107006: 2102 movs r1, #2
}
107008: e8bd 4010 ldmia.w sp!, {r4, lr}
check_access(ctx, RTEMS_FS_PERMS_WRITE);
10700c: f7ff bf8c b.w 106f28 <check_access>
if (!exclusive) {
107010: 064a lsls r2, r1, #25
107012: d404 bmi.n 10701e <rtems_filesystem_eval_path_continue+0x3e>
check_access(ctx, ctx->flags);
107014: 4620 mov r0, r4
}
107016: e8bd 4010 ldmia.w sp!, {r4, lr}
check_access(ctx, ctx->flags);
10701a: f7ff bf85 b.w 106f28 <check_access>
if (!rtems_filesystem_location_is_null(&ctx->currentloc)) {
10701e: 6aa1 ldr r1, [r4, #40] ; 0x28
107020: f647 62e4 movw r2, #32484 ; 0x7ee4
107024: f2c0 0211 movt r2, #17
ctx->pathlen = 0;
107028: e9c4 3300 strd r3, r3, [r4]
ctx->token = NULL;
10702c: 60a3 str r3, [r4, #8]
if (!rtems_filesystem_location_is_null(&ctx->currentloc)) {
10702e: 4291 cmp r1, r2
107030: d020 beq.n 107074 <rtems_filesystem_eval_path_continue+0x94>
errno = eno;
107032: f009 fb7b bl 11072c <__errno>
107036: 2211 movs r2, #17
107038: 4603 mov r3, r0
10703a: 601a str r2, [r3, #0]
rtems_filesystem_location_detach(&ctx->currentloc);
10703c: f104 0018 add.w r0, r4, #24
}
107040: e8bd 4010 ldmia.w sp!, {r4, lr}
rtems_filesystem_location_detach(&ctx->currentloc);
107044: f000 b998 b.w 107378 <rtems_filesystem_location_detach>
if (!rtems_filesystem_location_is_null(&ctx->currentloc)) {
107048: 6aa2 ldr r2, [r4, #40] ; 0x28
10704a: f647 63e4 movw r3, #32484 ; 0x7ee4
10704e: f2c0 0311 movt r3, #17
ctx->pathlen = 0;
107052: e9c4 1100 strd r1, r1, [r4]
ctx->tokenlen = 0;
107056: e9c4 1102 strd r1, r1, [r4, #8]
if (!rtems_filesystem_location_is_null(&ctx->currentloc)) {
10705a: 429a cmp r2, r3
10705c: d00a beq.n 107074 <rtems_filesystem_eval_path_continue+0x94> <== ALWAYS TAKEN
errno = eno;
10705e: f009 fb65 bl 11072c <__errno>
107062: 2202 movs r2, #2
107064: 4603 mov r3, r0
107066: 601a str r2, [r3, #0]
rtems_filesystem_location_detach(&ctx->currentloc);
107068: f104 0018 add.w r0, r4, #24
}
10706c: e8bd 4010 ldmia.w sp!, {r4, lr}
rtems_filesystem_location_detach(&ctx->currentloc);
107070: f000 b982 b.w 107378 <rtems_filesystem_location_detach>
}
107074: bd10 pop {r4, pc}
107076: bf00 nop
0010ddf4 <rtems_filesystem_eval_path_eat_delimiter>:
void rtems_filesystem_eval_path_eat_delimiter(
rtems_filesystem_eval_path_context_t *ctx
)
{
const char *current = ctx->path;
const char *end = current + ctx->pathlen;
10ddf4: e9d0 3200 ldrd r3, r2, [r0]
10ddf8: eb03 0c02 add.w ip, r3, r2
while (current != end && rtems_filesystem_is_delimiter(*current)) {
10ddfc: 4563 cmp r3, ip
10ddfe: bf04 itt eq
10de00: 461a moveq r2, r3
10de02: 2300 moveq r3, #0
10de04: d103 bne.n 10de0e <rtems_filesystem_eval_path_eat_delimiter+0x1a> <== NEVER TAKEN
10de06: e00b b.n 10de20 <rtems_filesystem_eval_path_eat_delimiter+0x2c> <== NOT EXECUTED
10de08: 459c cmp ip, r3
++current;
10de0a: 461a mov r2, r3
while (current != end && rtems_filesystem_is_delimiter(*current)) {
10de0c: d00b beq.n 10de26 <rtems_filesystem_eval_path_eat_delimiter+0x32>
10de0e: 7819 ldrb r1, [r3, #0]
10de10: 461a mov r2, r3
10de12: 3301 adds r3, #1
10de14: 295c cmp r1, #92 ; 0x5c
10de16: bf18 it ne
10de18: 292f cmpne r1, #47 ; 0x2f
10de1a: d0f5 beq.n 10de08 <rtems_filesystem_eval_path_eat_delimiter+0x14>
}
ctx->path = current;
ctx->pathlen = (size_t) (end - current);
10de1c: ebac 0302 sub.w r3, ip, r2
10de20: e9c0 2300 strd r2, r3, [r0]
}
10de24: 4770 bx lr
10de26: 2300 movs r3, #0
ctx->pathlen = (size_t) (end - current);
10de28: e9c0 2300 strd r2, r3, [r0]
}
10de2c: 4770 bx lr
10de2e: bf00 nop
0010dcb8 <rtems_filesystem_eval_path_generic>:
void rtems_filesystem_eval_path_generic(
rtems_filesystem_eval_path_context_t *ctx,
void *arg,
const rtems_filesystem_eval_path_generic_config *config
)
{
10dcb8: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
} else {
/* This is the root file system */
status = (*config->eval_token)(ctx, arg, ".", 1);
}
} else {
status = (*config->eval_token)(ctx, arg, "..", 2);
10dcbc: f248 283c movw r8, #33340 ; 0x823c
status = (*config->eval_token)(ctx, arg, ".", 1);
10dcc0: f647 6394 movw r3, #32404 ; 0x7e94
{
10dcc4: 4604 mov r4, r0
10dcc6: 460e mov r6, r1
10dcc8: 4615 mov r5, r2
return &ctx->currentloc;
10dcca: f100 0b18 add.w fp, r0, #24
status = (*config->eval_token)(ctx, arg, "..", 2);
10dcce: f2c0 0811 movt r8, #17
{
10dcd2: b083 sub sp, #12
status = (*config->eval_token)(ctx, arg, ".", 1);
10dcd4: f2c0 0311 movt r3, #17
10dcd8: 9301 str r3, [sp, #4]
rtems_filesystem_eval_path_next_token(ctx);
10dcda: 4620 mov r0, r4
10dcdc: f000 f8a8 bl 10de30 <rtems_filesystem_eval_path_next_token>
*token = ctx->token;
10dce0: e9d4 a902 ldrd sl, r9, [r4, #8]
if (tokenlen > 0) {
10dce4: f1b9 0f00 cmp.w r9, #0
10dce8: d02d beq.n 10dd46 <rtems_filesystem_eval_path_generic+0x8e>
if ((*config->is_directory)(ctx, arg)) {
10dcea: 682b ldr r3, [r5, #0]
10dcec: 4631 mov r1, r6
10dcee: 4620 mov r0, r4
10dcf0: 4798 blx r3
10dcf2: 2800 cmp r0, #0
10dcf4: d077 beq.n 10dde6 <rtems_filesystem_eval_path_generic+0x12e>
return tokenlen == 1 && token [0] == '.';
10dcf6: f1b9 0f01 cmp.w r9, #1
10dcfa: d011 beq.n 10dd20 <rtems_filesystem_eval_path_generic+0x68>
return tokenlen == 2 && token [0] == '.' && token [1] == '.';
10dcfc: f1b9 0f02 cmp.w r9, #2
10dd00: d103 bne.n 10dd0a <rtems_filesystem_eval_path_generic+0x52>
10dd02: f89a 3000 ldrb.w r3, [sl]
10dd06: 2b2e cmp r3, #46 ; 0x2e
10dd08: d037 beq.n 10dd7a <rtems_filesystem_eval_path_generic+0xc2>
}
} else {
status = (*config->eval_token)(ctx, arg, token, tokenlen);
10dd0a: 686f ldr r7, [r5, #4]
10dd0c: 464b mov r3, r9
10dd0e: 4652 mov r2, sl
10dd10: 4631 mov r1, r6
10dd12: 4620 mov r0, r4
10dd14: 47b8 blx r7
}
if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) {
10dd16: 2802 cmp r0, #2
10dd18: d013 beq.n 10dd42 <rtems_filesystem_eval_path_generic+0x8a>
while (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE) {
10dd1a: 2800 cmp r0, #0
10dd1c: d0dd beq.n 10dcda <rtems_filesystem_eval_path_generic+0x22>
10dd1e: e012 b.n 10dd46 <rtems_filesystem_eval_path_generic+0x8e>
return tokenlen == 1 && token [0] == '.';
10dd20: f89a 3000 ldrb.w r3, [sl]
10dd24: 2b2e cmp r3, #46 ; 0x2e
10dd26: d1f0 bne.n 10dd0a <rtems_filesystem_eval_path_generic+0x52>
if (rtems_filesystem_eval_path_has_path(ctx)) {
10dd28: 6863 ldr r3, [r4, #4]
10dd2a: b913 cbnz r3, 10dd32 <rtems_filesystem_eval_path_generic+0x7a>
if ((eval_flags & RTEMS_FS_REJECT_TERMINAL_DOT) == 0) {
10dd2c: 6923 ldr r3, [r4, #16]
10dd2e: 05da lsls r2, r3, #23
10dd30: d41c bmi.n 10dd6c <rtems_filesystem_eval_path_generic+0xb4>
status = (*config->eval_token)(ctx, arg, ".", 1);
10dd32: 9a01 ldr r2, [sp, #4]
10dd34: 2301 movs r3, #1
10dd36: 686f ldr r7, [r5, #4]
10dd38: 4631 mov r1, r6
10dd3a: 4620 mov r0, r4
10dd3c: 47b8 blx r7
if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) {
10dd3e: 2802 cmp r0, #2
10dd40: d1eb bne.n 10dd1a <rtems_filesystem_eval_path_generic+0x62> <== NEVER TAKEN
if (rtems_filesystem_eval_path_has_path(ctx)) {
10dd42: 6863 ldr r3, [r4, #4]
10dd44: b913 cbnz r3, 10dd4c <rtems_filesystem_eval_path_generic+0x94>
}
} else {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
}
}
}
10dd46: b003 add sp, #12
10dd48: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
rtems_filesystem_eval_path_eat_delimiter(ctx);
10dd4c: 4620 mov r0, r4
10dd4e: f000 f851 bl 10ddf4 <rtems_filesystem_eval_path_eat_delimiter>
(eval_flags & RTEMS_FS_ACCEPT_RESIDUAL_DELIMITERS) == 0
10dd52: 6923 ldr r3, [r4, #16]
if (
10dd54: 061b lsls r3, r3, #24
10dd56: d502 bpl.n 10dd5e <rtems_filesystem_eval_path_generic+0xa6>
|| rtems_filesystem_eval_path_has_path(ctx)
10dd58: 6863 ldr r3, [r4, #4]
10dd5a: 2b00 cmp r3, #0
10dd5c: d0f3 beq.n 10dd46 <rtems_filesystem_eval_path_generic+0x8e>
rtems_filesystem_eval_path_error(ctx, ENOENT);
10dd5e: 2102 movs r1, #2
rtems_filesystem_eval_path_error(ctx, ENOTDIR);
10dd60: 4620 mov r0, r4
}
10dd62: b003 add sp, #12
10dd64: e8bd 4ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
rtems_filesystem_eval_path_error(ctx, ENOTDIR);
10dd68: f7f9 ba32 b.w 1071d0 <rtems_filesystem_eval_path_error>
rtems_filesystem_eval_path_error(ctx, EINVAL);
10dd6c: 2116 movs r1, #22
rtems_filesystem_eval_path_error(ctx, ENOTDIR);
10dd6e: 4620 mov r0, r4
}
10dd70: b003 add sp, #12
10dd72: e8bd 4ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
rtems_filesystem_eval_path_error(ctx, ENOTDIR);
10dd76: f7f9 ba2b b.w 1071d0 <rtems_filesystem_eval_path_error>
return tokenlen == 2 && token [0] == '.' && token [1] == '.';
10dd7a: f89a 3001 ldrb.w r3, [sl, #1]
10dd7e: 2b2e cmp r3, #46 ; 0x2e
10dd80: d1c3 bne.n 10dd0a <rtems_filesystem_eval_path_generic+0x52> <== ALWAYS TAKEN
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
10dd82: e9d4 310b ldrd r3, r1, [r4, #44] ; 0x2c
&& (*mt_entry->ops->are_nodes_equal_h)( loc, rootloc );
10dd86: 68d8 ldr r0, [r3, #12]
10dd88: 6902 ldr r2, [r0, #16]
10dd8a: 6948 ldr r0, [r1, #20]
10dd8c: 4283 cmp r3, r0
10dd8e: d017 beq.n 10ddc0 <rtems_filesystem_eval_path_generic+0x108>
return (*mt_entry->ops->are_nodes_equal_h)( loc, mt_fs_root );
10dd90: 6a59 ldr r1, [r3, #36] ; 0x24
10dd92: 4658 mov r0, fp
10dd94: 4790 blx r2
} else if (is_fs_root(currentloc)) {
10dd96: b1f8 cbz r0, 10ddd8 <rtems_filesystem_eval_path_generic+0x120>
if (currentloc->mt_entry->mt_point_node != NULL) {
10dd98: 6ae1 ldr r1, [r4, #44] ; 0x2c
10dd9a: 6a0b ldr r3, [r1, #32]
10dd9c: 2b00 cmp r3, #0
10dd9e: d0c8 beq.n 10dd32 <rtems_filesystem_eval_path_generic+0x7a> <== ALWAYS TAKEN
size_t tokenlen = ctx->tokenlen;
10dda0: 68e0 ldr r0, [r4, #12]
ctx->tokenlen = 0;
10dda2: 2500 movs r5, #0
ctx->pathlen += tokenlen;
10dda4: e9d4 2300 ldrd r2, r3, [r4]
rtems_filesystem_eval_path_restart(
10dda8: 3120 adds r1, #32
ctx->tokenlen = 0;
10ddaa: 60e5 str r5, [r4, #12]
ctx->path -= tokenlen;
10ddac: 1a12 subs r2, r2, r0
ctx->pathlen += tokenlen;
10ddae: 4403 add r3, r0
10ddb0: e9c4 2300 strd r2, r3, [r4]
10ddb4: 4620 mov r0, r4
}
10ddb6: b003 add sp, #12
10ddb8: e8bd 4ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
rtems_filesystem_eval_path_restart(
10ddbc: f7f9 ba46 b.w 10724c <rtems_filesystem_eval_path_restart>
&& (*mt_entry->ops->are_nodes_equal_h)( loc, rootloc );
10ddc0: 4658 mov r0, fp
10ddc2: 4790 blx r2
10ddc4: 2800 cmp r0, #0
10ddc6: d1b4 bne.n 10dd32 <rtems_filesystem_eval_path_generic+0x7a>
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
10ddc8: 6ae3 ldr r3, [r4, #44] ; 0x2c
return (*mt_entry->ops->are_nodes_equal_h)( loc, mt_fs_root );
10ddca: 4658 mov r0, fp
10ddcc: 68da ldr r2, [r3, #12]
10ddce: 6a59 ldr r1, [r3, #36] ; 0x24
10ddd0: 6912 ldr r2, [r2, #16]
10ddd2: 4790 blx r2
} else if (is_fs_root(currentloc)) {
10ddd4: 2800 cmp r0, #0
10ddd6: d1df bne.n 10dd98 <rtems_filesystem_eval_path_generic+0xe0> <== ALWAYS TAKEN
status = (*config->eval_token)(ctx, arg, "..", 2);
10ddd8: 686f ldr r7, [r5, #4]
10ddda: 2302 movs r3, #2
10dddc: 4642 mov r2, r8
10ddde: 4631 mov r1, r6
10dde0: 4620 mov r0, r4
10dde2: 47b8 blx r7
10dde4: e797 b.n 10dd16 <rtems_filesystem_eval_path_generic+0x5e>
rtems_filesystem_eval_path_error(ctx, ENOTDIR);
10dde6: 2114 movs r1, #20
10dde8: 4620 mov r0, r4
}
10ddea: b003 add sp, #12
10ddec: e8bd 4ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
rtems_filesystem_eval_path_error(ctx, ENOTDIR);
10ddf0: f7f9 b9ee b.w 1071d0 <rtems_filesystem_eval_path_error>
0010de30 <rtems_filesystem_eval_path_next_token>:
}
void rtems_filesystem_eval_path_next_token(
rtems_filesystem_eval_path_context_t *ctx
)
{
10de30: b430 push {r4, r5}
const char *end = current + ctx->pathlen;
10de32: e9d0 1500 ldrd r1, r5, [r0]
10de36: 440d add r5, r1
while (current != end && rtems_filesystem_is_delimiter(*current)) {
10de38: 42a9 cmp r1, r5
10de3a: bf08 it eq
10de3c: 460c moveq r4, r1
10de3e: d103 bne.n 10de48 <rtems_filesystem_eval_path_next_token+0x18>
10de40: e02d b.n 10de9e <rtems_filesystem_eval_path_next_token+0x6e>
10de42: 428d cmp r5, r1
++current;
10de44: 460c mov r4, r1
while (current != end && rtems_filesystem_is_delimiter(*current)) {
10de46: d02a beq.n 10de9e <rtems_filesystem_eval_path_next_token+0x6e>
10de48: 780b ldrb r3, [r1, #0]
10de4a: 460c mov r4, r1
10de4c: 46a4 mov ip, r4
10de4e: 3101 adds r1, #1
10de50: 2b5c cmp r3, #92 ; 0x5c
10de52: bf18 it ne
10de54: 2b2f cmpne r3, #47 ; 0x2f
10de56: bf0c ite eq
10de58: 2201 moveq r2, #1
10de5a: 2200 movne r2, #0
10de5c: d0f1 beq.n 10de42 <rtems_filesystem_eval_path_next_token+0x12>
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
10de5e: 42a5 cmp r5, r4
ctx->pathlen = (size_t) (end - current);
10de60: eba5 0104 sub.w r1, r5, r4
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
10de64: bf08 it eq
10de66: 460b moveq r3, r1
ctx->pathlen = (size_t) (end - current);
10de68: 6041 str r1, [r0, #4]
ctx->path = current;
10de6a: 6004 str r4, [r0, #0]
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
10de6c: bf08 it eq
10de6e: 4611 moveq r1, r2
10de70: d102 bne.n 10de78 <rtems_filesystem_eval_path_next_token+0x48> <== NEVER TAKEN
10de72: e00e b.n 10de92 <rtems_filesystem_eval_path_next_token+0x62> <== NOT EXECUTED
10de74: 4565 cmp r5, ip
10de76: d00c beq.n 10de92 <rtems_filesystem_eval_path_next_token+0x62>
++current;
10de78: 4662 mov r2, ip
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
10de7a: f81c 3b01 ldrb.w r3, [ip], #1
10de7e: 2b5c cmp r3, #92 ; 0x5c
10de80: bf18 it ne
10de82: 2b2f cmpne r3, #47 ; 0x2f
10de84: bf0c ite eq
10de86: 2301 moveq r3, #1
10de88: 2300 movne r3, #0
10de8a: d1f3 bne.n 10de74 <rtems_filesystem_eval_path_next_token+0x44>
ctx->pathlen = (size_t) (end - current);
10de8c: 1aab subs r3, r5, r2
ctx->tokenlen = (size_t) (current - begin);
10de8e: 1b11 subs r1, r2, r4
10de90: 4615 mov r5, r2
ctx->pathlen = (size_t) (end - current);
10de92: e9c0 5300 strd r5, r3, [r0]
ctx->tokenlen = (size_t) (current - begin);
10de96: e9c0 4102 strd r4, r1, [r0, #8]
rtems_filesystem_eval_path_eat_delimiter(ctx);
next_token(ctx);
}
10de9a: bc30 pop {r4, r5}
10de9c: 4770 bx lr
ctx->tokenlen = (size_t) (current - begin);
10de9e: 2100 movs r1, #0
10dea0: 4625 mov r5, r4
10dea2: 460b mov r3, r1
10dea4: e7f5 b.n 10de92 <rtems_filesystem_eval_path_next_token+0x62>
10dea6: bf00 nop
00107290 <rtems_filesystem_eval_path_recursive>:
{
107290: e92d 41f0 stmdb sp!, {r4, r5, r6, r7, r8, lr}
107294: 4604 mov r4, r0
if (pathlen > 0) {
107296: 4615 mov r5, r2
107298: 2a00 cmp r2, #0
10729a: d035 beq.n 107308 <rtems_filesystem_eval_path_recursive+0x78> <== ALWAYS TAKEN
if (ctx->recursionlevel < RTEMS_FILESYSTEM_SYMLOOP_MAX) {
10729c: 6943 ldr r3, [r0, #20]
10729e: 2b1f cmp r3, #31
1072a0: dc1b bgt.n 1072da <rtems_filesystem_eval_path_recursive+0x4a>
if (rtems_filesystem_is_delimiter(path [0])) {
1072a2: 780a ldrb r2, [r1, #0]
1072a4: 4688 mov r8, r1
size_t saved_pathlen = ctx->pathlen;
1072a6: e9d0 7600 ldrd r7, r6, [r0]
if (rtems_filesystem_is_delimiter(path [0])) {
1072aa: 2a5c cmp r2, #92 ; 0x5c
1072ac: bf18 it ne
1072ae: 2a2f cmpne r2, #47 ; 0x2f
1072b0: d040 beq.n 107334 <rtems_filesystem_eval_path_recursive+0xa4>
++ctx->recursionlevel;
1072b2: 3301 adds r3, #1
ctx->path = path;
1072b4: f8c4 8000 str.w r8, [r4]
ctx->pathlen = pathlen;
1072b8: 6065 str r5, [r4, #4]
++ctx->recursionlevel;
1072ba: 6163 str r3, [r4, #20]
(*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);
1072bc: 6ae3 ldr r3, [r4, #44] ; 0x2c
1072be: 4620 mov r0, r4
1072c0: 68db ldr r3, [r3, #12]
1072c2: 689b ldr r3, [r3, #8]
1072c4: 4798 blx r3
while (ctx->pathlen > 0) {
1072c6: 6863 ldr r3, [r4, #4]
1072c8: 2b00 cmp r3, #0
1072ca: d1f7 bne.n 1072bc <rtems_filesystem_eval_path_recursive+0x2c>
--ctx->recursionlevel;
1072cc: 6963 ldr r3, [r4, #20]
ctx->pathlen = saved_pathlen;
1072ce: e9c4 7600 strd r7, r6, [r4]
--ctx->recursionlevel;
1072d2: 3b01 subs r3, #1
1072d4: 6163 str r3, [r4, #20]
}
1072d6: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
if (!rtems_filesystem_location_is_null(&ctx->currentloc)) {
1072da: 6a81 ldr r1, [r0, #40] ; 0x28
1072dc: f647 62e4 movw r2, #32484 ; 0x7ee4
1072e0: f2c0 0211 movt r2, #17
ctx->path = NULL;
1072e4: 2300 movs r3, #0
ctx->pathlen = 0;
1072e6: e9c0 3300 strd r3, r3, [r0]
if (!rtems_filesystem_location_is_null(&ctx->currentloc)) {
1072ea: 4291 cmp r1, r2
ctx->tokenlen = 0;
1072ec: e9c0 3302 strd r3, r3, [r0, #8]
if (!rtems_filesystem_location_is_null(&ctx->currentloc)) {
1072f0: d0f1 beq.n 1072d6 <rtems_filesystem_eval_path_recursive+0x46> <== ALWAYS TAKEN
errno = eno;
1072f2: f009 fa1b bl 11072c <__errno>
1072f6: 225c movs r2, #92 ; 0x5c
1072f8: 4603 mov r3, r0
1072fa: 601a str r2, [r3, #0]
rtems_filesystem_location_detach(&ctx->currentloc);
1072fc: f104 0018 add.w r0, r4, #24
}
107300: e8bd 41f0 ldmia.w sp!, {r4, r5, r6, r7, r8, lr}
rtems_filesystem_location_detach(&ctx->currentloc);
107304: f000 b838 b.w 107378 <rtems_filesystem_location_detach>
if (!rtems_filesystem_location_is_null(&ctx->currentloc)) {
107308: 6a82 ldr r2, [r0, #40] ; 0x28 <== NOT EXECUTED
10730a: f647 63e4 movw r3, #32484 ; 0x7ee4 <== NOT EXECUTED
10730e: f2c0 0311 movt r3, #17 <== NOT EXECUTED
ctx->pathlen = 0;
107312: e9c0 5500 strd r5, r5, [r0] <== NOT EXECUTED
ctx->tokenlen = 0;
107316: e9c0 5502 strd r5, r5, [r0, #8] <== NOT EXECUTED
if (!rtems_filesystem_location_is_null(&ctx->currentloc)) {
10731a: 429a cmp r2, r3 <== NOT EXECUTED
10731c: d0db beq.n 1072d6 <rtems_filesystem_eval_path_recursive+0x46> <== NOT EXECUTED
errno = eno;
10731e: f009 fa05 bl 11072c <__errno> <== NOT EXECUTED
107322: 2202 movs r2, #2 <== NOT EXECUTED
107324: 4603 mov r3, r0 <== NOT EXECUTED
107326: 601a str r2, [r3, #0] <== NOT EXECUTED
rtems_filesystem_location_detach(&ctx->currentloc);
107328: f104 0018 add.w r0, r4, #24 <== NOT EXECUTED
}
10732c: e8bd 41f0 ldmia.w sp!, {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
rtems_filesystem_location_detach(&ctx->currentloc);
107330: f000 b822 b.w 107378 <rtems_filesystem_location_detach> <== NOT EXECUTED
rtems_filesystem_eval_path_restart(ctx, &ctx->rootloc);
107334: f100 0130 add.w r1, r0, #48 ; 0x30
107338: f7ff ff88 bl 10724c <rtems_filesystem_eval_path_restart>
++ctx->recursionlevel;
10733c: 6963 ldr r3, [r4, #20]
10733e: e7b8 b.n 1072b2 <rtems_filesystem_eval_path_recursive+0x22>
00107140 <rtems_filesystem_eval_path_start_with_parent>:
{
107140: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
107144: 468a mov sl, r1
107146: b083 sub sp, #12
107148: 4606 mov r6, r0
size_t pathlen = strlen(path);
10714a: 4608 mov r0, r1
{
10714c: 4690 mov r8, r2
10714e: 4699 mov r9, r3
size_t pathlen = strlen(path);
107150: f00a fa96 bl 111680 <strlen>
107154: 4607 mov r7, r0
while (pathlen > 0) {
107156: eb0a 0e00 add.w lr, sl, r0
size_t pathlen = strlen(path);
10715a: 4604 mov r4, r0
while (pathlen > 0) {
10715c: e008 b.n 107170 <rtems_filesystem_eval_path_start_with_parent+0x30>
if (rtems_filesystem_is_delimiter(path [i])) {
10715e: f81e cd01 ldrb.w ip, [lr, #-1]!
107162: f1bc 0f5c cmp.w ip, #92 ; 0x5c
107166: bf18 it ne
107168: f1bc 0f2f cmpne.w ip, #47 ; 0x2f
10716c: d02a beq.n 1071c4 <rtems_filesystem_eval_path_start_with_parent+0x84>
pathlen = i;
10716e: 462c mov r4, r5
size_t i = pathlen - 1;
107170: 1e65 subs r5, r4, #1
while (pathlen > 0) {
107172: 2c00 cmp r4, #0
107174: d1f3 bne.n 10715e <rtems_filesystem_eval_path_start_with_parent+0x1e>
if (pathlen > 0) {
107176: b9f7 cbnz r7, 1071b6 <rtems_filesystem_eval_path_start_with_parent+0x76>
const char *name = NULL;
107178: 46bb mov fp, r7
&rtems_filesystem_root,
10717a: f000 fafd bl 107778 <rtems_current_user_env_get>
10717e: 4605 mov r5, r0
107180: 3504 adds r5, #4
&rtems_filesystem_current
107182: f000 faf9 bl 107778 <rtems_current_user_env_get>
currentloc = rtems_filesystem_eval_path_start_with_root_and_current(
107186: 9b0c ldr r3, [sp, #48] ; 0x30
107188: 4622 mov r2, r4
10718a: 4651 mov r1, sl
10718c: 9001 str r0, [sp, #4]
10718e: 9500 str r5, [sp, #0]
107190: 4630 mov r0, r6
107192: f7ff ff71 bl 107078 <rtems_filesystem_eval_path_start_with_root_and_current>
107196: 4601 mov r1, r0
rtems_filesystem_location_clone(parentloc, currentloc);
107198: 4648 mov r0, r9
10719a: f006 fc69 bl 10da70 <rtems_filesystem_location_clone>
rtems_filesystem_eval_path_continue(ctx);
10719e: 4630 mov r0, r6
ctx->pathlen = namelen;
1071a0: e9c6 b700 strd fp, r7, [r6]
ctx->flags = eval_flags;
1071a4: f8c6 8010 str.w r8, [r6, #16]
rtems_filesystem_eval_path_continue(ctx);
1071a8: f7ff ff1a bl 106fe0 <rtems_filesystem_eval_path_continue>
return &ctx->currentloc;
1071ac: f106 0018 add.w r0, r6, #24
}
1071b0: b003 add sp, #12
1071b2: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
if (pathlen > 0) {
1071b6: 46d3 mov fp, sl
parentpath = ".";
1071b8: f647 6a94 movw sl, #32404 ; 0x7e94
1071bc: f2c0 0a11 movt sl, #17
parentpathlen = 1;
1071c0: 2401 movs r4, #1
1071c2: e7da b.n 10717a <rtems_filesystem_eval_path_start_with_parent+0x3a>
if (pathlen > 0) {
1071c4: 2f00 cmp r7, #0
1071c6: d0d7 beq.n 107178 <rtems_filesystem_eval_path_start_with_parent+0x38><== ALWAYS TAKEN
namelen = pathlen - parentpathlen;
1071c8: 1b3f subs r7, r7, r4
name = path + parentpathlen;
1071ca: eb0a 0b04 add.w fp, sl, r4
namelen = pathlen - parentpathlen;
1071ce: e7d4 b.n 10717a <rtems_filesystem_eval_path_start_with_parent+0x3a>
001069a0 <rtems_filesystem_get_mount_handler>:
rtems_filesystem_fsmount_me_t
rtems_filesystem_get_mount_handler(
const char *type
)
{
1069a0: b570 push {r4, r5, r6, lr}
find_arg fa = {
.type = type,
.mount_h = NULL
};
if ( type != NULL ) {
1069a2: 4604 mov r4, r0
1069a4: b310 cbz r0, 1069ec <rtems_filesystem_get_mount_handler+0x4c>
while ( table_entry->type && !stop ) {
1069a6: f647 1520 movw r5, #31008 ; 0x7920
1069aa: f2c0 0511 movt r5, #17
1069ae: 6828 ldr r0, [r5, #0]
1069b0: b138 cbz r0, 1069c2 <rtems_filesystem_get_mount_handler+0x22>
if ( strcmp( entry->type, fa->type ) != 0 ) {
1069b2: 4621 mov r1, r4
1069b4: f00a fc68 bl 111288 <strcmp>
1069b8: b1b8 cbz r0, 1069ea <rtems_filesystem_get_mount_handler+0x4a>
while ( table_entry->type && !stop ) {
1069ba: f855 0f08 ldr.w r0, [r5, #8]!
1069be: 2800 cmp r0, #0
1069c0: d1f7 bne.n 1069b2 <rtems_filesystem_get_mount_handler+0x12>
return _Chain_Immutable_head( the_chain )->next;
1069c2: f240 1628 movw r6, #296 ; 0x128
1069c6: f2c0 0620 movt r6, #32
rtems_libio_lock();
1069ca: f7ff fd95 bl 1064f8 <rtems_libio_lock>
1069ce: f856 5b04 ldr.w r5, [r6], #4
for (
1069d2: 42b5 cmp r5, r6
1069d4: d00f beq.n 1069f6 <rtems_filesystem_get_mount_handler+0x56> <== NEVER TAKEN
if ( strcmp( entry->type, fa->type ) != 0 ) {
1069d6: 68a8 ldr r0, [r5, #8] <== NOT EXECUTED
1069d8: 4621 mov r1, r4 <== NOT EXECUTED
1069da: f00a fc55 bl 111288 <strcmp> <== NOT EXECUTED
1069de: b938 cbnz r0, 1069f0 <rtems_filesystem_get_mount_handler+0x50> <== NOT EXECUTED
fa->mount_h = entry->mount_h;
1069e0: 68ec ldr r4, [r5, #12] <== NOT EXECUTED
rtems_libio_unlock();
1069e2: f7ff fd8f bl 106504 <rtems_libio_unlock>
rtems_filesystem_iterate( find_handler, &fa );
}
return fa.mount_h;
}
1069e6: 4620 mov r0, r4
1069e8: bd70 pop {r4, r5, r6, pc}
fa->mount_h = entry->mount_h;
1069ea: 686c ldr r4, [r5, #4]
}
1069ec: 4620 mov r0, r4
1069ee: bd70 pop {r4, r5, r6, pc}
return the_node->next;
1069f0: 682d ldr r5, [r5, #0] <== NOT EXECUTED
for (
1069f2: 42b5 cmp r5, r6 <== NOT EXECUTED
1069f4: d1ef bne.n 1069d6 <rtems_filesystem_get_mount_handler+0x36> <== NOT EXECUTED
find_arg fa = {
1069f6: 2400 movs r4, #0
1069f8: e7f3 b.n 1069e2 <rtems_filesystem_get_mount_handler+0x42>
1069fa: bf00 nop <== NOT EXECUTED
1069fc: 0000 movs r0, r0 <== NOT EXECUTED
...
0010752c <rtems_filesystem_global_location_release>:
{
10752c: 4603 mov r3, r0
if (!deferred) {
10752e: b1c1 cbz r1, 107562 <rtems_filesystem_global_location_release+0x36>
__asm__ volatile (
107530: f3ef 8100 mrs r1, CPSR
107534: f041 0280 orr.w r2, r1, #128 ; 0x80
107538: f382 8900 msr CPSR_fc, r2
if (global_loc->deferred_released_count == 0) {
10753c: 6a02 ldr r2, [r0, #32]
10753e: b122 cbz r2, 10754a <rtems_filesystem_global_location_release+0x1e>
++global_loc->deferred_released_count;
107540: 3201 adds r2, #1 <== NOT EXECUTED
107542: 6202 str r2, [r0, #32] <== NOT EXECUTED
__asm__ volatile (
107544: f381 8900 msr CPSR_fc, r1 <== NOT EXECUTED
}
107548: 4770 bx lr <== NOT EXECUTED
rtems_filesystem_global_location_t *head =
10754a: f242 723c movw r2, #10044 ; 0x273c
global_loc->deferred_released_count = 1;
10754e: 2001 movs r0, #1
rtems_filesystem_global_location_t *head =
107550: f2c0 0220 movt r2, #32
global_loc->deferred_released_count = 1;
107554: 6218 str r0, [r3, #32]
rtems_filesystem_global_location_t *head =
107556: 6810 ldr r0, [r2, #0]
deferred_released_global_locations = global_loc;
107558: 6013 str r3, [r2, #0]
global_loc->deferred_released_next = head;
10755a: 61d8 str r0, [r3, #28]
10755c: f381 8900 msr CPSR_fc, r1
}
107560: 4770 bx lr
release_with_count(global_loc, 1);
107562: 2101 movs r1, #1
107564: f7ff bf72 b.w 10744c <release_with_count>
0010608c <rtems_filesystem_initialize>:
{
int rv = 0;
const rtems_filesystem_mount_configuration *root_config =
&rtems_filesystem_root_configuration;
rv = mount(
10608c: f647 100c movw r0, #30988 ; 0x790c
{
106090: b510 push {r4, lr}
rv = mount(
106092: f2c0 0011 movt r0, #17
{
106096: b082 sub sp, #8
rv = mount(
106098: 6903 ldr r3, [r0, #16]
10609a: 461c mov r4, r3
10609c: e9d0 2302 ldrd r2, r3, [r0, #8]
1060a0: 9400 str r4, [sp, #0]
1060a2: e9d0 0100 ldrd r0, r1, [r0]
1060a6: f000 fb63 bl 106770 <mount>
root_config->target,
root_config->filesystemtype,
root_config->options,
root_config->data
);
if ( rv != 0 )
1060aa: b950 cbnz r0, 1060c2 <rtems_filesystem_initialize+0x36>
* Traditionally RTEMS devices are under "/dev" so install this directory.
*
* If the mkdir() fails, we can't print anything so just fatal error.
*/
rv = mkdir( "/dev", S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH );
1060ac: f647 40ec movw r0, #31980 ; 0x7cec
1060b0: f240 11ed movw r1, #493 ; 0x1ed
1060b4: f2c0 0011 movt r0, #17
1060b8: f000 fb02 bl 1066c0 <mkdir>
if ( rv != 0 )
1060bc: b930 cbnz r0, 1060cc <rtems_filesystem_initialize+0x40>
* it will be mounted onto is created. Moreover, if it is going to
* use a device, then it is REALLY unfair to attempt this
* before device drivers are initialized. So we return via a base
* filesystem image and nothing auto-mounted at this point.
*/
}
1060be: b002 add sp, #8
1060c0: bd10 pop {r4, pc}
rtems_fatal_error_occurred( 0xABCD0002 );
1060c2: 2002 movs r0, #2 <== NOT EXECUTED
1060c4: f6ca 30cd movt r0, #43981 ; 0xabcd <== NOT EXECUTED
1060c8: f002 fcea bl 108aa0 <rtems_fatal_error_occurred> <== NOT EXECUTED
rtems_fatal_error_occurred( 0xABCD0003 );
1060cc: 2003 movs r0, #3 <== NOT EXECUTED
1060ce: f6ca 30cd movt r0, #43981 ; 0xabcd <== NOT EXECUTED
1060d2: f002 fce5 bl 108aa0 <rtems_fatal_error_occurred> <== NOT EXECUTED
1060d6: bf00 nop
00106188 <rtems_filesystem_iterate>:
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
106188: b5f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
rtems_chain_control *chain = &filesystem_chain;
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
10618a: f644 042c movw r4, #18476 ; 0x482c <== NOT EXECUTED
10618e: f2c0 0415 movt r4, #21 <== NOT EXECUTED
{
106192: b083 sub sp, #12 <== NOT EXECUTED
106194: 4605 mov r5, r0 <== NOT EXECUTED
106196: 460e mov r6, r1 <== NOT EXECUTED
while ( table_entry->type && !stop ) {
106198: 6823 ldr r3, [r4, #0] <== NOT EXECUTED
10619a: b90b cbnz r3, 1061a0 <rtems_filesystem_iterate+0x18> <== NOT EXECUTED
10619c: e008 b.n 1061b0 <rtems_filesystem_iterate+0x28> <== NOT EXECUTED
10619e: bb00 cbnz r0, 1061e2 <rtems_filesystem_iterate+0x5a> <== NOT EXECUTED
stop = (*routine)( table_entry, routine_arg );
1061a0: 4620 mov r0, r4 <== NOT EXECUTED
1061a2: 4631 mov r1, r6 <== NOT EXECUTED
1061a4: 47a8 blx r5 <== NOT EXECUTED
while ( table_entry->type && !stop ) {
1061a6: 68a3 ldr r3, [r4, #8] <== NOT EXECUTED
1061a8: 3408 adds r4, #8 <== NOT EXECUTED
1061aa: 2b00 cmp r3, #0 <== NOT EXECUTED
1061ac: d1f7 bne.n 10619e <rtems_filesystem_iterate+0x16> <== NOT EXECUTED
++table_entry;
}
if ( !stop ) {
1061ae: b9c0 cbnz r0, 1061e2 <rtems_filesystem_iterate+0x5a> <== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
1061b0: f240 27e0 movw r7, #736 ; 0x2e0 <== NOT EXECUTED
1061b4: f2c0 0720 movt r7, #32 <== NOT EXECUTED
rtems_libio_lock();
1061b8: f7ff fd2c bl 105c14 <rtems_libio_lock> <== NOT EXECUTED
1061bc: f857 4b04 ldr.w r4, [r7], #4 <== NOT EXECUTED
for (
1061c0: 42bc cmp r4, r7 <== NOT EXECUTED
1061c2: bf08 it eq <== NOT EXECUTED
1061c4: 2000 moveq r0, #0 <== NOT EXECUTED
1061c6: d101 bne.n 1061cc <rtems_filesystem_iterate+0x44> <== NOT EXECUTED
1061c8: e007 b.n 1061da <rtems_filesystem_iterate+0x52> <== NOT EXECUTED
node = rtems_chain_first( chain );
!rtems_chain_is_tail( chain, node ) && !stop;
1061ca: b930 cbnz r0, 1061da <rtems_filesystem_iterate+0x52> <== NOT EXECUTED
node = rtems_chain_next( node )
) {
const filesystem_node *fsn = (filesystem_node *) node;
stop = (*routine)( &fsn->entry, routine_arg );
1061cc: f104 0008 add.w r0, r4, #8 <== NOT EXECUTED
1061d0: 4631 mov r1, r6 <== NOT EXECUTED
1061d2: 47a8 blx r5 <== NOT EXECUTED
return the_node->next;
1061d4: 6824 ldr r4, [r4, #0] <== NOT EXECUTED
for (
1061d6: 42bc cmp r4, r7 <== NOT EXECUTED
1061d8: d1f7 bne.n 1061ca <rtems_filesystem_iterate+0x42> <== NOT EXECUTED
1061da: 9001 str r0, [sp, #4] <== NOT EXECUTED
}
rtems_libio_unlock();
1061dc: f7ff fd20 bl 105c20 <rtems_libio_unlock> <== NOT EXECUTED
1061e0: 9801 ldr r0, [sp, #4] <== NOT EXECUTED
}
return stop;
}
1061e2: b003 add sp, #12 <== NOT EXECUTED
1061e4: bdf0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
1061e6: bf00 nop
00107568 <rtems_filesystem_location_remove_from_mt_entry>:
__asm__ volatile (
107568: f3ef 8c00 mrs ip, CPSR
10756c: f04c 0380 orr.w r3, ip, #128 ; 0x80
107570: f383 8900 msr CPSR_fc, r3
do_unmount = rtems_filesystem_is_ready_for_unmount(loc->mt_entry);
107574: 6943 ldr r3, [r0, #20]
previous = the_node->previous;
107576: e9d0 1200 ldrd r1, r2, [r0]
next->previous = previous;
10757a: 604a str r2, [r1, #4]
previous->next = next;
10757c: 6011 str r1, [r2, #0]
10757e: f893 2028 ldrb.w r2, [r3, #40] ; 0x28
107582: b112 cbz r2, 10758a <rtems_filesystem_location_remove_from_mt_entry+0x22>
__asm__ volatile (
107584: f38c 8900 msr CPSR_fc, ip
if (do_unmount) {
107588: 4770 bx lr
&& rtems_chain_has_only_one_node( &mt_entry->location_chain )
10758a: 69d9 ldr r1, [r3, #28]
{
10758c: b410 push {r4}
10758e: 695c ldr r4, [r3, #20]
107590: 428c cmp r4, r1
107592: d103 bne.n 10759c <rtems_filesystem_location_remove_from_mt_entry+0x34>
&& mt_entry->mt_fs_root->reference_count == 1;
107594: 6a59 ldr r1, [r3, #36] ; 0x24
107596: 6989 ldr r1, [r1, #24]
107598: 2901 cmp r1, #1
10759a: d004 beq.n 1075a6 <rtems_filesystem_location_remove_from_mt_entry+0x3e><== ALWAYS TAKEN
10759c: f38c 8900 msr CPSR_fc, ip
}
1075a0: f85d 4b04 ldr.w r4, [sp], #4
1075a4: 4770 bx lr
return &the_chain->Tail.Node;
1075a6: f103 0114 add.w r1, r3, #20 <== NOT EXECUTED
head->previous = NULL;
1075aa: 619a str r2, [r3, #24] <== NOT EXECUTED
return &the_chain->Tail.Node;
1075ac: f103 0218 add.w r2, r3, #24 <== NOT EXECUTED
tail->previous = head;
1075b0: 61d9 str r1, [r3, #28] <== NOT EXECUTED
head->next = tail;
1075b2: 615a str r2, [r3, #20] <== NOT EXECUTED
1075b4: f38c 8900 msr CPSR_fc, ip <== NOT EXECUTED
rtems_filesystem_do_unmount(loc->mt_entry);
1075b8: 6940 ldr r0, [r0, #20] <== NOT EXECUTED
}
1075ba: f85d 4b04 ldr.w r4, [sp], #4 <== NOT EXECUTED
rtems_filesystem_do_unmount(loc->mt_entry);
1075be: f7ff bf21 b.w 107404 <rtems_filesystem_do_unmount> <== NOT EXECUTED
1075c2: bf00 nop
00107638 <rtems_filesystem_location_transform_to_global>:
{
107638: b530 push {r4, r5, lr}
10763a: 4605 mov r5, r0
10763c: b083 sub sp, #12
rtems_filesystem_global_location_t *global_loc = malloc(sizeof(*global_loc));
10763e: 2024 movs r0, #36 ; 0x24
107640: f7fe ffb2 bl 1065a8 <malloc>
if (global_loc != NULL) {
107644: 4604 mov r4, r0
107646: b310 cbz r0, 10768e <rtems_filesystem_location_transform_to_global+0x56>
dst->node_access_2 = src->node_access_2;
107648: e9d5 0102 ldrd r0, r1, [r5, #8]
global_loc->deferred_released_next = NULL;
10764c: 2300 movs r3, #0
dst->handlers = src->handlers;
10764e: 692a ldr r2, [r5, #16]
global_loc->deferred_released_count = 0;
107650: 6223 str r3, [r4, #32]
dst->node_access = src->node_access;
107652: 60a0 str r0, [r4, #8]
global_loc->reference_count = 1;
107654: 2001 movs r0, #1
global_loc->deferred_released_next = NULL;
107656: e9c4 0306 strd r0, r3, [r4, #24]
dst->mt_entry = src->mt_entry;
10765a: 696b ldr r3, [r5, #20]
dst->node_access_2 = src->node_access_2;
10765c: 60e1 str r1, [r4, #12]
dst->mt_entry = src->mt_entry;
10765e: e9c4 2304 strd r2, r3, [r4, #16]
__asm__ volatile (
107662: f3ef 8100 mrs r1, CPSR
107666: f041 0380 orr.w r3, r1, #128 ; 0x80
10766a: f383 8900 msr CPSR_fc, r3
10766e: 6963 ldr r3, [r4, #20]
old_last = tail->previous;
107670: 69da ldr r2, [r3, #28]
return &the_chain->Tail.Node;
107672: f103 0018 add.w r0, r3, #24
the_node->next = tail;
107676: 6020 str r0, [r4, #0]
tail->previous = the_node;
107678: 61dc str r4, [r3, #28]
old_last->next = the_node;
10767a: 6014 str r4, [r2, #0]
the_node->previous = old_last;
10767c: 6062 str r2, [r4, #4]
__asm__ volatile (
10767e: f381 8900 msr CPSR_fc, r1
rtems_filesystem_location_remove_from_mt_entry(loc);
107682: 4628 mov r0, r5
107684: f7ff ff70 bl 107568 <rtems_filesystem_location_remove_from_mt_entry>
}
107688: 4620 mov r0, r4
10768a: b003 add sp, #12
10768c: bd30 pop {r4, r5, pc}
rtems_filesystem_location_free(loc);
10768e: 4628 mov r0, r5 <== NOT EXECUTED
107690: f006 fa04 bl 10da9c <rtems_filesystem_location_free> <== NOT EXECUTED
return rtems_filesystem_global_location_obtain( &global_loc );
107694: a801 add r0, sp, #4 <== NOT EXECUTED
rtems_filesystem_global_location_t *global_loc = NULL;
107696: 9401 str r4, [sp, #4] <== NOT EXECUTED
return rtems_filesystem_global_location_obtain( &global_loc );
107698: f7ff ff10 bl 1074bc <rtems_filesystem_global_location_obtain> <== NOT EXECUTED
10769c: 4604 mov r4, r0 <== NOT EXECUTED
errno = ENOMEM;
10769e: f009 f845 bl 11072c <__errno> <== NOT EXECUTED
1076a2: 230c movs r3, #12 <== NOT EXECUTED
1076a4: 6003 str r3, [r0, #0] <== NOT EXECUTED
return global_loc;
1076a6: e7ef b.n 107688 <rtems_filesystem_location_transform_to_global+0x50> <== NOT EXECUTED
00107c34 <rtems_filesystem_mount_iterate>:
bool rtems_filesystem_mount_iterate(
rtems_filesystem_mt_entry_visitor visitor,
void *visitor_arg
)
{
107c34: b5f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
107c36: f240 26d4 movw r6, #724 ; 0x2d4 <== NOT EXECUTED
107c3a: f2c0 0620 movt r6, #32 <== NOT EXECUTED
107c3e: b083 sub sp, #12 <== NOT EXECUTED
107c40: 4605 mov r5, r0 <== NOT EXECUTED
107c42: 460f mov r7, r1 <== NOT EXECUTED
rtems_libio_lock();
107c44: f7fd ffe6 bl 105c14 <rtems_libio_lock> <== NOT EXECUTED
107c48: f856 4b04 ldr.w r4, [r6], #4 <== NOT EXECUTED
rtems_chain_control *chain = &rtems_filesystem_mount_table;
rtems_chain_node *node = NULL;
bool stop = false;
rtems_filesystem_mt_lock();
for (
107c4c: 42b4 cmp r4, r6 <== NOT EXECUTED
107c4e: d101 bne.n 107c54 <rtems_filesystem_mount_iterate+0x20> <== NOT EXECUTED
107c50: e00c b.n 107c6c <rtems_filesystem_mount_iterate+0x38> <== NOT EXECUTED
node = rtems_chain_first( chain );
!rtems_chain_is_tail( chain, node ) && !stop;
107c52: b928 cbnz r0, 107c60 <rtems_filesystem_mount_iterate+0x2c> <== NOT EXECUTED
node = rtems_chain_next( node )
) {
const rtems_filesystem_mount_table_entry_t *mt_entry =
(rtems_filesystem_mount_table_entry_t *) node;
stop = (*visitor)( mt_entry, visitor_arg );
107c54: 4620 mov r0, r4 <== NOT EXECUTED
107c56: 4639 mov r1, r7 <== NOT EXECUTED
107c58: 47a8 blx r5 <== NOT EXECUTED
return the_node->next;
107c5a: 6824 ldr r4, [r4, #0] <== NOT EXECUTED
for (
107c5c: 42b4 cmp r4, r6 <== NOT EXECUTED
107c5e: d1f8 bne.n 107c52 <rtems_filesystem_mount_iterate+0x1e> <== NOT EXECUTED
107c60: 9001 str r0, [sp, #4] <== NOT EXECUTED
rtems_libio_unlock();
107c62: f7fd ffdd bl 105c20 <rtems_libio_unlock> <== NOT EXECUTED
}
rtems_filesystem_mt_unlock();
return stop;
}
107c66: 9801 ldr r0, [sp, #4] <== NOT EXECUTED
107c68: b003 add sp, #12 <== NOT EXECUTED
107c6a: bdf0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
bool stop = false;
107c6c: 2000 movs r0, #0 <== NOT EXECUTED
107c6e: e7f7 b.n 107c60 <rtems_filesystem_mount_iterate+0x2c> <== NOT EXECUTED
00104e5c <rtems_filesystem_register>:
int
rtems_filesystem_register(
const char *type,
rtems_filesystem_fsmount_me_t mount_h
)
{
104e5c: e92d 41f0 stmdb sp!, {r4, r5, r6, r7, r8, lr}
104e60: 4606 mov r6, r0
104e62: 460f mov r7, r1
rtems_chain_control *chain = &filesystem_chain;
size_t type_size = strlen(type) + 1;
104e64: f007 ff4c bl 10cd00 <strlen>
104e68: 4602 mov r2, r0
size_t fsn_size = sizeof( filesystem_node ) + type_size;
filesystem_node *fsn = malloc( fsn_size );
104e6a: 3011 adds r0, #17
size_t type_size = strlen(type) + 1;
104e6c: 1c54 adds r4, r2, #1
filesystem_node *fsn = malloc( fsn_size );
104e6e: f003 fce3 bl 108838 <malloc>
char *type_storage = (char *) fsn + sizeof( *fsn );
if ( fsn == NULL )
104e72: 2800 cmp r0, #0
104e74: d053 beq.n 104f1e <rtems_filesystem_register+0xc2>
rtems_set_errno_and_return_minus_one( ENOMEM );
memcpy(type_storage, type, type_size);
104e76: f100 0310 add.w r3, r0, #16
104e7a: 4622 mov r2, r4
104e7c: 4605 mov r5, r0
104e7e: 4631 mov r1, r6
104e80: 4618 mov r0, r3
while ( table_entry->type && !stop ) {
104e82: f24d 34f8 movw r4, #54264 ; 0xd3f8
memcpy(type_storage, type, type_size);
104e86: f007 e9dc blx 10c240 <memcpy>
while ( table_entry->type && !stop ) {
104e8a: f2c0 0410 movt r4, #16
fsn->entry.type = type_storage;
fsn->entry.mount_h = mount_h;
104e8e: e9c5 0702 strd r0, r7, [r5, #8]
rtems_libio_lock();
104e92: f003 fcc5 bl 108820 <rtems_libio_lock>
while ( table_entry->type && !stop ) {
104e96: 6820 ldr r0, [r4, #0]
104e98: b138 cbz r0, 104eaa <rtems_filesystem_register+0x4e>
if ( strcmp( entry->type, fa->type ) != 0 ) {
104e9a: 4631 mov r1, r6
104e9c: f007 fd04 bl 10c8a8 <strcmp>
104ea0: b330 cbz r0, 104ef0 <rtems_filesystem_register+0x94>
while ( table_entry->type && !stop ) {
104ea2: f854 0f08 ldr.w r0, [r4, #8]!
104ea6: 2800 cmp r0, #0
104ea8: d1f7 bne.n 104e9a <rtems_filesystem_register+0x3e> <== ALWAYS TAKEN
return _Chain_Immutable_head( the_chain )->next;
104eaa: f240 08cc movw r8, #204 ; 0xcc
104eae: f2c0 0820 movt r8, #32
104eb2: 4647 mov r7, r8
rtems_libio_lock();
104eb4: f003 fcb4 bl 108820 <rtems_libio_lock>
104eb8: f857 4b04 ldr.w r4, [r7], #4
for (
104ebc: 42bc cmp r4, r7
104ebe: d02b beq.n 104f18 <rtems_filesystem_register+0xbc>
if ( strcmp( entry->type, fa->type ) != 0 ) {
104ec0: 68a0 ldr r0, [r4, #8]
104ec2: 4631 mov r1, r6
104ec4: f007 fcf0 bl 10c8a8 <strcmp>
104ec8: b9a0 cbnz r0, 104ef4 <rtems_filesystem_register+0x98>
fa->mount_h = entry->mount_h;
104eca: 68e4 ldr r4, [r4, #12]
rtems_libio_unlock();
104ecc: f003 fcae bl 10882c <rtems_libio_unlock>
if ( rtems_filesystem_get_mount_handler( type ) == NULL ) {
104ed0: b9ac cbnz r4, 104efe <rtems_filesystem_register+0xa2>
104ed2: 4f17 ldr r7, [pc, #92] ; (104f30 <rtems_filesystem_register+0xd4>)
104ed4: f1a7 0804 sub.w r8, r7, #4
old_last = tail->previous;
104ed8: f8d8 3008 ldr.w r3, [r8, #8]
the_node->next = tail;
104edc: 602f str r7, [r5, #0]
tail->previous = the_node;
104ede: f8c8 5008 str.w r5, [r8, #8]
old_last->next = the_node;
104ee2: 601d str r5, [r3, #0]
the_node->previous = old_last;
104ee4: 606b str r3, [r5, #4]
rtems_libio_unlock();
free( fsn );
rtems_set_errno_and_return_minus_one( EINVAL );
}
rtems_libio_unlock();
104ee6: f003 fca1 bl 10882c <rtems_libio_unlock>
return 0;
104eea: 2000 movs r0, #0
}
104eec: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
fa->mount_h = entry->mount_h;
104ef0: 6864 ldr r4, [r4, #4] <== NOT EXECUTED
if ( !stop ) {
104ef2: e7ed b.n 104ed0 <rtems_filesystem_register+0x74> <== NOT EXECUTED
return the_node->next;
104ef4: 6824 ldr r4, [r4, #0]
for (
104ef6: 42bc cmp r4, r7
104ef8: d1e2 bne.n 104ec0 <rtems_filesystem_register+0x64>
find_arg fa = {
104efa: 2400 movs r4, #0
104efc: e7e6 b.n 104ecc <rtems_filesystem_register+0x70>
rtems_libio_unlock();
104efe: f003 fc95 bl 10882c <rtems_libio_unlock>
free( fsn );
104f02: 4628 mov r0, r5
104f04: f003 fbf6 bl 1086f4 <free>
rtems_set_errno_and_return_minus_one( EINVAL );
104f08: f007 f93a bl 10c180 <__errno>
104f0c: 2216 movs r2, #22
104f0e: 4603 mov r3, r0
104f10: 601a str r2, [r3, #0]
104f12: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff
104f16: e7e9 b.n 104eec <rtems_filesystem_register+0x90>
rtems_libio_unlock();
104f18: f003 fc88 bl 10882c <rtems_libio_unlock>
return fa.mount_h;
104f1c: e7dc b.n 104ed8 <rtems_filesystem_register+0x7c>
rtems_set_errno_and_return_minus_one( ENOMEM );
104f1e: f007 f92f bl 10c180 <__errno>
104f22: 220c movs r2, #12
104f24: 4603 mov r3, r0
104f26: 601a str r2, [r3, #0]
104f28: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff
104f2c: e7de b.n 104eec <rtems_filesystem_register+0x90>
104f2e: bf00 nop
104f30: 002000d0 .word 0x002000d0
00104d9c <rtems_gxx_key_create>:
}
int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
104d9c: b570 push {r4, r5, r6, lr}
104d9e: 4606 mov r6, r0
int eno;
pthread_key_t *pkey;
pkey = malloc( sizeof( *pkey ) );
104da0: 2004 movs r0, #4
{
104da2: 460d mov r5, r1
pkey = malloc( sizeof( *pkey ) );
104da4: f000 f8ac bl 104f00 <malloc>
*key = pkey;
104da8: 6030 str r0, [r6, #0]
if ( pkey == NULL )
104daa: b170 cbz r0, 104dca <rtems_gxx_key_create+0x2e>
printk(
"gxx_wrappers: create key=%x, dtor=%x, pkey=%x\n", key, dtor, pkey
);
#endif
eno = pthread_key_create(pkey, dtor);
104dac: 4629 mov r1, r5
104dae: 4604 mov r4, r0
104db0: f001 ff58 bl 106c64 <pthread_key_create>
if ( eno != 0 ) {
104db4: 4605 mov r5, r0
104db6: b908 cbnz r0, 104dbc <rtems_gxx_key_create+0x20>
free( pkey );
*key = NULL;
}
return eno;
}
104db8: 4628 mov r0, r5
104dba: bd70 pop {r4, r5, r6, pc}
free( pkey );
104dbc: 4620 mov r0, r4 <== NOT EXECUTED
104dbe: f005 fcfb bl 10a7b8 <free> <== NOT EXECUTED
*key = NULL;
104dc2: 2300 movs r3, #0 <== NOT EXECUTED
}
104dc4: 4628 mov r0, r5 <== NOT EXECUTED
*key = NULL;
104dc6: 6033 str r3, [r6, #0] <== NOT EXECUTED
}
104dc8: bd70 pop {r4, r5, r6, pc} <== NOT EXECUTED
return ENOMEM;
104dca: 250c movs r5, #12 <== NOT EXECUTED
104dcc: e7f4 b.n 104db8 <rtems_gxx_key_create+0x1c> <== NOT EXECUTED
104dce: bf00 nop
00104e94 <rtems_gxx_recursive_mutex_init>:
void rtems_gxx_recursive_mutex_init(__gthread_recursive_mutex_t *mutex)
{
104e94: b510 push {r4, lr}
104e96: 4604 mov r4, r0
104e98: b082 sub sp, #8
status = rtems_semaphore_create(
104e9a: f244 3032 movw r0, #17202 ; 0x4332
104e9e: 2300 movs r3, #0
104ea0: 2254 movs r2, #84 ; 0x54
104ea2: 2101 movs r1, #1
104ea4: f2c4 7043 movt r0, #18243 ; 0x4743
104ea8: 9400 str r4, [sp, #0]
104eaa: f002 f829 bl 106f00 <rtems_semaphore_create>
if ( status != RTEMS_SUCCESSFUL ) {
104eae: b908 cbnz r0, 104eb4 <rtems_gxx_recursive_mutex_init+0x20>
rtems_gxx_mutex_init(mutex);
}
104eb0: b002 add sp, #8
104eb2: bd10 pop {r4, pc}
_Internal_error( INTERNAL_ERROR_GXX_MUTEX_INIT_FAILED );
104eb4: 2016 movs r0, #22 <== NOT EXECUTED
104eb6: f002 fea1 bl 107bfc <_Internal_error> <== NOT EXECUTED
104eba: bf00 nop
001065f0 <rtems_heap_allocate_aligned_with_boundary>:
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
1065f0: e92d 41f0 stmdb sp!, {r4, r5, r6, r7, r8, lr}
1065f4: f242 7450 movw r4, #10064 ; 0x2750
1065f8: f2c0 0420 movt r4, #32
Heap_Control *heap = RTEMS_Malloc_Heap;
1065fc: f242 7338 movw r3, #10040 ; 0x2738
106600: f2c0 0320 movt r3, #32
{
106604: 4606 mov r6, r0
106606: 6824 ldr r4, [r4, #0]
106608: 460d mov r5, r1
Heap_Control *heap = RTEMS_Malloc_Heap;
10660a: f8d3 8000 ldr.w r8, [r3]
{
10660e: 4617 mov r7, r2
if ( _System_state_Is_up( state ) ) {
106610: 2c02 cmp r4, #2
106612: d010 beq.n 106636 <rtems_heap_allocate_aligned_with_boundary+0x46>
} else if ( _System_state_Is_before_multitasking( state ) ) {
106614: 2c01 cmp r4, #1
106616: d015 beq.n 106644 <rtems_heap_allocate_aligned_with_boundary+0x54>
boundary
);
_RTEMS_Unlock_allocator();
break;
case MALLOC_SYSTEM_STATE_NO_PROTECTION:
p = _Heap_Allocate_aligned_with_boundary(
106618: 4613 mov r3, r2
10661a: 460a mov r2, r1
10661c: 4601 mov r1, r0
10661e: 4640 mov r0, r8
106620: f002 faca bl 108bb8 <_Heap_Allocate_aligned_with_boundary>
106624: 4604 mov r4, r0
* Do not attempt to allocate memory if not in correct system state.
*/
return NULL;
}
if ( p == NULL && alignment == 0 && boundary == 0 ) {
106626: ea54 0305 orrs.w r3, r4, r5
10662a: d11b bne.n 106664 <rtems_heap_allocate_aligned_with_boundary+0x74> <== NEVER TAKEN
10662c: b34f cbz r7, 106682 <rtems_heap_allocate_aligned_with_boundary+0x92>
return NULL;
10662e: 2400 movs r4, #0
*/
if ( p != NULL && rtems_malloc_dirty_helper != NULL )
(*rtems_malloc_dirty_helper)( p, size );
return p;
}
106630: 4620 mov r0, r4
106632: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
106636: f242 7380 movw r3, #10112 ; 0x2780
10663a: f2c0 0320 movt r3, #32
10663e: 691b ldr r3, [r3, #16]
if ( _Thread_Dispatch_is_enabled() ) {
106640: 2b00 cmp r3, #0
106642: d1f4 bne.n 10662e <rtems_heap_allocate_aligned_with_boundary+0x3e>
_RTEMS_Lock_allocator();
106644: f002 fa6e bl 108b24 <_RTEMS_Lock_allocator>
_Malloc_Process_deferred_frees();
106648: f7ff fdfe bl 106248 <_Malloc_Process_deferred_frees>
p = _Heap_Allocate_aligned_with_boundary(
10664c: 463b mov r3, r7
10664e: 462a mov r2, r5
106650: 4631 mov r1, r6
106652: 4640 mov r0, r8
106654: f002 fab0 bl 108bb8 <_Heap_Allocate_aligned_with_boundary>
106658: 4604 mov r4, r0
_RTEMS_Unlock_allocator();
10665a: f002 fa69 bl 108b30 <_RTEMS_Unlock_allocator>
if ( p == NULL && alignment == 0 && boundary == 0 ) {
10665e: ea54 0305 orrs.w r3, r4, r5
106662: d0e3 beq.n 10662c <rtems_heap_allocate_aligned_with_boundary+0x3c>
if ( p != NULL && rtems_malloc_dirty_helper != NULL )
106664: 2c00 cmp r4, #0
106666: d0e2 beq.n 10662e <rtems_heap_allocate_aligned_with_boundary+0x3e>
106668: f242 7334 movw r3, #10036 ; 0x2734
10666c: f2c0 0320 movt r3, #32
106670: 681b ldr r3, [r3, #0]
106672: 2b00 cmp r3, #0
106674: d0dc beq.n 106630 <rtems_heap_allocate_aligned_with_boundary+0x40>
(*rtems_malloc_dirty_helper)( p, size );
106676: 4620 mov r0, r4
106678: 4631 mov r1, r6
10667a: 4798 blx r3
}
10667c: 4620 mov r0, r4
10667e: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
p = (*rtems_malloc_extend_handler)( heap, size );
106682: f647 53d8 movw r3, #32216 ; 0x7dd8
106686: 4631 mov r1, r6
106688: f2c0 0311 movt r3, #17
10668c: 4640 mov r0, r8
10668e: 681b ldr r3, [r3, #0]
106690: 4798 blx r3
106692: 4604 mov r4, r0
106694: e7e6 b.n 106664 <rtems_heap_allocate_aligned_with_boundary+0x74>
106696: bf00 nop
00105030 <rtems_heap_extend_via_sbrk>:
void *rtems_heap_extend_via_sbrk(
Heap_Control *heap,
size_t alloc_size
)
{
ptrdiff_t sbrk_amount = RTEMS_Malloc_Sbrk_amount;
105030: f641 73a0 movw r3, #8096 ; 0x1fa0
{
105034: e92d 41f0 stmdb sp!, {r4, r5, r6, r7, r8, lr}
ptrdiff_t sbrk_amount = RTEMS_Malloc_Sbrk_amount;
105038: f2c0 0320 movt r3, #32
10503c: 681e ldr r6, [r3, #0]
ptrdiff_t sbrk_size = (ptrdiff_t) alloc_size;
ptrdiff_t misaligned = sbrk_amount != 0 ? sbrk_size % sbrk_amount : 0;
10503e: b30e cbz r6, 105084 <rtems_heap_extend_via_sbrk+0x54>
105040: 460c mov r4, r1
105042: 4605 mov r5, r0
105044: 4631 mov r1, r6
105046: 4620 mov r0, r4
ptrdiff_t sbrk_size = (ptrdiff_t) alloc_size;
105048: 4627 mov r7, r4
ptrdiff_t misaligned = sbrk_amount != 0 ? sbrk_size % sbrk_amount : 0;
10504a: f006 fe27 bl 10bc9c <__aeabi_idivmod>
void *return_this = NULL;
if ( misaligned != 0 ) {
10504e: b9e1 cbnz r1, 10508a <rtems_heap_extend_via_sbrk+0x5a>
sbrk_size += sbrk_amount - misaligned;
}
if ( sbrk_size > 0 && sbrk_amount > 0 ) {
105050: 2f00 cmp r7, #0
105052: bfc8 it gt
105054: 2e00 cmpgt r6, #0
105056: dd15 ble.n 105084 <rtems_heap_extend_via_sbrk+0x54> <== ALWAYS TAKEN
void *area_begin = sbrk( sbrk_size );
105058: 4638 mov r0, r7
10505a: f7ff fcaf bl 1049bc <sbrk>
if ( area_begin != (void *) -1 ) {
10505e: 1c43 adds r3, r0, #1
void *area_begin = sbrk( sbrk_size );
105060: 4601 mov r1, r0
if ( area_begin != (void *) -1 ) {
105062: d00f beq.n 105084 <rtems_heap_extend_via_sbrk+0x54>
bool ok = _Protected_heap_Extend( heap, area_begin, sbrk_size );
105064: 463a mov r2, r7
105066: 4628 mov r0, r5
105068: f002 fc00 bl 10786c <_Protected_heap_Extend>
if ( ok ) {
10506c: b138 cbz r0, 10507e <rtems_heap_extend_via_sbrk+0x4e>
RTEMS_INLINE_ROUTINE void *_Protected_heap_Allocate(
Heap_Control *heap,
uintptr_t size
)
{
return _Protected_heap_Allocate_aligned_with_boundary( heap, size, 0, 0 );
10506e: 2300 movs r3, #0
105070: 4621 mov r1, r4
105072: 4628 mov r0, r5
105074: 461a mov r2, r3
}
}
}
return return_this;
}
105076: e8bd 41f0 ldmia.w sp!, {r4, r5, r6, r7, r8, lr}
10507a: f002 bbe5 b.w 107848 <_Protected_heap_Allocate_aligned_with_boundary>
sbrk( -sbrk_size );
10507e: 4278 negs r0, r7
105080: f7ff fc9c bl 1049bc <sbrk>
}
105084: 2000 movs r0, #0
105086: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
sbrk_size += sbrk_amount - misaligned;
10508a: 1a71 subs r1, r6, r1
10508c: 1867 adds r7, r4, r1
10508e: e7df b.n 105050 <rtems_heap_extend_via_sbrk+0x20>
0010718c <rtems_libio_set_private_env>:
{
10718c: b5f8 push {r3, r4, r5, r6, r7, lr}
if (uses_global_env) {
10718e: f64b 55f0 movw r5, #48624 ; 0xbdf0
107192: f2c0 0532 movt r5, #50 ; 0x32
rtems_user_env_t *old_env = rtems_current_user_env;
107196: f000 ff1f bl 107fd8 <rtems_current_user_env_get>
if (uses_global_env) {
10719a: 42a8 cmp r0, r5
rtems_status_code sc = RTEMS_SUCCESSFUL;
10719c: bf18 it ne
10719e: 2400 movne r4, #0
if (uses_global_env) {
1071a0: d001 beq.n 1071a6 <rtems_libio_set_private_env+0x1a>
}
1071a2: 4620 mov r0, r4
1071a4: bdf8 pop {r3, r4, r5, r6, r7, pc}
Thread_Life_state life_state =
1071a6: 4604 mov r4, r0
_Thread_Set_life_protection(THREAD_LIFE_PROTECTED);
1071a8: 2001 movs r0, #1
1071aa: f005 fcf1 bl 10cb90 <_Thread_Set_life_protection>
rtems_user_env_t *new_env = calloc(1, sizeof(*new_env));
1071ae: 2148 movs r1, #72 ; 0x48
_Thread_Set_life_protection(THREAD_LIFE_PROTECTED);
1071b0: 4607 mov r7, r0
rtems_user_env_t *new_env = calloc(1, sizeof(*new_env));
1071b2: 2001 movs r0, #1
1071b4: f7ff fa46 bl 106644 <calloc>
if (new_env != NULL) {
1071b8: 4606 mov r6, r0
1071ba: b398 cbz r0, 107224 <rtems_libio_set_private_env+0x98>
*new_env = *old_env;
1071bc: 2248 movs r2, #72 ; 0x48
1071be: 4621 mov r1, r4
1071c0: f010 ed5e blx 117c80 <memcpy>
rtems_filesystem_global_location_obtain(&old_env->root_directory);
1071c4: 1d20 adds r0, r4, #4
1071c6: f000 fd37 bl 107c38 <rtems_filesystem_global_location_obtain>
new_env->root_directory =
1071ca: 6070 str r0, [r6, #4]
rtems_filesystem_global_location_obtain(&old_env->current_directory);
1071cc: 4620 mov r0, r4
1071ce: f000 fd33 bl 107c38 <rtems_filesystem_global_location_obtain>
return loc->handlers == &rtems_filesystem_null_handlers;
1071d2: 6873 ldr r3, [r6, #4]
new_env->current_directory =
1071d4: 6030 str r0, [r6, #0]
if (
1071d6: 691a ldr r2, [r3, #16]
1071d8: f646 73c0 movw r3, #28608 ; 0x6fc0
1071dc: f2c0 0312 movt r3, #18
1071e0: 429a cmp r2, r3
1071e2: d00f beq.n 107204 <rtems_libio_set_private_env+0x78>
&& !rtems_filesystem_global_location_is_null(new_env->current_directory)
1071e4: 6902 ldr r2, [r0, #16]
1071e6: 429a cmp r2, r3
1071e8: d00c beq.n 107204 <rtems_libio_set_private_env+0x78> <== ALWAYS TAKEN
1071ea: f24e 3380 movw r3, #58240 ; 0xe380
rtems_status_code sc = RTEMS_SUCCESSFUL;
1071ee: 2400 movs r4, #0
1071f0: f2c0 0332 movt r3, #50 ; 0x32
executing->user_environment = new_env;
1071f4: 699b ldr r3, [r3, #24]
1071f6: f8c3 6188 str.w r6, [r3, #392] ; 0x188
_Thread_Set_life_protection(life_state);
1071fa: 4638 mov r0, r7
1071fc: f005 fcc8 bl 10cb90 <_Thread_Set_life_protection>
}
107200: 4620 mov r0, r4
107202: bdf8 pop {r3, r4, r5, r6, r7, pc}
if (!uses_global_env) {
107204: 42ae cmp r6, r5
sc = RTEMS_UNSATISFIED;
107206: bf08 it eq
107208: 240d moveq r4, #13
if (!uses_global_env) {
10720a: d0f6 beq.n 1071fa <rtems_libio_set_private_env+0x6e> <== ALWAYS TAKEN
rtems_filesystem_global_location_release(env->current_directory, false);
10720c: 2100 movs r1, #0
sc = RTEMS_UNSATISFIED;
10720e: 240d movs r4, #13
rtems_filesystem_global_location_release(env->current_directory, false);
107210: f000 fd4a bl 107ca8 <rtems_filesystem_global_location_release>
rtems_filesystem_global_location_release(env->root_directory, false);
107214: 6870 ldr r0, [r6, #4]
107216: 2100 movs r1, #0
107218: f000 fd46 bl 107ca8 <rtems_filesystem_global_location_release>
free(env);
10721c: 4630 mov r0, r6
10721e: f7ff fae3 bl 1067e8 <free>
}
107222: e7ea b.n 1071fa <rtems_libio_set_private_env+0x6e>
sc = RTEMS_NO_MEMORY;
107224: 241a movs r4, #26
107226: e7e8 b.n 1071fa <rtems_libio_set_private_env+0x6e>
00107504 <rtems_mkdir>:
return (retval);
}
int
rtems_mkdir(const char *path, mode_t mode)
{
107504: e92d 47f0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, lr}
107508: b09c sub sp, #112 ; 0x70
10750a: 460f mov r7, r1
int success = 0;
char *dup_path = strdup(path);
10750c: f011 fba8 bl 118c60 <strdup>
if (dup_path != NULL) {
107510: 2800 cmp r0, #0
107512: f000 8085 beq.w 107620 <rtems_mkdir+0x11c>
107516: 4606 mov r6, r0
if (p[0] == '/') /* Skip leading '/'. */
107518: 7800 ldrb r0, [r0, #0]
*p = '/';
10751a: 2500 movs r5, #0
10751c: 2301 movs r3, #1
oumask = umask(0);
10751e: 46a9 mov r9, r5
*p = '/';
107520: f04f 082f mov.w r8, #47 ; 0x2f
if (p[0] == '/') /* Skip leading '/'. */
107524: 282f cmp r0, #47 ; 0x2f
if (p[0] == '\0')
107526: bf06 itte eq
107528: 7870 ldrbeq r0, [r6, #1]
++p;
10752a: 1c74 addeq r4, r6, #1
if (p[0] == '\0')
10752c: 4634 movne r4, r6
10752e: 3401 adds r4, #1
107530: b1a8 cbz r0, 10755e <rtems_mkdir+0x5a>
else if (p[0] != '/')
107532: 282f cmp r0, #47 ; 0x2f
107534: d10f bne.n 107556 <rtems_mkdir+0x52>
if (!last && p[1] == '\0')
107536: 7822 ldrb r2, [r4, #0]
*p = '\0';
107538: f804 9c01 strb.w r9, [r4, #-1]
if (first) {
10753c: 2b00 cmp r3, #0
10753e: d164 bne.n 10760a <rtems_mkdir+0x106>
if (last)
107540: b1aa cbz r2, 10756e <rtems_mkdir+0x6a>
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
107542: f240 11ff movw r1, #511 ; 0x1ff
107546: 4630 mov r0, r6
107548: f7ff fab8 bl 106abc <mkdir>
10754c: 2800 cmp r0, #0
10754e: db1f blt.n 107590 <rtems_mkdir+0x8c>
*p = '/';
107550: 2300 movs r3, #0
107552: f804 8c01 strb.w r8, [r4, #-1]
if (p[0] == '\0')
107556: f814 0b01 ldrb.w r0, [r4], #1
10755a: 2800 cmp r0, #0
10755c: d1e9 bne.n 107532 <rtems_mkdir+0x2e>
if (first) {
10755e: b133 cbz r3, 10756e <rtems_mkdir+0x6a>
oumask = umask(0);
107560: f000 fc60 bl 107e24 <umask>
107564: 4605 mov r5, r0
(void)umask(numask);
107566: f020 00c0 bic.w r0, r0, #192 ; 0xc0
10756a: f000 fc5b bl 107e24 <umask>
(void)umask(oumask);
10756e: 4628 mov r0, r5
107570: f000 fc58 bl 107e24 <umask>
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
107574: 4639 mov r1, r7
107576: 4630 mov r0, r6
107578: f7ff faa0 bl 106abc <mkdir>
10757c: 2800 cmp r0, #0
10757e: db23 blt.n 1075c8 <rtems_mkdir+0xc4>
107580: 2400 movs r4, #0
success = build(dup_path, mode);
free(dup_path);
107582: 4630 mov r0, r6
107584: f7ff f930 bl 1067e8 <free>
}
return success != 0 ? 0 : -1;
}
107588: 4620 mov r0, r4
10758a: b01c add sp, #112 ; 0x70
10758c: e8bd 87f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, pc}
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
107590: f04f 0a00 mov.w sl, #0
if (errno == EEXIST || errno == EISDIR) {
107594: f00f f9cc bl 116930 <__errno>
107598: 6803 ldr r3, [r0, #0]
10759a: 2b11 cmp r3, #17
10759c: d004 beq.n 1075a8 <rtems_mkdir+0xa4>
10759e: f00f f9c7 bl 116930 <__errno>
1075a2: 6803 ldr r3, [r0, #0]
1075a4: 2b15 cmp r3, #21
1075a6: d112 bne.n 1075ce <rtems_mkdir+0xca> <== NEVER TAKEN
if (stat(path, &sb) < 0) {
1075a8: a902 add r1, sp, #8
1075aa: 4630 mov r0, r6
1075ac: f000 f84c bl 107648 <stat>
1075b0: 2800 cmp r0, #0
1075b2: db0c blt.n 1075ce <rtems_mkdir+0xca> <== ALWAYS TAKEN
} else if (!S_ISDIR(sb.st_mode)) {
1075b4: 9b06 ldr r3, [sp, #24]
1075b6: f403 4370 and.w r3, r3, #61440 ; 0xf000
1075ba: f5b3 4f80 cmp.w r3, #16384 ; 0x4000
1075be: d10f bne.n 1075e0 <rtems_mkdir+0xdc>
if (last)
1075c0: f1ba 0f00 cmp.w sl, #0
1075c4: d1dc bne.n 107580 <rtems_mkdir+0x7c>
1075c6: e7c3 b.n 107550 <rtems_mkdir+0x4c>
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
1075c8: f04f 0a01 mov.w sl, #1
1075cc: e7e2 b.n 107594 <rtems_mkdir+0x90>
if (!first && !last)
1075ce: f1ba 0f00 cmp.w sl, #0
1075d2: d114 bne.n 1075fe <rtems_mkdir+0xfa> <== NEVER TAKEN
(void)umask(oumask);
1075d4: 4628 mov r0, r5
1075d6: f04f 34ff mov.w r4, #4294967295 ; 0xffffffff
1075da: f000 fc23 bl 107e24 <umask>
1075de: e7d0 b.n 107582 <rtems_mkdir+0x7e>
if (last)
1075e0: f1ba 0f00 cmp.w sl, #0
1075e4: d006 beq.n 1075f4 <rtems_mkdir+0xf0>
errno = EEXIST;
1075e6: f00f f9a3 bl 116930 <__errno>
1075ea: 2311 movs r3, #17
1075ec: f04f 34ff mov.w r4, #4294967295 ; 0xffffffff
1075f0: 6003 str r3, [r0, #0]
1075f2: e7c6 b.n 107582 <rtems_mkdir+0x7e>
errno = ENOTDIR;
1075f4: f00f f99c bl 116930 <__errno>
1075f8: 2314 movs r3, #20
1075fa: 6003 str r3, [r0, #0]
if (!first && !last)
1075fc: e7ea b.n 1075d4 <rtems_mkdir+0xd0>
free(dup_path);
1075fe: 4630 mov r0, r6
return success != 0 ? 0 : -1;
107600: f04f 34ff mov.w r4, #4294967295 ; 0xffffffff
free(dup_path);
107604: f7ff f8f0 bl 1067e8 <free>
return success != 0 ? 0 : -1;
107608: e7be b.n 107588 <rtems_mkdir+0x84>
oumask = umask(0);
10760a: 2000 movs r0, #0
10760c: 9201 str r2, [sp, #4]
10760e: f000 fc09 bl 107e24 <umask>
107612: 4605 mov r5, r0
(void)umask(numask);
107614: f020 00c0 bic.w r0, r0, #192 ; 0xc0
107618: f000 fc04 bl 107e24 <umask>
10761c: 9a01 ldr r2, [sp, #4]
first = 0;
10761e: e78f b.n 107540 <rtems_mkdir+0x3c>
return success != 0 ? 0 : -1;
107620: f04f 34ff mov.w r4, #4294967295 ; 0xffffffff
107624: e7b0 b.n 107588 <rtems_mkdir+0x84>
107626: bf00 nop
001064f0 <rtems_print_printer_printf>:
}
void rtems_print_printer_printf(rtems_printer *printer)
{
printer->context = NULL;
printer->printer = rtems_printf_plugin;
1064f0: f246 43e9 movw r3, #25833 ; 0x64e9 <== NOT EXECUTED
printer->context = NULL;
1064f4: 2200 movs r2, #0 <== NOT EXECUTED
printer->printer = rtems_printf_plugin;
1064f6: f2c0 0310 movt r3, #16 <== NOT EXECUTED
1064fa: e9c0 2300 strd r2, r3, [r0] <== NOT EXECUTED
}
1064fe: 4770 bx lr <== NOT EXECUTED
00106c9c <rtems_printf>:
106c9c: b1a0 cbz r0, 106cc8 <rtems_printf+0x2c>
int rtems_printf(
const rtems_printer *printer,
const char *format,
...
)
{
106c9e: b40e push {r1, r2, r3}
106ca0: 6843 ldr r3, [r0, #4]
106ca2: b500 push {lr}
106ca4: b082 sub sp, #8
106ca6: b14b cbz r3, 106cbc <rtems_printf+0x20>
int len = 0;
if ( rtems_print_printer_valid( printer ) ) {
va_list ap;
va_start( ap, format );
106ca8: aa04 add r2, sp, #16
len = printer->printer( printer->context, format, ap );
106caa: 9903 ldr r1, [sp, #12]
106cac: 6800 ldr r0, [r0, #0]
va_start( ap, format );
106cae: 9201 str r2, [sp, #4]
len = printer->printer( printer->context, format, ap );
106cb0: 4798 blx r3
va_end( ap );
}
return len;
}
106cb2: b002 add sp, #8
106cb4: f85d eb04 ldr.w lr, [sp], #4
106cb8: b003 add sp, #12
106cba: 4770 bx lr
int len = 0;
106cbc: 4618 mov r0, r3 <== NOT EXECUTED
}
106cbe: b002 add sp, #8 <== NOT EXECUTED
106cc0: f85d eb04 ldr.w lr, [sp], #4 <== NOT EXECUTED
106cc4: b003 add sp, #12 <== NOT EXECUTED
106cc6: 4770 bx lr <== NOT EXECUTED
106cc8: 4770 bx lr
106cca: bf00 nop
00106dd0 <rtems_resource_snapshot_take>:
return count;
}
void rtems_resource_snapshot_take(rtems_resource_snapshot *snapshot)
{
106dd0: b5f0 push {r4, r5, r6, r7, lr}
uint32_t *active;
size_t i;
memset(snapshot, 0, sizeof(*snapshot));
106dd2: 22f8 movs r2, #248 ; 0xf8
{
106dd4: b083 sub sp, #12
memset(snapshot, 0, sizeof(*snapshot));
106dd6: 2100 movs r1, #0
{
106dd8: 4606 mov r6, r0
memset(snapshot, 0, sizeof(*snapshot));
106dda: f00a f8e1 bl 110fa0 <memset>
_RTEMS_Lock_allocator();
106dde: f001 fea1 bl 108b24 <_RTEMS_Lock_allocator>
_Thread_Kill_zombies();
106de2: f004 fa33 bl 10b24c <_Thread_Kill_zombies>
get_heap_info(RTEMS_Malloc_Heap, &snapshot->heap_info);
106de6: f242 7338 movw r3, #10040 ; 0x2738
_Heap_Get_information(heap, info);
106dea: f106 0158 add.w r1, r6, #88 ; 0x58
get_heap_info(RTEMS_Malloc_Heap, &snapshot->heap_info);
106dee: f2c0 0320 movt r3, #32
106df2: 4c31 ldr r4, [pc, #196] ; (106eb8 <rtems_resource_snapshot_take+0xe8>)
_Heap_Get_information(heap, info);
106df4: 6818 ldr r0, [r3, #0]
106df6: f106 05b4 add.w r5, r6, #180 ; 0xb4
106dfa: f002 f941 bl 109080 <_Heap_Get_information>
memset(&info->Stats, 0, sizeof(info->Stats));
106dfe: 2240 movs r2, #64 ; 0x40
106e00: 2100 movs r1, #0
106e02: f106 0070 add.w r0, r6, #112 ; 0x70
106e06: f104 0778 add.w r7, r4, #120 ; 0x78
106e0a: f00a f8c9 bl 110fa0 <memset>
_Heap_Get_information(heap, info);
106e0e: f242 70d8 movw r0, #10200 ; 0x27d8
106e12: 4631 mov r1, r6
106e14: f2c0 0020 movt r0, #32
106e18: f002 f932 bl 109080 <_Heap_Get_information>
memset(&info->Stats, 0, sizeof(info->Stats));
106e1c: 2100 movs r1, #0
106e1e: 2240 movs r2, #64 ; 0x40
106e20: f106 0018 add.w r0, r6, #24
106e24: f00a f8bc bl 110fa0 <memset>
106e28: 2102 movs r1, #2
106e2a: 2003 movs r0, #3
106e2c: e003 b.n 106e36 <rtems_resource_snapshot_take+0x66>
active = &snapshot->active_posix_keys;
for (i = 0; i < RTEMS_ARRAY_SIZE(objects_info_table); ++i) {
const Objects_Information *information;
information = _Objects_Get_information(
106e2e: f854 0c08 ldr.w r0, [r4, #-8]
106e32: f834 1c04 ldrh.w r1, [r4, #-4]
for (i = 0; i < RTEMS_ARRAY_SIZE(objects_info_table); ++i) {
106e36: 3408 adds r4, #8
information = _Objects_Get_information(
106e38: f003 f8e6 bl 10a008 <_Objects_Get_information>
objects_info_table[i].api,
objects_info_table[i].cls
);
if (information != NULL) {
106e3c: b110 cbz r0, 106e44 <rtems_resource_snapshot_take+0x74>
active[i] = _Objects_Active_count(information);
106e3e: f003 f8c1 bl 109fc4 <_Objects_Active_count>
106e42: 6028 str r0, [r5, #0]
for (i = 0; i < RTEMS_ARRAY_SIZE(objects_info_table); ++i) {
106e44: 42bc cmp r4, r7
106e46: f105 0504 add.w r5, r5, #4
106e4a: d1f0 bne.n 106e2e <rtems_resource_snapshot_take+0x5e>
}
}
_RTEMS_Unlock_allocator();
106e4c: f001 fe70 bl 108b30 <_RTEMS_Unlock_allocator>
_Objects_Get_next(*id, &_POSIX_Keys_Information, id);
106e50: f240 17e0 movw r7, #480 ; 0x1e0
Objects_Id id = OBJECTS_ID_INITIAL_INDEX;
106e54: 2300 movs r3, #0
while ((the_key = get_next_key(&id)) != NULL ) {
106e56: 4618 mov r0, r3
uint32_t count = 0;
106e58: 461d mov r5, r3
_Objects_Get_next(*id, &_POSIX_Keys_Information, id);
106e5a: f2c0 0720 movt r7, #32
Objects_Id id = OBJECTS_ID_INITIAL_INDEX;
106e5e: 9301 str r3, [sp, #4]
while ((the_key = get_next_key(&id)) != NULL ) {
106e60: e005 b.n 106e6e <rtems_resource_snapshot_take+0x9e>
count += _Chain_Node_count_unprotected(&the_key->Key_value_pairs);
106e62: f001 fe9d bl 108ba0 <_Chain_Node_count_unprotected>
106e66: 4405 add r5, r0
* previous thread life protection state and thus may not return if the
* executing thread was restarted or deleted in the mean-time.
*/
RTEMS_INLINE_ROUTINE void _Objects_Allocator_unlock( void )
{
_RTEMS_Unlock_allocator();
106e68: f001 fe62 bl 108b30 <_RTEMS_Unlock_allocator>
_Objects_Get_next(*id, &_POSIX_Keys_Information, id);
106e6c: 9801 ldr r0, [sp, #4]
106e6e: aa01 add r2, sp, #4
106e70: 4639 mov r1, r7
106e72: f003 f8e3 bl 10a03c <_Objects_Get_next>
while ((the_key = get_next_key(&id)) != NULL ) {
106e76: 4604 mov r4, r0
count += _Chain_Node_count_unprotected(&the_key->Key_value_pairs);
106e78: 3014 adds r0, #20
while ((the_key = get_next_key(&id)) != NULL ) {
106e7a: 2c00 cmp r4, #0
106e7c: d1f1 bne.n 106e62 <rtems_resource_snapshot_take+0x92>
snapshot->active_posix_key_value_pairs = get_active_posix_key_value_pairs();
106e7e: f8c6 50b0 str.w r5, [r6, #176] ; 0xb0
rtems_libio_lock();
106e82: f7ff fb39 bl 1064f8 <rtems_libio_lock>
iop = rtems_libio_iop_free_head;
106e86: f242 7330 movw r3, #10032 ; 0x2730
106e8a: f2c0 0320 movt r3, #32
106e8e: 681b ldr r3, [r3, #0]
while (iop != NULL) {
106e90: b17b cbz r3, 106eb2 <rtems_resource_snapshot_take+0xe2>
iop = iop->data1;
106e92: 6adb ldr r3, [r3, #44] ; 0x2c
++free_count;
106e94: 3401 adds r4, #1
while (iop != NULL) {
106e96: 2b00 cmp r3, #0
106e98: d1fb bne.n 106e92 <rtems_resource_snapshot_take+0xc2>
rtems_libio_unlock();
106e9a: f7ff fb33 bl 106504 <rtems_libio_unlock>
return (int) rtems_libio_number_iops - free_count;
106e9e: f647 1330 movw r3, #31024 ; 0x7930
106ea2: f2c0 0311 movt r3, #17
106ea6: 681b ldr r3, [r3, #0]
106ea8: 1b1c subs r4, r3, r4
snapshot->open_files = open_files();
106eaa: f8c6 40f0 str.w r4, [r6, #240] ; 0xf0
}
106eae: b003 add sp, #12
106eb0: bdf0 pop {r4, r5, r6, r7, pc}
int free_count = 0;
106eb2: 461c mov r4, r3
106eb4: e7f1 b.n 106e9a <rtems_resource_snapshot_take+0xca>
106eb6: bf00 nop
106eb8: 00117e24 .word 0x00117e24
00106c78 <rtems_termios_close>:
{
106c78: b538 push {r3, r4, r5, lr}
106c7a: 4604 mov r4, r0
struct rtems_termios_tty *tty = args->iop->data1;
106c7c: 6823 ldr r3, [r4, #0]
_Mutex_Acquire( mutex );
106c7e: f240 1098 movw r0, #408 ; 0x198
106c82: f2c0 0020 movt r0, #32
106c86: 6add ldr r5, [r3, #44] ; 0x2c
106c88: f002 fe94 bl 1099b4 <_Mutex_Acquire>
if (tty->refcount == 1) {
106c8c: 68ab ldr r3, [r5, #8]
106c8e: 2b01 cmp r3, #1
106c90: d00a beq.n 106ca8 <rtems_termios_close+0x30> <== NEVER TAKEN
if (--tty->refcount == 0) {
106c92: 3b01 subs r3, #1 <== NOT EXECUTED
106c94: 60ab str r3, [r5, #8] <== NOT EXECUTED
106c96: b17b cbz r3, 106cb8 <rtems_termios_close+0x40> <== NOT EXECUTED
_Mutex_Release( mutex );
106c98: f240 1098 movw r0, #408 ; 0x198
106c9c: f2c0 0020 movt r0, #32
106ca0: f002 feb4 bl 109a0c <_Mutex_Release>
}
106ca4: 2000 movs r0, #0
106ca6: bd38 pop {r3, r4, r5, pc}
rtems_termios_ttyTail = tty->back;
106ca8: e9d5 3200 ldrd r3, r2, [r5]
if (tty->forw == NULL) {
106cac: b17b cbz r3, 106cce <rtems_termios_close+0x56>
tty->forw->back = tty->back;
106cae: 605a str r2, [r3, #4] <== NOT EXECUTED
if (tty->back == NULL) {
106cb0: b142 cbz r2, 106cc4 <rtems_termios_close+0x4c> <== NOT EXECUTED
rtems_termios_ttyHead = tty->forw;
106cb2: 6013 str r3, [r2, #0] <== NOT EXECUTED
if (--tty->refcount == 0) {
106cb4: 2300 movs r3, #0
106cb6: 60ab str r3, [r5, #8]
rtems_termios_destroy_tty (tty, arg, true);
106cb8: 2201 movs r2, #1
106cba: 4621 mov r1, r4
106cbc: 4628 mov r0, r5
106cbe: f7fe ff85 bl 105bcc <rtems_termios_destroy_tty>
106cc2: e7e9 b.n 106c98 <rtems_termios_close+0x20>
rtems_termios_ttyHead = tty->forw;
106cc4: f242 3270 movw r2, #9072 ; 0x2370 <== NOT EXECUTED
106cc8: f2c0 0220 movt r2, #32 <== NOT EXECUTED
106ccc: e7f1 b.n 106cb2 <rtems_termios_close+0x3a> <== NOT EXECUTED
rtems_termios_ttyTail = tty->back;
106cce: f242 3174 movw r1, #9076 ; 0x2374
106cd2: f2c0 0120 movt r1, #32
106cd6: 600a str r2, [r1, #0]
if ( rtems_termios_ttyTail != NULL ) {
106cd8: b112 cbz r2, 106ce0 <rtems_termios_close+0x68>
rtems_termios_ttyTail->forw = NULL;
106cda: 6013 str r3, [r2, #0] <== NOT EXECUTED
tty->back->forw = tty->forw;
106cdc: 682b ldr r3, [r5, #0] <== NOT EXECUTED
106cde: e7e8 b.n 106cb2 <rtems_termios_close+0x3a> <== NOT EXECUTED
rtems_termios_ttyHead = tty->forw;
106ce0: f242 3370 movw r3, #9072 ; 0x2370
106ce4: f2c0 0320 movt r3, #32
106ce8: 601a str r2, [r3, #0]
if ( rtems_termios_ttyHead != NULL ) {
106cea: e7e3 b.n 106cb4 <rtems_termios_close+0x3c>
0010e6b4 <rtems_termios_dequeue_characters>:
{
10e6b4: b510 push {r4, lr}
if (tty->handler.mode == TERMIOS_TASK_DRIVEN) {
10e6b6: f8d0 413c ldr.w r4, [r0, #316] ; 0x13c
tty->t_dqlen += len;
10e6ba: f8d0 20e0 ldr.w r2, [r0, #224] ; 0xe0
if (tty->handler.mode == TERMIOS_TASK_DRIVEN) {
10e6be: 2c02 cmp r4, #2
tty->t_dqlen += len;
10e6c0: 440a add r2, r1
10e6c2: f8c0 20e0 str.w r2, [r0, #224] ; 0xe0
if (tty->handler.mode == TERMIOS_TASK_DRIVEN) {
10e6c6: d011 beq.n 10e6ec <rtems_termios_dequeue_characters+0x38>
if (tty->t_line == PPPDISC ) {
10e6c8: f8d0 315c ldr.w r3, [r0, #348] ; 0x15c
10e6cc: 2b05 cmp r3, #5
10e6ce: d003 beq.n 10e6d8 <rtems_termios_dequeue_characters+0x24>
}
10e6d0: e8bd 4010 ldmia.w sp!, {r4, lr}
return rtems_termios_refill_transmitter(tty);
10e6d4: f7fe bda6 b.w 10d224 <rtems_termios_refill_transmitter>
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
10e6d8: f644 73c8 movw r3, #20424 ; 0x4fc8
10e6dc: f2c0 0320 movt r3, #32
10e6e0: f8d3 30b4 ldr.w r3, [r3, #180] ; 0xb4
10e6e4: b103 cbz r3, 10e6e8 <rtems_termios_dequeue_characters+0x34>
rtems_termios_linesw[tty->t_line].l_start(tty);
10e6e6: 4798 blx r3
}
10e6e8: 2000 movs r0, #0
10e6ea: bd10 pop {r4, pc}
sc = rtems_event_send(tty->txTaskId, TERMIOS_TX_START_EVENT);
10e6ec: f8d0 0158 ldr.w r0, [r0, #344] ; 0x158
10e6f0: 4621 mov r1, r4
10e6f2: f000 f93f bl 10e974 <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
10e6f6: 2800 cmp r0, #0
10e6f8: d0f6 beq.n 10e6e8 <rtems_termios_dequeue_characters+0x34> <== NEVER TAKEN
rtems_fatal_error_occurred (sc);
10e6fa: f7f8 f827 bl 10674c <rtems_fatal_error_occurred> <== NOT EXECUTED
10e6fe: bf00 nop
0010e3a4 <rtems_termios_enqueue_raw_characters>:
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
10e3a4: f8d0 315c ldr.w r3, [r0, #348] ; 0x15c
{
10e3a8: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
10e3ac: f644 78c8 movw r8, #20424 ; 0x4fc8
10e3b0: f2c0 0820 movt r8, #32
{
10e3b4: b087 sub sp, #28
10e3b6: 4604 mov r4, r0
10e3b8: 460e mov r6, r1
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
10e3ba: eb08 1343 add.w r3, r8, r3, lsl #5
{
10e3be: 4615 mov r5, r2
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
10e3c0: 691b ldr r3, [r3, #16]
10e3c2: b1e3 cbz r3, 10e3fe <rtems_termios_enqueue_raw_characters+0x5a>
while (len--) {
10e3c4: b16a cbz r2, 10e3e2 <rtems_termios_enqueue_raw_characters+0x3e>
10e3c6: 460f mov r7, r1
10e3c8: e004 b.n 10e3d4 <rtems_termios_enqueue_raw_characters+0x30>
rtems_termios_linesw[tty->t_line].l_rint(c,tty);
10e3ca: f8d4 315c ldr.w r3, [r4, #348] ; 0x15c
10e3ce: eb08 1343 add.w r3, r8, r3, lsl #5
10e3d2: 691b ldr r3, [r3, #16]
10e3d4: f817 0b01 ldrb.w r0, [r7], #1
10e3d8: 4621 mov r1, r4
10e3da: 4798 blx r3
while (len--) {
10e3dc: 1beb subs r3, r5, r7
10e3de: 42de cmn r6, r3
10e3e0: d1f3 bne.n 10e3ca <rtems_termios_enqueue_raw_characters+0x26>
if (tty->tty_rcv.sw_pfn != NULL && !tty->tty_rcvwakeup) {
10e3e2: f8d4 316c ldr.w r3, [r4, #364] ; 0x16c
10e3e6: b123 cbz r3, 10e3f2 <rtems_termios_enqueue_raw_characters+0x4e>
10e3e8: f894 5174 ldrb.w r5, [r4, #372] ; 0x174
10e3ec: 2d00 cmp r5, #0
10e3ee: f000 80f5 beq.w 10e5dc <rtems_termios_enqueue_raw_characters+0x238> <== NEVER TAKEN
return 0;
10e3f2: f04f 0900 mov.w r9, #0
}
10e3f6: 4648 mov r0, r9
10e3f8: b007 add sp, #28
10e3fa: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
int dropped = 0;
10e3fe: 4691 mov r9, r2
while (len--) {
10e400: 2a00 cmp r2, #0
10e402: d07d beq.n 10e500 <rtems_termios_enqueue_raw_characters+0x15c> <== ALWAYS TAKEN
rtems_termios_device_context *ctx = tty->device_context;
10e404: f8d0 817c ldr.w r8, [r0, #380] ; 0x17c
bool flow_rcv = false; /* true, if flow control char received */
10e408: 469a mov sl, r3
rtems_termios_device_context *ctx = tty->device_context;
10e40a: 460f mov r7, r1
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
10e40c: 4691 mov r9, r2
10e40e: 4655 mov r5, sl
10e410: f100 0350 add.w r3, r0, #80 ; 0x50
10e414: e9cd a302 strd sl, r3, [sp, #8]
if (tty->flow_ctrl & FL_MDXON) {
10e418: f8d4 3148 ldr.w r3, [r4, #328] ; 0x148
c = *buf++;
10e41c: f817 0b01 ldrb.w r0, [r7], #1
if (tty->flow_ctrl & FL_MDXON) {
10e420: 059a lsls r2, r3, #22
10e422: d508 bpl.n 10e436 <rtems_termios_enqueue_raw_characters+0x92>
if (c == tty->termios.c_cc[VSTOP]) {
10e424: f894 306d ldrb.w r3, [r4, #109] ; 0x6d
if (c == tty->termios.c_cc[VSTART]) {
10e428: f894 206c ldrb.w r2, [r4, #108] ; 0x6c
if (c == tty->termios.c_cc[VSTOP]) {
10e42c: 4283 cmp r3, r0
10e42e: f000 80a7 beq.w 10e580 <rtems_termios_enqueue_raw_characters+0x1dc>
else if (c == tty->termios.c_cc[VSTART]) {
10e432: 4290 cmp r0, r2
10e434: d071 beq.n 10e51a <rtems_termios_enqueue_raw_characters+0x176> <== ALWAYS TAKEN
if (flow_rcv) {
10e436: 2d00 cmp r5, #0
10e438: d175 bne.n 10e526 <rtems_termios_enqueue_raw_characters+0x182> <== ALWAYS TAKEN
if (c == '\r' && (tty->termios.c_iflag & IGNCR) != 0) {
10e43a: 280d cmp r0, #13
10e43c: f000 80ab beq.w 10e596 <rtems_termios_enqueue_raw_characters+0x1f2>
c = iprocEarly (c, tty);
10e440: 4621 mov r1, r4
10e442: f7fe fc03 bl 10cc4c <iprocEarly>
( *context->lock_acquire )( context, lock_context );
10e446: f8d8 3014 ldr.w r3, [r8, #20]
10e44a: a905 add r1, sp, #20
10e44c: 9001 str r0, [sp, #4]
10e44e: 4640 mov r0, r8
10e450: 4798 blx r3
head = tty->rawInBuf.Head;
10e452: f8d4 a084 ldr.w sl, [r4, #132] ; 0x84
oldTail = tty->rawInBuf.Tail;
10e456: f8d4 0088 ldr.w r0, [r4, #136] ; 0x88
newTail = (oldTail + 1) % tty->rawInBuf.Size;
10e45a: f8d4 108c ldr.w r1, [r4, #140] ; 0x8c
10e45e: 3001 adds r0, #1
10e460: f7fe fa3c bl 10c8dc <__aeabi_uidivmod>
if ((tty->flow_ctrl & FL_IREQXOF) != 0 && (((newTail - head) %
10e464: f8d4 3148 ldr.w r3, [r4, #328] ; 0x148
newTail = (oldTail + 1) % tty->rawInBuf.Size;
10e468: 468b mov fp, r1
if ((tty->flow_ctrl & FL_IREQXOF) != 0 && (((newTail - head) %
10e46a: 07d8 lsls r0, r3, #31
10e46c: d52a bpl.n 10e4c4 <rtems_termios_enqueue_raw_characters+0x120> <== NEVER TAKEN
tty->rawInBuf.Size) > tty->highwater)) {
10e46e: f8d4 108c ldr.w r1, [r4, #140] ; 0x8c <== NOT EXECUTED
if ((tty->flow_ctrl & FL_IREQXOF) != 0 && (((newTail - head) %
10e472: ebab 000a sub.w r0, fp, sl <== NOT EXECUTED
10e476: f7fe fa31 bl 10c8dc <__aeabi_uidivmod> <== NOT EXECUTED
10e47a: f8d4 3150 ldr.w r3, [r4, #336] ; 0x150 <== NOT EXECUTED
10e47e: 4299 cmp r1, r3 <== NOT EXECUTED
10e480: d920 bls.n 10e4c4 <rtems_termios_enqueue_raw_characters+0x120> <== NOT EXECUTED
tty->flow_ctrl |= FL_IREQXOF;
10e482: f8d4 3148 ldr.w r3, [r4, #328] ; 0x148 <== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
10e486: f240 4202 movw r2, #1026 ; 0x402 <== NOT EXECUTED
tty->flow_ctrl |= FL_IREQXOF;
10e48a: f043 0301 orr.w r3, r3, #1 <== NOT EXECUTED
10e48e: f8c4 3148 str.w r3, [r4, #328] ; 0x148 <== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
10e492: f8d4 3148 ldr.w r3, [r4, #328] ; 0x148 <== NOT EXECUTED
10e496: 4013 ands r3, r2 <== NOT EXECUTED
10e498: f5b3 6f80 cmp.w r3, #1024 ; 0x400 <== NOT EXECUTED
if ((tty->flow_ctrl & FL_OSTOP) ||
10e49c: f8d4 3148 ldr.w r3, [r4, #328] ; 0x148 <== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
10e4a0: f000 80a9 beq.w 10e5f6 <rtems_termios_enqueue_raw_characters+0x252> <== NOT EXECUTED
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
10e4a4: f403 7382 and.w r3, r3, #260 ; 0x104 <== NOT EXECUTED
10e4a8: f5b3 7f80 cmp.w r3, #256 ; 0x100 <== NOT EXECUTED
10e4ac: d10a bne.n 10e4c4 <rtems_termios_enqueue_raw_characters+0x120> <== NOT EXECUTED
tty->flow_ctrl |= FL_IRTSOFF;
10e4ae: f8d4 3148 ldr.w r3, [r4, #328] ; 0x148 <== NOT EXECUTED
10e4b2: f043 0304 orr.w r3, r3, #4 <== NOT EXECUTED
10e4b6: f8c4 3148 str.w r3, [r4, #328] ; 0x148 <== NOT EXECUTED
if (tty->flow.stop_remote_tx != NULL) {
10e4ba: f8d4 3140 ldr.w r3, [r4, #320] ; 0x140 <== NOT EXECUTED
10e4be: b10b cbz r3, 10e4c4 <rtems_termios_enqueue_raw_characters+0x120> <== NOT EXECUTED
tty->flow.stop_remote_tx(ctx);
10e4c0: 4640 mov r0, r8 <== NOT EXECUTED
10e4c2: 4798 blx r3 <== NOT EXECUTED
if (newTail != head) {
10e4c4: 45da cmp sl, fp
10e4c6: d06a beq.n 10e59e <rtems_termios_enqueue_raw_characters+0x1fa>
tty->rawInBuf.theBuf[newTail] = c;
10e4c8: f8d4 3080 ldr.w r3, [r4, #128] ; 0x80
10e4cc: 9a01 ldr r2, [sp, #4]
10e4ce: f803 200b strb.w r2, [r3, fp]
if (tty->tty_rcv.sw_pfn != NULL && !tty->tty_rcvwakeup) {
10e4d2: f8d4 316c ldr.w r3, [r4, #364] ; 0x16c
tty->rawInBuf.Tail = newTail;
10e4d6: f8c4 b088 str.w fp, [r4, #136] ; 0x88
if (tty->tty_rcv.sw_pfn != NULL && !tty->tty_rcvwakeup) {
10e4da: 2b00 cmp r3, #0
10e4dc: d078 beq.n 10e5d0 <rtems_termios_enqueue_raw_characters+0x22c>
10e4de: f894 2174 ldrb.w r2, [r4, #372] ; 0x174
( *context->lock_release )( context, lock_context );
10e4e2: f8d8 3018 ldr.w r3, [r8, #24]
10e4e6: 2a00 cmp r2, #0
10e4e8: f000 8095 beq.w 10e616 <rtems_termios_enqueue_raw_characters+0x272>
10e4ec: a905 add r1, sp, #20
10e4ee: 4640 mov r0, r8
10e4f0: 4798 blx r3
while (len--) {
10e4f2: eba9 0307 sub.w r3, r9, r7
10e4f6: 42de cmn r6, r3
10e4f8: d18e bne.n 10e418 <rtems_termios_enqueue_raw_characters+0x74> <== ALWAYS TAKEN
tty->rawInBufDropped += dropped;
10e4fa: f8dd 9008 ldr.w r9, [sp, #8]
10e4fe: 464a mov r2, r9
10e500: f8d4 30b4 ldr.w r3, [r4, #180] ; 0xb4
_Semaphore_Post_binary( &binary_semaphore->Semaphore );
10e504: f104 0090 add.w r0, r4, #144 ; 0x90
10e508: 4413 add r3, r2
10e50a: f8c4 30b4 str.w r3, [r4, #180] ; 0xb4
10e50e: f000 fb2d bl 10eb6c <_Semaphore_Post_binary>
}
10e512: 4648 mov r0, r9
10e514: b007 add sp, #28
10e516: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
tty->flow_ctrl &= ~FL_ORCVXOF;
10e51a: f8d4 3148 ldr.w r3, [r4, #328] ; 0x148 <== NOT EXECUTED
10e51e: f023 0310 bic.w r3, r3, #16 <== NOT EXECUTED
10e522: f8c4 3148 str.w r3, [r4, #328] ; 0x148 <== NOT EXECUTED
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
10e526: f8d4 3148 ldr.w r3, [r4, #328] ; 0x148
10e52a: f003 0330 and.w r3, r3, #48 ; 0x30
10e52e: 2b20 cmp r3, #32
10e530: bf18 it ne
10e532: 2501 movne r5, #1
10e534: d005 beq.n 10e542 <rtems_termios_enqueue_raw_characters+0x19e> <== ALWAYS TAKEN
while (len--) {
10e536: eba9 0307 sub.w r3, r9, r7
10e53a: 42de cmn r6, r3
10e53c: f47f af6c bne.w 10e418 <rtems_termios_enqueue_raw_characters+0x74> <== ALWAYS TAKEN
10e540: e7db b.n 10e4fa <rtems_termios_enqueue_raw_characters+0x156>
( *context->lock_acquire )( context, lock_context );
10e542: f8d8 3014 ldr.w r3, [r8, #20] <== NOT EXECUTED
10e546: a905 add r1, sp, #20 <== NOT EXECUTED
10e548: 4640 mov r0, r8 <== NOT EXECUTED
10e54a: 4798 blx r3 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
10e54c: f8d4 3148 ldr.w r3, [r4, #328] ; 0x148 <== NOT EXECUTED
10e550: f023 0320 bic.w r3, r3, #32 <== NOT EXECUTED
10e554: f8c4 3148 str.w r3, [r4, #328] ; 0x148 <== NOT EXECUTED
if (tty->rawOutBufState != rob_idle) {
10e558: f8d4 30e4 ldr.w r3, [r4, #228] ; 0xe4 <== NOT EXECUTED
10e55c: b14b cbz r3, 10e572 <rtems_termios_enqueue_raw_characters+0x1ce> <== NOT EXECUTED
ctx, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
10e55e: f8d4 30c0 ldr.w r3, [r4, #192] ; 0xc0 <== NOT EXECUTED
(*tty->handler.write)(
10e562: 2201 movs r2, #1 <== NOT EXECUTED
ctx, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
10e564: f8d4 10b8 ldr.w r1, [r4, #184] ; 0xb8 <== NOT EXECUTED
(*tty->handler.write)(
10e568: 4640 mov r0, r8 <== NOT EXECUTED
10e56a: 4419 add r1, r3 <== NOT EXECUTED
10e56c: f8d4 3130 ldr.w r3, [r4, #304] ; 0x130 <== NOT EXECUTED
10e570: 4798 blx r3 <== NOT EXECUTED
( *context->lock_release )( context, lock_context );
10e572: f8d8 3018 ldr.w r3, [r8, #24] <== NOT EXECUTED
10e576: a905 add r1, sp, #20 <== NOT EXECUTED
10e578: 4640 mov r0, r8 <== NOT EXECUTED
}
10e57a: 2501 movs r5, #1 <== NOT EXECUTED
( *context->lock_release )( context, lock_context );
10e57c: 4798 blx r3 <== NOT EXECUTED
}
10e57e: e7da b.n 10e536 <rtems_termios_enqueue_raw_characters+0x192> <== NOT EXECUTED
if (c == tty->termios.c_cc[VSTART]) {
10e580: 4293 cmp r3, r2
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
10e582: f8d4 3148 ldr.w r3, [r4, #328] ; 0x148
10e586: bf0c ite eq
10e588: f083 0310 eoreq.w r3, r3, #16
tty->flow_ctrl |= FL_ORCVXOF;
10e58c: f043 0310 orrne.w r3, r3, #16
10e590: f8c4 3148 str.w r3, [r4, #328] ; 0x148
10e594: e7c7 b.n 10e526 <rtems_termios_enqueue_raw_characters+0x182>
if (c == '\r' && (tty->termios.c_iflag & IGNCR) != 0) {
10e596: 6d23 ldr r3, [r4, #80] ; 0x50
10e598: 061b lsls r3, r3, #24
10e59a: d4cc bmi.n 10e536 <rtems_termios_enqueue_raw_characters+0x192>
10e59c: e750 b.n 10e440 <rtems_termios_enqueue_raw_characters+0x9c>
++dropped;
10e59e: 9b02 ldr r3, [sp, #8]
if (tty->tty_rcv.sw_pfn != NULL && !tty->tty_rcvwakeup) {
10e5a0: f8d4 216c ldr.w r2, [r4, #364] ; 0x16c
++dropped;
10e5a4: 3301 adds r3, #1
10e5a6: 9302 str r3, [sp, #8]
( *context->lock_release )( context, lock_context );
10e5a8: f8d8 3018 ldr.w r3, [r8, #24]
if (tty->tty_rcv.sw_pfn != NULL && !tty->tty_rcvwakeup) {
10e5ac: 2a00 cmp r2, #0
10e5ae: d09d beq.n 10e4ec <rtems_termios_enqueue_raw_characters+0x148> <== ALWAYS TAKEN
10e5b0: f894 2174 ldrb.w r2, [r4, #372] ; 0x174
10e5b4: 2a00 cmp r2, #0
10e5b6: d199 bne.n 10e4ec <rtems_termios_enqueue_raw_characters+0x148> <== ALWAYS TAKEN
tty->tty_rcvwakeup = true;
10e5b8: f04f 0201 mov.w r2, #1
10e5bc: a905 add r1, sp, #20
10e5be: 4640 mov r0, r8
10e5c0: f884 2174 strb.w r2, [r4, #372] ; 0x174
10e5c4: 4798 blx r3
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
10e5c6: e9d4 315b ldrd r3, r1, [r4, #364] ; 0x16c
10e5ca: 9803 ldr r0, [sp, #12]
10e5cc: 4798 blx r3
10e5ce: e7b2 b.n 10e536 <rtems_termios_enqueue_raw_characters+0x192>
10e5d0: f8d8 3018 ldr.w r3, [r8, #24]
10e5d4: a905 add r1, sp, #20
10e5d6: 4640 mov r0, r8
10e5d8: 4798 blx r3
if (callReciveCallback) {
10e5da: e7ac b.n 10e536 <rtems_termios_enqueue_raw_characters+0x192>
tty->tty_rcvwakeup = true;
10e5dc: 2201 movs r2, #1
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
10e5de: f104 0050 add.w r0, r4, #80 ; 0x50
10e5e2: f8d4 1170 ldr.w r1, [r4, #368] ; 0x170
return 0;
10e5e6: 46a9 mov r9, r5
tty->tty_rcvwakeup = true;
10e5e8: f884 2174 strb.w r2, [r4, #372] ; 0x174
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
10e5ec: 4798 blx r3
}
10e5ee: 4648 mov r0, r9
10e5f0: b007 add sp, #28
10e5f2: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
if ((tty->flow_ctrl & FL_OSTOP) ||
10e5f6: 0699 lsls r1, r3, #26 <== NOT EXECUTED
10e5f8: d531 bpl.n 10e65e <rtems_termios_enqueue_raw_characters+0x2ba> <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
10e5fa: f8d4 3148 ldr.w r3, [r4, #328] ; 0x148 <== NOT EXECUTED
(*tty->handler.write)(ctx,
10e5fe: 2201 movs r2, #1 <== NOT EXECUTED
10e600: f104 016d add.w r1, r4, #109 ; 0x6d <== NOT EXECUTED
10e604: 4640 mov r0, r8 <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
10e606: f043 0302 orr.w r3, r3, #2 <== NOT EXECUTED
10e60a: f8c4 3148 str.w r3, [r4, #328] ; 0x148 <== NOT EXECUTED
(*tty->handler.write)(ctx,
10e60e: f8d4 3130 ldr.w r3, [r4, #304] ; 0x130 <== NOT EXECUTED
10e612: 4798 blx r3 <== NOT EXECUTED
10e614: e756 b.n 10e4c4 <rtems_termios_enqueue_raw_characters+0x120> <== NOT EXECUTED
if ((tty->termios.c_lflag & ICANON) != 0) {
10e616: 6de2 ldr r2, [r4, #92] ; 0x5c
10e618: 05d2 lsls r2, r2, #23
10e61a: d513 bpl.n 10e644 <rtems_termios_enqueue_raw_characters+0x2a0>
c == tty->termios.c_cc[VEOL] || c == tty->termios.c_cc[VEOL2];
10e61c: 9901 ldr r1, [sp, #4]
10e61e: 290a cmp r1, #10
10e620: d0ca beq.n 10e5b8 <rtems_termios_enqueue_raw_characters+0x214>
return c == '\n' || c == tty->termios.c_cc[VEOF] ||
10e622: f894 2060 ldrb.w r2, [r4, #96] ; 0x60
10e626: 428a cmp r2, r1
10e628: d0c6 beq.n 10e5b8 <rtems_termios_enqueue_raw_characters+0x214>
10e62a: f894 2061 ldrb.w r2, [r4, #97] ; 0x61
10e62e: 428a cmp r2, r1
10e630: d0c2 beq.n 10e5b8 <rtems_termios_enqueue_raw_characters+0x214>
if (mustCallReceiveCallback (tty, c, newTail, head)) {
10e632: f894 2062 ldrb.w r2, [r4, #98] ; 0x62
10e636: 428a cmp r2, r1
10e638: d0be beq.n 10e5b8 <rtems_termios_enqueue_raw_characters+0x214>
10e63a: a905 add r1, sp, #20
10e63c: 4640 mov r0, r8
10e63e: 2500 movs r5, #0
10e640: 4798 blx r3
if (callReciveCallback) {
10e642: e778 b.n 10e536 <rtems_termios_enqueue_raw_characters+0x192>
unsigned int rawContentSize = (newTail - head) % tty->rawInBuf.Size;
10e644: f8d4 108c ldr.w r1, [r4, #140] ; 0x8c
10e648: ebab 000a sub.w r0, fp, sl
10e64c: 9301 str r3, [sp, #4]
10e64e: f7fe f945 bl 10c8dc <__aeabi_uidivmod>
return rawContentSize >= tty->termios.c_cc[VMIN];
10e652: f894 2070 ldrb.w r2, [r4, #112] ; 0x70
if (mustCallReceiveCallback (tty, c, newTail, head)) {
10e656: 9b01 ldr r3, [sp, #4]
10e658: 4291 cmp r1, r2
10e65a: d2ad bcs.n 10e5b8 <rtems_termios_enqueue_raw_characters+0x214>
10e65c: e7ed b.n 10e63a <rtems_termios_enqueue_raw_characters+0x296>
if ((tty->flow_ctrl & FL_OSTOP) ||
10e65e: f8d4 30e4 ldr.w r3, [r4, #228] ; 0xe4 <== NOT EXECUTED
10e662: 2b00 cmp r3, #0 <== NOT EXECUTED
10e664: f47f af2e bne.w 10e4c4 <rtems_termios_enqueue_raw_characters+0x120> <== NOT EXECUTED
10e668: e7c7 b.n 10e5fa <rtems_termios_enqueue_raw_characters+0x256> <== NOT EXECUTED
10e66a: bf00 nop
0010df50 <rtems_termios_ioctl>:
struct rtems_termios_tty *tty = args->iop->data1;
10df50: 6803 ldr r3, [r0, #0]
{
10df52: e92d 43f0 stmdb sp!, {r4, r5, r6, r7, r8, r9, lr}
args->ioctl_return = 0;
10df56: 2600 movs r6, #0
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
10df58: f8d0 8008 ldr.w r8, [r0, #8]
{
10df5c: 4605 mov r5, r0
10df5e: b083 sub sp, #12
struct rtems_termios_tty *tty = args->iop->data1;
10df60: 6adc ldr r4, [r3, #44] ; 0x2c
args->ioctl_return = 0;
10df62: 60c6 str r6, [r0, #12]
rtems_mutex_lock (&tty->osem);
10df64: f104 0728 add.w r7, r4, #40 ; 0x28
_Mutex_Acquire( mutex );
10df68: 4638 mov r0, r7
10df6a: f7f9 f98d bl 107288 <_Mutex_Acquire>
switch (args->command) {
10df6e: 6869 ldr r1, [r5, #4]
10df70: f247 4310 movw r3, #29712 ; 0x7410
10df74: f2c8 0304 movt r3, #32772 ; 0x8004
10df78: 4299 cmp r1, r3
10df7a: f000 80fe beq.w 10e17a <rtems_termios_ioctl+0x22a>
10df7e: f240 809f bls.w 10e0c0 <rtems_termios_ioctl+0x170>
10df82: f247 430c movw r3, #29708 ; 0x740c
10df86: f2c8 0308 movt r3, #32776 ; 0x8008
10df8a: 4299 cmp r1, r3
10df8c: f000 811d beq.w 10e1ca <rtems_termios_ioctl+0x27a>
10df90: f240 80da bls.w 10e148 <rtems_termios_ioctl+0x1f8>
10df94: f648 33ec movw r3, #35820 ; 0x8bec
10df98: f6c7 73d3 movt r3, #32723 ; 0x7fd3
10df9c: 440b add r3, r1
10df9e: 2b02 cmp r3, #2
10dfa0: f200 8153 bhi.w 10e24a <rtems_termios_ioctl+0x2fa> <== ALWAYS TAKEN
tty->termios = *(struct termios *)args->buffer;
10dfa4: f8d5 e008 ldr.w lr, [r5, #8]
if (args->command == TIOCSETAW || args->command == TIOCSETAF) {
10dfa8: f648 39eb movw r9, #35819 ; 0x8beb
10dfac: f6c7 79d3 movt r9, #32723 ; 0x7fd3
tty->termios = *(struct termios *)args->buffer;
10dfb0: f104 0850 add.w r8, r4, #80 ; 0x50
if (args->command == TIOCSETAW || args->command == TIOCSETAF) {
10dfb4: 4489 add r9, r1
tty->termios = *(struct termios *)args->buffer;
10dfb6: 46c4 mov ip, r8
if (args->command == TIOCSETAW || args->command == TIOCSETAF) {
10dfb8: f1b9 0f01 cmp.w r9, #1
tty->termios = *(struct termios *)args->buffer;
10dfbc: e8be 000f ldmia.w lr!, {r0, r1, r2, r3}
10dfc0: e8ac 000f stmia.w ip!, {r0, r1, r2, r3}
10dfc4: e8be 000f ldmia.w lr!, {r0, r1, r2, r3}
10dfc8: e8ac 000f stmia.w ip!, {r0, r1, r2, r3}
10dfcc: e89e 0007 ldmia.w lr, {r0, r1, r2}
10dfd0: e88c 0007 stmia.w ip, {r0, r1, r2}
if (args->command == TIOCSETAW || args->command == TIOCSETAF) {
10dfd4: f240 818c bls.w 10e2f0 <rtems_termios_ioctl+0x3a0>
if (( tty->flow_ctrl & FL_MDXON) &&
10dfd8: f8d4 3148 ldr.w r3, [r4, #328] ; 0x148
rtems_termios_device_context *ctx = tty->device_context;
10dfdc: f8d4 517c ldr.w r5, [r4, #380] ; 0x17c
if (( tty->flow_ctrl & FL_MDXON) &&
10dfe0: 059e lsls r6, r3, #22
10dfe2: d527 bpl.n 10e034 <rtems_termios_ioctl+0xe4>
!(tty->termios.c_iflag & IXON)) {
10dfe4: 6d23 ldr r3, [r4, #80] ; 0x50
if (( tty->flow_ctrl & FL_MDXON) &&
10dfe6: 0598 lsls r0, r3, #22
10dfe8: d424 bmi.n 10e034 <rtems_termios_ioctl+0xe4>
tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF);
10dfea: f8d4 3148 ldr.w r3, [r4, #328] ; 0x148
10dfee: f423 7304 bic.w r3, r3, #528 ; 0x210
10dff2: f8c4 3148 str.w r3, [r4, #328] ; 0x148
if (tty->flow_ctrl & FL_OSTOP) {
10dff6: f8d4 3148 ldr.w r3, [r4, #328] ; 0x148
10dffa: 0699 lsls r1, r3, #26
10dffc: d51a bpl.n 10e034 <rtems_termios_ioctl+0xe4> <== NEVER TAKEN
( *context->lock_acquire )( context, lock_context );
10dffe: 696b ldr r3, [r5, #20] <== NOT EXECUTED
10e000: a901 add r1, sp, #4 <== NOT EXECUTED
10e002: 4628 mov r0, r5 <== NOT EXECUTED
10e004: 4798 blx r3 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
10e006: f8d4 3148 ldr.w r3, [r4, #328] ; 0x148 <== NOT EXECUTED
10e00a: f023 0320 bic.w r3, r3, #32 <== NOT EXECUTED
10e00e: f8c4 3148 str.w r3, [r4, #328] ; 0x148 <== NOT EXECUTED
if (tty->rawOutBufState != rob_idle) {
10e012: f8d4 30e4 ldr.w r3, [r4, #228] ; 0xe4 <== NOT EXECUTED
10e016: b14b cbz r3, 10e02c <rtems_termios_ioctl+0xdc> <== NOT EXECUTED
ctx, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
10e018: f8d4 30c0 ldr.w r3, [r4, #192] ; 0xc0 <== NOT EXECUTED
(*tty->handler.write)(
10e01c: 2201 movs r2, #1 <== NOT EXECUTED
ctx, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
10e01e: f8d4 10b8 ldr.w r1, [r4, #184] ; 0xb8 <== NOT EXECUTED
(*tty->handler.write)(
10e022: 4628 mov r0, r5 <== NOT EXECUTED
10e024: 4419 add r1, r3 <== NOT EXECUTED
10e026: f8d4 3130 ldr.w r3, [r4, #304] ; 0x130 <== NOT EXECUTED
10e02a: 4798 blx r3 <== NOT EXECUTED
( *context->lock_release )( context, lock_context );
10e02c: 69ab ldr r3, [r5, #24] <== NOT EXECUTED
10e02e: a901 add r1, sp, #4 <== NOT EXECUTED
10e030: 4628 mov r0, r5 <== NOT EXECUTED
10e032: 4798 blx r3 <== NOT EXECUTED
if (( tty->flow_ctrl & FL_MDXOF) && !(tty->termios.c_iflag & IXOFF)) {
10e034: f8d4 3148 ldr.w r3, [r4, #328] ; 0x148
10e038: 055a lsls r2, r3, #21
10e03a: d503 bpl.n 10e044 <rtems_termios_ioctl+0xf4>
10e03c: 6d23 ldr r3, [r4, #80] ; 0x50
10e03e: 055b lsls r3, r3, #21
10e040: f140 8170 bpl.w 10e324 <rtems_termios_ioctl+0x3d4> <== NEVER TAKEN
if (( tty->flow_ctrl & FL_MDRTS) && !(tty->termios.c_cflag & CRTSCTS)) {
10e044: f8d4 2148 ldr.w r2, [r4, #328] ; 0x148
10e048: 6da3 ldr r3, [r4, #88] ; 0x58
10e04a: 05d6 lsls r6, r2, #23
10e04c: f403 3340 and.w r3, r3, #196608 ; 0x30000
10e050: f140 812c bpl.w 10e2ac <rtems_termios_ioctl+0x35c> <== NEVER TAKEN
10e054: 2b00 cmp r3, #0 <== NOT EXECUTED
10e056: f000 8110 beq.w 10e27a <rtems_termios_ioctl+0x32a> <== NOT EXECUTED
tty->flow_ctrl |= FL_MDRTS;
10e05a: f8d4 3148 ldr.w r3, [r4, #328] ; 0x148 <== NOT EXECUTED
10e05e: f443 7380 orr.w r3, r3, #256 ; 0x100 <== NOT EXECUTED
10e062: f8c4 3148 str.w r3, [r4, #328] ; 0x148 <== NOT EXECUTED
if (tty->termios.c_iflag & IXOFF) {
10e066: 6d23 ldr r3, [r4, #80] ; 0x50
10e068: 0559 lsls r1, r3, #21
tty->flow_ctrl |= FL_MDXOF;
10e06a: bf42 ittt mi
10e06c: f8d4 2148 ldrmi.w r2, [r4, #328] ; 0x148
10e070: f442 6280 orrmi.w r2, r2, #1024 ; 0x400
10e074: f8c4 2148 strmi.w r2, [r4, #328] ; 0x148
if (tty->termios.c_iflag & IXON) {
10e078: 059a lsls r2, r3, #22
tty->flow_ctrl |= FL_MDXON;
10e07a: bf42 ittt mi
10e07c: f8d4 3148 ldrmi.w r3, [r4, #328] ; 0x148
10e080: f443 7300 orrmi.w r3, r3, #512 ; 0x200
10e084: f8c4 3148 strmi.w r3, [r4, #328] ; 0x148
if (tty->termios.c_lflag & ICANON) {
10e088: 6de3 ldr r3, [r4, #92] ; 0x5c
10e08a: f413 7380 ands.w r3, r3, #256 ; 0x100
10e08e: f000 8111 beq.w 10e2b4 <rtems_termios_ioctl+0x364>
tty->rawInBufSemaphoreTimeout = 0;
10e092: 2300 movs r3, #0
tty->rawInBufSemaphoreWait = true;
10e094: 2201 movs r2, #1
10e096: f884 20a8 strb.w r2, [r4, #168] ; 0xa8
tty->rawInBufSemaphoreFirstTimeout = 0;
10e09a: e9c4 332b strd r3, r3, [r4, #172] ; 0xac
if (tty->handler.set_attributes) {
10e09e: f8d4 3134 ldr.w r3, [r4, #308] ; 0x134
10e0a2: b12b cbz r3, 10e0b0 <rtems_termios_ioctl+0x160>
sc = (*tty->handler.set_attributes)(tty->device_context, &tty->termios) ?
10e0a4: f8d4 017c ldr.w r0, [r4, #380] ; 0x17c
10e0a8: 4641 mov r1, r8
RTEMS_SUCCESSFUL : RTEMS_IO_ERROR;
10e0aa: 261b movs r6, #27
sc = (*tty->handler.set_attributes)(tty->device_context, &tty->termios) ?
10e0ac: 4798 blx r3
RTEMS_SUCCESSFUL : RTEMS_IO_ERROR;
10e0ae: b100 cbz r0, 10e0b2 <rtems_termios_ioctl+0x162>
10e0b0: 2600 movs r6, #0
_Mutex_Release( mutex );
10e0b2: 4638 mov r0, r7
10e0b4: f7f9 f914 bl 1072e0 <_Mutex_Release>
}
10e0b8: 4630 mov r0, r6
10e0ba: b003 add sp, #12
10e0bc: e8bd 83f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, pc}
switch (args->command) {
10e0c0: f247 431a movw r3, #29722 ; 0x741a
10e0c4: f2c4 0304 movt r3, #16388 ; 0x4004
10e0c8: 4299 cmp r1, r3
10e0ca: f000 80b3 beq.w 10e234 <rtems_termios_ioctl+0x2e4>
10e0ce: d917 bls.n 10e100 <rtems_termios_ioctl+0x1b0>
10e0d0: f247 4313 movw r3, #29715 ; 0x7413
10e0d4: f2c4 032c movt r3, #16428 ; 0x402c
10e0d8: 4299 cmp r1, r3
10e0da: f040 80b6 bne.w 10e24a <rtems_termios_ioctl+0x2fa>
*(struct termios *)args->buffer = tty->termios;
10e0de: 3450 adds r4, #80 ; 0x50
10e0e0: 68ad ldr r5, [r5, #8]
10e0e2: cc0f ldmia r4!, {r0, r1, r2, r3}
10e0e4: c50f stmia r5!, {r0, r1, r2, r3}
10e0e6: cc0f ldmia r4!, {r0, r1, r2, r3}
10e0e8: c50f stmia r5!, {r0, r1, r2, r3}
10e0ea: e894 0007 ldmia.w r4, {r0, r1, r2}
10e0ee: e885 0007 stmia.w r5, {r0, r1, r2}
10e0f2: 4638 mov r0, r7
10e0f4: f7f9 f8f4 bl 1072e0 <_Mutex_Release>
}
10e0f8: 4630 mov r0, r6
10e0fa: b003 add sp, #12
10e0fc: e8bd 83f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, pc}
switch (args->command) {
10e100: f247 435e movw r3, #29790 ; 0x745e
10e104: f2c2 0300 movt r3, #8192 ; 0x2000
10e108: 4299 cmp r1, r3
10e10a: d06b beq.n 10e1e4 <rtems_termios_ioctl+0x294>
10e10c: f246 637f movw r3, #26239 ; 0x667f
10e110: f2c4 0304 movt r3, #16388 ; 0x4004
10e114: 4299 cmp r1, r3
10e116: f040 8098 bne.w 10e24a <rtems_termios_ioctl+0x2fa> <== NEVER TAKEN
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
10e11a: f8d4 3088 ldr.w r3, [r4, #136] ; 0x88 <== NOT EXECUTED
10e11e: 4638 mov r0, r7 <== NOT EXECUTED
10e120: f8d4 2084 ldr.w r2, [r4, #132] ; 0x84 <== NOT EXECUTED
sc = RTEMS_SUCCESSFUL;
10e124: 2600 movs r6, #0 <== NOT EXECUTED
if ( rawnc < 0 )
10e126: 1a9a subs r2, r3, r2 <== NOT EXECUTED
rawnc += tty->rawInBuf.Size;
10e128: bf44 itt mi <== NOT EXECUTED
10e12a: f8d4 308c ldrmi.w r3, [r4, #140] ; 0x8c <== NOT EXECUTED
10e12e: 18d2 addmi r2, r2, r3 <== NOT EXECUTED
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
10e130: e9d4 3110 ldrd r3, r1, [r4, #64] ; 0x40 <== NOT EXECUTED
10e134: 1a5b subs r3, r3, r1 <== NOT EXECUTED
10e136: 68a9 ldr r1, [r5, #8] <== NOT EXECUTED
10e138: 4413 add r3, r2 <== NOT EXECUTED
10e13a: 600b str r3, [r1, #0] <== NOT EXECUTED
10e13c: f7f9 f8d0 bl 1072e0 <_Mutex_Release> <== NOT EXECUTED
}
10e140: 4630 mov r0, r6 <== NOT EXECUTED
10e142: b003 add sp, #12 <== NOT EXECUTED
10e144: e8bd 83f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, pc} <== NOT EXECUTED
switch (args->command) {
10e148: f247 431b movw r3, #29723 ; 0x741b
10e14c: f2c8 0304 movt r3, #32772 ; 0x8004
10e150: 4299 cmp r1, r3
10e152: d051 beq.n 10e1f8 <rtems_termios_ioctl+0x2a8>
10e154: f247 430b movw r3, #29707 ; 0x740b
10e158: f2c8 0308 movt r3, #32776 ; 0x8008
10e15c: 4299 cmp r1, r3
10e15e: d174 bne.n 10e24a <rtems_termios_ioctl+0x2fa> <== ALWAYS TAKEN
tty->tty_snd = *wakeup;
10e160: e898 0003 ldmia.w r8, {r0, r1}
10e164: f504 74b2 add.w r4, r4, #356 ; 0x164
10e168: e884 0003 stmia.w r4, {r0, r1}
10e16c: 4638 mov r0, r7
10e16e: f7f9 f8b7 bl 1072e0 <_Mutex_Release>
}
10e172: 4630 mov r0, r6
10e174: b003 add sp, #12
10e176: e8bd 83f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, pc}
flags = *((int *)args->buffer);
10e17a: 68ab ldr r3, [r5, #8]
10e17c: 681b ldr r3, [r3, #0]
if (flags == 0) {
10e17e: 2b00 cmp r3, #0
10e180: d173 bne.n 10e26a <rtems_termios_ioctl+0x31a> <== NEVER TAKEN
10e182: 2501 movs r5, #1 <== NOT EXECUTED
rtems_termios_device_context *ctx = tty->device_context;
10e184: f8d4 617c ldr.w r6, [r4, #380] ; 0x17c
( *context->lock_acquire )( context, lock_context );
10e188: a901 add r1, sp, #4
10e18a: 6973 ldr r3, [r6, #20]
10e18c: 4630 mov r0, r6
10e18e: 4798 blx r3
tty->rawOutBuf.Tail = 0;
10e190: 2300 movs r3, #0
( *context->lock_release )( context, lock_context );
10e192: a901 add r1, sp, #4
10e194: f8c4 30c0 str.w r3, [r4, #192] ; 0xc0
10e198: 4630 mov r0, r6
tty->rawOutBufState = rob_idle;
10e19a: f8c4 30e4 str.w r3, [r4, #228] ; 0xe4
tty->rawOutBuf.Head = 0;
10e19e: f8c4 30bc str.w r3, [r4, #188] ; 0xbc
10e1a2: 69b3 ldr r3, [r6, #24]
10e1a4: 4798 blx r3
if (flags & FREAD) {
10e1a6: 2d00 cmp r5, #0
10e1a8: d082 beq.n 10e0b0 <rtems_termios_ioctl+0x160>
rtems_termios_device_context *ctx = tty->device_context;
10e1aa: f8d4 517c ldr.w r5, [r4, #380] ; 0x17c
tty->rawInBuf.Tail = 0;
10e1ae: 2600 movs r6, #0
( *context->lock_acquire )( context, lock_context );
10e1b0: a901 add r1, sp, #4
10e1b2: 696b ldr r3, [r5, #20]
10e1b4: 4628 mov r0, r5
10e1b6: 4798 blx r3
10e1b8: f8c4 6088 str.w r6, [r4, #136] ; 0x88
( *context->lock_release )( context, lock_context );
10e1bc: a901 add r1, sp, #4
10e1be: 69ab ldr r3, [r5, #24]
10e1c0: 4628 mov r0, r5
tty->rawInBuf.Head = 0;
10e1c2: f8c4 6084 str.w r6, [r4, #132] ; 0x84
10e1c6: 4798 blx r3
}
10e1c8: e773 b.n 10e0b2 <rtems_termios_ioctl+0x162>
tty->tty_rcv = *wakeup;
10e1ca: e898 0003 ldmia.w r8, {r0, r1}
10e1ce: f504 74b6 add.w r4, r4, #364 ; 0x16c
10e1d2: e884 0003 stmia.w r4, {r0, r1}
10e1d6: 4638 mov r0, r7
10e1d8: f7f9 f882 bl 1072e0 <_Mutex_Release>
}
10e1dc: 4630 mov r0, r6
10e1de: b003 add sp, #12
10e1e0: e8bd 83f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, pc}
drainOutput (tty);
10e1e4: 4620 mov r0, r4
10e1e6: f7fe fd69 bl 10ccbc <drainOutput>
10e1ea: 4638 mov r0, r7
10e1ec: f7f9 f878 bl 1072e0 <_Mutex_Release>
}
10e1f0: 4630 mov r0, r6
10e1f2: b003 add sp, #12
10e1f4: e8bd 83f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, pc}
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
10e1f8: f8d4 315c ldr.w r3, [r4, #348] ; 0x15c
10e1fc: f644 78c8 movw r8, #20424 ; 0x4fc8
10e200: f2c0 0820 movt r8, #32
10e204: eb08 1343 add.w r3, r8, r3, lsl #5
10e208: 685e ldr r6, [r3, #4]
10e20a: b116 cbz r6, 10e212 <rtems_termios_ioctl+0x2c2>
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
10e20c: 4620 mov r0, r4
10e20e: 47b0 blx r6
10e210: 4606 mov r6, r0
tty->t_line=*(int*)(args->buffer);
10e212: 68ab ldr r3, [r5, #8]
tty->t_sc = NULL; /* ensure that no more valid data */
10e214: 2200 movs r2, #0
tty->t_line=*(int*)(args->buffer);
10e216: 681b ldr r3, [r3, #0]
tty->t_sc = NULL; /* ensure that no more valid data */
10e218: f8c4 2160 str.w r2, [r4, #352] ; 0x160
tty->t_line=*(int*)(args->buffer);
10e21c: f8c4 315c str.w r3, [r4, #348] ; 0x15c
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
10e220: 015b lsls r3, r3, #5
10e222: f858 3003 ldr.w r3, [r8, r3]
10e226: 2b00 cmp r3, #0
10e228: f43f af43 beq.w 10e0b2 <rtems_termios_ioctl+0x162>
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
10e22c: 4620 mov r0, r4
10e22e: 4798 blx r3
10e230: 4606 mov r6, r0
10e232: e73e b.n 10e0b2 <rtems_termios_ioctl+0x162>
*(int*)(args->buffer)=tty->t_line;
10e234: f8d4 215c ldr.w r2, [r4, #348] ; 0x15c
10e238: 4638 mov r0, r7
10e23a: 68ab ldr r3, [r5, #8]
10e23c: 601a str r2, [r3, #0]
10e23e: f7f9 f84f bl 1072e0 <_Mutex_Release>
}
10e242: 4630 mov r0, r6
10e244: b003 add sp, #12
10e246: e8bd 83f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, pc}
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
10e24a: f8d4 215c ldr.w r2, [r4, #348] ; 0x15c
10e24e: f644 73c8 movw r3, #20424 ; 0x4fc8
10e252: f2c0 0320 movt r3, #32
10e256: eb03 1342 add.w r3, r3, r2, lsl #5
10e25a: 699e ldr r6, [r3, #24]
10e25c: 2e00 cmp r6, #0
10e25e: d077 beq.n 10e350 <rtems_termios_ioctl+0x400>
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
10e260: 4629 mov r1, r5
10e262: 4620 mov r0, r4
10e264: 47b0 blx r6
10e266: 4606 mov r6, r0
10e268: e723 b.n 10e0b2 <rtems_termios_ioctl+0x162>
if (flags & FREAD) {
10e26a: f003 0501 and.w r5, r3, #1
if (flags & FWRITE) {
10e26e: 079b lsls r3, r3, #30
10e270: d488 bmi.n 10e184 <rtems_termios_ioctl+0x234>
if (flags & FREAD) {
10e272: 2d00 cmp r5, #0
10e274: f43f af1c beq.w 10e0b0 <rtems_termios_ioctl+0x160> <== ALWAYS TAKEN
10e278: e797 b.n 10e1aa <rtems_termios_ioctl+0x25a>
tty->flow_ctrl &= ~(FL_MDRTS);
10e27a: f8d4 3148 ldr.w r3, [r4, #328] ; 0x148 <== NOT EXECUTED
10e27e: f423 7380 bic.w r3, r3, #256 ; 0x100 <== NOT EXECUTED
10e282: f8c4 3148 str.w r3, [r4, #328] ; 0x148 <== NOT EXECUTED
if ((tty->flow_ctrl & FL_IRTSOFF) &&
10e286: f8d4 3148 ldr.w r3, [r4, #328] ; 0x148 <== NOT EXECUTED
10e28a: 0758 lsls r0, r3, #29 <== NOT EXECUTED
10e28c: d569 bpl.n 10e362 <rtems_termios_ioctl+0x412> <== NOT EXECUTED
(tty->flow.start_remote_tx != NULL)) {
10e28e: f8d4 3144 ldr.w r3, [r4, #324] ; 0x144 <== NOT EXECUTED
if ((tty->flow_ctrl & FL_IRTSOFF) &&
10e292: 2b00 cmp r3, #0 <== NOT EXECUTED
10e294: d065 beq.n 10e362 <rtems_termios_ioctl+0x412> <== NOT EXECUTED
tty->flow.start_remote_tx(ctx);
10e296: 4628 mov r0, r5 <== NOT EXECUTED
10e298: 4798 blx r3 <== NOT EXECUTED
if (tty->termios.c_cflag & CRTSCTS) {
10e29a: 6da3 ldr r3, [r4, #88] ; 0x58 <== NOT EXECUTED
tty->flow_ctrl &= ~(FL_IRTSOFF);
10e29c: f8d4 2148 ldr.w r2, [r4, #328] ; 0x148 <== NOT EXECUTED
if (tty->termios.c_cflag & CRTSCTS) {
10e2a0: f403 3340 and.w r3, r3, #196608 ; 0x30000 <== NOT EXECUTED
tty->flow_ctrl &= ~(FL_IRTSOFF);
10e2a4: f022 0204 bic.w r2, r2, #4 <== NOT EXECUTED
10e2a8: f8c4 2148 str.w r2, [r4, #328] ; 0x148 <== NOT EXECUTED
if (tty->termios.c_cflag & CRTSCTS) {
10e2ac: 2b00 cmp r3, #0
10e2ae: f43f aeda beq.w 10e066 <rtems_termios_ioctl+0x116> <== NEVER TAKEN
10e2b2: e6d2 b.n 10e05a <rtems_termios_ioctl+0x10a> <== NOT EXECUTED
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
10e2b4: f64f 52cc movw r2, #64972 ; 0xfdcc
10e2b8: f894 1071 ldrb.w r1, [r4, #113] ; 0x71
10e2bc: f2c0 0210 movt r2, #16
rtems_clock_get_ticks_per_second() / 10;
10e2c0: f64c 40cd movw r0, #52429 ; 0xcccd
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
10e2c4: 6812 ldr r2, [r2, #0]
rtems_clock_get_ticks_per_second() / 10;
10e2c6: f6cc 40cc movt r0, #52428 ; 0xcccc
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
10e2ca: fb01 f202 mul.w r2, r1, r2
rtems_clock_get_ticks_per_second() / 10;
10e2ce: fba0 0202 umull r0, r2, r0, r2
if (tty->termios.c_cc[VMIN])
10e2d2: f894 0070 ldrb.w r0, [r4, #112] ; 0x70
rtems_clock_get_ticks_per_second() / 10;
10e2d6: 08d2 lsrs r2, r2, #3
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
10e2d8: 67e2 str r2, [r4, #124] ; 0x7c
if (tty->termios.c_cc[VTIME]) {
10e2da: bb81 cbnz r1, 10e33e <rtems_termios_ioctl+0x3ee>
if (tty->termios.c_cc[VMIN]) {
10e2dc: 2800 cmp r0, #0
10e2de: d047 beq.n 10e370 <rtems_termios_ioctl+0x420>
tty->rawInBufSemaphoreWait = true;
10e2e0: 2301 movs r3, #1
tty->rawInBufSemaphoreTimeout = 0;
10e2e2: f8c4 10ac str.w r1, [r4, #172] ; 0xac
tty->rawInBufSemaphoreWait = true;
10e2e6: f884 30a8 strb.w r3, [r4, #168] ; 0xa8
tty->rawInBufSemaphoreFirstTimeout = 0;
10e2ea: f8c4 10b0 str.w r1, [r4, #176] ; 0xb0
10e2ee: e6d6 b.n 10e09e <rtems_termios_ioctl+0x14e>
drainOutput (tty);
10e2f0: 4620 mov r0, r4
10e2f2: f7fe fce3 bl 10ccbc <drainOutput>
if (args->command == TIOCSETAF) {
10e2f6: 686a ldr r2, [r5, #4]
10e2f8: f247 4316 movw r3, #29718 ; 0x7416
10e2fc: f2c8 032c movt r3, #32812 ; 0x802c
10e300: 429a cmp r2, r3
10e302: f47f ae69 bne.w 10dfd8 <rtems_termios_ioctl+0x88>
rtems_termios_device_context *ctx = tty->device_context;
10e306: f8d4 517c ldr.w r5, [r4, #380] ; 0x17c
( *context->lock_acquire )( context, lock_context );
10e30a: a901 add r1, sp, #4
10e30c: 696b ldr r3, [r5, #20]
10e30e: 4628 mov r0, r5
10e310: 4798 blx r3
tty->rawInBuf.Tail = 0;
10e312: f8c4 6088 str.w r6, [r4, #136] ; 0x88
( *context->lock_release )( context, lock_context );
10e316: a901 add r1, sp, #4
10e318: 69ab ldr r3, [r5, #24]
10e31a: 4628 mov r0, r5
tty->rawInBuf.Head = 0;
10e31c: f8c4 6084 str.w r6, [r4, #132] ; 0x84
10e320: 4798 blx r3
}
10e322: e659 b.n 10dfd8 <rtems_termios_ioctl+0x88>
tty->flow_ctrl &= ~(FL_MDXOF);
10e324: f8d4 3148 ldr.w r3, [r4, #328] ; 0x148
10e328: f423 6380 bic.w r3, r3, #1024 ; 0x400
10e32c: f8c4 3148 str.w r3, [r4, #328] ; 0x148
tty->flow_ctrl &= ~(FL_ISNTXOF);
10e330: f8d4 3148 ldr.w r3, [r4, #328] ; 0x148
10e334: f023 0302 bic.w r3, r3, #2
10e338: f8c4 3148 str.w r3, [r4, #328] ; 0x148
10e33c: e682 b.n 10e044 <rtems_termios_ioctl+0xf4>
tty->rawInBufSemaphoreFirstTimeout = 0;
10e33e: 2800 cmp r0, #0
10e340: bf08 it eq
10e342: 4613 moveq r3, r2
10e344: e9c4 232b strd r2, r3, [r4, #172] ; 0xac
tty->rawInBufSemaphoreWait = true;
10e348: 2301 movs r3, #1
10e34a: f884 30a8 strb.w r3, [r4, #168] ; 0xa8
if (tty->termios.c_cc[VMIN])
10e34e: e6a6 b.n 10e09e <rtems_termios_ioctl+0x14e>
} else if (tty->handler.ioctl) {
10e350: f8d4 3138 ldr.w r3, [r4, #312] ; 0x138
10e354: b17b cbz r3, 10e376 <rtems_termios_ioctl+0x426>
args->ioctl_return = (*tty->handler.ioctl) (tty->device_context,
10e356: f8d4 017c ldr.w r0, [r4, #380] ; 0x17c <== NOT EXECUTED
10e35a: 68aa ldr r2, [r5, #8] <== NOT EXECUTED
10e35c: 4798 blx r3 <== NOT EXECUTED
10e35e: 60e8 str r0, [r5, #12] <== NOT EXECUTED
sc = RTEMS_SUCCESSFUL;
10e360: e6a7 b.n 10e0b2 <rtems_termios_ioctl+0x162> <== NOT EXECUTED
tty->flow_ctrl &= ~(FL_IRTSOFF);
10e362: f8d4 3148 ldr.w r3, [r4, #328] ; 0x148 <== NOT EXECUTED
10e366: f023 0304 bic.w r3, r3, #4 <== NOT EXECUTED
10e36a: f8c4 3148 str.w r3, [r4, #328] ; 0x148 <== NOT EXECUTED
if (tty->termios.c_cflag & CRTSCTS) {
10e36e: e67a b.n 10e066 <rtems_termios_ioctl+0x116> <== NOT EXECUTED
tty->rawInBufSemaphoreWait = false;
10e370: f884 00a8 strb.w r0, [r4, #168] ; 0xa8
10e374: e693 b.n 10e09e <rtems_termios_ioctl+0x14e>
sc = RTEMS_INVALID_NUMBER;
10e376: 260a movs r6, #10
10e378: e69b b.n 10e0b2 <rtems_termios_ioctl+0x162>
10e37a: bf00 nop
00106be4 <rtems_termios_open>:
{
106be4: e92d 41f0 stmdb sp!, {r4, r5, r6, r7, r8, lr}
106be8: 4604 mov r4, r0
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
106bea: f242 3670 movw r6, #9072 ; 0x2370
_Mutex_Acquire( mutex );
106bee: f240 1098 movw r0, #408 ; 0x198
{
106bf2: b082 sub sp, #8
106bf4: f2c0 0020 movt r0, #32
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
106bf8: f2c0 0620 movt r6, #32
{
106bfc: 4698 mov r8, r3
106bfe: 460d mov r5, r1
106c00: 4617 mov r7, r2
106c02: f002 fed7 bl 1099b4 <_Mutex_Acquire>
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
106c06: 6833 ldr r3, [r6, #0]
106c08: b913 cbnz r3, 106c10 <rtems_termios_open+0x2c>
106c0a: e007 b.n 106c1c <rtems_termios_open+0x38>
106c0c: 681b ldr r3, [r3, #0] <== NOT EXECUTED
106c0e: b12b cbz r3, 106c1c <rtems_termios_open+0x38> <== NOT EXECUTED
if ((tty->major == major) && (tty->minor == minor))
106c10: 68da ldr r2, [r3, #12] <== NOT EXECUTED
106c12: 42a2 cmp r2, r4 <== NOT EXECUTED
106c14: d1fa bne.n 106c0c <rtems_termios_open+0x28> <== NOT EXECUTED
106c16: 6918 ldr r0, [r3, #16] <== NOT EXECUTED
106c18: 42a8 cmp r0, r5 <== NOT EXECUTED
106c1a: d1f7 bne.n 106c0c <rtems_termios_open+0x28> <== NOT EXECUTED
tty = rtems_termios_open_tty(
106c1c: 4620 mov r0, r4
106c1e: 2400 movs r4, #0
106c20: 463a mov r2, r7
106c22: 4629 mov r1, r5
106c24: f8cd 8004 str.w r8, [sp, #4]
106c28: 9400 str r4, [sp, #0]
106c2a: f7ff f825 bl 105c78 <rtems_termios_open_tty>
if (tty == NULL) {
106c2e: b1d8 cbz r0, 106c68 <rtems_termios_open+0x84>
if (tty->refcount == 1) {
106c30: 6883 ldr r3, [r0, #8]
106c32: 2b01 cmp r3, #1
106c34: d009 beq.n 106c4a <rtems_termios_open+0x66> <== NEVER TAKEN
_Mutex_Release( mutex );
106c36: f240 1098 movw r0, #408 ; 0x198
106c3a: f2c0 0020 movt r0, #32
106c3e: f002 fee5 bl 109a0c <_Mutex_Release>
return RTEMS_SUCCESSFUL;
106c42: 2000 movs r0, #0
}
106c44: b002 add sp, #8
106c46: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
tty->forw = rtems_termios_ttyHead;
106c4a: 6833 ldr r3, [r6, #0]
106c4c: e9c0 3400 strd r3, r4, [r0]
if (rtems_termios_ttyHead != NULL)
106c50: b103 cbz r3, 106c54 <rtems_termios_open+0x70>
rtems_termios_ttyHead->back = tty;
106c52: 6058 str r0, [r3, #4] <== NOT EXECUTED
if (rtems_termios_ttyTail == NULL)
106c54: f242 3374 movw r3, #9076 ; 0x2374
rtems_termios_ttyHead = tty;
106c58: 6030 str r0, [r6, #0]
if (rtems_termios_ttyTail == NULL)
106c5a: f2c0 0320 movt r3, #32
106c5e: 681a ldr r2, [r3, #0]
106c60: 2a00 cmp r2, #0
106c62: d1e8 bne.n 106c36 <rtems_termios_open+0x52> <== ALWAYS TAKEN
rtems_termios_ttyTail = tty;
106c64: 6018 str r0, [r3, #0]
106c66: e7e6 b.n 106c36 <rtems_termios_open+0x52>
106c68: f240 1098 movw r0, #408 ; 0x198
106c6c: f2c0 0020 movt r0, #32
106c70: f002 fecc bl 109a0c <_Mutex_Release>
return RTEMS_NO_MEMORY;
106c74: 201a movs r0, #26
106c76: e7e5 b.n 106c44 <rtems_termios_open+0x60>
00107324 <rtems_termios_register_isig_handler>:
if (handler == NULL) {
107324: 4603 mov r3, r0
107326: b130 cbz r0, 107336 <rtems_termios_register_isig_handler+0x12>
termios_isig_handler = handler;
107328: f240 1234 movw r2, #308 ; 0x134
return RTEMS_SUCCESSFUL;
10732c: 2000 movs r0, #0
termios_isig_handler = handler;
10732e: f2c0 0220 movt r2, #32
107332: 6013 str r3, [r2, #0]
return RTEMS_SUCCESSFUL;
107334: 4770 bx lr
return RTEMS_INVALID_ADDRESS;
107336: 2009 movs r0, #9 <== NOT EXECUTED
}
107338: 4770 bx lr <== NOT EXECUTED
10733a: bf00 nop
00108e58 <rtems_termios_set_best_baud>:
{
const rtems_assoc_t *current = &rtems_termios_baud_table[ 0 ];
const rtems_assoc_t *last = current;
speed_t spd;
while ( current->name != NULL && current->local_value < baud ) {
108e58: f642 3368 movw r3, #11112 ; 0x2b68
108e5c: f2c0 0311 movt r3, #17
108e60: 681a ldr r2, [r3, #0]
108e62: b1f2 cbz r2, 108ea2 <rtems_termios_set_best_baud+0x4a>
const rtems_assoc_t *last = current;
108e64: 469c mov ip, r3
{
108e66: b510 push {r4, lr}
108e68: e002 b.n 108e70 <rtems_termios_set_best_baud+0x18>
while ( current->name != NULL && current->local_value < baud ) {
108e6a: f853 2f0c ldr.w r2, [r3, #12]!
108e6e: b19a cbz r2, 108e98 <rtems_termios_set_best_baud+0x40>
108e70: 685a ldr r2, [r3, #4]
108e72: 46e6 mov lr, ip
108e74: 469c mov ip, r3
108e76: 428a cmp r2, r1
108e78: d3f7 bcc.n 108e6a <rtems_termios_set_best_baud+0x12>
last = current;
++current;
}
if ( current->name != NULL ) {
uint32_t mid = (last->local_value + current->local_value) / UINT32_C( 2 );
108e7a: f8de 4004 ldr.w r4, [lr, #4]
108e7e: 4422 add r2, r4
spd = baud <= mid ? last->remote_value : current->remote_value;
108e80: ebb1 0f52 cmp.w r1, r2, lsr #1
108e84: d903 bls.n 108e8e <rtems_termios_set_best_baud+0x36>
108e86: 689b ldr r3, [r3, #8]
} else {
spd = B460800;
}
term->c_ispeed = spd;
term->c_ospeed = spd;
108e88: e9c0 3309 strd r3, r3, [r0, #36] ; 0x24
}
108e8c: bd10 pop {r4, pc}
spd = baud <= mid ? last->remote_value : current->remote_value;
108e8e: f8de 3008 ldr.w r3, [lr, #8]
term->c_ospeed = spd;
108e92: e9c0 3309 strd r3, r3, [r0, #36] ; 0x24
}
108e96: bd10 pop {r4, pc}
spd = B460800;
108e98: f44f 23e1 mov.w r3, #460800 ; 0x70800
term->c_ospeed = spd;
108e9c: e9c0 3309 strd r3, r3, [r0, #36] ; 0x24
}
108ea0: bd10 pop {r4, pc}
spd = B460800;
108ea2: f44f 23e1 mov.w r3, #460800 ; 0x70800 <== NOT EXECUTED
term->c_ospeed = spd;
108ea6: e9c0 3309 strd r3, r3, [r0, #36] ; 0x24 <== NOT EXECUTED
108eaa: 4770 bx lr <== NOT EXECUTED
00104ccc <rtems_verror>:
int rtems_verror(
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
104ccc: b5f8 push {r3, r4, r5, r6, r7, lr}
int local_errno = 0;
int chars_written = 0;
rtems_status_code status;
if (error_flag & RTEMS_ERROR_PANIC) {
104cce: 0083 lsls r3, r0, #2
{
104cd0: 4604 mov r4, r0
104cd2: 460d mov r5, r1
104cd4: 4616 mov r6, r2
if (error_flag & RTEMS_ERROR_PANIC) {
104cd6: d507 bpl.n 104ce8 <rtems_verror+0x1c>
if (rtems_panic_in_progress++)
104cd8: f247 43c8 movw r3, #29896 ; 0x74c8
104cdc: f2c0 0320 movt r3, #32
104ce0: 6818 ldr r0, [r3, #0]
104ce2: 1c42 adds r2, r0, #1
104ce4: 601a str r2, [r3, #0]
104ce6: bb18 cbnz r0, 104d30 <rtems_verror+0x64>
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
104ce8: f7ff fd1e bl 104728 <__getreent>
104cec: 6880 ldr r0, [r0, #8]
status = error_flag & ~RTEMS_ERROR_MASK;
104cee: f024 47e0 bic.w r7, r4, #1879048192 ; 0x70000000
(void) fflush(stdout); /* in case stdout/stderr same */
104cf2: f02d ff57 bl 132ba4 <fflush>
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
104cf6: f014 4480 ands.w r4, r4, #1073741824 ; 0x40000000
104cfa: d127 bne.n 104d4c <rtems_verror+0x80>
#if defined(RTEMS_MULTIPROCESSING)
if (_System_state_Is_multiprocessing)
fprintf(stderr, "[%" PRIu16 "] ", rtems_object_get_local_node());
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
104cfc: f7ff fd14 bl 104728 <__getreent>
104d00: 4629 mov r1, r5
104d02: 68c0 ldr r0, [r0, #12]
104d04: 4632 mov r2, r6
104d06: f042 fed7 bl 147ab8 <vfprintf>
104d0a: 4605 mov r5, r0
if (status)
104d0c: bb57 cbnz r7, 104d64 <rtems_verror+0x98>
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
}
chars_written += fprintf(stderr, "\n");
104d0e: f7ff fd0b bl 104728 <__getreent>
104d12: f249 6184 movw r1, #38532 ; 0x9684
104d16: 68c0 ldr r0, [r0, #12]
104d18: f2c0 0116 movt r1, #22
104d1c: f02e fb96 bl 13344c <fprintf>
104d20: 4405 add r5, r0
(void) fflush(stderr);
104d22: f7ff fd01 bl 104728 <__getreent>
104d26: 68c0 ldr r0, [r0, #12]
104d28: f02d ff3c bl 132ba4 <fflush>
return chars_written;
}
104d2c: 4628 mov r0, r5
104d2e: bdf8 pop {r3, r4, r5, r6, r7, pc}
const ISR_lock_Context *lock_context
)
{
uint32_t disable_level;
disable_level = cpu_self->thread_dispatch_disable_level;
104d30: f647 0380 movw r3, #30848 ; 0x7880 <== NOT EXECUTED
if (rtems_panic_in_progress > 2)
104d34: 2a02 cmp r2, #2 <== NOT EXECUTED
104d36: f2c0 0320 movt r3, #32 <== NOT EXECUTED
return 0;
104d3a: bfc8 it gt <== NOT EXECUTED
104d3c: 2500 movgt r5, #0 <== NOT EXECUTED
104d3e: 6919 ldr r1, [r3, #16] <== NOT EXECUTED
_Profiling_Thread_dispatch_disable_critical(
cpu_self,
disable_level,
lock_context
);
cpu_self->thread_dispatch_disable_level = disable_level + 1;
104d40: f101 0101 add.w r1, r1, #1 <== NOT EXECUTED
104d44: 6119 str r1, [r3, #16] <== NOT EXECUTED
if (rtems_panic_in_progress > 2)
104d46: ddcf ble.n 104ce8 <rtems_verror+0x1c> <== NOT EXECUTED
}
104d48: 4628 mov r0, r5 <== NOT EXECUTED
104d4a: bdf8 pop {r3, r4, r5, r6, r7, pc} <== NOT EXECUTED
local_errno = errno;
104d4c: f02d fdac bl 1328a8 <__errno>
104d50: 6804 ldr r4, [r0, #0]
chars_written += vfprintf(stderr, printf_format, arglist);
104d52: f7ff fce9 bl 104728 <__getreent>
104d56: 4629 mov r1, r5
104d58: 68c0 ldr r0, [r0, #12]
104d5a: 4632 mov r2, r6
104d5c: f042 feac bl 147ab8 <vfprintf>
104d60: 4605 mov r5, r0
if (status)
104d62: b177 cbz r7, 104d82 <rtems_verror+0xb6>
fprintf(stderr, " (status: %s)", rtems_status_text(status));
104d64: f7ff fce0 bl 104728 <__getreent>
104d68: 68c6 ldr r6, [r0, #12]
104d6a: 4638 mov r0, r7
104d6c: f00b f85a bl 10fe24 <rtems_status_text>
104d70: f64d 3164 movw r1, #56164 ; 0xdb64
104d74: 4602 mov r2, r0
104d76: f2c0 0115 movt r1, #21
104d7a: 4630 mov r0, r6
104d7c: f02e fb66 bl 13344c <fprintf>
chars_written +=
104d80: 4405 add r5, r0
if (local_errno) {
104d82: 2c00 cmp r4, #0
104d84: d0c3 beq.n 104d0e <rtems_verror+0x42>
if ((local_errno > 0) && *strerror(local_errno))
104d86: dd04 ble.n 104d92 <rtems_verror+0xc6>
104d88: 4620 mov r0, r4
104d8a: f038 ff21 bl 13dbd0 <strerror>
104d8e: 7803 ldrb r3, [r0, #0]
104d90: b95b cbnz r3, 104daa <rtems_verror+0xde>
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
104d92: f7ff fcc9 bl 104728 <__getreent>
104d96: f64d 3184 movw r1, #56196 ; 0xdb84
104d9a: 68c0 ldr r0, [r0, #12]
104d9c: 4622 mov r2, r4
104d9e: f2c0 0115 movt r1, #21
104da2: f02e fb53 bl 13344c <fprintf>
104da6: 4405 add r5, r0
104da8: e7b1 b.n 104d0e <rtems_verror+0x42>
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
104daa: f7ff fcbd bl 104728 <__getreent>
104dae: 68c6 ldr r6, [r0, #12]
104db0: 4620 mov r0, r4
104db2: f038 ff0d bl 13dbd0 <strerror>
104db6: f64d 3174 movw r1, #56180 ; 0xdb74
104dba: 4602 mov r2, r0
104dbc: f2c0 0115 movt r1, #21
104dc0: 4630 mov r0, r6
104dc2: f02e fb43 bl 13344c <fprintf>
104dc6: 4405 add r5, r0
104dc8: e7a1 b.n 104d0e <rtems_verror+0x42>
104dca: bf00 nop
00106c8c <rtems_vprintf>:
*
* @return true The printer is valid else false is returned.
*/
static inline bool rtems_print_printer_valid(const rtems_printer *printer)
{
return printer != NULL && printer->printer != NULL;
106c8c: b118 cbz r0, 106c96 <rtems_vprintf+0xa>
106c8e: 6843 ldr r3, [r0, #4]
106c90: b10b cbz r3, 106c96 <rtems_vprintf+0xa>
va_list ap
)
{
int len = 0;
if ( rtems_print_printer_valid( printer ) ) {
len = printer->printer( printer->context, format, ap );
106c92: 6800 ldr r0, [r0, #0]
106c94: 4718 bx r3
}
return len;
}
106c96: 2000 movs r0, #0 <== NOT EXECUTED
106c98: 4770 bx lr <== NOT EXECUTED
106c9a: bf00 nop
00105818 <setgrent>:
void setgrent(void)
{
105818: b570 push {r4, r5, r6, lr}
pthread_once(&grp_once, grp_init);
10581a: f245 71bd movw r1, #22461 ; 0x57bd
10581e: f247 40d0 movw r0, #29904 ; 0x74d0
return pthread_getspecific(grp_key);
105822: f247 45cc movw r5, #29900 ; 0x74cc
pthread_once(&grp_once, grp_init);
105826: f2c0 0110 movt r1, #16
10582a: f2c0 0020 movt r0, #32
return pthread_getspecific(grp_key);
10582e: f2c0 0520 movt r5, #32
pthread_once(&grp_once, grp_init);
105832: f009 fdeb bl 10f40c <pthread_once>
return pthread_getspecific(grp_key);
105836: 6828 ldr r0, [r5, #0]
105838: f009 fc68 bl 10f10c <pthread_getspecific>
grp_context *ctx = grp_get_context();
if (ctx == NULL) {
10583c: 4604 mov r4, r0
10583e: b188 cbz r0, 105864 <setgrent+0x4c>
return;
}
}
_libcsupport_pwdgrp_init();
105840: f000 ffcc bl 1067dc <_libcsupport_pwdgrp_init>
if (ctx->fp != NULL)
105844: 6820 ldr r0, [r4, #0]
105846: b108 cbz r0, 10584c <setgrent+0x34>
fclose(ctx->fp);
105848: f02d f8aa bl 1329a0 <fclose>
ctx->fp = fopen("/etc/group", "r");
10584c: f648 01c4 movw r1, #35012 ; 0x88c4
105850: f64d 30c8 movw r0, #56264 ; 0xdbc8
105854: f2c0 0116 movt r1, #22
105858: f2c0 0015 movt r0, #21
10585c: f02d fdea bl 133434 <fopen>
105860: 6020 str r0, [r4, #0]
}
105862: bd70 pop {r4, r5, r6, pc}
ctx = calloc(1, sizeof(*ctx));
105864: f44f 718a mov.w r1, #276 ; 0x114
105868: 2001 movs r0, #1
10586a: f7ff f8e5 bl 104a38 <calloc>
10586e: 4606 mov r6, r0
105870: 4604 mov r4, r0
if (ctx == NULL)
105872: 2800 cmp r0, #0
105874: d0f5 beq.n 105862 <setgrent+0x4a> <== ALWAYS TAKEN
eno = pthread_setspecific(grp_key, ctx);
105876: 6828 ldr r0, [r5, #0]
105878: 4631 mov r1, r6
10587a: f009 fc69 bl 10f150 <pthread_setspecific>
if (eno != 0) {
10587e: 2800 cmp r0, #0
105880: d0de beq.n 105840 <setgrent+0x28> <== NEVER TAKEN
free(ctx);
105882: 4630 mov r0, r6 <== NOT EXECUTED
}
105884: e8bd 4070 ldmia.w sp!, {r4, r5, r6, lr} <== NOT EXECUTED
free(ctx);
105888: f7ff bdfa b.w 105480 <free> <== NOT EXECUTED
001067a0 <unmount>:
* in some form is supported on most UNIX and POSIX systems. This
* routine is necessary to mount instantiations of a file system
* into the file system name space.
*/
int unmount( const char *path )
{
1067a0: b530 push {r4, r5, lr}
1067a2: b091 sub sp, #68 ; 0x44
1067a4: 4601 mov r1, r0
int rv = 0;
rtems_filesystem_eval_path_context_t ctx;
int eval_flags = RTEMS_FS_FOLLOW_LINK;
const rtems_filesystem_location_info_t *currentloc =
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
1067a6: 2218 movs r2, #24
1067a8: a802 add r0, sp, #8
1067aa: f7ff fd01 bl 1061b0 <rtems_filesystem_eval_path_start>
rtems_filesystem_mount_table_entry_t *mt_entry = currentloc->mt_entry;
1067ae: 6944 ldr r4, [r0, #20]
1067b0: 68e3 ldr r3, [r4, #12]
1067b2: 6a61 ldr r1, [r4, #36] ; 0x24
1067b4: 691b ldr r3, [r3, #16]
1067b6: 4798 blx r3
if ( rtems_filesystem_location_is_instance_root( currentloc ) ) {
1067b8: 2800 cmp r0, #0
1067ba: d043 beq.n 106844 <unmount+0xa4>
&rtems_filesystem_root->location;
1067bc: f000 f88e bl 1068dc <rtems_current_user_env_get>
1067c0: 6845 ldr r5, [r0, #4]
&rtems_filesystem_current->location;
1067c2: f000 f88b bl 1068dc <rtems_current_user_env_get>
return mt_entry == root->mt_entry || mt_entry == current->mt_entry;
1067c6: 696b ldr r3, [r5, #20]
1067c8: 429c cmp r4, r3
1067ca: d030 beq.n 10682e <unmount+0x8e>
1067cc: 6803 ldr r3, [r0, #0]
1067ce: 695b ldr r3, [r3, #20]
1067d0: 429c cmp r4, r3
1067d2: d02c beq.n 10682e <unmount+0x8e>
if ( !contains_root_or_current_directory( mt_entry ) ) {
const rtems_filesystem_operations_table *mt_point_ops =
mt_entry->mt_point_node->location.mt_entry->ops;
1067d4: 6a23 ldr r3, [r4, #32]
rv = (*mt_point_ops->unmount_h)( mt_entry );
1067d6: 4620 mov r0, r4
const rtems_filesystem_operations_table *mt_point_ops =
1067d8: 695b ldr r3, [r3, #20]
rv = (*mt_point_ops->unmount_h)( mt_entry );
1067da: 68db ldr r3, [r3, #12]
1067dc: 6b1b ldr r3, [r3, #48] ; 0x30
1067de: 4798 blx r3
if ( rv == 0 ) {
1067e0: 4605 mov r5, r0
1067e2: b128 cbz r0, 1067f0 <unmount+0x50>
} else {
errno = EACCES;
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
1067e4: a802 add r0, sp, #8
1067e6: f7ff fd67 bl 1062b8 <rtems_filesystem_eval_path_cleanup>
rtems_fatal_error_occurred( 0xdeadbeef );
}
}
return rv;
}
1067ea: 4628 mov r0, r5
1067ec: b011 add sp, #68 ; 0x44
1067ee: bd30 pop {r4, r5, pc}
rtems_id self_task_id = rtems_task_self();
1067f0: f002 f9a0 bl 108b34 <rtems_task_self>
__asm__ volatile (
1067f4: f3ef 8300 mrs r3, CPSR
1067f8: f043 0280 orr.w r2, r3, #128 ; 0x80
1067fc: f382 8900 msr CPSR_fc, r2
mt_entry->unmount_task = self_task_id;
106800: 63e0 str r0, [r4, #60] ; 0x3c
mt_entry->mounted = false;
106802: f884 5028 strb.w r5, [r4, #40] ; 0x28
__asm__ volatile (
106806: f383 8900 msr CPSR_fc, r3
rtems_filesystem_eval_path_cleanup( &ctx );
10680a: a802 add r0, sp, #8
10680c: f7ff fd54 bl 1062b8 <rtems_filesystem_eval_path_cleanup>
return rtems_event_system_receive(
106810: ab01 add r3, sp, #4
106812: 462a mov r2, r5
106814: 4629 mov r1, r5
106816: f04f 4000 mov.w r0, #2147483648 ; 0x80000000
10681a: f002 f927 bl 108a6c <rtems_event_system_receive>
if ( sc != RTEMS_SUCCESSFUL ) {
10681e: 2800 cmp r0, #0
106820: d0e3 beq.n 1067ea <unmount+0x4a> <== NEVER TAKEN
rtems_fatal_error_occurred( 0xdeadbeef );
106822: f64b 60ef movw r0, #48879 ; 0xbeef <== NOT EXECUTED
106826: f6cd 60ad movt r0, #57005 ; 0xdead <== NOT EXECUTED
10682a: f002 f9e5 bl 108bf8 <rtems_fatal_error_occurred> <== NOT EXECUTED
errno = EBUSY;
10682e: f00e fa27 bl 114c80 <__errno>
106832: 2210 movs r2, #16
106834: 4603 mov r3, r0
106836: 601a str r2, [r3, #0]
rtems_filesystem_eval_path_cleanup( &ctx );
106838: a802 add r0, sp, #8
rv = -1;
10683a: f04f 35ff mov.w r5, #4294967295 ; 0xffffffff
rtems_filesystem_eval_path_cleanup( &ctx );
10683e: f7ff fd3b bl 1062b8 <rtems_filesystem_eval_path_cleanup>
if ( rv == 0 ) {
106842: e7d2 b.n 1067ea <unmount+0x4a>
errno = EACCES;
106844: f00e fa1c bl 114c80 <__errno>
106848: 220d movs r2, #13
10684a: 4603 mov r3, r0
10684c: 601a str r2, [r3, #0]
rtems_filesystem_eval_path_cleanup( &ctx );
10684e: a802 add r0, sp, #8
rv = -1;
106850: f04f 35ff mov.w r5, #4294967295 ; 0xffffffff
rtems_filesystem_eval_path_cleanup( &ctx );
106854: f7ff fd30 bl 1062b8 <rtems_filesystem_eval_path_cleanup>
if ( rv == 0 ) {
106858: e7c7 b.n 1067ea <unmount+0x4a>
10685a: bf00 nop
00117330 <write>:
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
117330: b570 push {r4, r5, r6, lr}
rtems_libio_t *iop;
ssize_t n;
rtems_libio_check_buffer( buffer );
117332: 2900 cmp r1, #0
117334: d046 beq.n 1173c4 <write+0x94> <== ALWAYS TAKEN
rtems_libio_check_count( count );
117336: b37a cbz r2, 117398 <write+0x68>
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_WRITE, EBADF );
117338: f647 1330 movw r3, #31024 ; 0x7930
11733c: f2c0 0311 movt r3, #17
117340: 681b ldr r3, [r3, #0]
117342: 4298 cmp r0, r3
117344: d236 bcs.n 1173b4 <write+0x84>
return &rtems_libio_iops[ fd ];
117346: eb00 0040 add.w r0, r0, r0, lsl #1
11734a: f242 45c0 movw r5, #9408 ; 0x24c0
11734e: f2c0 0520 movt r5, #32
117352: 0104 lsls r4, r0, #4
117354: 1960 adds r0, r4, r5
__asm__ volatile (
117356: f3ef 8c00 mrs ip, CPSR
11735a: f04c 0380 orr.w r3, ip, #128 ; 0x80
11735e: f383 8900 msr CPSR_fc, r3
val = *obj;
117362: 5963 ldr r3, [r4, r5]
*obj = val + arg;
117364: f503 5680 add.w r6, r3, #4096 ; 0x1000
117368: 5166 str r6, [r4, r5]
__asm__ volatile (
11736a: f38c 8900 msr CPSR_fc, ip
11736e: f403 7382 and.w r3, r3, #260 ; 0x104
117372: f5b3 7f82 cmp.w r3, #260 ; 0x104
117376: d111 bne.n 11739c <write+0x6c>
/*
* Now process the write() request.
*/
n = (*iop->pathinfo.handlers->write_h)( iop, buffer, count );
117378: 6a03 ldr r3, [r0, #32]
11737a: 68db ldr r3, [r3, #12]
11737c: 4798 blx r3
__asm__ volatile (
11737e: f3ef 8200 mrs r2, CPSR
117382: f042 0380 orr.w r3, r2, #128 ; 0x80
117386: f383 8900 msr CPSR_fc, r3
*obj = val - arg;
11738a: 5963 ldr r3, [r4, r5]
11738c: f5a3 5380 sub.w r3, r3, #4096 ; 0x1000
117390: 5163 str r3, [r4, r5]
__asm__ volatile (
117392: f382 8900 msr CPSR_fc, r2
rtems_libio_iop_drop( iop );
return n;
}
117396: bd70 pop {r4, r5, r6, pc}
rtems_libio_check_count( count );
117398: 4610 mov r0, r2
}
11739a: bd70 pop {r4, r5, r6, pc}
__asm__ volatile (
11739c: f3ef 8200 mrs r2, CPSR
1173a0: f042 0380 orr.w r3, r2, #128 ; 0x80
1173a4: f383 8900 msr CPSR_fc, r3
1173a8: 5963 ldr r3, [r4, r5]
1173aa: f5a3 5380 sub.w r3, r3, #4096 ; 0x1000
1173ae: 5163 str r3, [r4, r5]
__asm__ volatile (
1173b0: f382 8900 msr CPSR_fc, r2
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_WRITE, EBADF );
1173b4: f7f9 f9ba bl 11072c <__errno>
1173b8: 2209 movs r2, #9
1173ba: 4603 mov r3, r0
1173bc: 601a str r2, [r3, #0]
1173be: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff
}
1173c2: bd70 pop {r4, r5, r6, pc}
rtems_libio_check_buffer( buffer );
1173c4: f7f9 f9b2 bl 11072c <__errno> <== NOT EXECUTED
1173c8: 2216 movs r2, #22 <== NOT EXECUTED
1173ca: 4603 mov r3, r0 <== NOT EXECUTED
1173cc: 601a str r2, [r3, #0] <== NOT EXECUTED
1173ce: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff <== NOT EXECUTED
}
1173d2: bd70 pop {r4, r5, r6, pc} <== NOT EXECUTED