RTEMS-6
Annotated Report
libcsupport
Sun Feb 28 23:13:55 2021
001099a0 <RTEMS_Malloc_Initialize>:
Heap_Control *RTEMS_Malloc_Initialize(
const Memory_Information *mem,
Heap_Initialization_or_extend_handler extend
)
{
1099a0: 55 push %ebp
Heap_Initialization_or_extend_handler init_or_extend;
uintptr_t page_size;
size_t i;
heap = &_Malloc_Heap;
RTEMS_Malloc_Heap = heap;
1099a1: ba c0 04 13 00 mov $0x1304c0,%edx
{
1099a6: 89 e5 mov %esp,%ebp
1099a8: 57 push %edi
1099a9: 56 push %esi
1099aa: 53 push %ebx
1099ab: 31 db xor %ebx,%ebx
1099ad: 83 ec 2c sub $0x2c,%esp
RTEMS_Malloc_Heap = heap;
1099b0: 89 15 20 03 13 00 mov %edx,0x130320
{
1099b6: 8b 7d 08 mov 0x8(%ebp),%edi
init_or_extend = _Heap_Initialize;
1099b9: c7 45 e4 50 50 10 00 movl $0x105050,-0x1c(%ebp)
page_size = CPU_HEAP_ALIGNMENT;
for (i = 0; i < _Memory_Get_count( mem ); ++i) {
1099c0: 8b 0f mov (%edi),%ecx
1099c2: 85 c9 test %ecx,%ecx
1099c4: 74 6a je 109a30 <RTEMS_Malloc_Initialize+0x90> <== NEVER TAKEN
1099c6: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1099cd: 8d 76 00 lea 0x0(%esi),%esi
const Memory_Information *information,
size_t index
)
{
_Assert( index < _Memory_Get_count( information ) );
return &information->areas[ index ];
1099d0: 8b 4f 04 mov 0x4(%edi),%ecx
1099d3: 8d 04 5b lea (%ebx,%ebx,2),%eax
1099d6: 8d 34 81 lea (%ecx,%eax,4),%esi
Memory_Area *area;
uintptr_t space_available;
area = _Memory_Get_area( mem, i );
space_available = ( *init_or_extend )(
1099d9: b8 04 00 00 00 mov $0x4,%eax
*
* @return The free memory area size in bytes of the memory area.
*/
RTEMS_INLINE_ROUTINE uintptr_t _Memory_Get_free_size( const Memory_Area *area )
{
return (uintptr_t) area->end - (uintptr_t) area->free;
1099de: 8b 4e 04 mov 0x4(%esi),%ecx
1099e1: 89 44 24 0c mov %eax,0xc(%esp)
1099e5: 8b 46 08 mov 0x8(%esi),%eax
1099e8: c7 04 24 c0 04 13 00 movl $0x1304c0,(%esp)
1099ef: 89 4c 24 04 mov %ecx,0x4(%esp)
1099f3: 29 c8 sub %ecx,%eax
1099f5: 89 44 24 08 mov %eax,0x8(%esp)
1099f9: 8b 45 e4 mov -0x1c(%ebp),%eax
1099fc: ff d0 call *%eax
_Memory_Get_free_begin( area ),
_Memory_Get_free_size( area ),
page_size
);
if ( space_available > 0 ) {
1099fe: 85 c0 test %eax,%eax
109a00: 74 0c je 109a0e <RTEMS_Malloc_Initialize+0x6e>
RTEMS_INLINE_ROUTINE void _Memory_Consume(
Memory_Area *area,
uintptr_t consume
)
{
area->free = (char *) area->free + consume;
109a02: 8b 46 08 mov 0x8(%esi),%eax
109a05: 89 46 04 mov %eax,0x4(%esi)
_Memory_Consume( area, _Memory_Get_free_size( area ) );
init_or_extend = extend;
109a08: 8b 45 0c mov 0xc(%ebp),%eax
109a0b: 89 45 e4 mov %eax,-0x1c(%ebp)
for (i = 0; i < _Memory_Get_count( mem ); ++i) {
109a0e: 43 inc %ebx
109a0f: 3b 1f cmp (%edi),%ebx
109a11: 72 bd jb 1099d0 <RTEMS_Malloc_Initialize+0x30> <== NEVER TAKEN
}
}
if ( init_or_extend == _Heap_Initialize ) {
109a13: 81 7d e4 50 50 10 00 cmpl $0x105050,-0x1c(%ebp)
109a1a: 74 14 je 109a30 <RTEMS_Malloc_Initialize+0x90>
_Internal_error( INTERNAL_ERROR_NO_MEMORY_FOR_HEAP );
}
return heap;
}
109a1c: 83 c4 2c add $0x2c,%esp
109a1f: b8 c0 04 13 00 mov $0x1304c0,%eax
109a24: 5b pop %ebx
109a25: 5e pop %esi
109a26: 5f pop %edi
109a27: 5d pop %ebp
109a28: c3 ret
109a29: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
_Internal_error( INTERNAL_ERROR_NO_MEMORY_FOR_HEAP );
109a30: c7 04 24 17 00 00 00 movl $0x17,(%esp)
109a37: e8 e4 b9 ff ff call 105420 <_Internal_error>
109a3c: 90 nop
109a3d: 90 nop
109a3e: 90 nop
109a3f: 90 nop
00100f10 <_Console_simple_Read>:
ssize_t _Console_simple_Read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
100f10: 55 push %ebp <== NOT EXECUTED
100f11: 89 e5 mov %esp,%ebp <== NOT EXECUTED
100f13: 57 push %edi <== NOT EXECUTED
100f14: 56 push %esi <== NOT EXECUTED
100f15: 53 push %ebx <== NOT EXECUTED
100f16: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED
100f19: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED
ssize_t n;
buf = buffer;
n = (ssize_t) count;
for ( i = 0; i < n; ++i ) {
100f1c: 85 ff test %edi,%edi <== NOT EXECUTED
100f1e: 7e 2d jle 100f4d <_Console_simple_Read+0x3d> <== NOT EXECUTED
100f20: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED
100f23: 8d 34 3b lea (%ebx,%edi,1),%esi <== NOT EXECUTED
100f26: eb 14 jmp 100f3c <_Console_simple_Read+0x2c> <== NOT EXECUTED
100f28: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
100f2f: 90 nop <== NOT EXECUTED
c = getchark();
if ( c != -1 ) {
break;
}
(void) rtems_task_wake_after( 1 );
100f30: c7 04 24 01 00 00 00 movl $0x1,(%esp) <== NOT EXECUTED
100f37: e8 44 3b 00 00 call 104a80 <rtems_task_wake_after> <== NOT EXECUTED
c = getchark();
100f3c: e8 1f 00 00 00 call 100f60 <getchark> <== NOT EXECUTED
if ( c != -1 ) {
100f41: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED
100f44: 74 ea je 100f30 <_Console_simple_Read+0x20> <== NOT EXECUTED
}
buf[ i ] = (char) c;
100f46: 88 03 mov %al,(%ebx) <== NOT EXECUTED
for ( i = 0; i < n; ++i ) {
100f48: 43 inc %ebx <== NOT EXECUTED
100f49: 39 f3 cmp %esi,%ebx <== NOT EXECUTED
100f4b: 75 ef jne 100f3c <_Console_simple_Read+0x2c> <== NOT EXECUTED
}
return n;
}
100f4d: 83 c4 1c add $0x1c,%esp <== NOT EXECUTED
100f50: 89 f8 mov %edi,%eax <== NOT EXECUTED
100f52: 5b pop %ebx <== NOT EXECUTED
100f53: 5e pop %esi <== NOT EXECUTED
100f54: 5f pop %edi <== NOT EXECUTED
100f55: 5d pop %ebp <== NOT EXECUTED
100f56: c3 ret <== NOT EXECUTED
100f57: 90 nop
100f58: 90 nop
100f59: 90 nop
100f5a: 90 nop
100f5b: 90 nop
100f5c: 90 nop
100f5d: 90 nop
100f5e: 90 nop
100f5f: 90 nop
00109830 <_Malloc_Process_deferred_frees>:
{
109830: 55 push %ebp <== NOT EXECUTED
109831: 89 e5 mov %esp,%ebp <== NOT EXECUTED
109833: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED
109836: eb 21 jmp 109859 <_Malloc_Process_deferred_frees+0x29> <== NOT EXECUTED
109838: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10983f: 90 nop
new_first = old_first->next;
109840: 8b 0a mov (%edx),%ecx
head->next = new_first;
109842: 89 0d 1c a4 12 00 mov %ecx,0x12a41c
new_first->previous = head;
109848: c7 41 04 1c a4 12 00 movl $0x12a41c,0x4(%ecx)
rtems_interrupt_lock_release( &_Malloc_GC_lock, &lock_context );
10984f: 50 push %eax
109850: 9d popf
free( to_be_freed );
109851: 89 14 24 mov %edx,(%esp)
109854: e8 57 ff ff ff call 1097b0 <free>
rtems_interrupt_lock_acquire( &_Malloc_GC_lock, &lock_context );
109859: 9c pushf
10985a: fa cli
10985b: 58 pop %eax
return _Chain_Immutable_head( the_chain )->next;
10985c: 8b 15 1c a4 12 00 mov 0x12a41c,%edx
if ( !_Chain_Is_empty(the_chain))
109862: 81 fa 20 a4 12 00 cmp $0x12a420,%edx
109868: 75 d6 jne 109840 <_Malloc_Process_deferred_frees+0x10>
rtems_interrupt_lock_release( &_Malloc_GC_lock, &lock_context );
10986a: 50 push %eax
10986b: 9d popf
}
10986c: 89 ec mov %ebp,%esp
10986e: 5d pop %ebp
10986f: c3 ret
00100fb0 <_gettimeofday_r>:
int _gettimeofday_r(
struct _reent *ignored_reentrancy_stuff RTEMS_UNUSED,
struct timeval *tp,
void *__tz
)
{
100fb0: 55 push %ebp
100fb1: 89 e5 mov %esp,%ebp
100fb3: 83 ec 18 sub $0x18,%esp
100fb6: 8b 45 0c mov 0xc(%ebp),%eax
if ( !tp )
100fb9: 85 c0 test %eax,%eax
100fbb: 74 0e je 100fcb <_gettimeofday_r+0x1b> <== NEVER TAKEN
100fbd: 89 04 24 mov %eax,(%esp)
100fc0: e8 ab 54 00 00 call 106470 <_Timecounter_Microtime>
return 0;
100fc5: 31 c0 xor %eax,%eax
struct timezone *tzp = __tz;
return gettimeofday( tp, tzp );
}
100fc7: 89 ec mov %ebp,%esp
100fc9: 5d pop %ebp
100fca: c3 ret
rtems_set_errno_and_return_minus_one( EFAULT );
100fcb: e8 c0 80 01 00 call 119090 <__errno> <== NOT EXECUTED
100fd0: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED
100fd6: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
100fdb: eb ea jmp 100fc7 <_gettimeofday_r+0x17> <== NOT EXECUTED
100fdd: 90 nop
100fde: 90 nop
100fdf: 90 nop
00103d50 <_libcsupport_scangr>:
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
103d50: 55 push %ebp
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
103d51: 31 c0 xor %eax,%eax
{
103d53: 89 e5 mov %esp,%ebp
103d55: 83 ec 38 sub $0x38,%esp
103d58: 89 5d f4 mov %ebx,-0xc(%ebp)
103d5b: 8b 5d 08 mov 0x8(%ebp),%ebx
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
103d5e: 8d 4d 10 lea 0x10(%ebp),%ecx
{
103d61: 89 75 f8 mov %esi,-0x8(%ebp)
103d64: 8b 75 0c mov 0xc(%ebp),%esi
103d67: 89 7d fc mov %edi,-0x4(%ebp)
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
103d6a: 8d 7d 14 lea 0x14(%ebp),%edi
103d6d: 89 44 24 04 mov %eax,0x4(%esp)
103d71: 89 3c 24 mov %edi,(%esp)
103d74: 89 d8 mov %ebx,%eax
103d76: 89 f2 mov %esi,%edx
103d78: e8 63 fc ff ff call 1039e0 <scanString>
103d7d: 85 c0 test %eax,%eax
103d7f: 75 0f jne 103d90 <_libcsupport_scangr+0x40>
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
|| !scanInt(fp, &grgid)
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
return 0;
103d81: 31 c0 xor %eax,%eax
}
}
grp->gr_mem[memcount] = NULL;
return 1;
}
103d83: 8b 5d f4 mov -0xc(%ebp),%ebx
103d86: 8b 75 f8 mov -0x8(%ebp),%esi
103d89: 8b 7d fc mov -0x4(%ebp),%edi
103d8c: 89 ec mov %ebp,%esp
103d8e: 5d pop %ebp
103d8f: c3 ret
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
103d90: 89 3c 24 mov %edi,(%esp)
103d93: 8d 56 04 lea 0x4(%esi),%edx
103d96: 31 c0 xor %eax,%eax
103d98: 89 44 24 04 mov %eax,0x4(%esp)
103d9c: 8d 4d 10 lea 0x10(%ebp),%ecx
103d9f: 89 d8 mov %ebx,%eax
103da1: e8 3a fc ff ff call 1039e0 <scanString>
103da6: 85 c0 test %eax,%eax
103da8: 74 d7 je 103d81 <_libcsupport_scangr+0x31> <== NEVER TAKEN
|| !scanInt(fp, &grgid)
103daa: 8d 55 e0 lea -0x20(%ebp),%edx
103dad: 89 d8 mov %ebx,%eax
103daf: e8 6c fb ff ff call 103920 <scanInt>
103db4: 85 c0 test %eax,%eax
103db6: 74 c9 je 103d81 <_libcsupport_scangr+0x31> <== NEVER TAKEN
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
103db8: 89 3c 24 mov %edi,(%esp)
103dbb: b9 01 00 00 00 mov $0x1,%ecx
103dc0: 89 d8 mov %ebx,%eax
103dc2: 89 4c 24 04 mov %ecx,0x4(%esp)
103dc6: 8d 55 e4 lea -0x1c(%ebp),%edx
103dc9: 8d 4d 10 lea 0x10(%ebp),%ecx
103dcc: e8 0f fc ff ff call 1039e0 <scanString>
103dd1: 85 c0 test %eax,%eax
103dd3: 74 ac je 103d81 <_libcsupport_scangr+0x31> <== NEVER TAKEN
grp->gr_gid = grgid;
103dd5: 8b 45 e0 mov -0x20(%ebp),%eax
103dd8: ba 13 00 00 00 mov $0x13,%edx
if (grmem[0] == '\0') {
103ddd: 8b 4d e4 mov -0x1c(%ebp),%ecx
grp->gr_gid = grgid;
103de0: 66 89 46 08 mov %ax,0x8(%esi)
if (grmem[0] == '\0') {
103de4: 0f b6 01 movzbl (%ecx),%eax
103de7: 84 c0 test %al,%al
103de9: 74 33 je 103e1e <_libcsupport_scangr+0xce>
103deb: 89 ca mov %ecx,%edx
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
103ded: bb 01 00 00 00 mov $0x1,%ebx
103df2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
103df9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
memcount++;
103e00: 8d 7b 01 lea 0x1(%ebx),%edi
if(*cp == ',')
103e03: 3c 2c cmp $0x2c,%al
103e05: 75 07 jne 103e0e <_libcsupport_scangr+0xbe>
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
103e07: 8d 43 02 lea 0x2(%ebx),%eax
memcount++;
103e0a: 89 fb mov %edi,%ebx
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
103e0c: 89 c7 mov %eax,%edi
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
103e0e: 0f b6 42 01 movzbl 0x1(%edx),%eax
103e12: 42 inc %edx
103e13: 84 c0 test %al,%al
103e15: 75 e9 jne 103e00 <_libcsupport_scangr+0xb0>
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
103e17: 8d 14 bd 0f 00 00 00 lea 0xf(,%edi,4),%edx
103e1e: 39 55 14 cmp %edx,0x14(%ebp)
103e21: 0f 82 5a ff ff ff jb 103d81 <_libcsupport_scangr+0x31> <== NEVER TAKEN
grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15);
103e27: 8b 45 10 mov 0x10(%ebp),%eax
103e2a: 83 c0 0f add $0xf,%eax
103e2d: 83 e0 f0 and $0xfffffff0,%eax
103e30: 89 46 0c mov %eax,0xc(%esi)
if (grmem[0] == '\0') {
103e33: 80 39 00 cmpb $0x0,(%ecx)
103e36: 74 3f je 103e77 <_libcsupport_scangr+0x127>
grp->gr_mem[0] = grmem;
103e38: 89 08 mov %ecx,(%eax)
grp->gr_mem[memcount] = NULL;
103e3a: 83 c0 04 add $0x4,%eax
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
103e3d: bb 01 00 00 00 mov $0x1,%ebx
103e42: 8b 4d e4 mov -0x1c(%ebp),%ecx
103e45: 0f b6 11 movzbl (%ecx),%edx
103e48: 84 d2 test %dl,%dl
103e4a: 74 2b je 103e77 <_libcsupport_scangr+0x127> <== NEVER TAKEN
103e4c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
grp->gr_mem[memcount++] = cp + 1;
103e50: 8d 04 9d 00 00 00 00 lea 0x0(,%ebx,4),%eax
103e57: 41 inc %ecx
if(*cp == ',') {
103e58: 80 fa 2c cmp $0x2c,%dl
103e5b: 75 0e jne 103e6b <_libcsupport_scangr+0x11b>
*cp = '\0';
103e5d: c6 41 ff 00 movb $0x0,-0x1(%ecx)
grp->gr_mem[memcount++] = cp + 1;
103e61: 43 inc %ebx
103e62: 8b 56 0c mov 0xc(%esi),%edx
103e65: 89 0c 02 mov %ecx,(%edx,%eax,1)
grp->gr_mem[memcount] = NULL;
103e68: 83 c0 04 add $0x4,%eax
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
103e6b: 0f b6 11 movzbl (%ecx),%edx
103e6e: 84 d2 test %dl,%dl
103e70: 75 de jne 103e50 <_libcsupport_scangr+0x100>
grp->gr_mem[memcount] = NULL;
103e72: 8b 56 0c mov 0xc(%esi),%edx
103e75: 01 d0 add %edx,%eax
103e77: c7 00 00 00 00 00 movl $0x0,(%eax)
return 1;
103e7d: b8 01 00 00 00 mov $0x1,%eax
103e82: e9 fc fe ff ff jmp 103d83 <_libcsupport_scangr+0x33>
103e87: 90 nop
103e88: 90 nop
103e89: 90 nop
103e8a: 90 nop
103e8b: 90 nop
103e8c: 90 nop
103e8d: 90 nop
103e8e: 90 nop
103e8f: 90 nop
00103b50 <_libcsupport_scanpw>:
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
103b50: 55 push %ebp
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
103b51: 31 c0 xor %eax,%eax
{
103b53: 89 e5 mov %esp,%ebp
103b55: 56 push %esi
103b56: 53 push %ebx
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
103b57: 8d 75 14 lea 0x14(%ebp),%esi
{
103b5a: 83 ec 20 sub $0x20,%esp
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
103b5d: 89 44 24 04 mov %eax,0x4(%esp)
{
103b61: 8b 5d 0c mov 0xc(%ebp),%ebx
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
103b64: 8d 4d 10 lea 0x10(%ebp),%ecx
103b67: 89 34 24 mov %esi,(%esp)
103b6a: 8b 45 08 mov 0x8(%ebp),%eax
103b6d: 89 da mov %ebx,%edx
103b6f: e8 6c fe ff ff call 1039e0 <scanString>
103b74: 85 c0 test %eax,%eax
103b76: 75 18 jne 103b90 <_libcsupport_scanpw+0x40>
|| !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;
103b78: 31 c0 xor %eax,%eax
pwd->pw_uid = pwuid;
pwd->pw_gid = pwgid;
return 1;
}
103b7a: 83 c4 20 add $0x20,%esp
103b7d: 5b pop %ebx
103b7e: 5e pop %esi
103b7f: 5d pop %ebp
103b80: c3 ret
103b81: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
103b88: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
103b8f: 90 nop
|| !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0)
103b90: 89 34 24 mov %esi,(%esp)
103b93: 8d 53 04 lea 0x4(%ebx),%edx
103b96: 31 c0 xor %eax,%eax
103b98: 89 44 24 04 mov %eax,0x4(%esp)
103b9c: 8b 45 08 mov 0x8(%ebp),%eax
103b9f: 8d 4d 10 lea 0x10(%ebp),%ecx
103ba2: e8 39 fe ff ff call 1039e0 <scanString>
103ba7: 85 c0 test %eax,%eax
103ba9: 74 cd je 103b78 <_libcsupport_scanpw+0x28> <== NEVER TAKEN
|| !scanInt(fp, &pwuid)
103bab: 8b 45 08 mov 0x8(%ebp),%eax
103bae: 8d 55 f0 lea -0x10(%ebp),%edx
103bb1: e8 6a fd ff ff call 103920 <scanInt>
103bb6: 85 c0 test %eax,%eax
103bb8: 74 be je 103b78 <_libcsupport_scanpw+0x28>
|| !scanInt(fp, &pwgid)
103bba: 8b 45 08 mov 0x8(%ebp),%eax
103bbd: 8d 55 f4 lea -0xc(%ebp),%edx
103bc0: e8 5b fd ff ff call 103920 <scanInt>
103bc5: 85 c0 test %eax,%eax
103bc7: 74 af je 103b78 <_libcsupport_scanpw+0x28>
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
103bc9: 89 34 24 mov %esi,(%esp)
103bcc: 8d 53 0c lea 0xc(%ebx),%edx
103bcf: 31 c0 xor %eax,%eax
103bd1: 89 44 24 04 mov %eax,0x4(%esp)
103bd5: 8b 45 08 mov 0x8(%ebp),%eax
103bd8: 8d 4d 10 lea 0x10(%ebp),%ecx
103bdb: e8 00 fe ff ff call 1039e0 <scanString>
103be0: 85 c0 test %eax,%eax
103be2: 74 94 je 103b78 <_libcsupport_scanpw+0x28> <== NEVER TAKEN
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
103be4: 89 34 24 mov %esi,(%esp)
103be7: 8d 53 10 lea 0x10(%ebx),%edx
103bea: 31 c0 xor %eax,%eax
103bec: 89 44 24 04 mov %eax,0x4(%esp)
103bf0: 8b 45 08 mov 0x8(%ebp),%eax
103bf3: 8d 4d 10 lea 0x10(%ebp),%ecx
103bf6: e8 e5 fd ff ff call 1039e0 <scanString>
103bfb: 85 c0 test %eax,%eax
103bfd: 0f 84 75 ff ff ff je 103b78 <_libcsupport_scanpw+0x28> <== NEVER TAKEN
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
103c03: 8b 45 08 mov 0x8(%ebp),%eax
103c06: 8d 53 14 lea 0x14(%ebx),%edx
103c09: 31 c9 xor %ecx,%ecx
103c0b: 89 4c 24 04 mov %ecx,0x4(%esp)
103c0f: 8d 4d 10 lea 0x10(%ebp),%ecx
103c12: 89 34 24 mov %esi,(%esp)
103c15: e8 c6 fd ff ff call 1039e0 <scanString>
103c1a: 85 c0 test %eax,%eax
103c1c: 0f 84 56 ff ff ff je 103b78 <_libcsupport_scanpw+0x28> <== NEVER TAKEN
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
103c22: 89 34 24 mov %esi,(%esp)
103c25: 8d 53 18 lea 0x18(%ebx),%edx
103c28: b8 01 00 00 00 mov $0x1,%eax
103c2d: 89 44 24 04 mov %eax,0x4(%esp)
103c31: 8b 45 08 mov 0x8(%ebp),%eax
103c34: 8d 4d 10 lea 0x10(%ebp),%ecx
103c37: e8 a4 fd ff ff call 1039e0 <scanString>
103c3c: 85 c0 test %eax,%eax
103c3e: 0f 84 34 ff ff ff je 103b78 <_libcsupport_scanpw+0x28>
pwd->pw_uid = pwuid;
103c44: 8b 45 f0 mov -0x10(%ebp),%eax
103c47: 66 89 43 08 mov %ax,0x8(%ebx)
pwd->pw_gid = pwgid;
103c4b: 8b 45 f4 mov -0xc(%ebp),%eax
103c4e: 66 89 43 0a mov %ax,0xa(%ebx)
return 1;
103c52: b8 01 00 00 00 mov $0x1,%eax
103c57: e9 1e ff ff ff jmp 103b7a <_libcsupport_scanpw+0x2a>
103c5c: 90 nop
103c5d: 90 nop
103c5e: 90 nop
103c5f: 90 nop
001244b0 <_read_r>:
struct _reent *ptr RTEMS_UNUSED,
int fd,
void *buf,
size_t nbytes
)
{
1244b0: 55 push %ebp
1244b1: 89 e5 mov %esp,%ebp
1244b3: 83 ec 08 sub $0x8,%esp
1244b6: 8b 55 10 mov 0x10(%ebp),%edx
1244b9: 8b 45 0c mov 0xc(%ebp),%eax
1244bc: 8b 4d 14 mov 0x14(%ebp),%ecx
rtems_libio_check_buffer( buffer );
1244bf: 85 d2 test %edx,%edx
1244c1: 74 35 je 1244f8 <_read_r+0x48> <== NEVER TAKEN
rtems_libio_check_count( count );
1244c3: 85 c9 test %ecx,%ecx
1244c5: 74 19 je 1244e0 <_read_r+0x30> <== NEVER TAKEN
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_READ, EBADF );
1244c7: 3b 05 9c 47 12 00 cmp 0x12479c,%eax
1244cd: 73 17 jae 1244e6 <_read_r+0x36> <== NEVER TAKEN
return read( fd, buf, nbytes );
}
1244cf: 89 ec mov %ebp,%esp
1244d1: 5d pop %ebp
1244d2: e9 49 ff ff ff jmp 124420 <read.part.0>
1244d7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1244de: 66 90 xchg %ax,%ax
rtems_libio_check_count( count );
1244e0: 31 c0 xor %eax,%eax
}
1244e2: 89 ec mov %ebp,%esp <== NOT EXECUTED
1244e4: 5d pop %ebp <== NOT EXECUTED
1244e5: c3 ret <== NOT EXECUTED
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_READ, EBADF );
1244e6: e8 a5 4b ff ff call 119090 <__errno> <== NOT EXECUTED
1244eb: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED
1244f1: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
1244f6: eb ea jmp 1244e2 <_read_r+0x32> <== NOT EXECUTED
rtems_libio_check_buffer( buffer );
1244f8: e8 93 4b ff ff call 119090 <__errno> <== NOT EXECUTED
1244fd: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
124503: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
124508: eb d8 jmp 1244e2 <_read_r+0x32> <== NOT EXECUTED
12450a: 90 nop
12450b: 90 nop
12450c: 90 nop
12450d: 90 nop
12450e: 90 nop
12450f: 90 nop
00101a00 <_times>:
* POSIX 1003.1b 4.5.2 - Get Process Times
*/
clock_t _times(
struct tms *ptms
)
{
101a00: 55 push %ebp
101a01: 89 e5 mov %esp,%ebp
101a03: 57 push %edi
101a04: 56 push %esi
101a05: 53 push %ebx
101a06: 83 ec 3c sub $0x3c,%esp
101a09: 8b 5d 08 mov 0x8(%ebp),%ebx
uint32_t tick_interval;
sbintime_t uptime;
sbintime_t cpu_time_used;
if ( !ptms )
101a0c: 85 db test %ebx,%ebx
101a0e: 0f 84 0c 01 00 00 je 101b20 <_times+0x120>
rtems_set_errno_and_return_minus_one( EFAULT );
tick_interval = (uint32_t)
101a14: 69 35 b0 f1 11 00 c6 imul $0x10c6,0x11f1b0,%esi
101a1b: 10 00 00
(SBT_1US * rtems_configuration_get_microseconds_per_tick());
ptms = memset( ptms, 0, sizeof( *ptms ) );
101a1e: 31 ff xor %edi,%edi
101a20: f6 c3 01 test $0x1,%bl
101a23: 89 d8 mov %ebx,%eax
101a25: b9 20 00 00 00 mov $0x20,%ecx
101a2a: 0f 85 10 01 00 00 jne 101b40 <_times+0x140> <== NEVER TAKEN
101a30: a8 02 test $0x2,%al
101a32: 0f 85 18 01 00 00 jne 101b50 <_times+0x150> <== NEVER TAKEN
101a38: 89 ca mov %ecx,%edx
101a3a: 83 e2 f8 and $0xfffffff8,%edx
101a3d: 89 55 d4 mov %edx,-0x2c(%ebp)
101a40: 31 d2 xor %edx,%edx
101a42: 89 3c 10 mov %edi,(%eax,%edx,1)
101a45: 89 7c 10 04 mov %edi,0x4(%eax,%edx,1)
101a49: 83 c2 08 add $0x8,%edx
101a4c: 3b 55 d4 cmp -0x2c(%ebp),%edx
101a4f: 72 f1 jb 101a42 <_times+0x42>
101a51: 01 d0 add %edx,%eax
101a53: f6 c1 04 test $0x4,%cl
101a56: 0f 85 a4 00 00 00 jne 101b00 <_times+0x100> <== NEVER TAKEN
101a5c: f6 c1 02 test $0x2,%cl
101a5f: 75 7f jne 101ae0 <_times+0xe0> <== NEVER TAKEN
101a61: f6 c1 01 test $0x1,%cl
101a64: 75 6a jne 101ad0 <_times+0xd0> <== NEVER TAKEN
*/
static inline void _TOD_Get_zero_based_uptime(
Timestamp_Control *time
)
{
*time = _Timecounter_Sbinuptime() - SBT_1S;
101a66: e8 45 35 00 00 call 104fb0 <_Timecounter_Sbinuptime>
_TOD_Get_zero_based_uptime( &uptime );
ptms->tms_stime = ((clock_t) uptime) / tick_interval;
101a6b: 31 ff xor %edi,%edi
101a6d: 89 74 24 08 mov %esi,0x8(%esp)
101a71: 89 7c 24 0c mov %edi,0xc(%esp)
101a75: 89 04 24 mov %eax,(%esp)
101a78: 4a dec %edx
101a79: 89 54 24 04 mov %edx,0x4(%esp)
101a7d: e8 2e 56 01 00 call 1170b0 <__udivdi3>
101a82: 89 43 08 mov %eax,0x8(%ebx)
* since there is no separation of OS from application tasks.
* But we can at least make a distinction between the number
* of ticks since boot and the number of ticks executed by this
* this thread.
*/
_Thread_Get_CPU_time_used( _Thread_Get_executing(), &cpu_time_used );
101a85: 8d 45 e0 lea -0x20(%ebp),%eax
ptms->tms_stime = ((clock_t) uptime) / tick_interval;
101a88: 89 53 0c mov %edx,0xc(%ebx)
_Thread_Get_CPU_time_used( _Thread_Get_executing(), &cpu_time_used );
101a8b: 89 44 24 04 mov %eax,0x4(%esp)
101a8f: a1 98 7e 12 00 mov 0x127e98,%eax
101a94: 89 04 24 mov %eax,(%esp)
101a97: e8 d4 42 00 00 call 105d70 <_Thread_Get_CPU_time_used>
ptms->tms_utime = ((clock_t) cpu_time_used) / tick_interval;
101a9c: 8b 45 e0 mov -0x20(%ebp),%eax
101a9f: 89 74 24 08 mov %esi,0x8(%esp)
101aa3: 8b 55 e4 mov -0x1c(%ebp),%edx
101aa6: 89 7c 24 0c mov %edi,0xc(%esp)
101aaa: 89 04 24 mov %eax,(%esp)
101aad: 89 54 24 04 mov %edx,0x4(%esp)
101ab1: e8 fa 55 01 00 call 1170b0 <__udivdi3>
101ab6: 89 03 mov %eax,(%ebx)
return ptms->tms_stime;
101ab8: 8b 43 08 mov 0x8(%ebx),%eax
ptms->tms_utime = ((clock_t) cpu_time_used) / tick_interval;
101abb: 89 53 04 mov %edx,0x4(%ebx)
return ptms->tms_stime;
101abe: 8b 53 0c mov 0xc(%ebx),%edx
}
101ac1: 83 c4 3c add $0x3c,%esp
101ac4: 5b pop %ebx
101ac5: 5e pop %esi
101ac6: 5f pop %edi
101ac7: 5d pop %ebp
101ac8: c3 ret
101ac9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
ptms = memset( ptms, 0, sizeof( *ptms ) );
101ad0: c6 00 00 movb $0x0,(%eax) <== NOT EXECUTED
101ad3: eb 91 jmp 101a66 <_times+0x66> <== NOT EXECUTED
101ad5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
101adc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
101ae0: 66 c7 00 00 00 movw $0x0,(%eax) <== NOT EXECUTED
101ae5: 83 c0 02 add $0x2,%eax <== NOT EXECUTED
101ae8: f6 c1 01 test $0x1,%cl <== NOT EXECUTED
101aeb: 0f 84 75 ff ff ff je 101a66 <_times+0x66> <== NOT EXECUTED
101af1: eb dd jmp 101ad0 <_times+0xd0> <== NOT EXECUTED
101af3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
101afa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
101b00: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED
101b06: 83 c0 04 add $0x4,%eax <== NOT EXECUTED
101b09: f6 c1 02 test $0x2,%cl <== NOT EXECUTED
101b0c: 0f 84 4f ff ff ff je 101a61 <_times+0x61> <== NOT EXECUTED
101b12: eb cc jmp 101ae0 <_times+0xe0> <== NOT EXECUTED
101b14: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
101b1b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
101b1f: 90 nop <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EFAULT );
101b20: e8 fb 67 01 00 call 118320 <__errno>
101b25: ba ff ff ff ff mov $0xffffffff,%edx
101b2a: c7 00 0e 00 00 00 movl $0xe,(%eax)
}
101b30: 83 c4 3c add $0x3c,%esp
rtems_set_errno_and_return_minus_one( EFAULT );
101b33: b8 ff ff ff ff mov $0xffffffff,%eax
}
101b38: 5b pop %ebx
101b39: 5e pop %esi
101b3a: 5f pop %edi
101b3b: 5d pop %ebp
101b3c: c3 ret
101b3d: 8d 76 00 lea 0x0(%esi),%esi
ptms = memset( ptms, 0, sizeof( *ptms ) );
101b40: c6 03 00 movb $0x0,(%ebx) <== NOT EXECUTED
101b43: 8d 43 01 lea 0x1(%ebx),%eax <== NOT EXECUTED
101b46: b9 1f 00 00 00 mov $0x1f,%ecx <== NOT EXECUTED
101b4b: e9 e0 fe ff ff jmp 101a30 <_times+0x30> <== NOT EXECUTED
101b50: 66 c7 00 00 00 movw $0x0,(%eax) <== NOT EXECUTED
101b55: 83 e9 02 sub $0x2,%ecx <== NOT EXECUTED
101b58: 83 c0 02 add $0x2,%eax <== NOT EXECUTED
101b5b: e9 d8 fe ff ff jmp 101a38 <_times+0x38> <== NOT EXECUTED
00109680 <calloc>:
void *calloc(
size_t nelem,
size_t elsize
)
{
109680: 55 push %ebp
109681: 89 e5 mov %esp,%ebp
109683: 57 push %edi
109684: 53 push %ebx
109685: 83 ec 10 sub $0x10,%esp
void *cptr;
size_t length;
length = nelem * elsize;
109688: 8b 55 0c mov 0xc(%ebp),%edx
10968b: 8b 7d 08 mov 0x8(%ebp),%edi
10968e: 0f af fa imul %edx,%edi
cptr = malloc( length );
109691: 89 3c 24 mov %edi,(%esp)
109694: e8 47 79 ff ff call 100fe0 <malloc>
RTEMS_OBFUSCATE_VARIABLE( cptr );
109699: 89 c3 mov %eax,%ebx
if ( RTEMS_PREDICT_FALSE( cptr == NULL ) ) {
10969b: 85 db test %ebx,%ebx
10969d: 74 18 je 1096b7 <calloc+0x37>
return cptr;
}
return memset( cptr, 0, length );
10969f: 89 fa mov %edi,%edx
1096a1: 89 df mov %ebx,%edi
1096a3: 83 fa 08 cmp $0x8,%edx
1096a6: 73 48 jae 1096f0 <calloc+0x70>
1096a8: f6 c2 04 test $0x4,%dl
1096ab: 75 33 jne 1096e0 <calloc+0x60> <== NEVER TAKEN
1096ad: f6 c2 02 test $0x2,%dl
1096b0: 75 1e jne 1096d0 <calloc+0x50>
1096b2: f6 c2 01 test $0x1,%dl
1096b5: 75 09 jne 1096c0 <calloc+0x40>
}
1096b7: 83 c4 10 add $0x10,%esp
1096ba: 89 d8 mov %ebx,%eax
1096bc: 5b pop %ebx
1096bd: 5f pop %edi
1096be: 5d pop %ebp
1096bf: c3 ret
return memset( cptr, 0, length );
1096c0: c6 07 00 movb $0x0,(%edi)
}
1096c3: 83 c4 10 add $0x10,%esp
1096c6: 89 d8 mov %ebx,%eax
1096c8: 5b pop %ebx
1096c9: 5f pop %edi
1096ca: 5d pop %ebp
1096cb: c3 ret
1096cc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
return memset( cptr, 0, length );
1096d0: 66 c7 07 00 00 movw $0x0,(%edi)
1096d5: 83 c7 02 add $0x2,%edi
1096d8: f6 c2 01 test $0x1,%dl
1096db: 74 da je 1096b7 <calloc+0x37>
1096dd: eb e1 jmp 1096c0 <calloc+0x40>
1096df: 90 nop
1096e0: c7 07 00 00 00 00 movl $0x0,(%edi) <== NOT EXECUTED
1096e6: 83 c7 04 add $0x4,%edi <== NOT EXECUTED
1096e9: f6 c2 02 test $0x2,%dl <== NOT EXECUTED
1096ec: 74 c4 je 1096b2 <calloc+0x32> <== NOT EXECUTED
1096ee: eb e0 jmp 1096d0 <calloc+0x50> <== NOT EXECUTED
1096f0: f6 c3 01 test $0x1,%bl
1096f3: 75 2b jne 109720 <calloc+0xa0> <== NEVER TAKEN
1096f5: f7 c7 02 00 00 00 test $0x2,%edi
1096fb: 75 33 jne 109730 <calloc+0xb0> <== NEVER TAKEN
1096fd: f7 c7 04 00 00 00 test $0x4,%edi
109703: 75 3b jne 109740 <calloc+0xc0>
109705: 89 d1 mov %edx,%ecx
109707: 31 c0 xor %eax,%eax
109709: c1 e9 02 shr $0x2,%ecx
10970c: 83 e2 03 and $0x3,%edx
10970f: f3 ab rep stos %eax,%es:(%edi)
109711: eb 95 jmp 1096a8 <calloc+0x28>
109713: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10971a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
109720: c6 03 00 movb $0x0,(%ebx) <== NOT EXECUTED
109723: 8d 7b 01 lea 0x1(%ebx),%edi <== NOT EXECUTED
109726: 4a dec %edx <== NOT EXECUTED
109727: eb cc jmp 1096f5 <calloc+0x75> <== NOT EXECUTED
109729: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
109730: 66 c7 07 00 00 movw $0x0,(%edi) <== NOT EXECUTED
109735: 83 ea 02 sub $0x2,%edx <== NOT EXECUTED
109738: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
10973b: eb c0 jmp 1096fd <calloc+0x7d> <== NOT EXECUTED
10973d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
109740: c7 07 00 00 00 00 movl $0x0,(%edi)
109746: 83 ea 04 sub $0x4,%edx
109749: 83 c7 04 add $0x4,%edi
10974c: eb b7 jmp 109705 <calloc+0x85>
10974e: 90 nop
10974f: 90 nop
0010de20 <chroot>:
#include <unistd.h>
#include <rtems/libio_.h>
int chroot( const char *path )
{
10de20: 55 push %ebp
10de21: 89 e5 mov %esp,%ebp
10de23: 56 push %esi
/*
* 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(
10de24: be c4 75 15 00 mov $0x1575c4,%esi
{
10de29: 53 push %ebx
10de2a: 81 ec d0 00 00 00 sub $0xd0,%esp
10de30: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_filesystem_eval_path_start_with_root_and_current(
10de33: 89 1c 24 mov %ebx,(%esp)
10de36: e8 05 92 01 00 call 127040 <strlen>
10de3b: b9 c0 75 15 00 mov $0x1575c0,%ecx
10de40: ba 19 00 00 00 mov $0x19,%edx
10de45: 89 74 24 10 mov %esi,0x10(%esp)
10de49: 8d b5 68 ff ff ff lea -0x98(%ebp),%esi
10de4f: 89 4c 24 14 mov %ecx,0x14(%esp)
10de53: 89 54 24 0c mov %edx,0xc(%esp)
10de57: 89 5c 24 04 mov %ebx,0x4(%esp)
rtems_filesystem_location_copy_and_detach(
10de5b: 8d 9d 50 ff ff ff lea -0xb0(%ebp),%ebx
10de61: 89 34 24 mov %esi,(%esp)
10de64: 89 44 24 08 mov %eax,0x8(%esp)
10de68: e8 d3 1e 00 00 call 10fd40 <rtems_filesystem_eval_path_start_with_root_and_current>
10de6d: 8d 45 80 lea -0x80(%ebp),%eax
10de70: 89 44 24 04 mov %eax,0x4(%esp)
10de74: 89 1c 24 mov %ebx,(%esp)
10de77: e8 f4 29 00 00 call 110870 <rtems_filesystem_location_copy_and_detach>
&rtems_global_user_env.root_directory,
&rtems_global_user_env.current_directory
);
rtems_filesystem_eval_path_extract_currentloc( &ctx, &loc );
new_current_loc = rtems_filesystem_location_transform_to_global( &loc );
10de7c: 89 1c 24 mov %ebx,(%esp)
10de7f: e8 7c 2a 00 00 call 110900 <rtems_filesystem_location_transform_to_global>
if ( !rtems_filesystem_global_location_is_null( new_current_loc ) ) {
10de84: 81 78 10 60 14 13 00 cmpl $0x131460,0x10(%eax)
new_current_loc = rtems_filesystem_location_transform_to_global( &loc );
10de8b: 89 85 4c ff ff ff mov %eax,-0xb4(%ebp)
if ( !rtems_filesystem_global_location_is_null( new_current_loc ) ) {
10de91: 0f 84 f9 00 00 00 je 10df90 <chroot+0x170>
rtems_filesystem_global_location_t *new_root_loc =
rtems_filesystem_global_location_obtain( &new_current_loc );
10de97: 8d 85 4c ff ff ff lea -0xb4(%ebp),%eax
10de9d: 89 04 24 mov %eax,(%esp)
10dea0: e8 4b 28 00 00 call 1106f0 <rtems_filesystem_global_location_obtain>
)
{
struct stat st;
st.st_mode = 0;
(void) ( *loc->handlers->fstat_h )( loc, &st );
10dea5: 8d 55 a0 lea -0x60(%ebp),%edx
st.st_mode = 0;
10dea8: c7 45 b0 00 00 00 00 movl $0x0,-0x50(%ebp)
10deaf: 89 c3 mov %eax,%ebx
(void) ( *loc->handlers->fstat_h )( loc, &st );
10deb1: 8b 40 10 mov 0x10(%eax),%eax
10deb4: 89 54 24 04 mov %edx,0x4(%esp)
10deb8: 89 1c 24 mov %ebx,(%esp)
10debb: ff 50 18 call *0x18(%eax)
mode_t type = rtems_filesystem_location_type( &new_root_loc->location );
if ( S_ISDIR( type ) ) {
10debe: 8b 45 b0 mov -0x50(%ebp),%eax
10dec1: 25 00 f0 00 00 and $0xf000,%eax
10dec6: 3d 00 40 00 00 cmp $0x4000,%eax
10decb: 75 53 jne 10df20 <chroot+0x100>
sc = rtems_libio_set_private_env();
10decd: e8 8e 15 00 00 call 10f460 <rtems_libio_set_private_env>
if (sc == RTEMS_SUCCESSFUL) {
10ded2: 85 c0 test %eax,%eax
10ded4: 0f 85 96 00 00 00 jne 10df70 <chroot+0x150>
rtems_filesystem_global_location_assign(
&rtems_filesystem_root,
10deda: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
10dee0: e8 9b 2e 00 00 call 110d80 <rtems_current_user_env_get>
rtems_filesystem_global_location_assign(
10dee5: 89 5c 24 04 mov %ebx,0x4(%esp)
10dee9: 83 c0 04 add $0x4,%eax
10deec: 89 04 24 mov %eax,(%esp)
10deef: e8 7c 26 00 00 call 110570 <rtems_filesystem_global_location_assign>
new_root_loc
);
rtems_filesystem_global_location_assign(
10def4: 8b 9d 4c ff ff ff mov -0xb4(%ebp),%ebx
&rtems_filesystem_current,
10defa: e8 81 2e 00 00 call 110d80 <rtems_current_user_env_get>
rtems_filesystem_global_location_assign(
10deff: 89 5c 24 04 mov %ebx,0x4(%esp)
10df03: 89 04 24 mov %eax,(%esp)
10df06: e8 65 26 00 00 call 110570 <rtems_filesystem_global_location_assign>
}
} else {
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
10df0b: 89 34 24 mov %esi,(%esp)
10df0e: e8 9d 21 00 00 call 1100b0 <rtems_filesystem_eval_path_cleanup>
if ( rv != 0 ) {
rtems_filesystem_global_location_release( new_current_loc, false );
}
return rv;
}
10df13: 81 c4 d0 00 00 00 add $0xd0,%esp
int rv = 0;
10df19: 31 c0 xor %eax,%eax
}
10df1b: 5b pop %ebx
10df1c: 5e pop %esi
10df1d: 5d pop %ebp
10df1e: c3 ret
10df1f: 90 nop
if ( !rtems_filesystem_location_is_null( loc ) ) {
10df20: 81 7b 10 60 14 13 00 cmpl $0x131460,0x10(%ebx)
10df27: 74 0b je 10df34 <chroot+0x114> <== NEVER TAKEN
errno = eno;
10df29: e8 e2 8b 01 00 call 126b10 <__errno>
10df2e: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED
rtems_filesystem_global_location_release( new_root_loc, true );
10df34: 89 1c 24 mov %ebx,(%esp)
10df37: ba 01 00 00 00 mov $0x1,%edx
10df3c: 89 54 24 04 mov %edx,0x4(%esp)
10df40: e8 5b 28 00 00 call 1107a0 <rtems_filesystem_global_location_release>
rtems_filesystem_eval_path_cleanup( &ctx );
10df45: 89 34 24 mov %esi,(%esp)
10df48: e8 63 21 00 00 call 1100b0 <rtems_filesystem_eval_path_cleanup>
rtems_filesystem_global_location_release( new_current_loc, false );
10df4d: 31 c0 xor %eax,%eax
10df4f: 89 44 24 04 mov %eax,0x4(%esp)
10df53: 8b 85 4c ff ff ff mov -0xb4(%ebp),%eax
10df59: 89 04 24 mov %eax,(%esp)
10df5c: e8 3f 28 00 00 call 1107a0 <rtems_filesystem_global_location_release>
}
10df61: 81 c4 d0 00 00 00 add $0xd0,%esp
rtems_filesystem_global_location_release( new_current_loc, false );
10df67: b8 ff ff ff ff mov $0xffffffff,%eax
}
10df6c: 5b pop %ebx
10df6d: 5e pop %esi
10df6e: 5d pop %ebp
10df6f: c3 ret
if (sc != RTEMS_UNSATISFIED) {
10df70: 83 f8 0d cmp $0xd,%eax
10df73: 74 bf je 10df34 <chroot+0x114> <== NEVER TAKEN
errno = ENOMEM;
10df75: e8 96 8b 01 00 call 126b10 <__errno>
10df7a: c7 00 0c 00 00 00 movl $0xc,(%eax)
10df80: eb b2 jmp 10df34 <chroot+0x114>
10df82: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10df89: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
rtems_filesystem_eval_path_cleanup( &ctx );
10df90: 89 34 24 mov %esi,(%esp)
10df93: e8 18 21 00 00 call 1100b0 <rtems_filesystem_eval_path_cleanup>
if ( rv != 0 ) {
10df98: eb b3 jmp 10df4d <chroot+0x12d>
10df9a: 90 nop
10df9b: 90 nop
10df9c: 90 nop
10df9d: 90 nop
10df9e: 90 nop
10df9f: 90 nop
0010cb00 <close>:
#include <rtems/libio_.h>
int close(
int fd
)
{
10cb00: 55 push %ebp
10cb01: 89 e5 mov %esp,%ebp
10cb03: 57 push %edi
10cb04: 56 push %esi
10cb05: 53 push %ebx
10cb06: 83 ec 2c sub $0x2c,%esp
10cb09: 8b 7d 08 mov 0x8(%ebp),%edi
rtems_libio_t *iop;
unsigned int flags;
int rc;
if ( (uint32_t) fd >= rtems_libio_number_iops ) {
10cb0c: 3b 3d 9c 47 12 00 cmp 0x12479c,%edi
10cb12: 73 51 jae 10cb65 <close+0x65>
return &rtems_libio_iops[ fd ];
10cb14: 8d 04 bf lea (%edi,%edi,4),%eax
10cb17: 8d 34 47 lea (%edi,%eax,2),%esi
10cb1a: c1 e6 02 shl $0x2,%esi
10cb1d: 8d 86 c0 c5 12 00 lea 0x12c5c0(%esi),%eax
10cb23: 8b 96 c0 c5 12 00 mov 0x12c5c0(%esi),%edx
10cb29: 89 45 e4 mov %eax,-0x1c(%ebp)
return val;
10cb2c: eb 32 jmp 10cb60 <close+0x60>
10cb2e: 66 90 xchg %ax,%ax
if ( ( flags & LIBIO_FLAGS_OPEN ) == 0 ) {
rtems_set_errno_and_return_minus_one( EBADF );
}
/* The expected flags */
flags &= LIBIO_FLAGS_REFERENCE_INC - 1U;
10cb30: 89 d1 mov %edx,%ecx
10cb32: 81 e1 ff 0f 00 00 and $0xfff,%ecx
ISR_Level level;
unsigned int actual;
(void) succ;
(void) fail;
_ISR_Local_disable( level );
10cb38: 9c pushf
10cb39: fa cli
10cb3a: 5b pop %ebx
actual = *obj;
10cb3b: 8b 86 c0 c5 12 00 mov 0x12c5c0(%esi),%eax
success = ( actual == *expected );
if ( success ) {
10cb41: 39 c1 cmp %eax,%ecx
10cb43: 75 0c jne 10cb51 <close+0x51>
desired = flags & ~LIBIO_FLAGS_OPEN;
10cb45: 81 e2 ff 0e 00 00 and $0xeff,%edx
10cb4b: 89 96 c0 c5 12 00 mov %edx,0x12c5c0(%esi)
*obj = desired;
} else {
*expected = actual;
}
_ISR_Local_enable( level );
10cb51: 53 push %ebx
10cb52: 9d popf
desired,
ATOMIC_ORDER_ACQ_REL,
ATOMIC_ORDER_RELAXED
);
if ( success ) {
10cb53: 39 c1 cmp %eax,%ecx
10cb55: 74 29 je 10cb80 <close+0x80>
break;
}
if ( ( flags & ~( LIBIO_FLAGS_REFERENCE_INC - 1U ) ) != 0 ) {
10cb57: a9 00 f0 ff ff test $0xfffff000,%eax
10cb5c: 75 52 jne 10cbb0 <close+0xb0> <== ALWAYS TAKEN
10cb5e: 89 c2 mov %eax,%edx <== NOT EXECUTED
if ( ( flags & LIBIO_FLAGS_OPEN ) == 0 ) {
10cb60: f6 c6 01 test $0x1,%dh
10cb63: 75 cb jne 10cb30 <close+0x30>
rtems_set_errno_and_return_minus_one( EBADF );
10cb65: e8 26 c5 00 00 call 119090 <__errno>
10cb6a: c7 00 09 00 00 00 movl $0x9,(%eax)
rc = (*iop->pathinfo.handlers->close_h)( iop );
rtems_libio_free( iop );
return rc;
}
10cb70: 83 c4 2c add $0x2c,%esp
rtems_set_errno_and_return_minus_one( EBADF );
10cb73: b8 ff ff ff ff mov $0xffffffff,%eax
}
10cb78: 5b pop %ebx
10cb79: 5e pop %esi
10cb7a: 5f pop %edi
10cb7b: 5d pop %ebp
10cb7c: c3 ret
10cb7d: 8d 76 00 lea 0x0(%esi),%esi
rc = (*iop->pathinfo.handlers->close_h)( iop );
10cb80: 8d 04 bf lea (%edi,%edi,4),%eax
10cb83: 8d 04 47 lea (%edi,%eax,2),%eax
10cb86: 8b 7d e4 mov -0x1c(%ebp),%edi
10cb89: 8b 04 85 dc c5 12 00 mov 0x12c5dc(,%eax,4),%eax
10cb90: 89 3c 24 mov %edi,(%esp)
10cb93: ff 50 04 call *0x4(%eax)
rtems_libio_free( iop );
10cb96: 89 3c 24 mov %edi,(%esp)
rc = (*iop->pathinfo.handlers->close_h)( iop );
10cb99: 89 45 e4 mov %eax,-0x1c(%ebp)
rtems_libio_free( iop );
10cb9c: e8 cf 01 00 00 call 10cd70 <rtems_libio_free>
10cba1: 8b 45 e4 mov -0x1c(%ebp),%eax
}
10cba4: 83 c4 2c add $0x2c,%esp
10cba7: 5b pop %ebx
10cba8: 5e pop %esi
10cba9: 5f pop %edi
10cbaa: 5d pop %ebp
10cbab: c3 ret
10cbac: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
rtems_set_errno_and_return_minus_one( EBUSY );
10cbb0: e8 db c4 00 00 call 119090 <__errno>
10cbb5: c7 00 10 00 00 00 movl $0x10,(%eax) <== NOT EXECUTED
}
10cbbb: 83 c4 2c add $0x2c,%esp <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EBUSY );
10cbbe: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
}
10cbc3: 5b pop %ebx <== NOT EXECUTED
10cbc4: 5e pop %esi <== NOT EXECUTED
10cbc5: 5f pop %edi <== NOT EXECUTED
10cbc6: 5d pop %ebp <== NOT EXECUTED
10cbc7: c3 ret <== NOT EXECUTED
10cbc8: 90 nop
10cbc9: 90 nop
10cbca: 90 nop
10cbcb: 90 nop
10cbcc: 90 nop
10cbcd: 90 nop
10cbce: 90 nop
10cbcf: 90 nop
00101dd0 <endgrent>:
void endgrent(void)
{
101dd0: 55 push %ebp
pthread_once(&grp_once, grp_init);
101dd1: ba 80 1c 10 00 mov $0x101c80,%edx
{
101dd6: 89 e5 mov %esp,%ebp
101dd8: 83 ec 18 sub $0x18,%esp
pthread_once(&grp_once, grp_init);
101ddb: 89 54 24 04 mov %edx,0x4(%esp)
101ddf: c7 04 24 ec a3 1a 00 movl $0x1aa3ec,(%esp)
{
101de6: 89 5d fc mov %ebx,-0x4(%ebp)
pthread_once(&grp_once, grp_init);
101de9: e8 42 0e 01 00 call 112c30 <pthread_once>
return pthread_getspecific(grp_key);
101dee: a1 e8 a3 1a 00 mov 0x1aa3e8,%eax
101df3: 89 04 24 mov %eax,(%esp)
101df6: e8 d5 09 01 00 call 1127d0 <pthread_getspecific>
grp_context *ctx = grp_get_context();
if (ctx == NULL)
101dfb: 85 c0 test %eax,%eax
101dfd: 74 2b je 101e2a <endgrent+0x5a>
101dff: 89 c3 mov %eax,%ebx
return;
if (ctx->fp != NULL) {
101e01: 8b 00 mov (%eax),%eax
101e03: 85 c0 test %eax,%eax
101e05: 74 08 je 101e0f <endgrent+0x3f> <== NEVER TAKEN
fclose(ctx->fp);
101e07: 89 04 24 mov %eax,(%esp)
101e0a: e8 c1 75 05 00 call 1593d0 <fclose>
}
free(ctx);
101e0f: 89 1c 24 mov %ebx,(%esp)
101e12: e8 49 f9 ff ff call 101760 <free>
pthread_setspecific(grp_key, NULL);
101e17: 31 c0 xor %eax,%eax
101e19: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
101e1d: a1 e8 a3 1a 00 mov 0x1aa3e8,%eax <== NOT EXECUTED
101e22: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
101e25: e8 e6 09 01 00 call 112810 <pthread_setspecific> <== NOT EXECUTED
}
101e2a: 8b 5d fc mov -0x4(%ebp),%ebx
101e2d: 89 ec mov %ebp,%esp
101e2f: 5d pop %ebp
101e30: c3 ret
101e31: 90 nop
101e32: 90 nop
101e33: 90 nop
101e34: 90 nop
101e35: 90 nop
101e36: 90 nop
101e37: 90 nop
101e38: 90 nop
101e39: 90 nop
101e3a: 90 nop
101e3b: 90 nop
101e3c: 90 nop
101e3d: 90 nop
101e3e: 90 nop
101e3f: 90 nop
00100c50 <endpwent>:
void endpwent(void)
{
if (passwd_fp != NULL)
100c50: a1 48 ae 12 00 mov 0x12ae48,%eax
100c55: 85 c0 test %eax,%eax
100c57: 74 17 je 100c70 <endpwent+0x20> <== NEVER TAKEN
{
100c59: 55 push %ebp
100c5a: 89 e5 mov %esp,%ebp
100c5c: 83 ec 18 sub $0x18,%esp
fclose(passwd_fp);
100c5f: 89 04 24 mov %eax,(%esp)
100c62: e8 29 8e 01 00 call 119a90 <fclose>
}
100c67: 89 ec mov %ebp,%esp
100c69: 5d pop %ebp
100c6a: c3 ret
100c6b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
100c6f: 90 nop
100c70: c3 ret <== NOT EXECUTED
100c71: 90 nop
100c72: 90 nop
100c73: 90 nop
100c74: 90 nop
100c75: 90 nop
100c76: 90 nop
100c77: 90 nop
100c78: 90 nop
100c79: 90 nop
100c7a: 90 nop
100c7b: 90 nop
100c7c: 90 nop
100c7d: 90 nop
100c7e: 90 nop
100c7f: 90 nop
00101470 <fchdir>:
/**
* compatible with SVr4, 4.4BSD and X/OPEN - Change Directory
*/
int fchdir( int fd )
{
101470: 55 push %ebp
101471: 89 e5 mov %esp,%ebp
101473: 57 push %edi
101474: 56 push %esi
101475: 53 push %ebx
101476: 81 ec 9c 00 00 00 sub $0x9c,%esp
int rv = 0;
rtems_libio_t *iop;
struct stat st;
rtems_filesystem_location_info_t loc;
st.st_mode = 0;
10147c: c7 45 a0 00 00 00 00 movl $0x0,-0x60(%ebp)
{
101483: 8b 5d 08 mov 0x8(%ebp),%ebx
st.st_uid = 0;
st.st_gid = 0;
LIBIO_GET_IOP( fd, iop );
101486: 3b 1d b0 2c 12 00 cmp 0x122cb0,%ebx
st.st_uid = 0;
10148c: c7 45 a6 00 00 00 00 movl $0x0,-0x5a(%ebp)
LIBIO_GET_IOP( fd, iop );
101493: 0f 83 27 01 00 00 jae 1015c0 <fchdir+0x150>
101499: 8d 04 9b lea (%ebx,%ebx,4),%eax
10149c: 8d 34 43 lea (%ebx,%eax,2),%esi
10149f: c1 e6 02 shl $0x2,%esi
1014a2: 8d be 80 a7 12 00 lea 0x12a780(%esi),%edi
_ISR_Local_disable( level );
1014a8: 9c pushf
1014a9: fa cli
1014aa: 59 pop %ecx
val = *obj;
1014ab: 8b 86 80 a7 12 00 mov 0x12a780(%esi),%eax
*obj = val + arg;
1014b1: 8d 90 00 10 00 00 lea 0x1000(%eax),%edx
1014b7: 89 96 80 a7 12 00 mov %edx,0x12a780(%esi)
_ISR_Local_enable( level );
1014bd: 51 push %ecx
1014be: 9d popf
1014bf: f6 c4 01 test $0x1,%ah
1014c2: 0f 84 ed 00 00 00 je 1015b5 <fchdir+0x145>
static inline void rtems_filesystem_instance_lock(
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
1014c8: 8b 47 20 mov 0x20(%edi),%eax
(*mt_entry->ops->lock_h)( mt_entry );
1014cb: 8b 48 0c mov 0xc(%eax),%ecx
1014ce: 89 04 24 mov %eax,(%esp)
1014d1: ff 11 call *(%ecx)
rtems_filesystem_instance_lock( &iop->pathinfo );
rv = (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, &st );
1014d3: 8d 86 8c a7 12 00 lea 0x12a78c(%esi),%eax
1014d9: 89 85 74 ff ff ff mov %eax,-0x8c(%ebp)
1014df: 8d 4d 90 lea -0x70(%ebp),%ecx
1014e2: 89 c2 mov %eax,%edx
1014e4: 89 4c 24 04 mov %ecx,0x4(%esp)
1014e8: 8b 47 1c mov 0x1c(%edi),%eax
1014eb: 89 14 24 mov %edx,(%esp)
1014ee: ff 50 18 call *0x18(%eax)
if ( rv == 0 ) {
1014f1: 85 c0 test %eax,%eax
rv = (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, &st );
1014f3: 89 c6 mov %eax,%esi
if ( rv == 0 ) {
1014f5: 74 39 je 101530 <fchdir+0xc0> <== ALWAYS TAKEN
static inline void rtems_filesystem_instance_unlock(
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
1014f7: 8d 04 9b lea (%ebx,%ebx,4),%eax
1014fa: 8d 04 43 lea (%ebx,%eax,2),%eax
1014fd: 8b 04 85 a0 a7 12 00 mov 0x12a7a0(,%eax,4),%eax
(*mt_entry->ops->unlock_h)( mt_entry );
101504: 8b 48 0c mov 0xc(%eax),%ecx
101507: 89 04 24 mov %eax,(%esp)
10150a: ff 51 04 call *0x4(%ecx)
_ISR_Local_disable( level );
10150d: 9c pushf
10150e: fa cli
10150f: 58 pop %eax
*obj = val - arg;
101510: 81 2f 00 10 00 00 subl $0x1000,(%edi)
_ISR_Local_enable( level );
101516: 50 push %eax
101517: 9d popf
}
}
rtems_filesystem_instance_unlock( &iop->pathinfo );
rtems_libio_iop_drop( iop );
if ( rv == 0 ) {
101518: 85 f6 test %esi,%esi
10151a: 74 64 je 101580 <fchdir+0x110>
rv = rtems_filesystem_chdir( &loc );
}
return rv;
}
10151c: 81 c4 9c 00 00 00 add $0x9c,%esp
101522: 89 f0 mov %esi,%eax
101524: 5b pop %ebx
101525: 5e pop %esi
101526: 5f pop %edi
101527: 5d pop %ebp
101528: c3 ret
101529: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
bool access_ok = rtems_filesystem_check_access(
101530: c7 04 24 01 00 00 00 movl $0x1,(%esp)
101537: 0f b7 45 a8 movzwl -0x58(%ebp),%eax
10153b: 89 44 24 0c mov %eax,0xc(%esp)
10153f: 0f b7 45 a6 movzwl -0x5a(%ebp),%eax
101543: 89 44 24 08 mov %eax,0x8(%esp)
101547: 8b 45 a0 mov -0x60(%ebp),%eax
10154a: 89 44 24 04 mov %eax,0x4(%esp)
10154e: e8 5d 21 00 00 call 1036b0 <rtems_filesystem_check_access>
if ( access_ok ) {
101553: 84 c0 test %al,%al
101555: 74 49 je 1015a0 <fchdir+0x130>
rtems_filesystem_location_clone( &loc, &iop->pathinfo );
101557: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax
10155d: 89 44 24 04 mov %eax,0x4(%esp)
101561: 8d 85 78 ff ff ff lea -0x88(%ebp),%eax
101567: 89 04 24 mov %eax,(%esp)
10156a: e8 a1 a5 00 00 call 10bb10 <rtems_filesystem_location_clone>
10156f: eb 86 jmp 1014f7 <fchdir+0x87>
101571: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
101578: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10157f: 90 nop
rv = rtems_filesystem_chdir( &loc );
101580: 8d 85 78 ff ff ff lea -0x88(%ebp),%eax
101586: 89 04 24 mov %eax,(%esp)
101589: e8 f2 a4 00 00 call 10ba80 <rtems_filesystem_chdir>
}
10158e: 81 c4 9c 00 00 00 add $0x9c,%esp
101594: 5b pop %ebx
rv = rtems_filesystem_chdir( &loc );
101595: 89 c6 mov %eax,%esi
}
101597: 89 f0 mov %esi,%eax
101599: 5e pop %esi
10159a: 5f pop %edi
10159b: 5d pop %ebp
10159c: c3 ret
10159d: 8d 76 00 lea 0x0(%esi),%esi
errno = EACCES;
1015a0: e8 eb 99 01 00 call 11af90 <__errno>
rv = -1;
1015a5: be ff ff ff ff mov $0xffffffff,%esi
errno = EACCES;
1015aa: c7 00 0d 00 00 00 movl $0xd,(%eax)
rv = -1;
1015b0: e9 42 ff ff ff jmp 1014f7 <fchdir+0x87>
_ISR_Local_disable( level );
1015b5: 9c pushf
1015b6: fa cli
1015b7: 58 pop %eax
*obj = val - arg;
1015b8: 81 2f 00 10 00 00 subl $0x1000,(%edi)
_ISR_Local_enable( level );
1015be: 50 push %eax
1015bf: 9d popf
LIBIO_GET_IOP( fd, iop );
1015c0: e8 cb 99 01 00 call 11af90 <__errno>
1015c5: be ff ff ff ff mov $0xffffffff,%esi
1015ca: c7 00 09 00 00 00 movl $0x9,(%eax)
1015d0: e9 47 ff ff ff jmp 10151c <fchdir+0xac>
1015d5: 90 nop
1015d6: 90 nop
1015d7: 90 nop
1015d8: 90 nop
1015d9: 90 nop
1015da: 90 nop
1015db: 90 nop
1015dc: 90 nop
1015dd: 90 nop
1015de: 90 nop
1015df: 90 nop
001016b0 <fchmod>:
/**
* POSIX 1003.1b 5.6.4 - Change File Modes
*/
int fchmod( int fd, mode_t mode )
{
1016b0: 55 push %ebp
1016b1: 89 e5 mov %esp,%ebp
1016b3: 56 push %esi
1016b4: 53 push %ebx
1016b5: 83 ec 10 sub $0x10,%esp
1016b8: 8b 45 08 mov 0x8(%ebp),%eax
int rv;
rtems_libio_t *iop;
LIBIO_GET_IOP( fd, iop );
1016bb: 3b 05 b0 2c 12 00 cmp 0x122cb0,%eax
1016c1: 73 78 jae 10173b <fchmod+0x8b> <== NEVER TAKEN
return &rtems_libio_iops[ fd ];
1016c3: 8d 14 80 lea (%eax,%eax,4),%edx
1016c6: 8d 1c 50 lea (%eax,%edx,2),%ebx
1016c9: c1 e3 02 shl $0x2,%ebx
1016cc: 8d b3 80 a7 12 00 lea 0x12a780(%ebx),%esi
_ISR_Local_disable( level );
1016d2: 9c pushf
1016d3: fa cli
1016d4: 5a pop %edx
val = *obj;
1016d5: 8b 83 80 a7 12 00 mov 0x12a780(%ebx),%eax
*obj = val + arg;
1016db: 8d 88 00 10 00 00 lea 0x1000(%eax),%ecx
1016e1: 89 8b 80 a7 12 00 mov %ecx,0x12a780(%ebx)
_ISR_Local_enable( level );
1016e7: 52 push %edx
1016e8: 9d popf
1016e9: f6 c4 01 test $0x1,%ah
1016ec: 74 42 je 101730 <fchmod+0x80> <== NEVER TAKEN
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
1016ee: 8b 46 20 mov 0x20(%esi),%eax
rtems_filesystem_instance_lock( &iop->pathinfo );
rv = rtems_filesystem_chmod( &iop->pathinfo, mode );
1016f1: 81 c3 8c a7 12 00 add $0x12a78c,%ebx
(*mt_entry->ops->lock_h)( mt_entry );
1016f7: 8b 50 0c mov 0xc(%eax),%edx
1016fa: 89 04 24 mov %eax,(%esp)
1016fd: ff 12 call *(%edx)
1016ff: 8b 45 0c mov 0xc(%ebp),%eax
101702: 89 1c 24 mov %ebx,(%esp)
101705: 89 44 24 04 mov %eax,0x4(%esp)
101709: e8 d2 fe ff ff call 1015e0 <rtems_filesystem_chmod>
10170e: 89 c3 mov %eax,%ebx
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
101710: 8b 46 20 mov 0x20(%esi),%eax
(*mt_entry->ops->unlock_h)( mt_entry );
101713: 8b 50 0c mov 0xc(%eax),%edx
101716: 89 04 24 mov %eax,(%esp)
101719: ff 52 04 call *0x4(%edx)
_ISR_Local_disable( level );
10171c: 9c pushf
10171d: fa cli
10171e: 58 pop %eax
*obj = val - arg;
10171f: 81 2e 00 10 00 00 subl $0x1000,(%esi)
_ISR_Local_enable( level );
101725: 50 push %eax
101726: 9d popf
rtems_filesystem_instance_unlock( &iop->pathinfo );
rtems_libio_iop_drop( iop );
return rv;
}
101727: 83 c4 10 add $0x10,%esp
10172a: 89 d8 mov %ebx,%eax
10172c: 5b pop %ebx
10172d: 5e pop %esi
10172e: 5d pop %ebp
10172f: c3 ret
_ISR_Local_disable( level );
101730: 9c pushf
101731: fa cli
101732: 58 pop %eax
*obj = val - arg;
101733: 81 2e 00 10 00 00 subl $0x1000,(%esi)
_ISR_Local_enable( level );
101739: 50 push %eax
10173a: 9d popf
LIBIO_GET_IOP( fd, iop );
10173b: e8 50 98 01 00 call 11af90 <__errno>
101740: bb ff ff ff ff mov $0xffffffff,%ebx
101745: c7 00 09 00 00 00 movl $0x9,(%eax)
10174b: eb da jmp 101727 <fchmod+0x77>
10174d: 90 nop
10174e: 90 nop
10174f: 90 nop
00101900 <fcntl>:
int fcntl(
int fd,
int cmd,
...
)
{
101900: 55 push %ebp
101901: 89 e5 mov %esp,%ebp
101903: 57 push %edi
101904: 56 push %esi
101905: 53 push %ebx
101906: 83 ec 2c sub $0x2c,%esp
101909: 8b 75 08 mov 0x8(%ebp),%esi
LIBIO_GET_IOP( fd, iop );
10190c: 3b 35 b0 2c 12 00 cmp 0x122cb0,%esi
101912: 0f 83 3a 03 00 00 jae 101c52 <fcntl+0x352>
return &rtems_libio_iops[ fd ];
101918: 8d 04 b6 lea (%esi,%esi,4),%eax
10191b: 8d 1c 46 lea (%esi,%eax,2),%ebx
10191e: c1 e3 02 shl $0x2,%ebx
101921: 8d bb 80 a7 12 00 lea 0x12a780(%ebx),%edi
_ISR_Local_disable( level );
101927: 9c pushf
101928: fa cli
101929: 5a pop %edx
val = *obj;
10192a: 8b 83 80 a7 12 00 mov 0x12a780(%ebx),%eax
*obj = val + arg;
101930: 8d 88 00 10 00 00 lea 0x1000(%eax),%ecx
101936: 89 8b 80 a7 12 00 mov %ecx,0x12a780(%ebx)
_ISR_Local_enable( level );
10193c: 52 push %edx
10193d: 9d popf
10193e: f6 c4 01 test $0x1,%ah
101941: 0f 84 00 03 00 00 je 101c47 <fcntl+0x347>
switch ( cmd ) {
101947: 83 7d 0c 14 cmpl $0x14,0xc(%ebp)
10194b: 77 43 ja 101990 <fcntl+0x90> <== NEVER TAKEN
10194d: 8b 45 0c mov 0xc(%ebp),%eax
101950: ff 24 85 c0 30 12 00 jmp *0x1230c0(,%eax,4)
101957: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10195e: 66 90 xchg %ax,%ax
errno = ENOTSUP;
101960: e8 2b 96 01 00 call 11af90 <__errno>
ret = -1;
101965: ba ff ff ff ff mov $0xffffffff,%edx
errno = ENOTSUP;
10196a: c7 00 86 00 00 00 movl $0x86,(%eax)
_ISR_Local_disable( level );
101970: 9c pushf
101971: fa cli
101972: 58 pop %eax
*obj = val - arg;
101973: 81 2f 00 10 00 00 subl $0x1000,(%edi)
_ISR_Local_enable( level );
101979: 50 push %eax
10197a: 9d popf
va_list ap;
va_start( ap, cmd );
ret = vfcntl(fd,cmd,ap);
va_end(ap);
return ret;
}
10197b: 83 c4 2c add $0x2c,%esp
10197e: 89 d0 mov %edx,%eax
101980: 5b pop %ebx
101981: 5e pop %esi
101982: 5f pop %edi
101983: 5d pop %ebp
101984: c3 ret
101985: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10198c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
errno = EINVAL;
101990: e8 fb 95 01 00 call 11af90 <__errno>
ret = -1;
101995: ba ff ff ff ff mov $0xffffffff,%edx
errno = EINVAL;
10199a: c7 00 16 00 00 00 movl $0x16,(%eax)
if (ret >= 0) {
1019a0: eb ce jmp 101970 <fcntl+0x70>
1019a2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1019a9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
val = *obj;
1019b0: 8b 83 80 a7 12 00 mov 0x12a780(%ebx),%eax
oflag = rtems_libio_to_fcntl_flags( rtems_libio_iop_flags( iop ) );
1019b6: 89 04 24 mov %eax,(%esp)
1019b9: e8 82 07 00 00 call 102140 <rtems_libio_to_fcntl_flags>
1019be: 89 45 e4 mov %eax,-0x1c(%ebp)
diop = rtems_libio_allocate();
1019c1: e8 ca 07 00 00 call 102190 <rtems_libio_allocate>
if (diop != NULL) {
1019c6: 89 45 e0 mov %eax,-0x20(%ebp)
1019c9: 85 c0 test %eax,%eax
1019cb: 0f 84 96 02 00 00 je 101c67 <fcntl+0x367> <== NEVER TAKEN
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
1019d1: 8b 47 20 mov 0x20(%edi),%eax
rtems_filesystem_location_clone( &diop->pathinfo, &iop->pathinfo );
1019d4: 81 c3 8c a7 12 00 add $0x12a78c,%ebx
(*mt_entry->ops->lock_h)( mt_entry );
1019da: 8b 50 0c mov 0xc(%eax),%edx
1019dd: 89 04 24 mov %eax,(%esp)
1019e0: ff 12 call *(%edx)
1019e2: 8b 4d e0 mov -0x20(%ebp),%ecx
1019e5: 89 5c 24 04 mov %ebx,0x4(%esp)
1019e9: 8d 41 0c lea 0xc(%ecx),%eax
1019ec: 89 04 24 mov %eax,(%esp)
1019ef: e8 1c a1 00 00 call 10bb10 <rtems_filesystem_location_clone>
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
1019f4: 8b 47 20 mov 0x20(%edi),%eax
(*mt_entry->ops->unlock_h)( mt_entry );
1019f7: 8b 50 0c mov 0xc(%eax),%edx
1019fa: 89 04 24 mov %eax,(%esp)
1019fd: ff 52 04 call *0x4(%edx)
rv = (*diop->pathinfo.handlers->open_h)( diop, NULL, oflag, 0 );
101a00: 8b 4d e0 mov -0x20(%ebp),%ecx
101a03: 31 d2 xor %edx,%edx
101a05: 8b 5d e4 mov -0x1c(%ebp),%ebx
101a08: 89 4d e4 mov %ecx,-0x1c(%ebp)
101a0b: 8b 41 1c mov 0x1c(%ecx),%eax
101a0e: 89 54 24 0c mov %edx,0xc(%esp)
101a12: 31 d2 xor %edx,%edx
101a14: 89 0c 24 mov %ecx,(%esp)
101a17: 89 5c 24 08 mov %ebx,0x8(%esp)
101a1b: 89 54 24 04 mov %edx,0x4(%esp)
101a1f: ff 10 call *(%eax)
if ( rv == 0 ) {
101a21: 8b 4d e4 mov -0x1c(%ebp),%ecx
101a24: 85 c0 test %eax,%eax
101a26: 0f 85 f4 01 00 00 jne 101c20 <fcntl+0x320> <== NEVER TAKEN
LIBIO_FLAGS_OPEN | rtems_libio_fcntl_flags( oflag )
101a2c: 89 1c 24 mov %ebx,(%esp)
101a2f: e8 bc 06 00 00 call 1020f0 <rtems_libio_fcntl_flags>
_ISR_Local_disable( level );
101a34: 9c pushf
101a35: fa cli
101a36: 5a pop %edx
*obj = val | arg;
101a37: 8b 4d e4 mov -0x1c(%ebp),%ecx
101a3a: 8b 19 mov (%ecx),%ebx
101a3c: 09 d8 or %ebx,%eax
101a3e: 0d 00 01 00 00 or $0x100,%eax
101a43: 89 01 mov %eax,(%ecx)
_ISR_Local_enable( level );
101a45: 52 push %edx
101a46: 9d popf
rv = rtems_libio_iop_to_descriptor( diop );
101a47: 81 e9 80 a7 12 00 sub $0x12a780,%ecx
101a4d: c1 f9 02 sar $0x2,%ecx
101a50: 69 d1 a3 8b 2e ba imul $0xba2e8ba3,%ecx,%edx
101a56: e9 85 00 00 00 jmp 101ae0 <fcntl+0x1e0>
101a5b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
101a5f: 90 nop
val = *obj;
101a60: 8b 83 80 a7 12 00 mov 0x12a780(%ebx),%eax
ret = ((rtems_libio_iop_flags(iop) & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0);
101a66: c1 e8 0b shr $0xb,%eax
101a69: 83 e0 01 and $0x1,%eax
101a6c: 89 c2 mov %eax,%edx
int err = (*iop->pathinfo.handlers->fcntl_h)( iop, cmd );
101a6e: 89 3c 24 mov %edi,(%esp)
101a71: 8d 04 b6 lea (%esi,%esi,4),%eax
101a74: 8b 4d 0c mov 0xc(%ebp),%ecx
101a77: 89 55 e4 mov %edx,-0x1c(%ebp)
101a7a: 8d 04 46 lea (%esi,%eax,2),%eax
101a7d: 8b 04 85 9c a7 12 00 mov 0x12a79c(,%eax,4),%eax
101a84: 89 4c 24 04 mov %ecx,0x4(%esp)
101a88: ff 50 28 call *0x28(%eax)
if (err) {
101a8b: 8b 55 e4 mov -0x1c(%ebp),%edx
101a8e: 85 c0 test %eax,%eax
int err = (*iop->pathinfo.handlers->fcntl_h)( iop, cmd );
101a90: 89 c3 mov %eax,%ebx
if (err) {
101a92: 0f 84 d8 fe ff ff je 101970 <fcntl+0x70> <== ALWAYS TAKEN
errno = err;
101a98: e8 f3 94 01 00 call 11af90 <__errno> <== NOT EXECUTED
ret = -1;
101a9d: ba ff ff ff ff mov $0xffffffff,%edx <== NOT EXECUTED
errno = err;
101aa2: 89 18 mov %ebx,(%eax) <== NOT EXECUTED
ret = -1;
101aa4: e9 c7 fe ff ff jmp 101970 <fcntl+0x70> <== NOT EXECUTED
101aa9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
if ( va_arg( ap, int ) )
101ab0: 8b 55 10 mov 0x10(%ebp),%edx
101ab3: 85 d2 test %edx,%edx
101ab5: 0f 84 55 01 00 00 je 101c10 <fcntl+0x310>
_ISR_Local_disable( level );
101abb: 9c pushf
101abc: fa cli
101abd: 58 pop %eax
*obj = val | arg;
101abe: 81 0f 00 08 00 00 orl $0x800,(%edi)
_ISR_Local_enable( level );
101ac4: 50 push %eax
101ac5: 9d popf
int ret = 0;
101ac6: 31 d2 xor %edx,%edx
101ac8: eb a4 jmp 101a6e <fcntl+0x16e>
101aca: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
val = *obj;
101ad0: 8b 83 80 a7 12 00 mov 0x12a780(%ebx),%eax
ret = rtems_libio_to_fcntl_flags( rtems_libio_iop_flags( iop ) );
101ad6: 89 04 24 mov %eax,(%esp)
101ad9: e8 62 06 00 00 call 102140 <rtems_libio_to_fcntl_flags>
101ade: 89 c2 mov %eax,%edx
if (ret >= 0) {
101ae0: 85 d2 test %edx,%edx
101ae2: 0f 88 88 fe ff ff js 101970 <fcntl+0x70> <== NEVER TAKEN
101ae8: eb 84 jmp 101a6e <fcntl+0x16e>
101aea: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
fd2 = va_arg( ap, int );
101af0: 8b 4d 10 mov 0x10(%ebp),%ecx
if ( (uint32_t) fd2 >= rtems_libio_number_iops ) {
101af3: 3b 0d b0 2c 12 00 cmp 0x122cb0,%ecx
101af9: 0f 83 70 01 00 00 jae 101c6f <fcntl+0x36f> <== NEVER TAKEN
return &rtems_libio_iops[ fd ];
101aff: 8d 04 89 lea (%ecx,%ecx,4),%eax
101b02: 8d 04 41 lea (%ecx,%eax,2),%eax
101b05: c1 e0 02 shl $0x2,%eax
101b08: 89 45 e0 mov %eax,-0x20(%ebp)
101b0b: 8d 90 80 a7 12 00 lea 0x12a780(%eax),%edx
101b11: 89 55 e4 mov %edx,-0x1c(%ebp)
if (iop != iop2)
101b14: 39 d7 cmp %edx,%edi
101b16: 0f 84 24 01 00 00 je 101c40 <fcntl+0x340> <== NEVER TAKEN
101b1c: 8b 80 80 a7 12 00 mov 0x12a780(%eax),%eax
if ((rtems_libio_iop_flags( iop2 ) & LIBIO_FLAGS_OPEN) != 0) {
101b22: f6 c4 01 test $0x1,%ah
101b25: 74 18 je 101b3f <fcntl+0x23f> <== NEVER TAKEN
101b27: 89 4d dc mov %ecx,-0x24(%ebp)
rv = (*iop2->pathinfo.handlers->close_h)( iop2 );
101b2a: 8b 4d e4 mov -0x1c(%ebp),%ecx
101b2d: 8b 41 1c mov 0x1c(%ecx),%eax
101b30: 89 0c 24 mov %ecx,(%esp)
101b33: ff 50 04 call *0x4(%eax)
if (rv == 0) {
101b36: 8b 4d dc mov -0x24(%ebp),%ecx
101b39: 85 c0 test %eax,%eax
rv = (*iop2->pathinfo.handlers->close_h)( iop2 );
101b3b: 89 c2 mov %eax,%edx
if (rv == 0) {
101b3d: 75 a1 jne 101ae0 <fcntl+0x1e0> <== NEVER TAKEN
101b3f: 89 4d d8 mov %ecx,-0x28(%ebp)
101b42: 8b 83 80 a7 12 00 mov 0x12a780(%ebx),%eax
oflag = rtems_libio_to_fcntl_flags( rtems_libio_iop_flags( iop ) );
101b48: 89 04 24 mov %eax,(%esp)
101b4b: e8 f0 05 00 00 call 102140 <rtems_libio_to_fcntl_flags>
rtems_libio_iop_flags_set( iop2, rtems_libio_fcntl_flags( oflag ) );
101b50: 89 04 24 mov %eax,(%esp)
101b53: 89 45 dc mov %eax,-0x24(%ebp)
101b56: e8 95 05 00 00 call 1020f0 <rtems_libio_fcntl_flags>
_ISR_Local_disable( level );
101b5b: 9c pushf
101b5c: fa cli
101b5d: 5a pop %edx
*obj = val | arg;
101b5e: 8b 4d e4 mov -0x1c(%ebp),%ecx
101b61: 09 01 or %eax,(%ecx)
_ISR_Local_enable( level );
101b63: 52 push %edx
101b64: 9d popf
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
101b65: 8b 47 20 mov 0x20(%edi),%eax
rtems_filesystem_location_clone( &iop2->pathinfo, &iop->pathinfo );
101b68: 81 c3 8c a7 12 00 add $0x12a78c,%ebx
(*mt_entry->ops->lock_h)( mt_entry );
101b6e: 8b 50 0c mov 0xc(%eax),%edx
101b71: 89 04 24 mov %eax,(%esp)
101b74: ff 12 call *(%edx)
101b76: 8b 55 e0 mov -0x20(%ebp),%edx
101b79: 89 5c 24 04 mov %ebx,0x4(%esp)
101b7d: 81 c2 8c a7 12 00 add $0x12a78c,%edx
101b83: 89 14 24 mov %edx,(%esp)
101b86: e8 85 9f 00 00 call 10bb10 <rtems_filesystem_location_clone>
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
101b8b: 8b 47 20 mov 0x20(%edi),%eax
(*mt_entry->ops->unlock_h)( mt_entry );
101b8e: 8b 50 0c mov 0xc(%eax),%edx
101b91: 89 04 24 mov %eax,(%esp)
101b94: ff 52 04 call *0x4(%edx)
rv = (*iop2->pathinfo.handlers->open_h)( iop2, NULL, oflag, 0 );
101b97: 8b 4d d8 mov -0x28(%ebp),%ecx
101b9a: 31 d2 xor %edx,%edx
101b9c: 89 54 24 0c mov %edx,0xc(%esp)
101ba0: 89 4d e0 mov %ecx,-0x20(%ebp)
101ba3: 8d 04 89 lea (%ecx,%ecx,4),%eax
101ba6: 8d 04 41 lea (%ecx,%eax,2),%eax
101ba9: 8b 4d dc mov -0x24(%ebp),%ecx
101bac: 8b 04 85 9c a7 12 00 mov 0x12a79c(,%eax,4),%eax
101bb3: 89 4c 24 08 mov %ecx,0x8(%esp)
101bb7: 31 c9 xor %ecx,%ecx
101bb9: 89 4c 24 04 mov %ecx,0x4(%esp)
101bbd: 8b 4d e4 mov -0x1c(%ebp),%ecx
101bc0: 89 0c 24 mov %ecx,(%esp)
101bc3: ff 10 call *(%eax)
if ( rv == 0 ) {
101bc5: 8b 4d e0 mov -0x20(%ebp),%ecx
101bc8: 85 c0 test %eax,%eax
rv = (*iop2->pathinfo.handlers->open_h)( iop2, NULL, oflag, 0 );
101bca: 89 c2 mov %eax,%edx
if ( rv == 0 ) {
101bcc: 0f 85 0e ff ff ff jne 101ae0 <fcntl+0x1e0> <== NEVER TAKEN
rv = fd2;
101bd2: 89 ca mov %ecx,%edx
101bd4: e9 07 ff ff ff jmp 101ae0 <fcntl+0x1e0>
101bd9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
flags = rtems_libio_fcntl_flags( va_arg( ap, int ) );
101be0: 8b 45 10 mov 0x10(%ebp),%eax
101be3: 89 04 24 mov %eax,(%esp)
101be6: e8 05 05 00 00 call 1020f0 <rtems_libio_fcntl_flags>
_ISR_Local_disable( level );
101beb: 9c pushf
101bec: fa cli
101bed: 5a pop %edx
*obj = val & arg;
101bee: 81 27 fe fd ff ff andl $0xfffffdfe,(%edi)
_ISR_Local_enable( level );
101bf4: 52 push %edx
101bf5: 9d popf
_ISR_Local_disable( level );
101bf6: 9c pushf
101bf7: fa cli
101bf8: 5a pop %edx
rtems_libio_iop_flags_set( iop, flags & mask );
101bf9: 25 01 02 00 00 and $0x201,%eax
*obj = val | arg;
101bfe: 09 07 or %eax,(%edi)
_ISR_Local_enable( level );
101c00: 52 push %edx
101c01: 9d popf
int ret = 0;
101c02: 31 d2 xor %edx,%edx
101c04: e9 65 fe ff ff jmp 101a6e <fcntl+0x16e>
101c09: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
_ISR_Local_disable( level );
101c10: 9c pushf
101c11: fa cli
101c12: 58 pop %eax
*obj = val & arg;
101c13: 81 27 ff f7 ff ff andl $0xfffff7ff,(%edi)
_ISR_Local_enable( level );
101c19: 50 push %eax
101c1a: 9d popf
if (ret >= 0) {
101c1b: e9 4e fe ff ff jmp 101a6e <fcntl+0x16e>
rtems_libio_free( diop );
101c20: 89 0c 24 mov %ecx,(%esp) <== NOT EXECUTED
101c23: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED
101c26: e8 c5 05 00 00 call 1021f0 <rtems_libio_free> <== NOT EXECUTED
101c2b: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED
101c2e: e9 ad fe ff ff jmp 101ae0 <fcntl+0x1e0> <== NOT EXECUTED
101c33: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
101c3a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
int rv = 0;
101c40: 31 d2 xor %edx,%edx <== NOT EXECUTED
101c42: e9 27 fe ff ff jmp 101a6e <fcntl+0x16e> <== NOT EXECUTED
_ISR_Local_disable( level );
101c47: 9c pushf
101c48: fa cli
101c49: 58 pop %eax
*obj = val - arg;
101c4a: 81 2f 00 10 00 00 subl $0x1000,(%edi)
_ISR_Local_enable( level );
101c50: 50 push %eax
101c51: 9d popf
LIBIO_GET_IOP( fd, iop );
101c52: e8 39 93 01 00 call 11af90 <__errno>
101c57: ba ff ff ff ff mov $0xffffffff,%edx
101c5c: c7 00 09 00 00 00 movl $0x9,(%eax)
101c62: e9 14 fd ff ff jmp 10197b <fcntl+0x7b>
rv = -1;
101c67: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED
101c6a: e9 01 fd ff ff jmp 101970 <fcntl+0x70> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EBADF );
101c6f: e8 1c 93 01 00 call 11af90 <__errno> <== NOT EXECUTED
101c74: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED
101c77: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED
if (ret >= 0) {
101c7d: e9 ee fc ff ff jmp 101970 <fcntl+0x70> <== NOT EXECUTED
101c82: 90 nop
101c83: 90 nop
101c84: 90 nop
101c85: 90 nop
101c86: 90 nop
101c87: 90 nop
101c88: 90 nop
101c89: 90 nop
101c8a: 90 nop
101c8b: 90 nop
101c8c: 90 nop
101c8d: 90 nop
101c8e: 90 nop
101c8f: 90 nop
00106810 <fpathconf>:
*/
long fpathconf(
int fd,
int name
)
{
106810: 55 push %ebp
106811: 89 e5 mov %esp,%ebp
106813: 83 ec 18 sub $0x18,%esp
106816: 89 5d f4 mov %ebx,-0xc(%ebp)
106819: 8b 45 08 mov 0x8(%ebp),%eax
long return_value;
rtems_libio_t *iop;
const rtems_filesystem_limits_and_options_t *the_limits;
LIBIO_GET_IOP( fd, iop );
10681c: 3b 05 54 da 11 00 cmp 0x11da54,%eax
{
106822: 89 75 f8 mov %esi,-0x8(%ebp)
106825: 8b 4d 0c mov 0xc(%ebp),%ecx
106828: 89 7d fc mov %edi,-0x4(%ebp)
LIBIO_GET_IOP( fd, iop );
10682b: 0f 83 47 01 00 00 jae 106978 <fpathconf+0x168>
106831: 8d 14 80 lea (%eax,%eax,4),%edx
106834: 8d 04 50 lea (%eax,%edx,2),%eax
106837: c1 e0 02 shl $0x2,%eax
10683a: 8d 98 a0 45 12 00 lea 0x1245a0(%eax),%ebx
_ISR_Local_disable( level );
106840: 9c pushf
106841: fa cli
106842: 5e pop %esi
val = *obj;
106843: 8b 90 a0 45 12 00 mov 0x1245a0(%eax),%edx
*obj = val + arg;
106849: 8d ba 00 10 00 00 lea 0x1000(%edx),%edi
10684f: 89 b8 a0 45 12 00 mov %edi,0x1245a0(%eax)
_ISR_Local_enable( level );
106855: 56 push %esi
106856: 9d popf
106857: f6 c6 01 test $0x1,%dh
10685a: 0f 84 0d 01 00 00 je 10696d <fpathconf+0x15d> <== NEVER TAKEN
/*
* Now process the information request.
*/
the_limits = iop->pathinfo.mt_entry->pathconf_limits_and_options;
106860: 8b 43 20 mov 0x20(%ebx),%eax
106863: 83 f9 0b cmp $0xb,%ecx
106866: 8b 40 2c mov 0x2c(%eax),%eax
switch ( name ) {
106869: 0f 87 e9 00 00 00 ja 106958 <fpathconf+0x148>
10686f: ff 24 8d ac e6 11 00 jmp *0x11e6ac(,%ecx,4)
106876: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10687d: 8d 76 00 lea 0x0(%esi),%esi
break;
case _PC_ASYNC_IO:
return_value = the_limits->posix_async_io;
break;
case _PC_PRIO_IO:
return_value = the_limits->posix_prio_io;
106880: 8b 40 24 mov 0x24(%eax),%eax
break;
106883: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10688a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
_ISR_Local_disable( level );
106890: 9c pushf
106891: fa cli
106892: 5a pop %edx
*obj = val - arg;
106893: 81 2b 00 10 00 00 subl $0x1000,(%ebx)
_ISR_Local_enable( level );
106899: 52 push %edx
10689a: 9d popf
break;
}
rtems_libio_iop_drop( iop );
return return_value;
}
10689b: 8b 5d f4 mov -0xc(%ebp),%ebx
10689e: 8b 75 f8 mov -0x8(%ebp),%esi
1068a1: 8b 7d fc mov -0x4(%ebp),%edi
1068a4: 89 ec mov %ebp,%esp
1068a6: 5d pop %ebp
1068a7: c3 ret
1068a8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1068af: 90 nop
return_value = the_limits->posix_sync_io;
1068b0: 8b 40 28 mov 0x28(%eax),%eax
break;
1068b3: eb db jmp 106890 <fpathconf+0x80>
1068b5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1068bc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
return_value = the_limits->link_max;
1068c0: 8b 00 mov (%eax),%eax
break;
1068c2: eb cc jmp 106890 <fpathconf+0x80>
1068c4: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1068cb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
1068cf: 90 nop
return_value = the_limits->max_canon;
1068d0: 8b 40 04 mov 0x4(%eax),%eax
break;
1068d3: eb bb jmp 106890 <fpathconf+0x80>
1068d5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1068dc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
return_value = the_limits->max_input;
1068e0: 8b 40 08 mov 0x8(%eax),%eax
break;
1068e3: eb ab jmp 106890 <fpathconf+0x80>
1068e5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1068ec: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
return_value = the_limits->name_max;
1068f0: 8b 40 0c mov 0xc(%eax),%eax
break;
1068f3: eb 9b jmp 106890 <fpathconf+0x80>
1068f5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1068fc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
return_value = the_limits->path_max;
106900: 8b 40 10 mov 0x10(%eax),%eax
break;
106903: eb 8b jmp 106890 <fpathconf+0x80>
106905: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10690c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
return_value = the_limits->pipe_buf;
106910: 8b 40 14 mov 0x14(%eax),%eax
break;
106913: e9 78 ff ff ff jmp 106890 <fpathconf+0x80>
106918: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10691f: 90 nop
return_value = the_limits->posix_chown_restrictions;
106920: 8b 40 1c mov 0x1c(%eax),%eax
break;
106923: e9 68 ff ff ff jmp 106890 <fpathconf+0x80>
106928: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10692f: 90 nop
return_value = the_limits->posix_no_trunc;
106930: 8b 40 20 mov 0x20(%eax),%eax
break;
106933: e9 58 ff ff ff jmp 106890 <fpathconf+0x80>
106938: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10693f: 90 nop
return_value = the_limits->posix_vdisable;
106940: 8b 40 2c mov 0x2c(%eax),%eax
break;
106943: e9 48 ff ff ff jmp 106890 <fpathconf+0x80>
106948: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10694f: 90 nop
return_value = the_limits->posix_async_io;
106950: 8b 40 18 mov 0x18(%eax),%eax
break;
106953: e9 38 ff ff ff jmp 106890 <fpathconf+0x80>
errno = EINVAL;
106958: e8 83 00 01 00 call 1169e0 <__errno>
10695d: c7 00 16 00 00 00 movl $0x16,(%eax)
return_value = -1;
106963: b8 ff ff ff ff mov $0xffffffff,%eax
break;
106968: e9 23 ff ff ff jmp 106890 <fpathconf+0x80>
_ISR_Local_disable( level );
10696d: 9c pushf <== NOT EXECUTED
10696e: fa cli <== NOT EXECUTED
10696f: 58 pop %eax <== NOT EXECUTED
*obj = val - arg;
106970: 81 2b 00 10 00 00 subl $0x1000,(%ebx) <== NOT EXECUTED
_ISR_Local_enable( level );
106976: 50 push %eax <== NOT EXECUTED
106977: 9d popf <== NOT EXECUTED
LIBIO_GET_IOP( fd, iop );
106978: e8 63 00 01 00 call 1169e0 <__errno>
10697d: c7 00 09 00 00 00 movl $0x9,(%eax)
106983: b8 ff ff ff ff mov $0xffffffff,%eax
106988: e9 0e ff ff ff jmp 10689b <fpathconf+0x8b>
10698d: 90 nop
10698e: 90 nop
10698f: 90 nop
00124170 <fstat>:
int fstat(
int fd,
struct stat *sbuf
)
{
124170: 55 push %ebp
124171: 89 e5 mov %esp,%ebp
124173: 57 push %edi
124174: 56 push %esi
124175: 53 push %ebx
124176: 83 ec 2c sub $0x2c,%esp
int rv;
/*
* Check to see if we were passed a valid pointer.
*/
if ( !sbuf )
124179: 8b 45 0c mov 0xc(%ebp),%eax
{
12417c: 8b 5d 08 mov 0x8(%ebp),%ebx
if ( !sbuf )
12417f: 85 c0 test %eax,%eax
124181: 0f 84 5c 01 00 00 je 1242e3 <fstat+0x173> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EFAULT );
/*
* Now process the stat() request.
*/
LIBIO_GET_IOP( fd, iop );
124187: 3b 1d 9c 47 12 00 cmp 0x12479c,%ebx
12418d: 0f 83 3b 01 00 00 jae 1242ce <fstat+0x15e>
124193: 8d 04 9b lea (%ebx,%ebx,4),%eax
124196: 8d 04 43 lea (%ebx,%eax,2),%eax
124199: c1 e0 02 shl $0x2,%eax
12419c: 8d b0 c0 c5 12 00 lea 0x12c5c0(%eax),%esi
1241a2: 89 75 e0 mov %esi,-0x20(%ebp)
_ISR_Local_disable( level );
1241a5: 9c pushf
1241a6: fa cli
1241a7: 59 pop %ecx
val = *obj;
1241a8: 8b 90 c0 c5 12 00 mov 0x12c5c0(%eax),%edx
*obj = val + arg;
1241ae: 8d b2 00 10 00 00 lea 0x1000(%edx),%esi
1241b4: 89 b0 c0 c5 12 00 mov %esi,0x12c5c0(%eax)
_ISR_Local_enable( level );
1241ba: 51 push %ecx
1241bb: 9d popf
1241bc: f6 c6 01 test $0x1,%dh
1241bf: 0f 84 fb 00 00 00 je 1242c0 <fstat+0x150>
/*
* Zero out the stat structure so the various support
* versions of stat don't have to.
*/
memset( sbuf, 0, sizeof(struct stat) );
1241c5: 8b 4d 0c mov 0xc(%ebp),%ecx
1241c8: 31 f6 xor %esi,%esi
1241ca: bf 58 00 00 00 mov $0x58,%edi
1241cf: f6 c1 01 test $0x1,%cl
1241d2: 0f 85 b8 00 00 00 jne 124290 <fstat+0x120> <== NEVER TAKEN
1241d8: f6 c1 02 test $0x2,%cl
1241db: 0f 85 cf 00 00 00 jne 1242b0 <fstat+0x140> <== NEVER TAKEN
1241e1: 89 fa mov %edi,%edx
1241e3: 83 e2 f8 and $0xfffffff8,%edx
1241e6: 89 55 e4 mov %edx,-0x1c(%ebp)
1241e9: 31 d2 xor %edx,%edx
1241eb: 89 34 11 mov %esi,(%ecx,%edx,1)
1241ee: 89 74 11 04 mov %esi,0x4(%ecx,%edx,1)
1241f2: 83 c2 08 add $0x8,%edx
1241f5: 3b 55 e4 cmp -0x1c(%ebp),%edx
1241f8: 72 f1 jb 1241eb <fstat+0x7b>
1241fa: 01 d1 add %edx,%ecx
1241fc: f7 c7 04 00 00 00 test $0x4,%edi
124202: 75 6c jne 124270 <fstat+0x100> <== NEVER TAKEN
124204: f7 c7 02 00 00 00 test $0x2,%edi
12420a: 75 54 jne 124260 <fstat+0xf0> <== NEVER TAKEN
12420c: 83 e7 01 and $0x1,%edi
12420f: 75 3f jne 124250 <fstat+0xe0> <== NEVER TAKEN
rv = (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, sbuf );
124211: 8d 14 9b lea (%ebx,%ebx,4),%edx
124214: 8b 7d 0c mov 0xc(%ebp),%edi
124217: 05 cc c5 12 00 add $0x12c5cc,%eax
12421c: 89 04 24 mov %eax,(%esp)
12421f: 8d 14 53 lea (%ebx,%edx,2),%edx
124222: 8b 14 95 dc c5 12 00 mov 0x12c5dc(,%edx,4),%edx
124229: 89 7c 24 04 mov %edi,0x4(%esp)
12422d: ff 52 18 call *0x18(%edx)
_ISR_Local_disable( level );
124230: 9c pushf
124231: fa cli
124232: 5a pop %edx
*obj = val - arg;
124233: 8b 7d e0 mov -0x20(%ebp),%edi
124236: 81 2f 00 10 00 00 subl $0x1000,(%edi)
_ISR_Local_enable( level );
12423c: 52 push %edx
12423d: 9d popf
rtems_libio_iop_drop( iop );
return rv;
}
12423e: 83 c4 2c add $0x2c,%esp
124241: 5b pop %ebx
124242: 5e pop %esi
124243: 5f pop %edi
124244: 5d pop %ebp
124245: c3 ret
124246: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
12424d: 8d 76 00 lea 0x0(%esi),%esi
memset( sbuf, 0, sizeof(struct stat) );
124250: c6 01 00 movb $0x0,(%ecx) <== NOT EXECUTED
124253: eb bc jmp 124211 <fstat+0xa1> <== NOT EXECUTED
124255: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
12425c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
124260: 66 c7 01 00 00 movw $0x0,(%ecx) <== NOT EXECUTED
124265: 83 c1 02 add $0x2,%ecx <== NOT EXECUTED
124268: 83 e7 01 and $0x1,%edi <== NOT EXECUTED
12426b: 74 a4 je 124211 <fstat+0xa1> <== NOT EXECUTED
12426d: eb e1 jmp 124250 <fstat+0xe0> <== NOT EXECUTED
12426f: 90 nop <== NOT EXECUTED
124270: c7 01 00 00 00 00 movl $0x0,(%ecx) <== NOT EXECUTED
124276: 83 c1 04 add $0x4,%ecx <== NOT EXECUTED
124279: f7 c7 02 00 00 00 test $0x2,%edi <== NOT EXECUTED
12427f: 74 8b je 12420c <fstat+0x9c> <== NOT EXECUTED
124281: eb dd jmp 124260 <fstat+0xf0> <== NOT EXECUTED
124283: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
12428a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
124290: c6 01 00 movb $0x0,(%ecx) <== NOT EXECUTED
124293: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED
124296: 8d 4f 01 lea 0x1(%edi),%ecx <== NOT EXECUTED
124299: bf 57 00 00 00 mov $0x57,%edi <== NOT EXECUTED
12429e: e9 35 ff ff ff jmp 1241d8 <fstat+0x68> <== NOT EXECUTED
1242a3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1242aa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
1242b0: 66 c7 01 00 00 movw $0x0,(%ecx) <== NOT EXECUTED
1242b5: 83 ef 02 sub $0x2,%edi <== NOT EXECUTED
1242b8: 83 c1 02 add $0x2,%ecx <== NOT EXECUTED
1242bb: e9 21 ff ff ff jmp 1241e1 <fstat+0x71> <== NOT EXECUTED
_ISR_Local_disable( level );
1242c0: 9c pushf
1242c1: fa cli
1242c2: 58 pop %eax
*obj = val - arg;
1242c3: 8b 7d e0 mov -0x20(%ebp),%edi
1242c6: 81 2f 00 10 00 00 subl $0x1000,(%edi)
_ISR_Local_enable( level );
1242cc: 50 push %eax
1242cd: 9d popf
LIBIO_GET_IOP( fd, iop );
1242ce: e8 bd 4d ff ff call 119090 <__errno>
1242d3: c7 00 09 00 00 00 movl $0x9,(%eax)
1242d9: b8 ff ff ff ff mov $0xffffffff,%eax
1242de: e9 5b ff ff ff jmp 12423e <fstat+0xce>
rtems_set_errno_and_return_minus_one( EFAULT );
1242e3: e8 a8 4d ff ff call 119090 <__errno> <== NOT EXECUTED
1242e8: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED
1242ee: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
1242f3: e9 46 ff ff ff jmp 12423e <fstat+0xce> <== NOT EXECUTED
1242f8: 90 nop
1242f9: 90 nop
1242fa: 90 nop
1242fb: 90 nop
1242fc: 90 nop
1242fd: 90 nop
1242fe: 90 nop
1242ff: 90 nop
00101ca0 <getgrent>:
return pthread_getspecific(grp_key);
}
struct group *getgrent(void)
{
101ca0: 55 push %ebp
101ca1: 89 e5 mov %esp,%ebp
101ca3: 83 ec 18 sub $0x18,%esp
101ca6: 89 5d fc mov %ebx,-0x4(%ebp)
pthread_once(&grp_once, grp_init);
101ca9: bb 80 1c 10 00 mov $0x101c80,%ebx
101cae: 89 5c 24 04 mov %ebx,0x4(%esp)
101cb2: c7 04 24 ec a3 1a 00 movl $0x1aa3ec,(%esp)
101cb9: e8 72 0f 01 00 call 112c30 <pthread_once>
return pthread_getspecific(grp_key);
101cbe: a1 e8 a3 1a 00 mov 0x1aa3e8,%eax
101cc3: 89 04 24 mov %eax,(%esp)
101cc6: e8 05 0b 01 00 call 1127d0 <pthread_getspecific>
grp_context *ctx = grp_get_context();
if (ctx == NULL)
101ccb: 85 c0 test %eax,%eax
101ccd: 74 41 je 101d10 <getgrent+0x70>
return NULL;
if (ctx->fp == NULL)
101ccf: 8b 10 mov (%eax),%edx
101cd1: 85 d2 test %edx,%edx
101cd3: 74 3b je 101d10 <getgrent+0x70> <== NEVER TAKEN
return NULL;
if (!_libcsupport_scangr(ctx->fp, &ctx->grp, ctx->buf, sizeof(ctx->buf)))
101cd5: 89 14 24 mov %edx,(%esp)
101cd8: 8d 98 04 01 00 00 lea 0x104(%eax),%ebx
101cde: b9 00 01 00 00 mov $0x100,%ecx
101ce3: 89 4c 24 0c mov %ecx,0xc(%esp)
101ce7: 83 c0 04 add $0x4,%eax
101cea: 89 44 24 08 mov %eax,0x8(%esp)
101cee: 89 5c 24 04 mov %ebx,0x4(%esp)
101cf2: e8 59 20 00 00 call 103d50 <_libcsupport_scangr>
101cf7: 85 c0 test %eax,%eax
101cf9: 74 15 je 101d10 <getgrent+0x70>
return NULL;
return &ctx->grp;
}
101cfb: 89 d8 mov %ebx,%eax
101cfd: 8b 5d fc mov -0x4(%ebp),%ebx
101d00: 89 ec mov %ebp,%esp
101d02: 5d pop %ebp
101d03: c3 ret
101d04: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
101d0b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
101d0f: 90 nop
return NULL;
101d10: 31 db xor %ebx,%ebx
}
101d12: 89 d8 mov %ebx,%eax
101d14: 8b 5d fc mov -0x4(%ebp),%ebx
101d17: 89 ec mov %ebp,%esp
101d19: 5d pop %ebp
101d1a: c3 ret
101d1b: 90 nop
101d1c: 90 nop
101d1d: 90 nop
101d1e: 90 nop
101d1f: 90 nop
00101ee0 <getgroups>:
*/
int getgroups(
int gidsetsize,
gid_t grouplist[]
)
{
101ee0: 55 push %ebp
101ee1: 89 e5 mov %esp,%ebp
101ee3: 57 push %edi
101ee4: 56 push %esi
101ee5: 53 push %ebx
101ee6: 81 ec 5c 01 00 00 sub $0x15c,%esp
char buf[256];
gid_t gid;
const char *user;
struct group *grp;
rv = getpwuid_r(getuid(), &pwd, &buf[0], sizeof(buf), &pwd_res);
101eec: e8 df 01 00 00 call 1020d0 <getuid>
101ef1: 8d 95 c8 fe ff ff lea -0x138(%ebp),%edx
101ef7: b9 00 01 00 00 mov $0x100,%ecx
101efc: 89 54 24 10 mov %edx,0x10(%esp)
101f00: 8d 95 e8 fe ff ff lea -0x118(%ebp),%edx
101f06: 89 54 24 08 mov %edx,0x8(%esp)
101f0a: 8d 95 cc fe ff ff lea -0x134(%ebp),%edx
101f10: 89 4c 24 0c mov %ecx,0xc(%esp)
101f14: 89 54 24 04 mov %edx,0x4(%esp)
101f18: 0f b7 c0 movzwl %ax,%eax
101f1b: 89 04 24 mov %eax,(%esp)
101f1e: e8 fd 1d 00 00 call 103d20 <getpwuid_r>
101f23: 89 85 c4 fe ff ff mov %eax,-0x13c(%ebp)
if (rv != 0) {
101f29: 85 c0 test %eax,%eax
101f2b: 74 13 je 101f40 <getgroups+0x60>
if (gidsetsize == 0 || rv <= gidsetsize) {
return rv;
} else {
rtems_set_errno_and_return_minus_one(EINVAL);
}
}
101f2d: 8b 85 c4 fe ff ff mov -0x13c(%ebp),%eax
101f33: 81 c4 5c 01 00 00 add $0x15c,%esp
101f39: 5b pop %ebx
101f3a: 5e pop %esi
101f3b: 5f pop %edi
101f3c: 5d pop %ebp
101f3d: c3 ret
101f3e: 66 90 xchg %ax,%ax
gid = pwd.pw_gid;
101f40: 0f b7 85 d6 fe ff ff movzwl -0x12a(%ebp),%eax
user = pwd.pw_name;
101f47: 8b 9d cc fe ff ff mov -0x134(%ebp),%ebx
gid = pwd.pw_gid;
101f4d: 89 85 c0 fe ff ff mov %eax,-0x140(%ebp)
setgrent();
101f53: e8 c8 fd ff ff call 101d20 <setgrent>
while ((grp = getgrent()) != NULL) {
101f58: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
101f5f: 90 nop
101f60: e8 3b fd ff ff call 101ca0 <getgrent>
101f65: 85 c0 test %eax,%eax
101f67: 74 52 je 101fbb <getgroups+0xdb>
if (grp->gr_gid == gid) {
101f69: 0f b7 70 08 movzwl 0x8(%eax),%esi
101f6d: 3b b5 c0 fe ff ff cmp -0x140(%ebp),%esi
101f73: 74 eb je 101f60 <getgroups+0x80>
char **mem = &grp->gr_mem[0];
101f75: 8b 78 0c mov 0xc(%eax),%edi
while (*mem != NULL) {
101f78: 8b 07 mov (%edi),%eax
101f7a: 85 c0 test %eax,%eax
101f7c: 75 0c jne 101f8a <getgroups+0xaa> <== ALWAYS TAKEN
101f7e: eb e0 jmp 101f60 <getgroups+0x80> <== NOT EXECUTED
101f80: 8b 47 04 mov 0x4(%edi),%eax
++mem;
101f83: 83 c7 04 add $0x4,%edi
while (*mem != NULL) {
101f86: 85 c0 test %eax,%eax
101f88: 74 d6 je 101f60 <getgroups+0x80>
if (strcmp(*mem, user) == 0) {
101f8a: 89 5c 24 04 mov %ebx,0x4(%esp)
101f8e: 89 04 24 mov %eax,(%esp)
101f91: e8 ca 7b 06 00 call 169b60 <strcmp>
101f96: 85 c0 test %eax,%eax
101f98: 75 e6 jne 101f80 <getgroups+0xa0>
if (rv < gidsetsize) {
101f9a: 8b 85 c4 fe ff ff mov -0x13c(%ebp),%eax
101fa0: 3b 45 08 cmp 0x8(%ebp),%eax
101fa3: 7d 07 jge 101fac <getgroups+0xcc>
grouplist[rv] = grp->gr_gid;
101fa5: 8b 55 0c mov 0xc(%ebp),%edx
101fa8: 66 89 34 42 mov %si,(%edx,%eax,2)
++rv;
101fac: ff 85 c4 fe ff ff incl -0x13c(%ebp)
while ((grp = getgrent()) != NULL) {
101fb2: e8 e9 fc ff ff call 101ca0 <getgrent>
101fb7: 85 c0 test %eax,%eax
101fb9: 75 ae jne 101f69 <getgroups+0x89>
endgrent();
101fbb: e8 10 fe ff ff call 101dd0 <endgrent>
if (gidsetsize == 0 || rv <= gidsetsize) {
101fc0: 8b 55 08 mov 0x8(%ebp),%edx
101fc3: 85 d2 test %edx,%edx
101fc5: 0f 84 62 ff ff ff je 101f2d <getgroups+0x4d>
101fcb: 8b 85 c4 fe ff ff mov -0x13c(%ebp),%eax
101fd1: 3b 45 08 cmp 0x8(%ebp),%eax
101fd4: 0f 8e 53 ff ff ff jle 101f2d <getgroups+0x4d>
rtems_set_errno_and_return_minus_one(EINVAL);
101fda: e8 11 72 05 00 call 1591f0 <__errno>
101fdf: c7 00 16 00 00 00 movl $0x16,(%eax)
101fe5: b8 ff ff ff ff mov $0xffffffff,%eax
101fea: 89 85 c4 fe ff ff mov %eax,-0x13c(%ebp)
101ff0: e9 38 ff ff ff jmp 101f2d <getgroups+0x4d>
101ff5: 90 nop
101ff6: 90 nop
101ff7: 90 nop
101ff8: 90 nop
101ff9: 90 nop
101ffa: 90 nop
101ffb: 90 nop
101ffc: 90 nop
101ffd: 90 nop
101ffe: 90 nop
101fff: 90 nop
00100b20 <getlogin>:
* 4.2.4 Get User Name, P1003.1b-1993, p. 87
*
* @note P1003.1c/D10, p. 49 adds getlogin_r().
*/
char *getlogin( void )
{
100b20: 55 push %ebp
100b21: 89 e5 mov %esp,%ebp
100b23: 83 ec 18 sub $0x18,%esp
100b26: 89 5d fc mov %ebx,-0x4(%ebp)
(void) getlogin_r( _POSIX_types_Getlogin_buffer, LOGIN_NAME_MAX );
100b29: e8 b2 1b 00 00 call 1026e0 <rtems_current_user_env_get>
100b2e: 8d 58 14 lea 0x14(%eax),%ebx
return ERANGE;
/* Set the pointer to a default name */
pname = "";
pw = getpwuid(getuid());
100b31: e8 5a 01 00 00 call 100c90 <getuid>
100b36: 0f b7 c0 movzwl %ax,%eax
100b39: 89 04 24 mov %eax,(%esp)
100b3c: e8 ff 00 00 00 call 100c40 <getpwuid>
if ( pw )
100b41: 85 c0 test %eax,%eax
100b43: 74 2b je 100b70 <getlogin+0x50>
pname = pw->pw_name;
100b45: 8b 00 mov (%eax),%eax <== NOT EXECUTED
strncpy( name, pname, LOGIN_NAME_MAX );
100b47: 89 1c 24 mov %ebx,(%esp)
100b4a: ba 09 00 00 00 mov $0x9,%edx
100b4f: 89 54 24 08 mov %edx,0x8(%esp)
100b53: 89 44 24 04 mov %eax,0x4(%esp)
100b57: e8 44 a7 01 00 call 11b2a0 <strncpy>
return _POSIX_types_Getlogin_buffer;
100b5c: e8 7f 1b 00 00 call 1026e0 <rtems_current_user_env_get>
}
100b61: 8b 5d fc mov -0x4(%ebp),%ebx
100b64: 89 ec mov %ebp,%esp
100b66: 5d pop %ebp
return _POSIX_types_Getlogin_buffer;
100b67: 83 c0 14 add $0x14,%eax
}
100b6a: c3 ret
100b6b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
100b6f: 90 nop
pname = "";
100b70: b8 c5 4e 12 00 mov $0x124ec5,%eax
100b75: eb d0 jmp 100b47 <getlogin+0x27>
100b77: 90 nop
100b78: 90 nop
100b79: 90 nop
100b7a: 90 nop
100b7b: 90 nop
100b7c: 90 nop
100b7d: 90 nop
100b7e: 90 nop
100b7f: 90 nop
00100b80 <getlogin_r>:
{
100b80: 55 push %ebp
100b81: 89 e5 mov %esp,%ebp
100b83: 83 ec 18 sub $0x18,%esp
100b86: 89 5d fc mov %ebx,-0x4(%ebp)
100b89: 8b 5d 08 mov 0x8(%ebp),%ebx
if ( !name )
100b8c: 85 db test %ebx,%ebx
100b8e: 74 60 je 100bf0 <getlogin_r+0x70>
if ( namesize < LOGIN_NAME_MAX )
100b90: 83 7d 0c 08 cmpl $0x8,0xc(%ebp)
100b94: 76 3a jbe 100bd0 <getlogin_r+0x50> <== ALWAYS TAKEN
pw = getpwuid(getuid());
100b96: e8 f5 00 00 00 call 100c90 <getuid> <== NOT EXECUTED
100b9b: 0f b7 c0 movzwl %ax,%eax <== NOT EXECUTED
100b9e: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
100ba1: e8 9a 00 00 00 call 100c40 <getpwuid> <== NOT EXECUTED
if ( pw )
100ba6: 85 c0 test %eax,%eax <== NOT EXECUTED
100ba8: 74 36 je 100be0 <getlogin_r+0x60> <== NOT EXECUTED
pname = pw->pw_name;
100baa: 8b 00 mov (%eax),%eax <== NOT EXECUTED
strncpy( name, pname, LOGIN_NAME_MAX );
100bac: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
100baf: ba 09 00 00 00 mov $0x9,%edx <== NOT EXECUTED
100bb4: 89 54 24 08 mov %edx,0x8(%esp) <== NOT EXECUTED
100bb8: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
100bbc: e8 df a6 01 00 call 11b2a0 <strncpy> <== NOT EXECUTED
return 0;
}
100bc1: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
100bc4: 89 ec mov %ebp,%esp <== NOT EXECUTED
100bc6: 5d pop %ebp <== NOT EXECUTED
strncpy( name, pname, LOGIN_NAME_MAX );
100bc7: 31 c0 xor %eax,%eax <== NOT EXECUTED
}
100bc9: c3 ret <== NOT EXECUTED
100bca: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
100bd0: 8b 5d fc mov -0x4(%ebp),%ebx
100bd3: 89 ec mov %ebp,%esp
return ERANGE;
100bd5: b8 22 00 00 00 mov $0x22,%eax
}
100bda: 5d pop %ebp
100bdb: c3 ret
100bdc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
pname = "";
100be0: b8 c5 4e 12 00 mov $0x124ec5,%eax <== NOT EXECUTED
100be5: eb c5 jmp 100bac <getlogin_r+0x2c> <== NOT EXECUTED
100be7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
100bee: 66 90 xchg %ax,%ax <== NOT EXECUTED
}
100bf0: 8b 5d fc mov -0x4(%ebp),%ebx
100bf3: 89 ec mov %ebp,%esp
return EFAULT;
100bf5: b8 0e 00 00 00 mov $0xe,%eax
}
100bfa: 5d pop %ebp
100bfb: c3 ret
100bfc: 90 nop
100bfd: 90 nop
100bfe: 90 nop
100bff: 90 nop
00101cd0 <lstat>:
* POSIX 1003.1b 5.6.2 - Get File Status
*
* Reused from lstat().
*/
int _STAT_NAME( const char *path, struct stat *buf )
{
101cd0: 55 push %ebp
int rv = 0;
rtems_filesystem_eval_path_context_t ctx;
int eval_flags = _STAT_FOLLOW_LINKS;
const rtems_filesystem_location_info_t *currentloc =
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
101cd1: b8 08 00 00 00 mov $0x8,%eax
{
101cd6: 89 e5 mov %esp,%ebp
101cd8: 57 push %edi
memset( buf, 0, sizeof( *buf ) );
101cd9: 31 ff xor %edi,%edi
{
101cdb: 56 push %esi
101cdc: be 58 00 00 00 mov $0x58,%esi
101ce1: 53 push %ebx
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
101ce2: 8d 5d b0 lea -0x50(%ebp),%ebx
{
101ce5: 83 ec 6c sub $0x6c,%esp
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
101ce8: 89 44 24 08 mov %eax,0x8(%esp)
101cec: 8b 45 08 mov 0x8(%ebp),%eax
101cef: 89 1c 24 mov %ebx,(%esp)
101cf2: 89 44 24 04 mov %eax,0x4(%esp)
101cf6: e8 65 12 00 00 call 102f60 <rtems_filesystem_eval_path_start>
memset( buf, 0, sizeof( *buf ) );
101cfb: 8b 55 0c mov 0xc(%ebp),%edx
101cfe: f6 c2 01 test $0x1,%dl
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
101d01: 89 c1 mov %eax,%ecx
memset( buf, 0, sizeof( *buf ) );
101d03: 0f 85 a7 00 00 00 jne 101db0 <lstat+0xe0> <== NEVER TAKEN
101d09: f6 c2 02 test $0x2,%dl
101d0c: 0f 85 be 00 00 00 jne 101dd0 <lstat+0x100> <== NEVER TAKEN
101d12: 89 f0 mov %esi,%eax
101d14: 83 e0 f8 and $0xfffffff8,%eax
101d17: 89 45 a4 mov %eax,-0x5c(%ebp)
101d1a: 31 c0 xor %eax,%eax
101d1c: 89 3c 02 mov %edi,(%edx,%eax,1)
101d1f: 89 7c 02 04 mov %edi,0x4(%edx,%eax,1)
101d23: 83 c0 08 add $0x8,%eax
101d26: 3b 45 a4 cmp -0x5c(%ebp),%eax
101d29: 72 f1 jb 101d1c <lstat+0x4c>
101d2b: 01 c2 add %eax,%edx
101d2d: f7 c6 04 00 00 00 test $0x4,%esi
101d33: 75 5b jne 101d90 <lstat+0xc0> <== NEVER TAKEN
101d35: f7 c6 02 00 00 00 test $0x2,%esi
101d3b: 75 43 jne 101d80 <lstat+0xb0> <== NEVER TAKEN
101d3d: 83 e6 01 and $0x1,%esi
101d40: 75 2e jne 101d70 <lstat+0xa0> <== NEVER TAKEN
rv = (*currentloc->handlers->fstat_h)( currentloc, buf );
101d42: 8b 7d 0c mov 0xc(%ebp),%edi
101d45: 8b 41 10 mov 0x10(%ecx),%eax
101d48: 89 0c 24 mov %ecx,(%esp)
101d4b: 89 7c 24 04 mov %edi,0x4(%esp)
101d4f: ff 50 18 call *0x18(%eax)
rtems_filesystem_eval_path_cleanup( &ctx );
101d52: 89 1c 24 mov %ebx,(%esp)
rv = (*currentloc->handlers->fstat_h)( currentloc, buf );
101d55: 89 45 a4 mov %eax,-0x5c(%ebp)
rtems_filesystem_eval_path_cleanup( &ctx );
101d58: e8 b3 13 00 00 call 103110 <rtems_filesystem_eval_path_cleanup>
return rv;
}
101d5d: 8b 45 a4 mov -0x5c(%ebp),%eax
101d60: 83 c4 6c add $0x6c,%esp
101d63: 5b pop %ebx
101d64: 5e pop %esi
101d65: 5f pop %edi
101d66: 5d pop %ebp
101d67: c3 ret
101d68: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
101d6f: 90 nop
memset( buf, 0, sizeof( *buf ) );
101d70: c6 02 00 movb $0x0,(%edx) <== NOT EXECUTED
101d73: eb cd jmp 101d42 <lstat+0x72> <== NOT EXECUTED
101d75: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
101d7c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
101d80: 66 c7 02 00 00 movw $0x0,(%edx) <== NOT EXECUTED
101d85: 83 c2 02 add $0x2,%edx <== NOT EXECUTED
101d88: 83 e6 01 and $0x1,%esi <== NOT EXECUTED
101d8b: 74 b5 je 101d42 <lstat+0x72> <== NOT EXECUTED
101d8d: eb e1 jmp 101d70 <lstat+0xa0> <== NOT EXECUTED
101d8f: 90 nop <== NOT EXECUTED
101d90: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED
101d96: 83 c2 04 add $0x4,%edx <== NOT EXECUTED
101d99: f7 c6 02 00 00 00 test $0x2,%esi <== NOT EXECUTED
101d9f: 74 9c je 101d3d <lstat+0x6d> <== NOT EXECUTED
101da1: eb dd jmp 101d80 <lstat+0xb0> <== NOT EXECUTED
101da3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
101daa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
101db0: c6 02 00 movb $0x0,(%edx) <== NOT EXECUTED
101db3: be 57 00 00 00 mov $0x57,%esi <== NOT EXECUTED
101db8: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
101dbb: 8d 50 01 lea 0x1(%eax),%edx <== NOT EXECUTED
101dbe: f6 c2 02 test $0x2,%dl <== NOT EXECUTED
101dc1: 0f 84 4b ff ff ff je 101d12 <lstat+0x42> <== NOT EXECUTED
101dc7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
101dce: 66 90 xchg %ax,%ax <== NOT EXECUTED
101dd0: 66 c7 02 00 00 movw $0x0,(%edx) <== NOT EXECUTED
101dd5: 83 ee 02 sub $0x2,%esi <== NOT EXECUTED
101dd8: 83 c2 02 add $0x2,%edx <== NOT EXECUTED
101ddb: e9 32 ff ff ff jmp 101d12 <lstat+0x42> <== NOT EXECUTED
00101320 <mount>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
101320: 55 push %ebp
101321: 89 e5 mov %esp,%ebp
101323: 57 push %edi
101324: 56 push %esi
101325: 53 push %ebx
101326: 81 ec 8c 00 00 00 sub $0x8c,%esp
int rv = 0;
if (
10132c: 83 7d 14 01 cmpl $0x1,0x14(%ebp)
{
101330: 8b 75 10 mov 0x10(%ebp),%esi
if (
101333: 0f 87 77 04 00 00 ja 1017b0 <mount+0x490>
options == RTEMS_FILESYSTEM_READ_ONLY
|| options == RTEMS_FILESYSTEM_READ_WRITE
) {
rtems_filesystem_fsmount_me_t fsmount_me_h =
rtems_filesystem_get_mount_handler( filesystemtype );
101339: 89 34 24 mov %esi,(%esp)
10133c: e8 cf 04 00 00 call 101810 <rtems_filesystem_get_mount_handler>
101341: 89 45 8c mov %eax,-0x74(%ebp)
if ( fsmount_me_h != NULL ) {
101344: 85 c0 test %eax,%eax
101346: 0f 84 64 04 00 00 je 1017b0 <mount+0x490>
const char *target = target_or_null != NULL ? target_or_null : "/";
10134c: 8b 45 0c mov 0xc(%ebp),%eax
10134f: 85 c0 test %eax,%eax
101351: 0f 84 c9 02 00 00 je 101620 <mount+0x300>
size_t target_size = strlen( target ) + 1;
101357: 8b 45 0c mov 0xc(%ebp),%eax
10135a: 89 04 24 mov %eax,(%esp)
10135d: e8 de 87 01 00 call 119b40 <strlen>
101362: 40 inc %eax
101363: 89 45 94 mov %eax,-0x6c(%ebp)
101366: 8b 45 0c mov 0xc(%ebp),%eax
101369: 89 45 88 mov %eax,-0x78(%ebp)
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
10136c: 89 34 24 mov %esi,(%esp)
10136f: e8 cc 87 01 00 call 119b40 <strlen>
101374: 89 85 7c ff ff ff mov %eax,-0x84(%ebp)
10137a: 8d 50 01 lea 0x1(%eax),%edx
10137d: 89 55 90 mov %edx,-0x70(%ebp)
size_t source_size = source_or_null != NULL ?
101380: 8d 58 65 lea 0x65(%eax),%ebx
strlen( source_or_null ) + 1 : 0;
101383: 8b 45 08 mov 0x8(%ebp),%eax
101386: 85 c0 test %eax,%eax
101388: 0f 84 42 02 00 00 je 1015d0 <mount+0x2b0>
10138e: 8b 45 08 mov 0x8(%ebp),%eax
101391: 89 04 24 mov %eax,(%esp)
101394: e8 a7 87 01 00 call 119b40 <strlen>
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
101399: 8b 7d 94 mov -0x6c(%ebp),%edi
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
10139c: c7 04 24 01 00 00 00 movl $0x1,(%esp)
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
1013a3: 01 fb add %edi,%ebx
strlen( source_or_null ) + 1 : 0;
1013a5: 8d 48 01 lea 0x1(%eax),%ecx
1013a8: 89 4d 80 mov %ecx,-0x80(%ebp)
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
1013ab: 8d 44 03 01 lea 0x1(%ebx,%eax,1),%eax
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
1013af: 89 44 24 04 mov %eax,0x4(%esp)
1013b3: e8 c8 82 00 00 call 109680 <calloc>
if ( mt_entry != NULL ) {
1013b8: 85 c0 test %eax,%eax
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
1013ba: 89 c3 mov %eax,%ebx
if ( mt_entry != NULL ) {
1013bc: 0f 84 de 02 00 00 je 1016a0 <mount+0x380> <== NEVER TAKEN
memcpy( str, filesystemtype, filesystemtype_size );
1013c2: 8b 55 90 mov -0x70(%ebp),%edx
rtems_filesystem_global_location_t *mt_fs_root =
1013c5: 8d 40 40 lea 0x40(%eax),%eax
1013c8: 89 45 84 mov %eax,-0x7c(%ebp)
char *str = (char *) mt_fs_root + sizeof( *mt_fs_root );
1013cb: 8d 43 64 lea 0x64(%ebx),%eax
memcpy( str, filesystemtype, filesystemtype_size );
1013ce: 89 c7 mov %eax,%edi
1013d0: 83 fa 08 cmp $0x8,%edx
1013d3: 89 d1 mov %edx,%ecx
1013d5: 0f 83 95 01 00 00 jae 101570 <mount+0x250> <== NEVER TAKEN
1013db: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
mt_entry->type = str;
1013dd: 89 43 34 mov %eax,0x34(%ebx)
str += filesystemtype_size;
1013e0: 8b 75 90 mov -0x70(%ebp),%esi
memcpy( str, source_or_null, source_size );
1013e3: 8b 55 80 mov -0x80(%ebp),%edx
str += filesystemtype_size;
1013e6: 01 f0 add %esi,%eax
memcpy( str, source_or_null, source_size );
1013e8: 8b 75 08 mov 0x8(%ebp),%esi
1013eb: 83 fa 08 cmp $0x8,%edx
1013ee: 89 d1 mov %edx,%ecx
1013f0: 89 c7 mov %eax,%edi
1013f2: 0f 83 38 01 00 00 jae 101530 <mount+0x210>
1013f8: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
mt_entry->dev = str;
1013fa: 89 43 38 mov %eax,0x38(%ebx)
str += source_size;
1013fd: 8b 4d 80 mov -0x80(%ebp),%ecx
101400: 01 c8 add %ecx,%eax
memcpy( str, target, target_size );
101402: 8b 4d 94 mov -0x6c(%ebp),%ecx
101405: 89 c7 mov %eax,%edi
101407: 8b 75 88 mov -0x78(%ebp),%esi
10140a: 83 f9 08 cmp $0x8,%ecx
10140d: 0f 83 7d 01 00 00 jae 101590 <mount+0x270>
101413: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
void *starting_address,
size_t number_nodes,
size_t node_size
)
{
_Chain_Initialize(
101415: ba 24 00 00 00 mov $0x24,%edx
10141a: b9 01 00 00 00 mov $0x1,%ecx
mt_entry->target = str;
10141f: 89 43 30 mov %eax,0x30(%ebx)
mt_entry->mounted = true;
101422: c6 43 28 01 movb $0x1,0x28(%ebx)
mt_entry->pathconf_limits_and_options = &rtems_filesystem_default_pathconf;
101426: c7 43 2c e0 4f 12 00 movl $0x124fe0,0x2c(%ebx)
mt_fs_root->location.mt_entry = mt_entry;
10142d: 89 5b 54 mov %ebx,0x54(%ebx)
mt_fs_root->reference_count = 1;
101430: c7 43 58 01 00 00 00 movl $0x1,0x58(%ebx)
mt_entry->mt_fs_root = mt_fs_root;
101437: 8b 45 84 mov -0x7c(%ebp),%eax
10143a: 89 43 24 mov %eax,0x24(%ebx)
10143d: 89 44 24 04 mov %eax,0x4(%esp)
rtems_chain_initialize(
101441: 8d 43 14 lea 0x14(%ebx),%eax
101444: 89 54 24 0c mov %edx,0xc(%esp)
101448: 89 4c 24 08 mov %ecx,0x8(%esp)
10144c: 89 04 24 mov %eax,(%esp)
10144f: e8 cc 37 00 00 call 104c20 <_Chain_Initialize>
filesystemtype,
&target_length
);
if ( mt_entry != NULL ) {
mt_entry->writeable = options == RTEMS_FILESYSTEM_READ_WRITE;
101454: 0f b6 45 14 movzbl 0x14(%ebp),%eax
101458: 88 43 29 mov %al,0x29(%ebx)
rv = (*fsmount_me_h)( mt_entry, data );
10145b: 8b 45 18 mov 0x18(%ebp),%eax
mt_entry->writeable = options == RTEMS_FILESYSTEM_READ_WRITE;
10145e: 80 63 29 01 andb $0x1,0x29(%ebx)
rv = (*fsmount_me_h)( mt_entry, data );
101462: 89 1c 24 mov %ebx,(%esp)
101465: 89 44 24 04 mov %eax,0x4(%esp)
101469: 8b 45 8c mov -0x74(%ebp),%eax
10146c: ff d0 call *%eax
if ( rv == 0 ) {
10146e: 85 c0 test %eax,%eax
rv = (*fsmount_me_h)( mt_entry, data );
101470: 89 c6 mov %eax,%esi
if ( rv == 0 ) {
101472: 0f 85 9e 00 00 00 jne 101516 <mount+0x1f6>
if ( target != NULL ) {
101478: 8b 45 0c mov 0xc(%ebp),%eax
10147b: 85 c0 test %eax,%eax
10147d: 0f 84 3d 02 00 00 je 1016c0 <mount+0x3a0>
rtems_filesystem_eval_path_start( &ctx, target, eval_flags );
101483: 8d 7d b0 lea -0x50(%ebp),%edi
101486: b8 1f 00 00 00 mov $0x1f,%eax
10148b: 89 44 24 08 mov %eax,0x8(%esp)
10148f: 8b 45 0c mov 0xc(%ebp),%eax
101492: 89 3c 24 mov %edi,(%esp)
101495: 89 44 24 04 mov %eax,0x4(%esp)
101499: e8 a2 0a 00 00 call 101f40 <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;
10149e: 8b 50 14 mov 0x14(%eax),%edx
return (*mt_entry->ops->are_nodes_equal_h)(
1014a1: 8b 4a 0c mov 0xc(%edx),%ecx
1014a4: 8b 52 24 mov 0x24(%edx),%edx
1014a7: 89 04 24 mov %eax,(%esp)
1014aa: 89 54 24 04 mov %edx,0x4(%esp)
1014ae: ff 51 10 call *0x10(%ecx)
if ( !rtems_filesystem_location_is_instance_root( currentloc ) ) {
1014b1: 84 c0 test %al,%al
1014b3: 0f 85 0c 03 00 00 jne 1017c5 <mount+0x4a5>
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(
1014b9: 8d 45 c8 lea -0x38(%ebp),%eax
1014bc: 89 44 24 04 mov %eax,0x4(%esp)
1014c0: 8d 75 98 lea -0x68(%ebp),%esi
1014c3: 89 34 24 mov %esi,(%esp)
1014c6: e8 d5 10 00 00 call 1025a0 <rtems_filesystem_location_copy_and_detach>
mt_point_node = rtems_filesystem_location_transform_to_global( &targetloc );
1014cb: 89 34 24 mov %esi,(%esp)
1014ce: e8 5d 11 00 00 call 102630 <rtems_filesystem_location_transform_to_global>
mt_entry->mt_point_node = mt_point_node;
1014d3: 89 43 20 mov %eax,0x20(%ebx)
mt_point_node = rtems_filesystem_location_transform_to_global( &targetloc );
1014d6: 89 c2 mov %eax,%edx
rv = (*mt_point_node->location.mt_entry->ops->mount_h)( mt_entry );
1014d8: 8b 40 14 mov 0x14(%eax),%eax
1014db: 89 55 94 mov %edx,-0x6c(%ebp)
1014de: 8b 40 0c mov 0xc(%eax),%eax
1014e1: 89 1c 24 mov %ebx,(%esp)
1014e4: ff 50 2c call *0x2c(%eax)
if ( rv == 0 ) {
1014e7: 8b 55 94 mov -0x6c(%ebp),%edx
1014ea: 85 c0 test %eax,%eax
rv = (*mt_point_node->location.mt_entry->ops->mount_h)( mt_entry );
1014ec: 89 c6 mov %eax,%esi
if ( rv == 0 ) {
1014ee: 0f 84 4c 01 00 00 je 101640 <mount+0x320>
rtems_filesystem_global_location_release( mt_point_node, true );
1014f4: 89 14 24 mov %edx,(%esp) <== NOT EXECUTED
1014f7: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
1014fc: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
101500: e8 cb 0f 00 00 call 1024d0 <rtems_filesystem_global_location_release><== NOT EXECUTED
rtems_filesystem_eval_path_cleanup( &ctx );
101505: 89 3c 24 mov %edi,(%esp)
101508: e8 03 0b 00 00 call 102010 <rtems_filesystem_eval_path_cleanup>
} else {
rv = register_root_file_system( mt_entry );
}
if ( rv != 0 ) {
(*mt_entry->ops->fsunmount_me_h)( mt_entry );
10150d: 8b 43 0c mov 0xc(%ebx),%eax
101510: 89 1c 24 mov %ebx,(%esp)
101513: ff 50 34 call *0x34(%eax)
}
}
if ( rv != 0 ) {
free( mt_entry );
101516: 89 1c 24 mov %ebx,(%esp)
101519: e8 92 82 00 00 call 1097b0 <free>
errno = EINVAL;
rv = -1;
}
return rv;
}
10151e: 81 c4 8c 00 00 00 add $0x8c,%esp
101524: 89 f0 mov %esi,%eax
101526: 5b pop %ebx
101527: 5e pop %esi
101528: 5f pop %edi
101529: 5d pop %ebp
10152a: c3 ret
10152b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10152f: 90 nop
memcpy( str, source_or_null, source_size );
101530: a8 01 test $0x1,%al
101532: 0f 85 28 02 00 00 jne 101760 <mount+0x440> <== NEVER TAKEN
101538: f7 c7 02 00 00 00 test $0x2,%edi
10153e: 0f 85 fc 01 00 00 jne 101740 <mount+0x420>
101544: f7 c7 04 00 00 00 test $0x4,%edi
10154a: 0f 84 a8 fe ff ff je 1013f8 <mount+0xd8>
101550: 8b 16 mov (%esi),%edx
101552: 83 c7 04 add $0x4,%edi
101555: 83 c6 04 add $0x4,%esi
101558: 83 e9 04 sub $0x4,%ecx
10155b: 89 57 fc mov %edx,-0x4(%edi)
10155e: e9 95 fe ff ff jmp 1013f8 <mount+0xd8>
101563: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10156a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
memcpy( str, filesystemtype, filesystemtype_size );
101570: a8 04 test $0x4,%al <== NOT EXECUTED
101572: 0f 84 63 fe ff ff je 1013db <mount+0xbb> <== NOT EXECUTED
101578: 8b 0e mov (%esi),%ecx <== NOT EXECUTED
10157a: 8d 7b 68 lea 0x68(%ebx),%edi <== NOT EXECUTED
10157d: 83 c6 04 add $0x4,%esi <== NOT EXECUTED
101580: 89 08 mov %ecx,(%eax) <== NOT EXECUTED
101582: 8b 8d 7c ff ff ff mov -0x84(%ebp),%ecx <== NOT EXECUTED
101588: 83 e9 03 sub $0x3,%ecx <== NOT EXECUTED
10158b: e9 4b fe ff ff jmp 1013db <mount+0xbb> <== NOT EXECUTED
memcpy( str, target, target_size );
101590: a8 01 test $0x1,%al
101592: 0f 85 e8 01 00 00 jne 101780 <mount+0x460> <== NEVER TAKEN
101598: f7 c7 02 00 00 00 test $0x2,%edi
10159e: 0f 85 ec 01 00 00 jne 101790 <mount+0x470> <== ALWAYS TAKEN
1015a4: f7 c7 04 00 00 00 test $0x4,%edi
1015aa: 0f 84 63 fe ff ff je 101413 <mount+0xf3>
1015b0: 8b 16 mov (%esi),%edx
1015b2: 83 c7 04 add $0x4,%edi
1015b5: 83 c6 04 add $0x4,%esi
1015b8: 83 e9 04 sub $0x4,%ecx
1015bb: 89 57 fc mov %edx,-0x4(%edi)
1015be: e9 50 fe ff ff jmp 101413 <mount+0xf3>
1015c3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1015ca: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
1015d0: c7 04 24 01 00 00 00 movl $0x1,(%esp)
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
1015d7: 8b 45 94 mov -0x6c(%ebp),%eax
1015da: 01 d8 add %ebx,%eax
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
1015dc: 89 44 24 04 mov %eax,0x4(%esp)
1015e0: e8 9b 80 00 00 call 109680 <calloc>
if ( mt_entry != NULL ) {
1015e5: 85 c0 test %eax,%eax
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
1015e7: 89 c3 mov %eax,%ebx
if ( mt_entry != NULL ) {
1015e9: 0f 84 b1 00 00 00 je 1016a0 <mount+0x380> <== NEVER TAKEN
memcpy( str, filesystemtype, filesystemtype_size );
1015ef: 8b 55 90 mov -0x70(%ebp),%edx
rtems_filesystem_global_location_t *mt_fs_root =
1015f2: 8d 43 40 lea 0x40(%ebx),%eax
1015f5: 89 45 84 mov %eax,-0x7c(%ebp)
char *str = (char *) mt_fs_root + sizeof( *mt_fs_root );
1015f8: 8d 43 64 lea 0x64(%ebx),%eax
memcpy( str, filesystemtype, filesystemtype_size );
1015fb: 89 c7 mov %eax,%edi
1015fd: 83 fa 08 cmp $0x8,%edx
101600: 89 d1 mov %edx,%ecx
101602: 73 7c jae 101680 <mount+0x360> <== NEVER TAKEN
101604: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
mt_entry->type = str;
101606: 89 43 34 mov %eax,0x34(%ebx)
str += filesystemtype_size;
101609: 8b 55 90 mov -0x70(%ebp),%edx
10160c: 01 d0 add %edx,%eax
if ( source_or_null != NULL ) {
10160e: e9 ef fd ff ff jmp 101402 <mount+0xe2>
101613: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10161a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
101620: c7 45 94 02 00 00 00 movl $0x2,-0x6c(%ebp)
const char *target = target_or_null != NULL ? target_or_null : "/";
101627: c7 45 88 a0 47 12 00 movl $0x1247a0,-0x78(%ebp)
10162e: e9 39 fd ff ff jmp 10136c <mount+0x4c>
101633: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10163a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
rtems_libio_lock();
101640: e8 1b 83 00 00 call 109960 <rtems_libio_lock>
Chain_Node *old_last;
_Assert( _Chain_Is_node_off_chain( the_node ) );
tail = _Chain_Tail( the_chain );
old_last = tail->previous;
101645: a1 04 a2 12 00 mov 0x12a204,%eax
the_node->next = tail;
10164a: c7 03 00 a2 12 00 movl $0x12a200,(%ebx)
tail->previous = the_node;
101650: 89 1d 04 a2 12 00 mov %ebx,0x12a204
old_last->next = the_node;
101656: 89 18 mov %ebx,(%eax)
the_node->previous = old_last;
101658: 89 43 04 mov %eax,0x4(%ebx)
rtems_libio_unlock();
10165b: e8 20 83 00 00 call 109980 <rtems_libio_unlock>
rtems_filesystem_eval_path_cleanup( &ctx );
101660: 89 3c 24 mov %edi,(%esp)
101663: e8 a8 09 00 00 call 102010 <rtems_filesystem_eval_path_cleanup>
}
101668: 81 c4 8c 00 00 00 add $0x8c,%esp
10166e: 89 f0 mov %esi,%eax
101670: 5b pop %ebx
101671: 5e pop %esi
101672: 5f pop %edi
101673: 5d pop %ebp
101674: c3 ret
101675: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10167c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
memcpy( str, filesystemtype, filesystemtype_size );
101680: a8 04 test $0x4,%al <== NOT EXECUTED
101682: 74 80 je 101604 <mount+0x2e4> <== NOT EXECUTED
101684: 8b 0e mov (%esi),%ecx <== NOT EXECUTED
101686: 8d 7b 68 lea 0x68(%ebx),%edi <== NOT EXECUTED
101689: 83 c6 04 add $0x4,%esi <== NOT EXECUTED
10168c: 89 08 mov %ecx,(%eax) <== NOT EXECUTED
10168e: 8b 8d 7c ff ff ff mov -0x84(%ebp),%ecx <== NOT EXECUTED
101694: 83 e9 03 sub $0x3,%ecx <== NOT EXECUTED
101697: e9 68 ff ff ff jmp 101604 <mount+0x2e4> <== NOT EXECUTED
10169c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
errno = ENOMEM;
1016a0: e8 eb 79 01 00 call 119090 <__errno> <== NOT EXECUTED
rv = -1;
1016a5: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED
errno = ENOMEM;
1016aa: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED
}
1016b0: 81 c4 8c 00 00 00 add $0x8c,%esp <== NOT EXECUTED
1016b6: 89 f0 mov %esi,%eax <== NOT EXECUTED
1016b8: 5b pop %ebx <== NOT EXECUTED
1016b9: 5e pop %esi <== NOT EXECUTED
1016ba: 5f pop %edi <== NOT EXECUTED
1016bb: 5d pop %ebp <== NOT EXECUTED
1016bc: c3 ret <== NOT EXECUTED
1016bd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
rtems_libio_lock();
1016c0: e8 9b 82 00 00 call 109960 <rtems_libio_lock>
if ( rtems_chain_is_empty( &rtems_filesystem_mount_table ) ) {
1016c5: 81 3d fc a1 12 00 00 cmpl $0x12a200,0x12a1fc
1016cc: a2 12 00
1016cf: 0f 85 13 01 00 00 jne 1017e8 <mount+0x4c8> <== NEVER TAKEN
the_node->next = tail;
1016d5: c7 03 00 a2 12 00 movl $0x12a200,(%ebx)
old_last = tail->previous;
1016db: a1 04 a2 12 00 mov 0x12a204,%eax
tail->previous = the_node;
1016e0: 89 1d 04 a2 12 00 mov %ebx,0x12a204
old_last->next = the_node;
1016e6: 89 18 mov %ebx,(%eax)
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
1016e8: 83 c3 24 add $0x24,%ebx
the_node->previous = old_last;
1016eb: 89 43 e0 mov %eax,-0x20(%ebx)
rtems_libio_unlock();
1016ee: e8 8d 82 00 00 call 109980 <rtems_libio_unlock>
1016f3: 89 1c 24 mov %ebx,(%esp)
1016f6: e8 25 0d 00 00 call 102420 <rtems_filesystem_global_location_obtain>
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
1016fb: 89 1c 24 mov %ebx,(%esp)
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
1016fe: 89 c7 mov %eax,%edi
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
101700: e8 1b 0d 00 00 call 102420 <rtems_filesystem_global_location_obtain>
101705: 89 c3 mov %eax,%ebx
&rtems_filesystem_root,
101707: e8 e4 10 00 00 call 1027f0 <rtems_current_user_env_get>
rtems_filesystem_global_location_assign(
10170c: 89 7c 24 04 mov %edi,0x4(%esp)
101710: 83 c0 04 add $0x4,%eax
101713: 89 04 24 mov %eax,(%esp)
101716: e8 85 0b 00 00 call 1022a0 <rtems_filesystem_global_location_assign>
&rtems_filesystem_current,
10171b: e8 d0 10 00 00 call 1027f0 <rtems_current_user_env_get>
rtems_filesystem_global_location_assign(
101720: 89 5c 24 04 mov %ebx,0x4(%esp)
101724: 89 04 24 mov %eax,(%esp)
101727: e8 74 0b 00 00 call 1022a0 <rtems_filesystem_global_location_assign>
}
10172c: 81 c4 8c 00 00 00 add $0x8c,%esp
101732: 89 f0 mov %esi,%eax
101734: 5b pop %ebx
101735: 5e pop %esi
101736: 5f pop %edi
101737: 5d pop %ebp
101738: c3 ret
101739: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
memcpy( str, source_or_null, source_size );
101740: 0f b7 16 movzwl (%esi),%edx
101743: 83 c7 02 add $0x2,%edi
101746: 83 c6 02 add $0x2,%esi
101749: 83 e9 02 sub $0x2,%ecx
10174c: 66 89 57 fe mov %dx,-0x2(%edi)
101750: e9 ef fd ff ff jmp 101544 <mount+0x224>
101755: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10175c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
101760: 0f b6 16 movzbl (%esi),%edx <== NOT EXECUTED
101763: 8d 78 01 lea 0x1(%eax),%edi <== NOT EXECUTED
101766: 46 inc %esi <== NOT EXECUTED
101767: 88 10 mov %dl,(%eax) <== NOT EXECUTED
101769: 8b 4d 80 mov -0x80(%ebp),%ecx <== NOT EXECUTED
10176c: 49 dec %ecx <== NOT EXECUTED
10176d: e9 c6 fd ff ff jmp 101538 <mount+0x218> <== NOT EXECUTED
101772: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
101779: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
memcpy( str, target, target_size );
101780: 0f b6 16 movzbl (%esi),%edx <== NOT EXECUTED
101783: 8d 78 01 lea 0x1(%eax),%edi <== NOT EXECUTED
101786: 46 inc %esi <== NOT EXECUTED
101787: 49 dec %ecx <== NOT EXECUTED
101788: 88 10 mov %dl,(%eax) <== NOT EXECUTED
10178a: e9 09 fe ff ff jmp 101598 <mount+0x278> <== NOT EXECUTED
10178f: 90 nop <== NOT EXECUTED
101790: 0f b7 16 movzwl (%esi),%edx
101793: 83 c7 02 add $0x2,%edi
101796: 83 c6 02 add $0x2,%esi
101799: 83 e9 02 sub $0x2,%ecx
10179c: 66 89 57 fe mov %dx,-0x2(%edi)
1017a0: e9 ff fd ff ff jmp 1015a4 <mount+0x284>
1017a5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1017ac: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
errno = EINVAL;
1017b0: e8 db 78 01 00 call 119090 <__errno>
rv = -1;
1017b5: be ff ff ff ff mov $0xffffffff,%esi
errno = EINVAL;
1017ba: c7 00 16 00 00 00 movl $0x16,(%eax)
return rv;
1017c0: e9 59 fd ff ff jmp 10151e <mount+0x1fe>
rtems_filesystem_eval_path_error( &ctx, EBUSY );
1017c5: 89 3c 24 mov %edi,(%esp)
1017c8: b8 10 00 00 00 mov $0x10,%eax
rv = -1;
1017cd: be ff ff ff ff mov $0xffffffff,%esi
rtems_filesystem_eval_path_error( &ctx, EBUSY );
1017d2: 89 44 24 04 mov %eax,0x4(%esp)
1017d6: e8 c5 07 00 00 call 101fa0 <rtems_filesystem_eval_path_error>
rtems_filesystem_eval_path_cleanup( &ctx );
1017db: 89 3c 24 mov %edi,(%esp)
1017de: e8 2d 08 00 00 call 102010 <rtems_filesystem_eval_path_cleanup>
if ( rv != 0 ) {
1017e3: e9 25 fd ff ff jmp 10150d <mount+0x1ed>
errno = EINVAL;
1017e8: e8 a3 78 01 00 call 119090 <__errno> <== NOT EXECUTED
rv = -1;
1017ed: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED
errno = EINVAL;
1017f2: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
1017f8: e8 83 81 00 00 call 109980 <rtems_libio_unlock> <== NOT EXECUTED
if ( rv != 0 ) {
1017fd: e9 0b fd ff ff jmp 10150d <mount+0x1ed> <== NOT EXECUTED
101802: 90 nop
101803: 90 nop
101804: 90 nop
101805: 90 nop
101806: 90 nop
101807: 90 nop
101808: 90 nop
101809: 90 nop
10180a: 90 nop
10180b: 90 nop
10180c: 90 nop
10180d: 90 nop
10180e: 90 nop
10180f: 90 nop
00103c30 <mount_and_make_target_path>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
103c30: 55 push %ebp
103c31: 89 e5 mov %esp,%ebp
103c33: 83 ec 38 sub $0x38,%esp
103c36: 89 5d f4 mov %ebx,-0xc(%ebp)
103c39: 8b 45 08 mov 0x8(%ebp),%eax
103c3c: 89 75 f8 mov %esi,-0x8(%ebp)
103c3f: 8b 5d 0c mov 0xc(%ebp),%ebx
103c42: 89 7d fc mov %edi,-0x4(%ebp)
103c45: 8b 75 14 mov 0x14(%ebp),%esi
103c48: 8b 7d 18 mov 0x18(%ebp),%edi
103c4b: 89 45 e4 mov %eax,-0x1c(%ebp)
103c4e: 8b 45 10 mov 0x10(%ebp),%eax
int rv = -1;
if (target != NULL) {
103c51: 85 db test %ebx,%ebx
{
103c53: 89 45 e0 mov %eax,-0x20(%ebp)
if (target != NULL) {
103c56: 74 4e je 103ca6 <mount_and_make_target_path+0x76>
rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);
103c58: 89 1c 24 mov %ebx,(%esp)
103c5b: b8 ff 01 00 00 mov $0x1ff,%eax
103c60: 89 44 24 04 mov %eax,0x4(%esp)
103c64: e8 a7 0d 00 00 call 104a10 <rtems_mkdir>
if (rv == 0) {
103c69: 85 c0 test %eax,%eax
103c6b: 74 13 je 103c80 <mount_and_make_target_path+0x50> <== ALWAYS TAKEN
} else {
errno = EINVAL;
}
return rv;
}
103c6d: 8b 5d f4 mov -0xc(%ebp),%ebx
103c70: 8b 75 f8 mov -0x8(%ebp),%esi
103c73: 8b 7d fc mov -0x4(%ebp),%edi
103c76: 89 ec mov %ebp,%esp
103c78: 5d pop %ebp
103c79: c3 ret
103c7a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
rv = mount(
103c80: 89 7d 18 mov %edi,0x18(%ebp)
103c83: 8b 45 e0 mov -0x20(%ebp),%eax
103c86: 89 75 14 mov %esi,0x14(%ebp)
}
103c89: 8b 7d fc mov -0x4(%ebp),%edi
rv = mount(
103c8c: 89 5d 0c mov %ebx,0xc(%ebp)
}
103c8f: 8b 75 f8 mov -0x8(%ebp),%esi
103c92: 8b 5d f4 mov -0xc(%ebp),%ebx
rv = mount(
103c95: 89 45 10 mov %eax,0x10(%ebp)
103c98: 8b 45 e4 mov -0x1c(%ebp),%eax
103c9b: 89 45 08 mov %eax,0x8(%ebp)
}
103c9e: 89 ec mov %ebp,%esp
103ca0: 5d pop %ebp
rv = mount(
103ca1: e9 fa f9 ff ff jmp 1036a0 <mount>
errno = EINVAL;
103ca6: e8 05 5f 02 00 call 129bb0 <__errno>
103cab: c7 00 16 00 00 00 movl $0x16,(%eax)
int rv = -1;
103cb1: b8 ff ff ff ff mov $0xffffffff,%eax
return rv;
103cb6: eb b5 jmp 103c6d <mount_and_make_target_path+0x3d>
103cb8: 90 nop
103cb9: 90 nop
103cba: 90 nop
103cbb: 90 nop
103cbc: 90 nop
103cbd: 90 nop
103cbe: 90 nop
103cbf: 90 nop
001018b0 <newlib_create_hook>:
bool newlib_create_hook(
rtems_tcb *current_task RTEMS_UNUSED,
rtems_tcb *creating_task
)
{
1018b0: 55 push %ebp
_REENT_INIT_PTR((creating_task->libc_reent)); /* GCC extension: structure constants */
1018b1: 31 c9 xor %ecx,%ecx
{
1018b3: 89 e5 mov %esp,%ebp
1018b5: 83 ec 0c sub $0xc,%esp
1018b8: 89 75 f8 mov %esi,-0x8(%ebp)
1018bb: 8b 75 0c mov 0xc(%ebp),%esi
1018be: 89 5d f4 mov %ebx,-0xc(%ebp)
1018c1: bb 58 01 00 00 mov $0x158,%ebx
1018c6: 89 7d fc mov %edi,-0x4(%ebp)
_REENT_INIT_PTR((creating_task->libc_reent)); /* GCC extension: structure constants */
1018c9: 8b 96 04 01 00 00 mov 0x104(%esi),%edx
1018cf: f6 c2 01 test $0x1,%dl
1018d2: 0f 85 a8 00 00 00 jne 101980 <newlib_create_hook+0xd0> <== NEVER TAKEN
1018d8: f6 c2 02 test $0x2,%dl
1018db: 0f 85 bf 00 00 00 jne 1019a0 <newlib_create_hook+0xf0> <== NEVER TAKEN
1018e1: 89 df mov %ebx,%edi
1018e3: 31 c0 xor %eax,%eax
1018e5: 83 e7 f8 and $0xfffffff8,%edi
1018e8: 89 0c 02 mov %ecx,(%edx,%eax,1)
1018eb: 89 4c 02 04 mov %ecx,0x4(%edx,%eax,1)
1018ef: 83 c0 08 add $0x8,%eax
1018f2: 39 f8 cmp %edi,%eax
1018f4: 72 f2 jb 1018e8 <newlib_create_hook+0x38>
1018f6: 01 c2 add %eax,%edx
1018f8: f6 c3 04 test $0x4,%bl
1018fb: 0f 85 cf 00 00 00 jne 1019d0 <newlib_create_hook+0x120> <== NEVER TAKEN
101901: f6 c3 02 test $0x2,%bl
101904: 0f 85 b6 00 00 00 jne 1019c0 <newlib_create_hook+0x110> <== NEVER TAKEN
10190a: f6 c3 01 test $0x1,%bl
10190d: 0f 85 9d 00 00 00 jne 1019b0 <newlib_create_hook+0x100> <== NEVER TAKEN
101913: 8b 86 04 01 00 00 mov 0x104(%esi),%eax
101919: ba 01 00 00 00 mov $0x1,%edx
10191e: bb 0e 33 cd ab mov $0xabcd330e,%ebx
101923: be 34 12 6d e6 mov $0xe66d1234,%esi
101928: bf ec de 05 00 mov $0x5deec,%edi
10192d: 31 c9 xor %ecx,%ecx
10192f: 89 90 a4 00 00 00 mov %edx,0xa4(%eax)
101935: ba 0b 00 00 00 mov $0xb,%edx
10193a: 89 98 ac 00 00 00 mov %ebx,0xac(%eax)
return true;
}
101940: 8b 5d f4 mov -0xc(%ebp),%ebx
_REENT_INIT_PTR((creating_task->libc_reent)); /* GCC extension: structure constants */
101943: 89 b0 b0 00 00 00 mov %esi,0xb0(%eax)
}
101949: 8b 75 f8 mov -0x8(%ebp),%esi
_REENT_INIT_PTR((creating_task->libc_reent)); /* GCC extension: structure constants */
10194c: 89 b8 b4 00 00 00 mov %edi,0xb4(%eax)
}
101952: 8b 7d fc mov -0x4(%ebp),%edi
_REENT_INIT_PTR((creating_task->libc_reent)); /* GCC extension: structure constants */
101955: c7 40 04 a0 4c 13 00 movl $0x134ca0,0x4(%eax)
10195c: c7 40 08 20 4d 13 00 movl $0x134d20,0x8(%eax)
101963: c7 40 0c a0 4d 13 00 movl $0x134da0,0xc(%eax)
10196a: 89 88 a8 00 00 00 mov %ecx,0xa8(%eax)
101970: 66 89 90 b8 00 00 00 mov %dx,0xb8(%eax)
}
101977: 89 ec mov %ebp,%esp
101979: b0 01 mov $0x1,%al
10197b: 5d pop %ebp
10197c: c3 ret
10197d: 8d 76 00 lea 0x0(%esi),%esi
_REENT_INIT_PTR((creating_task->libc_reent)); /* GCC extension: structure constants */
101980: c6 02 00 movb $0x0,(%edx) <== NOT EXECUTED
101983: 42 inc %edx <== NOT EXECUTED
101984: bb 57 01 00 00 mov $0x157,%ebx <== NOT EXECUTED
101989: f6 c2 02 test $0x2,%dl <== NOT EXECUTED
10198c: 0f 84 4f ff ff ff je 1018e1 <newlib_create_hook+0x31> <== NOT EXECUTED
101992: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
101999: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1019a0: 66 c7 02 00 00 movw $0x0,(%edx) <== NOT EXECUTED
1019a5: 83 eb 02 sub $0x2,%ebx <== NOT EXECUTED
1019a8: 83 c2 02 add $0x2,%edx <== NOT EXECUTED
1019ab: e9 31 ff ff ff jmp 1018e1 <newlib_create_hook+0x31> <== NOT EXECUTED
1019b0: c6 02 00 movb $0x0,(%edx) <== NOT EXECUTED
1019b3: e9 5b ff ff ff jmp 101913 <newlib_create_hook+0x63> <== NOT EXECUTED
1019b8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1019bf: 90 nop <== NOT EXECUTED
1019c0: 66 c7 02 00 00 movw $0x0,(%edx) <== NOT EXECUTED
1019c5: 83 c2 02 add $0x2,%edx <== NOT EXECUTED
1019c8: e9 3d ff ff ff jmp 10190a <newlib_create_hook+0x5a> <== NOT EXECUTED
1019cd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
1019d0: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED
1019d6: 83 c2 04 add $0x4,%edx <== NOT EXECUTED
1019d9: e9 23 ff ff ff jmp 101901 <newlib_create_hook+0x51> <== NOT EXECUTED
1019de: 90 nop
1019df: 90 nop
0010bf50 <open>:
/**
* POSIX 1003.1 5.3.1 - Open a File
*/
int open( const char *path, int oflag, ... )
{
10bf50: 55 push %ebp
10bf51: 89 e5 mov %esp,%ebp
10bf53: 57 push %edi
10bf54: 56 push %esi
10bf55: 53 push %ebx
10bf56: 81 ec cc 00 00 00 sub $0xcc,%esp
mode_t mode = 0;
rtems_libio_t *iop = NULL;
va_start( ap, oflag );
mode = va_arg( ap, mode_t );
10bf5c: 8b 45 10 mov 0x10(%ebp),%eax
{
10bf5f: 8b 75 0c mov 0xc(%ebp),%esi
mode = va_arg( ap, mode_t );
10bf62: 89 85 50 ff ff ff mov %eax,-0xb0(%ebp)
iop = rtems_libio_allocate();
10bf68: e8 a3 0d 00 00 call 10cd10 <rtems_libio_allocate>
if ( iop != NULL ) {
10bf6d: 85 c0 test %eax,%eax
10bf6f: 0f 84 a7 02 00 00 je 10c21c <open+0x2cc>
int rwflag = oflag + 1;
10bf75: 8d 56 01 lea 0x1(%esi),%edx
10bf78: 89 c3 mov %eax,%ebx
bool write_access = (rwflag & _FWRITE) == _FWRITE;
10bf7a: 89 d0 mov %edx,%eax
bool make = (oflag & O_CREAT) == O_CREAT;
10bf7c: 89 f7 mov %esi,%edi
bool write_access = (rwflag & _FWRITE) == _FWRITE;
10bf7e: 83 e0 02 and $0x2,%eax
bool exclusive = (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL);
10bf81: 89 f1 mov %esi,%ecx
bool write_access = (rwflag & _FWRITE) == _FWRITE;
10bf83: 89 85 54 ff ff ff mov %eax,-0xac(%ebp)
int follow = (oflag & O_NOFOLLOW) == O_NOFOLLOW ? 0 : RTEMS_FS_FOLLOW_LINK;
10bf89: 89 f0 mov %esi,%eax
bool make = (oflag & O_CREAT) == O_CREAT;
10bf8b: 81 e7 00 02 00 00 and $0x200,%edi
int follow = (oflag & O_NOFOLLOW) == O_NOFOLLOW ? 0 : RTEMS_FS_FOLLOW_LINK;
10bf91: 25 00 00 10 00 and $0x100000,%eax
bool exclusive = (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL);
10bf96: 81 e1 00 0a 00 00 and $0xa00,%ecx
int follow = (oflag & O_NOFOLLOW) == O_NOFOLLOW ? 0 : RTEMS_FS_FOLLOW_LINK;
10bf9c: 83 f8 01 cmp $0x1,%eax
10bf9f: 19 c0 sbb %eax,%eax
10bfa1: 83 e0 18 and $0x18,%eax
| (read_access ? RTEMS_FS_PERMS_READ : 0)
10bfa4: f6 c2 01 test $0x1,%dl
10bfa7: 74 03 je 10bfac <open+0x5c>
10bfa9: 83 c8 04 or $0x4,%eax
| (write_access ? RTEMS_FS_PERMS_WRITE : 0)
10bfac: 8b 95 54 ff ff ff mov -0xac(%ebp),%edx
10bfb2: 85 d2 test %edx,%edx
10bfb4: 74 03 je 10bfb9 <open+0x69>
10bfb6: 83 c8 02 or $0x2,%eax
| (make ? RTEMS_FS_MAKE : 0)
10bfb9: 85 ff test %edi,%edi
10bfbb: 0f 85 6f 01 00 00 jne 10c130 <open+0x1e0>
| (exclusive ? RTEMS_FS_EXCLUSIVE : 0);
10bfc1: 81 f9 00 0a 00 00 cmp $0xa00,%ecx
10bfc7: 75 03 jne 10bfcc <open+0x7c>
int eval_flags = follow
10bfc9: 83 c8 40 or $0x40,%eax
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
10bfcc: 89 44 24 08 mov %eax,0x8(%esp)
10bfd0: 8b 45 08 mov 0x8(%ebp),%eax
10bfd3: 8d bd 58 ff ff ff lea -0xa8(%ebp),%edi
10bfd9: 89 3c 24 mov %edi,(%esp)
10bfdc: 89 44 24 04 mov %eax,0x4(%esp)
10bfe0: e8 5b 5f ff ff call 101f40 <rtems_filesystem_eval_path_start>
return ctx->tokenlen > 0;
10bfe5: 8b 95 64 ff ff ff mov -0x9c(%ebp),%edx
10bfeb: 8d 8d 70 ff ff ff lea -0x90(%ebp),%ecx
if ( rtems_filesystem_eval_path_has_token( &ctx ) ) {
10bff1: 85 d2 test %edx,%edx
10bff3: 0f 85 47 01 00 00 jne 10c140 <open+0x1f0>
if ( write_access || open_dir ) {
10bff9: 8b 85 54 ff ff ff mov -0xac(%ebp),%eax
open_dir = ( oflag & O_DIRECTORY ) == O_DIRECTORY;
10bfff: 89 f2 mov %esi,%edx
10c001: 81 e2 00 00 20 00 and $0x200000,%edx
if ( write_access || open_dir ) {
10c007: 89 95 4c ff ff ff mov %edx,-0xb4(%ebp)
10c00d: 09 d0 or %edx,%eax
10c00f: 74 5f je 10c070 <open+0x120>
)
{
struct stat st;
st.st_mode = 0;
(void) ( *loc->handlers->fstat_h )( loc, &st );
10c011: 89 0c 24 mov %ecx,(%esp)
10c014: 8d 45 90 lea -0x70(%ebp),%eax
10c017: 89 44 24 04 mov %eax,0x4(%esp)
10c01b: 8b 45 80 mov -0x80(%ebp),%eax
st.st_mode = 0;
10c01e: c7 45 a0 00 00 00 00 movl $0x0,-0x60(%ebp)
(void) ( *loc->handlers->fstat_h )( loc, &st );
10c025: ff 50 18 call *0x18(%eax)
if ( write_access && S_ISDIR( type ) ) {
10c028: 8b 95 54 ff ff ff mov -0xac(%ebp),%edx
10c02e: 8d 8d 70 ff ff ff lea -0x90(%ebp),%ecx
return st.st_mode;
10c034: 8b 45 a0 mov -0x60(%ebp),%eax
10c037: 85 d2 test %edx,%edx
10c039: 8b 95 4c ff ff ff mov -0xb4(%ebp),%edx
10c03f: 0f 84 7b 01 00 00 je 10c1c0 <open+0x270>
10c045: 25 00 f0 00 00 and $0xf000,%eax
10c04a: 3d 00 40 00 00 cmp $0x4000,%eax
10c04f: 0f 84 ab 01 00 00 je 10c200 <open+0x2b0>
if ( open_dir && !S_ISDIR( type ) ) {
10c055: 85 d2 test %edx,%edx
10c057: 74 17 je 10c070 <open+0x120> <== ALWAYS TAKEN
rtems_filesystem_eval_path_error( &ctx, ENOTDIR );
10c059: 89 3c 24 mov %edi,(%esp)
10c05c: b9 14 00 00 00 mov $0x14,%ecx
10c061: 89 4c 24 04 mov %ecx,0x4(%esp)
10c065: e8 36 5f ff ff call 101fa0 <rtems_filesystem_eval_path_error>
10c06a: 8d 8d 70 ff ff ff lea -0x90(%ebp),%ecx
rtems_filesystem_location_copy_and_detach(
10c070: 89 4c 24 04 mov %ecx,0x4(%esp)
rtems_filesystem_eval_path_extract_currentloc( &ctx, &iop->pathinfo );
10c074: 8d 43 0c lea 0xc(%ebx),%eax
10c077: 89 04 24 mov %eax,(%esp)
10c07a: e8 21 65 ff ff call 1025a0 <rtems_filesystem_location_copy_and_detach>
rtems_filesystem_eval_path_cleanup( &ctx );
10c07f: 89 3c 24 mov %edi,(%esp)
10c082: e8 89 5f ff ff call 102010 <rtems_filesystem_eval_path_cleanup>
rtems_libio_iop_flags_set( iop, rtems_libio_fcntl_flags( oflag ) );
10c087: 89 34 24 mov %esi,(%esp)
10c08a: e8 31 0c 00 00 call 10ccc0 <rtems_libio_fcntl_flags>
#else
unsigned int val;
ISR_Level level;
(void) order;
_ISR_Local_disable( level );
10c08f: 9c pushf
10c090: fa cli
10c091: 5a pop %edx
val = *obj;
*obj = val | arg;
10c092: 09 03 or %eax,(%ebx)
_ISR_Local_enable( level );
10c094: 52 push %edx
10c095: 9d popf
rv = (*iop->pathinfo.handlers->open_h)( iop, path, oflag, mode );
10c096: 8b 8d 50 ff ff ff mov -0xb0(%ebp),%ecx
10c09c: 8b 43 1c mov 0x1c(%ebx),%eax
10c09f: 89 74 24 08 mov %esi,0x8(%esp)
10c0a3: 89 1c 24 mov %ebx,(%esp)
10c0a6: 89 4c 24 0c mov %ecx,0xc(%esp)
10c0aa: 8b 4d 08 mov 0x8(%ebp),%ecx
10c0ad: 89 4c 24 04 mov %ecx,0x4(%esp)
10c0b1: ff 10 call *(%eax)
if ( rv == 0 ) {
10c0b3: 85 c0 test %eax,%eax
rv = (*iop->pathinfo.handlers->open_h)( iop, path, oflag, mode );
10c0b5: 89 c7 mov %eax,%edi
if ( rv == 0 ) {
10c0b7: 75 24 jne 10c0dd <open+0x18d>
int fd = rtems_libio_iop_to_descriptor( iop );
10c0b9: 89 df mov %ebx,%edi
10c0bb: 81 ef c0 c5 12 00 sub $0x12c5c0,%edi
10c0c1: c1 ff 02 sar $0x2,%edi
10c0c4: 69 ff a3 8b 2e ba imul $0xba2e8ba3,%edi,%edi
_ISR_Local_disable( level );
10c0ca: 9c pushf
10c0cb: fa cli
10c0cc: 58 pop %eax
*obj = val | arg;
10c0cd: 81 0b 00 01 00 00 orl $0x100,(%ebx)
_ISR_Local_enable( level );
10c0d3: 50 push %eax
10c0d4: 9d popf
if ( truncate ) {
10c0d5: 81 e6 00 04 00 00 and $0x400,%esi
10c0db: 75 13 jne 10c0f0 <open+0x1a0>
if ( rv < 0 ) {
10c0dd: 85 ff test %edi,%edi
10c0df: 78 35 js 10c116 <open+0x1c6>
}
va_end( ap );
return rv;
}
10c0e1: 81 c4 cc 00 00 00 add $0xcc,%esp
10c0e7: 89 f8 mov %edi,%eax
10c0e9: 5b pop %ebx
10c0ea: 5e pop %esi
10c0eb: 5f pop %edi
10c0ec: 5d pop %ebp
10c0ed: c3 ret
10c0ee: 66 90 xchg %ax,%ax
rv = ftruncate( fd, 0 );
10c0f0: 89 3c 24 mov %edi,(%esp)
10c0f3: 31 c0 xor %eax,%eax
10c0f5: 31 d2 xor %edx,%edx
10c0f7: 89 44 24 04 mov %eax,0x4(%esp)
10c0fb: 89 54 24 08 mov %edx,0x8(%esp)
10c0ff: e8 dc 0a 00 00 call 10cbe0 <ftruncate>
if ( rv != 0 ) {
10c104: 85 c0 test %eax,%eax
10c106: 74 d5 je 10c0dd <open+0x18d>
(*iop->pathinfo.handlers->close_h)( iop );
10c108: 8b 43 1c mov 0x1c(%ebx),%eax
rv = -1;
10c10b: bf ff ff ff ff mov $0xffffffff,%edi
(*iop->pathinfo.handlers->close_h)( iop );
10c110: 89 1c 24 mov %ebx,(%esp)
10c113: ff 50 04 call *0x4(%eax)
rtems_libio_free( iop );
10c116: 89 1c 24 mov %ebx,(%esp)
10c119: e8 52 0c 00 00 call 10cd70 <rtems_libio_free>
}
10c11e: 81 c4 cc 00 00 00 add $0xcc,%esp
10c124: 89 f8 mov %edi,%eax
10c126: 5b pop %ebx
10c127: 5e pop %esi
10c128: 5f pop %edi
10c129: 5d pop %ebp
10c12a: c3 ret
10c12b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10c12f: 90 nop
| (make ? RTEMS_FS_MAKE : 0)
10c130: 83 c8 20 or $0x20,%eax
10c133: e9 89 fe ff ff jmp 10bfc1 <open+0x71>
10c138: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10c13f: 90 nop
rv = rtems_filesystem_mknod(
10c140: 89 54 24 08 mov %edx,0x8(%esp)
return ctx->token;
10c144: 8b 85 60 ff ff ff mov -0xa0(%ebp),%eax
10c14a: 89 0c 24 mov %ecx,(%esp)
10c14d: 89 95 48 ff ff ff mov %edx,-0xb8(%ebp)
10c153: 89 85 4c ff ff ff mov %eax,-0xb4(%ebp)
10c159: 31 c0 xor %eax,%eax
10c15b: 89 44 24 10 mov %eax,0x10(%esp)
10c15f: 31 c0 xor %eax,%eax
10c161: 89 44 24 14 mov %eax,0x14(%esp)
10c165: 8b 85 50 ff ff ff mov -0xb0(%ebp),%eax
10c16b: 0d 00 80 00 00 or $0x8000,%eax
10c170: 89 44 24 0c mov %eax,0xc(%esp)
10c174: 8b 85 4c ff ff ff mov -0xb4(%ebp),%eax
10c17a: 89 44 24 04 mov %eax,0x4(%esp)
10c17e: e8 5d 50 ff ff call 1011e0 <rtems_filesystem_mknod>
if ( rv == 0 ) {
10c183: 85 c0 test %eax,%eax
10c185: 75 59 jne 10c1e0 <open+0x290>
rtems_filesystem_eval_path_continue( ctx );
10c187: 89 3c 24 mov %edi,(%esp)
ctx->flags = flags;
10c18a: 31 c0 xor %eax,%eax
ctx->pathlen = pathlen;
10c18c: 8b 95 48 ff ff ff mov -0xb8(%ebp),%edx
ctx->flags = flags;
10c192: 89 85 68 ff ff ff mov %eax,-0x98(%ebp)
ctx->path = path;
10c198: 8b 85 4c ff ff ff mov -0xb4(%ebp),%eax
ctx->pathlen = pathlen;
10c19e: 89 95 5c ff ff ff mov %edx,-0xa4(%ebp)
ctx->path = path;
10c1a4: 89 85 58 ff ff ff mov %eax,-0xa8(%ebp)
10c1aa: e8 f1 5a ff ff call 101ca0 <rtems_filesystem_eval_path_continue>
10c1af: 8d 8d 70 ff ff ff lea -0x90(%ebp),%ecx
10c1b5: e9 3f fe ff ff jmp 10bff9 <open+0xa9>
10c1ba: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
if ( open_dir && !S_ISDIR( type ) ) {
10c1c0: 85 d2 test %edx,%edx
10c1c2: 0f 84 a8 fe ff ff je 10c070 <open+0x120> <== NEVER TAKEN
10c1c8: 25 00 f0 00 00 and $0xf000,%eax
10c1cd: 3d 00 40 00 00 cmp $0x4000,%eax
10c1d2: 0f 84 98 fe ff ff je 10c070 <open+0x120>
10c1d8: e9 7c fe ff ff jmp 10c059 <open+0x109>
10c1dd: 8d 76 00 lea 0x0(%esi),%esi
rtems_filesystem_eval_path_error( ctx, 0 );
10c1e0: 89 3c 24 mov %edi,(%esp)
10c1e3: 31 c9 xor %ecx,%ecx
10c1e5: 89 4c 24 04 mov %ecx,0x4(%esp)
10c1e9: e8 b2 5d ff ff call 101fa0 <rtems_filesystem_eval_path_error>
10c1ee: 8d 8d 70 ff ff ff lea -0x90(%ebp),%ecx
10c1f4: e9 00 fe ff ff jmp 10bff9 <open+0xa9>
10c1f9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
rtems_filesystem_eval_path_error( &ctx, EISDIR );
10c200: 89 3c 24 mov %edi,(%esp)
10c203: b8 15 00 00 00 mov $0x15,%eax
10c208: 89 44 24 04 mov %eax,0x4(%esp)
10c20c: e8 8f 5d ff ff call 101fa0 <rtems_filesystem_eval_path_error>
if ( open_dir && !S_ISDIR( type ) ) {
10c211: 8d 8d 70 ff ff ff lea -0x90(%ebp),%ecx
10c217: e9 54 fe ff ff jmp 10c070 <open+0x120>
errno = ENFILE;
10c21c: e8 6f ce 00 00 call 119090 <__errno>
rv = -1;
10c221: bf ff ff ff ff mov $0xffffffff,%edi
errno = ENFILE;
10c226: c7 00 17 00 00 00 movl $0x17,(%eax)
return rv;
10c22c: e9 b0 fe ff ff jmp 10c0e1 <open+0x191>
10c231: 90 nop
10c232: 90 nop
10c233: 90 nop
10c234: 90 nop
10c235: 90 nop
10c236: 90 nop
10c237: 90 nop
10c238: 90 nop
10c239: 90 nop
10c23a: 90 nop
10c23b: 90 nop
10c23c: 90 nop
10c23d: 90 nop
10c23e: 90 nop
10c23f: 90 nop
001043b0 <posix_memalign>:
int posix_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
1043b0: 55 push %ebp
1043b1: 89 e5 mov %esp,%ebp
1043b3: 53 push %ebx
1043b4: 8b 45 0c mov 0xc(%ebp),%eax
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
1043b7: 8d 50 ff lea -0x1(%eax),%edx
1043ba: 85 c2 test %eax,%edx
1043bc: 75 12 jne 1043d0 <posix_memalign+0x20> <== NEVER TAKEN
1043be: 83 f8 03 cmp $0x3,%eax
1043c1: 76 0d jbe 1043d0 <posix_memalign+0x20>
/*
* rtems_memalign does all of the error checking work EXCEPT
* for adding restrictionso on the alignment.
*/
return rtems_memalign( pointer, alignment, size );
}
1043c3: 5b pop %ebx
1043c4: 5d pop %ebp
return rtems_memalign( pointer, alignment, size );
1043c5: e9 86 04 00 00 jmp 104850 <rtems_memalign>
1043ca: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
}
1043d0: 5b pop %ebx
1043d1: b8 16 00 00 00 mov $0x16,%eax
1043d6: 5d pop %ebp
1043d7: c3 ret
1043d8: 90 nop
1043d9: 90 nop
1043da: 90 nop
1043db: 90 nop
1043dc: 90 nop
1043dd: 90 nop
1043de: 90 nop
1043df: 90 nop
00124420 <read.part.0>:
#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);
124420: 55 push %ebp
124421: 89 e5 mov %esp,%ebp
124423: 83 ec 38 sub $0x38,%esp
124426: 89 75 f8 mov %esi,-0x8(%ebp)
124429: 89 d6 mov %edx,%esi
12442b: 89 5d f4 mov %ebx,-0xc(%ebp)
12442e: 8d 14 80 lea (%eax,%eax,4),%edx
124431: 89 7d fc mov %edi,-0x4(%ebp)
124434: 8d 04 50 lea (%eax,%edx,2),%eax
124437: c1 e0 02 shl $0x2,%eax
12443a: 8d 98 c0 c5 12 00 lea 0x12c5c0(%eax),%ebx
_ISR_Local_disable( level );
124440: 9c pushf
124441: fa cli
124442: 8f 45 e4 pop -0x1c(%ebp)
val = *obj;
124445: 8b 90 c0 c5 12 00 mov 0x12c5c0(%eax),%edx
*obj = val + arg;
12444b: 8d ba 00 10 00 00 lea 0x1000(%edx),%edi
124451: 89 b8 c0 c5 12 00 mov %edi,0x12c5c0(%eax)
_ISR_Local_enable( level );
124457: ff 75 e4 push -0x1c(%ebp)
12445a: 9d popf
ssize_t n;
rtems_libio_check_buffer( buffer );
rtems_libio_check_count( count );
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_READ, EBADF );
12445b: 81 e2 02 01 00 00 and $0x102,%edx
124461: 81 fa 02 01 00 00 cmp $0x102,%edx
124467: 75 29 jne 124492 <read.part.0+0x72> <== NEVER TAKEN
/*
* Now process the read().
*/
n = (*iop->pathinfo.handlers->read_h)( iop, buffer, count );
124469: 89 4c 24 08 mov %ecx,0x8(%esp)
12446d: 8b 43 1c mov 0x1c(%ebx),%eax
124470: 89 74 24 04 mov %esi,0x4(%esp)
124474: 89 1c 24 mov %ebx,(%esp)
124477: ff 50 08 call *0x8(%eax)
_ISR_Local_disable( level );
12447a: 9c pushf
12447b: fa cli
12447c: 5a pop %edx
*obj = val - arg;
12447d: 81 2b 00 10 00 00 subl $0x1000,(%ebx)
_ISR_Local_enable( level );
124483: 52 push %edx
124484: 9d popf
rtems_libio_iop_drop( iop );
return n;
}
124485: 8b 5d f4 mov -0xc(%ebp),%ebx
124488: 8b 75 f8 mov -0x8(%ebp),%esi
12448b: 8b 7d fc mov -0x4(%ebp),%edi
12448e: 89 ec mov %ebp,%esp
124490: 5d pop %ebp
124491: c3 ret
_ISR_Local_disable( level );
124492: 9c pushf <== NOT EXECUTED
124493: fa cli <== NOT EXECUTED
124494: 58 pop %eax <== NOT EXECUTED
*obj = val - arg;
124495: 81 2b 00 10 00 00 subl $0x1000,(%ebx) <== NOT EXECUTED
_ISR_Local_enable( level );
12449b: 50 push %eax <== NOT EXECUTED
12449c: 9d popf <== NOT EXECUTED
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_READ, EBADF );
12449d: e8 ee 4b ff ff call 119090 <__errno> <== NOT EXECUTED
1244a2: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED
1244a8: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
1244ad: eb d6 jmp 124485 <read.part.0+0x65> <== NOT EXECUTED
1244af: 90 nop
00118240 <realloc>:
return new_ptr;
}
void *realloc( void *ptr, size_t size )
{
118240: 55 push %ebp
118241: 89 e5 mov %esp,%ebp
118243: 83 ec 58 sub $0x58,%esp
118246: 89 7d fc mov %edi,-0x4(%ebp)
118249: 8b 7d 0c mov 0xc(%ebp),%edi
11824c: 89 5d f4 mov %ebx,-0xc(%ebp)
11824f: 8b 5d 08 mov 0x8(%ebp),%ebx
118252: 89 75 f8 mov %esi,-0x8(%ebp)
Heap_Control *heap;
Heap_Resize_status status;
uintptr_t old_size;
uintptr_t avail_size;
if ( size == 0 ) {
118255: 85 ff test %edi,%edi
118257: 0f 84 23 01 00 00 je 118380 <realloc+0x140> <== NEVER TAKEN
free( ptr );
return NULL;
}
if ( ptr == NULL ) {
11825d: 85 db test %ebx,%ebx
11825f: 0f 84 fb 00 00 00 je 118360 <realloc+0x120>
return malloc( size );
}
heap = RTEMS_Malloc_Heap;
118265: 8b 35 20 03 13 00 mov 0x130320,%esi
switch ( _Malloc_System_state() ) {
11826b: e8 d0 8d fe ff call 101040 <_Malloc_System_state>
118270: 85 c0 test %eax,%eax
118272: 0f 84 98 00 00 00 je 118310 <realloc+0xd0>
118278: 48 dec %eax
118279: 0f 85 7c 00 00 00 jne 1182fb <realloc+0xbb> <== NEVER 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 );
11827f: 89 34 24 mov %esi,(%esp)
118282: 8d 45 e4 lea -0x1c(%ebp),%eax
118285: 89 44 24 10 mov %eax,0x10(%esp)
118289: 8d 45 e0 lea -0x20(%ebp),%eax
11828c: 89 44 24 0c mov %eax,0xc(%esp)
118290: 89 7c 24 08 mov %edi,0x8(%esp)
118294: 89 5c 24 04 mov %ebx,0x4(%esp)
118298: e8 43 0a 00 00 call 118ce0 <_Heap_Resize_block>
11829d: 89 c6 mov %eax,%esi
break;
default:
return NULL;
}
switch ( status ) {
11829f: 85 f6 test %esi,%esi
1182a1: 0f 84 a0 00 00 00 je 118347 <realloc+0x107>
1182a7: 4e dec %esi
1182a8: 75 46 jne 1182f0 <realloc+0xb0>
new_ptr = malloc( new_size );
1182aa: 89 3c 24 mov %edi,(%esp)
case HEAP_RESIZE_SUCCESSFUL:
return ptr;
case HEAP_RESIZE_UNSATISFIED:
return new_alloc( ptr, size, old_size );
1182ad: 8b 75 e0 mov -0x20(%ebp),%esi
new_ptr = malloc( new_size );
1182b0: e8 2b 8d fe ff call 100fe0 <malloc>
if ( new_ptr == NULL ) {
1182b5: 85 c0 test %eax,%eax
1182b7: 74 44 je 1182fd <realloc+0xbd>
memcpy( new_ptr, old_ptr, ( new_size < old_size ) ? new_size : old_size );
1182b9: 39 fe cmp %edi,%esi
1182bb: 89 f1 mov %esi,%ecx
1182bd: 76 02 jbe 1182c1 <realloc+0x81> <== ALWAYS TAKEN
1182bf: 89 f9 mov %edi,%ecx <== NOT EXECUTED
1182c1: 83 f9 08 cmp $0x8,%ecx
1182c4: 89 c7 mov %eax,%edi
1182c6: 89 de mov %ebx,%esi
1182c8: 0f 83 c2 00 00 00 jae 118390 <realloc+0x150> <== ALWAYS TAKEN
1182ce: 89 45 d4 mov %eax,-0x2c(%ebp)
1182d1: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
free( old_ptr );
1182d3: 89 1c 24 mov %ebx,(%esp)
1182d6: e8 d5 14 ff ff call 1097b0 <free>
return new_ptr;
1182db: 8b 45 d4 mov -0x2c(%ebp),%eax
default:
errno = EINVAL;
return NULL;
}
}
1182de: 8b 5d f4 mov -0xc(%ebp),%ebx
1182e1: 8b 75 f8 mov -0x8(%ebp),%esi
1182e4: 8b 7d fc mov -0x4(%ebp),%edi
1182e7: 89 ec mov %ebp,%esp
1182e9: 5d pop %ebp
1182ea: c3 ret
1182eb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
1182ef: 90 nop
errno = EINVAL;
1182f0: e8 9b 0d 00 00 call 119090 <__errno>
1182f5: c7 00 16 00 00 00 movl $0x16,(%eax)
return NULL;
1182fb: 31 c0 xor %eax,%eax
}
1182fd: 8b 5d f4 mov -0xc(%ebp),%ebx
118300: 8b 75 f8 mov -0x8(%ebp),%esi
118303: 8b 7d fc mov -0x4(%ebp),%edi
118306: 89 ec mov %ebp,%esp
118308: 5d pop %ebp
118309: c3 ret
11830a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
_RTEMS_Lock_allocator();
118310: e8 3b c8 fe ff call 104b50 <_RTEMS_Lock_allocator>
_Malloc_Process_deferred_frees();
118315: e8 16 15 ff ff call 109830 <_Malloc_Process_deferred_frees>
status = _Heap_Resize_block( heap, ptr, size, &old_size, &avail_size );
11831a: 8d 45 e4 lea -0x1c(%ebp),%eax
11831d: 89 44 24 10 mov %eax,0x10(%esp)
118321: 8d 45 e0 lea -0x20(%ebp),%eax
118324: 89 34 24 mov %esi,(%esp)
118327: 89 44 24 0c mov %eax,0xc(%esp)
11832b: 89 7c 24 08 mov %edi,0x8(%esp)
11832f: 89 5c 24 04 mov %ebx,0x4(%esp)
118333: e8 a8 09 00 00 call 118ce0 <_Heap_Resize_block>
118338: 89 c6 mov %eax,%esi
_RTEMS_Unlock_allocator();
11833a: e8 31 c8 fe ff call 104b70 <_RTEMS_Unlock_allocator>
switch ( status ) {
11833f: 85 f6 test %esi,%esi
118341: 0f 85 60 ff ff ff jne 1182a7 <realloc+0x67>
}
118347: 8b 75 f8 mov -0x8(%ebp),%esi
switch ( status ) {
11834a: 89 d8 mov %ebx,%eax
}
11834c: 8b 5d f4 mov -0xc(%ebp),%ebx
11834f: 8b 7d fc mov -0x4(%ebp),%edi
118352: 89 ec mov %ebp,%esp
118354: 5d pop %ebp
118355: c3 ret
118356: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11835d: 8d 76 00 lea 0x0(%esi),%esi
return malloc( size );
118360: 89 7d 08 mov %edi,0x8(%ebp)
}
118363: 8b 5d f4 mov -0xc(%ebp),%ebx
118366: 8b 75 f8 mov -0x8(%ebp),%esi
118369: 8b 7d fc mov -0x4(%ebp),%edi
11836c: 89 ec mov %ebp,%esp
11836e: 5d pop %ebp
return malloc( size );
11836f: e9 6c 8c fe ff jmp 100fe0 <malloc>
118374: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11837b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
11837f: 90 nop
free( ptr );
118380: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
118383: e8 28 14 ff ff call 1097b0 <free> <== NOT EXECUTED
return NULL;
118388: 31 c0 xor %eax,%eax <== NOT EXECUTED
11838a: e9 6e ff ff ff jmp 1182fd <realloc+0xbd> <== NOT EXECUTED
11838f: 90 nop <== NOT EXECUTED
memcpy( new_ptr, old_ptr, ( new_size < old_size ) ? new_size : old_size );
118390: a8 04 test $0x4,%al
118392: 0f 84 36 ff ff ff je 1182ce <realloc+0x8e>
118398: 8b 13 mov (%ebx),%edx
11839a: 8d 78 04 lea 0x4(%eax),%edi
11839d: 83 e9 04 sub $0x4,%ecx
1183a0: 8d 73 04 lea 0x4(%ebx),%esi
1183a3: 89 10 mov %edx,(%eax)
1183a5: e9 24 ff ff ff jmp 1182ce <realloc+0x8e>
1183aa: 90 nop
1183ab: 90 nop
1183ac: 90 nop
1183ad: 90 nop
1183ae: 90 nop
1183af: 90 nop
00104350 <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)
{
104350: 55 push %ebp <== NOT EXECUTED
104351: 89 e5 mov %esp,%ebp <== NOT EXECUTED
104353: 57 push %edi <== NOT EXECUTED
104354: 56 push %esi <== NOT EXECUTED
104355: 53 push %ebx <== NOT EXECUTED
104356: 81 ec 9c 03 00 00 sub $0x39c,%esp <== NOT EXECUTED
10435c: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED
10435f: 8b 5d 0c mov 0xc(%ebp),%ebx <== 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) {
104362: 85 f6 test %esi,%esi <== NOT EXECUTED
104364: 0f 84 46 06 00 00 je 1049b0 <realpath+0x660> <== NOT EXECUTED
errno = EINVAL;
return (NULL);
}
if (path[0] == '\0') {
10436a: 0f b6 16 movzbl (%esi),%edx <== NOT EXECUTED
10436d: 84 d2 test %dl,%dl <== NOT EXECUTED
10436f: 0f 84 8b 05 00 00 je 104900 <realpath+0x5b0> <== NOT EXECUTED
resolved = malloc(PATH_MAX);
if (resolved == NULL)
return (NULL);
m = 1;
} else
m = 0;
104375: 31 ff xor %edi,%edi <== NOT EXECUTED
if (resolved == NULL) {
104377: 85 db test %ebx,%ebx <== NOT EXECUTED
m = 0;
104379: 89 bd 74 fc ff ff mov %edi,-0x38c(%ebp) <== NOT EXECUTED
if (resolved == NULL) {
10437f: 0f 84 2b 05 00 00 je 1048b0 <realpath+0x560> <== NOT EXECUTED
symlinks = 0;
if (path[0] == '/') {
104385: 80 fa 2f cmp $0x2f,%dl <== NOT EXECUTED
104388: 0f 85 12 02 00 00 jne 1045a0 <realpath+0x250> <== NOT EXECUTED
resolved[0] = '/';
resolved[1] = '\0';
if (path[1] == '\0')
10438e: 80 7e 01 00 cmpb $0x0,0x1(%esi) <== NOT EXECUTED
104392: 89 d8 mov %ebx,%eax <== NOT EXECUTED
resolved[0] = '/';
104394: 66 c7 03 2f 00 movw $0x2f,(%ebx) <== NOT EXECUTED
if (path[1] == '\0')
104399: 0f 84 e8 01 00 00 je 104587 <realpath+0x237> <== NOT EXECUTED
return (resolved);
resolved_len = 1;
left_len = strlcpy(left, path + 1, sizeof(left));
10439f: 8d 46 01 lea 0x1(%esi),%eax <== NOT EXECUTED
1043a2: bf ff 00 00 00 mov $0xff,%edi <== NOT EXECUTED
1043a7: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1043ab: 8d 85 eb fc ff ff lea -0x315(%ebp),%eax <== NOT EXECUTED
1043b1: 89 7c 24 08 mov %edi,0x8(%esp) <== NOT EXECUTED
1043b5: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
1043b8: 89 85 7c fc ff ff mov %eax,-0x384(%ebp) <== NOT EXECUTED
1043be: e8 1d 5d 06 00 call 16a0e0 <strlcpy> <== NOT EXECUTED
resolved_len = 1;
1043c3: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED
1043c8: 89 95 80 fc ff ff mov %edx,-0x380(%ebp) <== NOT EXECUTED
left_len = strlcpy(left, path + 1, sizeof(left));
1043ce: 89 85 84 fc ff ff mov %eax,-0x37c(%ebp) <== NOT EXECUTED
1043d4: 31 c0 xor %eax,%eax <== NOT EXECUTED
return (NULL);
}
resolved_len = strlen(resolved);
left_len = strlcpy(left, path, sizeof(left));
}
if (left_len >= sizeof(left) || resolved_len >= PATH_MAX) {
1043d6: 8b b5 84 fc ff ff mov -0x37c(%ebp),%esi <== NOT EXECUTED
1043dc: 81 fe fe 00 00 00 cmp $0xfe,%esi <== NOT EXECUTED
1043e2: 0f 87 78 03 00 00 ja 104760 <realpath+0x410> <== NOT EXECUTED
1043e8: 84 c0 test %al,%al <== NOT EXECUTED
1043ea: 0f 85 70 03 00 00 jne 104760 <realpath+0x410> <== NOT EXECUTED
}
/*
* Iterate over path components in `left'.
*/
while (left_len != 0) {
1043f0: 85 f6 test %esi,%esi <== NOT EXECUTED
1043f2: 0f 84 76 01 00 00 je 10456e <realpath+0x21e> <== NOT EXECUTED
symlinks = 0;
1043f8: 31 c0 xor %eax,%eax <== NOT EXECUTED
1043fa: 89 85 70 fc ff ff mov %eax,-0x390(%ebp) <== NOT EXECUTED
/*
* Extract the next path component and adjust `left'
* and its length.
*/
p = strchr(left, '/');
104400: b8 2f 00 00 00 mov $0x2f,%eax <== NOT EXECUTED
104405: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
104409: 8b 85 7c fc ff ff mov -0x384(%ebp),%eax <== NOT EXECUTED
10440f: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
104412: e8 49 56 06 00 call 169a60 <strchr> <== NOT EXECUTED
s = p ? p : left + left_len;
104417: 85 c0 test %eax,%eax <== NOT EXECUTED
p = strchr(left, '/');
104419: 89 c2 mov %eax,%edx <== NOT EXECUTED
s = p ? p : left + left_len;
10441b: 0f 84 3f 02 00 00 je 104660 <realpath+0x310> <== NOT EXECUTED
if (s - left >= sizeof(next_token)) {
104421: 8b bd 7c fc ff ff mov -0x384(%ebp),%edi <== NOT EXECUTED
104427: 29 f8 sub %edi,%eax <== NOT EXECUTED
104429: 3d fe 00 00 00 cmp $0xfe,%eax <== NOT EXECUTED
10442e: 0f 87 2c 03 00 00 ja 104760 <realpath+0x410> <== NOT EXECUTED
if (m)
free(resolved);
errno = ENAMETOOLONG;
return (NULL);
}
memcpy(next_token, left, s - left);
104434: 8b b5 7c fc ff ff mov -0x384(%ebp),%esi <== NOT EXECUTED
10443a: 8d bd ea fd ff ff lea -0x216(%ebp),%edi <== NOT EXECUTED
104440: 83 f8 08 cmp $0x8,%eax <== NOT EXECUTED
104443: 89 85 78 fc ff ff mov %eax,-0x388(%ebp) <== NOT EXECUTED
104449: 0f 83 61 02 00 00 jae 1046b0 <realpath+0x360> <== NOT EXECUTED
10444f: 8b 8d 78 fc ff ff mov -0x388(%ebp),%ecx <== NOT EXECUTED
104455: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED
next_token[s - left] = '\0';
104457: 31 c9 xor %ecx,%ecx <== NOT EXECUTED
104459: 88 8c 05 ea fd ff ff mov %cl,-0x216(%ebp,%eax,1) <== NOT EXECUTED
left_len -= s - left;
if (p != NULL)
memmove(left, s + 1, left_len + 1);
104460: 89 95 78 fc ff ff mov %edx,-0x388(%ebp) <== NOT EXECUTED
left_len -= s - left;
104466: 29 85 84 fc ff ff sub %eax,-0x37c(%ebp) <== NOT EXECUTED
10446c: 8b 8d 84 fc ff ff mov -0x37c(%ebp),%ecx <== NOT EXECUTED
memmove(left, s + 1, left_len + 1);
104472: 8d 41 01 lea 0x1(%ecx),%eax <== NOT EXECUTED
104475: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
104479: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED
10447c: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
104480: 8b 85 7c fc ff ff mov -0x384(%ebp),%eax <== NOT EXECUTED
104486: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
104489: e8 42 a8 05 00 call 15ecd0 <memmove> <== NOT EXECUTED
10448e: 8b 95 78 fc ff ff mov -0x388(%ebp),%edx <== NOT EXECUTED
if (resolved[resolved_len - 1] != '/') {
104494: 8b 85 80 fc ff ff mov -0x380(%ebp),%eax <== NOT EXECUTED
10449a: 80 7c 03 ff 2f cmpb $0x2f,-0x1(%ebx,%eax,1) <== NOT EXECUTED
10449f: 74 20 je 1044c1 <realpath+0x171> <== NOT EXECUTED
if (resolved_len + 1 >= PATH_MAX) {
1044a1: 40 inc %eax <== NOT EXECUTED
1044a2: 3d fe 00 00 00 cmp $0xfe,%eax <== NOT EXECUTED
1044a7: 0f 87 b3 02 00 00 ja 104760 <realpath+0x410> <== NOT EXECUTED
if (m)
free(resolved);
errno = ENAMETOOLONG;
return (NULL);
}
resolved[resolved_len++] = '/';
1044ad: 8b bd 80 fc ff ff mov -0x380(%ebp),%edi <== NOT EXECUTED
resolved[resolved_len] = '\0';
1044b3: 89 85 80 fc ff ff mov %eax,-0x380(%ebp) <== NOT EXECUTED
resolved[resolved_len++] = '/';
1044b9: c6 04 3b 2f movb $0x2f,(%ebx,%edi,1) <== NOT EXECUTED
resolved[resolved_len] = '\0';
1044bd: c6 04 03 00 movb $0x0,(%ebx,%eax,1) <== NOT EXECUTED
}
if (next_token[0] == '\0') {
1044c1: 80 bd ea fd ff ff 00 cmpb $0x0,-0x216(%ebp) <== NOT EXECUTED
1044c8: 0f 84 32 01 00 00 je 104600 <realpath+0x2b0> <== NOT EXECUTED
errno = ENOTDIR;
return (NULL);
}
continue;
}
else if (strcmp(next_token, ".") == 0)
1044ce: 0f b7 85 ea fd ff ff movzwl -0x216(%ebp),%eax <== NOT EXECUTED
1044d5: 83 f8 2e cmp $0x2e,%eax <== NOT EXECUTED
1044d8: 0f 84 82 00 00 00 je 104560 <realpath+0x210> <== NOT EXECUTED
continue;
else if (strcmp(next_token, "..") == 0) {
1044de: 3d 2e 2e 00 00 cmp $0x2e2e,%eax <== NOT EXECUTED
1044e3: 0f 84 f7 01 00 00 je 1046e0 <realpath+0x390> <== NOT EXECUTED
}
/*
* Append the next path component and lstat() it.
*/
resolved_len = strlcat(resolved, next_token, PATH_MAX);
1044e9: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
1044ec: 8d 85 ea fd ff ff lea -0x216(%ebp),%eax <== NOT EXECUTED
1044f2: be ff 00 00 00 mov $0xff,%esi <== NOT EXECUTED
1044f7: 89 74 24 08 mov %esi,0x8(%esp) <== NOT EXECUTED
1044fb: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1044ff: 89 95 78 fc ff ff mov %edx,-0x388(%ebp) <== NOT EXECUTED
104505: e8 56 5b 06 00 call 16a060 <strlcat> <== NOT EXECUTED
if (resolved_len >= PATH_MAX) {
10450a: 8b 95 78 fc ff ff mov -0x388(%ebp),%edx <== NOT EXECUTED
resolved_len = strlcat(resolved, next_token, PATH_MAX);
104510: 89 85 80 fc ff ff mov %eax,-0x380(%ebp) <== NOT EXECUTED
if (resolved_len >= PATH_MAX) {
104516: 3d fe 00 00 00 cmp $0xfe,%eax <== NOT EXECUTED
10451b: 0f 87 3f 02 00 00 ja 104760 <realpath+0x410> <== NOT EXECUTED
if (m)
free(resolved);
errno = ENAMETOOLONG;
return (NULL);
}
if (lstat(resolved, &sb) != 0) {
104521: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
104524: 8d 85 90 fc ff ff lea -0x370(%ebp),%eax <== NOT EXECUTED
10452a: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
10452e: 89 95 78 fc ff ff mov %edx,-0x388(%ebp) <== NOT EXECUTED
104534: e8 a7 e0 ff ff call 1025e0 <lstat> <== NOT EXECUTED
104539: 8b 95 78 fc ff ff mov -0x388(%ebp),%edx <== NOT EXECUTED
10453f: 85 c0 test %eax,%eax <== NOT EXECUTED
104541: 0f 85 89 04 00 00 jne 1049d0 <realpath+0x680> <== NOT EXECUTED
if (m)
free(resolved);
return (NULL);
}
if (S_ISLNK(sb.st_mode)) {
104547: 8b 85 a0 fc ff ff mov -0x360(%ebp),%eax <== NOT EXECUTED
10454d: 25 00 f0 00 00 and $0xf000,%eax <== NOT EXECUTED
104552: 3d 00 a0 00 00 cmp $0xa000,%eax <== NOT EXECUTED
104557: 0f 84 33 02 00 00 je 104790 <realpath+0x440> <== NOT EXECUTED
10455d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
while (left_len != 0) {
104560: 8b b5 84 fc ff ff mov -0x37c(%ebp),%esi <== NOT EXECUTED
104566: 85 f6 test %esi,%esi <== NOT EXECUTED
104568: 0f 85 92 fe ff ff jne 104400 <realpath+0xb0> <== NOT EXECUTED
/*
* Remove trailing slash except when the resolved pathname
* is a single "/".
*/
if (resolved_len > 1 && resolved[resolved_len - 1] == '/')
10456e: 8b b5 80 fc ff ff mov -0x380(%ebp),%esi <== NOT EXECUTED
104574: 89 d8 mov %ebx,%eax <== NOT EXECUTED
104576: 83 fe 01 cmp $0x1,%esi <== NOT EXECUTED
104579: 76 0c jbe 104587 <realpath+0x237> <== NOT EXECUTED
10457b: 8d 54 33 ff lea -0x1(%ebx,%esi,1),%edx <== NOT EXECUTED
10457f: 80 3a 2f cmpb $0x2f,(%edx) <== NOT EXECUTED
104582: 75 03 jne 104587 <realpath+0x237> <== NOT EXECUTED
resolved[resolved_len - 1] = '\0';
104584: c6 02 00 movb $0x0,(%edx) <== NOT EXECUTED
return (resolved);
}
104587: 81 c4 9c 03 00 00 add $0x39c,%esp <== NOT EXECUTED
10458d: 5b pop %ebx <== NOT EXECUTED
10458e: 5e pop %esi <== NOT EXECUTED
10458f: 5f pop %edi <== NOT EXECUTED
104590: 5d pop %ebp <== NOT EXECUTED
104591: c3 ret <== NOT EXECUTED
104592: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
104599: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
if (getcwd(resolved, PATH_MAX) == NULL) {
1045a0: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
1045a3: b9 ff 00 00 00 mov $0xff,%ecx <== NOT EXECUTED
1045a8: 89 4c 24 04 mov %ecx,0x4(%esp) <== NOT EXECUTED
1045ac: e8 8f 89 05 00 call 15cf40 <getcwd> <== NOT EXECUTED
1045b1: 85 c0 test %eax,%eax <== NOT EXECUTED
1045b3: 0f 84 67 03 00 00 je 104920 <realpath+0x5d0> <== NOT EXECUTED
resolved_len = strlen(resolved);
1045b9: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
left_len = strlcpy(left, path, sizeof(left));
1045bc: 8d bd eb fc ff ff lea -0x315(%ebp),%edi <== NOT EXECUTED
resolved_len = strlen(resolved);
1045c2: e8 79 5b 06 00 call 16a140 <strlen> <== NOT EXECUTED
left_len = strlcpy(left, path, sizeof(left));
1045c7: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED
1045cb: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
1045ce: 89 bd 7c fc ff ff mov %edi,-0x384(%ebp) <== NOT EXECUTED
resolved_len = strlen(resolved);
1045d4: 89 85 80 fc ff ff mov %eax,-0x380(%ebp) <== NOT EXECUTED
left_len = strlcpy(left, path, sizeof(left));
1045da: b8 ff 00 00 00 mov $0xff,%eax <== NOT EXECUTED
1045df: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
1045e3: e8 f8 5a 06 00 call 16a0e0 <strlcpy> <== NOT EXECUTED
if (left_len >= sizeof(left) || resolved_len >= PATH_MAX) {
1045e8: 81 bd 80 fc ff ff fe cmpl $0xfe,-0x380(%ebp) <== NOT EXECUTED
1045ef: 00 00 00
left_len = strlcpy(left, path, sizeof(left));
1045f2: 89 85 84 fc ff ff mov %eax,-0x37c(%ebp) <== NOT EXECUTED
if (left_len >= sizeof(left) || resolved_len >= PATH_MAX) {
1045f8: 0f 97 c0 seta %al <== NOT EXECUTED
1045fb: e9 d6 fd ff ff jmp 1043d6 <realpath+0x86> <== NOT EXECUTED
if (lstat(resolved, &sb) != 0) {
104600: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
104603: 8d 85 90 fc ff ff lea -0x370(%ebp),%eax <== NOT EXECUTED
104609: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
10460d: e8 ce df ff ff call 1025e0 <lstat> <== NOT EXECUTED
104612: 85 c0 test %eax,%eax <== NOT EXECUTED
104614: 0f 85 b6 03 00 00 jne 1049d0 <realpath+0x680> <== NOT EXECUTED
if (!S_ISDIR(sb.st_mode)) {
10461a: 8b 85 a0 fc ff ff mov -0x360(%ebp),%eax <== NOT EXECUTED
104620: 25 00 f0 00 00 and $0xf000,%eax <== NOT EXECUTED
104625: 3d 00 40 00 00 cmp $0x4000,%eax <== NOT EXECUTED
10462a: 0f 84 30 ff ff ff je 104560 <realpath+0x210> <== NOT EXECUTED
if (m)
104630: 8b bd 74 fc ff ff mov -0x38c(%ebp),%edi <== NOT EXECUTED
104636: 85 ff test %edi,%edi <== NOT EXECUTED
104638: 0f 85 b2 02 00 00 jne 1048f0 <realpath+0x5a0> <== NOT EXECUTED
errno = ENOTDIR;
10463e: e8 ad 4b 05 00 call 1591f0 <__errno> <== NOT EXECUTED
104643: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED
}
104649: 81 c4 9c 03 00 00 add $0x39c,%esp <== NOT EXECUTED
return (NULL);
10464f: 31 c0 xor %eax,%eax <== NOT EXECUTED
}
104651: 5b pop %ebx <== NOT EXECUTED
104652: 5e pop %esi <== NOT EXECUTED
104653: 5f pop %edi <== NOT EXECUTED
104654: 5d pop %ebp <== NOT EXECUTED
104655: c3 ret <== NOT EXECUTED
104656: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10465d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
if (s - left >= sizeof(next_token)) {
104660: 81 bd 84 fc ff ff fe cmpl $0xfe,-0x37c(%ebp) <== NOT EXECUTED
104667: 00 00 00
10466a: 0f 87 f0 00 00 00 ja 104760 <realpath+0x410> <== NOT EXECUTED
memcpy(next_token, left, s - left);
104670: 8b 85 84 fc ff ff mov -0x37c(%ebp),%eax <== NOT EXECUTED
104676: 8d bd ea fd ff ff lea -0x216(%ebp),%edi <== NOT EXECUTED
10467c: 8b b5 7c fc ff ff mov -0x384(%ebp),%esi <== NOT EXECUTED
104682: 83 f8 08 cmp $0x8,%eax <== NOT EXECUTED
104685: 89 c1 mov %eax,%ecx <== NOT EXECUTED
104687: 0f 83 a3 00 00 00 jae 104730 <realpath+0x3e0> <== NOT EXECUTED
10468d: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED
next_token[s - left] = '\0';
10468f: 31 c9 xor %ecx,%ecx <== NOT EXECUTED
left_len -= s - left;
104691: 31 f6 xor %esi,%esi <== NOT EXECUTED
next_token[s - left] = '\0';
104693: 8b 85 84 fc ff ff mov -0x37c(%ebp),%eax <== NOT EXECUTED
left_len -= s - left;
104699: 89 b5 84 fc ff ff mov %esi,-0x37c(%ebp) <== NOT EXECUTED
next_token[s - left] = '\0';
10469f: 88 8c 05 ea fd ff ff mov %cl,-0x216(%ebp,%eax,1) <== NOT EXECUTED
if (p != NULL)
1046a6: e9 e9 fd ff ff jmp 104494 <realpath+0x144> <== NOT EXECUTED
1046ab: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1046af: 90 nop <== NOT EXECUTED
memcpy(next_token, left, s - left);
1046b0: b9 02 00 00 00 mov $0x2,%ecx <== NOT EXECUTED
1046b5: 85 c9 test %ecx,%ecx <== NOT EXECUTED
1046b7: 0f 85 c3 02 00 00 jne 104980 <realpath+0x630> <== NOT EXECUTED
1046bd: f7 c7 04 00 00 00 test $0x4,%edi <== NOT EXECUTED
1046c3: 0f 84 86 fd ff ff je 10444f <realpath+0xff> <== NOT EXECUTED
1046c9: 8b 0e mov (%esi),%ecx <== NOT EXECUTED
1046cb: 83 c7 04 add $0x4,%edi <== NOT EXECUTED
1046ce: 83 c6 04 add $0x4,%esi <== NOT EXECUTED
1046d1: 89 4f fc mov %ecx,-0x4(%edi) <== NOT EXECUTED
1046d4: 83 ad 78 fc ff ff 04 subl $0x4,-0x388(%ebp) <== NOT EXECUTED
1046db: e9 6f fd ff ff jmp 10444f <realpath+0xff> <== NOT EXECUTED
else if (strcmp(next_token, "..") == 0) {
1046e0: 80 bd ec fd ff ff 00 cmpb $0x0,-0x214(%ebp) <== NOT EXECUTED
1046e7: 0f 85 fc fd ff ff jne 1044e9 <realpath+0x199> <== NOT EXECUTED
if (resolved_len > 1) {
1046ed: 83 bd 80 fc ff ff 01 cmpl $0x1,-0x380(%ebp) <== NOT EXECUTED
1046f4: 0f 86 66 fe ff ff jbe 104560 <realpath+0x210> <== NOT EXECUTED
resolved[resolved_len - 1] = '\0';
1046fa: 8b 85 80 fc ff ff mov -0x380(%ebp),%eax <== NOT EXECUTED
q = strrchr(resolved, '/') + 1;
104700: b9 2f 00 00 00 mov $0x2f,%ecx <== NOT EXECUTED
resolved[resolved_len - 1] = '\0';
104705: c6 44 03 ff 00 movb $0x0,-0x1(%ebx,%eax,1) <== NOT EXECUTED
q = strrchr(resolved, '/') + 1;
10470a: 89 4c 24 04 mov %ecx,0x4(%esp) <== NOT EXECUTED
10470e: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
104711: e8 2a 69 06 00 call 16b040 <strrchr> <== NOT EXECUTED
*q = '\0';
104716: c6 40 01 00 movb $0x0,0x1(%eax) <== NOT EXECUTED
q = strrchr(resolved, '/') + 1;
10471a: 40 inc %eax <== NOT EXECUTED
resolved_len = q - resolved;
10471b: 29 d8 sub %ebx,%eax <== NOT EXECUTED
10471d: 89 85 80 fc ff ff mov %eax,-0x380(%ebp) <== NOT EXECUTED
104723: e9 38 fe ff ff jmp 104560 <realpath+0x210> <== NOT EXECUTED
104728: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10472f: 90 nop <== NOT EXECUTED
memcpy(next_token, left, s - left);
104730: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED
104735: 85 c0 test %eax,%eax <== NOT EXECUTED
104737: 0f 85 b3 02 00 00 jne 1049f0 <realpath+0x6a0> <== NOT EXECUTED
10473d: f7 c7 04 00 00 00 test $0x4,%edi <== NOT EXECUTED
104743: 0f 84 44 ff ff ff je 10468d <realpath+0x33d> <== NOT EXECUTED
104749: 8b 06 mov (%esi),%eax <== NOT EXECUTED
10474b: 83 c7 04 add $0x4,%edi <== NOT EXECUTED
10474e: 83 c6 04 add $0x4,%esi <== NOT EXECUTED
104751: 83 e9 04 sub $0x4,%ecx <== NOT EXECUTED
104754: 89 47 fc mov %eax,-0x4(%edi) <== NOT EXECUTED
104757: e9 31 ff ff ff jmp 10468d <realpath+0x33d> <== NOT EXECUTED
10475c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
if (m)
104760: 8b 85 74 fc ff ff mov -0x38c(%ebp),%eax <== NOT EXECUTED
104766: 85 c0 test %eax,%eax <== NOT EXECUTED
104768: 0f 85 d2 01 00 00 jne 104940 <realpath+0x5f0> <== NOT EXECUTED
errno = ENAMETOOLONG;
10476e: e8 7d 4a 05 00 call 1591f0 <__errno> <== NOT EXECUTED
104773: c7 00 5b 00 00 00 movl $0x5b,(%eax) <== NOT EXECUTED
}
104779: 81 c4 9c 03 00 00 add $0x39c,%esp <== NOT EXECUTED
return (NULL);
10477f: 31 c0 xor %eax,%eax <== NOT EXECUTED
}
104781: 5b pop %ebx <== NOT EXECUTED
104782: 5e pop %esi <== NOT EXECUTED
104783: 5f pop %edi <== NOT EXECUTED
104784: 5d pop %ebp <== NOT EXECUTED
104785: c3 ret <== NOT EXECUTED
104786: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10478d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
if (symlinks++ > MAXSYMLINKS) {
104790: 8b 85 70 fc ff ff mov -0x390(%ebp),%eax <== NOT EXECUTED
104796: 8d 78 01 lea 0x1(%eax),%edi <== NOT EXECUTED
104799: 83 f8 20 cmp $0x20,%eax <== NOT EXECUTED
10479c: 0f 87 6c 02 00 00 ja 104a0e <realpath+0x6be> <== NOT EXECUTED
slen = readlink(resolved, symlink, sizeof(symlink) - 1);
1047a2: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
1047a5: 8d b5 e9 fe ff ff lea -0x117(%ebp),%esi <== NOT EXECUTED
1047ab: b8 fe 00 00 00 mov $0xfe,%eax <== NOT EXECUTED
1047b0: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
1047b4: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED
1047b8: 89 95 84 fc ff ff mov %edx,-0x37c(%ebp) <== NOT EXECUTED
1047be: e8 3d f9 ff ff call 104100 <readlink> <== NOT EXECUTED
if (slen < 0) {
1047c3: 8b 95 84 fc ff ff mov -0x37c(%ebp),%edx <== NOT EXECUTED
1047c9: 85 c0 test %eax,%eax <== NOT EXECUTED
slen = readlink(resolved, symlink, sizeof(symlink) - 1);
1047cb: 89 c1 mov %eax,%ecx <== NOT EXECUTED
if (slen < 0) {
1047cd: 0f 88 fd 01 00 00 js 1049d0 <realpath+0x680> <== NOT EXECUTED
symlink[slen] = '\0';
1047d3: 31 c0 xor %eax,%eax <== NOT EXECUTED
1047d5: 88 84 0d e9 fe ff ff mov %al,-0x117(%ebp,%ecx,1) <== NOT EXECUTED
if (symlink[0] == '/') {
1047dc: 80 bd e9 fe ff ff 2f cmpb $0x2f,-0x117(%ebp) <== NOT EXECUTED
1047e3: 0f 84 67 01 00 00 je 104950 <realpath+0x600> <== NOT EXECUTED
} else if (resolved_len > 1) {
1047e9: 8b 85 80 fc ff ff mov -0x380(%ebp),%eax <== NOT EXECUTED
1047ef: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED
1047f2: 76 3b jbe 10482f <realpath+0x4df> <== NOT EXECUTED
resolved[resolved_len - 1] = '\0';
1047f4: c6 44 03 ff 00 movb $0x0,-0x1(%ebx,%eax,1) <== NOT EXECUTED
q = strrchr(resolved, '/') + 1;
1047f9: b8 2f 00 00 00 mov $0x2f,%eax <== NOT EXECUTED
1047fe: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
104802: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
104805: 89 8d 78 fc ff ff mov %ecx,-0x388(%ebp) <== NOT EXECUTED
10480b: 89 95 84 fc ff ff mov %edx,-0x37c(%ebp) <== NOT EXECUTED
104811: e8 2a 68 06 00 call 16b040 <strrchr> <== NOT EXECUTED
resolved_len = q - resolved;
104816: 8b 8d 78 fc ff ff mov -0x388(%ebp),%ecx <== NOT EXECUTED
10481c: 8b 95 84 fc ff ff mov -0x37c(%ebp),%edx <== NOT EXECUTED
*q = '\0';
104822: c6 40 01 00 movb $0x0,0x1(%eax) <== NOT EXECUTED
q = strrchr(resolved, '/') + 1;
104826: 40 inc %eax <== NOT EXECUTED
resolved_len = q - resolved;
104827: 29 d8 sub %ebx,%eax <== NOT EXECUTED
104829: 89 85 80 fc ff ff mov %eax,-0x380(%ebp) <== NOT EXECUTED
if (p != NULL) {
10482f: 85 d2 test %edx,%edx <== NOT EXECUTED
104831: 74 50 je 104883 <realpath+0x533> <== NOT EXECUTED
if (symlink[slen - 1] != '/') {
104833: 80 bc 0d e8 fe ff ff cmpb $0x2f,-0x118(%ebp,%ecx,1) <== NOT EXECUTED
10483a: 2f
10483b: 74 20 je 10485d <realpath+0x50d> <== NOT EXECUTED
if (slen + 1 >= sizeof(symlink)) {
10483d: 8d 41 01 lea 0x1(%ecx),%eax <== NOT EXECUTED
104840: 3d fe 00 00 00 cmp $0xfe,%eax <== NOT EXECUTED
104845: 0f 8f 15 ff ff ff jg 104760 <realpath+0x410> <== NOT EXECUTED
symlink[slen] = '/';
10484b: b2 2f mov $0x2f,%dl <== NOT EXECUTED
10484d: 88 94 0d e9 fe ff ff mov %dl,-0x117(%ebp,%ecx,1) <== NOT EXECUTED
symlink[slen + 1] = 0;
104854: 31 c9 xor %ecx,%ecx <== NOT EXECUTED
104856: 88 8c 05 e9 fe ff ff mov %cl,-0x117(%ebp,%eax,1) <== NOT EXECUTED
left_len = strlcat(symlink, left,
10485d: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
104860: b8 ff 00 00 00 mov $0xff,%eax <== NOT EXECUTED
104865: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
104869: 8b 85 7c fc ff ff mov -0x384(%ebp),%eax <== NOT EXECUTED
10486f: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
104873: e8 e8 57 06 00 call 16a060 <strlcat> <== NOT EXECUTED
if (left_len >= sizeof(left)) {
104878: 3d fe 00 00 00 cmp $0xfe,%eax <== NOT EXECUTED
10487d: 0f 87 dd fe ff ff ja 104760 <realpath+0x410> <== NOT EXECUTED
left_len = strlcpy(left, symlink, sizeof(left));
104883: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED
104887: b8 ff 00 00 00 mov $0xff,%eax <== NOT EXECUTED
10488c: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
104890: 8b 85 7c fc ff ff mov -0x384(%ebp),%eax <== NOT EXECUTED
104896: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
104899: e8 42 58 06 00 call 16a0e0 <strlcpy> <== NOT EXECUTED
if (symlinks++ > MAXSYMLINKS) {
10489e: 89 bd 70 fc ff ff mov %edi,-0x390(%ebp) <== NOT EXECUTED
left_len = strlcpy(left, symlink, sizeof(left));
1048a4: 89 85 84 fc ff ff mov %eax,-0x37c(%ebp) <== NOT EXECUTED
1048aa: e9 b1 fc ff ff jmp 104560 <realpath+0x210> <== NOT EXECUTED
1048af: 90 nop <== NOT EXECUTED
resolved = malloc(PATH_MAX);
1048b0: c7 04 24 ff 00 00 00 movl $0xff,(%esp) <== NOT EXECUTED
1048b7: 88 95 84 fc ff ff mov %dl,-0x37c(%ebp) <== NOT EXECUTED
1048bd: e8 2e de ff ff call 1026f0 <malloc> <== NOT EXECUTED
if (resolved == NULL)
1048c2: 0f b6 95 84 fc ff ff movzbl -0x37c(%ebp),%edx <== NOT EXECUTED
1048c9: 85 c0 test %eax,%eax <== NOT EXECUTED
resolved = malloc(PATH_MAX);
1048cb: 89 c3 mov %eax,%ebx <== NOT EXECUTED
if (resolved == NULL)
1048cd: 0f 84 a6 fe ff ff je 104779 <realpath+0x429> <== NOT EXECUTED
m = 1;
1048d3: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED
1048d8: 89 8d 74 fc ff ff mov %ecx,-0x38c(%ebp) <== NOT EXECUTED
1048de: e9 a2 fa ff ff jmp 104385 <realpath+0x35> <== NOT EXECUTED
1048e3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1048ea: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
free(resolved);
1048f0: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
1048f3: e8 68 ce ff ff call 101760 <free> <== NOT EXECUTED
1048f8: e9 41 fd ff ff jmp 10463e <realpath+0x2ee> <== NOT EXECUTED
1048fd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
errno = ENOENT;
104900: e8 eb 48 05 00 call 1591f0 <__errno> <== NOT EXECUTED
104905: c7 00 02 00 00 00 movl $0x2,(%eax) <== NOT EXECUTED
return (NULL);
10490b: 31 c0 xor %eax,%eax <== NOT EXECUTED
10490d: e9 75 fc ff ff jmp 104587 <realpath+0x237> <== NOT EXECUTED
104912: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
104919: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
if (m)
104920: 8b 95 74 fc ff ff mov -0x38c(%ebp),%edx <== NOT EXECUTED
104926: 85 d2 test %edx,%edx <== NOT EXECUTED
104928: 75 3a jne 104964 <realpath+0x614> <== NOT EXECUTED
resolved[0] = '.';
10492a: 66 c7 03 2e 00 movw $0x2e,(%ebx) <== NOT EXECUTED
10492f: e9 53 fc ff ff jmp 104587 <realpath+0x237> <== NOT EXECUTED
104934: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10493b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10493f: 90 nop <== NOT EXECUTED
free(resolved);
104940: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
104943: e8 18 ce ff ff call 101760 <free> <== NOT EXECUTED
104948: e9 21 fe ff ff jmp 10476e <realpath+0x41e> <== NOT EXECUTED
10494d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
resolved[1] = 0;
104950: c6 43 01 00 movb $0x0,0x1(%ebx) <== NOT EXECUTED
resolved_len = 1;
104954: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
104959: 89 85 80 fc ff ff mov %eax,-0x380(%ebp) <== NOT EXECUTED
10495f: e9 cb fe ff ff jmp 10482f <realpath+0x4df> <== NOT EXECUTED
free(resolved);
104964: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
104967: 89 85 84 fc ff ff mov %eax,-0x37c(%ebp) <== NOT EXECUTED
10496d: e8 ee cd ff ff call 101760 <free> <== NOT EXECUTED
104972: 8b 85 84 fc ff ff mov -0x37c(%ebp),%eax <== NOT EXECUTED
104978: e9 0a fc ff ff jmp 104587 <realpath+0x237> <== NOT EXECUTED
10497d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
memcpy(next_token, left, s - left);
104980: 0f b7 0e movzwl (%esi),%ecx <== NOT EXECUTED
104983: 8d bd ec fd ff ff lea -0x214(%ebp),%edi <== NOT EXECUTED
104989: 8d b5 ed fc ff ff lea -0x313(%ebp),%esi <== NOT EXECUTED
10498f: 66 89 8d ea fd ff ff mov %cx,-0x216(%ebp) <== NOT EXECUTED
104996: 8d 48 fe lea -0x2(%eax),%ecx <== NOT EXECUTED
104999: 89 8d 78 fc ff ff mov %ecx,-0x388(%ebp) <== NOT EXECUTED
10499f: e9 19 fd ff ff jmp 1046bd <realpath+0x36d> <== NOT EXECUTED
1049a4: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1049ab: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1049af: 90 nop <== NOT EXECUTED
errno = EINVAL;
1049b0: e8 3b 48 05 00 call 1591f0 <__errno> <== NOT EXECUTED
1049b5: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
return (NULL);
1049bb: 31 c0 xor %eax,%eax <== NOT EXECUTED
1049bd: e9 c5 fb ff ff jmp 104587 <realpath+0x237> <== NOT EXECUTED
1049c2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1049c9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
if (m)
1049d0: 8b 85 74 fc ff ff mov -0x38c(%ebp),%eax <== NOT EXECUTED
1049d6: 85 c0 test %eax,%eax <== NOT EXECUTED
1049d8: 0f 84 9b fd ff ff je 104779 <realpath+0x429> <== NOT EXECUTED
free(resolved);
1049de: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
1049e1: e8 7a cd ff ff call 101760 <free> <== NOT EXECUTED
return (NULL);
1049e6: 31 c0 xor %eax,%eax <== NOT EXECUTED
1049e8: e9 9a fb ff ff jmp 104587 <realpath+0x237> <== NOT EXECUTED
1049ed: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
memcpy(next_token, left, s - left);
1049f0: 0f b7 06 movzwl (%esi),%eax <== NOT EXECUTED
1049f3: 8d bd ec fd ff ff lea -0x214(%ebp),%edi <== NOT EXECUTED
1049f9: 8d b5 ed fc ff ff lea -0x313(%ebp),%esi <== NOT EXECUTED
1049ff: 8d 49 fe lea -0x2(%ecx),%ecx <== NOT EXECUTED
104a02: 66 89 85 ea fd ff ff mov %ax,-0x216(%ebp) <== NOT EXECUTED
104a09: e9 2f fd ff ff jmp 10473d <realpath+0x3ed> <== NOT EXECUTED
if (m)
104a0e: 8b 95 74 fc ff ff mov -0x38c(%ebp),%edx <== NOT EXECUTED
104a14: 85 d2 test %edx,%edx <== NOT EXECUTED
104a16: 75 12 jne 104a2a <realpath+0x6da> <== NOT EXECUTED
errno = ELOOP;
104a18: e8 d3 47 05 00 call 1591f0 <__errno> <== NOT EXECUTED
104a1d: c7 00 5c 00 00 00 movl $0x5c,(%eax) <== NOT EXECUTED
return (NULL);
104a23: 31 c0 xor %eax,%eax <== NOT EXECUTED
104a25: e9 5d fb ff ff jmp 104587 <realpath+0x237> <== NOT EXECUTED
free(resolved);
104a2a: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
104a2d: e8 2e cd ff ff call 101760 <free> <== NOT EXECUTED
104a32: eb e4 jmp 104a18 <realpath+0x6c8> <== NOT EXECUTED
104a34: 90 nop
104a35: 90 nop
104a36: 90 nop
104a37: 90 nop
104a38: 90 nop
104a39: 90 nop
104a3a: 90 nop
104a3b: 90 nop
104a3c: 90 nop
104a3d: 90 nop
104a3e: 90 nop
104a3f: 90 nop
0011e660 <rtems_assoc_32_to_string>:
const rtems_assoc_32_pair *pairs,
size_t pair_count,
const char *separator,
const char *fallback
)
{
11e660: 55 push %ebp
11e661: 89 e5 mov %esp,%ebp
11e663: 57 push %edi
11e664: 56 push %esi
11e665: 31 f6 xor %esi,%esi
11e667: 53 push %ebx
11e668: 31 db xor %ebx,%ebx
11e66a: 83 ec 3c sub $0x3c,%esp
11e66d: 8b 45 08 mov 0x8(%ebp),%eax
11e670: 8b 4d 1c mov 0x1c(%ebp),%ecx
11e673: 8b 7d 14 mov 0x14(%ebp),%edi
11e676: 89 45 e0 mov %eax,-0x20(%ebp)
11e679: 8b 45 0c mov 0xc(%ebp),%eax
11e67c: 89 4d d4 mov %ecx,-0x2c(%ebp)
11e67f: 8b 4d 20 mov 0x20(%ebp),%ecx
11e682: 89 45 e4 mov %eax,-0x1c(%ebp)
11e685: 8b 45 10 mov 0x10(%ebp),%eax
11e688: 89 4d d0 mov %ecx,-0x30(%ebp)
11e68b: 89 45 d8 mov %eax,-0x28(%ebp)
11e68e: 8b 45 18 mov 0x18(%ebp),%eax
11e691: 89 45 dc mov %eax,-0x24(%ebp)
size_t len;
size_t i;
len = 0;
for ( i = 0; i < pair_count ; ++i ) {
11e694: 85 c0 test %eax,%eax
11e696: 0f 84 84 00 00 00 je 11e720 <rtems_assoc_32_to_string+0xc0> <== NEVER TAKEN
11e69c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
const rtems_assoc_32_pair *p;
p = &pairs[ i ];
if ( ( value & p->bits ) != 0 ) {
11e6a0: 8b 45 e0 mov -0x20(%ebp),%eax
11e6a3: 23 04 df and (%edi,%ebx,8),%eax
11e6a6: 74 56 je 11e6fe <rtems_assoc_32_to_string+0x9e>
if ( len > 0 ) {
11e6a8: 85 f6 test %esi,%esi
11e6aa: 8b 45 e4 mov -0x1c(%ebp),%eax
11e6ad: 74 2c je 11e6db <rtems_assoc_32_to_string+0x7b>
if ( len < buffer_size ) {
11e6af: 8b 55 d8 mov -0x28(%ebp),%edx
return 0;
11e6b2: 31 c0 xor %eax,%eax
if ( len < buffer_size ) {
11e6b4: 39 f2 cmp %esi,%edx
11e6b6: 76 04 jbe 11e6bc <rtems_assoc_32_to_string+0x5c>
return buffer_size - len;
11e6b8: 89 d0 mov %edx,%eax
11e6ba: 29 f0 sub %esi,%eax
len += strlcpy( &buffer[ len ], separator, space( buffer_size, len ) );
11e6bc: 89 44 24 08 mov %eax,0x8(%esp)
11e6c0: 8b 45 d4 mov -0x2c(%ebp),%eax
11e6c3: 89 44 24 04 mov %eax,0x4(%esp)
11e6c7: 8b 45 e4 mov -0x1c(%ebp),%eax
11e6ca: 01 f0 add %esi,%eax
11e6cc: 89 04 24 mov %eax,(%esp)
11e6cf: e8 1c 12 00 00 call 11f8f0 <strlcpy>
11e6d4: 01 c6 add %eax,%esi
}
len += strlcpy( &buffer[ len ], p->name, space( buffer_size, len ) );
11e6d6: 8b 45 e4 mov -0x1c(%ebp),%eax
11e6d9: 01 f0 add %esi,%eax
if ( len < buffer_size ) {
11e6db: 8b 55 d8 mov -0x28(%ebp),%edx
return 0;
11e6de: 31 c9 xor %ecx,%ecx
if ( len < buffer_size ) {
11e6e0: 39 d6 cmp %edx,%esi
11e6e2: 73 04 jae 11e6e8 <rtems_assoc_32_to_string+0x88>
return buffer_size - len;
11e6e4: 89 d1 mov %edx,%ecx
11e6e6: 29 f1 sub %esi,%ecx
len += strlcpy( &buffer[ len ], p->name, space( buffer_size, len ) );
11e6e8: 89 4c 24 08 mov %ecx,0x8(%esp)
11e6ec: 8b 4c df 04 mov 0x4(%edi,%ebx,8),%ecx
11e6f0: 89 04 24 mov %eax,(%esp)
11e6f3: 89 4c 24 04 mov %ecx,0x4(%esp)
11e6f7: e8 f4 11 00 00 call 11f8f0 <strlcpy>
11e6fc: 01 c6 add %eax,%esi
for ( i = 0; i < pair_count ; ++i ) {
11e6fe: 43 inc %ebx
11e6ff: 39 5d dc cmp %ebx,-0x24(%ebp)
11e702: 75 9c jne 11e6a0 <rtems_assoc_32_to_string+0x40>
}
}
if ( len == 0 ) {
11e704: 85 f6 test %esi,%esi
11e706: 74 18 je 11e720 <rtems_assoc_32_to_string+0xc0>
len += strlcpy( buffer, fallback, buffer_size );
}
return len;
}
11e708: 83 c4 3c add $0x3c,%esp
11e70b: 89 f0 mov %esi,%eax
11e70d: 5b pop %ebx
11e70e: 5e pop %esi
11e70f: 5f pop %edi
11e710: 5d pop %ebp
11e711: c3 ret
11e712: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11e719: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
len += strlcpy( buffer, fallback, buffer_size );
11e720: 8b 45 d8 mov -0x28(%ebp),%eax
11e723: 89 45 10 mov %eax,0x10(%ebp)
11e726: 8b 45 d0 mov -0x30(%ebp),%eax
11e729: 89 45 0c mov %eax,0xc(%ebp)
11e72c: 8b 45 e4 mov -0x1c(%ebp),%eax
11e72f: 89 45 08 mov %eax,0x8(%ebp)
}
11e732: 83 c4 3c add $0x3c,%esp
11e735: 5b pop %ebx
11e736: 5e pop %esi
11e737: 5f pop %edi
11e738: 5d pop %ebp
len += strlcpy( buffer, fallback, buffer_size );
11e739: e9 b2 11 00 00 jmp 11f8f0 <strlcpy>
11e73e: 90 nop
11e73f: 90 nop
0010ce90 <rtems_assoc_local_by_remote_bitfield>:
uint32_t rtems_assoc_local_by_remote_bitfield(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
10ce90: 55 push %ebp
10ce91: 89 e5 mov %esp,%ebp
10ce93: 57 push %edi
10ce94: bf 20 00 00 00 mov $0x20,%edi
10ce99: 56 push %esi
10ce9a: 53 push %ebx
uint32_t b;
uint32_t local_value = 0;
for (b = 1; b; b <<= 1) {
10ce9b: bb 01 00 00 00 mov $0x1,%ebx
{
10cea0: 83 ec 2c sub $0x2c,%esp
uint32_t local_value = 0;
10cea3: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
{
10ceaa: 8b 75 0c mov 0xc(%ebp),%esi
10cead: eb 06 jmp 10ceb5 <rtems_assoc_local_by_remote_bitfield+0x25>
10ceaf: 90 nop
for (b = 1; b; b <<= 1) {
10ceb0: 01 db add %ebx,%ebx
10ceb2: 4f dec %edi
10ceb3: 74 1b je 10ced0 <rtems_assoc_local_by_remote_bitfield+0x40>
if (b & remote_value)
10ceb5: 85 de test %ebx,%esi
10ceb7: 74 f7 je 10ceb0 <rtems_assoc_local_by_remote_bitfield+0x20>
local_value |= rtems_assoc_local_by_remote(ap, b);
10ceb9: 89 5c 24 04 mov %ebx,0x4(%esp)
10cebd: 8b 45 08 mov 0x8(%ebp),%eax
for (b = 1; b; b <<= 1) {
10cec0: 01 db add %ebx,%ebx
local_value |= rtems_assoc_local_by_remote(ap, b);
10cec2: 89 04 24 mov %eax,(%esp)
10cec5: e8 16 00 00 00 call 10cee0 <rtems_assoc_local_by_remote>
10ceca: 09 45 e4 or %eax,-0x1c(%ebp)
for (b = 1; b; b <<= 1) {
10cecd: 4f dec %edi
10cece: 75 e5 jne 10ceb5 <rtems_assoc_local_by_remote_bitfield+0x25><== ALWAYS TAKEN
}
return local_value;
}
10ced0: 8b 45 e4 mov -0x1c(%ebp),%eax
10ced3: 83 c4 2c add $0x2c,%esp
10ced6: 5b pop %ebx
10ced7: 5e pop %esi
10ced8: 5f pop %edi
10ced9: 5d pop %ebp
10ceda: c3 ret
10cedb: 90 nop
10cedc: 90 nop
10cedd: 90 nop
10cede: 90 nop
10cedf: 90 nop
00101030 <rtems_assoc_name_by_remote_bitfield>:
char *rtems_assoc_name_by_remote_bitfield(
const rtems_assoc_t *ap,
uint32_t value,
char *buffer
)
{
101030: 55 push %ebp
101031: 89 e5 mov %esp,%ebp
101033: 57 push %edi
uint32_t b;
*buffer = 0;
for (b = 1; b; b <<= 1) {
101034: bf 01 00 00 00 mov $0x1,%edi
{
101039: 56 push %esi
*buffer = 0;
10103a: be 20 00 00 00 mov $0x20,%esi
{
10103f: 53 push %ebx
101040: 83 ec 1c sub $0x1c,%esp
101043: 8b 5d 10 mov 0x10(%ebp),%ebx
*buffer = 0;
101046: c6 03 00 movb $0x0,(%ebx)
for (b = 1; b; b <<= 1) {
101049: eb 25 jmp 101070 <rtems_assoc_name_by_remote_bitfield+0x40>
10104b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10104f: 90 nop
if (b & value) {
if (*buffer)
strcat(buffer, " ");
strcat(buffer, rtems_assoc_name_by_remote(ap, b));
101050: 89 7c 24 04 mov %edi,0x4(%esp)
101054: 8b 45 08 mov 0x8(%ebp),%eax
101057: 89 04 24 mov %eax,(%esp)
10105a: e8 41 00 00 00 call 1010a0 <rtems_assoc_name_by_remote>
10105f: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
101062: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
101066: e8 25 81 01 00 call 119190 <strcat> <== NOT EXECUTED
for (b = 1; b; b <<= 1) {
10106b: 01 ff add %edi,%edi
10106d: 4e dec %esi
10106e: 74 20 je 101090 <rtems_assoc_name_by_remote_bitfield+0x60>
if (b & value) {
101070: 85 7d 0c test %edi,0xc(%ebp)
101073: 74 f6 je 10106b <rtems_assoc_name_by_remote_bitfield+0x3b>
if (*buffer)
101075: 80 3b 00 cmpb $0x0,(%ebx)
101078: 74 d6 je 101050 <rtems_assoc_name_by_remote_bitfield+0x20>
strcat(buffer, " ");
10107a: 89 1c 24 mov %ebx,(%esp)
10107d: e8 4e 83 01 00 call 1193d0 <strlen>
101082: 66 c7 04 03 20 00 movw $0x20,(%ebx,%eax,1)
101088: eb c6 jmp 101050 <rtems_assoc_name_by_remote_bitfield+0x20>
10108a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
}
}
return buffer;
}
101090: 83 c4 1c add $0x1c,%esp
101093: 89 d8 mov %ebx,%eax
101095: 5b pop %ebx
101096: 5e pop %esi
101097: 5f pop %edi
101098: 5d pop %ebp
101099: c3 ret
10109a: 90 nop
10109b: 90 nop
10109c: 90 nop
10109d: 90 nop
10109e: 90 nop
10109f: 90 nop
00118fd0 <rtems_assoc_ptr_by_local>:
const rtems_assoc_t *rtems_assoc_ptr_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
118fd0: 55 push %ebp
118fd1: 89 e5 mov %esp,%ebp
118fd3: 57 push %edi
118fd4: 8b 55 0c mov 0xc(%ebp),%edx
118fd7: 56 push %esi
118fd8: 53 push %ebx
118fd9: 8b 5d 08 mov 0x8(%ebp),%ebx
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
118fdc: 8b 03 mov (%ebx),%eax
118fde: 85 c0 test %eax,%eax
118fe0: 74 3d je 11901f <rtems_assoc_ptr_by_local+0x4f>
118fe2: 89 c6 mov %eax,%esi
118fe4: bf 9c 58 12 00 mov $0x12589c,%edi
118fe9: b9 0a 00 00 00 mov $0xa,%ecx
118fee: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi)
118ff0: 0f 97 c0 seta %al
118ff3: 1c 00 sbb $0x0,%al
118ff5: 84 c0 test %al,%al
118ff7: 75 37 jne 119030 <rtems_assoc_ptr_by_local+0x60>
default_ap = ap++;
for ( ; ap->name; ap++)
118ff9: 8b 73 0c mov 0xc(%ebx),%esi
default_ap = ap++;
118ffc: 8d 43 0c lea 0xc(%ebx),%eax
for ( ; ap->name; ap++)
118fff: 85 f6 test %esi,%esi
119001: 75 17 jne 11901a <rtems_assoc_ptr_by_local+0x4a> <== ALWAYS TAKEN
119003: eb 3b jmp 119040 <rtems_assoc_ptr_by_local+0x70> <== NOT EXECUTED
119005: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11900c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
119010: 8b 48 0c mov 0xc(%eax),%ecx
119013: 83 c0 0c add $0xc,%eax
119016: 85 c9 test %ecx,%ecx
119018: 74 26 je 119040 <rtems_assoc_ptr_by_local+0x70>
if (ap->local_value == local_value)
11901a: 39 50 04 cmp %edx,0x4(%eax)
11901d: 75 f1 jne 119010 <rtems_assoc_ptr_by_local+0x40>
return ap;
return default_ap;
}
11901f: 5b pop %ebx
119020: 5e pop %esi
119021: 5f pop %edi
119022: 5d pop %ebp
119023: c3 ret
119024: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11902b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
11902f: 90 nop
119030: 89 d8 mov %ebx,%eax
const rtems_assoc_t *default_ap = 0;
119032: 31 db xor %ebx,%ebx
119034: eb e4 jmp 11901a <rtems_assoc_ptr_by_local+0x4a>
119036: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11903d: 8d 76 00 lea 0x0(%esi),%esi
for ( ; ap->name; ap++)
119040: 89 d8 mov %ebx,%eax
}
119042: 5b pop %ebx
119043: 5e pop %esi
119044: 5f pop %edi
119045: 5d pop %ebp
119046: c3 ret
119047: 90 nop
119048: 90 nop
119049: 90 nop
11904a: 90 nop
11904b: 90 nop
11904c: 90 nop
11904d: 90 nop
11904e: 90 nop
11904f: 90 nop
00101160 <rtems_assoc_ptr_by_name>:
const rtems_assoc_t *rtems_assoc_ptr_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
101160: 55 push %ebp
101161: 89 e5 mov %esp,%ebp
101163: 57 push %edi
101164: 56 push %esi
101165: 53 push %ebx
101166: 83 ec 1c sub $0x1c,%esp
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
101169: 8b 45 08 mov 0x8(%ebp),%eax
{
10116c: 8b 5d 0c mov 0xc(%ebp),%ebx
if (rtems_assoc_is_default(ap))
10116f: 8b 00 mov (%eax),%eax
101171: 85 c0 test %eax,%eax
101173: 74 7b je 1011f0 <rtems_assoc_ptr_by_name+0x90>
101175: bf a8 00 12 00 mov $0x1200a8,%edi
10117a: b9 0a 00 00 00 mov $0xa,%ecx
10117f: 89 c6 mov %eax,%esi
101181: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi)
101183: 0f 97 c2 seta %dl
101186: 80 da 00 sbb $0x0,%dl
101189: 84 d2 test %dl,%dl
10118b: 75 43 jne 1011d0 <rtems_assoc_ptr_by_name+0x70>
default_ap = ap++;
10118d: 8b 45 08 mov 0x8(%ebp),%eax
101190: 8d 70 0c lea 0xc(%eax),%esi
for ( ; ap->name; ap++)
101193: 8b 40 0c mov 0xc(%eax),%eax
101196: 85 c0 test %eax,%eax
101198: 75 10 jne 1011aa <rtems_assoc_ptr_by_name+0x4a> <== ALWAYS TAKEN
10119a: eb 44 jmp 1011e0 <rtems_assoc_ptr_by_name+0x80> <== NOT EXECUTED
10119c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1011a0: 8b 46 0c mov 0xc(%esi),%eax
1011a3: 83 c6 0c add $0xc,%esi
1011a6: 85 c0 test %eax,%eax
1011a8: 74 36 je 1011e0 <rtems_assoc_ptr_by_name+0x80>
if (strcmp(ap->name, name) == 0)
1011aa: 89 5c 24 04 mov %ebx,0x4(%esp)
1011ae: 89 04 24 mov %eax,(%esp)
1011b1: e8 3a 80 01 00 call 1191f0 <strcmp>
1011b6: 85 c0 test %eax,%eax
1011b8: 75 e6 jne 1011a0 <rtems_assoc_ptr_by_name+0x40>
return ap;
return default_ap;
}
1011ba: 83 c4 1c add $0x1c,%esp
1011bd: 89 f0 mov %esi,%eax
1011bf: 5b pop %ebx
1011c0: 5e pop %esi
1011c1: 5f pop %edi
1011c2: 5d pop %ebp
1011c3: c3 ret
1011c4: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1011cb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
1011cf: 90 nop
1011d0: 8b 75 08 mov 0x8(%ebp),%esi
const rtems_assoc_t *default_ap = 0;
1011d3: c7 45 08 00 00 00 00 movl $0x0,0x8(%ebp)
1011da: eb ce jmp 1011aa <rtems_assoc_ptr_by_name+0x4a>
1011dc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
for ( ; ap->name; ap++)
1011e0: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED
}
1011e3: 83 c4 1c add $0x1c,%esp <== NOT EXECUTED
1011e6: 5b pop %ebx <== NOT EXECUTED
1011e7: 89 f0 mov %esi,%eax <== NOT EXECUTED
1011e9: 5e pop %esi <== NOT EXECUTED
1011ea: 5f pop %edi <== NOT EXECUTED
1011eb: 5d pop %ebp <== NOT EXECUTED
1011ec: c3 ret <== NOT EXECUTED
1011ed: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
1011f0: 83 c4 1c add $0x1c,%esp
const rtems_assoc_t *default_ap = 0;
1011f3: 31 f6 xor %esi,%esi
}
1011f5: 5b pop %ebx
1011f6: 89 f0 mov %esi,%eax
1011f8: 5e pop %esi
1011f9: 5f pop %edi
1011fa: 5d pop %ebp
1011fb: c3 ret
1011fc: 90 nop
1011fd: 90 nop
1011fe: 90 nop
1011ff: 90 nop
0010cf10 <rtems_assoc_ptr_by_remote>:
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
10cf10: 55 push %ebp
10cf11: 89 e5 mov %esp,%ebp
10cf13: 57 push %edi
10cf14: 8b 55 0c mov 0xc(%ebp),%edx
10cf17: 56 push %esi
10cf18: 53 push %ebx
10cf19: 8b 5d 08 mov 0x8(%ebp),%ebx
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
10cf1c: 8b 03 mov (%ebx),%eax
10cf1e: 85 c0 test %eax,%eax
10cf20: 74 3d je 10cf5f <rtems_assoc_ptr_by_remote+0x4f>
10cf22: 89 c6 mov %eax,%esi
10cf24: bf 9c 58 12 00 mov $0x12589c,%edi
10cf29: b9 0a 00 00 00 mov $0xa,%ecx
10cf2e: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi)
10cf30: 0f 97 c0 seta %al
10cf33: 1c 00 sbb $0x0,%al
10cf35: 84 c0 test %al,%al
10cf37: 75 37 jne 10cf70 <rtems_assoc_ptr_by_remote+0x60>
default_ap = ap++;
for ( ; ap->name; ap++)
10cf39: 8b 73 0c mov 0xc(%ebx),%esi
default_ap = ap++;
10cf3c: 8d 43 0c lea 0xc(%ebx),%eax
for ( ; ap->name; ap++)
10cf3f: 85 f6 test %esi,%esi
10cf41: 75 17 jne 10cf5a <rtems_assoc_ptr_by_remote+0x4a> <== ALWAYS TAKEN
10cf43: eb 3b jmp 10cf80 <rtems_assoc_ptr_by_remote+0x70> <== NOT EXECUTED
10cf45: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10cf4c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10cf50: 8b 48 0c mov 0xc(%eax),%ecx
10cf53: 83 c0 0c add $0xc,%eax
10cf56: 85 c9 test %ecx,%ecx
10cf58: 74 26 je 10cf80 <rtems_assoc_ptr_by_remote+0x70>
if (ap->remote_value == remote_value)
10cf5a: 39 50 08 cmp %edx,0x8(%eax)
10cf5d: 75 f1 jne 10cf50 <rtems_assoc_ptr_by_remote+0x40>
return ap;
return default_ap;
}
10cf5f: 5b pop %ebx
10cf60: 5e pop %esi
10cf61: 5f pop %edi
10cf62: 5d pop %ebp
10cf63: c3 ret
10cf64: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10cf6b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10cf6f: 90 nop
10cf70: 89 d8 mov %ebx,%eax
const rtems_assoc_t *default_ap = 0;
10cf72: 31 db xor %ebx,%ebx
10cf74: eb e4 jmp 10cf5a <rtems_assoc_ptr_by_remote+0x4a>
10cf76: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10cf7d: 8d 76 00 lea 0x0(%esi),%esi
for ( ; ap->name; ap++)
10cf80: 89 d8 mov %ebx,%eax
}
10cf82: 5b pop %ebx
10cf83: 5e pop %esi
10cf84: 5f pop %edi
10cf85: 5d pop %ebp
10cf86: c3 ret
10cf87: 90 nop
10cf88: 90 nop
10cf89: 90 nop
10cf8a: 90 nop
10cf8b: 90 nop
10cf8c: 90 nop
10cf8d: 90 nop
10cf8e: 90 nop
10cf8f: 90 nop
00101280 <rtems_assoc_remote_by_local_bitfield>:
uint32_t rtems_assoc_remote_by_local_bitfield(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
101280: 55 push %ebp
101281: 89 e5 mov %esp,%ebp
101283: 57 push %edi
101284: bf 20 00 00 00 mov $0x20,%edi
101289: 56 push %esi
10128a: 53 push %ebx
uint32_t b;
uint32_t remote_value = 0;
for (b = 1; b; b <<= 1)
10128b: bb 01 00 00 00 mov $0x1,%ebx
{
101290: 83 ec 2c sub $0x2c,%esp
uint32_t remote_value = 0;
101293: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
{
10129a: 8b 75 0c mov 0xc(%ebp),%esi
10129d: eb 06 jmp 1012a5 <rtems_assoc_remote_by_local_bitfield+0x25>
10129f: 90 nop
for (b = 1; b; b <<= 1)
1012a0: 01 db add %ebx,%ebx
1012a2: 4f dec %edi
1012a3: 74 1b je 1012c0 <rtems_assoc_remote_by_local_bitfield+0x40>
if (b & local_value)
1012a5: 85 de test %ebx,%esi
1012a7: 74 f7 je 1012a0 <rtems_assoc_remote_by_local_bitfield+0x20>
remote_value |= rtems_assoc_remote_by_local(ap, b);
1012a9: 89 5c 24 04 mov %ebx,0x4(%esp)
1012ad: 8b 45 08 mov 0x8(%ebp),%eax
for (b = 1; b; b <<= 1)
1012b0: 01 db add %ebx,%ebx
remote_value |= rtems_assoc_remote_by_local(ap, b);
1012b2: 89 04 24 mov %eax,(%esp)
1012b5: e8 16 00 00 00 call 1012d0 <rtems_assoc_remote_by_local>
1012ba: 09 45 e4 or %eax,-0x1c(%ebp)
for (b = 1; b; b <<= 1)
1012bd: 4f dec %edi
1012be: 75 e5 jne 1012a5 <rtems_assoc_remote_by_local_bitfield+0x25><== ALWAYS TAKEN
return remote_value;
}
1012c0: 8b 45 e4 mov -0x1c(%ebp),%eax
1012c3: 83 c4 2c add $0x2c,%esp
1012c6: 5b pop %ebx
1012c7: 5e pop %esi
1012c8: 5f pop %edi
1012c9: 5d pop %ebp
1012ca: c3 ret
1012cb: 90 nop
1012cc: 90 nop
1012cd: 90 nop
1012ce: 90 nop
1012cf: 90 nop
001101e0 <rtems_cache_aligned_malloc>:
#include <rtems.h>
#include <rtems/malloc.h>
void *rtems_cache_aligned_malloc( size_t nbytes )
{
1101e0: 55 push %ebp
1101e1: 89 e5 mov %esp,%ebp
1101e3: 83 ec 18 sub $0x18,%esp
1101e6: 89 5d fc mov %ebx,-0x4(%ebp)
1101e9: 8b 5d 08 mov 0x8(%ebp),%ebx
size_t line_size = rtems_cache_get_maximal_line_size();
1101ec: e8 cf 3a 00 00 call 113cc0 <rtems_cache_get_maximal_line_size>
if ( line_size > 0 ) {
1101f1: 85 c0 test %eax,%eax
1101f3: 74 0a je 1101ff <rtems_cache_aligned_malloc+0x1f> <== NEVER TAKEN
/* Assume that the cache line size is a power of two */
size_t m = line_size - 1;
nbytes = (nbytes + m) & ~m;
1101f5: 8d 54 18 ff lea -0x1(%eax,%ebx,1),%edx
1101f9: 89 c3 mov %eax,%ebx
1101fb: f7 db neg %ebx
1101fd: 21 d3 and %edx,%ebx
}
return rtems_heap_allocate_aligned_with_boundary( nbytes, line_size, 0 );
1101ff: 89 1c 24 mov %ebx,(%esp)
110202: 31 d2 xor %edx,%edx
110204: 89 54 24 08 mov %edx,0x8(%esp)
110208: 89 44 24 04 mov %eax,0x4(%esp)
11020c: e8 8f 37 ff ff call 1039a0 <rtems_heap_allocate_aligned_with_boundary>
}
110211: 8b 5d fc mov -0x4(%ebp),%ebx
110214: 89 ec mov %ebp,%esp
110216: 5d pop %ebp
110217: c3 ret
110218: 90 nop
110219: 90 nop
11021a: 90 nop
11021b: 90 nop
11021c: 90 nop
11021d: 90 nop
11021e: 90 nop
11021f: 90 nop
001010d0 <rtems_cache_coherent_add_area>:
void rtems_cache_coherent_add_area(
void *area_begin,
uintptr_t area_size
)
{
1010d0: 55 push %ebp
1010d1: 89 e5 mov %esp,%ebp
1010d3: 83 ec 18 sub $0x18,%esp
if ( _System_state_Is_up( _System_state_Get()) ) {
1010d6: 83 3d c0 9e 12 00 02 cmpl $0x2,0x129ec0
{
1010dd: 89 5d f8 mov %ebx,-0x8(%ebp)
1010e0: 8b 5d 08 mov 0x8(%ebp),%ebx
1010e3: 89 75 fc mov %esi,-0x4(%ebp)
1010e6: 8b 75 0c mov 0xc(%ebp),%esi
if ( _System_state_Is_up( _System_state_Get()) ) {
1010e9: 74 35 je 101120 <rtems_cache_coherent_add_area+0x50>
ok = _Heap_Initialize( heap, area_begin, area_size, 0 );
1010eb: 89 74 24 08 mov %esi,0x8(%esp)
Heap_Control *heap = cache_coherent_heap;
1010ef: a1 00 9e 12 00 mov 0x129e00,%eax
ok = _Heap_Initialize( heap, area_begin, area_size, 0 );
1010f4: 31 d2 xor %edx,%edx
1010f6: 89 54 24 0c mov %edx,0xc(%esp)
1010fa: 89 5c 24 04 mov %ebx,0x4(%esp)
if ( heap == NULL ) {
1010fe: 85 c0 test %eax,%eax
101100: 74 5e je 101160 <rtems_cache_coherent_add_area+0x90> <== NEVER TAKEN
_Heap_Extend( heap, area_begin, area_size, 0 );
101102: 89 04 24 mov %eax,(%esp)
101105: e8 a6 45 00 00 call 1056b0 <_Heap_Extend>
_RTEMS_Unlock_allocator();
} else {
add_area( area_begin, area_size );
}
}
10110a: 8b 5d f8 mov -0x8(%ebp),%ebx
10110d: 8b 75 fc mov -0x4(%ebp),%esi
101110: 89 ec mov %ebp,%esp
101112: 5d pop %ebp
101113: c3 ret
101114: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10111b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10111f: 90 nop
_RTEMS_Lock_allocator();
101120: e8 1b 3d 00 00 call 104e40 <_RTEMS_Lock_allocator>
Heap_Control *heap = cache_coherent_heap;
101125: a1 00 9e 12 00 mov 0x129e00,%eax
ok = _Heap_Initialize( heap, area_begin, area_size, 0 );
10112a: 31 d2 xor %edx,%edx
10112c: 89 54 24 0c mov %edx,0xc(%esp)
101130: 89 74 24 08 mov %esi,0x8(%esp)
101134: 89 5c 24 04 mov %ebx,0x4(%esp)
if ( heap == NULL ) {
101138: 85 c0 test %eax,%eax
10113a: 74 44 je 101180 <rtems_cache_coherent_add_area+0xb0>
_Heap_Extend( heap, area_begin, area_size, 0 );
10113c: 89 04 24 mov %eax,(%esp)
10113f: e8 6c 45 00 00 call 1056b0 <_Heap_Extend>
}
101144: 8b 5d f8 mov -0x8(%ebp),%ebx
101147: 8b 75 fc mov -0x4(%ebp),%esi
10114a: 89 ec mov %ebp,%esp
10114c: 5d pop %ebp
_RTEMS_Unlock_allocator();
10114d: e9 0e 3d 00 00 jmp 104e60 <_RTEMS_Unlock_allocator>
101152: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
101159: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
ok = _Heap_Initialize( heap, area_begin, area_size, 0 );
101160: c7 04 24 20 9e 12 00 movl $0x129e20,(%esp) <== NOT EXECUTED
101167: e8 d4 41 00 00 call 105340 <_Heap_Initialize> <== NOT EXECUTED
if ( ok ) {
10116c: 85 c0 test %eax,%eax <== NOT EXECUTED
10116e: 74 9a je 10110a <rtems_cache_coherent_add_area+0x3a> <== NOT EXECUTED
cache_coherent_heap = heap;
101170: b8 20 9e 12 00 mov $0x129e20,%eax <== NOT EXECUTED
101175: a3 00 9e 12 00 mov %eax,0x129e00 <== NOT EXECUTED
10117a: eb 8e jmp 10110a <rtems_cache_coherent_add_area+0x3a> <== NOT EXECUTED
10117c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
ok = _Heap_Initialize( heap, area_begin, area_size, 0 );
101180: c7 04 24 20 9e 12 00 movl $0x129e20,(%esp)
101187: e8 b4 41 00 00 call 105340 <_Heap_Initialize>
if ( ok ) {
10118c: 85 c0 test %eax,%eax
10118e: 74 b4 je 101144 <rtems_cache_coherent_add_area+0x74>
cache_coherent_heap = heap;
101190: b9 20 9e 12 00 mov $0x129e20,%ecx
101195: 89 0d 00 9e 12 00 mov %ecx,0x129e00
10119b: eb a7 jmp 101144 <rtems_cache_coherent_add_area+0x74>
10119d: 90 nop
10119e: 90 nop
10119f: 90 nop
00101020 <rtems_cache_coherent_allocate>:
void *rtems_cache_coherent_allocate(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
101020: 55 push %ebp
101021: 89 e5 mov %esp,%ebp
101023: 83 ec 28 sub $0x28,%esp
void *ptr;
Heap_Control *heap;
_RTEMS_Lock_allocator();
101026: e8 15 3e 00 00 call 104e40 <_RTEMS_Lock_allocator>
heap = cache_coherent_heap;
10102b: a1 00 9e 12 00 mov 0x129e00,%eax
if ( heap == NULL ) {
101030: 85 c0 test %eax,%eax
101032: 74 2c je 101060 <rtems_cache_coherent_allocate+0x40>
heap = RTEMS_Malloc_Heap;
}
ptr = _Heap_Allocate_aligned_with_boundary(
101034: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
101037: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED
10103a: 89 54 24 0c mov %edx,0xc(%esp) <== NOT EXECUTED
10103e: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED
101041: 89 54 24 08 mov %edx,0x8(%esp) <== NOT EXECUTED
101045: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
101048: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
10104c: e8 1f 3f 00 00 call 104f70 <_Heap_Allocate_aligned_with_boundary> <== NOT EXECUTED
101051: 89 45 f4 mov %eax,-0xc(%ebp)
size,
alignment,
boundary
);
_RTEMS_Unlock_allocator();
101054: e8 07 3e 00 00 call 104e60 <_RTEMS_Unlock_allocator>
return ptr;
}
101059: 8b 45 f4 mov -0xc(%ebp),%eax
10105c: 89 ec mov %ebp,%esp
10105e: 5d pop %ebp
10105f: c3 ret
heap = RTEMS_Malloc_Heap;
101060: a1 8c 9e 12 00 mov 0x129e8c,%eax
101065: eb cd jmp 101034 <rtems_cache_coherent_allocate+0x14>
101067: 90 nop
101068: 90 nop
101069: 90 nop
10106a: 90 nop
10106b: 90 nop
10106c: 90 nop
10106d: 90 nop
10106e: 90 nop
10106f: 90 nop
00101070 <rtems_cache_coherent_free>:
void rtems_cache_coherent_free( void *ptr )
{
101070: 55 push %ebp
101071: 89 e5 mov %esp,%ebp
101073: 83 ec 18 sub $0x18,%esp
101076: 89 5d fc mov %ebx,-0x4(%ebp)
101079: 8b 5d 08 mov 0x8(%ebp),%ebx
Heap_Control *heap;
_RTEMS_Lock_allocator();
10107c: e8 bf 3d 00 00 call 104e40 <_RTEMS_Lock_allocator>
heap = cache_coherent_heap;
101081: a1 00 9e 12 00 mov 0x129e00,%eax
if ( heap != NULL ) {
101086: 85 c0 test %eax,%eax
101088: 74 26 je 1010b0 <rtems_cache_coherent_free+0x40>
if ( _Heap_Free( heap, ptr ) ) {
10108a: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
10108e: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
101091: e8 3a 49 00 00 call 1059d0 <_Heap_Free> <== NOT EXECUTED
101096: 84 c0 test %al,%al
101098: 74 16 je 1010b0 <rtems_cache_coherent_free+0x40>
if ( heap != NULL ) {
_Heap_Free( heap, ptr );
}
_RTEMS_Unlock_allocator();
}
10109a: 8b 5d fc mov -0x4(%ebp),%ebx
10109d: 89 ec mov %ebp,%esp
10109f: 5d pop %ebp
_RTEMS_Unlock_allocator();
1010a0: e9 bb 3d 00 00 jmp 104e60 <_RTEMS_Unlock_allocator>
1010a5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1010ac: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
heap = RTEMS_Malloc_Heap;
1010b0: a1 8c 9e 12 00 mov 0x129e8c,%eax
if ( heap != NULL ) {
1010b5: 85 c0 test %eax,%eax
1010b7: 74 e1 je 10109a <rtems_cache_coherent_free+0x2a> <== NEVER TAKEN
_Heap_Free( heap, ptr );
1010b9: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
1010bd: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
1010c0: e8 0b 49 00 00 call 1059d0 <_Heap_Free> <== NOT EXECUTED
}
1010c5: 8b 5d fc mov -0x4(%ebp),%ebx
1010c8: 89 ec mov %ebp,%esp
1010ca: 5d pop %ebp
_RTEMS_Unlock_allocator();
1010cb: e9 90 3d 00 00 jmp 104e60 <_RTEMS_Unlock_allocator>
001039b0 <rtems_calloc>:
void *rtems_calloc( size_t nelem, size_t elsize )
{
1039b0: 55 push %ebp
1039b1: 89 e5 mov %esp,%ebp
1039b3: 57 push %edi
1039b4: 53 push %ebx
1039b5: 83 ec 10 sub $0x10,%esp
size_t length;
void *p;
length = nelem * elsize;
1039b8: 8b 55 0c mov 0xc(%ebp),%edx
1039bb: 8b 4d 08 mov 0x8(%ebp),%ecx
1039be: 0f af d1 imul %ecx,%edx
if ( size == 0 ) {
1039c1: 85 d2 test %edx,%edx
length = nelem * elsize;
1039c3: 89 d7 mov %edx,%edi
if ( size == 0 ) {
1039c5: 0f 84 a5 00 00 00 je 103a70 <rtems_calloc+0xc0>
return rtems_heap_allocate_aligned_with_boundary( size, 0, 0 );
1039cb: 89 3c 24 mov %edi,(%esp)
1039ce: 31 c0 xor %eax,%eax
1039d0: 31 d2 xor %edx,%edx
1039d2: 89 44 24 08 mov %eax,0x8(%esp)
1039d6: 89 54 24 04 mov %edx,0x4(%esp)
1039da: e8 b1 fe ff ff call 103890 <rtems_heap_allocate_aligned_with_boundary>
1039df: 89 c3 mov %eax,%ebx
p = rtems_malloc( length );
RTEMS_OBFUSCATE_VARIABLE( p );
if ( RTEMS_PREDICT_FALSE( p == NULL ) ) {
1039e1: 85 db test %ebx,%ebx
1039e3: 74 18 je 1039fd <rtems_calloc+0x4d>
return p;
}
return memset( p, 0, length );
1039e5: 89 fa mov %edi,%edx
1039e7: 89 df mov %ebx,%edi
1039e9: 83 fa 08 cmp $0x8,%edx
1039ec: 73 52 jae 103a40 <rtems_calloc+0x90> <== NEVER TAKEN
1039ee: f6 c2 04 test $0x4,%dl
1039f1: 75 3d jne 103a30 <rtems_calloc+0x80> <== ALWAYS TAKEN
1039f3: f6 c2 02 test $0x2,%dl <== NOT EXECUTED
1039f6: 75 28 jne 103a20 <rtems_calloc+0x70> <== NOT EXECUTED
1039f8: f6 c2 01 test $0x1,%dl
1039fb: 75 13 jne 103a10 <rtems_calloc+0x60> <== NEVER TAKEN
}
1039fd: 83 c4 10 add $0x10,%esp
103a00: 89 d8 mov %ebx,%eax
103a02: 5b pop %ebx
103a03: 5f pop %edi
103a04: 5d pop %ebp
103a05: c3 ret
103a06: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
103a0d: 8d 76 00 lea 0x0(%esi),%esi
return memset( p, 0, length );
103a10: c6 07 00 movb $0x0,(%edi) <== NOT EXECUTED
}
103a13: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
103a16: 89 d8 mov %ebx,%eax <== NOT EXECUTED
103a18: 5b pop %ebx <== NOT EXECUTED
103a19: 5f pop %edi <== NOT EXECUTED
103a1a: 5d pop %ebp <== NOT EXECUTED
103a1b: c3 ret <== NOT EXECUTED
103a1c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
return memset( p, 0, length );
103a20: 66 c7 07 00 00 movw $0x0,(%edi) <== NOT EXECUTED
103a25: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
103a28: f6 c2 01 test $0x1,%dl <== NOT EXECUTED
103a2b: 74 d0 je 1039fd <rtems_calloc+0x4d> <== NOT EXECUTED
103a2d: eb e1 jmp 103a10 <rtems_calloc+0x60> <== NOT EXECUTED
103a2f: 90 nop <== NOT EXECUTED
103a30: c7 07 00 00 00 00 movl $0x0,(%edi)
103a36: 83 c7 04 add $0x4,%edi
103a39: f6 c2 02 test $0x2,%dl
103a3c: 74 ba je 1039f8 <rtems_calloc+0x48> <== ALWAYS TAKEN
103a3e: eb e0 jmp 103a20 <rtems_calloc+0x70> <== NOT EXECUTED
103a40: f6 c3 01 test $0x1,%bl <== NOT EXECUTED
103a43: 75 3b jne 103a80 <rtems_calloc+0xd0> <== NOT EXECUTED
103a45: f7 c7 02 00 00 00 test $0x2,%edi <== NOT EXECUTED
103a4b: 75 43 jne 103a90 <rtems_calloc+0xe0> <== NOT EXECUTED
103a4d: f7 c7 04 00 00 00 test $0x4,%edi <== NOT EXECUTED
103a53: 75 4b jne 103aa0 <rtems_calloc+0xf0> <== NOT EXECUTED
103a55: 89 d1 mov %edx,%ecx <== NOT EXECUTED
103a57: 31 c0 xor %eax,%eax <== NOT EXECUTED
103a59: c1 e9 02 shr $0x2,%ecx <== NOT EXECUTED
103a5c: 83 e2 03 and $0x3,%edx <== NOT EXECUTED
103a5f: f3 ab rep stos %eax,%es:(%edi) <== NOT EXECUTED
103a61: eb 8b jmp 1039ee <rtems_calloc+0x3e> <== NOT EXECUTED
103a63: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
103a6a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
return NULL;
103a70: 31 db xor %ebx,%ebx
103a72: e9 6a ff ff ff jmp 1039e1 <rtems_calloc+0x31>
103a77: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
103a7e: 66 90 xchg %ax,%ax
return memset( p, 0, length );
103a80: c6 03 00 movb $0x0,(%ebx) <== NOT EXECUTED
103a83: 8d 7b 01 lea 0x1(%ebx),%edi <== NOT EXECUTED
103a86: 4a dec %edx <== NOT EXECUTED
103a87: eb bc jmp 103a45 <rtems_calloc+0x95> <== NOT EXECUTED
103a89: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
103a90: 66 c7 07 00 00 movw $0x0,(%edi) <== NOT EXECUTED
103a95: 83 ea 02 sub $0x2,%edx <== NOT EXECUTED
103a98: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
103a9b: eb b0 jmp 103a4d <rtems_calloc+0x9d> <== NOT EXECUTED
103a9d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
103aa0: c7 07 00 00 00 00 movl $0x0,(%edi) <== NOT EXECUTED
103aa6: 83 ea 04 sub $0x4,%edx <== NOT EXECUTED
103aa9: 83 c7 04 add $0x4,%edi <== NOT EXECUTED
103aac: eb a7 jmp 103a55 <rtems_calloc+0xa5> <== NOT EXECUTED
103aae: 90 nop
103aaf: 90 nop
0010ba80 <rtems_filesystem_chdir>:
#include <unistd.h>
#include <rtems/libio_.h>
int rtems_filesystem_chdir( rtems_filesystem_location_info_t *loc )
{
10ba80: 55 push %ebp
10ba81: 89 e5 mov %esp,%ebp
10ba83: 83 ec 78 sub $0x78,%esp
10ba86: 89 5d fc mov %ebx,-0x4(%ebp)
int rv = 0;
rtems_filesystem_global_location_t *global_loc =
rtems_filesystem_location_transform_to_global( loc );
10ba89: 8b 45 08 mov 0x8(%ebp),%eax
10ba8c: 89 04 24 mov %eax,(%esp)
10ba8f: e8 fc 88 ff ff call 104390 <rtems_filesystem_location_transform_to_global>
(void) ( *loc->handlers->fstat_h )( loc, &st );
10ba94: 8d 55 a0 lea -0x60(%ebp),%edx
st.st_mode = 0;
10ba97: c7 45 b0 00 00 00 00 movl $0x0,-0x50(%ebp)
10ba9e: 89 c3 mov %eax,%ebx
(void) ( *loc->handlers->fstat_h )( loc, &st );
10baa0: 8b 40 10 mov 0x10(%eax),%eax
10baa3: 89 54 24 04 mov %edx,0x4(%esp)
10baa7: 89 1c 24 mov %ebx,(%esp)
10baaa: ff 50 18 call *0x18(%eax)
mode_t type = rtems_filesystem_location_type( &global_loc->location );
if ( S_ISDIR( type ) ) {
10baad: 8b 45 b0 mov -0x50(%ebp),%eax
10bab0: 25 00 f0 00 00 and $0xf000,%eax
10bab5: 3d 00 40 00 00 cmp $0x4000,%eax
10baba: 75 24 jne 10bae0 <rtems_filesystem_chdir+0x60>
rtems_filesystem_global_location_assign(
&rtems_filesystem_current,
10babc: e8 3f 8b ff ff call 104600 <rtems_current_user_env_get>
rtems_filesystem_global_location_assign(
10bac1: 89 5c 24 04 mov %ebx,0x4(%esp)
10bac5: 89 04 24 mov %eax,(%esp)
10bac8: e8 33 85 ff ff call 104000 <rtems_filesystem_global_location_assign>
int rv = 0;
10bacd: 31 c0 xor %eax,%eax
rtems_filesystem_global_location_release( global_loc, true );
rv = -1;
}
return rv;
}
10bacf: 8b 5d fc mov -0x4(%ebp),%ebx
10bad2: 89 ec mov %ebp,%esp
10bad4: 5d pop %ebp
10bad5: c3 ret
10bad6: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10badd: 8d 76 00 lea 0x0(%esi),%esi
if ( !rtems_filesystem_location_is_null( loc ) ) {
10bae0: 81 7b 10 e0 32 12 00 cmpl $0x1232e0,0x10(%ebx)
10bae7: 74 0b je 10baf4 <rtems_filesystem_chdir+0x74>
errno = eno;
10bae9: e8 a2 f4 00 00 call 11af90 <__errno>
10baee: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED
rtems_filesystem_global_location_release( global_loc, true );
10baf4: 89 1c 24 mov %ebx,(%esp)
10baf7: b8 01 00 00 00 mov $0x1,%eax
10bafc: 89 44 24 04 mov %eax,0x4(%esp)
10bb00: e8 2b 87 ff ff call 104230 <rtems_filesystem_global_location_release>
rv = -1;
10bb05: b8 ff ff ff ff mov $0xffffffff,%eax
return rv;
10bb0a: eb c3 jmp 10bacf <rtems_filesystem_chdir+0x4f>
10bb0c: 90 nop
10bb0d: 90 nop
10bb0e: 90 nop
10bb0f: 90 nop
001022f0 <rtems_filesystem_do_unmount>:
}
void rtems_filesystem_do_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
1022f0: 55 push %ebp
1022f1: 89 e5 mov %esp,%ebp
1022f3: 83 ec 18 sub $0x18,%esp
1022f6: 89 5d fc mov %ebx,-0x4(%ebp)
1022f9: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_libio_lock();
1022fc: e8 5f 76 00 00 call 109960 <rtems_libio_lock>
next = the_node->next;
102301: 8b 13 mov (%ebx),%edx
previous = the_node->previous;
102303: 8b 43 04 mov 0x4(%ebx),%eax
next->previous = previous;
102306: 89 42 04 mov %eax,0x4(%edx)
previous->next = next;
102309: 89 10 mov %edx,(%eax)
rtems_libio_unlock();
10230b: e8 70 76 00 00 call 109980 <rtems_libio_unlock>
release_with_count(global_loc, 1);
102310: 8b 43 20 mov 0x20(%ebx),%eax
102313: ba 01 00 00 00 mov $0x1,%edx
102318: e8 43 00 00 00 call 102360 <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);
10231d: 8b 43 0c mov 0xc(%ebx),%eax
102320: 89 1c 24 mov %ebx,(%esp)
102323: ff 50 34 call *0x34(%eax)
if (mt_entry->unmount_task != 0) {
102326: 8b 43 3c mov 0x3c(%ebx),%eax
102329: 85 c0 test %eax,%eax
10232b: 74 15 je 102342 <rtems_filesystem_do_unmount+0x52> <== NEVER TAKEN
*
* @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 );
10232d: 89 04 24 mov %eax,(%esp)
102330: ba 00 00 00 80 mov $0x80000000,%edx
102335: 89 54 24 04 mov %edx,0x4(%esp)
102339: e8 f2 25 00 00 call 104930 <rtems_event_system_send>
rtems_status_code sc =
rtems_event_transient_send(mt_entry->unmount_task);
if (sc != RTEMS_SUCCESSFUL) {
10233e: 85 c0 test %eax,%eax
102340: 75 0e jne 102350 <rtems_filesystem_do_unmount+0x60> <== NEVER TAKEN
rtems_fatal_error_occurred(0xdeadbeef);
}
}
free(mt_entry);
102342: 89 5d 08 mov %ebx,0x8(%ebp)
}
102345: 8b 5d fc mov -0x4(%ebp),%ebx
102348: 89 ec mov %ebp,%esp
10234a: 5d pop %ebp
free(mt_entry);
10234b: e9 60 74 00 00 jmp 1097b0 <free>
rtems_fatal_error_occurred(0xdeadbeef);
102350: c7 04 24 ef be ad de movl $0xdeadbeef,(%esp) <== NOT EXECUTED
102357: e8 d4 27 00 00 call 104b30 <rtems_fatal_error_occurred> <== NOT EXECUTED
10235c: 90 nop
10235d: 90 nop
10235e: 90 nop
10235f: 90 nop
00109ba0 <rtems_filesystem_eval_path_check_access>:
int eval_flags,
mode_t node_mode,
uid_t node_uid,
gid_t node_gid
)
{
109ba0: 55 push %ebp
109ba1: 89 e5 mov %esp,%ebp
109ba3: 83 ec 28 sub $0x28,%esp
109ba6: 0f b7 45 14 movzwl 0x14(%ebp),%eax
109baa: 0f b7 55 18 movzwl 0x18(%ebp),%edx
bool access_ok = rtems_filesystem_check_access(
109bae: 89 44 24 08 mov %eax,0x8(%esp)
109bb2: 8b 45 10 mov 0x10(%ebp),%eax
109bb5: 89 54 24 0c mov %edx,0xc(%esp)
109bb9: 89 44 24 04 mov %eax,0x4(%esp)
109bbd: 8b 45 0c mov 0xc(%ebp),%eax
109bc0: 89 04 24 mov %eax,(%esp)
109bc3: e8 48 ff ff ff call 109b10 <rtems_filesystem_check_access>
node_mode,
node_uid,
node_gid
);
if (!access_ok) {
109bc8: 84 c0 test %al,%al
109bca: 74 04 je 109bd0 <rtems_filesystem_eval_path_check_access+0x30>
rtems_filesystem_eval_path_error(ctx, EACCES);
}
return access_ok;
}
109bcc: 89 ec mov %ebp,%esp
109bce: 5d pop %ebp
109bcf: c3 ret
109bd0: 88 45 f7 mov %al,-0x9(%ebp)
rtems_filesystem_eval_path_error(ctx, EACCES);
109bd3: 8b 55 08 mov 0x8(%ebp),%edx
109bd6: b8 0d 00 00 00 mov $0xd,%eax
109bdb: 89 44 24 04 mov %eax,0x4(%esp)
109bdf: 89 14 24 mov %edx,(%esp)
109be2: e8 b9 83 ff ff call 101fa0 <rtems_filesystem_eval_path_error>
109be7: 0f b6 45 f7 movzbl -0x9(%ebp),%eax <== NOT EXECUTED
}
109beb: 89 ec mov %ebp,%esp <== NOT EXECUTED
109bed: 5d pop %ebp <== NOT EXECUTED
109bee: c3 ret <== NOT EXECUTED
109bef: 90 nop
00101ca0 <rtems_filesystem_eval_path_continue>:
{
101ca0: 55 push %ebp
101ca1: 89 e5 mov %esp,%ebp
101ca3: 83 ec 18 sub $0x18,%esp
101ca6: 89 5d fc mov %ebx,-0x4(%ebp)
101ca9: 8b 5d 08 mov 0x8(%ebp),%ebx
while (ctx->pathlen > 0) {
101cac: 8b 4b 04 mov 0x4(%ebx),%ecx
101caf: 85 c9 test %ecx,%ecx
101cb1: 74 20 je 101cd3 <rtems_filesystem_eval_path_continue+0x33>
101cb3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
101cba: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
(*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);
101cc0: 8b 43 2c mov 0x2c(%ebx),%eax
101cc3: 8b 40 0c mov 0xc(%eax),%eax
101cc6: 89 1c 24 mov %ebx,(%esp)
101cc9: ff 50 08 call *0x8(%eax)
while (ctx->pathlen > 0) {
101ccc: 8b 53 04 mov 0x4(%ebx),%edx
101ccf: 85 d2 test %edx,%edx
101cd1: 75 ed jne 101cc0 <rtems_filesystem_eval_path_continue+0x20>
if (rtems_filesystem_eval_path_has_token(ctx)) {
101cd3: 8b 43 0c mov 0xc(%ebx),%eax
return ctx->flags;
101cd6: 8b 53 10 mov 0x10(%ebx),%edx
101cd9: 85 c0 test %eax,%eax
101cdb: 74 23 je 101d00 <rtems_filesystem_eval_path_continue+0x60>
if (make) {
101cdd: f6 c2 20 test $0x20,%dl
101ce0: 74 4e je 101d30 <rtems_filesystem_eval_path_continue+0x90>
check_access(ctx, RTEMS_FS_PERMS_WRITE);
101ce2: ba 02 00 00 00 mov $0x2,%edx
check_access(ctx, ctx->flags);
101ce7: 89 d8 mov %ebx,%eax
}
101ce9: 8b 5d fc mov -0x4(%ebp),%ebx
101cec: 89 ec mov %ebp,%esp
101cee: 5d pop %ebp
check_access(ctx, ctx->flags);
101cef: e9 7c fe ff ff jmp 101b70 <check_access>
101cf4: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
101cfb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
101cff: 90 nop
if (!exclusive) {
101d00: f6 c2 40 test $0x40,%dl
101d03: 74 e2 je 101ce7 <rtems_filesystem_eval_path_continue+0x47>
if (!rtems_filesystem_location_is_null(&ctx->currentloc)) {
101d05: 81 7b 28 80 50 12 00 cmpl $0x125080,0x28(%ebx)
ctx->path = NULL;
101d0c: c7 03 00 00 00 00 movl $0x0,(%ebx)
ctx->pathlen = 0;
101d12: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx)
ctx->token = NULL;
101d19: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx)
if (!rtems_filesystem_location_is_null(&ctx->currentloc)) {
101d20: 74 4e je 101d70 <rtems_filesystem_eval_path_continue+0xd0>
errno = eno;
101d22: e8 69 73 01 00 call 119090 <__errno>
101d27: c7 00 11 00 00 00 movl $0x11,(%eax)
101d2d: eb 30 jmp 101d5f <rtems_filesystem_eval_path_continue+0xbf>
101d2f: 90 nop
if (!rtems_filesystem_location_is_null(&ctx->currentloc)) {
101d30: 81 7b 28 80 50 12 00 cmpl $0x125080,0x28(%ebx)
ctx->path = NULL;
101d37: c7 03 00 00 00 00 movl $0x0,(%ebx)
ctx->pathlen = 0;
101d3d: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx)
ctx->token = NULL;
101d44: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx)
ctx->tokenlen = 0;
101d4b: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
if (!rtems_filesystem_location_is_null(&ctx->currentloc)) {
101d52: 74 1c je 101d70 <rtems_filesystem_eval_path_continue+0xd0><== NEVER TAKEN
errno = eno;
101d54: e8 37 73 01 00 call 119090 <__errno>
101d59: c7 00 02 00 00 00 movl $0x2,(%eax)
rtems_filesystem_location_detach(&ctx->currentloc);
101d5f: 83 c3 18 add $0x18,%ebx
101d62: 89 5d 08 mov %ebx,0x8(%ebp)
}
101d65: 8b 5d fc mov -0x4(%ebp),%ebx
101d68: 89 ec mov %ebp,%esp
101d6a: 5d pop %ebp
rtems_filesystem_location_detach(&ctx->currentloc);
101d6b: e9 d0 04 00 00 jmp 102240 <rtems_filesystem_location_detach>
}
101d70: 8b 5d fc mov -0x4(%ebp),%ebx
101d73: 89 ec mov %ebp,%esp
101d75: 5d pop %ebp
101d76: c3 ret
101d77: 90 nop
101d78: 90 nop
101d79: 90 nop
101d7a: 90 nop
101d7b: 90 nop
101d7c: 90 nop
101d7d: 90 nop
101d7e: 90 nop
101d7f: 90 nop
00109df0 <rtems_filesystem_eval_path_eat_delimiter>:
#include <rtems/libio_.h>
void rtems_filesystem_eval_path_eat_delimiter(
rtems_filesystem_eval_path_context_t *ctx
)
{
109df0: 55 push %ebp
109df1: 89 e5 mov %esp,%ebp
109df3: 53 push %ebx
109df4: 8b 5d 08 mov 0x8(%ebp),%ebx
const char *current = ctx->path;
109df7: 8b 03 mov (%ebx),%eax
const char *end = current + ctx->pathlen;
109df9: 8b 4b 04 mov 0x4(%ebx),%ecx
109dfc: 01 c1 add %eax,%ecx
while (current != end && rtems_filesystem_is_delimiter(*current)) {
109dfe: 39 c8 cmp %ecx,%eax
109e00: 75 13 jne 109e15 <rtems_filesystem_eval_path_eat_delimiter+0x25><== ALWAYS TAKEN
109e02: eb 2c jmp 109e30 <rtems_filesystem_eval_path_eat_delimiter+0x40><== NOT EXECUTED
109e04: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
109e0b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
109e0f: 90 nop <== NOT EXECUTED
++current;
109e10: 40 inc %eax
while (current != end && rtems_filesystem_is_delimiter(*current)) {
109e11: 39 c1 cmp %eax,%ecx
109e13: 74 1b je 109e30 <rtems_filesystem_eval_path_eat_delimiter+0x40>
109e15: 0f b6 10 movzbl (%eax),%edx
109e18: 80 fa 2f cmp $0x2f,%dl
109e1b: 74 f3 je 109e10 <rtems_filesystem_eval_path_eat_delimiter+0x20>
109e1d: 80 fa 5c cmp $0x5c,%dl
109e20: 74 ee je 109e10 <rtems_filesystem_eval_path_eat_delimiter+0x20>
}
ctx->path = current;
109e22: 89 03 mov %eax,(%ebx)
ctx->pathlen = (size_t) (end - current);
109e24: 29 c1 sub %eax,%ecx
109e26: 89 4b 04 mov %ecx,0x4(%ebx)
}
109e29: 5b pop %ebx
109e2a: 5d pop %ebp
109e2b: c3 ret
109e2c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
ctx->path = current;
109e30: 89 03 mov %eax,(%ebx)
ctx->pathlen = (size_t) (end - current);
109e32: 31 c9 xor %ecx,%ecx
109e34: 89 4b 04 mov %ecx,0x4(%ebx)
}
109e37: 5b pop %ebx
109e38: 5d pop %ebp
109e39: c3 ret
109e3a: 90 nop
109e3b: 90 nop
109e3c: 90 nop
109e3d: 90 nop
109e3e: 90 nop
109e3f: 90 nop
00109bf0 <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
)
{
109bf0: 55 push %ebp
109bf1: 89 e5 mov %esp,%ebp
109bf3: 57 push %edi
109bf4: 56 push %esi
109bf5: 53 push %ebx
109bf6: 83 ec 2c sub $0x2c,%esp
109bf9: 8b 7d 08 mov 0x8(%ebp),%edi
109bfc: 8b 5d 10 mov 0x10(%ebp),%ebx
109bff: 8b 75 0c mov 0xc(%ebp),%esi
return &ctx->currentloc;
109c02: 8d 47 18 lea 0x18(%edi),%eax
109c05: 89 45 dc mov %eax,-0x24(%ebp)
109c08: 89 d8 mov %ebx,%eax
109c0a: 89 fb mov %edi,%ebx
109c0c: 89 c7 mov %eax,%edi
109c0e: 66 90 xchg %ax,%ax
rtems_filesystem_eval_path_next_token(ctx);
109c10: 89 1c 24 mov %ebx,(%esp)
109c13: e8 28 02 00 00 call 109e40 <rtems_filesystem_eval_path_next_token>
*tokenlen = ctx->tokenlen;
109c18: 8b 4b 0c mov 0xc(%ebx),%ecx
*token = ctx->token;
109c1b: 8b 43 08 mov 0x8(%ebx),%eax
const char *token;
size_t tokenlen;
rtems_filesystem_eval_path_get_next_token(ctx, &token, &tokenlen);
if (tokenlen > 0) {
109c1e: 89 4d e4 mov %ecx,-0x1c(%ebp)
109c21: 85 c9 test %ecx,%ecx
109c23: 89 45 e0 mov %eax,-0x20(%ebp)
109c26: 0f 84 93 00 00 00 je 109cbf <rtems_filesystem_eval_path_generic+0xcf>
if ((*config->is_directory)(ctx, arg)) {
109c2c: 89 74 24 04 mov %esi,0x4(%esp)
109c30: 89 1c 24 mov %ebx,(%esp)
109c33: ff 17 call *(%edi)
109c35: 84 c0 test %al,%al
109c37: 0f 84 63 01 00 00 je 109da0 <rtems_filesystem_eval_path_generic+0x1b0>
return tokenlen == 1 && token [0] == '.';
109c3d: 8b 4d e4 mov -0x1c(%ebp),%ecx
109c40: 83 f9 01 cmp $0x1,%ecx
109c43: 74 3b je 109c80 <rtems_filesystem_eval_path_generic+0x90>
return tokenlen == 2 && token [0] == '.' && token [1] == '.';
109c45: 83 f9 02 cmp $0x2,%ecx
109c48: 75 0c jne 109c56 <rtems_filesystem_eval_path_generic+0x66>
109c4a: 8b 45 e0 mov -0x20(%ebp),%eax
109c4d: 80 38 2e cmpb $0x2e,(%eax)
109c50: 0f 84 ca 00 00 00 je 109d20 <rtems_filesystem_eval_path_generic+0x130>
}
} else {
status = (*config->eval_token)(ctx, arg, "..", 2);
}
} else {
status = (*config->eval_token)(ctx, arg, token, tokenlen);
109c56: 89 4c 24 0c mov %ecx,0xc(%esp)
109c5a: 8b 45 e0 mov -0x20(%ebp),%eax
109c5d: 89 74 24 04 mov %esi,0x4(%esp)
109c61: 89 1c 24 mov %ebx,(%esp)
109c64: 89 44 24 08 mov %eax,0x8(%esp)
109c68: ff 57 04 call *0x4(%edi)
}
if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) {
109c6b: 83 f8 02 cmp $0x2,%eax
109c6e: 74 46 je 109cb6 <rtems_filesystem_eval_path_generic+0xc6>
while (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE) {
109c70: 85 c0 test %eax,%eax
109c72: 74 9c je 109c10 <rtems_filesystem_eval_path_generic+0x20>
109c74: eb 49 jmp 109cbf <rtems_filesystem_eval_path_generic+0xcf>
109c76: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
109c7d: 8d 76 00 lea 0x0(%esi),%esi
return tokenlen == 1 && token [0] == '.';
109c80: 8b 45 e0 mov -0x20(%ebp),%eax
109c83: 80 38 2e cmpb $0x2e,(%eax)
109c86: 75 ce jne 109c56 <rtems_filesystem_eval_path_generic+0x66>
if (rtems_filesystem_eval_path_has_path(ctx)) {
109c88: 8b 43 04 mov 0x4(%ebx),%eax
109c8b: 85 c0 test %eax,%eax
109c8d: 75 06 jne 109c95 <rtems_filesystem_eval_path_generic+0xa5>
if ((eval_flags & RTEMS_FS_REJECT_TERMINAL_DOT) == 0) {
109c8f: f6 43 11 01 testb $0x1,0x11(%ebx)
109c93: 75 6b jne 109d00 <rtems_filesystem_eval_path_generic+0x110>
status = (*config->eval_token)(ctx, arg, ".", 1);
109c95: 89 74 24 04 mov %esi,0x4(%esp)
109c99: ba 01 00 00 00 mov $0x1,%edx
109c9e: b9 f2 68 12 00 mov $0x1268f2,%ecx
109ca3: 89 54 24 0c mov %edx,0xc(%esp)
109ca7: 89 4c 24 08 mov %ecx,0x8(%esp)
109cab: 89 1c 24 mov %ebx,(%esp)
109cae: ff 57 04 call *0x4(%edi)
if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) {
109cb1: 83 f8 02 cmp $0x2,%eax
109cb4: 75 ba jne 109c70 <rtems_filesystem_eval_path_generic+0x80><== ALWAYS TAKEN
if (rtems_filesystem_eval_path_has_path(ctx)) {
109cb6: 8b 73 04 mov 0x4(%ebx),%esi
109cb9: 89 df mov %ebx,%edi
109cbb: 85 f6 test %esi,%esi
109cbd: 75 11 jne 109cd0 <rtems_filesystem_eval_path_generic+0xe0>
}
} else {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
}
}
}
109cbf: 83 c4 2c add $0x2c,%esp
109cc2: 5b pop %ebx
109cc3: 5e pop %esi
109cc4: 5f pop %edi
109cc5: 5d pop %ebp
109cc6: c3 ret
109cc7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
109cce: 66 90 xchg %ax,%ax
rtems_filesystem_eval_path_eat_delimiter(ctx);
109cd0: 89 1c 24 mov %ebx,(%esp)
109cd3: e8 18 01 00 00 call 109df0 <rtems_filesystem_eval_path_eat_delimiter>
if (
109cd8: f6 43 10 80 testb $0x80,0x10(%ebx)
109cdc: 74 07 je 109ce5 <rtems_filesystem_eval_path_generic+0xf5>
|| rtems_filesystem_eval_path_has_path(ctx)
109cde: 8b 5b 04 mov 0x4(%ebx),%ebx
109ce1: 85 db test %ebx,%ebx
109ce3: 74 da je 109cbf <rtems_filesystem_eval_path_generic+0xcf>
rtems_filesystem_eval_path_error(ctx, ENOTDIR);
109ce5: 89 7d 08 mov %edi,0x8(%ebp)
rtems_filesystem_eval_path_error(ctx, ENOENT);
109ce8: c7 45 0c 02 00 00 00 movl $0x2,0xc(%ebp)
}
109cef: 83 c4 2c add $0x2c,%esp
109cf2: 5b pop %ebx
109cf3: 5e pop %esi
109cf4: 5f pop %edi
109cf5: 5d pop %ebp
rtems_filesystem_eval_path_error(ctx, ENOTDIR);
109cf6: e9 a5 82 ff ff jmp 101fa0 <rtems_filesystem_eval_path_error>
109cfb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
109cff: 90 nop
rtems_filesystem_eval_path_error(ctx, EINVAL);
109d00: c7 45 0c 16 00 00 00 movl $0x16,0xc(%ebp)
109d07: 89 df mov %ebx,%edi
rtems_filesystem_eval_path_error(ctx, ENOTDIR);
109d09: 89 7d 08 mov %edi,0x8(%ebp)
}
109d0c: 83 c4 2c add $0x2c,%esp
109d0f: 5b pop %ebx
109d10: 5e pop %esi
109d11: 5f pop %edi
109d12: 5d pop %ebp
rtems_filesystem_eval_path_error(ctx, ENOTDIR);
109d13: e9 88 82 ff ff jmp 101fa0 <rtems_filesystem_eval_path_error>
109d18: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
109d1f: 90 nop
return tokenlen == 2 && token [0] == '.' && token [1] == '.';
109d20: 80 78 01 2e cmpb $0x2e,0x1(%eax)
109d24: 0f 85 2c ff ff ff jne 109c56 <rtems_filesystem_eval_path_generic+0x66><== NEVER TAKEN
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
109d2a: 8b 43 2c mov 0x2c(%ebx),%eax
109d2d: 8b 4b 30 mov 0x30(%ebx),%ecx
&& (*mt_entry->ops->are_nodes_equal_h)( loc, rootloc );
109d30: 8b 50 0c mov 0xc(%eax),%edx
109d33: 3b 41 14 cmp 0x14(%ecx),%eax
109d36: 8b 52 10 mov 0x10(%edx),%edx
109d39: 74 45 je 109d80 <rtems_filesystem_eval_path_generic+0x190>
return (*mt_entry->ops->are_nodes_equal_h)( loc, mt_fs_root );
109d3b: 8b 40 24 mov 0x24(%eax),%eax
109d3e: 89 44 24 04 mov %eax,0x4(%esp)
109d42: 8b 45 dc mov -0x24(%ebp),%eax
109d45: 89 04 24 mov %eax,(%esp)
109d48: ff d2 call *%edx
} else if (is_fs_root(currentloc)) {
109d4a: 84 c0 test %al,%al
109d4c: 74 72 je 109dc0 <rtems_filesystem_eval_path_generic+0x1d0>
if (currentloc->mt_entry->mt_point_node != NULL) {
109d4e: 8b 43 2c mov 0x2c(%ebx),%eax
109d51: 8b 50 20 mov 0x20(%eax),%edx
109d54: 85 d2 test %edx,%edx
109d56: 0f 84 39 ff ff ff je 109c95 <rtems_filesystem_eval_path_generic+0xa5><== NEVER TAKEN
size_t tokenlen = ctx->tokenlen;
109d5c: 8b 4b 0c mov 0xc(%ebx),%ecx
rtems_filesystem_eval_path_restart(
109d5f: 83 c0 20 add $0x20,%eax
ctx->path -= tokenlen;
109d62: 29 0b sub %ecx,(%ebx)
ctx->pathlen += tokenlen;
109d64: 01 4b 04 add %ecx,0x4(%ebx)
ctx->tokenlen = 0;
109d67: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
109d6e: 89 5d 08 mov %ebx,0x8(%ebp)
109d71: 89 45 0c mov %eax,0xc(%ebp)
}
109d74: 83 c4 2c add $0x2c,%esp
109d77: 5b pop %ebx
109d78: 5e pop %esi
109d79: 5f pop %edi
109d7a: 5d pop %ebp
rtems_filesystem_eval_path_restart(
109d7b: e9 e0 82 ff ff jmp 102060 <rtems_filesystem_eval_path_restart>
&& (*mt_entry->ops->are_nodes_equal_h)( loc, rootloc );
109d80: 89 4c 24 04 mov %ecx,0x4(%esp)
109d84: 8b 45 dc mov -0x24(%ebp),%eax
109d87: 89 04 24 mov %eax,(%esp)
109d8a: ff d2 call *%edx
109d8c: 84 c0 test %al,%al
109d8e: 0f 85 01 ff ff ff jne 109c95 <rtems_filesystem_eval_path_generic+0xa5>
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
109d94: 8b 43 2c mov 0x2c(%ebx),%eax
return (*mt_entry->ops->are_nodes_equal_h)( loc, mt_fs_root );
109d97: 8b 48 0c mov 0xc(%eax),%ecx
109d9a: 8b 51 10 mov 0x10(%ecx),%edx
109d9d: eb 9c jmp 109d3b <rtems_filesystem_eval_path_generic+0x14b>
109d9f: 90 nop
rtems_filesystem_eval_path_error(ctx, ENOTDIR);
109da0: c7 45 0c 14 00 00 00 movl $0x14,0xc(%ebp)
109da7: 89 df mov %ebx,%edi
109da9: 89 7d 08 mov %edi,0x8(%ebp)
}
109dac: 83 c4 2c add $0x2c,%esp
109daf: 5b pop %ebx
109db0: 5e pop %esi
109db1: 5f pop %edi
109db2: 5d pop %ebp
rtems_filesystem_eval_path_error(ctx, ENOTDIR);
109db3: e9 e8 81 ff ff jmp 101fa0 <rtems_filesystem_eval_path_error>
109db8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
109dbf: 90 nop
status = (*config->eval_token)(ctx, arg, "..", 2);
109dc0: 89 74 24 04 mov %esi,0x4(%esp)
109dc4: b8 02 00 00 00 mov $0x2,%eax
109dc9: 89 44 24 0c mov %eax,0xc(%esp)
109dcd: b8 f1 68 12 00 mov $0x1268f1,%eax
109dd2: 89 44 24 08 mov %eax,0x8(%esp)
109dd6: 89 1c 24 mov %ebx,(%esp)
109dd9: ff 57 04 call *0x4(%edi)
109ddc: e9 8a fe ff ff jmp 109c6b <rtems_filesystem_eval_path_generic+0x7b>
109de1: 90 nop
109de2: 90 nop
109de3: 90 nop
109de4: 90 nop
109de5: 90 nop
109de6: 90 nop
109de7: 90 nop
109de8: 90 nop
109de9: 90 nop
109dea: 90 nop
109deb: 90 nop
109dec: 90 nop
109ded: 90 nop
109dee: 90 nop
109def: 90 nop
00109e40 <rtems_filesystem_eval_path_next_token>:
}
void rtems_filesystem_eval_path_next_token(
rtems_filesystem_eval_path_context_t *ctx
)
{
109e40: 55 push %ebp
109e41: 89 e5 mov %esp,%ebp
109e43: 57 push %edi
109e44: 56 push %esi
109e45: 8b 75 08 mov 0x8(%ebp),%esi
109e48: 53 push %ebx
const char *current = ctx->path;
109e49: 8b 06 mov (%esi),%eax
const char *end = current + ctx->pathlen;
109e4b: 8b 5e 04 mov 0x4(%esi),%ebx
109e4e: 01 c3 add %eax,%ebx
while (current != end && rtems_filesystem_is_delimiter(*current)) {
109e50: 39 d8 cmp %ebx,%eax
109e52: 75 11 jne 109e65 <rtems_filesystem_eval_path_next_token+0x25>
109e54: eb 6a jmp 109ec0 <rtems_filesystem_eval_path_next_token+0x80>
109e56: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
109e5d: 8d 76 00 lea 0x0(%esi),%esi
++current;
109e60: 40 inc %eax
while (current != end && rtems_filesystem_is_delimiter(*current)) {
109e61: 39 c3 cmp %eax,%ebx
109e63: 74 5b je 109ec0 <rtems_filesystem_eval_path_next_token+0x80>
109e65: 0f b6 10 movzbl (%eax),%edx
109e68: 80 fa 2f cmp $0x2f,%dl
109e6b: 74 f3 je 109e60 <rtems_filesystem_eval_path_next_token+0x20>
109e6d: 80 fa 5c cmp $0x5c,%dl
109e70: 74 ee je 109e60 <rtems_filesystem_eval_path_next_token+0x20>
ctx->path = current;
109e72: 89 06 mov %eax,(%esi)
ctx->pathlen = (size_t) (end - current);
109e74: 89 df mov %ebx,%edi
109e76: 29 c7 sub %eax,%edi
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
109e78: 39 c3 cmp %eax,%ebx
ctx->pathlen = (size_t) (end - current);
109e7a: 89 7e 04 mov %edi,0x4(%esi)
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
109e7d: 74 7b je 109efa <rtems_filesystem_eval_path_next_token+0xba><== NEVER TAKEN
109e7f: 89 c2 mov %eax,%edx
109e81: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
109e88: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
109e8f: 90 nop
109e90: 0f b6 0a movzbl (%edx),%ecx
109e93: 80 f9 2f cmp $0x2f,%cl
109e96: 74 48 je 109ee0 <rtems_filesystem_eval_path_next_token+0xa0>
109e98: 80 f9 5c cmp $0x5c,%cl
109e9b: 74 43 je 109ee0 <rtems_filesystem_eval_path_next_token+0xa0>
++current;
109e9d: 42 inc %edx
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
109e9e: 39 da cmp %ebx,%edx
109ea0: 75 ee jne 109e90 <rtems_filesystem_eval_path_next_token+0x50>
ctx->path = current;
109ea2: 89 1e mov %ebx,(%esi)
109ea4: 31 c9 xor %ecx,%ecx
ctx->pathlen = (size_t) (end - current);
109ea6: 89 4e 04 mov %ecx,0x4(%esi)
ctx->token = begin;
109ea9: 89 46 08 mov %eax,0x8(%esi)
ctx->tokenlen = (size_t) (current - begin);
109eac: 89 7e 0c mov %edi,0xc(%esi)
rtems_filesystem_eval_path_eat_delimiter(ctx);
next_token(ctx);
}
109eaf: 5b pop %ebx
109eb0: 5e pop %esi
109eb1: 5f pop %edi
109eb2: 5d pop %ebp
109eb3: c3 ret
109eb4: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
109ebb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
109ebf: 90 nop
ctx->pathlen = (size_t) (end - current);
109ec0: 31 c9 xor %ecx,%ecx
ctx->tokenlen = (size_t) (current - begin);
109ec2: 89 c3 mov %eax,%ebx
109ec4: 31 ff xor %edi,%edi
ctx->path = current;
109ec6: 89 1e mov %ebx,(%esi)
ctx->pathlen = (size_t) (end - current);
109ec8: 89 4e 04 mov %ecx,0x4(%esi)
ctx->token = begin;
109ecb: 89 46 08 mov %eax,0x8(%esi)
ctx->tokenlen = (size_t) (current - begin);
109ece: 89 7e 0c mov %edi,0xc(%esi)
}
109ed1: 5b pop %ebx
109ed2: 5e pop %esi
109ed3: 5f pop %edi
109ed4: 5d pop %ebp
109ed5: c3 ret
109ed6: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
109edd: 8d 76 00 lea 0x0(%esi),%esi
ctx->token = begin;
109ee0: 89 46 08 mov %eax,0x8(%esi)
ctx->pathlen = (size_t) (end - current);
109ee3: 29 d3 sub %edx,%ebx
ctx->tokenlen = (size_t) (current - begin);
109ee5: 89 d7 mov %edx,%edi
ctx->pathlen = (size_t) (end - current);
109ee7: 89 d9 mov %ebx,%ecx
ctx->tokenlen = (size_t) (current - begin);
109ee9: 29 c7 sub %eax,%edi
ctx->pathlen = (size_t) (end - current);
109eeb: 89 4e 04 mov %ecx,0x4(%esi)
ctx->tokenlen = (size_t) (current - begin);
109eee: 89 d3 mov %edx,%ebx
ctx->path = current;
109ef0: 89 1e mov %ebx,(%esi)
ctx->tokenlen = (size_t) (current - begin);
109ef2: 89 7e 0c mov %edi,0xc(%esi)
}
109ef5: 5b pop %ebx
109ef6: 5e pop %esi
109ef7: 5f pop %edi
109ef8: 5d pop %ebp
109ef9: c3 ret
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
109efa: 89 f9 mov %edi,%ecx <== NOT EXECUTED
109efc: 31 ff xor %edi,%edi <== NOT EXECUTED
109efe: eb c6 jmp 109ec6 <rtems_filesystem_eval_path_next_token+0x86><== NOT EXECUTED
001020d0 <rtems_filesystem_eval_path_recursive>:
{
1020d0: 55 push %ebp
1020d1: 89 e5 mov %esp,%ebp
1020d3: 57 push %edi
1020d4: 56 push %esi
1020d5: 53 push %ebx
1020d6: 83 ec 2c sub $0x2c,%esp
1020d9: 8b 7d 10 mov 0x10(%ebp),%edi
1020dc: 8b 5d 08 mov 0x8(%ebp),%ebx
1020df: 8b 4d 0c mov 0xc(%ebp),%ecx
if (pathlen > 0) {
1020e2: 85 ff test %edi,%edi
1020e4: 0f 84 a6 00 00 00 je 102190 <rtems_filesystem_eval_path_recursive+0xc0><== NEVER TAKEN
if (ctx->recursionlevel < RTEMS_FILESYSTEM_SYMLOOP_MAX) {
1020ea: 8b 43 14 mov 0x14(%ebx),%eax
1020ed: 83 f8 1f cmp $0x1f,%eax
1020f0: 7f 5e jg 102150 <rtems_filesystem_eval_path_recursive+0x80>
size_t saved_pathlen = ctx->pathlen;
1020f2: 8b 53 04 mov 0x4(%ebx),%edx
const char *saved_path = ctx->path;
1020f5: 8b 33 mov (%ebx),%esi
size_t saved_pathlen = ctx->pathlen;
1020f7: 89 55 e4 mov %edx,-0x1c(%ebp)
if (rtems_filesystem_is_delimiter(path [0])) {
1020fa: 0f b6 11 movzbl (%ecx),%edx
1020fd: 80 fa 2f cmp $0x2f,%dl
102100: 0f 84 da 00 00 00 je 1021e0 <rtems_filesystem_eval_path_recursive+0x110>
102106: 80 fa 5c cmp $0x5c,%dl
102109: 0f 84 d1 00 00 00 je 1021e0 <rtems_filesystem_eval_path_recursive+0x110><== NEVER TAKEN
ctx->path = path;
10210f: 89 0b mov %ecx,(%ebx)
++ctx->recursionlevel;
102111: 40 inc %eax
ctx->pathlen = pathlen;
102112: 89 7b 04 mov %edi,0x4(%ebx)
++ctx->recursionlevel;
102115: 89 43 14 mov %eax,0x14(%ebx)
while (ctx->pathlen > 0) {
102118: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10211f: 90 nop
(*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);
102120: 8b 43 2c mov 0x2c(%ebx),%eax
102123: 8b 40 0c mov 0xc(%eax),%eax
102126: 89 1c 24 mov %ebx,(%esp)
102129: ff 50 08 call *0x8(%eax)
while (ctx->pathlen > 0) {
10212c: 8b 43 04 mov 0x4(%ebx),%eax
10212f: 85 c0 test %eax,%eax
102131: 75 ed jne 102120 <rtems_filesystem_eval_path_recursive+0x50>
ctx->path = saved_path;
102133: 89 33 mov %esi,(%ebx)
ctx->pathlen = saved_pathlen;
102135: 8b 45 e4 mov -0x1c(%ebp),%eax
--ctx->recursionlevel;
102138: ff 4b 14 decl 0x14(%ebx)
ctx->pathlen = saved_pathlen;
10213b: 89 43 04 mov %eax,0x4(%ebx)
}
10213e: 83 c4 2c add $0x2c,%esp
102141: 5b pop %ebx
102142: 5e pop %esi
102143: 5f pop %edi
102144: 5d pop %ebp
102145: c3 ret
102146: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10214d: 8d 76 00 lea 0x0(%esi),%esi
if (!rtems_filesystem_location_is_null(&ctx->currentloc)) {
102150: 81 7b 28 80 50 12 00 cmpl $0x125080,0x28(%ebx)
ctx->path = NULL;
102157: c7 03 00 00 00 00 movl $0x0,(%ebx)
ctx->pathlen = 0;
10215d: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx)
ctx->token = NULL;
102164: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx)
ctx->tokenlen = 0;
10216b: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
if (!rtems_filesystem_location_is_null(&ctx->currentloc)) {
102172: 74 ca je 10213e <rtems_filesystem_eval_path_recursive+0x6e><== NEVER TAKEN
errno = eno;
102174: e8 17 6f 01 00 call 119090 <__errno>
102179: c7 00 5c 00 00 00 movl $0x5c,(%eax)
rtems_filesystem_location_detach(&ctx->currentloc);
10217f: eb 3e jmp 1021bf <rtems_filesystem_eval_path_recursive+0xef>
102181: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
102188: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10218f: 90 nop
if (!rtems_filesystem_location_is_null(&ctx->currentloc)) {
102190: 81 7b 28 80 50 12 00 cmpl $0x125080,0x28(%ebx) <== NOT EXECUTED
ctx->path = NULL;
102197: c7 03 00 00 00 00 movl $0x0,(%ebx) <== NOT EXECUTED
ctx->pathlen = 0;
10219d: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) <== NOT EXECUTED
ctx->token = NULL;
1021a4: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) <== NOT EXECUTED
ctx->tokenlen = 0;
1021ab: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) <== NOT EXECUTED
if (!rtems_filesystem_location_is_null(&ctx->currentloc)) {
1021b2: 74 8a je 10213e <rtems_filesystem_eval_path_recursive+0x6e><== NOT EXECUTED
errno = eno;
1021b4: e8 d7 6e 01 00 call 119090 <__errno> <== NOT EXECUTED
1021b9: c7 00 02 00 00 00 movl $0x2,(%eax) <== NOT EXECUTED
rtems_filesystem_location_detach(&ctx->currentloc);
1021bf: 83 c3 18 add $0x18,%ebx
1021c2: 89 5d 08 mov %ebx,0x8(%ebp)
}
1021c5: 83 c4 2c add $0x2c,%esp
1021c8: 5b pop %ebx
1021c9: 5e pop %esi
1021ca: 5f pop %edi
1021cb: 5d pop %ebp
rtems_filesystem_location_detach(&ctx->currentloc);
1021cc: e9 6f 00 00 00 jmp 102240 <rtems_filesystem_location_detach>
1021d1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1021d8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1021df: 90 nop
rtems_filesystem_eval_path_restart(ctx, &ctx->rootloc);
1021e0: 89 1c 24 mov %ebx,(%esp)
1021e3: 8d 43 30 lea 0x30(%ebx),%eax
1021e6: 89 44 24 04 mov %eax,0x4(%esp)
1021ea: 89 4d e0 mov %ecx,-0x20(%ebp)
1021ed: e8 6e fe ff ff call 102060 <rtems_filesystem_eval_path_restart>
++ctx->recursionlevel;
1021f2: 8b 43 14 mov 0x14(%ebx),%eax
1021f5: 8b 4d e0 mov -0x20(%ebp),%ecx
1021f8: e9 12 ff ff ff jmp 10210f <rtems_filesystem_eval_path_recursive+0x3f>
1021fd: 90 nop
1021fe: 90 nop
1021ff: 90 nop
00105050 <rtems_filesystem_eval_path_start_with_parent>:
{
105050: 55 push %ebp
105051: 89 e5 mov %esp,%ebp
105053: 57 push %edi
105054: 56 push %esi
105055: 53 push %ebx
105056: 83 ec 3c sub $0x3c,%esp
105059: 8b 7d 0c mov 0xc(%ebp),%edi
10505c: 8b 75 08 mov 0x8(%ebp),%esi
size_t pathlen = strlen(path);
10505f: 89 3c 24 mov %edi,(%esp)
105062: e8 39 af 01 00 call 11ffa0 <strlen>
105067: 89 45 e4 mov %eax,-0x1c(%ebp)
10506a: 89 c1 mov %eax,%ecx
10506c: 89 c3 mov %eax,%ebx
while (pathlen > 0) {
10506e: eb 1a jmp 10508a <rtems_filesystem_eval_path_start_with_parent+0x3a>
if (rtems_filesystem_is_delimiter(path [i])) {
105070: 0f b6 44 1f ff movzbl -0x1(%edi,%ebx,1),%eax
size_t i = pathlen - 1;
105075: 8d 53 ff lea -0x1(%ebx),%edx
if (rtems_filesystem_is_delimiter(path [i])) {
105078: 3c 2f cmp $0x2f,%al
10507a: 0f 84 90 00 00 00 je 105110 <rtems_filesystem_eval_path_start_with_parent+0xc0>
105080: 3c 5c cmp $0x5c,%al
105082: 0f 84 88 00 00 00 je 105110 <rtems_filesystem_eval_path_start_with_parent+0xc0><== NEVER TAKEN
pathlen = i;
105088: 89 d3 mov %edx,%ebx
while (pathlen > 0) {
10508a: 85 db test %ebx,%ebx
10508c: 75 e2 jne 105070 <rtems_filesystem_eval_path_start_with_parent+0x20>
const char *name = NULL;
10508e: 31 d2 xor %edx,%edx
if (pathlen > 0) {
105090: 85 c9 test %ecx,%ecx
105092: 75 6c jne 105100 <rtems_filesystem_eval_path_start_with_parent+0xb0>
105094: 89 55 dc mov %edx,-0x24(%ebp)
&rtems_filesystem_current
105097: e8 b4 09 00 00 call 105a50 <rtems_current_user_env_get>
10509c: 89 45 e0 mov %eax,-0x20(%ebp)
&rtems_filesystem_root,
10509f: e8 ac 09 00 00 call 105a50 <rtems_current_user_env_get>
currentloc = rtems_filesystem_eval_path_start_with_root_and_current(
1050a4: 8b 4d e0 mov -0x20(%ebp),%ecx
1050a7: 89 5c 24 08 mov %ebx,0x8(%esp)
1050ab: 89 7c 24 04 mov %edi,0x4(%esp)
1050af: 89 34 24 mov %esi,(%esp)
1050b2: 89 4c 24 14 mov %ecx,0x14(%esp)
&rtems_filesystem_root,
1050b6: 83 c0 04 add $0x4,%eax
1050b9: 89 44 24 10 mov %eax,0x10(%esp)
currentloc = rtems_filesystem_eval_path_start_with_root_and_current(
1050bd: 8b 45 18 mov 0x18(%ebp),%eax
1050c0: 89 44 24 0c mov %eax,0xc(%esp)
1050c4: e8 67 fd ff ff call 104e30 <rtems_filesystem_eval_path_start_with_root_and_current>
rtems_filesystem_location_clone(parentloc, currentloc);
1050c9: 89 44 24 04 mov %eax,0x4(%esp)
1050cd: 8b 45 14 mov 0x14(%ebp),%eax
1050d0: 89 04 24 mov %eax,(%esp)
1050d3: e8 48 b1 00 00 call 110220 <rtems_filesystem_location_clone>
ctx->pathlen = namelen;
1050d8: 8b 45 e4 mov -0x1c(%ebp),%eax
ctx->path = name;
1050db: 8b 55 dc mov -0x24(%ebp),%edx
ctx->pathlen = namelen;
1050de: 89 46 04 mov %eax,0x4(%esi)
ctx->flags = eval_flags;
1050e1: 8b 45 10 mov 0x10(%ebp),%eax
ctx->path = name;
1050e4: 89 16 mov %edx,(%esi)
ctx->flags = eval_flags;
1050e6: 89 46 10 mov %eax,0x10(%esi)
rtems_filesystem_eval_path_continue(ctx);
1050e9: 89 34 24 mov %esi,(%esp)
1050ec: e8 5f fc ff ff call 104d50 <rtems_filesystem_eval_path_continue>
return &ctx->currentloc;
1050f1: 8d 46 18 lea 0x18(%esi),%eax
}
1050f4: 83 c4 3c add $0x3c,%esp
1050f7: 5b pop %ebx
1050f8: 5e pop %esi
1050f9: 5f pop %edi
1050fa: 5d pop %ebp
1050fb: c3 ret
1050fc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
if (pathlen > 0) {
105100: 89 fa mov %edi,%edx
parentpathlen = 1;
105102: bb 01 00 00 00 mov $0x1,%ebx
parentpath = ".";
105107: bf 12 cb 12 00 mov $0x12cb12,%edi
10510c: eb 86 jmp 105094 <rtems_filesystem_eval_path_start_with_parent+0x44>
10510e: 66 90 xchg %ax,%ax
const char *name = NULL;
105110: 31 d2 xor %edx,%edx
if (pathlen > 0) {
105112: 85 c9 test %ecx,%ecx
105114: 0f 84 7a ff ff ff je 105094 <rtems_filesystem_eval_path_start_with_parent+0x44><== NEVER TAKEN
name = path + parentpathlen;
10511a: 8d 14 1f lea (%edi,%ebx,1),%edx
namelen = pathlen - parentpathlen;
10511d: 29 d9 sub %ebx,%ecx
10511f: 89 4d e4 mov %ecx,-0x1c(%ebp)
105122: e9 6d ff ff ff jmp 105094 <rtems_filesystem_eval_path_start_with_parent+0x44>
105127: 90 nop
105128: 90 nop
105129: 90 nop
10512a: 90 nop
10512b: 90 nop
10512c: 90 nop
10512d: 90 nop
10512e: 90 nop
10512f: 90 nop
00101d80 <rtems_filesystem_eval_path_start_with_root_and_current>:
{
101d80: 55 push %ebp
101d81: b9 30 00 00 00 mov $0x30,%ecx
101d86: 89 e5 mov %esp,%ebp
101d88: 57 push %edi
101d89: 56 push %esi
memset(ctx, 0, sizeof(*ctx));
101d8a: 31 f6 xor %esi,%esi
{
101d8c: 53 push %ebx
101d8d: 83 ec 3c sub $0x3c,%esp
101d90: 8b 5d 08 mov 0x8(%ebp),%ebx
101d93: 8d 43 08 lea 0x8(%ebx),%eax
memset(ctx, 0, sizeof(*ctx));
101d96: f6 c3 01 test $0x1,%bl
101d99: 0f 85 81 01 00 00 jne 101f20 <rtems_filesystem_eval_path_start_with_root_and_current+0x1a0><== NEVER TAKEN
101d9f: a8 02 test $0x2,%al
101da1: 0f 85 69 01 00 00 jne 101f10 <rtems_filesystem_eval_path_start_with_root_and_current+0x190><== NEVER TAKEN
101da7: 89 cf mov %ecx,%edi
101da9: 31 d2 xor %edx,%edx
101dab: 83 e7 f8 and $0xfffffff8,%edi
101dae: 89 34 10 mov %esi,(%eax,%edx,1)
101db1: 89 74 10 04 mov %esi,0x4(%eax,%edx,1)
101db5: 83 c2 08 add $0x8,%edx
101db8: 39 fa cmp %edi,%edx
101dba: 72 f2 jb 101dae <rtems_filesystem_eval_path_start_with_root_and_current+0x2e>
101dbc: 01 d0 add %edx,%eax
101dbe: f6 c1 04 test $0x4,%cl
101dc1: 0f 85 09 01 00 00 jne 101ed0 <rtems_filesystem_eval_path_start_with_root_and_current+0x150><== NEVER TAKEN
101dc7: f6 c1 02 test $0x2,%cl
101dca: 0f 85 e0 00 00 00 jne 101eb0 <rtems_filesystem_eval_path_start_with_root_and_current+0x130><== NEVER TAKEN
101dd0: f6 c1 01 test $0x1,%cl
101dd3: 0f 85 c7 00 00 00 jne 101ea0 <rtems_filesystem_eval_path_start_with_root_and_current+0x120><== NEVER TAKEN
ctx->path = path;
101dd9: 8b 45 0c mov 0xc(%ebp),%eax
101ddc: 89 03 mov %eax,(%ebx)
ctx->pathlen = pathlen;
101dde: 8b 45 10 mov 0x10(%ebp),%eax
101de1: 89 43 04 mov %eax,0x4(%ebx)
ctx->flags = eval_flags;
101de4: 8b 45 14 mov 0x14(%ebp),%eax
101de7: 89 43 10 mov %eax,0x10(%ebx)
if (ctx->pathlen > 0) {
101dea: 8b 45 10 mov 0x10(%ebp),%eax
101ded: 85 c0 test %eax,%eax
101def: 75 6f jne 101e60 <rtems_filesystem_eval_path_start_with_root_and_current+0xe0>
rtems_filesystem_global_location_t *global_loc = NULL;
101df1: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
return rtems_filesystem_global_location_obtain( &global_loc );
101df8: 8d 75 e4 lea -0x1c(%ebp),%esi
101dfb: 89 34 24 mov %esi,(%esp)
101dfe: e8 1d 06 00 00 call 102420 <rtems_filesystem_global_location_obtain>
rtems_filesystem_global_location_t *global_loc = NULL;
101e03: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
ctx->rootloc = rtems_filesystem_global_location_obtain_null();
101e0a: 89 43 30 mov %eax,0x30(%ebx)
return rtems_filesystem_global_location_obtain( &global_loc );
101e0d: 89 34 24 mov %esi,(%esp)
101e10: e8 0b 06 00 00 call 102420 <rtems_filesystem_global_location_obtain>
ctx->startloc = rtems_filesystem_global_location_obtain_null();
101e15: 89 43 34 mov %eax,0x34(%ebx)
errno = ENOENT;
101e18: e8 73 72 01 00 call 119090 <__errno>
101e1d: c7 00 02 00 00 00 movl $0x2,(%eax)
rtems_filesystem_instance_lock(&ctx->startloc->location);
101e23: 8b 43 34 mov 0x34(%ebx),%eax
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
101e26: 8b 40 14 mov 0x14(%eax),%eax
rtems_filesystem_location_clone(
101e29: 8d 73 18 lea 0x18(%ebx),%esi
(*mt_entry->ops->lock_h)( mt_entry );
101e2c: 8b 50 0c mov 0xc(%eax),%edx
101e2f: 89 04 24 mov %eax,(%esp)
101e32: ff 12 call *(%edx)
101e34: 8b 43 34 mov 0x34(%ebx),%eax
101e37: 89 34 24 mov %esi,(%esp)
101e3a: 89 44 24 04 mov %eax,0x4(%esp)
101e3e: e8 0d 79 00 00 call 109750 <rtems_filesystem_location_clone>
rtems_filesystem_eval_path_continue(ctx);
101e43: 89 1c 24 mov %ebx,(%esp)
101e46: e8 55 fe ff ff call 101ca0 <rtems_filesystem_eval_path_continue>
}
101e4b: 83 c4 3c add $0x3c,%esp
101e4e: 89 f0 mov %esi,%eax
101e50: 5b pop %ebx
101e51: 5e pop %esi
101e52: 5f pop %edi
101e53: 5d pop %ebp
101e54: c3 ret
101e55: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
101e5c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
char c = ctx->path [0];
101e60: 8b 45 0c mov 0xc(%ebp),%eax
101e63: 0f b6 10 movzbl (%eax),%edx
ctx->rootloc = rtems_filesystem_global_location_obtain(global_root_ptr);
101e66: 8b 45 18 mov 0x18(%ebp),%eax
char c = ctx->path [0];
101e69: 88 55 d7 mov %dl,-0x29(%ebp)
ctx->rootloc = rtems_filesystem_global_location_obtain(global_root_ptr);
101e6c: 89 04 24 mov %eax,(%esp)
101e6f: e8 ac 05 00 00 call 102420 <rtems_filesystem_global_location_obtain>
if (rtems_filesystem_is_delimiter(c)) {
101e74: 0f b6 55 d7 movzbl -0x29(%ebp),%edx
101e78: 80 fa 2f cmp $0x2f,%dl
ctx->rootloc = rtems_filesystem_global_location_obtain(global_root_ptr);
101e7b: 89 43 30 mov %eax,0x30(%ebx)
if (rtems_filesystem_is_delimiter(c)) {
101e7e: 74 70 je 101ef0 <rtems_filesystem_eval_path_start_with_root_and_current+0x170>
101e80: 80 fa 5c cmp $0x5c,%dl
101e83: 74 6b je 101ef0 <rtems_filesystem_eval_path_start_with_root_and_current+0x170><== NEVER TAKEN
ctx->startloc = rtems_filesystem_global_location_obtain(
101e85: 8b 45 1c mov 0x1c(%ebp),%eax
101e88: 89 04 24 mov %eax,(%esp)
101e8b: e8 90 05 00 00 call 102420 <rtems_filesystem_global_location_obtain>
101e90: 89 43 34 mov %eax,0x34(%ebx)
101e93: eb 91 jmp 101e26 <rtems_filesystem_eval_path_start_with_root_and_current+0xa6>
101e95: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
101e9c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
memset(ctx, 0, sizeof(*ctx));
101ea0: c6 00 00 movb $0x0,(%eax) <== NOT EXECUTED
101ea3: e9 31 ff ff ff jmp 101dd9 <rtems_filesystem_eval_path_start_with_root_and_current+0x59><== NOT EXECUTED
101ea8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
101eaf: 90 nop <== NOT EXECUTED
101eb0: 66 c7 00 00 00 movw $0x0,(%eax) <== NOT EXECUTED
101eb5: 83 c0 02 add $0x2,%eax <== NOT EXECUTED
101eb8: f6 c1 01 test $0x1,%cl <== NOT EXECUTED
101ebb: 0f 84 18 ff ff ff je 101dd9 <rtems_filesystem_eval_path_start_with_root_and_current+0x59><== NOT EXECUTED
101ec1: eb dd jmp 101ea0 <rtems_filesystem_eval_path_start_with_root_and_current+0x120><== NOT EXECUTED
101ec3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
101eca: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
101ed0: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED
101ed6: 83 c0 04 add $0x4,%eax <== NOT EXECUTED
101ed9: f6 c1 02 test $0x2,%cl <== NOT EXECUTED
101edc: 0f 84 ee fe ff ff je 101dd0 <rtems_filesystem_eval_path_start_with_root_and_current+0x50><== NOT EXECUTED
101ee2: eb cc jmp 101eb0 <rtems_filesystem_eval_path_start_with_root_and_current+0x130><== NOT EXECUTED
101ee4: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
101eeb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
101eef: 90 nop <== NOT EXECUTED
++ctx->path;
101ef0: ff 03 incl (%ebx)
--ctx->pathlen;
101ef2: ff 4b 04 decl 0x4(%ebx)
&ctx->rootloc
101ef5: 8d 43 30 lea 0x30(%ebx),%eax
101ef8: 89 04 24 mov %eax,(%esp)
ctx->startloc = rtems_filesystem_global_location_obtain(
101efb: e8 20 05 00 00 call 102420 <rtems_filesystem_global_location_obtain>
101f00: 89 43 34 mov %eax,0x34(%ebx)
101f03: e9 1e ff ff ff jmp 101e26 <rtems_filesystem_eval_path_start_with_root_and_current+0xa6>
101f08: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
101f0f: 90 nop
memset(ctx, 0, sizeof(*ctx));
101f10: 66 c7 00 00 00 movw $0x0,(%eax) <== NOT EXECUTED
101f15: 83 e9 02 sub $0x2,%ecx <== NOT EXECUTED
101f18: 83 c0 02 add $0x2,%eax <== NOT EXECUTED
101f1b: e9 87 fe ff ff jmp 101da7 <rtems_filesystem_eval_path_start_with_root_and_current+0x27><== NOT EXECUTED
101f20: c6 43 08 00 movb $0x0,0x8(%ebx) <== NOT EXECUTED
101f24: 8d 43 09 lea 0x9(%ebx),%eax <== NOT EXECUTED
101f27: b9 2f 00 00 00 mov $0x2f,%ecx <== NOT EXECUTED
101f2c: e9 6e fe ff ff jmp 101d9f <rtems_filesystem_eval_path_start_with_root_and_current+0x1f><== NOT EXECUTED
101f31: 90 nop
101f32: 90 nop
101f33: 90 nop
101f34: 90 nop
101f35: 90 nop
101f36: 90 nop
101f37: 90 nop
101f38: 90 nop
101f39: 90 nop
101f3a: 90 nop
101f3b: 90 nop
101f3c: 90 nop
101f3d: 90 nop
101f3e: 90 nop
101f3f: 90 nop
00101810 <rtems_filesystem_get_mount_handler>:
rtems_filesystem_fsmount_me_t
rtems_filesystem_get_mount_handler(
const char *type
)
{
101810: 55 push %ebp
find_arg fa = {
101811: 31 c0 xor %eax,%eax
{
101813: 89 e5 mov %esp,%ebp
101815: 56 push %esi
101816: 53 push %ebx
101817: 83 ec 20 sub $0x20,%esp
10181a: 8b 75 08 mov 0x8(%ebp),%esi
.type = type,
.mount_h = NULL
};
if ( type != NULL ) {
10181d: 85 f6 test %esi,%esi
10181f: 74 72 je 101893 <rtems_filesystem_get_mount_handler+0x83><== NEVER TAKEN
while ( table_entry->type && !stop ) {
101821: a1 b8 47 12 00 mov 0x1247b8,%eax
101826: bb b8 47 12 00 mov $0x1247b8,%ebx
10182b: 85 c0 test %eax,%eax
10182d: 74 1b je 10184a <rtems_filesystem_get_mount_handler+0x3a><== NEVER TAKEN
10182f: 90 nop
if ( strcmp( entry->type, fa->type ) != 0 ) {
101830: 89 74 24 04 mov %esi,0x4(%esp)
101834: 89 04 24 mov %eax,(%esp)
101837: e8 24 81 01 00 call 119960 <strcmp>
10183c: 85 c0 test %eax,%eax
10183e: 74 50 je 101890 <rtems_filesystem_get_mount_handler+0x80>
while ( table_entry->type && !stop ) {
101840: 8b 43 08 mov 0x8(%ebx),%eax
++table_entry;
101843: 83 c3 08 add $0x8,%ebx
while ( table_entry->type && !stop ) {
101846: 85 c0 test %eax,%eax
101848: 75 e6 jne 101830 <rtems_filesystem_get_mount_handler+0x20>
rtems_libio_lock();
10184a: e8 11 81 00 00 call 109960 <rtems_libio_lock>
return _Chain_Immutable_head( the_chain )->next;
10184f: 8b 1d 08 a2 12 00 mov 0x12a208,%ebx
for (
101855: 81 fb 0c a2 12 00 cmp $0x12a20c,%ebx
10185b: 74 4d je 1018aa <rtems_filesystem_get_mount_handler+0x9a><== ALWAYS TAKEN
10185d: 8d 76 00 lea 0x0(%esi),%esi
if ( strcmp( entry->type, fa->type ) != 0 ) {
101860: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED
101864: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED
101867: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
10186a: e8 f1 80 01 00 call 119960 <strcmp> <== NOT EXECUTED
10186f: 85 c0 test %eax,%eax <== NOT EXECUTED
101871: 75 2d jne 1018a0 <rtems_filesystem_get_mount_handler+0x90><== NOT EXECUTED
fa->mount_h = entry->mount_h;
101873: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED
return &the_chain->Tail.Node;
101876: 89 45 f4 mov %eax,-0xc(%ebp)
rtems_libio_unlock();
101879: e8 02 81 00 00 call 109980 <rtems_libio_unlock>
rtems_filesystem_iterate( find_handler, &fa );
}
return fa.mount_h;
10187e: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED
}
101881: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
101884: 5b pop %ebx <== NOT EXECUTED
101885: 5e pop %esi <== NOT EXECUTED
101886: 5d pop %ebp <== NOT EXECUTED
101887: c3 ret <== NOT EXECUTED
101888: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10188f: 90 nop <== NOT EXECUTED
fa->mount_h = entry->mount_h;
101890: 8b 43 04 mov 0x4(%ebx),%eax
}
101893: 83 c4 20 add $0x20,%esp
101896: 5b pop %ebx
101897: 5e pop %esi
101898: 5d pop %ebp
101899: c3 ret
10189a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
return the_node->next;
1018a0: 8b 1b mov (%ebx),%ebx <== NOT EXECUTED
for (
1018a2: 81 fb 0c a2 12 00 cmp $0x12a20c,%ebx <== NOT EXECUTED
1018a8: 75 b6 jne 101860 <rtems_filesystem_get_mount_handler+0x50><== NOT EXECUTED
find_arg fa = {
1018aa: 31 c0 xor %eax,%eax
1018ac: eb c8 jmp 101876 <rtems_filesystem_get_mount_handler+0x66>
1018ae: 90 nop
1018af: 90 nop
001024d0 <rtems_filesystem_global_location_release>:
{
1024d0: 55 push %ebp
1024d1: 89 e5 mov %esp,%ebp
if (!deferred) {
1024d3: 80 7d 0c 00 cmpb $0x0,0xc(%ebp)
{
1024d7: 8b 45 08 mov 0x8(%ebp),%eax
if (!deferred) {
1024da: 74 34 je 102510 <rtems_filesystem_global_location_release+0x40>
rtems_interrupt_lock_acquire(&deferred_release_lock, &lock_context);
1024dc: 9c pushf
1024dd: fa cli
1024de: 59 pop %ecx
if (global_loc->deferred_released_count == 0) {
1024df: 8b 50 20 mov 0x20(%eax),%edx
1024e2: 85 d2 test %edx,%edx
1024e4: 74 0a je 1024f0 <rtems_filesystem_global_location_release+0x20><== ALWAYS TAKEN
++global_loc->deferred_released_count;
1024e6: 42 inc %edx <== NOT EXECUTED
1024e7: 89 50 20 mov %edx,0x20(%eax) <== NOT EXECUTED
rtems_interrupt_lock_release(&deferred_release_lock, &lock_context);
1024ea: 51 push %ecx
1024eb: 9d popf
}
1024ec: 5d pop %ebp
1024ed: c3 ret
1024ee: 66 90 xchg %ax,%ax
global_loc->deferred_released_count = 1;
1024f0: c7 40 20 01 00 00 00 movl $0x1,0x20(%eax)
global_loc->deferred_released_next = head;
1024f7: 8b 15 c4 03 13 00 mov 0x1303c4,%edx
deferred_released_global_locations = global_loc;
1024fd: a3 c4 03 13 00 mov %eax,0x1303c4
global_loc->deferred_released_next = head;
102502: 89 50 1c mov %edx,0x1c(%eax)
deferred_released_global_locations = global_loc;
102505: eb e3 jmp 1024ea <rtems_filesystem_global_location_release+0x1a>
102507: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10250e: 66 90 xchg %ax,%ax
}
102510: 5d pop %ebp
release_with_count(global_loc, 1);
102511: ba 01 00 00 00 mov $0x1,%edx
102516: e9 45 fe ff ff jmp 102360 <release_with_count>
10251b: 90 nop
10251c: 90 nop
10251d: 90 nop
10251e: 90 nop
10251f: 90 nop
00100e30 <rtems_filesystem_initialize>:
/*
* Default mode for created files.
*/
void rtems_filesystem_initialize( void )
{
100e30: 55 push %ebp
100e31: 89 e5 mov %esp,%ebp
100e33: 83 ec 28 sub $0x28,%esp
int rv = 0;
const rtems_filesystem_mount_configuration *root_config =
&rtems_filesystem_root_configuration;
rv = mount(
100e36: a1 b4 47 12 00 mov 0x1247b4,%eax
100e3b: 89 44 24 10 mov %eax,0x10(%esp)
100e3f: a1 b0 47 12 00 mov 0x1247b0,%eax
100e44: 89 44 24 0c mov %eax,0xc(%esp)
100e48: a1 ac 47 12 00 mov 0x1247ac,%eax
100e4d: 89 44 24 08 mov %eax,0x8(%esp)
100e51: a1 a8 47 12 00 mov 0x1247a8,%eax
100e56: 89 44 24 04 mov %eax,0x4(%esp)
100e5a: a1 a4 47 12 00 mov 0x1247a4,%eax
100e5f: 89 04 24 mov %eax,(%esp)
100e62: e8 b9 04 00 00 call 101320 <mount>
root_config->target,
root_config->filesystemtype,
root_config->options,
root_config->data
);
if ( rv != 0 )
100e67: 85 c0 test %eax,%eax
100e69: 75 1d jne 100e88 <rtems_filesystem_initialize+0x58> <== NEVER TAKEN
* 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 );
100e6b: c7 04 24 54 4f 12 00 movl $0x124f54,(%esp)
100e72: b8 ed 01 00 00 mov $0x1ed,%eax
100e77: 89 44 24 04 mov %eax,0x4(%esp)
100e7b: e8 30 03 00 00 call 1011b0 <mkdir>
if ( rv != 0 )
100e80: 85 c0 test %eax,%eax
100e82: 75 10 jne 100e94 <rtems_filesystem_initialize+0x64> <== NEVER TAKEN
* 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.
*/
}
100e84: 89 ec mov %ebp,%esp
100e86: 5d pop %ebp
100e87: c3 ret
rtems_fatal_error_occurred( 0xABCD0002 );
100e88: c7 04 24 02 00 cd ab movl $0xabcd0002,(%esp) <== NOT EXECUTED
100e8f: e8 9c 3c 00 00 call 104b30 <rtems_fatal_error_occurred> <== NOT EXECUTED
rtems_fatal_error_occurred( 0xABCD0003 );
100e94: c7 04 24 03 00 cd ab movl $0xabcd0003,(%esp) <== NOT EXECUTED
100e9b: e8 90 3c 00 00 call 104b30 <rtems_fatal_error_occurred> <== NOT EXECUTED
00102fc0 <rtems_filesystem_iterate>:
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
102fc0: 55 push %ebp <== NOT EXECUTED
102fc1: 89 e5 mov %esp,%ebp <== NOT EXECUTED
102fc3: 57 push %edi <== NOT EXECUTED
102fc4: 56 push %esi <== NOT EXECUTED
102fc5: 53 push %ebx <== NOT EXECUTED
102fc6: 83 ec 2c sub $0x2c,%esp <== 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 ) {
102fc9: 8b 0d 50 49 18 00 mov 0x184950,%ecx <== NOT EXECUTED
{
102fcf: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED
102fd2: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED
while ( table_entry->type && !stop ) {
102fd5: 85 c9 test %ecx,%ecx <== NOT EXECUTED
102fd7: 74 21 je 102ffa <rtems_filesystem_iterate+0x3a> <== NOT EXECUTED
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
102fd9: bb 50 49 18 00 mov $0x184950,%ebx <== NOT EXECUTED
102fde: eb 04 jmp 102fe4 <rtems_filesystem_iterate+0x24> <== NOT EXECUTED
while ( table_entry->type && !stop ) {
102fe0: 84 c0 test %al,%al <== NOT EXECUTED
102fe2: 75 62 jne 103046 <rtems_filesystem_iterate+0x86> <== NOT EXECUTED
stop = (*routine)( table_entry, routine_arg );
102fe4: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
++table_entry;
102fe7: 83 c3 08 add $0x8,%ebx <== NOT EXECUTED
stop = (*routine)( table_entry, routine_arg );
102fea: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED
102fee: ff d6 call *%esi <== NOT EXECUTED
while ( table_entry->type && !stop ) {
102ff0: 8b 13 mov (%ebx),%edx <== NOT EXECUTED
102ff2: 85 d2 test %edx,%edx <== NOT EXECUTED
102ff4: 75 ea jne 102fe0 <rtems_filesystem_iterate+0x20> <== NOT EXECUTED
}
if ( !stop ) {
102ff6: 84 c0 test %al,%al <== NOT EXECUTED
102ff8: 75 4c jne 103046 <rtems_filesystem_iterate+0x86> <== NOT EXECUTED
rtems_libio_lock();
102ffa: e8 11 f4 ff ff call 102410 <rtems_libio_lock> <== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
102fff: 8b 1d c0 1a 1a 00 mov 0x1a1ac0,%ebx <== NOT EXECUTED
for (
103005: 31 c0 xor %eax,%eax
103007: 81 fb c4 1a 1a 00 cmp $0x1a1ac4,%ebx
10300d: 75 15 jne 103024 <rtems_filesystem_iterate+0x64>
10300f: eb 29 jmp 10303a <rtems_filesystem_iterate+0x7a>
103011: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
103018: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10301f: 90 nop
node = rtems_chain_first( chain );
!rtems_chain_is_tail( chain, node ) && !stop;
103020: 84 c0 test %al,%al
103022: 75 16 jne 10303a <rtems_filesystem_iterate+0x7a>
node = rtems_chain_next( node )
) {
const filesystem_node *fsn = (filesystem_node *) node;
stop = (*routine)( &fsn->entry, routine_arg );
103024: 89 7c 24 04 mov %edi,0x4(%esp)
103028: 8d 43 08 lea 0x8(%ebx),%eax
10302b: 89 04 24 mov %eax,(%esp)
10302e: ff d6 call *%esi
return the_node->next;
103030: 8b 1b mov (%ebx),%ebx
for (
103032: 81 fb c4 1a 1a 00 cmp $0x1a1ac4,%ebx
103038: 75 e6 jne 103020 <rtems_filesystem_iterate+0x60>
10303a: 88 45 e7 mov %al,-0x19(%ebp)
}
rtems_libio_unlock();
10303d: e8 ee f3 ff ff call 102430 <rtems_libio_unlock>
103042: 0f b6 45 e7 movzbl -0x19(%ebp),%eax
}
return stop;
}
103046: 83 c4 2c add $0x2c,%esp
103049: 5b pop %ebx
10304a: 5e pop %esi
10304b: 5f pop %edi
10304c: 5d pop %ebp
10304d: c3 ret
10304e: 90 nop
10304f: 90 nop
00102520 <rtems_filesystem_location_remove_from_mt_entry>:
{
102520: 55 push %ebp
102521: 89 e5 mov %esp,%ebp
102523: 83 ec 08 sub $0x8,%esp
102526: 89 5d f8 mov %ebx,-0x8(%ebp)
102529: 8b 55 08 mov 0x8(%ebp),%edx
10252c: 89 75 fc mov %esi,-0x4(%ebp)
rtems_filesystem_mt_entry_lock(lock_context);
10252f: 9c pushf
102530: fa cli
102531: 5b pop %ebx
previous = the_node->previous;
102532: 8b 42 04 mov 0x4(%edx),%eax
next = the_node->next;
102535: 8b 0a mov (%edx),%ecx
next->previous = previous;
102537: 89 41 04 mov %eax,0x4(%ecx)
previous->next = next;
10253a: 89 08 mov %ecx,(%eax)
do_unmount = rtems_filesystem_is_ready_for_unmount(loc->mt_entry);
10253c: 8b 42 14 mov 0x14(%edx),%eax
10253f: 80 78 28 00 cmpb $0x0,0x28(%eax)
102543: 75 08 jne 10254d <rtems_filesystem_location_remove_from_mt_entry+0x2d>
&& rtems_chain_has_only_one_node( &mt_entry->location_chain )
102545: 8b 70 1c mov 0x1c(%eax),%esi
102548: 39 70 14 cmp %esi,0x14(%eax)
10254b: 74 13 je 102560 <rtems_filesystem_location_remove_from_mt_entry+0x40>
rtems_filesystem_mt_entry_unlock(lock_context);
10254d: 53 push %ebx
10254e: 9d popf
}
10254f: 8b 5d f8 mov -0x8(%ebp),%ebx
102552: 8b 75 fc mov -0x4(%ebp),%esi
102555: 89 ec mov %ebp,%esp
102557: 5d pop %ebp
102558: c3 ret
102559: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
&& mt_entry->mt_fs_root->reference_count == 1;
102560: 8b 48 24 mov 0x24(%eax),%ecx
102563: 83 79 18 01 cmpl $0x1,0x18(%ecx)
102567: 75 e4 jne 10254d <rtems_filesystem_location_remove_from_mt_entry+0x2d><== ALWAYS TAKEN
head->previous = NULL;
102569: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) <== NOT EXECUTED
return &the_chain->Tail.Node;
102570: 8d 48 14 lea 0x14(%eax),%ecx <== NOT EXECUTED
return &the_chain->Head.Node;
102573: 89 48 1c mov %ecx,0x1c(%eax) <== NOT EXECUTED
return &the_chain->Tail.Node;
102576: 8d 70 18 lea 0x18(%eax),%esi <== NOT EXECUTED
102579: 89 70 14 mov %esi,0x14(%eax) <== NOT EXECUTED
rtems_filesystem_mt_entry_unlock(lock_context);
10257c: 53 push %ebx <== NOT EXECUTED
10257d: 9d popf <== NOT EXECUTED
rtems_filesystem_do_unmount(loc->mt_entry);
10257e: 8b 42 14 mov 0x14(%edx),%eax <== NOT EXECUTED
}
102581: 8b 5d f8 mov -0x8(%ebp),%ebx <== NOT EXECUTED
102584: 8b 75 fc mov -0x4(%ebp),%esi <== NOT EXECUTED
rtems_filesystem_do_unmount(loc->mt_entry);
102587: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED
}
10258a: 89 ec mov %ebp,%esp <== NOT EXECUTED
10258c: 5d pop %ebp <== NOT EXECUTED
rtems_filesystem_do_unmount(loc->mt_entry);
10258d: e9 5e fd ff ff jmp 1022f0 <rtems_filesystem_do_unmount> <== NOT EXECUTED
102592: 90 nop
102593: 90 nop
102594: 90 nop
102595: 90 nop
102596: 90 nop
102597: 90 nop
102598: 90 nop
102599: 90 nop
10259a: 90 nop
10259b: 90 nop
10259c: 90 nop
10259d: 90 nop
10259e: 90 nop
10259f: 90 nop
00102630 <rtems_filesystem_location_transform_to_global>:
{
102630: 55 push %ebp
102631: 89 e5 mov %esp,%ebp
102633: 83 ec 38 sub $0x38,%esp
rtems_filesystem_global_location_t *global_loc = malloc(sizeof(*global_loc));
102636: c7 04 24 24 00 00 00 movl $0x24,(%esp)
{
10263d: 89 75 f8 mov %esi,-0x8(%ebp)
102640: 8b 75 08 mov 0x8(%ebp),%esi
102643: 89 5d f4 mov %ebx,-0xc(%ebp)
102646: 89 7d fc mov %edi,-0x4(%ebp)
rtems_filesystem_global_location_t *global_loc = malloc(sizeof(*global_loc));
102649: e8 92 e9 ff ff call 100fe0 <malloc>
if (global_loc != NULL) {
10264e: 85 c0 test %eax,%eax
102650: 74 5e je 1026b0 <rtems_filesystem_location_transform_to_global+0x80><== NEVER TAKEN
global_loc->reference_count = 1;
102652: c7 40 18 01 00 00 00 movl $0x1,0x18(%eax)
102659: 89 c3 mov %eax,%ebx
global_loc->deferred_released_next = NULL;
10265b: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax)
global_loc->deferred_released_count = 0;
102662: c7 40 20 00 00 00 00 movl $0x0,0x20(%eax)
dst->node_access = src->node_access;
102669: 8b 46 08 mov 0x8(%esi),%eax
10266c: 89 43 08 mov %eax,0x8(%ebx)
dst->node_access_2 = src->node_access_2;
10266f: 8b 46 0c mov 0xc(%esi),%eax
102672: 89 43 0c mov %eax,0xc(%ebx)
dst->handlers = src->handlers;
102675: 8b 46 10 mov 0x10(%esi),%eax
102678: 89 43 10 mov %eax,0x10(%ebx)
dst->mt_entry = src->mt_entry;
10267b: 8b 46 14 mov 0x14(%esi),%eax
10267e: 89 43 14 mov %eax,0x14(%ebx)
rtems_filesystem_mt_entry_lock( lock_context );
102681: 9c pushf
102682: fa cli
102683: 59 pop %ecx
&loc->mt_entry->location_chain,
102684: 8b 43 14 mov 0x14(%ebx),%eax
old_last = tail->previous;
102687: 8b 50 1c mov 0x1c(%eax),%edx
return &the_chain->Tail.Node;
10268a: 8d 78 18 lea 0x18(%eax),%edi
10268d: 89 3b mov %edi,(%ebx)
tail->previous = the_node;
10268f: 89 58 1c mov %ebx,0x1c(%eax)
old_last->next = the_node;
102692: 89 1a mov %ebx,(%edx)
the_node->previous = old_last;
102694: 89 53 04 mov %edx,0x4(%ebx)
rtems_filesystem_mt_entry_unlock( lock_context );
102697: 51 push %ecx
102698: 9d popf
rtems_filesystem_location_remove_from_mt_entry(loc);
102699: 89 34 24 mov %esi,(%esp)
10269c: e8 7f fe ff ff call 102520 <rtems_filesystem_location_remove_from_mt_entry>
}
1026a1: 8b 75 f8 mov -0x8(%ebp),%esi
1026a4: 89 d8 mov %ebx,%eax
1026a6: 8b 5d f4 mov -0xc(%ebp),%ebx
1026a9: 8b 7d fc mov -0x4(%ebp),%edi
1026ac: 89 ec mov %ebp,%esp
1026ae: 5d pop %ebp
1026af: c3 ret
rtems_filesystem_location_free(loc);
1026b0: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
1026b3: e8 b8 71 00 00 call 109870 <rtems_filesystem_location_free> <== NOT EXECUTED
return rtems_filesystem_global_location_obtain( &global_loc );
1026b8: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED
1026bb: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
rtems_filesystem_global_location_t *global_loc = NULL;
1026be: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) <== NOT EXECUTED
return rtems_filesystem_global_location_obtain( &global_loc );
1026c5: e8 56 fd ff ff call 102420 <rtems_filesystem_global_location_obtain><== NOT EXECUTED
1026ca: 89 c3 mov %eax,%ebx <== NOT EXECUTED
errno = ENOMEM;
1026cc: e8 bf 69 01 00 call 119090 <__errno> <== NOT EXECUTED
1026d1: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED
return global_loc;
1026d7: eb c8 jmp 1026a1 <rtems_filesystem_location_transform_to_global+0x71><== NOT EXECUTED
1026d9: 90 nop
1026da: 90 nop
1026db: 90 nop
1026dc: 90 nop
1026dd: 90 nop
1026de: 90 nop
1026df: 90 nop
001011e0 <rtems_filesystem_mknod>:
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
1011e0: 55 push %ebp
1011e1: 89 e5 mov %esp,%ebp
1011e3: 83 ec 28 sub $0x28,%esp
1011e6: 89 5d f4 mov %ebx,-0xc(%ebp)
1011e9: 8b 45 0c mov 0xc(%ebp),%eax
1011ec: 89 75 f8 mov %esi,-0x8(%ebp)
1011ef: 8b 55 1c mov 0x1c(%ebp),%edx
1011f2: 89 7d fc mov %edi,-0x4(%ebp)
1011f5: 8b 5d 14 mov 0x14(%ebp),%ebx
1011f8: 8b 75 08 mov 0x8(%ebp),%esi
1011fb: 89 45 e4 mov %eax,-0x1c(%ebp)
1011fe: 8b 45 18 mov 0x18(%ebp),%eax
101201: 89 55 dc mov %edx,-0x24(%ebp)
101204: 8b 7d 10 mov 0x10(%ebp),%edi
101207: 89 45 d8 mov %eax,-0x28(%ebp)
int rv = 0;
mode &= ~rtems_filesystem_umask;
10120a: e8 e1 15 00 00 call 1027f0 <rtems_current_user_env_get>
10120f: 8b 40 08 mov 0x8(%eax),%eax
101212: f7 d0 not %eax
101214: 21 c3 and %eax,%ebx
switch (mode & S_IFMT) {
101216: 89 d8 mov %ebx,%eax
101218: 25 00 f0 00 00 and $0xf000,%eax
10121d: 3d 00 40 00 00 cmp $0x4000,%eax
101222: 74 38 je 10125c <rtems_filesystem_mknod+0x7c>
101224: 76 2a jbe 101250 <rtems_filesystem_mknod+0x70>
101226: 2d 00 60 00 00 sub $0x6000,%eax
10122b: a9 00 d0 ff ff test $0xffffd000,%eax
101230: 74 2a je 10125c <rtems_filesystem_mknod+0x7c> <== ALWAYS TAKEN
case S_IFDIR:
case S_IFIFO:
case S_IFREG:
break;
default:
errno = EINVAL;
101232: e8 59 7e 01 00 call 119090 <__errno>
rv = (*ops->mknod_h)( parentloc, name, namelen, mode, dev );
}
return rv;
}
101237: 8b 5d f4 mov -0xc(%ebp),%ebx
10123a: 8b 75 f8 mov -0x8(%ebp),%esi
10123d: 8b 7d fc mov -0x4(%ebp),%edi
errno = EINVAL;
101240: c7 00 16 00 00 00 movl $0x16,(%eax)
}
101246: 89 ec mov %ebp,%esp
101248: b8 ff ff ff ff mov $0xffffffff,%eax
10124d: 5d pop %ebp
10124e: c3 ret
10124f: 90 nop
switch (mode & S_IFMT) {
101250: 2d 00 10 00 00 sub $0x1000,%eax
101255: a9 00 e0 ff ff test $0xffffe000,%eax
10125a: 75 d6 jne 101232 <rtems_filesystem_mknod+0x52>
const rtems_filesystem_operations_table *ops = parentloc->mt_entry->ops;
10125c: 8b 46 14 mov 0x14(%esi),%eax
rv = (*ops->mknod_h)( parentloc, name, namelen, mode, dev );
10125f: 8b 4d dc mov -0x24(%ebp),%ecx
101262: 8b 55 d8 mov -0x28(%ebp),%edx
101265: 8b 40 0c mov 0xc(%eax),%eax
101268: 89 4d 1c mov %ecx,0x1c(%ebp)
10126b: 8b 4d e4 mov -0x1c(%ebp),%ecx
10126e: 89 5d 14 mov %ebx,0x14(%ebp)
}
101271: 8b 5d f4 mov -0xc(%ebp),%ebx
rv = (*ops->mknod_h)( parentloc, name, namelen, mode, dev );
101274: 89 7d 10 mov %edi,0x10(%ebp)
}
101277: 8b 7d fc mov -0x4(%ebp),%edi
rv = (*ops->mknod_h)( parentloc, name, namelen, mode, dev );
10127a: 89 75 08 mov %esi,0x8(%ebp)
}
10127d: 8b 75 f8 mov -0x8(%ebp),%esi
rv = (*ops->mknod_h)( parentloc, name, namelen, mode, dev );
101280: 89 55 18 mov %edx,0x18(%ebp)
101283: 89 4d 0c mov %ecx,0xc(%ebp)
101286: 8b 40 14 mov 0x14(%eax),%eax
}
101289: 89 ec mov %ebp,%esp
10128b: 5d pop %ebp
rv = (*ops->mknod_h)( parentloc, name, namelen, mode, dev );
10128c: ff e0 jmp *%eax
10128e: 90 nop
10128f: 90 nop
001060b0 <rtems_filesystem_mount_iterate>:
bool rtems_filesystem_mount_iterate(
rtems_filesystem_mt_entry_visitor visitor,
void *visitor_arg
)
{
1060b0: 55 push %ebp <== NOT EXECUTED
1060b1: 89 e5 mov %esp,%ebp <== NOT EXECUTED
1060b3: 57 push %edi <== NOT EXECUTED
1060b4: 56 push %esi <== NOT EXECUTED
1060b5: 53 push %ebx <== NOT EXECUTED
1060b6: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED
1060b9: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED
1060bc: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED
rtems_libio_lock();
1060bf: e8 4c c3 ff ff call 102410 <rtems_libio_lock> <== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
1060c4: 8b 1d b4 1a 1a 00 mov 0x1a1ab4,%ebx <== NOT EXECUTED
rtems_chain_control *chain = &rtems_filesystem_mount_table;
rtems_chain_node *node = NULL;
bool stop = false;
rtems_filesystem_mt_lock();
for (
1060ca: 81 fb b8 1a 1a 00 cmp $0x1a1ab8,%ebx <== NOT EXECUTED
1060d0: 75 12 jne 1060e4 <rtems_filesystem_mount_iterate+0x34> <== NOT EXECUTED
1060d2: eb 37 jmp 10610b <rtems_filesystem_mount_iterate+0x5b> <== NOT EXECUTED
1060d4: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1060db: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1060df: 90 nop <== NOT EXECUTED
node = rtems_chain_first( chain );
!rtems_chain_is_tail( chain, node ) && !stop;
1060e0: 84 c0 test %al,%al <== NOT EXECUTED
1060e2: 75 13 jne 1060f7 <rtems_filesystem_mount_iterate+0x47> <== 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 );
1060e4: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
1060e7: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED
1060eb: ff d7 call *%edi <== NOT EXECUTED
return the_node->next;
1060ed: 8b 1b mov (%ebx),%ebx <== NOT EXECUTED
for (
1060ef: 81 fb b8 1a 1a 00 cmp $0x1a1ab8,%ebx <== NOT EXECUTED
1060f5: 75 e9 jne 1060e0 <rtems_filesystem_mount_iterate+0x30> <== NOT EXECUTED
1060f7: 88 45 e7 mov %al,-0x19(%ebp) <== NOT EXECUTED
rtems_libio_unlock();
1060fa: e8 31 c3 ff ff call 102430 <rtems_libio_unlock> <== NOT EXECUTED
}
rtems_filesystem_mt_unlock();
return stop;
}
1060ff: 0f b6 45 e7 movzbl -0x19(%ebp),%eax <== NOT EXECUTED
106103: 83 c4 2c add $0x2c,%esp <== NOT EXECUTED
106106: 5b pop %ebx <== NOT EXECUTED
106107: 5e pop %esi <== NOT EXECUTED
106108: 5f pop %edi <== NOT EXECUTED
106109: 5d pop %ebp <== NOT EXECUTED
10610a: c3 ret <== NOT EXECUTED
bool stop = false;
10610b: 31 c0 xor %eax,%eax <== NOT EXECUTED
10610d: eb e8 jmp 1060f7 <rtems_filesystem_mount_iterate+0x47> <== NOT EXECUTED
10610f: 90 nop
00100ea0 <rtems_filesystem_register>:
int
rtems_filesystem_register(
const char *type,
rtems_filesystem_fsmount_me_t mount_h
)
{
100ea0: 55 push %ebp
100ea1: 89 e5 mov %esp,%ebp
100ea3: 57 push %edi
100ea4: 56 push %esi
100ea5: 53 push %ebx
100ea6: 83 ec 1c sub $0x1c,%esp
rtems_chain_control *chain = &filesystem_chain;
size_t type_size = strlen(type) + 1;
100ea9: 8b 45 08 mov 0x8(%ebp),%eax
100eac: 89 04 24 mov %eax,(%esp)
100eaf: e8 ac 7f 01 00 call 118e60 <strlen>
100eb4: 8d 70 01 lea 0x1(%eax),%esi
100eb7: 89 c7 mov %eax,%edi
size_t fsn_size = sizeof( filesystem_node ) + type_size;
100eb9: 83 c0 11 add $0x11,%eax
filesystem_node *fsn = malloc( fsn_size );
100ebc: 89 04 24 mov %eax,(%esp)
100ebf: e8 7c 7c 00 00 call 108b40 <malloc>
char *type_storage = (char *) fsn + sizeof( *fsn );
if ( fsn == NULL )
100ec4: 85 c0 test %eax,%eax
filesystem_node *fsn = malloc( fsn_size );
100ec6: 89 c3 mov %eax,%ebx
if ( fsn == NULL )
100ec8: 0f 84 16 01 00 00 je 100fe4 <rtems_filesystem_register+0x144>
rtems_set_errno_and_return_minus_one( ENOMEM );
memcpy(type_storage, type, type_size);
100ece: 89 f1 mov %esi,%ecx
100ed0: 83 c0 10 add $0x10,%eax
100ed3: 8b 75 08 mov 0x8(%ebp),%esi
100ed6: 83 f9 08 cmp $0x8,%ecx
100ed9: 89 c2 mov %eax,%edx
100edb: 0f 83 af 00 00 00 jae 100f90 <rtems_filesystem_register+0xf0> <== NEVER TAKEN
100ee1: 89 d7 mov %edx,%edi
100ee3: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
fsn->entry.type = type_storage;
100ee5: 89 43 08 mov %eax,0x8(%ebx)
fsn->entry.mount_h = mount_h;
100ee8: 8b 45 0c mov 0xc(%ebp),%eax
100eeb: 89 43 0c mov %eax,0xc(%ebx)
rtems_libio_lock();
100eee: e8 0d 7c 00 00 call 108b00 <rtems_libio_lock>
while ( table_entry->type && !stop ) {
100ef3: a1 9c f7 11 00 mov 0x11f79c,%eax
100ef8: 85 c0 test %eax,%eax
100efa: 74 22 je 100f1e <rtems_filesystem_register+0x7e> <== NEVER TAKEN
100efc: 8b 7d 08 mov 0x8(%ebp),%edi
100eff: be 9c f7 11 00 mov $0x11f79c,%esi
if ( strcmp( entry->type, fa->type ) != 0 ) {
100f04: 89 7c 24 04 mov %edi,0x4(%esp)
100f08: 89 04 24 mov %eax,(%esp)
100f0b: e8 70 7d 01 00 call 118c80 <strcmp>
100f10: 85 c0 test %eax,%eax
100f12: 74 4c je 100f60 <rtems_filesystem_register+0xc0> <== NEVER TAKEN
while ( table_entry->type && !stop ) {
100f14: 8b 46 08 mov 0x8(%esi),%eax
++table_entry;
100f17: 83 c6 08 add $0x8,%esi
while ( table_entry->type && !stop ) {
100f1a: 85 c0 test %eax,%eax
100f1c: 75 e6 jne 100f04 <rtems_filesystem_register+0x64> <== NEVER TAKEN
rtems_libio_lock();
100f1e: e8 dd 7b 00 00 call 108b00 <rtems_libio_lock>
return _Chain_Immutable_head( the_chain )->next;
100f23: 8b 35 08 42 12 00 mov 0x124208,%esi
return &the_chain->Tail.Node;
100f29: 8b 7d 08 mov 0x8(%ebp),%edi
for (
100f2c: 81 fe 0c 42 12 00 cmp $0x12420c,%esi
100f32: 0f 84 a5 00 00 00 je 100fdd <rtems_filesystem_register+0x13d>
100f38: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
100f3f: 90 nop
if ( strcmp( entry->type, fa->type ) != 0 ) {
100f40: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED
100f44: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED
100f47: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
100f4a: e8 31 7d 01 00 call 118c80 <strcmp> <== NOT EXECUTED
100f4f: 85 c0 test %eax,%eax
100f51: 75 5d jne 100fb0 <rtems_filesystem_register+0x110>
fa->mount_h = entry->mount_h;
100f53: 8b 76 0c mov 0xc(%esi),%esi
rtems_libio_unlock();
100f56: e8 c5 7b 00 00 call 108b20 <rtems_libio_unlock>
return stop;
100f5b: eb 06 jmp 100f63 <rtems_filesystem_register+0xc3>
100f5d: 8d 76 00 lea 0x0(%esi),%esi
fa->mount_h = entry->mount_h;
100f60: 8b 76 04 mov 0x4(%esi),%esi <== NOT EXECUTED
if ( rtems_filesystem_get_mount_handler( type ) == NULL ) {
100f63: 85 f6 test %esi,%esi
100f65: 75 57 jne 100fbe <rtems_filesystem_register+0x11e>
the_node->next = tail;
100f67: c7 03 0c 42 12 00 movl $0x12420c,(%ebx)
old_last = tail->previous;
100f6d: a1 10 42 12 00 mov 0x124210,%eax
tail->previous = the_node;
100f72: 89 1d 10 42 12 00 mov %ebx,0x124210
old_last->next = the_node;
100f78: 89 18 mov %ebx,(%eax)
the_node->previous = old_last;
100f7a: 89 43 04 mov %eax,0x4(%ebx)
rtems_libio_unlock();
free( fsn );
rtems_set_errno_and_return_minus_one( EINVAL );
}
rtems_libio_unlock();
100f7d: e8 9e 7b 00 00 call 108b20 <rtems_libio_unlock>
return 0;
100f82: 31 c0 xor %eax,%eax
}
100f84: 83 c4 1c add $0x1c,%esp
100f87: 5b pop %ebx
100f88: 5e pop %esi
100f89: 5f pop %edi
100f8a: 5d pop %ebp
100f8b: c3 ret
100f8c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
memcpy(type_storage, type, type_size);
100f90: a8 04 test $0x4,%al <== NOT EXECUTED
100f92: 0f 84 49 ff ff ff je 100ee1 <rtems_filesystem_register+0x41> <== NOT EXECUTED
100f98: 8b 16 mov (%esi),%edx <== NOT EXECUTED
100f9a: 8d 4f fd lea -0x3(%edi),%ecx <== NOT EXECUTED
100f9d: 8d 76 04 lea 0x4(%esi),%esi <== NOT EXECUTED
100fa0: 89 53 10 mov %edx,0x10(%ebx) <== NOT EXECUTED
100fa3: 8d 53 14 lea 0x14(%ebx),%edx <== NOT EXECUTED
100fa6: e9 36 ff ff ff jmp 100ee1 <rtems_filesystem_register+0x41> <== NOT EXECUTED
100fab: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
100faf: 90 nop <== NOT EXECUTED
return the_node->next;
100fb0: 8b 36 mov (%esi),%esi
for (
100fb2: 81 fe 0c 42 12 00 cmp $0x12420c,%esi
100fb8: 75 86 jne 100f40 <rtems_filesystem_register+0xa0>
find_arg fa = {
100fba: 31 f6 xor %esi,%esi
100fbc: eb 98 jmp 100f56 <rtems_filesystem_register+0xb6>
rtems_libio_unlock();
100fbe: e8 5d 7b 00 00 call 108b20 <rtems_libio_unlock>
free( fsn );
100fc3: 89 1c 24 mov %ebx,(%esp)
100fc6: e8 85 79 00 00 call 108950 <free>
rtems_set_errno_and_return_minus_one( EINVAL );
100fcb: e8 60 79 01 00 call 118930 <__errno>
100fd0: c7 00 16 00 00 00 movl $0x16,(%eax)
100fd6: b8 ff ff ff ff mov $0xffffffff,%eax
100fdb: eb a7 jmp 100f84 <rtems_filesystem_register+0xe4>
rtems_libio_unlock();
100fdd: e8 3e 7b 00 00 call 108b20 <rtems_libio_unlock>
return fa.mount_h;
100fe2: eb 83 jmp 100f67 <rtems_filesystem_register+0xc7>
rtems_set_errno_and_return_minus_one( ENOMEM );
100fe4: e8 47 79 01 00 call 118930 <__errno>
100fe9: c7 00 0c 00 00 00 movl $0xc,(%eax)
100fef: 83 c8 ff or $0xffffffff,%eax
100ff2: eb 90 jmp 100f84 <rtems_filesystem_register+0xe4>
100ff4: 90 nop
100ff5: 90 nop
100ff6: 90 nop
100ff7: 90 nop
100ff8: 90 nop
100ff9: 90 nop
100ffa: 90 nop
100ffb: 90 nop
100ffc: 90 nop
100ffd: 90 nop
100ffe: 90 nop
100fff: 90 nop
00100ba0 <rtems_gxx_key_create>:
}
int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
100ba0: 55 push %ebp
100ba1: 89 e5 mov %esp,%ebp
100ba3: 83 ec 28 sub $0x28,%esp
int eno;
pthread_key_t *pkey;
pkey = malloc( sizeof( *pkey ) );
100ba6: c7 04 24 04 00 00 00 movl $0x4,(%esp)
{
100bad: 89 75 fc mov %esi,-0x4(%ebp)
100bb0: 8b 75 08 mov 0x8(%ebp),%esi
100bb3: 89 5d f8 mov %ebx,-0x8(%ebp)
pkey = malloc( sizeof( *pkey ) );
100bb6: e8 25 03 00 00 call 100ee0 <malloc>
*key = pkey;
100bbb: 89 06 mov %eax,(%esi)
if ( pkey == NULL )
100bbd: 85 c0 test %eax,%eax
100bbf: 74 3d je 100bfe <rtems_gxx_key_create+0x5e> <== NEVER TAKEN
100bc1: 89 c3 mov %eax,%ebx
printk(
"gxx_wrappers: create key=%x, dtor=%x, pkey=%x\n", key, dtor, pkey
);
#endif
eno = pthread_key_create(pkey, dtor);
100bc3: 8b 45 0c mov 0xc(%ebp),%eax
100bc6: 89 1c 24 mov %ebx,(%esp)
100bc9: 89 44 24 04 mov %eax,0x4(%esp)
100bcd: e8 5e 3c 00 00 call 104830 <pthread_key_create>
if ( eno != 0 ) {
100bd2: 85 c0 test %eax,%eax
100bd4: 75 0a jne 100be0 <rtems_gxx_key_create+0x40> <== NEVER TAKEN
free( pkey );
*key = NULL;
}
return eno;
}
100bd6: 8b 5d f8 mov -0x8(%ebp),%ebx
100bd9: 8b 75 fc mov -0x4(%ebp),%esi
100bdc: 89 ec mov %ebp,%esp
100bde: 5d pop %ebp
100bdf: c3 ret
free( pkey );
100be0: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
100be3: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED
100be6: e8 e5 a8 00 00 call 10b4d0 <free> <== NOT EXECUTED
*key = NULL;
100beb: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED
100bee: c7 06 00 00 00 00 movl $0x0,(%esi) <== NOT EXECUTED
}
100bf4: 8b 5d f8 mov -0x8(%ebp),%ebx <== NOT EXECUTED
100bf7: 8b 75 fc mov -0x4(%ebp),%esi <== NOT EXECUTED
100bfa: 89 ec mov %ebp,%esp <== NOT EXECUTED
100bfc: 5d pop %ebp <== NOT EXECUTED
100bfd: c3 ret <== NOT EXECUTED
return ENOMEM;
100bfe: b8 0c 00 00 00 mov $0xc,%eax <== NOT EXECUTED
100c03: eb d1 jmp 100bd6 <rtems_gxx_key_create+0x36> <== NOT EXECUTED
100c05: 90 nop
100c06: 90 nop
100c07: 90 nop
100c08: 90 nop
100c09: 90 nop
100c0a: 90 nop
100c0b: 90 nop
100c0c: 90 nop
100c0d: 90 nop
100c0e: 90 nop
100c0f: 90 nop
00100d40 <rtems_gxx_mutex_lock>:
int rtems_gxx_mutex_lock (__gthread_mutex_t *mutex)
{
100d40: 55 push %ebp <== NOT EXECUTED
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: lock mutex=%X\n", *mutex );
#endif
status = rtems_semaphore_obtain(
100d41: 31 c0 xor %eax,%eax <== NOT EXECUTED
{
100d43: 89 e5 mov %esp,%ebp <== NOT EXECUTED
100d45: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED
status = rtems_semaphore_obtain(
100d48: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
100d4c: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
100d4f: 31 d2 xor %edx,%edx <== NOT EXECUTED
100d51: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
100d55: 8b 00 mov (%eax),%eax <== NOT EXECUTED
100d57: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
100d5a: e8 61 42 00 00 call 104fc0 <rtems_semaphore_obtain> <== NOT EXECUTED
*(rtems_id *)mutex,
RTEMS_WAIT,
RTEMS_NO_TIMEOUT
);
if ( status == RTEMS_SUCCESSFUL )
100d5f: 85 c0 test %eax,%eax
100d61: 0f 95 c0 setne %al
return 0;
return -1;
}
100d64: 89 ec mov %ebp,%esp
100d66: 5d pop %ebp
if ( status == RTEMS_SUCCESSFUL )
100d67: 0f b6 c0 movzbl %al,%eax
100d6a: f7 d8 neg %eax
}
100d6c: c3 ret
100d6d: 90 nop
100d6e: 90 nop
100d6f: 90 nop
00100e00 <rtems_gxx_recursive_mutex_init>:
void rtems_gxx_recursive_mutex_init(__gthread_recursive_mutex_t *mutex)
{
100e00: 55 push %ebp
status = rtems_semaphore_create(
100e01: ba 54 00 00 00 mov $0x54,%edx
{
100e06: 89 e5 mov %esp,%ebp
100e08: 83 ec 28 sub $0x28,%esp
status = rtems_semaphore_create(
100e0b: 89 54 24 08 mov %edx,0x8(%esp)
100e0f: 8b 45 08 mov 0x8(%ebp),%eax
100e12: b9 01 00 00 00 mov $0x1,%ecx
100e17: 89 4c 24 04 mov %ecx,0x4(%esp)
100e1b: c7 04 24 32 43 43 47 movl $0x47434332,(%esp)
100e22: 89 44 24 10 mov %eax,0x10(%esp)
100e26: 31 c0 xor %eax,%eax
100e28: 89 44 24 0c mov %eax,0xc(%esp)
100e2c: e8 cf 3d 00 00 call 104c00 <rtems_semaphore_create>
if ( status != RTEMS_SUCCESSFUL ) {
100e31: 85 c0 test %eax,%eax
100e33: 75 04 jne 100e39 <rtems_gxx_recursive_mutex_init+0x39> <== NEVER TAKEN
rtems_gxx_mutex_init(mutex);
}
100e35: 89 ec mov %ebp,%esp
100e37: 5d pop %ebp
100e38: c3 ret
_Internal_error( INTERNAL_ERROR_GXX_MUTEX_INIT_FAILED );
100e39: c7 04 24 16 00 00 00 movl $0x16,(%esp) <== NOT EXECUTED
100e40: e8 5b 53 00 00 call 1061a0 <_Internal_error> <== NOT EXECUTED
100e45: 90 nop
100e46: 90 nop
100e47: 90 nop
100e48: 90 nop
100e49: 90 nop
100e4a: 90 nop
100e4b: 90 nop
100e4c: 90 nop
100e4d: 90 nop
100e4e: 90 nop
100e4f: 90 nop
00100e50 <rtems_gxx_recursive_mutex_lock>:
int rtems_gxx_recursive_mutex_lock(__gthread_recursive_mutex_t *mutex)
{
100e50: 55 push %ebp <== NOT EXECUTED
status = rtems_semaphore_obtain(
100e51: 31 c0 xor %eax,%eax <== NOT EXECUTED
{
100e53: 89 e5 mov %esp,%ebp <== NOT EXECUTED
100e55: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED
status = rtems_semaphore_obtain(
100e58: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
100e5c: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
100e5f: 31 d2 xor %edx,%edx <== NOT EXECUTED
100e61: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
100e65: 8b 00 mov (%eax),%eax <== NOT EXECUTED
100e67: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
100e6a: e8 51 41 00 00 call 104fc0 <rtems_semaphore_obtain> <== NOT EXECUTED
if ( status == RTEMS_SUCCESSFUL )
100e6f: 85 c0 test %eax,%eax
100e71: 0f 95 c0 setne %al
return rtems_gxx_mutex_lock(mutex);
}
100e74: 89 ec mov %ebp,%esp
100e76: 5d pop %ebp
if ( status == RTEMS_SUCCESSFUL )
100e77: 0f b6 c0 movzbl %al,%eax
100e7a: f7 d8 neg %eax
}
100e7c: c3 ret
100e7d: 90 nop
100e7e: 90 nop
100e7f: 90 nop
00100e80 <rtems_gxx_recursive_mutex_trylock>:
int rtems_gxx_recursive_mutex_trylock(__gthread_recursive_mutex_t *mutex)
{
100e80: 55 push %ebp <== NOT EXECUTED
status = rtems_semaphore_obtain (*(rtems_id *)mutex, RTEMS_NO_WAIT, 0);
100e81: 31 c0 xor %eax,%eax <== NOT EXECUTED
{
100e83: 89 e5 mov %esp,%ebp <== NOT EXECUTED
100e85: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED
status = rtems_semaphore_obtain (*(rtems_id *)mutex, RTEMS_NO_WAIT, 0);
100e88: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
100e8c: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
100e8f: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED
100e94: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
100e98: 8b 00 mov (%eax),%eax <== NOT EXECUTED
100e9a: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
100e9d: e8 1e 41 00 00 call 104fc0 <rtems_semaphore_obtain> <== NOT EXECUTED
if ( status == RTEMS_SUCCESSFUL )
100ea2: 85 c0 test %eax,%eax
100ea4: 0f 95 c0 setne %al
return rtems_gxx_mutex_trylock(mutex);
}
100ea7: 89 ec mov %ebp,%esp
100ea9: 5d pop %ebp
if ( status == RTEMS_SUCCESSFUL )
100eaa: 0f b6 c0 movzbl %al,%eax
100ead: f7 d8 neg %eax
}
100eaf: c3 ret
00101070 <rtems_heap_allocate_aligned_with_boundary>:
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
101070: 55 push %ebp
101071: 89 e5 mov %esp,%ebp
101073: 83 ec 38 sub $0x38,%esp
101076: 89 5d f4 mov %ebx,-0xc(%ebp)
101079: a1 d4 03 13 00 mov 0x1303d4,%eax
10107e: 89 75 f8 mov %esi,-0x8(%ebp)
101081: 8b 5d 0c mov 0xc(%ebp),%ebx
101084: 89 7d fc mov %edi,-0x4(%ebp)
101087: 8b 75 08 mov 0x8(%ebp),%esi
Heap_Control *heap = RTEMS_Malloc_Heap;
10108a: 8b 3d 20 03 13 00 mov 0x130320,%edi
if ( _System_state_Is_up( state ) ) {
101090: 83 f8 02 cmp $0x2,%eax
101093: 74 3b je 1010d0 <rtems_heap_allocate_aligned_with_boundary+0x60>
} else if ( _System_state_Is_before_multitasking( state ) ) {
101095: 48 dec %eax
101096: 74 41 je 1010d9 <rtems_heap_allocate_aligned_with_boundary+0x69>
boundary
);
_RTEMS_Unlock_allocator();
break;
case MALLOC_SYSTEM_STATE_NO_PROTECTION:
p = _Heap_Allocate_aligned_with_boundary(
101098: 89 5c 24 08 mov %ebx,0x8(%esp)
10109c: 8b 45 10 mov 0x10(%ebp),%eax
10109f: 89 74 24 04 mov %esi,0x4(%esp)
1010a3: 89 3c 24 mov %edi,(%esp)
1010a6: 89 44 24 0c mov %eax,0xc(%esp)
1010aa: e8 d1 3b 00 00 call 104c80 <_Heap_Allocate_aligned_with_boundary>
* Do not attempt to allocate memory if not in correct system state.
*/
return NULL;
}
if ( p == NULL && alignment == 0 && boundary == 0 ) {
1010af: 09 c3 or %eax,%ebx
1010b1: 75 56 jne 101109 <rtems_heap_allocate_aligned_with_boundary+0x99><== ALWAYS TAKEN
1010b3: 8b 45 10 mov 0x10(%ebp),%eax
1010b6: 85 c0 test %eax,%eax
1010b8: 0f 84 82 00 00 00 je 101140 <rtems_heap_allocate_aligned_with_boundary+0xd0><== ALWAYS TAKEN
return NULL;
1010be: 31 c0 xor %eax,%eax
*/
if ( p != NULL && rtems_malloc_dirty_helper != NULL )
(*rtems_malloc_dirty_helper)( p, size );
return p;
}
1010c0: 8b 5d f4 mov -0xc(%ebp),%ebx
1010c3: 8b 75 f8 mov -0x8(%ebp),%esi
1010c6: 8b 7d fc mov -0x4(%ebp),%edi
1010c9: 89 ec mov %ebp,%esp
1010cb: 5d pop %ebp
1010cc: c3 ret
1010cd: 8d 76 00 lea 0x0(%esi),%esi
1010d0: a1 f0 03 13 00 mov 0x1303f0,%eax
if ( _Thread_Dispatch_is_enabled() ) {
1010d5: 85 c0 test %eax,%eax
1010d7: 75 e5 jne 1010be <rtems_heap_allocate_aligned_with_boundary+0x4e>
_RTEMS_Lock_allocator();
1010d9: e8 72 3a 00 00 call 104b50 <_RTEMS_Lock_allocator>
_Malloc_Process_deferred_frees();
1010de: e8 4d 87 00 00 call 109830 <_Malloc_Process_deferred_frees>
p = _Heap_Allocate_aligned_with_boundary(
1010e3: 8b 45 10 mov 0x10(%ebp),%eax
1010e6: 89 5c 24 08 mov %ebx,0x8(%esp)
1010ea: 89 74 24 04 mov %esi,0x4(%esp)
1010ee: 89 3c 24 mov %edi,(%esp)
1010f1: 89 44 24 0c mov %eax,0xc(%esp)
1010f5: e8 86 3b 00 00 call 104c80 <_Heap_Allocate_aligned_with_boundary>
1010fa: 89 45 e4 mov %eax,-0x1c(%ebp)
_RTEMS_Unlock_allocator();
1010fd: e8 6e 3a 00 00 call 104b70 <_RTEMS_Unlock_allocator>
101102: 8b 45 e4 mov -0x1c(%ebp),%eax
if ( p == NULL && alignment == 0 && boundary == 0 ) {
101105: 09 c3 or %eax,%ebx
101107: 74 aa je 1010b3 <rtems_heap_allocate_aligned_with_boundary+0x43>
if ( p != NULL && rtems_malloc_dirty_helper != NULL )
101109: 85 c0 test %eax,%eax
10110b: 74 b1 je 1010be <rtems_heap_allocate_aligned_with_boundary+0x4e>
10110d: 8b 15 1c 03 13 00 mov 0x13031c,%edx
101113: 85 d2 test %edx,%edx
101115: 74 a9 je 1010c0 <rtems_heap_allocate_aligned_with_boundary+0x50>
(*rtems_malloc_dirty_helper)( p, size );
101117: 89 74 24 04 mov %esi,0x4(%esp)
10111b: 89 04 24 mov %eax,(%esp)
10111e: 89 45 e4 mov %eax,-0x1c(%ebp)
101121: ff d2 call *%edx
101123: 8b 45 e4 mov -0x1c(%ebp),%eax
}
101126: 8b 5d f4 mov -0xc(%ebp),%ebx
101129: 8b 75 f8 mov -0x8(%ebp),%esi
10112c: 8b 7d fc mov -0x4(%ebp),%edi
10112f: 89 ec mov %ebp,%esp
101131: 5d pop %ebp
101132: c3 ret
101133: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10113a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
p = (*rtems_malloc_extend_handler)( heap, size );
101140: 89 74 24 04 mov %esi,0x4(%esp)
101144: 89 3c 24 mov %edi,(%esp)
101147: ff 15 c0 4f 12 00 call *0x124fc0
10114d: eb ba jmp 101109 <rtems_heap_allocate_aligned_with_boundary+0x99>
10114f: 90 nop
00101330 <rtems_heap_extend_via_sbrk>:
void *rtems_heap_extend_via_sbrk(
Heap_Control *heap,
size_t alloc_size
)
{
101330: 55 push %ebp
101331: 89 e5 mov %esp,%ebp
101333: 56 push %esi
101334: 53 push %ebx
101335: 83 ec 10 sub $0x10,%esp
ptrdiff_t sbrk_amount = RTEMS_Malloc_Sbrk_amount;
101338: 8b 0d 28 84 12 00 mov 0x128428,%ecx
{
10133e: 8b 75 0c mov 0xc(%ebp),%esi
ptrdiff_t sbrk_size = (ptrdiff_t) alloc_size;
ptrdiff_t misaligned = sbrk_amount != 0 ? sbrk_size % sbrk_amount : 0;
101341: 85 c9 test %ecx,%ecx
101343: 74 65 je 1013aa <rtems_heap_extend_via_sbrk+0x7a>
101345: 89 f0 mov %esi,%eax
ptrdiff_t sbrk_size = (ptrdiff_t) alloc_size;
101347: 89 f3 mov %esi,%ebx
ptrdiff_t misaligned = sbrk_amount != 0 ? sbrk_size % sbrk_amount : 0;
101349: 99 cltd
10134a: f7 f9 idiv %ecx
void *return_this = NULL;
if ( misaligned != 0 ) {
10134c: 85 d2 test %edx,%edx
10134e: 75 70 jne 1013c0 <rtems_heap_extend_via_sbrk+0x90>
sbrk_size += sbrk_amount - misaligned;
}
if ( sbrk_size > 0 && sbrk_amount > 0 ) {
101350: 85 db test %ebx,%ebx
101352: 7e 56 jle 1013aa <rtems_heap_extend_via_sbrk+0x7a> <== NEVER TAKEN
101354: 85 c9 test %ecx,%ecx
101356: 7e 52 jle 1013aa <rtems_heap_extend_via_sbrk+0x7a> <== NEVER TAKEN
void *area_begin = sbrk( sbrk_size );
101358: 89 1c 24 mov %ebx,(%esp)
10135b: e8 f0 f2 ff ff call 100650 <sbrk>
if ( area_begin != (void *) -1 ) {
101360: 83 f8 ff cmp $0xffffffff,%eax
101363: 74 45 je 1013aa <rtems_heap_extend_via_sbrk+0x7a>
bool ok = _Protected_heap_Extend( heap, area_begin, sbrk_size );
101365: 89 44 24 04 mov %eax,0x4(%esp)
101369: 8b 45 08 mov 0x8(%ebp),%eax
10136c: 89 5c 24 08 mov %ebx,0x8(%esp)
101370: 89 04 24 mov %eax,(%esp)
101373: e8 98 51 00 00 call 106510 <_Protected_heap_Extend>
if ( ok ) {
101378: 84 c0 test %al,%al
10137a: 74 24 je 1013a0 <rtems_heap_extend_via_sbrk+0x70>
RTEMS_INLINE_ROUTINE void *_Protected_heap_Allocate(
Heap_Control *heap,
uintptr_t size
)
{
return _Protected_heap_Allocate_aligned_with_boundary( heap, size, 0, 0 );
10137c: 89 74 24 04 mov %esi,0x4(%esp)
101380: 31 c0 xor %eax,%eax
101382: 31 d2 xor %edx,%edx
101384: 89 44 24 0c mov %eax,0xc(%esp)
101388: 8b 45 08 mov 0x8(%ebp),%eax
10138b: 89 54 24 08 mov %edx,0x8(%esp)
10138f: 89 04 24 mov %eax,(%esp)
101392: e8 39 51 00 00 call 1064d0 <_Protected_heap_Allocate_aligned_with_boundary>
}
}
}
return return_this;
}
101397: 83 c4 10 add $0x10,%esp
10139a: 5b pop %ebx
10139b: 5e pop %esi
10139c: 5d pop %ebp
10139d: c3 ret
10139e: 66 90 xchg %ax,%ax
sbrk( -sbrk_size );
1013a0: f7 db neg %ebx
1013a2: 89 1c 24 mov %ebx,(%esp)
1013a5: e8 a6 f2 ff ff call 100650 <sbrk>
}
1013aa: 83 c4 10 add $0x10,%esp
void *return_this = NULL;
1013ad: 31 c0 xor %eax,%eax
}
1013af: 5b pop %ebx
1013b0: 5e pop %esi
1013b1: 5d pop %ebp
1013b2: c3 ret
1013b3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1013ba: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
sbrk_size += sbrk_amount - misaligned;
1013c0: 89 cb mov %ecx,%ebx
1013c2: 29 d3 sub %edx,%ebx
1013c4: 01 f3 add %esi,%ebx
1013c6: eb 88 jmp 101350 <rtems_heap_extend_via_sbrk+0x20>
1013c8: 90 nop
1013c9: 90 nop
1013ca: 90 nop
1013cb: 90 nop
1013cc: 90 nop
1013cd: 90 nop
1013ce: 90 nop
1013cf: 90 nop
0010cd70 <rtems_libio_free>:
void rtems_libio_free(
rtems_libio_t *iop
)
{
10cd70: 55 push %ebp
10cd71: 89 e5 mov %esp,%ebp
10cd73: 57 push %edi
10cd74: 56 push %esi
10cd75: 53 push %ebx
10cd76: 83 ec 1c sub $0x1c,%esp
10cd79: 8b 5d 08 mov 0x8(%ebp),%ebx
size_t zero;
rtems_filesystem_location_free( &iop->pathinfo );
10cd7c: 8d 43 0c lea 0xc(%ebx),%eax
10cd7f: 89 04 24 mov %eax,(%esp)
10cd82: e8 e9 ca ff ff call 109870 <rtems_filesystem_location_free>
rtems_libio_lock();
10cd87: e8 d4 cb ff ff call 109960 <rtems_libio_lock>
_ISR_Local_disable( level );
10cd8c: 9c pushf
10cd8d: fa cli
10cd8e: 58 pop %eax
*obj = val & arg;
10cd8f: 81 23 00 f0 ff ff andl $0xfffff000,(%ebx)
_ISR_Local_enable( level );
10cd95: 50 push %eax
10cd96: 9d popf
* Clear everything except the reference count part. At this point in time
* there may be still some holders of this file descriptor.
*/
rtems_libio_iop_flags_clear( iop, LIBIO_FLAGS_REFERENCE_INC - 1U );
zero = offsetof( rtems_libio_t, offset );
memset( (char *) iop + zero, 0, sizeof( *iop ) - zero );
10cd97: 31 f6 xor %esi,%esi
10cd99: f6 c3 01 test $0x1,%bl
10cd9c: 8d 43 04 lea 0x4(%ebx),%eax
10cd9f: b9 28 00 00 00 mov $0x28,%ecx
10cda4: 0f 85 86 00 00 00 jne 10ce30 <rtems_libio_free+0xc0> <== NEVER TAKEN
10cdaa: a8 02 test $0x2,%al
10cdac: 75 72 jne 10ce20 <rtems_libio_free+0xb0> <== NEVER TAKEN
10cdae: 89 cf mov %ecx,%edi
10cdb0: 31 d2 xor %edx,%edx
10cdb2: 83 e7 f8 and $0xfffffff8,%edi
10cdb5: 89 34 10 mov %esi,(%eax,%edx,1)
10cdb8: 89 74 10 04 mov %esi,0x4(%eax,%edx,1)
10cdbc: 83 c2 08 add $0x8,%edx
10cdbf: 39 fa cmp %edi,%edx
10cdc1: 72 f2 jb 10cdb5 <rtems_libio_free+0x45>
10cdc3: 01 d0 add %edx,%eax
10cdc5: f6 c1 04 test $0x4,%cl
10cdc8: 75 46 jne 10ce10 <rtems_libio_free+0xa0> <== NEVER TAKEN
10cdca: f6 c1 02 test $0x2,%cl
10cdcd: 75 31 jne 10ce00 <rtems_libio_free+0x90> <== NEVER TAKEN
10cdcf: f6 c1 01 test $0x1,%cl
10cdd2: 75 1c jne 10cdf0 <rtems_libio_free+0x80> <== NEVER TAKEN
/*
* Append it to the free list. This increases the likelihood that a use
* after close is detected.
*/
*rtems_libio_iop_free_tail = iop;
10cdd4: a1 28 a4 12 00 mov 0x12a428,%eax
10cdd9: 89 18 mov %ebx,(%eax)
rtems_libio_iop_free_tail = &iop->data1;
10cddb: 83 c3 28 add $0x28,%ebx
10cdde: 89 1d 28 a4 12 00 mov %ebx,0x12a428
rtems_libio_unlock();
}
10cde4: 83 c4 1c add $0x1c,%esp
10cde7: 5b pop %ebx
10cde8: 5e pop %esi
10cde9: 5f pop %edi
10cdea: 5d pop %ebp
rtems_libio_unlock();
10cdeb: e9 90 cb ff ff jmp 109980 <rtems_libio_unlock>
memset( (char *) iop + zero, 0, sizeof( *iop ) - zero );
10cdf0: c6 00 00 movb $0x0,(%eax) <== NOT EXECUTED
10cdf3: eb df jmp 10cdd4 <rtems_libio_free+0x64> <== NOT EXECUTED
10cdf5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10cdfc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10ce00: 66 c7 00 00 00 movw $0x0,(%eax) <== NOT EXECUTED
10ce05: 83 c0 02 add $0x2,%eax <== NOT EXECUTED
10ce08: f6 c1 01 test $0x1,%cl <== NOT EXECUTED
10ce0b: 74 c7 je 10cdd4 <rtems_libio_free+0x64> <== NOT EXECUTED
10ce0d: eb e1 jmp 10cdf0 <rtems_libio_free+0x80> <== NOT EXECUTED
10ce0f: 90 nop <== NOT EXECUTED
10ce10: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED
10ce16: 83 c0 04 add $0x4,%eax <== NOT EXECUTED
10ce19: f6 c1 02 test $0x2,%cl <== NOT EXECUTED
10ce1c: 74 b1 je 10cdcf <rtems_libio_free+0x5f> <== NOT EXECUTED
10ce1e: eb e0 jmp 10ce00 <rtems_libio_free+0x90> <== NOT EXECUTED
10ce20: 66 c7 00 00 00 movw $0x0,(%eax) <== NOT EXECUTED
10ce25: 83 e9 02 sub $0x2,%ecx <== NOT EXECUTED
10ce28: 83 c0 02 add $0x2,%eax <== NOT EXECUTED
10ce2b: eb 81 jmp 10cdae <rtems_libio_free+0x3e> <== NOT EXECUTED
10ce2d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
10ce30: c6 43 04 00 movb $0x0,0x4(%ebx) <== NOT EXECUTED
10ce34: 8d 43 05 lea 0x5(%ebx),%eax <== NOT EXECUTED
10ce37: b9 27 00 00 00 mov $0x27,%ecx <== NOT EXECUTED
10ce3c: e9 69 ff ff ff jmp 10cdaa <rtems_libio_free+0x3a> <== NOT EXECUTED
10ce41: 90 nop
10ce42: 90 nop
10ce43: 90 nop
10ce44: 90 nop
10ce45: 90 nop
10ce46: 90 nop
10ce47: 90 nop
10ce48: 90 nop
10ce49: 90 nop
10ce4a: 90 nop
10ce4b: 90 nop
10ce4c: 90 nop
10ce4d: 90 nop
10ce4e: 90 nop
10ce4f: 90 nop
00109a60 <rtems_libio_post_driver>:
/*
* This is a replaceable stub which opens the console, if present.
*/
void rtems_libio_post_driver(void)
{
109a60: 55 push %ebp
/*
* Attempt to open /dev/console.
*/
if ( open( CONSOLE_DEVICE_NAME, O_RDONLY, 0 ) != STDIN_FILENO ) {
109a61: 31 c0 xor %eax,%eax
{
109a63: 89 e5 mov %esp,%ebp
109a65: 83 ec 18 sub $0x18,%esp
if ( open( CONSOLE_DEVICE_NAME, O_RDONLY, 0 ) != STDIN_FILENO ) {
109a68: 89 44 24 08 mov %eax,0x8(%esp)
109a6c: 31 c0 xor %eax,%eax
109a6e: 89 44 24 04 mov %eax,0x4(%esp)
109a72: c7 04 24 13 57 12 00 movl $0x125713,(%esp)
109a79: e8 d2 24 00 00 call 10bf50 <open>
109a7e: 85 c0 test %eax,%eax
109a80: 74 0e je 109a90 <rtems_libio_post_driver+0x30>
if ( open( CONSOLE_DEVICE_NAME, O_WRONLY, 0 ) != STDERR_FILENO ) {
_Internal_error( INTERNAL_ERROR_LIBIO_STDERR_FD_OPEN_FAILED );
}
atexit(rtems_libio_exit);
}
109a82: 89 ec mov %ebp,%esp <== NOT EXECUTED
109a84: 5d pop %ebp <== NOT EXECUTED
109a85: c3 ret <== NOT EXECUTED
109a86: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
109a8d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
if ( open( CONSOLE_DEVICE_NAME, O_WRONLY, 0 ) != STDOUT_FILENO ) {
109a90: c7 04 24 13 57 12 00 movl $0x125713,(%esp)
109a97: 31 c9 xor %ecx,%ecx
109a99: b8 01 00 00 00 mov $0x1,%eax
109a9e: 89 4c 24 08 mov %ecx,0x8(%esp)
109aa2: 89 44 24 04 mov %eax,0x4(%esp)
109aa6: e8 a5 24 00 00 call 10bf50 <open>
109aab: 48 dec %eax
109aac: 75 30 jne 109ade <rtems_libio_post_driver+0x7e>
if ( open( CONSOLE_DEVICE_NAME, O_WRONLY, 0 ) != STDERR_FILENO ) {
109aae: c7 04 24 13 57 12 00 movl $0x125713,(%esp)
109ab5: 31 c0 xor %eax,%eax
109ab7: ba 01 00 00 00 mov $0x1,%edx
109abc: 89 44 24 08 mov %eax,0x8(%esp)
109ac0: 89 54 24 04 mov %edx,0x4(%esp)
109ac4: e8 87 24 00 00 call 10bf50 <open>
109ac9: 83 f8 02 cmp $0x2,%eax
109acc: 75 1c jne 109aea <rtems_libio_post_driver+0x8a>
atexit(rtems_libio_exit);
109ace: c7 04 24 20 bf 10 00 movl $0x10bf20,(%esp)
109ad5: e8 76 f5 00 00 call 119050 <atexit>
}
109ada: 89 ec mov %ebp,%esp
109adc: 5d pop %ebp
109add: c3 ret
_Internal_error( INTERNAL_ERROR_LIBIO_STDOUT_FD_OPEN_FAILED );
109ade: c7 04 24 24 00 00 00 movl $0x24,(%esp)
109ae5: e8 36 b9 ff ff call 105420 <_Internal_error>
_Internal_error( INTERNAL_ERROR_LIBIO_STDERR_FD_OPEN_FAILED );
109aea: c7 04 24 25 00 00 00 movl $0x25,(%esp)
109af1: e8 2a b9 ff ff call 105420 <_Internal_error>
109af6: 90 nop
109af7: 90 nop
109af8: 90 nop
109af9: 90 nop
109afa: 90 nop
109afb: 90 nop
109afc: 90 nop
109afd: 90 nop
109afe: 90 nop
109aff: 90 nop
00104350 <rtems_libio_set_private_env>:
{
104350: 55 push %ebp
104351: 89 e5 mov %esp,%ebp
104353: 83 ec 28 sub $0x28,%esp
104356: 89 5d f4 mov %ebx,-0xc(%ebp)
104359: 31 db xor %ebx,%ebx
10435b: 89 75 f8 mov %esi,-0x8(%ebp)
10435e: 89 7d fc mov %edi,-0x4(%ebp)
rtems_user_env_t *old_env = rtems_current_user_env;
104361: e8 5a 19 00 00 call 105cc0 <rtems_current_user_env_get>
if (uses_global_env) {
104366: 3d 00 9f 28 00 cmp $0x289f00,%eax
10436b: 74 13 je 104380 <rtems_libio_set_private_env+0x30>
}
10436d: 8b 75 f8 mov -0x8(%ebp),%esi
104370: 89 d8 mov %ebx,%eax
104372: 8b 5d f4 mov -0xc(%ebp),%ebx
104375: 8b 7d fc mov -0x4(%ebp),%edi
104378: 89 ec mov %ebp,%esp
10437a: 5d pop %ebp
10437b: c3 ret
10437c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
_Thread_Set_life_protection(THREAD_LIFE_PROTECTED);
104380: c7 04 24 01 00 00 00 movl $0x1,(%esp)
rtems_user_env_t *new_env = calloc(1, sizeof(*new_env));
104387: bb 48 00 00 00 mov $0x48,%ebx
_Thread_Set_life_protection(THREAD_LIFE_PROTECTED);
10438c: e8 7f a0 00 00 call 10e410 <_Thread_Set_life_protection>
rtems_user_env_t *new_env = calloc(1, sizeof(*new_env));
104391: 89 5c 24 04 mov %ebx,0x4(%esp)
104395: c7 04 24 01 00 00 00 movl $0x1,(%esp)
_Thread_Set_life_protection(THREAD_LIFE_PROTECTED);
10439c: 89 c6 mov %eax,%esi
rtems_user_env_t *new_env = calloc(1, sizeof(*new_env));
10439e: e8 3d e9 ff ff call 102ce0 <calloc>
if (new_env != NULL) {
1043a3: 85 c0 test %eax,%eax
rtems_user_env_t *new_env = calloc(1, sizeof(*new_env));
1043a5: 89 c7 mov %eax,%edi
if (new_env != NULL) {
1043a7: 0f 84 a9 00 00 00 je 104456 <rtems_libio_set_private_env+0x106>
*new_env = *old_env;
1043ad: 31 c0 xor %eax,%eax
1043af: 8b 90 00 9f 28 00 mov 0x289f00(%eax),%edx
1043b5: 89 14 07 mov %edx,(%edi,%eax,1)
1043b8: 83 c0 04 add $0x4,%eax
1043bb: 83 f8 48 cmp $0x48,%eax
1043be: 72 ef jb 1043af <rtems_libio_set_private_env+0x5f>
rtems_filesystem_global_location_obtain(&old_env->root_directory);
1043c0: c7 04 24 04 9f 28 00 movl $0x289f04,(%esp)
1043c7: e8 24 13 00 00 call 1056f0 <rtems_filesystem_global_location_obtain>
rtems_filesystem_global_location_obtain(&old_env->current_directory);
1043cc: c7 04 24 00 9f 28 00 movl $0x289f00,(%esp)
new_env->root_directory =
1043d3: 89 47 04 mov %eax,0x4(%edi)
rtems_filesystem_global_location_obtain(&old_env->current_directory);
1043d6: e8 15 13 00 00 call 1056f0 <rtems_filesystem_global_location_obtain>
return loc->handlers == &rtems_filesystem_null_handlers;
1043db: 8b 57 04 mov 0x4(%edi),%edx
if (
1043de: 81 7a 10 e0 0a 14 00 cmpl $0x140ae0,0x10(%edx)
new_env->current_directory =
1043e5: 89 07 mov %eax,(%edi)
if (
1043e7: 74 37 je 104420 <rtems_libio_set_private_env+0xd0>
&& !rtems_filesystem_global_location_is_null(new_env->current_directory)
1043e9: 81 78 10 e0 0a 14 00 cmpl $0x140ae0,0x10(%eax)
1043f0: 74 2e je 104420 <rtems_libio_set_private_env+0xd0> <== NEVER TAKEN
executing->user_environment = new_env;
1043f2: a1 18 e2 28 00 mov 0x28e218,%eax
rtems_status_code sc = RTEMS_SUCCESSFUL;
1043f7: 31 db xor %ebx,%ebx
executing->user_environment = new_env;
1043f9: 89 b8 34 01 00 00 mov %edi,0x134(%eax)
_Thread_Set_life_protection(life_state);
1043ff: 89 34 24 mov %esi,(%esp)
104402: e8 09 a0 00 00 call 10e410 <_Thread_Set_life_protection>
}
104407: 8b 75 f8 mov -0x8(%ebp),%esi
10440a: 89 d8 mov %ebx,%eax
10440c: 8b 7d fc mov -0x4(%ebp),%edi
10440f: 8b 5d f4 mov -0xc(%ebp),%ebx
104412: 89 ec mov %ebp,%esp
104414: 5d pop %ebp
104415: c3 ret
104416: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10441d: 8d 76 00 lea 0x0(%esi),%esi
if (!uses_global_env) {
104420: 81 ff 00 9f 28 00 cmp $0x289f00,%edi
sc = RTEMS_UNSATISFIED;
104426: bb 0d 00 00 00 mov $0xd,%ebx
if (!uses_global_env) {
10442b: 74 d2 je 1043ff <rtems_libio_set_private_env+0xaf> <== NEVER TAKEN
rtems_filesystem_global_location_release(env->current_directory, false);
10442d: 89 04 24 mov %eax,(%esp)
104430: 31 d2 xor %edx,%edx
104432: 89 54 24 04 mov %edx,0x4(%esp)
104436: e8 65 13 00 00 call 1057a0 <rtems_filesystem_global_location_release>
rtems_filesystem_global_location_release(env->root_directory, false);
10443b: 8b 47 04 mov 0x4(%edi),%eax
10443e: 31 c9 xor %ecx,%ecx
104440: 89 4c 24 04 mov %ecx,0x4(%esp)
104444: 89 04 24 mov %eax,(%esp)
104447: e8 54 13 00 00 call 1057a0 <rtems_filesystem_global_location_release>
free(env);
10444c: 89 3c 24 mov %edi,(%esp)
10444f: e8 ec eb ff ff call 103040 <free>
}
104454: eb a9 jmp 1043ff <rtems_libio_set_private_env+0xaf>
sc = RTEMS_NO_MEMORY;
104456: bb 1a 00 00 00 mov $0x1a,%ebx
10445b: eb a2 jmp 1043ff <rtems_libio_set_private_env+0xaf>
10445d: 90 nop
10445e: 90 nop
10445f: 90 nop
00102140 <rtems_libio_to_fcntl_flags>:
int rtems_libio_to_fcntl_flags( unsigned int flags )
{
102140: 55 push %ebp
102141: 89 e5 mov %esp,%ebp
102143: 8b 55 08 mov 0x8(%ebp),%edx
int fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
102146: 89 d0 mov %edx,%eax
102148: 83 e0 06 and $0x6,%eax
10214b: 83 f8 06 cmp $0x6,%eax
10214e: 74 30 je 102180 <rtems_libio_to_fcntl_flags+0x40>
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
fcntl_flags |= O_RDONLY;
102150: 31 c0 xor %eax,%eax
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
102152: f6 c2 02 test $0x2,%dl
102155: 74 19 je 102170 <rtems_libio_to_fcntl_flags+0x30> <== NEVER TAKEN
} else if ( (flags & LIBIO_FLAGS_WRITE) == LIBIO_FLAGS_WRITE) {
fcntl_flags |= O_WRONLY;
}
if ( (flags & LIBIO_FLAGS_NO_DELAY) == LIBIO_FLAGS_NO_DELAY ) {
102157: f6 c2 01 test $0x1,%dl
10215a: 74 05 je 102161 <rtems_libio_to_fcntl_flags+0x21>
fcntl_flags |= O_NONBLOCK;
10215c: 0d 00 40 00 00 or $0x4000,%eax
}
if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) {
102161: f6 c6 02 test $0x2,%dh
102164: 74 03 je 102169 <rtems_libio_to_fcntl_flags+0x29>
fcntl_flags |= O_APPEND;
102166: 83 c8 08 or $0x8,%eax
}
return fcntl_flags;
}
102169: 5d pop %ebp
10216a: c3 ret
10216b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10216f: 90 nop
} else if ( (flags & LIBIO_FLAGS_WRITE) == LIBIO_FLAGS_WRITE) {
102170: 89 d0 mov %edx,%eax <== NOT EXECUTED
102172: c1 e8 02 shr $0x2,%eax <== NOT EXECUTED
fcntl_flags |= O_WRONLY;
102175: 83 e0 01 and $0x1,%eax <== NOT EXECUTED
102178: eb dd jmp 102157 <rtems_libio_to_fcntl_flags+0x17> <== NOT EXECUTED
10217a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
fcntl_flags |= O_RDWR;
102180: b8 02 00 00 00 mov $0x2,%eax
102185: eb d0 jmp 102157 <rtems_libio_to_fcntl_flags+0x17>
102187: 90 nop
102188: 90 nop
102189: 90 nop
10218a: 90 nop
10218b: 90 nop
10218c: 90 nop
10218d: 90 nop
10218e: 90 nop
10218f: 90 nop
001008c0 <rtems_malloc_dirty_memory>:
void rtems_malloc_dirty_memory(
void *start,
size_t size
)
{
1008c0: 55 push %ebp
1008c1: 89 e5 mov %esp,%ebp
1008c3: 57 push %edi
(void) memset(start, 0xCF, size);
1008c4: 8b 55 0c mov 0xc(%ebp),%edx
1008c7: 8b 7d 08 mov 0x8(%ebp),%edi
1008ca: 83 fa 08 cmp $0x8,%edx
1008cd: 73 31 jae 100900 <rtems_malloc_dirty_memory+0x40>
1008cf: f6 c2 04 test $0x4,%dl
1008d2: 74 09 je 1008dd <rtems_malloc_dirty_memory+0x1d>
1008d4: c7 07 cf cf cf cf movl $0xcfcfcfcf,(%edi)
1008da: 83 c7 04 add $0x4,%edi
1008dd: f6 c2 02 test $0x2,%dl
1008e0: 74 08 je 1008ea <rtems_malloc_dirty_memory+0x2a>
1008e2: 66 c7 07 cf cf movw $0xcfcf,(%edi)
1008e7: 83 c7 02 add $0x2,%edi
1008ea: f6 c2 01 test $0x1,%dl
1008ed: 74 03 je 1008f2 <rtems_malloc_dirty_memory+0x32>
1008ef: c6 07 cf movb $0xcf,(%edi) <== NOT EXECUTED
}
1008f2: 5f pop %edi
1008f3: 5d pop %ebp
1008f4: c3 ret
1008f5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1008fc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
(void) memset(start, 0xCF, size);
100900: f7 c7 01 00 00 00 test $0x1,%edi
100906: 75 28 jne 100930 <rtems_malloc_dirty_memory+0x70> <== NEVER TAKEN
100908: f7 c7 02 00 00 00 test $0x2,%edi
10090e: 75 30 jne 100940 <rtems_malloc_dirty_memory+0x80> <== NEVER TAKEN
100910: f7 c7 04 00 00 00 test $0x4,%edi
100916: 75 38 jne 100950 <rtems_malloc_dirty_memory+0x90>
100918: 89 d1 mov %edx,%ecx
10091a: b8 cf cf cf cf mov $0xcfcfcfcf,%eax
10091f: c1 e9 02 shr $0x2,%ecx
100922: 83 e2 03 and $0x3,%edx
100925: f3 ab rep stos %eax,%es:(%edi)
100927: eb a6 jmp 1008cf <rtems_malloc_dirty_memory+0xf>
100929: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
100930: c6 07 cf movb $0xcf,(%edi) <== NOT EXECUTED
100933: 4a dec %edx <== NOT EXECUTED
100934: 47 inc %edi <== NOT EXECUTED
100935: eb d1 jmp 100908 <rtems_malloc_dirty_memory+0x48> <== NOT EXECUTED
100937: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10093e: 66 90 xchg %ax,%ax <== NOT EXECUTED
100940: 66 c7 07 cf cf movw $0xcfcf,(%edi) <== NOT EXECUTED
100945: 83 ea 02 sub $0x2,%edx <== NOT EXECUTED
100948: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
10094b: eb c3 jmp 100910 <rtems_malloc_dirty_memory+0x50> <== NOT EXECUTED
10094d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
100950: c7 07 cf cf cf cf movl $0xcfcfcfcf,(%edi)
100956: 83 ea 04 sub $0x4,%edx
100959: 83 c7 04 add $0x4,%edi
10095c: eb ba jmp 100918 <rtems_malloc_dirty_memory+0x58>
10095e: 90 nop
10095f: 90 nop
00104a10 <rtems_mkdir>:
return (retval);
}
int
rtems_mkdir(const char *path, mode_t mode)
{
104a10: 55 push %ebp
104a11: 89 e5 mov %esp,%ebp
104a13: 57 push %edi
104a14: 56 push %esi
104a15: 53 push %ebx
104a16: 81 ec 8c 00 00 00 sub $0x8c,%esp
int success = 0;
char *dup_path = strdup(path);
104a1c: 8b 45 08 mov 0x8(%ebp),%eax
104a1f: 89 04 24 mov %eax,(%esp)
104a22: e8 69 80 02 00 call 12ca90 <strdup>
if (dup_path != NULL) {
104a27: 85 c0 test %eax,%eax
104a29: 0f 84 54 01 00 00 je 104b83 <rtems_mkdir+0x173>
104a2f: 89 c7 mov %eax,%edi
if (p[0] == '/') /* Skip leading '/'. */
104a31: 0f b6 00 movzbl (%eax),%eax
104a34: 89 fb mov %edi,%ebx
104a36: 3c 2f cmp $0x2f,%al
104a38: 75 07 jne 104a41 <rtems_mkdir+0x31>
if (p[0] == '\0')
104a3a: 0f b6 47 01 movzbl 0x1(%edi),%eax
++p;
104a3e: 8d 5f 01 lea 0x1(%edi),%ebx
if (p[0] == '\0')
104a41: 43 inc %ebx
*p = '/';
104a42: 31 f6 xor %esi,%esi
if (p[0] == '\0')
104a44: 84 c0 test %al,%al
*p = '/';
104a46: ba 01 00 00 00 mov $0x1,%edx
if (p[0] == '\0')
104a4b: 74 41 je 104a8e <rtems_mkdir+0x7e> <== NEVER TAKEN
104a4d: 8d 76 00 lea 0x0(%esi),%esi
else if (p[0] != '/')
104a50: 3c 2f cmp $0x2f,%al
104a52: 75 32 jne 104a86 <rtems_mkdir+0x76>
*p = '\0';
104a54: c6 43 ff 00 movb $0x0,-0x1(%ebx)
if (first) {
104a58: 85 d2 test %edx,%edx
if (!last && p[1] == '\0')
104a5a: 0f b6 0b movzbl (%ebx),%ecx
if (first) {
104a5d: 0f 85 28 01 00 00 jne 104b8b <rtems_mkdir+0x17b>
if (last)
104a63: 84 c9 test %cl,%cl
104a65: 74 46 je 104aad <rtems_mkdir+0x9d> <== NEVER TAKEN
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
104a67: 89 3c 24 mov %edi,(%esp)
104a6a: b8 ff 01 00 00 mov $0x1ff,%eax
104a6f: 89 44 24 04 mov %eax,0x4(%esp)
104a73: e8 b8 ea ff ff call 103530 <mkdir>
104a78: 85 c0 test %eax,%eax
104a7a: 0f 88 b0 00 00 00 js 104b30 <rtems_mkdir+0x120>
*p = '/';
104a80: c6 43 ff 2f movb $0x2f,-0x1(%ebx)
104a84: 31 d2 xor %edx,%edx
if (p[0] == '\0')
104a86: 0f b6 03 movzbl (%ebx),%eax
104a89: 43 inc %ebx
104a8a: 84 c0 test %al,%al
104a8c: 75 c2 jne 104a50 <rtems_mkdir+0x40>
if (first) {
104a8e: 85 d2 test %edx,%edx
104a90: 74 1b je 104aad <rtems_mkdir+0x9d>
oumask = umask(0);
104a92: c7 04 24 00 00 00 00 movl $0x0,(%esp)
104a99: e8 12 0f 00 00 call 1059b0 <umask>
104a9e: 89 c6 mov %eax,%esi
numask = oumask & ~(S_IWUSR | S_IXUSR);
104aa0: 25 3f ff ff ff and $0xffffff3f,%eax
(void)umask(numask);
104aa5: 89 04 24 mov %eax,(%esp)
104aa8: e8 03 0f 00 00 call 1059b0 <umask>
(void)umask(oumask);
104aad: 89 34 24 mov %esi,(%esp)
104ab0: e8 fb 0e 00 00 call 1059b0 <umask>
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
104ab5: 8b 45 0c mov 0xc(%ebp),%eax
104ab8: 89 3c 24 mov %edi,(%esp)
104abb: 89 44 24 04 mov %eax,0x4(%esp)
104abf: e8 6c ea ff ff call 103530 <mkdir>
104ac4: 85 c0 test %eax,%eax
104ac6: 78 18 js 104ae0 <rtems_mkdir+0xd0>
104ac8: 31 db xor %ebx,%ebx
success = build(dup_path, mode);
free(dup_path);
104aca: 89 3c 24 mov %edi,(%esp)
104acd: e8 6e e5 ff ff call 103040 <free>
}
return success != 0 ? 0 : -1;
}
104ad2: 81 c4 8c 00 00 00 add $0x8c,%esp
104ad8: 89 d8 mov %ebx,%eax
104ada: 5b pop %ebx
104adb: 5e pop %esi
104adc: 5f pop %edi
104add: 5d pop %ebp
104ade: c3 ret
104adf: 90 nop
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
104ae0: c7 45 84 01 00 00 00 movl $0x1,-0x7c(%ebp)
if (errno == EEXIST || errno == EISDIR) {
104ae7: e8 c4 50 02 00 call 129bb0 <__errno>
104aec: 83 38 11 cmpl $0x11,(%eax)
104aef: 74 0a je 104afb <rtems_mkdir+0xeb>
104af1: e8 ba 50 02 00 call 129bb0 <__errno>
104af6: 83 38 15 cmpl $0x15,(%eax)
104af9: 75 3e jne 104b39 <rtems_mkdir+0x129> <== ALWAYS TAKEN
if (stat(path, &sb) < 0) {
104afb: 89 3c 24 mov %edi,(%esp)
104afe: 8d 45 90 lea -0x70(%ebp),%eax
104b01: 89 44 24 04 mov %eax,0x4(%esp)
104b05: e8 e6 00 00 00 call 104bf0 <stat>
104b0a: 85 c0 test %eax,%eax
104b0c: 78 2b js 104b39 <rtems_mkdir+0x129> <== NEVER TAKEN
} else if (!S_ISDIR(sb.st_mode)) {
104b0e: 8b 45 a0 mov -0x60(%ebp),%eax
104b11: 25 00 f0 00 00 and $0xf000,%eax
104b16: 3d 00 40 00 00 cmp $0x4000,%eax
104b1b: 75 35 jne 104b52 <rtems_mkdir+0x142>
if (last)
104b1d: 8b 4d 84 mov -0x7c(%ebp),%ecx
104b20: 85 c9 test %ecx,%ecx
104b22: 75 a4 jne 104ac8 <rtems_mkdir+0xb8>
104b24: e9 57 ff ff ff jmp 104a80 <rtems_mkdir+0x70>
104b29: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
104b30: c7 45 84 00 00 00 00 movl $0x0,-0x7c(%ebp)
104b37: eb ae jmp 104ae7 <rtems_mkdir+0xd7>
if (!first && !last)
104b39: 8b 55 84 mov -0x7c(%ebp),%edx
104b3c: 85 d2 test %edx,%edx
104b3e: 75 3b jne 104b7b <rtems_mkdir+0x16b> <== ALWAYS TAKEN
(void)umask(oumask);
104b40: 89 34 24 mov %esi,(%esp)
104b43: bb ff ff ff ff mov $0xffffffff,%ebx
104b48: e8 63 0e 00 00 call 1059b0 <umask>
104b4d: e9 78 ff ff ff jmp 104aca <rtems_mkdir+0xba>
if (last)
104b52: 8b 5d 84 mov -0x7c(%ebp),%ebx
104b55: 85 db test %ebx,%ebx
104b57: 74 15 je 104b6e <rtems_mkdir+0x15e>
errno = EEXIST;
104b59: e8 52 50 02 00 call 129bb0 <__errno>
104b5e: bb ff ff ff ff mov $0xffffffff,%ebx
104b63: c7 00 11 00 00 00 movl $0x11,(%eax)
104b69: e9 5c ff ff ff jmp 104aca <rtems_mkdir+0xba>
errno = ENOTDIR;
104b6e: e8 3d 50 02 00 call 129bb0 <__errno>
104b73: c7 00 14 00 00 00 movl $0x14,(%eax)
if (!first && !last)
104b79: eb c5 jmp 104b40 <rtems_mkdir+0x130>
free(dup_path);
104b7b: 89 3c 24 mov %edi,(%esp)
104b7e: e8 bd e4 ff ff call 103040 <free>
return success != 0 ? 0 : -1;
104b83: 83 cb ff or $0xffffffff,%ebx
104b86: e9 47 ff ff ff jmp 104ad2 <rtems_mkdir+0xc2>
oumask = umask(0);
104b8b: c7 04 24 00 00 00 00 movl $0x0,(%esp)
104b92: 88 4d 84 mov %cl,-0x7c(%ebp)
104b95: e8 16 0e 00 00 call 1059b0 <umask>
104b9a: 89 c6 mov %eax,%esi
numask = oumask & ~(S_IWUSR | S_IXUSR);
104b9c: 25 3f ff ff ff and $0xffffff3f,%eax
(void)umask(numask);
104ba1: 89 04 24 mov %eax,(%esp)
104ba4: e8 07 0e 00 00 call 1059b0 <umask>
104ba9: 0f b6 4d 84 movzbl -0x7c(%ebp),%ecx
first = 0;
104bad: e9 b1 fe ff ff jmp 104a63 <rtems_mkdir+0x53>
104bb2: 90 nop
104bb3: 90 nop
104bb4: 90 nop
104bb5: 90 nop
104bb6: 90 nop
104bb7: 90 nop
104bb8: 90 nop
104bb9: 90 nop
104bba: 90 nop
104bbb: 90 nop
104bbc: 90 nop
104bbd: 90 nop
104bbe: 90 nop
104bbf: 90 nop
00103630 <rtems_print_printer_printf>:
void rtems_print_printer_printf(rtems_printer *printer)
{
103630: 55 push %ebp <== NOT EXECUTED
103631: 89 e5 mov %esp,%ebp <== NOT EXECUTED
103633: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
printer->context = NULL;
103636: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED
printer->printer = rtems_printf_plugin;
10363c: c7 40 04 10 36 10 00 movl $0x103610,0x4(%eax) <== NOT EXECUTED
}
103643: 5d pop %ebp <== NOT EXECUTED
103644: c3 ret <== NOT EXECUTED
103645: 90 nop
103646: 90 nop
103647: 90 nop
103648: 90 nop
103649: 90 nop
10364a: 90 nop
10364b: 90 nop
10364c: 90 nop
10364d: 90 nop
10364e: 90 nop
10364f: 90 nop
00118200 <rtems_printf>:
int rtems_printf(
const rtems_printer *printer,
const char *format,
...
)
{
118200: 55 push %ebp
118201: 89 e5 mov %esp,%ebp
118203: 83 ec 18 sub $0x18,%esp
118206: 8b 45 08 mov 0x8(%ebp),%eax
118209: 85 c0 test %eax,%eax
11820b: 74 23 je 118230 <rtems_printf+0x30>
11820d: 8b 50 04 mov 0x4(%eax),%edx
118210: 85 d2 test %edx,%edx
118212: 74 1c je 118230 <rtems_printf+0x30> <== NEVER TAKEN
int len = 0;
if ( rtems_print_printer_valid( printer ) ) {
va_list ap;
va_start( ap, format );
118214: 8d 55 10 lea 0x10(%ebp),%edx
len = printer->printer( printer->context, format, ap );
118217: 89 54 24 08 mov %edx,0x8(%esp)
11821b: 8b 55 0c mov 0xc(%ebp),%edx
11821e: 89 54 24 04 mov %edx,0x4(%esp)
118222: 8b 10 mov (%eax),%edx
118224: 89 14 24 mov %edx,(%esp)
118227: ff 50 04 call *0x4(%eax)
va_end( ap );
}
return len;
}
11822a: 89 ec mov %ebp,%esp
11822c: 5d pop %ebp
11822d: c3 ret
11822e: 66 90 xchg %ax,%ax
118230: 89 ec mov %ebp,%esp
int len = 0;
118232: 31 c0 xor %eax,%eax
}
118234: 5d pop %ebp
118235: c3 ret
118236: 90 nop
118237: 90 nop
118238: 90 nop
118239: 90 nop
11823a: 90 nop
11823b: 90 nop
11823c: 90 nop
11823d: 90 nop
11823e: 90 nop
11823f: 90 nop
001048c0 <rtems_resource_snapshot_take>:
return count;
}
void rtems_resource_snapshot_take(rtems_resource_snapshot *snapshot)
{
1048c0: 55 push %ebp
uint32_t *active;
size_t i;
memset(snapshot, 0, sizeof(*snapshot));
1048c1: 31 c9 xor %ecx,%ecx
{
1048c3: 89 e5 mov %esp,%ebp
1048c5: 57 push %edi
1048c6: bf f4 00 00 00 mov $0xf4,%edi
1048cb: 56 push %esi
1048cc: 53 push %ebx
1048cd: 83 ec 2c sub $0x2c,%esp
1048d0: 8b 75 08 mov 0x8(%ebp),%esi
memset(snapshot, 0, sizeof(*snapshot));
1048d3: f7 c6 01 00 00 00 test $0x1,%esi
1048d9: 89 f2 mov %esi,%edx
1048db: 0f 85 01 02 00 00 jne 104ae2 <rtems_resource_snapshot_take+0x222> <== NEVER TAKEN
1048e1: f6 c2 02 test $0x2,%dl
1048e4: 0f 85 0c 02 00 00 jne 104af6 <rtems_resource_snapshot_take+0x236> <== NEVER TAKEN
1048ea: 89 fb mov %edi,%ebx
1048ec: 31 c0 xor %eax,%eax
1048ee: 83 e3 f8 and $0xfffffff8,%ebx
1048f1: 89 0c 02 mov %ecx,(%edx,%eax,1)
1048f4: 89 4c 02 04 mov %ecx,0x4(%edx,%eax,1)
1048f8: 83 c0 08 add $0x8,%eax
1048fb: 39 d8 cmp %ebx,%eax
1048fd: 72 f2 jb 1048f1 <rtems_resource_snapshot_take+0x31>
1048ff: 01 c2 add %eax,%edx
104901: f7 c7 04 00 00 00 test $0x4,%edi
104907: 0f 85 0e 02 00 00 jne 104b1b <rtems_resource_snapshot_take+0x25b> <== ALWAYS TAKEN
10490d: f7 c7 02 00 00 00 test $0x2,%edi
104913: 0f 85 f5 01 00 00 jne 104b0e <rtems_resource_snapshot_take+0x24e> <== NEVER TAKEN
104919: 83 e7 01 and $0x1,%edi
10491c: 0f 85 e4 01 00 00 jne 104b06 <rtems_resource_snapshot_take+0x246> <== NEVER TAKEN
_RTEMS_Lock_allocator();
104922: e8 59 38 00 00 call 108180 <_RTEMS_Lock_allocator>
memset(&info->Stats, 0, sizeof(info->Stats));
104927: bf 40 00 00 00 mov $0x40,%edi
_Thread_Kill_zombies();
10492c: e8 5f 75 00 00 call 10be90 <_Thread_Kill_zombies>
get_heap_info(RTEMS_Malloc_Heap, &snapshot->heap_info);
104931: 8d 46 58 lea 0x58(%esi),%eax
104934: 89 44 24 04 mov %eax,0x4(%esp)
_Heap_Get_information(heap, info);
104938: a1 0c 48 13 00 mov 0x13480c,%eax
10493d: 89 04 24 mov %eax,(%esp)
104940: e8 0b 41 00 00 call 108a50 <_Heap_Get_information>
memset(&info->Stats, 0, sizeof(info->Stats));
104945: 8d 56 70 lea 0x70(%esi),%edx
104948: 31 c9 xor %ecx,%ecx
10494a: f7 c6 01 00 00 00 test $0x1,%esi
104950: 0f 85 e3 01 00 00 jne 104b39 <rtems_resource_snapshot_take+0x279> <== NEVER TAKEN
104956: f6 c2 02 test $0x2,%dl
104959: 0f 85 ca 01 00 00 jne 104b29 <rtems_resource_snapshot_take+0x269> <== NEVER TAKEN
10495f: 89 fb mov %edi,%ebx
104961: 31 c0 xor %eax,%eax
104963: 83 e3 f8 and $0xfffffff8,%ebx
104966: 89 0c 02 mov %ecx,(%edx,%eax,1)
104969: 89 4c 02 04 mov %ecx,0x4(%edx,%eax,1)
10496d: 83 c0 08 add $0x8,%eax
104970: 39 d8 cmp %ebx,%eax
104972: 72 f2 jb 104966 <rtems_resource_snapshot_take+0xa6>
104974: 01 c2 add %eax,%edx
104976: f7 c7 04 00 00 00 test $0x4,%edi
10497c: 74 09 je 104987 <rtems_resource_snapshot_take+0xc7> <== ALWAYS TAKEN
10497e: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED
104984: 83 c2 04 add $0x4,%edx <== NOT EXECUTED
104987: f7 c7 02 00 00 00 test $0x2,%edi
10498d: 74 08 je 104997 <rtems_resource_snapshot_take+0xd7> <== ALWAYS TAKEN
10498f: 66 c7 02 00 00 movw $0x0,(%edx) <== NOT EXECUTED
104994: 83 c2 02 add $0x2,%edx <== NOT EXECUTED
104997: 83 e7 01 and $0x1,%edi
10499a: 74 03 je 10499f <rtems_resource_snapshot_take+0xdf> <== ALWAYS TAKEN
10499c: c6 02 00 movb $0x0,(%edx) <== NOT EXECUTED
_Heap_Get_information(heap, info);
10499f: 89 74 24 04 mov %esi,0x4(%esp)
memset(&info->Stats, 0, sizeof(info->Stats));
1049a3: bb 40 00 00 00 mov $0x40,%ebx
_Heap_Get_information(heap, info);
1049a8: c7 04 24 a0 48 13 00 movl $0x1348a0,(%esp)
1049af: e8 9c 40 00 00 call 108a50 <_Heap_Get_information>
memset(&info->Stats, 0, sizeof(info->Stats));
1049b4: 8d 56 18 lea 0x18(%esi),%edx
1049b7: 31 c9 xor %ecx,%ecx
1049b9: f7 c6 01 00 00 00 test $0x1,%esi
1049bf: 0f 85 95 01 00 00 jne 104b5a <rtems_resource_snapshot_take+0x29a> <== NEVER TAKEN
1049c5: f6 c2 02 test $0x2,%dl
1049c8: 0f 85 7c 01 00 00 jne 104b4a <rtems_resource_snapshot_take+0x28a> <== NEVER TAKEN
1049ce: 89 df mov %ebx,%edi
1049d0: 31 c0 xor %eax,%eax
1049d2: 83 e7 f8 and $0xfffffff8,%edi
1049d5: 89 0c 02 mov %ecx,(%edx,%eax,1)
1049d8: 89 4c 02 04 mov %ecx,0x4(%edx,%eax,1)
1049dc: 83 c0 08 add $0x8,%eax
1049df: 39 f8 cmp %edi,%eax
1049e1: 72 f2 jb 1049d5 <rtems_resource_snapshot_take+0x115>
1049e3: 01 c2 add %eax,%edx
1049e5: f6 c3 04 test $0x4,%bl
1049e8: 74 09 je 1049f3 <rtems_resource_snapshot_take+0x133> <== ALWAYS TAKEN
1049ea: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED
1049f0: 83 c2 04 add $0x4,%edx <== NOT EXECUTED
1049f3: f6 c3 02 test $0x2,%bl
1049f6: 74 08 je 104a00 <rtems_resource_snapshot_take+0x140> <== ALWAYS TAKEN
1049f8: 66 c7 02 00 00 movw $0x0,(%edx) <== NOT EXECUTED
1049fd: 83 c2 02 add $0x2,%edx <== NOT EXECUTED
104a00: f6 c3 01 test $0x1,%bl
104a03: 74 03 je 104a08 <rtems_resource_snapshot_take+0x148> <== ALWAYS TAKEN
104a05: c6 02 00 movb $0x0,(%edx) <== NOT EXECUTED
104a08: ba 03 00 00 00 mov $0x3,%edx
104a0d: b8 02 00 00 00 mov $0x2,%eax
get_heap_info(&_Workspace_Area, &snapshot->workspace_info);
active = &snapshot->active_posix_keys;
for (i = 0; i < RTEMS_ARRAY_SIZE(objects_info_table); ++i) {
104a12: 31 db xor %ebx,%ebx
104a14: eb 19 jmp 104a2f <rtems_resource_snapshot_take+0x16f>
104a16: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
104a1d: 8d 76 00 lea 0x0(%esi),%esi
const Objects_Information *information;
information = _Objects_Get_information(
objects_info_table[i].api,
objects_info_table[i].cls
104a20: 0f b7 04 dd 04 b1 12 movzwl 0x12b104(,%ebx,8),%eax <== NOT EXECUTED
104a27: 00
information = _Objects_Get_information(
104a28: 8b 14 dd 00 b1 12 00 mov 0x12b100(,%ebx,8),%edx <== NOT EXECUTED
104a2f: 89 44 24 04 mov %eax,0x4(%esp)
104a33: 89 14 24 mov %edx,(%esp)
104a36: e8 05 56 00 00 call 10a040 <_Objects_Get_information>
);
if (information != NULL) {
104a3b: 85 c0 test %eax,%eax
104a3d: 74 12 je 104a51 <rtems_resource_snapshot_take+0x191>
active[i] = _Objects_Active_count(information);
104a3f: 89 04 24 mov %eax,(%esp)
104a42: e8 59 55 00 00 call 109fa0 <_Objects_Active_count>
104a47: 0f b7 c0 movzwl %ax,%eax
104a4a: 89 84 9e b4 00 00 00 mov %eax,0xb4(%esi,%ebx,4)
for (i = 0; i < RTEMS_ARRAY_SIZE(objects_info_table); ++i) {
104a51: 43 inc %ebx
104a52: 83 fb 0f cmp $0xf,%ebx
104a55: 75 c9 jne 104a20 <rtems_resource_snapshot_take+0x160>
}
}
_RTEMS_Unlock_allocator();
104a57: e8 44 37 00 00 call 1081a0 <_RTEMS_Unlock_allocator>
uint32_t count = 0;
104a5c: 31 db xor %ebx,%ebx
while ((the_key = get_next_key(&id)) != NULL ) {
104a5e: 31 c0 xor %eax,%eax
Objects_Id id = OBJECTS_ID_INITIAL_INDEX;
104a60: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
while ((the_key = get_next_key(&id)) != NULL ) {
104a67: 8d 7d e4 lea -0x1c(%ebp),%edi
104a6a: eb 19 jmp 104a85 <rtems_resource_snapshot_take+0x1c5>
104a6c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
count += _Chain_Node_count_unprotected(&the_key->Key_value_pairs);
104a70: 83 c0 14 add $0x14,%eax
104a73: 89 04 24 mov %eax,(%esp)
104a76: e8 35 38 00 00 call 1082b0 <_Chain_Node_count_unprotected>
104a7b: 01 c3 add %eax,%ebx
* 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();
104a7d: e8 1e 37 00 00 call 1081a0 <_RTEMS_Unlock_allocator>
_Objects_Get_next(*id, &_POSIX_Keys_Information, id);
104a82: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED
104a85: 89 7c 24 08 mov %edi,0x8(%esp)
104a89: ba 00 07 13 00 mov $0x130700,%edx
104a8e: 89 54 24 04 mov %edx,0x4(%esp)
104a92: 89 04 24 mov %eax,(%esp)
104a95: e8 f6 55 00 00 call 10a090 <_Objects_Get_next>
while ((the_key = get_next_key(&id)) != NULL ) {
104a9a: 85 c0 test %eax,%eax
104a9c: 75 d2 jne 104a70 <rtems_resource_snapshot_take+0x1b0>
snapshot->active_posix_key_value_pairs = get_active_posix_key_value_pairs();
104a9e: 89 9e b0 00 00 00 mov %ebx,0xb0(%esi)
int free_count = 0;
104aa4: 31 db xor %ebx,%ebx
rtems_libio_lock();
104aa6: e8 45 ed ff ff call 1037f0 <rtems_libio_lock>
iop = rtems_libio_iop_free_head;
104aab: a1 04 48 13 00 mov 0x134804,%eax
while (iop != NULL) {
104ab0: 85 c0 test %eax,%eax
104ab2: 74 14 je 104ac8 <rtems_resource_snapshot_take+0x208>
104ab4: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
104abb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
104abf: 90 nop
iop = iop->data1;
104ac0: 8b 40 28 mov 0x28(%eax),%eax
++free_count;
104ac3: 43 inc %ebx
while (iop != NULL) {
104ac4: 85 c0 test %eax,%eax
104ac6: 75 f8 jne 104ac0 <rtems_resource_snapshot_take+0x200>
rtems_libio_unlock();
104ac8: e8 43 ed ff ff call 103810 <rtems_libio_unlock>
return (int) rtems_libio_number_iops - free_count;
104acd: a1 64 a8 12 00 mov 0x12a864,%eax
104ad2: 29 d8 sub %ebx,%eax
snapshot->open_files = open_files();
104ad4: 89 86 f0 00 00 00 mov %eax,0xf0(%esi)
}
104ada: 83 c4 2c add $0x2c,%esp
104add: 5b pop %ebx
104ade: 5e pop %esi
104adf: 5f pop %edi
104ae0: 5d pop %ebp
104ae1: c3 ret
memset(snapshot, 0, sizeof(*snapshot));
104ae2: c6 06 00 movb $0x0,(%esi) <== NOT EXECUTED
104ae5: 8d 56 01 lea 0x1(%esi),%edx <== NOT EXECUTED
104ae8: bf f3 00 00 00 mov $0xf3,%edi <== NOT EXECUTED
104aed: f6 c2 02 test $0x2,%dl <== NOT EXECUTED
104af0: 0f 84 f4 fd ff ff je 1048ea <rtems_resource_snapshot_take+0x2a> <== NOT EXECUTED
104af6: 66 c7 02 00 00 movw $0x0,(%edx) <== NOT EXECUTED
104afb: 83 ef 02 sub $0x2,%edi <== NOT EXECUTED
104afe: 83 c2 02 add $0x2,%edx <== NOT EXECUTED
104b01: e9 e4 fd ff ff jmp 1048ea <rtems_resource_snapshot_take+0x2a> <== NOT EXECUTED
104b06: c6 02 00 movb $0x0,(%edx) <== NOT EXECUTED
104b09: e9 14 fe ff ff jmp 104922 <rtems_resource_snapshot_take+0x62> <== NOT EXECUTED
104b0e: 66 c7 02 00 00 movw $0x0,(%edx) <== NOT EXECUTED
104b13: 83 c2 02 add $0x2,%edx <== NOT EXECUTED
104b16: e9 fe fd ff ff jmp 104919 <rtems_resource_snapshot_take+0x59> <== NOT EXECUTED
104b1b: c7 02 00 00 00 00 movl $0x0,(%edx)
104b21: 83 c2 04 add $0x4,%edx
104b24: e9 e4 fd ff ff jmp 10490d <rtems_resource_snapshot_take+0x4d>
memset(&info->Stats, 0, sizeof(info->Stats));
104b29: 66 c7 02 00 00 movw $0x0,(%edx) <== NOT EXECUTED
104b2e: 83 ef 02 sub $0x2,%edi <== NOT EXECUTED
104b31: 83 c2 02 add $0x2,%edx <== NOT EXECUTED
104b34: e9 26 fe ff ff jmp 10495f <rtems_resource_snapshot_take+0x9f> <== NOT EXECUTED
104b39: c6 46 70 00 movb $0x0,0x70(%esi) <== NOT EXECUTED
104b3d: 8d 56 71 lea 0x71(%esi),%edx <== NOT EXECUTED
104b40: bf 3f 00 00 00 mov $0x3f,%edi <== NOT EXECUTED
104b45: e9 0c fe ff ff jmp 104956 <rtems_resource_snapshot_take+0x96> <== NOT EXECUTED
104b4a: 66 c7 02 00 00 movw $0x0,(%edx) <== NOT EXECUTED
104b4f: 83 eb 02 sub $0x2,%ebx <== NOT EXECUTED
104b52: 83 c2 02 add $0x2,%edx <== NOT EXECUTED
104b55: e9 74 fe ff ff jmp 1049ce <rtems_resource_snapshot_take+0x10e> <== NOT EXECUTED
104b5a: c6 46 18 00 movb $0x0,0x18(%esi) <== NOT EXECUTED
104b5e: 8d 56 19 lea 0x19(%esi),%edx <== NOT EXECUTED
104b61: bb 3f 00 00 00 mov $0x3f,%ebx <== NOT EXECUTED
104b66: e9 5a fe ff ff jmp 1049c5 <rtems_resource_snapshot_take+0x105> <== NOT EXECUTED
104b6b: 90 nop
104b6c: 90 nop
104b6d: 90 nop
104b6e: 90 nop
104b6f: 90 nop
0011a400 <rtems_termios_close>:
{
11a400: 55 push %ebp
11a401: 89 e5 mov %esp,%ebp
11a403: 56 push %esi
11a404: 53 push %ebx
11a405: 83 ec 10 sub $0x10,%esp
11a408: 8b 75 08 mov 0x8(%ebp),%esi
struct rtems_termios_tty *tty = args->iop->data1;
11a40b: 8b 06 mov (%esi),%eax
11a40d: 8b 58 28 mov 0x28(%eax),%ebx
_Mutex_Acquire( mutex );
11a410: c7 04 24 54 94 12 00 movl $0x129454,(%esp)
11a417: e8 24 ba fe ff call 105e40 <_Mutex_Acquire>
if (tty->refcount == 1) {
11a41c: 8b 43 08 mov 0x8(%ebx),%eax
11a41f: 83 f8 01 cmp $0x1,%eax
11a422: 74 1c je 11a440 <rtems_termios_close+0x40>
if (--tty->refcount == 0) {
11a424: 48 dec %eax
11a425: 89 43 08 mov %eax,0x8(%ebx)
11a428: 74 2f je 11a459 <rtems_termios_close+0x59> <== NEVER TAKEN
_Mutex_Release( mutex );
11a42a: c7 04 24 54 94 12 00 movl $0x129454,(%esp)
11a431: e8 7a ba fe ff call 105eb0 <_Mutex_Release>
}
11a436: 83 c4 10 add $0x10,%esp
11a439: 31 c0 xor %eax,%eax
11a43b: 5b pop %ebx
11a43c: 5e pop %esi
11a43d: 5d pop %ebp
11a43e: c3 ret
11a43f: 90 nop
if (tty->forw == NULL) {
11a440: 8b 13 mov (%ebx),%edx
rtems_termios_ttyTail = tty->back;
11a442: 8b 43 04 mov 0x4(%ebx),%eax
if (tty->forw == NULL) {
11a445: 85 d2 test %edx,%edx
11a447: 74 37 je 11a480 <rtems_termios_close+0x80> <== ALWAYS TAKEN
tty->forw->back = tty->back;
11a449: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED
if (tty->back == NULL) {
11a44c: 85 c0 test %eax,%eax <== NOT EXECUTED
11a44e: 74 20 je 11a470 <rtems_termios_close+0x70> <== NOT EXECUTED
tty->back->forw = tty->forw;
11a450: 89 10 mov %edx,(%eax) <== NOT EXECUTED
if (--tty->refcount == 0) {
11a452: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx)
rtems_termios_destroy_tty (tty, arg, true);
11a459: b9 01 00 00 00 mov $0x1,%ecx
11a45e: 89 f2 mov %esi,%edx
11a460: 89 d8 mov %ebx,%eax
11a462: e8 89 e4 ff ff call 1188f0 <rtems_termios_destroy_tty>
11a467: eb c1 jmp 11a42a <rtems_termios_close+0x2a>
11a469: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
rtems_termios_ttyHead = tty->forw;
11a470: 89 15 f0 1c 13 00 mov %edx,0x131cf0 <== NOT EXECUTED
rtems_termios_ttyHead->back = NULL;
11a476: eb da jmp 11a452 <rtems_termios_close+0x52> <== NOT EXECUTED
11a478: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11a47f: 90 nop <== NOT EXECUTED
rtems_termios_ttyTail = tty->back;
11a480: a3 ec 1c 13 00 mov %eax,0x131cec
if ( rtems_termios_ttyTail != NULL ) {
11a485: 85 c0 test %eax,%eax
11a487: 74 17 je 11a4a0 <rtems_termios_close+0xa0> <== ALWAYS TAKEN
rtems_termios_ttyTail->forw = NULL;
11a489: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED
tty->back->forw = tty->forw;
11a48f: 8b 13 mov (%ebx),%edx <== NOT EXECUTED
11a491: eb bd jmp 11a450 <rtems_termios_close+0x50> <== NOT EXECUTED
11a493: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11a49a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
rtems_termios_ttyHead = tty->forw;
11a4a0: 31 c0 xor %eax,%eax
11a4a2: a3 f0 1c 13 00 mov %eax,0x131cf0
if ( rtems_termios_ttyHead != NULL ) {
11a4a7: eb a9 jmp 11a452 <rtems_termios_close+0x52>
11a4a9: 90 nop
11a4aa: 90 nop
11a4ab: 90 nop
11a4ac: 90 nop
11a4ad: 90 nop
11a4ae: 90 nop
11a4af: 90 nop
00118b50 <rtems_termios_dequeue_characters>:
* for each transmitted character.
* It returns number of characters left to transmit
*/
int
rtems_termios_dequeue_characters (void *ttyp, int len)
{
118b50: 55 push %ebp
118b51: 89 e5 mov %esp,%ebp
118b53: 83 ec 18 sub $0x18,%esp
118b56: 8b 45 08 mov 0x8(%ebp),%eax
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
118b59: 8b 4d 0c mov 0xc(%ebp),%ecx
118b5c: 01 88 e0 00 00 00 add %ecx,0xe0(%eax)
if (tty->handler.mode == TERMIOS_TASK_DRIVEN) {
118b62: 83 b8 3c 01 00 00 02 cmpl $0x2,0x13c(%eax)
118b69: 74 35 je 118ba0 <rtems_termios_dequeue_characters+0x50>
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
return 0; /* nothing to output in IRQ... */
}
if (tty->t_line == PPPDISC ) {
118b6b: 83 b8 5c 01 00 00 05 cmpl $0x5,0x15c(%eax)
118b72: 74 0c je 118b80 <rtems_termios_dequeue_characters+0x30>
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
}
118b74: 89 ec mov %ebp,%esp
118b76: 5d pop %ebp
return rtems_termios_refill_transmitter(tty);
118b77: e9 b4 f8 ff ff jmp 118430 <rtems_termios_refill_transmitter>
118b7c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
118b80: 8b 15 14 4c 13 00 mov 0x134c14,%edx
118b86: 85 d2 test %edx,%edx
118b88: 74 05 je 118b8f <rtems_termios_dequeue_characters+0x3f> <== NEVER TAKEN
rtems_termios_linesw[tty->t_line].l_start(tty);
118b8a: 89 04 24 mov %eax,(%esp)
118b8d: ff d2 call *%edx
}
118b8f: 89 ec mov %ebp,%esp
118b91: 31 c0 xor %eax,%eax
118b93: 5d pop %ebp
118b94: c3 ret
118b95: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
118b9c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
sc = rtems_event_send(tty->txTaskId, TERMIOS_TX_START_EVENT);
118ba0: ba 02 00 00 00 mov $0x2,%edx
118ba5: 89 54 24 04 mov %edx,0x4(%esp)
118ba9: 8b 80 58 01 00 00 mov 0x158(%eax),%eax
118baf: 89 04 24 mov %eax,(%esp)
118bb2: e8 59 00 00 00 call 118c10 <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
118bb7: 85 c0 test %eax,%eax
118bb9: 74 d4 je 118b8f <rtems_termios_dequeue_characters+0x3f> <== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
118bbb: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
118bbe: e8 6d bf fe ff call 104b30 <rtems_fatal_error_occurred> <== NOT EXECUTED
118bc3: 90 nop
118bc4: 90 nop
118bc5: 90 nop
118bc6: 90 nop
118bc7: 90 nop
118bc8: 90 nop
118bc9: 90 nop
118bca: 90 nop
118bcb: 90 nop
118bcc: 90 nop
118bcd: 90 nop
118bce: 90 nop
118bcf: 90 nop
001186b0 <rtems_termios_enqueue_raw_characters>:
{
1186b0: 55 push %ebp
1186b1: 89 e5 mov %esp,%ebp
1186b3: 57 push %edi
1186b4: 56 push %esi
1186b5: 53 push %ebx
1186b6: 83 ec 3c sub $0x3c,%esp
1186b9: 8b 7d 08 mov 0x8(%ebp),%edi
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
1186bc: 8b 87 5c 01 00 00 mov 0x15c(%edi),%eax
1186c2: c1 e0 05 shl $0x5,%eax
1186c5: 8b 80 70 4b 13 00 mov 0x134b70(%eax),%eax
1186cb: 85 c0 test %eax,%eax
1186cd: 0f 84 7d 00 00 00 je 118750 <rtems_termios_enqueue_raw_characters+0xa0>
while (len--) {
1186d3: 8b 55 10 mov 0x10(%ebp),%edx
1186d6: 85 d2 test %edx,%edx
1186d8: 74 36 je 118710 <rtems_termios_enqueue_raw_characters+0x60><== NEVER TAKEN
1186da: 8b 5d 0c mov 0xc(%ebp),%ebx
1186dd: 8b 75 10 mov 0x10(%ebp),%esi
1186e0: 8d 74 33 ff lea -0x1(%ebx,%esi,1),%esi
1186e4: eb 1a jmp 118700 <rtems_termios_enqueue_raw_characters+0x50>
1186e6: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1186ed: 8d 76 00 lea 0x0(%esi),%esi
rtems_termios_linesw[tty->t_line].l_rint(c,tty);
1186f0: 8b 87 5c 01 00 00 mov 0x15c(%edi),%eax
1186f6: 43 inc %ebx
1186f7: c1 e0 05 shl $0x5,%eax
1186fa: 8b 80 70 4b 13 00 mov 0x134b70(%eax),%eax
118700: 89 7c 24 04 mov %edi,0x4(%esp)
118704: 0f be 13 movsbl (%ebx),%edx
118707: 89 14 24 mov %edx,(%esp)
11870a: ff d0 call *%eax
while (len--) {
11870c: 39 f3 cmp %esi,%ebx
11870e: 75 e0 jne 1186f0 <rtems_termios_enqueue_raw_characters+0x40><== NEVER TAKEN
return 0;
118710: c7 45 cc 00 00 00 00 movl $0x0,-0x34(%ebp)
if (tty->tty_rcv.sw_pfn != NULL && !tty->tty_rcvwakeup) {
118717: 8b 87 6c 01 00 00 mov 0x16c(%edi),%eax
11871d: 85 c0 test %eax,%eax
11871f: 74 22 je 118743 <rtems_termios_enqueue_raw_characters+0x93>
118721: 80 bf 74 01 00 00 00 cmpb $0x0,0x174(%edi)
118728: 75 19 jne 118743 <rtems_termios_enqueue_raw_characters+0x93><== NEVER TAKEN
tty->tty_rcvwakeup = true;
11872a: c6 87 74 01 00 00 01 movb $0x1,0x174(%edi)
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
118731: 8b 97 70 01 00 00 mov 0x170(%edi),%edx
118737: 89 54 24 04 mov %edx,0x4(%esp)
11873b: 8d 57 50 lea 0x50(%edi),%edx
11873e: 89 14 24 mov %edx,(%esp)
118741: ff d0 call *%eax
}
118743: 8b 45 cc mov -0x34(%ebp),%eax
118746: 83 c4 3c add $0x3c,%esp
118749: 5b pop %ebx
11874a: 5e pop %esi
11874b: 5f pop %edi
11874c: 5d pop %ebp
11874d: c3 ret
11874e: 66 90 xchg %ax,%ax
while (len--) {
118750: 8b 4d 10 mov 0x10(%ebp),%ecx
118753: 85 c9 test %ecx,%ecx
118755: 0f 84 e5 03 00 00 je 118b40 <rtems_termios_enqueue_raw_characters+0x490><== NEVER TAKEN
bool flow_rcv = false; /* true, if flow control char received */
11875b: c6 45 d7 00 movb $0x0,-0x29(%ebp)
rtems_termios_device_context *ctx = tty->device_context;
11875f: 8b 9f 7c 01 00 00 mov 0x17c(%edi),%ebx
int dropped = 0;
118765: c7 45 cc 00 00 00 00 movl $0x0,-0x34(%ebp)
rtems_termios_device_context *ctx = tty->device_context;
11876c: 8b 75 0c mov 0xc(%ebp),%esi
11876f: 90 nop
if (tty->flow_ctrl & FL_MDXON) {
118770: 8b 97 48 01 00 00 mov 0x148(%edi),%edx
c = *buf++;
118776: 46 inc %esi
118777: 0f b6 46 ff movzbl -0x1(%esi),%eax
if (tty->flow_ctrl & FL_MDXON) {
11877b: f6 c6 02 test $0x2,%dh
11877e: 74 1f je 11879f <rtems_termios_enqueue_raw_characters+0xef>
if (c == tty->termios.c_cc[VSTART]) {
118780: 0f b6 4f 6c movzbl 0x6c(%edi),%ecx
if (c == tty->termios.c_cc[VSTOP]) {
118784: 0f be d0 movsbl %al,%edx
if (c == tty->termios.c_cc[VSTART]) {
118787: 89 4d d0 mov %ecx,-0x30(%ebp)
if (c == tty->termios.c_cc[VSTOP]) {
11878a: 0f b6 4f 6d movzbl 0x6d(%edi),%ecx
11878e: 39 ca cmp %ecx,%edx
118790: 0f 84 6a 01 00 00 je 118900 <rtems_termios_enqueue_raw_characters+0x250>
else if (c == tty->termios.c_cc[VSTART]) {
118796: 3b 55 d0 cmp -0x30(%ebp),%edx
118799: 0f 84 21 02 00 00 je 1189c0 <rtems_termios_enqueue_raw_characters+0x310><== NEVER TAKEN
if (flow_rcv) {
11879f: 80 7d d7 00 cmpb $0x0,-0x29(%ebp)
1187a3: 0f 85 77 01 00 00 jne 118920 <rtems_termios_enqueue_raw_characters+0x270><== NEVER TAKEN
if (c == '\r' && (tty->termios.c_iflag & IGNCR) != 0) {
1187a9: 3c 0d cmp $0xd,%al
1187ab: 0f 84 ff 01 00 00 je 1189b0 <rtems_termios_enqueue_raw_characters+0x300>
c = iprocEarly (c, tty);
1187b1: 89 fa mov %edi,%edx
1187b3: 0f b6 c0 movzbl %al,%eax
1187b6: e8 15 fc ff ff call 1183d0 <iprocEarly>
( *context->lock_acquire )( context, lock_context );
1187bb: 89 1c 24 mov %ebx,(%esp)
1187be: 88 45 d6 mov %al,-0x2a(%ebp)
1187c1: 8d 45 e4 lea -0x1c(%ebp),%eax
1187c4: 89 44 24 04 mov %eax,0x4(%esp)
1187c8: ff 53 14 call *0x14(%ebx)
head = tty->rawInBuf.Head;
1187cb: 8b 87 84 00 00 00 mov 0x84(%edi),%eax
newTail = (oldTail + 1) % tty->rawInBuf.Size;
1187d1: 31 d2 xor %edx,%edx
head = tty->rawInBuf.Head;
1187d3: 89 45 d0 mov %eax,-0x30(%ebp)
oldTail = tty->rawInBuf.Tail;
1187d6: 8b 87 88 00 00 00 mov 0x88(%edi),%eax
newTail = (oldTail + 1) % tty->rawInBuf.Size;
1187dc: 8b 8f 8c 00 00 00 mov 0x8c(%edi),%ecx
1187e2: 40 inc %eax
1187e3: f7 f1 div %ecx
if ((tty->flow_ctrl & FL_IREQXOF) != 0 && (((newTail - head) %
1187e5: 8b 87 48 01 00 00 mov 0x148(%edi),%eax
1187eb: a8 01 test $0x1,%al
newTail = (oldTail + 1) % tty->rawInBuf.Size;
1187ed: 89 d1 mov %edx,%ecx
if ((tty->flow_ctrl & FL_IREQXOF) != 0 && (((newTail - head) %
1187ef: 74 7f je 118870 <rtems_termios_enqueue_raw_characters+0x1c0><== ALWAYS TAKEN
tty->rawInBuf.Size) > tty->highwater)) {
1187f1: 8b 97 8c 00 00 00 mov 0x8c(%edi),%edx <== NOT EXECUTED
if ((tty->flow_ctrl & FL_IREQXOF) != 0 && (((newTail - head) %
1187f7: 8b 45 d0 mov -0x30(%ebp),%eax <== NOT EXECUTED
tty->rawInBuf.Size) > tty->highwater)) {
1187fa: 89 55 c8 mov %edx,-0x38(%ebp) <== NOT EXECUTED
if ((tty->flow_ctrl & FL_IREQXOF) != 0 && (((newTail - head) %
1187fd: 89 ca mov %ecx,%edx <== NOT EXECUTED
1187ff: 29 c2 sub %eax,%edx <== NOT EXECUTED
118801: 89 d0 mov %edx,%eax <== NOT EXECUTED
118803: 31 d2 xor %edx,%edx <== NOT EXECUTED
118805: f7 75 c8 divl -0x38(%ebp) <== NOT EXECUTED
118808: 3b 97 50 01 00 00 cmp 0x150(%edi),%edx <== NOT EXECUTED
11880e: 76 60 jbe 118870 <rtems_termios_enqueue_raw_characters+0x1c0><== NOT EXECUTED
tty->flow_ctrl |= FL_IREQXOF;
118810: 8b 87 48 01 00 00 mov 0x148(%edi),%eax <== NOT EXECUTED
118816: 83 c8 01 or $0x1,%eax <== NOT EXECUTED
118819: 89 87 48 01 00 00 mov %eax,0x148(%edi) <== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
11881f: 8b 87 48 01 00 00 mov 0x148(%edi),%eax <== NOT EXECUTED
118825: 25 02 04 00 00 and $0x402,%eax <== NOT EXECUTED
11882a: 3d 00 04 00 00 cmp $0x400,%eax <== NOT EXECUTED
if ((tty->flow_ctrl & FL_OSTOP) ||
11882f: 8b 87 48 01 00 00 mov 0x148(%edi),%eax <== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
118835: 0f 84 25 02 00 00 je 118a60 <rtems_termios_enqueue_raw_characters+0x3b0><== NOT EXECUTED
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
11883b: 25 04 01 00 00 and $0x104,%eax <== NOT EXECUTED
118840: 3d 00 01 00 00 cmp $0x100,%eax <== NOT EXECUTED
118845: 75 29 jne 118870 <rtems_termios_enqueue_raw_characters+0x1c0><== NOT EXECUTED
tty->flow_ctrl |= FL_IRTSOFF;
118847: 8b 87 48 01 00 00 mov 0x148(%edi),%eax <== NOT EXECUTED
11884d: 83 c8 04 or $0x4,%eax <== NOT EXECUTED
118850: 89 87 48 01 00 00 mov %eax,0x148(%edi) <== NOT EXECUTED
if (tty->flow.stop_remote_tx != NULL) {
118856: 8b 87 40 01 00 00 mov 0x140(%edi),%eax <== NOT EXECUTED
11885c: 85 c0 test %eax,%eax <== NOT EXECUTED
11885e: 74 10 je 118870 <rtems_termios_enqueue_raw_characters+0x1c0><== NOT EXECUTED
tty->flow.stop_remote_tx(ctx);
118860: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
118863: 89 4d c8 mov %ecx,-0x38(%ebp) <== NOT EXECUTED
118866: ff d0 call *%eax <== NOT EXECUTED
118868: 8b 4d c8 mov -0x38(%ebp),%ecx <== NOT EXECUTED
11886b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11886f: 90 nop <== NOT EXECUTED
if (newTail != head) {
118870: 39 4d d0 cmp %ecx,-0x30(%ebp)
118873: 0f 84 67 01 00 00 je 1189e0 <rtems_termios_enqueue_raw_characters+0x330>
tty->rawInBuf.theBuf[newTail] = c;
118879: 8b 87 80 00 00 00 mov 0x80(%edi),%eax
11887f: 0f b6 55 d6 movzbl -0x2a(%ebp),%edx
118883: 88 14 08 mov %dl,(%eax,%ecx,1)
tty->rawInBuf.Tail = newTail;
118886: 89 8f 88 00 00 00 mov %ecx,0x88(%edi)
if (tty->tty_rcv.sw_pfn != NULL && !tty->tty_rcvwakeup) {
11888c: 8b 87 6c 01 00 00 mov 0x16c(%edi),%eax
118892: 85 c0 test %eax,%eax
118894: 0f 84 96 01 00 00 je 118a30 <rtems_termios_enqueue_raw_characters+0x380>
( *context->lock_release )( context, lock_context );
11889a: 8b 43 18 mov 0x18(%ebx),%eax
11889d: 80 bf 74 01 00 00 00 cmpb $0x0,0x174(%edi)
1188a4: 89 45 c8 mov %eax,-0x38(%ebp)
1188a7: 0f 84 f3 01 00 00 je 118aa0 <rtems_termios_enqueue_raw_characters+0x3f0>
1188ad: 89 1c 24 mov %ebx,(%esp)
1188b0: 8d 4d e4 lea -0x1c(%ebp),%ecx
1188b3: 89 4c 24 04 mov %ecx,0x4(%esp)
1188b7: ff d0 call *%eax
while (len--) {
1188b9: 8b 45 10 mov 0x10(%ebp),%eax
1188bc: 29 f0 sub %esi,%eax
1188be: 03 45 0c add 0xc(%ebp),%eax
1188c1: 0f 85 a9 fe ff ff jne 118770 <rtems_termios_enqueue_raw_characters+0xc0><== NEVER TAKEN
1188c7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1188ce: 66 90 xchg %ax,%ax
tty->rawInBufDropped += dropped;
1188d0: 8b 45 cc mov -0x34(%ebp),%eax
1188d3: 01 87 b4 00 00 00 add %eax,0xb4(%edi)
1188d9: 8d 87 90 00 00 00 lea 0x90(%edi),%eax
1188df: 89 04 24 mov %eax,(%esp)
1188e2: e8 39 05 00 00 call 118e20 <_Semaphore_Post_binary>
}
1188e7: 8b 45 cc mov -0x34(%ebp),%eax
1188ea: 83 c4 3c add $0x3c,%esp
1188ed: 5b pop %ebx
1188ee: 5e pop %esi
1188ef: 5f pop %edi
1188f0: 5d pop %ebp
1188f1: c3 ret
1188f2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1188f9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
if (c == tty->termios.c_cc[VSTART]) {
118900: 3b 55 d0 cmp -0x30(%ebp),%edx
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
118903: 8b 87 48 01 00 00 mov 0x148(%edi),%eax
if (c == tty->termios.c_cc[VSTART]) {
118909: 0f 84 41 01 00 00 je 118a50 <rtems_termios_enqueue_raw_characters+0x3a0><== NEVER TAKEN
tty->flow_ctrl |= FL_ORCVXOF;
11890f: 83 c8 10 or $0x10,%eax
118912: 89 87 48 01 00 00 mov %eax,0x148(%edi)
118918: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11891f: 90 nop
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
118920: c6 45 d7 01 movb $0x1,-0x29(%ebp)
118924: 8b 87 48 01 00 00 mov 0x148(%edi),%eax
11892a: 83 e0 30 and $0x30,%eax
11892d: 83 f8 20 cmp $0x20,%eax
118930: 74 1e je 118950 <rtems_termios_enqueue_raw_characters+0x2a0><== NEVER TAKEN
while (len--) {
118932: 8b 45 10 mov 0x10(%ebp),%eax
118935: 29 f0 sub %esi,%eax
118937: 03 45 0c add 0xc(%ebp),%eax
11893a: 0f 85 30 fe ff ff jne 118770 <rtems_termios_enqueue_raw_characters+0xc0><== NEVER TAKEN
118940: eb 8e jmp 1188d0 <rtems_termios_enqueue_raw_characters+0x220>
118942: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
118949: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
( *context->lock_acquire )( context, lock_context );
118950: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
118953: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED
118956: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
11895a: ff 53 14 call *0x14(%ebx) <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
11895d: 8b 87 48 01 00 00 mov 0x148(%edi),%eax <== NOT EXECUTED
118963: 83 e0 df and $0xffffffdf,%eax <== NOT EXECUTED
118966: 89 87 48 01 00 00 mov %eax,0x148(%edi) <== NOT EXECUTED
if (tty->rawOutBufState != rob_idle) {
11896c: 8b 87 e4 00 00 00 mov 0xe4(%edi),%eax <== NOT EXECUTED
118972: 85 c0 test %eax,%eax <== NOT EXECUTED
118974: 74 24 je 11899a <rtems_termios_enqueue_raw_characters+0x2ea><== NOT EXECUTED
(*tty->handler.write)(
118976: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED
ctx, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
11897b: 8b 87 c0 00 00 00 mov 0xc0(%edi),%eax <== NOT EXECUTED
(*tty->handler.write)(
118981: 89 54 24 08 mov %edx,0x8(%esp) <== NOT EXECUTED
ctx, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
118985: 8b 8f b8 00 00 00 mov 0xb8(%edi),%ecx <== NOT EXECUTED
(*tty->handler.write)(
11898b: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
ctx, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
11898e: 01 c8 add %ecx,%eax <== NOT EXECUTED
(*tty->handler.write)(
118990: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
118994: ff 97 30 01 00 00 call *0x130(%edi) <== NOT EXECUTED
( *context->lock_release )( context, lock_context );
11899a: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
11899d: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED
1189a0: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1189a4: ff 53 18 call *0x18(%ebx) <== NOT EXECUTED
}
1189a7: c6 45 d7 01 movb $0x1,-0x29(%ebp) <== NOT EXECUTED
1189ab: eb 85 jmp 118932 <rtems_termios_enqueue_raw_characters+0x282><== NOT EXECUTED
1189ad: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
if (c == '\r' && (tty->termios.c_iflag & IGNCR) != 0) {
1189b0: f6 47 50 80 testb $0x80,0x50(%edi)
1189b4: 0f 84 f7 fd ff ff je 1187b1 <rtems_termios_enqueue_raw_characters+0x101>
1189ba: e9 73 ff ff ff jmp 118932 <rtems_termios_enqueue_raw_characters+0x282>
1189bf: 90 nop
tty->flow_ctrl &= ~FL_ORCVXOF;
1189c0: 8b 87 48 01 00 00 mov 0x148(%edi),%eax <== NOT EXECUTED
1189c6: 83 e0 ef and $0xffffffef,%eax <== NOT EXECUTED
1189c9: 89 87 48 01 00 00 mov %eax,0x148(%edi) <== NOT EXECUTED
if (flow_rcv) {
1189cf: e9 4c ff ff ff jmp 118920 <rtems_termios_enqueue_raw_characters+0x270><== NOT EXECUTED
1189d4: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1189db: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1189df: 90 nop <== NOT EXECUTED
if (tty->tty_rcv.sw_pfn != NULL && !tty->tty_rcvwakeup) {
1189e0: 8b 97 6c 01 00 00 mov 0x16c(%edi),%edx
++dropped;
1189e6: ff 45 cc incl -0x34(%ebp)
( *context->lock_release )( context, lock_context );
1189e9: 8b 43 18 mov 0x18(%ebx),%eax
if (tty->tty_rcv.sw_pfn != NULL && !tty->tty_rcvwakeup) {
1189ec: 85 d2 test %edx,%edx
1189ee: 0f 84 b9 fe ff ff je 1188ad <rtems_termios_enqueue_raw_characters+0x1fd><== NEVER TAKEN
1189f4: 80 bf 74 01 00 00 00 cmpb $0x0,0x174(%edi)
1189fb: 0f 85 ac fe ff ff jne 1188ad <rtems_termios_enqueue_raw_characters+0x1fd><== NEVER TAKEN
tty->tty_rcvwakeup = true;
118a01: c6 87 74 01 00 00 01 movb $0x1,0x174(%edi)
118a08: 8d 4d e4 lea -0x1c(%ebp),%ecx
118a0b: 89 4c 24 04 mov %ecx,0x4(%esp)
118a0f: 89 1c 24 mov %ebx,(%esp)
118a12: ff d0 call *%eax
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
118a14: 8b 87 70 01 00 00 mov 0x170(%edi),%eax
118a1a: 89 44 24 04 mov %eax,0x4(%esp)
118a1e: 8d 47 50 lea 0x50(%edi),%eax
118a21: 89 04 24 mov %eax,(%esp)
118a24: ff 97 6c 01 00 00 call *0x16c(%edi)
118a2a: e9 03 ff ff ff jmp 118932 <rtems_termios_enqueue_raw_characters+0x282>
118a2f: 90 nop
118a30: 89 1c 24 mov %ebx,(%esp)
118a33: 8d 45 e4 lea -0x1c(%ebp),%eax
118a36: 89 44 24 04 mov %eax,0x4(%esp)
118a3a: ff 53 18 call *0x18(%ebx)
if (callReciveCallback) {
118a3d: e9 f0 fe ff ff jmp 118932 <rtems_termios_enqueue_raw_characters+0x282>
118a42: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
118a49: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
118a50: 83 f0 10 xor $0x10,%eax <== NOT EXECUTED
118a53: 89 87 48 01 00 00 mov %eax,0x148(%edi) <== NOT EXECUTED
118a59: e9 c2 fe ff ff jmp 118920 <rtems_termios_enqueue_raw_characters+0x270><== NOT EXECUTED
118a5e: 66 90 xchg %ax,%ax <== NOT EXECUTED
if ((tty->flow_ctrl & FL_OSTOP) ||
118a60: a8 20 test $0x20,%al <== NOT EXECUTED
118a62: 0f 84 b8 00 00 00 je 118b20 <rtems_termios_enqueue_raw_characters+0x470><== NOT EXECUTED
118a68: 89 4d c8 mov %ecx,-0x38(%ebp) <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
118a6b: 8b 87 48 01 00 00 mov 0x148(%edi),%eax <== NOT EXECUTED
118a71: 83 c8 02 or $0x2,%eax <== NOT EXECUTED
118a74: 89 87 48 01 00 00 mov %eax,0x148(%edi) <== NOT EXECUTED
(*tty->handler.write)(ctx,
118a7a: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
118a7f: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
(void *)&(tty->termios.c_cc[VSTOP]), 1);
118a83: 8d 47 6d lea 0x6d(%edi),%eax <== NOT EXECUTED
118a86: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
(*tty->handler.write)(ctx,
118a8a: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
118a8d: ff 97 30 01 00 00 call *0x130(%edi) <== NOT EXECUTED
118a93: 8b 4d c8 mov -0x38(%ebp),%ecx <== NOT EXECUTED
118a96: e9 d5 fd ff ff jmp 118870 <rtems_termios_enqueue_raw_characters+0x1c0><== NOT EXECUTED
118a9b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
118a9f: 90 nop <== NOT EXECUTED
if ((tty->termios.c_lflag & ICANON) != 0) {
118aa0: f6 47 5d 01 testb $0x1,0x5d(%edi)
118aa4: 74 3a je 118ae0 <rtems_termios_enqueue_raw_characters+0x430>
c == tty->termios.c_cc[VEOL] || c == tty->termios.c_cc[VEOL2];
118aa6: 0f b6 45 d6 movzbl -0x2a(%ebp),%eax
118aaa: 3c 0a cmp $0xa,%al
118aac: 74 4d je 118afb <rtems_termios_enqueue_raw_characters+0x44b>
return c == '\n' || c == tty->termios.c_cc[VEOF] ||
118aae: 3a 47 60 cmp 0x60(%edi),%al
118ab1: 74 48 je 118afb <rtems_termios_enqueue_raw_characters+0x44b>
118ab3: 3a 47 61 cmp 0x61(%edi),%al
118ab6: 74 43 je 118afb <rtems_termios_enqueue_raw_characters+0x44b>
if (mustCallReceiveCallback (tty, c, newTail, head)) {
118ab8: 3a 47 62 cmp 0x62(%edi),%al
118abb: 74 3e je 118afb <rtems_termios_enqueue_raw_characters+0x44b>
118abd: 89 1c 24 mov %ebx,(%esp)
118ac0: 8d 45 e4 lea -0x1c(%ebp),%eax
118ac3: 89 44 24 04 mov %eax,0x4(%esp)
118ac7: 8b 45 c8 mov -0x38(%ebp),%eax
118aca: ff d0 call *%eax
118acc: c6 45 d7 00 movb $0x0,-0x29(%ebp)
118ad0: e9 5d fe ff ff jmp 118932 <rtems_termios_enqueue_raw_characters+0x282>
118ad5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
118adc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
unsigned int rawContentSize = (newTail - head) % tty->rawInBuf.Size;
118ae0: 8b 97 8c 00 00 00 mov 0x8c(%edi),%edx
118ae6: 89 c8 mov %ecx,%eax
118ae8: 8b 4d d0 mov -0x30(%ebp),%ecx
118aeb: 29 c8 sub %ecx,%eax
118aed: 89 d1 mov %edx,%ecx
118aef: 31 d2 xor %edx,%edx
118af1: f7 f1 div %ecx
return rawContentSize >= tty->termios.c_cc[VMIN];
118af3: 0f b6 47 70 movzbl 0x70(%edi),%eax
if (mustCallReceiveCallback (tty, c, newTail, head)) {
118af7: 39 c2 cmp %eax,%edx
118af9: 72 c2 jb 118abd <rtems_termios_enqueue_raw_characters+0x40d>
tty->tty_rcvwakeup = true;
118afb: c6 87 74 01 00 00 01 movb $0x1,0x174(%edi)
118b02: 8d 45 e4 lea -0x1c(%ebp),%eax
118b05: 89 44 24 04 mov %eax,0x4(%esp)
118b09: 8b 45 c8 mov -0x38(%ebp),%eax
118b0c: 89 1c 24 mov %ebx,(%esp)
118b0f: ff d0 call *%eax
if (callReciveCallback) {
118b11: e9 fe fe ff ff jmp 118a14 <rtems_termios_enqueue_raw_characters+0x364>
118b16: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
118b1d: 8d 76 00 lea 0x0(%esi),%esi
if ((tty->flow_ctrl & FL_OSTOP) ||
118b20: 8b 87 e4 00 00 00 mov 0xe4(%edi),%eax <== NOT EXECUTED
118b26: 85 c0 test %eax,%eax <== NOT EXECUTED
118b28: 0f 85 42 fd ff ff jne 118870 <rtems_termios_enqueue_raw_characters+0x1c0><== NOT EXECUTED
118b2e: 66 90 xchg %ax,%ax <== NOT EXECUTED
118b30: e9 33 ff ff ff jmp 118a68 <rtems_termios_enqueue_raw_characters+0x3b8><== NOT EXECUTED
118b35: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
118b3c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
int dropped = 0;
118b40: c7 45 cc 00 00 00 00 movl $0x0,-0x34(%ebp) <== NOT EXECUTED
118b47: e9 87 fd ff ff jmp 1188d3 <rtems_termios_enqueue_raw_characters+0x223><== NOT EXECUTED
118b4c: 90 nop
118b4d: 90 nop
118b4e: 90 nop
118b4f: 90 nop
0011a4b0 <rtems_termios_ioctl>:
{
11a4b0: 55 push %ebp
11a4b1: 89 e5 mov %esp,%ebp
11a4b3: 57 push %edi
11a4b4: 56 push %esi
11a4b5: 53 push %ebx
11a4b6: 83 ec 3c sub $0x3c,%esp
11a4b9: 8b 55 08 mov 0x8(%ebp),%edx
struct rtems_termios_tty *tty = args->iop->data1;
11a4bc: 8b 02 mov (%edx),%eax
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
11a4be: 8b 7a 08 mov 0x8(%edx),%edi
struct rtems_termios_tty *tty = args->iop->data1;
11a4c1: 8b 58 28 mov 0x28(%eax),%ebx
args->ioctl_return = 0;
11a4c4: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx)
rtems_mutex_lock (&tty->osem);
11a4cb: 8d 73 28 lea 0x28(%ebx),%esi
_Mutex_Acquire( mutex );
11a4ce: 89 34 24 mov %esi,(%esp)
11a4d1: e8 6a b9 fe ff call 105e40 <_Mutex_Acquire>
switch (args->command) {
11a4d6: 8b 55 08 mov 0x8(%ebp),%edx
11a4d9: 8b 42 04 mov 0x4(%edx),%eax
11a4dc: 3d 10 74 04 80 cmp $0x80047410,%eax
11a4e1: 0f 84 39 03 00 00 je 11a820 <rtems_termios_ioctl+0x370> <== NEVER TAKEN
11a4e7: 0f 86 53 02 00 00 jbe 11a740 <rtems_termios_ioctl+0x290>
11a4ed: 3d 0c 74 08 80 cmp $0x8008740c,%eax
11a4f2: 0f 84 b8 03 00 00 je 11a8b0 <rtems_termios_ioctl+0x400>
11a4f8: 0f 86 82 02 00 00 jbe 11a780 <rtems_termios_ioctl+0x2d0>
11a4fe: 8d 88 ec 8b d3 7f lea 0x7fd38bec(%eax),%ecx
11a504: 83 f9 02 cmp $0x2,%ecx
11a507: 0f 87 e3 02 00 00 ja 11a7f0 <rtems_termios_ioctl+0x340> <== NEVER TAKEN
tty->termios = *(struct termios *)args->buffer;
11a50d: 89 45 d4 mov %eax,-0x2c(%ebp)
11a510: 8b 7a 08 mov 0x8(%edx),%edi
11a513: 31 c9 xor %ecx,%ecx
11a515: 8b 04 0f mov (%edi,%ecx,1),%eax
11a518: 89 44 0b 50 mov %eax,0x50(%ebx,%ecx,1)
11a51c: 83 c1 04 add $0x4,%ecx
11a51f: 83 f9 2c cmp $0x2c,%ecx
11a522: 72 f1 jb 11a515 <rtems_termios_ioctl+0x65>
if (args->command == TIOCSETAW || args->command == TIOCSETAF) {
11a524: 8b 45 d4 mov -0x2c(%ebp),%eax
11a527: 05 eb 8b d3 7f add $0x7fd38beb,%eax
11a52c: 83 f8 01 cmp $0x1,%eax
11a52f: 0f 86 df 04 00 00 jbe 11aa14 <rtems_termios_ioctl+0x564>
if (( tty->flow_ctrl & FL_MDXON) &&
11a535: 8b 83 48 01 00 00 mov 0x148(%ebx),%eax
rtems_termios_device_context *ctx = tty->device_context;
11a53b: 8b bb 7c 01 00 00 mov 0x17c(%ebx),%edi
if (( tty->flow_ctrl & FL_MDXON) &&
11a541: f6 c4 02 test $0x2,%ah
11a544: 0f 84 86 00 00 00 je 11a5d0 <rtems_termios_ioctl+0x120>
11a54a: f6 43 51 02 testb $0x2,0x51(%ebx)
11a54e: 0f 85 7c 00 00 00 jne 11a5d0 <rtems_termios_ioctl+0x120>
tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF);
11a554: 8b 83 48 01 00 00 mov 0x148(%ebx),%eax
11a55a: 25 ef fd ff ff and $0xfffffdef,%eax
11a55f: 89 83 48 01 00 00 mov %eax,0x148(%ebx)
if (tty->flow_ctrl & FL_OSTOP) {
11a565: 8b 83 48 01 00 00 mov 0x148(%ebx),%eax
11a56b: a8 20 test $0x20,%al
11a56d: 74 61 je 11a5d0 <rtems_termios_ioctl+0x120> <== ALWAYS TAKEN
( *context->lock_acquire )( context, lock_context );
11a56f: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
11a572: 8d 55 e4 lea -0x1c(%ebp),%edx <== NOT EXECUTED
11a575: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
11a579: ff 57 14 call *0x14(%edi) <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
11a57c: 8b 83 48 01 00 00 mov 0x148(%ebx),%eax <== NOT EXECUTED
if (tty->rawOutBufState != rob_idle) {
11a582: 8d 55 e4 lea -0x1c(%ebp),%edx <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
11a585: 83 e0 df and $0xffffffdf,%eax <== NOT EXECUTED
11a588: 89 83 48 01 00 00 mov %eax,0x148(%ebx) <== NOT EXECUTED
if (tty->rawOutBufState != rob_idle) {
11a58e: 8b 83 e4 00 00 00 mov 0xe4(%ebx),%eax <== NOT EXECUTED
11a594: 85 c0 test %eax,%eax <== NOT EXECUTED
11a596: 74 27 je 11a5bf <rtems_termios_ioctl+0x10f> <== NOT EXECUTED
(*tty->handler.write)(
11a598: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED
ctx, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
11a59d: 8b 83 c0 00 00 00 mov 0xc0(%ebx),%eax <== NOT EXECUTED
(*tty->handler.write)(
11a5a3: 89 54 24 08 mov %edx,0x8(%esp) <== NOT EXECUTED
ctx, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
11a5a7: 8b 8b b8 00 00 00 mov 0xb8(%ebx),%ecx <== NOT EXECUTED
(*tty->handler.write)(
11a5ad: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
ctx, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
11a5b0: 01 c8 add %ecx,%eax <== NOT EXECUTED
(*tty->handler.write)(
11a5b2: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
11a5b6: ff 93 30 01 00 00 call *0x130(%ebx) <== NOT EXECUTED
11a5bc: 8d 55 e4 lea -0x1c(%ebp),%edx <== NOT EXECUTED
( *context->lock_release )( context, lock_context );
11a5bf: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
11a5c3: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
11a5c6: ff 57 18 call *0x18(%edi) <== NOT EXECUTED
11a5c9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
if (( tty->flow_ctrl & FL_MDXOF) && !(tty->termios.c_iflag & IXOFF)) {
11a5d0: 8b 83 48 01 00 00 mov 0x148(%ebx),%eax
11a5d6: f6 c4 04 test $0x4,%ah
11a5d9: 74 26 je 11a601 <rtems_termios_ioctl+0x151>
11a5db: f6 43 51 04 testb $0x4,0x51(%ebx)
11a5df: 75 20 jne 11a601 <rtems_termios_ioctl+0x151> <== NEVER TAKEN
tty->flow_ctrl &= ~(FL_MDXOF);
11a5e1: 8b 83 48 01 00 00 mov 0x148(%ebx),%eax
11a5e7: 25 ff fb ff ff and $0xfffffbff,%eax
11a5ec: 89 83 48 01 00 00 mov %eax,0x148(%ebx)
tty->flow_ctrl &= ~(FL_ISNTXOF);
11a5f2: 8b 83 48 01 00 00 mov 0x148(%ebx),%eax
11a5f8: 83 e0 fd and $0xfffffffd,%eax
11a5fb: 89 83 48 01 00 00 mov %eax,0x148(%ebx)
if (( tty->flow_ctrl & FL_MDRTS) && !(tty->termios.c_cflag & CRTSCTS)) {
11a601: 8b 93 48 01 00 00 mov 0x148(%ebx),%edx
11a607: 8b 43 58 mov 0x58(%ebx),%eax
11a60a: 25 00 00 03 00 and $0x30000,%eax
11a60f: f6 c6 01 test $0x1,%dh
11a612: 74 5c je 11a670 <rtems_termios_ioctl+0x1c0> <== ALWAYS TAKEN
11a614: 85 c0 test %eax,%eax <== NOT EXECUTED
11a616: 0f 85 94 03 00 00 jne 11a9b0 <rtems_termios_ioctl+0x500> <== NOT EXECUTED
tty->flow_ctrl &= ~(FL_MDRTS);
11a61c: 8b 83 48 01 00 00 mov 0x148(%ebx),%eax <== NOT EXECUTED
11a622: 25 ff fe ff ff and $0xfffffeff,%eax <== NOT EXECUTED
11a627: 89 83 48 01 00 00 mov %eax,0x148(%ebx) <== NOT EXECUTED
if ((tty->flow_ctrl & FL_IRTSOFF) &&
11a62d: 8b 83 48 01 00 00 mov 0x148(%ebx),%eax <== NOT EXECUTED
11a633: a8 04 test $0x4,%al <== NOT EXECUTED
11a635: 0f 84 55 04 00 00 je 11aa90 <rtems_termios_ioctl+0x5e0> <== NOT EXECUTED
(tty->flow.start_remote_tx != NULL)) {
11a63b: 8b 83 44 01 00 00 mov 0x144(%ebx),%eax <== NOT EXECUTED
if ((tty->flow_ctrl & FL_IRTSOFF) &&
11a641: 85 c0 test %eax,%eax <== NOT EXECUTED
11a643: 0f 84 47 04 00 00 je 11aa90 <rtems_termios_ioctl+0x5e0> <== NOT EXECUTED
tty->flow.start_remote_tx(ctx);
11a649: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
11a64c: ff d0 call *%eax <== NOT EXECUTED
tty->flow_ctrl &= ~(FL_IRTSOFF);
11a64e: 8b 93 48 01 00 00 mov 0x148(%ebx),%edx <== NOT EXECUTED
if (tty->termios.c_cflag & CRTSCTS) {
11a654: 8b 43 58 mov 0x58(%ebx),%eax <== NOT EXECUTED
tty->flow_ctrl &= ~(FL_IRTSOFF);
11a657: 83 e2 fb and $0xfffffffb,%edx <== NOT EXECUTED
11a65a: 89 93 48 01 00 00 mov %edx,0x148(%ebx) <== NOT EXECUTED
if (tty->termios.c_cflag & CRTSCTS) {
11a660: 25 00 00 03 00 and $0x30000,%eax <== NOT EXECUTED
tty->flow_ctrl &= ~(FL_IRTSOFF);
11a665: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11a66c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
if (tty->termios.c_cflag & CRTSCTS) {
11a670: 85 c0 test %eax,%eax
11a672: 0f 85 38 03 00 00 jne 11a9b0 <rtems_termios_ioctl+0x500> <== NEVER TAKEN
if (tty->termios.c_iflag & IXOFF) {
11a678: 8b 43 50 mov 0x50(%ebx),%eax
11a67b: f6 c4 04 test $0x4,%ah
11a67e: 74 12 je 11a692 <rtems_termios_ioctl+0x1e2>
tty->flow_ctrl |= FL_MDXOF;
11a680: 8b 93 48 01 00 00 mov 0x148(%ebx),%edx
11a686: 81 ca 00 04 00 00 or $0x400,%edx
11a68c: 89 93 48 01 00 00 mov %edx,0x148(%ebx)
if (tty->termios.c_iflag & IXON) {
11a692: f6 c4 02 test $0x2,%ah
11a695: 74 11 je 11a6a8 <rtems_termios_ioctl+0x1f8>
tty->flow_ctrl |= FL_MDXON;
11a697: 8b 83 48 01 00 00 mov 0x148(%ebx),%eax
11a69d: 0d 00 02 00 00 or $0x200,%eax
11a6a2: 89 83 48 01 00 00 mov %eax,0x148(%ebx)
if (tty->termios.c_lflag & ICANON) {
11a6a8: f6 43 5d 01 testb $0x1,0x5d(%ebx)
11a6ac: 0f 85 de 02 00 00 jne 11a990 <rtems_termios_ioctl+0x4e0>
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
11a6b2: 0f b6 53 71 movzbl 0x71(%ebx),%edx
11a6b6: 8b 3d e8 2d 12 00 mov 0x122de8,%edi
11a6bc: 89 d1 mov %edx,%ecx
11a6be: 0f af d7 imul %edi,%edx
rtems_clock_get_ticks_per_second() / 10;
11a6c1: bf cd cc cc cc mov $0xcccccccd,%edi
11a6c6: 89 d0 mov %edx,%eax
11a6c8: f7 e7 mul %edi
if (tty->termios.c_cc[VMIN])
11a6ca: 0f b6 43 70 movzbl 0x70(%ebx),%eax
rtems_clock_get_ticks_per_second() / 10;
11a6ce: c1 ea 03 shr $0x3,%edx
if (tty->termios.c_cc[VTIME]) {
11a6d1: 84 c9 test %cl,%cl
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
11a6d3: 89 53 7c mov %edx,0x7c(%ebx)
if (tty->termios.c_cc[VTIME]) {
11a6d6: 0f 84 94 03 00 00 je 11aa70 <rtems_termios_ioctl+0x5c0>
tty->rawInBufSemaphoreWait = true;
11a6dc: c6 83 a8 00 00 00 01 movb $0x1,0xa8(%ebx)
if (tty->termios.c_cc[VMIN])
11a6e3: 84 c0 test %al,%al
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
11a6e5: 89 93 ac 00 00 00 mov %edx,0xac(%ebx)
if (tty->termios.c_cc[VMIN])
11a6eb: 0f 85 ae 02 00 00 jne 11a99f <rtems_termios_ioctl+0x4ef>
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
11a6f1: 89 93 b0 00 00 00 mov %edx,0xb0(%ebx)
11a6f7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11a6fe: 66 90 xchg %ax,%ax
if (tty->handler.set_attributes) {
11a700: 8b 83 34 01 00 00 mov 0x134(%ebx),%eax
11a706: 85 c0 test %eax,%eax
11a708: 74 66 je 11a770 <rtems_termios_ioctl+0x2c0>
sc = (*tty->handler.set_attributes)(tty->device_context, &tty->termios) ?
11a70a: 8d 53 50 lea 0x50(%ebx),%edx
11a70d: 89 54 24 04 mov %edx,0x4(%esp)
11a711: 8b 93 7c 01 00 00 mov 0x17c(%ebx),%edx
11a717: 89 14 24 mov %edx,(%esp)
11a71a: ff d0 call *%eax
RTEMS_SUCCESSFUL : RTEMS_IO_ERROR;
11a71c: 84 c0 test %al,%al
11a71e: 75 50 jne 11a770 <rtems_termios_ioctl+0x2c0>
11a720: bf 1b 00 00 00 mov $0x1b,%edi
_Mutex_Release( mutex );
11a725: 89 34 24 mov %esi,(%esp)
11a728: e8 83 b7 fe ff call 105eb0 <_Mutex_Release>
}
11a72d: 83 c4 3c add $0x3c,%esp
11a730: 89 f8 mov %edi,%eax
11a732: 5b pop %ebx
11a733: 5e pop %esi
11a734: 5f pop %edi
11a735: 5d pop %ebp
11a736: c3 ret
11a737: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11a73e: 66 90 xchg %ax,%ax
switch (args->command) {
11a740: 3d 1a 74 04 40 cmp $0x4004741a,%eax
11a745: 0f 84 95 01 00 00 je 11a8e0 <rtems_termios_ioctl+0x430>
11a74b: 76 63 jbe 11a7b0 <rtems_termios_ioctl+0x300>
11a74d: 3d 13 74 2c 40 cmp $0x402c7413,%eax
11a752: 0f 85 98 00 00 00 jne 11a7f0 <rtems_termios_ioctl+0x340>
*(struct termios *)args->buffer = tty->termios;
11a758: 8b 4a 08 mov 0x8(%edx),%ecx
11a75b: 31 c0 xor %eax,%eax
11a75d: 8b 54 03 50 mov 0x50(%ebx,%eax,1),%edx
11a761: 89 14 01 mov %edx,(%ecx,%eax,1)
11a764: 83 c0 04 add $0x4,%eax
11a767: 83 f8 2c cmp $0x2c,%eax
11a76a: 72 f1 jb 11a75d <rtems_termios_ioctl+0x2ad>
11a76c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
sc = RTEMS_SUCCESSFUL;
11a770: 31 ff xor %edi,%edi
break;
11a772: eb b1 jmp 11a725 <rtems_termios_ioctl+0x275>
11a774: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11a77b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
11a77f: 90 nop
switch (args->command) {
11a780: 3d 1b 74 04 80 cmp $0x8004741b,%eax
11a785: 0f 84 75 01 00 00 je 11a900 <rtems_termios_ioctl+0x450>
11a78b: 3d 0b 74 08 80 cmp $0x8008740b,%eax
11a790: 75 5e jne 11a7f0 <rtems_termios_ioctl+0x340> <== NEVER TAKEN
tty->tty_snd = *wakeup;
11a792: 8b 07 mov (%edi),%eax
11a794: 8b 57 04 mov 0x4(%edi),%edx
sc = RTEMS_SUCCESSFUL;
11a797: 31 ff xor %edi,%edi
tty->tty_snd = *wakeup;
11a799: 89 83 64 01 00 00 mov %eax,0x164(%ebx)
11a79f: 89 93 68 01 00 00 mov %edx,0x168(%ebx)
break;
11a7a5: e9 7b ff ff ff jmp 11a725 <rtems_termios_ioctl+0x275>
11a7aa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
switch (args->command) {
11a7b0: 3d 5e 74 00 20 cmp $0x2000745e,%eax
11a7b5: 0f 84 15 01 00 00 je 11a8d0 <rtems_termios_ioctl+0x420>
11a7bb: 3d 7f 66 04 40 cmp $0x4004667f,%eax
11a7c0: 75 2e jne 11a7f0 <rtems_termios_ioctl+0x340> <== ALWAYS TAKEN
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
11a7c2: 8b 83 88 00 00 00 mov 0x88(%ebx),%eax <== NOT EXECUTED
11a7c8: 8b 8b 84 00 00 00 mov 0x84(%ebx),%ecx <== NOT EXECUTED
if ( rawnc < 0 )
11a7ce: 29 c8 sub %ecx,%eax <== NOT EXECUTED
11a7d0: 0f 88 aa 01 00 00 js 11a980 <rtems_termios_ioctl+0x4d0> <== NOT EXECUTED
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
11a7d6: 8b 4b 40 mov 0x40(%ebx),%ecx <== NOT EXECUTED
11a7d9: 8b 7b 44 mov 0x44(%ebx),%edi <== NOT EXECUTED
11a7dc: 8b 52 08 mov 0x8(%edx),%edx <== NOT EXECUTED
11a7df: 01 c8 add %ecx,%eax <== NOT EXECUTED
11a7e1: 29 f8 sub %edi,%eax <== NOT EXECUTED
sc = RTEMS_SUCCESSFUL;
11a7e3: 31 ff xor %edi,%edi <== NOT EXECUTED
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
11a7e5: 89 02 mov %eax,(%edx) <== NOT EXECUTED
break;
11a7e7: e9 39 ff ff ff jmp 11a725 <rtems_termios_ioctl+0x275> <== NOT EXECUTED
11a7ec: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
11a7f0: 8b 8b 5c 01 00 00 mov 0x15c(%ebx),%ecx
11a7f6: c1 e1 05 shl $0x5,%ecx
11a7f9: 8b 89 18 1d 13 00 mov 0x131d18(%ecx),%ecx
11a7ff: 85 c9 test %ecx,%ecx
11a801: 0f 84 d9 01 00 00 je 11a9e0 <rtems_termios_ioctl+0x530>
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
11a807: 89 54 24 04 mov %edx,0x4(%esp)
11a80b: 89 1c 24 mov %ebx,(%esp)
11a80e: ff d1 call *%ecx
11a810: 89 c7 mov %eax,%edi
11a812: e9 0e ff ff ff jmp 11a725 <rtems_termios_ioctl+0x275>
11a817: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11a81e: 66 90 xchg %ax,%ax
flags = *((int *)args->buffer);
11a820: 8b 42 08 mov 0x8(%edx),%eax
11a823: 8b 00 mov (%eax),%eax
if (flags == 0) {
11a825: 85 c0 test %eax,%eax
11a827: 0f 85 33 01 00 00 jne 11a960 <rtems_termios_ioctl+0x4b0> <== ALWAYS TAKEN
11a82d: bf 01 00 00 00 mov $0x1,%edi <== NOT EXECUTED
rtems_termios_device_context *ctx = tty->device_context;
11a832: 8b 83 7c 01 00 00 mov 0x17c(%ebx),%eax
( *context->lock_acquire )( context, lock_context );
11a838: 8d 55 e4 lea -0x1c(%ebp),%edx
11a83b: 89 54 24 04 mov %edx,0x4(%esp)
11a83f: 89 04 24 mov %eax,(%esp)
11a842: 89 45 d4 mov %eax,-0x2c(%ebp)
11a845: ff 50 14 call *0x14(%eax)
( *context->lock_release )( context, lock_context );
11a848: 8d 55 e4 lea -0x1c(%ebp),%edx
tty->rawOutBuf.Tail = 0;
11a84b: 31 c0 xor %eax,%eax
11a84d: 89 83 c0 00 00 00 mov %eax,0xc0(%ebx)
tty->rawOutBuf.Head = 0;
11a853: 31 c0 xor %eax,%eax
11a855: 89 83 bc 00 00 00 mov %eax,0xbc(%ebx)
tty->rawOutBufState = rob_idle;
11a85b: 31 c0 xor %eax,%eax
11a85d: 89 83 e4 00 00 00 mov %eax,0xe4(%ebx)
11a863: 8b 45 d4 mov -0x2c(%ebp),%eax
11a866: 89 54 24 04 mov %edx,0x4(%esp)
11a86a: 89 04 24 mov %eax,(%esp)
11a86d: ff 50 18 call *0x18(%eax)
if (flags & FREAD) {
11a870: 85 ff test %edi,%edi
11a872: 0f 84 f8 fe ff ff je 11a770 <rtems_termios_ioctl+0x2c0> <== NEVER TAKEN
rtems_termios_device_context *ctx = tty->device_context;
11a878: 8b bb 7c 01 00 00 mov 0x17c(%ebx),%edi
( *context->lock_acquire )( context, lock_context );
11a87e: 8d 45 e4 lea -0x1c(%ebp),%eax
11a881: 89 44 24 04 mov %eax,0x4(%esp)
11a885: 89 3c 24 mov %edi,(%esp)
11a888: ff 57 14 call *0x14(%edi)
tty->rawInBuf.Tail = 0;
11a88b: 31 c9 xor %ecx,%ecx
tty->rawInBuf.Head = 0;
11a88d: 31 c0 xor %eax,%eax
tty->rawInBuf.Tail = 0;
11a88f: 89 8b 88 00 00 00 mov %ecx,0x88(%ebx)
tty->rawInBuf.Head = 0;
11a895: 89 83 84 00 00 00 mov %eax,0x84(%ebx)
( *context->lock_release )( context, lock_context );
11a89b: 8d 45 e4 lea -0x1c(%ebp),%eax
11a89e: 89 3c 24 mov %edi,(%esp)
11a8a1: 89 44 24 04 mov %eax,0x4(%esp)
11a8a5: ff 57 18 call *0x18(%edi)
sc = RTEMS_SUCCESSFUL;
11a8a8: 31 ff xor %edi,%edi
}
11a8aa: e9 76 fe ff ff jmp 11a725 <rtems_termios_ioctl+0x275>
11a8af: 90 nop
tty->tty_rcv = *wakeup;
11a8b0: 8b 07 mov (%edi),%eax
11a8b2: 8b 57 04 mov 0x4(%edi),%edx
sc = RTEMS_SUCCESSFUL;
11a8b5: 31 ff xor %edi,%edi
tty->tty_rcv = *wakeup;
11a8b7: 89 83 6c 01 00 00 mov %eax,0x16c(%ebx)
11a8bd: 89 93 70 01 00 00 mov %edx,0x170(%ebx)
break;
11a8c3: e9 5d fe ff ff jmp 11a725 <rtems_termios_ioctl+0x275>
11a8c8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11a8cf: 90 nop
drainOutput (tty);
11a8d0: 89 d8 mov %ebx,%eax
sc = RTEMS_SUCCESSFUL;
11a8d2: 31 ff xor %edi,%edi
drainOutput (tty);
11a8d4: e8 57 df ff ff call 118830 <drainOutput>
break;
11a8d9: e9 47 fe ff ff jmp 11a725 <rtems_termios_ioctl+0x275>
11a8de: 66 90 xchg %ax,%ax
*(int*)(args->buffer)=tty->t_line;
11a8e0: 8b 8b 5c 01 00 00 mov 0x15c(%ebx),%ecx
sc = RTEMS_SUCCESSFUL;
11a8e6: 31 ff xor %edi,%edi
*(int*)(args->buffer)=tty->t_line;
11a8e8: 8b 42 08 mov 0x8(%edx),%eax
11a8eb: 89 08 mov %ecx,(%eax)
break;
11a8ed: e9 33 fe ff ff jmp 11a725 <rtems_termios_ioctl+0x275>
11a8f2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11a8f9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
11a900: 8b 83 5c 01 00 00 mov 0x15c(%ebx),%eax
11a906: c1 e0 05 shl $0x5,%eax
11a909: 8b 80 04 1d 13 00 mov 0x131d04(%eax),%eax
11a90f: 85 c0 test %eax,%eax
11a911: 0f 84 b9 00 00 00 je 11a9d0 <rtems_termios_ioctl+0x520>
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
11a917: 89 1c 24 mov %ebx,(%esp)
11a91a: 89 55 08 mov %edx,0x8(%ebp)
11a91d: ff d0 call *%eax
11a91f: 8b 55 08 mov 0x8(%ebp),%edx
11a922: 89 c7 mov %eax,%edi
tty->t_line=*(int*)(args->buffer);
11a924: 8b 42 08 mov 0x8(%edx),%eax
tty->t_sc = NULL; /* ensure that no more valid data */
11a927: 31 d2 xor %edx,%edx
tty->t_line=*(int*)(args->buffer);
11a929: 8b 00 mov (%eax),%eax
tty->t_sc = NULL; /* ensure that no more valid data */
11a92b: 89 93 60 01 00 00 mov %edx,0x160(%ebx)
tty->t_line=*(int*)(args->buffer);
11a931: 89 83 5c 01 00 00 mov %eax,0x15c(%ebx)
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
11a937: c1 e0 05 shl $0x5,%eax
11a93a: 8b 80 00 1d 13 00 mov 0x131d00(%eax),%eax
11a940: 85 c0 test %eax,%eax
11a942: 0f 84 dd fd ff ff je 11a725 <rtems_termios_ioctl+0x275>
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
11a948: 89 1c 24 mov %ebx,(%esp)
11a94b: ff d0 call *%eax
11a94d: 89 c7 mov %eax,%edi
11a94f: e9 d1 fd ff ff jmp 11a725 <rtems_termios_ioctl+0x275>
11a954: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11a95b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
11a95f: 90 nop
if (flags & FREAD) {
11a960: 89 c7 mov %eax,%edi
11a962: 83 e7 01 and $0x1,%edi
if (flags & FWRITE) {
11a965: a8 02 test $0x2,%al
11a967: 0f 84 03 ff ff ff je 11a870 <rtems_termios_ioctl+0x3c0>
11a96d: e9 c0 fe ff ff jmp 11a832 <rtems_termios_ioctl+0x382>
11a972: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11a979: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
rawnc += tty->rawInBuf.Size;
11a980: 8b 8b 8c 00 00 00 mov 0x8c(%ebx),%ecx <== NOT EXECUTED
11a986: 01 c8 add %ecx,%eax <== NOT EXECUTED
11a988: e9 49 fe ff ff jmp 11a7d6 <rtems_termios_ioctl+0x326> <== NOT EXECUTED
11a98d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
tty->rawInBufSemaphoreWait = true;
11a990: c6 83 a8 00 00 00 01 movb $0x1,0xa8(%ebx)
tty->rawInBufSemaphoreTimeout = 0;
11a997: 31 d2 xor %edx,%edx
11a999: 89 93 ac 00 00 00 mov %edx,0xac(%ebx)
tty->rawInBufSemaphoreFirstTimeout = 0;
11a99f: 31 c0 xor %eax,%eax
11a9a1: 89 83 b0 00 00 00 mov %eax,0xb0(%ebx)
11a9a7: e9 54 fd ff ff jmp 11a700 <rtems_termios_ioctl+0x250>
11a9ac: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
tty->flow_ctrl |= FL_MDRTS;
11a9b0: 8b 83 48 01 00 00 mov 0x148(%ebx),%eax <== NOT EXECUTED
11a9b6: 0d 00 01 00 00 or $0x100,%eax <== NOT EXECUTED
11a9bb: 89 83 48 01 00 00 mov %eax,0x148(%ebx) <== NOT EXECUTED
11a9c1: e9 b2 fc ff ff jmp 11a678 <rtems_termios_ioctl+0x1c8> <== NOT EXECUTED
11a9c6: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11a9cd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
sc = RTEMS_SUCCESSFUL;
11a9d0: 31 ff xor %edi,%edi
11a9d2: e9 4d ff ff ff jmp 11a924 <rtems_termios_ioctl+0x474>
11a9d7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11a9de: 66 90 xchg %ax,%ax
} else if (tty->handler.ioctl) {
11a9e0: 8b 8b 38 01 00 00 mov 0x138(%ebx),%ecx
11a9e6: 85 c9 test %ecx,%ecx
11a9e8: 0f 84 b6 00 00 00 je 11aaa4 <rtems_termios_ioctl+0x5f4> <== ALWAYS TAKEN
args->ioctl_return = (*tty->handler.ioctl) (tty->device_context,
11a9ee: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED
11a9f1: 8b 7a 08 mov 0x8(%edx),%edi <== NOT EXECUTED
11a9f4: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
11a9f8: 89 7c 24 08 mov %edi,0x8(%esp) <== NOT EXECUTED
sc = RTEMS_SUCCESSFUL;
11a9fc: 31 ff xor %edi,%edi <== NOT EXECUTED
args->ioctl_return = (*tty->handler.ioctl) (tty->device_context,
11a9fe: 8b 83 7c 01 00 00 mov 0x17c(%ebx),%eax <== NOT EXECUTED
11aa04: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
11aa07: ff d1 call *%ecx <== NOT EXECUTED
11aa09: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
11aa0c: 89 42 0c mov %eax,0xc(%edx) <== NOT EXECUTED
sc = RTEMS_SUCCESSFUL;
11aa0f: e9 11 fd ff ff jmp 11a725 <rtems_termios_ioctl+0x275> <== NOT EXECUTED
11aa14: 89 55 08 mov %edx,0x8(%ebp)
drainOutput (tty);
11aa17: 89 d8 mov %ebx,%eax
11aa19: e8 12 de ff ff call 118830 <drainOutput>
if (args->command == TIOCSETAF) {
11aa1e: 8b 55 08 mov 0x8(%ebp),%edx
11aa21: 81 7a 04 16 74 2c 80 cmpl $0x802c7416,0x4(%edx)
11aa28: 0f 85 07 fb ff ff jne 11a535 <rtems_termios_ioctl+0x85>
rtems_termios_device_context *ctx = tty->device_context;
11aa2e: 8b bb 7c 01 00 00 mov 0x17c(%ebx),%edi
( *context->lock_acquire )( context, lock_context );
11aa34: 8d 45 e4 lea -0x1c(%ebp),%eax
11aa37: 89 44 24 04 mov %eax,0x4(%esp)
11aa3b: 89 3c 24 mov %edi,(%esp)
11aa3e: ff 57 14 call *0x14(%edi)
tty->rawInBuf.Tail = 0;
11aa41: 31 c0 xor %eax,%eax
11aa43: 89 83 88 00 00 00 mov %eax,0x88(%ebx)
tty->rawInBuf.Head = 0;
11aa49: 31 c0 xor %eax,%eax
11aa4b: 89 83 84 00 00 00 mov %eax,0x84(%ebx)
( *context->lock_release )( context, lock_context );
11aa51: 8d 45 e4 lea -0x1c(%ebp),%eax
11aa54: 89 44 24 04 mov %eax,0x4(%esp)
11aa58: 89 3c 24 mov %edi,(%esp)
11aa5b: ff 57 18 call *0x18(%edi)
}
11aa5e: e9 d2 fa ff ff jmp 11a535 <rtems_termios_ioctl+0x85>
11aa63: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11aa6a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
if (tty->termios.c_cc[VMIN]) {
11aa70: 84 c0 test %al,%al
11aa72: 0f 85 18 ff ff ff jne 11a990 <rtems_termios_ioctl+0x4e0>
tty->rawInBufSemaphoreWait = false;
11aa78: c6 83 a8 00 00 00 00 movb $0x0,0xa8(%ebx)
11aa7f: 90 nop
11aa80: e9 7b fc ff ff jmp 11a700 <rtems_termios_ioctl+0x250>
11aa85: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11aa8c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
tty->flow_ctrl &= ~(FL_IRTSOFF);
11aa90: 8b 83 48 01 00 00 mov 0x148(%ebx),%eax <== NOT EXECUTED
11aa96: 83 e0 fb and $0xfffffffb,%eax <== NOT EXECUTED
11aa99: 89 83 48 01 00 00 mov %eax,0x148(%ebx) <== NOT EXECUTED
if (tty->termios.c_cflag & CRTSCTS) {
11aa9f: e9 d4 fb ff ff jmp 11a678 <rtems_termios_ioctl+0x1c8> <== NOT EXECUTED
sc = RTEMS_INVALID_NUMBER;
11aaa4: bf 0a 00 00 00 mov $0xa,%edi
11aaa9: e9 77 fc ff ff jmp 11a725 <rtems_termios_ioctl+0x275>
11aaae: 90 nop
11aaaf: 90 nop
0011a340 <rtems_termios_open>:
{
11a340: 55 push %ebp
11a341: 89 e5 mov %esp,%ebp
11a343: 56 push %esi
11a344: 53 push %ebx
11a345: 83 ec 10 sub $0x10,%esp
_Mutex_Acquire( mutex );
11a348: c7 04 24 54 94 12 00 movl $0x129454,(%esp)
11a34f: 8b 5d 08 mov 0x8(%ebp),%ebx
11a352: 8b 75 0c mov 0xc(%ebp),%esi
11a355: e8 e6 ba fe ff call 105e40 <_Mutex_Acquire>
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
11a35a: a1 f0 1c 13 00 mov 0x131cf0,%eax
11a35f: 85 c0 test %eax,%eax
11a361: 75 13 jne 11a376 <rtems_termios_open+0x36>
11a363: eb 1b jmp 11a380 <rtems_termios_open+0x40>
11a365: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11a36c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
11a370: 8b 00 mov (%eax),%eax <== NOT EXECUTED
11a372: 85 c0 test %eax,%eax <== NOT EXECUTED
11a374: 74 0a je 11a380 <rtems_termios_open+0x40> <== NOT EXECUTED
if ((tty->major == major) && (tty->minor == minor))
11a376: 39 58 0c cmp %ebx,0xc(%eax)
11a379: 75 f5 jne 11a370 <rtems_termios_open+0x30> <== NEVER TAKEN
11a37b: 39 70 10 cmp %esi,0x10(%eax)
11a37e: 75 f0 jne 11a370 <rtems_termios_open+0x30> <== NEVER TAKEN
tty = rtems_termios_open_tty(
11a380: 89 04 24 mov %eax,(%esp)
11a383: 8b 55 14 mov 0x14(%ebp),%edx
11a386: 31 c9 xor %ecx,%ecx
11a388: 89 4c 24 04 mov %ecx,0x4(%esp)
11a38c: 8b 4d 10 mov 0x10(%ebp),%ecx
11a38f: 89 d8 mov %ebx,%eax
11a391: 89 54 24 08 mov %edx,0x8(%esp)
11a395: 89 f2 mov %esi,%edx
11a397: e8 84 e6 ff ff call 118a20 <rtems_termios_open_tty>
if (tty == NULL) {
11a39c: 85 c0 test %eax,%eax
11a39e: 74 4c je 11a3ec <rtems_termios_open+0xac>
if (tty->refcount == 1) {
11a3a0: 83 78 08 01 cmpl $0x1,0x8(%eax)
11a3a4: 74 1a je 11a3c0 <rtems_termios_open+0x80>
_Mutex_Release( mutex );
11a3a6: c7 04 24 54 94 12 00 movl $0x129454,(%esp)
11a3ad: e8 fe ba fe ff call 105eb0 <_Mutex_Release>
return RTEMS_SUCCESSFUL;
11a3b2: 31 c0 xor %eax,%eax
}
11a3b4: 83 c4 10 add $0x10,%esp
11a3b7: 5b pop %ebx
11a3b8: 5e pop %esi
11a3b9: 5d pop %ebp
11a3ba: c3 ret
11a3bb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
11a3bf: 90 nop
tty->back = NULL;
11a3c0: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
tty->forw = rtems_termios_ttyHead;
11a3c7: 8b 15 f0 1c 13 00 mov 0x131cf0,%edx
11a3cd: 89 10 mov %edx,(%eax)
if (rtems_termios_ttyHead != NULL)
11a3cf: 85 d2 test %edx,%edx
11a3d1: 74 03 je 11a3d6 <rtems_termios_open+0x96> <== ALWAYS TAKEN
rtems_termios_ttyHead->back = tty;
11a3d3: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED
rtems_termios_ttyHead = tty;
11a3d6: a3 f0 1c 13 00 mov %eax,0x131cf0
if (rtems_termios_ttyTail == NULL)
11a3db: 8b 15 ec 1c 13 00 mov 0x131cec,%edx
11a3e1: 85 d2 test %edx,%edx
11a3e3: 75 c1 jne 11a3a6 <rtems_termios_open+0x66> <== NEVER TAKEN
rtems_termios_ttyTail = tty;
11a3e5: a3 ec 1c 13 00 mov %eax,0x131cec
11a3ea: eb ba jmp 11a3a6 <rtems_termios_open+0x66>
11a3ec: c7 04 24 54 94 12 00 movl $0x129454,(%esp)
11a3f3: e8 b8 ba fe ff call 105eb0 <_Mutex_Release>
return RTEMS_NO_MEMORY;
11a3f8: b8 1a 00 00 00 mov $0x1a,%eax
11a3fd: eb b5 jmp 11a3b4 <rtems_termios_open+0x74>
11a3ff: 90 nop
00104be0 <rtems_termios_register_isig_handler>:
{
104be0: 55 push %ebp
104be1: 89 e5 mov %esp,%ebp
104be3: 8b 45 08 mov 0x8(%ebp),%eax
if (handler == NULL) {
104be6: 85 c0 test %eax,%eax
104be8: 74 16 je 104c00 <rtems_termios_register_isig_handler+0x20><== NEVER TAKEN
termios_isig_handler = handler;
104bea: a3 58 92 12 00 mov %eax,0x129258
return RTEMS_SUCCESSFUL;
104bef: 31 c0 xor %eax,%eax
}
104bf1: 5d pop %ebp
104bf2: c3 ret
104bf3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
104bfa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
104c00: 5d pop %ebp <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
104c01: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED
}
104c06: c3 ret <== NOT EXECUTED
104c07: 90 nop
104c08: 90 nop
104c09: 90 nop
104c0a: 90 nop
104c0b: 90 nop
104c0c: 90 nop
104c0d: 90 nop
104c0e: 90 nop
104c0f: 90 nop
001072d0 <rtems_termios_set_best_baud>:
void rtems_termios_set_best_baud(
struct termios *term,
uint32_t baud
)
{
1072d0: 55 push %ebp
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 ) {
1072d1: 8b 15 20 5d 12 00 mov 0x125d20,%edx
1072d7: b9 20 5d 12 00 mov $0x125d20,%ecx
{
1072dc: 89 e5 mov %esp,%ebp
1072de: 89 c8 mov %ecx,%eax
1072e0: 56 push %esi
1072e1: 8b 75 08 mov 0x8(%ebp),%esi
1072e4: 53 push %ebx
1072e5: 8b 5d 0c mov 0xc(%ebp),%ebx
while ( current->name != NULL && current->local_value < baud ) {
1072e8: 85 d2 test %edx,%edx
1072ea: 75 12 jne 1072fe <rtems_termios_set_best_baud+0x2e> <== ALWAYS TAKEN
1072ec: eb 32 jmp 107320 <rtems_termios_set_best_baud+0x50> <== NOT EXECUTED
1072ee: 66 90 xchg %ax,%ax <== NOT EXECUTED
last = current;
++current;
1072f0: 8d 50 0c lea 0xc(%eax),%edx
while ( current->name != NULL && current->local_value < baud ) {
1072f3: 89 c1 mov %eax,%ecx
1072f5: 8b 40 0c mov 0xc(%eax),%eax
1072f8: 85 c0 test %eax,%eax
1072fa: 74 24 je 107320 <rtems_termios_set_best_baud+0x50>
1072fc: 89 d0 mov %edx,%eax
1072fe: 8b 50 04 mov 0x4(%eax),%edx
107301: 39 da cmp %ebx,%edx
107303: 72 eb jb 1072f0 <rtems_termios_set_best_baud+0x20>
}
if ( current->name != NULL ) {
uint32_t mid = (last->local_value + current->local_value) / UINT32_C( 2 );
107305: 03 51 04 add 0x4(%ecx),%edx
107308: d1 ea shr %edx
spd = baud <= mid ? last->remote_value : current->remote_value;
10730a: 39 d3 cmp %edx,%ebx
10730c: 77 22 ja 107330 <rtems_termios_set_best_baud+0x60>
10730e: 8b 41 08 mov 0x8(%ecx),%eax
} else {
spd = B460800;
}
term->c_ispeed = spd;
107311: 89 46 24 mov %eax,0x24(%esi)
term->c_ospeed = spd;
107314: 89 46 28 mov %eax,0x28(%esi)
}
107317: 5b pop %ebx
107318: 5e pop %esi
107319: 5d pop %ebp
10731a: c3 ret
10731b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10731f: 90 nop
spd = B460800;
107320: b8 00 08 07 00 mov $0x70800,%eax <== NOT EXECUTED
term->c_ispeed = spd;
107325: 89 46 24 mov %eax,0x24(%esi) <== NOT EXECUTED
term->c_ospeed = spd;
107328: 89 46 28 mov %eax,0x28(%esi) <== NOT EXECUTED
}
10732b: 5b pop %ebx <== NOT EXECUTED
10732c: 5e pop %esi <== NOT EXECUTED
10732d: 5d pop %ebp <== NOT EXECUTED
10732e: c3 ret <== NOT EXECUTED
10732f: 90 nop <== NOT EXECUTED
spd = baud <= mid ? last->remote_value : current->remote_value;
107330: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED
term->c_ispeed = spd;
107333: 89 46 24 mov %eax,0x24(%esi) <== NOT EXECUTED
term->c_ospeed = spd;
107336: 89 46 28 mov %eax,0x28(%esi) <== NOT EXECUTED
}
107339: 5b pop %ebx <== NOT EXECUTED
10733a: 5e pop %esi <== NOT EXECUTED
10733b: 5d pop %ebp <== NOT EXECUTED
10733c: c3 ret <== NOT EXECUTED
10733d: 90 nop
10733e: 90 nop
10733f: 90 nop
00100d00 <rtems_verror>:
int rtems_verror(
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
100d00: 55 push %ebp
100d01: 89 e5 mov %esp,%ebp
100d03: 57 push %edi
100d04: 56 push %esi
100d05: 53 push %ebx
100d06: 83 ec 1c sub $0x1c,%esp
100d09: 8b 75 08 mov 0x8(%ebp),%esi
int local_errno = 0;
int chars_written = 0;
rtems_status_code status;
if (error_flag & RTEMS_ERROR_PANIC) {
100d0c: f7 c6 00 00 00 20 test $0x20000000,%esi
100d12: 74 16 je 100d2a <rtems_verror+0x2a>
if (rtems_panic_in_progress++)
100d14: a1 e4 a3 1a 00 mov 0x1aa3e4,%eax
100d19: 8d 50 01 lea 0x1(%eax),%edx
100d1c: 85 c0 test %eax,%eax
100d1e: 89 15 e4 a3 1a 00 mov %edx,0x1aa3e4
100d24: 0f 85 86 00 00 00 jne 100db0 <rtems_verror+0xb0> <== NEVER TAKEN
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
100d2a: e8 d1 f5 ff ff call 100300 <__getreent>
status = error_flag & ~RTEMS_ERROR_MASK;
100d2f: 89 f7 mov %esi,%edi
100d31: 81 e7 ff ff ff 8f and $0x8fffffff,%edi
(void) fflush(stdout); /* in case stdout/stderr same */
100d37: 8b 40 08 mov 0x8(%eax),%eax
100d3a: 89 04 24 mov %eax,(%esp)
100d3d: e8 be 89 05 00 call 159700 <fflush>
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
100d42: 81 e6 00 00 00 40 and $0x40000000,%esi
100d48: 0f 85 82 00 00 00 jne 100dd0 <rtems_verror+0xd0>
#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);
100d4e: e8 ad f5 ff ff call 100300 <__getreent>
100d53: 8b 4d 10 mov 0x10(%ebp),%ecx
100d56: 89 4c 24 08 mov %ecx,0x8(%esp)
100d5a: 8b 4d 0c mov 0xc(%ebp),%ecx
100d5d: 89 4c 24 04 mov %ecx,0x4(%esp)
100d61: 8b 40 0c mov 0xc(%eax),%eax
100d64: 89 04 24 mov %eax,(%esp)
100d67: e8 74 94 07 00 call 17a1e0 <vfprintf>
if (status)
100d6c: 85 ff test %edi,%edi
chars_written += vfprintf(stderr, printf_format, arglist);
100d6e: 89 c3 mov %eax,%ebx
if (status)
100d70: 0f 85 ca 00 00 00 jne 100e40 <rtems_verror+0x140>
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
}
chars_written += fprintf(stderr, "\n");
100d76: e8 85 f5 ff ff call 100300 <__getreent>
100d7b: ba 7c d4 19 00 mov $0x19d47c,%edx
100d80: 89 54 24 04 mov %edx,0x4(%esp)
100d84: 8b 40 0c mov 0xc(%eax),%eax
100d87: 89 04 24 mov %eax,(%esp)
100d8a: e8 51 99 05 00 call 15a6e0 <fprintf>
100d8f: 01 c3 add %eax,%ebx
(void) fflush(stderr);
100d91: e8 6a f5 ff ff call 100300 <__getreent>
100d96: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED
100d99: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
100d9c: e8 5f 89 05 00 call 159700 <fflush> <== NOT EXECUTED
return chars_written;
}
100da1: 83 c4 1c add $0x1c,%esp
100da4: 89 d8 mov %ebx,%eax
100da6: 5b pop %ebx
100da7: 5e pop %esi
100da8: 5f pop %edi
100da9: 5d pop %ebp
100daa: c3 ret
100dab: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
100daf: 90 nop
const ISR_lock_Context *lock_context
)
{
uint32_t disable_level;
disable_level = cpu_self->thread_dispatch_disable_level;
100db0: a1 30 a8 1a 00 mov 0x1aa830,%eax <== NOT EXECUTED
return 0;
100db5: 31 db xor %ebx,%ebx <== NOT EXECUTED
_Profiling_Thread_dispatch_disable_critical(
cpu_self,
disable_level,
lock_context
);
cpu_self->thread_dispatch_disable_level = disable_level + 1;
100db7: 40 inc %eax <== NOT EXECUTED
if (rtems_panic_in_progress > 2)
100db8: 83 fa 02 cmp $0x2,%edx <== NOT EXECUTED
100dbb: a3 30 a8 1a 00 mov %eax,0x1aa830 <== NOT EXECUTED
100dc0: 0f 8e 64 ff ff ff jle 100d2a <rtems_verror+0x2a> <== NOT EXECUTED
}
100dc6: 83 c4 1c add $0x1c,%esp <== NOT EXECUTED
100dc9: 89 d8 mov %ebx,%eax <== NOT EXECUTED
100dcb: 5b pop %ebx <== NOT EXECUTED
100dcc: 5e pop %esi <== NOT EXECUTED
100dcd: 5f pop %edi <== NOT EXECUTED
100dce: 5d pop %ebp <== NOT EXECUTED
100dcf: c3 ret <== NOT EXECUTED
local_errno = errno;
100dd0: e8 1b 84 05 00 call 1591f0 <__errno>
100dd5: 8b 30 mov (%eax),%esi
chars_written += vfprintf(stderr, printf_format, arglist);
100dd7: e8 24 f5 ff ff call 100300 <__getreent>
100ddc: 8b 55 10 mov 0x10(%ebp),%edx
100ddf: 8b 4d 0c mov 0xc(%ebp),%ecx
100de2: 89 54 24 08 mov %edx,0x8(%esp)
100de6: 89 4c 24 04 mov %ecx,0x4(%esp)
100dea: 8b 40 0c mov 0xc(%eax),%eax
100ded: 89 04 24 mov %eax,(%esp)
100df0: e8 eb 93 07 00 call 17a1e0 <vfprintf>
if (status)
100df5: 85 ff test %edi,%edi
chars_written += vfprintf(stderr, printf_format, arglist);
100df7: 89 c3 mov %eax,%ebx
if (status)
100df9: 75 47 jne 100e42 <rtems_verror+0x142>
if (local_errno) {
100dfb: 85 f6 test %esi,%esi
100dfd: 0f 84 73 ff ff ff je 100d76 <rtems_verror+0x76>
if ((local_errno > 0) && *strerror(local_errno))
100e03: 7e 0d jle 100e12 <rtems_verror+0x112>
100e05: 89 34 24 mov %esi,(%esp)
100e08: e8 33 92 06 00 call 16a040 <strerror>
100e0d: 80 38 00 cmpb $0x0,(%eax)
100e10: 75 5e jne 100e70 <rtems_verror+0x170> <== ALWAYS TAKEN
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
100e12: e8 e9 f4 ff ff call 100300 <__getreent>
100e17: b9 58 e6 18 00 mov $0x18e658,%ecx
100e1c: 89 74 24 08 mov %esi,0x8(%esp)
100e20: 89 4c 24 04 mov %ecx,0x4(%esp)
100e24: 8b 40 0c mov 0xc(%eax),%eax
100e27: 89 04 24 mov %eax,(%esp)
100e2a: e8 b1 98 05 00 call 15a6e0 <fprintf>
100e2f: 01 c3 add %eax,%ebx
100e31: e9 40 ff ff ff jmp 100d76 <rtems_verror+0x76>
100e36: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
100e3d: 8d 76 00 lea 0x0(%esi),%esi
int local_errno = 0;
100e40: 31 f6 xor %esi,%esi
fprintf(stderr, " (status: %s)", rtems_status_text(status));
100e42: 89 3c 24 mov %edi,(%esp)
100e45: e8 96 2e 01 00 call 113ce0 <rtems_status_text>
100e4a: 89 c7 mov %eax,%edi
100e4c: e8 af f4 ff ff call 100300 <__getreent>
100e51: 89 7c 24 08 mov %edi,0x8(%esp)
100e55: bf 3d e6 18 00 mov $0x18e63d,%edi
100e5a: 89 7c 24 04 mov %edi,0x4(%esp)
100e5e: 8b 40 0c mov 0xc(%eax),%eax
100e61: 89 04 24 mov %eax,(%esp)
100e64: e8 77 98 05 00 call 15a6e0 <fprintf>
chars_written +=
100e69: 01 c3 add %eax,%ebx
100e6b: eb 8e jmp 100dfb <rtems_verror+0xfb>
100e6d: 8d 76 00 lea 0x0(%esi),%esi
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
100e70: 89 34 24 mov %esi,(%esp)
100e73: e8 c8 91 06 00 call 16a040 <strerror>
100e78: 89 c6 mov %eax,%esi
100e7a: e8 81 f4 ff ff call 100300 <__getreent>
100e7f: 89 74 24 08 mov %esi,0x8(%esp)
100e83: be 4b e6 18 00 mov $0x18e64b,%esi
100e88: 89 74 24 04 mov %esi,0x4(%esp)
100e8c: 8b 40 0c mov 0xc(%eax),%eax
100e8f: 89 04 24 mov %eax,(%esp)
100e92: e8 49 98 05 00 call 15a6e0 <fprintf>
100e97: 01 c3 add %eax,%ebx
100e99: e9 d8 fe ff ff jmp 100d76 <rtems_verror+0x76>
100e9e: 90 nop
100e9f: 90 nop
001181d0 <rtems_vprintf>:
int rtems_vprintf(
const rtems_printer *printer,
const char *format,
va_list ap
)
{
1181d0: 55 push %ebp
1181d1: 89 e5 mov %esp,%ebp
1181d3: 53 push %ebx
1181d4: 8b 45 08 mov 0x8(%ebp),%eax
*
* @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;
1181d7: 85 c0 test %eax,%eax
1181d9: 74 15 je 1181f0 <rtems_vprintf+0x20> <== NEVER TAKEN
1181db: 8b 50 04 mov 0x4(%eax),%edx
1181de: 85 d2 test %edx,%edx
1181e0: 74 0e je 1181f0 <rtems_vprintf+0x20> <== NEVER TAKEN
int len = 0;
if ( rtems_print_printer_valid( printer ) ) {
len = printer->printer( printer->context, format, ap );
1181e2: 8b 00 mov (%eax),%eax
}
return len;
}
1181e4: 5b pop %ebx
len = printer->printer( printer->context, format, ap );
1181e5: 89 45 08 mov %eax,0x8(%ebp)
}
1181e8: 5d pop %ebp
len = printer->printer( printer->context, format, ap );
1181e9: ff e2 jmp *%edx
1181eb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
1181ef: 90 nop
}
1181f0: 5b pop %ebx <== NOT EXECUTED
1181f1: 31 c0 xor %eax,%eax <== NOT EXECUTED
1181f3: 5d pop %ebp <== NOT EXECUTED
1181f4: c3 ret <== NOT EXECUTED
1181f5: 90 nop
1181f6: 90 nop
1181f7: 90 nop
1181f8: 90 nop
1181f9: 90 nop
1181fa: 90 nop
1181fb: 90 nop
1181fc: 90 nop
1181fd: 90 nop
1181fe: 90 nop
1181ff: 90 nop
00101d20 <setgrent>:
void setgrent(void)
{
101d20: 55 push %ebp
pthread_once(&grp_once, grp_init);
101d21: b9 80 1c 10 00 mov $0x101c80,%ecx
{
101d26: 89 e5 mov %esp,%ebp
101d28: 56 push %esi
101d29: 53 push %ebx
101d2a: 83 ec 10 sub $0x10,%esp
pthread_once(&grp_once, grp_init);
101d2d: 89 4c 24 04 mov %ecx,0x4(%esp)
101d31: c7 04 24 ec a3 1a 00 movl $0x1aa3ec,(%esp)
101d38: e8 f3 0e 01 00 call 112c30 <pthread_once>
return pthread_getspecific(grp_key);
101d3d: a1 e8 a3 1a 00 mov 0x1aa3e8,%eax
101d42: 89 04 24 mov %eax,(%esp)
101d45: e8 86 0a 01 00 call 1127d0 <pthread_getspecific>
grp_context *ctx = grp_get_context();
if (ctx == NULL) {
101d4a: 85 c0 test %eax,%eax
101d4c: 89 c3 mov %eax,%ebx
101d4e: 74 40 je 101d90 <setgrent+0x70>
return;
}
}
_libcsupport_pwdgrp_init();
101d50: e8 db 1d 00 00 call 103b30 <_libcsupport_pwdgrp_init>
if (ctx->fp != NULL)
101d55: 8b 03 mov (%ebx),%eax
101d57: 85 c0 test %eax,%eax
101d59: 74 08 je 101d63 <setgrent+0x43>
fclose(ctx->fp);
101d5b: 89 04 24 mov %eax,(%esp)
101d5e: e8 6d 76 05 00 call 1593d0 <fclose>
ctx->fp = fopen("/etc/group", "r");
101d63: c7 04 24 ec e6 18 00 movl $0x18e6ec,(%esp)
101d6a: b8 97 5b 19 00 mov $0x195b97,%eax
101d6f: 89 44 24 04 mov %eax,0x4(%esp)
101d73: e8 48 89 05 00 call 15a6c0 <fopen>
101d78: 89 03 mov %eax,(%ebx)
}
101d7a: 83 c4 10 add $0x10,%esp
101d7d: 5b pop %ebx
101d7e: 5e pop %esi
101d7f: 5d pop %ebp
101d80: c3 ret
101d81: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
101d88: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
101d8f: 90 nop
ctx = calloc(1, sizeof(*ctx));
101d90: c7 04 24 01 00 00 00 movl $0x1,(%esp)
101d97: ba 14 01 00 00 mov $0x114,%edx
101d9c: 89 54 24 04 mov %edx,0x4(%esp)
101da0: e8 0b ea ff ff call 1007b0 <calloc>
if (ctx == NULL)
101da5: 85 c0 test %eax,%eax
ctx = calloc(1, sizeof(*ctx));
101da7: 89 c6 mov %eax,%esi
101da9: 89 c3 mov %eax,%ebx
if (ctx == NULL)
101dab: 74 cd je 101d7a <setgrent+0x5a> <== NEVER TAKEN
eno = pthread_setspecific(grp_key, ctx);
101dad: 89 44 24 04 mov %eax,0x4(%esp)
101db1: a1 e8 a3 1a 00 mov 0x1aa3e8,%eax
101db6: 89 04 24 mov %eax,(%esp)
101db9: e8 52 0a 01 00 call 112810 <pthread_setspecific>
if (eno != 0) {
101dbe: 85 c0 test %eax,%eax
101dc0: 74 8e je 101d50 <setgrent+0x30> <== ALWAYS TAKEN
free(ctx);
101dc2: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
101dc5: e8 96 f9 ff ff call 101760 <free> <== NOT EXECUTED
return;
101dca: eb ae jmp 101d7a <setgrent+0x5a> <== NOT EXECUTED
101dcc: 90 nop
101dcd: 90 nop
101dce: 90 nop
101dcf: 90 nop
00104bf0 <stat>:
* POSIX 1003.1b 5.6.2 - Get File Status
*
* Reused from lstat().
*/
int _STAT_NAME( const char *path, struct stat *buf )
{
104bf0: 55 push %ebp
int rv = 0;
rtems_filesystem_eval_path_context_t ctx;
int eval_flags = _STAT_FOLLOW_LINKS;
const rtems_filesystem_location_info_t *currentloc =
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
104bf1: b8 18 00 00 00 mov $0x18,%eax
{
104bf6: 89 e5 mov %esp,%ebp
104bf8: 57 push %edi
memset( buf, 0, sizeof( *buf ) );
104bf9: 31 ff xor %edi,%edi
{
104bfb: 56 push %esi
104bfc: be 58 00 00 00 mov $0x58,%esi
104c01: 53 push %ebx
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
104c02: 8d 5d b0 lea -0x50(%ebp),%ebx
{
104c05: 83 ec 6c sub $0x6c,%esp
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
104c08: 89 44 24 08 mov %eax,0x8(%esp)
104c0c: 8b 45 08 mov 0x8(%ebp),%eax
104c0f: 89 1c 24 mov %ebx,(%esp)
104c12: 89 44 24 04 mov %eax,0x4(%esp)
104c16: e8 e5 04 00 00 call 105100 <rtems_filesystem_eval_path_start>
memset( buf, 0, sizeof( *buf ) );
104c1b: 8b 55 0c mov 0xc(%ebp),%edx
104c1e: f6 c2 01 test $0x1,%dl
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
104c21: 89 c1 mov %eax,%ecx
memset( buf, 0, sizeof( *buf ) );
104c23: 0f 85 a7 00 00 00 jne 104cd0 <stat+0xe0> <== NEVER TAKEN
104c29: f6 c2 02 test $0x2,%dl
104c2c: 0f 85 be 00 00 00 jne 104cf0 <stat+0x100> <== NEVER TAKEN
104c32: 89 f0 mov %esi,%eax
104c34: 83 e0 f8 and $0xfffffff8,%eax
104c37: 89 45 a4 mov %eax,-0x5c(%ebp)
104c3a: 31 c0 xor %eax,%eax
104c3c: 89 3c 02 mov %edi,(%edx,%eax,1)
104c3f: 89 7c 02 04 mov %edi,0x4(%edx,%eax,1)
104c43: 83 c0 08 add $0x8,%eax
104c46: 3b 45 a4 cmp -0x5c(%ebp),%eax
104c49: 72 f1 jb 104c3c <stat+0x4c>
104c4b: 01 c2 add %eax,%edx
104c4d: f7 c6 04 00 00 00 test $0x4,%esi
104c53: 75 5b jne 104cb0 <stat+0xc0> <== NEVER TAKEN
104c55: f7 c6 02 00 00 00 test $0x2,%esi
104c5b: 75 43 jne 104ca0 <stat+0xb0> <== NEVER TAKEN
104c5d: 83 e6 01 and $0x1,%esi
104c60: 75 2e jne 104c90 <stat+0xa0> <== NEVER TAKEN
rv = (*currentloc->handlers->fstat_h)( currentloc, buf );
104c62: 8b 7d 0c mov 0xc(%ebp),%edi
104c65: 8b 41 10 mov 0x10(%ecx),%eax
104c68: 89 0c 24 mov %ecx,(%esp)
104c6b: 89 7c 24 04 mov %edi,0x4(%esp)
104c6f: ff 50 18 call *0x18(%eax)
rtems_filesystem_eval_path_cleanup( &ctx );
104c72: 89 1c 24 mov %ebx,(%esp)
rv = (*currentloc->handlers->fstat_h)( currentloc, buf );
104c75: 89 45 a4 mov %eax,-0x5c(%ebp)
rtems_filesystem_eval_path_cleanup( &ctx );
104c78: e8 33 06 00 00 call 1052b0 <rtems_filesystem_eval_path_cleanup>
return rv;
}
104c7d: 8b 45 a4 mov -0x5c(%ebp),%eax
104c80: 83 c4 6c add $0x6c,%esp
104c83: 5b pop %ebx
104c84: 5e pop %esi
104c85: 5f pop %edi
104c86: 5d pop %ebp
104c87: c3 ret
104c88: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
104c8f: 90 nop
memset( buf, 0, sizeof( *buf ) );
104c90: c6 02 00 movb $0x0,(%edx) <== NOT EXECUTED
104c93: eb cd jmp 104c62 <stat+0x72> <== NOT EXECUTED
104c95: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
104c9c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
104ca0: 66 c7 02 00 00 movw $0x0,(%edx) <== NOT EXECUTED
104ca5: 83 c2 02 add $0x2,%edx <== NOT EXECUTED
104ca8: 83 e6 01 and $0x1,%esi <== NOT EXECUTED
104cab: 74 b5 je 104c62 <stat+0x72> <== NOT EXECUTED
104cad: eb e1 jmp 104c90 <stat+0xa0> <== NOT EXECUTED
104caf: 90 nop <== NOT EXECUTED
104cb0: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED
104cb6: 83 c2 04 add $0x4,%edx <== NOT EXECUTED
104cb9: f7 c6 02 00 00 00 test $0x2,%esi <== NOT EXECUTED
104cbf: 74 9c je 104c5d <stat+0x6d> <== NOT EXECUTED
104cc1: eb dd jmp 104ca0 <stat+0xb0> <== NOT EXECUTED
104cc3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
104cca: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
104cd0: c6 02 00 movb $0x0,(%edx) <== NOT EXECUTED
104cd3: be 57 00 00 00 mov $0x57,%esi <== NOT EXECUTED
104cd8: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
104cdb: 8d 50 01 lea 0x1(%eax),%edx <== NOT EXECUTED
104cde: f6 c2 02 test $0x2,%dl <== NOT EXECUTED
104ce1: 0f 84 4b ff ff ff je 104c32 <stat+0x42> <== NOT EXECUTED
104ce7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
104cee: 66 90 xchg %ax,%ax <== NOT EXECUTED
104cf0: 66 c7 02 00 00 movw $0x0,(%edx) <== NOT EXECUTED
104cf5: 83 ee 02 sub $0x2,%esi <== NOT EXECUTED
104cf8: 83 c2 02 add $0x2,%edx <== NOT EXECUTED
104cfb: e9 32 ff ff ff jmp 104c32 <stat+0x42> <== NOT EXECUTED
001029f0 <statvfs>:
#include <string.h>
#include <rtems/libio_.h>
int statvfs( const char *__restrict path, struct statvfs *__restrict buf )
{
1029f0: 55 push %ebp
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 );
1029f1: b8 18 00 00 00 mov $0x18,%eax
{
1029f6: 89 e5 mov %esp,%ebp
1029f8: 57 push %edi
memset( buf, 0, sizeof( *buf ) );
1029f9: 31 ff xor %edi,%edi
{
1029fb: 56 push %esi
1029fc: be 38 00 00 00 mov $0x38,%esi
102a01: 53 push %ebx
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
102a02: 8d 5d b0 lea -0x50(%ebp),%ebx
{
102a05: 83 ec 6c sub $0x6c,%esp
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
102a08: 89 44 24 08 mov %eax,0x8(%esp)
102a0c: 8b 45 08 mov 0x8(%ebp),%eax
102a0f: 89 1c 24 mov %ebx,(%esp)
102a12: 89 44 24 04 mov %eax,0x4(%esp)
102a16: e8 45 05 00 00 call 102f60 <rtems_filesystem_eval_path_start>
102a1b: 89 c1 mov %eax,%ecx
memset( buf, 0, sizeof( *buf ) );
102a1d: 8b 45 0c mov 0xc(%ebp),%eax
102a20: a8 01 test $0x1,%al
102a22: 0f 85 88 00 00 00 jne 102ab0 <statvfs+0xc0> <== NEVER TAKEN
102a28: a8 02 test $0x2,%al
102a2a: 75 74 jne 102aa0 <statvfs+0xb0> <== NEVER TAKEN
102a2c: 89 f2 mov %esi,%edx
102a2e: 83 e2 f8 and $0xfffffff8,%edx
102a31: 89 55 a4 mov %edx,-0x5c(%ebp)
102a34: 31 d2 xor %edx,%edx
102a36: 89 3c 10 mov %edi,(%eax,%edx,1)
102a39: 89 7c 10 04 mov %edi,0x4(%eax,%edx,1)
102a3d: 83 c2 08 add $0x8,%edx
102a40: 3b 55 a4 cmp -0x5c(%ebp),%edx
102a43: 72 f1 jb 102a36 <statvfs+0x46>
102a45: 01 d0 add %edx,%eax
102a47: f7 c6 04 00 00 00 test $0x4,%esi
102a4d: 74 09 je 102a58 <statvfs+0x68> <== ALWAYS TAKEN
102a4f: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED
102a55: 83 c0 04 add $0x4,%eax <== NOT EXECUTED
102a58: f7 c6 02 00 00 00 test $0x2,%esi
102a5e: 74 08 je 102a68 <statvfs+0x78> <== ALWAYS TAKEN
102a60: 66 c7 00 00 00 movw $0x0,(%eax) <== NOT EXECUTED
102a65: 83 c0 02 add $0x2,%eax <== NOT EXECUTED
102a68: 83 e6 01 and $0x1,%esi
102a6b: 74 03 je 102a70 <statvfs+0x80> <== ALWAYS TAKEN
102a6d: c6 00 00 movb $0x0,(%eax) <== NOT EXECUTED
rv = (*currentloc->mt_entry->ops->statvfs_h)( currentloc, buf );
102a70: 8b 41 14 mov 0x14(%ecx),%eax
102a73: 8b 7d 0c mov 0xc(%ebp),%edi
102a76: 8b 40 0c mov 0xc(%eax),%eax
102a79: 89 7c 24 04 mov %edi,0x4(%esp)
102a7d: 89 0c 24 mov %ecx,(%esp)
102a80: ff 50 48 call *0x48(%eax)
rtems_filesystem_eval_path_cleanup( &ctx );
102a83: 89 1c 24 mov %ebx,(%esp)
rv = (*currentloc->mt_entry->ops->statvfs_h)( currentloc, buf );
102a86: 89 45 a4 mov %eax,-0x5c(%ebp)
rtems_filesystem_eval_path_cleanup( &ctx );
102a89: e8 82 06 00 00 call 103110 <rtems_filesystem_eval_path_cleanup>
return rv;
}
102a8e: 8b 45 a4 mov -0x5c(%ebp),%eax
102a91: 83 c4 6c add $0x6c,%esp
102a94: 5b pop %ebx
102a95: 5e pop %esi
102a96: 5f pop %edi
102a97: 5d pop %ebp
102a98: c3 ret
102a99: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
memset( buf, 0, sizeof( *buf ) );
102aa0: 66 c7 00 00 00 movw $0x0,(%eax) <== NOT EXECUTED
102aa5: 83 ee 02 sub $0x2,%esi <== NOT EXECUTED
102aa8: 83 c0 02 add $0x2,%eax <== NOT EXECUTED
102aab: e9 7c ff ff ff jmp 102a2c <statvfs+0x3c> <== NOT EXECUTED
102ab0: c6 00 00 movb $0x0,(%eax) <== NOT EXECUTED
102ab3: be 37 00 00 00 mov $0x37,%esi <== NOT EXECUTED
102ab8: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
102abb: 40 inc %eax <== NOT EXECUTED
102abc: e9 67 ff ff ff jmp 102a28 <statvfs+0x38> <== NOT EXECUTED
102ac1: 90 nop
102ac2: 90 nop
102ac3: 90 nop
102ac4: 90 nop
102ac5: 90 nop
102ac6: 90 nop
102ac7: 90 nop
102ac8: 90 nop
102ac9: 90 nop
102aca: 90 nop
102acb: 90 nop
102acc: 90 nop
102acd: 90 nop
102ace: 90 nop
102acf: 90 nop
00101e70 <uname>:
*/
int uname(
struct utsname *name
)
{
101e70: 55 push %ebp
101e71: 89 e5 mov %esp,%ebp
101e73: 83 ec 28 sub $0x28,%esp
101e76: 89 5d fc mov %ebx,-0x4(%ebp)
101e79: 8b 5d 08 mov 0x8(%ebp),%ebx
release = 5.3
version = Generic_101318-12
machine = sun4m
*/
if ( !name )
101e7c: 85 db test %ebx,%ebx
101e7e: 0f 84 b8 00 00 00 je 101f3c <uname+0xcc>
rtems_set_errno_and_return_minus_one( EFAULT );
strncpy( name->sysname, "RTEMS", sizeof(name->sysname) );
101e84: 89 1c 24 mov %ebx,(%esp)
101e87: ba c0 04 12 00 mov $0x1204c0,%edx
101e8c: b8 30 00 00 00 mov $0x30,%eax
101e91: 89 54 24 04 mov %edx,0x4(%esp)
101e95: 89 44 24 08 mov %eax,0x8(%esp)
101e99: e8 a2 79 01 00 call 119840 <strncpy>
snprintf(
101e9e: b8 c6 04 12 00 mov $0x1204c6,%eax
101ea3: b9 01 00 00 00 mov $0x1,%ecx
101ea8: 89 44 24 08 mov %eax,0x8(%esp)
101eac: b8 30 00 00 00 mov $0x30,%eax
101eb1: 89 44 24 04 mov %eax,0x4(%esp)
101eb5: 8d 43 30 lea 0x30(%ebx),%eax
101eb8: 89 4c 24 0c mov %ecx,0xc(%esp)
101ebc: 89 04 24 mov %eax,(%esp)
101ebf: e8 2c 75 01 00 call 1193f0 <snprintf>
name->nodename,
sizeof(name->nodename),
"Node %" PRId16, rtems_object_get_local_node()
);
strncpy( name->release, RTEMS_VERSION, sizeof(name->release) );
101ec4: b8 30 00 00 00 mov $0x30,%eax <== NOT EXECUTED
101ec9: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
101ecd: b8 cf 04 12 00 mov $0x1204cf,%eax <== NOT EXECUTED
101ed2: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
101ed6: 8d 43 60 lea 0x60(%ebx),%eax <== NOT EXECUTED
101ed9: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
101edc: e8 5f 79 01 00 call 119840 <strncpy> <== NOT EXECUTED
strncpy( name->version, "", sizeof(name->version) );
101ee1: b8 30 00 00 00 mov $0x30,%eax
101ee6: ba 05 32 12 00 mov $0x123205,%edx
101eeb: 89 44 24 08 mov %eax,0x8(%esp)
101eef: 8d 83 90 00 00 00 lea 0x90(%ebx),%eax
snprintf( name->machine, sizeof(name->machine), "%s/%s", CPU_NAME, CPU_MODEL_NAME );
101ef5: 81 c3 c0 00 00 00 add $0xc0,%ebx
strncpy( name->version, "", sizeof(name->version) );
101efb: 89 54 24 04 mov %edx,0x4(%esp)
101eff: 89 04 24 mov %eax,(%esp)
101f02: e8 39 79 01 00 call 119840 <strncpy>
snprintf( name->machine, sizeof(name->machine), "%s/%s", CPU_NAME, CPU_MODEL_NAME );
101f07: b8 dd 04 12 00 mov $0x1204dd,%eax <== NOT EXECUTED
101f0c: b9 d5 04 12 00 mov $0x1204d5,%ecx <== NOT EXECUTED
101f11: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
101f15: b8 e8 04 12 00 mov $0x1204e8,%eax <== NOT EXECUTED
101f1a: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
101f1e: b8 30 00 00 00 mov $0x30,%eax <== NOT EXECUTED
101f23: 89 4c 24 10 mov %ecx,0x10(%esp) <== NOT EXECUTED
101f27: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
101f2b: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
101f2e: e8 bd 74 01 00 call 1193f0 <snprintf> <== NOT EXECUTED
return 0;
101f33: 31 c0 xor %eax,%eax
}
101f35: 8b 5d fc mov -0x4(%ebp),%ebx
101f38: 89 ec mov %ebp,%esp
101f3a: 5d pop %ebp
101f3b: c3 ret
rtems_set_errno_and_return_minus_one( EFAULT );
101f3c: e8 bf 71 01 00 call 119100 <__errno>
101f41: c7 00 0e 00 00 00 movl $0xe,(%eax)
101f47: b8 ff ff ff ff mov $0xffffffff,%eax
101f4c: eb e7 jmp 101f35 <uname+0xc5>
101f4e: 90 nop
101f4f: 90 nop
00103d10 <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 )
{
103d10: 55 push %ebp
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 );
103d11: b9 18 00 00 00 mov $0x18,%ecx
{
103d16: 89 e5 mov %esp,%ebp
103d18: 57 push %edi
103d19: 56 push %esi
103d1a: 53 push %ebx
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
103d1b: 8d 75 b0 lea -0x50(%ebp),%esi
{
103d1e: 83 ec 5c sub $0x5c,%esp
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
103d21: 89 4c 24 08 mov %ecx,0x8(%esp)
103d25: 8b 45 08 mov 0x8(%ebp),%eax
103d28: 89 34 24 mov %esi,(%esp)
103d2b: 89 44 24 04 mov %eax,0x4(%esp)
103d2f: e8 8c f6 ff ff call 1033c0 <rtems_filesystem_eval_path_start>
rtems_filesystem_mount_table_entry_t *mt_entry = currentloc->mt_entry;
103d34: 8b 58 14 mov 0x14(%eax),%ebx
103d37: 8b 4b 24 mov 0x24(%ebx),%ecx
103d3a: 8b 53 0c mov 0xc(%ebx),%edx
103d3d: 89 04 24 mov %eax,(%esp)
103d40: 89 4c 24 04 mov %ecx,0x4(%esp)
103d44: ff 52 10 call *0x10(%edx)
if ( rtems_filesystem_location_is_instance_root( currentloc ) ) {
103d47: 84 c0 test %al,%al
103d49: 0f 84 b1 00 00 00 je 103e00 <unmount+0xf0>
&rtems_filesystem_root->location;
103d4f: e8 dc 01 00 00 call 103f30 <rtems_current_user_env_get>
103d54: 8b 78 04 mov 0x4(%eax),%edi
&rtems_filesystem_current->location;
103d57: e8 d4 01 00 00 call 103f30 <rtems_current_user_env_get>
return mt_entry == root->mt_entry || mt_entry == current->mt_entry;
103d5c: 3b 5f 14 cmp 0x14(%edi),%ebx
103d5f: 74 7f je 103de0 <unmount+0xd0>
103d61: 8b 00 mov (%eax),%eax
103d63: 3b 58 14 cmp 0x14(%eax),%ebx
103d66: 74 78 je 103de0 <unmount+0xd0>
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;
103d68: 8b 43 20 mov 0x20(%ebx),%eax
const rtems_filesystem_operations_table *mt_point_ops =
103d6b: 8b 40 14 mov 0x14(%eax),%eax
rv = (*mt_point_ops->unmount_h)( mt_entry );
103d6e: 8b 40 0c mov 0xc(%eax),%eax
103d71: 89 1c 24 mov %ebx,(%esp)
103d74: ff 50 30 call *0x30(%eax)
if ( rv == 0 ) {
103d77: 85 c0 test %eax,%eax
rv = (*mt_point_ops->unmount_h)( mt_entry );
103d79: 89 c7 mov %eax,%edi
if ( rv == 0 ) {
103d7b: 74 13 je 103d90 <unmount+0x80>
} else {
errno = EACCES;
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
103d7d: 89 34 24 mov %esi,(%esp)
103d80: e8 eb f7 ff ff call 103570 <rtems_filesystem_eval_path_cleanup>
rtems_fatal_error_occurred( 0xdeadbeef );
}
}
return rv;
}
103d85: 83 c4 5c add $0x5c,%esp
103d88: 89 f8 mov %edi,%eax
103d8a: 5b pop %ebx
103d8b: 5e pop %esi
103d8c: 5f pop %edi
103d8d: 5d pop %ebp
103d8e: c3 ret
103d8f: 90 nop
rtems_id self_task_id = rtems_task_self();
103d90: e8 7b 42 00 00 call 108010 <rtems_task_self>
rtems_filesystem_mt_entry_lock( lock_context );
103d95: 9c pushf
103d96: fa cli
103d97: 5a pop %edx
mt_entry->unmount_task = self_task_id;
103d98: 89 43 3c mov %eax,0x3c(%ebx)
mt_entry->mounted = false;
103d9b: c6 43 28 00 movb $0x0,0x28(%ebx)
rtems_filesystem_mt_entry_unlock( lock_context );
103d9f: 52 push %edx
103da0: 9d popf
rtems_filesystem_eval_path_cleanup( &ctx );
103da1: 89 34 24 mov %esi,(%esp)
103da4: e8 c7 f7 ff ff call 103570 <rtems_filesystem_eval_path_cleanup>
return rtems_event_system_receive(
103da9: 8d 45 ac lea -0x54(%ebp),%eax
103dac: 31 d2 xor %edx,%edx
103dae: 89 44 24 0c mov %eax,0xc(%esp)
103db2: 31 c0 xor %eax,%eax
103db4: 89 44 24 08 mov %eax,0x8(%esp)
103db8: 89 54 24 04 mov %edx,0x4(%esp)
103dbc: c7 04 24 00 00 00 80 movl $0x80000000,(%esp)
103dc3: e8 b8 40 00 00 call 107e80 <rtems_event_system_receive>
if ( sc != RTEMS_SUCCESSFUL ) {
103dc8: 85 c0 test %eax,%eax
103dca: 74 b9 je 103d85 <unmount+0x75> <== ALWAYS TAKEN
rtems_fatal_error_occurred( 0xdeadbeef );
103dcc: c7 04 24 ef be ad de movl $0xdeadbeef,(%esp) <== NOT EXECUTED
103dd3: e8 88 43 00 00 call 108160 <rtems_fatal_error_occurred> <== NOT EXECUTED
103dd8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
103ddf: 90 nop <== NOT EXECUTED
errno = EBUSY;
103de0: e8 bb 2a 02 00 call 1268a0 <__errno>
rv = -1;
103de5: bf ff ff ff ff mov $0xffffffff,%edi
errno = EBUSY;
103dea: c7 00 10 00 00 00 movl $0x10,(%eax)
rtems_filesystem_eval_path_cleanup( &ctx );
103df0: 89 34 24 mov %esi,(%esp)
103df3: e8 78 f7 ff ff call 103570 <rtems_filesystem_eval_path_cleanup>
if ( rv == 0 ) {
103df8: eb 8b jmp 103d85 <unmount+0x75>
103dfa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
errno = EACCES;
103e00: e8 9b 2a 02 00 call 1268a0 <__errno>
rv = -1;
103e05: bf ff ff ff ff mov $0xffffffff,%edi
errno = EACCES;
103e0a: c7 00 0d 00 00 00 movl $0xd,(%eax)
rtems_filesystem_eval_path_cleanup( &ctx );
103e10: 89 34 24 mov %esi,(%esp)
103e13: e8 58 f7 ff ff call 103570 <rtems_filesystem_eval_path_cleanup>
if ( rv == 0 ) {
103e18: e9 68 ff ff ff jmp 103d85 <unmount+0x75>
103e1d: 90 nop
103e1e: 90 nop
103e1f: 90 nop
00124550 <write>:
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
124550: 55 push %ebp
124551: 89 e5 mov %esp,%ebp
124553: 83 ec 28 sub $0x28,%esp
124556: 89 5d f4 mov %ebx,-0xc(%ebp)
124559: 8b 4d 0c mov 0xc(%ebp),%ecx
12455c: 89 75 f8 mov %esi,-0x8(%ebp)
12455f: 8b 45 08 mov 0x8(%ebp),%eax
124562: 89 7d fc mov %edi,-0x4(%ebp)
rtems_libio_t *iop;
ssize_t n;
rtems_libio_check_buffer( buffer );
124565: 85 c9 test %ecx,%ecx
124567: 0f 84 9f 00 00 00 je 12460c <write+0xbc> <== NEVER TAKEN
rtems_libio_check_count( count );
12456d: 8b 55 10 mov 0x10(%ebp),%edx
124570: 85 d2 test %edx,%edx
124572: 74 6c je 1245e0 <write+0x90>
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_WRITE, EBADF );
124574: 3b 05 9c 47 12 00 cmp 0x12479c,%eax
12457a: 73 7e jae 1245fa <write+0xaa>
12457c: 8d 14 80 lea (%eax,%eax,4),%edx
12457f: 8d 04 50 lea (%eax,%edx,2),%eax
124582: c1 e0 02 shl $0x2,%eax
124585: 8d 98 c0 c5 12 00 lea 0x12c5c0(%eax),%ebx
_ISR_Local_disable( level );
12458b: 9c pushf
12458c: fa cli
12458d: 5e pop %esi
val = *obj;
12458e: 8b 90 c0 c5 12 00 mov 0x12c5c0(%eax),%edx
*obj = val + arg;
124594: 8d ba 00 10 00 00 lea 0x1000(%edx),%edi
12459a: 89 b8 c0 c5 12 00 mov %edi,0x12c5c0(%eax)
_ISR_Local_enable( level );
1245a0: 56 push %esi
1245a1: 9d popf
1245a2: 81 e2 04 01 00 00 and $0x104,%edx
1245a8: 81 fa 04 01 00 00 cmp $0x104,%edx
1245ae: 75 3f jne 1245ef <write+0x9f>
/*
* Now process the write() request.
*/
n = (*iop->pathinfo.handlers->write_h)( iop, buffer, count );
1245b0: 89 4c 24 04 mov %ecx,0x4(%esp)
1245b4: 8b 75 10 mov 0x10(%ebp),%esi
1245b7: 89 1c 24 mov %ebx,(%esp)
1245ba: 8b 43 1c mov 0x1c(%ebx),%eax
1245bd: 89 74 24 08 mov %esi,0x8(%esp)
1245c1: ff 50 0c call *0xc(%eax)
_ISR_Local_disable( level );
1245c4: 9c pushf
1245c5: fa cli
1245c6: 5a pop %edx
*obj = val - arg;
1245c7: 81 2b 00 10 00 00 subl $0x1000,(%ebx)
_ISR_Local_enable( level );
1245cd: 52 push %edx
1245ce: 9d popf
rtems_libio_iop_drop( iop );
return n;
}
1245cf: 8b 5d f4 mov -0xc(%ebp),%ebx
1245d2: 8b 75 f8 mov -0x8(%ebp),%esi
1245d5: 8b 7d fc mov -0x4(%ebp),%edi
1245d8: 89 ec mov %ebp,%esp
1245da: 5d pop %ebp
1245db: c3 ret
1245dc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
1245e0: 8b 5d f4 mov -0xc(%ebp),%ebx
rtems_libio_check_count( count );
1245e3: 31 c0 xor %eax,%eax
}
1245e5: 8b 75 f8 mov -0x8(%ebp),%esi
1245e8: 8b 7d fc mov -0x4(%ebp),%edi
1245eb: 89 ec mov %ebp,%esp
1245ed: 5d pop %ebp
1245ee: c3 ret
_ISR_Local_disable( level );
1245ef: 9c pushf
1245f0: fa cli
1245f1: 58 pop %eax
*obj = val - arg;
1245f2: 81 2b 00 10 00 00 subl $0x1000,(%ebx)
_ISR_Local_enable( level );
1245f8: 50 push %eax
1245f9: 9d popf
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_WRITE, EBADF );
1245fa: e8 91 4a ff ff call 119090 <__errno>
1245ff: c7 00 09 00 00 00 movl $0x9,(%eax)
124605: b8 ff ff ff ff mov $0xffffffff,%eax
12460a: eb c3 jmp 1245cf <write+0x7f>
rtems_libio_check_buffer( buffer );
12460c: e8 7f 4a ff ff call 119090 <__errno> <== NOT EXECUTED
124611: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
124617: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
12461c: eb b1 jmp 1245cf <write+0x7f> <== NOT EXECUTED
12461e: 90 nop
12461f: 90 nop