=============================================================================== 0010f0e8 : #define MAXSYMLINK 5 int IMFS_Set_handlers( rtems_filesystem_location_info_t *loc ) { 10f0e8: 55 push %ebp 10f0e9: 89 e5 mov %esp,%ebp 10f0eb: 8b 45 08 mov 0x8(%ebp),%eax IMFS_jnode_t *node = loc->node_access; IMFS_fs_info_t *fs_info; fs_info = loc->mt_entry->fs_info; 10f0ee: 8b 50 10 mov 0x10(%eax),%edx 10f0f1: 8b 4a 34 mov 0x34(%edx),%ecx switch( node->type ) { 10f0f4: 8b 10 mov (%eax),%edx 10f0f6: 83 7a 4c 07 cmpl $0x7,0x4c(%edx) 10f0fa: 77 12 ja 10f10e <== NEVER TAKEN 10f0fc: 8b 52 4c mov 0x4c(%edx),%edx 10f0ff: ff 24 95 d0 17 12 00 jmp *0x1217d0(,%edx,4) 10f106: 66 90 xchg %ax,%ax case IMFS_DIRECTORY: loc->handlers = fs_info->directory_handlers; 10f108: 8b 51 0c mov 0xc(%ecx),%edx 10f10b: 89 50 08 mov %edx,0x8(%eax) loc->handlers = fs_info->fifo_handlers; break; } return 0; } 10f10e: 31 c0 xor %eax,%eax 10f110: c9 leave 10f111: c3 ret 10f112: 66 90 xchg %ax,%ax break; case IMFS_LINEAR_FILE: loc->handlers = fs_info->memfile_handlers; break; case IMFS_MEMORY_FILE: loc->handlers = fs_info->memfile_handlers; 10f114: 8b 51 08 mov 0x8(%ecx),%edx 10f117: 89 50 08 mov %edx,0x8(%eax) loc->handlers = fs_info->fifo_handlers; break; } return 0; } 10f11a: 31 c0 xor %eax,%eax 10f11c: c9 leave 10f11d: c3 ret 10f11e: 66 90 xchg %ax,%ax case IMFS_DEVICE: loc->handlers = &IMFS_device_handlers; break; case IMFS_SYM_LINK: case IMFS_HARD_LINK: loc->handlers = &IMFS_link_handlers; 10f120: c7 40 08 80 18 12 00 movl $0x121880,0x8(%eax) loc->handlers = fs_info->fifo_handlers; break; } return 0; } 10f127: 31 c0 xor %eax,%eax 10f129: c9 leave 10f12a: c3 ret 10f12b: 90 nop break; case IMFS_MEMORY_FILE: loc->handlers = fs_info->memfile_handlers; break; case IMFS_FIFO: loc->handlers = fs_info->fifo_handlers; 10f12c: 8b 51 10 mov 0x10(%ecx),%edx 10f12f: 89 50 08 mov %edx,0x8(%eax) break; } return 0; } 10f132: 31 c0 xor %eax,%eax 10f134: c9 leave 10f135: c3 ret 10f136: 66 90 xchg %ax,%ax switch( node->type ) { case IMFS_DIRECTORY: loc->handlers = fs_info->directory_handlers; break; case IMFS_DEVICE: loc->handlers = &IMFS_device_handlers; 10f138: c7 40 08 00 18 12 00 movl $0x121800,0x8(%eax) loc->handlers = fs_info->fifo_handlers; break; } return 0; } 10f13f: 31 c0 xor %eax,%eax 10f141: c9 leave 10f142: c3 ret =============================================================================== 0010fa60 : void IMFS_check_node_remove( IMFS_jnode_t *jnode ) { 10fa60: 55 push %ebp 10fa61: 89 e5 mov %esp,%ebp 10fa63: 53 push %ebx 10fa64: 83 ec 10 sub $0x10,%esp 10fa67: 8b 5d 08 mov 0x8(%ebp),%ebx if ( !rtems_libio_is_file_open( jnode ) && jnode->st_nlink < 1 ) { 10fa6a: 53 push %ebx 10fa6b: e8 f8 04 00 00 call 10ff68 10fa70: 83 c4 10 add $0x10,%esp 10fa73: 85 c0 test %eax,%eax 10fa75: 75 2d jne 10faa4 10fa77: 66 83 7b 34 00 cmpw $0x0,0x34(%ebx) 10fa7c: 75 26 jne 10faa4 if ( rtems_filesystem_current.node_access == jnode ) 10fa7e: a1 90 59 12 00 mov 0x125990,%eax 10fa83: 39 58 04 cmp %ebx,0x4(%eax) 10fa86: 74 58 je 10fae0 rtems_filesystem_current.node_access = NULL; switch ( jnode->type ) { 10fa88: 8b 43 4c mov 0x4c(%ebx),%eax 10fa8b: 83 f8 04 cmp $0x4,%eax 10fa8e: 74 34 je 10fac4 10fa90: 83 f8 05 cmp $0x5,%eax 10fa93: 74 17 je 10faac break; default: break; } free( jnode ); 10fa95: 89 5d 08 mov %ebx,0x8(%ebp) } } 10fa98: 8b 5d fc mov -0x4(%ebp),%ebx 10fa9b: c9 leave break; default: break; } free( jnode ); 10fa9c: e9 13 86 ff ff jmp 1080b4 10faa1: 8d 76 00 lea 0x0(%esi),%esi } } 10faa4: 8b 5d fc mov -0x4(%ebp),%ebx 10faa7: c9 leave 10faa8: c3 ret 10faa9: 8d 76 00 lea 0x0(%esi),%esi if ( rtems_filesystem_current.node_access == jnode ) rtems_filesystem_current.node_access = NULL; switch ( jnode->type ) { case IMFS_MEMORY_FILE: IMFS_memfile_remove( jnode ); 10faac: 83 ec 0c sub $0xc,%esp 10faaf: 53 push %ebx 10fab0: e8 cb 23 00 00 call 111e80 break; 10fab5: 83 c4 10 add $0x10,%esp break; default: break; } free( jnode ); 10fab8: 89 5d 08 mov %ebx,0x8(%ebp) } } 10fabb: 8b 5d fc mov -0x4(%ebp),%ebx 10fabe: c9 leave break; default: break; } free( jnode ); 10fabf: e9 f0 85 ff ff jmp 1080b4 switch ( jnode->type ) { case IMFS_MEMORY_FILE: IMFS_memfile_remove( jnode ); break; case IMFS_SYM_LINK: free( jnode->info.sym_link.name ); 10fac4: 83 ec 0c sub $0xc,%esp 10fac7: ff 73 50 pushl 0x50(%ebx) 10faca: e8 e5 85 ff ff call 1080b4 break; 10facf: 83 c4 10 add $0x10,%esp default: break; } free( jnode ); 10fad2: 89 5d 08 mov %ebx,0x8(%ebp) } } 10fad5: 8b 5d fc mov -0x4(%ebp),%ebx 10fad8: c9 leave break; default: break; } free( jnode ); 10fad9: e9 d6 85 ff ff jmp 1080b4 10fade: 66 90 xchg %ax,%ax void IMFS_check_node_remove( IMFS_jnode_t *jnode ) { if ( !rtems_libio_is_file_open( jnode ) && jnode->st_nlink < 1 ) { if ( rtems_filesystem_current.node_access == jnode ) rtems_filesystem_current.node_access = NULL; 10fae0: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) 10fae7: eb 9f jmp 10fa88 =============================================================================== 0010eea8 : int IMFS_chown( rtems_filesystem_location_info_t *pathloc, /* IN */ uid_t owner, /* IN */ gid_t group /* IN */ ) { 10eea8: 55 push %ebp 10eea9: 89 e5 mov %esp,%ebp 10eeab: 57 push %edi 10eeac: 56 push %esi 10eead: 53 push %ebx 10eeae: 83 ec 1c sub $0x1c,%esp 10eeb1: 8b 7d 0c mov 0xc(%ebp),%edi 10eeb4: 8b 75 10 mov 0x10(%ebp),%esi IMFS_jnode_t *jnode; #if defined(RTEMS_POSIX_API) uid_t st_uid; #endif jnode = (IMFS_jnode_t *) pathloc->node_access; 10eeb7: 8b 45 08 mov 0x8(%ebp),%eax 10eeba: 8b 18 mov (%eax),%ebx /* * Verify I am the owner of the node or the super user. */ #if defined(RTEMS_POSIX_API) st_uid = geteuid(); 10eebc: e8 bb 0e 00 00 call 10fd7c if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) ) 10eec1: 66 39 43 3c cmp %ax,0x3c(%ebx) 10eec5: 74 05 je 10eecc 10eec7: 66 85 c0 test %ax,%ax 10eeca: 75 2c jne 10eef8 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EPERM ); #endif jnode->st_uid = owner; 10eecc: 66 89 7b 3c mov %di,0x3c(%ebx) jnode->st_gid = group; 10eed0: 66 89 73 3e mov %si,0x3e(%ebx) IMFS_update_ctime( jnode ); 10eed4: 83 ec 08 sub $0x8,%esp 10eed7: 6a 00 push $0x0 10eed9: 8d 45 e0 lea -0x20(%ebp),%eax 10eedc: 50 push %eax 10eedd: e8 4e 92 ff ff call 108130 10eee2: 8b 45 e0 mov -0x20(%ebp),%eax 10eee5: 89 43 48 mov %eax,0x48(%ebx) return 0; 10eee8: 83 c4 10 add $0x10,%esp 10eeeb: 31 c0 xor %eax,%eax } 10eeed: 8d 65 f4 lea -0xc(%ebp),%esp 10eef0: 5b pop %ebx 10eef1: 5e pop %esi 10eef2: 5f pop %edi 10eef3: c9 leave 10eef4: c3 ret 10eef5: 8d 76 00 lea 0x0(%esi),%esi #if defined(RTEMS_POSIX_API) st_uid = geteuid(); if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) ) rtems_set_errno_and_return_minus_one( EPERM ); 10eef8: e8 73 43 00 00 call 113270 <__errno> 10eefd: c7 00 01 00 00 00 movl $0x1,(%eax) 10ef03: b8 ff ff ff ff mov $0xffffffff,%eax 10ef08: eb e3 jmp 10eeed =============================================================================== 0010ef7c : IMFS_jnode_types_t type, const char *name, mode_t mode, const IMFS_types_union *info ) { 10ef7c: 55 push %ebp 10ef7d: 89 e5 mov %esp,%ebp 10ef7f: 57 push %edi 10ef80: 56 push %esi 10ef81: 53 push %ebx 10ef82: 83 ec 1c sub $0x1c,%esp 10ef85: 8b 45 08 mov 0x8(%ebp),%eax 10ef88: 8b 5d 0c mov 0xc(%ebp),%ebx IMFS_fs_info_t *fs_info; /* * MUST have a parent node to call this routine. */ if ( parent_loc == NULL ) 10ef8b: 85 c0 test %eax,%eax 10ef8d: 0f 84 ba 00 00 00 je 10f04d <== NEVER TAKEN return NULL; parent = parent_loc->node_access; 10ef93: 8b 38 mov (%eax),%edi fs_info = parent_loc->mt_entry->fs_info; 10ef95: 8b 40 10 mov 0x10(%eax),%eax 10ef98: 8b 70 34 mov 0x34(%eax),%esi /* * Reject creation of FIFOs if support is disabled. */ if ( type == IMFS_FIFO && 10ef9b: 83 fb 07 cmp $0x7,%ebx 10ef9e: 0f 84 9c 00 00 00 je 10f040 return NULL; /* * Allocate filesystem node and fill in basic information */ node = IMFS_allocate_node( type, name, mode & ~rtems_filesystem_umask ); 10efa4: 50 push %eax 10efa5: a1 90 59 12 00 mov 0x125990,%eax 10efaa: 8b 40 2c mov 0x2c(%eax),%eax 10efad: f7 d0 not %eax 10efaf: 23 45 14 and 0x14(%ebp),%eax 10efb2: 50 push %eax 10efb3: ff 75 10 pushl 0x10(%ebp) 10efb6: 53 push %ebx 10efb7: e8 50 ff ff ff call 10ef0c if ( !node ) 10efbc: 83 c4 10 add $0x10,%esp 10efbf: 85 c0 test %eax,%eax 10efc1: 74 73 je 10f036 return NULL; /* * Set the type specific information */ if ( type == IMFS_DIRECTORY ) { 10efc3: 83 fb 01 cmp $0x1,%ebx 10efc6: 74 38 je 10f000 rtems_chain_initialize_empty(&node->info.directory.Entries); } else if ( type == IMFS_HARD_LINK ) { 10efc8: 83 fb 03 cmp $0x3,%ebx 10efcb: 0f 84 97 00 00 00 je 10f068 node->info.hard_link.link_node = info->hard_link.link_node; } else if ( type == IMFS_SYM_LINK ) { 10efd1: 83 fb 04 cmp $0x4,%ebx 10efd4: 0f 84 8e 00 00 00 je 10f068 node->info.sym_link.name = info->sym_link.name; } else if ( type == IMFS_DEVICE ) { 10efda: 83 fb 02 cmp $0x2,%ebx 10efdd: 74 79 je 10f058 node->info.device.major = info->device.major; node->info.device.minor = info->device.minor; } else if ( type == IMFS_LINEAR_FILE ) { 10efdf: 83 fb 06 cmp $0x6,%ebx 10efe2: 0f 84 8c 00 00 00 je 10f074 node->info.linearfile.size = 0; node->info.linearfile.direct = 0; } else if ( type == IMFS_MEMORY_FILE ) { 10efe8: 83 fb 05 cmp $0x5,%ebx 10efeb: 0f 84 9b 00 00 00 je 10f08c node->info.file.size = 0; node->info.file.indirect = 0; node->info.file.doubly_indirect = 0; node->info.file.triply_indirect = 0; } else if ( type == IMFS_FIFO ) { 10eff1: 83 fb 07 cmp $0x7,%ebx 10eff4: 75 1d jne 10f013 <== NEVER TAKEN node->info.fifo.pipe = NULL; 10eff6: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) 10effd: eb 14 jmp 10f013 10efff: 90 nop RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); 10f000: 8d 50 54 lea 0x54(%eax),%edx 10f003: 89 50 50 mov %edx,0x50(%eax) head->next = tail; head->previous = NULL; 10f006: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); 10f00d: 8d 50 50 lea 0x50(%eax),%edx 10f010: 89 50 58 mov %edx,0x58(%eax) } /* * This node MUST have a parent, so put it in that directory list. */ node->Parent = parent; 10f013: 89 78 08 mov %edi,0x8(%eax) node->st_ino = ++fs_info->ino_count; 10f016: 8b 56 04 mov 0x4(%esi),%edx 10f019: 42 inc %edx 10f01a: 89 56 04 mov %edx,0x4(%esi) 10f01d: 89 50 38 mov %edx,0x38(%eax) 10f020: 83 ec 08 sub $0x8,%esp 10f023: 50 push %eax rtems_chain_append( &parent->info.directory.Entries, &node->Node ); 10f024: 83 c7 50 add $0x50,%edi 10f027: 57 push %edi 10f028: 89 45 e4 mov %eax,-0x1c(%ebp) 10f02b: e8 a8 cf ff ff call 10bfd8 <_Chain_Append> return node; 10f030: 83 c4 10 add $0x10,%esp 10f033: 8b 45 e4 mov -0x1c(%ebp),%eax } 10f036: 8d 65 f4 lea -0xc(%ebp),%esp 10f039: 5b pop %ebx 10f03a: 5e pop %esi 10f03b: 5f pop %edi 10f03c: c9 leave 10f03d: c3 ret 10f03e: 66 90 xchg %ax,%ax fs_info = parent_loc->mt_entry->fs_info; /* * Reject creation of FIFOs if support is disabled. */ if ( type == IMFS_FIFO && 10f040: 81 7e 10 60 17 12 00 cmpl $0x121760,0x10(%esi) 10f047: 0f 85 57 ff ff ff jne 10efa4 fs_info->fifo_handlers == &rtems_filesystem_handlers_default ) return NULL; 10f04d: 31 c0 xor %eax,%eax node->st_ino = ++fs_info->ino_count; rtems_chain_append( &parent->info.directory.Entries, &node->Node ); return node; } 10f04f: 8d 65 f4 lea -0xc(%ebp),%esp 10f052: 5b pop %ebx 10f053: 5e pop %esi 10f054: 5f pop %edi 10f055: c9 leave 10f056: c3 ret 10f057: 90 nop } else if ( type == IMFS_HARD_LINK ) { node->info.hard_link.link_node = info->hard_link.link_node; } else if ( type == IMFS_SYM_LINK ) { node->info.sym_link.name = info->sym_link.name; } else if ( type == IMFS_DEVICE ) { node->info.device.major = info->device.major; 10f058: 8b 4d 18 mov 0x18(%ebp),%ecx 10f05b: 8b 11 mov (%ecx),%edx 10f05d: 89 50 50 mov %edx,0x50(%eax) node->info.device.minor = info->device.minor; 10f060: 8b 51 04 mov 0x4(%ecx),%edx 10f063: 89 50 54 mov %edx,0x54(%eax) 10f066: eb ab jmp 10f013 if ( type == IMFS_DIRECTORY ) { rtems_chain_initialize_empty(&node->info.directory.Entries); } else if ( type == IMFS_HARD_LINK ) { node->info.hard_link.link_node = info->hard_link.link_node; } else if ( type == IMFS_SYM_LINK ) { node->info.sym_link.name = info->sym_link.name; 10f068: 8b 4d 18 mov 0x18(%ebp),%ecx 10f06b: 8b 11 mov (%ecx),%edx 10f06d: 89 50 50 mov %edx,0x50(%eax) 10f070: eb a1 jmp 10f013 10f072: 66 90 xchg %ax,%ax } else if ( type == IMFS_DEVICE ) { node->info.device.major = info->device.major; node->info.device.minor = info->device.minor; } else if ( type == IMFS_LINEAR_FILE ) { node->info.linearfile.size = 0; 10f074: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) 10f07b: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) node->info.linearfile.direct = 0; 10f082: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax) 10f089: eb 88 jmp 10f013 10f08b: 90 nop } else if ( type == IMFS_MEMORY_FILE ) { node->info.file.size = 0; 10f08c: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) 10f093: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) node->info.file.indirect = 0; 10f09a: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax) node->info.file.doubly_indirect = 0; 10f0a1: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax) node->info.file.triply_indirect = 0; 10f0a8: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax) 10f0af: e9 5f ff ff ff jmp 10f013 =============================================================================== 0010a4e8 : */ void IMFS_dump_directory( IMFS_jnode_t *the_directory, int level ) { 10a4e8: 55 push %ebp 10a4e9: 89 e5 mov %esp,%ebp 10a4eb: 57 push %edi 10a4ec: 56 push %esi 10a4ed: 53 push %ebx 10a4ee: 83 ec 1c sub $0x1c,%esp 10a4f1: 8b 45 08 mov 0x8(%ebp),%eax 10a4f4: 8b 75 0c mov 0xc(%ebp),%esi * */ int IMFS_memfile_maximum_size( void ) { return IMFS_MEMFILE_MAXIMUM_SIZE; } 10a4f7: 8b 78 50 mov 0x50(%eax),%edi RTEMS_INLINE_ROUTINE bool _Chain_Is_tail( Chain_Control *the_chain, const Chain_Node *the_node ) { return (the_node == _Chain_Tail(the_chain)); 10a4fa: 83 c0 54 add $0x54,%eax 10a4fd: 89 45 e4 mov %eax,-0x1c(%ebp) IMFS_assert( level >= 0 ); IMFS_assert( the_directory->type == IMFS_DIRECTORY ); the_chain = &the_directory->info.directory.Entries; for ( the_node = rtems_chain_first( the_chain ); 10a500: 39 c7 cmp %eax,%edi 10a502: 74 47 je 10a54b for ( i=0 ; i<=level ; i++ ) fprintf(stdout, "...." ); IMFS_print_jnode( the_jnode ); if ( the_jnode->type == IMFS_DIRECTORY ) IMFS_dump_directory( the_jnode, level + 1 ); 10a504: 8d 46 01 lea 0x1(%esi),%eax 10a507: 89 45 e0 mov %eax,-0x20(%ebp) 10a50a: 66 90 xchg %ax,%ax !rtems_chain_is_tail( the_chain, the_node ); the_node = the_node->next ) { the_jnode = (IMFS_jnode_t *) the_node; for ( i=0 ; i<=level ; i++ ) 10a50c: 85 f6 test %esi,%esi 10a50e: 78 22 js 10a532 <== NEVER TAKEN 10a510: 31 db xor %ebx,%ebx 10a512: 66 90 xchg %ax,%ax fprintf(stdout, "...." ); 10a514: a1 20 c4 12 00 mov 0x12c420,%eax 10a519: ff 70 08 pushl 0x8(%eax) 10a51c: 6a 04 push $0x4 10a51e: 6a 01 push $0x1 10a520: 68 92 71 12 00 push $0x127192 10a525: e8 96 e0 00 00 call 1185c0 !rtems_chain_is_tail( the_chain, the_node ); the_node = the_node->next ) { the_jnode = (IMFS_jnode_t *) the_node; for ( i=0 ; i<=level ; i++ ) 10a52a: 43 inc %ebx 10a52b: 83 c4 10 add $0x10,%esp 10a52e: 39 de cmp %ebx,%esi 10a530: 7d e2 jge 10a514 fprintf(stdout, "...." ); IMFS_print_jnode( the_jnode ); 10a532: 83 ec 0c sub $0xc,%esp 10a535: 57 push %edi 10a536: e8 75 fe ff ff call 10a3b0 if ( the_jnode->type == IMFS_DIRECTORY ) 10a53b: 83 c4 10 add $0x10,%esp 10a53e: 83 7f 4c 01 cmpl $0x1,0x4c(%edi) 10a542: 74 10 je 10a554 the_chain = &the_directory->info.directory.Entries; for ( the_node = rtems_chain_first( the_chain ); !rtems_chain_is_tail( the_chain, the_node ); the_node = the_node->next ) { 10a544: 8b 3f mov (%edi),%edi IMFS_assert( level >= 0 ); IMFS_assert( the_directory->type == IMFS_DIRECTORY ); the_chain = &the_directory->info.directory.Entries; for ( the_node = rtems_chain_first( the_chain ); 10a546: 3b 7d e4 cmp -0x1c(%ebp),%edi 10a549: 75 c1 jne 10a50c fprintf(stdout, "...." ); IMFS_print_jnode( the_jnode ); if ( the_jnode->type == IMFS_DIRECTORY ) IMFS_dump_directory( the_jnode, level + 1 ); } } 10a54b: 8d 65 f4 lea -0xc(%ebp),%esp 10a54e: 5b pop %ebx 10a54f: 5e pop %esi 10a550: 5f pop %edi 10a551: c9 leave 10a552: c3 ret 10a553: 90 nop for ( i=0 ; i<=level ; i++ ) fprintf(stdout, "...." ); IMFS_print_jnode( the_jnode ); if ( the_jnode->type == IMFS_DIRECTORY ) IMFS_dump_directory( the_jnode, level + 1 ); 10a554: 83 ec 08 sub $0x8,%esp 10a557: ff 75 e0 pushl -0x20(%ebp) 10a55a: 57 push %edi 10a55b: e8 88 ff ff ff call 10a4e8 10a560: 83 c4 10 add $0x10,%esp 10a563: eb df jmp 10a544 =============================================================================== 0010f1f4 : const char *pathname, /* IN */ size_t pathnamelen, /* IN */ int flags, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN/OUT */ ) { 10f1f4: 55 push %ebp 10f1f5: 89 e5 mov %esp,%ebp 10f1f7: 57 push %edi 10f1f8: 56 push %esi 10f1f9: 53 push %ebx 10f1fa: 83 ec 5c sub $0x5c,%esp char token[ IMFS_NAME_MAX + 1 ]; rtems_filesystem_location_info_t newloc; IMFS_jnode_t *node; int result; if ( !rtems_libio_is_valid_perms( flags ) ) { 10f1fd: f7 45 10 f8 ff ff ff testl $0xfffffff8,0x10(%ebp) 10f204: 0f 85 ee 01 00 00 jne 10f3f8 <== NEVER TAKEN /* * This was filled in by the caller and is valid in the * mount table. */ node = pathloc->node_access; 10f20a: 8b 45 14 mov 0x14(%ebp),%eax 10f20d: 8b 38 mov (%eax),%edi size_t pathnamelen, /* IN */ int flags, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN/OUT */ ) { int i = 0; 10f20f: c7 45 a4 00 00 00 00 movl $0x0,-0x5c(%ebp) 10f216: 8d 75 af lea -0x51(%ebp),%esi * Evaluate all tokens until we are done or an error occurs. */ while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) { type = IMFS_get_token( &pathname[i], pathnamelen, token, &len ); 10f219: 8d 55 e4 lea -0x1c(%ebp),%edx 10f21c: 52 push %edx 10f21d: 56 push %esi 10f21e: ff 75 0c pushl 0xc(%ebp) 10f221: 8b 45 08 mov 0x8(%ebp),%eax 10f224: 03 45 a4 add -0x5c(%ebp),%eax 10f227: 50 push %eax 10f228: e8 17 07 00 00 call 10f944 10f22d: 89 c3 mov %eax,%ebx pathnamelen -= len; 10f22f: 8b 55 e4 mov -0x1c(%ebp),%edx i += len; if ( !pathloc->node_access ) 10f232: 8b 4d 14 mov 0x14(%ebp),%ecx 10f235: 8b 01 mov (%ecx),%eax 10f237: 83 c4 10 add $0x10,%esp 10f23a: 85 c0 test %eax,%eax 10f23c: 0f 84 e6 00 00 00 je 10f328 <== NEVER TAKEN */ while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) { type = IMFS_get_token( &pathname[i], pathnamelen, token, &len ); pathnamelen -= len; 10f242: 29 55 0c sub %edx,0xc(%ebp) i += len; 10f245: 01 55 a4 add %edx,-0x5c(%ebp) rtems_set_errno_and_return_minus_one( ENOENT ); /* * I cannot move out of this directory without execute permission. */ if ( type != IMFS_NO_MORE_PATH ) 10f248: 85 db test %ebx,%ebx 10f24a: 75 44 jne 10f290 * new fs root node and let let the mounted filesystem set the handlers. * * NOTE: The behavior of stat() on a mount point appears to be questionable. */ if ( node->type == IMFS_DIRECTORY ) { 10f24c: 83 78 4c 01 cmpl $0x1,0x4c(%eax) 10f250: 0f 84 26 01 00 00 je 10f37c flags, pathloc ); } else { result = IMFS_Set_handlers( pathloc ); } } else { result = IMFS_Set_handlers( pathloc ); 10f256: 83 ec 0c sub $0xc,%esp 10f259: ff 75 14 pushl 0x14(%ebp) 10f25c: e8 87 fe ff ff call 10f0e8 10f261: 89 c3 mov %eax,%ebx 10f263: 5a pop %edx 10f264: 59 pop %ecx /* * Verify we have the correct permissions for this node. */ if ( !IMFS_evaluate_permission( pathloc, flags ) ) 10f265: ff 75 10 pushl 0x10(%ebp) 10f268: ff 75 14 pushl 0x14(%ebp) 10f26b: e8 d4 fe ff ff call 10f144 10f270: 83 c4 10 add $0x10,%esp 10f273: 85 c0 test %eax,%eax 10f275: 0f 85 d1 00 00 00 jne 10f34c rtems_set_errno_and_return_minus_one( EACCES ); 10f27b: e8 f0 3f 00 00 call 113270 <__errno> 10f280: c7 00 0d 00 00 00 movl $0xd,(%eax) 10f286: bb ff ff ff ff mov $0xffffffff,%ebx 10f28b: e9 bc 00 00 00 jmp 10f34c /* * I cannot move out of this directory without execute permission. */ if ( type != IMFS_NO_MORE_PATH ) if ( node->type == IMFS_DIRECTORY ) 10f290: 83 7f 4c 01 cmpl $0x1,0x4c(%edi) 10f294: 0f 84 be 00 00 00 je 10f358 if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) ) rtems_set_errno_and_return_minus_one( EACCES ); node = pathloc->node_access; 10f29a: 89 c7 mov %eax,%edi switch( type ) { 10f29c: 83 fb 03 cmp $0x3,%ebx 10f29f: 74 1b je 10f2bc 10f2a1: 83 fb 04 cmp $0x4,%ebx 10f2a4: 0f 84 92 00 00 00 je 10f33c 10f2aa: 83 fb 02 cmp $0x2,%ebx 10f2ad: 74 51 je 10f300 /* * Evaluate all tokens until we are done or an error occurs. */ while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) { 10f2af: 83 fb 04 cmp $0x4,%ebx 10f2b2: 0f 85 61 ff ff ff jne 10f219 <== ALWAYS TAKEN 10f2b8: eb 92 jmp 10f24c <== NOT EXECUTED 10f2ba: 66 90 xchg %ax,%ax <== NOT EXECUTED case IMFS_NAME: /* * If we are at a link follow it. */ if ( node->type == IMFS_HARD_LINK ) { 10f2bc: 8b 40 4c mov 0x4c(%eax),%eax 10f2bf: 83 f8 03 cmp $0x3,%eax 10f2c2: 0f 84 08 01 00 00 je 10f3d0 * It would be a design error if we evaluated the link and * was broken. */ IMFS_assert( node ); } else if ( node->type == IMFS_SYM_LINK ) { 10f2c8: 83 f8 04 cmp $0x4,%eax 10f2cb: 0f 84 51 01 00 00 je 10f422 } /* * Only a directory can be decended into. */ if ( node->type != IMFS_DIRECTORY ) 10f2d1: 48 dec %eax 10f2d2: 0f 85 35 01 00 00 jne 10f40d /* * If we are at a node that is a mount point. Set loc to the * new fs root node and let them finish evaluating the path. */ if ( node->info.directory.mt_fs != NULL ) { 10f2d8: 8b 47 5c mov 0x5c(%edi),%eax 10f2db: 85 c0 test %eax,%eax 10f2dd: 0f 85 a4 00 00 00 jne 10f387 } /* * Otherwise find the token name in the present location. */ node = IMFS_find_match_in_dir( node, token ); 10f2e3: 83 ec 08 sub $0x8,%esp 10f2e6: 56 push %esi 10f2e7: 57 push %edi 10f2e8: e8 eb 05 00 00 call 10f8d8 10f2ed: 89 c7 mov %eax,%edi if ( !node ) 10f2ef: 83 c4 10 add $0x10,%esp 10f2f2: 85 c0 test %eax,%eax 10f2f4: 74 32 je 10f328 /* * Set the node access to the point we have found. */ pathloc->node_access = node; 10f2f6: 8b 45 14 mov 0x14(%ebp),%eax 10f2f9: 89 38 mov %edi,(%eax) 10f2fb: e9 19 ff ff ff jmp 10f219 case IMFS_UP_DIR: /* * Am I at the root of all filesystems? (chroot'ed?) */ if ( pathloc->node_access == rtems_filesystem_root.node_access ) 10f300: 8b 15 90 59 12 00 mov 0x125990,%edx 10f306: 39 42 18 cmp %eax,0x18(%edx) 10f309: 0f 84 0a ff ff ff je 10f219 /* * Am I at the root of this mounted filesystem? */ if (pathloc->node_access == pathloc->mt_entry->mt_fs_root.node_access) { 10f30f: 8b 4d 14 mov 0x14(%ebp),%ecx 10f312: 8b 51 10 mov 0x10(%ecx),%edx /* * Am I at the root of this mounted filesystem? */ if (pathloc->node_access == 10f315: 39 42 1c cmp %eax,0x1c(%edx) 10f318: 0f 84 d2 00 00 00 je 10f3f0 pathnamelen+len, flags,pathloc); } } else { if ( !node->Parent ) 10f31e: 8b 78 08 mov 0x8(%eax),%edi 10f321: 85 ff test %edi,%edi 10f323: 75 d1 jne 10f2f6 10f325: 8d 76 00 lea 0x0(%esi),%esi /* * Otherwise find the token name in the present location. */ node = IMFS_find_match_in_dir( node, token ); if ( !node ) rtems_set_errno_and_return_minus_one( ENOENT ); 10f328: e8 43 3f 00 00 call 113270 <__errno> 10f32d: c7 00 02 00 00 00 movl $0x2,(%eax) 10f333: bb ff ff ff ff mov $0xffffffff,%ebx 10f338: eb 12 jmp 10f34c 10f33a: 66 90 xchg %ax,%ax case IMFS_NO_MORE_PATH: case IMFS_CURRENT_DIR: break; case IMFS_INVALID_TOKEN: rtems_set_errno_and_return_minus_one( ENAMETOOLONG ); 10f33c: e8 2f 3f 00 00 call 113270 <__errno> 10f341: c7 00 5b 00 00 00 movl $0x5b,(%eax) 10f347: bb ff ff ff ff mov $0xffffffff,%ebx if ( !IMFS_evaluate_permission( pathloc, flags ) ) rtems_set_errno_and_return_minus_one( EACCES ); return result; } 10f34c: 89 d8 mov %ebx,%eax 10f34e: 8d 65 f4 lea -0xc(%ebp),%esp 10f351: 5b pop %ebx 10f352: 5e pop %esi 10f353: 5f pop %edi 10f354: c9 leave 10f355: c3 ret 10f356: 66 90 xchg %ax,%ax /* * I cannot move out of this directory without execute permission. */ if ( type != IMFS_NO_MORE_PATH ) if ( node->type == IMFS_DIRECTORY ) if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) ) 10f358: 83 ec 08 sub $0x8,%esp 10f35b: 6a 01 push $0x1 10f35d: ff 75 14 pushl 0x14(%ebp) 10f360: e8 df fd ff ff call 10f144 10f365: 83 c4 10 add $0x10,%esp 10f368: 85 c0 test %eax,%eax 10f36a: 0f 84 0b ff ff ff je 10f27b 10f370: 8b 55 14 mov 0x14(%ebp),%edx 10f373: 8b 02 mov (%edx),%eax 10f375: e9 20 ff ff ff jmp 10f29a 10f37a: 66 90 xchg %ax,%ax * * NOTE: The behavior of stat() on a mount point appears to be questionable. */ if ( node->type == IMFS_DIRECTORY ) { if ( node->info.directory.mt_fs != NULL ) { 10f37c: 8b 40 5c mov 0x5c(%eax),%eax 10f37f: 85 c0 test %eax,%eax 10f381: 0f 84 cf fe ff ff je 10f256 newloc = node->info.directory.mt_fs->mt_fs_root; 10f387: 8d 7d d0 lea -0x30(%ebp),%edi 10f38a: 8d 70 1c lea 0x1c(%eax),%esi 10f38d: b9 05 00 00 00 mov $0x5,%ecx 10f392: f3 a5 rep movsl %ds:(%esi),%es:(%edi) *pathloc = newloc; 10f394: 8d 75 d0 lea -0x30(%ebp),%esi 10f397: b1 05 mov $0x5,%cl 10f399: 8b 7d 14 mov 0x14(%ebp),%edi 10f39c: f3 a5 rep movsl %ds:(%esi),%es:(%edi) return (*pathloc->ops->evalpath_h)( &pathname[i-len], 10f39e: 8b 55 e4 mov -0x1c(%ebp),%edx 10f3a1: 8b 4d 14 mov 0x14(%ebp),%ecx 10f3a4: 8b 41 0c mov 0xc(%ecx),%eax 10f3a7: 51 push %ecx 10f3a8: ff 75 10 pushl 0x10(%ebp) 10f3ab: 8b 4d 0c mov 0xc(%ebp),%ecx 10f3ae: 01 d1 add %edx,%ecx 10f3b0: 51 push %ecx 10f3b1: 8b 4d a4 mov -0x5c(%ebp),%ecx 10f3b4: 29 d1 sub %edx,%ecx 10f3b6: 8b 55 08 mov 0x8(%ebp),%edx 10f3b9: 01 ca add %ecx,%edx 10f3bb: 52 push %edx 10f3bc: ff 10 call *(%eax) 10f3be: 89 c3 mov %eax,%ebx 10f3c0: 83 c4 10 add $0x10,%esp if ( !IMFS_evaluate_permission( pathloc, flags ) ) rtems_set_errno_and_return_minus_one( EACCES ); return result; } 10f3c3: 89 d8 mov %ebx,%eax 10f3c5: 8d 65 f4 lea -0xc(%ebp),%esp 10f3c8: 5b pop %ebx 10f3c9: 5e pop %esi 10f3ca: 5f pop %edi 10f3cb: c9 leave 10f3cc: c3 ret 10f3cd: 8d 76 00 lea 0x0(%esi),%esi case IMFS_NAME: /* * If we are at a link follow it. */ if ( node->type == IMFS_HARD_LINK ) { IMFS_evaluate_hard_link( pathloc, 0 ); 10f3d0: 83 ec 08 sub $0x8,%esp 10f3d3: 6a 00 push $0x0 10f3d5: ff 75 14 pushl 0x14(%ebp) 10f3d8: e8 d3 fd ff ff call 10f1b0 node = pathloc->node_access; 10f3dd: 8b 55 14 mov 0x14(%ebp),%edx 10f3e0: 8b 3a mov (%edx),%edi 10f3e2: 8b 47 4c mov 0x4c(%edi),%eax 10f3e5: 83 c4 10 add $0x10,%esp 10f3e8: e9 e4 fe ff ff jmp 10f2d1 10f3ed: 8d 76 00 lea 0x0(%esi),%esi */ if ( pathloc->node_access == rtems_filesystem_root.node_access ) { break; /* Throw out the .. in this case */ } else { newloc = pathloc->mt_entry->mt_point_node; 10f3f0: 8d 7d d0 lea -0x30(%ebp),%edi 10f3f3: 8d 72 08 lea 0x8(%edx),%esi 10f3f6: eb 95 jmp 10f38d rtems_filesystem_location_info_t newloc; IMFS_jnode_t *node; int result; if ( !rtems_libio_is_valid_perms( flags ) ) { rtems_set_errno_and_return_minus_one( EIO ); 10f3f8: e8 73 3e 00 00 call 113270 <__errno> <== NOT EXECUTED 10f3fd: c7 00 05 00 00 00 movl $0x5,(%eax) <== NOT EXECUTED 10f403: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED 10f408: e9 3f ff ff ff jmp 10f34c <== NOT EXECUTED /* * Only a directory can be decended into. */ if ( node->type != IMFS_DIRECTORY ) rtems_set_errno_and_return_minus_one( ENOTDIR ); 10f40d: e8 5e 3e 00 00 call 113270 <__errno> 10f412: c7 00 14 00 00 00 movl $0x14,(%eax) 10f418: bb ff ff ff ff mov $0xffffffff,%ebx 10f41d: e9 2a ff ff ff jmp 10f34c * was broken. */ IMFS_assert( node ); } else if ( node->type == IMFS_SYM_LINK ) { result = IMFS_evaluate_sym_link( pathloc, 0 ); 10f422: 83 ec 08 sub $0x8,%esp 10f425: 6a 00 push $0x0 10f427: ff 75 14 pushl 0x14(%ebp) 10f42a: e8 1d 00 00 00 call 10f44c 10f42f: 89 c3 mov %eax,%ebx /* * In contrast to a hard link, it is possible to have a broken * symbolic link. */ node = pathloc->node_access; 10f431: 8b 4d 14 mov 0x14(%ebp),%ecx 10f434: 8b 39 mov (%ecx),%edi if ( result == -1 ) 10f436: 83 c4 10 add $0x10,%esp 10f439: 83 f8 ff cmp $0xffffffff,%eax 10f43c: 0f 84 0a ff ff ff je 10f34c <== NEVER TAKEN /* * In contrast to a hard link, it is possible to have a broken * symbolic link. */ node = pathloc->node_access; 10f442: 8b 47 4c mov 0x4c(%edi),%eax 10f445: e9 87 fe ff ff jmp 10f2d1 =============================================================================== 0010f574 : int IMFS_evaluate_for_make( const char *path, /* IN */ rtems_filesystem_location_info_t *pathloc, /* IN/OUT */ const char **name /* OUT */ ) { 10f574: 55 push %ebp 10f575: 89 e5 mov %esp,%ebp 10f577: 57 push %edi 10f578: 56 push %esi 10f579: 53 push %ebx 10f57a: 83 ec 5c sub $0x5c,%esp /* * This was filled in by the caller and is valid in the * mount table. */ node = pathloc->node_access; 10f57d: 8b 45 0c mov 0xc(%ebp),%eax 10f580: 8b 18 mov (%eax),%ebx /* * Get the path length. */ pathlen = strlen( path ); 10f582: 31 c0 xor %eax,%eax 10f584: b9 ff ff ff ff mov $0xffffffff,%ecx 10f589: 8b 7d 08 mov 0x8(%ebp),%edi 10f58c: f2 ae repnz scas %es:(%edi),%al 10f58e: f7 d1 not %ecx 10f590: 8d 71 ff lea -0x1(%ecx),%esi const char *path, /* IN */ rtems_filesystem_location_info_t *pathloc, /* IN/OUT */ const char **name /* OUT */ ) { int i = 0; 10f593: c7 45 a4 00 00 00 00 movl $0x0,-0x5c(%ebp) * Evaluate all tokens until we are done or an error occurs. */ while( !done ) { type = IMFS_get_token( &path[i], pathlen, token, &len ); 10f59a: 8d 55 e4 lea -0x1c(%ebp),%edx 10f59d: 52 push %edx 10f59e: 8d 4d af lea -0x51(%ebp),%ecx 10f5a1: 51 push %ecx 10f5a2: 56 push %esi 10f5a3: 8b 45 08 mov 0x8(%ebp),%eax 10f5a6: 03 45 a4 add -0x5c(%ebp),%eax 10f5a9: 50 push %eax 10f5aa: e8 95 03 00 00 call 10f944 10f5af: 89 c7 mov %eax,%edi pathlen -= len; 10f5b1: 8b 55 e4 mov -0x1c(%ebp),%edx 10f5b4: 29 d6 sub %edx,%esi i += len; if ( !pathloc->node_access ) 10f5b6: 8b 4d 0c mov 0xc(%ebp),%ecx 10f5b9: 8b 01 mov (%ecx),%eax 10f5bb: 83 c4 10 add $0x10,%esp 10f5be: 85 c0 test %eax,%eax 10f5c0: 0f 84 55 01 00 00 je 10f71b <== NEVER TAKEN /* * I cannot move out of this directory without execute permission. */ if ( type != IMFS_NO_MORE_PATH ) 10f5c6: 85 ff test %edi,%edi 10f5c8: 75 1a jne 10f5e4 pathloc->node_access = node; break; case IMFS_NO_MORE_PATH: rtems_set_errno_and_return_minus_one( EEXIST ); 10f5ca: e8 a1 3c 00 00 call 113270 <__errno> 10f5cf: c7 00 11 00 00 00 movl $0x11,(%eax) 10f5d5: bb ff ff ff ff mov $0xffffffff,%ebx if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) ) rtems_set_errno_and_return_minus_one( EACCES ); return result; } 10f5da: 89 d8 mov %ebx,%eax 10f5dc: 8d 65 f4 lea -0xc(%ebp),%esp 10f5df: 5b pop %ebx 10f5e0: 5e pop %esi 10f5e1: 5f pop %edi 10f5e2: c9 leave 10f5e3: c3 ret /* * I cannot move out of this directory without execute permission. */ if ( type != IMFS_NO_MORE_PATH ) if ( node->type == IMFS_DIRECTORY ) 10f5e4: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx) 10f5e8: 0f 84 c6 00 00 00 je 10f6b4 while( !done ) { type = IMFS_get_token( &path[i], pathlen, token, &len ); pathlen -= len; i += len; 10f5ee: 01 55 a4 add %edx,-0x5c(%ebp) if ( type != IMFS_NO_MORE_PATH ) if ( node->type == IMFS_DIRECTORY ) if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) ) rtems_set_errno_and_return_minus_one( EACCES ); node = pathloc->node_access; 10f5f1: 89 c3 mov %eax,%ebx switch( type ) { 10f5f3: 83 ff 02 cmp $0x2,%edi 10f5f6: 0f 84 88 00 00 00 je 10f684 10f5fc: 76 26 jbe 10f624 10f5fe: 83 ff 03 cmp $0x3,%edi 10f601: 74 2d je 10f630 10f603: 83 ff 04 cmp $0x4,%edi 10f606: 75 92 jne 10f59a <== NEVER TAKEN case IMFS_NO_MORE_PATH: rtems_set_errno_and_return_minus_one( EEXIST ); break; case IMFS_INVALID_TOKEN: rtems_set_errno_and_return_minus_one( ENAMETOOLONG ); 10f608: e8 63 3c 00 00 call 113270 <__errno> 10f60d: c7 00 5b 00 00 00 movl $0x5b,(%eax) 10f613: bb ff ff ff ff mov $0xffffffff,%ebx if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) ) rtems_set_errno_and_return_minus_one( EACCES ); return result; } 10f618: 89 d8 mov %ebx,%eax 10f61a: 8d 65 f4 lea -0xc(%ebp),%esp 10f61d: 5b pop %ebx 10f61e: 5e pop %esi 10f61f: 5f pop %edi 10f620: c9 leave 10f621: c3 ret 10f622: 66 90 xchg %ax,%ax if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) ) rtems_set_errno_and_return_minus_one( EACCES ); node = pathloc->node_access; switch( type ) { 10f624: 85 ff test %edi,%edi 10f626: 74 a2 je 10f5ca <== NEVER TAKEN 10f628: e9 6d ff ff ff jmp 10f59a 10f62d: 8d 76 00 lea 0x0(%esi),%esi pathloc->node_access = node; break; case IMFS_NAME: if ( node->type == IMFS_HARD_LINK ) { 10f630: 8b 40 4c mov 0x4c(%eax),%eax 10f633: 83 f8 03 cmp $0x3,%eax 10f636: 0f 84 b4 01 00 00 je 10f7f0 result = IMFS_evaluate_link( pathloc, 0 ); if ( result == -1 ) return -1; } else if ( node->type == IMFS_SYM_LINK ) { 10f63c: 83 f8 04 cmp $0x4,%eax 10f63f: 0f 84 ca 01 00 00 je 10f80f if ( result == -1 ) return -1; } node = pathloc->node_access; if ( !node ) 10f645: 85 db test %ebx,%ebx 10f647: 0f 84 67 01 00 00 je 10f7b4 <== NEVER TAKEN /* * Only a directory can be decended into. */ if ( node->type != IMFS_DIRECTORY ) 10f64d: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx) 10f651: 0f 85 5d 01 00 00 jne 10f7b4 /* * If we are at a node that is a mount point. Set loc to the * new fs root node and let them finish evaluating the path. */ if ( node->info.directory.mt_fs != NULL ) { 10f657: 8b 43 5c mov 0x5c(%ebx),%eax 10f65a: 85 c0 test %eax,%eax 10f65c: 0f 85 67 01 00 00 jne 10f7c9 /* * Otherwise find the token name in the present location. */ node = IMFS_find_match_in_dir( node, token ); 10f662: 83 ec 08 sub $0x8,%esp 10f665: 8d 45 af lea -0x51(%ebp),%eax 10f668: 50 push %eax 10f669: 53 push %ebx 10f66a: e8 69 02 00 00 call 10f8d8 10f66f: 89 c3 mov %eax,%ebx /* * If there is no node we have found the name of the node we * wish to create. */ if ( ! node ) 10f671: 83 c4 10 add $0x10,%esp 10f674: 85 c0 test %eax,%eax 10f676: 74 64 je 10f6dc done = true; else pathloc->node_access = node; 10f678: 8b 55 0c mov 0xc(%ebp),%edx 10f67b: 89 02 mov %eax,(%edx) 10f67d: e9 18 ff ff ff jmp 10f59a 10f682: 66 90 xchg %ax,%ax case IMFS_UP_DIR: /* * Am I at the root of all filesystems? (chroot'ed?) */ if ( pathloc->node_access == rtems_filesystem_root.node_access ) 10f684: 8b 15 90 59 12 00 mov 0x125990,%edx 10f68a: 3b 42 18 cmp 0x18(%edx),%eax 10f68d: 0f 84 07 ff ff ff je 10f59a /* * Am I at the root of this mounted filesystem? */ if (pathloc->node_access == pathloc->mt_entry->mt_fs_root.node_access){ 10f693: 8b 4d 0c mov 0xc(%ebp),%ecx 10f696: 8b 51 10 mov 0x10(%ecx),%edx 10f699: 3b 42 1c cmp 0x1c(%edx),%eax 10f69c: 0f 84 8e 00 00 00 je 10f730 *pathloc = newloc; return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name ); } } else { if ( !node->Parent ) 10f6a2: 8b 58 08 mov 0x8(%eax),%ebx 10f6a5: 85 db test %ebx,%ebx 10f6a7: 74 72 je 10f71b rtems_set_errno_and_return_minus_one( ENOENT ); node = node->Parent; } pathloc->node_access = node; 10f6a9: 8b 4d 0c mov 0xc(%ebp),%ecx 10f6ac: 89 19 mov %ebx,(%ecx) break; 10f6ae: e9 e7 fe ff ff jmp 10f59a 10f6b3: 90 nop * I cannot move out of this directory without execute permission. */ if ( type != IMFS_NO_MORE_PATH ) if ( node->type == IMFS_DIRECTORY ) if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) ) 10f6b4: 83 ec 08 sub $0x8,%esp 10f6b7: 6a 01 push $0x1 10f6b9: ff 75 0c pushl 0xc(%ebp) 10f6bc: 89 55 a0 mov %edx,-0x60(%ebp) 10f6bf: e8 80 fa ff ff call 10f144 10f6c4: 83 c4 10 add $0x10,%esp 10f6c7: 85 c0 test %eax,%eax 10f6c9: 8b 55 a0 mov -0x60(%ebp),%edx 10f6cc: 0f 84 cd 00 00 00 je 10f79f 10f6d2: 8b 4d 0c mov 0xc(%ebp),%ecx 10f6d5: 8b 01 mov (%ecx),%eax 10f6d7: e9 12 ff ff ff jmp 10f5ee case IMFS_CURRENT_DIR: break; } } *name = &path[ i - len ]; 10f6dc: 8b 45 a4 mov -0x5c(%ebp),%eax 10f6df: 2b 45 e4 sub -0x1c(%ebp),%eax 10f6e2: 03 45 08 add 0x8(%ebp),%eax 10f6e5: 8b 4d 10 mov 0x10(%ebp),%ecx 10f6e8: 89 01 mov %eax,(%ecx) /* * We have evaluated the path as far as we can. * Verify there is not any invalid stuff at the end of the name. */ for( ; path[i] != '\0'; i++) { 10f6ea: 8b 4d 08 mov 0x8(%ebp),%ecx 10f6ed: 8b 55 a4 mov -0x5c(%ebp),%edx 10f6f0: 8a 04 11 mov (%ecx,%edx,1),%al 10f6f3: 84 c0 test %al,%al 10f6f5: 74 75 je 10f76c 10f6f7: 89 d3 mov %edx,%ebx 10f6f9: 89 ce mov %ecx,%esi 10f6fb: eb 0b jmp 10f708 10f6fd: 8d 76 00 lea 0x0(%esi),%esi 10f700: 43 inc %ebx 10f701: 8a 04 1e mov (%esi,%ebx,1),%al 10f704: 84 c0 test %al,%al 10f706: 74 64 je 10f76c if ( !IMFS_is_separator( path[ i ] ) ) 10f708: 83 ec 0c sub $0xc,%esp 10f70b: 0f be c0 movsbl %al,%eax 10f70e: 50 push %eax 10f70f: e8 04 98 ff ff call 108f18 10f714: 83 c4 10 add $0x10,%esp 10f717: 85 c0 test %eax,%eax 10f719: 75 e5 jne 10f700 rtems_set_errno_and_return_minus_one( ENOENT ); 10f71b: e8 50 3b 00 00 call 113270 <__errno> 10f720: c7 00 02 00 00 00 movl $0x2,(%eax) 10f726: bb ff ff ff ff mov $0xffffffff,%ebx 10f72b: e9 aa fe ff ff jmp 10f5da if ( pathloc->node_access == rtems_filesystem_root.node_access ) { break; } else { newloc = pathloc->mt_entry->mt_point_node; 10f730: 8d 7d d0 lea -0x30(%ebp),%edi 10f733: 8d 72 08 lea 0x8(%edx),%esi 10f736: b9 05 00 00 00 mov $0x5,%ecx 10f73b: f3 a5 rep movsl %ds:(%esi),%es:(%edi) *pathloc = newloc; 10f73d: 8d 75 d0 lea -0x30(%ebp),%esi 10f740: b1 05 mov $0x5,%cl 10f742: 8b 7d 0c mov 0xc(%ebp),%edi 10f745: f3 a5 rep movsl %ds:(%esi),%es:(%edi) return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name ); 10f747: 53 push %ebx 10f748: 8b 55 0c mov 0xc(%ebp),%edx 10f74b: 8b 42 0c mov 0xc(%edx),%eax 10f74e: ff 75 10 pushl 0x10(%ebp) 10f751: 52 push %edx */ if ( node->info.directory.mt_fs != NULL ) { newloc = node->info.directory.mt_fs->mt_fs_root; *pathloc = newloc; return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name ); 10f752: 8b 55 a4 mov -0x5c(%ebp),%edx 10f755: 2b 55 e4 sub -0x1c(%ebp),%edx 10f758: 03 55 08 add 0x8(%ebp),%edx 10f75b: 52 push %edx 10f75c: ff 50 04 call *0x4(%eax) 10f75f: 89 c3 mov %eax,%ebx 10f761: 83 c4 10 add $0x10,%esp 10f764: e9 71 fe ff ff jmp 10f5da 10f769: 8d 76 00 lea 0x0(%esi),%esi /* * Verify we can execute and write to this directory. */ result = IMFS_Set_handlers( pathloc ); 10f76c: 83 ec 0c sub $0xc,%esp 10f76f: ff 75 0c pushl 0xc(%ebp) 10f772: e8 71 f9 ff ff call 10f0e8 10f777: 89 c3 mov %eax,%ebx /* * The returned node must be a directory */ node = pathloc->node_access; if ( node->type != IMFS_DIRECTORY ) 10f779: 8b 55 0c mov 0xc(%ebp),%edx 10f77c: 8b 02 mov (%edx),%eax 10f77e: 83 c4 10 add $0x10,%esp 10f781: 83 78 4c 01 cmpl $0x1,0x4c(%eax) 10f785: 75 2d jne 10f7b4 <== NEVER TAKEN /* * We must have Write and execute permission on the returned node. */ if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) ) 10f787: 83 ec 08 sub $0x8,%esp 10f78a: 6a 03 push $0x3 10f78c: ff 75 0c pushl 0xc(%ebp) 10f78f: e8 b0 f9 ff ff call 10f144 10f794: 83 c4 10 add $0x10,%esp 10f797: 85 c0 test %eax,%eax 10f799: 0f 85 3b fe ff ff jne 10f5da rtems_set_errno_and_return_minus_one( EACCES ); 10f79f: e8 cc 3a 00 00 call 113270 <__errno> 10f7a4: c7 00 0d 00 00 00 movl $0xd,(%eax) 10f7aa: bb ff ff ff ff mov $0xffffffff,%ebx 10f7af: e9 26 fe ff ff jmp 10f5da /* * The returned node must be a directory */ node = pathloc->node_access; if ( node->type != IMFS_DIRECTORY ) rtems_set_errno_and_return_minus_one( ENOTDIR ); 10f7b4: e8 b7 3a 00 00 call 113270 <__errno> 10f7b9: c7 00 14 00 00 00 movl $0x14,(%eax) 10f7bf: bb ff ff ff ff mov $0xffffffff,%ebx 10f7c4: e9 11 fe ff ff jmp 10f5da * If we are at a node that is a mount point. Set loc to the * new fs root node and let them finish evaluating the path. */ if ( node->info.directory.mt_fs != NULL ) { newloc = node->info.directory.mt_fs->mt_fs_root; 10f7c9: 8d 7d d0 lea -0x30(%ebp),%edi 10f7cc: 8d 70 1c lea 0x1c(%eax),%esi 10f7cf: b9 05 00 00 00 mov $0x5,%ecx 10f7d4: f3 a5 rep movsl %ds:(%esi),%es:(%edi) *pathloc = newloc; 10f7d6: 8d 75 d0 lea -0x30(%ebp),%esi 10f7d9: b1 05 mov $0x5,%cl 10f7db: 8b 7d 0c mov 0xc(%ebp),%edi 10f7de: f3 a5 rep movsl %ds:(%esi),%es:(%edi) return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name ); 10f7e0: 51 push %ecx 10f7e1: 8b 4d 0c mov 0xc(%ebp),%ecx 10f7e4: 8b 41 0c mov 0xc(%ecx),%eax 10f7e7: ff 75 10 pushl 0x10(%ebp) 10f7ea: 51 push %ecx 10f7eb: e9 62 ff ff ff jmp 10f752 case IMFS_NAME: if ( node->type == IMFS_HARD_LINK ) { result = IMFS_evaluate_link( pathloc, 0 ); 10f7f0: 83 ec 08 sub $0x8,%esp 10f7f3: 6a 00 push $0x0 10f7f5: ff 75 0c pushl 0xc(%ebp) 10f7f8: e8 cb fc ff ff call 10f4c8 if ( result == -1 ) 10f7fd: 83 c4 10 add $0x10,%esp 10f800: 83 f8 ff cmp $0xffffffff,%eax 10f803: 74 29 je 10f82e <== NEVER TAKEN 10f805: 8b 45 0c mov 0xc(%ebp),%eax 10f808: 8b 18 mov (%eax),%ebx 10f80a: e9 36 fe ff ff jmp 10f645 return -1; } else if ( node->type == IMFS_SYM_LINK ) { result = IMFS_evaluate_link( pathloc, 0 ); 10f80f: 83 ec 08 sub $0x8,%esp 10f812: 6a 00 push $0x0 10f814: ff 75 0c pushl 0xc(%ebp) 10f817: e8 ac fc ff ff call 10f4c8 if ( result == -1 ) 10f81c: 83 c4 10 add $0x10,%esp 10f81f: 83 f8 ff cmp $0xffffffff,%eax 10f822: 74 0a je 10f82e <== NEVER TAKEN 10f824: 8b 55 0c mov 0xc(%ebp),%edx 10f827: 8b 1a mov (%edx),%ebx 10f829: e9 17 fe ff ff jmp 10f645 10f82e: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10f830: e9 a5 fd ff ff jmp 10f5da <== NOT EXECUTED =============================================================================== 0010f4c8 : */ int IMFS_evaluate_link( rtems_filesystem_location_info_t *node, /* IN/OUT */ int flags /* IN */ ) { 10f4c8: 55 push %ebp 10f4c9: 89 e5 mov %esp,%ebp 10f4cb: 57 push %edi 10f4cc: 56 push %esi 10f4cd: 53 push %ebx 10f4ce: 83 ec 0c sub $0xc,%esp 10f4d1: 8b 75 08 mov 0x8(%ebp),%esi 10f4d4: 8b 7d 0c mov 0xc(%ebp),%edi */ rtems_filesystem_link_counts ++; if ( rtems_filesystem_link_counts > MAXSYMLINK ) { rtems_filesystem_link_counts = 0; rtems_set_errno_and_return_minus_one( ELOOP ); 10f4d7: 8b 15 90 59 12 00 mov 0x125990,%edx 10f4dd: eb 0e jmp 10f4ed 10f4df: 90 nop */ if ( jnode->type == IMFS_HARD_LINK ) result = IMFS_evaluate_hard_link( node, flags ); else if (jnode->type == IMFS_SYM_LINK ) 10f4e0: 83 f8 04 cmp $0x4,%eax 10f4e3: 74 53 je 10f538 result = IMFS_evaluate_sym_link( node, flags ); } while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) || 10f4e5: 83 e8 03 sub $0x3,%eax 10f4e8: 83 f8 01 cmp $0x1,%eax 10f4eb: 77 3a ja 10f527 <== ALWAYS TAKEN { IMFS_jnode_t *jnode; int result = 0; do { jnode = node->node_access; 10f4ed: 8b 1e mov (%esi),%ebx /* * Increment and check the link counter. */ rtems_filesystem_link_counts ++; 10f4ef: 8b 42 30 mov 0x30(%edx),%eax 10f4f2: 40 inc %eax 10f4f3: 66 89 42 30 mov %ax,0x30(%edx) if ( rtems_filesystem_link_counts > MAXSYMLINK ) { 10f4f7: 66 83 f8 05 cmp $0x5,%ax 10f4fb: 77 57 ja 10f554 /* * Follow the Link node. */ if ( jnode->type == IMFS_HARD_LINK ) 10f4fd: 8b 43 4c mov 0x4c(%ebx),%eax 10f500: 83 f8 03 cmp $0x3,%eax 10f503: 75 db jne 10f4e0 result = IMFS_evaluate_hard_link( node, flags ); 10f505: 83 ec 08 sub $0x8,%esp 10f508: 57 push %edi 10f509: 56 push %esi 10f50a: e8 a1 fc ff ff call 10f1b0 10f50f: 83 c4 10 add $0x10,%esp else if (jnode->type == IMFS_SYM_LINK ) result = IMFS_evaluate_sym_link( node, flags ); } while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) || ( jnode->type == IMFS_HARD_LINK ) ) ); 10f512: 85 c0 test %eax,%eax 10f514: 75 33 jne 10f549 10f516: 8b 43 4c mov 0x4c(%ebx),%eax 10f519: 8b 15 90 59 12 00 mov 0x125990,%edx result = IMFS_evaluate_hard_link( node, flags ); else if (jnode->type == IMFS_SYM_LINK ) result = IMFS_evaluate_sym_link( node, flags ); } while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) || 10f51f: 83 e8 03 sub $0x3,%eax 10f522: 83 f8 01 cmp $0x1,%eax 10f525: 76 c6 jbe 10f4ed <== ALWAYS TAKEN 10f527: 31 c0 xor %eax,%eax /* * Clear link counter. */ rtems_filesystem_link_counts = 0; 10f529: 66 c7 42 30 00 00 movw $0x0,0x30(%edx) return result; } 10f52f: 8d 65 f4 lea -0xc(%ebp),%esp 10f532: 5b pop %ebx 10f533: 5e pop %esi 10f534: 5f pop %edi 10f535: c9 leave 10f536: c3 ret 10f537: 90 nop if ( jnode->type == IMFS_HARD_LINK ) result = IMFS_evaluate_hard_link( node, flags ); else if (jnode->type == IMFS_SYM_LINK ) result = IMFS_evaluate_sym_link( node, flags ); 10f538: 83 ec 08 sub $0x8,%esp 10f53b: 57 push %edi 10f53c: 56 push %esi 10f53d: e8 0a ff ff ff call 10f44c 10f542: 83 c4 10 add $0x10,%esp } while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) || ( jnode->type == IMFS_HARD_LINK ) ) ); 10f545: 85 c0 test %eax,%eax 10f547: 74 cd je 10f516 10f549: 8b 15 90 59 12 00 mov 0x125990,%edx 10f54f: eb d8 jmp 10f529 10f551: 8d 76 00 lea 0x0(%esi),%esi * Increment and check the link counter. */ rtems_filesystem_link_counts ++; if ( rtems_filesystem_link_counts > MAXSYMLINK ) { rtems_filesystem_link_counts = 0; 10f554: 66 c7 42 30 00 00 movw $0x0,0x30(%edx) rtems_set_errno_and_return_minus_one( ELOOP ); 10f55a: e8 11 3d 00 00 call 113270 <__errno> 10f55f: c7 00 5c 00 00 00 movl $0x5c,(%eax) 10f565: b8 ff ff ff ff mov $0xffffffff,%eax */ rtems_filesystem_link_counts = 0; return result; } 10f56a: 8d 65 f4 lea -0xc(%ebp),%esp 10f56d: 5b pop %ebx 10f56e: 5e pop %esi 10f56f: 5f pop %edi 10f570: c9 leave 10f571: c3 ret =============================================================================== 0010f144 : */ int IMFS_evaluate_permission( rtems_filesystem_location_info_t *node, int flags ) { 10f144: 55 push %ebp 10f145: 89 e5 mov %esp,%ebp 10f147: 57 push %edi 10f148: 56 push %esi 10f149: 53 push %ebx 10f14a: 83 ec 0c sub $0xc,%esp 10f14d: 8b 75 0c mov 0xc(%ebp),%esi uid_t st_uid; gid_t st_gid; IMFS_jnode_t *jnode; int flags_to_test; if ( !rtems_libio_is_valid_perms( flags ) ) 10f150: f7 c6 f8 ff ff ff test $0xfffffff8,%esi 10f156: 75 44 jne 10f19c <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EPERM ); jnode = node->node_access; 10f158: 8b 45 08 mov 0x8(%ebp),%eax 10f15b: 8b 18 mov (%eax),%ebx #if defined(RTEMS_POSIX_API) st_uid = geteuid(); 10f15d: e8 1a 0c 00 00 call 10fd7c 10f162: 89 c7 mov %eax,%edi st_gid = getegid(); 10f164: e8 03 0c 00 00 call 10fd6c * Check if I am owner or a group member or someone else. */ flags_to_test = flags; if ( st_uid == jnode->st_uid ) 10f169: 66 39 7b 3c cmp %di,0x3c(%ebx) 10f16d: 74 1d je 10f18c flags_to_test <<= 6; else if ( st_gid == jnode->st_gid ) 10f16f: 66 39 43 3e cmp %ax,0x3e(%ebx) 10f173: 74 1f je 10f194 <== ALWAYS TAKEN /* * If all of the flags are set we have permission * to do this. */ if ( ( flags_to_test & jnode->st_mode) == flags_to_test ) 10f175: 8b 43 30 mov 0x30(%ebx),%eax 10f178: 21 f0 and %esi,%eax gid_t st_gid; IMFS_jnode_t *jnode; int flags_to_test; if ( !rtems_libio_is_valid_perms( flags ) ) rtems_set_errno_and_return_minus_one( EPERM ); 10f17a: 39 c6 cmp %eax,%esi 10f17c: 0f 94 c0 sete %al 10f17f: 0f b6 c0 movzbl %al,%eax */ if ( ( flags_to_test & jnode->st_mode) == flags_to_test ) return 1; return 0; } 10f182: 83 c4 0c add $0xc,%esp 10f185: 5b pop %ebx 10f186: 5e pop %esi 10f187: 5f pop %edi 10f188: c9 leave 10f189: c3 ret 10f18a: 66 90 xchg %ax,%ax */ flags_to_test = flags; if ( st_uid == jnode->st_uid ) flags_to_test <<= 6; 10f18c: c1 e6 06 shl $0x6,%esi 10f18f: eb e4 jmp 10f175 10f191: 8d 76 00 lea 0x0(%esi),%esi else if ( st_gid == jnode->st_gid ) flags_to_test <<= 3; 10f194: c1 e6 03 shl $0x3,%esi 10f197: eb dc jmp 10f175 10f199: 8d 76 00 lea 0x0(%esi),%esi gid_t st_gid; IMFS_jnode_t *jnode; int flags_to_test; if ( !rtems_libio_is_valid_perms( flags ) ) rtems_set_errno_and_return_minus_one( EPERM ); 10f19c: e8 cf 40 00 00 call 113270 <__errno> <== NOT EXECUTED 10f1a1: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED 10f1a7: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10f1ac: eb d4 jmp 10f182 <== NOT EXECUTED =============================================================================== 0010f44c : int IMFS_evaluate_sym_link( rtems_filesystem_location_info_t *node, /* IN/OUT */ int flags /* IN */ ) { 10f44c: 55 push %ebp 10f44d: 89 e5 mov %esp,%ebp 10f44f: 57 push %edi 10f450: 56 push %esi 10f451: 53 push %ebx 10f452: 83 ec 20 sub $0x20,%esp 10f455: 8b 5d 08 mov 0x8(%ebp),%ebx 10f458: 8b 75 0c mov 0xc(%ebp),%esi IMFS_jnode_t *jnode = node->node_access; 10f45b: 8b 3b mov (%ebx),%edi /* * Move the node_access to either the symbolic links parent or * root depending on the symbolic links path. */ node->node_access = jnode->Parent; 10f45d: 8b 47 08 mov 0x8(%edi),%eax 10f460: 89 03 mov %eax,(%ebx) rtems_filesystem_get_sym_start_loc( 10f462: 53 push %ebx 10f463: 8d 45 e4 lea -0x1c(%ebp),%eax 10f466: 50 push %eax 10f467: ff 77 50 pushl 0x50(%edi) 10f46a: e8 f9 0d 00 00 call 110268 ); /* * Use eval path to evaluate the path of the symbolic link. */ result = IMFS_eval_path( 10f46f: 8b 57 50 mov 0x50(%edi),%edx 10f472: 03 55 e4 add -0x1c(%ebp),%edx 10f475: 31 c0 xor %eax,%eax 10f477: b9 ff ff ff ff mov $0xffffffff,%ecx 10f47c: 89 d7 mov %edx,%edi 10f47e: f2 ae repnz scas %es:(%edi),%al 10f480: f7 d1 not %ecx 10f482: 49 dec %ecx 10f483: 53 push %ebx 10f484: 56 push %esi 10f485: 51 push %ecx 10f486: 52 push %edx 10f487: e8 68 fd ff ff call 10f1f4 10f48c: 89 c7 mov %eax,%edi strlen( &jnode->info.sym_link.name[i] ), flags, node ); IMFS_Set_handlers( node ); 10f48e: 83 c4 14 add $0x14,%esp 10f491: 53 push %ebx 10f492: e8 51 fc ff ff call 10f0e8 /* * Verify we have the correct permissions for this node. */ if ( !IMFS_evaluate_permission( node, flags ) ) 10f497: 58 pop %eax 10f498: 5a pop %edx 10f499: 56 push %esi 10f49a: 53 push %ebx 10f49b: e8 a4 fc ff ff call 10f144 10f4a0: 83 c4 10 add $0x10,%esp 10f4a3: 85 c0 test %eax,%eax 10f4a5: 74 0d je 10f4b4 rtems_set_errno_and_return_minus_one( EACCES ); return result; } 10f4a7: 89 f8 mov %edi,%eax 10f4a9: 8d 65 f4 lea -0xc(%ebp),%esp 10f4ac: 5b pop %ebx 10f4ad: 5e pop %esi 10f4ae: 5f pop %edi 10f4af: c9 leave 10f4b0: c3 ret 10f4b1: 8d 76 00 lea 0x0(%esi),%esi /* * Verify we have the correct permissions for this node. */ if ( !IMFS_evaluate_permission( node, flags ) ) rtems_set_errno_and_return_minus_one( EACCES ); 10f4b4: e8 b7 3d 00 00 call 113270 <__errno> 10f4b9: c7 00 0d 00 00 00 movl $0xd,(%eax) 10f4bf: bf ff ff ff ff mov $0xffffffff,%edi 10f4c4: eb e1 jmp 10f4a7 =============================================================================== 001129f0 : int IMFS_fchmod( rtems_filesystem_location_info_t *loc, mode_t mode ) { 1129f0: 55 push %ebp 1129f1: 89 e5 mov %esp,%ebp 1129f3: 53 push %ebx 1129f4: 83 ec 14 sub $0x14,%esp IMFS_jnode_t *jnode; #if defined(RTEMS_POSIX_API) uid_t st_uid; #endif jnode = loc->node_access; 1129f7: 8b 45 08 mov 0x8(%ebp),%eax 1129fa: 8b 18 mov (%eax),%ebx /* * Verify I am the owner of the node or the super user. */ #if defined(RTEMS_POSIX_API) st_uid = geteuid(); 1129fc: e8 7b d3 ff ff call 10fd7c if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) ) 112a01: 66 39 43 3c cmp %ax,0x3c(%ebx) 112a05: 74 05 je 112a0c 112a07: 66 85 c0 test %ax,%ax 112a0a: 75 34 jne 112a40 <== ALWAYS TAKEN /* * Change only the RWX permissions on the jnode to mode. */ jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX); jnode->st_mode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX); 112a0c: 8b 45 0c mov 0xc(%ebp),%eax 112a0f: 25 ff 0f 00 00 and $0xfff,%eax /* * Change only the RWX permissions on the jnode to mode. */ jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX); 112a14: 8b 53 30 mov 0x30(%ebx),%edx 112a17: 81 e2 00 f0 ff ff and $0xfffff000,%edx jnode->st_mode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX); 112a1d: 09 d0 or %edx,%eax 112a1f: 89 43 30 mov %eax,0x30(%ebx) IMFS_update_ctime( jnode ); 112a22: 83 ec 08 sub $0x8,%esp 112a25: 6a 00 push $0x0 112a27: 8d 45 f0 lea -0x10(%ebp),%eax 112a2a: 50 push %eax 112a2b: e8 00 57 ff ff call 108130 112a30: 8b 45 f0 mov -0x10(%ebp),%eax 112a33: 89 43 48 mov %eax,0x48(%ebx) return 0; 112a36: 83 c4 10 add $0x10,%esp 112a39: 31 c0 xor %eax,%eax } 112a3b: 8b 5d fc mov -0x4(%ebp),%ebx 112a3e: c9 leave 112a3f: c3 ret */ #if defined(RTEMS_POSIX_API) st_uid = geteuid(); if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) ) rtems_set_errno_and_return_minus_one( EPERM ); 112a40: e8 2b 08 00 00 call 113270 <__errno> 112a45: c7 00 01 00 00 00 movl $0x1,(%eax) 112a4b: b8 ff ff ff ff mov $0xffffffff,%eax 112a50: eb e9 jmp 112a3b =============================================================================== 00108a84 : int IMFS_fifo_ioctl( rtems_libio_t *iop, uint32_t command, void *buffer ) { 108a84: 55 push %ebp 108a85: 89 e5 mov %esp,%ebp 108a87: 53 push %ebx 108a88: 83 ec 04 sub $0x4,%esp 108a8b: 8b 45 08 mov 0x8(%ebp),%eax 108a8e: 8b 55 0c mov 0xc(%ebp),%edx 108a91: 8b 4d 10 mov 0x10(%ebp),%ecx int err; if (command == FIONBIO) { 108a94: 81 fa 7e 66 04 80 cmp $0x8004667e,%edx 108a9a: 74 1c je 108ab8 iop->flags &= ~LIBIO_FLAGS_NO_DELAY; return 0; } } else err = pipe_ioctl(LIBIO2PIPE(iop), command, buffer, iop); 108a9c: 50 push %eax 108a9d: 51 push %ecx 108a9e: 52 push %edx 108a9f: 8b 40 18 mov 0x18(%eax),%eax 108aa2: ff 70 50 pushl 0x50(%eax) 108aa5: e8 26 98 00 00 call 1122d0 IMFS_FIFO_RETURN(err); 108aaa: 83 c4 10 add $0x10,%esp 108aad: 85 c0 test %eax,%eax 108aaf: 78 3e js 108aef } 108ab1: 8b 5d fc mov -0x4(%ebp),%ebx 108ab4: c9 leave 108ab5: c3 ret 108ab6: 66 90 xchg %ax,%ax ) { int err; if (command == FIONBIO) { if (buffer == NULL) 108ab8: 85 c9 test %ecx,%ecx 108aba: 74 20 je 108adc err = -EFAULT; else { if (*(int *)buffer) 108abc: 8b 11 mov (%ecx),%edx 108abe: 85 d2 test %edx,%edx 108ac0: 74 0e je 108ad0 iop->flags |= LIBIO_FLAGS_NO_DELAY; 108ac2: 83 48 14 01 orl $0x1,0x14(%eax) else iop->flags &= ~LIBIO_FLAGS_NO_DELAY; return 0; 108ac6: 31 c0 xor %eax,%eax } else err = pipe_ioctl(LIBIO2PIPE(iop), command, buffer, iop); IMFS_FIFO_RETURN(err); } 108ac8: 8b 5d fc mov -0x4(%ebp),%ebx 108acb: c9 leave 108acc: c3 ret 108acd: 8d 76 00 lea 0x0(%esi),%esi err = -EFAULT; else { if (*(int *)buffer) iop->flags |= LIBIO_FLAGS_NO_DELAY; else iop->flags &= ~LIBIO_FLAGS_NO_DELAY; 108ad0: 83 60 14 fe andl $0xfffffffe,0x14(%eax) return 0; 108ad4: 31 c0 xor %eax,%eax } else err = pipe_ioctl(LIBIO2PIPE(iop), command, buffer, iop); IMFS_FIFO_RETURN(err); } 108ad6: 8b 5d fc mov -0x4(%ebp),%ebx 108ad9: c9 leave 108ada: c3 ret 108adb: 90 nop ) { int err; if (command == FIONBIO) { if (buffer == NULL) 108adc: bb 0e 00 00 00 mov $0xe,%ebx } } else err = pipe_ioctl(LIBIO2PIPE(iop), command, buffer, iop); IMFS_FIFO_RETURN(err); 108ae1: e8 82 c9 00 00 call 115468 <__errno> 108ae6: 89 18 mov %ebx,(%eax) 108ae8: b8 ff ff ff ff mov $0xffffffff,%eax 108aed: eb c2 jmp 108ab1 108aef: 89 c3 mov %eax,%ebx 108af1: f7 db neg %ebx 108af3: eb ec jmp 108ae1 =============================================================================== 00108a40 : rtems_off64_t IMFS_fifo_lseek( rtems_libio_t *iop, rtems_off64_t offset, int whence ) { 108a40: 55 push %ebp 108a41: 89 e5 mov %esp,%ebp 108a43: 53 push %ebx 108a44: 83 ec 10 sub $0x10,%esp 108a47: 8b 45 08 mov 0x8(%ebp),%eax off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop); 108a4a: 50 push %eax 108a4b: ff 75 14 pushl 0x14(%ebp) 108a4e: ff 75 10 pushl 0x10(%ebp) 108a51: ff 75 0c pushl 0xc(%ebp) 108a54: 8b 40 18 mov 0x18(%eax),%eax 108a57: ff 70 50 pushl 0x50(%eax) 108a5a: e8 d1 98 00 00 call 112330 108a5f: 89 c3 mov %eax,%ebx 108a61: 99 cltd IMFS_FIFO_RETURN(err); 108a62: 83 c4 20 add $0x20,%esp 108a65: 85 d2 test %edx,%edx 108a67: 78 05 js 108a6e <== ALWAYS TAKEN } 108a69: 8b 5d fc mov -0x4(%ebp),%ebx 108a6c: c9 leave 108a6d: c3 ret rtems_off64_t offset, int whence ) { off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop); IMFS_FIFO_RETURN(err); 108a6e: e8 f5 c9 00 00 call 115468 <__errno> 108a73: f7 db neg %ebx 108a75: 89 18 mov %ebx,(%eax) 108a77: b8 ff ff ff ff mov $0xffffffff,%eax 108a7c: ba ff ff ff ff mov $0xffffffff,%edx 108a81: eb e6 jmp 108a69 =============================================================================== 00108af8 : ssize_t IMFS_fifo_write( rtems_libio_t *iop, const void *buffer, size_t count ) { 108af8: 55 push %ebp 108af9: 89 e5 mov %esp,%ebp 108afb: 56 push %esi 108afc: 53 push %ebx 108afd: 83 ec 10 sub $0x10,%esp 108b00: 8b 45 08 mov 0x8(%ebp),%eax IMFS_jnode_t *jnode = iop->pathinfo.node_access; 108b03: 8b 58 18 mov 0x18(%eax),%ebx int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop); 108b06: 50 push %eax 108b07: ff 75 10 pushl 0x10(%ebp) 108b0a: ff 75 0c pushl 0xc(%ebp) 108b0d: ff 73 50 pushl 0x50(%ebx) 108b10: e8 bb 95 00 00 call 1120d0 108b15: 89 c6 mov %eax,%esi if (err > 0) { 108b17: 83 c4 10 add $0x10,%esp 108b1a: 83 f8 00 cmp $0x0,%eax 108b1d: 7e 25 jle 108b44 IMFS_mtime_ctime_update(jnode); 108b1f: 83 ec 08 sub $0x8,%esp 108b22: 6a 00 push $0x0 108b24: 8d 45 f0 lea -0x10(%ebp),%eax 108b27: 50 push %eax 108b28: e8 3f 0f 00 00 call 109a6c 108b2d: 8b 45 f0 mov -0x10(%ebp),%eax 108b30: 89 43 44 mov %eax,0x44(%ebx) 108b33: 89 43 48 mov %eax,0x48(%ebx) 108b36: 83 c4 10 add $0x10,%esp 108b39: 89 f0 mov %esi,%eax } IMFS_FIFO_RETURN(err); } 108b3b: 8d 65 f8 lea -0x8(%ebp),%esp 108b3e: 5b pop %ebx 108b3f: 5e pop %esi 108b40: c9 leave 108b41: c3 ret 108b42: 66 90 xchg %ax,%ax int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop); if (err > 0) { IMFS_mtime_ctime_update(jnode); } IMFS_FIFO_RETURN(err); 108b44: 75 09 jne 108b4f <== ALWAYS TAKEN 108b46: 31 c0 xor %eax,%eax } 108b48: 8d 65 f8 lea -0x8(%ebp),%esp 108b4b: 5b pop %ebx <== NOT EXECUTED 108b4c: 5e pop %esi <== NOT EXECUTED 108b4d: c9 leave <== NOT EXECUTED 108b4e: c3 ret <== NOT EXECUTED int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop); if (err > 0) { IMFS_mtime_ctime_update(jnode); } IMFS_FIFO_RETURN(err); 108b4f: e8 14 c9 00 00 call 115468 <__errno> 108b54: f7 de neg %esi 108b56: 89 30 mov %esi,(%eax) 108b58: b8 ff ff ff ff mov $0xffffffff,%eax 108b5d: eb dc jmp 108b3b =============================================================================== 0010f8d8 : IMFS_jnode_t *IMFS_find_match_in_dir( IMFS_jnode_t *directory, char *name ) { 10f8d8: 55 push %ebp 10f8d9: 89 e5 mov %esp,%ebp 10f8db: 57 push %edi 10f8dc: 56 push %esi 10f8dd: 53 push %ebx 10f8de: 83 ec 0c sub $0xc,%esp 10f8e1: 8b 45 08 mov 0x8(%ebp),%eax 10f8e4: 8b 5d 0c mov 0xc(%ebp),%ebx /* * Check for "." and ".." */ if ( !strcmp( name, dotname ) ) 10f8e7: bf f0 17 12 00 mov $0x1217f0,%edi 10f8ec: b9 02 00 00 00 mov $0x2,%ecx 10f8f1: 89 de mov %ebx,%esi 10f8f3: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) 10f8f5: 74 13 je 10f90a <== NEVER TAKEN return directory; if ( !strcmp( name, dotdotname ) ) 10f8f7: bf f2 17 12 00 mov $0x1217f2,%edi 10f8fc: b9 03 00 00 00 mov $0x3,%ecx 10f901: 89 de mov %ebx,%esi 10f903: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) 10f905: 75 0d jne 10f914 <== ALWAYS TAKEN return directory->Parent; 10f907: 8b 40 08 mov 0x8(%eax),%eax if ( !strcmp( name, the_jnode->name ) ) return the_jnode; } return 0; } 10f90a: 8d 65 f4 lea -0xc(%ebp),%esp 10f90d: 5b pop %ebx 10f90e: 5e pop %esi 10f90f: 5f pop %edi 10f910: c9 leave 10f911: c3 ret 10f912: 66 90 xchg %ax,%ax 10f914: 8b 70 50 mov 0x50(%eax),%esi RTEMS_INLINE_ROUTINE bool _Chain_Is_tail( Chain_Control *the_chain, const Chain_Node *the_node ) { return (the_node == _Chain_Tail(the_chain)); 10f917: 8d 78 54 lea 0x54(%eax),%edi if ( !strcmp( name, dotdotname ) ) return directory->Parent; the_chain = &directory->info.directory.Entries; for ( the_node = rtems_chain_first( the_chain ); 10f91a: 39 fe cmp %edi,%esi 10f91c: 75 08 jne 10f926 10f91e: eb 20 jmp 10f940 !rtems_chain_is_tail( the_chain, the_node ); the_node = the_node->next ) { 10f920: 8b 36 mov (%esi),%esi if ( !strcmp( name, dotdotname ) ) return directory->Parent; the_chain = &directory->info.directory.Entries; for ( the_node = rtems_chain_first( the_chain ); 10f922: 39 fe cmp %edi,%esi 10f924: 74 1a je 10f940 !rtems_chain_is_tail( the_chain, the_node ); the_node = the_node->next ) { the_jnode = (IMFS_jnode_t *) the_node; if ( !strcmp( name, the_jnode->name ) ) 10f926: 8d 46 0c lea 0xc(%esi),%eax 10f929: 83 ec 08 sub $0x8,%esp 10f92c: 50 push %eax 10f92d: 53 push %ebx 10f92e: e8 a9 45 00 00 call 113edc 10f933: 83 c4 10 add $0x10,%esp 10f936: 85 c0 test %eax,%eax 10f938: 75 e6 jne 10f920 for ( the_node = rtems_chain_first( the_chain ); !rtems_chain_is_tail( the_chain, the_node ); the_node = the_node->next ) { the_jnode = (IMFS_jnode_t *) the_node; 10f93a: 89 f0 mov %esi,%eax 10f93c: eb cc jmp 10f90a 10f93e: 66 90 xchg %ax,%ax if ( !strcmp( name, the_jnode->name ) ) return the_jnode; } return 0; 10f940: 31 c0 xor %eax,%eax 10f942: eb c6 jmp 10f90a =============================================================================== 0010f838 : ((IMFS_jnode_t *)( rtems_chain_head( jnode_get_control( jnode ) )->next)) int IMFS_fsunmount( rtems_filesystem_mount_table_entry_t *temp_mt_entry ) { 10f838: 55 push %ebp 10f839: 89 e5 mov %esp,%ebp 10f83b: 57 push %edi 10f83c: 56 push %esi 10f83d: 53 push %ebx 10f83e: 83 ec 3c sub $0x3c,%esp 10f841: 8b 45 08 mov 0x8(%ebp),%eax /* * Traverse tree that starts at the mt_fs_root and deallocate memory * associated memory space */ jnode = (IMFS_jnode_t *)temp_mt_entry->mt_fs_root.node_access; 10f844: 8b 58 1c mov 0x1c(%eax),%ebx loc = temp_mt_entry->mt_fs_root; 10f847: 8d 55 d4 lea -0x2c(%ebp),%edx 10f84a: 89 55 c4 mov %edx,-0x3c(%ebp) 10f84d: 8d 70 1c lea 0x1c(%eax),%esi 10f850: b9 05 00 00 00 mov $0x5,%ecx 10f855: 89 d7 mov %edx,%edi 10f857: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* * Set this to null to indicate that it is being unmounted. */ temp_mt_entry->mt_fs_root.node_access = NULL; 10f859: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax) do { next = jnode->Parent; 10f860: 8b 73 08 mov 0x8(%ebx),%esi loc.node_access = (void *)jnode; 10f863: 89 5d d4 mov %ebx,-0x2c(%ebp) IMFS_Set_handlers( &loc ); 10f866: 83 ec 0c sub $0xc,%esp 10f869: 8d 45 d4 lea -0x2c(%ebp),%eax 10f86c: 50 push %eax 10f86d: e8 76 f8 ff ff call 10f0e8 if ( jnode->type != IMFS_DIRECTORY ) { 10f872: 83 c4 10 add $0x10,%esp 10f875: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx) 10f879: 75 31 jne 10f8ac RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 10f87b: 8d 43 54 lea 0x54(%ebx),%eax result = IMFS_unlink( NULL, &loc ); if (result != 0) return -1; jnode = next; } else if ( jnode_has_no_children( jnode ) ) { 10f87e: 39 43 50 cmp %eax,0x50(%ebx) 10f881: 74 42 je 10f8c5 result = IMFS_unlink( NULL, &loc ); if (result != 0) return -1; jnode = next; } if ( jnode != NULL ) { 10f883: 85 db test %ebx,%ebx 10f885: 74 19 je 10f8a0 if ( jnode->type == IMFS_DIRECTORY ) { 10f887: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx) 10f88b: 75 d3 jne 10f860 <== NEVER TAKEN } } } while (jnode != NULL); return 0; } 10f88d: 8b 43 50 mov 0x50(%ebx),%eax 10f890: 8d 53 54 lea 0x54(%ebx),%edx return -1; jnode = next; } if ( jnode != NULL ) { if ( jnode->type == IMFS_DIRECTORY ) { if ( jnode_has_children( jnode ) ) 10f893: 39 d0 cmp %edx,%eax 10f895: 74 c9 je 10f860 jnode = jnode_get_first_child( jnode ); 10f897: 89 c3 mov %eax,%ebx } } } while (jnode != NULL); 10f899: 85 c0 test %eax,%eax 10f89b: 75 c3 jne 10f860 <== ALWAYS TAKEN 10f89d: 8d 76 00 lea 0x0(%esi),%esi return 0; 10f8a0: 31 c0 xor %eax,%eax } 10f8a2: 8d 65 f4 lea -0xc(%ebp),%esp 10f8a5: 5b pop %ebx 10f8a6: 5e pop %esi 10f8a7: 5f pop %edi 10f8a8: c9 leave 10f8a9: c3 ret 10f8aa: 66 90 xchg %ax,%ax next = jnode->Parent; loc.node_access = (void *)jnode; IMFS_Set_handlers( &loc ); if ( jnode->type != IMFS_DIRECTORY ) { result = IMFS_unlink( NULL, &loc ); 10f8ac: 83 ec 08 sub $0x8,%esp 10f8af: 8d 55 d4 lea -0x2c(%ebp),%edx 10f8b2: 52 push %edx if (result != 0) return -1; jnode = next; } else if ( jnode_has_no_children( jnode ) ) { result = IMFS_unlink( NULL, &loc ); 10f8b3: 6a 00 push $0x0 10f8b5: e8 42 83 ff ff call 107bfc if (result != 0) 10f8ba: 83 c4 10 add $0x10,%esp 10f8bd: 85 c0 test %eax,%eax 10f8bf: 75 0d jne 10f8ce <== NEVER TAKEN return -1; jnode = next; 10f8c1: 89 f3 mov %esi,%ebx 10f8c3: eb be jmp 10f883 result = IMFS_unlink( NULL, &loc ); if (result != 0) return -1; jnode = next; } else if ( jnode_has_no_children( jnode ) ) { result = IMFS_unlink( NULL, &loc ); 10f8c5: 83 ec 08 sub $0x8,%esp 10f8c8: 8d 45 d4 lea -0x2c(%ebp),%eax 10f8cb: 50 push %eax 10f8cc: eb e5 jmp 10f8b3 if (result != 0) return -1; 10f8ce: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10f8d3: eb cd jmp 10f8a2 <== NOT EXECUTED =============================================================================== 0010f944 : const char *path, int pathlen, char *token, int *token_len ) { 10f944: 55 push %ebp 10f945: 89 e5 mov %esp,%ebp 10f947: 57 push %edi 10f948: 56 push %esi 10f949: 53 push %ebx 10f94a: 83 ec 1c sub $0x1c,%esp 10f94d: 8b 7d 08 mov 0x8(%ebp),%edi 10f950: 8b 5d 10 mov 0x10(%ebp),%ebx register char c; /* * Copy a name into token. (Remember NULL is a token.) */ c = path[i]; 10f953: 8a 17 mov (%edi),%dl int pathlen, char *token, int *token_len ) { register int i = 0; 10f955: 31 f6 xor %esi,%esi 10f957: 89 7d e4 mov %edi,-0x1c(%ebp) 10f95a: 89 df mov %ebx,%edi 10f95c: 88 d3 mov %dl,%bl /* * Copy a name into token. (Remember NULL is a token.) */ c = path[i]; while ( (!IMFS_is_separator(c)) && (i < pathlen) && (i <= IMFS_NAME_MAX) ) { 10f95e: eb 07 jmp 10f967 return IMFS_INVALID_TOKEN; if ( !IMFS_is_valid_name_char(c) ) type = IMFS_INVALID_TOKEN; c = path [++i]; 10f960: 46 inc %esi 10f961: 8b 45 e4 mov -0x1c(%ebp),%eax 10f964: 8a 1c 30 mov (%eax,%esi,1),%bl /* * Copy a name into token. (Remember NULL is a token.) */ c = path[i]; while ( (!IMFS_is_separator(c)) && (i < pathlen) && (i <= IMFS_NAME_MAX) ) { 10f967: 83 ec 0c sub $0xc,%esp 10f96a: 0f be c3 movsbl %bl,%eax 10f96d: 50 push %eax 10f96e: e8 a5 95 ff ff call 108f18 10f973: 83 c4 10 add $0x10,%esp 10f976: 85 c0 test %eax,%eax 10f978: 75 1a jne 10f994 10f97a: 3b 75 0c cmp 0xc(%ebp),%esi 10f97d: 7d 15 jge 10f994 token[i] = c; 10f97f: 88 1c 37 mov %bl,(%edi,%esi,1) if ( i == IMFS_NAME_MAX ) 10f982: 83 fe 20 cmp $0x20,%esi 10f985: 75 d9 jne 10f960 return IMFS_INVALID_TOKEN; 10f987: b8 04 00 00 00 mov $0x4,%eax else if ( strcmp( token, "." ) == 0 ) type = IMFS_CURRENT_DIR; } return type; } 10f98c: 8d 65 f4 lea -0xc(%ebp),%esp 10f98f: 5b pop %ebx 10f990: 5e pop %esi 10f991: 5f pop %edi 10f992: c9 leave 10f993: c3 ret 10f994: 88 da mov %bl,%dl 10f996: 89 fb mov %edi,%ebx /* * Copy a seperator into token. */ if ( i == 0 ) { 10f998: 85 f6 test %esi,%esi 10f99a: 75 25 jne 10f9c1 token[i] = c; 10f99c: 88 17 mov %dl,(%edi) if ( (token[i] != '\0') && pathlen ) { 10f99e: 84 d2 test %dl,%dl 10f9a0: 74 16 je 10f9b8 10f9a2: 8b 45 0c mov 0xc(%ebp),%eax 10f9a5: 85 c0 test %eax,%eax 10f9a7: 74 0f je 10f9b8 i++; type = IMFS_CURRENT_DIR; 10f9a9: b8 01 00 00 00 mov $0x1,%eax if ( i == 0 ) { token[i] = c; if ( (token[i] != '\0') && pathlen ) { i++; 10f9ae: be 01 00 00 00 mov $0x1,%esi 10f9b3: eb 05 jmp 10f9ba 10f9b5: 8d 76 00 lea 0x0(%esi),%esi type = IMFS_CURRENT_DIR; } else { type = IMFS_NO_MORE_PATH; 10f9b8: 31 c0 xor %eax,%eax /* * Set token_len to the number of characters copied. */ *token_len = i; 10f9ba: 8b 55 14 mov 0x14(%ebp),%edx 10f9bd: 89 32 mov %esi,(%edx) 10f9bf: eb cb jmp 10f98c i++; type = IMFS_CURRENT_DIR; } else { type = IMFS_NO_MORE_PATH; } } else if (token[ i-1 ] != '\0') { 10f9c1: 80 7c 37 ff 00 cmpb $0x0,-0x1(%edi,%esi,1) 10f9c6: 74 04 je 10f9cc <== NEVER TAKEN token[i] = '\0'; 10f9c8: c6 04 37 00 movb $0x0,(%edi,%esi,1) /* * Set token_len to the number of characters copied. */ *token_len = i; 10f9cc: 8b 45 14 mov 0x14(%ebp),%eax 10f9cf: 89 30 mov %esi,(%eax) * If we copied something that was not a seperator see if * it was a special name. */ if ( type == IMFS_NAME ) { if ( strcmp( token, "..") == 0 ) 10f9d1: bf f5 17 12 00 mov $0x1217f5,%edi 10f9d6: b9 03 00 00 00 mov $0x3,%ecx 10f9db: 89 de mov %ebx,%esi 10f9dd: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) 10f9df: 75 0f jne 10f9f0 type = IMFS_UP_DIR; 10f9e1: b8 02 00 00 00 mov $0x2,%eax else if ( strcmp( token, "." ) == 0 ) type = IMFS_CURRENT_DIR; } return type; } 10f9e6: 8d 65 f4 lea -0xc(%ebp),%esp 10f9e9: 5b pop %ebx 10f9ea: 5e pop %esi 10f9eb: 5f pop %edi 10f9ec: c9 leave 10f9ed: c3 ret 10f9ee: 66 90 xchg %ax,%ax */ if ( type == IMFS_NAME ) { if ( strcmp( token, "..") == 0 ) type = IMFS_UP_DIR; else if ( strcmp( token, "." ) == 0 ) 10f9f0: bf f6 17 12 00 mov $0x1217f6,%edi 10f9f5: b9 02 00 00 00 mov $0x2,%ecx 10f9fa: 89 de mov %ebx,%esi 10f9fc: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) 10f9fe: 0f 97 c0 seta %al 10fa01: 0f 92 c2 setb %dl 10fa04: 28 d0 sub %dl,%al 10fa06: 0f be c0 movsbl %al,%eax 10fa09: 83 f8 01 cmp $0x1,%eax 10fa0c: 19 c0 sbb %eax,%eax 10fa0e: 83 e0 fe and $0xfffffffe,%eax 10fa11: 83 c0 03 add $0x3,%eax type = IMFS_CURRENT_DIR; } return type; } 10fa14: 8d 65 f4 lea -0xc(%ebp),%esp 10fa17: 5b pop %ebx 10fa18: 5e pop %esi 10fa19: 5f pop %edi 10fa1a: c9 leave 10fa1b: c3 ret =============================================================================== 00107844 : const rtems_filesystem_operations_table *op_table, const rtems_filesystem_file_handlers_r *memfile_handlers, const rtems_filesystem_file_handlers_r *directory_handlers, const rtems_filesystem_file_handlers_r *fifo_handlers ) { 107844: 55 push %ebp 107845: 89 e5 mov %esp,%ebp 107847: 57 push %edi 107848: 56 push %esi 107849: 53 push %ebx 10784a: 83 ec 1c sub $0x1c,%esp 10784d: 8b 5d 08 mov 0x8(%ebp),%ebx IMFS_jnode_t *jnode; /* * determine/check value for imfs_memfile_bytes_per_block */ IMFS_determine_bytes_per_block(&imfs_memfile_bytes_per_block, 107850: 8b 0d 70 39 12 00 mov 0x123970,%ecx /* * check, whether requested bytes per block is valid */ for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) { if (bit_mask == requested_bytes_per_block) { 107856: 83 f9 10 cmp $0x10,%ecx 107859: 74 1f je 10787a is_valid = true; break; } if(bit_mask > requested_bytes_per_block) 10785b: 83 f9 0f cmp $0xf,%ecx 10785e: 7e 15 jle 107875 107860: ba 05 00 00 00 mov $0x5,%edx 107865: b8 20 00 00 00 mov $0x20,%eax /* * check, whether requested bytes per block is valid */ for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) { if (bit_mask == requested_bytes_per_block) { 10786a: 39 c1 cmp %eax,%ecx 10786c: 74 0c je 10787a is_valid = true; break; } if(bit_mask > requested_bytes_per_block) 10786e: 7c 05 jl 107875 <== NEVER TAKEN int bit_mask; /* * check, whether requested bytes per block is valid */ for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) { 107870: d1 e0 shl %eax 107872: 4a dec %edx 107873: 75 f5 jne 10786a <== ALWAYS TAKEN if(bit_mask > requested_bytes_per_block) break; } *dest_bytes_per_block = ((is_valid) ? requested_bytes_per_block : default_bytes_per_block); 107875: b9 80 00 00 00 mov $0x80,%ecx break; } if(bit_mask > requested_bytes_per_block) break; } *dest_bytes_per_block = ((is_valid) 10787a: 89 0d e0 78 12 00 mov %ecx,0x1278e0 /* * Create the root node * * NOTE: UNIX root is 755 and owned by root/root (0/0). */ temp_mt_entry->mt_fs_root.node_access = IMFS_create_root_node(); 107880: e8 2f 78 00 00 call 10f0b4 107885: 89 c2 mov %eax,%edx 107887: 89 43 1c mov %eax,0x1c(%ebx) temp_mt_entry->mt_fs_root.handlers = directory_handlers; 10788a: 8b 45 14 mov 0x14(%ebp),%eax 10788d: 89 43 24 mov %eax,0x24(%ebx) temp_mt_entry->mt_fs_root.ops = op_table; 107890: 8b 45 0c mov 0xc(%ebp),%eax 107893: 89 43 28 mov %eax,0x28(%ebx) temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS; 107896: 8d 7b 38 lea 0x38(%ebx),%edi 107899: be a0 17 12 00 mov $0x1217a0,%esi 10789e: b9 0c 00 00 00 mov $0xc,%ecx 1078a3: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* * Create custom file system data. */ fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) ); 1078a5: 83 ec 08 sub $0x8,%esp 1078a8: 6a 14 push $0x14 1078aa: 6a 01 push $0x1 1078ac: 89 55 e4 mov %edx,-0x1c(%ebp) 1078af: e8 70 06 00 00 call 107f24 if ( !fs_info ) { 1078b4: 83 c4 10 add $0x10,%esp 1078b7: 85 c0 test %eax,%eax 1078b9: 8b 55 e4 mov -0x1c(%ebp),%edx 1078bc: 74 3c je 1078fa free(temp_mt_entry->mt_fs_root.node_access); rtems_set_errno_and_return_minus_one(ENOMEM); } temp_mt_entry->fs_info = fs_info; 1078be: 89 43 34 mov %eax,0x34(%ebx) /* * Set st_ino for the root to 1. */ fs_info->instance = imfs_instance++; 1078c1: 8b 0d e4 78 12 00 mov 0x1278e4,%ecx 1078c7: 89 08 mov %ecx,(%eax) 1078c9: 41 inc %ecx 1078ca: 89 0d e4 78 12 00 mov %ecx,0x1278e4 fs_info->ino_count = 1; 1078d0: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax) fs_info->memfile_handlers = memfile_handlers; 1078d7: 8b 4d 10 mov 0x10(%ebp),%ecx 1078da: 89 48 08 mov %ecx,0x8(%eax) fs_info->directory_handlers = directory_handlers; 1078dd: 8b 4d 14 mov 0x14(%ebp),%ecx 1078e0: 89 48 0c mov %ecx,0xc(%eax) fs_info->fifo_handlers = fifo_handlers; 1078e3: 8b 4d 18 mov 0x18(%ebp),%ecx 1078e6: 89 48 10 mov %ecx,0x10(%eax) jnode = temp_mt_entry->mt_fs_root.node_access; jnode->st_ino = fs_info->ino_count; 1078e9: c7 42 38 01 00 00 00 movl $0x1,0x38(%edx) return 0; 1078f0: 31 c0 xor %eax,%eax } 1078f2: 8d 65 f4 lea -0xc(%ebp),%esp 1078f5: 5b pop %ebx 1078f6: 5e pop %esi 1078f7: 5f pop %edi 1078f8: c9 leave 1078f9: c3 ret /* * Create custom file system data. */ fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) ); if ( !fs_info ) { free(temp_mt_entry->mt_fs_root.node_access); 1078fa: 83 ec 0c sub $0xc,%esp 1078fd: 52 push %edx 1078fe: e8 b1 07 00 00 call 1080b4 rtems_set_errno_and_return_minus_one(ENOMEM); 107903: e8 68 b9 00 00 call 113270 <__errno> 107908: c7 00 0c 00 00 00 movl $0xc,(%eax) 10790e: 83 c4 10 add $0x10,%esp 107911: 83 c8 ff or $0xffffffff,%eax 107914: eb dc jmp 1078f2 =============================================================================== 00107918 : int IMFS_link( rtems_filesystem_location_info_t *to_loc, /* IN */ rtems_filesystem_location_info_t *parent_loc, /* IN */ const char *token /* IN */ ) { 107918: 55 push %ebp 107919: 89 e5 mov %esp,%ebp 10791b: 57 push %edi 10791c: 53 push %ebx 10791d: 83 ec 50 sub $0x50,%esp 107920: 8b 55 10 mov 0x10(%ebp),%edx int i; /* * Verify this node can be linked to. */ info.hard_link.link_node = to_loc->node_access; 107923: 8b 45 08 mov 0x8(%ebp),%eax 107926: 8b 00 mov (%eax),%eax 107928: 89 45 d8 mov %eax,-0x28(%ebp) if ( info.hard_link.link_node->st_nlink >= LINK_MAX ) 10792b: 66 83 78 34 07 cmpw $0x7,0x34(%eax) 107930: 77 66 ja 107998 rtems_set_errno_and_return_minus_one( EMLINK ); /* * Remove any separators at the end of the string. */ IMFS_get_token( token, strlen( token ), new_name, &i ); 107932: 31 c0 xor %eax,%eax 107934: b9 ff ff ff ff mov $0xffffffff,%ecx 107939: 89 d7 mov %edx,%edi 10793b: f2 ae repnz scas %es:(%edi),%al 10793d: f7 d1 not %ecx 10793f: 49 dec %ecx 107940: 8d 45 f4 lea -0xc(%ebp),%eax 107943: 50 push %eax 107944: 8d 5d b7 lea -0x49(%ebp),%ebx 107947: 53 push %ebx 107948: 51 push %ecx 107949: 52 push %edx 10794a: e8 f5 7f 00 00 call 10f944 new_node = IMFS_create_node( parent_loc, IMFS_HARD_LINK, new_name, ( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )), &info 10794f: 8d 45 d8 lea -0x28(%ebp),%eax * was ONLY passed a NULL when we created the root node. We * added a new IMFS_create_root_node() so this path no longer * existed. The result was simpler code which should not have * this path. */ new_node = IMFS_create_node( 107952: 89 04 24 mov %eax,(%esp) 107955: 68 ff a1 00 00 push $0xa1ff 10795a: 53 push %ebx 10795b: 6a 03 push $0x3 10795d: ff 75 0c pushl 0xc(%ebp) 107960: e8 17 76 00 00 call 10ef7c new_name, ( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )), &info ); if ( !new_node ) 107965: 83 c4 20 add $0x20,%esp 107968: 85 c0 test %eax,%eax 10796a: 74 3e je 1079aa rtems_set_errno_and_return_minus_one( ENOMEM ); /* * Increment the link count of the node being pointed to. */ info.hard_link.link_node->st_nlink++; 10796c: 8b 45 d8 mov -0x28(%ebp),%eax 10796f: 66 ff 40 34 incw 0x34(%eax) IMFS_update_ctime( info.hard_link.link_node ); 107973: 83 ec 08 sub $0x8,%esp 107976: 6a 00 push $0x0 107978: 8d 45 ec lea -0x14(%ebp),%eax 10797b: 50 push %eax 10797c: e8 af 07 00 00 call 108130 107981: 8b 55 ec mov -0x14(%ebp),%edx 107984: 8b 45 d8 mov -0x28(%ebp),%eax 107987: 89 50 48 mov %edx,0x48(%eax) return 0; 10798a: 83 c4 10 add $0x10,%esp 10798d: 31 c0 xor %eax,%eax } 10798f: 8d 65 f8 lea -0x8(%ebp),%esp 107992: 5b pop %ebx 107993: 5f pop %edi 107994: c9 leave 107995: c3 ret 107996: 66 90 xchg %ax,%ax /* * Verify this node can be linked to. */ info.hard_link.link_node = to_loc->node_access; if ( info.hard_link.link_node->st_nlink >= LINK_MAX ) rtems_set_errno_and_return_minus_one( EMLINK ); 107998: e8 d3 b8 00 00 call 113270 <__errno> 10799d: c7 00 1f 00 00 00 movl $0x1f,(%eax) 1079a3: b8 ff ff ff ff mov $0xffffffff,%eax 1079a8: eb e5 jmp 10798f ( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )), &info ); if ( !new_node ) rtems_set_errno_and_return_minus_one( ENOMEM ); 1079aa: e8 c1 b8 00 00 call 113270 <__errno> 1079af: c7 00 0c 00 00 00 movl $0xc,(%eax) 1079b5: b8 ff ff ff ff mov $0xffffffff,%eax 1079ba: eb d3 jmp 10798f =============================================================================== 00111dc8 : */ MEMFILE_STATIC int IMFS_memfile_addblock( IMFS_jnode_t *the_jnode, unsigned int block ) { 111dc8: 55 push %ebp 111dc9: 89 e5 mov %esp,%ebp 111dcb: 53 push %ebx 111dcc: 83 ec 08 sub $0x8,%esp IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE ); /* * Obtain the pointer for the specified block number */ block_entry_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 1 ); 111dcf: 6a 01 push $0x1 111dd1: ff 75 0c pushl 0xc(%ebp) 111dd4: ff 75 08 pushl 0x8(%ebp) 111dd7: e8 28 fc ff ff call 111a04 111ddc: 89 c3 mov %eax,%ebx if ( *block_entry_ptr ) 111dde: 83 c4 10 add $0x10,%esp 111de1: 8b 00 mov (%eax),%eax 111de3: 85 c0 test %eax,%eax 111de5: 74 09 je 111df0 return 0; 111de7: 31 c0 xor %eax,%eax if ( !memory ) return 1; *block_entry_ptr = memory; return 0; } 111de9: 8b 5d fc mov -0x4(%ebp),%ebx 111dec: c9 leave 111ded: c3 ret 111dee: 66 90 xchg %ax,%ax return 0; /* * There is no memory for this block number so allocate it. */ memory = memfile_alloc_block(); 111df0: e8 eb fb ff ff call 1119e0 if ( !memory ) 111df5: 85 c0 test %eax,%eax 111df7: 74 07 je 111e00 return 1; *block_entry_ptr = memory; 111df9: 89 03 mov %eax,(%ebx) return 0; 111dfb: 31 c0 xor %eax,%eax 111dfd: eb ea jmp 111de9 111dff: 90 nop /* * There is no memory for this block number so allocate it. */ memory = memfile_alloc_block(); if ( !memory ) return 1; 111e00: b8 01 00 00 00 mov $0x1,%eax 111e05: eb e2 jmp 111de9 =============================================================================== 00112008 : */ MEMFILE_STATIC int IMFS_memfile_extend( IMFS_jnode_t *the_jnode, off_t new_length ) { 112008: 55 push %ebp 112009: 89 e5 mov %esp,%ebp 11200b: 57 push %edi 11200c: 56 push %esi 11200d: 53 push %ebx 11200e: 83 ec 2c sub $0x2c,%esp 112011: 8b 5d 08 mov 0x8(%ebp),%ebx 112014: 8b 45 0c mov 0xc(%ebp),%eax 112017: 8b 55 10 mov 0x10(%ebp),%edx 11201a: 89 45 d8 mov %eax,-0x28(%ebp) 11201d: 89 55 dc mov %edx,-0x24(%ebp) IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE ); /* * Verify new file size is supported */ if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE ) 112020: a1 e0 78 12 00 mov 0x1278e0,%eax 112025: 89 c1 mov %eax,%ecx 112027: c1 e9 02 shr $0x2,%ecx 11202a: 8d 51 01 lea 0x1(%ecx),%edx 11202d: 0f af d1 imul %ecx,%edx 112030: 42 inc %edx 112031: 0f af d1 imul %ecx,%edx 112034: 4a dec %edx 112035: 0f af d0 imul %eax,%edx 112038: 31 c9 xor %ecx,%ecx 11203a: 3b 4d dc cmp -0x24(%ebp),%ecx 11203d: 7f 1a jg 112059 <== NEVER TAKEN 11203f: 7d 13 jge 112054 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); 112041: e8 2a 12 00 00 call 113270 <__errno> 112046: c7 00 16 00 00 00 movl $0x16,(%eax) 11204c: b8 ff ff ff ff mov $0xffffffff,%eax 112051: eb 19 jmp 11206c 112053: 90 nop IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE ); /* * Verify new file size is supported */ if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE ) 112054: 3b 55 d8 cmp -0x28(%ebp),%edx 112057: 76 e8 jbe 112041 rtems_set_errno_and_return_minus_one( EINVAL ); /* * Verify new file size is actually larger than current size */ if ( new_length <= the_jnode->info.file.size ) 112059: 8b 53 50 mov 0x50(%ebx),%edx 11205c: 8b 4b 54 mov 0x54(%ebx),%ecx 11205f: 89 55 e0 mov %edx,-0x20(%ebp) 112062: 89 4d e4 mov %ecx,-0x1c(%ebp) 112065: 39 4d dc cmp %ecx,-0x24(%ebp) 112068: 7d 0a jge 112074 <== ALWAYS TAKEN return 0; 11206a: 31 c0 xor %eax,%eax /* * Set the new length of the file. */ the_jnode->info.file.size = new_length; return 0; } 11206c: 8d 65 f4 lea -0xc(%ebp),%esp 11206f: 5b pop %ebx 112070: 5e pop %esi 112071: 5f pop %edi 112072: c9 leave 112073: c3 ret rtems_set_errno_and_return_minus_one( EINVAL ); /* * Verify new file size is actually larger than current size */ if ( new_length <= the_jnode->info.file.size ) 112074: 7f 05 jg 11207b <== NEVER TAKEN 112076: 39 55 d8 cmp %edx,-0x28(%ebp) 112079: 76 ef jbe 11206a return 0; /* * Calculate the number of range of blocks to allocate */ new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK; 11207b: 89 45 d0 mov %eax,-0x30(%ebp) 11207e: 89 c1 mov %eax,%ecx 112080: c1 f9 1f sar $0x1f,%ecx 112083: 89 4d d4 mov %ecx,-0x2c(%ebp) 112086: ff 75 d4 pushl -0x2c(%ebp) 112089: ff 75 d0 pushl -0x30(%ebp) 11208c: ff 75 dc pushl -0x24(%ebp) 11208f: ff 75 d8 pushl -0x28(%ebp) 112092: e8 d9 c9 00 00 call 11ea70 <__divdi3> 112097: 83 c4 10 add $0x10,%esp 11209a: 89 c6 mov %eax,%esi old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK; 11209c: ff 75 d4 pushl -0x2c(%ebp) 11209f: ff 75 d0 pushl -0x30(%ebp) 1120a2: ff 75 e4 pushl -0x1c(%ebp) 1120a5: ff 75 e0 pushl -0x20(%ebp) 1120a8: e8 c3 c9 00 00 call 11ea70 <__divdi3> 1120ad: 83 c4 10 add $0x10,%esp 1120b0: 89 45 e0 mov %eax,-0x20(%ebp) /* * Now allocate each of those blocks. */ for ( block=old_blocks ; block<=new_blocks ; block++ ) { 1120b3: 39 c6 cmp %eax,%esi 1120b5: 72 51 jb 112108 <== NEVER TAKEN 1120b7: 89 c7 mov %eax,%edi 1120b9: eb 06 jmp 1120c1 1120bb: 90 nop 1120bc: 47 inc %edi 1120bd: 39 fe cmp %edi,%esi 1120bf: 72 47 jb 112108 if ( IMFS_memfile_addblock( the_jnode, block ) ) { 1120c1: 83 ec 08 sub $0x8,%esp 1120c4: 57 push %edi 1120c5: 53 push %ebx 1120c6: e8 fd fc ff ff call 111dc8 1120cb: 83 c4 10 add $0x10,%esp 1120ce: 85 c0 test %eax,%eax 1120d0: 74 ea je 1120bc for ( ; block>=old_blocks ; block-- ) { 1120d2: 39 7d e0 cmp %edi,-0x20(%ebp) 1120d5: 77 17 ja 1120ee <== NEVER TAKEN 1120d7: 8b 75 e0 mov -0x20(%ebp),%esi 1120da: 66 90 xchg %ax,%ax IMFS_memfile_remove_block( the_jnode, block ); 1120dc: 83 ec 08 sub $0x8,%esp 1120df: 57 push %edi 1120e0: 53 push %ebx 1120e1: e8 f6 fe ff ff call 111fdc /* * Now allocate each of those blocks. */ for ( block=old_blocks ; block<=new_blocks ; block++ ) { if ( IMFS_memfile_addblock( the_jnode, block ) ) { for ( ; block>=old_blocks ; block-- ) { 1120e6: 4f dec %edi 1120e7: 83 c4 10 add $0x10,%esp 1120ea: 39 fe cmp %edi,%esi 1120ec: 76 ee jbe 1120dc IMFS_memfile_remove_block( the_jnode, block ); } rtems_set_errno_and_return_minus_one( ENOSPC ); 1120ee: e8 7d 11 00 00 call 113270 <__errno> 1120f3: c7 00 1c 00 00 00 movl $0x1c,(%eax) 1120f9: b8 ff ff ff ff mov $0xffffffff,%eax /* * Set the new length of the file. */ the_jnode->info.file.size = new_length; return 0; } 1120fe: 8d 65 f4 lea -0xc(%ebp),%esp 112101: 5b pop %ebx 112102: 5e pop %esi 112103: 5f pop %edi 112104: c9 leave 112105: c3 ret 112106: 66 90 xchg %ax,%ax } /* * Set the new length of the file. */ the_jnode->info.file.size = new_length; 112108: 8b 45 d8 mov -0x28(%ebp),%eax 11210b: 8b 55 dc mov -0x24(%ebp),%edx 11210e: 89 43 50 mov %eax,0x50(%ebx) 112111: 89 53 54 mov %edx,0x54(%ebx) return 0; 112114: 31 c0 xor %eax,%eax } 112116: 8d 65 f4 lea -0xc(%ebp),%esp 112119: 5b pop %ebx 11211a: 5e pop %esi 11211b: 5f pop %edi 11211c: c9 leave 11211d: c3 ret =============================================================================== 00111a04 : #endif IMFS_jnode_t *the_jnode, unsigned int block, int malloc_it ) { 111a04: 55 push %ebp 111a05: 89 e5 mov %esp,%ebp 111a07: 57 push %edi 111a08: 56 push %esi 111a09: 53 push %ebx 111a0a: 83 ec 1c sub $0x1c,%esp 111a0d: 8b 5d 08 mov 0x8(%ebp),%ebx 111a10: 8b 75 0c mov 0xc(%ebp),%esi 111a13: 8b 7d 10 mov 0x10(%ebp),%edi my_block = block; /* * Is the block number in the simple indirect portion? */ if ( my_block <= LAST_INDIRECT ) { 111a16: 8b 0d e0 78 12 00 mov 0x1278e0,%ecx 111a1c: c1 e9 02 shr $0x2,%ecx 111a1f: 8d 41 ff lea -0x1(%ecx),%eax 111a22: 39 c6 cmp %eax,%esi 111a24: 77 1a ja 111a40 p = info->indirect; 111a26: 8b 43 58 mov 0x58(%ebx),%eax if ( malloc_it ) { 111a29: 85 ff test %edi,%edi 111a2b: 74 53 je 111a80 if ( !p ) { 111a2d: 85 c0 test %eax,%eax 111a2f: 0f 84 b6 00 00 00 je 111aeb } if ( !p ) return 0; return &info->indirect[ my_block ]; 111a35: 8d 04 b0 lea (%eax,%esi,4),%eax /* * This means the requested block number is out of range. */ return 0; } 111a38: 83 c4 1c add $0x1c,%esp 111a3b: 5b pop %ebx 111a3c: 5e pop %esi 111a3d: 5f pop %edi 111a3e: c9 leave 111a3f: c3 ret /* * Is the block number in the doubly indirect portion? */ if ( my_block <= LAST_DOUBLY_INDIRECT ) { 111a40: 8d 41 01 lea 0x1(%ecx),%eax 111a43: 0f af c1 imul %ecx,%eax 111a46: 8d 50 ff lea -0x1(%eax),%edx 111a49: 39 d6 cmp %edx,%esi 111a4b: 77 3b ja 111a88 my_block -= FIRST_DOUBLY_INDIRECT; 111a4d: 29 ce sub %ecx,%esi singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS; 111a4f: 89 f0 mov %esi,%eax 111a51: 31 d2 xor %edx,%edx 111a53: f7 f1 div %ecx 111a55: 89 c6 mov %eax,%esi doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS; p = info->doubly_indirect; 111a57: 8b 43 5c mov 0x5c(%ebx),%eax if ( malloc_it ) { 111a5a: 85 ff test %edi,%edi 111a5c: 74 7e je 111adc if ( !p ) { 111a5e: 85 c0 test %eax,%eax 111a60: 0f 84 96 00 00 00 je 111afc if ( !p ) return 0; info->doubly_indirect = p; } p1 = (block_p *)p[ doubly ]; 111a66: 8d 1c b0 lea (%eax,%esi,4),%ebx 111a69: 8b 03 mov (%ebx),%eax if ( !p1 ) { 111a6b: 85 c0 test %eax,%eax 111a6d: 0f 84 a4 00 00 00 je 111b17 p = (block_p *)p[ doubly ]; if ( !p ) return 0; return (block_p *)&p[ singly ]; 111a73: 8d 04 90 lea (%eax,%edx,4),%eax /* * This means the requested block number is out of range. */ return 0; } 111a76: 83 c4 1c add $0x1c,%esp 111a79: 5b pop %ebx 111a7a: 5e pop %esi 111a7b: 5f pop %edi 111a7c: c9 leave 111a7d: c3 ret 111a7e: 66 90 xchg %ax,%ax info->indirect = p; } return &info->indirect[ my_block ]; } if ( !p ) 111a80: 85 c0 test %eax,%eax 111a82: 75 b1 jne 111a35 <== ALWAYS TAKEN if ( !p ) return 0; p1 = (block_p *) p[ triply ]; if ( !p1 ) return 0; 111a84: 31 c0 xor %eax,%eax 111a86: eb ee jmp 111a76 <== NOT EXECUTED } /* * Is the block number in the triply indirect portion? */ if ( my_block <= LAST_TRIPLY_INDIRECT ) { 111a88: 8d 50 01 lea 0x1(%eax),%edx 111a8b: 0f af d1 imul %ecx,%edx 111a8e: 4a dec %edx 111a8f: 39 d6 cmp %edx,%esi 111a91: 77 f1 ja 111a84 <== NEVER TAKEN my_block -= FIRST_TRIPLY_INDIRECT; 111a93: 29 c6 sub %eax,%esi 111a95: 89 f0 mov %esi,%eax singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS; 111a97: 31 d2 xor %edx,%edx 111a99: f7 f1 div %ecx 111a9b: 89 55 e4 mov %edx,-0x1c(%ebp) doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS; triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS; 111a9e: 31 d2 xor %edx,%edx 111aa0: f7 f1 div %ecx 111aa2: 89 c6 mov %eax,%esi doubly %= IMFS_MEMFILE_BLOCK_SLOTS; p = info->triply_indirect; 111aa4: 8b 4b 60 mov 0x60(%ebx),%ecx if ( malloc_it ) { 111aa7: 85 ff test %edi,%edi 111aa9: 0f 84 82 00 00 00 je 111b31 if ( !p ) { 111aaf: 85 c9 test %ecx,%ecx 111ab1: 0f 84 9b 00 00 00 je 111b52 if ( !p ) return 0; info->triply_indirect = p; } p1 = (block_p *) p[ triply ]; 111ab7: 8d 1c b1 lea (%ecx,%esi,4),%ebx 111aba: 8b 0b mov (%ebx),%ecx if ( !p1 ) { 111abc: 85 c9 test %ecx,%ecx 111abe: 0f 84 c5 00 00 00 je 111b89 if ( !p1 ) return 0; p[ triply ] = (block_p) p1; } p2 = (block_p *)p1[ doubly ]; 111ac4: 8d 1c 91 lea (%ecx,%edx,4),%ebx 111ac7: 8b 13 mov (%ebx),%edx if ( !p2 ) { 111ac9: 85 d2 test %edx,%edx 111acb: 0f 84 a0 00 00 00 je 111b71 p2 = (block_p *)p1[ doubly ]; if ( !p2 ) return 0; return (block_p *)&p2[ singly ]; 111ad1: 8b 4d e4 mov -0x1c(%ebp),%ecx 111ad4: 8d 04 8a lea (%edx,%ecx,4),%eax 111ad7: eb 9d jmp 111a76 111ad9: 8d 76 00 lea 0x0(%esi),%esi } return (block_p *)&p1[ singly ]; } if ( !p ) 111adc: 85 c0 test %eax,%eax 111ade: 74 a4 je 111a84 <== NEVER TAKEN return 0; p = (block_p *)p[ doubly ]; 111ae0: 8b 04 b0 mov (%eax,%esi,4),%eax if ( !p ) 111ae3: 85 c0 test %eax,%eax 111ae5: 75 8c jne 111a73 <== ALWAYS TAKEN if ( !p ) return 0; p1 = (block_p *) p[ triply ]; if ( !p1 ) return 0; 111ae7: 31 c0 xor %eax,%eax 111ae9: eb 8b jmp 111a76 <== NOT EXECUTED p = info->indirect; if ( malloc_it ) { if ( !p ) { p = memfile_alloc_block(); 111aeb: e8 f0 fe ff ff call 1119e0 if ( !p ) 111af0: 85 c0 test %eax,%eax 111af2: 74 90 je 111a84 <== NEVER TAKEN return 0; info->indirect = p; 111af4: 89 43 58 mov %eax,0x58(%ebx) 111af7: e9 39 ff ff ff jmp 111a35 p = info->doubly_indirect; if ( malloc_it ) { if ( !p ) { p = memfile_alloc_block(); 111afc: 89 55 e0 mov %edx,-0x20(%ebp) 111aff: e8 dc fe ff ff call 1119e0 if ( !p ) 111b04: 85 c0 test %eax,%eax 111b06: 8b 55 e0 mov -0x20(%ebp),%edx 111b09: 0f 84 75 ff ff ff je 111a84 <== NEVER TAKEN return 0; info->doubly_indirect = p; 111b0f: 89 43 5c mov %eax,0x5c(%ebx) 111b12: e9 4f ff ff ff jmp 111a66 } p1 = (block_p *)p[ doubly ]; if ( !p1 ) { p1 = memfile_alloc_block(); 111b17: 89 55 e0 mov %edx,-0x20(%ebp) 111b1a: e8 c1 fe ff ff call 1119e0 if ( !p1 ) 111b1f: 85 c0 test %eax,%eax 111b21: 8b 55 e0 mov -0x20(%ebp),%edx 111b24: 0f 84 5a ff ff ff je 111a84 <== NEVER TAKEN return 0; p[ doubly ] = (block_p) p1; 111b2a: 89 03 mov %eax,(%ebx) 111b2c: e9 42 ff ff ff jmp 111a73 p1[ doubly ] = (block_p) p2; } return (block_p *)&p2[ singly ]; } if ( !p ) 111b31: 85 c9 test %ecx,%ecx 111b33: 0f 84 4b ff ff ff je 111a84 <== NEVER TAKEN return 0; p1 = (block_p *) p[ triply ]; 111b39: 8b 04 81 mov (%ecx,%eax,4),%eax if ( !p1 ) 111b3c: 85 c0 test %eax,%eax 111b3e: 0f 84 40 ff ff ff je 111a84 <== NEVER TAKEN return 0; p2 = (block_p *)p1[ doubly ]; 111b44: 8b 14 90 mov (%eax,%edx,4),%edx if ( !p2 ) return 0; 111b47: 31 c0 xor %eax,%eax p1 = (block_p *) p[ triply ]; if ( !p1 ) return 0; p2 = (block_p *)p1[ doubly ]; if ( !p2 ) 111b49: 85 d2 test %edx,%edx 111b4b: 75 84 jne 111ad1 <== ALWAYS TAKEN 111b4d: e9 24 ff ff ff jmp 111a76 <== NOT EXECUTED p = info->triply_indirect; if ( malloc_it ) { if ( !p ) { p = memfile_alloc_block(); 111b52: 89 55 e0 mov %edx,-0x20(%ebp) 111b55: e8 86 fe ff ff call 1119e0 111b5a: 89 c1 mov %eax,%ecx if ( !p ) return 0; 111b5c: 31 c0 xor %eax,%eax p = info->triply_indirect; if ( malloc_it ) { if ( !p ) { p = memfile_alloc_block(); if ( !p ) 111b5e: 85 c9 test %ecx,%ecx 111b60: 8b 55 e0 mov -0x20(%ebp),%edx 111b63: 0f 84 0d ff ff ff je 111a76 <== NEVER TAKEN return 0; info->triply_indirect = p; 111b69: 89 4b 60 mov %ecx,0x60(%ebx) 111b6c: e9 46 ff ff ff jmp 111ab7 p[ triply ] = (block_p) p1; } p2 = (block_p *)p1[ doubly ]; if ( !p2 ) { p2 = memfile_alloc_block(); 111b71: e8 6a fe ff ff call 1119e0 111b76: 89 c2 mov %eax,%edx if ( !p2 ) return 0; 111b78: 31 c0 xor %eax,%eax } p2 = (block_p *)p1[ doubly ]; if ( !p2 ) { p2 = memfile_alloc_block(); if ( !p2 ) 111b7a: 85 d2 test %edx,%edx 111b7c: 0f 84 f4 fe ff ff je 111a76 <== NEVER TAKEN return 0; p1[ doubly ] = (block_p) p2; 111b82: 89 13 mov %edx,(%ebx) 111b84: e9 48 ff ff ff jmp 111ad1 info->triply_indirect = p; } p1 = (block_p *) p[ triply ]; if ( !p1 ) { p1 = memfile_alloc_block(); 111b89: 89 55 e0 mov %edx,-0x20(%ebp) 111b8c: e8 4f fe ff ff call 1119e0 111b91: 89 c1 mov %eax,%ecx if ( !p1 ) return 0; 111b93: 31 c0 xor %eax,%eax } p1 = (block_p *) p[ triply ]; if ( !p1 ) { p1 = memfile_alloc_block(); if ( !p1 ) 111b95: 85 c9 test %ecx,%ecx 111b97: 8b 55 e0 mov -0x20(%ebp),%edx 111b9a: 0f 84 d6 fe ff ff je 111a76 <== NEVER TAKEN return 0; p[ triply ] = (block_p) p1; 111ba0: 89 0b mov %ecx,(%ebx) 111ba2: e9 1d ff ff ff jmp 111ac4 =============================================================================== 00111ba8 : IMFS_jnode_t *the_jnode, off_t start, unsigned char *destination, unsigned int length ) { 111ba8: 55 push %ebp 111ba9: 89 e5 mov %esp,%ebp 111bab: 57 push %edi 111bac: 56 push %esi 111bad: 53 push %ebx 111bae: 83 ec 3c sub $0x3c,%esp 111bb1: 8b 75 0c mov 0xc(%ebp),%esi 111bb4: 8b 7d 10 mov 0x10(%ebp),%edi * Linear files (as created from a tar file are easier to handle * than block files). */ my_length = length; if (the_jnode->type == IMFS_LINEAR_FILE) { 111bb7: 8b 45 08 mov 0x8(%ebp),%eax 111bba: 83 78 4c 06 cmpl $0x6,0x4c(%eax) 111bbe: 0f 84 60 01 00 00 je 111d24 <== NEVER TAKEN /* * If the last byte we are supposed to read is past the end of this * in memory file, then shorten the length to read. */ last_byte = start + length; 111bc4: 89 f0 mov %esi,%eax if ( last_byte > the_jnode->info.file.size ) 111bc6: 8b 55 08 mov 0x8(%ebp),%edx 111bc9: 8b 4a 50 mov 0x50(%edx),%ecx /* * If the last byte we are supposed to read is past the end of this * in memory file, then shorten the length to read. */ last_byte = start + length; 111bcc: 8b 5d 18 mov 0x18(%ebp),%ebx 111bcf: 01 f3 add %esi,%ebx 111bd1: 89 5d d0 mov %ebx,-0x30(%ebp) if ( last_byte > the_jnode->info.file.size ) 111bd4: 31 d2 xor %edx,%edx 111bd6: 8b 5d 08 mov 0x8(%ebp),%ebx 111bd9: 3b 53 54 cmp 0x54(%ebx),%edx 111bdc: 0f 8d d2 00 00 00 jge 111cb4 <== ALWAYS TAKEN /* * Linear files (as created from a tar file are easier to handle * than block files). */ my_length = length; 111be2: 8b 45 18 mov 0x18(%ebp),%eax 111be5: 89 45 cc mov %eax,-0x34(%ebp) */ /* * Phase 1: possibly the last part of one block */ start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK; 111be8: 8b 15 e0 78 12 00 mov 0x1278e0,%edx 111bee: 89 55 d0 mov %edx,-0x30(%ebp) 111bf1: 89 d0 mov %edx,%eax 111bf3: 99 cltd 111bf4: 89 d3 mov %edx,%ebx 111bf6: 52 push %edx 111bf7: 50 push %eax 111bf8: 57 push %edi 111bf9: 56 push %esi 111bfa: 89 45 c0 mov %eax,-0x40(%ebp) 111bfd: e8 ba cf 00 00 call 11ebbc <__moddi3> 111c02: 83 c4 10 add $0x10,%esp 111c05: 89 45 c8 mov %eax,-0x38(%ebp) block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; 111c08: 8b 4d c0 mov -0x40(%ebp),%ecx 111c0b: 53 push %ebx 111c0c: 51 push %ecx 111c0d: 57 push %edi 111c0e: 56 push %esi 111c0f: e8 5c ce 00 00 call 11ea70 <__divdi3> 111c14: 83 c4 10 add $0x10,%esp 111c17: 89 c3 mov %eax,%ebx if ( start_offset ) { 111c19: 8b 7d c8 mov -0x38(%ebp),%edi 111c1c: 85 ff test %edi,%edi 111c1e: 0f 84 a0 00 00 00 je 111cc4 to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset; if ( to_copy > my_length ) to_copy = my_length; block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 111c24: 56 push %esi 111c25: 6a 00 push $0x0 111c27: 50 push %eax 111c28: ff 75 08 pushl 0x8(%ebp) 111c2b: e8 d4 fd ff ff call 111a04 if ( !block_ptr ) 111c30: 83 c4 10 add $0x10,%esp 111c33: 85 c0 test %eax,%eax 111c35: 0f 84 65 01 00 00 je 111da0 <== NEVER TAKEN * Phase 1: possibly the last part of one block */ start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK; block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; if ( start_offset ) { to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset; 111c3b: 8b 4d d0 mov -0x30(%ebp),%ecx 111c3e: 2b 4d c8 sub -0x38(%ebp),%ecx 111c41: 8b 55 cc mov -0x34(%ebp),%edx 111c44: 39 ca cmp %ecx,%edx 111c46: 0f 87 3c 01 00 00 ja 111d88 if ( to_copy > my_length ) to_copy = my_length; block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); if ( !block_ptr ) return copied; memcpy( dest, &(*block_ptr)[ start_offset ], to_copy ); 111c4c: 8b 75 c8 mov -0x38(%ebp),%esi 111c4f: 03 30 add (%eax),%esi dest += to_copy; 111c51: 8b 7d 14 mov 0x14(%ebp),%edi 111c54: 89 d1 mov %edx,%ecx 111c56: f3 a4 rep movsb %ds:(%esi),%es:(%edi) 111c58: 89 7d c8 mov %edi,-0x38(%ebp) block++; 111c5b: 43 inc %ebx my_length -= to_copy; 111c5c: 29 55 cc sub %edx,-0x34(%ebp) 111c5f: a1 e0 78 12 00 mov 0x1278e0,%eax 111c64: 89 45 d0 mov %eax,-0x30(%ebp) copied += to_copy; 111c67: 89 55 c4 mov %edx,-0x3c(%ebp) /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { 111c6a: 8b 4d d0 mov -0x30(%ebp),%ecx 111c6d: 39 4d cc cmp %ecx,-0x34(%ebp) 111c70: 73 24 jae 111c96 111c72: eb 60 jmp 111cd4 block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); if ( !block_ptr ) return copied; memcpy( dest, &(*block_ptr)[ 0 ], to_copy ); 111c74: 8b 30 mov (%eax),%esi 111c76: 8b 7d c8 mov -0x38(%ebp),%edi 111c79: 8b 4d d0 mov -0x30(%ebp),%ecx 111c7c: f3 a4 rep movsb %ds:(%esi),%es:(%edi) dest += to_copy; 111c7e: 89 7d c8 mov %edi,-0x38(%ebp) block++; 111c81: 43 inc %ebx my_length -= to_copy; 111c82: 8b 7d d0 mov -0x30(%ebp),%edi 111c85: 29 7d cc sub %edi,-0x34(%ebp) copied += to_copy; 111c88: 01 7d c4 add %edi,-0x3c(%ebp) /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { 111c8b: 8b 45 cc mov -0x34(%ebp),%eax 111c8e: 39 05 e0 78 12 00 cmp %eax,0x1278e0 111c94: 77 3e ja 111cd4 block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 111c96: 51 push %ecx 111c97: 6a 00 push $0x0 111c99: 53 push %ebx 111c9a: ff 75 08 pushl 0x8(%ebp) 111c9d: e8 62 fd ff ff call 111a04 if ( !block_ptr ) 111ca2: 83 c4 10 add $0x10,%esp 111ca5: 85 c0 test %eax,%eax 111ca7: 75 cb jne 111c74 <== ALWAYS TAKEN IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK ); if ( my_length ) { block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); if ( !block_ptr ) return copied; 111ca9: 8b 45 c4 mov -0x3c(%ebp),%eax <== NOT EXECUTED } IMFS_update_atime( the_jnode ); return copied; } 111cac: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 111caf: 5b pop %ebx <== NOT EXECUTED 111cb0: 5e pop %esi <== NOT EXECUTED 111cb1: 5f pop %edi <== NOT EXECUTED 111cb2: c9 leave <== NOT EXECUTED 111cb3: c3 ret <== NOT EXECUTED /* * If the last byte we are supposed to read is past the end of this * in memory file, then shorten the length to read. */ last_byte = start + length; if ( last_byte > the_jnode->info.file.size ) 111cb4: 0f 8e be 00 00 00 jle 111d78 <== ALWAYS TAKEN my_length = the_jnode->info.file.size - start; 111cba: 29 c1 sub %eax,%ecx 111cbc: 89 4d cc mov %ecx,-0x34(%ebp) 111cbf: e9 24 ff ff ff jmp 111be8 unsigned int last_byte; unsigned int copied; unsigned int start_offset; unsigned char *dest; dest = destination; 111cc4: 8b 55 14 mov 0x14(%ebp),%edx 111cc7: 89 55 c8 mov %edx,-0x38(%ebp) */ last_byte = start + length; if ( last_byte > the_jnode->info.file.size ) my_length = the_jnode->info.file.size - start; copied = 0; 111cca: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp) 111cd1: eb 97 jmp 111c6a 111cd3: 90 nop /* * Phase 3: possibly the first part of one block */ IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK ); if ( my_length ) { 111cd4: 8b 55 cc mov -0x34(%ebp),%edx 111cd7: 85 d2 test %edx,%edx 111cd9: 74 23 je 111cfe block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 111cdb: 50 push %eax 111cdc: 6a 00 push $0x0 111cde: 53 push %ebx 111cdf: ff 75 08 pushl 0x8(%ebp) 111ce2: e8 1d fd ff ff call 111a04 if ( !block_ptr ) 111ce7: 83 c4 10 add $0x10,%esp 111cea: 85 c0 test %eax,%eax 111cec: 74 bb je 111ca9 <== NEVER TAKEN return copied; memcpy( dest, &(*block_ptr)[ 0 ], my_length ); 111cee: 8b 30 mov (%eax),%esi 111cf0: 8b 7d c8 mov -0x38(%ebp),%edi 111cf3: 8b 4d cc mov -0x34(%ebp),%ecx 111cf6: f3 a4 rep movsb %ds:(%esi),%es:(%edi) copied += my_length; 111cf8: 8b 55 cc mov -0x34(%ebp),%edx 111cfb: 01 55 c4 add %edx,-0x3c(%ebp) } IMFS_update_atime( the_jnode ); 111cfe: 83 ec 08 sub $0x8,%esp 111d01: 6a 00 push $0x0 111d03: 8d 45 e0 lea -0x20(%ebp),%eax 111d06: 50 push %eax 111d07: e8 24 64 ff ff call 108130 111d0c: 8b 45 e0 mov -0x20(%ebp),%eax 111d0f: 8b 4d 08 mov 0x8(%ebp),%ecx 111d12: 89 41 40 mov %eax,0x40(%ecx) return copied; 111d15: 8b 45 c4 mov -0x3c(%ebp),%eax 111d18: 83 c4 10 add $0x10,%esp } 111d1b: 8d 65 f4 lea -0xc(%ebp),%esp 111d1e: 5b pop %ebx 111d1f: 5e pop %esi 111d20: 5f pop %edi 111d21: c9 leave 111d22: c3 ret 111d23: 90 nop my_length = length; if (the_jnode->type == IMFS_LINEAR_FILE) { unsigned char *file_ptr; file_ptr = (unsigned char *)the_jnode->info.linearfile.direct; 111d24: 8b 50 58 mov 0x58(%eax),%edx 111d27: 89 55 cc mov %edx,-0x34(%ebp) if (my_length > (the_jnode->info.linearfile.size - start)) 111d2a: 89 c1 mov %eax,%ecx 111d2c: 8b 40 50 mov 0x50(%eax),%eax 111d2f: 8b 51 54 mov 0x54(%ecx),%edx 111d32: 89 c1 mov %eax,%ecx 111d34: 89 d3 mov %edx,%ebx 111d36: 29 f1 sub %esi,%ecx 111d38: 19 fb sbb %edi,%ebx 111d3a: 89 4d d0 mov %ecx,-0x30(%ebp) 111d3d: 89 5d d4 mov %ebx,-0x2c(%ebp) 111d40: 31 c9 xor %ecx,%ecx 111d42: 39 d9 cmp %ebx,%ecx 111d44: 7d 4a jge 111d90 <== ALWAYS TAKEN /* * Linear files (as created from a tar file are easier to handle * than block files). */ my_length = length; 111d46: 8b 5d 18 mov 0x18(%ebp),%ebx <== NOT EXECUTED file_ptr = (unsigned char *)the_jnode->info.linearfile.direct; if (my_length > (the_jnode->info.linearfile.size - start)) my_length = the_jnode->info.linearfile.size - start; memcpy(dest, &file_ptr[start], my_length); 111d49: 03 75 cc add -0x34(%ebp),%esi 111d4c: 8b 7d 14 mov 0x14(%ebp),%edi 111d4f: 89 d9 mov %ebx,%ecx 111d51: f3 a4 rep movsb %ds:(%esi),%es:(%edi) IMFS_update_atime( the_jnode ); 111d53: 83 ec 08 sub $0x8,%esp 111d56: 6a 00 push $0x0 111d58: 8d 45 e0 lea -0x20(%ebp),%eax 111d5b: 50 push %eax 111d5c: e8 cf 63 ff ff call 108130 111d61: 8b 45 e0 mov -0x20(%ebp),%eax 111d64: 8b 7d 08 mov 0x8(%ebp),%edi 111d67: 89 47 40 mov %eax,0x40(%edi) return my_length; 111d6a: 89 d8 mov %ebx,%eax 111d6c: 83 c4 10 add $0x10,%esp } IMFS_update_atime( the_jnode ); return copied; } 111d6f: 8d 65 f4 lea -0xc(%ebp),%esp 111d72: 5b pop %ebx 111d73: 5e pop %esi 111d74: 5f pop %edi 111d75: c9 leave 111d76: c3 ret 111d77: 90 nop /* * If the last byte we are supposed to read is past the end of this * in memory file, then shorten the length to read. */ last_byte = start + length; if ( last_byte > the_jnode->info.file.size ) 111d78: 39 4d d0 cmp %ecx,-0x30(%ebp) 111d7b: 0f 86 61 fe ff ff jbe 111be2 111d81: e9 34 ff ff ff jmp 111cba 111d86: 66 90 xchg %ax,%ax * Phase 1: possibly the last part of one block */ start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK; block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; if ( start_offset ) { to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset; 111d88: 89 ca mov %ecx,%edx 111d8a: e9 bd fe ff ff jmp 111c4c 111d8f: 90 nop if (the_jnode->type == IMFS_LINEAR_FILE) { unsigned char *file_ptr; file_ptr = (unsigned char *)the_jnode->info.linearfile.direct; if (my_length > (the_jnode->info.linearfile.size - start)) 111d90: 7f 08 jg 111d9a <== NEVER TAKEN 111d92: 8b 5d d0 mov -0x30(%ebp),%ebx 111d95: 39 5d 18 cmp %ebx,0x18(%ebp) 111d98: 76 ac jbe 111d46 <== NEVER TAKEN my_length = the_jnode->info.linearfile.size - start; 111d9a: 89 c3 mov %eax,%ebx 111d9c: 29 f3 sub %esi,%ebx 111d9e: eb a9 jmp 111d49 to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset; if ( to_copy > my_length ) to_copy = my_length; block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); if ( !block_ptr ) return copied; 111da0: 31 c0 xor %eax,%eax 111da2: e9 05 ff ff ff jmp 111cac <== NOT EXECUTED =============================================================================== 00111e80 : * is better to stick to simple, easy to understand algorithms. */ int IMFS_memfile_remove( IMFS_jnode_t *the_jnode ) { 111e80: 55 push %ebp 111e81: 89 e5 mov %esp,%ebp 111e83: 57 push %edi 111e84: 56 push %esi 111e85: 53 push %ebx 111e86: 83 ec 1c sub $0x1c,%esp /* * Eventually this could be set smarter at each call to * memfile_free_blocks_in_table to greatly speed this up. */ to_free = IMFS_MEMFILE_BLOCK_SLOTS; 111e89: 8b 3d e0 78 12 00 mov 0x1278e0,%edi 111e8f: c1 ef 02 shr $0x2,%edi * + doubly indirect * + triply indirect */ info = &the_jnode->info.file; if ( info->indirect ) { 111e92: 8b 45 08 mov 0x8(%ebp),%eax 111e95: 8b 50 58 mov 0x58(%eax),%edx 111e98: 85 d2 test %edx,%edx 111e9a: 74 10 je 111eac memfile_free_blocks_in_table( &info->indirect, to_free ); 111e9c: 83 ec 08 sub $0x8,%esp 111e9f: 57 push %edi 111ea0: 83 c0 58 add $0x58,%eax 111ea3: 50 push %eax 111ea4: e8 7b ff ff ff call 111e24 111ea9: 83 c4 10 add $0x10,%esp } if ( info->doubly_indirect ) { 111eac: 8b 4d 08 mov 0x8(%ebp),%ecx 111eaf: 8b 51 5c mov 0x5c(%ecx),%edx 111eb2: 85 d2 test %edx,%edx 111eb4: 74 55 je 111f0b for ( i=0 ; i<== NEVER TAKEN 111ec2: 31 c9 xor %ecx,%ecx 111ec4: 31 db xor %ebx,%ebx 111ec6: 8b 75 08 mov 0x8(%ebp),%esi 111ec9: eb 04 jmp 111ecf 111ecb: 90 nop 111ecc: 8b 56 5c mov 0x5c(%esi),%edx if ( info->doubly_indirect[i] ) { 111ecf: c1 e1 02 shl $0x2,%ecx 111ed2: 83 3c 0a 00 cmpl $0x0,(%edx,%ecx,1) 111ed6: 74 14 je 111eec <== NEVER TAKEN memfile_free_blocks_in_table( 111ed8: 83 ec 08 sub $0x8,%esp 111edb: 57 push %edi 111edc: 01 ca add %ecx,%edx 111ede: 52 push %edx 111edf: e8 40 ff ff ff call 111e24 111ee4: 83 c4 10 add $0x10,%esp 111ee7: a1 e0 78 12 00 mov 0x1278e0,%eax if ( info->indirect ) { memfile_free_blocks_in_table( &info->indirect, to_free ); } if ( info->doubly_indirect ) { for ( i=0 ; i if ( info->doubly_indirect[i] ) { memfile_free_blocks_in_table( (block_p **)&info->doubly_indirect[i], to_free ); } } memfile_free_blocks_in_table( &info->doubly_indirect, to_free ); 111ef8: 83 ec 08 sub $0x8,%esp 111efb: 57 push %edi 111efc: 8b 45 08 mov 0x8(%ebp),%eax 111eff: 83 c0 5c add $0x5c,%eax 111f02: 50 push %eax 111f03: e8 1c ff ff ff call 111e24 111f08: 83 c4 10 add $0x10,%esp } if ( info->triply_indirect ) { 111f0b: 8b 45 08 mov 0x8(%ebp),%eax 111f0e: 8b 50 60 mov 0x60(%eax),%edx 111f11: 85 d2 test %edx,%edx 111f13: 0f 84 b6 00 00 00 je 111fcf for ( i=0 ; i<== NEVER TAKEN p = (block_p *) info->triply_indirect[i]; 111f29: 8b 32 mov (%edx),%esi if ( !p ) /* ensure we have a valid pointer */ 111f2b: 85 f6 test %esi,%esi 111f2d: 0f 84 89 00 00 00 je 111fbc <== NEVER TAKEN } if ( info->triply_indirect ) { for ( i=0 ; itriply_indirect[i]; 111f33: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) if ( !p ) /* ensure we have a valid pointer */ 111f3a: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) 111f41: 8d 76 00 lea 0x0(%esi),%esi break; for ( j=0 ; j<== NEVER TAKEN 111f4b: 31 d2 xor %edx,%edx 111f4d: 31 db xor %ebx,%ebx 111f4f: 90 nop if ( p[j] ) { 111f50: c1 e2 02 shl $0x2,%edx 111f53: 8b 0c 16 mov (%esi,%edx,1),%ecx 111f56: 85 c9 test %ecx,%ecx 111f58: 74 15 je 111f6f <== NEVER TAKEN memfile_free_blocks_in_table( (block_p **)&p[j], to_free); 111f5a: 83 ec 08 sub $0x8,%esp 111f5d: 57 push %edi 111f5e: 8d 14 16 lea (%esi,%edx,1),%edx 111f61: 52 push %edx 111f62: e8 bd fe ff ff call 111e24 111f67: 83 c4 10 add $0x10,%esp 111f6a: a1 e0 78 12 00 mov 0x1278e0,%eax if ( info->triply_indirect ) { for ( i=0 ; itriply_indirect[i]; if ( !p ) /* ensure we have a valid pointer */ break; for ( j=0 ; j if ( p[j] ) { memfile_free_blocks_in_table( (block_p **)&p[j], to_free); } } memfile_free_blocks_in_table( 111f7b: 83 ec 08 sub $0x8,%esp 111f7e: 57 push %edi 111f7f: 8b 45 e0 mov -0x20(%ebp),%eax 111f82: 8b 4d 08 mov 0x8(%ebp),%ecx 111f85: 03 41 60 add 0x60(%ecx),%eax 111f88: 50 push %eax 111f89: e8 96 fe ff ff call 111e24 memfile_free_blocks_in_table( &info->doubly_indirect, to_free ); } if ( info->triply_indirect ) { for ( i=0 ; i p = (block_p *) info->triply_indirect[i]; if ( !p ) /* ensure we have a valid pointer */ 111fa3: 8b 55 e4 mov -0x1c(%ebp),%edx 111fa6: c1 e2 02 shl $0x2,%edx 111fa9: 89 55 e0 mov %edx,-0x20(%ebp) } if ( info->triply_indirect ) { for ( i=0 ; itriply_indirect[i]; 111fac: 8b 4d 08 mov 0x8(%ebp),%ecx 111faf: 8b 51 60 mov 0x60(%ecx),%edx 111fb2: 8b 4d e0 mov -0x20(%ebp),%ecx 111fb5: 8b 34 0a mov (%edx,%ecx,1),%esi if ( !p ) /* ensure we have a valid pointer */ 111fb8: 85 f6 test %esi,%esi 111fba: 75 88 jne 111f44 <== ALWAYS TAKEN } } memfile_free_blocks_in_table( (block_p **)&info->triply_indirect[i], to_free ); } memfile_free_blocks_in_table( 111fbc: 83 ec 08 sub $0x8,%esp 111fbf: 57 push %edi (block_p **)&info->triply_indirect, to_free ); 111fc0: 8b 45 08 mov 0x8(%ebp),%eax 111fc3: 83 c0 60 add $0x60,%eax } } memfile_free_blocks_in_table( (block_p **)&info->triply_indirect[i], to_free ); } memfile_free_blocks_in_table( 111fc6: 50 push %eax 111fc7: e8 58 fe ff ff call 111e24 111fcc: 83 c4 10 add $0x10,%esp (block_p **)&info->triply_indirect, to_free ); } return 0; } 111fcf: 31 c0 xor %eax,%eax 111fd1: 8d 65 f4 lea -0xc(%ebp),%esp 111fd4: 5b pop %ebx 111fd5: 5e pop %esi 111fd6: 5f pop %edi 111fd7: c9 leave 111fd8: c3 ret =============================================================================== 00112120 : IMFS_jnode_t *the_jnode, off_t start, const unsigned char *source, unsigned int length ) { 112120: 55 push %ebp 112121: 89 e5 mov %esp,%ebp 112123: 57 push %edi 112124: 56 push %esi 112125: 53 push %ebx 112126: 83 ec 3c sub $0x3c,%esp 112129: 8b 5d 0c mov 0xc(%ebp),%ebx 11212c: 8b 75 10 mov 0x10(%ebp),%esi /* * If the last byte we are supposed to write is past the end of this * in memory file, then extend the length. */ last_byte = start + my_length; 11212f: 8b 4d 18 mov 0x18(%ebp),%ecx 112132: 01 d9 add %ebx,%ecx if ( last_byte > the_jnode->info.file.size ) { 112134: 89 c8 mov %ecx,%eax 112136: 31 d2 xor %edx,%edx 112138: 8b 7d 08 mov 0x8(%ebp),%edi 11213b: 3b 57 54 cmp 0x54(%edi),%edx 11213e: 7c 1c jl 11215c <== NEVER TAKEN 112140: 0f 8e f2 00 00 00 jle 112238 <== ALWAYS TAKEN status = IMFS_memfile_extend( the_jnode, last_byte ); 112146: 51 push %ecx 112147: 52 push %edx 112148: 50 push %eax 112149: ff 75 08 pushl 0x8(%ebp) 11214c: e8 b7 fe ff ff call 112008 if ( status ) 112151: 83 c4 10 add $0x10,%esp 112154: 85 c0 test %eax,%eax 112156: 0f 85 52 01 00 00 jne 1122ae */ /* * Phase 1: possibly the last part of one block */ start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK; 11215c: a1 e0 78 12 00 mov 0x1278e0,%eax 112161: 89 45 d4 mov %eax,-0x2c(%ebp) 112164: 99 cltd 112165: 89 45 c8 mov %eax,-0x38(%ebp) 112168: 89 55 cc mov %edx,-0x34(%ebp) 11216b: 52 push %edx 11216c: 50 push %eax 11216d: 56 push %esi 11216e: 53 push %ebx 11216f: e8 48 ca 00 00 call 11ebbc <__moddi3> 112174: 83 c4 10 add $0x10,%esp 112177: 89 c7 mov %eax,%edi block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; 112179: ff 75 cc pushl -0x34(%ebp) 11217c: ff 75 c8 pushl -0x38(%ebp) 11217f: 56 push %esi 112180: 53 push %ebx 112181: e8 ea c8 00 00 call 11ea70 <__divdi3> 112186: 83 c4 10 add $0x10,%esp 112189: 89 c3 mov %eax,%ebx if ( start_offset ) { 11218b: 85 ff test %edi,%edi 11218d: 75 5d jne 1121ec unsigned int last_byte; unsigned int start_offset; int copied; const unsigned char *src; src = source; 11218f: 8b 75 14 mov 0x14(%ebp),%esi /* * Phase 1: possibly the last part of one block */ start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK; block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; if ( start_offset ) { 112192: 8b 55 18 mov 0x18(%ebp),%edx status = IMFS_memfile_extend( the_jnode, last_byte ); if ( status ) rtems_set_errno_and_return_minus_one( ENOSPC ); } copied = 0; 112195: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp) /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { 11219c: 3b 55 d4 cmp -0x2c(%ebp),%edx 11219f: 73 26 jae 1121c7 1121a1: e9 a2 00 00 00 jmp 112248 1121a6: 66 90 xchg %ax,%ax if ( !block_ptr ) return copied; #if 0 fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src ); #endif memcpy( &(*block_ptr)[ 0 ], src, to_copy ); 1121a8: 8b 00 mov (%eax),%eax src += to_copy; 1121aa: 89 c7 mov %eax,%edi 1121ac: 8b 4d d4 mov -0x2c(%ebp),%ecx 1121af: f3 a4 rep movsb %ds:(%esi),%es:(%edi) block++; 1121b1: 43 inc %ebx my_length -= to_copy; 1121b2: 2b 55 d4 sub -0x2c(%ebp),%edx * IMFS_memfile_write * * This routine writes the specified data buffer into the in memory * file pointed to by the_jnode. The file is extended as needed. */ MEMFILE_STATIC ssize_t IMFS_memfile_write( 1121b5: 8b 45 d4 mov -0x2c(%ebp),%eax 1121b8: 01 45 c8 add %eax,-0x38(%ebp) /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { 1121bb: 39 15 e0 78 12 00 cmp %edx,0x1278e0 1121c1: 0f 87 81 00 00 00 ja 112248 block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 1121c7: 57 push %edi 1121c8: 6a 00 push $0x0 1121ca: 53 push %ebx 1121cb: ff 75 08 pushl 0x8(%ebp) 1121ce: 89 55 c4 mov %edx,-0x3c(%ebp) 1121d1: e8 2e f8 ff ff call 111a04 if ( !block_ptr ) 1121d6: 83 c4 10 add $0x10,%esp 1121d9: 85 c0 test %eax,%eax 1121db: 8b 55 c4 mov -0x3c(%ebp),%edx 1121de: 75 c8 jne 1121a8 <== ALWAYS TAKEN IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK ); to_copy = my_length; if ( my_length ) { block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); if ( !block_ptr ) 1121e0: 8b 45 c8 mov -0x38(%ebp),%eax <== NOT EXECUTED } IMFS_mtime_ctime_update( the_jnode ); return copied; } 1121e3: 8d 65 f4 lea -0xc(%ebp),%esp 1121e6: 5b pop %ebx 1121e7: 5e pop %esi 1121e8: 5f pop %edi 1121e9: c9 leave 1121ea: c3 ret 1121eb: 90 nop block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; if ( start_offset ) { to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset; if ( to_copy > my_length ) to_copy = my_length; block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 1121ec: 50 push %eax 1121ed: 6a 00 push $0x0 1121ef: 53 push %ebx 1121f0: ff 75 08 pushl 0x8(%ebp) 1121f3: e8 0c f8 ff ff call 111a04 if ( !block_ptr ) 1121f8: 83 c4 10 add $0x10,%esp 1121fb: 85 c0 test %eax,%eax 1121fd: 0f 84 a1 00 00 00 je 1122a4 <== NEVER TAKEN * Phase 1: possibly the last part of one block */ start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK; block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; if ( start_offset ) { to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset; 112203: 8b 55 d4 mov -0x2c(%ebp),%edx 112206: 29 fa sub %edi,%edx 112208: 89 55 c8 mov %edx,-0x38(%ebp) 11220b: 8b 55 18 mov 0x18(%ebp),%edx 11220e: 39 55 c8 cmp %edx,-0x38(%ebp) 112211: 0f 87 85 00 00 00 ja 11229c block, to_copy, src ); #endif memcpy( &(*block_ptr)[ start_offset ], src, to_copy ); 112217: 03 38 add (%eax),%edi src += to_copy; 112219: 8b 75 14 mov 0x14(%ebp),%esi 11221c: 8b 4d c8 mov -0x38(%ebp),%ecx 11221f: f3 a4 rep movsb %ds:(%esi),%es:(%edi) block++; 112221: 43 inc %ebx my_length -= to_copy; 112222: 8b 55 18 mov 0x18(%ebp),%edx 112225: 2b 55 c8 sub -0x38(%ebp),%edx copied += to_copy; 112228: 8b 3d e0 78 12 00 mov 0x1278e0,%edi 11222e: 89 7d d4 mov %edi,-0x2c(%ebp) 112231: e9 66 ff ff ff jmp 11219c 112236: 66 90 xchg %ax,%ax * If the last byte we are supposed to write is past the end of this * in memory file, then extend the length. */ last_byte = start + my_length; if ( last_byte > the_jnode->info.file.size ) { 112238: 3b 4f 50 cmp 0x50(%edi),%ecx 11223b: 0f 86 1b ff ff ff jbe 11215c <== NEVER TAKEN 112241: e9 00 ff ff ff jmp 112146 112246: 66 90 xchg %ax,%ax * Phase 3: possibly the first part of one block */ IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK ); to_copy = my_length; if ( my_length ) { 112248: 85 d2 test %edx,%edx 11224a: 74 28 je 112274 block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 11224c: 51 push %ecx 11224d: 6a 00 push $0x0 11224f: 53 push %ebx 112250: ff 75 08 pushl 0x8(%ebp) 112253: 89 55 c4 mov %edx,-0x3c(%ebp) 112256: e8 a9 f7 ff ff call 111a04 if ( !block_ptr ) 11225b: 83 c4 10 add $0x10,%esp 11225e: 85 c0 test %eax,%eax 112260: 8b 55 c4 mov -0x3c(%ebp),%edx 112263: 0f 84 77 ff ff ff je 1121e0 <== NEVER TAKEN return copied; #if 0 fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src ); #endif memcpy( &(*block_ptr)[ 0 ], src, my_length ); 112269: 8b 00 mov (%eax),%eax 11226b: 89 c7 mov %eax,%edi 11226d: 89 d1 mov %edx,%ecx 11226f: f3 a4 rep movsb %ds:(%esi),%es:(%edi) my_length = 0; copied += to_copy; 112271: 01 55 c8 add %edx,-0x38(%ebp) } IMFS_mtime_ctime_update( the_jnode ); 112274: 83 ec 08 sub $0x8,%esp 112277: 6a 00 push $0x0 112279: 8d 45 e0 lea -0x20(%ebp),%eax 11227c: 50 push %eax 11227d: e8 ae 5e ff ff call 108130 112282: 8b 45 e0 mov -0x20(%ebp),%eax 112285: 8b 55 08 mov 0x8(%ebp),%edx 112288: 89 42 44 mov %eax,0x44(%edx) 11228b: 89 42 48 mov %eax,0x48(%edx) return copied; 11228e: 83 c4 10 add $0x10,%esp 112291: 8b 45 c8 mov -0x38(%ebp),%eax } 112294: 8d 65 f4 lea -0xc(%ebp),%esp 112297: 5b pop %ebx 112298: 5e pop %esi 112299: 5f pop %edi 11229a: c9 leave 11229b: c3 ret * Phase 1: possibly the last part of one block */ start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK; block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; if ( start_offset ) { to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset; 11229c: 89 55 c8 mov %edx,-0x38(%ebp) 11229f: e9 73 ff ff ff jmp 112217 if ( to_copy > my_length ) to_copy = my_length; block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); if ( !block_ptr ) return copied; 1122a4: 31 c0 xor %eax,%eax } IMFS_mtime_ctime_update( the_jnode ); return copied; } 1122a6: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1122a9: 5b pop %ebx <== NOT EXECUTED 1122aa: 5e pop %esi <== NOT EXECUTED 1122ab: 5f pop %edi <== NOT EXECUTED 1122ac: c9 leave <== NOT EXECUTED 1122ad: c3 ret <== NOT EXECUTED last_byte = start + my_length; if ( last_byte > the_jnode->info.file.size ) { status = IMFS_memfile_extend( the_jnode, last_byte ); if ( status ) rtems_set_errno_and_return_minus_one( ENOSPC ); 1122ae: e8 bd 0f 00 00 call 113270 <__errno> 1122b3: c7 00 1c 00 00 00 movl $0x1c,(%eax) 1122b9: 83 c8 ff or $0xffffffff,%eax 1122bc: e9 22 ff ff ff jmp 1121e3 =============================================================================== 001079bc : const char *token, /* IN */ mode_t mode, /* IN */ dev_t dev, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN/OUT */ ) { 1079bc: 55 push %ebp 1079bd: 89 e5 mov %esp,%ebp 1079bf: 57 push %edi 1079c0: 56 push %esi 1079c1: 53 push %ebx 1079c2: 83 ec 5c sub $0x5c,%esp 1079c5: 8b 55 08 mov 0x8(%ebp),%edx 1079c8: 8b 5d 0c mov 0xc(%ebp),%ebx 1079cb: 8b 75 10 mov 0x10(%ebp),%esi 1079ce: 8b 45 14 mov 0x14(%ebp),%eax 1079d1: 89 45 a4 mov %eax,-0x5c(%ebp) IMFS_jnode_t *new_node; int result; char new_name[ IMFS_NAME_MAX + 1 ]; IMFS_types_union info; IMFS_get_token( token, strlen( token ), new_name, &result ); 1079d4: 31 c0 xor %eax,%eax 1079d6: b9 ff ff ff ff mov $0xffffffff,%ecx 1079db: 89 d7 mov %edx,%edi 1079dd: f2 ae repnz scas %es:(%edi),%al 1079df: f7 d1 not %ecx 1079e1: 49 dec %ecx 1079e2: 8d 45 e4 lea -0x1c(%ebp),%eax 1079e5: 50 push %eax 1079e6: 8d 7d af lea -0x51(%ebp),%edi 1079e9: 57 push %edi 1079ea: 51 push %ecx 1079eb: 52 push %edx 1079ec: e8 53 7f 00 00 call 10f944 /* * Figure out what type of IMFS node this is. */ if ( S_ISDIR(mode) ) 1079f1: 89 d8 mov %ebx,%eax 1079f3: 25 00 f0 00 00 and $0xf000,%eax 1079f8: 83 c4 10 add $0x10,%esp 1079fb: 3d 00 40 00 00 cmp $0x4000,%eax 107a00: 74 56 je 107a58 type = IMFS_DIRECTORY; else if ( S_ISREG(mode) ) 107a02: 3d 00 80 00 00 cmp $0x8000,%eax 107a07: 74 57 je 107a60 type = IMFS_MEMORY_FILE; else if ( S_ISBLK(mode) || S_ISCHR(mode) ) { 107a09: 3d 00 60 00 00 cmp $0x6000,%eax 107a0e: 74 14 je 107a24 107a10: 3d 00 20 00 00 cmp $0x2000,%eax 107a15: 74 0d je 107a24 type = IMFS_DEVICE; rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor ); } else if (S_ISFIFO(mode)) 107a17: 3d 00 10 00 00 cmp $0x1000,%eax 107a1c: 74 4a je 107a68 <== ALWAYS TAKEN mode_t mode, /* IN */ dev_t dev, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN/OUT */ ) { IMFS_token_types type = 0; 107a1e: 31 d2 xor %edx,%edx <== NOT EXECUTED 107a20: eb 10 jmp 107a32 <== NOT EXECUTED 107a22: 66 90 xchg %ax,%ax <== NOT EXECUTED type = IMFS_DIRECTORY; else if ( S_ISREG(mode) ) type = IMFS_MEMORY_FILE; else if ( S_ISBLK(mode) || S_ISCHR(mode) ) { type = IMFS_DEVICE; rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor ); 107a24: 89 75 d0 mov %esi,-0x30(%ebp) dev_t device ) { union __rtems_dev_t temp; temp.device = device; 107a27: 8b 45 a4 mov -0x5c(%ebp),%eax 107a2a: 89 45 d4 mov %eax,-0x2c(%ebp) if ( S_ISDIR(mode) ) type = IMFS_DIRECTORY; else if ( S_ISREG(mode) ) type = IMFS_MEMORY_FILE; else if ( S_ISBLK(mode) || S_ISCHR(mode) ) { type = IMFS_DEVICE; 107a2d: ba 02 00 00 00 mov $0x2,%edx * was ONLY passed a NULL when we created the root node. We * added a new IMFS_create_root_node() so this path no longer * existed. The result was simpler code which should not have * this path. */ new_node = IMFS_create_node( pathloc, type, new_name, mode, &info ); 107a32: 83 ec 0c sub $0xc,%esp 107a35: 8d 45 d0 lea -0x30(%ebp),%eax 107a38: 50 push %eax 107a39: 53 push %ebx 107a3a: 57 push %edi 107a3b: 52 push %edx 107a3c: ff 75 18 pushl 0x18(%ebp) 107a3f: e8 38 75 00 00 call 10ef7c if ( !new_node ) 107a44: 83 c4 20 add $0x20,%esp 107a47: 85 c0 test %eax,%eax 107a49: 74 24 je 107a6f rtems_set_errno_and_return_minus_one( ENOMEM ); return 0; 107a4b: 31 c0 xor %eax,%eax } 107a4d: 8d 65 f4 lea -0xc(%ebp),%esp 107a50: 5b pop %ebx 107a51: 5e pop %esi 107a52: 5f pop %edi 107a53: c9 leave 107a54: c3 ret 107a55: 8d 76 00 lea 0x0(%esi),%esi /* * Figure out what type of IMFS node this is. */ if ( S_ISDIR(mode) ) type = IMFS_DIRECTORY; 107a58: ba 01 00 00 00 mov $0x1,%edx 107a5d: eb d3 jmp 107a32 107a5f: 90 nop else if ( S_ISREG(mode) ) type = IMFS_MEMORY_FILE; 107a60: ba 05 00 00 00 mov $0x5,%edx 107a65: eb cb jmp 107a32 107a67: 90 nop else if ( S_ISBLK(mode) || S_ISCHR(mode) ) { type = IMFS_DEVICE; rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor ); } else if (S_ISFIFO(mode)) type = IMFS_FIFO; 107a68: ba 07 00 00 00 mov $0x7,%edx 107a6d: eb c3 jmp 107a32 * existed. The result was simpler code which should not have * this path. */ new_node = IMFS_create_node( pathloc, type, new_name, mode, &info ); if ( !new_node ) rtems_set_errno_and_return_minus_one( ENOMEM ); 107a6f: e8 fc b7 00 00 call 113270 <__errno> 107a74: c7 00 0c 00 00 00 movl $0xc,(%eax) 107a7a: b8 ff ff ff ff mov $0xffffffff,%eax 107a7f: eb cc jmp 107a4d =============================================================================== 00107a84 : #include int IMFS_mount( rtems_filesystem_mount_table_entry_t *mt_entry ) { 107a84: 55 push %ebp 107a85: 89 e5 mov %esp,%ebp 107a87: 83 ec 08 sub $0x8,%esp 107a8a: 8b 55 08 mov 0x8(%ebp),%edx IMFS_jnode_t *node; node = mt_entry->mt_point_node.node_access; 107a8d: 8b 42 08 mov 0x8(%edx),%eax /* * Is the node that we are mounting onto a directory node ? */ if ( node->type != IMFS_DIRECTORY ) 107a90: 83 78 4c 01 cmpl $0x1,0x4c(%eax) 107a94: 75 0a jne 107aa0 <== NEVER TAKEN /* * Set mt_fs pointer to point to the mount table entry for * the mounted file system. */ node->info.directory.mt_fs = mt_entry; 107a96: 89 50 5c mov %edx,0x5c(%eax) return 0; 107a99: 31 c0 xor %eax,%eax } 107a9b: c9 leave 107a9c: c3 ret 107a9d: 8d 76 00 lea 0x0(%esi),%esi /* * Is the node that we are mounting onto a directory node ? */ if ( node->type != IMFS_DIRECTORY ) rtems_set_errno_and_return_minus_one( ENOTDIR ); 107aa0: e8 cb b7 00 00 call 113270 <__errno> <== NOT EXECUTED 107aa5: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED 107aab: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED * the mounted file system. */ node->info.directory.mt_fs = mt_entry; return 0; } 107ab0: c9 leave <== NOT EXECUTED 107ab1: c3 ret <== NOT EXECUTED =============================================================================== 0010a3b0 : * This routine prints the contents of the specified jnode. */ void IMFS_print_jnode( IMFS_jnode_t *the_jnode ) { 10a3b0: 55 push %ebp 10a3b1: 89 e5 mov %esp,%ebp 10a3b3: 53 push %ebx 10a3b4: 83 ec 0c sub $0xc,%esp 10a3b7: 8b 5d 08 mov 0x8(%ebp),%ebx IMFS_assert( the_jnode ); fprintf(stdout, "%s", the_jnode->name ); 10a3ba: a1 20 c4 12 00 mov 0x12c420,%eax 10a3bf: ff 70 08 pushl 0x8(%eax) 10a3c2: 8d 43 0c lea 0xc(%ebx),%eax 10a3c5: 50 push %eax 10a3c6: e8 d1 d5 00 00 call 11799c switch( the_jnode->type ) { 10a3cb: 8b 43 4c mov 0x4c(%ebx),%eax 10a3ce: 83 c4 10 add $0x10,%esp 10a3d1: 83 f8 07 cmp $0x7,%eax 10a3d4: 76 1e jbe 10a3f4 <== ALWAYS TAKEN case IMFS_FIFO: fprintf(stdout, " FIFO not printed\n" ); return; default: fprintf(stdout, " bad type %d\n", the_jnode->type ); 10a3d6: 52 push %edx <== NOT EXECUTED 10a3d7: 50 push %eax <== NOT EXECUTED 10a3d8: 68 84 71 12 00 push $0x127184 <== NOT EXECUTED 10a3dd: a1 20 c4 12 00 mov 0x12c420,%eax <== NOT EXECUTED 10a3e2: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 10a3e5: e8 a6 d4 00 00 call 117890 <== NOT EXECUTED return; 10a3ea: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } puts(""); } 10a3ed: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a3f0: c9 leave <== NOT EXECUTED 10a3f1: c3 ret <== NOT EXECUTED 10a3f2: 66 90 xchg %ax,%ax <== NOT EXECUTED ) { IMFS_assert( the_jnode ); fprintf(stdout, "%s", the_jnode->name ); switch( the_jnode->type ) { 10a3f4: ff 24 85 9c 71 12 00 jmp *0x12719c(,%eax,4) 10a3fb: 90 nop case IMFS_HARD_LINK: fprintf(stdout, " links not printed\n" ); return; case IMFS_SYM_LINK: fprintf(stdout, " links not printed\n" ); 10a3fc: a1 20 c4 12 00 mov 0x12c420,%eax 10a401: ff 70 08 pushl 0x8(%eax) 10a404: 6a 13 push $0x13 10a406: 6a 01 push $0x1 10a408: 68 5d 71 12 00 push $0x12715d 10a40d: e8 ae e1 00 00 call 1185c0 return; 10a412: 83 c4 10 add $0x10,%esp default: fprintf(stdout, " bad type %d\n", the_jnode->type ); return; } puts(""); } 10a415: 8b 5d fc mov -0x4(%ebp),%ebx 10a418: c9 leave 10a419: c3 ret 10a41a: 66 90 xchg %ax,%ax case IMFS_SYM_LINK: fprintf(stdout, " links not printed\n" ); return; case IMFS_FIFO: fprintf(stdout, " FIFO not printed\n" ); 10a41c: a1 20 c4 12 00 mov 0x12c420,%eax 10a421: ff 70 08 pushl 0x8(%eax) 10a424: 6a 12 push $0x12 10a426: 6a 01 push $0x1 10a428: 68 71 71 12 00 push $0x127171 10a42d: e8 8e e1 00 00 call 1185c0 return; 10a432: 83 c4 10 add $0x10,%esp default: fprintf(stdout, " bad type %d\n", the_jnode->type ); return; } puts(""); } 10a435: 8b 5d fc mov -0x4(%ebp),%ebx 10a438: c9 leave 10a439: c3 ret 10a43a: 66 90 xchg %ax,%ax the_jnode->info.file.indirect, the_jnode->info.file.doubly_indirect, the_jnode->info.file.triply_indirect ); #else fprintf(stdout, " (file %" PRId32 ")", 10a43c: 51 push %ecx 10a43d: ff 73 50 pushl 0x50(%ebx) 10a440: 68 51 71 12 00 push $0x127151 10a445: a1 20 c4 12 00 mov 0x12c420,%eax 10a44a: ff 70 08 pushl 0x8(%eax) 10a44d: e8 3e d4 00 00 call 117890 (uint32_t)the_jnode->info.file.size ); #endif break; 10a452: 83 c4 10 add $0x10,%esp default: fprintf(stdout, " bad type %d\n", the_jnode->type ); return; } puts(""); 10a455: c7 45 08 89 74 12 00 movl $0x127489,0x8(%ebp) } 10a45c: 8b 5d fc mov -0x4(%ebp),%ebx 10a45f: c9 leave default: fprintf(stdout, " bad type %d\n", the_jnode->type ); return; } puts(""); 10a460: e9 53 ed 00 00 jmp 1191b8 10a465: 8d 76 00 lea 0x0(%esi),%esi fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")", the_jnode->info.device.major, the_jnode->info.device.minor ); break; case IMFS_LINEAR_FILE: fprintf(stdout, " (file %" PRId32 " %p)", 10a468: ff 73 58 pushl 0x58(%ebx) 10a46b: ff 73 50 pushl 0x50(%ebx) 10a46e: 68 42 71 12 00 push $0x127142 10a473: a1 20 c4 12 00 mov 0x12c420,%eax 10a478: ff 70 08 pushl 0x8(%eax) 10a47b: e8 10 d4 00 00 call 117890 (uint32_t)the_jnode->info.linearfile.size, the_jnode->info.linearfile.direct ); break; 10a480: 83 c4 10 add $0x10,%esp default: fprintf(stdout, " bad type %d\n", the_jnode->type ); return; } puts(""); 10a483: c7 45 08 89 74 12 00 movl $0x127489,0x8(%ebp) } 10a48a: 8b 5d fc mov -0x4(%ebp),%ebx 10a48d: c9 leave default: fprintf(stdout, " bad type %d\n", the_jnode->type ); return; } puts(""); 10a48e: e9 25 ed 00 00 jmp 1191b8 10a493: 90 nop IMFS_assert( the_jnode ); fprintf(stdout, "%s", the_jnode->name ); switch( the_jnode->type ) { case IMFS_DIRECTORY: fprintf(stdout, "/" ); 10a494: 83 ec 08 sub $0x8,%esp 10a497: a1 20 c4 12 00 mov 0x12c420,%eax 10a49c: ff 70 08 pushl 0x8(%eax) 10a49f: 6a 2f push $0x2f 10a4a1: e8 4a d4 00 00 call 1178f0 break; 10a4a6: 83 c4 10 add $0x10,%esp default: fprintf(stdout, " bad type %d\n", the_jnode->type ); return; } puts(""); 10a4a9: c7 45 08 89 74 12 00 movl $0x127489,0x8(%ebp) } 10a4b0: 8b 5d fc mov -0x4(%ebp),%ebx 10a4b3: c9 leave default: fprintf(stdout, " bad type %d\n", the_jnode->type ); return; } puts(""); 10a4b4: e9 ff ec 00 00 jmp 1191b8 10a4b9: 8d 76 00 lea 0x0(%esi),%esi case IMFS_DIRECTORY: fprintf(stdout, "/" ); break; case IMFS_DEVICE: fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")", 10a4bc: ff 73 54 pushl 0x54(%ebx) 10a4bf: ff 73 50 pushl 0x50(%ebx) 10a4c2: 68 2f 71 12 00 push $0x12712f 10a4c7: a1 20 c4 12 00 mov 0x12c420,%eax 10a4cc: ff 70 08 pushl 0x8(%eax) 10a4cf: e8 bc d3 00 00 call 117890 the_jnode->info.device.major, the_jnode->info.device.minor ); break; 10a4d4: 83 c4 10 add $0x10,%esp default: fprintf(stdout, " bad type %d\n", the_jnode->type ); return; } puts(""); 10a4d7: c7 45 08 89 74 12 00 movl $0x127489,0x8(%ebp) } 10a4de: 8b 5d fc mov -0x4(%ebp),%ebx 10a4e1: c9 leave default: fprintf(stdout, " bad type %d\n", the_jnode->type ); return; } puts(""); 10a4e2: e9 d1 ec 00 00 jmp 1191b8 =============================================================================== 00107ac4 : ssize_t IMFS_readlink( rtems_filesystem_location_info_t *loc, char *buf, /* OUT */ size_t bufsize ) { 107ac4: 55 push %ebp 107ac5: 89 e5 mov %esp,%ebp 107ac7: 57 push %edi 107ac8: 56 push %esi 107ac9: 53 push %ebx 107aca: 8b 7d 0c mov 0xc(%ebp),%edi 107acd: 8b 5d 10 mov 0x10(%ebp),%ebx IMFS_jnode_t *node; ssize_t i; node = loc->node_access; 107ad0: 8b 45 08 mov 0x8(%ebp),%eax 107ad3: 8b 30 mov (%eax),%esi IMFS_assert( node->type == IMFS_SYM_LINK ); for( i=0; ((iinfo.sym_link.name[i] != '\0')); i++ ) 107ad5: 85 db test %ebx,%ebx 107ad7: 74 28 je 107b01 <== NEVER TAKEN 107ad9: 8b 46 50 mov 0x50(%esi),%eax 107adc: 8a 10 mov (%eax),%dl 107ade: 84 d2 test %dl,%dl 107ae0: 74 1f je 107b01 <== NEVER TAKEN 107ae2: 31 c9 xor %ecx,%ecx 107ae4: 31 c0 xor %eax,%eax 107ae6: eb 0a jmp 107af2 107ae8: 8b 56 50 mov 0x50(%esi),%edx 107aeb: 8a 14 02 mov (%edx,%eax,1),%dl 107aee: 84 d2 test %dl,%dl 107af0: 74 0a je 107afc buf[i] = node->info.sym_link.name[i]; 107af2: 88 14 0f mov %dl,(%edi,%ecx,1) node = loc->node_access; IMFS_assert( node->type == IMFS_SYM_LINK ); for( i=0; ((iinfo.sym_link.name[i] != '\0')); i++ ) 107af5: 40 inc %eax 107af6: 89 c1 mov %eax,%ecx 107af8: 39 d8 cmp %ebx,%eax 107afa: 72 ec jb 107ae8 buf[i] = node->info.sym_link.name[i]; return i; } 107afc: 5b pop %ebx 107afd: 5e pop %esi 107afe: 5f pop %edi 107aff: c9 leave 107b00: c3 ret node = loc->node_access; IMFS_assert( node->type == IMFS_SYM_LINK ); for( i=0; ((iinfo.sym_link.name[i] != '\0')); i++ ) 107b01: 31 c0 xor %eax,%eax 107b03: eb f7 jmp 107afc <== NOT EXECUTED =============================================================================== 00107b08 : rtems_filesystem_location_info_t *old_parent_loc, /* IN */ rtems_filesystem_location_info_t *old_loc, /* IN */ rtems_filesystem_location_info_t *new_parent_loc, /* IN */ const char *new_name /* IN */ ) { 107b08: 55 push %ebp 107b09: 89 e5 mov %esp,%ebp 107b0b: 53 push %ebx 107b0c: 83 ec 18 sub $0x18,%esp IMFS_jnode_t *the_jnode; IMFS_jnode_t *new_parent; the_jnode = old_loc->node_access; 107b0f: 8b 45 0c mov 0xc(%ebp),%eax 107b12: 8b 18 mov (%eax),%ebx strncpy( the_jnode->name, new_name, IMFS_NAME_MAX ); 107b14: 6a 20 push $0x20 107b16: ff 75 14 pushl 0x14(%ebp) 107b19: 8d 43 0c lea 0xc(%ebx),%eax 107b1c: 50 push %eax 107b1d: e8 3a c5 00 00 call 11405c if ( the_jnode->Parent != NULL ) 107b22: 83 c4 10 add $0x10,%esp 107b25: 8b 4b 08 mov 0x8(%ebx),%ecx 107b28: 85 c9 test %ecx,%ecx 107b2a: 74 0c je 107b38 <== NEVER TAKEN */ RTEMS_INLINE_ROUTINE void rtems_chain_extract( rtems_chain_node *the_node ) { _Chain_Extract( the_node ); 107b2c: 83 ec 0c sub $0xc,%esp 107b2f: 53 push %ebx 107b30: e8 c7 44 00 00 call 10bffc <_Chain_Extract> 107b35: 83 c4 10 add $0x10,%esp rtems_chain_extract( (rtems_chain_node *) the_jnode ); new_parent = new_parent_loc->node_access; 107b38: 8b 45 10 mov 0x10(%ebp),%eax 107b3b: 8b 00 mov (%eax),%eax the_jnode->Parent = new_parent; 107b3d: 89 43 08 mov %eax,0x8(%ebx) RTEMS_INLINE_ROUTINE void rtems_chain_append( rtems_chain_control *the_chain, rtems_chain_node *the_node ) { _Chain_Append( the_chain, the_node ); 107b40: 83 ec 08 sub $0x8,%esp 107b43: 53 push %ebx rtems_chain_append( &new_parent->info.directory.Entries, &the_jnode->Node ); 107b44: 83 c0 50 add $0x50,%eax 107b47: 50 push %eax 107b48: e8 8b 44 00 00 call 10bfd8 <_Chain_Append> /* * Update the time. */ IMFS_update_ctime( the_jnode ); 107b4d: 58 pop %eax 107b4e: 5a pop %edx 107b4f: 6a 00 push $0x0 107b51: 8d 45 f0 lea -0x10(%ebp),%eax 107b54: 50 push %eax 107b55: e8 d6 05 00 00 call 108130 107b5a: 8b 45 f0 mov -0x10(%ebp),%eax 107b5d: 89 43 48 mov %eax,0x48(%ebx) return 0; } 107b60: 31 c0 xor %eax,%eax 107b62: 8b 5d fc mov -0x4(%ebp),%ebx 107b65: c9 leave 107b66: c3 ret =============================================================================== 0010fb10 : int IMFS_stat( rtems_filesystem_location_info_t *loc, struct stat *buf ) { 10fb10: 55 push %ebp 10fb11: 89 e5 mov %esp,%ebp 10fb13: 56 push %esi 10fb14: 53 push %ebx 10fb15: 8b 4d 08 mov 0x8(%ebp),%ecx 10fb18: 8b 45 0c mov 0xc(%ebp),%eax IMFS_fs_info_t *fs_info; IMFS_jnode_t *the_jnode; IMFS_device_t *io; the_jnode = loc->node_access; 10fb1b: 8b 11 mov (%ecx),%edx switch ( the_jnode->type ) { 10fb1d: 83 7a 4c 07 cmpl $0x7,0x4c(%edx) 10fb21: 76 15 jbe 10fb38 <== ALWAYS TAKEN case IMFS_FIFO: buf->st_size = 0; break; default: rtems_set_errno_and_return_minus_one( ENOTSUP ); 10fb23: e8 48 37 00 00 call 113270 <__errno> 10fb28: c7 00 86 00 00 00 movl $0x86,(%eax) 10fb2e: b8 ff ff ff ff mov $0xffffffff,%eax buf->st_atime = the_jnode->stat_atime; buf->st_mtime = the_jnode->stat_mtime; buf->st_ctime = the_jnode->stat_ctime; return 0; } 10fb33: 5b pop %ebx 10fb34: 5e pop %esi 10fb35: c9 leave 10fb36: c3 ret 10fb37: 90 nop IMFS_device_t *io; the_jnode = loc->node_access; switch ( the_jnode->type ) { 10fb38: 8b 5a 4c mov 0x4c(%edx),%ebx 10fb3b: ff 24 9d f8 18 12 00 jmp *0x1218f8(,%ebx,4) 10fb42: 66 90 xchg %ax,%ax case IMFS_SYM_LINK: buf->st_size = 0; break; case IMFS_FIFO: buf->st_size = 0; 10fb44: c7 40 20 00 00 00 00 movl $0x0,0x20(%eax) 10fb4b: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax) /* * The device number of the IMFS is the major number and the minor is the * instance. */ fs_info = loc->mt_entry->fs_info; 10fb52: 8b 49 10 mov 0x10(%ecx),%ecx buf->st_dev = rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance ); 10fb55: 8b 49 34 mov 0x34(%ecx),%ecx 10fb58: 8b 09 mov (%ecx),%ecx /* * The device number of the IMFS is the major number and the minor is the * instance. */ fs_info = loc->mt_entry->fs_info; buf->st_dev = 10fb5a: c7 00 fe ff 00 00 movl $0xfffe,(%eax) 10fb60: 89 48 04 mov %ecx,0x4(%eax) rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance ); buf->st_mode = the_jnode->st_mode; 10fb63: 8b 4a 30 mov 0x30(%edx),%ecx 10fb66: 89 48 0c mov %ecx,0xc(%eax) buf->st_nlink = the_jnode->st_nlink; 10fb69: 8b 4a 34 mov 0x34(%edx),%ecx 10fb6c: 66 89 48 10 mov %cx,0x10(%eax) buf->st_ino = the_jnode->st_ino; 10fb70: 8b 4a 38 mov 0x38(%edx),%ecx 10fb73: 89 48 08 mov %ecx,0x8(%eax) buf->st_uid = the_jnode->st_uid; 10fb76: 8b 4a 3c mov 0x3c(%edx),%ecx 10fb79: 66 89 48 12 mov %cx,0x12(%eax) buf->st_gid = the_jnode->st_gid; 10fb7d: 66 8b 4a 3e mov 0x3e(%edx),%cx 10fb81: 66 89 48 14 mov %cx,0x14(%eax) buf->st_atime = the_jnode->stat_atime; 10fb85: 8b 4a 40 mov 0x40(%edx),%ecx 10fb88: 89 48 28 mov %ecx,0x28(%eax) buf->st_mtime = the_jnode->stat_mtime; 10fb8b: 8b 4a 44 mov 0x44(%edx),%ecx 10fb8e: 89 48 30 mov %ecx,0x30(%eax) buf->st_ctime = the_jnode->stat_ctime; 10fb91: 8b 52 48 mov 0x48(%edx),%edx 10fb94: 89 50 38 mov %edx,0x38(%eax) return 0; 10fb97: 31 c0 xor %eax,%eax } 10fb99: 5b pop %ebx 10fb9a: 5e pop %esi 10fb9b: c9 leave 10fb9c: c3 ret 10fb9d: 8d 76 00 lea 0x0(%esi),%esi switch ( the_jnode->type ) { case IMFS_DEVICE: io = &the_jnode->info.device; buf->st_rdev = rtems_filesystem_make_dev_t( io->major, io->minor ); 10fba0: 8b 5a 54 mov 0x54(%edx),%ebx rtems_device_minor_number _minor ) { union __rtems_dev_t temp; temp.__overlay.major = _major; 10fba3: 8b 72 50 mov 0x50(%edx),%esi 10fba6: 89 70 18 mov %esi,0x18(%eax) 10fba9: 89 58 1c mov %ebx,0x1c(%eax) break; 10fbac: eb a4 jmp 10fb52 10fbae: 66 90 xchg %ax,%ax case IMFS_LINEAR_FILE: case IMFS_MEMORY_FILE: buf->st_size = the_jnode->info.file.size; 10fbb0: 8b 5a 50 mov 0x50(%edx),%ebx 10fbb3: 8b 72 54 mov 0x54(%edx),%esi 10fbb6: 89 58 20 mov %ebx,0x20(%eax) 10fbb9: 89 70 24 mov %esi,0x24(%eax) break; 10fbbc: eb 94 jmp 10fb52 =============================================================================== 00107bfc : int IMFS_unlink( rtems_filesystem_location_info_t *parentloc, /* IN */ rtems_filesystem_location_info_t *loc /* IN */ ) { 107bfc: 55 push %ebp 107bfd: 89 e5 mov %esp,%ebp 107bff: 57 push %edi 107c00: 56 push %esi 107c01: 53 push %ebx 107c02: 83 ec 3c sub $0x3c,%esp 107c05: 8b 5d 0c mov 0xc(%ebp),%ebx IMFS_jnode_t *node; rtems_filesystem_location_info_t the_link; int result = 0; node = loc->node_access; 107c08: 8b 13 mov (%ebx),%edx /* * If this is the last last pointer to the node * free the node. */ if ( node->type == IMFS_HARD_LINK ) { 107c0a: 83 7a 4c 03 cmpl $0x3,0x4c(%edx) 107c0e: 74 18 je 107c28 /* * Now actually free the node we were asked to free. */ result = (*loc->handlers->rmnod_h)( parentloc, loc ); 107c10: 83 ec 08 sub $0x8,%esp 107c13: 8b 43 08 mov 0x8(%ebx),%eax 107c16: 53 push %ebx 107c17: ff 75 08 pushl 0x8(%ebp) 107c1a: ff 50 34 call *0x34(%eax) return result; 107c1d: 83 c4 10 add $0x10,%esp } 107c20: 8d 65 f4 lea -0xc(%ebp),%esp 107c23: 5b pop %ebx 107c24: 5e pop %esi 107c25: 5f pop %edi 107c26: c9 leave 107c27: c3 ret * free the node. */ if ( node->type == IMFS_HARD_LINK ) { if ( !node->info.hard_link.link_node ) 107c28: 8b 42 50 mov 0x50(%edx),%eax 107c2b: 85 c0 test %eax,%eax 107c2d: 74 79 je 107ca8 <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); the_link = *loc; 107c2f: 8d 7d cc lea -0x34(%ebp),%edi 107c32: b9 05 00 00 00 mov $0x5,%ecx 107c37: 89 de mov %ebx,%esi 107c39: f3 a5 rep movsl %ds:(%esi),%es:(%edi) the_link.node_access = node->info.hard_link.link_node; 107c3b: 89 45 cc mov %eax,-0x34(%ebp) IMFS_Set_handlers( &the_link ); 107c3e: 83 ec 0c sub $0xc,%esp 107c41: 8d 75 cc lea -0x34(%ebp),%esi 107c44: 56 push %esi 107c45: 89 55 c4 mov %edx,-0x3c(%ebp) 107c48: e8 9b 74 00 00 call 10f0e8 /* * If removing the last hard link to a node, then we need * to remove the node that is a link and the node itself. */ if ( node->info.hard_link.link_node->st_nlink == 1) 107c4d: 8b 55 c4 mov -0x3c(%ebp),%edx 107c50: 8b 42 50 mov 0x50(%edx),%eax 107c53: 8b 48 34 mov 0x34(%eax),%ecx 107c56: 83 c4 10 add $0x10,%esp 107c59: 66 83 f9 01 cmp $0x1,%cx 107c5d: 74 27 je 107c86 if ( result != 0 ) return -1; } else { node->info.hard_link.link_node->st_nlink --; 107c5f: 49 dec %ecx 107c60: 66 89 48 34 mov %cx,0x34(%eax) IMFS_update_ctime( node->info.hard_link.link_node ); 107c64: 83 ec 08 sub $0x8,%esp 107c67: 6a 00 push $0x0 107c69: 8d 45 e0 lea -0x20(%ebp),%eax 107c6c: 50 push %eax 107c6d: 89 55 c4 mov %edx,-0x3c(%ebp) 107c70: e8 bb 04 00 00 call 108130 107c75: 8b 55 c4 mov -0x3c(%ebp),%edx 107c78: 8b 42 50 mov 0x50(%edx),%eax 107c7b: 8b 55 e0 mov -0x20(%ebp),%edx 107c7e: 89 50 48 mov %edx,0x48(%eax) 107c81: 83 c4 10 add $0x10,%esp 107c84: eb 8a jmp 107c10 * to remove the node that is a link and the node itself. */ if ( node->info.hard_link.link_node->st_nlink == 1) { result = (*the_link.handlers->rmnod_h)( parentloc, &the_link ); 107c86: 83 ec 08 sub $0x8,%esp 107c89: 56 push %esi 107c8a: ff 75 08 pushl 0x8(%ebp) 107c8d: 8b 45 d4 mov -0x2c(%ebp),%eax 107c90: ff 50 34 call *0x34(%eax) if ( result != 0 ) 107c93: 83 c4 10 add $0x10,%esp 107c96: 85 c0 test %eax,%eax 107c98: 0f 84 72 ff ff ff je 107c10 return -1; 107c9e: b8 ff ff ff ff mov $0xffffffff,%eax 107ca3: e9 78 ff ff ff jmp 107c20 */ if ( node->type == IMFS_HARD_LINK ) { if ( !node->info.hard_link.link_node ) rtems_set_errno_and_return_minus_one( EINVAL ); 107ca8: e8 c3 b5 00 00 call 113270 <__errno> <== NOT EXECUTED 107cad: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 107cb3: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 107cb8: e9 63 ff ff ff jmp 107c20 <== NOT EXECUTED =============================================================================== 00107cc0 : #include int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry ) { 107cc0: 55 push %ebp 107cc1: 89 e5 mov %esp,%ebp 107cc3: 83 ec 08 sub $0x8,%esp IMFS_jnode_t *node; node = mt_entry->mt_point_node.node_access; 107cc6: 8b 45 08 mov 0x8(%ebp),%eax 107cc9: 8b 40 08 mov 0x8(%eax),%eax /* * Is the node that we are mounting onto a directory node ? */ if ( node->type != IMFS_DIRECTORY ) 107ccc: 83 78 4c 01 cmpl $0x1,0x4c(%eax) 107cd0: 75 12 jne 107ce4 <== NEVER TAKEN /* * Did the node indicate that there was a directory mounted here? */ if ( node->info.directory.mt_fs == NULL ) 107cd2: 8b 50 5c mov 0x5c(%eax),%edx 107cd5: 85 d2 test %edx,%edx 107cd7: 74 1d je 107cf6 <== NEVER TAKEN /* * Set the mt_fs pointer to indicate that there is no longer * a file system mounted to this point. */ node->info.directory.mt_fs = NULL; 107cd9: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax) return 0; 107ce0: 31 c0 xor %eax,%eax } 107ce2: c9 leave 107ce3: c3 ret /* * Is the node that we are mounting onto a directory node ? */ if ( node->type != IMFS_DIRECTORY ) rtems_set_errno_and_return_minus_one( ENOTDIR ); 107ce4: e8 87 b5 00 00 call 113270 <__errno> <== NOT EXECUTED 107ce9: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED 107cef: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED */ node->info.directory.mt_fs = NULL; return 0; } 107cf4: c9 leave <== NOT EXECUTED 107cf5: c3 ret <== NOT EXECUTED /* * Did the node indicate that there was a directory mounted here? */ if ( node->info.directory.mt_fs == NULL ) rtems_set_errno_and_return_minus_one( EINVAL ); /* XXX */ 107cf6: e8 75 b5 00 00 call 113270 <__errno> <== NOT EXECUTED 107cfb: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 107d01: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED */ node->info.directory.mt_fs = NULL; return 0; } 107d06: c9 leave <== NOT EXECUTED 107d07: c3 ret <== NOT EXECUTED =============================================================================== 001082dc : void RTEMS_Malloc_Initialize( void *heap_begin, uintptr_t heap_size, size_t sbrk_amount ) { 1082dc: 55 push %ebp 1082dd: 89 e5 mov %esp,%ebp 1082df: 57 push %edi 1082e0: 56 push %esi 1082e1: 53 push %ebx 1082e2: 83 ec 0c sub $0xc,%esp 1082e5: 8b 5d 08 mov 0x8(%ebp),%ebx 1082e8: 8b 75 0c mov 0xc(%ebp),%esi 1082eb: 8b 7d 10 mov 0x10(%ebp),%edi /* * If configured, initialize the statistics support */ if ( rtems_malloc_statistics_helpers != NULL ) { 1082ee: a1 e8 5f 12 00 mov 0x125fe8,%eax 1082f3: 85 c0 test %eax,%eax 1082f5: 74 02 je 1082f9 (*rtems_malloc_statistics_helpers->initialize)(); 1082f7: ff 10 call *(%eax) } /* * Initialize the garbage collection list to start with nothing on it. */ malloc_deferred_frees_initialize(); 1082f9: e8 76 ff ff ff call 108274 /* * Initialize the optional sbrk support for extending the heap */ if ( rtems_malloc_sbrk_helpers != NULL ) { 1082fe: a1 ec 5f 12 00 mov 0x125fec,%eax 108303: 85 c0 test %eax,%eax 108305: 74 0e je 108315 heap_begin = (*rtems_malloc_sbrk_helpers->initialize)( 108307: 83 ec 08 sub $0x8,%esp 10830a: 57 push %edi 10830b: 53 push %ebx 10830c: ff 10 call *(%eax) 10830e: 89 c3 mov %eax,%ebx 108310: 83 c4 10 add $0x10,%esp heap_begin, sbrk_amount ); heap_size = (uintptr_t) sbrk_amount; 108313: 89 fe mov %edi,%esi * of the time under UNIX because zero'ing memory when it is first * given to a process eliminates the chance of a process seeing data * left over from another process. This would be a security violation. */ if ( 108315: 80 3d e4 5f 12 00 00 cmpb $0x0,0x125fe4 10831c: 75 1f jne 10833d !rtems_unified_work_area && rtems_configuration_get_do_zero_of_workspace() 10831e: 80 3d a8 3a 12 00 00 cmpb $0x0,0x123aa8 108325: 75 41 jne 108368 void *area_begin, uintptr_t area_size, uintptr_t page_size ) { return _Heap_Initialize( heap, area_begin, area_size, page_size ); 108327: 6a 04 push $0x4 108329: 56 push %esi 10832a: 53 push %ebx 10832b: ff 35 b0 39 12 00 pushl 0x1239b0 108331: e8 b6 43 00 00 call 10c6ec <_Heap_Initialize> RTEMS_Malloc_Heap, heap_begin, heap_size, CPU_HEAP_ALIGNMENT ); if ( status == 0 ) { 108336: 83 c4 10 add $0x10,%esp 108339: 85 c0 test %eax,%eax 10833b: 74 3e je 10837b rtems_fatal_error_occurred( RTEMS_NO_MEMORY ); } } MSBUMP( space_available, _Protected_heap_Get_size(RTEMS_Malloc_Heap) ); 10833d: 8b 1d 40 7c 12 00 mov 0x127c40,%ebx 108343: 83 ec 0c sub $0xc,%esp 108346: ff 35 b0 39 12 00 pushl 0x1239b0 10834c: e8 07 4e 00 00 call 10d158 <_Protected_heap_Get_size> 108351: 8d 1c 18 lea (%eax,%ebx,1),%ebx 108354: 89 1d 40 7c 12 00 mov %ebx,0x127c40 10835a: 83 c4 10 add $0x10,%esp } 10835d: 8d 65 f4 lea -0xc(%ebp),%esp 108360: 5b pop %ebx 108361: 5e pop %esi 108362: 5f pop %edi 108363: c9 leave 108364: c3 ret 108365: 8d 76 00 lea 0x0(%esi),%esi if ( !rtems_unified_work_area && rtems_configuration_get_do_zero_of_workspace() ) { memset( heap_begin, 0, heap_size ); 108368: 31 c0 xor %eax,%eax 10836a: 89 df mov %ebx,%edi 10836c: 89 f1 mov %esi,%ecx 10836e: f3 aa rep stos %al,%es:(%edi) * Unfortunately we cannot use assert if this fails because if this * has failed we do not have a heap and if we do not have a heap * STDIO cannot work because there will be no buffers. */ if ( !rtems_unified_work_area ) { 108370: 80 3d e4 5f 12 00 00 cmpb $0x0,0x125fe4 108377: 74 ae je 108327 <== ALWAYS TAKEN 108379: eb c2 jmp 10833d <== NOT EXECUTED heap_begin, heap_size, CPU_HEAP_ALIGNMENT ); if ( status == 0 ) { rtems_fatal_error_occurred( RTEMS_NO_MEMORY ); 10837b: 83 ec 0c sub $0xc,%esp 10837e: 6a 1a push $0x1a 108380: e8 6f 39 00 00 call 10bcf4 =============================================================================== 00107df0 : static rtems_printk_plugin_t print_handler; void Stack_check_Dump_threads_usage( Thread_Control *the_thread ) { 107df0: 55 push %ebp <== NOT EXECUTED 107df1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107df3: 57 push %edi <== NOT EXECUTED 107df4: 56 push %esi <== NOT EXECUTED 107df5: 53 push %ebx <== NOT EXECUTED 107df6: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 107df9: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED /* * Obtain interrupt stack information */ #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE) if (the_thread == (Thread_Control *) -1) { 107dfc: 83 fb ff cmp $0xffffffff,%ebx <== NOT EXECUTED 107dff: 0f 84 37 01 00 00 je 107f3c <== NOT EXECUTED the_thread = 0; current = 0; } else #endif { stack = &the_thread->Start.Initial_stack; 107e05: 8d b3 b8 00 00 00 lea 0xb8(%ebx),%esi <== NOT EXECUTED current = (void *)_CPU_Context_Get_SP( &the_thread->Registers ); 107e0b: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED 107e11: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED 107e14: 8b 8b bc 00 00 00 mov 0xbc(%ebx),%ecx <== NOT EXECUTED } low = Stack_check_usable_stack_start(stack); 107e1a: 8d 51 10 lea 0x10(%ecx),%edx <== NOT EXECUTED 107e1d: 89 55 d4 mov %edx,-0x2c(%ebp) <== NOT EXECUTED size = Stack_check_usable_stack_size(stack); 107e20: 8b 3e mov (%esi),%edi <== NOT EXECUTED 107e22: 83 ef 10 sub $0x10,%edi <== NOT EXECUTED /* * start at lower memory and find first word that does not * match pattern */ base += PATTERN_SIZE_WORDS; 107e25: 8d 41 20 lea 0x20(%ecx),%eax <== NOT EXECUTED for (ebase = base + length; base < ebase; base++) 107e28: 89 fa mov %edi,%edx <== NOT EXECUTED 107e2a: 83 e2 fc and $0xfffffffc,%edx <== NOT EXECUTED 107e2d: 8d 14 10 lea (%eax,%edx,1),%edx <== NOT EXECUTED 107e30: 39 d0 cmp %edx,%eax <== NOT EXECUTED 107e32: 73 23 jae 107e57 <== NOT EXECUTED if (*base != U32_PATTERN) 107e34: 81 79 20 a5 a5 a5 a5 cmpl $0xa5a5a5a5,0x20(%ecx) <== NOT EXECUTED 107e3b: 74 13 je 107e50 <== NOT EXECUTED 107e3d: e9 a2 00 00 00 jmp 107ee4 <== NOT EXECUTED 107e42: 66 90 xchg %ax,%ax <== NOT EXECUTED 107e44: 81 38 a5 a5 a5 a5 cmpl $0xa5a5a5a5,(%eax) <== NOT EXECUTED 107e4a: 0f 85 94 00 00 00 jne 107ee4 <== NOT EXECUTED * start at lower memory and find first word that does not * match pattern */ base += PATTERN_SIZE_WORDS; for (ebase = base + length; base < ebase; base++) 107e50: 83 c0 04 add $0x4,%eax <== NOT EXECUTED 107e53: 39 c2 cmp %eax,%edx <== NOT EXECUTED 107e55: 77 ed ja 107e44 <== NOT EXECUTED high_water_mark = Stack_check_find_high_water_mark(low, size); if ( high_water_mark ) used = Stack_check_Calculate_used( low, size, high_water_mark ); else used = 0; 107e57: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) <== NOT EXECUTED #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE) if ( the_thread ) 107e5e: 85 db test %ebx,%ebx <== NOT EXECUTED 107e60: 0f 84 98 00 00 00 je 107efe <== NOT EXECUTED #endif { (*print_handler)( 107e66: a1 c4 a5 12 00 mov 0x12a5c4,%eax <== NOT EXECUTED 107e6b: 89 45 cc mov %eax,-0x34(%ebp) <== NOT EXECUTED 107e6e: 50 push %eax <== NOT EXECUTED 107e6f: 8d 45 e3 lea -0x1d(%ebp),%eax <== NOT EXECUTED 107e72: 50 push %eax <== NOT EXECUTED 107e73: 6a 05 push $0x5 <== NOT EXECUTED 107e75: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 107e78: e8 27 5f 00 00 call 10dda4 <== NOT EXECUTED 107e7d: 50 push %eax <== NOT EXECUTED 107e7e: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 107e81: 68 73 3d 12 00 push $0x123d73 <== NOT EXECUTED 107e86: ff 35 c0 a5 12 00 pushl 0x12a5c0 <== NOT EXECUTED 107e8c: ff 55 cc call *-0x34(%ebp) <== NOT EXECUTED 107e8f: 83 c4 20 add $0x20,%esp <== NOT EXECUTED (*print_handler)( print_context, " %010p - %010p %010p %8" PRId32 " ", stack->area, stack->area + stack->size - 1, 107e92: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED else { (*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 ); } #endif (*print_handler)( 107e95: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 107e98: 57 push %edi <== NOT EXECUTED 107e99: ff 75 d0 pushl -0x30(%ebp) <== NOT EXECUTED print_context, " %010p - %010p %010p %8" PRId32 " ", stack->area, stack->area + stack->size - 1, 107e9c: 8b 16 mov (%esi),%edx <== NOT EXECUTED else { (*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 ); } #endif (*print_handler)( 107e9e: 8d 54 10 ff lea -0x1(%eax,%edx,1),%edx <== NOT EXECUTED 107ea2: 52 push %edx <== NOT EXECUTED 107ea3: 50 push %eax <== NOT EXECUTED 107ea4: 68 8e 3d 12 00 push $0x123d8e <== NOT EXECUTED 107ea9: ff 35 c0 a5 12 00 pushl 0x12a5c0 <== NOT EXECUTED 107eaf: ff 15 c4 a5 12 00 call *0x12a5c4 <== NOT EXECUTED stack->area + stack->size - 1, current, size ); if (Stack_check_Initialized == 0) { 107eb5: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 107eb8: 8b 15 c8 a5 12 00 mov 0x12a5c8,%edx <== NOT EXECUTED 107ebe: 85 d2 test %edx,%edx <== NOT EXECUTED 107ec0: 74 5a je 107f1c <== NOT EXECUTED (*print_handler)( print_context, "Unavailable\n" ); } else { (*print_handler)( print_context, "%8" PRId32 "\n", used ); 107ec2: 50 push %eax <== NOT EXECUTED 107ec3: ff 75 d4 pushl -0x2c(%ebp) <== NOT EXECUTED 107ec6: 68 b9 3d 12 00 push $0x123db9 <== NOT EXECUTED 107ecb: ff 35 c0 a5 12 00 pushl 0x12a5c0 <== NOT EXECUTED 107ed1: ff 15 c4 a5 12 00 call *0x12a5c4 <== NOT EXECUTED 107ed7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } 107eda: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 107edd: 5b pop %ebx <== NOT EXECUTED 107ede: 5e pop %esi <== NOT EXECUTED 107edf: 5f pop %edi <== NOT EXECUTED 107ee0: c9 leave <== NOT EXECUTED 107ee1: c3 ret <== NOT EXECUTED 107ee2: 66 90 xchg %ax,%ax <== NOT EXECUTED low = Stack_check_usable_stack_start(stack); size = Stack_check_usable_stack_size(stack); high_water_mark = Stack_check_find_high_water_mark(low, size); if ( high_water_mark ) 107ee4: 85 c0 test %eax,%eax <== NOT EXECUTED 107ee6: 0f 84 6b ff ff ff je 107e57 <== NOT EXECUTED used = Stack_check_Calculate_used( low, size, high_water_mark ); 107eec: 8b 55 d4 mov -0x2c(%ebp),%edx <== NOT EXECUTED 107eef: 01 fa add %edi,%edx <== NOT EXECUTED 107ef1: 29 c2 sub %eax,%edx <== NOT EXECUTED 107ef3: 89 55 d4 mov %edx,-0x2c(%ebp) <== NOT EXECUTED else used = 0; #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE) if ( the_thread ) 107ef6: 85 db test %ebx,%ebx <== NOT EXECUTED 107ef8: 0f 85 68 ff ff ff jne 107e66 <== NOT EXECUTED rtems_object_get_name( the_thread->Object.id, sizeof(name), name ) ); } #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE) else { (*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 ); 107efe: 51 push %ecx <== NOT EXECUTED 107eff: 6a ff push $0xffffffff <== NOT EXECUTED 107f01: 68 80 3d 12 00 push $0x123d80 <== NOT EXECUTED 107f06: ff 35 c0 a5 12 00 pushl 0x12a5c0 <== NOT EXECUTED 107f0c: ff 15 c4 a5 12 00 call *0x12a5c4 <== NOT EXECUTED 107f12: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107f15: e9 78 ff ff ff jmp 107e92 <== NOT EXECUTED 107f1a: 66 90 xchg %ax,%ax <== NOT EXECUTED current, size ); if (Stack_check_Initialized == 0) { (*print_handler)( print_context, "Unavailable\n" ); 107f1c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 107f1f: 68 ac 3d 12 00 push $0x123dac <== NOT EXECUTED 107f24: ff 35 c0 a5 12 00 pushl 0x12a5c0 <== NOT EXECUTED 107f2a: ff 15 c4 a5 12 00 call *0x12a5c4 <== NOT EXECUTED 107f30: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } else { (*print_handler)( print_context, "%8" PRId32 "\n", used ); } } 107f33: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 107f36: 5b pop %ebx <== NOT EXECUTED 107f37: 5e pop %esi <== NOT EXECUTED 107f38: 5f pop %edi <== NOT EXECUTED 107f39: c9 leave <== NOT EXECUTED 107f3a: c3 ret <== NOT EXECUTED 107f3b: 90 nop <== NOT EXECUTED /* * Obtain interrupt stack information */ #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE) if (the_thread == (Thread_Control *) -1) { if (!Stack_check_Interrupt_stack.area) 107f3c: 8b 0d 34 a9 12 00 mov 0x12a934,%ecx <== NOT EXECUTED 107f42: 85 c9 test %ecx,%ecx <== NOT EXECUTED 107f44: 74 94 je 107eda <== NOT EXECUTED return; stack = &Stack_check_Interrupt_stack; 107f46: be 30 a9 12 00 mov $0x12a930,%esi <== NOT EXECUTED the_thread = 0; current = 0; 107f4b: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp) <== NOT EXECUTED #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE) if (the_thread == (Thread_Control *) -1) { if (!Stack_check_Interrupt_stack.area) return; stack = &Stack_check_Interrupt_stack; the_thread = 0; 107f52: 31 db xor %ebx,%ebx <== NOT EXECUTED 107f54: e9 c1 fe ff ff jmp 107e1a <== NOT EXECUTED =============================================================================== 00107f5c : /* * Stack_check_Initialize */ void Stack_check_Initialize( void ) { 107f5c: 55 push %ebp 107f5d: 89 e5 mov %esp,%ebp 107f5f: 57 push %edi static uint32_t pattern[ 4 ] = { 0xFEEDF00D, 0x0BAD0D06, /* FEED FOOD to BAD DOG */ 0xDEADF00D, 0x600D0D06 /* DEAD FOOD but GOOD DOG */ }; if ( Stack_check_Initialized ) 107f60: 8b 15 c8 a5 12 00 mov 0x12a5c8,%edx 107f66: 85 d2 test %edx,%edx 107f68: 75 5a jne 107fc4 /* * Dope the pattern and fill areas */ p = Stack_check_Pattern.pattern; for ( i = 0; i < PATTERN_SIZE_WORDS; i++ ) { p[i] = pattern[ i%4 ]; 107f6a: c7 05 20 a9 12 00 0d movl $0xfeedf00d,0x12a920 107f71: f0 ed fe 107f74: c7 05 24 a9 12 00 06 movl $0xbad0d06,0x12a924 107f7b: 0d ad 0b 107f7e: c7 05 28 a9 12 00 0d movl $0xdeadf00d,0x12a928 107f85: f0 ad de 107f88: c7 05 2c a9 12 00 06 movl $0x600d0d06,0x12a92c 107f8f: 0d 0d 60 /* * If appropriate, setup the interrupt stack for high water testing * also. */ #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE) if (_CPU_Interrupt_stack_low && _CPU_Interrupt_stack_high) { 107f92: 8b 15 cc b0 12 00 mov 0x12b0cc,%edx 107f98: 85 d2 test %edx,%edx 107f9a: 74 1e je 107fba <== NEVER TAKEN 107f9c: 8b 0d d0 b0 12 00 mov 0x12b0d0,%ecx 107fa2: 85 c9 test %ecx,%ecx 107fa4: 74 14 je 107fba <== NEVER TAKEN Stack_check_Interrupt_stack.area = _CPU_Interrupt_stack_low; 107fa6: 89 15 34 a9 12 00 mov %edx,0x12a934 Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high - 107fac: 29 d1 sub %edx,%ecx 107fae: 89 0d 30 a9 12 00 mov %ecx,0x12a930 (char *) _CPU_Interrupt_stack_low; Stack_check_Dope_stack(&Stack_check_Interrupt_stack); 107fb4: b0 a5 mov $0xa5,%al 107fb6: 89 d7 mov %edx,%edi 107fb8: f3 aa rep stos %al,%es:(%edi) } #endif Stack_check_Initialized = 1; 107fba: c7 05 c8 a5 12 00 01 movl $0x1,0x12a5c8 107fc1: 00 00 00 } 107fc4: 5f pop %edi 107fc5: c9 leave 107fc6: c3 ret =============================================================================== 00108018 : Thread_Control *running, bool pattern_ok ) RTEMS_COMPILER_NO_RETURN_ATTRIBUTE; void Stack_check_report_blown_task(Thread_Control *running, bool pattern_ok) { 108018: 55 push %ebp <== NOT EXECUTED 108019: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10801b: 56 push %esi <== NOT EXECUTED 10801c: 53 push %ebx <== NOT EXECUTED 10801d: 83 ec 3c sub $0x3c,%esp <== NOT EXECUTED 108020: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 108023: 8a 55 0c mov 0xc(%ebp),%dl <== NOT EXECUTED Stack_Control *stack = &running->Start.Initial_stack; void *pattern_area = Stack_check_Get_pattern(stack); 108026: 8b b3 bc 00 00 00 mov 0xbc(%ebx),%esi <== NOT EXECUTED char name[32]; printk("BLOWN STACK!!!\n"); 10802c: 68 bf 3d 12 00 push $0x123dbf <== NOT EXECUTED 108031: 88 55 d4 mov %dl,-0x2c(%ebp) <== NOT EXECUTED 108034: e8 cb 1b 00 00 call 109c04 <== NOT EXECUTED printk("task control block: 0x%08" PRIxPTR "\n", running); 108039: 5a pop %edx <== NOT EXECUTED 10803a: 59 pop %ecx <== NOT EXECUTED 10803b: 53 push %ebx <== NOT EXECUTED 10803c: 68 cf 3d 12 00 push $0x123dcf <== NOT EXECUTED 108041: e8 be 1b 00 00 call 109c04 <== NOT EXECUTED printk("task ID: 0x%08lx\n", (unsigned long) running->Object.id); 108046: 59 pop %ecx <== NOT EXECUTED 108047: 58 pop %eax <== NOT EXECUTED 108048: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 10804b: 68 ec 3d 12 00 push $0x123dec <== NOT EXECUTED 108050: e8 af 1b 00 00 call 109c04 <== NOT EXECUTED printk( 108055: 58 pop %eax <== NOT EXECUTED 108056: 5a pop %edx <== NOT EXECUTED 108057: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED 10805a: 68 fe 3d 12 00 push $0x123dfe <== NOT EXECUTED 10805f: e8 a0 1b 00 00 call 109c04 <== NOT EXECUTED "task name: 0x%08" PRIx32 "\n", running->Object.name.name_u32 ); printk( 108064: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 108067: 8d 45 d8 lea -0x28(%ebp),%eax <== NOT EXECUTED 10806a: 50 push %eax <== NOT EXECUTED 10806b: 6a 20 push $0x20 <== NOT EXECUTED 10806d: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 108070: e8 2f 5d 00 00 call 10dda4 <== NOT EXECUTED 108075: 5a pop %edx <== NOT EXECUTED 108076: 59 pop %ecx <== NOT EXECUTED 108077: 50 push %eax <== NOT EXECUTED 108078: 68 12 3e 12 00 push $0x123e12 <== NOT EXECUTED 10807d: e8 82 1b 00 00 call 109c04 <== NOT EXECUTED ); printk( "task stack area (%lu Bytes): 0x%08" PRIxPTR " .. 0x%08" PRIxPTR "\n", (unsigned long) stack->size, stack->area, ((char *) stack->area + stack->size) 108082: 8b 8b bc 00 00 00 mov 0xbc(%ebx),%ecx <== NOT EXECUTED 108088: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED ); printk( "task name string: %s\n", rtems_object_get_name(running->Object.id, sizeof(name), name) ); printk( 10808e: 8d 1c 01 lea (%ecx,%eax,1),%ebx <== NOT EXECUTED 108091: 53 push %ebx <== NOT EXECUTED 108092: 51 push %ecx <== NOT EXECUTED 108093: 50 push %eax <== NOT EXECUTED 108094: 68 40 3e 12 00 push $0x123e40 <== NOT EXECUTED 108099: e8 66 1b 00 00 call 109c04 <== NOT EXECUTED "task stack area (%lu Bytes): 0x%08" PRIxPTR " .. 0x%08" PRIxPTR "\n", (unsigned long) stack->size, stack->area, ((char *) stack->area + stack->size) ); if (!pattern_ok) { 10809e: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 1080a1: 8a 55 d4 mov -0x2c(%ebp),%dl <== NOT EXECUTED 1080a4: 84 d2 test %dl,%dl <== NOT EXECUTED 1080a6: 74 10 je 1080b8 <== NOT EXECUTED rtems_configuration_get_user_multiprocessing_table()->node ); } #endif rtems_fatal_error_occurred(0x81); 1080a8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1080ab: 68 81 00 00 00 push $0x81 <== NOT EXECUTED 1080b0: e8 ff 64 00 00 call 10e5b4 <== NOT EXECUTED 1080b5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED ) RTEMS_COMPILER_NO_RETURN_ATTRIBUTE; void Stack_check_report_blown_task(Thread_Control *running, bool pattern_ok) { Stack_Control *stack = &running->Start.Initial_stack; void *pattern_area = Stack_check_Get_pattern(stack); 1080b8: 8d 46 08 lea 0x8(%esi),%eax <== NOT EXECUTED (unsigned long) stack->size, stack->area, ((char *) stack->area + stack->size) ); if (!pattern_ok) { printk( 1080bb: 83 c6 18 add $0x18,%esi <== NOT EXECUTED 1080be: 56 push %esi <== NOT EXECUTED 1080bf: 50 push %eax <== NOT EXECUTED 1080c0: 6a 10 push $0x10 <== NOT EXECUTED 1080c2: 68 74 3e 12 00 push $0x123e74 <== NOT EXECUTED 1080c7: e8 38 1b 00 00 call 109c04 <== NOT EXECUTED 1080cc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1080cf: eb d7 jmp 1080a8 <== NOT EXECUTED =============================================================================== 0010be9c <_API_extensions_Run_postdriver>: * * _API_extensions_Run_postdriver */ void _API_extensions_Run_postdriver( void ) { 10be9c: 55 push %ebp 10be9d: 89 e5 mov %esp,%ebp 10be9f: 53 push %ebx 10bea0: 83 ec 04 sub $0x4,%esp the_extension = (API_extensions_Control *) the_node; (*the_extension->postswitch_hook)( _Thread_Executing ); } } 10bea3: 8b 1d b8 7f 12 00 mov 0x127fb8,%ebx void _API_extensions_Run_postdriver( void ) { Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _Chain_First( &_API_extensions_List ); 10bea9: 81 fb bc 7f 12 00 cmp $0x127fbc,%ebx 10beaf: 74 10 je 10bec1 <_API_extensions_Run_postdriver+0x25><== NEVER TAKEN 10beb1: 8d 76 00 lea 0x0(%esi),%esi * Currently all APIs configure this hook so it is always non-NULL. */ #if defined(FUNCTIONALITY_NOT_CURRENTLY_USED_BY_ANY_API) if ( the_extension->postdriver_hook ) #endif (*the_extension->postdriver_hook)(); 10beb4: ff 53 08 call *0x8(%ebx) Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _Chain_First( &_API_extensions_List ); !_Chain_Is_tail( &_API_extensions_List, the_node ) ; the_node = the_node->next ) { 10beb7: 8b 1b mov (%ebx),%ebx void _API_extensions_Run_postdriver( void ) { Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _Chain_First( &_API_extensions_List ); 10beb9: 81 fb bc 7f 12 00 cmp $0x127fbc,%ebx 10bebf: 75 f3 jne 10beb4 <_API_extensions_Run_postdriver+0x18> #if defined(FUNCTIONALITY_NOT_CURRENTLY_USED_BY_ANY_API) if ( the_extension->postdriver_hook ) #endif (*the_extension->postdriver_hook)(); } } 10bec1: 58 pop %eax 10bec2: 5b pop %ebx 10bec3: c9 leave 10bec4: c3 ret =============================================================================== 0010bec8 <_API_extensions_Run_postswitch>: * * _API_extensions_Run_postswitch */ void _API_extensions_Run_postswitch( void ) { 10bec8: 55 push %ebp 10bec9: 89 e5 mov %esp,%ebp 10becb: 53 push %ebx 10becc: 83 ec 04 sub $0x4,%esp the_extension = (API_extensions_Control *) the_node; (*the_extension->postswitch_hook)( _Thread_Executing ); } } 10becf: 8b 1d b8 7f 12 00 mov 0x127fb8,%ebx void _API_extensions_Run_postswitch( void ) { Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _Chain_First( &_API_extensions_List ); 10bed5: 81 fb bc 7f 12 00 cmp $0x127fbc,%ebx 10bedb: 74 1c je 10bef9 <_API_extensions_Run_postswitch+0x31><== NEVER TAKEN 10bedd: 8d 76 00 lea 0x0(%esi),%esi !_Chain_Is_tail( &_API_extensions_List, the_node ) ; the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; (*the_extension->postswitch_hook)( _Thread_Executing ); 10bee0: 83 ec 0c sub $0xc,%esp 10bee3: ff 35 38 83 12 00 pushl 0x128338 10bee9: ff 53 0c call *0xc(%ebx) Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _Chain_First( &_API_extensions_List ); !_Chain_Is_tail( &_API_extensions_List, the_node ) ; the_node = the_node->next ) { 10beec: 8b 1b mov (%ebx),%ebx void _API_extensions_Run_postswitch( void ) { Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _Chain_First( &_API_extensions_List ); 10beee: 83 c4 10 add $0x10,%esp 10bef1: 81 fb bc 7f 12 00 cmp $0x127fbc,%ebx 10bef7: 75 e7 jne 10bee0 <_API_extensions_Run_postswitch+0x18> the_extension = (API_extensions_Control *) the_node; (*the_extension->postswitch_hook)( _Thread_Executing ); } } 10bef9: 8b 5d fc mov -0x4(%ebp),%ebx 10befc: c9 leave 10befd: c3 ret =============================================================================== 0010e3e0 <_CORE_RWLock_Obtain_for_reading>: Objects_Id id, bool wait, Watchdog_Interval timeout, CORE_RWLock_API_mp_support_callout api_rwlock_mp_support ) { 10e3e0: 55 push %ebp 10e3e1: 89 e5 mov %esp,%ebp 10e3e3: 57 push %edi 10e3e4: 56 push %esi 10e3e5: 53 push %ebx 10e3e6: 83 ec 1c sub $0x1c,%esp 10e3e9: 8b 5d 08 mov 0x8(%ebp),%ebx 10e3ec: 8b 7d 0c mov 0xc(%ebp),%edi 10e3ef: 8b 4d 14 mov 0x14(%ebp),%ecx 10e3f2: 8a 55 10 mov 0x10(%ebp),%dl ISR_Level level; Thread_Control *executing = _Thread_Executing; 10e3f5: 8b 35 d8 bc 12 00 mov 0x12bcd8,%esi * If unlocked, then OK to read. * If locked for reading and no waiters, then OK to read. * If any thread is waiting, then we wait. */ _ISR_Disable( level ); 10e3fb: 9c pushf 10e3fc: fa cli 10e3fd: 8f 45 e4 popl -0x1c(%ebp) switch ( the_rwlock->current_state ) { 10e400: 8b 43 44 mov 0x44(%ebx),%eax 10e403: 85 c0 test %eax,%eax 10e405: 75 1d jne 10e424 <_CORE_RWLock_Obtain_for_reading+0x44> case CORE_RWLOCK_UNLOCKED: the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING; 10e407: c7 43 44 01 00 00 00 movl $0x1,0x44(%ebx) the_rwlock->number_of_readers += 1; 10e40e: ff 43 48 incl 0x48(%ebx) _ISR_Enable( level ); 10e411: ff 75 e4 pushl -0x1c(%ebp) 10e414: 9d popf executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 10e415: c7 46 34 00 00 00 00 movl $0x0,0x34(%esi) timeout, _CORE_RWLock_Timeout ); /* return to API level so it can dispatch and we block */ } 10e41c: 8d 65 f4 lea -0xc(%ebp),%esp 10e41f: 5b pop %ebx 10e420: 5e pop %esi 10e421: 5f pop %edi 10e422: c9 leave 10e423: c3 ret * If locked for reading and no waiters, then OK to read. * If any thread is waiting, then we wait. */ _ISR_Disable( level ); switch ( the_rwlock->current_state ) { 10e424: 48 dec %eax 10e425: 74 51 je 10e478 <_CORE_RWLock_Obtain_for_reading+0x98> /* * If the thread is not willing to wait, then return immediately. */ if ( !wait ) { 10e427: 84 d2 test %dl,%dl 10e429: 75 15 jne 10e440 <_CORE_RWLock_Obtain_for_reading+0x60> _ISR_Enable( level ); 10e42b: ff 75 e4 pushl -0x1c(%ebp) 10e42e: 9d popf executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; 10e42f: c7 46 34 02 00 00 00 movl $0x2,0x34(%esi) timeout, _CORE_RWLock_Timeout ); /* return to API level so it can dispatch and we block */ } 10e436: 8d 65 f4 lea -0xc(%ebp),%esp 10e439: 5b pop %ebx 10e43a: 5e pop %esi 10e43b: 5f pop %edi 10e43c: c9 leave 10e43d: c3 ret 10e43e: 66 90 xchg %ax,%ax 10e440: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx) /* * We need to wait to enter this critical section */ _Thread_queue_Enter_critical_section( &the_rwlock->Wait_queue ); executing->Wait.queue = &the_rwlock->Wait_queue; 10e447: 89 5e 44 mov %ebx,0x44(%esi) executing->Wait.id = id; 10e44a: 89 7e 20 mov %edi,0x20(%esi) executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_READ; 10e44d: c7 46 30 00 00 00 00 movl $0x0,0x30(%esi) executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 10e454: c7 46 34 00 00 00 00 movl $0x0,0x34(%esi) _ISR_Enable( level ); 10e45b: ff 75 e4 pushl -0x1c(%ebp) 10e45e: 9d popf _Thread_queue_Enqueue_with_handler( 10e45f: c7 45 10 e4 e5 10 00 movl $0x10e5e4,0x10(%ebp) 10e466: 89 4d 0c mov %ecx,0xc(%ebp) 10e469: 89 5d 08 mov %ebx,0x8(%ebp) timeout, _CORE_RWLock_Timeout ); /* return to API level so it can dispatch and we block */ } 10e46c: 8d 65 f4 lea -0xc(%ebp),%esp 10e46f: 5b pop %ebx 10e470: 5e pop %esi 10e471: 5f pop %edi 10e472: c9 leave executing->Wait.id = id; executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_READ; executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; _ISR_Enable( level ); _Thread_queue_Enqueue_with_handler( 10e473: e9 1c 1c 00 00 jmp 110094 <_Thread_queue_Enqueue_with_handler> executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; return; case CORE_RWLOCK_LOCKED_FOR_READING: { Thread_Control *waiter; waiter = _Thread_queue_First( &the_rwlock->Wait_queue ); 10e478: 83 ec 0c sub $0xc,%esp 10e47b: 53 push %ebx 10e47c: 88 55 e0 mov %dl,-0x20(%ebp) 10e47f: 89 4d dc mov %ecx,-0x24(%ebp) 10e482: e8 35 1f 00 00 call 1103bc <_Thread_queue_First> if ( !waiter ) { 10e487: 83 c4 10 add $0x10,%esp 10e48a: 85 c0 test %eax,%eax 10e48c: 8a 55 e0 mov -0x20(%ebp),%dl 10e48f: 8b 4d dc mov -0x24(%ebp),%ecx 10e492: 75 93 jne 10e427 <_CORE_RWLock_Obtain_for_reading+0x47> the_rwlock->number_of_readers += 1; 10e494: ff 43 48 incl 0x48(%ebx) _ISR_Enable( level ); 10e497: ff 75 e4 pushl -0x1c(%ebp) 10e49a: 9d popf executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 10e49b: c7 46 34 00 00 00 00 movl $0x0,0x34(%esi) return; 10e4a2: e9 75 ff ff ff jmp 10e41c <_CORE_RWLock_Obtain_for_reading+0x3c> =============================================================================== 0010e4a8 <_CORE_RWLock_Obtain_for_writing>: Objects_Id id, bool wait, Watchdog_Interval timeout, CORE_RWLock_API_mp_support_callout api_rwlock_mp_support ) { 10e4a8: 55 push %ebp 10e4a9: 89 e5 mov %esp,%ebp 10e4ab: 57 push %edi 10e4ac: 56 push %esi 10e4ad: 53 push %ebx 10e4ae: 83 ec 0c sub $0xc,%esp 10e4b1: 8b 45 08 mov 0x8(%ebp),%eax 10e4b4: 8b 7d 0c mov 0xc(%ebp),%edi 10e4b7: 8b 75 14 mov 0x14(%ebp),%esi 10e4ba: 8a 5d 10 mov 0x10(%ebp),%bl ISR_Level level; Thread_Control *executing = _Thread_Executing; 10e4bd: 8b 15 d8 bc 12 00 mov 0x12bcd8,%edx * Otherwise, we have to block. * If locked for reading and no waiters, then OK to read. * If any thread is waiting, then we wait. */ _ISR_Disable( level ); 10e4c3: 9c pushf 10e4c4: fa cli 10e4c5: 59 pop %ecx switch ( the_rwlock->current_state ) { 10e4c6: 83 78 44 00 cmpl $0x0,0x44(%eax) 10e4ca: 75 18 jne 10e4e4 <_CORE_RWLock_Obtain_for_writing+0x3c> case CORE_RWLOCK_UNLOCKED: the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING; 10e4cc: c7 40 44 02 00 00 00 movl $0x2,0x44(%eax) _ISR_Enable( level ); 10e4d3: 51 push %ecx 10e4d4: 9d popf executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 10e4d5: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx) _CORE_RWLock_Timeout ); /* return to API level so it can dispatch and we block */ } 10e4dc: 83 c4 0c add $0xc,%esp 10e4df: 5b pop %ebx 10e4e0: 5e pop %esi 10e4e1: 5f pop %edi 10e4e2: c9 leave 10e4e3: c3 ret /* * If the thread is not willing to wait, then return immediately. */ if ( !wait ) { 10e4e4: 84 db test %bl,%bl 10e4e6: 75 14 jne 10e4fc <_CORE_RWLock_Obtain_for_writing+0x54> _ISR_Enable( level ); 10e4e8: 51 push %ecx 10e4e9: 9d popf executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; 10e4ea: c7 42 34 02 00 00 00 movl $0x2,0x34(%edx) _CORE_RWLock_Timeout ); /* return to API level so it can dispatch and we block */ } 10e4f1: 83 c4 0c add $0xc,%esp 10e4f4: 5b pop %ebx 10e4f5: 5e pop %esi 10e4f6: 5f pop %edi 10e4f7: c9 leave 10e4f8: c3 ret 10e4f9: 8d 76 00 lea 0x0(%esi),%esi 10e4fc: c7 40 30 01 00 00 00 movl $0x1,0x30(%eax) /* * We need to wait to enter this critical section */ _Thread_queue_Enter_critical_section( &the_rwlock->Wait_queue ); executing->Wait.queue = &the_rwlock->Wait_queue; 10e503: 89 42 44 mov %eax,0x44(%edx) executing->Wait.id = id; 10e506: 89 7a 20 mov %edi,0x20(%edx) executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_WRITE; 10e509: c7 42 30 01 00 00 00 movl $0x1,0x30(%edx) executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 10e510: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx) _ISR_Enable( level ); 10e517: 51 push %ecx 10e518: 9d popf _Thread_queue_Enqueue_with_handler( 10e519: c7 45 10 e4 e5 10 00 movl $0x10e5e4,0x10(%ebp) 10e520: 89 75 0c mov %esi,0xc(%ebp) 10e523: 89 45 08 mov %eax,0x8(%ebp) _CORE_RWLock_Timeout ); /* return to API level so it can dispatch and we block */ } 10e526: 83 c4 0c add $0xc,%esp 10e529: 5b pop %ebx 10e52a: 5e pop %esi 10e52b: 5f pop %edi 10e52c: c9 leave executing->Wait.id = id; executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_WRITE; executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; _ISR_Enable( level ); _Thread_queue_Enqueue_with_handler( 10e52d: e9 62 1b 00 00 jmp 110094 <_Thread_queue_Enqueue_with_handler> =============================================================================== 0010e534 <_CORE_RWLock_Release>: */ CORE_RWLock_Status _CORE_RWLock_Release( CORE_RWLock_Control *the_rwlock ) { 10e534: 55 push %ebp 10e535: 89 e5 mov %esp,%ebp 10e537: 53 push %ebx 10e538: 83 ec 04 sub $0x4,%esp 10e53b: 8b 5d 08 mov 0x8(%ebp),%ebx ISR_Level level; Thread_Control *executing = _Thread_Executing; 10e53e: 8b 0d d8 bc 12 00 mov 0x12bcd8,%ecx * Otherwise, we have to block. * If locked for reading and no waiters, then OK to read. * If any thread is waiting, then we wait. */ _ISR_Disable( level ); 10e544: 9c pushf 10e545: fa cli 10e546: 5a pop %edx if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){ 10e547: 8b 43 44 mov 0x44(%ebx),%eax 10e54a: 85 c0 test %eax,%eax 10e54c: 74 7a je 10e5c8 <_CORE_RWLock_Release+0x94> _ISR_Enable( level ); executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; return CORE_RWLOCK_SUCCESSFUL; } if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) { 10e54e: 48 dec %eax 10e54f: 74 63 je 10e5b4 <_CORE_RWLock_Release+0x80> return CORE_RWLOCK_SUCCESSFUL; } } /* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */ executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 10e551: c7 41 34 00 00 00 00 movl $0x0,0x34(%ecx) /* * Implicitly transition to "unlocked" and find another thread interested * in obtaining this rwlock. */ the_rwlock->current_state = CORE_RWLOCK_UNLOCKED; 10e558: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) _ISR_Enable( level ); 10e55f: 52 push %edx 10e560: 9d popf next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue ); 10e561: 83 ec 0c sub $0xc,%esp 10e564: 53 push %ebx 10e565: e8 02 1a 00 00 call 10ff6c <_Thread_queue_Dequeue> if ( next ) { 10e56a: 83 c4 10 add $0x10,%esp 10e56d: 85 c0 test %eax,%eax 10e56f: 74 39 je 10e5aa <_CORE_RWLock_Release+0x76> if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) { 10e571: 83 78 30 01 cmpl $0x1,0x30(%eax) 10e575: 74 61 je 10e5d8 <_CORE_RWLock_Release+0xa4> } /* * Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING */ the_rwlock->number_of_readers += 1; 10e577: ff 43 48 incl 0x48(%ebx) the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING; 10e57a: c7 43 44 01 00 00 00 movl $0x1,0x44(%ebx) 10e581: eb 17 jmp 10e59a <_CORE_RWLock_Release+0x66> 10e583: 90 nop /* * Now see if more readers can be let go. */ while ( 1 ) { next = _Thread_queue_First( &the_rwlock->Wait_queue ); if ( !next || 10e584: 83 78 30 01 cmpl $0x1,0x30(%eax) 10e588: 74 20 je 10e5aa <_CORE_RWLock_Release+0x76><== NEVER TAKEN next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) return CORE_RWLOCK_SUCCESSFUL; the_rwlock->number_of_readers += 1; 10e58a: ff 43 48 incl 0x48(%ebx) _Thread_queue_Extract( &the_rwlock->Wait_queue, next ); 10e58d: 83 ec 08 sub $0x8,%esp 10e590: 50 push %eax 10e591: 53 push %ebx 10e592: e8 0d 1d 00 00 call 1102a4 <_Thread_queue_Extract> } 10e597: 83 c4 10 add $0x10,%esp /* * Now see if more readers can be let go. */ while ( 1 ) { next = _Thread_queue_First( &the_rwlock->Wait_queue ); 10e59a: 83 ec 0c sub $0xc,%esp 10e59d: 53 push %ebx 10e59e: e8 19 1e 00 00 call 1103bc <_Thread_queue_First> if ( !next || 10e5a3: 83 c4 10 add $0x10,%esp 10e5a6: 85 c0 test %eax,%eax 10e5a8: 75 da jne 10e584 <_CORE_RWLock_Release+0x50> } /* indentation is to match _ISR_Disable at top */ return CORE_RWLOCK_SUCCESSFUL; } 10e5aa: 31 c0 xor %eax,%eax 10e5ac: 8b 5d fc mov -0x4(%ebp),%ebx 10e5af: c9 leave 10e5b0: c3 ret 10e5b1: 8d 76 00 lea 0x0(%esi),%esi _ISR_Enable( level ); executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; return CORE_RWLOCK_SUCCESSFUL; } if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) { the_rwlock->number_of_readers -= 1; 10e5b4: 8b 43 48 mov 0x48(%ebx),%eax 10e5b7: 48 dec %eax 10e5b8: 89 43 48 mov %eax,0x48(%ebx) if ( the_rwlock->number_of_readers != 0 ) { 10e5bb: 85 c0 test %eax,%eax 10e5bd: 74 92 je 10e551 <_CORE_RWLock_Release+0x1d> /* must be unlocked again */ _ISR_Enable( level ); 10e5bf: 52 push %edx 10e5c0: 9d popf } /* indentation is to match _ISR_Disable at top */ return CORE_RWLOCK_SUCCESSFUL; } 10e5c1: 31 c0 xor %eax,%eax 10e5c3: 8b 5d fc mov -0x4(%ebp),%ebx 10e5c6: c9 leave 10e5c7: c3 ret * If any thread is waiting, then we wait. */ _ISR_Disable( level ); if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){ _ISR_Enable( level ); 10e5c8: 52 push %edx 10e5c9: 9d popf executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; 10e5ca: c7 41 34 02 00 00 00 movl $0x2,0x34(%ecx) } /* indentation is to match _ISR_Disable at top */ return CORE_RWLOCK_SUCCESSFUL; } 10e5d1: 31 c0 xor %eax,%eax 10e5d3: 8b 5d fc mov -0x4(%ebp),%ebx 10e5d6: c9 leave 10e5d7: c3 ret next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue ); if ( next ) { if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) { the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING; 10e5d8: c7 43 44 02 00 00 00 movl $0x2,0x44(%ebx) return CORE_RWLOCK_SUCCESSFUL; 10e5df: eb c9 jmp 10e5aa <_CORE_RWLock_Release+0x76> =============================================================================== 0010e5e4 <_CORE_RWLock_Timeout>: void _CORE_RWLock_Timeout( Objects_Id id, void *ignored ) { 10e5e4: 55 push %ebp 10e5e5: 89 e5 mov %esp,%ebp 10e5e7: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10e5ea: 8d 45 f4 lea -0xc(%ebp),%eax 10e5ed: 50 push %eax 10e5ee: ff 75 08 pushl 0x8(%ebp) 10e5f1: e8 1e 16 00 00 call 10fc14 <_Thread_Get> switch ( location ) { 10e5f6: 83 c4 10 add $0x10,%esp 10e5f9: 8b 55 f4 mov -0xc(%ebp),%edx 10e5fc: 85 d2 test %edx,%edx 10e5fe: 75 17 jne 10e617 <_CORE_RWLock_Timeout+0x33><== NEVER TAKEN #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* impossible */ #endif break; case OBJECTS_LOCAL: _Thread_queue_Process_timeout( the_thread ); 10e600: 83 ec 0c sub $0xc,%esp 10e603: 50 push %eax 10e604: e8 93 1e 00 00 call 11049c <_Thread_queue_Process_timeout> */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 10e609: a1 30 b7 12 00 mov 0x12b730,%eax 10e60e: 48 dec %eax 10e60f: a3 30 b7 12 00 mov %eax,0x12b730 10e614: 83 c4 10 add $0x10,%esp _Thread_Unnest_dispatch(); break; } } 10e617: c9 leave 10e618: c3 ret =============================================================================== 001198dc <_CORE_message_queue_Broadcast>: Objects_Id id __attribute__((unused)), CORE_message_queue_API_mp_support_callout api_message_queue_mp_support __attribute__((unused)), #endif uint32_t *count ) { 1198dc: 55 push %ebp 1198dd: 89 e5 mov %esp,%ebp 1198df: 57 push %edi 1198e0: 56 push %esi 1198e1: 53 push %ebx 1198e2: 83 ec 1c sub $0x1c,%esp 1198e5: 8b 5d 08 mov 0x8(%ebp),%ebx Thread_Control *the_thread; uint32_t number_broadcasted; Thread_Wait_information *waitp; if ( size > the_message_queue->maximum_message_size ) { 1198e8: 8b 45 10 mov 0x10(%ebp),%eax 1198eb: 39 43 4c cmp %eax,0x4c(%ebx) 1198ee: 72 60 jb 119950 <_CORE_message_queue_Broadcast+0x74><== NEVER TAKEN * NOTE: This check is critical because threads can block on * send and receive and this ensures that we are broadcasting * the message to threads waiting to receive -- not to send. */ if ( the_message_queue->number_of_pending_messages != 0 ) { 1198f0: 8b 43 48 mov 0x48(%ebx),%eax 1198f3: 85 c0 test %eax,%eax 1198f5: 75 45 jne 11993c <_CORE_message_queue_Broadcast+0x60> 1198f7: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) 1198fe: eb 18 jmp 119918 <_CORE_message_queue_Broadcast+0x3c> */ number_broadcasted = 0; while ((the_thread = _Thread_queue_Dequeue(&the_message_queue->Wait_queue))) { waitp = &the_thread->Wait; number_broadcasted += 1; 119900: ff 45 e4 incl -0x1c(%ebp) const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 119903: 8b 42 2c mov 0x2c(%edx),%eax 119906: 89 c7 mov %eax,%edi 119908: 8b 75 0c mov 0xc(%ebp),%esi 11990b: 8b 4d 10 mov 0x10(%ebp),%ecx 11990e: f3 a4 rep movsb %ds:(%esi),%es:(%edi) buffer, waitp->return_argument_second.mutable_object, size ); *(size_t *) the_thread->Wait.return_argument = size; 119910: 8b 42 28 mov 0x28(%edx),%eax 119913: 8b 55 10 mov 0x10(%ebp),%edx 119916: 89 10 mov %edx,(%eax) /* * There must be no pending messages if there is a thread waiting to * receive a message. */ number_broadcasted = 0; while ((the_thread = 119918: 83 ec 0c sub $0xc,%esp 11991b: 53 push %ebx 11991c: e8 af 28 00 00 call 11c1d0 <_Thread_queue_Dequeue> 119921: 89 c2 mov %eax,%edx 119923: 83 c4 10 add $0x10,%esp 119926: 85 c0 test %eax,%eax 119928: 75 d6 jne 119900 <_CORE_message_queue_Broadcast+0x24> if ( !_Objects_Is_local_id( the_thread->Object.id ) ) (*api_message_queue_mp_support) ( the_thread, id ); #endif } *count = number_broadcasted; 11992a: 8b 55 e4 mov -0x1c(%ebp),%edx 11992d: 8b 45 1c mov 0x1c(%ebp),%eax 119930: 89 10 mov %edx,(%eax) return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 119932: 31 c0 xor %eax,%eax } 119934: 8d 65 f4 lea -0xc(%ebp),%esp 119937: 5b pop %ebx 119938: 5e pop %esi 119939: 5f pop %edi 11993a: c9 leave 11993b: c3 ret * send and receive and this ensures that we are broadcasting * the message to threads waiting to receive -- not to send. */ if ( the_message_queue->number_of_pending_messages != 0 ) { *count = 0; 11993c: 8b 55 1c mov 0x1c(%ebp),%edx 11993f: c7 02 00 00 00 00 movl $0x0,(%edx) return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 119945: 31 c0 xor %eax,%eax #endif } *count = number_broadcasted; return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; } 119947: 8d 65 f4 lea -0xc(%ebp),%esp 11994a: 5b pop %ebx 11994b: 5e pop %esi 11994c: 5f pop %edi 11994d: c9 leave 11994e: c3 ret 11994f: 90 nop Thread_Control *the_thread; uint32_t number_broadcasted; Thread_Wait_information *waitp; if ( size > the_message_queue->maximum_message_size ) { return CORE_MESSAGE_QUEUE_STATUS_INVALID_SIZE; 119950: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED #endif } *count = number_broadcasted; return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; } 119955: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 119958: 5b pop %ebx <== NOT EXECUTED 119959: 5e pop %esi <== NOT EXECUTED 11995a: 5f pop %edi <== NOT EXECUTED 11995b: c9 leave <== NOT EXECUTED 11995c: c3 ret <== NOT EXECUTED =============================================================================== 00114a1c <_CORE_message_queue_Initialize>: CORE_message_queue_Control *the_message_queue, CORE_message_queue_Attributes *the_message_queue_attributes, uint32_t maximum_pending_messages, size_t maximum_message_size ) { 114a1c: 55 push %ebp 114a1d: 89 e5 mov %esp,%ebp 114a1f: 57 push %edi 114a20: 56 push %esi 114a21: 53 push %ebx 114a22: 83 ec 0c sub $0xc,%esp 114a25: 8b 5d 08 mov 0x8(%ebp),%ebx 114a28: 8b 75 10 mov 0x10(%ebp),%esi 114a2b: 8b 45 14 mov 0x14(%ebp),%eax size_t message_buffering_required; size_t allocated_message_size; the_message_queue->maximum_pending_messages = maximum_pending_messages; 114a2e: 89 73 44 mov %esi,0x44(%ebx) the_message_queue->number_of_pending_messages = 0; 114a31: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx) the_message_queue->maximum_message_size = maximum_message_size; 114a38: 89 43 4c mov %eax,0x4c(%ebx) CORE_message_queue_Control *the_message_queue, CORE_message_queue_Notify_Handler the_handler, void *the_argument ) { the_message_queue->notify_handler = the_handler; 114a3b: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) the_message_queue->notify_argument = the_argument; 114a42: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx) /* * Round size up to multiple of a pointer for chain init and * check for overflow on adding overhead to each message. */ allocated_message_size = maximum_message_size; if (allocated_message_size & (sizeof(uint32_t) - 1)) { 114a49: a8 03 test $0x3,%al 114a4b: 74 17 je 114a64 <_CORE_message_queue_Initialize+0x48> allocated_message_size += sizeof(uint32_t); 114a4d: 8d 50 04 lea 0x4(%eax),%edx allocated_message_size &= ~(sizeof(uint32_t) - 1); 114a50: 83 e2 fc and $0xfffffffc,%edx } if (allocated_message_size < maximum_message_size) 114a53: 39 d0 cmp %edx,%eax 114a55: 76 0f jbe 114a66 <_CORE_message_queue_Initialize+0x4a><== ALWAYS TAKEN */ the_message_queue->message_buffers = (CORE_message_queue_Buffer *) _Workspace_Allocate( message_buffering_required ); if (the_message_queue->message_buffers == 0) return false; 114a57: 31 c0 xor %eax,%eax STATES_WAITING_FOR_MESSAGE, CORE_MESSAGE_QUEUE_STATUS_TIMEOUT ); return true; } 114a59: 8d 65 f4 lea -0xc(%ebp),%esp 114a5c: 5b pop %ebx 114a5d: 5e pop %esi 114a5e: 5f pop %edi 114a5f: c9 leave 114a60: c3 ret 114a61: 8d 76 00 lea 0x0(%esi),%esi /* * Round size up to multiple of a pointer for chain init and * check for overflow on adding overhead to each message. */ allocated_message_size = maximum_message_size; if (allocated_message_size & (sizeof(uint32_t) - 1)) { 114a64: 89 c2 mov %eax,%edx /* * Calculate how much total memory is required for message buffering and * check for overflow on the multiplication. */ message_buffering_required = (size_t) maximum_pending_messages * (allocated_message_size + sizeof(CORE_message_queue_Buffer_control)); 114a66: 8d 7a 14 lea 0x14(%edx),%edi /* * Calculate how much total memory is required for message buffering and * check for overflow on the multiplication. */ message_buffering_required = (size_t) maximum_pending_messages * 114a69: 89 f8 mov %edi,%eax 114a6b: 0f af c6 imul %esi,%eax (allocated_message_size + sizeof(CORE_message_queue_Buffer_control)); if (message_buffering_required < allocated_message_size) 114a6e: 39 d0 cmp %edx,%eax 114a70: 72 e5 jb 114a57 <_CORE_message_queue_Initialize+0x3b><== NEVER TAKEN /* * Attempt to allocate the message memory */ the_message_queue->message_buffers = (CORE_message_queue_Buffer *) _Workspace_Allocate( message_buffering_required ); 114a72: 83 ec 0c sub $0xc,%esp 114a75: 50 push %eax 114a76: e8 4d 2b 00 00 call 1175c8 <_Workspace_Allocate> return false; /* * Attempt to allocate the message memory */ the_message_queue->message_buffers = (CORE_message_queue_Buffer *) 114a7b: 89 43 5c mov %eax,0x5c(%ebx) _Workspace_Allocate( message_buffering_required ); if (the_message_queue->message_buffers == 0) 114a7e: 83 c4 10 add $0x10,%esp 114a81: 85 c0 test %eax,%eax 114a83: 74 d2 je 114a57 <_CORE_message_queue_Initialize+0x3b> /* * Initialize the pool of inactive messages, pending messages, * and set of waiting threads. */ _Chain_Initialize ( 114a85: 57 push %edi 114a86: 56 push %esi 114a87: 50 push %eax 114a88: 8d 43 68 lea 0x68(%ebx),%eax 114a8b: 50 push %eax 114a8c: e8 47 52 00 00 call 119cd8 <_Chain_Initialize> RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); 114a91: 8d 43 54 lea 0x54(%ebx),%eax 114a94: 89 43 50 mov %eax,0x50(%ebx) head->next = tail; head->previous = NULL; 114a97: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); 114a9e: 8d 43 50 lea 0x50(%ebx),%eax 114aa1: 89 43 58 mov %eax,0x58(%ebx) allocated_message_size + sizeof( CORE_message_queue_Buffer_control ) ); _Chain_Initialize_empty( &the_message_queue->Pending_messages ); _Thread_queue_Initialize( 114aa4: 6a 06 push $0x6 114aa6: 68 80 00 00 00 push $0x80 114aab: 8b 45 0c mov 0xc(%ebp),%eax 114aae: 83 38 01 cmpl $0x1,(%eax) 114ab1: 0f 94 c0 sete %al 114ab4: 0f b6 c0 movzbl %al,%eax 114ab7: 50 push %eax 114ab8: 53 push %ebx 114ab9: e8 3e 22 00 00 call 116cfc <_Thread_queue_Initialize> THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO, STATES_WAITING_FOR_MESSAGE, CORE_MESSAGE_QUEUE_STATUS_TIMEOUT ); return true; 114abe: 83 c4 20 add $0x20,%esp 114ac1: b0 01 mov $0x1,%al } 114ac3: 8d 65 f4 lea -0xc(%ebp),%esp 114ac6: 5b pop %ebx 114ac7: 5e pop %esi 114ac8: 5f pop %edi 114ac9: c9 leave 114aca: c3 ret =============================================================================== 001110e0 <_CORE_message_queue_Insert_message>: void _CORE_message_queue_Insert_message( CORE_message_queue_Control *the_message_queue, CORE_message_queue_Buffer_control *the_message, CORE_message_queue_Submit_types submit_type ) { 1110e0: 55 push %ebp 1110e1: 89 e5 mov %esp,%ebp 1110e3: 56 push %esi 1110e4: 53 push %ebx 1110e5: 83 ec 10 sub $0x10,%esp 1110e8: 8b 45 08 mov 0x8(%ebp),%eax 1110eb: 8b 55 0c mov 0xc(%ebp),%edx 1110ee: 8b 4d 10 mov 0x10(%ebp),%ecx 1110f1: 89 4a 08 mov %ecx,0x8(%edx) _CORE_message_queue_Append_unprotected(the_message_queue, the_message); else _CORE_message_queue_Prepend_unprotected(the_message_queue, the_message); _ISR_Enable( level ); #else if ( submit_type == CORE_MESSAGE_QUEUE_SEND_REQUEST ) { 1110f4: 81 f9 ff ff ff 7f cmp $0x7fffffff,%ecx 1110fa: 74 70 je 11116c <_CORE_message_queue_Insert_message+0x8c> _ISR_Disable( level ); SET_NOTIFY(); the_message_queue->number_of_pending_messages++; _CORE_message_queue_Append_unprotected(the_message_queue, the_message); _ISR_Enable( level ); } else if ( submit_type == CORE_MESSAGE_QUEUE_URGENT_REQUEST ) { 1110fc: 81 f9 00 00 00 80 cmp $0x80000000,%ecx 111102: 0f 84 88 00 00 00 je 111190 <_CORE_message_queue_Insert_message+0xb0> * the message is actually in the queue at this point. */ if ( notify && the_message_queue->notify_handler ) (*the_message_queue->notify_handler)(the_message_queue->notify_argument); #endif } 111108: 8b 58 50 mov 0x50(%eax),%ebx RTEMS_INLINE_ROUTINE bool _Chain_Is_tail( Chain_Control *the_chain, const Chain_Node *the_node ) { return (the_node == _Chain_Tail(the_chain)); 11110b: 8d 70 54 lea 0x54(%eax),%esi int the_priority; the_priority = _CORE_message_queue_Get_message_priority(the_message); the_header = &the_message_queue->Pending_messages; the_node = _Chain_First( the_header ); while ( !_Chain_Is_tail( the_header, the_node ) ) { 11110e: 39 de cmp %ebx,%esi 111110: 74 05 je 111117 <_CORE_message_queue_Insert_message+0x37> this_message = (CORE_message_queue_Buffer_control *) the_node; this_priority = _CORE_message_queue_Get_message_priority(this_message); if ( this_priority <= the_priority ) { 111112: 3b 4b 08 cmp 0x8(%ebx),%ecx 111115: 7d 45 jge 11115c <_CORE_message_queue_Insert_message+0x7c> the_node = the_node->next; continue; } break; } _ISR_Disable( level ); 111117: 9c pushf 111118: fa cli 111119: 5e pop %esi SET_NOTIFY(); 11111a: 8b 48 48 mov 0x48(%eax),%ecx * * INTERRUPT LATENCY: * insert */ void _CORE_message_queue_Insert_message( 11111d: 85 c9 test %ecx,%ecx 11111f: 0f 94 45 f7 sete -0x9(%ebp) } break; } _ISR_Disable( level ); SET_NOTIFY(); the_message_queue->number_of_pending_messages++; 111123: 41 inc %ecx 111124: 89 48 48 mov %ecx,0x48(%eax) _Chain_Insert_unprotected( the_node->previous, &the_message->Node ); 111127: 8b 4b 04 mov 0x4(%ebx),%ecx Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 11112a: 89 4a 04 mov %ecx,0x4(%edx) before_node = after_node->next; 11112d: 8b 19 mov (%ecx),%ebx after_node->next = the_node; 11112f: 89 11 mov %edx,(%ecx) the_node->next = before_node; 111131: 89 1a mov %ebx,(%edx) before_node->previous = the_node; 111133: 89 53 04 mov %edx,0x4(%ebx) _ISR_Enable( level ); 111136: 56 push %esi 111137: 9d popf /* * According to POSIX, does this happen before or after the message * is actually enqueued. It is logical to think afterwards, because * the message is actually in the queue at this point. */ if ( notify && the_message_queue->notify_handler ) 111138: 80 7d f7 00 cmpb $0x0,-0x9(%ebp) 11113c: 74 16 je 111154 <_CORE_message_queue_Insert_message+0x74> 11113e: 8b 50 60 mov 0x60(%eax),%edx 111141: 85 d2 test %edx,%edx 111143: 74 0f je 111154 <_CORE_message_queue_Insert_message+0x74> (*the_message_queue->notify_handler)(the_message_queue->notify_argument); 111145: 8b 40 64 mov 0x64(%eax),%eax 111148: 89 45 08 mov %eax,0x8(%ebp) #endif } 11114b: 83 c4 10 add $0x10,%esp 11114e: 5b pop %ebx 11114f: 5e pop %esi 111150: c9 leave * According to POSIX, does this happen before or after the message * is actually enqueued. It is logical to think afterwards, because * the message is actually in the queue at this point. */ if ( notify && the_message_queue->notify_handler ) (*the_message_queue->notify_handler)(the_message_queue->notify_argument); 111151: ff e2 jmp *%edx 111153: 90 nop #endif } 111154: 83 c4 10 add $0x10,%esp 111157: 5b pop %ebx 111158: 5e pop %esi 111159: c9 leave 11115a: c3 ret 11115b: 90 nop this_message = (CORE_message_queue_Buffer_control *) the_node; this_priority = _CORE_message_queue_Get_message_priority(this_message); if ( this_priority <= the_priority ) { the_node = the_node->next; 11115c: 8b 1b mov (%ebx),%ebx int the_priority; the_priority = _CORE_message_queue_Get_message_priority(the_message); the_header = &the_message_queue->Pending_messages; the_node = _Chain_First( the_header ); while ( !_Chain_Is_tail( the_header, the_node ) ) { 11115e: 39 de cmp %ebx,%esi 111160: 74 b5 je 111117 <_CORE_message_queue_Insert_message+0x37> this_message = (CORE_message_queue_Buffer_control *) the_node; this_priority = _CORE_message_queue_Get_message_priority(this_message); if ( this_priority <= the_priority ) { 111162: 3b 4b 08 cmp 0x8(%ebx),%ecx 111165: 7c b0 jl 111117 <_CORE_message_queue_Insert_message+0x37> 111167: eb f3 jmp 11115c <_CORE_message_queue_Insert_message+0x7c> 111169: 8d 76 00 lea 0x0(%esi),%esi else _CORE_message_queue_Prepend_unprotected(the_message_queue, the_message); _ISR_Enable( level ); #else if ( submit_type == CORE_MESSAGE_QUEUE_SEND_REQUEST ) { _ISR_Disable( level ); 11116c: 9c pushf 11116d: fa cli 11116e: 5b pop %ebx SET_NOTIFY(); 11116f: 8b 48 48 mov 0x48(%eax),%ecx * * INTERRUPT LATENCY: * insert */ void _CORE_message_queue_Insert_message( 111172: 85 c9 test %ecx,%ecx 111174: 0f 94 45 f7 sete -0x9(%ebp) _ISR_Enable( level ); #else if ( submit_type == CORE_MESSAGE_QUEUE_SEND_REQUEST ) { _ISR_Disable( level ); SET_NOTIFY(); the_message_queue->number_of_pending_messages++; 111178: 41 inc %ecx 111179: 89 48 48 mov %ecx,0x48(%eax) Chain_Control *the_chain, Chain_Node *the_node ) { Chain_Node *tail = _Chain_Tail( the_chain ); Chain_Node *old_last = tail->previous; 11117c: 8b 48 58 mov 0x58(%eax),%ecx RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected( Chain_Control *the_chain, Chain_Node *the_node ) { Chain_Node *tail = _Chain_Tail( the_chain ); 11117f: 8d 70 54 lea 0x54(%eax),%esi 111182: 89 32 mov %esi,(%edx) Chain_Node *old_last = tail->previous; the_node->next = tail; tail->previous = the_node; 111184: 89 50 58 mov %edx,0x58(%eax) old_last->next = the_node; 111187: 89 11 mov %edx,(%ecx) the_node->previous = old_last; 111189: 89 4a 04 mov %ecx,0x4(%edx) _CORE_message_queue_Append_unprotected(the_message_queue, the_message); _ISR_Enable( level ); 11118c: 53 push %ebx 11118d: 9d popf 11118e: eb a8 jmp 111138 <_CORE_message_queue_Insert_message+0x58> } else if ( submit_type == CORE_MESSAGE_QUEUE_URGENT_REQUEST ) { _ISR_Disable( level ); 111190: 9c pushf 111191: fa cli 111192: 5b pop %ebx SET_NOTIFY(); 111193: 8b 48 48 mov 0x48(%eax),%ecx * * INTERRUPT LATENCY: * insert */ void _CORE_message_queue_Insert_message( 111196: 85 c9 test %ecx,%ecx 111198: 0f 94 45 f7 sete -0x9(%ebp) _CORE_message_queue_Append_unprotected(the_message_queue, the_message); _ISR_Enable( level ); } else if ( submit_type == CORE_MESSAGE_QUEUE_URGENT_REQUEST ) { _ISR_Disable( level ); SET_NOTIFY(); the_message_queue->number_of_pending_messages++; 11119c: 41 inc %ecx 11119d: 89 48 48 mov %ecx,0x48(%eax) RTEMS_INLINE_ROUTINE void _Chain_Prepend_unprotected( Chain_Control *the_chain, Chain_Node *the_node ) { _Chain_Insert_unprotected(_Chain_Head(the_chain), the_node); 1111a0: 8d 48 50 lea 0x50(%eax),%ecx 1111a3: 89 4a 04 mov %ecx,0x4(%edx) ) { Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; 1111a6: 8b 48 50 mov 0x50(%eax),%ecx after_node->next = the_node; 1111a9: 89 50 50 mov %edx,0x50(%eax) the_node->next = before_node; 1111ac: 89 0a mov %ecx,(%edx) before_node->previous = the_node; 1111ae: 89 51 04 mov %edx,0x4(%ecx) _CORE_message_queue_Prepend_unprotected(the_message_queue, the_message); _ISR_Enable( level ); 1111b1: 53 push %ebx 1111b2: 9d popf 1111b3: eb 83 jmp 111138 <_CORE_message_queue_Insert_message+0x58> =============================================================================== 00114acc <_CORE_message_queue_Seize>: void *buffer, size_t *size_p, bool wait, Watchdog_Interval timeout ) { 114acc: 55 push %ebp 114acd: 89 e5 mov %esp,%ebp 114acf: 57 push %edi 114ad0: 56 push %esi 114ad1: 53 push %ebx 114ad2: 83 ec 2c sub $0x2c,%esp 114ad5: 8b 55 08 mov 0x8(%ebp),%edx 114ad8: 8b 45 0c mov 0xc(%ebp),%eax 114adb: 89 45 dc mov %eax,-0x24(%ebp) 114ade: 8b 4d 10 mov 0x10(%ebp),%ecx 114ae1: 89 4d e0 mov %ecx,-0x20(%ebp) 114ae4: 8b 45 14 mov 0x14(%ebp),%eax 114ae7: 8b 5d 1c mov 0x1c(%ebp),%ebx 114aea: 89 5d d8 mov %ebx,-0x28(%ebp) 114aed: 0f b6 7d 18 movzbl 0x18(%ebp),%edi ISR_Level level; CORE_message_queue_Buffer_control *the_message; Thread_Control *executing; executing = _Thread_Executing; 114af1: 8b 0d d8 0c 13 00 mov 0x130cd8,%ecx executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 114af7: c7 41 34 00 00 00 00 movl $0x0,0x34(%ecx) _ISR_Disable( level ); 114afe: 9c pushf 114aff: fa cli 114b00: 8f 45 e4 popl -0x1c(%ebp) executing->Wait.return_argument = size_p; /* Wait.count will be filled in with the message priority */ _ISR_Enable( level ); _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); } 114b03: 8b 5a 50 mov 0x50(%edx),%ebx RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 114b06: 8d 72 54 lea 0x54(%edx),%esi */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected( Chain_Control *the_chain ) { if ( !_Chain_Is_empty(the_chain)) 114b09: 39 f3 cmp %esi,%ebx 114b0b: 74 7b je 114b88 <_CORE_message_queue_Seize+0xbc> Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *old_first = head->next; Chain_Node *new_first = old_first->next; 114b0d: 8b 0b mov (%ebx),%ecx head->next = new_first; 114b0f: 89 4a 50 mov %ecx,0x50(%edx) */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_first_unprotected( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); 114b12: 8d 72 50 lea 0x50(%edx),%esi 114b15: 89 71 04 mov %esi,0x4(%ecx) executing = _Thread_Executing; executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; _ISR_Disable( level ); the_message = _CORE_message_queue_Get_pending_message( the_message_queue ); if ( the_message != NULL ) { the_message_queue->number_of_pending_messages -= 1; 114b18: ff 4a 48 decl 0x48(%edx) _ISR_Enable( level ); 114b1b: ff 75 e4 pushl -0x1c(%ebp) 114b1e: 9d popf *size_p = the_message->Contents.size; 114b1f: 8b 4b 0c mov 0xc(%ebx),%ecx 114b22: 89 08 mov %ecx,(%eax) _Thread_Executing->Wait.count = 114b24: 8b 73 08 mov 0x8(%ebx),%esi 114b27: 8b 0d d8 0c 13 00 mov 0x130cd8,%ecx 114b2d: 89 71 24 mov %esi,0x24(%ecx) _CORE_message_queue_Get_message_priority( the_message ); _CORE_message_queue_Copy_buffer( the_message->Contents.buffer, 114b30: 8d 4b 10 lea 0x10(%ebx),%ecx 114b33: 89 4d e4 mov %ecx,-0x1c(%ebp) const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 114b36: 8b 08 mov (%eax),%ecx 114b38: 8b 7d e0 mov -0x20(%ebp),%edi 114b3b: 8b 75 e4 mov -0x1c(%ebp),%esi 114b3e: f3 a4 rep movsb %ds:(%esi),%es:(%edi) * is not, then we can go ahead and free the buffer. * * NOTE: If we note that the queue was not full before this receive, * then we can avoid this dequeue. */ the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue ); 114b40: 83 ec 0c sub $0xc,%esp 114b43: 52 push %edx 114b44: 89 55 d4 mov %edx,-0x2c(%ebp) 114b47: e8 20 1e 00 00 call 11696c <_Thread_queue_Dequeue> if ( !the_thread ) { 114b4c: 83 c4 10 add $0x10,%esp 114b4f: 85 c0 test %eax,%eax 114b51: 8b 55 d4 mov -0x2c(%ebp),%edx 114b54: 0f 84 86 00 00 00 je 114be0 <_CORE_message_queue_Seize+0x114> CORE_message_queue_Buffer_control *the_message, int priority ) { #if defined(RTEMS_SCORE_COREMSG_ENABLE_MESSAGE_PRIORITY) the_message->priority = priority; 114b5a: 8b 48 24 mov 0x24(%eax),%ecx 114b5d: 89 4b 08 mov %ecx,0x8(%ebx) */ _CORE_message_queue_Set_message_priority( the_message, the_thread->Wait.count ); the_message->Contents.size = (size_t) the_thread->Wait.option; 114b60: 8b 48 30 mov 0x30(%eax),%ecx 114b63: 89 4b 0c mov %ecx,0xc(%ebx) const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 114b66: 8b 70 2c mov 0x2c(%eax),%esi 114b69: 8b 7d e4 mov -0x1c(%ebp),%edi 114b6c: f3 a4 rep movsb %ds:(%esi),%es:(%edi) the_thread->Wait.return_argument_second.immutable_object, the_message->Contents.buffer, the_message->Contents.size ); _CORE_message_queue_Insert_message( 114b6e: 8b 43 08 mov 0x8(%ebx),%eax 114b71: 89 45 10 mov %eax,0x10(%ebp) 114b74: 89 5d 0c mov %ebx,0xc(%ebp) 114b77: 89 55 08 mov %edx,0x8(%ebp) executing->Wait.return_argument = size_p; /* Wait.count will be filled in with the message priority */ _ISR_Enable( level ); _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); } 114b7a: 8d 65 f4 lea -0xc(%ebp),%esp 114b7d: 5b pop %ebx 114b7e: 5e pop %esi 114b7f: 5f pop %edi 114b80: c9 leave the_thread->Wait.return_argument_second.immutable_object, the_message->Contents.buffer, the_message->Contents.size ); _CORE_message_queue_Insert_message( 114b81: e9 ae 51 00 00 jmp 119d34 <_CORE_message_queue_Insert_message> 114b86: 66 90 xchg %ax,%ax return; } #endif } if ( !wait ) { 114b88: 89 fb mov %edi,%ebx 114b8a: 84 db test %bl,%bl 114b8c: 75 16 jne 114ba4 <_CORE_message_queue_Seize+0xd8> _ISR_Enable( level ); 114b8e: ff 75 e4 pushl -0x1c(%ebp) 114b91: 9d popf executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT; 114b92: c7 41 34 04 00 00 00 movl $0x4,0x34(%ecx) executing->Wait.return_argument = size_p; /* Wait.count will be filled in with the message priority */ _ISR_Enable( level ); _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); } 114b99: 8d 65 f4 lea -0xc(%ebp),%esp 114b9c: 5b pop %ebx 114b9d: 5e pop %esi 114b9e: 5f pop %edi 114b9f: c9 leave 114ba0: c3 ret 114ba1: 8d 76 00 lea 0x0(%esi),%esi RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 114ba4: c7 42 30 01 00 00 00 movl $0x1,0x30(%edx) executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT; return; } _Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue ); executing->Wait.queue = &the_message_queue->Wait_queue; 114bab: 89 51 44 mov %edx,0x44(%ecx) executing->Wait.id = id; 114bae: 8b 5d dc mov -0x24(%ebp),%ebx 114bb1: 89 59 20 mov %ebx,0x20(%ecx) executing->Wait.return_argument_second.mutable_object = buffer; 114bb4: 8b 5d e0 mov -0x20(%ebp),%ebx 114bb7: 89 59 2c mov %ebx,0x2c(%ecx) executing->Wait.return_argument = size_p; 114bba: 89 41 28 mov %eax,0x28(%ecx) /* Wait.count will be filled in with the message priority */ _ISR_Enable( level ); 114bbd: ff 75 e4 pushl -0x1c(%ebp) 114bc0: 9d popf _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 114bc1: c7 45 10 c0 6d 11 00 movl $0x116dc0,0x10(%ebp) 114bc8: 8b 45 d8 mov -0x28(%ebp),%eax 114bcb: 89 45 0c mov %eax,0xc(%ebp) 114bce: 89 55 08 mov %edx,0x8(%ebp) } 114bd1: 8d 65 f4 lea -0xc(%ebp),%esp 114bd4: 5b pop %ebx 114bd5: 5e pop %esi 114bd6: 5f pop %edi 114bd7: c9 leave executing->Wait.return_argument_second.mutable_object = buffer; executing->Wait.return_argument = size_p; /* Wait.count will be filled in with the message priority */ _ISR_Enable( level ); _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 114bd8: e9 b7 1e 00 00 jmp 116a94 <_Thread_queue_Enqueue_with_handler> 114bdd: 8d 76 00 lea 0x0(%esi),%esi RTEMS_INLINE_ROUTINE void _CORE_message_queue_Free_message_buffer ( CORE_message_queue_Control *the_message_queue, CORE_message_queue_Buffer_control *the_message ) { _Chain_Append( &the_message_queue->Inactive_messages, &the_message->Node ); 114be0: 89 5d 0c mov %ebx,0xc(%ebp) 114be3: 83 c2 68 add $0x68,%edx 114be6: 89 55 08 mov %edx,0x8(%ebp) } 114be9: 8d 65 f4 lea -0xc(%ebp),%esp 114bec: 5b pop %ebx 114bed: 5e pop %esi 114bee: 5f pop %edi 114bef: c9 leave 114bf0: e9 a7 fd ff ff jmp 11499c <_Chain_Append> =============================================================================== 0010c038 <_CORE_message_queue_Submit>: #endif CORE_message_queue_Submit_types submit_type, bool wait, Watchdog_Interval timeout ) { 10c038: 55 push %ebp 10c039: 89 e5 mov %esp,%ebp 10c03b: 57 push %edi 10c03c: 56 push %esi 10c03d: 53 push %ebx 10c03e: 83 ec 1c sub $0x1c,%esp 10c041: 8b 5d 08 mov 0x8(%ebp),%ebx 10c044: 8b 75 0c mov 0xc(%ebp),%esi 10c047: 8a 4d 20 mov 0x20(%ebp),%cl CORE_message_queue_Buffer_control *the_message; Thread_Control *the_thread; if ( size > the_message_queue->maximum_message_size ) { 10c04a: 8b 45 10 mov 0x10(%ebp),%eax 10c04d: 39 43 4c cmp %eax,0x4c(%ebx) 10c050: 72 32 jb 10c084 <_CORE_message_queue_Submit+0x4c> } /* * Is there a thread currently waiting on this message queue? */ if ( the_message_queue->number_of_pending_messages == 0 ) { 10c052: 8b 43 48 mov 0x48(%ebx),%eax 10c055: 85 c0 test %eax,%eax 10c057: 74 3b je 10c094 <_CORE_message_queue_Submit+0x5c> /* * No one waiting on the message queue at this time, so attempt to * queue the message up for a future receive. */ if ( the_message_queue->number_of_pending_messages < 10c059: 39 43 44 cmp %eax,0x44(%ebx) 10c05c: 0f 87 ba 00 00 00 ja 10c11c <_CORE_message_queue_Submit+0xe4> /* * No message buffers were available so we may need to return an * overflow error or block the sender until the message is placed * on the queue. */ if ( !wait ) { 10c062: 84 c9 test %cl,%cl 10c064: 0f 84 ee 00 00 00 je 10c158 <_CORE_message_queue_Submit+0x120> /* * Do NOT block on a send if the caller is in an ISR. It is * deadly to block in an ISR. */ if ( _ISR_Is_in_progress() ) { 10c06a: 8b 15 34 83 12 00 mov 0x128334,%edx 10c070: 85 d2 test %edx,%edx 10c072: 74 60 je 10c0d4 <_CORE_message_queue_Submit+0x9c> return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED; 10c074: b8 03 00 00 00 mov $0x3,%eax _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); } return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT; #endif } 10c079: 8d 65 f4 lea -0xc(%ebp),%esp 10c07c: 5b pop %ebx 10c07d: 5e pop %esi 10c07e: 5f pop %edi 10c07f: c9 leave 10c080: c3 ret 10c081: 8d 76 00 lea 0x0(%esi),%esi { CORE_message_queue_Buffer_control *the_message; Thread_Control *the_thread; if ( size > the_message_queue->maximum_message_size ) { return CORE_MESSAGE_QUEUE_STATUS_INVALID_SIZE; 10c084: b8 01 00 00 00 mov $0x1,%eax _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); } return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT; #endif } 10c089: 8d 65 f4 lea -0xc(%ebp),%esp 10c08c: 5b pop %ebx 10c08d: 5e pop %esi 10c08e: 5f pop %edi 10c08f: c9 leave 10c090: c3 ret 10c091: 8d 76 00 lea 0x0(%esi),%esi /* * Is there a thread currently waiting on this message queue? */ if ( the_message_queue->number_of_pending_messages == 0 ) { the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue ); 10c094: 83 ec 0c sub $0xc,%esp 10c097: 53 push %ebx 10c098: 88 4d e4 mov %cl,-0x1c(%ebp) 10c09b: e8 8c 1c 00 00 call 10dd2c <_Thread_queue_Dequeue> 10c0a0: 89 c2 mov %eax,%edx if ( the_thread ) { 10c0a2: 83 c4 10 add $0x10,%esp 10c0a5: 85 c0 test %eax,%eax 10c0a7: 8a 4d e4 mov -0x1c(%ebp),%cl 10c0aa: 0f 84 b8 00 00 00 je 10c168 <_CORE_message_queue_Submit+0x130> const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 10c0b0: 8b 40 2c mov 0x2c(%eax),%eax 10c0b3: 89 c7 mov %eax,%edi 10c0b5: 8b 4d 10 mov 0x10(%ebp),%ecx 10c0b8: f3 a4 rep movsb %ds:(%esi),%es:(%edi) _CORE_message_queue_Copy_buffer( buffer, the_thread->Wait.return_argument_second.mutable_object, size ); *(size_t *) the_thread->Wait.return_argument = size; 10c0ba: 8b 42 28 mov 0x28(%edx),%eax 10c0bd: 8b 4d 10 mov 0x10(%ebp),%ecx 10c0c0: 89 08 mov %ecx,(%eax) the_thread->Wait.count = (uint32_t) submit_type; 10c0c2: 8b 45 1c mov 0x1c(%ebp),%eax 10c0c5: 89 42 24 mov %eax,0x24(%edx) #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) (*api_message_queue_mp_support) ( the_thread, id ); #endif return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 10c0c8: 31 c0 xor %eax,%eax _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); } return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT; #endif } 10c0ca: 8d 65 f4 lea -0xc(%ebp),%esp 10c0cd: 5b pop %ebx 10c0ce: 5e pop %esi 10c0cf: 5f pop %edi 10c0d0: c9 leave 10c0d1: c3 ret 10c0d2: 66 90 xchg %ax,%ax * Thus the unusual choice to open a new scope and declare * it as a variable. Doing this emphasizes how dangerous it * would be to use this variable prior to here. */ { Thread_Control *executing = _Thread_Executing; 10c0d4: a1 38 83 12 00 mov 0x128338,%eax ISR_Level level; _ISR_Disable( level ); 10c0d9: 9c pushf 10c0da: fa cli 10c0db: 59 pop %ecx RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 10c0dc: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx) _Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue ); executing->Wait.queue = &the_message_queue->Wait_queue; 10c0e3: 89 58 44 mov %ebx,0x44(%eax) executing->Wait.id = id; 10c0e6: 8b 55 14 mov 0x14(%ebp),%edx 10c0e9: 89 50 20 mov %edx,0x20(%eax) executing->Wait.return_argument_second.immutable_object = buffer; 10c0ec: 89 70 2c mov %esi,0x2c(%eax) executing->Wait.option = (uint32_t) size; 10c0ef: 8b 55 10 mov 0x10(%ebp),%edx 10c0f2: 89 50 30 mov %edx,0x30(%eax) executing->Wait.count = submit_type; 10c0f5: 8b 55 1c mov 0x1c(%ebp),%edx 10c0f8: 89 50 24 mov %edx,0x24(%eax) _ISR_Enable( level ); 10c0fb: 51 push %ecx 10c0fc: 9d popf _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 10c0fd: 50 push %eax 10c0fe: 68 80 e1 10 00 push $0x10e180 10c103: ff 75 24 pushl 0x24(%ebp) 10c106: 53 push %ebx 10c107: e8 48 1d 00 00 call 10de54 <_Thread_queue_Enqueue_with_handler> } return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT; 10c10c: 83 c4 10 add $0x10,%esp 10c10f: b8 07 00 00 00 mov $0x7,%eax #endif } 10c114: 8d 65 f4 lea -0xc(%ebp),%esp 10c117: 5b pop %ebx 10c118: 5e pop %esi 10c119: 5f pop %edi 10c11a: c9 leave 10c11b: c3 ret _CORE_message_queue_Allocate_message_buffer ( CORE_message_queue_Control *the_message_queue ) { return (CORE_message_queue_Buffer_control *) _Chain_Get( &the_message_queue->Inactive_messages ); 10c11c: 83 ec 0c sub $0xc,%esp 10c11f: 8d 43 68 lea 0x68(%ebx),%eax 10c122: 50 push %eax 10c123: e8 ec fe ff ff call 10c014 <_Chain_Get> 10c128: 89 c2 mov %eax,%edx return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED; #endif _CORE_message_queue_Copy_buffer( buffer, the_message->Contents.buffer, 10c12a: 8d 40 10 lea 0x10(%eax),%eax const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 10c12d: 89 c7 mov %eax,%edi 10c12f: 8b 4d 10 mov 0x10(%ebp),%ecx 10c132: f3 a4 rep movsb %ds:(%esi),%es:(%edi) size ); the_message->Contents.size = size; 10c134: 8b 4d 10 mov 0x10(%ebp),%ecx 10c137: 89 4a 0c mov %ecx,0xc(%edx) CORE_message_queue_Buffer_control *the_message, int priority ) { #if defined(RTEMS_SCORE_COREMSG_ENABLE_MESSAGE_PRIORITY) the_message->priority = priority; 10c13a: 8b 45 1c mov 0x1c(%ebp),%eax 10c13d: 89 42 08 mov %eax,0x8(%edx) _CORE_message_queue_Set_message_priority( the_message, submit_type ); _CORE_message_queue_Insert_message( 10c140: 83 c4 0c add $0xc,%esp 10c143: 50 push %eax 10c144: 52 push %edx 10c145: 53 push %ebx 10c146: e8 95 4f 00 00 call 1110e0 <_CORE_message_queue_Insert_message> the_message_queue, the_message, submit_type ); return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 10c14b: 83 c4 10 add $0x10,%esp 10c14e: 31 c0 xor %eax,%eax 10c150: e9 34 ff ff ff jmp 10c089 <_CORE_message_queue_Submit+0x51> 10c155: 8d 76 00 lea 0x0(%esi),%esi * No message buffers were available so we may need to return an * overflow error or block the sender until the message is placed * on the queue. */ if ( !wait ) { return CORE_MESSAGE_QUEUE_STATUS_TOO_MANY; 10c158: b8 02 00 00 00 mov $0x2,%eax _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); } return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT; #endif } 10c15d: 8d 65 f4 lea -0xc(%ebp),%esp 10c160: 5b pop %ebx 10c161: 5e pop %esi 10c162: 5f pop %edi 10c163: c9 leave 10c164: c3 ret 10c165: 8d 76 00 lea 0x0(%esi),%esi /* * Is there a thread currently waiting on this message queue? */ if ( the_message_queue->number_of_pending_messages == 0 ) { the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue ); if ( the_thread ) { 10c168: 8b 43 48 mov 0x48(%ebx),%eax 10c16b: e9 e9 fe ff ff jmp 10c059 <_CORE_message_queue_Submit+0x21> =============================================================================== 0010c17c <_CORE_mutex_Initialize>: CORE_mutex_Status _CORE_mutex_Initialize( CORE_mutex_Control *the_mutex, CORE_mutex_Attributes *the_mutex_attributes, uint32_t initial_lock ) { 10c17c: 55 push %ebp 10c17d: 89 e5 mov %esp,%ebp 10c17f: 57 push %edi 10c180: 56 push %esi 10c181: 53 push %ebx 10c182: 83 ec 0c sub $0xc,%esp 10c185: 8b 45 08 mov 0x8(%ebp),%eax 10c188: 8b 5d 0c mov 0xc(%ebp),%ebx 10c18b: 8b 55 10 mov 0x10(%ebp),%edx /* Add this to the RTEMS environment later ????????? rtems_assert( initial_lock == CORE_MUTEX_LOCKED || initial_lock == CORE_MUTEX_UNLOCKED ); */ the_mutex->Attributes = *the_mutex_attributes; 10c18e: 8d 78 40 lea 0x40(%eax),%edi 10c191: b9 04 00 00 00 mov $0x4,%ecx 10c196: 89 de mov %ebx,%esi 10c198: f3 a5 rep movsl %ds:(%esi),%es:(%edi) the_mutex->lock = initial_lock; 10c19a: 89 50 50 mov %edx,0x50(%eax) the_mutex->blocked_count = 0; 10c19d: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax) if ( initial_lock == CORE_MUTEX_LOCKED ) { 10c1a4: 85 d2 test %edx,%edx 10c1a6: 75 30 jne 10c1d8 <_CORE_mutex_Initialize+0x5c> the_mutex->nest_count = 1; 10c1a8: c7 40 54 01 00 00 00 movl $0x1,0x54(%eax) the_mutex->holder = _Thread_Executing; 10c1af: 8b 15 38 83 12 00 mov 0x128338,%edx 10c1b5: 89 50 5c mov %edx,0x5c(%eax) the_mutex->holder_id = _Thread_Executing->Object.id; 10c1b8: 8b 4a 08 mov 0x8(%edx),%ecx 10c1bb: 89 48 60 mov %ecx,0x60(%eax) STATES_WAITING_FOR_MUTEX, CORE_MUTEX_TIMEOUT ); return CORE_MUTEX_STATUS_SUCCESSFUL; } 10c1be: 8b 48 48 mov 0x48(%eax),%ecx if ( initial_lock == CORE_MUTEX_LOCKED ) { the_mutex->nest_count = 1; the_mutex->holder = _Thread_Executing; the_mutex->holder_id = _Thread_Executing->Object.id; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 10c1c1: 83 f9 02 cmp $0x2,%ecx 10c1c4: 74 05 je 10c1cb <_CORE_mutex_Initialize+0x4f> 10c1c6: 83 f9 03 cmp $0x3,%ecx 10c1c9: 75 22 jne 10c1ed <_CORE_mutex_Initialize+0x71> _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { if ( _Thread_Executing->current_priority < 10c1cb: 8b 48 4c mov 0x4c(%eax),%ecx 10c1ce: 39 4a 14 cmp %ecx,0x14(%edx) 10c1d1: 72 41 jb 10c214 <_CORE_mutex_Initialize+0x98> _Chain_Prepend_unprotected( &_Thread_Executing->lock_mutex, &the_mutex->queue.lock_queue ); the_mutex->queue.priority_before = _Thread_Executing->current_priority; #endif _Thread_Executing->resource_count++; 10c1d3: ff 42 1c incl 0x1c(%edx) 10c1d6: eb 15 jmp 10c1ed <_CORE_mutex_Initialize+0x71> } } else { the_mutex->nest_count = 0; 10c1d8: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) the_mutex->holder = NULL; 10c1df: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax) the_mutex->holder_id = 0; 10c1e6: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax) } _Thread_queue_Initialize( 10c1ed: 6a 05 push $0x5 10c1ef: 68 00 04 00 00 push $0x400 10c1f4: 31 d2 xor %edx,%edx 10c1f6: 83 7b 08 00 cmpl $0x0,0x8(%ebx) 10c1fa: 0f 95 c2 setne %dl 10c1fd: 52 push %edx 10c1fe: 50 push %eax 10c1ff: e8 b8 1e 00 00 call 10e0bc <_Thread_queue_Initialize> THREAD_QUEUE_DISCIPLINE_FIFO : THREAD_QUEUE_DISCIPLINE_PRIORITY, STATES_WAITING_FOR_MUTEX, CORE_MUTEX_TIMEOUT ); return CORE_MUTEX_STATUS_SUCCESSFUL; 10c204: 83 c4 10 add $0x10,%esp 10c207: 31 c0 xor %eax,%eax } 10c209: 8d 65 f4 lea -0xc(%ebp),%esp 10c20c: 5b pop %ebx 10c20d: 5e pop %esi 10c20e: 5f pop %edi 10c20f: c9 leave 10c210: c3 ret 10c211: 8d 76 00 lea 0x0(%esi),%esi if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { if ( _Thread_Executing->current_priority < the_mutex->Attributes.priority_ceiling ) return CORE_MUTEX_STATUS_CEILING_VIOLATED; 10c214: b8 06 00 00 00 mov $0x6,%eax STATES_WAITING_FOR_MUTEX, CORE_MUTEX_TIMEOUT ); return CORE_MUTEX_STATUS_SUCCESSFUL; } 10c219: 8d 65 f4 lea -0xc(%ebp),%esp 10c21c: 5b pop %ebx 10c21d: 5e pop %esi 10c21e: 5f pop %edi 10c21f: c9 leave 10c220: c3 ret =============================================================================== 0010c274 <_CORE_mutex_Seize>: Objects_Id _id, bool _wait, Watchdog_Interval _timeout, ISR_Level _level ) { 10c274: 55 push %ebp 10c275: 89 e5 mov %esp,%ebp 10c277: 53 push %ebx 10c278: 83 ec 14 sub $0x14,%esp 10c27b: 8b 5d 08 mov 0x8(%ebp),%ebx 10c27e: 8a 55 10 mov 0x10(%ebp),%dl _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 10c281: a1 90 7d 12 00 mov 0x127d90,%eax 10c286: 85 c0 test %eax,%eax 10c288: 74 04 je 10c28e <_CORE_mutex_Seize+0x1a> 10c28a: 84 d2 test %dl,%dl 10c28c: 75 36 jne 10c2c4 <_CORE_mutex_Seize+0x50><== ALWAYS TAKEN 10c28e: 83 ec 08 sub $0x8,%esp 10c291: 8d 45 18 lea 0x18(%ebp),%eax 10c294: 50 push %eax 10c295: 53 push %ebx 10c296: 88 55 f4 mov %dl,-0xc(%ebp) 10c299: e8 1a 4f 00 00 call 1111b8 <_CORE_mutex_Seize_interrupt_trylock> 10c29e: 83 c4 10 add $0x10,%esp 10c2a1: 85 c0 test %eax,%eax 10c2a3: 8a 55 f4 mov -0xc(%ebp),%dl 10c2a6: 74 14 je 10c2bc <_CORE_mutex_Seize+0x48> 10c2a8: 84 d2 test %dl,%dl 10c2aa: 75 30 jne 10c2dc <_CORE_mutex_Seize+0x68> 10c2ac: ff 75 18 pushl 0x18(%ebp) 10c2af: 9d popf 10c2b0: a1 38 83 12 00 mov 0x128338,%eax 10c2b5: c7 40 34 01 00 00 00 movl $0x1,0x34(%eax) } 10c2bc: 8b 5d fc mov -0x4(%ebp),%ebx 10c2bf: c9 leave 10c2c0: c3 ret 10c2c1: 8d 76 00 lea 0x0(%esi),%esi bool _wait, Watchdog_Interval _timeout, ISR_Level _level ) { _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 10c2c4: 83 3d 20 7f 12 00 01 cmpl $0x1,0x127f20 10c2cb: 76 c1 jbe 10c28e <_CORE_mutex_Seize+0x1a> 10c2cd: 53 push %ebx 10c2ce: 6a 12 push $0x12 10c2d0: 6a 00 push $0x0 10c2d2: 6a 00 push $0x0 10c2d4: e8 1b 06 00 00 call 10c8f4 <_Internal_error_Occurred> 10c2d9: 8d 76 00 lea 0x0(%esi),%esi 10c2dc: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx) 10c2e3: a1 38 83 12 00 mov 0x128338,%eax 10c2e8: 89 58 44 mov %ebx,0x44(%eax) 10c2eb: 8b 55 0c mov 0xc(%ebp),%edx 10c2ee: 89 50 20 mov %edx,0x20(%eax) 10c2f1: a1 90 7d 12 00 mov 0x127d90,%eax 10c2f6: 40 inc %eax 10c2f7: a3 90 7d 12 00 mov %eax,0x127d90 10c2fc: ff 75 18 pushl 0x18(%ebp) 10c2ff: 9d popf 10c300: 83 ec 08 sub $0x8,%esp 10c303: ff 75 14 pushl 0x14(%ebp) 10c306: 53 push %ebx 10c307: e8 18 ff ff ff call 10c224 <_CORE_mutex_Seize_interrupt_blocking> 10c30c: 83 c4 10 add $0x10,%esp } 10c30f: 8b 5d fc mov -0x4(%ebp),%ebx 10c312: c9 leave 10c313: c3 ret =============================================================================== 001111b8 <_CORE_mutex_Seize_interrupt_trylock>: #if defined(__RTEMS_DO_NOT_INLINE_CORE_MUTEX_SEIZE__) int _CORE_mutex_Seize_interrupt_trylock( CORE_mutex_Control *the_mutex, ISR_Level *level_p ) { 1111b8: 55 push %ebp 1111b9: 89 e5 mov %esp,%ebp 1111bb: 56 push %esi 1111bc: 53 push %ebx 1111bd: 8b 45 08 mov 0x8(%ebp),%eax 1111c0: 8b 4d 0c mov 0xc(%ebp),%ecx { Thread_Control *executing; /* disabled when you get here */ executing = _Thread_Executing; 1111c3: 8b 15 38 83 12 00 mov 0x128338,%edx executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 1111c9: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx) if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 1111d0: 8b 58 50 mov 0x50(%eax),%ebx 1111d3: 85 db test %ebx,%ebx 1111d5: 74 31 je 111208 <_CORE_mutex_Seize_interrupt_trylock+0x50> the_mutex->lock = CORE_MUTEX_LOCKED; 1111d7: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) the_mutex->holder = executing; 1111de: 89 50 5c mov %edx,0x5c(%eax) the_mutex->holder_id = executing->Object.id; 1111e1: 8b 5a 08 mov 0x8(%edx),%ebx 1111e4: 89 58 60 mov %ebx,0x60(%eax) the_mutex->nest_count = 1; 1111e7: c7 40 54 01 00 00 00 movl $0x1,0x54(%eax) return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p ); } 1111ee: 8b 58 48 mov 0x48(%eax),%ebx if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 1111f1: 83 fb 02 cmp $0x2,%ebx 1111f4: 74 26 je 11121c <_CORE_mutex_Seize_interrupt_trylock+0x64> 1111f6: 83 fb 03 cmp $0x3,%ebx 1111f9: 74 3d je 111238 <_CORE_mutex_Seize_interrupt_trylock+0x80> executing->resource_count++; } if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { _ISR_Enable( *level_p ); 1111fb: ff 31 pushl (%ecx) 1111fd: 9d popf return 0; 1111fe: 31 c0 xor %eax,%eax 111200: 8d 65 f8 lea -0x8(%ebp),%esp 111203: 5b pop %ebx 111204: 5e pop %esi 111205: c9 leave 111206: c3 ret 111207: 90 nop /* * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { 111208: 3b 50 5c cmp 0x5c(%eax),%edx 11120b: 74 17 je 111224 <_CORE_mutex_Seize_interrupt_trylock+0x6c> /* * The mutex is not available and the caller must deal with the possibility * of blocking. */ return 1; 11120d: b8 01 00 00 00 mov $0x1,%eax 111212: 8d 65 f8 lea -0x8(%ebp),%esp 111215: 5b pop %ebx 111216: 5e pop %esi 111217: c9 leave 111218: c3 ret 111219: 8d 76 00 lea 0x0(%esi),%esi _Chain_Prepend_unprotected( &executing->lock_mutex, &the_mutex->queue.lock_queue ); the_mutex->queue.priority_before = executing->current_priority; #endif executing->resource_count++; 11121c: ff 42 1c incl 0x1c(%edx) 11121f: eb da jmp 1111fb <_CORE_mutex_Seize_interrupt_trylock+0x43> 111221: 8d 76 00 lea 0x0(%esi),%esi * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { 111224: 8b 58 40 mov 0x40(%eax),%ebx 111227: 85 db test %ebx,%ebx 111229: 75 45 jne 111270 <_CORE_mutex_Seize_interrupt_trylock+0xb8> case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 11122b: ff 40 54 incl 0x54(%eax) _ISR_Enable( *level_p ); 11122e: ff 31 pushl (%ecx) 111230: 9d popf return 0; 111231: 31 c0 xor %eax,%eax 111233: eb dd jmp 111212 <_CORE_mutex_Seize_interrupt_trylock+0x5a> 111235: 8d 76 00 lea 0x0(%esi),%esi _Chain_Prepend_unprotected( &executing->lock_mutex, &the_mutex->queue.lock_queue ); the_mutex->queue.priority_before = executing->current_priority; #endif executing->resource_count++; 111238: 8b 5a 1c mov 0x1c(%edx),%ebx 11123b: 8d 73 01 lea 0x1(%ebx),%esi 11123e: 89 72 1c mov %esi,0x1c(%edx) Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { 111241: 8b 72 14 mov 0x14(%edx),%esi 111244: 39 70 4c cmp %esi,0x4c(%eax) 111247: 74 6b je 1112b4 <_CORE_mutex_Seize_interrupt_trylock+0xfc> _ISR_Enable( *level_p ); return 0; } if ( current > ceiling ) { 111249: 72 39 jb 111284 <_CORE_mutex_Seize_interrupt_trylock+0xcc> ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 11124b: c7 42 34 06 00 00 00 movl $0x6,0x34(%edx) the_mutex->lock = CORE_MUTEX_UNLOCKED; 111252: c7 40 50 01 00 00 00 movl $0x1,0x50(%eax) the_mutex->nest_count = 0; /* undo locking above */ 111259: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) executing->resource_count--; /* undo locking above */ 111260: 89 5a 1c mov %ebx,0x1c(%edx) _ISR_Enable( *level_p ); 111263: ff 31 pushl (%ecx) 111265: 9d popf return 0; 111266: 31 c0 xor %eax,%eax 111268: 8d 65 f8 lea -0x8(%ebp),%esp 11126b: 5b pop %ebx 11126c: 5e pop %esi 11126d: c9 leave 11126e: c3 ret 11126f: 90 nop * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { 111270: 4b dec %ebx 111271: 75 9a jne 11120d <_CORE_mutex_Seize_interrupt_trylock+0x55> the_mutex->nest_count++; _ISR_Enable( *level_p ); return 0; #if defined(RTEMS_POSIX_API) case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 111273: c7 42 34 02 00 00 00 movl $0x2,0x34(%edx) _ISR_Enable( *level_p ); 11127a: ff 31 pushl (%ecx) 11127c: 9d popf return 0; 11127d: 31 c0 xor %eax,%eax 11127f: eb 91 jmp 111212 <_CORE_mutex_Seize_interrupt_trylock+0x5a> 111281: 8d 76 00 lea 0x0(%esi),%esi rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 111284: 8b 15 90 7d 12 00 mov 0x127d90,%edx 11128a: 42 inc %edx 11128b: 89 15 90 7d 12 00 mov %edx,0x127d90 return 0; } if ( current > ceiling ) { _Thread_Disable_dispatch(); _ISR_Enable( *level_p ); 111291: ff 31 pushl (%ecx) 111293: 9d popf _Thread_Change_priority( 111294: 52 push %edx 111295: 6a 00 push $0x0 111297: ff 70 4c pushl 0x4c(%eax) 11129a: ff 70 5c pushl 0x5c(%eax) 11129d: e8 d6 c2 ff ff call 10d578 <_Thread_Change_priority> the_mutex->holder, the_mutex->Attributes.priority_ceiling, false ); _Thread_Enable_dispatch(); 1112a2: e8 09 c7 ff ff call 10d9b0 <_Thread_Enable_dispatch> 1112a7: 83 c4 10 add $0x10,%esp return 0; 1112aa: 31 c0 xor %eax,%eax 1112ac: e9 61 ff ff ff jmp 111212 <_CORE_mutex_Seize_interrupt_trylock+0x5a> 1112b1: 8d 76 00 lea 0x0(%esi),%esi Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( *level_p ); 1112b4: ff 31 pushl (%ecx) 1112b6: 9d popf return 0; 1112b7: 31 c0 xor %eax,%eax 1112b9: e9 54 ff ff ff jmp 111212 <_CORE_mutex_Seize_interrupt_trylock+0x5a> =============================================================================== 0010c314 <_CORE_mutex_Surrender>: #else Objects_Id id __attribute__((unused)), CORE_mutex_API_mp_support_callout api_mutex_mp_support __attribute__((unused)) #endif ) { 10c314: 55 push %ebp 10c315: 89 e5 mov %esp,%ebp 10c317: 53 push %ebx 10c318: 83 ec 04 sub $0x4,%esp 10c31b: 8b 5d 08 mov 0x8(%ebp),%ebx Thread_Control *the_thread; Thread_Control *holder; holder = the_mutex->holder; 10c31e: 8b 43 5c mov 0x5c(%ebx),%eax * allowed when the mutex in quetion is FIFO or simple Priority * discipline. But Priority Ceiling or Priority Inheritance mutexes * must be released by the thread which acquired them. */ if ( the_mutex->Attributes.only_owner_release ) { 10c321: 80 7b 44 00 cmpb $0x0,0x44(%ebx) 10c325: 74 15 je 10c33c <_CORE_mutex_Surrender+0x28> if ( !_Thread_Is_executing( holder ) ) 10c327: 3b 05 38 83 12 00 cmp 0x128338,%eax 10c32d: 74 0d je 10c33c <_CORE_mutex_Surrender+0x28> return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE; 10c32f: b8 03 00 00 00 mov $0x3,%eax } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; return CORE_MUTEX_STATUS_SUCCESSFUL; } 10c334: 8b 5d fc mov -0x4(%ebp),%ebx 10c337: c9 leave 10c338: c3 ret 10c339: 8d 76 00 lea 0x0(%esi),%esi return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE; } /* XXX already unlocked -- not right status */ if ( !the_mutex->nest_count ) 10c33c: 8b 53 54 mov 0x54(%ebx),%edx 10c33f: 85 d2 test %edx,%edx 10c341: 74 51 je 10c394 <_CORE_mutex_Surrender+0x80> return CORE_MUTEX_STATUS_SUCCESSFUL; the_mutex->nest_count--; 10c343: 4a dec %edx 10c344: 89 53 54 mov %edx,0x54(%ebx) if ( the_mutex->nest_count != 0 ) { 10c347: 85 d2 test %edx,%edx 10c349: 75 49 jne 10c394 <_CORE_mutex_Surrender+0x80> } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; return CORE_MUTEX_STATUS_SUCCESSFUL; } 10c34b: 8b 53 48 mov 0x48(%ebx),%edx /* * Formally release the mutex before possibly transferring it to a * blocked thread. */ if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 10c34e: 83 fa 02 cmp $0x2,%edx 10c351: 74 69 je 10c3bc <_CORE_mutex_Surrender+0xa8> 10c353: 83 fa 03 cmp $0x3,%edx 10c356: 74 64 je 10c3bc <_CORE_mutex_Surrender+0xa8> if ( holder->resource_count == 0 && holder->real_priority != holder->current_priority ) { _Thread_Change_priority( holder, holder->real_priority, true ); } } the_mutex->holder = NULL; 10c358: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) the_mutex->holder_id = 0; 10c35f: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) /* * Now we check if another thread was waiting for this mutex. If so, * transfer the mutex to that thread. */ if ( ( the_thread = _Thread_queue_Dequeue( &the_mutex->Wait_queue ) ) ) { 10c366: 83 ec 0c sub $0xc,%esp 10c369: 53 push %ebx 10c36a: e8 bd 19 00 00 call 10dd2c <_Thread_queue_Dequeue> 10c36f: 83 c4 10 add $0x10,%esp 10c372: 85 c0 test %eax,%eax 10c374: 74 7a je 10c3f0 <_CORE_mutex_Surrender+0xdc> } else #endif { the_mutex->holder = the_thread; 10c376: 89 43 5c mov %eax,0x5c(%ebx) the_mutex->holder_id = the_thread->Object.id; 10c379: 8b 50 08 mov 0x8(%eax),%edx 10c37c: 89 53 60 mov %edx,0x60(%ebx) the_mutex->nest_count = 1; 10c37f: c7 43 54 01 00 00 00 movl $0x1,0x54(%ebx) switch ( the_mutex->Attributes.discipline ) { 10c386: 8b 53 48 mov 0x48(%ebx),%edx 10c389: 83 fa 02 cmp $0x2,%edx 10c38c: 74 56 je 10c3e4 <_CORE_mutex_Surrender+0xd0> 10c38e: 83 fa 03 cmp $0x3,%edx 10c391: 74 09 je 10c39c <_CORE_mutex_Surrender+0x88> 10c393: 90 nop } } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; return CORE_MUTEX_STATUS_SUCCESSFUL; 10c394: 31 c0 xor %eax,%eax } 10c396: 8b 5d fc mov -0x4(%ebp),%ebx 10c399: c9 leave 10c39a: c3 ret 10c39b: 90 nop _CORE_mutex_Push_priority( the_mutex, the_thread ); the_thread->resource_count++; break; case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING: _CORE_mutex_Push_priority( the_mutex, the_thread ); the_thread->resource_count++; 10c39c: ff 40 1c incl 0x1c(%eax) if (the_mutex->Attributes.priority_ceiling < 10c39f: 8b 53 4c mov 0x4c(%ebx),%edx 10c3a2: 3b 50 14 cmp 0x14(%eax),%edx 10c3a5: 73 ed jae 10c394 <_CORE_mutex_Surrender+0x80> the_thread->current_priority){ _Thread_Change_priority( 10c3a7: 51 push %ecx 10c3a8: 6a 00 push $0x0 10c3aa: 52 push %edx 10c3ab: 50 push %eax 10c3ac: e8 c7 11 00 00 call 10d578 <_Thread_Change_priority> 10c3b1: 83 c4 10 add $0x10,%esp } } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; return CORE_MUTEX_STATUS_SUCCESSFUL; 10c3b4: 31 c0 xor %eax,%eax 10c3b6: e9 79 ff ff ff jmp 10c334 <_CORE_mutex_Surrender+0x20> 10c3bb: 90 nop _CORE_mutex_Pop_priority( the_mutex, holder ); if ( pop_status != CORE_MUTEX_STATUS_SUCCESSFUL ) return pop_status; holder->resource_count--; 10c3bc: 8b 50 1c mov 0x1c(%eax),%edx 10c3bf: 4a dec %edx 10c3c0: 89 50 1c mov %edx,0x1c(%eax) /* * Whether or not someone is waiting for the mutex, an * inherited priority must be lowered if this is the last * mutex (i.e. resource) this task has. */ if ( holder->resource_count == 0 && 10c3c3: 85 d2 test %edx,%edx 10c3c5: 75 91 jne 10c358 <_CORE_mutex_Surrender+0x44> holder->real_priority != holder->current_priority ) { 10c3c7: 8b 50 18 mov 0x18(%eax),%edx /* * Whether or not someone is waiting for the mutex, an * inherited priority must be lowered if this is the last * mutex (i.e. resource) this task has. */ if ( holder->resource_count == 0 && 10c3ca: 3b 50 14 cmp 0x14(%eax),%edx 10c3cd: 74 89 je 10c358 <_CORE_mutex_Surrender+0x44> holder->real_priority != holder->current_priority ) { _Thread_Change_priority( holder, holder->real_priority, true ); 10c3cf: 51 push %ecx 10c3d0: 6a 01 push $0x1 10c3d2: 52 push %edx 10c3d3: 50 push %eax 10c3d4: e8 9f 11 00 00 call 10d578 <_Thread_Change_priority> 10c3d9: 83 c4 10 add $0x10,%esp 10c3dc: e9 77 ff ff ff jmp 10c358 <_CORE_mutex_Surrender+0x44> 10c3e1: 8d 76 00 lea 0x0(%esi),%esi case CORE_MUTEX_DISCIPLINES_FIFO: case CORE_MUTEX_DISCIPLINES_PRIORITY: break; case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT: _CORE_mutex_Push_priority( the_mutex, the_thread ); the_thread->resource_count++; 10c3e4: ff 40 1c incl 0x1c(%eax) } } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; return CORE_MUTEX_STATUS_SUCCESSFUL; 10c3e7: 31 c0 xor %eax,%eax case CORE_MUTEX_DISCIPLINES_PRIORITY: break; case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT: _CORE_mutex_Push_priority( the_mutex, the_thread ); the_thread->resource_count++; break; 10c3e9: e9 46 ff ff ff jmp 10c334 <_CORE_mutex_Surrender+0x20> 10c3ee: 66 90 xchg %ax,%ax } break; } } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; 10c3f0: c7 43 50 01 00 00 00 movl $0x1,0x50(%ebx) return CORE_MUTEX_STATUS_SUCCESSFUL; 10c3f7: 31 c0 xor %eax,%eax 10c3f9: e9 36 ff ff ff jmp 10c334 <_CORE_mutex_Surrender+0x20> =============================================================================== 001152b8 <_CORE_semaphore_Seize>: CORE_semaphore_Control *the_semaphore, Objects_Id id, bool wait, Watchdog_Interval timeout ) { 1152b8: 55 push %ebp 1152b9: 89 e5 mov %esp,%ebp 1152bb: 57 push %edi 1152bc: 56 push %esi 1152bd: 53 push %ebx 1152be: 83 ec 1c sub $0x1c,%esp 1152c1: 8b 45 08 mov 0x8(%ebp),%eax 1152c4: 8b 7d 0c mov 0xc(%ebp),%edi 1152c7: 8b 75 14 mov 0x14(%ebp),%esi 1152ca: 8a 5d 10 mov 0x10(%ebp),%bl Thread_Control *executing; ISR_Level level; executing = _Thread_Executing; 1152cd: 8b 15 b8 e0 12 00 mov 0x12e0b8,%edx executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 1152d3: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx) _ISR_Disable( level ); 1152da: 9c pushf 1152db: fa cli 1152dc: 8f 45 e4 popl -0x1c(%ebp) if ( the_semaphore->count != 0 ) { 1152df: 8b 48 48 mov 0x48(%eax),%ecx 1152e2: 85 c9 test %ecx,%ecx 1152e4: 75 46 jne 11532c <_CORE_semaphore_Seize+0x74> /* * If the semaphore was not available and the caller was not willing * to block, then return immediately with a status indicating that * the semaphore was not available and the caller never blocked. */ if ( !wait ) { 1152e6: 84 db test %bl,%bl 1152e8: 75 16 jne 115300 <_CORE_semaphore_Seize+0x48> _ISR_Enable( level ); 1152ea: ff 75 e4 pushl -0x1c(%ebp) 1152ed: 9d popf executing->Wait.return_code = CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT; 1152ee: c7 42 34 01 00 00 00 movl $0x1,0x34(%edx) _Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue ); executing->Wait.queue = &the_semaphore->Wait_queue; executing->Wait.id = id; _ISR_Enable( level ); _Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout ); } 1152f5: 83 c4 1c add $0x1c,%esp 1152f8: 5b pop %ebx 1152f9: 5e pop %esi 1152fa: 5f pop %edi 1152fb: c9 leave 1152fc: c3 ret 1152fd: 8d 76 00 lea 0x0(%esi),%esi 115300: c7 40 30 01 00 00 00 movl $0x1,0x30(%eax) /* * If the semaphore is not available and the caller is willing to * block, then we now block the caller with optional timeout. */ _Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue ); executing->Wait.queue = &the_semaphore->Wait_queue; 115307: 89 42 44 mov %eax,0x44(%edx) executing->Wait.id = id; 11530a: 89 7a 20 mov %edi,0x20(%edx) _ISR_Enable( level ); 11530d: ff 75 e4 pushl -0x1c(%ebp) 115310: 9d popf _Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout ); 115311: c7 45 10 a4 1b 11 00 movl $0x111ba4,0x10(%ebp) 115318: 89 75 0c mov %esi,0xc(%ebp) 11531b: 89 45 08 mov %eax,0x8(%ebp) } 11531e: 83 c4 1c add $0x1c,%esp 115321: 5b pop %ebx 115322: 5e pop %esi 115323: 5f pop %edi 115324: c9 leave */ _Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue ); executing->Wait.queue = &the_semaphore->Wait_queue; executing->Wait.id = id; _ISR_Enable( level ); _Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout ); 115325: e9 4e c5 ff ff jmp 111878 <_Thread_queue_Enqueue_with_handler> 11532a: 66 90 xchg %ax,%ax executing = _Thread_Executing; executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL; _ISR_Disable( level ); if ( the_semaphore->count != 0 ) { the_semaphore->count -= 1; 11532c: 49 dec %ecx 11532d: 89 48 48 mov %ecx,0x48(%eax) _ISR_Enable( level ); 115330: ff 75 e4 pushl -0x1c(%ebp) 115333: 9d popf _Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue ); executing->Wait.queue = &the_semaphore->Wait_queue; executing->Wait.id = id; _ISR_Enable( level ); _Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout ); } 115334: 83 c4 1c add $0x1c,%esp 115337: 5b pop %ebx 115338: 5e pop %esi 115339: 5f pop %edi 11533a: c9 leave 11533b: c3 ret =============================================================================== 0010c44c <_CORE_semaphore_Surrender>: CORE_semaphore_Status _CORE_semaphore_Surrender( CORE_semaphore_Control *the_semaphore, Objects_Id id, CORE_semaphore_API_mp_support_callout api_semaphore_mp_support ) { 10c44c: 55 push %ebp 10c44d: 89 e5 mov %esp,%ebp 10c44f: 53 push %ebx 10c450: 83 ec 10 sub $0x10,%esp 10c453: 8b 5d 08 mov 0x8(%ebp),%ebx ISR_Level level; CORE_semaphore_Status status; status = CORE_SEMAPHORE_STATUS_SUCCESSFUL; if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) { 10c456: 53 push %ebx 10c457: e8 d0 18 00 00 call 10dd2c <_Thread_queue_Dequeue> 10c45c: 83 c4 10 add $0x10,%esp 10c45f: 85 c0 test %eax,%eax 10c461: 74 09 je 10c46c <_CORE_semaphore_Surrender+0x20> { Thread_Control *the_thread; ISR_Level level; CORE_semaphore_Status status; status = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 10c463: 31 c0 xor %eax,%eax status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED; _ISR_Enable( level ); } return status; } 10c465: 8b 5d fc mov -0x4(%ebp),%ebx 10c468: c9 leave 10c469: c3 ret 10c46a: 66 90 xchg %ax,%ax if ( !_Objects_Is_local_id( the_thread->Object.id ) ) (*api_semaphore_mp_support) ( the_thread, id ); #endif } else { _ISR_Disable( level ); 10c46c: 9c pushf 10c46d: fa cli 10c46e: 5a pop %edx if ( the_semaphore->count < the_semaphore->Attributes.maximum_count ) 10c46f: 8b 43 48 mov 0x48(%ebx),%eax 10c472: 3b 43 40 cmp 0x40(%ebx),%eax 10c475: 72 0d jb 10c484 <_CORE_semaphore_Surrender+0x38><== ALWAYS TAKEN the_semaphore->count += 1; else status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED; 10c477: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED _ISR_Enable( level ); 10c47c: 52 push %edx 10c47d: 9d popf } return status; } 10c47e: 8b 5d fc mov -0x4(%ebp),%ebx 10c481: c9 leave 10c482: c3 ret 10c483: 90 nop #endif } else { _ISR_Disable( level ); if ( the_semaphore->count < the_semaphore->Attributes.maximum_count ) the_semaphore->count += 1; 10c484: 40 inc %eax 10c485: 89 43 48 mov %eax,0x48(%ebx) { Thread_Control *the_thread; ISR_Level level; CORE_semaphore_Status status; status = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 10c488: 31 c0 xor %eax,%eax 10c48a: eb f0 jmp 10c47c <_CORE_semaphore_Surrender+0x30> =============================================================================== 0010c6ac <_Chain_Get_with_empty_check>: bool _Chain_Get_with_empty_check( Chain_Control *chain, Chain_Node **node ) { 10c6ac: 55 push %ebp 10c6ad: 89 e5 mov %esp,%ebp 10c6af: 57 push %edi 10c6b0: 56 push %esi 10c6b1: 53 push %ebx 10c6b2: 8b 45 08 mov 0x8(%ebp),%eax 10c6b5: 8b 7d 0c mov 0xc(%ebp),%edi ISR_Level level; bool is_empty_now; _ISR_Disable( level ); 10c6b8: 9c pushf 10c6b9: fa cli 10c6ba: 5e pop %esi Chain_Node **the_node ) { bool is_empty_now = true; Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); 10c6bb: 8d 58 04 lea 0x4(%eax),%ebx Chain_Node *old_first = head->next; 10c6be: 8b 10 mov (%eax),%edx if ( old_first != tail ) { 10c6c0: 39 d3 cmp %edx,%ebx 10c6c2: 74 18 je 10c6dc <_Chain_Get_with_empty_check+0x30> Chain_Node *new_first = old_first->next; 10c6c4: 8b 0a mov (%edx),%ecx head->next = new_first; 10c6c6: 89 08 mov %ecx,(%eax) new_first->previous = head; 10c6c8: 89 41 04 mov %eax,0x4(%ecx) *the_node = old_first; 10c6cb: 89 17 mov %edx,(%edi) is_empty_now = new_first == tail; 10c6cd: 39 cb cmp %ecx,%ebx 10c6cf: 0f 94 c0 sete %al is_empty_now = _Chain_Get_with_empty_check_unprotected( chain, node ); _ISR_Enable( level ); 10c6d2: 56 push %esi 10c6d3: 9d popf return is_empty_now; } 10c6d4: 5b pop %ebx 10c6d5: 5e pop %esi 10c6d6: 5f pop %edi 10c6d7: c9 leave 10c6d8: c3 ret 10c6d9: 8d 76 00 lea 0x0(%esi),%esi } else *the_node = NULL; 10c6dc: c7 07 00 00 00 00 movl $0x0,(%edi) RTEMS_INLINE_ROUTINE bool _Chain_Get_with_empty_check_unprotected( Chain_Control *the_chain, Chain_Node **the_node ) { bool is_empty_now = true; 10c6e2: b0 01 mov $0x1,%al 10c6e4: eb ec jmp 10c6d2 <_Chain_Get_with_empty_check+0x26> =============================================================================== 00111084 <_Chain_Initialize>: Chain_Control *the_chain, void *starting_address, size_t number_nodes, size_t node_size ) { 111084: 55 push %ebp 111085: 89 e5 mov %esp,%ebp 111087: 57 push %edi 111088: 56 push %esi 111089: 53 push %ebx 11108a: 83 ec 08 sub $0x8,%esp 11108d: 8b 7d 08 mov 0x8(%ebp),%edi 111090: 8b 4d 10 mov 0x10(%ebp),%ecx 111093: 8b 75 14 mov 0x14(%ebp),%esi size_t count = number_nodes; Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); 111096: 8d 47 04 lea 0x4(%edi),%eax 111099: 89 45 f0 mov %eax,-0x10(%ebp) Chain_Node *current = head; Chain_Node *next = starting_address; head->previous = NULL; 11109c: c7 47 04 00 00 00 00 movl $0x0,0x4(%edi) while ( count-- ) { 1110a3: 85 c9 test %ecx,%ecx 1110a5: 74 35 je 1110dc <_Chain_Initialize+0x58><== NEVER TAKEN 1110a7: 49 dec %ecx 1110a8: 89 4d ec mov %ecx,-0x14(%ebp) { size_t count = number_nodes; Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); Chain_Node *current = head; Chain_Node *next = starting_address; 1110ab: 8b 45 0c mov 0xc(%ebp),%eax ) { size_t count = number_nodes; Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); Chain_Node *current = head; 1110ae: 89 fa mov %edi,%edx 1110b0: eb 07 jmp 1110b9 <_Chain_Initialize+0x35> 1110b2: 66 90 xchg %ax,%ax Chain_Node *next = starting_address; head->previous = NULL; while ( count-- ) { 1110b4: 89 c2 mov %eax,%edx current->next = next; next->previous = current; current = next; next = (Chain_Node *) 1110b6: 89 d8 mov %ebx,%eax 1110b8: 49 dec %ecx Chain_Node *next = starting_address; head->previous = NULL; while ( count-- ) { current->next = next; 1110b9: 89 02 mov %eax,(%edx) next->previous = current; 1110bb: 89 50 04 mov %edx,0x4(%eax) * node_size - size of node in bytes * * Output parameters: NONE */ void _Chain_Initialize( 1110be: 8d 1c 30 lea (%eax,%esi,1),%ebx Chain_Node *current = head; Chain_Node *next = starting_address; head->previous = NULL; while ( count-- ) { 1110c1: 85 c9 test %ecx,%ecx 1110c3: 75 ef jne 1110b4 <_Chain_Initialize+0x30> * node_size - size of node in bytes * * Output parameters: NONE */ void _Chain_Initialize( 1110c5: 0f af 75 ec imul -0x14(%ebp),%esi 1110c9: 03 75 0c add 0xc(%ebp),%esi current = next; next = (Chain_Node *) _Addresses_Add_offset( (void *) next, node_size ); } current->next = tail; 1110cc: 8b 45 f0 mov -0x10(%ebp),%eax 1110cf: 89 06 mov %eax,(%esi) tail->previous = current; 1110d1: 89 77 08 mov %esi,0x8(%edi) } 1110d4: 83 c4 08 add $0x8,%esp 1110d7: 5b pop %ebx 1110d8: 5e pop %esi 1110d9: 5f pop %edi 1110da: c9 leave 1110db: c3 ret ) { size_t count = number_nodes; Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); Chain_Node *current = head; 1110dc: 89 fe mov %edi,%esi <== NOT EXECUTED 1110de: eb ec jmp 1110cc <_Chain_Initialize+0x48><== NOT EXECUTED =============================================================================== 0010b070 <_Event_Seize>: rtems_event_set event_in, rtems_option option_set, rtems_interval ticks, rtems_event_set *event_out ) { 10b070: 55 push %ebp 10b071: 89 e5 mov %esp,%ebp 10b073: 57 push %edi 10b074: 56 push %esi 10b075: 53 push %ebx 10b076: 83 ec 2c sub $0x2c,%esp 10b079: 8b 45 08 mov 0x8(%ebp),%eax 10b07c: 8b 4d 0c mov 0xc(%ebp),%ecx 10b07f: 8b 55 10 mov 0x10(%ebp),%edx 10b082: 89 55 dc mov %edx,-0x24(%ebp) 10b085: 8b 7d 14 mov 0x14(%ebp),%edi rtems_event_set pending_events; ISR_Level level; RTEMS_API_Control *api; Thread_blocking_operation_States sync_state; executing = _Thread_Executing; 10b088: 8b 1d 38 83 12 00 mov 0x128338,%ebx executing->Wait.return_code = RTEMS_SUCCESSFUL; 10b08e: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx) api = executing->API_Extensions[ THREAD_API_RTEMS ]; 10b095: 8b b3 e8 00 00 00 mov 0xe8(%ebx),%esi _ISR_Disable( level ); 10b09b: 9c pushf 10b09c: fa cli 10b09d: 8f 45 e0 popl -0x20(%ebp) pending_events = api->pending_events; 10b0a0: 8b 16 mov (%esi),%edx 10b0a2: 89 55 d4 mov %edx,-0x2c(%ebp) seized_events = _Event_sets_Get( pending_events, event_in ); if ( !_Event_sets_Is_empty( seized_events ) && 10b0a5: 21 c2 and %eax,%edx 10b0a7: 89 55 e4 mov %edx,-0x1c(%ebp) 10b0aa: 74 0d je 10b0b9 <_Event_Seize+0x49> 10b0ac: 39 d0 cmp %edx,%eax 10b0ae: 0f 84 84 00 00 00 je 10b138 <_Event_Seize+0xc8> (seized_events == event_in || _Options_Is_any( option_set )) ) { 10b0b4: f6 c1 02 test $0x2,%cl 10b0b7: 75 7f jne 10b138 <_Event_Seize+0xc8> _ISR_Enable( level ); *event_out = seized_events; return; } if ( _Options_Is_no_wait( option_set ) ) { 10b0b9: f6 c1 01 test $0x1,%cl 10b0bc: 75 62 jne 10b120 <_Event_Seize+0xb0> * set properly when we are marked as in the event critical section. * * NOTE: Since interrupts are disabled, this isn't that much of an * issue but better safe than sorry. */ executing->Wait.option = (uint32_t) option_set; 10b0be: 89 4b 30 mov %ecx,0x30(%ebx) executing->Wait.count = (uint32_t) event_in; 10b0c1: 89 43 24 mov %eax,0x24(%ebx) executing->Wait.return_argument = event_out; 10b0c4: 89 7b 28 mov %edi,0x28(%ebx) _Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 10b0c7: c7 05 68 87 12 00 01 movl $0x1,0x128768 10b0ce: 00 00 00 _ISR_Enable( level ); 10b0d1: ff 75 e0 pushl -0x20(%ebp) 10b0d4: 9d popf if ( ticks ) { 10b0d5: 8b 45 dc mov -0x24(%ebp),%eax 10b0d8: 85 c0 test %eax,%eax 10b0da: 0f 85 80 00 00 00 jne 10b160 <_Event_Seize+0xf0> NULL ); _Watchdog_Insert_ticks( &executing->Timer, ticks ); } _Thread_Set_state( executing, STATES_WAITING_FOR_EVENT ); 10b0e0: 83 ec 08 sub $0x8,%esp 10b0e3: 68 00 01 00 00 push $0x100 10b0e8: 53 push %ebx 10b0e9: e8 e2 30 00 00 call 10e1d0 <_Thread_Set_state> _ISR_Disable( level ); 10b0ee: 9c pushf 10b0ef: fa cli 10b0f0: 5a pop %edx sync_state = _Event_Sync_state; 10b0f1: a1 68 87 12 00 mov 0x128768,%eax _Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10b0f6: c7 05 68 87 12 00 00 movl $0x0,0x128768 10b0fd: 00 00 00 if ( sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) { 10b100: 83 c4 10 add $0x10,%esp 10b103: 83 f8 01 cmp $0x1,%eax 10b106: 74 4c je 10b154 <_Event_Seize+0xe4> * An interrupt completed the thread's blocking request. * The blocking thread was satisfied by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ _Thread_blocking_operation_Cancel( sync_state, executing, level ); 10b108: 89 55 10 mov %edx,0x10(%ebp) 10b10b: 89 5d 0c mov %ebx,0xc(%ebp) 10b10e: 89 45 08 mov %eax,0x8(%ebp) } 10b111: 8d 65 f4 lea -0xc(%ebp),%esp 10b114: 5b pop %ebx 10b115: 5e pop %esi 10b116: 5f pop %edi 10b117: c9 leave * An interrupt completed the thread's blocking request. * The blocking thread was satisfied by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ _Thread_blocking_operation_Cancel( sync_state, executing, level ); 10b118: e9 0f 24 00 00 jmp 10d52c <_Thread_blocking_operation_Cancel> 10b11d: 8d 76 00 lea 0x0(%esi),%esi *event_out = seized_events; return; } if ( _Options_Is_no_wait( option_set ) ) { _ISR_Enable( level ); 10b120: ff 75 e0 pushl -0x20(%ebp) 10b123: 9d popf executing->Wait.return_code = RTEMS_UNSATISFIED; 10b124: c7 43 34 0d 00 00 00 movl $0xd,0x34(%ebx) *event_out = seized_events; 10b12b: 8b 55 e4 mov -0x1c(%ebp),%edx 10b12e: 89 17 mov %edx,(%edi) * The blocking thread was satisfied by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ _Thread_blocking_operation_Cancel( sync_state, executing, level ); } 10b130: 8d 65 f4 lea -0xc(%ebp),%esp 10b133: 5b pop %ebx 10b134: 5e pop %esi 10b135: 5f pop %edi 10b136: c9 leave 10b137: c3 ret RTEMS_INLINE_ROUTINE rtems_event_set _Event_sets_Clear( rtems_event_set the_event_set, rtems_event_set the_mask ) { return ( the_event_set & ~(the_mask) ); 10b138: 8b 45 e4 mov -0x1c(%ebp),%eax 10b13b: f7 d0 not %eax 10b13d: 23 45 d4 and -0x2c(%ebp),%eax 10b140: 89 06 mov %eax,(%esi) if ( !_Event_sets_Is_empty( seized_events ) && (seized_events == event_in || _Options_Is_any( option_set )) ) { api->pending_events = _Event_sets_Clear( pending_events, seized_events ); _ISR_Enable( level ); 10b142: ff 75 e0 pushl -0x20(%ebp) 10b145: 9d popf *event_out = seized_events; 10b146: 8b 45 e4 mov -0x1c(%ebp),%eax 10b149: 89 07 mov %eax,(%edi) * The blocking thread was satisfied by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ _Thread_blocking_operation_Cancel( sync_state, executing, level ); } 10b14b: 8d 65 f4 lea -0xc(%ebp),%esp 10b14e: 5b pop %ebx 10b14f: 5e pop %esi 10b150: 5f pop %edi 10b151: c9 leave 10b152: c3 ret 10b153: 90 nop _ISR_Disable( level ); sync_state = _Event_Sync_state; _Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; if ( sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) { _ISR_Enable( level ); 10b154: 52 push %edx 10b155: 9d popf * The blocking thread was satisfied by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ _Thread_blocking_operation_Cancel( sync_state, executing, level ); } 10b156: 8d 65 f4 lea -0xc(%ebp),%esp 10b159: 5b pop %ebx 10b15a: 5e pop %esi 10b15b: 5f pop %edi 10b15c: c9 leave 10b15d: c3 ret 10b15e: 66 90 xchg %ax,%ax _Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; _ISR_Enable( level ); if ( ticks ) { _Watchdog_Initialize( 10b160: 8b 43 08 mov 0x8(%ebx),%eax Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 10b163: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) the_watchdog->routine = routine; 10b16a: c7 43 64 14 b3 10 00 movl $0x10b314,0x64(%ebx) the_watchdog->id = id; 10b171: 89 43 68 mov %eax,0x68(%ebx) the_watchdog->user_data = user_data; 10b174: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10b17b: 8b 45 dc mov -0x24(%ebp),%eax 10b17e: 89 43 54 mov %eax,0x54(%ebx) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10b181: 83 ec 08 sub $0x8,%esp &executing->Timer, _Event_Timeout, executing->Object.id, NULL ); _Watchdog_Insert_ticks( &executing->Timer, ticks ); 10b184: 8d 43 48 lea 0x48(%ebx),%eax 10b187: 50 push %eax 10b188: 68 60 7e 12 00 push $0x127e60 10b18d: e8 8e 35 00 00 call 10e720 <_Watchdog_Insert> 10b192: 83 c4 10 add $0x10,%esp 10b195: e9 46 ff ff ff jmp 10b0e0 <_Event_Seize+0x70> =============================================================================== 0010b1f0 <_Event_Surrender>: */ void _Event_Surrender( Thread_Control *the_thread ) { 10b1f0: 55 push %ebp 10b1f1: 89 e5 mov %esp,%ebp 10b1f3: 57 push %edi 10b1f4: 56 push %esi 10b1f5: 53 push %ebx 10b1f6: 83 ec 2c sub $0x2c,%esp 10b1f9: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_event_set event_condition; rtems_event_set seized_events; rtems_option option_set; RTEMS_API_Control *api; api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; 10b1fc: 8b 8b e8 00 00 00 mov 0xe8(%ebx),%ecx option_set = (rtems_option) the_thread->Wait.option; 10b202: 8b 7b 30 mov 0x30(%ebx),%edi _ISR_Disable( level ); 10b205: 9c pushf 10b206: fa cli 10b207: 8f 45 d4 popl -0x2c(%ebp) pending_events = api->pending_events; 10b20a: 8b 11 mov (%ecx),%edx event_condition = (rtems_event_set) the_thread->Wait.count; 10b20c: 8b 43 24 mov 0x24(%ebx),%eax seized_events = _Event_sets_Get( pending_events, event_condition ); /* * No events were seized in this operation */ if ( _Event_sets_Is_empty( seized_events ) ) { 10b20f: 89 c6 mov %eax,%esi 10b211: 21 d6 and %edx,%esi 10b213: 89 75 e4 mov %esi,-0x1c(%ebp) 10b216: 74 74 je 10b28c <_Event_Surrender+0x9c> /* * If we are in an ISR and sending to the current thread, then * we have a critical section issue to deal with. */ if ( _ISR_Is_in_progress() && 10b218: 8b 35 34 83 12 00 mov 0x128334,%esi 10b21e: 85 f6 test %esi,%esi 10b220: 74 0c je 10b22e <_Event_Surrender+0x3e> 10b222: 3b 1d 38 83 12 00 cmp 0x128338,%ebx 10b228: 0f 84 96 00 00 00 je 10b2c4 <_Event_Surrender+0xd4> } /* * Otherwise, this is a normal send to another thread */ if ( _States_Is_waiting_for_event( the_thread->current_state ) ) { 10b22e: f6 43 11 01 testb $0x1,0x11(%ebx) 10b232: 74 4c je 10b280 <_Event_Surrender+0x90> if ( seized_events == event_condition || _Options_Is_any( option_set ) ) { 10b234: 3b 45 e4 cmp -0x1c(%ebp),%eax 10b237: 74 05 je 10b23e <_Event_Surrender+0x4e> 10b239: 83 e7 02 and $0x2,%edi 10b23c: 74 42 je 10b280 <_Event_Surrender+0x90> <== NEVER TAKEN RTEMS_INLINE_ROUTINE rtems_event_set _Event_sets_Clear( rtems_event_set the_event_set, rtems_event_set the_mask ) { return ( the_event_set & ~(the_mask) ); 10b23e: 8b 45 e4 mov -0x1c(%ebp),%eax 10b241: f7 d0 not %eax 10b243: 21 d0 and %edx,%eax 10b245: 89 01 mov %eax,(%ecx) api->pending_events = _Event_sets_Clear( pending_events, seized_events ); the_thread->Wait.count = 0; 10b247: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 10b24e: 8b 43 28 mov 0x28(%ebx),%eax 10b251: 8b 75 e4 mov -0x1c(%ebp),%esi 10b254: 89 30 mov %esi,(%eax) _ISR_Flash( level ); 10b256: ff 75 d4 pushl -0x2c(%ebp) 10b259: 9d popf 10b25a: fa cli if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 10b25b: 83 7b 50 02 cmpl $0x2,0x50(%ebx) 10b25f: 74 37 je 10b298 <_Event_Surrender+0xa8> _ISR_Enable( level ); 10b261: ff 75 d4 pushl -0x2c(%ebp) 10b264: 9d popf RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 10b265: 83 ec 08 sub $0x8,%esp 10b268: 68 f8 ff 03 10 push $0x1003fff8 10b26d: 53 push %ebx 10b26e: e8 d9 23 00 00 call 10d64c <_Thread_Clear_state> 10b273: 83 c4 10 add $0x10,%esp } return; } } _ISR_Enable( level ); } 10b276: 8d 65 f4 lea -0xc(%ebp),%esp 10b279: 5b pop %ebx 10b27a: 5e pop %esi 10b27b: 5f pop %edi 10b27c: c9 leave 10b27d: c3 ret 10b27e: 66 90 xchg %ax,%ax _Thread_Unblock( the_thread ); } return; } } _ISR_Enable( level ); 10b280: ff 75 d4 pushl -0x2c(%ebp) 10b283: 9d popf } 10b284: 8d 65 f4 lea -0xc(%ebp),%esp 10b287: 5b pop %ebx 10b288: 5e pop %esi 10b289: 5f pop %edi 10b28a: c9 leave 10b28b: c3 ret /* * No events were seized in this operation */ if ( _Event_sets_Is_empty( seized_events ) ) { _ISR_Enable( level ); 10b28c: ff 75 d4 pushl -0x2c(%ebp) 10b28f: 9d popf } return; } } _ISR_Enable( level ); } 10b290: 8d 65 f4 lea -0xc(%ebp),%esp 10b293: 5b pop %ebx 10b294: 5e pop %esi 10b295: 5f pop %edi 10b296: c9 leave 10b297: c3 ret RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 10b298: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { _ISR_Enable( level ); _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 10b29f: ff 75 d4 pushl -0x2c(%ebp) 10b2a2: 9d popf (void) _Watchdog_Remove( &the_thread->Timer ); 10b2a3: 83 ec 0c sub $0xc,%esp 10b2a6: 8d 43 48 lea 0x48(%ebx),%eax 10b2a9: 50 push %eax 10b2aa: e8 b1 35 00 00 call 10e860 <_Watchdog_Remove> 10b2af: 58 pop %eax 10b2b0: 5a pop %edx 10b2b1: 68 f8 ff 03 10 push $0x1003fff8 10b2b6: 53 push %ebx 10b2b7: e8 90 23 00 00 call 10d64c <_Thread_Clear_state> 10b2bc: 83 c4 10 add $0x10,%esp 10b2bf: eb c3 jmp 10b284 <_Event_Surrender+0x94> 10b2c1: 8d 76 00 lea 0x0(%esi),%esi * If we are in an ISR and sending to the current thread, then * we have a critical section issue to deal with. */ if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) && ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || 10b2c4: 8b 35 68 87 12 00 mov 0x128768,%esi /* * If we are in an ISR and sending to the current thread, then * we have a critical section issue to deal with. */ if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) && 10b2ca: 83 fe 02 cmp $0x2,%esi 10b2cd: 74 0d je 10b2dc <_Event_Surrender+0xec> <== NEVER TAKEN ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || (_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) { 10b2cf: 8b 35 68 87 12 00 mov 0x128768,%esi * If we are in an ISR and sending to the current thread, then * we have a critical section issue to deal with. */ if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) && ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || 10b2d5: 4e dec %esi 10b2d6: 0f 85 52 ff ff ff jne 10b22e <_Event_Surrender+0x3e> (_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) { if ( seized_events == event_condition || _Options_Is_any(option_set) ) { 10b2dc: 3b 45 e4 cmp -0x1c(%ebp),%eax 10b2df: 74 05 je 10b2e6 <_Event_Surrender+0xf6> 10b2e1: 83 e7 02 and $0x2,%edi 10b2e4: 74 22 je 10b308 <_Event_Surrender+0x118><== NEVER TAKEN 10b2e6: 8b 45 e4 mov -0x1c(%ebp),%eax 10b2e9: f7 d0 not %eax 10b2eb: 21 d0 and %edx,%eax 10b2ed: 89 01 mov %eax,(%ecx) api->pending_events = _Event_sets_Clear( pending_events,seized_events ); the_thread->Wait.count = 0; 10b2ef: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 10b2f6: 8b 43 28 mov 0x28(%ebx),%eax 10b2f9: 8b 55 e4 mov -0x1c(%ebp),%edx 10b2fc: 89 10 mov %edx,(%eax) _Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED; 10b2fe: c7 05 68 87 12 00 03 movl $0x3,0x128768 10b305: 00 00 00 } _ISR_Enable( level ); 10b308: ff 75 d4 pushl -0x2c(%ebp) 10b30b: 9d popf return; 10b30c: e9 73 ff ff ff jmp 10b284 <_Event_Surrender+0x94> =============================================================================== 0010b314 <_Event_Timeout>: void _Event_Timeout( Objects_Id id, void *ignored ) { 10b314: 55 push %ebp 10b315: 89 e5 mov %esp,%ebp 10b317: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; ISR_Level level; the_thread = _Thread_Get( id, &location ); 10b31a: 8d 45 f4 lea -0xc(%ebp),%eax 10b31d: 50 push %eax 10b31e: ff 75 08 pushl 0x8(%ebp) 10b321: e8 ae 26 00 00 call 10d9d4 <_Thread_Get> switch ( location ) { 10b326: 83 c4 10 add $0x10,%esp 10b329: 8b 55 f4 mov -0xc(%ebp),%edx 10b32c: 85 d2 test %edx,%edx 10b32e: 75 37 jne 10b367 <_Event_Timeout+0x53> <== NEVER TAKEN * * If it is not satisfied, then it is "nothing happened" and * this is the "timeout" transition. After a request is satisfied, * a timeout is not allowed to occur. */ _ISR_Disable( level ); 10b330: 9c pushf 10b331: fa cli 10b332: 5a pop %edx _ISR_Enable( level ); return; } #endif the_thread->Wait.count = 0; 10b333: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax) if ( _Thread_Is_executing( the_thread ) ) { 10b33a: 3b 05 38 83 12 00 cmp 0x128338,%eax 10b340: 74 2a je 10b36c <_Event_Timeout+0x58> if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) _Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; } the_thread->Wait.return_code = RTEMS_TIMEOUT; 10b342: c7 40 34 06 00 00 00 movl $0x6,0x34(%eax) _ISR_Enable( level ); 10b349: 52 push %edx 10b34a: 9d popf 10b34b: 83 ec 08 sub $0x8,%esp 10b34e: 68 f8 ff 03 10 push $0x1003fff8 10b353: 50 push %eax 10b354: e8 f3 22 00 00 call 10d64c <_Thread_Clear_state> */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 10b359: a1 90 7d 12 00 mov 0x127d90,%eax 10b35e: 48 dec %eax 10b35f: a3 90 7d 12 00 mov %eax,0x127d90 _Thread_Unblock( the_thread ); _Thread_Unnest_dispatch(); break; 10b364: 83 c4 10 add $0x10,%esp case OBJECTS_REMOTE: /* impossible */ #endif case OBJECTS_ERROR: break; } } 10b367: c9 leave 10b368: c3 ret 10b369: 8d 76 00 lea 0x0(%esi),%esi } #endif the_thread->Wait.count = 0; if ( _Thread_Is_executing( the_thread ) ) { if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) 10b36c: 8b 0d 68 87 12 00 mov 0x128768,%ecx 10b372: 49 dec %ecx 10b373: 75 cd jne 10b342 <_Event_Timeout+0x2e> _Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; 10b375: c7 05 68 87 12 00 02 movl $0x2,0x128768 10b37c: 00 00 00 10b37f: eb c1 jmp 10b342 <_Event_Timeout+0x2e> =============================================================================== 00111314 <_Heap_Allocate_aligned_with_boundary>: Heap_Control *heap, uintptr_t alloc_size, uintptr_t alignment, uintptr_t boundary ) { 111314: 55 push %ebp 111315: 89 e5 mov %esp,%ebp 111317: 57 push %edi 111318: 56 push %esi 111319: 53 push %ebx 11131a: 83 ec 2c sub $0x2c,%esp 11131d: 8b 7d 0c mov 0xc(%ebp),%edi Heap_Statistics *const stats = &heap->stats; uintptr_t const block_size_floor = alloc_size + HEAP_BLOCK_HEADER_SIZE 111320: 8d 47 04 lea 0x4(%edi),%eax 111323: 89 45 dc mov %eax,-0x24(%ebp) - HEAP_ALLOC_BONUS; uintptr_t const page_size = heap->page_size; 111326: 8b 55 08 mov 0x8(%ebp),%edx 111329: 8b 52 10 mov 0x10(%edx),%edx 11132c: 89 55 cc mov %edx,-0x34(%ebp) Heap_Block *block = NULL; uintptr_t alloc_begin = 0; uint32_t search_count = 0; bool search_again = false; if ( block_size_floor < alloc_size ) { 11132f: 39 c7 cmp %eax,%edi 111331: 0f 87 69 01 00 00 ja 1114a0 <_Heap_Allocate_aligned_with_boundary+0x18c> /* Integer overflow occured */ return NULL; } if ( boundary != 0 ) { 111337: 8b 5d 14 mov 0x14(%ebp),%ebx 11133a: 85 db test %ebx,%ebx 11133c: 0f 85 56 01 00 00 jne 111498 <_Heap_Allocate_aligned_with_boundary+0x184> if ( stats->max_search < search_count ) { stats->max_search = search_count; } return (void *) alloc_begin; } 111342: 8b 45 08 mov 0x8(%ebp),%eax 111345: 8b 48 08 mov 0x8(%eax),%ecx do { Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); block = _Heap_Free_list_first( heap ); while ( block != free_list_tail ) { 111348: 39 c8 cmp %ecx,%eax 11134a: 0f 84 50 01 00 00 je 1114a0 <_Heap_Allocate_aligned_with_boundary+0x18c> 111350: c7 45 e4 01 00 00 00 movl $0x1,-0x1c(%ebp) uintptr_t const block_begin = (uintptr_t) block; uintptr_t const block_size = _Heap_Block_size( block ); uintptr_t const block_end = block_begin + block_size; uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block ); uintptr_t const alloc_begin_ceiling = block_end - min_block_size 111357: 8b 55 cc mov -0x34(%ebp),%edx 11135a: 83 c2 07 add $0x7,%edx 11135d: 89 55 c8 mov %edx,-0x38(%ebp) + HEAP_BLOCK_HEADER_SIZE + page_size - 1; uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS; 111360: c7 45 d0 04 00 00 00 movl $0x4,-0x30(%ebp) 111367: 29 7d d0 sub %edi,-0x30(%ebp) 11136a: eb 1e jmp 11138a <_Heap_Allocate_aligned_with_boundary+0x76> RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block( const Heap_Block *block ) { return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE; 11136c: 8d 59 08 lea 0x8(%ecx),%ebx } /* Statistics */ ++search_count; if ( alloc_begin != 0 ) { 11136f: 85 db test %ebx,%ebx 111371: 0f 85 f1 00 00 00 jne 111468 <_Heap_Allocate_aligned_with_boundary+0x154><== ALWAYS TAKEN break; } block = block->next; 111377: 8b 49 08 mov 0x8(%ecx),%ecx 11137a: 8b 45 e4 mov -0x1c(%ebp),%eax 11137d: 40 inc %eax do { Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); block = _Heap_Free_list_first( heap ); while ( block != free_list_tail ) { 11137e: 39 4d 08 cmp %ecx,0x8(%ebp) 111381: 0f 84 25 01 00 00 je 1114ac <_Heap_Allocate_aligned_with_boundary+0x198> 111387: 89 45 e4 mov %eax,-0x1c(%ebp) /* * The HEAP_PREV_BLOCK_USED flag is always set in the block size_and_flag * field. Thus the value is about one unit larger than the real block * size. The greater than operator takes this into account. */ if ( block->size_and_flag > block_size_floor ) { 11138a: 8b 59 04 mov 0x4(%ecx),%ebx 11138d: 39 5d dc cmp %ebx,-0x24(%ebp) 111390: 73 e5 jae 111377 <_Heap_Allocate_aligned_with_boundary+0x63> if ( alignment == 0 ) { 111392: 8b 55 10 mov 0x10(%ebp),%edx 111395: 85 d2 test %edx,%edx 111397: 74 d3 je 11136c <_Heap_Allocate_aligned_with_boundary+0x58> if ( stats->max_search < search_count ) { stats->max_search = search_count; } return (void *) alloc_begin; } 111399: 8b 45 08 mov 0x8(%ebp),%eax 11139c: 8b 40 14 mov 0x14(%eax),%eax 11139f: 89 45 d8 mov %eax,-0x28(%ebp) - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 1113a2: 83 e3 fe and $0xfffffffe,%ebx uintptr_t const page_size = heap->page_size; uintptr_t const min_block_size = heap->min_block_size; uintptr_t const block_begin = (uintptr_t) block; uintptr_t const block_size = _Heap_Block_size( block ); uintptr_t const block_end = block_begin + block_size; 1113a5: 8d 1c 19 lea (%ecx,%ebx,1),%ebx RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block( const Heap_Block *block ) { return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE; 1113a8: 8d 51 08 lea 0x8(%ecx),%edx 1113ab: 89 55 d4 mov %edx,-0x2c(%ebp) uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block ); uintptr_t const alloc_begin_ceiling = block_end - min_block_size + HEAP_BLOCK_HEADER_SIZE + page_size - 1; 1113ae: 8b 75 c8 mov -0x38(%ebp),%esi 1113b1: 29 c6 sub %eax,%esi uintptr_t const block_begin = (uintptr_t) block; uintptr_t const block_size = _Heap_Block_size( block ); uintptr_t const block_end = block_begin + block_size; uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block ); uintptr_t const alloc_begin_ceiling = block_end - min_block_size 1113b3: 01 de add %ebx,%esi + HEAP_BLOCK_HEADER_SIZE + page_size - 1; uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS; uintptr_t alloc_begin = alloc_end - alloc_size; 1113b5: 03 5d d0 add -0x30(%ebp),%ebx RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 1113b8: 89 d8 mov %ebx,%eax 1113ba: 31 d2 xor %edx,%edx 1113bc: f7 75 10 divl 0x10(%ebp) 1113bf: 29 d3 sub %edx,%ebx alloc_begin = _Heap_Align_down( alloc_begin, alignment ); /* Ensure that the we have a valid new block at the end */ if ( alloc_begin > alloc_begin_ceiling ) { 1113c1: 39 de cmp %ebx,%esi 1113c3: 73 0b jae 1113d0 <_Heap_Allocate_aligned_with_boundary+0xbc> 1113c5: 89 f0 mov %esi,%eax 1113c7: 31 d2 xor %edx,%edx 1113c9: f7 75 10 divl 0x10(%ebp) 1113cc: 89 f3 mov %esi,%ebx 1113ce: 29 d3 sub %edx,%ebx } alloc_end = alloc_begin + alloc_size; /* Ensure boundary constaint */ if ( boundary != 0 ) { 1113d0: 8b 45 14 mov 0x14(%ebp),%eax 1113d3: 85 c0 test %eax,%eax 1113d5: 74 5b je 111432 <_Heap_Allocate_aligned_with_boundary+0x11e> /* Ensure that the we have a valid new block at the end */ if ( alloc_begin > alloc_begin_ceiling ) { alloc_begin = _Heap_Align_down( alloc_begin_ceiling, alignment ); } alloc_end = alloc_begin + alloc_size; 1113d7: 8d 34 3b lea (%ebx,%edi,1),%esi 1113da: 89 f0 mov %esi,%eax 1113dc: 31 d2 xor %edx,%edx 1113de: f7 75 14 divl 0x14(%ebp) 1113e1: 89 f0 mov %esi,%eax 1113e3: 29 d0 sub %edx,%eax /* Ensure boundary constaint */ if ( boundary != 0 ) { uintptr_t const boundary_floor = alloc_begin_floor + alloc_size; uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary ); while ( alloc_begin < boundary_line && boundary_line < alloc_end ) { 1113e5: 39 c3 cmp %eax,%ebx 1113e7: 73 49 jae 111432 <_Heap_Allocate_aligned_with_boundary+0x11e> 1113e9: 39 c6 cmp %eax,%esi 1113eb: 76 45 jbe 111432 <_Heap_Allocate_aligned_with_boundary+0x11e> alloc_end = alloc_begin + alloc_size; /* Ensure boundary constaint */ if ( boundary != 0 ) { uintptr_t const boundary_floor = alloc_begin_floor + alloc_size; 1113ed: 8b 55 d4 mov -0x2c(%ebp),%edx 1113f0: 01 fa add %edi,%edx 1113f2: 89 55 e0 mov %edx,-0x20(%ebp) uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary ); while ( alloc_begin < boundary_line && boundary_line < alloc_end ) { if ( boundary_line < boundary_floor ) { 1113f5: 39 c2 cmp %eax,%edx 1113f7: 0f 87 7a ff ff ff ja 111377 <_Heap_Allocate_aligned_with_boundary+0x63> 1113fd: 89 ce mov %ecx,%esi 1113ff: eb 10 jmp 111411 <_Heap_Allocate_aligned_with_boundary+0xfd> 111401: 8d 76 00 lea 0x0(%esi),%esi /* Ensure boundary constaint */ if ( boundary != 0 ) { uintptr_t const boundary_floor = alloc_begin_floor + alloc_size; uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary ); while ( alloc_begin < boundary_line && boundary_line < alloc_end ) { 111404: 39 c1 cmp %eax,%ecx 111406: 76 28 jbe 111430 <_Heap_Allocate_aligned_with_boundary+0x11c> if ( boundary_line < boundary_floor ) { 111408: 39 45 e0 cmp %eax,-0x20(%ebp) 11140b: 0f 87 9f 00 00 00 ja 1114b0 <_Heap_Allocate_aligned_with_boundary+0x19c><== NEVER TAKEN return 0; } alloc_begin = boundary_line - alloc_size; 111411: 89 c3 mov %eax,%ebx 111413: 29 fb sub %edi,%ebx 111415: 89 d8 mov %ebx,%eax 111417: 31 d2 xor %edx,%edx 111419: f7 75 10 divl 0x10(%ebp) 11141c: 29 d3 sub %edx,%ebx alloc_begin = _Heap_Align_down( alloc_begin, alignment ); alloc_end = alloc_begin + alloc_size; 11141e: 8d 0c 3b lea (%ebx,%edi,1),%ecx 111421: 89 c8 mov %ecx,%eax 111423: 31 d2 xor %edx,%edx 111425: f7 75 14 divl 0x14(%ebp) 111428: 89 c8 mov %ecx,%eax 11142a: 29 d0 sub %edx,%eax /* Ensure boundary constaint */ if ( boundary != 0 ) { uintptr_t const boundary_floor = alloc_begin_floor + alloc_size; uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary ); while ( alloc_begin < boundary_line && boundary_line < alloc_end ) { 11142c: 39 c3 cmp %eax,%ebx 11142e: 72 d4 jb 111404 <_Heap_Allocate_aligned_with_boundary+0xf0> 111430: 89 f1 mov %esi,%ecx boundary_line = _Heap_Align_down( alloc_end, boundary ); } } /* Ensure that the we have a valid new block at the beginning */ if ( alloc_begin >= alloc_begin_floor ) { 111432: 39 5d d4 cmp %ebx,-0x2c(%ebp) 111435: 0f 87 3c ff ff ff ja 111377 <_Heap_Allocate_aligned_with_boundary+0x63> 11143b: be f8 ff ff ff mov $0xfffffff8,%esi 111440: 29 ce sub %ecx,%esi uintptr_t alloc_begin, uintptr_t page_size ) { return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size ) - HEAP_BLOCK_HEADER_SIZE); 111442: 01 de add %ebx,%esi RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 111444: 89 d8 mov %ebx,%eax 111446: 31 d2 xor %edx,%edx 111448: f7 75 cc divl -0x34(%ebp) uintptr_t const alloc_block_begin = (uintptr_t) _Heap_Block_of_alloc_area( alloc_begin, page_size ); uintptr_t const free_size = alloc_block_begin - block_begin; 11144b: 29 d6 sub %edx,%esi if ( free_size >= min_block_size || free_size == 0 ) { 11144d: 39 75 d8 cmp %esi,-0x28(%ebp) 111450: 0f 86 19 ff ff ff jbe 11136f <_Heap_Allocate_aligned_with_boundary+0x5b> 111456: 85 f6 test %esi,%esi 111458: 0f 85 19 ff ff ff jne 111377 <_Heap_Allocate_aligned_with_boundary+0x63> } /* Statistics */ ++search_count; if ( alloc_begin != 0 ) { 11145e: 85 db test %ebx,%ebx 111460: 0f 84 11 ff ff ff je 111377 <_Heap_Allocate_aligned_with_boundary+0x63><== NEVER TAKEN 111466: 66 90 xchg %ax,%ax search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin ); } while ( search_again ); if ( alloc_begin != 0 ) { /* Statistics */ ++stats->allocs; 111468: 8b 45 08 mov 0x8(%ebp),%eax 11146b: ff 40 48 incl 0x48(%eax) stats->searches += search_count; 11146e: 8b 55 e4 mov -0x1c(%ebp),%edx 111471: 01 50 4c add %edx,0x4c(%eax) block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size ); 111474: 57 push %edi 111475: 53 push %ebx 111476: 51 push %ecx 111477: 50 push %eax 111478: e8 83 b3 ff ff call 10c800 <_Heap_Block_allocate> 11147d: 89 d8 mov %ebx,%eax 11147f: 83 c4 10 add $0x10,%esp boundary ); } /* Statistics */ if ( stats->max_search < search_count ) { 111482: 8b 55 e4 mov -0x1c(%ebp),%edx 111485: 8b 4d 08 mov 0x8(%ebp),%ecx 111488: 39 51 44 cmp %edx,0x44(%ecx) 11148b: 73 15 jae 1114a2 <_Heap_Allocate_aligned_with_boundary+0x18e> stats->max_search = search_count; 11148d: 89 51 44 mov %edx,0x44(%ecx) } return (void *) alloc_begin; } 111490: 8d 65 f4 lea -0xc(%ebp),%esp 111493: 5b pop %ebx 111494: 5e pop %esi 111495: 5f pop %edi 111496: c9 leave 111497: c3 ret /* Integer overflow occured */ return NULL; } if ( boundary != 0 ) { if ( boundary < alloc_size ) { 111498: 3b 7d 14 cmp 0x14(%ebp),%edi 11149b: 76 1a jbe 1114b7 <_Heap_Allocate_aligned_with_boundary+0x1a3> 11149d: 8d 76 00 lea 0x0(%esi),%esi do { Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); block = _Heap_Free_list_first( heap ); while ( block != free_list_tail ) { 1114a0: 31 c0 xor %eax,%eax if ( stats->max_search < search_count ) { stats->max_search = search_count; } return (void *) alloc_begin; } 1114a2: 8d 65 f4 lea -0xc(%ebp),%esp 1114a5: 5b pop %ebx 1114a6: 5e pop %esi 1114a7: 5f pop %edi 1114a8: c9 leave 1114a9: c3 ret 1114aa: 66 90 xchg %ax,%ax do { Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); block = _Heap_Free_list_first( heap ); while ( block != free_list_tail ) { 1114ac: 31 c0 xor %eax,%eax 1114ae: eb d2 jmp 111482 <_Heap_Allocate_aligned_with_boundary+0x16e> 1114b0: 89 f1 mov %esi,%ecx <== NOT EXECUTED 1114b2: e9 c0 fe ff ff jmp 111377 <_Heap_Allocate_aligned_with_boundary+0x63><== NOT EXECUTED if ( boundary != 0 ) { if ( boundary < alloc_size ) { return NULL; } if ( alignment == 0 ) { 1114b7: 8b 4d 10 mov 0x10(%ebp),%ecx 1114ba: 85 c9 test %ecx,%ecx 1114bc: 0f 85 80 fe ff ff jne 111342 <_Heap_Allocate_aligned_with_boundary+0x2e> alignment = page_size; 1114c2: 89 55 10 mov %edx,0x10(%ebp) 1114c5: e9 78 fe ff ff jmp 111342 <_Heap_Allocate_aligned_with_boundary+0x2e> =============================================================================== 001118a8 <_Heap_Extend>: Heap_Control *heap, void *extend_area_begin_ptr, uintptr_t extend_area_size, uintptr_t *extended_size_ptr ) { 1118a8: 55 push %ebp 1118a9: 89 e5 mov %esp,%ebp 1118ab: 57 push %edi 1118ac: 56 push %esi 1118ad: 53 push %ebx 1118ae: 83 ec 4c sub $0x4c,%esp 1118b1: 8b 5d 08 mov 0x8(%ebp),%ebx 1118b4: 8b 4d 10 mov 0x10(%ebp),%ecx Heap_Statistics *const stats = &heap->stats; Heap_Block *const first_block = heap->first_block; 1118b7: 8b 43 20 mov 0x20(%ebx),%eax 1118ba: 89 45 d0 mov %eax,-0x30(%ebp) Heap_Block *start_block = first_block; Heap_Block *merge_below_block = NULL; Heap_Block *merge_above_block = NULL; Heap_Block *link_below_block = NULL; Heap_Block *link_above_block = NULL; Heap_Block *extend_first_block = NULL; 1118bd: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) Heap_Block *extend_last_block = NULL; 1118c4: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) uintptr_t const page_size = heap->page_size; 1118cb: 8b 53 10 mov 0x10(%ebx),%edx 1118ce: 89 55 d4 mov %edx,-0x2c(%ebp) uintptr_t const min_block_size = heap->min_block_size; 1118d1: 8b 43 14 mov 0x14(%ebx),%eax uintptr_t const extend_area_begin = (uintptr_t) extend_area_begin_ptr; uintptr_t const extend_area_end = extend_area_begin + extend_area_size; uintptr_t const free_size = stats->free_size; 1118d4: 8b 73 30 mov 0x30(%ebx),%esi 1118d7: 89 75 c0 mov %esi,-0x40(%ebp) uintptr_t extend_first_block_size = 0; uintptr_t extended_size = 0; bool extend_area_ok = false; if ( extend_area_end < extend_area_begin ) { 1118da: 8b 55 0c mov 0xc(%ebp),%edx 1118dd: 01 ca add %ecx,%edx 1118df: 89 55 cc mov %edx,-0x34(%ebp) 1118e2: 73 0c jae 1118f0 <_Heap_Extend+0x48> _Heap_Block_of_alloc_area( sub_area_end, page_size ); if ( sub_area_end > extend_area_begin && extend_area_end > sub_area_begin ) { return false; 1118e4: 31 c0 xor %eax,%eax if ( extended_size_ptr != NULL ) *extended_size_ptr = extended_size; return true; } 1118e6: 8d 65 f4 lea -0xc(%ebp),%esp 1118e9: 5b pop %ebx 1118ea: 5e pop %esi 1118eb: 5f pop %edi 1118ec: c9 leave 1118ed: c3 ret 1118ee: 66 90 xchg %ax,%ax if ( extend_area_end < extend_area_begin ) { return false; } extend_area_ok = _Heap_Get_first_and_last_block( 1118f0: 83 ec 08 sub $0x8,%esp 1118f3: 8d 55 e0 lea -0x20(%ebp),%edx 1118f6: 52 push %edx 1118f7: 8d 55 e4 lea -0x1c(%ebp),%edx 1118fa: 52 push %edx 1118fb: 50 push %eax 1118fc: ff 75 d4 pushl -0x2c(%ebp) 1118ff: 51 push %ecx 111900: ff 75 0c pushl 0xc(%ebp) 111903: e8 14 b1 ff ff call 10ca1c <_Heap_Get_first_and_last_block> page_size, min_block_size, &extend_first_block, &extend_last_block ); if (!extend_area_ok ) { 111908: 83 c4 20 add $0x20,%esp 11190b: 84 c0 test %al,%al 11190d: 74 d5 je 1118e4 <_Heap_Extend+0x3c> 11190f: 8b 7d d0 mov -0x30(%ebp),%edi 111912: c7 45 bc 00 00 00 00 movl $0x0,-0x44(%ebp) 111919: c7 45 b8 00 00 00 00 movl $0x0,-0x48(%ebp) 111920: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp) 111927: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp) 11192e: 8b 75 cc mov -0x34(%ebp),%esi 111931: 89 5d b4 mov %ebx,-0x4c(%ebp) 111934: eb 30 jmp 111966 <_Heap_Extend+0xbe> 111936: 66 90 xchg %ax,%ax return false; } if ( extend_area_end == sub_area_begin ) { merge_below_block = start_block; } else if ( extend_area_end < sub_area_end ) { 111938: 39 ce cmp %ecx,%esi 11193a: 73 03 jae 11193f <_Heap_Extend+0x97> 11193c: 89 7d b8 mov %edi,-0x48(%ebp) RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 11193f: 8d 59 f8 lea -0x8(%ecx),%ebx 111942: 89 c8 mov %ecx,%eax 111944: 31 d2 xor %edx,%edx 111946: f7 75 d4 divl -0x2c(%ebp) uintptr_t alloc_begin, uintptr_t page_size ) { return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size ) - HEAP_BLOCK_HEADER_SIZE); 111949: 29 d3 sub %edx,%ebx link_below_block = start_block; } if ( sub_area_end == extend_area_begin ) { 11194b: 3b 4d 0c cmp 0xc(%ebp),%ecx 11194e: 74 3c je 11198c <_Heap_Extend+0xe4> <== NEVER TAKEN start_block->prev_size = extend_area_end; merge_above_block = end_block; } else if ( sub_area_end < extend_area_begin ) { 111950: 39 4d 0c cmp %ecx,0xc(%ebp) 111953: 76 03 jbe 111958 <_Heap_Extend+0xb0> RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_of_alloc_area( uintptr_t alloc_begin, uintptr_t page_size ) { return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size ) 111955: 89 5d bc mov %ebx,-0x44(%ebp) - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 111958: 8b 7b 04 mov 0x4(%ebx),%edi 11195b: 83 e7 fe and $0xfffffffe,%edi RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 11195e: 8d 3c 3b lea (%ebx,%edi,1),%edi link_above_block = end_block; } start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) ); } while ( start_block != first_block ); 111961: 39 7d d0 cmp %edi,-0x30(%ebp) 111964: 74 39 je 11199f <_Heap_Extend+0xf7> return false; } do { uintptr_t const sub_area_begin = (start_block != first_block) ? (uintptr_t) start_block : heap->area_begin; 111966: 3b 7d d0 cmp -0x30(%ebp),%edi 111969: 0f 84 39 01 00 00 je 111aa8 <_Heap_Extend+0x200> 11196f: 89 f8 mov %edi,%eax uintptr_t const sub_area_end = start_block->prev_size; 111971: 8b 0f mov (%edi),%ecx Heap_Block *const end_block = _Heap_Block_of_alloc_area( sub_area_end, page_size ); if ( 111973: 39 4d 0c cmp %ecx,0xc(%ebp) 111976: 73 08 jae 111980 <_Heap_Extend+0xd8> sub_area_end > extend_area_begin && extend_area_end > sub_area_begin 111978: 39 f0 cmp %esi,%eax 11197a: 0f 82 64 ff ff ff jb 1118e4 <_Heap_Extend+0x3c> ) { return false; } if ( extend_area_end == sub_area_begin ) { 111980: 39 f0 cmp %esi,%eax 111982: 75 b4 jne 111938 <_Heap_Extend+0x90> 111984: 89 7d c4 mov %edi,-0x3c(%ebp) 111987: eb b6 jmp 11193f <_Heap_Extend+0x97> 111989: 8d 76 00 lea 0x0(%esi),%esi } else if ( extend_area_end < sub_area_end ) { link_below_block = start_block; } if ( sub_area_end == extend_area_begin ) { start_block->prev_size = extend_area_end; 11198c: 89 37 mov %esi,(%edi) RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_of_alloc_area( uintptr_t alloc_begin, uintptr_t page_size ) { return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size ) 11198e: 89 5d c8 mov %ebx,-0x38(%ebp) - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 111991: 8b 7b 04 mov 0x4(%ebx),%edi 111994: 83 e7 fe and $0xfffffffe,%edi RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 111997: 8d 3c 3b lea (%ebx,%edi,1),%edi } else if ( sub_area_end < extend_area_begin ) { link_above_block = end_block; } start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) ); } while ( start_block != first_block ); 11199a: 39 7d d0 cmp %edi,-0x30(%ebp) 11199d: 75 c7 jne 111966 <_Heap_Extend+0xbe> <== NEVER TAKEN 11199f: 8b 5d b4 mov -0x4c(%ebp),%ebx if ( extend_area_begin < heap->area_begin ) { 1119a2: 8b 75 0c mov 0xc(%ebp),%esi 1119a5: 3b 73 18 cmp 0x18(%ebx),%esi 1119a8: 0f 82 06 01 00 00 jb 111ab4 <_Heap_Extend+0x20c> heap->area_begin = extend_area_begin; } else if ( heap->area_end < extend_area_end ) { 1119ae: 8b 45 cc mov -0x34(%ebp),%eax 1119b1: 3b 43 1c cmp 0x1c(%ebx),%eax 1119b4: 76 03 jbe 1119b9 <_Heap_Extend+0x111> heap->area_end = extend_area_end; 1119b6: 89 43 1c mov %eax,0x1c(%ebx) } extend_first_block_size = (uintptr_t) extend_last_block - (uintptr_t) extend_first_block; 1119b9: 8b 55 e0 mov -0x20(%ebp),%edx 1119bc: 8b 45 e4 mov -0x1c(%ebp),%eax heap->area_begin = extend_area_begin; } else if ( heap->area_end < extend_area_end ) { heap->area_end = extend_area_end; } extend_first_block_size = 1119bf: 89 d1 mov %edx,%ecx 1119c1: 29 c1 sub %eax,%ecx (uintptr_t) extend_last_block - (uintptr_t) extend_first_block; extend_first_block->prev_size = extend_area_end; 1119c3: 8b 75 cc mov -0x34(%ebp),%esi 1119c6: 89 30 mov %esi,(%eax) extend_first_block->size_and_flag = extend_first_block_size | HEAP_PREV_BLOCK_USED; 1119c8: 89 ce mov %ecx,%esi 1119ca: 83 ce 01 or $0x1,%esi 1119cd: 89 70 04 mov %esi,0x4(%eax) _Heap_Protection_block_initialize( heap, extend_first_block ); extend_last_block->prev_size = extend_first_block_size; 1119d0: 89 0a mov %ecx,(%edx) extend_last_block->size_and_flag = 0; 1119d2: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) _Heap_Protection_block_initialize( heap, extend_last_block ); if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) { 1119d9: 39 43 20 cmp %eax,0x20(%ebx) 1119dc: 0f 86 da 00 00 00 jbe 111abc <_Heap_Extend+0x214> heap->first_block = extend_first_block; 1119e2: 89 43 20 mov %eax,0x20(%ebx) } else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) { heap->last_block = extend_last_block; } if ( merge_below_block != NULL ) { 1119e5: 8b 75 c4 mov -0x3c(%ebp),%esi 1119e8: 85 f6 test %esi,%esi 1119ea: 0f 84 10 01 00 00 je 111b00 <_Heap_Extend+0x258> Heap_Control *heap, uintptr_t extend_area_begin, Heap_Block *first_block ) { uintptr_t const page_size = heap->page_size; 1119f0: 8b 73 10 mov 0x10(%ebx),%esi uintptr_t const new_first_block_alloc_begin = _Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size ); 1119f3: 8b 4d 0c mov 0xc(%ebp),%ecx 1119f6: 83 c1 08 add $0x8,%ecx RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up( uintptr_t value, uintptr_t alignment ) { uintptr_t remainder = value % alignment; 1119f9: 89 c8 mov %ecx,%eax 1119fb: 31 d2 xor %edx,%edx 1119fd: f7 f6 div %esi if ( remainder != 0 ) { 1119ff: 85 d2 test %edx,%edx 111a01: 0f 84 c9 00 00 00 je 111ad0 <_Heap_Extend+0x228> <== ALWAYS TAKEN return value - remainder + alignment; 111a07: 8d 04 31 lea (%ecx,%esi,1),%eax <== NOT EXECUTED 111a0a: 29 d0 sub %edx,%eax <== NOT EXECUTED uintptr_t const new_first_block_begin = 111a0c: 8d 50 f8 lea -0x8(%eax),%edx uintptr_t const first_block_begin = (uintptr_t) first_block; uintptr_t const new_first_block_size = first_block_begin - new_first_block_begin; Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin; new_first_block->prev_size = first_block->prev_size; 111a0f: 8b 75 c4 mov -0x3c(%ebp),%esi 111a12: 8b 0e mov (%esi),%ecx 111a14: 89 48 f8 mov %ecx,-0x8(%eax) uintptr_t const new_first_block_alloc_begin = _Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size ); uintptr_t const new_first_block_begin = new_first_block_alloc_begin - HEAP_BLOCK_HEADER_SIZE; uintptr_t const first_block_begin = (uintptr_t) first_block; uintptr_t const new_first_block_size = 111a17: 89 f0 mov %esi,%eax 111a19: 29 d0 sub %edx,%eax first_block_begin - new_first_block_begin; Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin; new_first_block->prev_size = first_block->prev_size; new_first_block->size_and_flag = new_first_block_size | HEAP_PREV_BLOCK_USED; 111a1b: 83 c8 01 or $0x1,%eax 111a1e: 89 42 04 mov %eax,0x4(%edx) _Heap_Free_block( heap, new_first_block ); 111a21: 89 d8 mov %ebx,%eax 111a23: e8 64 fe ff ff call 11188c <_Heap_Free_block> link_below_block, extend_last_block ); } if ( merge_above_block != NULL ) { 111a28: 8b 45 c8 mov -0x38(%ebp),%eax 111a2b: 85 c0 test %eax,%eax 111a2d: 0f 84 a5 00 00 00 je 111ad8 <_Heap_Extend+0x230> ) { uintptr_t const page_size = heap->page_size; uintptr_t const last_block_begin = (uintptr_t) last_block; uintptr_t const last_block_new_size = _Heap_Align_down( extend_area_end - last_block_begin - HEAP_BLOCK_HEADER_SIZE, 111a33: 8b 4d cc mov -0x34(%ebp),%ecx 111a36: 83 e9 08 sub $0x8,%ecx uintptr_t extend_area_end ) { uintptr_t const page_size = heap->page_size; uintptr_t const last_block_begin = (uintptr_t) last_block; uintptr_t const last_block_new_size = _Heap_Align_down( 111a39: 2b 4d c8 sub -0x38(%ebp),%ecx RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 111a3c: 89 c8 mov %ecx,%eax 111a3e: 31 d2 xor %edx,%edx 111a40: f7 73 10 divl 0x10(%ebx) 111a43: 29 d1 sub %edx,%ecx ); Heap_Block *const new_last_block = _Heap_Block_at( last_block, last_block_new_size ); new_last_block->size_and_flag = (last_block->size_and_flag - last_block_new_size) 111a45: 8b 55 c8 mov -0x38(%ebp),%edx 111a48: 8b 42 04 mov 0x4(%edx),%eax 111a4b: 29 c8 sub %ecx,%eax | HEAP_PREV_BLOCK_USED; 111a4d: 83 c8 01 or $0x1,%eax 111a50: 89 44 11 04 mov %eax,0x4(%ecx,%edx,1) RTEMS_INLINE_ROUTINE void _Heap_Block_set_size( Heap_Block *block, uintptr_t size ) { uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED; 111a54: 8b 42 04 mov 0x4(%edx),%eax 111a57: 83 e0 01 and $0x1,%eax block->size_and_flag = size | flag; 111a5a: 09 c8 or %ecx,%eax 111a5c: 89 42 04 mov %eax,0x4(%edx) _Heap_Block_set_size( last_block, last_block_new_size ); _Heap_Free_block( heap, last_block ); 111a5f: 89 d8 mov %ebx,%eax 111a61: e8 26 fe ff ff call 11188c <_Heap_Free_block> extend_first_block, extend_last_block ); } if ( merge_below_block == NULL && merge_above_block == NULL ) { 111a66: 8b 75 c4 mov -0x3c(%ebp),%esi 111a69: 85 f6 test %esi,%esi 111a6b: 0f 84 ab 00 00 00 je 111b1c <_Heap_Extend+0x274> if ( extended_size_ptr != NULL ) *extended_size_ptr = extended_size; return true; } 111a71: 8b 53 24 mov 0x24(%ebx),%edx * This feature will be used to terminate the scattered heap area list. See * also _Heap_Extend(). */ RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap ) { _Heap_Block_set_size( 111a74: 8b 43 20 mov 0x20(%ebx),%eax 111a77: 29 d0 sub %edx,%eax RTEMS_INLINE_ROUTINE void _Heap_Block_set_size( Heap_Block *block, uintptr_t size ) { uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED; 111a79: 8b 4a 04 mov 0x4(%edx),%ecx 111a7c: 83 e1 01 and $0x1,%ecx block->size_and_flag = size | flag; 111a7f: 09 c8 or %ecx,%eax 111a81: 89 42 04 mov %eax,0x4(%edx) _Heap_Free_block( heap, extend_first_block ); } _Heap_Set_last_block_size( heap ); extended_size = stats->free_size - free_size; 111a84: 8b 43 30 mov 0x30(%ebx),%eax 111a87: 2b 45 c0 sub -0x40(%ebp),%eax /* Statistics */ stats->size += extended_size; 111a8a: 01 43 2c add %eax,0x2c(%ebx) if ( extended_size_ptr != NULL ) 111a8d: 8b 55 14 mov 0x14(%ebp),%edx 111a90: 85 d2 test %edx,%edx 111a92: 0f 84 a0 00 00 00 je 111b38 <_Heap_Extend+0x290> <== NEVER TAKEN *extended_size_ptr = extended_size; 111a98: 8b 55 14 mov 0x14(%ebp),%edx 111a9b: 89 02 mov %eax,(%edx) return true; 111a9d: b0 01 mov $0x1,%al } 111a9f: 8d 65 f4 lea -0xc(%ebp),%esp 111aa2: 5b pop %ebx 111aa3: 5e pop %esi 111aa4: 5f pop %edi 111aa5: c9 leave 111aa6: c3 ret 111aa7: 90 nop return false; } do { uintptr_t const sub_area_begin = (start_block != first_block) ? (uintptr_t) start_block : heap->area_begin; 111aa8: 8b 55 b4 mov -0x4c(%ebp),%edx 111aab: 8b 42 18 mov 0x18(%edx),%eax 111aae: e9 be fe ff ff jmp 111971 <_Heap_Extend+0xc9> 111ab3: 90 nop start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) ); } while ( start_block != first_block ); if ( extend_area_begin < heap->area_begin ) { heap->area_begin = extend_area_begin; 111ab4: 89 73 18 mov %esi,0x18(%ebx) 111ab7: e9 fd fe ff ff jmp 1119b9 <_Heap_Extend+0x111> extend_last_block->size_and_flag = 0; _Heap_Protection_block_initialize( heap, extend_last_block ); if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) { heap->first_block = extend_first_block; } else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) { 111abc: 39 53 24 cmp %edx,0x24(%ebx) 111abf: 0f 83 20 ff ff ff jae 1119e5 <_Heap_Extend+0x13d> heap->last_block = extend_last_block; 111ac5: 89 53 24 mov %edx,0x24(%ebx) 111ac8: e9 18 ff ff ff jmp 1119e5 <_Heap_Extend+0x13d> 111acd: 8d 76 00 lea 0x0(%esi),%esi uintptr_t remainder = value % alignment; if ( remainder != 0 ) { return value - remainder + alignment; } else { return value; 111ad0: 89 c8 mov %ecx,%eax 111ad2: e9 35 ff ff ff jmp 111a0c <_Heap_Extend+0x164> 111ad7: 90 nop ); } if ( merge_above_block != NULL ) { _Heap_Merge_above( heap, merge_above_block, extend_area_end ); } else if ( link_above_block != NULL ) { 111ad8: 8b 7d bc mov -0x44(%ebp),%edi 111adb: 85 ff test %edi,%edi 111add: 74 87 je 111a66 <_Heap_Extend+0x1be> _Heap_Link_above( 111adf: 8b 4d e0 mov -0x20(%ebp),%ecx ) { uintptr_t const link_begin = (uintptr_t) link; uintptr_t const first_block_begin = (uintptr_t) first_block; _Heap_Block_set_size( link, first_block_begin - link_begin ); 111ae2: 8b 45 e4 mov -0x1c(%ebp),%eax 111ae5: 2b 45 bc sub -0x44(%ebp),%eax RTEMS_INLINE_ROUTINE void _Heap_Block_set_size( Heap_Block *block, uintptr_t size ) { uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED; 111ae8: 8b 75 bc mov -0x44(%ebp),%esi 111aeb: 8b 56 04 mov 0x4(%esi),%edx 111aee: 83 e2 01 and $0x1,%edx block->size_and_flag = size | flag; 111af1: 09 d0 or %edx,%eax 111af3: 89 46 04 mov %eax,0x4(%esi) last_block->size_and_flag |= HEAP_PREV_BLOCK_USED; 111af6: 83 49 04 01 orl $0x1,0x4(%ecx) 111afa: e9 67 ff ff ff jmp 111a66 <_Heap_Extend+0x1be> 111aff: 90 nop heap->last_block = extend_last_block; } if ( merge_below_block != NULL ) { _Heap_Merge_below( heap, extend_area_begin, merge_below_block ); } else if ( link_below_block != NULL ) { 111b00: 8b 4d b8 mov -0x48(%ebp),%ecx 111b03: 85 c9 test %ecx,%ecx 111b05: 0f 84 1d ff ff ff je 111a28 <_Heap_Extend+0x180> { uintptr_t const last_block_begin = (uintptr_t) last_block; uintptr_t const link_begin = (uintptr_t) link; last_block->size_and_flag = (link_begin - last_block_begin) | HEAP_PREV_BLOCK_USED; 111b0b: 8b 45 b8 mov -0x48(%ebp),%eax 111b0e: 29 d0 sub %edx,%eax 111b10: 83 c8 01 or $0x1,%eax 111b13: 89 42 04 mov %eax,0x4(%edx) 111b16: e9 0d ff ff ff jmp 111a28 <_Heap_Extend+0x180> 111b1b: 90 nop extend_first_block, extend_last_block ); } if ( merge_below_block == NULL && merge_above_block == NULL ) { 111b1c: 8b 4d c8 mov -0x38(%ebp),%ecx 111b1f: 85 c9 test %ecx,%ecx 111b21: 0f 85 4a ff ff ff jne 111a71 <_Heap_Extend+0x1c9> _Heap_Free_block( heap, extend_first_block ); 111b27: 8b 55 e4 mov -0x1c(%ebp),%edx 111b2a: 89 d8 mov %ebx,%eax 111b2c: e8 5b fd ff ff call 11188c <_Heap_Free_block> 111b31: e9 3b ff ff ff jmp 111a71 <_Heap_Extend+0x1c9> 111b36: 66 90 xchg %ax,%ax stats->size += extended_size; if ( extended_size_ptr != NULL ) *extended_size_ptr = extended_size; return true; 111b38: b0 01 mov $0x1,%al <== NOT EXECUTED 111b3a: e9 a7 fd ff ff jmp 1118e6 <_Heap_Extend+0x3e> <== NOT EXECUTED =============================================================================== 001114cc <_Heap_Free>: return do_free; } #endif bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr ) { 1114cc: 55 push %ebp 1114cd: 89 e5 mov %esp,%ebp 1114cf: 57 push %edi 1114d0: 56 push %esi 1114d1: 53 push %ebx 1114d2: 83 ec 10 sub $0x10,%esp 1114d5: 8b 5d 08 mov 0x8(%ebp),%ebx 1114d8: 8b 45 0c mov 0xc(%ebp),%eax 1114db: 8d 48 f8 lea -0x8(%eax),%ecx 1114de: 31 d2 xor %edx,%edx 1114e0: f7 73 10 divl 0x10(%ebx) uintptr_t alloc_begin, uintptr_t page_size ) { return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size ) - HEAP_BLOCK_HEADER_SIZE); 1114e3: 29 d1 sub %edx,%ecx RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in_heap( const Heap_Control *heap, const Heap_Block *block ) { return (uintptr_t) block >= (uintptr_t) heap->first_block 1114e5: 8b 43 20 mov 0x20(%ebx),%eax && (uintptr_t) block <= (uintptr_t) heap->last_block; 1114e8: 39 c1 cmp %eax,%ecx 1114ea: 72 07 jb 1114f3 <_Heap_Free+0x27> 1114ec: 8b 73 24 mov 0x24(%ebx),%esi 1114ef: 39 f1 cmp %esi,%ecx 1114f1: 76 0d jbe 111500 <_Heap_Free+0x34> /* As we always coalesce free blocks, the block that preceedes prev_block must have been used. */ if ( !_Heap_Is_prev_used ( prev_block) ) { _HAssert( false ); return( false ); 1114f3: 31 c0 xor %eax,%eax --stats->used_blocks; ++stats->frees; stats->free_size += block_size; return( true ); } 1114f5: 83 c4 10 add $0x10,%esp 1114f8: 5b pop %ebx 1114f9: 5e pop %esi 1114fa: 5f pop %edi 1114fb: c9 leave 1114fc: c3 ret 1114fd: 8d 76 00 lea 0x0(%esi),%esi 111500: 8b 51 04 mov 0x4(%ecx),%edx 111503: 89 55 f0 mov %edx,-0x10(%ebp) - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 111506: 83 e2 fe and $0xfffffffe,%edx 111509: 89 55 ec mov %edx,-0x14(%ebp) RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 11150c: 8d 14 11 lea (%ecx,%edx,1),%edx const Heap_Control *heap, const Heap_Block *block ) { return (uintptr_t) block >= (uintptr_t) heap->first_block && (uintptr_t) block <= (uintptr_t) heap->last_block; 11150f: 39 d0 cmp %edx,%eax 111511: 77 e0 ja 1114f3 <_Heap_Free+0x27> <== NEVER TAKEN 111513: 39 d6 cmp %edx,%esi 111515: 72 dc jb 1114f3 <_Heap_Free+0x27> <== NEVER TAKEN 111517: 8b 7a 04 mov 0x4(%edx),%edi if ( !_Heap_Is_block_in_heap( heap, next_block ) ) { _HAssert( false ); return false; } if ( !_Heap_Is_prev_used( next_block ) ) { 11151a: f7 c7 01 00 00 00 test $0x1,%edi 111520: 74 d1 je 1114f3 <_Heap_Free+0x27> <== NEVER TAKEN - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 111522: 83 e7 fe and $0xfffffffe,%edi 111525: 89 7d e4 mov %edi,-0x1c(%ebp) return true; } next_block_size = _Heap_Block_size( next_block ); next_is_free = next_block != heap->last_block && !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size )); 111528: 39 d6 cmp %edx,%esi 11152a: 0f 84 c8 00 00 00 je 1115f8 <_Heap_Free+0x12c> return do_free; } #endif bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr ) 111530: f6 44 3a 04 01 testb $0x1,0x4(%edx,%edi,1) 111535: 0f 94 45 eb sete -0x15(%ebp) next_block_size = _Heap_Block_size( next_block ); next_is_free = next_block != heap->last_block && !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size )); if ( !_Heap_Is_prev_used( block ) ) { 111539: f6 45 f0 01 testb $0x1,-0x10(%ebp) 11153d: 75 45 jne 111584 <_Heap_Free+0xb8> uintptr_t const prev_size = block->prev_size; 11153f: 8b 39 mov (%ecx),%edi 111541: 89 7d f0 mov %edi,-0x10(%ebp) RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 111544: 29 f9 sub %edi,%ecx const Heap_Control *heap, const Heap_Block *block ) { return (uintptr_t) block >= (uintptr_t) heap->first_block && (uintptr_t) block <= (uintptr_t) heap->last_block; 111546: 39 c8 cmp %ecx,%eax 111548: 77 a9 ja 1114f3 <_Heap_Free+0x27> <== NEVER TAKEN 11154a: 39 ce cmp %ecx,%esi 11154c: 72 a5 jb 1114f3 <_Heap_Free+0x27> <== NEVER TAKEN return( false ); } /* As we always coalesce free blocks, the block that preceedes prev_block must have been used. */ if ( !_Heap_Is_prev_used ( prev_block) ) { 11154e: f6 41 04 01 testb $0x1,0x4(%ecx) 111552: 74 9f je 1114f3 <_Heap_Free+0x27> <== NEVER TAKEN _HAssert( false ); return( false ); } if ( next_is_free ) { /* coalesce both */ 111554: 80 7d eb 00 cmpb $0x0,-0x15(%ebp) 111558: 0f 84 a6 00 00 00 je 111604 <_Heap_Free+0x138> uintptr_t const size = block_size + prev_size + next_block_size; 11155e: 8b 7d e4 mov -0x1c(%ebp),%edi 111561: 03 7d ec add -0x14(%ebp),%edi 111564: 03 7d f0 add -0x10(%ebp),%edi --stats->used_blocks; ++stats->frees; stats->free_size += block_size; return( true ); } 111567: 8b 42 08 mov 0x8(%edx),%eax 11156a: 8b 52 0c mov 0xc(%edx),%edx RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block ) { Heap_Block *next = block->next; Heap_Block *prev = block->prev; prev->next = next; 11156d: 89 42 08 mov %eax,0x8(%edx) next->prev = prev; 111570: 89 50 0c mov %edx,0xc(%eax) } if ( next_is_free ) { /* coalesce both */ uintptr_t const size = block_size + prev_size + next_block_size; _Heap_Free_list_remove( next_block ); stats->free_blocks -= 1; 111573: ff 4b 38 decl 0x38(%ebx) prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED; 111576: 89 f8 mov %edi,%eax 111578: 83 c8 01 or $0x1,%eax 11157b: 89 41 04 mov %eax,0x4(%ecx) next_block = _Heap_Block_at( prev_block, size ); _HAssert(!_Heap_Is_prev_used( next_block)); next_block->prev_size = size; 11157e: 89 3c 39 mov %edi,(%ecx,%edi,1) 111581: eb 2a jmp 1115ad <_Heap_Free+0xe1> 111583: 90 nop uintptr_t const size = block_size + prev_size; prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED; next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; next_block->prev_size = size; } } else if ( next_is_free ) { /* coalesce next */ 111584: 80 7d eb 00 cmpb $0x0,-0x15(%ebp) 111588: 74 3a je 1115c4 <_Heap_Free+0xf8> uintptr_t const size = block_size + next_block_size; 11158a: 8b 7d e4 mov -0x1c(%ebp),%edi 11158d: 03 7d ec add -0x14(%ebp),%edi --stats->used_blocks; ++stats->frees; stats->free_size += block_size; return( true ); } 111590: 8b 42 08 mov 0x8(%edx),%eax 111593: 8b 52 0c mov 0xc(%edx),%edx ) { Heap_Block *next = old_block->next; Heap_Block *prev = old_block->prev; new_block->next = next; 111596: 89 41 08 mov %eax,0x8(%ecx) new_block->prev = prev; 111599: 89 51 0c mov %edx,0xc(%ecx) next->prev = new_block; 11159c: 89 48 0c mov %ecx,0xc(%eax) prev->next = new_block; 11159f: 89 4a 08 mov %ecx,0x8(%edx) next_block->prev_size = size; } } else if ( next_is_free ) { /* coalesce next */ uintptr_t const size = block_size + next_block_size; _Heap_Free_list_replace( next_block, block ); block->size_and_flag = size | HEAP_PREV_BLOCK_USED; 1115a2: 89 f8 mov %edi,%eax 1115a4: 83 c8 01 or $0x1,%eax 1115a7: 89 41 04 mov %eax,0x4(%ecx) next_block = _Heap_Block_at( block, size ); next_block->prev_size = size; 1115aa: 89 3c 39 mov %edi,(%ecx,%edi,1) stats->max_free_blocks = stats->free_blocks; } } /* Statistics */ --stats->used_blocks; 1115ad: ff 4b 40 decl 0x40(%ebx) ++stats->frees; 1115b0: ff 43 50 incl 0x50(%ebx) stats->free_size += block_size; 1115b3: 8b 55 ec mov -0x14(%ebp),%edx 1115b6: 01 53 30 add %edx,0x30(%ebx) return( true ); 1115b9: b0 01 mov $0x1,%al } 1115bb: 83 c4 10 add $0x10,%esp 1115be: 5b pop %ebx 1115bf: 5e pop %esi 1115c0: 5f pop %edi 1115c1: c9 leave 1115c2: c3 ret 1115c3: 90 nop RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after( Heap_Block *block_before, Heap_Block *new_block ) { Heap_Block *next = block_before->next; 1115c4: 8b 43 08 mov 0x8(%ebx),%eax new_block->next = next; 1115c7: 89 41 08 mov %eax,0x8(%ecx) new_block->prev = block_before; 1115ca: 89 59 0c mov %ebx,0xc(%ecx) block_before->next = new_block; 1115cd: 89 4b 08 mov %ecx,0x8(%ebx) next->prev = new_block; 1115d0: 89 48 0c mov %ecx,0xc(%eax) next_block->prev_size = size; } else { /* no coalesce */ /* Add 'block' to the head of the free blocks list as it tends to produce less fragmentation than adding to the tail. */ _Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block ); block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED; 1115d3: 8b 45 ec mov -0x14(%ebp),%eax 1115d6: 83 c8 01 or $0x1,%eax 1115d9: 89 41 04 mov %eax,0x4(%ecx) next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 1115dc: 83 62 04 fe andl $0xfffffffe,0x4(%edx) next_block->prev_size = block_size; 1115e0: 8b 45 ec mov -0x14(%ebp),%eax 1115e3: 89 02 mov %eax,(%edx) /* Statistics */ ++stats->free_blocks; 1115e5: 8b 43 38 mov 0x38(%ebx),%eax 1115e8: 40 inc %eax 1115e9: 89 43 38 mov %eax,0x38(%ebx) if ( stats->max_free_blocks < stats->free_blocks ) { 1115ec: 3b 43 3c cmp 0x3c(%ebx),%eax 1115ef: 76 bc jbe 1115ad <_Heap_Free+0xe1> stats->max_free_blocks = stats->free_blocks; 1115f1: 89 43 3c mov %eax,0x3c(%ebx) 1115f4: eb b7 jmp 1115ad <_Heap_Free+0xe1> 1115f6: 66 90 xchg %ax,%ax return true; } next_block_size = _Heap_Block_size( next_block ); next_is_free = next_block != heap->last_block && !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size )); 1115f8: c6 45 eb 00 movb $0x0,-0x15(%ebp) 1115fc: e9 38 ff ff ff jmp 111539 <_Heap_Free+0x6d> 111601: 8d 76 00 lea 0x0(%esi),%esi prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED; next_block = _Heap_Block_at( prev_block, size ); _HAssert(!_Heap_Is_prev_used( next_block)); next_block->prev_size = size; } else { /* coalesce prev */ uintptr_t const size = block_size + prev_size; 111604: 8b 45 ec mov -0x14(%ebp),%eax 111607: 03 45 f0 add -0x10(%ebp),%eax prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED; 11160a: 89 c6 mov %eax,%esi 11160c: 83 ce 01 or $0x1,%esi 11160f: 89 71 04 mov %esi,0x4(%ecx) next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 111612: 83 62 04 fe andl $0xfffffffe,0x4(%edx) next_block->prev_size = size; 111616: 89 02 mov %eax,(%edx) 111618: eb 93 jmp 1115ad <_Heap_Free+0xe1> =============================================================================== 0010c690 <_Heap_Get_first_and_last_block>: uintptr_t page_size, uintptr_t min_block_size, Heap_Block **first_block_ptr, Heap_Block **last_block_ptr ) { 10c690: 55 push %ebp 10c691: 89 e5 mov %esp,%ebp 10c693: 57 push %edi 10c694: 56 push %esi 10c695: 53 push %ebx 10c696: 8b 4d 08 mov 0x8(%ebp),%ecx 10c699: 8b 7d 0c mov 0xc(%ebp),%edi uintptr_t const heap_area_end = heap_area_begin + heap_area_size; 10c69c: 8d 34 0f lea (%edi,%ecx,1),%esi uintptr_t const alloc_area_begin = _Heap_Align_up( heap_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size ); 10c69f: 8d 59 08 lea 0x8(%ecx),%ebx RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up( uintptr_t value, uintptr_t alignment ) { uintptr_t remainder = value % alignment; 10c6a2: 89 d8 mov %ebx,%eax 10c6a4: 31 d2 xor %edx,%edx 10c6a6: f7 75 10 divl 0x10(%ebp) if ( remainder != 0 ) { 10c6a9: 85 d2 test %edx,%edx 10c6ab: 74 05 je 10c6b2 <_Heap_Get_first_and_last_block+0x22> return value - remainder + alignment; 10c6ad: 03 5d 10 add 0x10(%ebp),%ebx 10c6b0: 29 d3 sub %edx,%ebx _Heap_Align_down( heap_area_size - overhead, page_size ); Heap_Block *const first_block = (Heap_Block *) first_block_begin; Heap_Block *const last_block = _Heap_Block_at( first_block, first_block_size ); if ( 10c6b2: 39 f1 cmp %esi,%ecx 10c6b4: 77 2e ja 10c6e4 <_Heap_Get_first_and_last_block+0x54> uintptr_t const alloc_area_begin = _Heap_Align_up( heap_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size ); uintptr_t const first_block_begin = alloc_area_begin - HEAP_BLOCK_HEADER_SIZE; uintptr_t const overhead = HEAP_BLOCK_HEADER_SIZE + (first_block_begin - heap_area_begin); 10c6b6: 8d 73 f8 lea -0x8(%ebx),%esi uintptr_t const heap_area_end = heap_area_begin + heap_area_size; uintptr_t const alloc_area_begin = _Heap_Align_up( heap_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size ); uintptr_t const first_block_begin = alloc_area_begin - HEAP_BLOCK_HEADER_SIZE; uintptr_t const overhead = 10c6b9: 29 cb sub %ecx,%ebx Heap_Block *const last_block = _Heap_Block_at( first_block, first_block_size ); if ( heap_area_end < heap_area_begin || heap_area_size <= overhead 10c6bb: 39 df cmp %ebx,%edi 10c6bd: 76 25 jbe 10c6e4 <_Heap_Get_first_and_last_block+0x54> uintptr_t const first_block_begin = alloc_area_begin - HEAP_BLOCK_HEADER_SIZE; uintptr_t const overhead = HEAP_BLOCK_HEADER_SIZE + (first_block_begin - heap_area_begin); uintptr_t const first_block_size = _Heap_Align_down( heap_area_size - overhead, page_size ); 10c6bf: 29 df sub %ebx,%edi RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 10c6c1: 89 f8 mov %edi,%eax 10c6c3: 31 d2 xor %edx,%edx 10c6c5: f7 75 10 divl 0x10(%ebp) 10c6c8: 29 d7 sub %edx,%edi _Heap_Block_at( first_block, first_block_size ); if ( heap_area_end < heap_area_begin || heap_area_size <= overhead || first_block_size < min_block_size 10c6ca: 39 7d 14 cmp %edi,0x14(%ebp) 10c6cd: 77 15 ja 10c6e4 <_Heap_Get_first_and_last_block+0x54> ) { /* Invalid area or area too small */ return false; } *first_block_ptr = first_block; 10c6cf: 8b 45 18 mov 0x18(%ebp),%eax 10c6d2: 89 30 mov %esi,(%eax) RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 10c6d4: 01 f7 add %esi,%edi 10c6d6: 8b 45 1c mov 0x1c(%ebp),%eax 10c6d9: 89 38 mov %edi,(%eax) *last_block_ptr = last_block; return true; 10c6db: b0 01 mov $0x1,%al } 10c6dd: 5b pop %ebx 10c6de: 5e pop %esi 10c6df: 5f pop %edi 10c6e0: c9 leave 10c6e1: c3 ret 10c6e2: 66 90 xchg %ax,%ax heap_area_end < heap_area_begin || heap_area_size <= overhead || first_block_size < min_block_size ) { /* Invalid area or area too small */ return false; 10c6e4: 31 c0 xor %eax,%eax *first_block_ptr = first_block; *last_block_ptr = last_block; return true; } 10c6e6: 5b pop %ebx 10c6e7: 5e pop %esi 10c6e8: 5f pop %edi 10c6e9: c9 leave 10c6ea: c3 ret =============================================================================== 001151e0 <_Heap_Get_free_information>: void _Heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ) { 1151e0: 55 push %ebp 1151e1: 89 e5 mov %esp,%ebp 1151e3: 57 push %edi 1151e4: 56 push %esi 1151e5: 53 push %ebx 1151e6: 8b 7d 0c mov 0xc(%ebp),%edi Heap_Block *the_block; Heap_Block *const tail = _Heap_Free_list_tail(the_heap); info->number = 0; 1151e9: c7 07 00 00 00 00 movl $0x0,(%edi) info->largest = 0; 1151ef: c7 47 04 00 00 00 00 movl $0x0,0x4(%edi) info->total = 0; 1151f6: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi) info->number++; info->total += the_size; if ( info->largest < the_size ) info->largest = the_size; } } 1151fd: 8b 45 08 mov 0x8(%ebp),%eax 115200: 8b 50 08 mov 0x8(%eax),%edx info->number = 0; info->largest = 0; info->total = 0; for(the_block = _Heap_Free_list_first(the_heap); 115203: 39 d0 cmp %edx,%eax 115205: 74 31 je 115238 <_Heap_Get_free_information+0x58> 115207: b9 01 00 00 00 mov $0x1,%ecx 11520c: 31 f6 xor %esi,%esi 11520e: 31 db xor %ebx,%ebx 115210: eb 07 jmp 115219 <_Heap_Get_free_information+0x39> 115212: 66 90 xchg %ax,%ax 115214: 8b 77 04 mov 0x4(%edi),%esi 115217: 89 c1 mov %eax,%ecx - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 115219: 8b 42 04 mov 0x4(%edx),%eax 11521c: 83 e0 fe and $0xfffffffe,%eax /* As we always coalesce free blocks, prev block must have been used. */ _HAssert(_Heap_Is_prev_used(the_block)); info->number++; info->total += the_size; 11521f: 01 c3 add %eax,%ebx if ( info->largest < the_size ) 115221: 39 f0 cmp %esi,%eax 115223: 76 03 jbe 115228 <_Heap_Get_free_information+0x48> info->largest = the_size; 115225: 89 47 04 mov %eax,0x4(%edi) info->largest = 0; info->total = 0; for(the_block = _Heap_Free_list_first(the_heap); the_block != tail; the_block = the_block->next) 115228: 8b 52 08 mov 0x8(%edx),%edx 11522b: 8d 41 01 lea 0x1(%ecx),%eax info->number = 0; info->largest = 0; info->total = 0; for(the_block = _Heap_Free_list_first(the_heap); 11522e: 39 55 08 cmp %edx,0x8(%ebp) 115231: 75 e1 jne 115214 <_Heap_Get_free_information+0x34> 115233: 89 0f mov %ecx,(%edi) 115235: 89 5f 08 mov %ebx,0x8(%edi) info->number++; info->total += the_size; if ( info->largest < the_size ) info->largest = the_size; } } 115238: 5b pop %ebx 115239: 5e pop %esi 11523a: 5f pop %edi 11523b: c9 leave 11523c: c3 ret =============================================================================== 00112044 <_Heap_Get_information>: void _Heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ) { 112044: 55 push %ebp 112045: 89 e5 mov %esp,%ebp 112047: 57 push %edi 112048: 56 push %esi 112049: 53 push %ebx 11204a: 83 ec 04 sub $0x4,%esp 11204d: 8b 45 08 mov 0x8(%ebp),%eax 112050: 8b 5d 0c mov 0xc(%ebp),%ebx Heap_Block *the_block = the_heap->first_block; 112053: 8b 50 20 mov 0x20(%eax),%edx Heap_Block *const end = the_heap->last_block; 112056: 8b 40 24 mov 0x24(%eax),%eax 112059: 89 45 f0 mov %eax,-0x10(%ebp) memset(the_info, 0, sizeof(*the_info)); 11205c: b9 18 00 00 00 mov $0x18,%ecx 112061: 31 c0 xor %eax,%eax 112063: 89 df mov %ebx,%edi 112065: f3 aa rep stos %al,%es:(%edi) while ( the_block != end ) { 112067: 3b 55 f0 cmp -0x10(%ebp),%edx 11206a: 74 38 je 1120a4 <_Heap_Get_information+0x60><== NEVER TAKEN 11206c: 8b 7a 04 mov 0x4(%edx),%edi 11206f: eb 18 jmp 112089 <_Heap_Get_information+0x45> 112071: 8d 76 00 lea 0x0(%esi),%esi uintptr_t const the_size = _Heap_Block_size(the_block); Heap_Block *const next_block = _Heap_Block_at(the_block, the_size); Heap_Information *info; if ( _Heap_Is_prev_used(next_block) ) info = &the_info->Used; 112074: 8d 43 0c lea 0xc(%ebx),%eax else info = &the_info->Free; info->number++; 112077: ff 00 incl (%eax) info->total += the_size; 112079: 01 48 08 add %ecx,0x8(%eax) if ( info->largest < the_size ) 11207c: 39 48 04 cmp %ecx,0x4(%eax) 11207f: 73 03 jae 112084 <_Heap_Get_information+0x40> info->largest = the_size; 112081: 89 48 04 mov %ecx,0x4(%eax) Heap_Block *the_block = the_heap->first_block; Heap_Block *const end = the_heap->last_block; memset(the_info, 0, sizeof(*the_info)); while ( the_block != end ) { 112084: 39 75 f0 cmp %esi,-0x10(%ebp) 112087: 74 1b je 1120a4 <_Heap_Get_information+0x60> - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 112089: 89 f9 mov %edi,%ecx 11208b: 83 e1 fe and $0xfffffffe,%ecx RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 11208e: 8d 34 0a lea (%edx,%ecx,1),%esi 112091: 89 f2 mov %esi,%edx if ( info->largest < the_size ) info->largest = the_size; the_block = next_block; } } 112093: 8b 7e 04 mov 0x4(%esi),%edi while ( the_block != end ) { uintptr_t const the_size = _Heap_Block_size(the_block); Heap_Block *const next_block = _Heap_Block_at(the_block, the_size); Heap_Information *info; if ( _Heap_Is_prev_used(next_block) ) 112096: f7 c7 01 00 00 00 test $0x1,%edi 11209c: 75 d6 jne 112074 <_Heap_Get_information+0x30> info = &the_info->Used; else info = &the_info->Free; 11209e: 89 d8 mov %ebx,%eax 1120a0: eb d5 jmp 112077 <_Heap_Get_information+0x33> 1120a2: 66 90 xchg %ax,%ax if ( info->largest < the_size ) info->largest = the_size; the_block = next_block; } } 1120a4: 58 pop %eax 1120a5: 5b pop %ebx 1120a6: 5e pop %esi 1120a7: 5f pop %edi 1120a8: c9 leave 1120a9: c3 ret =============================================================================== 0011f528 <_Heap_Resize_block>: void *alloc_begin_ptr, uintptr_t new_alloc_size, uintptr_t *old_size, uintptr_t *new_size ) { 11f528: 55 push %ebp 11f529: 89 e5 mov %esp,%ebp 11f52b: 57 push %edi 11f52c: 56 push %esi 11f52d: 53 push %ebx 11f52e: 83 ec 2c sub $0x2c,%esp 11f531: 8b 5d 08 mov 0x8(%ebp),%ebx 11f534: 8b 75 0c mov 0xc(%ebp),%esi RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 11f537: 8d 4e f8 lea -0x8(%esi),%ecx 11f53a: 89 f0 mov %esi,%eax 11f53c: 31 d2 xor %edx,%edx 11f53e: f7 73 10 divl 0x10(%ebx) uintptr_t alloc_begin, uintptr_t page_size ) { return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size ) - HEAP_BLOCK_HEADER_SIZE); 11f541: 29 d1 sub %edx,%ecx uintptr_t const alloc_begin = (uintptr_t) alloc_begin_ptr; Heap_Block *const block = _Heap_Block_of_alloc_area( alloc_begin, page_size ); *old_size = 0; 11f543: 8b 45 14 mov 0x14(%ebp),%eax 11f546: c7 00 00 00 00 00 movl $0x0,(%eax) *new_size = 0; 11f54c: 8b 55 18 mov 0x18(%ebp),%edx 11f54f: c7 02 00 00 00 00 movl $0x0,(%edx) const Heap_Control *heap, const Heap_Block *block ) { return (uintptr_t) block >= (uintptr_t) heap->first_block && (uintptr_t) block <= (uintptr_t) heap->last_block; 11f555: 39 4b 20 cmp %ecx,0x20(%ebx) 11f558: 77 05 ja 11f55f <_Heap_Resize_block+0x37> 11f55a: 39 4b 24 cmp %ecx,0x24(%ebx) 11f55d: 73 0d jae 11f56c <_Heap_Resize_block+0x44> new_alloc_size, old_size, new_size ); } else { return HEAP_RESIZE_FATAL_ERROR; 11f55f: b8 02 00 00 00 mov $0x2,%eax } } 11f564: 8d 65 f4 lea -0xc(%ebp),%esp 11f567: 5b pop %ebx 11f568: 5e pop %esi 11f569: 5f pop %edi 11f56a: c9 leave 11f56b: c3 ret - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 11f56c: 8b 41 04 mov 0x4(%ecx),%eax 11f56f: 83 e0 fe and $0xfffffffe,%eax { Heap_Statistics *const stats = &heap->stats; uintptr_t const block_begin = (uintptr_t) block; uintptr_t block_size = _Heap_Block_size( block ); uintptr_t block_end = block_begin + block_size; 11f572: 8d 3c 01 lea (%ecx,%eax,1),%edi 11f575: 89 7d d4 mov %edi,-0x2c(%ebp) uintptr_t alloc_size = block_end - alloc_begin + HEAP_ALLOC_BONUS; 11f578: 89 fa mov %edi,%edx 11f57a: 29 f2 sub %esi,%edx 11f57c: 83 c2 04 add $0x4,%edx 11f57f: 89 55 e0 mov %edx,-0x20(%ebp) 11f582: 8b 57 04 mov 0x4(%edi),%edx 11f585: 83 e2 fe and $0xfffffffe,%edx 11f588: 89 55 d0 mov %edx,-0x30(%ebp) RTEMS_INLINE_ROUTINE bool _Heap_Is_free( const Heap_Block *block ) { return !_Heap_Is_used( block ); 11f58b: f6 44 17 04 01 testb $0x1,0x4(%edi,%edx,1) 11f590: 0f 94 45 df sete -0x21(%ebp) bool next_block_is_free = _Heap_Is_free( next_block );; _HAssert( _Heap_Is_block_in_heap( heap, next_block ) ); _HAssert( _Heap_Is_prev_used( next_block ) ); *old_size = alloc_size; 11f594: 8b 55 e0 mov -0x20(%ebp),%edx 11f597: 8b 7d 14 mov 0x14(%ebp),%edi 11f59a: 89 17 mov %edx,(%edi) if ( next_block_is_free ) { 11f59c: 80 7d df 00 cmpb $0x0,-0x21(%ebp) 11f5a0: 75 6e jne 11f610 <_Heap_Resize_block+0xe8> block_size += next_block_size; alloc_size += next_block_size; } if ( new_alloc_size > alloc_size ) { 11f5a2: 8b 55 e0 mov -0x20(%ebp),%edx 11f5a5: 39 55 10 cmp %edx,0x10(%ebp) 11f5a8: 77 79 ja 11f623 <_Heap_Resize_block+0xfb> return HEAP_RESIZE_UNSATISFIED; } if ( next_block_is_free ) { 11f5aa: 80 7d df 00 cmpb $0x0,-0x21(%ebp) 11f5ae: 74 31 je 11f5e1 <_Heap_Resize_block+0xb9> RTEMS_INLINE_ROUTINE void _Heap_Block_set_size( Heap_Block *block, uintptr_t size ) { uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED; 11f5b0: 8b 79 04 mov 0x4(%ecx),%edi 11f5b3: 83 e7 01 and $0x1,%edi block->size_and_flag = size | flag; 11f5b6: 09 c7 or %eax,%edi 11f5b8: 89 79 04 mov %edi,0x4(%ecx) new_size ); } else { return HEAP_RESIZE_FATAL_ERROR; } } 11f5bb: 8b 7d d4 mov -0x2c(%ebp),%edi 11f5be: 8b 7f 08 mov 0x8(%edi),%edi 11f5c1: 89 7d e4 mov %edi,-0x1c(%ebp) 11f5c4: 8b 55 d4 mov -0x2c(%ebp),%edx 11f5c7: 8b 7a 0c mov 0xc(%edx),%edi RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block ) { Heap_Block *next = block->next; Heap_Block *prev = block->prev; prev->next = next; 11f5ca: 8b 55 e4 mov -0x1c(%ebp),%edx 11f5cd: 89 57 08 mov %edx,0x8(%edi) next->prev = prev; 11f5d0: 89 7a 0c mov %edi,0xc(%edx) _Heap_Block_set_size( block, block_size ); _Heap_Free_list_remove( next_block ); next_block = _Heap_Block_at( block, block_size ); next_block->size_and_flag |= HEAP_PREV_BLOCK_USED; 11f5d3: 83 4c 01 04 01 orl $0x1,0x4(%ecx,%eax,1) /* Statistics */ --stats->free_blocks; 11f5d8: ff 4b 38 decl 0x38(%ebx) stats->free_size -= next_block_size; 11f5db: 8b 7d d0 mov -0x30(%ebp),%edi 11f5de: 29 7b 30 sub %edi,0x30(%ebx) } block = _Heap_Block_allocate( heap, block, alloc_begin, new_alloc_size ); 11f5e1: ff 75 10 pushl 0x10(%ebp) 11f5e4: 56 push %esi 11f5e5: 51 push %ecx 11f5e6: 53 push %ebx 11f5e7: e8 14 d2 fe ff call 10c800 <_Heap_Block_allocate> - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 11f5ec: 8b 50 04 mov 0x4(%eax),%edx 11f5ef: 83 e2 fe and $0xfffffffe,%edx block_size = _Heap_Block_size( block ); next_block = _Heap_Block_at( block, block_size ); *new_size = (uintptr_t) next_block - alloc_begin + HEAP_ALLOC_BONUS; 11f5f2: 29 f0 sub %esi,%eax 11f5f4: 8d 44 10 04 lea 0x4(%eax,%edx,1),%eax 11f5f8: 8b 55 18 mov 0x18(%ebp),%edx 11f5fb: 89 02 mov %eax,(%edx) /* Statistics */ ++stats->resizes; 11f5fd: ff 43 54 incl 0x54(%ebx) 11f600: 83 c4 10 add $0x10,%esp return HEAP_RESIZE_SUCCESSFUL; 11f603: 31 c0 xor %eax,%eax new_size ); } else { return HEAP_RESIZE_FATAL_ERROR; } } 11f605: 8d 65 f4 lea -0xc(%ebp),%esp 11f608: 5b pop %ebx 11f609: 5e pop %esi 11f60a: 5f pop %edi 11f60b: c9 leave 11f60c: c3 ret 11f60d: 8d 76 00 lea 0x0(%esi),%esi _HAssert( _Heap_Is_prev_used( next_block ) ); *old_size = alloc_size; if ( next_block_is_free ) { block_size += next_block_size; 11f610: 03 45 d0 add -0x30(%ebp),%eax alloc_size += next_block_size; 11f613: 8b 7d d0 mov -0x30(%ebp),%edi 11f616: 01 fa add %edi,%edx 11f618: 89 55 e0 mov %edx,-0x20(%ebp) } if ( new_alloc_size > alloc_size ) { 11f61b: 8b 55 e0 mov -0x20(%ebp),%edx 11f61e: 39 55 10 cmp %edx,0x10(%ebp) 11f621: 76 87 jbe 11f5aa <_Heap_Resize_block+0x82> return HEAP_RESIZE_UNSATISFIED; 11f623: b8 01 00 00 00 mov $0x1,%eax new_size ); } else { return HEAP_RESIZE_FATAL_ERROR; } } 11f628: 8d 65 f4 lea -0xc(%ebp),%esp 11f62b: 5b pop %ebx 11f62c: 5e pop %esi 11f62d: 5f pop %edi 11f62e: c9 leave 11f62f: c3 ret =============================================================================== 0011f630 <_Heap_Size_of_alloc_area>: bool _Heap_Size_of_alloc_area( Heap_Control *heap, void *alloc_begin_ptr, uintptr_t *alloc_size ) { 11f630: 55 push %ebp 11f631: 89 e5 mov %esp,%ebp 11f633: 56 push %esi 11f634: 53 push %ebx 11f635: 8b 5d 08 mov 0x8(%ebp),%ebx 11f638: 8b 75 0c mov 0xc(%ebp),%esi RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 11f63b: 8d 4e f8 lea -0x8(%esi),%ecx 11f63e: 89 f0 mov %esi,%eax 11f640: 31 d2 xor %edx,%edx 11f642: f7 73 10 divl 0x10(%ebx) uintptr_t alloc_begin, uintptr_t page_size ) { return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size ) - HEAP_BLOCK_HEADER_SIZE); 11f645: 29 d1 sub %edx,%ecx RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in_heap( const Heap_Control *heap, const Heap_Block *block ) { return (uintptr_t) block >= (uintptr_t) heap->first_block 11f647: 8b 43 20 mov 0x20(%ebx),%eax && (uintptr_t) block <= (uintptr_t) heap->last_block; 11f64a: 39 c1 cmp %eax,%ecx 11f64c: 72 07 jb 11f655 <_Heap_Size_of_alloc_area+0x25> 11f64e: 8b 53 24 mov 0x24(%ebx),%edx 11f651: 39 d1 cmp %edx,%ecx 11f653: 76 07 jbe 11f65c <_Heap_Size_of_alloc_area+0x2c><== ALWAYS TAKEN if ( !_Heap_Is_block_in_heap( heap, next_block ) || !_Heap_Is_prev_used( next_block ) ) { return false; 11f655: 31 c0 xor %eax,%eax } *alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin; return true; } 11f657: 5b pop %ebx 11f658: 5e pop %esi 11f659: c9 leave 11f65a: c3 ret 11f65b: 90 nop - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 11f65c: 8b 59 04 mov 0x4(%ecx),%ebx 11f65f: 83 e3 fe and $0xfffffffe,%ebx RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 11f662: 01 d9 add %ebx,%ecx const Heap_Control *heap, const Heap_Block *block ) { return (uintptr_t) block >= (uintptr_t) heap->first_block && (uintptr_t) block <= (uintptr_t) heap->last_block; 11f664: 39 c8 cmp %ecx,%eax 11f666: 77 ed ja 11f655 <_Heap_Size_of_alloc_area+0x25><== NEVER TAKEN 11f668: 39 ca cmp %ecx,%edx 11f66a: 72 e9 jb 11f655 <_Heap_Size_of_alloc_area+0x25><== NEVER TAKEN block_size = _Heap_Block_size( block ); next_block = _Heap_Block_at( block, block_size ); if ( !_Heap_Is_block_in_heap( heap, next_block ) || !_Heap_Is_prev_used( next_block ) 11f66c: f6 41 04 01 testb $0x1,0x4(%ecx) 11f670: 74 e3 je 11f655 <_Heap_Size_of_alloc_area+0x25><== NEVER TAKEN ) { return false; } *alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin; 11f672: 29 f1 sub %esi,%ecx 11f674: 8d 51 04 lea 0x4(%ecx),%edx 11f677: 8b 45 10 mov 0x10(%ebp),%eax 11f67a: 89 10 mov %edx,(%eax) return true; 11f67c: b0 01 mov $0x1,%al } 11f67e: 5b pop %ebx 11f67f: 5e pop %esi 11f680: c9 leave 11f681: c3 ret =============================================================================== 0010d334 <_Heap_Walk>: bool _Heap_Walk( Heap_Control *heap, int source, bool dump ) { 10d334: 55 push %ebp 10d335: 89 e5 mov %esp,%ebp 10d337: 57 push %edi 10d338: 56 push %esi 10d339: 53 push %ebx 10d33a: 83 ec 4c sub $0x4c,%esp 10d33d: 8b 5d 08 mov 0x8(%ebp),%ebx uintptr_t const page_size = heap->page_size; 10d340: 8b 43 10 mov 0x10(%ebx),%eax 10d343: 89 45 e0 mov %eax,-0x20(%ebp) uintptr_t const min_block_size = heap->min_block_size; 10d346: 8b 53 14 mov 0x14(%ebx),%edx 10d349: 89 55 d0 mov %edx,-0x30(%ebp) Heap_Block *const first_block = heap->first_block; 10d34c: 8b 43 20 mov 0x20(%ebx),%eax 10d34f: 89 45 dc mov %eax,-0x24(%ebp) Heap_Block *const last_block = heap->last_block; 10d352: 8b 53 24 mov 0x24(%ebx),%edx 10d355: 89 55 cc mov %edx,-0x34(%ebp) Heap_Block *block = first_block; Heap_Walk_printer printer = dump ? _Heap_Walk_print : _Heap_Walk_print_nothing; 10d358: 80 7d 10 00 cmpb $0x0,0x10(%ebp) 10d35c: 74 1a je 10d378 <_Heap_Walk+0x44> 10d35e: c7 45 d8 ec d2 10 00 movl $0x10d2ec,-0x28(%ebp) if ( !_System_state_Is_up( _System_state_Get() ) ) { 10d365: 83 3d 20 a4 12 00 03 cmpl $0x3,0x12a420 10d36c: 74 1a je 10d388 <_Heap_Walk+0x54> <== ALWAYS TAKEN } block = next_block; } while ( block != first_block ); return true; 10d36e: b0 01 mov $0x1,%al } 10d370: 8d 65 f4 lea -0xc(%ebp),%esp 10d373: 5b pop %ebx 10d374: 5e pop %esi 10d375: 5f pop %edi 10d376: c9 leave 10d377: c3 ret uintptr_t const min_block_size = heap->min_block_size; Heap_Block *const first_block = heap->first_block; Heap_Block *const last_block = heap->last_block; Heap_Block *block = first_block; Heap_Walk_printer printer = dump ? _Heap_Walk_print : _Heap_Walk_print_nothing; 10d378: c7 45 d8 e4 d2 10 00 movl $0x10d2e4,-0x28(%ebp) if ( !_System_state_Is_up( _System_state_Get() ) ) { 10d37f: 83 3d 20 a4 12 00 03 cmpl $0x3,0x12a420 10d386: 75 e6 jne 10d36e <_Heap_Walk+0x3a> Heap_Block *const first_free_block = _Heap_Free_list_first( heap ); Heap_Block *const last_free_block = _Heap_Free_list_last( heap ); Heap_Block *const first_block = heap->first_block; Heap_Block *const last_block = heap->last_block; (*printer)( 10d388: 52 push %edx 10d389: ff 73 0c pushl 0xc(%ebx) 10d38c: ff 73 08 pushl 0x8(%ebx) 10d38f: ff 75 cc pushl -0x34(%ebp) 10d392: ff 75 dc pushl -0x24(%ebp) 10d395: ff 73 1c pushl 0x1c(%ebx) 10d398: ff 73 18 pushl 0x18(%ebx) 10d39b: ff 75 d0 pushl -0x30(%ebp) 10d39e: ff 75 e0 pushl -0x20(%ebp) 10d3a1: 68 a4 25 12 00 push $0x1225a4 10d3a6: 6a 00 push $0x0 10d3a8: ff 75 0c pushl 0xc(%ebp) 10d3ab: ff 55 d8 call *-0x28(%ebp) heap->area_begin, heap->area_end, first_block, last_block, first_free_block, last_free_block ); if ( page_size == 0 ) { 10d3ae: 83 c4 30 add $0x30,%esp 10d3b1: 8b 45 e0 mov -0x20(%ebp),%eax 10d3b4: 85 c0 test %eax,%eax 10d3b6: 74 70 je 10d428 <_Heap_Walk+0xf4> (*printer)( source, true, "page size is zero\n" ); return false; } if ( !_Addresses_Is_aligned( (void *) page_size ) ) { 10d3b8: f6 45 e0 03 testb $0x3,-0x20(%ebp) 10d3bc: 75 72 jne 10d430 <_Heap_Walk+0xfc> RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10d3be: 8b 45 d0 mov -0x30(%ebp),%eax 10d3c1: 31 d2 xor %edx,%edx 10d3c3: f7 75 e0 divl -0x20(%ebp) ); return false; } if ( !_Heap_Is_aligned( min_block_size, page_size ) ) { 10d3c6: 85 d2 test %edx,%edx 10d3c8: 75 72 jne 10d43c <_Heap_Walk+0x108> RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block( const Heap_Block *block ) { return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE; 10d3ca: 8b 45 dc mov -0x24(%ebp),%eax 10d3cd: 83 c0 08 add $0x8,%eax RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10d3d0: 31 d2 xor %edx,%edx 10d3d2: f7 75 e0 divl -0x20(%ebp) ); return false; } if ( 10d3d5: 85 d2 test %edx,%edx 10d3d7: 75 6f jne 10d448 <_Heap_Walk+0x114> block = next_block; } while ( block != first_block ); return true; } 10d3d9: 8b 45 dc mov -0x24(%ebp),%eax 10d3dc: 8b 40 04 mov 0x4(%eax),%eax 10d3df: 89 45 e4 mov %eax,-0x1c(%ebp) ); return false; } if ( !_Heap_Is_prev_used( first_block ) ) { 10d3e2: a8 01 test $0x1,%al 10d3e4: 0f 84 ce 02 00 00 je 10d6b8 <_Heap_Walk+0x384> - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 10d3ea: 8b 55 cc mov -0x34(%ebp),%edx 10d3ed: 8b 42 04 mov 0x4(%edx),%eax 10d3f0: 83 e0 fe and $0xfffffffe,%eax RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 10d3f3: 01 d0 add %edx,%eax ); return false; } if ( _Heap_Is_free( last_block ) ) { 10d3f5: f6 40 04 01 testb $0x1,0x4(%eax) 10d3f9: 74 25 je 10d420 <_Heap_Walk+0xec> ); return false; } if ( 10d3fb: 39 45 dc cmp %eax,-0x24(%ebp) 10d3fe: 74 54 je 10d454 <_Heap_Walk+0x120> <== ALWAYS TAKEN _Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block ) { (*printer)( 10d400: 51 push %ecx <== NOT EXECUTED 10d401: 68 c0 26 12 00 push $0x1226c0 <== NOT EXECUTED 10d406: 66 90 xchg %ax,%ax <== NOT EXECUTED return false; } if ( !_Heap_Walk_is_in_free_list( heap, block ) ) { (*printer)( 10d408: 6a 01 push $0x1 10d40a: ff 75 0c pushl 0xc(%ebp) 10d40d: ff 55 d8 call *-0x28(%ebp) 10d410: 83 c4 10 add $0x10,%esp return false; } if ( !_Heap_Is_prev_used( next_block ) ) { if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) { return false; 10d413: 31 c0 xor %eax,%eax block = next_block; } while ( block != first_block ); return true; } 10d415: 8d 65 f4 lea -0xc(%ebp),%esp 10d418: 5b pop %ebx 10d419: 5e pop %esi 10d41a: 5f pop %edi 10d41b: c9 leave 10d41c: c3 ret 10d41d: 8d 76 00 lea 0x0(%esi),%esi return false; } if ( _Heap_Is_free( last_block ) ) { (*printer)( 10d420: 53 push %ebx 10d421: 68 5a 25 12 00 push $0x12255a 10d426: eb e0 jmp 10d408 <_Heap_Walk+0xd4> first_block, last_block, first_free_block, last_free_block ); if ( page_size == 0 ) { (*printer)( source, true, "page size is zero\n" ); 10d428: 57 push %edi 10d429: 68 29 25 12 00 push $0x122529 10d42e: eb d8 jmp 10d408 <_Heap_Walk+0xd4> return false; } if ( !_Addresses_Is_aligned( (void *) page_size ) ) { (*printer)( 10d430: ff 75 e0 pushl -0x20(%ebp) 10d433: 68 3c 25 12 00 push $0x12253c 10d438: eb ce jmp 10d408 <_Heap_Walk+0xd4> 10d43a: 66 90 xchg %ax,%ax return false; } if ( !_Heap_Is_aligned( min_block_size, page_size ) ) { (*printer)( 10d43c: ff 75 d0 pushl -0x30(%ebp) 10d43f: 68 38 26 12 00 push $0x122638 10d444: eb c2 jmp 10d408 <_Heap_Walk+0xd4> 10d446: 66 90 xchg %ax,%ax } if ( !_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size ) ) { (*printer)( 10d448: ff 75 dc pushl -0x24(%ebp) 10d44b: 68 5c 26 12 00 push $0x12265c 10d450: eb b6 jmp 10d408 <_Heap_Walk+0xd4> 10d452: 66 90 xchg %ax,%ax int source, Heap_Walk_printer printer, Heap_Control *heap ) { uintptr_t const page_size = heap->page_size; 10d454: 8b 43 10 mov 0x10(%ebx),%eax 10d457: 89 45 c8 mov %eax,-0x38(%ebp) block = next_block; } while ( block != first_block ); return true; } 10d45a: 8b 73 08 mov 0x8(%ebx),%esi const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); const Heap_Block *const first_free_block = _Heap_Free_list_first( heap ); const Heap_Block *prev_block = free_list_tail; const Heap_Block *free_block = first_free_block; while ( free_block != free_list_tail ) { 10d45d: 39 f3 cmp %esi,%ebx 10d45f: 74 65 je 10d4c6 <_Heap_Walk+0x192> block = next_block; } while ( block != first_block ); return true; } 10d461: 8b 43 20 mov 0x20(%ebx),%eax 10d464: 89 45 d4 mov %eax,-0x2c(%ebp) const Heap_Control *heap, const Heap_Block *block ) { return (uintptr_t) block >= (uintptr_t) heap->first_block && (uintptr_t) block <= (uintptr_t) heap->last_block; 10d467: 39 f0 cmp %esi,%eax 10d469: 0f 87 55 02 00 00 ja 10d6c4 <_Heap_Walk+0x390> <== NEVER TAKEN 10d46f: 8b 7b 24 mov 0x24(%ebx),%edi 10d472: 39 f7 cmp %esi,%edi 10d474: 0f 82 4a 02 00 00 jb 10d6c4 <_Heap_Walk+0x390> <== NEVER TAKEN RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block( const Heap_Block *block ) { return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE; 10d47a: 8d 46 08 lea 0x8(%esi),%eax RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10d47d: 31 d2 xor %edx,%edx 10d47f: f7 75 c8 divl -0x38(%ebp) ); return false; } if ( 10d482: 85 d2 test %edx,%edx 10d484: 0f 85 71 02 00 00 jne 10d6fb <_Heap_Walk+0x3c7> <== NEVER TAKEN - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 10d48a: 8b 46 04 mov 0x4(%esi),%eax 10d48d: 83 e0 fe and $0xfffffffe,%eax ); return false; } if ( _Heap_Is_used( free_block ) ) { 10d490: f6 44 06 04 01 testb $0x1,0x4(%esi,%eax,1) 10d495: 0f 85 6d 02 00 00 jne 10d708 <_Heap_Walk+0x3d4> <== NEVER TAKEN 10d49b: 89 da mov %ebx,%edx 10d49d: 8d 76 00 lea 0x0(%esi),%esi ); return false; } if ( free_block->prev != prev_block ) { 10d4a0: 8b 46 0c mov 0xc(%esi),%eax 10d4a3: 39 d0 cmp %edx,%eax 10d4a5: 0f 85 6a 02 00 00 jne 10d715 <_Heap_Walk+0x3e1> return false; } prev_block = free_block; free_block = free_block->next; 10d4ab: 8b 4e 08 mov 0x8(%esi),%ecx const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); const Heap_Block *const first_free_block = _Heap_Free_list_first( heap ); const Heap_Block *prev_block = free_list_tail; const Heap_Block *free_block = first_free_block; while ( free_block != free_list_tail ) { 10d4ae: 39 cb cmp %ecx,%ebx 10d4b0: 74 1a je 10d4cc <_Heap_Walk+0x198> const Heap_Control *heap, const Heap_Block *block ) { return (uintptr_t) block >= (uintptr_t) heap->first_block && (uintptr_t) block <= (uintptr_t) heap->last_block; 10d4b2: 39 4d d4 cmp %ecx,-0x2c(%ebp) 10d4b5: 0f 86 7d 01 00 00 jbe 10d638 <_Heap_Walk+0x304> if ( !_Heap_Is_block_in_heap( heap, free_block ) ) { (*printer)( 10d4bb: 51 push %ecx 10d4bc: 68 f0 26 12 00 push $0x1226f0 10d4c1: e9 42 ff ff ff jmp 10d408 <_Heap_Walk+0xd4> const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); const Heap_Block *const first_free_block = _Heap_Free_list_first( heap ); const Heap_Block *prev_block = free_list_tail; const Heap_Block *free_block = first_free_block; while ( free_block != free_list_tail ) { 10d4c6: 8b 53 20 mov 0x20(%ebx),%edx 10d4c9: 89 55 d4 mov %edx,-0x2c(%ebp) ); return false; } if ( _Heap_Is_used( free_block ) ) { 10d4cc: 8b 7d dc mov -0x24(%ebp),%edi 10d4cf: 8b 45 d4 mov -0x2c(%ebp),%eax 10d4d2: 66 90 xchg %ax,%ax - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 10d4d4: 8b 4d e4 mov -0x1c(%ebp),%ecx 10d4d7: 83 e1 fe and $0xfffffffe,%ecx RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 10d4da: 8d 34 39 lea (%ecx,%edi,1),%esi const Heap_Control *heap, const Heap_Block *block ) { return (uintptr_t) block >= (uintptr_t) heap->first_block && (uintptr_t) block <= (uintptr_t) heap->last_block; 10d4dd: 39 f0 cmp %esi,%eax 10d4df: 76 23 jbe 10d504 <_Heap_Walk+0x1d0> <== ALWAYS TAKEN Heap_Block *const next_block = _Heap_Block_at( block, block_size ); uintptr_t const next_block_begin = (uintptr_t) next_block; bool const is_not_last_block = block != last_block; if ( !_Heap_Is_block_in_heap( heap, next_block ) ) { (*printer)( 10d4e1: 83 ec 0c sub $0xc,%esp 10d4e4: 56 push %esi 10d4e5: 57 push %edi 10d4e6: 68 74 27 12 00 push $0x122774 10d4eb: 90 nop 10d4ec: 6a 01 push $0x1 10d4ee: ff 75 0c pushl 0xc(%ebp) 10d4f1: ff 55 d8 call *-0x28(%ebp) "block 0x%08x: next block 0x%08x not in heap\n", block, next_block ); return false; 10d4f4: 83 c4 20 add $0x20,%esp 10d4f7: 31 c0 xor %eax,%eax block = next_block; } while ( block != first_block ); return true; } 10d4f9: 8d 65 f4 lea -0xc(%ebp),%esp 10d4fc: 5b pop %ebx 10d4fd: 5e pop %esi 10d4fe: 5f pop %edi 10d4ff: c9 leave 10d500: c3 ret 10d501: 8d 76 00 lea 0x0(%esi),%esi 10d504: 39 73 24 cmp %esi,0x24(%ebx) 10d507: 72 d8 jb 10d4e1 <_Heap_Walk+0x1ad> uintptr_t const block_begin = (uintptr_t) block; uintptr_t const block_size = _Heap_Block_size( block ); bool const prev_used = _Heap_Is_prev_used( block ); Heap_Block *const next_block = _Heap_Block_at( block, block_size ); uintptr_t const next_block_begin = (uintptr_t) next_block; bool const is_not_last_block = block != last_block; 10d509: 3b 7d cc cmp -0x34(%ebp),%edi 10d50c: 0f 95 45 d4 setne -0x2c(%ebp) RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10d510: 89 c8 mov %ecx,%eax 10d512: 31 d2 xor %edx,%edx 10d514: f7 75 e0 divl -0x20(%ebp) ); return false; } if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) { 10d517: 85 d2 test %edx,%edx 10d519: 74 0a je 10d525 <_Heap_Walk+0x1f1> 10d51b: 80 7d d4 00 cmpb $0x0,-0x2c(%ebp) 10d51f: 0f 85 a6 01 00 00 jne 10d6cb <_Heap_Walk+0x397> ); return false; } if ( block_size < min_block_size && is_not_last_block ) { 10d525: 39 4d d0 cmp %ecx,-0x30(%ebp) 10d528: 76 0a jbe 10d534 <_Heap_Walk+0x200> 10d52a: 80 7d d4 00 cmpb $0x0,-0x2c(%ebp) 10d52e: 0f 85 a6 01 00 00 jne 10d6da <_Heap_Walk+0x3a6> <== ALWAYS TAKEN ); return false; } if ( next_block_begin <= block_begin && is_not_last_block ) { 10d534: 39 f7 cmp %esi,%edi 10d536: 72 0a jb 10d542 <_Heap_Walk+0x20e> 10d538: 80 7d d4 00 cmpb $0x0,-0x2c(%ebp) 10d53c: 0f 85 aa 01 00 00 jne 10d6ec <_Heap_Walk+0x3b8> block->size_and_flag = size | flag; } RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block ) { return block->size_and_flag & HEAP_PREV_BLOCK_USED; 10d542: 8b 55 e4 mov -0x1c(%ebp),%edx 10d545: 83 e2 01 and $0x1,%edx ); return false; } if ( !_Heap_Is_prev_used( next_block ) ) { 10d548: f6 46 04 01 testb $0x1,0x4(%esi) 10d54c: 74 4e je 10d59c <_Heap_Walk+0x268> if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) { return false; } } else if (prev_used) { 10d54e: 85 d2 test %edx,%edx 10d550: 74 2e je 10d580 <_Heap_Walk+0x24c> (*printer)( 10d552: 83 ec 0c sub $0xc,%esp 10d555: 51 push %ecx 10d556: 57 push %edi 10d557: 68 8b 25 12 00 push $0x12258b 10d55c: 6a 00 push $0x0 10d55e: ff 75 0c pushl 0xc(%ebp) 10d561: ff 55 d8 call *-0x28(%ebp) 10d564: 83 c4 20 add $0x20,%esp block->prev_size ); } block = next_block; } while ( block != first_block ); 10d567: 39 75 dc cmp %esi,-0x24(%ebp) 10d56a: 0f 84 fe fd ff ff je 10d36e <_Heap_Walk+0x3a> 10d570: 8b 56 04 mov 0x4(%esi),%edx 10d573: 89 55 e4 mov %edx,-0x1c(%ebp) 10d576: 8b 43 20 mov 0x20(%ebx),%eax 10d579: 89 f7 mov %esi,%edi 10d57b: e9 54 ff ff ff jmp 10d4d4 <_Heap_Walk+0x1a0> "block 0x%08x: size %u\n", block, block_size ); } else { (*printer)( 10d580: 83 ec 08 sub $0x8,%esp 10d583: ff 37 pushl (%edi) 10d585: 51 push %ecx 10d586: 57 push %edi 10d587: 68 d8 28 12 00 push $0x1228d8 10d58c: 6a 00 push $0x0 10d58e: ff 75 0c pushl 0xc(%ebp) 10d591: ff 55 d8 call *-0x28(%ebp) 10d594: 83 c4 20 add $0x20,%esp 10d597: eb ce jmp 10d567 <_Heap_Walk+0x233> 10d599: 8d 76 00 lea 0x0(%esi),%esi block = next_block; } while ( block != first_block ); return true; } 10d59c: 8b 43 08 mov 0x8(%ebx),%eax 10d59f: 89 45 b4 mov %eax,-0x4c(%ebp) block->prev, block->prev == first_free_block ? " (= first free)" : (block->prev == free_list_head ? " (= head)" : ""), block->next, block->next == last_free_block ? 10d5a2: 8b 47 08 mov 0x8(%edi),%eax 10d5a5: 89 45 e4 mov %eax,-0x1c(%ebp) Heap_Block *const last_free_block = _Heap_Free_list_last( heap ); bool const prev_used = _Heap_Is_prev_used( block ); uintptr_t const block_size = _Heap_Block_size( block ); Heap_Block *const next_block = _Heap_Block_at( block, block_size ); (*printer)( 10d5a8: 39 43 0c cmp %eax,0xc(%ebx) 10d5ab: 0f 84 cb 00 00 00 je 10d67c <_Heap_Walk+0x348> " (= first free)" : (block->prev == free_list_head ? " (= head)" : ""), block->next, block->next == last_free_block ? " (= last free)" : (block->next == free_list_tail ? " (= tail)" : "") 10d5b1: 39 c3 cmp %eax,%ebx 10d5b3: 0f 84 db 00 00 00 je 10d694 <_Heap_Walk+0x360> 10d5b9: c7 45 c8 29 24 12 00 movl $0x122429,-0x38(%ebp) false, "block 0x%08x: size %u, prev 0x%08x%s, next 0x%08x%s\n", block, block_size, block->prev, block->prev == first_free_block ? 10d5c0: 8b 47 0c mov 0xc(%edi),%eax 10d5c3: 89 45 d4 mov %eax,-0x2c(%ebp) Heap_Block *const last_free_block = _Heap_Free_list_last( heap ); bool const prev_used = _Heap_Is_prev_used( block ); uintptr_t const block_size = _Heap_Block_size( block ); Heap_Block *const next_block = _Heap_Block_at( block, block_size ); (*printer)( 10d5c6: 39 45 b4 cmp %eax,-0x4c(%ebp) 10d5c9: 0f 84 b9 00 00 00 je 10d688 <_Heap_Walk+0x354> block, block_size, block->prev, block->prev == first_free_block ? " (= first free)" : (block->prev == free_list_head ? " (= head)" : ""), 10d5cf: 39 c3 cmp %eax,%ebx 10d5d1: 0f 84 c9 00 00 00 je 10d6a0 <_Heap_Walk+0x36c> 10d5d7: b8 29 24 12 00 mov $0x122429,%eax Heap_Block *const last_free_block = _Heap_Free_list_last( heap ); bool const prev_used = _Heap_Is_prev_used( block ); uintptr_t const block_size = _Heap_Block_size( block ); Heap_Block *const next_block = _Heap_Block_at( block, block_size ); (*printer)( 10d5dc: 83 ec 0c sub $0xc,%esp 10d5df: ff 75 c8 pushl -0x38(%ebp) 10d5e2: ff 75 e4 pushl -0x1c(%ebp) 10d5e5: 50 push %eax 10d5e6: ff 75 d4 pushl -0x2c(%ebp) 10d5e9: 51 push %ecx 10d5ea: 57 push %edi 10d5eb: 68 34 28 12 00 push $0x122834 10d5f0: 6a 00 push $0x0 10d5f2: ff 75 0c pushl 0xc(%ebp) 10d5f5: 89 55 c4 mov %edx,-0x3c(%ebp) 10d5f8: 89 4d c0 mov %ecx,-0x40(%ebp) 10d5fb: ff 55 d8 call *-0x28(%ebp) block->next == last_free_block ? " (= last free)" : (block->next == free_list_tail ? " (= tail)" : "") ); if ( block_size != next_block->prev_size ) { 10d5fe: 8b 06 mov (%esi),%eax 10d600: 83 c4 30 add $0x30,%esp 10d603: 8b 4d c0 mov -0x40(%ebp),%ecx 10d606: 39 c1 cmp %eax,%ecx 10d608: 8b 55 c4 mov -0x3c(%ebp),%edx 10d60b: 75 5f jne 10d66c <_Heap_Walk+0x338> ); return false; } if ( !prev_used ) { 10d60d: 85 d2 test %edx,%edx 10d60f: 0f 84 97 00 00 00 je 10d6ac <_Heap_Walk+0x378> block = next_block; } while ( block != first_block ); return true; } 10d615: 8b 43 08 mov 0x8(%ebx),%eax ) { const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); const Heap_Block *free_block = _Heap_Free_list_first( heap ); while ( free_block != free_list_tail ) { 10d618: 39 c3 cmp %eax,%ebx 10d61a: 74 0f je 10d62b <_Heap_Walk+0x2f7> <== NEVER TAKEN if ( free_block == block ) { 10d61c: 39 c7 cmp %eax,%edi 10d61e: 0f 84 43 ff ff ff je 10d567 <_Heap_Walk+0x233> return true; } free_block = free_block->next; 10d624: 8b 40 08 mov 0x8(%eax),%eax ) { const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); const Heap_Block *free_block = _Heap_Free_list_first( heap ); while ( free_block != free_list_tail ) { 10d627: 39 c3 cmp %eax,%ebx 10d629: 75 f1 jne 10d61c <_Heap_Walk+0x2e8> return false; } if ( !_Heap_Walk_is_in_free_list( heap, block ) ) { (*printer)( 10d62b: 57 push %edi 10d62c: 68 00 29 12 00 push $0x122900 10d631: e9 d2 fd ff ff jmp 10d408 <_Heap_Walk+0xd4> 10d636: 66 90 xchg %ax,%ax const Heap_Control *heap, const Heap_Block *block ) { return (uintptr_t) block >= (uintptr_t) heap->first_block && (uintptr_t) block <= (uintptr_t) heap->last_block; 10d638: 39 f9 cmp %edi,%ecx 10d63a: 0f 87 7b fe ff ff ja 10d4bb <_Heap_Walk+0x187> <== NEVER TAKEN RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block( const Heap_Block *block ) { return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE; 10d640: 8d 41 08 lea 0x8(%ecx),%eax RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10d643: 31 d2 xor %edx,%edx 10d645: f7 75 c8 divl -0x38(%ebp) ); return false; } if ( 10d648: 85 d2 test %edx,%edx 10d64a: 0f 85 ad 00 00 00 jne 10d6fd <_Heap_Walk+0x3c9> - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 10d650: 8b 41 04 mov 0x4(%ecx),%eax 10d653: 83 e0 fe and $0xfffffffe,%eax ); return false; } if ( _Heap_Is_used( free_block ) ) { 10d656: f6 44 01 04 01 testb $0x1,0x4(%ecx,%eax,1) 10d65b: 0f 85 a9 00 00 00 jne 10d70a <_Heap_Walk+0x3d6> 10d661: 89 f2 mov %esi,%edx 10d663: 89 ce mov %ecx,%esi 10d665: e9 36 fe ff ff jmp 10d4a0 <_Heap_Walk+0x16c> 10d66a: 66 90 xchg %ax,%ax " (= last free)" : (block->next == free_list_tail ? " (= tail)" : "") ); if ( block_size != next_block->prev_size ) { (*printer)( 10d66c: 52 push %edx 10d66d: 56 push %esi 10d66e: 50 push %eax 10d66f: 51 push %ecx 10d670: 57 push %edi 10d671: 68 6c 28 12 00 push $0x12286c 10d676: e9 71 fe ff ff jmp 10d4ec <_Heap_Walk+0x1b8> 10d67b: 90 nop Heap_Block *const last_free_block = _Heap_Free_list_last( heap ); bool const prev_used = _Heap_Is_prev_used( block ); uintptr_t const block_size = _Heap_Block_size( block ); Heap_Block *const next_block = _Heap_Block_at( block, block_size ); (*printer)( 10d67c: c7 45 c8 f6 24 12 00 movl $0x1224f6,-0x38(%ebp) 10d683: e9 38 ff ff ff jmp 10d5c0 <_Heap_Walk+0x28c> 10d688: b8 0f 25 12 00 mov $0x12250f,%eax 10d68d: e9 4a ff ff ff jmp 10d5dc <_Heap_Walk+0x2a8> 10d692: 66 90 xchg %ax,%ax " (= first free)" : (block->prev == free_list_head ? " (= head)" : ""), block->next, block->next == last_free_block ? " (= last free)" : (block->next == free_list_tail ? " (= tail)" : "") 10d694: c7 45 c8 05 25 12 00 movl $0x122505,-0x38(%ebp) 10d69b: e9 20 ff ff ff jmp 10d5c0 <_Heap_Walk+0x28c> block, block_size, block->prev, block->prev == first_free_block ? " (= first free)" : (block->prev == free_list_head ? " (= head)" : ""), 10d6a0: b8 1f 25 12 00 mov $0x12251f,%eax 10d6a5: e9 32 ff ff ff jmp 10d5dc <_Heap_Walk+0x2a8> 10d6aa: 66 90 xchg %ax,%ax return false; } if ( !prev_used ) { (*printer)( 10d6ac: 57 push %edi 10d6ad: 68 a8 28 12 00 push $0x1228a8 10d6b2: e9 51 fd ff ff jmp 10d408 <_Heap_Walk+0xd4> 10d6b7: 90 nop return false; } if ( !_Heap_Is_prev_used( first_block ) ) { (*printer)( 10d6b8: 56 push %esi 10d6b9: 68 90 26 12 00 push $0x122690 10d6be: e9 45 fd ff ff jmp 10d408 <_Heap_Walk+0xd4> 10d6c3: 90 nop const Heap_Control *heap, const Heap_Block *block ) { return (uintptr_t) block >= (uintptr_t) heap->first_block && (uintptr_t) block <= (uintptr_t) heap->last_block; 10d6c4: 89 f1 mov %esi,%ecx <== NOT EXECUTED 10d6c6: e9 f0 fd ff ff jmp 10d4bb <_Heap_Walk+0x187> <== NOT EXECUTED return false; } if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) { (*printer)( 10d6cb: 83 ec 0c sub $0xc,%esp 10d6ce: 51 push %ecx 10d6cf: 57 push %edi 10d6d0: 68 a4 27 12 00 push $0x1227a4 10d6d5: e9 12 fe ff ff jmp 10d4ec <_Heap_Walk+0x1b8> return false; } if ( block_size < min_block_size && is_not_last_block ) { (*printer)( 10d6da: 83 ec 08 sub $0x8,%esp 10d6dd: ff 75 d0 pushl -0x30(%ebp) 10d6e0: 51 push %ecx 10d6e1: 57 push %edi 10d6e2: 68 d4 27 12 00 push $0x1227d4 10d6e7: e9 00 fe ff ff jmp 10d4ec <_Heap_Walk+0x1b8> return false; } if ( next_block_begin <= block_begin && is_not_last_block ) { (*printer)( 10d6ec: 83 ec 0c sub $0xc,%esp 10d6ef: 56 push %esi 10d6f0: 57 push %edi 10d6f1: 68 00 28 12 00 push $0x122800 10d6f6: e9 f1 fd ff ff jmp 10d4ec <_Heap_Walk+0x1b8> ); return false; } if ( 10d6fb: 89 f1 mov %esi,%ecx <== NOT EXECUTED !_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size ) ) { (*printer)( 10d6fd: 51 push %ecx 10d6fe: 68 10 27 12 00 push $0x122710 10d703: e9 00 fd ff ff jmp 10d408 <_Heap_Walk+0xd4> ); return false; } if ( _Heap_Is_used( free_block ) ) { 10d708: 89 f1 mov %esi,%ecx <== NOT EXECUTED (*printer)( 10d70a: 51 push %ecx 10d70b: 68 6f 25 12 00 push $0x12256f 10d710: e9 f3 fc ff ff jmp 10d408 <_Heap_Walk+0xd4> return false; } if ( free_block->prev != prev_block ) { (*printer)( 10d715: 83 ec 0c sub $0xc,%esp 10d718: 50 push %eax 10d719: 56 push %esi 10d71a: 68 40 27 12 00 push $0x122740 10d71f: e9 c8 fd ff ff jmp 10d4ec <_Heap_Walk+0x1b8> =============================================================================== 0010bda0 <_IO_Initialize_all_drivers>: * * Output Parameters: NONE */ void _IO_Initialize_all_drivers( void ) { 10bda0: 55 push %ebp 10bda1: 89 e5 mov %esp,%ebp 10bda3: 53 push %ebx 10bda4: 83 ec 04 sub $0x4,%esp rtems_device_major_number major; for ( major=0 ; major < _IO_Number_of_drivers ; major ++ ) 10bda7: 8b 0d 00 88 12 00 mov 0x128800,%ecx 10bdad: 85 c9 test %ecx,%ecx 10bdaf: 74 1a je 10bdcb <_IO_Initialize_all_drivers+0x2b><== NEVER TAKEN 10bdb1: 31 db xor %ebx,%ebx 10bdb3: 90 nop (void) rtems_io_initialize( major, 0, NULL ); 10bdb4: 52 push %edx 10bdb5: 6a 00 push $0x0 10bdb7: 6a 00 push $0x0 10bdb9: 53 push %ebx 10bdba: e8 85 52 00 00 call 111044 void _IO_Initialize_all_drivers( void ) { rtems_device_major_number major; for ( major=0 ; major < _IO_Number_of_drivers ; major ++ ) 10bdbf: 43 inc %ebx 10bdc0: 83 c4 10 add $0x10,%esp 10bdc3: 39 1d 00 88 12 00 cmp %ebx,0x128800 10bdc9: 77 e9 ja 10bdb4 <_IO_Initialize_all_drivers+0x14> (void) rtems_io_initialize( major, 0, NULL ); } 10bdcb: 8b 5d fc mov -0x4(%ebp),%ebx 10bdce: c9 leave 10bdcf: c3 ret =============================================================================== 0010bd08 <_IO_Manager_initialization>: * workspace. * */ void _IO_Manager_initialization(void) { 10bd08: 55 push %ebp 10bd09: 89 e5 mov %esp,%ebp 10bd0b: 57 push %edi 10bd0c: 56 push %esi 10bd0d: 53 push %ebx 10bd0e: 83 ec 1c sub $0x1c,%esp uint32_t index; rtems_driver_address_table *driver_table; uint32_t drivers_in_table; uint32_t number_of_drivers; driver_table = Configuration.Device_driver_table; 10bd11: 8b 1d b4 3a 12 00 mov 0x123ab4,%ebx drivers_in_table = Configuration.number_of_device_drivers; 10bd17: a1 b0 3a 12 00 mov 0x123ab0,%eax 10bd1c: 89 45 e4 mov %eax,-0x1c(%ebp) number_of_drivers = Configuration.maximum_drivers; 10bd1f: 8b 35 ac 3a 12 00 mov 0x123aac,%esi /* * If the user claims there are less drivers than are actually in * the table, then let's just go with the table's count. */ if ( number_of_drivers <= drivers_in_table ) 10bd25: 39 f0 cmp %esi,%eax 10bd27: 73 5f jae 10bd88 <_IO_Manager_initialization+0x80> * The application requested extra slots in the driver table, so we * have to allocate a new driver table and copy theirs to it. */ _IO_Driver_address_table = (rtems_driver_address_table *) _Workspace_Allocate_or_fatal_error( 10bd29: 8d 0c 76 lea (%esi,%esi,2),%ecx 10bd2c: c1 e1 03 shl $0x3,%ecx 10bd2f: 83 ec 0c sub $0xc,%esp 10bd32: 51 push %ecx 10bd33: 89 4d dc mov %ecx,-0x24(%ebp) 10bd36: e8 81 2c 00 00 call 10e9bc <_Workspace_Allocate_or_fatal_error> 10bd3b: 89 c2 mov %eax,%edx /* * The application requested extra slots in the driver table, so we * have to allocate a new driver table and copy theirs to it. */ _IO_Driver_address_table = (rtems_driver_address_table *) 10bd3d: a3 04 88 12 00 mov %eax,0x128804 _Workspace_Allocate_or_fatal_error( sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); _IO_Number_of_drivers = number_of_drivers; 10bd42: 89 35 00 88 12 00 mov %esi,0x128800 memset( 10bd48: 31 c0 xor %eax,%eax 10bd4a: 8b 4d dc mov -0x24(%ebp),%ecx 10bd4d: 89 d7 mov %edx,%edi 10bd4f: f3 aa rep stos %al,%es:(%edi) _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 10bd51: 83 c4 10 add $0x10,%esp 10bd54: 8b 45 e4 mov -0x1c(%ebp),%eax 10bd57: 85 c0 test %eax,%eax 10bd59: 74 25 je 10bd80 <_IO_Manager_initialization+0x78><== NEVER TAKEN 10bd5b: a1 04 88 12 00 mov 0x128804,%eax 10bd60: 89 45 e0 mov %eax,-0x20(%ebp) 10bd63: 31 c0 xor %eax,%eax 10bd65: 31 d2 xor %edx,%edx 10bd67: 90 nop _IO_Driver_address_table[index] = driver_table[index]; 10bd68: 8b 7d e0 mov -0x20(%ebp),%edi 10bd6b: 01 c7 add %eax,%edi 10bd6d: 8d 34 03 lea (%ebx,%eax,1),%esi 10bd70: b9 06 00 00 00 mov $0x6,%ecx 10bd75: f3 a5 rep movsl %ds:(%esi),%es:(%edi) memset( _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 10bd77: 42 inc %edx 10bd78: 83 c0 18 add $0x18,%eax 10bd7b: 39 55 e4 cmp %edx,-0x1c(%ebp) 10bd7e: 77 e8 ja 10bd68 <_IO_Manager_initialization+0x60> _IO_Driver_address_table[index] = driver_table[index]; } 10bd80: 8d 65 f4 lea -0xc(%ebp),%esp 10bd83: 5b pop %ebx 10bd84: 5e pop %esi 10bd85: 5f pop %edi 10bd86: c9 leave 10bd87: c3 ret * If the maximum number of driver is the same as the number in the * table, then we do not have to copy the driver table. They can't * register any dynamically. */ if ( number_of_drivers == drivers_in_table ) { _IO_Driver_address_table = driver_table; 10bd88: 89 1d 04 88 12 00 mov %ebx,0x128804 _IO_Number_of_drivers = number_of_drivers; 10bd8e: 8b 45 e4 mov -0x1c(%ebp),%eax 10bd91: a3 00 88 12 00 mov %eax,0x128800 sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) _IO_Driver_address_table[index] = driver_table[index]; } 10bd96: 8d 65 f4 lea -0xc(%ebp),%esp 10bd99: 5b pop %ebx 10bd9a: 5e pop %esi 10bd9b: 5f pop %edi 10bd9c: c9 leave 10bd9d: c3 ret =============================================================================== 0010c8f4 <_Internal_error_Occurred>: void _Internal_error_Occurred( Internal_errors_Source the_source, bool is_internal, Internal_errors_t the_error ) { 10c8f4: 55 push %ebp 10c8f5: 89 e5 mov %esp,%ebp 10c8f7: 53 push %ebx 10c8f8: 83 ec 08 sub $0x8,%esp 10c8fb: 8b 45 08 mov 0x8(%ebp),%eax 10c8fe: 8b 55 0c mov 0xc(%ebp),%edx 10c901: 8b 5d 10 mov 0x10(%ebp),%ebx _Internal_errors_What_happened.the_source = the_source; 10c904: a3 34 7e 12 00 mov %eax,0x127e34 _Internal_errors_What_happened.is_internal = is_internal; 10c909: 88 15 38 7e 12 00 mov %dl,0x127e38 _Internal_errors_What_happened.the_error = the_error; 10c90f: 89 1d 3c 7e 12 00 mov %ebx,0x127e3c _User_extensions_Fatal( the_source, is_internal, the_error ); 10c915: 53 push %ebx 10c916: 0f b6 d2 movzbl %dl,%edx 10c919: 52 push %edx 10c91a: 50 push %eax 10c91b: e8 9c 1c 00 00 call 10e5bc <_User_extensions_Fatal> RTEMS_INLINE_ROUTINE void _System_state_Set ( System_state_Codes state ) { _System_state_Current = state; 10c920: c7 05 20 7f 12 00 05 movl $0x5,0x127f20 <== NOT EXECUTED 10c927: 00 00 00 _System_state_Set( SYSTEM_STATE_FAILED ); _CPU_Fatal_halt( the_error ); 10c92a: fa cli <== NOT EXECUTED 10c92b: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10c92d: f4 hlt <== NOT EXECUTED 10c92e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c931: eb fe jmp 10c931 <_Internal_error_Occurred+0x3d><== NOT EXECUTED =============================================================================== 0011161c <_Objects_API_maximum_class>: #include unsigned int _Objects_API_maximum_class( uint32_t api ) { 11161c: 55 push %ebp 11161d: 89 e5 mov %esp,%ebp 11161f: 8b 45 08 mov 0x8(%ebp),%eax 111622: 48 dec %eax 111623: 83 f8 02 cmp $0x2,%eax 111626: 77 0c ja 111634 <_Objects_API_maximum_class+0x18> 111628: 8b 04 85 a0 1b 12 00 mov 0x121ba0(,%eax,4),%eax case OBJECTS_NO_API: default: break; } return 0; } 11162f: c9 leave 111630: c3 ret 111631: 8d 76 00 lea 0x0(%esi),%esi #include unsigned int _Objects_API_maximum_class( uint32_t api ) { 111634: 31 c0 xor %eax,%eax case OBJECTS_NO_API: default: break; } return 0; } 111636: c9 leave 111637: c3 ret =============================================================================== 0010c984 <_Objects_Allocate>: */ Objects_Control *_Objects_Allocate( Objects_Information *information ) { 10c984: 55 push %ebp 10c985: 89 e5 mov %esp,%ebp 10c987: 56 push %esi 10c988: 53 push %ebx 10c989: 8b 5d 08 mov 0x8(%ebp),%ebx * If the application is using the optional manager stubs and * still attempts to create the object, the information block * should be all zeroed out because it is in the BSS. So let's * check that code for this manager is even present. */ if ( information->size == 0 ) 10c98c: 8b 43 18 mov 0x18(%ebx),%eax 10c98f: 85 c0 test %eax,%eax 10c991: 75 0d jne 10c9a0 <_Objects_Allocate+0x1c><== ALWAYS TAKEN return NULL; 10c993: 31 c9 xor %ecx,%ecx <== NOT EXECUTED ); } #endif return the_object; } 10c995: 89 c8 mov %ecx,%eax 10c997: 8d 65 f8 lea -0x8(%ebp),%esp 10c99a: 5b pop %ebx 10c99b: 5e pop %esi 10c99c: c9 leave 10c99d: c3 ret 10c99e: 66 90 xchg %ax,%ax /* * OK. The manager should be initialized and configured to have objects. * With any luck, it is safe to attempt to allocate an object. */ the_object = (Objects_Control *) _Chain_Get( &information->Inactive ); 10c9a0: 8d 73 20 lea 0x20(%ebx),%esi 10c9a3: 83 ec 0c sub $0xc,%esp 10c9a6: 56 push %esi 10c9a7: e8 68 f6 ff ff call 10c014 <_Chain_Get> 10c9ac: 89 c1 mov %eax,%ecx if ( information->auto_extend ) { 10c9ae: 83 c4 10 add $0x10,%esp 10c9b1: 80 7b 12 00 cmpb $0x0,0x12(%ebx) 10c9b5: 74 de je 10c995 <_Objects_Allocate+0x11> /* * If the list is empty then we are out of objects and need to * extend information base. */ if ( !the_object ) { 10c9b7: 85 c0 test %eax,%eax 10c9b9: 74 29 je 10c9e4 <_Objects_Allocate+0x60> } if ( the_object ) { uint32_t block; block = (uint32_t) _Objects_Get_index( the_object->id ) - 10c9bb: 0f b7 41 08 movzwl 0x8(%ecx),%eax 10c9bf: 0f b7 53 08 movzwl 0x8(%ebx),%edx 10c9c3: 29 d0 sub %edx,%eax _Objects_Get_index( information->minimum_id ); block /= information->allocation_size; 10c9c5: 0f b7 73 14 movzwl 0x14(%ebx),%esi 10c9c9: 31 d2 xor %edx,%edx 10c9cb: f7 f6 div %esi information->inactive_per_block[ block ]--; 10c9cd: c1 e0 02 shl $0x2,%eax 10c9d0: 03 43 30 add 0x30(%ebx),%eax 10c9d3: ff 08 decl (%eax) information->inactive--; 10c9d5: 66 ff 4b 2c decw 0x2c(%ebx) ); } #endif return the_object; } 10c9d9: 89 c8 mov %ecx,%eax 10c9db: 8d 65 f8 lea -0x8(%ebp),%esp 10c9de: 5b pop %ebx 10c9df: 5e pop %esi 10c9e0: c9 leave 10c9e1: c3 ret 10c9e2: 66 90 xchg %ax,%ax * If the list is empty then we are out of objects and need to * extend information base. */ if ( !the_object ) { _Objects_Extend_information( information ); 10c9e4: 83 ec 0c sub $0xc,%esp 10c9e7: 53 push %ebx 10c9e8: e8 3b 00 00 00 call 10ca28 <_Objects_Extend_information> the_object = (Objects_Control *) _Chain_Get( &information->Inactive ); 10c9ed: 89 34 24 mov %esi,(%esp) 10c9f0: e8 1f f6 ff ff call 10c014 <_Chain_Get> 10c9f5: 89 c1 mov %eax,%ecx } if ( the_object ) { 10c9f7: 83 c4 10 add $0x10,%esp 10c9fa: 85 c0 test %eax,%eax 10c9fc: 74 97 je 10c995 <_Objects_Allocate+0x11> 10c9fe: eb bb jmp 10c9bb <_Objects_Allocate+0x37> =============================================================================== 0010ca28 <_Objects_Extend_information>: */ void _Objects_Extend_information( Objects_Information *information ) { 10ca28: 55 push %ebp 10ca29: 89 e5 mov %esp,%ebp 10ca2b: 57 push %edi 10ca2c: 56 push %esi 10ca2d: 53 push %ebx 10ca2e: 83 ec 4c sub $0x4c,%esp 10ca31: 8b 5d 08 mov 0x8(%ebp),%ebx /* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id ); 10ca34: 0f b7 43 08 movzwl 0x8(%ebx),%eax 10ca38: 89 45 cc mov %eax,-0x34(%ebp) index_base = minimum_index; block = 0; /* if ( information->maximum < minimum_index ) */ if ( information->object_blocks == NULL ) 10ca3b: 8b 4b 34 mov 0x34(%ebx),%ecx 10ca3e: 85 c9 test %ecx,%ecx 10ca40: 0f 84 62 02 00 00 je 10cca8 <_Objects_Extend_information+0x280> block_count = 0; else { block_count = information->maximum / information->allocation_size; 10ca46: 8b 73 10 mov 0x10(%ebx),%esi 10ca49: 66 89 75 d0 mov %si,-0x30(%ebp) 10ca4d: 8b 7b 14 mov 0x14(%ebx),%edi 10ca50: 89 f0 mov %esi,%eax 10ca52: 31 d2 xor %edx,%edx 10ca54: 66 f7 f7 div %di 10ca57: 0f b7 f0 movzwl %ax,%esi for ( ; block < block_count; block++ ) { 10ca5a: 85 f6 test %esi,%esi 10ca5c: 0f 84 5f 02 00 00 je 10ccc1 <_Objects_Extend_information+0x299><== NEVER TAKEN if ( information->object_blocks[ block ] == NULL ) { 10ca62: 8b 01 mov (%ecx),%eax 10ca64: 85 c0 test %eax,%eax 10ca66: 0f 84 67 02 00 00 je 10ccd3 <_Objects_Extend_information+0x2ab><== NEVER TAKEN 10ca6c: 0f b7 ff movzwl %di,%edi /* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id ); 10ca6f: 8b 55 cc mov -0x34(%ebp),%edx 10ca72: 89 55 d4 mov %edx,-0x2c(%ebp) index_base = minimum_index; block = 0; 10ca75: 31 d2 xor %edx,%edx 10ca77: 8b 45 d4 mov -0x2c(%ebp),%eax 10ca7a: eb 0a jmp 10ca86 <_Objects_Extend_information+0x5e> block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { if ( information->object_blocks[ block ] == NULL ) { 10ca7c: 83 3c 91 00 cmpl $0x0,(%ecx,%edx,4) 10ca80: 0f 84 c2 01 00 00 je 10cc48 <_Objects_Extend_information+0x220> do_extend = false; break; } else index_base += information->allocation_size; 10ca86: 01 f8 add %edi,%eax if ( information->object_blocks == NULL ) block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { 10ca88: 42 inc %edx 10ca89: 39 d6 cmp %edx,%esi 10ca8b: 77 ef ja 10ca7c <_Objects_Extend_information+0x54> 10ca8d: 89 45 d4 mov %eax,-0x2c(%ebp) /* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; 10ca90: b1 01 mov $0x1,%cl } else index_base += information->allocation_size; } } maximum = (uint32_t) information->maximum + information->allocation_size; 10ca92: 0f b7 45 d0 movzwl -0x30(%ebp),%eax 10ca96: 01 f8 add %edi,%eax 10ca98: 89 45 d0 mov %eax,-0x30(%ebp) /* * We need to limit the number of objects to the maximum number * representable in the index portion of the object Id. In the * case of 16-bit Ids, this is only 256 object instances. */ if ( maximum > OBJECTS_ID_FINAL_INDEX ) { 10ca9b: 3d ff ff 00 00 cmp $0xffff,%eax 10caa0: 0f 87 9a 01 00 00 ja 10cc40 <_Objects_Extend_information+0x218><== NEVER TAKEN /* * Allocate the name table, and the objects and if it fails either return or * generate a fatal error depending on auto-extending being active. */ block_size = information->allocation_size * information->size; 10caa6: 0f af 7b 18 imul 0x18(%ebx),%edi if ( information->auto_extend ) { 10caaa: 80 7b 12 00 cmpb $0x0,0x12(%ebx) 10caae: 0f 84 a0 01 00 00 je 10cc54 <_Objects_Extend_information+0x22c> new_object_block = _Workspace_Allocate( block_size ); 10cab4: 83 ec 0c sub $0xc,%esp 10cab7: 57 push %edi 10cab8: 89 55 b8 mov %edx,-0x48(%ebp) 10cabb: 88 4d b4 mov %cl,-0x4c(%ebp) 10cabe: e8 c5 1e 00 00 call 10e988 <_Workspace_Allocate> 10cac3: 89 45 c8 mov %eax,-0x38(%ebp) if ( !new_object_block ) 10cac6: 83 c4 10 add $0x10,%esp 10cac9: 85 c0 test %eax,%eax 10cacb: 8b 55 b8 mov -0x48(%ebp),%edx 10cace: 8a 4d b4 mov -0x4c(%ebp),%cl 10cad1: 0f 84 69 01 00 00 je 10cc40 <_Objects_Extend_information+0x218> } /* * Do we need to grow the tables? */ if ( do_extend ) { 10cad7: 84 c9 test %cl,%cl 10cad9: 0f 84 e6 00 00 00 je 10cbc5 <_Objects_Extend_information+0x19d> */ /* * Up the block count and maximum */ block_count++; 10cadf: 8d 7e 01 lea 0x1(%esi),%edi * Allocate the tables and break it up. */ block_size = block_count * (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) + ((maximum + minimum_index) * sizeof(Objects_Control *)); object_blocks = (void**) _Workspace_Allocate( block_size ); 10cae2: 83 ec 0c sub $0xc,%esp /* * Allocate the tables and break it up. */ block_size = block_count * (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) + 10cae5: 8d 04 7f lea (%edi,%edi,2),%eax ((maximum + minimum_index) * sizeof(Objects_Control *)); 10cae8: 03 45 d0 add -0x30(%ebp),%eax /* * Allocate the tables and break it up. */ block_size = block_count * (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) + 10caeb: 03 45 cc add -0x34(%ebp),%eax block_count++; /* * Allocate the tables and break it up. */ block_size = block_count * 10caee: c1 e0 02 shl $0x2,%eax (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) + ((maximum + minimum_index) * sizeof(Objects_Control *)); object_blocks = (void**) _Workspace_Allocate( block_size ); 10caf1: 50 push %eax 10caf2: 89 55 b8 mov %edx,-0x48(%ebp) 10caf5: e8 8e 1e 00 00 call 10e988 <_Workspace_Allocate> 10cafa: 89 45 c4 mov %eax,-0x3c(%ebp) if ( !object_blocks ) { 10cafd: 83 c4 10 add $0x10,%esp 10cb00: 85 c0 test %eax,%eax 10cb02: 8b 55 b8 mov -0x48(%ebp),%edx 10cb05: 0f 84 da 01 00 00 je 10cce5 <_Objects_Extend_information+0x2bd> 10cb0b: 8b 45 c4 mov -0x3c(%ebp),%eax 10cb0e: 8d 04 b8 lea (%eax,%edi,4),%eax 10cb11: 89 45 bc mov %eax,-0x44(%ebp) 10cb14: 8b 4d c4 mov -0x3c(%ebp),%ecx 10cb17: 8d 04 f9 lea (%ecx,%edi,8),%eax * Take the block count down. Saves all the (block_count - 1) * in the copies. */ block_count--; if ( information->maximum > minimum_index ) { 10cb1a: 0f b7 4b 10 movzwl 0x10(%ebx),%ecx 10cb1e: 39 4d cc cmp %ecx,-0x34(%ebp) 10cb21: 0f 82 4d 01 00 00 jb 10cc74 <_Objects_Extend_information+0x24c> } else { /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { 10cb27: 8b 4d cc mov -0x34(%ebp),%ecx 10cb2a: 85 c9 test %ecx,%ecx 10cb2c: 74 12 je 10cb40 <_Objects_Extend_information+0x118><== NEVER TAKEN 10cb2e: 31 c9 xor %ecx,%ecx 10cb30: 8b 7d cc mov -0x34(%ebp),%edi 10cb33: 90 nop local_table[ index ] = NULL; 10cb34: c7 04 88 00 00 00 00 movl $0x0,(%eax,%ecx,4) } else { /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { 10cb3b: 41 inc %ecx 10cb3c: 39 cf cmp %ecx,%edi 10cb3e: 77 f4 ja 10cb34 <_Objects_Extend_information+0x10c><== NEVER TAKEN 10cb40: c1 e6 02 shl $0x2,%esi 10cb43: 89 75 c0 mov %esi,-0x40(%ebp) } /* * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; 10cb46: 8b 4d c4 mov -0x3c(%ebp),%ecx 10cb49: 8b 75 c0 mov -0x40(%ebp),%esi 10cb4c: c7 04 31 00 00 00 00 movl $0x0,(%ecx,%esi,1) inactive_per_block[block_count] = 0; 10cb53: 8b 4d bc mov -0x44(%ebp),%ecx 10cb56: c7 04 31 00 00 00 00 movl $0x0,(%ecx,%esi,1) for ( index=index_base ; index < ( information->allocation_size + index_base ); 10cb5d: 0f b7 73 14 movzwl 0x14(%ebx),%esi 10cb61: 03 75 d4 add -0x2c(%ebp),%esi * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; inactive_per_block[block_count] = 0; for ( index=index_base ; 10cb64: 39 75 d4 cmp %esi,-0x2c(%ebp) 10cb67: 73 0f jae 10cb78 <_Objects_Extend_information+0x150><== NEVER TAKEN 10cb69: 8b 4d d4 mov -0x2c(%ebp),%ecx index < ( information->allocation_size + index_base ); index++ ) { local_table[ index ] = NULL; 10cb6c: c7 04 88 00 00 00 00 movl $0x0,(%eax,%ecx,4) object_blocks[block_count] = NULL; inactive_per_block[block_count] = 0; for ( index=index_base ; index < ( information->allocation_size + index_base ); index++ ) { 10cb73: 41 inc %ecx * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; inactive_per_block[block_count] = 0; for ( index=index_base ; 10cb74: 39 f1 cmp %esi,%ecx 10cb76: 72 f4 jb 10cb6c <_Objects_Extend_information+0x144> index < ( information->allocation_size + index_base ); index++ ) { local_table[ index ] = NULL; } _ISR_Disable( level ); 10cb78: 9c pushf 10cb79: fa cli 10cb7a: 5f pop %edi old_tables = information->object_blocks; 10cb7b: 8b 73 34 mov 0x34(%ebx),%esi information->object_blocks = object_blocks; 10cb7e: 8b 4d c4 mov -0x3c(%ebp),%ecx 10cb81: 89 4b 34 mov %ecx,0x34(%ebx) information->inactive_per_block = inactive_per_block; 10cb84: 8b 4d bc mov -0x44(%ebp),%ecx 10cb87: 89 4b 30 mov %ecx,0x30(%ebx) information->local_table = local_table; 10cb8a: 89 43 1c mov %eax,0x1c(%ebx) information->maximum = (Objects_Maximum) maximum; 10cb8d: 8b 45 d0 mov -0x30(%ebp),%eax 10cb90: 66 89 43 10 mov %ax,0x10(%ebx) uint32_t the_class, uint32_t node, uint32_t index ) { return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) | 10cb94: 8b 0b mov (%ebx),%ecx 10cb96: c1 e1 18 shl $0x18,%ecx 10cb99: 81 c9 00 00 01 00 or $0x10000,%ecx information->maximum_id = _Objects_Build_id( 10cb9f: 0f b7 43 04 movzwl 0x4(%ebx),%eax (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) | 10cba3: c1 e0 1b shl $0x1b,%eax 10cba6: 09 c1 or %eax,%ecx 10cba8: 0f b7 45 d0 movzwl -0x30(%ebp),%eax uint32_t the_class, uint32_t node, uint32_t index ) { return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) | 10cbac: 09 c1 or %eax,%ecx 10cbae: 89 4b 0c mov %ecx,0xc(%ebx) information->the_class, _Objects_Local_node, information->maximum ); _ISR_Enable( level ); 10cbb1: 57 push %edi 10cbb2: 9d popf _Workspace_Free( old_tables ); 10cbb3: 83 ec 0c sub $0xc,%esp 10cbb6: 56 push %esi 10cbb7: 89 55 b8 mov %edx,-0x48(%ebp) 10cbba: e8 e5 1d 00 00 call 10e9a4 <_Workspace_Free> 10cbbf: 83 c4 10 add $0x10,%esp 10cbc2: 8b 55 b8 mov -0x48(%ebp),%edx } /* * Assign the new object block to the object block table. */ information->object_blocks[ block ] = new_object_block; 10cbc5: c1 e2 02 shl $0x2,%edx 10cbc8: 89 55 d0 mov %edx,-0x30(%ebp) 10cbcb: 8b 43 34 mov 0x34(%ebx),%eax 10cbce: 8b 4d c8 mov -0x38(%ebp),%ecx 10cbd1: 89 0c 10 mov %ecx,(%eax,%edx,1) /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 10cbd4: ff 73 18 pushl 0x18(%ebx) 10cbd7: 0f b7 43 14 movzwl 0x14(%ebx),%eax 10cbdb: 50 push %eax 10cbdc: 51 push %ecx 10cbdd: 8d 7d dc lea -0x24(%ebp),%edi 10cbe0: 57 push %edi 10cbe1: e8 9e 44 00 00 call 111084 <_Chain_Initialize> /* * Move from the local chain, initialise, then append to the inactive chain */ index = index_base; while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) { 10cbe6: 83 c4 10 add $0x10,%esp 10cbe9: 8b 75 d4 mov -0x2c(%ebp),%esi information->the_class, _Objects_Local_node, index ); _Chain_Append( &information->Inactive, &the_object->Node ); 10cbec: 8d 43 20 lea 0x20(%ebx),%eax 10cbef: 89 45 d4 mov %eax,-0x2c(%ebp) /* * Move from the local chain, initialise, then append to the inactive chain */ index = index_base; while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) { 10cbf2: eb 29 jmp 10cc1d <_Objects_Extend_information+0x1f5> 10cbf4: 8b 13 mov (%ebx),%edx 10cbf6: c1 e2 18 shl $0x18,%edx 10cbf9: 81 ca 00 00 01 00 or $0x10000,%edx the_object->id = _Objects_Build_id( 10cbff: 0f b7 4b 04 movzwl 0x4(%ebx),%ecx (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) | 10cc03: c1 e1 1b shl $0x1b,%ecx 10cc06: 09 ca or %ecx,%edx uint32_t the_class, uint32_t node, uint32_t index ) { return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) | 10cc08: 09 f2 or %esi,%edx 10cc0a: 89 50 08 mov %edx,0x8(%eax) information->the_class, _Objects_Local_node, index ); _Chain_Append( &information->Inactive, &the_object->Node ); 10cc0d: 83 ec 08 sub $0x8,%esp 10cc10: 50 push %eax 10cc11: ff 75 d4 pushl -0x2c(%ebp) 10cc14: e8 bf f3 ff ff call 10bfd8 <_Chain_Append> index++; 10cc19: 46 inc %esi 10cc1a: 83 c4 10 add $0x10,%esp /* * Move from the local chain, initialise, then append to the inactive chain */ index = index_base; while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) { 10cc1d: 83 ec 0c sub $0xc,%esp 10cc20: 57 push %edi 10cc21: e8 ee f3 ff ff call 10c014 <_Chain_Get> 10cc26: 83 c4 10 add $0x10,%esp 10cc29: 85 c0 test %eax,%eax 10cc2b: 75 c7 jne 10cbf4 <_Objects_Extend_information+0x1cc> _Chain_Append( &information->Inactive, &the_object->Node ); index++; } information->inactive_per_block[ block ] = information->allocation_size; 10cc2d: 8b 43 14 mov 0x14(%ebx),%eax 10cc30: 8b 53 30 mov 0x30(%ebx),%edx 10cc33: 0f b7 c8 movzwl %ax,%ecx 10cc36: 8b 75 d0 mov -0x30(%ebp),%esi 10cc39: 89 0c 32 mov %ecx,(%edx,%esi,1) information->inactive = (Objects_Maximum)(information->inactive + information->allocation_size); 10cc3c: 66 01 43 2c add %ax,0x2c(%ebx) } 10cc40: 8d 65 f4 lea -0xc(%ebp),%esp 10cc43: 5b pop %ebx 10cc44: 5e pop %esi 10cc45: 5f pop %edi 10cc46: c9 leave 10cc47: c3 ret 10cc48: 89 45 d4 mov %eax,-0x2c(%ebp) else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { if ( information->object_blocks[ block ] == NULL ) { do_extend = false; 10cc4b: 31 c9 xor %ecx,%ecx 10cc4d: e9 40 fe ff ff jmp 10ca92 <_Objects_Extend_information+0x6a> 10cc52: 66 90 xchg %ax,%ax if ( information->auto_extend ) { new_object_block = _Workspace_Allocate( block_size ); if ( !new_object_block ) return; } else { new_object_block = _Workspace_Allocate_or_fatal_error( block_size ); 10cc54: 83 ec 0c sub $0xc,%esp 10cc57: 57 push %edi 10cc58: 89 55 b8 mov %edx,-0x48(%ebp) 10cc5b: 88 4d b4 mov %cl,-0x4c(%ebp) 10cc5e: e8 59 1d 00 00 call 10e9bc <_Workspace_Allocate_or_fatal_error> 10cc63: 89 45 c8 mov %eax,-0x38(%ebp) 10cc66: 83 c4 10 add $0x10,%esp 10cc69: 8a 4d b4 mov -0x4c(%ebp),%cl 10cc6c: 8b 55 b8 mov -0x48(%ebp),%edx 10cc6f: e9 63 fe ff ff jmp 10cad7 <_Objects_Extend_information+0xaf> /* * Copy each section of the table over. This has to be performed as * separate parts as size of each block has changed. */ memcpy( object_blocks, 10cc74: c1 e6 02 shl $0x2,%esi 10cc77: 89 75 c0 mov %esi,-0x40(%ebp) 10cc7a: 8b 73 34 mov 0x34(%ebx),%esi 10cc7d: 8b 7d c4 mov -0x3c(%ebp),%edi 10cc80: 8b 4d c0 mov -0x40(%ebp),%ecx 10cc83: f3 a4 rep movsb %ds:(%esi),%es:(%edi) information->object_blocks, block_count * sizeof(void*) ); memcpy( inactive_per_block, 10cc85: 8b 73 30 mov 0x30(%ebx),%esi 10cc88: 8b 7d bc mov -0x44(%ebp),%edi 10cc8b: 8b 4d c0 mov -0x40(%ebp),%ecx 10cc8e: f3 a4 rep movsb %ds:(%esi),%es:(%edi) information->inactive_per_block, block_count * sizeof(uint32_t) ); memcpy( local_table, information->local_table, (information->maximum + minimum_index) * sizeof(Objects_Control *) ); 10cc90: 0f b7 4b 10 movzwl 0x10(%ebx),%ecx 10cc94: 03 4d cc add -0x34(%ebp),%ecx information->object_blocks, block_count * sizeof(void*) ); memcpy( inactive_per_block, information->inactive_per_block, block_count * sizeof(uint32_t) ); memcpy( local_table, 10cc97: c1 e1 02 shl $0x2,%ecx 10cc9a: 8b 73 1c mov 0x1c(%ebx),%esi 10cc9d: 89 c7 mov %eax,%edi 10cc9f: f3 a4 rep movsb %ds:(%esi),%es:(%edi) 10cca1: e9 a0 fe ff ff jmp 10cb46 <_Objects_Extend_information+0x11e> 10cca6: 66 90 xchg %ax,%ax minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0; /* if ( information->maximum < minimum_index ) */ if ( information->object_blocks == NULL ) 10cca8: 8b 53 10 mov 0x10(%ebx),%edx 10ccab: 66 89 55 d0 mov %dx,-0x30(%ebp) 10ccaf: 0f b7 7b 14 movzwl 0x14(%ebx),%edi /* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id ); 10ccb3: 89 45 d4 mov %eax,-0x2c(%ebp) /* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; 10ccb6: b1 01 mov $0x1,%cl minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0; 10ccb8: 31 d2 xor %edx,%edx /* if ( information->maximum < minimum_index ) */ if ( information->object_blocks == NULL ) block_count = 0; 10ccba: 31 f6 xor %esi,%esi 10ccbc: e9 d1 fd ff ff jmp 10ca92 <_Objects_Extend_information+0x6a> else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { 10ccc1: 0f b7 ff movzwl %di,%edi <== NOT EXECUTED /* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id ); 10ccc4: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED 10ccc7: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED /* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; 10ccca: b1 01 mov $0x1,%cl <== NOT EXECUTED minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0; 10cccc: 31 d2 xor %edx,%edx <== NOT EXECUTED 10ccce: e9 bf fd ff ff jmp 10ca92 <_Objects_Extend_information+0x6a><== NOT EXECUTED block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { if ( information->object_blocks[ block ] == NULL ) { 10ccd3: 0f b7 ff movzwl %di,%edi <== NOT EXECUTED /* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id ); 10ccd6: 8b 4d cc mov -0x34(%ebp),%ecx <== NOT EXECUTED 10ccd9: 89 4d d4 mov %ecx,-0x2c(%ebp) <== NOT EXECUTED else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { if ( information->object_blocks[ block ] == NULL ) { do_extend = false; 10ccdc: 31 c9 xor %ecx,%ecx <== NOT EXECUTED * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0; 10ccde: 31 d2 xor %edx,%edx <== NOT EXECUTED 10cce0: e9 ad fd ff ff jmp 10ca92 <_Objects_Extend_information+0x6a><== NOT EXECUTED (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) + ((maximum + minimum_index) * sizeof(Objects_Control *)); object_blocks = (void**) _Workspace_Allocate( block_size ); if ( !object_blocks ) { _Workspace_Free( new_object_block ); 10cce5: 83 ec 0c sub $0xc,%esp 10cce8: ff 75 c8 pushl -0x38(%ebp) 10cceb: e8 b4 1c 00 00 call 10e9a4 <_Workspace_Free> return; 10ccf0: 83 c4 10 add $0x10,%esp 10ccf3: e9 48 ff ff ff jmp 10cc40 <_Objects_Extend_information+0x218> =============================================================================== 0010cd88 <_Objects_Get_information>: Objects_Information *_Objects_Get_information( Objects_APIs the_api, uint16_t the_class ) { 10cd88: 55 push %ebp 10cd89: 89 e5 mov %esp,%ebp 10cd8b: 56 push %esi 10cd8c: 53 push %ebx 10cd8d: 8b 75 08 mov 0x8(%ebp),%esi 10cd90: 8b 5d 0c mov 0xc(%ebp),%ebx Objects_Information *info; int the_class_api_maximum; if ( !the_class ) 10cd93: 66 85 db test %bx,%bx 10cd96: 75 0c jne 10cda4 <_Objects_Get_information+0x1c> the_class_api_maximum = _Objects_API_maximum_class( the_api ); if ( the_class_api_maximum == 0 ) return NULL; if ( the_class > (uint32_t) the_class_api_maximum ) return NULL; 10cd98: 31 c0 xor %eax,%eax if ( info->maximum == 0 ) return NULL; #endif return info; } 10cd9a: 8d 65 f8 lea -0x8(%ebp),%esp 10cd9d: 5b pop %ebx 10cd9e: 5e pop %esi 10cd9f: c9 leave 10cda0: c3 ret 10cda1: 8d 76 00 lea 0x0(%esi),%esi /* * This call implicitly validates the_api so we do not call * _Objects_Is_api_valid above here. */ the_class_api_maximum = _Objects_API_maximum_class( the_api ); 10cda4: 83 ec 0c sub $0xc,%esp 10cda7: 56 push %esi 10cda8: e8 6f 48 00 00 call 11161c <_Objects_API_maximum_class> if ( the_class_api_maximum == 0 ) 10cdad: 83 c4 10 add $0x10,%esp 10cdb0: 85 c0 test %eax,%eax 10cdb2: 74 e4 je 10cd98 <_Objects_Get_information+0x10> return NULL; if ( the_class > (uint32_t) the_class_api_maximum ) 10cdb4: 0f b7 db movzwl %bx,%ebx 10cdb7: 39 d8 cmp %ebx,%eax 10cdb9: 72 dd jb 10cd98 <_Objects_Get_information+0x10> return NULL; if ( !_Objects_Information_table[ the_api ] ) 10cdbb: 8b 14 b5 68 7d 12 00 mov 0x127d68(,%esi,4),%edx return NULL; 10cdc2: 31 c0 xor %eax,%eax return NULL; if ( the_class > (uint32_t) the_class_api_maximum ) return NULL; if ( !_Objects_Information_table[ the_api ] ) 10cdc4: 85 d2 test %edx,%edx 10cdc6: 74 d2 je 10cd9a <_Objects_Get_information+0x12><== NEVER TAKEN return NULL; info = _Objects_Information_table[ the_api ][ the_class ]; 10cdc8: 8b 04 9a mov (%edx,%ebx,4),%eax if ( !info ) 10cdcb: 85 c0 test %eax,%eax 10cdcd: 74 cb je 10cd9a <_Objects_Get_information+0x12><== NEVER TAKEN * Thus we may have 0 local instances and still have a valid object * pointer. */ #if !defined(RTEMS_MULTIPROCESSING) if ( info->maximum == 0 ) return NULL; 10cdcf: 31 d2 xor %edx,%edx 10cdd1: 66 83 78 10 00 cmpw $0x0,0x10(%eax) 10cdd6: 0f 95 c2 setne %dl 10cdd9: f7 da neg %edx 10cddb: 21 d0 and %edx,%eax 10cddd: eb bb jmp 10cd9a <_Objects_Get_information+0x12> =============================================================================== 0010cde0 <_Objects_Get_isr_disable>: Objects_Information *information, Objects_Id id, Objects_Locations *location, ISR_Level *level_p ) { 10cde0: 55 push %ebp 10cde1: 89 e5 mov %esp,%ebp 10cde3: 56 push %esi 10cde4: 53 push %ebx 10cde5: 8b 55 08 mov 0x8(%ebp),%edx 10cde8: 8b 5d 10 mov 0x10(%ebp),%ebx Objects_Control *the_object; uint32_t index; ISR_Level level; index = id - information->minimum_id + 1; 10cdeb: b8 01 00 00 00 mov $0x1,%eax 10cdf0: 2b 42 08 sub 0x8(%edx),%eax 10cdf3: 03 45 0c add 0xc(%ebp),%eax _ISR_Disable( level ); 10cdf6: 9c pushf 10cdf7: fa cli 10cdf8: 5e pop %esi if ( information->maximum >= index ) { 10cdf9: 0f b7 4a 10 movzwl 0x10(%edx),%ecx 10cdfd: 39 c8 cmp %ecx,%eax 10cdff: 77 1b ja 10ce1c <_Objects_Get_isr_disable+0x3c> if ( (the_object = information->local_table[ index ]) != NULL ) { 10ce01: 8b 52 1c mov 0x1c(%edx),%edx 10ce04: 8b 04 82 mov (%edx,%eax,4),%eax 10ce07: 85 c0 test %eax,%eax 10ce09: 74 21 je 10ce2c <_Objects_Get_isr_disable+0x4c> *location = OBJECTS_LOCAL; 10ce0b: c7 03 00 00 00 00 movl $0x0,(%ebx) *level_p = level; 10ce11: 8b 55 14 mov 0x14(%ebp),%edx 10ce14: 89 32 mov %esi,(%edx) _Objects_MP_Is_remote( information, id, location, &the_object ); return the_object; #else return NULL; #endif } 10ce16: 5b pop %ebx 10ce17: 5e pop %esi 10ce18: c9 leave 10ce19: c3 ret 10ce1a: 66 90 xchg %ax,%ax } _ISR_Enable( level ); *location = OBJECTS_ERROR; return NULL; } _ISR_Enable( level ); 10ce1c: 56 push %esi 10ce1d: 9d popf *location = OBJECTS_ERROR; 10ce1e: c7 03 01 00 00 00 movl $0x1,(%ebx) #if defined(RTEMS_MULTIPROCESSING) _Objects_MP_Is_remote( information, id, location, &the_object ); return the_object; #else return NULL; 10ce24: 31 c0 xor %eax,%eax #endif } 10ce26: 5b pop %ebx 10ce27: 5e pop %esi 10ce28: c9 leave 10ce29: c3 ret 10ce2a: 66 90 xchg %ax,%ax if ( (the_object = information->local_table[ index ]) != NULL ) { *location = OBJECTS_LOCAL; *level_p = level; return the_object; } _ISR_Enable( level ); 10ce2c: 56 push %esi 10ce2d: 9d popf *location = OBJECTS_ERROR; 10ce2e: c7 03 01 00 00 00 movl $0x1,(%ebx) return NULL; 10ce34: eb e0 jmp 10ce16 <_Objects_Get_isr_disable+0x36> =============================================================================== 0010e4d0 <_Objects_Get_name_as_string>: char *_Objects_Get_name_as_string( Objects_Id id, size_t length, char *name ) { 10e4d0: 55 push %ebp 10e4d1: 89 e5 mov %esp,%ebp 10e4d3: 57 push %edi 10e4d4: 56 push %esi 10e4d5: 53 push %ebx 10e4d6: 83 ec 2c sub $0x2c,%esp 10e4d9: 8b 55 08 mov 0x8(%ebp),%edx 10e4dc: 8b 75 0c mov 0xc(%ebp),%esi 10e4df: 8b 5d 10 mov 0x10(%ebp),%ebx char lname[5]; Objects_Control *the_object; Objects_Locations location; Objects_Id tmpId; if ( length == 0 ) 10e4e2: 85 f6 test %esi,%esi 10e4e4: 75 0e jne 10e4f4 <_Objects_Get_name_as_string+0x24> #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* not supported */ #endif case OBJECTS_ERROR: return NULL; 10e4e6: 31 db xor %ebx,%ebx _Thread_Enable_dispatch(); return name; } return NULL; /* unreachable path */ } 10e4e8: 89 d8 mov %ebx,%eax 10e4ea: 8d 65 f4 lea -0xc(%ebp),%esp 10e4ed: 5b pop %ebx 10e4ee: 5e pop %esi 10e4ef: 5f pop %edi 10e4f0: c9 leave 10e4f1: c3 ret 10e4f2: 66 90 xchg %ax,%ax Objects_Id tmpId; if ( length == 0 ) return NULL; if ( name == NULL ) 10e4f4: 85 db test %ebx,%ebx 10e4f6: 74 f0 je 10e4e8 <_Objects_Get_name_as_string+0x18> return NULL; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10e4f8: 85 d2 test %edx,%edx 10e4fa: 75 08 jne 10e504 <_Objects_Get_name_as_string+0x34> 10e4fc: a1 f8 af 12 00 mov 0x12aff8,%eax 10e501: 8b 50 08 mov 0x8(%eax),%edx information = _Objects_Get_information_id( tmpId ); 10e504: 83 ec 0c sub $0xc,%esp 10e507: 52 push %edx 10e508: 89 55 cc mov %edx,-0x34(%ebp) 10e50b: e8 f0 fe ff ff call 10e400 <_Objects_Get_information_id> 10e510: 89 c7 mov %eax,%edi if ( !information ) 10e512: 83 c4 10 add $0x10,%esp 10e515: 85 c0 test %eax,%eax 10e517: 8b 55 cc mov -0x34(%ebp),%edx 10e51a: 74 ca je 10e4e6 <_Objects_Get_name_as_string+0x16> return NULL; the_object = _Objects_Get( information, tmpId, &location ); 10e51c: 51 push %ecx 10e51d: 8d 45 e4 lea -0x1c(%ebp),%eax 10e520: 50 push %eax 10e521: 52 push %edx 10e522: 57 push %edi 10e523: e8 90 00 00 00 call 10e5b8 <_Objects_Get> switch ( location ) { 10e528: 83 c4 10 add $0x10,%esp 10e52b: 8b 55 e4 mov -0x1c(%ebp),%edx 10e52e: 85 d2 test %edx,%edx 10e530: 75 b4 jne 10e4e6 <_Objects_Get_name_as_string+0x16> return NULL; case OBJECTS_LOCAL: #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) if ( information->is_string ) { 10e532: 80 7f 38 00 cmpb $0x0,0x38(%edi) 10e536: 74 54 je 10e58c <_Objects_Get_name_as_string+0xbc> s = the_object->name.name_p; 10e538: 8b 78 0c mov 0xc(%eax),%edi lname[ 4 ] = '\0'; s = lname; } d = name; if ( s ) { 10e53b: 85 ff test %edi,%edi 10e53d: 74 74 je 10e5b3 <_Objects_Get_name_as_string+0xe3> for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 10e53f: 4e dec %esi 10e540: 89 75 d4 mov %esi,-0x2c(%ebp) 10e543: 74 6e je 10e5b3 <_Objects_Get_name_as_string+0xe3><== NEVER TAKEN 10e545: 8a 17 mov (%edi),%dl 10e547: 84 d2 test %dl,%dl 10e549: 74 68 je 10e5b3 <_Objects_Get_name_as_string+0xe3> 10e54b: 89 d9 mov %ebx,%ecx 10e54d: 31 c0 xor %eax,%eax 10e54f: 89 5d d0 mov %ebx,-0x30(%ebp) 10e552: eb 07 jmp 10e55b <_Objects_Get_name_as_string+0x8b> 10e554: 8a 14 07 mov (%edi,%eax,1),%dl 10e557: 84 d2 test %dl,%dl 10e559: 74 21 je 10e57c <_Objects_Get_name_as_string+0xac> *d = (isprint((unsigned char)*s)) ? *s : '*'; 10e55b: 0f b6 da movzbl %dl,%ebx 10e55e: 8b 35 e8 82 12 00 mov 0x1282e8,%esi 10e564: 0f be 5c 1e 01 movsbl 0x1(%esi,%ebx,1),%ebx 10e569: 81 e3 97 00 00 00 and $0x97,%ebx 10e56f: 75 02 jne 10e573 <_Objects_Get_name_as_string+0xa3> 10e571: b2 2a mov $0x2a,%dl 10e573: 88 11 mov %dl,(%ecx) s = lname; } d = name; if ( s ) { for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 10e575: 40 inc %eax 10e576: 41 inc %ecx 10e577: 3b 45 d4 cmp -0x2c(%ebp),%eax 10e57a: 72 d8 jb 10e554 <_Objects_Get_name_as_string+0x84> 10e57c: 8b 5d d0 mov -0x30(%ebp),%ebx *d = (isprint((unsigned char)*s)) ? *s : '*'; } } *d = '\0'; 10e57f: c6 01 00 movb $0x0,(%ecx) _Thread_Enable_dispatch(); 10e582: e8 a9 0b 00 00 call 10f130 <_Thread_Enable_dispatch> return name; 10e587: e9 5c ff ff ff jmp 10e4e8 <_Objects_Get_name_as_string+0x18> if ( information->is_string ) { s = the_object->name.name_p; } else #endif { uint32_t u32_name = (uint32_t) the_object->name.name_u32; 10e58c: 8b 40 0c mov 0xc(%eax),%eax lname[ 0 ] = (u32_name >> 24) & 0xff; 10e58f: 89 c2 mov %eax,%edx 10e591: c1 ea 18 shr $0x18,%edx 10e594: 88 55 df mov %dl,-0x21(%ebp) lname[ 1 ] = (u32_name >> 16) & 0xff; 10e597: 89 c2 mov %eax,%edx 10e599: c1 ea 10 shr $0x10,%edx 10e59c: 88 55 e0 mov %dl,-0x20(%ebp) lname[ 2 ] = (u32_name >> 8) & 0xff; 10e59f: 89 c2 mov %eax,%edx 10e5a1: c1 ea 08 shr $0x8,%edx 10e5a4: 88 55 e1 mov %dl,-0x1f(%ebp) lname[ 3 ] = (u32_name >> 0) & 0xff; 10e5a7: 88 45 e2 mov %al,-0x1e(%ebp) lname[ 4 ] = '\0'; 10e5aa: c6 45 e3 00 movb $0x0,-0x1d(%ebp) s = lname; 10e5ae: 8d 7d df lea -0x21(%ebp),%edi 10e5b1: eb 8c jmp 10e53f <_Objects_Get_name_as_string+0x6f> } d = name; if ( s ) { for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 10e5b3: 89 d9 mov %ebx,%ecx 10e5b5: eb c8 jmp 10e57f <_Objects_Get_name_as_string+0xaf> =============================================================================== 0010cf90 <_Objects_Get_next>: Objects_Information *information, Objects_Id id, Objects_Locations *location_p, Objects_Id *next_id_p ) { 10cf90: 55 push %ebp 10cf91: 89 e5 mov %esp,%ebp 10cf93: 57 push %edi 10cf94: 56 push %esi 10cf95: 53 push %ebx 10cf96: 83 ec 0c sub $0xc,%esp 10cf99: 8b 5d 08 mov 0x8(%ebp),%ebx 10cf9c: 8b 75 0c mov 0xc(%ebp),%esi 10cf9f: 8b 7d 10 mov 0x10(%ebp),%edi Objects_Control *object; Objects_Id next_id; if ( !information ) 10cfa2: 85 db test %ebx,%ebx 10cfa4: 75 0a jne 10cfb0 <_Objects_Get_next+0x20> if ( !location_p ) return NULL; if ( !next_id_p ) return NULL; 10cfa6: 31 c0 xor %eax,%eax return object; final: *next_id_p = OBJECTS_ID_FINAL; return 0; } 10cfa8: 8d 65 f4 lea -0xc(%ebp),%esp 10cfab: 5b pop %ebx 10cfac: 5e pop %esi 10cfad: 5f pop %edi 10cfae: c9 leave 10cfaf: c3 ret Objects_Id next_id; if ( !information ) return NULL; if ( !location_p ) 10cfb0: 85 ff test %edi,%edi 10cfb2: 74 f2 je 10cfa6 <_Objects_Get_next+0x16> return NULL; if ( !next_id_p ) 10cfb4: 8b 45 14 mov 0x14(%ebp),%eax 10cfb7: 85 c0 test %eax,%eax 10cfb9: 74 eb je 10cfa6 <_Objects_Get_next+0x16> return NULL; if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX) 10cfbb: 66 85 f6 test %si,%si 10cfbe: 75 04 jne 10cfc4 <_Objects_Get_next+0x34> next_id = information->minimum_id; 10cfc0: 8b 73 08 mov 0x8(%ebx),%esi 10cfc3: 90 nop else next_id = id; do { /* walked off end of list? */ if (_Objects_Get_index(next_id) > information->maximum) 10cfc4: 66 39 73 10 cmp %si,0x10(%ebx) 10cfc8: 72 22 jb 10cfec <_Objects_Get_next+0x5c> *location_p = OBJECTS_ERROR; goto final; } /* try to grab one */ object = _Objects_Get(information, next_id, location_p); 10cfca: 51 push %ecx 10cfcb: 57 push %edi 10cfcc: 56 push %esi 10cfcd: 53 push %ebx 10cfce: e8 2d 00 00 00 call 10d000 <_Objects_Get> next_id++; 10cfd3: 46 inc %esi } while (*location_p != OBJECTS_LOCAL); 10cfd4: 83 c4 10 add $0x10,%esp 10cfd7: 8b 17 mov (%edi),%edx 10cfd9: 85 d2 test %edx,%edx 10cfdb: 75 e7 jne 10cfc4 <_Objects_Get_next+0x34> *next_id_p = next_id; 10cfdd: 8b 55 14 mov 0x14(%ebp),%edx 10cfe0: 89 32 mov %esi,(%edx) return object; final: *next_id_p = OBJECTS_ID_FINAL; return 0; } 10cfe2: 8d 65 f4 lea -0xc(%ebp),%esp 10cfe5: 5b pop %ebx 10cfe6: 5e pop %esi 10cfe7: 5f pop %edi 10cfe8: c9 leave 10cfe9: c3 ret 10cfea: 66 90 xchg %ax,%ax do { /* walked off end of list? */ if (_Objects_Get_index(next_id) > information->maximum) { *location_p = OBJECTS_ERROR; 10cfec: c7 07 01 00 00 00 movl $0x1,(%edi) *next_id_p = next_id; return object; final: *next_id_p = OBJECTS_ID_FINAL; 10cff2: 8b 45 14 mov 0x14(%ebp),%eax 10cff5: c7 00 ff ff ff ff movl $0xffffffff,(%eax) return 0; 10cffb: 31 c0 xor %eax,%eax 10cffd: eb a9 jmp 10cfa8 <_Objects_Get_next+0x18> =============================================================================== 0011b2a0 <_Objects_Get_no_protection>: Objects_Control *_Objects_Get_no_protection( Objects_Information *information, Objects_Id id, Objects_Locations *location ) { 11b2a0: 55 push %ebp 11b2a1: 89 e5 mov %esp,%ebp 11b2a3: 53 push %ebx 11b2a4: 8b 55 08 mov 0x8(%ebp),%edx 11b2a7: 8b 5d 10 mov 0x10(%ebp),%ebx /* * You can't just extract the index portion or you can get tricked * by a value between 1 and maximum. */ index = id - information->minimum_id + 1; 11b2aa: b8 01 00 00 00 mov $0x1,%eax 11b2af: 2b 42 08 sub 0x8(%edx),%eax 11b2b2: 03 45 0c add 0xc(%ebp),%eax if ( information->maximum >= index ) { 11b2b5: 0f b7 4a 10 movzwl 0x10(%edx),%ecx 11b2b9: 39 c8 cmp %ecx,%eax 11b2bb: 77 13 ja 11b2d0 <_Objects_Get_no_protection+0x30> if ( (the_object = information->local_table[ index ]) != NULL ) { 11b2bd: 8b 52 1c mov 0x1c(%edx),%edx 11b2c0: 8b 04 82 mov (%edx,%eax,4),%eax 11b2c3: 85 c0 test %eax,%eax 11b2c5: 74 09 je 11b2d0 <_Objects_Get_no_protection+0x30><== NEVER TAKEN *location = OBJECTS_LOCAL; 11b2c7: c7 03 00 00 00 00 movl $0x0,(%ebx) * This isn't supported or required yet for Global objects so * if it isn't local, we don't find it. */ *location = OBJECTS_ERROR; return NULL; } 11b2cd: 5b pop %ebx 11b2ce: c9 leave 11b2cf: c3 ret /* * This isn't supported or required yet for Global objects so * if it isn't local, we don't find it. */ *location = OBJECTS_ERROR; 11b2d0: c7 03 01 00 00 00 movl $0x1,(%ebx) return NULL; 11b2d6: 31 c0 xor %eax,%eax } 11b2d8: 5b pop %ebx 11b2d9: c9 leave 11b2da: c3 ret =============================================================================== 0010e0e4 <_Objects_Id_to_name>: */ Objects_Name_or_id_lookup_errors _Objects_Id_to_name ( Objects_Id id, Objects_Name *name ) { 10e0e4: 55 push %ebp 10e0e5: 89 e5 mov %esp,%ebp 10e0e7: 83 ec 18 sub $0x18,%esp 10e0ea: 8b 55 08 mov 0x8(%ebp),%edx /* * Caller is trusted for name != NULL. */ tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10e0ed: 85 d2 test %edx,%edx 10e0ef: 75 08 jne 10e0f9 <_Objects_Id_to_name+0x15> 10e0f1: a1 78 af 12 00 mov 0x12af78,%eax 10e0f6: 8b 50 08 mov 0x8(%eax),%edx 10e0f9: 89 d0 mov %edx,%eax 10e0fb: c1 e8 18 shr $0x18,%eax 10e0fe: 83 e0 07 and $0x7,%eax */ RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid( uint32_t the_api ) { if ( !the_api || the_api > OBJECTS_APIS_LAST ) 10e101: 8d 48 ff lea -0x1(%eax),%ecx 10e104: 83 f9 02 cmp $0x2,%ecx 10e107: 77 1d ja 10e126 <_Objects_Id_to_name+0x42> the_api = _Objects_Get_API( tmpId ); if ( !_Objects_Is_api_valid( the_api ) ) return OBJECTS_INVALID_ID; if ( !_Objects_Information_table[ the_api ] ) 10e109: 8b 04 85 a8 a9 12 00 mov 0x12a9a8(,%eax,4),%eax 10e110: 85 c0 test %eax,%eax 10e112: 74 12 je 10e126 <_Objects_Id_to_name+0x42> */ RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class( Objects_Id id ) { return (uint32_t) 10e114: 89 d1 mov %edx,%ecx 10e116: c1 e9 1b shr $0x1b,%ecx return OBJECTS_INVALID_ID; the_class = _Objects_Get_class( tmpId ); information = _Objects_Information_table[ the_api ][ the_class ]; 10e119: 8b 04 88 mov (%eax,%ecx,4),%eax if ( !information ) 10e11c: 85 c0 test %eax,%eax 10e11e: 74 06 je 10e126 <_Objects_Id_to_name+0x42><== NEVER TAKEN return OBJECTS_INVALID_ID; #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) if ( information->is_string ) 10e120: 80 78 38 00 cmpb $0x0,0x38(%eax) 10e124: 74 0a je 10e130 <_Objects_Id_to_name+0x4c><== ALWAYS TAKEN the_api = _Objects_Get_API( tmpId ); if ( !_Objects_Is_api_valid( the_api ) ) return OBJECTS_INVALID_ID; if ( !_Objects_Information_table[ the_api ] ) return OBJECTS_INVALID_ID; 10e126: b8 03 00 00 00 mov $0x3,%eax return OBJECTS_INVALID_ID; *name = the_object->name; _Thread_Enable_dispatch(); return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; } 10e12b: c9 leave 10e12c: c3 ret 10e12d: 8d 76 00 lea 0x0(%esi),%esi #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) if ( information->is_string ) return OBJECTS_INVALID_ID; #endif the_object = _Objects_Get( information, tmpId, &ignored_location ); 10e130: 51 push %ecx 10e131: 8d 4d f4 lea -0xc(%ebp),%ecx 10e134: 51 push %ecx 10e135: 52 push %edx 10e136: 50 push %eax 10e137: e8 40 ff ff ff call 10e07c <_Objects_Get> if ( !the_object ) 10e13c: 83 c4 10 add $0x10,%esp 10e13f: 85 c0 test %eax,%eax 10e141: 74 e3 je 10e126 <_Objects_Id_to_name+0x42> return OBJECTS_INVALID_ID; *name = the_object->name; 10e143: 8b 50 0c mov 0xc(%eax),%edx 10e146: 8b 45 0c mov 0xc(%ebp),%eax 10e149: 89 10 mov %edx,(%eax) _Thread_Enable_dispatch(); 10e14b: e8 14 0b 00 00 call 10ec64 <_Thread_Enable_dispatch> return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; 10e150: 31 c0 xor %eax,%eax } 10e152: c9 leave 10e153: c3 ret =============================================================================== 0010cea0 <_Objects_Initialize_information>: , bool supports_global, Objects_Thread_queue_Extract_callout extract #endif ) { 10cea0: 55 push %ebp 10cea1: 89 e5 mov %esp,%ebp 10cea3: 57 push %edi 10cea4: 56 push %esi 10cea5: 53 push %ebx 10cea6: 83 ec 0c sub $0xc,%esp 10cea9: 8b 45 08 mov 0x8(%ebp),%eax 10ceac: 8b 55 0c mov 0xc(%ebp),%edx 10ceaf: 8b 5d 10 mov 0x10(%ebp),%ebx 10ceb2: 8b 75 20 mov 0x20(%ebp),%esi 10ceb5: 0f b7 7d 18 movzwl 0x18(%ebp),%edi uint32_t maximum_per_allocation; #if defined(RTEMS_MULTIPROCESSING) uint32_t index; #endif information->the_api = the_api; 10ceb9: 89 10 mov %edx,(%eax) information->the_class = the_class; 10cebb: 66 89 58 04 mov %bx,0x4(%eax) information->size = size; 10cebf: 89 78 18 mov %edi,0x18(%eax) information->local_table = 0; 10cec2: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax) information->inactive_per_block = 0; 10cec9: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax) information->object_blocks = 0; 10ced0: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax) information->inactive = 0; 10ced7: 66 c7 40 2c 00 00 movw $0x0,0x2c(%eax) #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) information->is_string = is_string; 10cedd: 8b 7d 1c mov 0x1c(%ebp),%edi 10cee0: 89 f9 mov %edi,%ecx 10cee2: 88 48 38 mov %cl,0x38(%eax) /* * Set the maximum value to 0. It will be updated when objects are * added to the inactive set from _Objects_Extend_information() */ information->maximum = 0; 10cee5: 66 c7 40 10 00 00 movw $0x0,0x10(%eax) /* * Register this Object Class in the Object Information Table. */ _Objects_Information_table[ the_api ][ the_class ] = information; 10ceeb: 0f b7 db movzwl %bx,%ebx 10ceee: 8b 3c 95 68 7d 12 00 mov 0x127d68(,%edx,4),%edi 10cef5: 89 04 9f mov %eax,(%edi,%ebx,4) /* * Are we operating in limited or unlimited (e.g. auto-extend) mode. */ information->auto_extend = (maximum & OBJECTS_UNLIMITED_OBJECTS) ? true : false; 10cef8: 8b 7d 14 mov 0x14(%ebp),%edi 10cefb: c1 ef 1f shr $0x1f,%edi _Objects_Information_table[ the_api ][ the_class ] = information; /* * Are we operating in limited or unlimited (e.g. auto-extend) mode. */ information->auto_extend = 10cefe: 89 f9 mov %edi,%ecx 10cf00: 88 48 12 mov %cl,0x12(%eax) (maximum & OBJECTS_UNLIMITED_OBJECTS) ? true : false; maximum_per_allocation = maximum & ~OBJECTS_UNLIMITED_OBJECTS; 10cf03: 8b 4d 14 mov 0x14(%ebp),%ecx 10cf06: 81 e1 ff ff ff 7f and $0x7fffffff,%ecx /* * Unlimited and maximum of zero is illogical. */ if ( information->auto_extend && maximum_per_allocation == 0) { 10cf0c: 85 ff test %edi,%edi 10cf0e: 74 04 je 10cf14 <_Objects_Initialize_information+0x74> 10cf10: 85 c9 test %ecx,%ecx 10cf12: 74 57 je 10cf6b <_Objects_Initialize_information+0xcb><== NEVER TAKEN } /* * The allocation unit is the maximum value */ information->allocation_size = maximum_per_allocation; 10cf14: 66 89 48 14 mov %cx,0x14(%eax) /* * Provide a null local table entry for the case of any empty table. */ information->local_table = &null_local_table; 10cf18: c7 40 1c 04 7a 12 00 movl $0x127a04,0x1c(%eax) uint32_t the_class, uint32_t node, uint32_t index ) { return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) | 10cf1f: c1 e2 18 shl $0x18,%edx 10cf22: 81 ca 00 00 01 00 or $0x10000,%edx (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) | 10cf28: c1 e3 1b shl $0x1b,%ebx 10cf2b: 09 da or %ebx,%edx /* * Calculate minimum and maximum Id's */ minimum_index = (maximum_per_allocation == 0) ? 0 : 1; 10cf2d: 31 db xor %ebx,%ebx 10cf2f: 85 c9 test %ecx,%ecx 10cf31: 0f 95 c3 setne %bl uint32_t the_class, uint32_t node, uint32_t index ) { return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) | 10cf34: 09 da or %ebx,%edx 10cf36: 89 50 08 mov %edx,0x8(%eax) if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) ) name_length = (name_length + OBJECTS_NAME_ALIGNMENT) & ~(OBJECTS_NAME_ALIGNMENT-1); #endif information->name_length = name_length; 10cf39: 66 89 70 3a mov %si,0x3a(%eax) RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); 10cf3d: 8d 50 24 lea 0x24(%eax),%edx 10cf40: 89 50 20 mov %edx,0x20(%eax) head->next = tail; head->previous = NULL; 10cf43: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax) */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); 10cf4a: 8d 50 20 lea 0x20(%eax),%edx 10cf4d: 89 50 28 mov %edx,0x28(%eax) _Chain_Initialize_empty( &information->Inactive ); /* * Initialize objects .. if there are any */ if ( maximum_per_allocation ) { 10cf50: 85 c9 test %ecx,%ecx 10cf52: 75 08 jne 10cf5c <_Objects_Initialize_information+0xbc> _Chain_Initialize_empty( &information->global_table[ index ] ); } else information->global_table = NULL; #endif } 10cf54: 8d 65 f4 lea -0xc(%ebp),%esp 10cf57: 5b pop %ebx 10cf58: 5e pop %esi 10cf59: 5f pop %edi 10cf5a: c9 leave 10cf5b: c3 ret /* * Always have the maximum size available so the current performance * figures are create are met. If the user moves past the maximum * number then a performance hit is taken. */ _Objects_Extend_information( information ); 10cf5c: 89 45 08 mov %eax,0x8(%ebp) _Chain_Initialize_empty( &information->global_table[ index ] ); } else information->global_table = NULL; #endif } 10cf5f: 8d 65 f4 lea -0xc(%ebp),%esp 10cf62: 5b pop %ebx 10cf63: 5e pop %esi 10cf64: 5f pop %edi 10cf65: c9 leave /* * Always have the maximum size available so the current performance * figures are create are met. If the user moves past the maximum * number then a performance hit is taken. */ _Objects_Extend_information( information ); 10cf66: e9 bd fa ff ff jmp 10ca28 <_Objects_Extend_information> /* * Unlimited and maximum of zero is illogical. */ if ( information->auto_extend && maximum_per_allocation == 0) { _Internal_error_Occurred( 10cf6b: 50 push %eax 10cf6c: 6a 13 push $0x13 10cf6e: 6a 01 push $0x1 10cf70: 6a 00 push $0x0 10cf72: e8 7d f9 ff ff call 10c8f4 <_Internal_error_Occurred> =============================================================================== 00117994 <_Objects_Name_to_id_string>: Objects_Name_or_id_lookup_errors _Objects_Name_to_id_string( Objects_Information *information, const char *name, Objects_Id *id ) { 117994: 55 push %ebp 117995: 89 e5 mov %esp,%ebp 117997: 57 push %edi 117998: 56 push %esi 117999: 53 push %ebx 11799a: 83 ec 1c sub $0x1c,%esp 11799d: 8b 7d 08 mov 0x8(%ebp),%edi Objects_Control *the_object; uint32_t index; /* ASSERT: information->is_string == true */ if ( !id ) 1179a0: 8b 5d 10 mov 0x10(%ebp),%ebx 1179a3: 85 db test %ebx,%ebx 1179a5: 74 75 je 117a1c <_Objects_Name_to_id_string+0x88> return OBJECTS_INVALID_ADDRESS; if ( !name ) 1179a7: 8b 4d 0c mov 0xc(%ebp),%ecx 1179aa: 85 c9 test %ecx,%ecx 1179ac: 74 4b je 1179f9 <_Objects_Name_to_id_string+0x65> return OBJECTS_INVALID_NAME; if ( information->maximum != 0 ) { 1179ae: 8b 47 10 mov 0x10(%edi),%eax 1179b1: 66 85 c0 test %ax,%ax 1179b4: 74 43 je 1179f9 <_Objects_Name_to_id_string+0x65> for ( index = 1; index <= information->maximum; index++ ) { 1179b6: 0f b7 c0 movzwl %ax,%eax 1179b9: 89 45 e4 mov %eax,-0x1c(%ebp) 1179bc: 8b 47 1c mov 0x1c(%edi),%eax 1179bf: bb 01 00 00 00 mov $0x1,%ebx 1179c4: 89 7d e0 mov %edi,-0x20(%ebp) 1179c7: 89 c7 mov %eax,%edi 1179c9: 8d 76 00 lea 0x0(%esi),%esi the_object = information->local_table[ index ]; 1179cc: 8b 34 9f mov (%edi,%ebx,4),%esi if ( !the_object ) 1179cf: 85 f6 test %esi,%esi 1179d1: 74 20 je 1179f3 <_Objects_Name_to_id_string+0x5f> continue; if ( !the_object->name.name_p ) 1179d3: 8b 46 0c mov 0xc(%esi),%eax 1179d6: 85 c0 test %eax,%eax 1179d8: 74 19 je 1179f3 <_Objects_Name_to_id_string+0x5f> continue; if (!strncmp( name, the_object->name.name_p, information->name_length)) { 1179da: 52 push %edx 1179db: 8b 4d e0 mov -0x20(%ebp),%ecx 1179de: 0f b7 51 3a movzwl 0x3a(%ecx),%edx 1179e2: 52 push %edx 1179e3: 50 push %eax 1179e4: ff 75 0c pushl 0xc(%ebp) 1179e7: e8 a0 34 00 00 call 11ae8c 1179ec: 83 c4 10 add $0x10,%esp 1179ef: 85 c0 test %eax,%eax 1179f1: 74 15 je 117a08 <_Objects_Name_to_id_string+0x74> if ( !name ) return OBJECTS_INVALID_NAME; if ( information->maximum != 0 ) { for ( index = 1; index <= information->maximum; index++ ) { 1179f3: 43 inc %ebx 1179f4: 3b 5d e4 cmp -0x1c(%ebp),%ebx 1179f7: 76 d3 jbe 1179cc <_Objects_Name_to_id_string+0x38> return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; } } } return OBJECTS_INVALID_NAME; 1179f9: b8 01 00 00 00 mov $0x1,%eax } 1179fe: 8d 65 f4 lea -0xc(%ebp),%esp 117a01: 5b pop %ebx 117a02: 5e pop %esi 117a03: 5f pop %edi 117a04: c9 leave 117a05: c3 ret 117a06: 66 90 xchg %ax,%ax if ( !the_object->name.name_p ) continue; if (!strncmp( name, the_object->name.name_p, information->name_length)) { *id = the_object->id; 117a08: 8b 46 08 mov 0x8(%esi),%eax 117a0b: 8b 55 10 mov 0x10(%ebp),%edx 117a0e: 89 02 mov %eax,(%edx) return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; 117a10: 31 c0 xor %eax,%eax } } } return OBJECTS_INVALID_NAME; } 117a12: 8d 65 f4 lea -0xc(%ebp),%esp 117a15: 5b pop %ebx 117a16: 5e pop %esi 117a17: 5f pop %edi 117a18: c9 leave 117a19: c3 ret 117a1a: 66 90 xchg %ax,%ax uint32_t index; /* ASSERT: information->is_string == true */ if ( !id ) return OBJECTS_INVALID_ADDRESS; 117a1c: b8 02 00 00 00 mov $0x2,%eax } } } return OBJECTS_INVALID_NAME; } 117a21: 8d 65 f4 lea -0xc(%ebp),%esp 117a24: 5b pop %ebx 117a25: 5e pop %esi 117a26: 5f pop %edi 117a27: c9 leave 117a28: c3 ret =============================================================================== 0010cfa8 <_Objects_Name_to_id_u32>: Objects_Information *information, uint32_t name, uint32_t node, Objects_Id *id ) { 10cfa8: 55 push %ebp 10cfa9: 89 e5 mov %esp,%ebp 10cfab: 57 push %edi 10cfac: 56 push %esi 10cfad: 53 push %ebx 10cfae: 8b 45 08 mov 0x8(%ebp),%eax 10cfb1: 8b 4d 0c mov 0xc(%ebp),%ecx 10cfb4: 8b 55 10 mov 0x10(%ebp),%edx 10cfb7: 8b 7d 14 mov 0x14(%ebp),%edi Objects_Name name_for_mp; #endif /* ASSERT: information->is_string == false */ if ( !id ) 10cfba: 85 ff test %edi,%edi 10cfbc: 74 56 je 10d014 <_Objects_Name_to_id_u32+0x6c> return OBJECTS_INVALID_ADDRESS; if ( name == 0 ) 10cfbe: 85 c9 test %ecx,%ecx 10cfc0: 74 08 je 10cfca <_Objects_Name_to_id_u32+0x22> return OBJECTS_INVALID_NAME; search_local_node = false; if ( information->maximum != 0 && 10cfc2: 8b 70 10 mov 0x10(%eax),%esi 10cfc5: 66 85 f6 test %si,%si 10cfc8: 75 0a jne 10cfd4 <_Objects_Name_to_id_u32+0x2c> return OBJECTS_INVALID_NAME; name_for_mp.name_u32 = name; return _Objects_MP_Global_name_search( information, name_for_mp, node, id ); #else return OBJECTS_INVALID_NAME; 10cfca: b8 01 00 00 00 mov $0x1,%eax #endif } 10cfcf: 5b pop %ebx 10cfd0: 5e pop %esi 10cfd1: 5f pop %edi 10cfd2: c9 leave 10cfd3: c3 ret if ( name == 0 ) return OBJECTS_INVALID_NAME; search_local_node = false; if ( information->maximum != 0 && 10cfd4: 85 d2 test %edx,%edx 10cfd6: 75 20 jne 10cff8 <_Objects_Name_to_id_u32+0x50> _Objects_Is_local_node( node ) )) search_local_node = true; if ( search_local_node ) { for ( index = 1; index <= information->maximum; index++ ) { 10cfd8: 0f b7 f6 movzwl %si,%esi 10cfdb: 8b 58 1c mov 0x1c(%eax),%ebx 10cfde: b8 01 00 00 00 mov $0x1,%eax 10cfe3: 90 nop the_object = information->local_table[ index ]; 10cfe4: 8b 14 83 mov (%ebx,%eax,4),%edx if ( !the_object ) 10cfe7: 85 d2 test %edx,%edx 10cfe9: 74 05 je 10cff0 <_Objects_Name_to_id_u32+0x48> continue; if ( name == the_object->name.name_u32 ) { 10cfeb: 39 4a 0c cmp %ecx,0xc(%edx) 10cfee: 74 18 je 10d008 <_Objects_Name_to_id_u32+0x60> _Objects_Is_local_node( node ) )) search_local_node = true; if ( search_local_node ) { for ( index = 1; index <= information->maximum; index++ ) { 10cff0: 40 inc %eax 10cff1: 39 c6 cmp %eax,%esi 10cff3: 73 ef jae 10cfe4 <_Objects_Name_to_id_u32+0x3c> 10cff5: eb d3 jmp 10cfca <_Objects_Name_to_id_u32+0x22> 10cff7: 90 nop return OBJECTS_INVALID_NAME; search_local_node = false; if ( information->maximum != 0 && (node == OBJECTS_SEARCH_ALL_NODES || 10cff8: 81 fa ff ff ff 7f cmp $0x7fffffff,%edx 10cffe: 74 d8 je 10cfd8 <_Objects_Name_to_id_u32+0x30> node == OBJECTS_SEARCH_LOCAL_NODE || 10d000: 4a dec %edx 10d001: 75 c7 jne 10cfca <_Objects_Name_to_id_u32+0x22> 10d003: eb d3 jmp 10cfd8 <_Objects_Name_to_id_u32+0x30> 10d005: 8d 76 00 lea 0x0(%esi),%esi the_object = information->local_table[ index ]; if ( !the_object ) continue; if ( name == the_object->name.name_u32 ) { *id = the_object->id; 10d008: 8b 42 08 mov 0x8(%edx),%eax 10d00b: 89 07 mov %eax,(%edi) return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; 10d00d: 31 c0 xor %eax,%eax name_for_mp.name_u32 = name; return _Objects_MP_Global_name_search( information, name_for_mp, node, id ); #else return OBJECTS_INVALID_NAME; #endif } 10d00f: 5b pop %ebx 10d010: 5e pop %esi 10d011: 5f pop %edi 10d012: c9 leave 10d013: c3 ret #endif /* ASSERT: information->is_string == false */ if ( !id ) return OBJECTS_INVALID_ADDRESS; 10d014: b8 02 00 00 00 mov $0x2,%eax name_for_mp.name_u32 = name; return _Objects_MP_Global_name_search( information, name_for_mp, node, id ); #else return OBJECTS_INVALID_NAME; #endif } 10d019: 5b pop %ebx 10d01a: 5e pop %esi 10d01b: 5f pop %edi 10d01c: c9 leave 10d01d: c3 ret =============================================================================== 0010d690 <_Objects_Set_name>: bool _Objects_Set_name( Objects_Information *information, Objects_Control *the_object, const char *name ) { 10d690: 55 push %ebp 10d691: 89 e5 mov %esp,%ebp 10d693: 57 push %edi 10d694: 56 push %esi 10d695: 53 push %ebx 10d696: 83 ec 14 sub $0x14,%esp 10d699: 8b 7d 08 mov 0x8(%ebp),%edi 10d69c: 8b 5d 10 mov 0x10(%ebp),%ebx size_t length; const char *s; s = name; length = strnlen( name, information->name_length ); 10d69f: 0f b7 47 3a movzwl 0x3a(%edi),%eax 10d6a3: 50 push %eax 10d6a4: 53 push %ebx 10d6a5: e8 8e 79 00 00 call 115038 10d6aa: 89 c6 mov %eax,%esi #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) if ( information->is_string ) { 10d6ac: 83 c4 10 add $0x10,%esp 10d6af: 80 7f 38 00 cmpb $0x0,0x38(%edi) 10d6b3: 75 57 jne 10d70c <_Objects_Set_name+0x7c> d[length] = '\0'; the_object->name.name_p = d; } else #endif { the_object->name.name_u32 = _Objects_Build_name( 10d6b5: 0f be 13 movsbl (%ebx),%edx 10d6b8: c1 e2 18 shl $0x18,%edx 10d6bb: 83 f8 01 cmp $0x1,%eax 10d6be: 76 38 jbe 10d6f8 <_Objects_Set_name+0x68> 10d6c0: 0f be 43 01 movsbl 0x1(%ebx),%eax 10d6c4: c1 e0 10 shl $0x10,%eax 10d6c7: 09 d0 or %edx,%eax 10d6c9: 83 fe 02 cmp $0x2,%esi 10d6cc: 74 31 je 10d6ff <_Objects_Set_name+0x6f> 10d6ce: 0f be 53 02 movsbl 0x2(%ebx),%edx 10d6d2: c1 e2 08 shl $0x8,%edx 10d6d5: 09 c2 or %eax,%edx 10d6d7: 83 fe 03 cmp $0x3,%esi 10d6da: 0f 84 80 00 00 00 je 10d760 <_Objects_Set_name+0xd0> 10d6e0: 0f be 43 03 movsbl 0x3(%ebx),%eax 10d6e4: 09 c2 or %eax,%edx 10d6e6: 8b 45 0c mov 0xc(%ebp),%eax 10d6e9: 89 50 0c mov %edx,0xc(%eax) ((3 < length) ? s[ 3 ] : ' ') ); } return true; 10d6ec: b0 01 mov $0x1,%al } 10d6ee: 8d 65 f4 lea -0xc(%ebp),%esp 10d6f1: 5b pop %ebx 10d6f2: 5e pop %esi 10d6f3: 5f pop %edi 10d6f4: c9 leave 10d6f5: c3 ret 10d6f6: 66 90 xchg %ax,%ax d[length] = '\0'; the_object->name.name_p = d; } else #endif { the_object->name.name_u32 = _Objects_Build_name( 10d6f8: 89 d0 mov %edx,%eax 10d6fa: 0d 00 00 20 00 or $0x200000,%eax 10d6ff: 89 c2 mov %eax,%edx 10d701: 80 ce 20 or $0x20,%dh 10d704: b8 20 00 00 00 mov $0x20,%eax 10d709: eb d9 jmp 10d6e4 <_Objects_Set_name+0x54> 10d70b: 90 nop #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) if ( information->is_string ) { char *d; d = _Workspace_Allocate( length + 1 ); 10d70c: 83 ec 0c sub $0xc,%esp 10d70f: 8d 40 01 lea 0x1(%eax),%eax 10d712: 50 push %eax 10d713: e8 bc 19 00 00 call 10f0d4 <_Workspace_Allocate> 10d718: 89 c7 mov %eax,%edi if ( !d ) 10d71a: 83 c4 10 add $0x10,%esp 10d71d: 85 c0 test %eax,%eax 10d71f: 74 3b je 10d75c <_Objects_Set_name+0xcc> return false; _Workspace_Free( (void *)the_object->name.name_p ); 10d721: 83 ec 0c sub $0xc,%esp 10d724: 8b 45 0c mov 0xc(%ebp),%eax 10d727: ff 70 0c pushl 0xc(%eax) 10d72a: e8 c1 19 00 00 call 10f0f0 <_Workspace_Free> the_object->name.name_p = NULL; 10d72f: 8b 45 0c mov 0xc(%ebp),%eax 10d732: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) strncpy( d, name, length ); 10d739: 83 c4 0c add $0xc,%esp 10d73c: 56 push %esi 10d73d: 53 push %ebx 10d73e: 57 push %edi 10d73f: e8 78 78 00 00 call 114fbc d[length] = '\0'; 10d744: c6 04 37 00 movb $0x0,(%edi,%esi,1) the_object->name.name_p = d; 10d748: 8b 45 0c mov 0xc(%ebp),%eax 10d74b: 89 78 0c mov %edi,0xc(%eax) 10d74e: 83 c4 10 add $0x10,%esp ((3 < length) ? s[ 3 ] : ' ') ); } return true; 10d751: b0 01 mov $0x1,%al } 10d753: 8d 65 f4 lea -0xc(%ebp),%esp 10d756: 5b pop %ebx 10d757: 5e pop %esi 10d758: 5f pop %edi 10d759: c9 leave 10d75a: c3 ret 10d75b: 90 nop if ( information->is_string ) { char *d; d = _Workspace_Allocate( length + 1 ); if ( !d ) return false; 10d75c: 31 c0 xor %eax,%eax 10d75e: eb 8e jmp 10d6ee <_Objects_Set_name+0x5e> d[length] = '\0'; the_object->name.name_p = d; } else #endif { the_object->name.name_u32 = _Objects_Build_name( 10d760: b8 20 00 00 00 mov $0x20,%eax 10d765: e9 7a ff ff ff jmp 10d6e4 <_Objects_Set_name+0x54> =============================================================================== 0010d020 <_Objects_Shrink_information>: */ void _Objects_Shrink_information( Objects_Information *information ) { 10d020: 55 push %ebp 10d021: 89 e5 mov %esp,%ebp 10d023: 57 push %edi 10d024: 56 push %esi 10d025: 53 push %ebx 10d026: 83 ec 1c sub $0x1c,%esp /* * Search the list to find block or chunk with all objects inactive. */ index_base = _Objects_Get_index( information->minimum_id ); 10d029: 8b 45 08 mov 0x8(%ebp),%eax 10d02c: 0f b7 58 08 movzwl 0x8(%eax),%ebx block_count = (information->maximum - index_base) / 10d030: 0f b7 48 14 movzwl 0x14(%eax),%ecx 10d034: 0f b7 40 10 movzwl 0x10(%eax),%eax 10d038: 29 d8 sub %ebx,%eax 10d03a: 31 d2 xor %edx,%edx 10d03c: f7 f1 div %ecx information->allocation_size; for ( block = 0; block < block_count; block++ ) { 10d03e: 85 c0 test %eax,%eax 10d040: 74 21 je 10d063 <_Objects_Shrink_information+0x43><== NEVER TAKEN if ( information->inactive_per_block[ block ] == 10d042: 8b 55 08 mov 0x8(%ebp),%edx 10d045: 8b 72 30 mov 0x30(%edx),%esi 10d048: 3b 0e cmp (%esi),%ecx 10d04a: 74 1f je 10d06b <_Objects_Shrink_information+0x4b><== NEVER TAKEN 10d04c: 31 d2 xor %edx,%edx 10d04e: eb 0e jmp 10d05e <_Objects_Shrink_information+0x3e> information->inactive -= information->allocation_size; return; } index_base += information->allocation_size; 10d050: 01 cb add %ecx,%ebx 10d052: 8d 3c 95 00 00 00 00 lea 0x0(,%edx,4),%edi index_base = _Objects_Get_index( information->minimum_id ); block_count = (information->maximum - index_base) / information->allocation_size; for ( block = 0; block < block_count; block++ ) { if ( information->inactive_per_block[ block ] == 10d059: 3b 0c 96 cmp (%esi,%edx,4),%ecx 10d05c: 74 12 je 10d070 <_Objects_Shrink_information+0x50> index_base = _Objects_Get_index( information->minimum_id ); block_count = (information->maximum - index_base) / information->allocation_size; for ( block = 0; block < block_count; block++ ) { 10d05e: 42 inc %edx 10d05f: 39 d0 cmp %edx,%eax 10d061: 77 ed ja 10d050 <_Objects_Shrink_information+0x30> return; } index_base += information->allocation_size; } } 10d063: 8d 65 f4 lea -0xc(%ebp),%esp 10d066: 5b pop %ebx 10d067: 5e pop %esi 10d068: 5f pop %edi 10d069: c9 leave 10d06a: c3 ret index_base = _Objects_Get_index( information->minimum_id ); block_count = (information->maximum - index_base) / information->allocation_size; for ( block = 0; block < block_count; block++ ) { if ( information->inactive_per_block[ block ] == 10d06b: 31 ff xor %edi,%edi <== NOT EXECUTED 10d06d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED information->allocation_size ) { /* * Assume the Inactive chain is never empty at this point */ the_object = (Objects_Control *) _Chain_First( &information->Inactive ); 10d070: 8b 55 08 mov 0x8(%ebp),%edx 10d073: 8b 42 20 mov 0x20(%edx),%eax 10d076: 89 7d e4 mov %edi,-0x1c(%ebp) 10d079: eb 07 jmp 10d082 <_Objects_Shrink_information+0x62> 10d07b: 90 nop if ((index >= index_base) && (index < (index_base + information->allocation_size))) { _Chain_Extract( &extract_me->Node ); } } while ( the_object ); 10d07c: 85 f6 test %esi,%esi 10d07e: 74 2c je 10d0ac <_Objects_Shrink_information+0x8c> index = _Objects_Get_index( the_object->id ); /* * Get the next node before the node is extracted */ extract_me = the_object; the_object = (Objects_Control *) the_object->Node.next; 10d080: 89 f0 mov %esi,%eax * Assume the Inactive chain is never empty at this point */ the_object = (Objects_Control *) _Chain_First( &information->Inactive ); do { index = _Objects_Get_index( the_object->id ); 10d082: 0f b7 50 08 movzwl 0x8(%eax),%edx /* * Get the next node before the node is extracted */ extract_me = the_object; the_object = (Objects_Control *) the_object->Node.next; 10d086: 8b 30 mov (%eax),%esi if ((index >= index_base) && 10d088: 39 da cmp %ebx,%edx 10d08a: 72 f0 jb 10d07c <_Objects_Shrink_information+0x5c> (index < (index_base + information->allocation_size))) { 10d08c: 8b 7d 08 mov 0x8(%ebp),%edi 10d08f: 0f b7 4f 14 movzwl 0x14(%edi),%ecx 10d093: 8d 0c 0b lea (%ebx,%ecx,1),%ecx /* * Get the next node before the node is extracted */ extract_me = the_object; the_object = (Objects_Control *) the_object->Node.next; if ((index >= index_base) && 10d096: 39 ca cmp %ecx,%edx 10d098: 73 e2 jae 10d07c <_Objects_Shrink_information+0x5c> (index < (index_base + information->allocation_size))) { _Chain_Extract( &extract_me->Node ); 10d09a: 83 ec 0c sub $0xc,%esp 10d09d: 50 push %eax 10d09e: e8 59 ef ff ff call 10bffc <_Chain_Extract> 10d0a3: 83 c4 10 add $0x10,%esp } } while ( the_object ); 10d0a6: 85 f6 test %esi,%esi 10d0a8: 75 d6 jne 10d080 <_Objects_Shrink_information+0x60> 10d0aa: 66 90 xchg %ax,%ax 10d0ac: 8b 7d e4 mov -0x1c(%ebp),%edi /* * Free the memory and reset the structures in the object' information */ _Workspace_Free( information->object_blocks[ block ] ); 10d0af: 83 ec 0c sub $0xc,%esp 10d0b2: 8b 55 08 mov 0x8(%ebp),%edx 10d0b5: 8b 42 34 mov 0x34(%edx),%eax 10d0b8: ff 34 38 pushl (%eax,%edi,1) 10d0bb: e8 e4 18 00 00 call 10e9a4 <_Workspace_Free> information->object_blocks[ block ] = NULL; 10d0c0: 8b 55 08 mov 0x8(%ebp),%edx 10d0c3: 8b 42 34 mov 0x34(%edx),%eax 10d0c6: c7 04 38 00 00 00 00 movl $0x0,(%eax,%edi,1) information->inactive_per_block[ block ] = 0; 10d0cd: 8b 42 30 mov 0x30(%edx),%eax 10d0d0: c7 04 38 00 00 00 00 movl $0x0,(%eax,%edi,1) information->inactive -= information->allocation_size; 10d0d7: 8b 42 14 mov 0x14(%edx),%eax 10d0da: 66 29 42 2c sub %ax,0x2c(%edx) return; 10d0de: 83 c4 10 add $0x10,%esp } index_base += information->allocation_size; } } 10d0e1: 8d 65 f4 lea -0xc(%ebp),%esp 10d0e4: 5b pop %ebx 10d0e5: 5e pop %esi 10d0e6: 5f pop %edi 10d0e7: c9 leave 10d0e8: c3 ret =============================================================================== 0010d524 <_POSIX_Absolute_timeout_to_ticks>: */ POSIX_Absolute_timeout_conversion_results_t _POSIX_Absolute_timeout_to_ticks( const struct timespec *abstime, Watchdog_Interval *ticks_out ) { 10d524: 55 push %ebp 10d525: 89 e5 mov %esp,%ebp 10d527: 57 push %edi 10d528: 56 push %esi 10d529: 53 push %ebx 10d52a: 83 ec 38 sub $0x38,%esp 10d52d: 8b 5d 08 mov 0x8(%ebp),%ebx 10d530: 8b 75 0c mov 0xc(%ebp),%esi /* * Make sure there is always a value returned. */ *ticks_out = 0; 10d533: c7 06 00 00 00 00 movl $0x0,(%esi) /* * Is the absolute time even valid? */ if ( !_Timespec_Is_valid(abstime) ) 10d539: 53 push %ebx 10d53a: e8 c1 3d 00 00 call 111300 <_Timespec_Is_valid> 10d53f: 83 c4 10 add $0x10,%esp 10d542: 84 c0 test %al,%al 10d544: 75 0a jne 10d550 <_POSIX_Absolute_timeout_to_ticks+0x2c> return POSIX_ABSOLUTE_TIMEOUT_INVALID; 10d546: 31 c0 xor %eax,%eax /* * This is the case we were expecting and it took this long to * get here. */ return POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE; } 10d548: 8d 65 f4 lea -0xc(%ebp),%esp 10d54b: 5b pop %ebx 10d54c: 5e pop %esi 10d54d: 5f pop %edi 10d54e: c9 leave 10d54f: c3 ret return POSIX_ABSOLUTE_TIMEOUT_INVALID; /* * Is the absolute time in the past? */ _TOD_Get( ¤t_time ); 10d550: 83 ec 0c sub $0xc,%esp 10d553: 8d 7d e0 lea -0x20(%ebp),%edi 10d556: 57 push %edi 10d557: e8 84 1d 00 00 call 10f2e0 <_TOD_Get> if ( _Timespec_Less_than( abstime, ¤t_time ) ) 10d55c: 5a pop %edx 10d55d: 59 pop %ecx 10d55e: 57 push %edi 10d55f: 53 push %ebx 10d560: e8 c3 3d 00 00 call 111328 <_Timespec_Less_than> 10d565: 83 c4 10 add $0x10,%esp 10d568: 84 c0 test %al,%al 10d56a: 74 10 je 10d57c <_POSIX_Absolute_timeout_to_ticks+0x58> return POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST; 10d56c: b8 01 00 00 00 mov $0x1,%eax /* * This is the case we were expecting and it took this long to * get here. */ return POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE; } 10d571: 8d 65 f4 lea -0xc(%ebp),%esp 10d574: 5b pop %ebx 10d575: 5e pop %esi 10d576: 5f pop %edi 10d577: c9 leave 10d578: c3 ret 10d579: 8d 76 00 lea 0x0(%esi),%esi return POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST; /* * How long until the requested absolute time? */ _Timespec_Subtract( ¤t_time, abstime, &difference ); 10d57c: 50 push %eax 10d57d: 8d 45 d8 lea -0x28(%ebp),%eax 10d580: 50 push %eax 10d581: 53 push %ebx 10d582: 57 push %edi 10d583: 89 45 d4 mov %eax,-0x2c(%ebp) 10d586: e8 c1 3d 00 00 call 11134c <_Timespec_Subtract> /* * Internally the SuperCore uses ticks, so convert to them. */ *ticks_out = _Timespec_To_ticks( &difference ); 10d58b: 8b 45 d4 mov -0x2c(%ebp),%eax 10d58e: 89 04 24 mov %eax,(%esp) 10d591: e8 f6 3d 00 00 call 11138c <_Timespec_To_ticks> 10d596: 89 06 mov %eax,(%esi) /* * If the difference was 0, then the future is now. It is so bright * we better wear shades. */ if ( !*ticks_out ) 10d598: 83 c4 10 add $0x10,%esp return POSIX_ABSOLUTE_TIMEOUT_IS_NOW; 10d59b: 83 f8 01 cmp $0x1,%eax 10d59e: 19 c0 sbb %eax,%eax 10d5a0: 83 c0 03 add $0x3,%eax /* * This is the case we were expecting and it took this long to * get here. */ return POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE; } 10d5a3: 8d 65 f4 lea -0xc(%ebp),%esp 10d5a6: 5b pop %ebx 10d5a7: 5e pop %esi 10d5a8: 5f pop %edi 10d5a9: c9 leave 10d5aa: c3 ret =============================================================================== 0010c0cc <_POSIX_Condition_variables_Get>: POSIX_Condition_variables_Control *_POSIX_Condition_variables_Get ( pthread_cond_t *cond, Objects_Locations *location ) { 10c0cc: 55 push %ebp 10c0cd: 89 e5 mov %esp,%ebp 10c0cf: 56 push %esi 10c0d0: 53 push %ebx 10c0d1: 8b 5d 08 mov 0x8(%ebp),%ebx 10c0d4: 8b 75 0c mov 0xc(%ebp),%esi int status; if ( !cond ) { 10c0d7: 85 db test %ebx,%ebx 10c0d9: 74 39 je 10c114 <_POSIX_Condition_variables_Get+0x48> *location = OBJECTS_ERROR; return (POSIX_Condition_variables_Control *) 0; } if ( *cond == PTHREAD_COND_INITIALIZER ) { 10c0db: 8b 03 mov (%ebx),%eax 10c0dd: 83 f8 ff cmp $0xffffffff,%eax 10c0e0: 74 1a je 10c0fc <_POSIX_Condition_variables_Get+0x30> } /* * Now call Objects_Get() */ return (POSIX_Condition_variables_Control *)_Objects_Get( 10c0e2: 52 push %edx 10c0e3: 56 push %esi 10c0e4: 50 push %eax 10c0e5: 68 40 9a 12 00 push $0x129a40 10c0ea: e8 75 2b 00 00 call 10ec64 <_Objects_Get> 10c0ef: 83 c4 10 add $0x10,%esp &_POSIX_Condition_variables_Information, (Objects_Id) *cond, location ); } 10c0f2: 8d 65 f8 lea -0x8(%ebp),%esp 10c0f5: 5b pop %ebx 10c0f6: 5e pop %esi 10c0f7: c9 leave 10c0f8: c3 ret 10c0f9: 8d 76 00 lea 0x0(%esi),%esi if ( *cond == PTHREAD_COND_INITIALIZER ) { /* * Do an "auto-create" here. */ status = pthread_cond_init( cond, 0 ); 10c0fc: 83 ec 08 sub $0x8,%esp 10c0ff: 6a 00 push $0x0 10c101: 53 push %ebx 10c102: e8 19 00 00 00 call 10c120 if ( status ) { 10c107: 83 c4 10 add $0x10,%esp 10c10a: 85 c0 test %eax,%eax 10c10c: 75 06 jne 10c114 <_POSIX_Condition_variables_Get+0x48> 10c10e: 8b 03 mov (%ebx),%eax 10c110: eb d0 jmp 10c0e2 <_POSIX_Condition_variables_Get+0x16> 10c112: 66 90 xchg %ax,%ax *location = OBJECTS_ERROR; 10c114: c7 06 01 00 00 00 movl $0x1,(%esi) return (POSIX_Condition_variables_Control *) 0; 10c11a: 31 c0 xor %eax,%eax 10c11c: eb d4 jmp 10c0f2 <_POSIX_Condition_variables_Get+0x26> =============================================================================== 0010c1e8 <_POSIX_Condition_variables_Signal_support>: int _POSIX_Condition_variables_Signal_support( pthread_cond_t *cond, bool is_broadcast ) { 10c1e8: 55 push %ebp 10c1e9: 89 e5 mov %esp,%ebp 10c1eb: 57 push %edi 10c1ec: 56 push %esi 10c1ed: 53 push %ebx 10c1ee: 83 ec 24 sub $0x24,%esp 10c1f1: 8a 5d 0c mov 0xc(%ebp),%bl register POSIX_Condition_variables_Control *the_cond; Objects_Locations location; Thread_Control *the_thread; the_cond = _POSIX_Condition_variables_Get( cond, &location ); 10c1f4: 8d 45 e4 lea -0x1c(%ebp),%eax 10c1f7: 50 push %eax 10c1f8: ff 75 08 pushl 0x8(%ebp) 10c1fb: e8 cc fe ff ff call 10c0cc <_POSIX_Condition_variables_Get> 10c200: 89 c7 mov %eax,%edi switch ( location ) { 10c202: 83 c4 10 add $0x10,%esp 10c205: 8b 45 e4 mov -0x1c(%ebp),%eax 10c208: 85 c0 test %eax,%eax 10c20a: 74 10 je 10c21c <_POSIX_Condition_variables_Signal_support+0x34> #endif case OBJECTS_ERROR: break; } return EINVAL; 10c20c: b8 16 00 00 00 mov $0x16,%eax } 10c211: 8d 65 f4 lea -0xc(%ebp),%esp 10c214: 5b pop %ebx 10c215: 5e pop %esi 10c216: 5f pop %edi 10c217: c9 leave 10c218: c3 ret 10c219: 8d 76 00 lea 0x0(%esi),%esi 10c21c: 8d 77 18 lea 0x18(%edi),%esi 10c21f: eb 0b jmp 10c22c <_POSIX_Condition_variables_Signal_support+0x44> 10c221: 8d 76 00 lea 0x0(%esi),%esi case OBJECTS_LOCAL: do { the_thread = _Thread_queue_Dequeue( &the_cond->Wait_queue ); if ( !the_thread ) the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX; } while ( is_broadcast && the_thread ); 10c224: 84 db test %bl,%bl 10c226: 74 20 je 10c248 <_POSIX_Condition_variables_Signal_support+0x60> 10c228: 85 c0 test %eax,%eax 10c22a: 74 1c je 10c248 <_POSIX_Condition_variables_Signal_support+0x60> the_cond = _POSIX_Condition_variables_Get( cond, &location ); switch ( location ) { case OBJECTS_LOCAL: do { the_thread = _Thread_queue_Dequeue( &the_cond->Wait_queue ); 10c22c: 83 ec 0c sub $0xc,%esp 10c22f: 56 push %esi 10c230: e8 23 39 00 00 call 10fb58 <_Thread_queue_Dequeue> if ( !the_thread ) 10c235: 83 c4 10 add $0x10,%esp 10c238: 85 c0 test %eax,%eax 10c23a: 75 e8 jne 10c224 <_POSIX_Condition_variables_Signal_support+0x3c> the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX; 10c23c: c7 47 14 00 00 00 00 movl $0x0,0x14(%edi) } while ( is_broadcast && the_thread ); 10c243: 84 db test %bl,%bl 10c245: 75 e1 jne 10c228 <_POSIX_Condition_variables_Signal_support+0x40> 10c247: 90 nop _Thread_Enable_dispatch(); 10c248: e8 8f 35 00 00 call 10f7dc <_Thread_Enable_dispatch> return 0; 10c24d: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return EINVAL; } 10c24f: 8d 65 f4 lea -0xc(%ebp),%esp 10c252: 5b pop %ebx 10c253: 5e pop %esi 10c254: 5f pop %edi 10c255: c9 leave 10c256: c3 ret =============================================================================== 0010c2b0 <_POSIX_Condition_variables_Wait_support>: pthread_cond_t *cond, pthread_mutex_t *mutex, Watchdog_Interval timeout, bool already_timedout ) { 10c2b0: 55 push %ebp 10c2b1: 89 e5 mov %esp,%ebp 10c2b3: 57 push %edi 10c2b4: 56 push %esi 10c2b5: 53 push %ebx 10c2b6: 83 ec 34 sub $0x34,%esp 10c2b9: 8b 7d 08 mov 0x8(%ebp),%edi 10c2bc: 8b 5d 0c mov 0xc(%ebp),%ebx 10c2bf: 8a 45 14 mov 0x14(%ebp),%al 10c2c2: 88 45 d7 mov %al,-0x29(%ebp) register POSIX_Condition_variables_Control *the_cond; Objects_Locations location; int status; int mutex_status; if ( !_POSIX_Mutex_Get( mutex, &location ) ) { 10c2c5: 8d 75 e4 lea -0x1c(%ebp),%esi 10c2c8: 56 push %esi 10c2c9: 53 push %ebx 10c2ca: e8 59 01 00 00 call 10c428 <_POSIX_Mutex_Get> 10c2cf: 83 c4 10 add $0x10,%esp 10c2d2: 85 c0 test %eax,%eax 10c2d4: 74 21 je 10c2f7 <_POSIX_Condition_variables_Wait_support+0x47> */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 10c2d6: a1 90 95 12 00 mov 0x129590,%eax 10c2db: 48 dec %eax 10c2dc: a3 90 95 12 00 mov %eax,0x129590 return EINVAL; } _Thread_Unnest_dispatch(); the_cond = _POSIX_Condition_variables_Get( cond, &location ); 10c2e1: 83 ec 08 sub $0x8,%esp 10c2e4: 56 push %esi 10c2e5: 57 push %edi 10c2e6: e8 e1 fd ff ff call 10c0cc <_POSIX_Condition_variables_Get> 10c2eb: 89 c6 mov %eax,%esi switch ( location ) { 10c2ed: 83 c4 10 add $0x10,%esp 10c2f0: 8b 55 e4 mov -0x1c(%ebp),%edx 10c2f3: 85 d2 test %edx,%edx 10c2f5: 74 11 je 10c308 <_POSIX_Condition_variables_Wait_support+0x58> #endif case OBJECTS_ERROR: break; } return EINVAL; 10c2f7: be 16 00 00 00 mov $0x16,%esi } 10c2fc: 89 f0 mov %esi,%eax 10c2fe: 8d 65 f4 lea -0xc(%ebp),%esp 10c301: 5b pop %ebx 10c302: 5e pop %esi 10c303: 5f pop %edi 10c304: c9 leave 10c305: c3 ret 10c306: 66 90 xchg %ax,%ax the_cond = _POSIX_Condition_variables_Get( cond, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( the_cond->Mutex && ( the_cond->Mutex != *mutex ) ) { 10c308: 8b 40 14 mov 0x14(%eax),%eax 10c30b: 85 c0 test %eax,%eax 10c30d: 74 19 je 10c328 <_POSIX_Condition_variables_Wait_support+0x78> 10c30f: 3b 03 cmp (%ebx),%eax 10c311: 74 15 je 10c328 <_POSIX_Condition_variables_Wait_support+0x78> _Thread_Enable_dispatch(); 10c313: e8 c4 34 00 00 call 10f7dc <_Thread_Enable_dispatch> return EINVAL; 10c318: be 16 00 00 00 mov $0x16,%esi case OBJECTS_ERROR: break; } return EINVAL; } 10c31d: 89 f0 mov %esi,%eax 10c31f: 8d 65 f4 lea -0xc(%ebp),%esp 10c322: 5b pop %ebx 10c323: 5e pop %esi 10c324: 5f pop %edi 10c325: c9 leave 10c326: c3 ret 10c327: 90 nop if ( the_cond->Mutex && ( the_cond->Mutex != *mutex ) ) { _Thread_Enable_dispatch(); return EINVAL; } (void) pthread_mutex_unlock( mutex ); 10c328: 83 ec 0c sub $0xc,%esp 10c32b: 53 push %ebx 10c32c: e8 73 03 00 00 call 10c6a4 _Thread_Enable_dispatch(); return EINVAL; } */ if ( !already_timedout ) { 10c331: 83 c4 10 add $0x10,%esp 10c334: 80 7d d7 00 cmpb $0x0,-0x29(%ebp) 10c338: 75 4e jne 10c388 <_POSIX_Condition_variables_Wait_support+0xd8> the_cond->Mutex = *mutex; 10c33a: 8b 03 mov (%ebx),%eax 10c33c: 89 46 14 mov %eax,0x14(%esi) RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 10c33f: c7 46 48 01 00 00 00 movl $0x1,0x48(%esi) _Thread_queue_Enter_critical_section( &the_cond->Wait_queue ); _Thread_Executing->Wait.return_code = 0; 10c346: a1 38 9b 12 00 mov 0x129b38,%eax 10c34b: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax) _Thread_Executing->Wait.queue = &the_cond->Wait_queue; 10c352: 83 c6 18 add $0x18,%esi 10c355: 89 70 44 mov %esi,0x44(%eax) _Thread_Executing->Wait.id = *cond; 10c358: 8b 17 mov (%edi),%edx 10c35a: 89 50 20 mov %edx,0x20(%eax) _Thread_queue_Enqueue( &the_cond->Wait_queue, timeout ); 10c35d: 50 push %eax 10c35e: 68 fc ff 10 00 push $0x10fffc 10c363: ff 75 10 pushl 0x10(%ebp) 10c366: 56 push %esi 10c367: e8 14 39 00 00 call 10fc80 <_Thread_queue_Enqueue_with_handler> _Thread_Enable_dispatch(); 10c36c: e8 6b 34 00 00 call 10f7dc <_Thread_Enable_dispatch> * a POSIX signal, then pthread_cond_wait returns spuriously, * according to the POSIX standard. It means that pthread_cond_wait * returns a success status, except for the fact that it was not * woken up a pthread_cond_signal or a pthread_cond_broadcast. */ status = _Thread_Executing->Wait.return_code; 10c371: a1 38 9b 12 00 mov 0x129b38,%eax 10c376: 8b 70 34 mov 0x34(%eax),%esi if ( status == EINTR ) 10c379: 83 c4 10 add $0x10,%esp 10c37c: 83 fe 04 cmp $0x4,%esi 10c37f: 75 11 jne 10c392 <_POSIX_Condition_variables_Wait_support+0xe2> status = 0; 10c381: 31 f6 xor %esi,%esi 10c383: eb 0d jmp 10c392 <_POSIX_Condition_variables_Wait_support+0xe2> 10c385: 8d 76 00 lea 0x0(%esi),%esi } else { _Thread_Enable_dispatch(); 10c388: e8 4f 34 00 00 call 10f7dc <_Thread_Enable_dispatch> status = ETIMEDOUT; 10c38d: be 74 00 00 00 mov $0x74,%esi /* * When we get here the dispatch disable level is 0. */ mutex_status = pthread_mutex_lock( mutex ); 10c392: 83 ec 0c sub $0xc,%esp 10c395: 53 push %ebx 10c396: e8 81 02 00 00 call 10c61c if ( mutex_status ) 10c39b: 83 c4 10 add $0x10,%esp 10c39e: 85 c0 test %eax,%eax 10c3a0: 0f 85 51 ff ff ff jne 10c2f7 <_POSIX_Condition_variables_Wait_support+0x47> case OBJECTS_ERROR: break; } return EINVAL; } 10c3a6: 89 f0 mov %esi,%eax 10c3a8: 8d 65 f4 lea -0xc(%ebp),%esp 10c3ab: 5b pop %ebx 10c3ac: 5e pop %esi 10c3ad: 5f pop %edi 10c3ae: c9 leave 10c3af: c3 ret =============================================================================== 001163a8 <_POSIX_Message_queue_Create_support>: const char *name_arg, int pshared, struct mq_attr *attr_ptr, POSIX_Message_queue_Control **message_queue ) { 1163a8: 55 push %ebp 1163a9: 89 e5 mov %esp,%ebp 1163ab: 57 push %edi 1163ac: 56 push %esi 1163ad: 53 push %ebx 1163ae: 83 ec 24 sub $0x24,%esp 1163b1: 8b 5d 10 mov 0x10(%ebp),%ebx CORE_message_queue_Attributes *the_mq_attr; struct mq_attr attr; char *name; size_t n; n = strnlen( name_arg, NAME_MAX ); 1163b4: 68 ff 00 00 00 push $0xff 1163b9: ff 75 08 pushl 0x8(%ebp) 1163bc: e8 d7 4b 00 00 call 11af98 1163c1: 89 c6 mov %eax,%esi 1163c3: a1 f0 0e 13 00 mov 0x130ef0,%eax 1163c8: 40 inc %eax 1163c9: a3 f0 0e 13 00 mov %eax,0x130ef0 * There is no real basis for the default values. They will work * but were not compared against any existing implementation for * compatibility. See README.mqueue for an example program we * think will print out the defaults. Report anything you find with it. */ if ( attr_ptr == NULL ) { 1163ce: 83 c4 10 add $0x10,%esp 1163d1: 85 db test %ebx,%ebx 1163d3: 0f 84 b7 00 00 00 je 116490 <_POSIX_Message_queue_Create_support+0xe8> attr.mq_maxmsg = 10; attr.mq_msgsize = 16; } else { if ( attr_ptr->mq_maxmsg <= 0 ){ 1163d9: 8b 7b 04 mov 0x4(%ebx),%edi 1163dc: 85 ff test %edi,%edi 1163de: 0f 8e f0 00 00 00 jle 1164d4 <_POSIX_Message_queue_Create_support+0x12c> _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EINVAL ); } if ( attr_ptr->mq_msgsize <= 0 ){ 1163e4: 8b 5b 08 mov 0x8(%ebx),%ebx 1163e7: 89 5d e4 mov %ebx,-0x1c(%ebp) 1163ea: 85 db test %ebx,%ebx 1163ec: 0f 8e e2 00 00 00 jle 1164d4 <_POSIX_Message_queue_Create_support+0x12c> RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control *_POSIX_Message_queue_Allocate( void ) { return (POSIX_Message_queue_Control *) _Objects_Allocate( &_POSIX_Message_queue_Information ); 1163f2: 83 ec 0c sub $0xc,%esp 1163f5: 68 80 12 13 00 push $0x131280 1163fa: e8 a5 c3 ff ff call 1127a4 <_Objects_Allocate> 1163ff: 89 c3 mov %eax,%ebx attr = *attr_ptr; } the_mq = _POSIX_Message_queue_Allocate(); if ( !the_mq ) { 116401: 83 c4 10 add $0x10,%esp 116404: 85 c0 test %eax,%eax 116406: 0f 84 0a 01 00 00 je 116516 <_POSIX_Message_queue_Create_support+0x16e> _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENFILE ); } the_mq->process_shared = pshared; 11640c: 8b 45 0c mov 0xc(%ebp),%eax 11640f: 89 43 10 mov %eax,0x10(%ebx) the_mq->named = true; 116412: c6 43 14 01 movb $0x1,0x14(%ebx) the_mq->open_count = 1; 116416: c7 43 18 01 00 00 00 movl $0x1,0x18(%ebx) the_mq->linked = true; 11641d: c6 43 15 01 movb $0x1,0x15(%ebx) /* * Make a copy of the user's string for name just in case it was * dynamically constructed. */ name = _Workspace_Allocate(n+1); 116421: 8d 56 01 lea 0x1(%esi),%edx 116424: 83 ec 0c sub $0xc,%esp 116427: 52 push %edx 116428: 89 55 e0 mov %edx,-0x20(%ebp) 11642b: e8 d4 e4 ff ff call 114904 <_Workspace_Allocate> 116430: 89 c6 mov %eax,%esi if (!name) { 116432: 83 c4 10 add $0x10,%esp 116435: 85 c0 test %eax,%eax 116437: 8b 55 e0 mov -0x20(%ebp),%edx 11643a: 0f 84 ab 00 00 00 je 1164eb <_POSIX_Message_queue_Create_support+0x143> _POSIX_Message_queue_Free( the_mq ); _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENOMEM ); } strncpy( name, name_arg, n+1 ); 116440: 50 push %eax 116441: 52 push %edx 116442: ff 75 08 pushl 0x8(%ebp) 116445: 56 push %esi 116446: e8 d1 4a 00 00 call 11af1c * * Joel: Cite POSIX or OpenGroup on above statement so we can determine * if it is a real requirement. */ the_mq_attr = &the_mq->Message_queue.Attributes; the_mq_attr->discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO; 11644b: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) if ( !_CORE_message_queue_Initialize( 116452: ff 75 e4 pushl -0x1c(%ebp) 116455: 57 push %edi * current scheduling policy. * * Joel: Cite POSIX or OpenGroup on above statement so we can determine * if it is a real requirement. */ the_mq_attr = &the_mq->Message_queue.Attributes; 116456: 8d 43 5c lea 0x5c(%ebx),%eax the_mq_attr->discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO; if ( !_CORE_message_queue_Initialize( 116459: 50 push %eax 11645a: 8d 43 1c lea 0x1c(%ebx),%eax 11645d: 50 push %eax 11645e: e8 25 0f 00 00 call 117388 <_CORE_message_queue_Initialize> 116463: 83 c4 20 add $0x20,%esp 116466: 84 c0 test %al,%al 116468: 74 3a je 1164a4 <_POSIX_Message_queue_Create_support+0xfc> Objects_Information *information, Objects_Control *the_object, const char *name ) { _Objects_Set_local_object( 11646a: 0f b7 53 08 movzwl 0x8(%ebx),%edx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 11646e: a1 9c 12 13 00 mov 0x13129c,%eax 116473: 89 1c 90 mov %ebx,(%eax,%edx,4) the_object ); #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) /* ASSERT: information->is_string */ the_object->name.name_p = name; 116476: 89 73 0c mov %esi,0xc(%ebx) &_POSIX_Message_queue_Information, &the_mq->Object, name ); *message_queue = the_mq; 116479: 8b 45 14 mov 0x14(%ebp),%eax 11647c: 89 18 mov %ebx,(%eax) _Thread_Enable_dispatch(); 11647e: e8 cd d3 ff ff call 113850 <_Thread_Enable_dispatch> return 0; 116483: 31 c0 xor %eax,%eax } 116485: 8d 65 f4 lea -0xc(%ebp),%esp 116488: 5b pop %ebx 116489: 5e pop %esi 11648a: 5f pop %edi 11648b: c9 leave 11648c: c3 ret 11648d: 8d 76 00 lea 0x0(%esi),%esi * compatibility. See README.mqueue for an example program we * think will print out the defaults. Report anything you find with it. */ if ( attr_ptr == NULL ) { attr.mq_maxmsg = 10; attr.mq_msgsize = 16; 116490: c7 45 e4 10 00 00 00 movl $0x10,-0x1c(%ebp) * but were not compared against any existing implementation for * compatibility. See README.mqueue for an example program we * think will print out the defaults. Report anything you find with it. */ if ( attr_ptr == NULL ) { attr.mq_maxmsg = 10; 116497: bf 0a 00 00 00 mov $0xa,%edi 11649c: e9 51 ff ff ff jmp 1163f2 <_POSIX_Message_queue_Create_support+0x4a> 1164a1: 8d 76 00 lea 0x0(%esi),%esi RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Free ( POSIX_Message_queue_Control *the_mq ) { _Objects_Free( &_POSIX_Message_queue_Information, &the_mq->Object ); 1164a4: 83 ec 08 sub $0x8,%esp 1164a7: 53 push %ebx 1164a8: 68 80 12 13 00 push $0x131280 1164ad: e8 66 c6 ff ff call 112b18 <_Objects_Free> attr.mq_maxmsg, attr.mq_msgsize ) ) { _POSIX_Message_queue_Free( the_mq ); _Workspace_Free(name); 1164b2: 89 34 24 mov %esi,(%esp) 1164b5: e8 66 e4 ff ff call 114920 <_Workspace_Free> _Thread_Enable_dispatch(); 1164ba: e8 91 d3 ff ff call 113850 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( ENOSPC ); 1164bf: e8 50 33 00 00 call 119814 <__errno> 1164c4: c7 00 1c 00 00 00 movl $0x1c,(%eax) 1164ca: 83 c4 10 add $0x10,%esp 1164cd: b8 ff ff ff ff mov $0xffffffff,%eax 1164d2: eb b1 jmp 116485 <_POSIX_Message_queue_Create_support+0xdd> _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EINVAL ); } if ( attr_ptr->mq_msgsize <= 0 ){ _Thread_Enable_dispatch(); 1164d4: e8 77 d3 ff ff call 113850 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EINVAL ); 1164d9: e8 36 33 00 00 call 119814 <__errno> 1164de: c7 00 16 00 00 00 movl $0x16,(%eax) 1164e4: b8 ff ff ff ff mov $0xffffffff,%eax 1164e9: eb 9a jmp 116485 <_POSIX_Message_queue_Create_support+0xdd> 1164eb: 83 ec 08 sub $0x8,%esp 1164ee: 53 push %ebx 1164ef: 68 80 12 13 00 push $0x131280 1164f4: e8 1f c6 ff ff call 112b18 <_Objects_Free> * dynamically constructed. */ name = _Workspace_Allocate(n+1); if (!name) { _POSIX_Message_queue_Free( the_mq ); _Thread_Enable_dispatch(); 1164f9: e8 52 d3 ff ff call 113850 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( ENOMEM ); 1164fe: e8 11 33 00 00 call 119814 <__errno> 116503: c7 00 0c 00 00 00 movl $0xc,(%eax) 116509: 83 c4 10 add $0x10,%esp 11650c: b8 ff ff ff ff mov $0xffffffff,%eax 116511: e9 6f ff ff ff jmp 116485 <_POSIX_Message_queue_Create_support+0xdd> attr = *attr_ptr; } the_mq = _POSIX_Message_queue_Allocate(); if ( !the_mq ) { _Thread_Enable_dispatch(); 116516: e8 35 d3 ff ff call 113850 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( ENFILE ); 11651b: e8 f4 32 00 00 call 119814 <__errno> 116520: c7 00 17 00 00 00 movl $0x17,(%eax) 116526: b8 ff ff ff ff mov $0xffffffff,%eax 11652b: e9 55 ff ff ff jmp 116485 <_POSIX_Message_queue_Create_support+0xdd> =============================================================================== 00116530 <_POSIX_Message_queue_Name_to_id>: */ int _POSIX_Message_queue_Name_to_id( const char *name, Objects_Id *id ) { 116530: 55 push %ebp 116531: 89 e5 mov %esp,%ebp 116533: 53 push %ebx 116534: 83 ec 14 sub $0x14,%esp 116537: 8b 5d 08 mov 0x8(%ebp),%ebx Objects_Name_or_id_lookup_errors status; Objects_Id the_id; if ( !name ) 11653a: 85 db test %ebx,%ebx 11653c: 74 05 je 116543 <_POSIX_Message_queue_Name_to_id+0x13> return EINVAL; if ( !name[0] ) 11653e: 80 3b 00 cmpb $0x0,(%ebx) 116541: 75 0d jne 116550 <_POSIX_Message_queue_Name_to_id+0x20> return EINVAL; 116543: b8 16 00 00 00 mov $0x16,%eax if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL ) return 0; return ENOENT; } 116548: 8b 5d fc mov -0x4(%ebp),%ebx 11654b: c9 leave 11654c: c3 ret 11654d: 8d 76 00 lea 0x0(%esi),%esi return EINVAL; if ( !name[0] ) return EINVAL; if ( strnlen( name, NAME_MAX ) >= NAME_MAX ) 116550: 83 ec 08 sub $0x8,%esp 116553: 68 ff 00 00 00 push $0xff 116558: 53 push %ebx 116559: e8 3a 4a 00 00 call 11af98 11655e: 83 c4 10 add $0x10,%esp 116561: 3d fe 00 00 00 cmp $0xfe,%eax 116566: 76 0c jbe 116574 <_POSIX_Message_queue_Name_to_id+0x44> return ENAMETOOLONG; 116568: b8 5b 00 00 00 mov $0x5b,%eax if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL ) return 0; return ENOENT; } 11656d: 8b 5d fc mov -0x4(%ebp),%ebx 116570: c9 leave 116571: c3 ret 116572: 66 90 xchg %ax,%ax return EINVAL; if ( strnlen( name, NAME_MAX ) >= NAME_MAX ) return ENAMETOOLONG; status = _Objects_Name_to_id_string( 116574: 50 push %eax 116575: 8d 45 f4 lea -0xc(%ebp),%eax 116578: 50 push %eax 116579: 53 push %ebx 11657a: 68 80 12 13 00 push $0x131280 11657f: e8 10 14 00 00 call 117994 <_Objects_Name_to_id_string> &_POSIX_Message_queue_Information, name, &the_id ); *id = the_id; 116584: 8b 4d f4 mov -0xc(%ebp),%ecx 116587: 8b 55 0c mov 0xc(%ebp),%edx 11658a: 89 0a mov %ecx,(%edx) if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL ) 11658c: 83 c4 10 add $0x10,%esp return 0; 11658f: 83 f8 01 cmp $0x1,%eax 116592: 19 c0 sbb %eax,%eax 116594: f7 d0 not %eax 116596: 83 e0 02 and $0x2,%eax return ENOENT; } 116599: 8b 5d fc mov -0x4(%ebp),%ebx 11659c: c9 leave 11659d: c3 ret =============================================================================== 0010fce8 <_POSIX_Message_queue_Receive_support>: size_t msg_len, unsigned int *msg_prio, bool wait, Watchdog_Interval timeout ) { 10fce8: 55 push %ebp 10fce9: 89 e5 mov %esp,%ebp 10fceb: 53 push %ebx 10fcec: 83 ec 28 sub $0x28,%esp 10fcef: 8b 5d 08 mov 0x8(%ebp),%ebx 10fcf2: 8a 45 18 mov 0x18(%ebp),%al 10fcf5: 88 45 e7 mov %al,-0x19(%ebp) POSIX_Message_queue_Control_fd *the_mq_fd; Objects_Locations location; size_t length_out; bool do_wait; the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); 10fcf8: 8d 45 f4 lea -0xc(%ebp),%eax RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *_POSIX_Message_queue_Get_fd ( mqd_t id, Objects_Locations *location ) { return (POSIX_Message_queue_Control_fd *) _Objects_Get( 10fcfb: 50 push %eax 10fcfc: 53 push %ebx 10fcfd: 68 20 14 13 00 push $0x131420 10fd02: e8 51 2f 00 00 call 112c58 <_Objects_Get> switch ( location ) { 10fd07: 83 c4 10 add $0x10,%esp 10fd0a: 8b 55 f4 mov -0xc(%ebp),%edx 10fd0d: 85 d2 test %edx,%edx 10fd0f: 74 17 je 10fd28 <_POSIX_Message_queue_Receive_support+0x40> #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); 10fd11: e8 fe 9a 00 00 call 119814 <__errno> 10fd16: c7 00 09 00 00 00 movl $0x9,(%eax) 10fd1c: b8 ff ff ff ff mov $0xffffffff,%eax } 10fd21: 8b 5d fc mov -0x4(%ebp),%ebx 10fd24: c9 leave 10fd25: c3 ret 10fd26: 66 90 xchg %ax,%ax the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) { 10fd28: 8b 50 14 mov 0x14(%eax),%edx 10fd2b: 89 d1 mov %edx,%ecx 10fd2d: 83 e1 03 and $0x3,%ecx 10fd30: 49 dec %ecx 10fd31: 0f 84 af 00 00 00 je 10fde6 <_POSIX_Message_queue_Receive_support+0xfe> _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EBADF ); } the_mq = the_mq_fd->Queue; 10fd37: 8b 40 10 mov 0x10(%eax),%eax if ( msg_len < the_mq->Message_queue.maximum_message_size ) { 10fd3a: 8b 4d 10 mov 0x10(%ebp),%ecx 10fd3d: 39 48 68 cmp %ecx,0x68(%eax) 10fd40: 77 62 ja 10fda4 <_POSIX_Message_queue_Receive_support+0xbc> /* * Now if something goes wrong, we return a "length" of -1 * to indicate an error. */ length_out = -1; 10fd42: c7 45 f0 ff ff ff ff movl $0xffffffff,-0x10(%ebp) /* * A timed receive with a bad time will do a poll regardless. */ if ( wait ) 10fd49: 80 7d e7 00 cmpb $0x0,-0x19(%ebp) 10fd4d: 75 45 jne 10fd94 <_POSIX_Message_queue_Receive_support+0xac><== ALWAYS TAKEN 10fd4f: 31 d2 xor %edx,%edx <== NOT EXECUTED do_wait = wait; /* * Now perform the actual message receive */ _CORE_message_queue_Seize( 10fd51: 83 ec 08 sub $0x8,%esp 10fd54: ff 75 1c pushl 0x1c(%ebp) 10fd57: 52 push %edx 10fd58: 8d 55 f0 lea -0x10(%ebp),%edx 10fd5b: 52 push %edx 10fd5c: ff 75 0c pushl 0xc(%ebp) 10fd5f: 53 push %ebx 10fd60: 83 c0 1c add $0x1c,%eax 10fd63: 50 push %eax 10fd64: e8 9f 1f 00 00 call 111d08 <_CORE_message_queue_Seize> &length_out, do_wait, timeout ); _Thread_Enable_dispatch(); 10fd69: 83 c4 20 add $0x20,%esp 10fd6c: e8 df 3a 00 00 call 113850 <_Thread_Enable_dispatch> *msg_prio = _POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count); 10fd71: 8b 15 98 14 13 00 mov 0x131498,%edx RTEMS_INLINE_ROUTINE unsigned int _POSIX_Message_queue_Priority_from_core( CORE_message_queue_Submit_types priority ) { /* absolute value without a library dependency */ return ((priority >= 0) ? priority : -priority); 10fd77: 8b 42 24 mov 0x24(%edx),%eax 10fd7a: 85 c0 test %eax,%eax 10fd7c: 78 22 js 10fda0 <_POSIX_Message_queue_Receive_support+0xb8> do_wait, timeout ); _Thread_Enable_dispatch(); *msg_prio = 10fd7e: 8b 4d 14 mov 0x14(%ebp),%ecx 10fd81: 89 01 mov %eax,(%ecx) _POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count); if ( !_Thread_Executing->Wait.return_code ) 10fd83: 8b 42 34 mov 0x34(%edx),%eax 10fd86: 85 c0 test %eax,%eax 10fd88: 75 36 jne 10fdc0 <_POSIX_Message_queue_Receive_support+0xd8> return length_out; 10fd8a: 8b 45 f0 mov -0x10(%ebp),%eax case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); } 10fd8d: 8b 5d fc mov -0x4(%ebp),%ebx 10fd90: c9 leave 10fd91: c3 ret 10fd92: 66 90 xchg %ax,%ax length_out = -1; /* * A timed receive with a bad time will do a poll regardless. */ if ( wait ) 10fd94: 80 e6 40 and $0x40,%dh 10fd97: 0f 94 c2 sete %dl 10fd9a: 0f b6 d2 movzbl %dl,%edx 10fd9d: eb b2 jmp 10fd51 <_POSIX_Message_queue_Receive_support+0x69> 10fd9f: 90 nop 10fda0: f7 d8 neg %eax 10fda2: eb da jmp 10fd7e <_POSIX_Message_queue_Receive_support+0x96> } the_mq = the_mq_fd->Queue; if ( msg_len < the_mq->Message_queue.maximum_message_size ) { _Thread_Enable_dispatch(); 10fda4: e8 a7 3a 00 00 call 113850 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EMSGSIZE ); 10fda9: e8 66 9a 00 00 call 119814 <__errno> 10fdae: c7 00 7a 00 00 00 movl $0x7a,(%eax) 10fdb4: b8 ff ff ff ff mov $0xffffffff,%eax 10fdb9: e9 63 ff ff ff jmp 10fd21 <_POSIX_Message_queue_Receive_support+0x39> 10fdbe: 66 90 xchg %ax,%ax _POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count); if ( !_Thread_Executing->Wait.return_code ) return length_out; rtems_set_errno_and_return_minus_one( 10fdc0: e8 4f 9a 00 00 call 119814 <__errno> 10fdc5: 89 c3 mov %eax,%ebx 10fdc7: 83 ec 0c sub $0xc,%esp 10fdca: a1 98 14 13 00 mov 0x131498,%eax 10fdcf: ff 70 34 pushl 0x34(%eax) 10fdd2: e8 29 02 00 00 call 110000 <_POSIX_Message_queue_Translate_core_message_queue_return_code> 10fdd7: 89 03 mov %eax,(%ebx) 10fdd9: 83 c4 10 add $0x10,%esp 10fddc: b8 ff ff ff ff mov $0xffffffff,%eax 10fde1: e9 3b ff ff ff jmp 10fd21 <_POSIX_Message_queue_Receive_support+0x39> the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) { _Thread_Enable_dispatch(); 10fde6: e8 65 3a 00 00 call 113850 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EBADF ); 10fdeb: e8 24 9a 00 00 call 119814 <__errno> 10fdf0: c7 00 09 00 00 00 movl $0x9,(%eax) 10fdf6: b8 ff ff ff ff mov $0xffffffff,%eax 10fdfb: e9 21 ff ff ff jmp 10fd21 <_POSIX_Message_queue_Receive_support+0x39> =============================================================================== 0010fe20 <_POSIX_Message_queue_Send_support>: size_t msg_len, uint32_t msg_prio, bool wait, Watchdog_Interval timeout ) { 10fe20: 55 push %ebp 10fe21: 89 e5 mov %esp,%ebp 10fe23: 56 push %esi 10fe24: 53 push %ebx 10fe25: 83 ec 20 sub $0x20,%esp 10fe28: 8b 75 08 mov 0x8(%ebp),%esi 10fe2b: 8b 5d 14 mov 0x14(%ebp),%ebx 10fe2e: 8a 55 18 mov 0x18(%ebp),%dl /* * Validate the priority. * XXX - Do not validate msg_prio is not less than 0. */ if ( msg_prio > MQ_PRIO_MAX ) 10fe31: 83 fb 20 cmp $0x20,%ebx 10fe34: 0f 87 92 00 00 00 ja 10fecc <_POSIX_Message_queue_Send_support+0xac> RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *_POSIX_Message_queue_Get_fd ( mqd_t id, Objects_Locations *location ) { return (POSIX_Message_queue_Control_fd *) _Objects_Get( 10fe3a: 51 push %ecx rtems_set_errno_and_return_minus_one( EINVAL ); the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); 10fe3b: 8d 45 f4 lea -0xc(%ebp),%eax 10fe3e: 50 push %eax 10fe3f: 56 push %esi 10fe40: 68 20 14 13 00 push $0x131420 10fe45: 88 55 e4 mov %dl,-0x1c(%ebp) 10fe48: e8 0b 2e 00 00 call 112c58 <_Objects_Get> switch ( location ) { 10fe4d: 83 c4 10 add $0x10,%esp 10fe50: 8b 55 f4 mov -0xc(%ebp),%edx 10fe53: 85 d2 test %edx,%edx 10fe55: 8a 55 e4 mov -0x1c(%ebp),%dl 10fe58: 75 5e jne 10feb8 <_POSIX_Message_queue_Send_support+0x98> case OBJECTS_LOCAL: if ( (the_mq_fd->oflag & O_ACCMODE) == O_RDONLY ) { 10fe5a: 8b 48 14 mov 0x14(%eax),%ecx 10fe5d: f6 c1 03 test $0x3,%cl 10fe60: 74 7e je 10fee0 <_POSIX_Message_queue_Send_support+0xc0> _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EBADF ); } the_mq = the_mq_fd->Queue; 10fe62: 8b 40 10 mov 0x10(%eax),%eax /* * A timed receive with a bad time will do a poll regardless. */ if ( wait ) 10fe65: 84 d2 test %dl,%dl 10fe67: 75 37 jne 10fea0 <_POSIX_Message_queue_Send_support+0x80> 10fe69: 31 d2 xor %edx,%edx do_wait = wait; /* * Now perform the actual message receive */ msg_status = _CORE_message_queue_Submit( 10fe6b: ff 75 1c pushl 0x1c(%ebp) 10fe6e: 52 push %edx RTEMS_INLINE_ROUTINE CORE_message_queue_Submit_types _POSIX_Message_queue_Priority_to_core( unsigned int priority ) { return priority * -1; 10fe6f: f7 db neg %ebx 10fe71: 53 push %ebx 10fe72: 6a 00 push $0x0 10fe74: 56 push %esi 10fe75: ff 75 10 pushl 0x10(%ebp) 10fe78: ff 75 0c pushl 0xc(%ebp) 10fe7b: 83 c0 1c add $0x1c,%eax 10fe7e: 50 push %eax 10fe7f: e8 b0 1f 00 00 call 111e34 <_CORE_message_queue_Submit> 10fe84: 89 c3 mov %eax,%ebx _POSIX_Message_queue_Priority_to_core( msg_prio ), do_wait, timeout /* no timeout */ ); _Thread_Enable_dispatch(); 10fe86: 83 c4 20 add $0x20,%esp 10fe89: e8 c2 39 00 00 call 113850 <_Thread_Enable_dispatch> * after it wakes up. The returned status is correct for * non-blocking operations but if we blocked, then we need * to look at the status in our TCB. */ if ( msg_status == CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT ) 10fe8e: 83 fb 07 cmp $0x7,%ebx 10fe91: 74 19 je 10feac <_POSIX_Message_queue_Send_support+0x8c> msg_status = _Thread_Executing->Wait.return_code; if ( !msg_status ) 10fe93: 85 db test %ebx,%ebx 10fe95: 75 61 jne 10fef8 <_POSIX_Message_queue_Send_support+0xd8> return msg_status; 10fe97: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); } 10fe99: 8d 65 f8 lea -0x8(%ebp),%esp 10fe9c: 5b pop %ebx 10fe9d: 5e pop %esi 10fe9e: c9 leave 10fe9f: c3 ret the_mq = the_mq_fd->Queue; /* * A timed receive with a bad time will do a poll regardless. */ if ( wait ) 10fea0: 31 d2 xor %edx,%edx 10fea2: f6 c5 40 test $0x40,%ch 10fea5: 0f 94 c2 sete %dl 10fea8: eb c1 jmp 10fe6b <_POSIX_Message_queue_Send_support+0x4b> 10feaa: 66 90 xchg %ax,%ax * non-blocking operations but if we blocked, then we need * to look at the status in our TCB. */ if ( msg_status == CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT ) msg_status = _Thread_Executing->Wait.return_code; 10feac: a1 98 14 13 00 mov 0x131498,%eax 10feb1: 8b 58 34 mov 0x34(%eax),%ebx 10feb4: eb dd jmp 10fe93 <_POSIX_Message_queue_Send_support+0x73> 10feb6: 66 90 xchg %ax,%ax #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); 10feb8: e8 57 99 00 00 call 119814 <__errno> 10febd: c7 00 09 00 00 00 movl $0x9,(%eax) 10fec3: b8 ff ff ff ff mov $0xffffffff,%eax 10fec8: eb cf jmp 10fe99 <_POSIX_Message_queue_Send_support+0x79> 10feca: 66 90 xchg %ax,%ax * Validate the priority. * XXX - Do not validate msg_prio is not less than 0. */ if ( msg_prio > MQ_PRIO_MAX ) rtems_set_errno_and_return_minus_one( EINVAL ); 10fecc: e8 43 99 00 00 call 119814 <__errno> 10fed1: c7 00 16 00 00 00 movl $0x16,(%eax) 10fed7: b8 ff ff ff ff mov $0xffffffff,%eax 10fedc: eb bb jmp 10fe99 <_POSIX_Message_queue_Send_support+0x79> 10fede: 66 90 xchg %ax,%ax the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( (the_mq_fd->oflag & O_ACCMODE) == O_RDONLY ) { _Thread_Enable_dispatch(); 10fee0: e8 6b 39 00 00 call 113850 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EBADF ); 10fee5: e8 2a 99 00 00 call 119814 <__errno> 10feea: c7 00 09 00 00 00 movl $0x9,(%eax) 10fef0: b8 ff ff ff ff mov $0xffffffff,%eax 10fef5: eb a2 jmp 10fe99 <_POSIX_Message_queue_Send_support+0x79> 10fef7: 90 nop msg_status = _Thread_Executing->Wait.return_code; if ( !msg_status ) return msg_status; rtems_set_errno_and_return_minus_one( 10fef8: e8 17 99 00 00 call 119814 <__errno> 10fefd: 89 c6 mov %eax,%esi 10feff: 83 ec 0c sub $0xc,%esp 10ff02: 53 push %ebx 10ff03: e8 f8 00 00 00 call 110000 <_POSIX_Message_queue_Translate_core_message_queue_return_code> 10ff08: 89 06 mov %eax,(%esi) 10ff0a: 83 c4 10 add $0x10,%esp 10ff0d: b8 ff ff ff ff mov $0xffffffff,%eax 10ff12: eb 85 jmp 10fe99 <_POSIX_Message_queue_Send_support+0x79> =============================================================================== 0010d0f4 <_POSIX_Mutex_Get>: POSIX_Mutex_Control *_POSIX_Mutex_Get ( pthread_mutex_t *mutex, Objects_Locations *location ) { 10d0f4: 55 push %ebp 10d0f5: 89 e5 mov %esp,%ebp 10d0f7: 56 push %esi 10d0f8: 53 push %ebx 10d0f9: 8b 5d 08 mov 0x8(%ebp),%ebx 10d0fc: 8b 75 0c mov 0xc(%ebp),%esi ___POSIX_Mutex_Get_support_error_check( mutex, location ); 10d0ff: 85 db test %ebx,%ebx 10d101: 74 39 je 10d13c <_POSIX_Mutex_Get+0x48> ___POSIX_Mutex_Get_support_auto_initialization( mutex, location ); 10d103: 8b 03 mov (%ebx),%eax 10d105: 83 f8 ff cmp $0xffffffff,%eax 10d108: 74 1a je 10d124 <_POSIX_Mutex_Get+0x30> return (POSIX_Mutex_Control *) _Objects_Get( &_POSIX_Mutex_Information, (Objects_Id) *mutex, location ); 10d10a: 52 push %edx 10d10b: 56 push %esi 10d10c: 50 push %eax 10d10d: 68 c0 d0 12 00 push $0x12d0c0 10d112: e8 e1 2b 00 00 call 10fcf8 <_Objects_Get> { ___POSIX_Mutex_Get_support_error_check( mutex, location ); ___POSIX_Mutex_Get_support_auto_initialization( mutex, location ); return (POSIX_Mutex_Control *) 10d117: 83 c4 10 add $0x10,%esp _Objects_Get( &_POSIX_Mutex_Information, (Objects_Id) *mutex, location ); } 10d11a: 8d 65 f8 lea -0x8(%ebp),%esp 10d11d: 5b pop %ebx 10d11e: 5e pop %esi 10d11f: c9 leave 10d120: c3 ret 10d121: 8d 76 00 lea 0x0(%esi),%esi Objects_Locations *location ) { ___POSIX_Mutex_Get_support_error_check( mutex, location ); ___POSIX_Mutex_Get_support_auto_initialization( mutex, location ); 10d124: 83 ec 08 sub $0x8,%esp 10d127: 6a 00 push $0x0 10d129: 53 push %ebx 10d12a: e8 b9 00 00 00 call 10d1e8 10d12f: 83 c4 10 add $0x10,%esp 10d132: 85 c0 test %eax,%eax 10d134: 75 06 jne 10d13c <_POSIX_Mutex_Get+0x48> 10d136: 8b 03 mov (%ebx),%eax 10d138: eb d0 jmp 10d10a <_POSIX_Mutex_Get+0x16> 10d13a: 66 90 xchg %ax,%ax 10d13c: c7 06 01 00 00 00 movl $0x1,(%esi) 10d142: 31 c0 xor %eax,%eax 10d144: eb d4 jmp 10d11a <_POSIX_Mutex_Get+0x26> =============================================================================== 0010d148 <_POSIX_Mutex_Get_interrupt_disable>: POSIX_Mutex_Control *_POSIX_Mutex_Get_interrupt_disable ( pthread_mutex_t *mutex, Objects_Locations *location, ISR_Level *level ) { 10d148: 55 push %ebp 10d149: 89 e5 mov %esp,%ebp 10d14b: 56 push %esi 10d14c: 53 push %ebx 10d14d: 8b 5d 08 mov 0x8(%ebp),%ebx 10d150: 8b 75 0c mov 0xc(%ebp),%esi ___POSIX_Mutex_Get_support_error_check( mutex, location ); 10d153: 85 db test %ebx,%ebx 10d155: 74 39 je 10d190 <_POSIX_Mutex_Get_interrupt_disable+0x48> ___POSIX_Mutex_Get_support_auto_initialization( mutex, location ); 10d157: 8b 03 mov (%ebx),%eax 10d159: 83 f8 ff cmp $0xffffffff,%eax 10d15c: 74 1a je 10d178 <_POSIX_Mutex_Get_interrupt_disable+0x30> return (POSIX_Mutex_Control *) _Objects_Get_isr_disable( 10d15e: ff 75 10 pushl 0x10(%ebp) 10d161: 56 push %esi 10d162: 50 push %eax 10d163: 68 c0 d0 12 00 push $0x12d0c0 10d168: e8 33 2b 00 00 call 10fca0 <_Objects_Get_isr_disable> 10d16d: 83 c4 10 add $0x10,%esp &_POSIX_Mutex_Information, (Objects_Id) *mutex, location, level ); } 10d170: 8d 65 f8 lea -0x8(%ebp),%esp 10d173: 5b pop %ebx 10d174: 5e pop %esi 10d175: c9 leave 10d176: c3 ret 10d177: 90 nop ISR_Level *level ) { ___POSIX_Mutex_Get_support_error_check( mutex, location ); ___POSIX_Mutex_Get_support_auto_initialization( mutex, location ); 10d178: 83 ec 08 sub $0x8,%esp 10d17b: 6a 00 push $0x0 10d17d: 53 push %ebx 10d17e: e8 65 00 00 00 call 10d1e8 10d183: 83 c4 10 add $0x10,%esp 10d186: 85 c0 test %eax,%eax 10d188: 75 06 jne 10d190 <_POSIX_Mutex_Get_interrupt_disable+0x48> 10d18a: 8b 03 mov (%ebx),%eax 10d18c: eb d0 jmp 10d15e <_POSIX_Mutex_Get_interrupt_disable+0x16> 10d18e: 66 90 xchg %ax,%ax 10d190: c7 06 01 00 00 00 movl $0x1,(%esi) 10d196: 31 c0 xor %eax,%eax 10d198: eb d6 jmp 10d170 <_POSIX_Mutex_Get_interrupt_disable+0x28> =============================================================================== 0010d348 <_POSIX_Mutex_Lock_support>: int _POSIX_Mutex_Lock_support( pthread_mutex_t *mutex, bool blocking, Watchdog_Interval timeout ) { 10d348: 55 push %ebp 10d349: 89 e5 mov %esp,%ebp 10d34b: 53 push %ebx 10d34c: 83 ec 18 sub $0x18,%esp 10d34f: 8a 5d 0c mov 0xc(%ebp),%bl register POSIX_Mutex_Control *the_mutex; Objects_Locations location; ISR_Level level; the_mutex = _POSIX_Mutex_Get_interrupt_disable( mutex, &location, &level ); 10d352: 8d 45 f0 lea -0x10(%ebp),%eax 10d355: 50 push %eax 10d356: 8d 45 f4 lea -0xc(%ebp),%eax 10d359: 50 push %eax 10d35a: ff 75 08 pushl 0x8(%ebp) 10d35d: e8 e6 fd ff ff call 10d148 <_POSIX_Mutex_Get_interrupt_disable> switch ( location ) { 10d362: 83 c4 10 add $0x10,%esp 10d365: 8b 55 f4 mov -0xc(%ebp),%edx 10d368: 85 d2 test %edx,%edx 10d36a: 75 34 jne 10d3a0 <_POSIX_Mutex_Lock_support+0x58> case OBJECTS_LOCAL: _CORE_mutex_Seize( 10d36c: 83 ec 0c sub $0xc,%esp 10d36f: ff 75 f0 pushl -0x10(%ebp) 10d372: ff 75 10 pushl 0x10(%ebp) 10d375: 0f b6 db movzbl %bl,%ebx 10d378: 53 push %ebx 10d379: ff 70 08 pushl 0x8(%eax) 10d37c: 83 c0 14 add $0x14,%eax 10d37f: 50 push %eax 10d380: e8 43 1d 00 00 call 10f0c8 <_CORE_mutex_Seize> the_mutex->Object.id, blocking, timeout, level ); return _POSIX_Mutex_Translate_core_mutex_return_code( 10d385: 83 c4 14 add $0x14,%esp (CORE_mutex_Status) _Thread_Executing->Wait.return_code 10d388: a1 98 d2 12 00 mov 0x12d298,%eax the_mutex->Object.id, blocking, timeout, level ); return _POSIX_Mutex_Translate_core_mutex_return_code( 10d38d: ff 70 34 pushl 0x34(%eax) 10d390: e8 1b 01 00 00 call 10d4b0 <_POSIX_Mutex_Translate_core_mutex_return_code> 10d395: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return EINVAL; } 10d398: 8b 5d fc mov -0x4(%ebp),%ebx 10d39b: c9 leave 10d39c: c3 ret 10d39d: 8d 76 00 lea 0x0(%esi),%esi #endif case OBJECTS_ERROR: break; } return EINVAL; 10d3a0: b8 16 00 00 00 mov $0x16,%eax } 10d3a5: 8b 5d fc mov -0x4(%ebp),%ebx 10d3a8: c9 leave 10d3a9: c3 ret =============================================================================== 00114978 <_POSIX_Semaphore_Create_support>: const char *name, int pshared, unsigned int value, POSIX_Semaphore_Control **the_sem ) { 114978: 55 push %ebp 114979: 89 e5 mov %esp,%ebp 11497b: 56 push %esi 11497c: 53 push %ebx 11497d: 8b 5d 08 mov 0x8(%ebp),%ebx POSIX_Semaphore_Control *the_semaphore; CORE_semaphore_Attributes *the_sem_attr; char *name_p = (char *)name; /* Sharing semaphores among processes is not currently supported */ if (pshared != 0) 114980: 8b 55 0c mov 0xc(%ebp),%edx 114983: 85 d2 test %edx,%edx 114985: 0f 85 b9 00 00 00 jne 114a44 <_POSIX_Semaphore_Create_support+0xcc> rtems_set_errno_and_return_minus_one( ENOSYS ); if ( name ) { 11498b: 85 db test %ebx,%ebx 11498d: 74 1c je 1149ab <_POSIX_Semaphore_Create_support+0x33> if ( strnlen( name, NAME_MAX ) >= NAME_MAX ) 11498f: 83 ec 08 sub $0x8,%esp 114992: 68 ff 00 00 00 push $0xff 114997: 53 push %ebx 114998: e8 3b 3d 00 00 call 1186d8 11499d: 83 c4 10 add $0x10,%esp 1149a0: 3d fe 00 00 00 cmp $0xfe,%eax 1149a5: 0f 87 ad 00 00 00 ja 114a58 <_POSIX_Semaphore_Create_support+0xe0> 1149ab: a1 10 db 12 00 mov 0x12db10,%eax 1149b0: 40 inc %eax 1149b1: a3 10 db 12 00 mov %eax,0x12db10 */ RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Allocate( void ) { return (POSIX_Semaphore_Control *) _Objects_Allocate( &_POSIX_Semaphore_Information ); 1149b6: 83 ec 0c sub $0xc,%esp 1149b9: 68 20 de 12 00 push $0x12de20 1149be: e8 65 b9 ff ff call 110328 <_Objects_Allocate> 1149c3: 89 c6 mov %eax,%esi _Thread_Disable_dispatch(); the_semaphore = _POSIX_Semaphore_Allocate(); if ( !the_semaphore ) { 1149c5: 83 c4 10 add $0x10,%esp 1149c8: 85 c0 test %eax,%eax 1149ca: 0f 84 9a 00 00 00 je 114a6a <_POSIX_Semaphore_Create_support+0xf2> _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENOSPC ); } the_semaphore->process_shared = pshared; 1149d0: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax) if ( name ) { 1149d7: 85 db test %ebx,%ebx 1149d9: 74 55 je 114a30 <_POSIX_Semaphore_Create_support+0xb8> the_semaphore->named = true; 1149db: c6 40 14 01 movb $0x1,0x14(%eax) the_semaphore->open_count = 1; 1149df: c7 40 18 01 00 00 00 movl $0x1,0x18(%eax) the_semaphore->linked = true; 1149e6: c6 40 15 01 movb $0x1,0x15(%eax) * blocking tasks on this semaphore should be. It could somehow * be derived from the current scheduling policy. One * thing is certain, no matter what we decide, it won't be * the same as all other POSIX implementations. :) */ the_sem_attr->discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO; 1149ea: c7 46 60 00 00 00 00 movl $0x0,0x60(%esi) /* * This effectively disables limit checking. */ the_sem_attr->maximum_count = 0xFFFFFFFF; 1149f1: c7 46 5c ff ff ff ff movl $0xffffffff,0x5c(%esi) _CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value ); 1149f8: 50 push %eax 1149f9: ff 75 10 pushl 0x10(%ebp) the_semaphore->named = false; the_semaphore->open_count = 0; the_semaphore->linked = false; } the_sem_attr = &the_semaphore->Semaphore.Attributes; 1149fc: 8d 46 5c lea 0x5c(%esi),%eax /* * This effectively disables limit checking. */ the_sem_attr->maximum_count = 0xFFFFFFFF; _CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value ); 1149ff: 50 push %eax 114a00: 8d 46 1c lea 0x1c(%esi),%eax 114a03: 50 push %eax 114a04: e8 a7 b3 ff ff call 10fdb0 <_CORE_semaphore_Initialize> Objects_Information *information, Objects_Control *the_object, const char *name ) { _Objects_Set_local_object( 114a09: 0f b7 56 08 movzwl 0x8(%esi),%edx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 114a0d: a1 3c de 12 00 mov 0x12de3c,%eax 114a12: 89 34 90 mov %esi,(%eax,%edx,4) the_object ); #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) /* ASSERT: information->is_string */ the_object->name.name_p = name; 114a15: 89 5e 0c mov %ebx,0xc(%esi) &_POSIX_Semaphore_Information, &the_semaphore->Object, name_p ); *the_sem = the_semaphore; 114a18: 8b 45 14 mov 0x14(%ebp),%eax 114a1b: 89 30 mov %esi,(%eax) _Thread_Enable_dispatch(); 114a1d: e8 b2 c9 ff ff call 1113d4 <_Thread_Enable_dispatch> return 0; 114a22: 83 c4 10 add $0x10,%esp 114a25: 31 c0 xor %eax,%eax } 114a27: 8d 65 f8 lea -0x8(%ebp),%esp 114a2a: 5b pop %ebx 114a2b: 5e pop %esi 114a2c: c9 leave 114a2d: c3 ret 114a2e: 66 90 xchg %ax,%ax if ( name ) { the_semaphore->named = true; the_semaphore->open_count = 1; the_semaphore->linked = true; } else { the_semaphore->named = false; 114a30: c6 40 14 00 movb $0x0,0x14(%eax) the_semaphore->open_count = 0; 114a34: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) the_semaphore->linked = false; 114a3b: c6 40 15 00 movb $0x0,0x15(%eax) 114a3f: eb a9 jmp 1149ea <_POSIX_Semaphore_Create_support+0x72> 114a41: 8d 76 00 lea 0x0(%esi),%esi CORE_semaphore_Attributes *the_sem_attr; char *name_p = (char *)name; /* Sharing semaphores among processes is not currently supported */ if (pshared != 0) rtems_set_errno_and_return_minus_one( ENOSYS ); 114a44: e8 5f 2b 00 00 call 1175a8 <__errno> 114a49: c7 00 58 00 00 00 movl $0x58,(%eax) 114a4f: b8 ff ff ff ff mov $0xffffffff,%eax 114a54: eb d1 jmp 114a27 <_POSIX_Semaphore_Create_support+0xaf> 114a56: 66 90 xchg %ax,%ax if ( name ) { if ( strnlen( name, NAME_MAX ) >= NAME_MAX ) rtems_set_errno_and_return_minus_one( ENAMETOOLONG ); 114a58: e8 4b 2b 00 00 call 1175a8 <__errno> 114a5d: c7 00 5b 00 00 00 movl $0x5b,(%eax) 114a63: b8 ff ff ff ff mov $0xffffffff,%eax 114a68: eb bd jmp 114a27 <_POSIX_Semaphore_Create_support+0xaf> _Thread_Disable_dispatch(); the_semaphore = _POSIX_Semaphore_Allocate(); if ( !the_semaphore ) { _Thread_Enable_dispatch(); 114a6a: e8 65 c9 ff ff call 1113d4 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( ENOSPC ); 114a6f: e8 34 2b 00 00 call 1175a8 <__errno> 114a74: c7 00 1c 00 00 00 movl $0x1c,(%eax) 114a7a: b8 ff ff ff ff mov $0xffffffff,%eax 114a7f: eb a6 jmp 114a27 <_POSIX_Semaphore_Create_support+0xaf> =============================================================================== 00114ad4 <_POSIX_Semaphore_Name_to_id>: int _POSIX_Semaphore_Name_to_id( const char *name, sem_t *id ) { 114ad4: 55 push %ebp 114ad5: 89 e5 mov %esp,%ebp 114ad7: 83 ec 18 sub $0x18,%esp 114ada: 8b 45 08 mov 0x8(%ebp),%eax Objects_Name_or_id_lookup_errors status; Objects_Id the_id; if ( !name ) 114add: 85 c0 test %eax,%eax 114adf: 74 05 je 114ae6 <_POSIX_Semaphore_Name_to_id+0x12> return EINVAL; if ( !name[0] ) 114ae1: 80 38 00 cmpb $0x0,(%eax) 114ae4: 75 0a jne 114af0 <_POSIX_Semaphore_Name_to_id+0x1c> return EINVAL; 114ae6: b8 16 00 00 00 mov $0x16,%eax if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL ) return 0; return ENOENT; } 114aeb: c9 leave 114aec: c3 ret 114aed: 8d 76 00 lea 0x0(%esi),%esi return EINVAL; if ( !name[0] ) return EINVAL; status = _Objects_Name_to_id_string( 114af0: 52 push %edx 114af1: 8d 55 f4 lea -0xc(%ebp),%edx 114af4: 52 push %edx 114af5: 50 push %eax 114af6: 68 20 de 12 00 push $0x12de20 114afb: e8 7c 0c 00 00 call 11577c <_Objects_Name_to_id_string> &_POSIX_Semaphore_Information, name, &the_id ); *id = the_id; 114b00: 8b 4d f4 mov -0xc(%ebp),%ecx 114b03: 8b 55 0c mov 0xc(%ebp),%edx 114b06: 89 0a mov %ecx,(%edx) if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL ) 114b08: 83 c4 10 add $0x10,%esp return 0; 114b0b: 83 f8 01 cmp $0x1,%eax 114b0e: 19 c0 sbb %eax,%eax 114b10: f7 d0 not %eax 114b12: 83 e0 02 and $0x2,%eax return ENOENT; } 114b15: c9 leave 114b16: c3 ret =============================================================================== 00114b40 <_POSIX_Semaphore_Wait_support>: int _POSIX_Semaphore_Wait_support( sem_t *sem, bool blocking, Watchdog_Interval timeout ) { 114b40: 55 push %ebp 114b41: 89 e5 mov %esp,%ebp 114b43: 53 push %ebx 114b44: 83 ec 18 sub $0x18,%esp 114b47: 8a 5d 0c mov 0xc(%ebp),%bl POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); 114b4a: 8d 45 f4 lea -0xc(%ebp),%eax sem_t *id, Objects_Locations *location ) { return (POSIX_Semaphore_Control *) _Objects_Get( &_POSIX_Semaphore_Information, (Objects_Id)*id, location ); 114b4d: 50 push %eax 114b4e: 8b 45 08 mov 0x8(%ebp),%eax 114b51: ff 30 pushl (%eax) 114b53: 68 20 de 12 00 push $0x12de20 114b58: e8 7f bc ff ff call 1107dc <_Objects_Get> switch ( location ) { 114b5d: 83 c4 10 add $0x10,%esp 114b60: 8b 55 f4 mov -0xc(%ebp),%edx 114b63: 85 d2 test %edx,%edx 114b65: 74 15 je 114b7c <_POSIX_Semaphore_Wait_support+0x3c> #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 114b67: e8 3c 2a 00 00 call 1175a8 <__errno> 114b6c: c7 00 16 00 00 00 movl $0x16,(%eax) 114b72: b8 ff ff ff ff mov $0xffffffff,%eax } 114b77: 8b 5d fc mov -0x4(%ebp),%ebx 114b7a: c9 leave 114b7b: c3 ret the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { case OBJECTS_LOCAL: _CORE_semaphore_Seize( 114b7c: ff 75 10 pushl 0x10(%ebp) 114b7f: 0f b6 db movzbl %bl,%ebx 114b82: 53 push %ebx 114b83: ff 70 08 pushl 0x8(%eax) 114b86: 83 c0 1c add $0x1c,%eax 114b89: 50 push %eax 114b8a: e8 29 07 00 00 call 1152b8 <_CORE_semaphore_Seize> &the_semaphore->Semaphore, the_semaphore->Object.id, blocking, timeout ); _Thread_Enable_dispatch(); 114b8f: e8 40 c8 ff ff call 1113d4 <_Thread_Enable_dispatch> if ( !_Thread_Executing->Wait.return_code ) 114b94: 83 c4 10 add $0x10,%esp 114b97: a1 b8 e0 12 00 mov 0x12e0b8,%eax 114b9c: 8b 40 34 mov 0x34(%eax),%eax 114b9f: 85 c0 test %eax,%eax 114ba1: 75 09 jne 114bac <_POSIX_Semaphore_Wait_support+0x6c> return 0; 114ba3: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 114ba5: 8b 5d fc mov -0x4(%ebp),%ebx 114ba8: c9 leave 114ba9: c3 ret 114baa: 66 90 xchg %ax,%ax _Thread_Enable_dispatch(); if ( !_Thread_Executing->Wait.return_code ) return 0; rtems_set_errno_and_return_minus_one( 114bac: e8 f7 29 00 00 call 1175a8 <__errno> 114bb1: 89 c3 mov %eax,%ebx 114bb3: 83 ec 0c sub $0xc,%esp 114bb6: a1 b8 e0 12 00 mov 0x12e0b8,%eax 114bbb: ff 70 34 pushl 0x34(%eax) 114bbe: e8 55 25 00 00 call 117118 <_POSIX_Semaphore_Translate_core_semaphore_return_code> 114bc3: 89 03 mov %eax,(%ebx) 114bc5: 83 c4 10 add $0x10,%esp 114bc8: b8 ff ff ff ff mov $0xffffffff,%eax 114bcd: eb a8 jmp 114b77 <_POSIX_Semaphore_Wait_support+0x37> =============================================================================== 001106fc <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch>: #include void _POSIX_Thread_Evaluate_cancellation_and_enable_dispatch( Thread_Control *the_thread ) { 1106fc: 55 push %ebp 1106fd: 89 e5 mov %esp,%ebp 1106ff: 83 ec 08 sub $0x8,%esp 110702: 8b 55 08 mov 0x8(%ebp),%edx POSIX_API_Control *thread_support; thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ]; 110705: 8b 82 ec 00 00 00 mov 0xec(%edx),%eax if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 11070b: 8b 88 d8 00 00 00 mov 0xd8(%eax),%ecx 110711: 85 c9 test %ecx,%ecx 110713: 75 09 jne 11071e <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x22><== NEVER TAKEN 110715: 83 b8 dc 00 00 00 01 cmpl $0x1,0xdc(%eax) 11071c: 74 06 je 110724 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x28> _Thread_Unnest_dispatch(); _POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED ); } else _Thread_Enable_dispatch(); } 11071e: c9 leave thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && thread_support->cancelation_requested ) { _Thread_Unnest_dispatch(); _POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED ); } else _Thread_Enable_dispatch(); 11071f: e9 d4 d6 ff ff jmp 10ddf8 <_Thread_Enable_dispatch> POSIX_API_Control *thread_support; thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && 110724: 8b 80 e0 00 00 00 mov 0xe0(%eax),%eax 11072a: 85 c0 test %eax,%eax 11072c: 74 f0 je 11071e <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x22> */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 11072e: a1 b0 90 12 00 mov 0x1290b0,%eax 110733: 48 dec %eax 110734: a3 b0 90 12 00 mov %eax,0x1290b0 thread_support->cancelation_requested ) { _Thread_Unnest_dispatch(); _POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED ); 110739: 83 ec 08 sub $0x8,%esp 11073c: 6a ff push $0xffffffff 11073e: 52 push %edx 11073f: e8 c0 08 00 00 call 111004 <_POSIX_Thread_Exit> 110744: 83 c4 10 add $0x10,%esp } else _Thread_Enable_dispatch(); } 110747: c9 leave 110748: c3 ret =============================================================================== 00111a6c <_POSIX_Thread_Translate_sched_param>: int policy, struct sched_param *param, Thread_CPU_budget_algorithms *budget_algorithm, Thread_CPU_budget_algorithm_callout *budget_callout ) { 111a6c: 55 push %ebp 111a6d: 89 e5 mov %esp,%ebp 111a6f: 57 push %edi 111a70: 56 push %esi 111a71: 53 push %ebx 111a72: 83 ec 18 sub $0x18,%esp 111a75: 8b 5d 08 mov 0x8(%ebp),%ebx 111a78: 8b 75 0c mov 0xc(%ebp),%esi 111a7b: 8b 7d 10 mov 0x10(%ebp),%edi if ( !_POSIX_Priority_Is_valid( param->sched_priority ) ) 111a7e: ff 36 pushl (%esi) 111a80: e8 cb ff ff ff call 111a50 <_POSIX_Priority_Is_valid> 111a85: 83 c4 10 add $0x10,%esp 111a88: 84 c0 test %al,%al 111a8a: 74 2a je 111ab6 <_POSIX_Thread_Translate_sched_param+0x4a><== NEVER TAKEN return EINVAL; *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; 111a8c: c7 07 00 00 00 00 movl $0x0,(%edi) *budget_callout = NULL; 111a92: 8b 45 14 mov 0x14(%ebp),%eax 111a95: c7 00 00 00 00 00 movl $0x0,(%eax) if ( policy == SCHED_OTHER ) { 111a9b: 85 db test %ebx,%ebx 111a9d: 74 25 je 111ac4 <_POSIX_Thread_Translate_sched_param+0x58> *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; return 0; } if ( policy == SCHED_FIFO ) { 111a9f: 83 fb 01 cmp $0x1,%ebx 111aa2: 0f 84 90 00 00 00 je 111b38 <_POSIX_Thread_Translate_sched_param+0xcc> *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; return 0; } if ( policy == SCHED_RR ) { 111aa8: 83 fb 02 cmp $0x2,%ebx 111aab: 0f 84 8f 00 00 00 je 111b40 <_POSIX_Thread_Translate_sched_param+0xd4> *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE; return 0; } if ( policy == SCHED_SPORADIC ) { 111ab1: 83 fb 04 cmp $0x4,%ebx 111ab4: 74 1e je 111ad4 <_POSIX_Thread_Translate_sched_param+0x68> if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) < _Timespec_To_ticks( ¶m->sched_ss_init_budget ) ) return EINVAL; if ( !_POSIX_Priority_Is_valid( param->sched_ss_low_priority ) ) return EINVAL; 111ab6: b8 16 00 00 00 mov $0x16,%eax *budget_callout = _POSIX_Threads_Sporadic_budget_callout; return 0; } return EINVAL; } 111abb: 8d 65 f4 lea -0xc(%ebp),%esp 111abe: 5b pop %ebx 111abf: 5e pop %esi 111ac0: 5f pop %edi 111ac1: c9 leave 111ac2: c3 ret 111ac3: 90 nop *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; *budget_callout = NULL; if ( policy == SCHED_OTHER ) { *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; 111ac4: c7 07 01 00 00 00 movl $0x1,(%edi) return 0; 111aca: 31 c0 xor %eax,%eax *budget_callout = _POSIX_Threads_Sporadic_budget_callout; return 0; } return EINVAL; } 111acc: 8d 65 f4 lea -0xc(%ebp),%esp 111acf: 5b pop %ebx 111ad0: 5e pop %esi 111ad1: 5f pop %edi 111ad2: c9 leave 111ad3: c3 ret *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE; return 0; } if ( policy == SCHED_SPORADIC ) { if ( (param->sched_ss_repl_period.tv_sec == 0) && 111ad4: 8b 5e 08 mov 0x8(%esi),%ebx 111ad7: 85 db test %ebx,%ebx 111ad9: 75 07 jne 111ae2 <_POSIX_Thread_Translate_sched_param+0x76> 111adb: 8b 4e 0c mov 0xc(%esi),%ecx 111ade: 85 c9 test %ecx,%ecx 111ae0: 74 d4 je 111ab6 <_POSIX_Thread_Translate_sched_param+0x4a> (param->sched_ss_repl_period.tv_nsec == 0) ) return EINVAL; if ( (param->sched_ss_init_budget.tv_sec == 0) && 111ae2: 8b 56 10 mov 0x10(%esi),%edx 111ae5: 85 d2 test %edx,%edx 111ae7: 75 07 jne 111af0 <_POSIX_Thread_Translate_sched_param+0x84> 111ae9: 8b 46 14 mov 0x14(%esi),%eax 111aec: 85 c0 test %eax,%eax 111aee: 74 c6 je 111ab6 <_POSIX_Thread_Translate_sched_param+0x4a> (param->sched_ss_init_budget.tv_nsec == 0) ) return EINVAL; if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) < 111af0: 83 ec 0c sub $0xc,%esp 111af3: 8d 46 08 lea 0x8(%esi),%eax 111af6: 50 push %eax 111af7: e8 00 da ff ff call 10f4fc <_Timespec_To_ticks> 111afc: 89 c3 mov %eax,%ebx _Timespec_To_ticks( ¶m->sched_ss_init_budget ) ) 111afe: 8d 46 10 lea 0x10(%esi),%eax 111b01: 89 04 24 mov %eax,(%esp) 111b04: e8 f3 d9 ff ff call 10f4fc <_Timespec_To_ticks> if ( (param->sched_ss_init_budget.tv_sec == 0) && (param->sched_ss_init_budget.tv_nsec == 0) ) return EINVAL; if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) < 111b09: 83 c4 10 add $0x10,%esp 111b0c: 39 c3 cmp %eax,%ebx 111b0e: 72 a6 jb 111ab6 <_POSIX_Thread_Translate_sched_param+0x4a> _Timespec_To_ticks( ¶m->sched_ss_init_budget ) ) return EINVAL; if ( !_POSIX_Priority_Is_valid( param->sched_ss_low_priority ) ) 111b10: 83 ec 0c sub $0xc,%esp 111b13: ff 76 04 pushl 0x4(%esi) 111b16: e8 35 ff ff ff call 111a50 <_POSIX_Priority_Is_valid> 111b1b: 83 c4 10 add $0x10,%esp 111b1e: 84 c0 test %al,%al 111b20: 74 94 je 111ab6 <_POSIX_Thread_Translate_sched_param+0x4a> return EINVAL; *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT; 111b22: c7 07 03 00 00 00 movl $0x3,(%edi) *budget_callout = _POSIX_Threads_Sporadic_budget_callout; 111b28: 8b 45 14 mov 0x14(%ebp),%eax 111b2b: c7 00 14 bd 10 00 movl $0x10bd14,(%eax) return 0; 111b31: 31 c0 xor %eax,%eax 111b33: eb 86 jmp 111abb <_POSIX_Thread_Translate_sched_param+0x4f> 111b35: 8d 76 00 lea 0x0(%esi),%esi return 0; } if ( policy == SCHED_FIFO ) { *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; return 0; 111b38: 31 c0 xor %eax,%eax 111b3a: e9 7c ff ff ff jmp 111abb <_POSIX_Thread_Translate_sched_param+0x4f> 111b3f: 90 nop } if ( policy == SCHED_RR ) { *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE; 111b40: c7 07 02 00 00 00 movl $0x2,(%edi) return 0; 111b46: 31 c0 xor %eax,%eax 111b48: e9 6e ff ff ff jmp 111abb <_POSIX_Thread_Translate_sched_param+0x4f> =============================================================================== 00110918 <_POSIX_Threads_Create_extension>: bool _POSIX_Threads_Create_extension( Thread_Control *executing __attribute__((unused)), Thread_Control *created ) { 110918: 55 push %ebp 110919: 89 e5 mov %esp,%ebp 11091b: 57 push %edi 11091c: 56 push %esi 11091d: 53 push %ebx 11091e: 83 ec 28 sub $0x28,%esp 110921: 8b 55 0c mov 0xc(%ebp),%edx POSIX_API_Control *api; POSIX_API_Control *executing_api; api = _Workspace_Allocate( sizeof( POSIX_API_Control ) ); 110924: 68 f0 00 00 00 push $0xf0 110929: 89 55 e4 mov %edx,-0x1c(%ebp) 11092c: e8 57 e0 ff ff call 10e988 <_Workspace_Allocate> 110931: 89 c3 mov %eax,%ebx if ( !api ) 110933: 83 c4 10 add $0x10,%esp 110936: 85 c0 test %eax,%eax 110938: 8b 55 e4 mov -0x1c(%ebp),%edx 11093b: 0f 84 2f 01 00 00 je 110a70 <_POSIX_Threads_Create_extension+0x158><== NEVER TAKEN return false; created->API_Extensions[ THREAD_API_POSIX ] = api; 110941: 89 82 ec 00 00 00 mov %eax,0xec(%edx) /* XXX check all fields are touched */ api->Attributes = _POSIX_Threads_Default_attributes; 110947: b9 40 00 00 00 mov $0x40,%ecx 11094c: 31 c0 xor %eax,%eax 11094e: 89 df mov %ebx,%edi 110950: f3 aa rep stos %al,%es:(%edi) 110952: c7 03 01 00 00 00 movl $0x1,(%ebx) 110958: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx) 11095f: c7 43 14 01 00 00 00 movl $0x1,0x14(%ebx) 110966: c7 43 18 02 00 00 00 movl $0x2,0x18(%ebx) 11096d: c7 43 38 01 00 00 00 movl $0x1,0x38(%ebx) 110974: c7 43 3c 01 00 00 00 movl $0x1,0x3c(%ebx) api->detachstate = _POSIX_Threads_Default_attributes.detachstate; 11097b: c7 43 40 01 00 00 00 movl $0x1,0x40(%ebx) api->schedpolicy = _POSIX_Threads_Default_attributes.schedpolicy; 110982: c7 83 84 00 00 00 01 movl $0x1,0x84(%ebx) 110989: 00 00 00 api->schedparam = _POSIX_Threads_Default_attributes.schedparam; 11098c: be 78 1b 12 00 mov $0x121b78,%esi 110991: 8d bb 88 00 00 00 lea 0x88(%ebx),%edi 110997: b1 07 mov $0x7,%cl 110999: f3 a5 rep movsl %ds:(%esi),%es:(%edi) RTEMS_INLINE_ROUTINE int _POSIX_Priority_From_core( Priority_Control priority ) { return (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1); 11099b: 0f b6 05 74 3a 12 00 movzbl 0x123a74,%eax 1109a2: 2b 42 14 sub 0x14(%edx),%eax 1109a5: 89 83 88 00 00 00 mov %eax,0x88(%ebx) _POSIX_Priority_From_core( created->current_priority ); /* * POSIX 1003.1 1996, 18.2.2.2 */ api->cancelation_requested = 0; 1109ab: c7 83 e0 00 00 00 00 movl $0x0,0xe0(%ebx) 1109b2: 00 00 00 api->cancelability_state = PTHREAD_CANCEL_ENABLE; 1109b5: c7 83 d8 00 00 00 00 movl $0x0,0xd8(%ebx) 1109bc: 00 00 00 api->cancelability_type = PTHREAD_CANCEL_DEFERRED; 1109bf: c7 83 dc 00 00 00 00 movl $0x0,0xdc(%ebx) 1109c6: 00 00 00 RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); 1109c9: 8d 83 e8 00 00 00 lea 0xe8(%ebx),%eax 1109cf: 89 83 e4 00 00 00 mov %eax,0xe4(%ebx) head->next = tail; head->previous = NULL; 1109d5: c7 83 e8 00 00 00 00 movl $0x0,0xe8(%ebx) 1109dc: 00 00 00 */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); 1109df: 8d 83 e4 00 00 00 lea 0xe4(%ebx),%eax 1109e5: 89 83 ec 00 00 00 mov %eax,0xec(%ebx) * * The check for class == 1 is debug. Should never really happen. */ /* XXX use signal constants */ api->signals_pending = 0; 1109eb: c7 83 d4 00 00 00 00 movl $0x0,0xd4(%ebx) 1109f2: 00 00 00 1109f5: 0f b6 42 0b movzbl 0xb(%edx),%eax 1109f9: 83 e0 07 and $0x7,%eax if ( _Objects_Get_API( created->Object.id ) == OBJECTS_POSIX_API 1109fc: 83 f8 03 cmp $0x3,%eax 1109ff: 74 53 je 110a54 <_POSIX_Threads_Create_extension+0x13c> #endif ) { executing_api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; api->signals_blocked = executing_api->signals_blocked; } else { api->signals_blocked = 0xffffffff; 110a01: c7 83 d0 00 00 00 ff movl $0xffffffff,0xd0(%ebx) 110a08: ff ff ff } _Thread_queue_Initialize( 110a0b: 6a 00 push $0x0 110a0d: 68 00 10 00 00 push $0x1000 110a12: 6a 00 push $0x0 110a14: 8d 43 44 lea 0x44(%ebx),%eax 110a17: 50 push %eax 110a18: 89 55 e4 mov %edx,-0x1c(%ebp) 110a1b: e8 9c d6 ff ff call 10e0bc <_Thread_queue_Initialize> THREAD_QUEUE_DISCIPLINE_FIFO, STATES_WAITING_FOR_JOIN_AT_EXIT, 0 ); _Watchdog_Initialize( 110a20: 8b 55 e4 mov -0x1c(%ebp),%edx 110a23: 8b 42 08 mov 0x8(%edx),%eax Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 110a26: c7 83 b0 00 00 00 00 movl $0x0,0xb0(%ebx) 110a2d: 00 00 00 the_watchdog->routine = routine; 110a30: c7 83 c4 00 00 00 7c movl $0x110a7c,0xc4(%ebx) 110a37: 0a 11 00 the_watchdog->id = id; 110a3a: 89 83 c8 00 00 00 mov %eax,0xc8(%ebx) the_watchdog->user_data = user_data; 110a40: 89 93 cc 00 00 00 mov %edx,0xcc(%ebx) _POSIX_Threads_Sporadic_budget_TSR, created->Object.id, created ); return true; 110a46: 83 c4 10 add $0x10,%esp 110a49: b0 01 mov $0x1,%al } 110a4b: 8d 65 f4 lea -0xc(%ebp),%esp 110a4e: 5b pop %ebx 110a4f: 5e pop %esi 110a50: 5f pop %edi 110a51: c9 leave 110a52: c3 ret 110a53: 90 nop if ( _Objects_Get_API( created->Object.id ) == OBJECTS_POSIX_API #if defined(RTEMS_DEBUG) && _Objects_Get_class( created->Object.id ) == 1 #endif ) { executing_api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 110a54: a1 38 83 12 00 mov 0x128338,%eax api->signals_blocked = executing_api->signals_blocked; 110a59: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax 110a5f: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax 110a65: 89 83 d0 00 00 00 mov %eax,0xd0(%ebx) 110a6b: eb 9e jmp 110a0b <_POSIX_Threads_Create_extension+0xf3> 110a6d: 8d 76 00 lea 0x0(%esi),%esi POSIX_API_Control *executing_api; api = _Workspace_Allocate( sizeof( POSIX_API_Control ) ); if ( !api ) return false; 110a70: 31 c0 xor %eax,%eax created->Object.id, created ); return true; } 110a72: 8d 65 f4 lea -0xc(%ebp),%esp 110a75: 5b pop %ebx 110a76: 5e pop %esi 110a77: 5f pop %edi 110a78: c9 leave 110a79: c3 ret =============================================================================== 00110890 <_POSIX_Threads_Delete_extension>: */ void _POSIX_Threads_Delete_extension( Thread_Control *executing __attribute__((unused)), Thread_Control *deleted ) { 110890: 55 push %ebp 110891: 89 e5 mov %esp,%ebp 110893: 57 push %edi 110894: 56 push %esi 110895: 53 push %ebx 110896: 83 ec 28 sub $0x28,%esp 110899: 8b 7d 0c mov 0xc(%ebp),%edi Thread_Control *the_thread; POSIX_API_Control *api; void **value_ptr; api = deleted->API_Extensions[ THREAD_API_POSIX ]; 11089c: 8b 87 ec 00 00 00 mov 0xec(%edi),%eax 1108a2: 89 45 e4 mov %eax,-0x1c(%ebp) /* * Run the POSIX cancellation handlers */ _POSIX_Threads_cancel_run( deleted ); 1108a5: 57 push %edi 1108a6: e8 fd 21 00 00 call 112aa8 <_POSIX_Threads_cancel_run> /* * Run all the key destructors */ _POSIX_Keys_Run_destructors( deleted ); 1108ab: 89 3c 24 mov %edi,(%esp) 1108ae: e8 5d 22 00 00 call 112b10 <_POSIX_Keys_Run_destructors> /* * Wakeup all the tasks which joined with this one */ value_ptr = (void **) deleted->Wait.return_argument; 1108b3: 8b 77 28 mov 0x28(%edi),%esi while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) ) 1108b6: 83 c4 10 add $0x10,%esp 1108b9: 8b 45 e4 mov -0x1c(%ebp),%eax 1108bc: 8d 58 44 lea 0x44(%eax),%ebx 1108bf: eb 08 jmp 1108c9 <_POSIX_Threads_Delete_extension+0x39> 1108c1: 8d 76 00 lea 0x0(%esi),%esi *(void **)the_thread->Wait.return_argument = value_ptr; 1108c4: 8b 40 28 mov 0x28(%eax),%eax 1108c7: 89 30 mov %esi,(%eax) /* * Wakeup all the tasks which joined with this one */ value_ptr = (void **) deleted->Wait.return_argument; while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) ) 1108c9: 83 ec 0c sub $0xc,%esp 1108cc: 53 push %ebx 1108cd: e8 5a d4 ff ff call 10dd2c <_Thread_queue_Dequeue> 1108d2: 83 c4 10 add $0x10,%esp 1108d5: 85 c0 test %eax,%eax 1108d7: 75 eb jne 1108c4 <_POSIX_Threads_Delete_extension+0x34> *(void **)the_thread->Wait.return_argument = value_ptr; if ( api->schedpolicy == SCHED_SPORADIC ) 1108d9: 8b 45 e4 mov -0x1c(%ebp),%eax 1108dc: 83 b8 84 00 00 00 04 cmpl $0x4,0x84(%eax) 1108e3: 74 1f je 110904 <_POSIX_Threads_Delete_extension+0x74> (void) _Watchdog_Remove( &api->Sporadic_timer ); deleted->API_Extensions[ THREAD_API_POSIX ] = NULL; 1108e5: c7 87 ec 00 00 00 00 movl $0x0,0xec(%edi) 1108ec: 00 00 00 _Workspace_Free( api ); 1108ef: 8b 45 e4 mov -0x1c(%ebp),%eax 1108f2: 89 45 08 mov %eax,0x8(%ebp) } 1108f5: 8d 65 f4 lea -0xc(%ebp),%esp 1108f8: 5b pop %ebx 1108f9: 5e pop %esi 1108fa: 5f pop %edi 1108fb: c9 leave if ( api->schedpolicy == SCHED_SPORADIC ) (void) _Watchdog_Remove( &api->Sporadic_timer ); deleted->API_Extensions[ THREAD_API_POSIX ] = NULL; _Workspace_Free( api ); 1108fc: e9 a3 e0 ff ff jmp 10e9a4 <_Workspace_Free> 110901: 8d 76 00 lea 0x0(%esi),%esi while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) ) *(void **)the_thread->Wait.return_argument = value_ptr; if ( api->schedpolicy == SCHED_SPORADIC ) (void) _Watchdog_Remove( &api->Sporadic_timer ); 110904: 83 ec 0c sub $0xc,%esp 110907: 05 a8 00 00 00 add $0xa8,%eax 11090c: 50 push %eax 11090d: e8 4e df ff ff call 10e860 <_Watchdog_Remove> 110912: 83 c4 10 add $0x10,%esp 110915: eb ce jmp 1108e5 <_POSIX_Threads_Delete_extension+0x55> =============================================================================== 00110854 <_POSIX_Threads_Initialize_user_threads>: * * This routine creates and starts all configured user * initialzation threads. */ void _POSIX_Threads_Initialize_user_threads( void ) { 110854: 55 push %ebp 110855: 89 e5 mov %esp,%ebp 110857: 83 ec 08 sub $0x8,%esp if ( _POSIX_Threads_Initialize_user_threads_p ) 11085a: a1 38 60 12 00 mov 0x126038,%eax 11085f: 85 c0 test %eax,%eax 110861: 74 05 je 110868 <_POSIX_Threads_Initialize_user_threads+0x14> (*_POSIX_Threads_Initialize_user_threads_p)(); } 110863: c9 leave * initialzation threads. */ void _POSIX_Threads_Initialize_user_threads( void ) { if ( _POSIX_Threads_Initialize_user_threads_p ) (*_POSIX_Threads_Initialize_user_threads_p)(); 110864: ff e0 jmp *%eax 110866: 66 90 xchg %ax,%ax } 110868: c9 leave 110869: c3 ret =============================================================================== 0010b9f4 <_POSIX_Threads_Initialize_user_threads_body>: * * Output parameters: NONE */ void _POSIX_Threads_Initialize_user_threads_body(void) { 10b9f4: 55 push %ebp 10b9f5: 89 e5 mov %esp,%ebp 10b9f7: 57 push %edi 10b9f8: 56 push %esi 10b9f9: 53 push %ebx 10b9fa: 83 ec 6c sub $0x6c,%esp uint32_t maximum; posix_initialization_threads_table *user_threads; pthread_t thread_id; pthread_attr_t attr; user_threads = Configuration_POSIX_API.User_initialization_threads_table; 10b9fd: 8b 3d 94 4d 12 00 mov 0x124d94,%edi maximum = Configuration_POSIX_API.number_of_initialization_threads; 10ba03: a1 90 4d 12 00 mov 0x124d90,%eax 10ba08: 89 45 94 mov %eax,-0x6c(%ebp) if ( !user_threads || maximum == 0 ) 10ba0b: 85 ff test %edi,%edi 10ba0d: 74 44 je 10ba53 <_POSIX_Threads_Initialize_user_threads_body+0x5f><== NEVER TAKEN 10ba0f: 85 c0 test %eax,%eax 10ba11: 74 40 je 10ba53 <_POSIX_Threads_Initialize_user_threads_body+0x5f><== NEVER TAKEN 10ba13: 31 db xor %ebx,%ebx 10ba15: 8d 75 a4 lea -0x5c(%ebp),%esi for ( index=0 ; index < maximum ; index++ ) { /* * There is no way for these calls to fail in this situation. */ (void) pthread_attr_init( &attr ); 10ba18: 83 ec 0c sub $0xc,%esp 10ba1b: 56 push %esi 10ba1c: e8 2f 61 00 00 call 111b50 (void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED ); 10ba21: 5a pop %edx 10ba22: 59 pop %ecx 10ba23: 6a 02 push $0x2 10ba25: 56 push %esi 10ba26: e8 51 61 00 00 call 111b7c (void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size); 10ba2b: 59 pop %ecx 10ba2c: 58 pop %eax 10ba2d: ff 74 df 04 pushl 0x4(%edi,%ebx,8) 10ba31: 56 push %esi 10ba32: e8 79 61 00 00 call 111bb0 status = pthread_create( 10ba37: 6a 00 push $0x0 10ba39: ff 34 df pushl (%edi,%ebx,8) 10ba3c: 56 push %esi 10ba3d: 8d 45 e4 lea -0x1c(%ebp),%eax 10ba40: 50 push %eax 10ba41: e8 92 fc ff ff call 10b6d8 &thread_id, &attr, user_threads[ index ].thread_entry, NULL ); if ( status ) 10ba46: 83 c4 20 add $0x20,%esp 10ba49: 85 c0 test %eax,%eax 10ba4b: 75 0e jne 10ba5b <_POSIX_Threads_Initialize_user_threads_body+0x67> * * Setting the attributes explicitly is critical, since we don't want * to inherit the idle tasks attributes. */ for ( index=0 ; index < maximum ; index++ ) { 10ba4d: 43 inc %ebx 10ba4e: 39 5d 94 cmp %ebx,-0x6c(%ebp) 10ba51: 77 c5 ja 10ba18 <_POSIX_Threads_Initialize_user_threads_body+0x24><== NEVER TAKEN NULL ); if ( status ) _Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status ); } } 10ba53: 8d 65 f4 lea -0xc(%ebp),%esp 10ba56: 5b pop %ebx 10ba57: 5e pop %esi 10ba58: 5f pop %edi 10ba59: c9 leave 10ba5a: c3 ret &attr, user_threads[ index ].thread_entry, NULL ); if ( status ) _Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status ); 10ba5b: 52 push %edx 10ba5c: 50 push %eax 10ba5d: 6a 01 push $0x1 10ba5f: 6a 02 push $0x2 10ba61: e8 c2 1e 00 00 call 10d928 <_Internal_error_Occurred> =============================================================================== 00110a7c <_POSIX_Threads_Sporadic_budget_TSR>: */ void _POSIX_Threads_Sporadic_budget_TSR( Objects_Id id __attribute__((unused)), void *argument ) { 110a7c: 55 push %ebp 110a7d: 89 e5 mov %esp,%ebp 110a7f: 56 push %esi 110a80: 53 push %ebx 110a81: 8b 75 0c mov 0xc(%ebp),%esi Thread_Control *the_thread; POSIX_API_Control *api; the_thread = argument; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 110a84: 8b 9e ec 00 00 00 mov 0xec(%esi),%ebx /* ticks is guaranteed to be at least one */ ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_init_budget ); 110a8a: 83 ec 0c sub $0xc,%esp 110a8d: 8d 83 98 00 00 00 lea 0x98(%ebx),%eax 110a93: 50 push %eax 110a94: e8 7f 0e 00 00 call 111918 <_Timespec_To_ticks> the_thread->cpu_time_budget = ticks; 110a99: 89 46 78 mov %eax,0x78(%esi) RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core( int priority ) { return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1); 110a9c: 0f b6 05 74 3a 12 00 movzbl 0x123a74,%eax 110aa3: 2b 83 88 00 00 00 sub 0x88(%ebx),%eax new_priority = _POSIX_Priority_To_core( api->schedparam.sched_priority ); the_thread->real_priority = new_priority; 110aa9: 89 46 18 mov %eax,0x18(%esi) */ #if 0 printk( "TSR %d %d %d\n", the_thread->resource_count, the_thread->current_priority, new_priority ); #endif if ( the_thread->resource_count == 0 ) { 110aac: 83 c4 10 add $0x10,%esp 110aaf: 8b 4e 1c mov 0x1c(%esi),%ecx 110ab2: 85 c9 test %ecx,%ecx 110ab4: 75 05 jne 110abb <_POSIX_Threads_Sporadic_budget_TSR+0x3f><== NEVER TAKEN /* * If this would make them less important, then do not change it. */ if ( the_thread->current_priority > new_priority ) { 110ab6: 39 46 14 cmp %eax,0x14(%esi) 110ab9: 77 35 ja 110af0 <_POSIX_Threads_Sporadic_budget_TSR+0x74> #endif } } /* ticks is guaranteed to be at least one */ ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_repl_period ); 110abb: 83 ec 0c sub $0xc,%esp 110abe: 8d 83 90 00 00 00 lea 0x90(%ebx),%eax 110ac4: 50 push %eax 110ac5: e8 4e 0e 00 00 call 111918 <_Timespec_To_ticks> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 110aca: 89 83 b4 00 00 00 mov %eax,0xb4(%ebx) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 110ad0: 83 c4 10 add $0x10,%esp _Watchdog_Insert_ticks( &api->Sporadic_timer, ticks ); 110ad3: 81 c3 a8 00 00 00 add $0xa8,%ebx 110ad9: 89 5d 0c mov %ebx,0xc(%ebp) 110adc: c7 45 08 60 7e 12 00 movl $0x127e60,0x8(%ebp) } 110ae3: 8d 65 f8 lea -0x8(%ebp),%esp 110ae6: 5b pop %ebx 110ae7: 5e pop %esi 110ae8: c9 leave 110ae9: e9 32 dc ff ff jmp 10e720 <_Watchdog_Insert> 110aee: 66 90 xchg %ax,%ax if ( the_thread->resource_count == 0 ) { /* * If this would make them less important, then do not change it. */ if ( the_thread->current_priority > new_priority ) { _Thread_Change_priority( the_thread, new_priority, true ); 110af0: 52 push %edx 110af1: 6a 01 push $0x1 110af3: 50 push %eax 110af4: 56 push %esi 110af5: e8 7e ca ff ff call 10d578 <_Thread_Change_priority> 110afa: 83 c4 10 add $0x10,%esp 110afd: eb bc jmp 110abb <_POSIX_Threads_Sporadic_budget_TSR+0x3f> =============================================================================== 00110b00 <_POSIX_Threads_Sporadic_budget_callout>: * _POSIX_Threads_Sporadic_budget_callout */ void _POSIX_Threads_Sporadic_budget_callout( Thread_Control *the_thread ) { 110b00: 55 push %ebp 110b01: 89 e5 mov %esp,%ebp 110b03: 83 ec 08 sub $0x8,%esp 110b06: 8b 45 08 mov 0x8(%ebp),%eax POSIX_API_Control *api; uint32_t new_priority; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 110b09: 8b 88 ec 00 00 00 mov 0xec(%eax),%ecx /* * This will prevent the thread from consuming its entire "budget" * while at low priority. */ the_thread->cpu_time_budget = 0xFFFFFFFF; /* XXX should be based on MAX_U32 */ 110b0f: c7 40 78 ff ff ff ff movl $0xffffffff,0x78(%eax) 110b16: 0f b6 15 74 3a 12 00 movzbl 0x123a74,%edx 110b1d: 2b 91 8c 00 00 00 sub 0x8c(%ecx),%edx new_priority = _POSIX_Priority_To_core(api->schedparam.sched_ss_low_priority); the_thread->real_priority = new_priority; 110b23: 89 50 18 mov %edx,0x18(%eax) */ #if 0 printk( "callout %d %d %d\n", the_thread->resource_count, the_thread->current_priority, new_priority ); #endif if ( the_thread->resource_count == 0 ) { 110b26: 8b 48 1c mov 0x1c(%eax),%ecx 110b29: 85 c9 test %ecx,%ecx 110b2b: 75 05 jne 110b32 <_POSIX_Threads_Sporadic_budget_callout+0x32><== NEVER TAKEN /* * Make sure we are actually lowering it. If they have lowered it * to logically lower than sched_ss_low_priority, then we do not want to * change it. */ if ( the_thread->current_priority < new_priority ) { 110b2d: 39 50 14 cmp %edx,0x14(%eax) 110b30: 72 02 jb 110b34 <_POSIX_Threads_Sporadic_budget_callout+0x34><== ALWAYS TAKEN #if 0 printk( "lower priority\n" ); #endif } } } 110b32: c9 leave <== NOT EXECUTED 110b33: c3 ret <== NOT EXECUTED * Make sure we are actually lowering it. If they have lowered it * to logically lower than sched_ss_low_priority, then we do not want to * change it. */ if ( the_thread->current_priority < new_priority ) { _Thread_Change_priority( the_thread, new_priority, true ); 110b34: 51 push %ecx 110b35: 6a 01 push $0x1 110b37: 52 push %edx 110b38: 50 push %eax 110b39: e8 3a ca ff ff call 10d578 <_Thread_Change_priority> 110b3e: 83 c4 10 add $0x10,%esp #if 0 printk( "lower priority\n" ); #endif } } } 110b41: c9 leave 110b42: c3 ret =============================================================================== 00112aa8 <_POSIX_Threads_cancel_run>: #include void _POSIX_Threads_cancel_run( Thread_Control *the_thread ) { 112aa8: 55 push %ebp 112aa9: 89 e5 mov %esp,%ebp 112aab: 57 push %edi 112aac: 56 push %esi 112aad: 53 push %ebx 112aae: 83 ec 0c sub $0xc,%esp POSIX_Cancel_Handler_control *handler; Chain_Control *handler_stack; POSIX_API_Control *thread_support; ISR_Level level; thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ]; 112ab1: 8b 45 08 mov 0x8(%ebp),%eax 112ab4: 8b b0 ec 00 00 00 mov 0xec(%eax),%esi handler_stack = &thread_support->Cancellation_Handlers; thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE; 112aba: c7 86 d8 00 00 00 01 movl $0x1,0xd8(%esi) 112ac1: 00 00 00 RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 112ac4: 8d be e8 00 00 00 lea 0xe8(%esi),%edi while ( !_Chain_Is_empty( handler_stack ) ) { 112aca: 39 be e4 00 00 00 cmp %edi,0xe4(%esi) 112ad0: 74 33 je 112b05 <_POSIX_Threads_cancel_run+0x5d> 112ad2: 66 90 xchg %ax,%ax _ISR_Disable( level ); 112ad4: 9c pushf 112ad5: fa cli 112ad6: 59 pop %ecx handler = (POSIX_Cancel_Handler_control *) 112ad7: 8b 9e ec 00 00 00 mov 0xec(%esi),%ebx ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 112add: 8b 13 mov (%ebx),%edx previous = the_node->previous; 112adf: 8b 43 04 mov 0x4(%ebx),%eax next->previous = previous; 112ae2: 89 42 04 mov %eax,0x4(%edx) previous->next = next; 112ae5: 89 10 mov %edx,(%eax) _Chain_Tail( handler_stack )->previous; _Chain_Extract_unprotected( &handler->Node ); _ISR_Enable( level ); 112ae7: 51 push %ecx 112ae8: 9d popf (*handler->routine)( handler->arg ); 112ae9: 83 ec 0c sub $0xc,%esp 112aec: ff 73 0c pushl 0xc(%ebx) 112aef: ff 53 08 call *0x8(%ebx) _Workspace_Free( handler ); 112af2: 89 1c 24 mov %ebx,(%esp) 112af5: e8 aa be ff ff call 10e9a4 <_Workspace_Free> handler_stack = &thread_support->Cancellation_Handlers; thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE; while ( !_Chain_Is_empty( handler_stack ) ) { 112afa: 83 c4 10 add $0x10,%esp 112afd: 39 be e4 00 00 00 cmp %edi,0xe4(%esi) 112b03: 75 cf jne 112ad4 <_POSIX_Threads_cancel_run+0x2c><== NEVER TAKEN (*handler->routine)( handler->arg ); _Workspace_Free( handler ); } } 112b05: 8d 65 f4 lea -0xc(%ebp),%esp 112b08: 5b pop %ebx 112b09: 5e pop %esi 112b0a: 5f pop %edi 112b0b: c9 leave 112b0c: c3 ret =============================================================================== 0011185c <_POSIX_Timer_Insert_helper>: Watchdog_Interval ticks, Objects_Id id, Watchdog_Service_routine_entry TSR, void *arg ) { 11185c: 55 push %ebp 11185d: 89 e5 mov %esp,%ebp 11185f: 56 push %esi 111860: 53 push %ebx 111861: 8b 5d 08 mov 0x8(%ebp),%ebx ISR_Level level; (void) _Watchdog_Remove( timer ); 111864: 83 ec 0c sub $0xc,%esp 111867: 53 push %ebx 111868: e8 03 db ff ff call 10f370 <_Watchdog_Remove> _ISR_Disable( level ); 11186d: 9c pushf 11186e: fa cli 11186f: 5e pop %esi /* * Check to see if the watchdog has just been inserted by a * higher priority interrupt. If so, abandon this insert. */ if ( timer->state != WATCHDOG_INACTIVE ) { 111870: 83 c4 10 add $0x10,%esp 111873: 8b 43 08 mov 0x8(%ebx),%eax 111876: 85 c0 test %eax,%eax 111878: 74 0e je 111888 <_POSIX_Timer_Insert_helper+0x2c> _ISR_Enable( level ); 11187a: 56 push %esi 11187b: 9d popf return false; 11187c: 31 c0 xor %eax,%eax */ _Watchdog_Initialize( timer, TSR, id, arg ); _Watchdog_Insert_ticks( timer, ticks ); _ISR_Enable( level ); return true; } 11187e: 8d 65 f8 lea -0x8(%ebp),%esp 111881: 5b pop %ebx 111882: 5e pop %esi 111883: c9 leave 111884: c3 ret 111885: 8d 76 00 lea 0x0(%esi),%esi Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 111888: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) the_watchdog->routine = routine; 11188f: 8b 45 14 mov 0x14(%ebp),%eax 111892: 89 43 1c mov %eax,0x1c(%ebx) the_watchdog->id = id; 111895: 8b 45 10 mov 0x10(%ebp),%eax 111898: 89 43 20 mov %eax,0x20(%ebx) the_watchdog->user_data = user_data; 11189b: 8b 45 18 mov 0x18(%ebp),%eax 11189e: 89 43 24 mov %eax,0x24(%ebx) Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 1118a1: 8b 45 0c mov 0xc(%ebp),%eax 1118a4: 89 43 0c mov %eax,0xc(%ebx) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 1118a7: 83 ec 08 sub $0x8,%esp 1118aa: 53 push %ebx 1118ab: 68 a0 a1 12 00 push $0x12a1a0 1118b0: e8 7b d9 ff ff call 10f230 <_Watchdog_Insert> * OK. Now we now the timer was not rescheduled by an interrupt * so we can atomically initialize it as in use. */ _Watchdog_Initialize( timer, TSR, id, arg ); _Watchdog_Insert_ticks( timer, ticks ); _ISR_Enable( level ); 1118b5: 56 push %esi 1118b6: 9d popf return true; 1118b7: 83 c4 10 add $0x10,%esp 1118ba: b0 01 mov $0x1,%al } 1118bc: 8d 65 f8 lea -0x8(%ebp),%esp 1118bf: 5b pop %ebx 1118c0: 5e pop %esi 1118c1: c9 leave 1118c2: c3 ret =============================================================================== 0010b804 <_POSIX_Timer_TSR>: * This is the operation that is run when a timer expires */ void _POSIX_Timer_TSR( Objects_Id timer __attribute__((unused)), void *data) { 10b804: 55 push %ebp 10b805: 89 e5 mov %esp,%ebp 10b807: 53 push %ebx 10b808: 83 ec 04 sub $0x4,%esp 10b80b: 8b 5d 0c mov 0xc(%ebp),%ebx bool activated; ptimer = (POSIX_Timer_Control *)data; /* Increment the number of expirations. */ ptimer->overrun = ptimer->overrun + 1; 10b80e: ff 43 68 incl 0x68(%ebx) /* The timer must be reprogrammed */ if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) || 10b811: 8b 53 54 mov 0x54(%ebx),%edx 10b814: 85 d2 test %edx,%edx 10b816: 75 28 jne 10b840 <_POSIX_Timer_TSR+0x3c> 10b818: 8b 43 58 mov 0x58(%ebx),%eax 10b81b: 85 c0 test %eax,%eax 10b81d: 75 21 jne 10b840 <_POSIX_Timer_TSR+0x3c> <== ALWAYS TAKEN /* The state really did not change but just to be safe */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; } else { /* Indicates that the timer is stopped */ ptimer->state = POSIX_TIMER_STATE_CREATE_STOP; 10b81f: c6 43 3c 04 movb $0x4,0x3c(%ebx) <== NOT EXECUTED /* * The sending of the signal to the process running the handling function * specified for that signal is simulated */ if ( pthread_kill ( ptimer->thread_id, ptimer->inf.sigev_signo ) ) { 10b823: 83 ec 08 sub $0x8,%esp 10b826: ff 73 44 pushl 0x44(%ebx) 10b829: ff 73 38 pushl 0x38(%ebx) 10b82c: e8 bb 5b 00 00 call 1113ec } /* After the signal handler returns, the count of expirations of the * timer must be set to 0. */ ptimer->overrun = 0; 10b831: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx) 10b838: 83 c4 10 add $0x10,%esp } 10b83b: 8b 5d fc mov -0x4(%ebp),%ebx 10b83e: c9 leave 10b83f: c3 ret ptimer->overrun = ptimer->overrun + 1; /* The timer must be reprogrammed */ if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) || ( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) { activated = _POSIX_Timer_Insert_helper( 10b840: 83 ec 0c sub $0xc,%esp 10b843: 53 push %ebx 10b844: 68 04 b8 10 00 push $0x10b804 10b849: ff 73 08 pushl 0x8(%ebx) 10b84c: ff 73 64 pushl 0x64(%ebx) 10b84f: 8d 43 10 lea 0x10(%ebx),%eax 10b852: 50 push %eax 10b853: e8 04 60 00 00 call 11185c <_POSIX_Timer_Insert_helper> ptimer->ticks, ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) 10b858: 83 c4 20 add $0x20,%esp 10b85b: 84 c0 test %al,%al 10b85d: 74 dc je 10b83b <_POSIX_Timer_TSR+0x37> <== NEVER TAKEN return; /* Store the time when the timer was started again */ _TOD_Get( &ptimer->time ); 10b85f: 83 ec 0c sub $0xc,%esp 10b862: 8d 43 6c lea 0x6c(%ebx),%eax 10b865: 50 push %eax 10b866: e8 91 16 00 00 call 10cefc <_TOD_Get> /* The state really did not change but just to be safe */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; 10b86b: c6 43 3c 03 movb $0x3,0x3c(%ebx) 10b86f: 83 c4 10 add $0x10,%esp 10b872: eb af jmp 10b823 <_POSIX_Timer_TSR+0x1f> =============================================================================== 00112b94 <_POSIX_signals_Check_signal>: bool _POSIX_signals_Check_signal( POSIX_API_Control *api, int signo, bool is_global ) { 112b94: 55 push %ebp 112b95: 89 e5 mov %esp,%ebp 112b97: 57 push %edi 112b98: 56 push %esi 112b99: 53 push %ebx 112b9a: 83 ec 78 sub $0x78,%esp 112b9d: 8b 5d 0c mov 0xc(%ebp),%ebx siginfo_t siginfo_struct; sigset_t saved_signals_blocked; Thread_Wait_information stored_thread_wait_information; if ( ! _POSIX_signals_Clear_signals( api, signo, &siginfo_struct, 112ba0: 6a 01 push $0x1 112ba2: 0f b6 45 10 movzbl 0x10(%ebp),%eax 112ba6: 50 push %eax 112ba7: 8d 55 dc lea -0x24(%ebp),%edx 112baa: 52 push %edx 112bab: 53 push %ebx 112bac: ff 75 08 pushl 0x8(%ebp) 112baf: 89 55 9c mov %edx,-0x64(%ebp) 112bb2: e8 b5 00 00 00 call 112c6c <_POSIX_signals_Clear_signals> 112bb7: 83 c4 20 add $0x20,%esp 112bba: 84 c0 test %al,%al 112bbc: 8b 55 9c mov -0x64(%ebp),%edx 112bbf: 0f 84 9b 00 00 00 je 112c60 <_POSIX_signals_Check_signal+0xcc> #endif /* * Just to prevent sending a signal which is currently being ignored. */ if ( _POSIX_signals_Vectors[ signo ].sa_handler == SIG_IGN ) 112bc5: 8d 04 5b lea (%ebx,%ebx,2),%eax 112bc8: c1 e0 02 shl $0x2,%eax 112bcb: 8b 88 a8 83 12 00 mov 0x1283a8(%eax),%ecx 112bd1: 89 4d a4 mov %ecx,-0x5c(%ebp) 112bd4: 49 dec %ecx 112bd5: 0f 84 85 00 00 00 je 112c60 <_POSIX_signals_Check_signal+0xcc><== NEVER TAKEN return false; /* * Block the signals requested in sa_mask */ saved_signals_blocked = api->signals_blocked; 112bdb: 8b 75 08 mov 0x8(%ebp),%esi 112bde: 8b b6 d0 00 00 00 mov 0xd0(%esi),%esi 112be4: 89 75 a0 mov %esi,-0x60(%ebp) api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask; 112be7: 8b 88 a4 83 12 00 mov 0x1283a4(%eax),%ecx 112bed: 09 f1 or %esi,%ecx 112bef: 8b 75 08 mov 0x8(%ebp),%esi 112bf2: 89 8e d0 00 00 00 mov %ecx,0xd0(%esi) /* * We have to save the blocking information of the current wait queue * because the signal handler may subsequently go on and put the thread * on a wait queue, for its own purposes. */ memcpy( &stored_thread_wait_information, &_Thread_Executing->Wait, 112bf8: 8d 75 b4 lea -0x4c(%ebp),%esi 112bfb: 89 75 94 mov %esi,-0x6c(%ebp) 112bfe: 8b 35 38 83 12 00 mov 0x128338,%esi 112c04: 83 c6 20 add $0x20,%esi 112c07: b9 0a 00 00 00 mov $0xa,%ecx 112c0c: 8b 7d 94 mov -0x6c(%ebp),%edi 112c0f: f3 a5 rep movsl %ds:(%esi),%es:(%edi) sizeof( Thread_Wait_information )); /* * Here, the signal handler function executes */ switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) { 112c11: 83 b8 a0 83 12 00 02 cmpl $0x2,0x1283a0(%eax) 112c18: 74 36 je 112c50 <_POSIX_signals_Check_signal+0xbc> &siginfo_struct, NULL /* context is undefined per 1003.1b-1993, p. 66 */ ); break; default: (*_POSIX_signals_Vectors[ signo ].sa_handler)( signo ); 112c1a: 83 ec 0c sub $0xc,%esp 112c1d: 53 push %ebx 112c1e: ff 55 a4 call *-0x5c(%ebp) break; 112c21: 83 c4 10 add $0x10,%esp } /* * Restore the blocking information */ memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information, 112c24: 8b 3d 38 83 12 00 mov 0x128338,%edi 112c2a: 83 c7 20 add $0x20,%edi 112c2d: b9 0a 00 00 00 mov $0xa,%ecx 112c32: 8b 75 94 mov -0x6c(%ebp),%esi 112c35: f3 a5 rep movsl %ds:(%esi),%es:(%edi) sizeof( Thread_Wait_information )); /* * Restore the previous set of blocked signals */ api->signals_blocked = saved_signals_blocked; 112c37: 8b 55 a0 mov -0x60(%ebp),%edx 112c3a: 8b 45 08 mov 0x8(%ebp),%eax 112c3d: 89 90 d0 00 00 00 mov %edx,0xd0(%eax) return true; 112c43: b0 01 mov $0x1,%al } 112c45: 8d 65 f4 lea -0xc(%ebp),%esp 112c48: 5b pop %ebx 112c49: 5e pop %esi 112c4a: 5f pop %edi 112c4b: c9 leave 112c4c: c3 ret 112c4d: 8d 76 00 lea 0x0(%esi),%esi /* * Here, the signal handler function executes */ switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) { case SA_SIGINFO: (*_POSIX_signals_Vectors[ signo ].sa_sigaction)( 112c50: 50 push %eax 112c51: 6a 00 push $0x0 112c53: 52 push %edx 112c54: 53 push %ebx 112c55: ff 55 a4 call *-0x5c(%ebp) signo, &siginfo_struct, NULL /* context is undefined per 1003.1b-1993, p. 66 */ ); break; 112c58: 83 c4 10 add $0x10,%esp 112c5b: eb c7 jmp 112c24 <_POSIX_signals_Check_signal+0x90> 112c5d: 8d 76 00 lea 0x0(%esi),%esi /* * Just to prevent sending a signal which is currently being ignored. */ if ( _POSIX_signals_Vectors[ signo ].sa_handler == SIG_IGN ) return false; 112c60: 31 c0 xor %eax,%eax * Restore the previous set of blocked signals */ api->signals_blocked = saved_signals_blocked; return true; } 112c62: 8d 65 f4 lea -0xc(%ebp),%esp 112c65: 5b pop %ebx 112c66: 5e pop %esi 112c67: 5f pop %edi 112c68: c9 leave 112c69: c3 ret =============================================================================== 0011321c <_POSIX_signals_Clear_process_signals>: */ void _POSIX_signals_Clear_process_signals( int signo ) { 11321c: 55 push %ebp 11321d: 89 e5 mov %esp,%ebp 11321f: 53 push %ebx 113220: 8b 4d 08 mov 0x8(%ebp),%ecx clear_signal = true; mask = signo_to_mask( signo ); ISR_Level level; _ISR_Disable( level ); 113223: 9c pushf 113224: fa cli 113225: 5a pop %edx if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) { 113226: 8d 04 49 lea (%ecx,%ecx,2),%eax 113229: c1 e0 02 shl $0x2,%eax 11322c: 83 b8 a0 83 12 00 02 cmpl $0x2,0x1283a0(%eax) 113233: 74 13 je 113248 <_POSIX_signals_Clear_process_signals+0x2c> 113235: 49 dec %ecx 113236: b8 fe ff ff ff mov $0xfffffffe,%eax if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) ) clear_signal = false; } if ( clear_signal ) { _POSIX_signals_Pending &= ~mask; 11323b: d3 c0 rol %cl,%eax 11323d: 21 05 a8 85 12 00 and %eax,0x1285a8 } _ISR_Enable( level ); 113243: 52 push %edx 113244: 9d popf } 113245: 5b pop %ebx 113246: c9 leave 113247: c3 ret RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 113248: 8d 98 c4 85 12 00 lea 0x1285c4(%eax),%ebx ISR_Level level; _ISR_Disable( level ); if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) { if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) ) 11324e: 39 98 c0 85 12 00 cmp %ebx,0x1285c0(%eax) 113254: 75 ed jne 113243 <_POSIX_signals_Clear_process_signals+0x27><== NEVER TAKEN 113256: eb dd jmp 113235 <_POSIX_signals_Clear_process_signals+0x19> =============================================================================== 00112c6c <_POSIX_signals_Clear_signals>: int signo, siginfo_t *info, bool is_global, bool check_blocked ) { 112c6c: 55 push %ebp 112c6d: 89 e5 mov %esp,%ebp 112c6f: 57 push %edi 112c70: 56 push %esi 112c71: 53 push %ebx 112c72: 83 ec 1c sub $0x1c,%esp 112c75: 8b 5d 0c mov 0xc(%ebp),%ebx 112c78: 0f b6 7d 14 movzbl 0x14(%ebp),%edi static inline sigset_t signo_to_mask( uint32_t sig ) { return 1u << (sig - 1); 112c7c: 8d 4b ff lea -0x1(%ebx),%ecx 112c7f: b8 01 00 00 00 mov $0x1,%eax 112c84: d3 e0 shl %cl,%eax /* set blocked signals based on if checking for them, SIGNAL_ALL_MASK * insures that no signals are blocked and all are checked. */ if ( check_blocked ) 112c86: 80 7d 18 00 cmpb $0x0,0x18(%ebp) 112c8a: 74 40 je 112ccc <_POSIX_signals_Clear_signals+0x60> signals_blocked = ~api->signals_blocked; 112c8c: 8b 55 08 mov 0x8(%ebp),%edx 112c8f: 8b 8a d0 00 00 00 mov 0xd0(%edx),%ecx 112c95: f7 d1 not %ecx signals_blocked = SIGNAL_ALL_MASK; /* XXX is this right for siginfo type signals? */ /* XXX are we sure they can be cleared the same way? */ _ISR_Disable( level ); 112c97: 9c pushf 112c98: fa cli 112c99: 8f 45 e4 popl -0x1c(%ebp) if ( is_global ) { 112c9c: 89 fa mov %edi,%edx 112c9e: 84 d2 test %dl,%dl 112ca0: 74 32 je 112cd4 <_POSIX_signals_Clear_signals+0x68> if ( mask & (_POSIX_signals_Pending & signals_blocked) ) { 112ca2: 23 05 a8 85 12 00 and 0x1285a8,%eax 112ca8: 85 c8 test %ecx,%eax 112caa: 74 54 je 112d00 <_POSIX_signals_Clear_signals+0x94> if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) { 112cac: 8d 14 5b lea (%ebx,%ebx,2),%edx 112caf: c1 e2 02 shl $0x2,%edx 112cb2: 83 ba a0 83 12 00 02 cmpl $0x2,0x1283a0(%edx) 112cb9: 74 49 je 112d04 <_POSIX_signals_Clear_signals+0x98> &psiginfo->Node ); } else do_callout = false; } _POSIX_signals_Clear_process_signals( signo ); 112cbb: 83 ec 0c sub $0xc,%esp 112cbe: 53 push %ebx 112cbf: e8 58 05 00 00 call 11321c <_POSIX_signals_Clear_process_signals> 112cc4: 83 c4 10 add $0x10,%esp do_callout = true; 112cc7: b0 01 mov $0x1,%al 112cc9: eb 26 jmp 112cf1 <_POSIX_signals_Clear_signals+0x85> 112ccb: 90 nop */ if ( check_blocked ) signals_blocked = ~api->signals_blocked; else signals_blocked = SIGNAL_ALL_MASK; 112ccc: b9 ff ff ff ff mov $0xffffffff,%ecx 112cd1: eb c4 jmp 112c97 <_POSIX_signals_Clear_signals+0x2b> 112cd3: 90 nop } _POSIX_signals_Clear_process_signals( signo ); do_callout = true; } } else { if ( mask & (api->signals_pending & signals_blocked) ) { 112cd4: 8b 55 08 mov 0x8(%ebp),%edx 112cd7: 8b 9a d4 00 00 00 mov 0xd4(%edx),%ebx 112cdd: 89 c6 mov %eax,%esi 112cdf: 21 de and %ebx,%esi 112ce1: 85 ce test %ecx,%esi 112ce3: 74 1b je 112d00 <_POSIX_signals_Clear_signals+0x94> api->signals_pending &= ~mask; 112ce5: f7 d0 not %eax 112ce7: 21 d8 and %ebx,%eax 112ce9: 89 82 d4 00 00 00 mov %eax,0xd4(%edx) do_callout = true; 112cef: b0 01 mov $0x1,%al } } _ISR_Enable( level ); 112cf1: ff 75 e4 pushl -0x1c(%ebp) 112cf4: 9d popf return do_callout; } 112cf5: 8d 65 f4 lea -0xc(%ebp),%esp 112cf8: 5b pop %ebx 112cf9: 5e pop %esi 112cfa: 5f pop %edi 112cfb: c9 leave 112cfc: c3 ret 112cfd: 8d 76 00 lea 0x0(%esi),%esi bool do_callout; POSIX_signals_Siginfo_node *psiginfo; mask = signo_to_mask( signo ); do_callout = false; 112d00: 31 c0 xor %eax,%eax 112d02: eb ed jmp 112cf1 <_POSIX_signals_Clear_signals+0x85> do_callout = true; } } _ISR_Enable( level ); return do_callout; } 112d04: 8d 8a c0 85 12 00 lea 0x1285c0(%edx),%ecx 112d0a: 8b 82 c0 85 12 00 mov 0x1285c0(%edx),%eax RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 112d10: 8d 71 04 lea 0x4(%ecx),%esi */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected( Chain_Control *the_chain ) { if ( !_Chain_Is_empty(the_chain)) 112d13: 39 f0 cmp %esi,%eax 112d15: 74 45 je 112d5c <_POSIX_signals_Clear_signals+0xf0> Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *old_first = head->next; Chain_Node *new_first = old_first->next; 112d17: 8b 30 mov (%eax),%esi head->next = new_first; 112d19: 89 b2 c0 85 12 00 mov %esi,0x1285c0(%edx) */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_first_unprotected( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); 112d1f: 89 4e 04 mov %ecx,0x4(%esi) if ( is_global ) { if ( mask & (_POSIX_signals_Pending & signals_blocked) ) { if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) { psiginfo = (POSIX_signals_Siginfo_node *) _Chain_Get_unprotected( &_POSIX_signals_Siginfo[ signo ] ); _POSIX_signals_Clear_process_signals( signo ); 112d22: 83 ec 0c sub $0xc,%esp 112d25: 53 push %ebx 112d26: 89 45 e0 mov %eax,-0x20(%ebp) 112d29: e8 ee 04 00 00 call 11321c <_POSIX_signals_Clear_process_signals> * It may be impossible to get here with an empty chain * BUT until that is proven we need to be defensive and * protect against it. */ if ( psiginfo ) { *info = psiginfo->Info; 112d2e: 8b 45 e0 mov -0x20(%ebp),%eax 112d31: 8d 70 08 lea 0x8(%eax),%esi 112d34: b9 03 00 00 00 mov $0x3,%ecx 112d39: 8b 7d 10 mov 0x10(%ebp),%edi 112d3c: f3 a5 rep movsl %ds:(%esi),%es:(%edi) Chain_Control *the_chain, Chain_Node *the_node ) { Chain_Node *tail = _Chain_Tail( the_chain ); Chain_Node *old_last = tail->previous; 112d3e: 8b 15 28 85 12 00 mov 0x128528,%edx the_node->next = tail; 112d44: c7 00 24 85 12 00 movl $0x128524,(%eax) tail->previous = the_node; 112d4a: a3 28 85 12 00 mov %eax,0x128528 old_last->next = the_node; 112d4f: 89 02 mov %eax,(%edx) the_node->previous = old_last; 112d51: 89 50 04 mov %edx,0x4(%eax) 112d54: 83 c4 10 add $0x10,%esp 112d57: e9 5f ff ff ff jmp 112cbb <_POSIX_signals_Clear_signals+0x4f> if ( is_global ) { if ( mask & (_POSIX_signals_Pending & signals_blocked) ) { if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) { psiginfo = (POSIX_signals_Siginfo_node *) _Chain_Get_unprotected( &_POSIX_signals_Siginfo[ signo ] ); _POSIX_signals_Clear_process_signals( signo ); 112d5c: 83 ec 0c sub $0xc,%esp 112d5f: 53 push %ebx 112d60: e8 b7 04 00 00 call 11321c <_POSIX_signals_Clear_process_signals> 112d65: 83 c4 10 add $0x10,%esp 112d68: e9 4e ff ff ff jmp 112cbb <_POSIX_signals_Clear_signals+0x4f> =============================================================================== 0010c0dc <_POSIX_signals_Get_lowest>: #include int _POSIX_signals_Get_lowest( sigset_t set ) { 10c0dc: 55 push %ebp 10c0dd: 89 e5 mov %esp,%ebp 10c0df: 56 push %esi 10c0e0: 53 push %ebx 10c0e1: 8b 55 08 mov 0x8(%ebp),%edx int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 10c0e4: b8 1b 00 00 00 mov $0x1b,%eax 10c0e9: bb 01 00 00 00 mov $0x1,%ebx #include #include #include #include int _POSIX_signals_Get_lowest( 10c0ee: 8d 48 ff lea -0x1(%eax),%ecx 10c0f1: 89 de mov %ebx,%esi 10c0f3: d3 e6 shl %cl,%esi ) { int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { if ( set & signo_to_mask( signo ) ) { 10c0f5: 85 d6 test %edx,%esi 10c0f7: 75 20 jne 10c119 <_POSIX_signals_Get_lowest+0x3d><== NEVER TAKEN sigset_t set ) { int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 10c0f9: 40 inc %eax 10c0fa: 83 f8 20 cmp $0x20,%eax 10c0fd: 75 ef jne 10c0ee <_POSIX_signals_Get_lowest+0x12> 10c0ff: b0 01 mov $0x1,%al 10c101: bb 01 00 00 00 mov $0x1,%ebx 10c106: eb 06 jmp 10c10e <_POSIX_signals_Get_lowest+0x32> */ #if (SIGHUP != 1) #error "Assumption that SIGHUP==1 violated!!" #endif for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { 10c108: 40 inc %eax 10c109: 83 f8 1b cmp $0x1b,%eax 10c10c: 74 0b je 10c119 <_POSIX_signals_Get_lowest+0x3d><== NEVER TAKEN #include #include #include #include int _POSIX_signals_Get_lowest( 10c10e: 8d 48 ff lea -0x1(%eax),%ecx 10c111: 89 de mov %ebx,%esi 10c113: d3 e6 shl %cl,%esi #if (SIGHUP != 1) #error "Assumption that SIGHUP==1 violated!!" #endif for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { if ( set & signo_to_mask( signo ) ) { 10c115: 85 d6 test %edx,%esi 10c117: 74 ef je 10c108 <_POSIX_signals_Get_lowest+0x2c> * a return 0. This routine will NOT be called unless a signal * is pending in the set passed in. */ found_it: return signo; } 10c119: 5b pop %ebx 10c11a: 5e pop %esi 10c11b: c9 leave 10c11c: c3 ret =============================================================================== 00124c6c <_POSIX_signals_Unblock_thread>: bool _POSIX_signals_Unblock_thread( Thread_Control *the_thread, int signo, siginfo_t *info ) { 124c6c: 55 push %ebp 124c6d: 89 e5 mov %esp,%ebp 124c6f: 57 push %edi 124c70: 56 push %esi 124c71: 53 push %ebx 124c72: 83 ec 0c sub $0xc,%esp 124c75: 8b 5d 08 mov 0x8(%ebp),%ebx 124c78: 8b 55 0c mov 0xc(%ebp),%edx POSIX_API_Control *api; sigset_t mask; siginfo_t *the_info = NULL; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 124c7b: 8b b3 ec 00 00 00 mov 0xec(%ebx),%esi 124c81: 8d 4a ff lea -0x1(%edx),%ecx 124c84: b8 01 00 00 00 mov $0x1,%eax 124c89: d3 e0 shl %cl,%eax /* * Is the thread is specifically waiting for a signal? */ if ( _States_Is_interruptible_signal( the_thread->current_state ) ) { 124c8b: 8b 4b 10 mov 0x10(%ebx),%ecx 124c8e: 89 cf mov %ecx,%edi 124c90: 81 e7 00 80 00 10 and $0x10008000,%edi 124c96: 81 ff 00 80 00 10 cmp $0x10008000,%edi 124c9c: 74 72 je 124d10 <_POSIX_signals_Unblock_thread+0xa4> } /* * Thread is not waiting due to a sigwait. */ if ( ~api->signals_blocked & mask ) { 124c9e: 8b 96 d0 00 00 00 mov 0xd0(%esi),%edx 124ca4: f7 d2 not %edx 124ca6: 85 d0 test %edx,%eax 124ca8: 74 5a je 124d04 <_POSIX_signals_Unblock_thread+0x98> * it is not blocked, THEN * we need to dispatch at the end of this ISR. * + Any other combination, do nothing. */ if ( _States_Is_interruptible_by_signal( the_thread->current_state ) ) { 124caa: f7 c1 00 00 00 10 test $0x10000000,%ecx 124cb0: 74 3a je 124cec <_POSIX_signals_Unblock_thread+0x80> the_thread->Wait.return_code = EINTR; 124cb2: c7 43 34 04 00 00 00 movl $0x4,0x34(%ebx) /* * In pthread_cond_wait, a thread will be blocking on a thread * queue, but is also interruptible by a POSIX signal. */ if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) ) 124cb9: f7 c1 e0 be 03 00 test $0x3bee0,%ecx 124cbf: 0f 85 93 00 00 00 jne 124d58 <_POSIX_signals_Unblock_thread+0xec> _Thread_queue_Extract_with_proxy( the_thread ); else if ( _States_Is_delaying(the_thread->current_state) ) { 124cc5: 83 e1 08 and $0x8,%ecx 124cc8: 74 3a je 124d04 <_POSIX_signals_Unblock_thread+0x98><== NEVER TAKEN (void) _Watchdog_Remove( &the_thread->Timer ); 124cca: 83 ec 0c sub $0xc,%esp 124ccd: 8d 43 48 lea 0x48(%ebx),%eax 124cd0: 50 push %eax 124cd1: e8 b2 ec fe ff call 113988 <_Watchdog_Remove> RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 124cd6: 5a pop %edx 124cd7: 59 pop %ecx 124cd8: 68 f8 ff 03 10 push $0x1003fff8 124cdd: 53 push %ebx 124cde: e8 91 da fe ff call 112774 <_Thread_Clear_state> 124ce3: 83 c4 10 add $0x10,%esp } else if ( the_thread->current_state == STATES_READY ) { if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) _Thread_Dispatch_necessary = true; } } return false; 124ce6: 31 c0 xor %eax,%eax 124ce8: eb 1c jmp 124d06 <_POSIX_signals_Unblock_thread+0x9a> 124cea: 66 90 xchg %ax,%ax else if ( _States_Is_delaying(the_thread->current_state) ) { (void) _Watchdog_Remove( &the_thread->Timer ); _Thread_Unblock( the_thread ); } } else if ( the_thread->current_state == STATES_READY ) { 124cec: 85 c9 test %ecx,%ecx 124cee: 75 14 jne 124d04 <_POSIX_signals_Unblock_thread+0x98><== NEVER TAKEN if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 124cf0: a1 b4 f0 12 00 mov 0x12f0b4,%eax 124cf5: 85 c0 test %eax,%eax 124cf7: 74 0b je 124d04 <_POSIX_signals_Unblock_thread+0x98> 124cf9: 3b 1d b8 f0 12 00 cmp 0x12f0b8,%ebx 124cff: 74 7b je 124d7c <_POSIX_signals_Unblock_thread+0x110><== ALWAYS TAKEN 124d01: 8d 76 00 lea 0x0(%esi),%esi _Thread_Dispatch_necessary = true; } } return false; 124d04: 31 c0 xor %eax,%eax } 124d06: 8d 65 f4 lea -0xc(%ebp),%esp 124d09: 5b pop %ebx 124d0a: 5e pop %esi 124d0b: 5f pop %edi 124d0c: c9 leave 124d0d: c3 ret 124d0e: 66 90 xchg %ax,%ax * Is the thread is specifically waiting for a signal? */ if ( _States_Is_interruptible_signal( the_thread->current_state ) ) { if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) { 124d10: 85 43 30 test %eax,0x30(%ebx) 124d13: 74 33 je 124d48 <_POSIX_signals_Unblock_thread+0xdc> the_thread->Wait.return_code = EINTR; 124d15: c7 43 34 04 00 00 00 movl $0x4,0x34(%ebx) the_info = (siginfo_t *) the_thread->Wait.return_argument; 124d1c: 8b 43 28 mov 0x28(%ebx),%eax if ( !info ) { 124d1f: 8b 75 10 mov 0x10(%ebp),%esi 124d22: 85 f6 test %esi,%esi 124d24: 74 42 je 124d68 <_POSIX_signals_Unblock_thread+0xfc> the_info->si_signo = signo; the_info->si_code = SI_USER; the_info->si_value.sival_int = 0; } else { *the_info = *info; 124d26: b9 03 00 00 00 mov $0x3,%ecx 124d2b: 89 c7 mov %eax,%edi 124d2d: 8b 75 10 mov 0x10(%ebp),%esi 124d30: f3 a5 rep movsl %ds:(%esi),%es:(%edi) } _Thread_queue_Extract_with_proxy( the_thread ); 124d32: 83 ec 0c sub $0xc,%esp 124d35: 53 push %ebx 124d36: e8 51 e4 fe ff call 11318c <_Thread_queue_Extract_with_proxy> return true; 124d3b: 83 c4 10 add $0x10,%esp 124d3e: b0 01 mov $0x1,%al if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) _Thread_Dispatch_necessary = true; } } return false; } 124d40: 8d 65 f4 lea -0xc(%ebp),%esp 124d43: 5b pop %ebx 124d44: 5e pop %esi 124d45: 5f pop %edi 124d46: c9 leave 124d47: c3 ret * Is the thread is specifically waiting for a signal? */ if ( _States_Is_interruptible_signal( the_thread->current_state ) ) { if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) { 124d48: 8b 8e d0 00 00 00 mov 0xd0(%esi),%ecx 124d4e: f7 d1 not %ecx 124d50: 85 c8 test %ecx,%eax 124d52: 75 c1 jne 124d15 <_POSIX_signals_Unblock_thread+0xa9> 124d54: eb ae jmp 124d04 <_POSIX_signals_Unblock_thread+0x98> 124d56: 66 90 xchg %ax,%ax /* * In pthread_cond_wait, a thread will be blocking on a thread * queue, but is also interruptible by a POSIX signal. */ if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) ) _Thread_queue_Extract_with_proxy( the_thread ); 124d58: 83 ec 0c sub $0xc,%esp 124d5b: 53 push %ebx 124d5c: e8 2b e4 fe ff call 11318c <_Thread_queue_Extract_with_proxy> 124d61: 83 c4 10 add $0x10,%esp } else if ( the_thread->current_state == STATES_READY ) { if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) _Thread_Dispatch_necessary = true; } } return false; 124d64: 31 c0 xor %eax,%eax 124d66: eb 9e jmp 124d06 <_POSIX_signals_Unblock_thread+0x9a> the_thread->Wait.return_code = EINTR; the_info = (siginfo_t *) the_thread->Wait.return_argument; if ( !info ) { the_info->si_signo = signo; 124d68: 89 10 mov %edx,(%eax) the_info->si_code = SI_USER; 124d6a: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax) the_info->si_value.sival_int = 0; 124d71: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax) 124d78: eb b8 jmp 124d32 <_POSIX_signals_Unblock_thread+0xc6> 124d7a: 66 90 xchg %ax,%ax _Thread_Unblock( the_thread ); } } else if ( the_thread->current_state == STATES_READY ) { if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) _Thread_Dispatch_necessary = true; 124d7c: c6 05 c4 f0 12 00 01 movb $0x1,0x12f0c4 } } return false; 124d83: 31 c0 xor %eax,%eax 124d85: e9 7c ff ff ff jmp 124d06 <_POSIX_signals_Unblock_thread+0x9a> =============================================================================== 0010d848 <_Protected_heap_Get_information>: bool _Protected_heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ) { 10d848: 55 push %ebp 10d849: 89 e5 mov %esp,%ebp 10d84b: 56 push %esi 10d84c: 53 push %ebx 10d84d: 8b 5d 08 mov 0x8(%ebp),%ebx 10d850: 8b 75 0c mov 0xc(%ebp),%esi if ( !the_heap ) 10d853: 85 db test %ebx,%ebx 10d855: 74 35 je 10d88c <_Protected_heap_Get_information+0x44> return false; if ( !the_info ) 10d857: 85 f6 test %esi,%esi 10d859: 74 31 je 10d88c <_Protected_heap_Get_information+0x44> return false; _RTEMS_Lock_allocator(); 10d85b: 83 ec 0c sub $0xc,%esp 10d85e: ff 35 40 88 12 00 pushl 0x128840 10d864: e8 e7 ed ff ff call 10c650 <_API_Mutex_Lock> _Heap_Get_information( the_heap, the_info ); 10d869: 5a pop %edx 10d86a: 59 pop %ecx 10d86b: 56 push %esi 10d86c: 53 push %ebx 10d86d: e8 d2 47 00 00 call 112044 <_Heap_Get_information> _RTEMS_Unlock_allocator(); 10d872: 58 pop %eax 10d873: ff 35 40 88 12 00 pushl 0x128840 10d879: e8 1a ee ff ff call 10c698 <_API_Mutex_Unlock> return true; 10d87e: 83 c4 10 add $0x10,%esp 10d881: b0 01 mov $0x1,%al } 10d883: 8d 65 f8 lea -0x8(%ebp),%esp 10d886: 5b pop %ebx 10d887: 5e pop %esi 10d888: c9 leave 10d889: c3 ret 10d88a: 66 90 xchg %ax,%ax { if ( !the_heap ) return false; if ( !the_info ) return false; 10d88c: 31 c0 xor %eax,%eax _RTEMS_Lock_allocator(); _Heap_Get_information( the_heap, the_info ); _RTEMS_Unlock_allocator(); return true; } 10d88e: 8d 65 f8 lea -0x8(%ebp),%esp 10d891: 5b pop %ebx 10d892: 5e pop %esi 10d893: c9 leave 10d894: c3 ret =============================================================================== 00110c04 <_Protected_heap_Walk>: bool _Protected_heap_Walk( Heap_Control *the_heap, int source, bool do_dump ) { 110c04: 55 push %ebp 110c05: 89 e5 mov %esp,%ebp 110c07: 56 push %esi 110c08: 53 push %ebx 110c09: 83 ec 10 sub $0x10,%esp 110c0c: 8b 5d 08 mov 0x8(%ebp),%ebx 110c0f: 8b 75 0c mov 0xc(%ebp),%esi 110c12: 8a 45 10 mov 0x10(%ebp),%al * then it is forbidden to lock a mutex. But since we are inside * a critical section, it should be safe to walk it unlocked. * * NOTE: Dispatching is also disabled during initialization. */ if ( !_Thread_Dispatch_disable_level ) { 110c15: 8b 15 d0 f2 12 00 mov 0x12f2d0,%edx 110c1b: 85 d2 test %edx,%edx 110c1d: 74 19 je 110c38 <_Protected_heap_Walk+0x34> _RTEMS_Lock_allocator(); status = _Heap_Walk( the_heap, source, do_dump ); _RTEMS_Unlock_allocator(); } else { status = _Heap_Walk( the_heap, source, do_dump ); 110c1f: 0f b6 c0 movzbl %al,%eax 110c22: 89 45 10 mov %eax,0x10(%ebp) 110c25: 89 75 0c mov %esi,0xc(%ebp) 110c28: 89 5d 08 mov %ebx,0x8(%ebp) } return status; } 110c2b: 8d 65 f8 lea -0x8(%ebp),%esp 110c2e: 5b pop %ebx 110c2f: 5e pop %esi 110c30: c9 leave if ( !_Thread_Dispatch_disable_level ) { _RTEMS_Lock_allocator(); status = _Heap_Walk( the_heap, source, do_dump ); _RTEMS_Unlock_allocator(); } else { status = _Heap_Walk( the_heap, source, do_dump ); 110c31: e9 32 f2 ff ff jmp 10fe68 <_Heap_Walk> 110c36: 66 90 xchg %ax,%ax * a critical section, it should be safe to walk it unlocked. * * NOTE: Dispatching is also disabled during initialization. */ if ( !_Thread_Dispatch_disable_level ) { _RTEMS_Lock_allocator(); 110c38: 83 ec 0c sub $0xc,%esp 110c3b: ff 35 80 f3 12 00 pushl 0x12f380 110c41: 88 45 f4 mov %al,-0xc(%ebp) 110c44: e8 bf e3 ff ff call 10f008 <_API_Mutex_Lock> status = _Heap_Walk( the_heap, source, do_dump ); 110c49: 83 c4 0c add $0xc,%esp 110c4c: 8a 45 f4 mov -0xc(%ebp),%al 110c4f: 0f b6 c0 movzbl %al,%eax 110c52: 50 push %eax 110c53: 56 push %esi 110c54: 53 push %ebx 110c55: e8 0e f2 ff ff call 10fe68 <_Heap_Walk> _RTEMS_Unlock_allocator(); 110c5a: 5a pop %edx 110c5b: ff 35 80 f3 12 00 pushl 0x12f380 110c61: 88 45 f4 mov %al,-0xc(%ebp) 110c64: e8 e7 e3 ff ff call 10f050 <_API_Mutex_Unlock> 110c69: 83 c4 10 add $0x10,%esp } else { status = _Heap_Walk( the_heap, source, do_dump ); } return status; } 110c6c: 8a 45 f4 mov -0xc(%ebp),%al 110c6f: 8d 65 f8 lea -0x8(%ebp),%esp 110c72: 5b pop %ebx 110c73: 5e pop %esi 110c74: c9 leave 110c75: c3 ret =============================================================================== 00110e94 <_RTEMS_tasks_Create_extension>: bool _RTEMS_tasks_Create_extension( Thread_Control *executing, Thread_Control *created ) { 110e94: 55 push %ebp 110e95: 89 e5 mov %esp,%ebp 110e97: 53 push %ebx 110e98: 83 ec 10 sub $0x10,%esp 110e9b: 8b 5d 0c mov 0xc(%ebp),%ebx /* * Notepads must be the last entry in the structure and they * can be left off if disabled in the configuration. */ to_allocate = sizeof( RTEMS_API_Control ); 110e9e: 80 3d 44 3a 12 00 01 cmpb $0x1,0x123a44 110ea5: 19 c0 sbb %eax,%eax 110ea7: 83 e0 c0 and $0xffffffc0,%eax 110eaa: 83 c0 60 add $0x60,%eax if ( !rtems_configuration_get_notepads_enabled() ) to_allocate -= (RTEMS_NUMBER_NOTEPADS * sizeof(uint32_t)); api = _Workspace_Allocate( to_allocate ); 110ead: 50 push %eax 110eae: e8 d5 da ff ff call 10e988 <_Workspace_Allocate> if ( !api ) 110eb3: 83 c4 10 add $0x10,%esp 110eb6: 85 c0 test %eax,%eax 110eb8: 74 6a je 110f24 <_RTEMS_tasks_Create_extension+0x90> return false; created->API_Extensions[ THREAD_API_RTEMS ] = api; 110eba: 89 83 e8 00 00 00 mov %eax,0xe8(%ebx) api->pending_events = EVENT_SETS_NONE_PENDING; 110ec0: c7 00 00 00 00 00 movl $0x0,(%eax) api->event_condition = 0; 110ec6: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) */ RTEMS_INLINE_ROUTINE void _ASR_Initialize ( ASR_Information *information ) { information->is_enabled = false; 110ecd: c6 40 08 00 movb $0x0,0x8(%eax) information->handler = NULL; 110ed1: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) information->mode_set = RTEMS_DEFAULT_MODES; 110ed8: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax) information->signals_posted = 0; 110edf: c7 40 14 00 00 00 00 movl $0x0,0x14(%eax) information->signals_pending = 0; 110ee6: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) information->nest_level = 0; 110eed: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax) _ASR_Initialize( &api->Signal ); created->task_variables = NULL; 110ef4: c7 83 f4 00 00 00 00 movl $0x0,0xf4(%ebx) 110efb: 00 00 00 if ( rtems_configuration_get_notepads_enabled() ) { 110efe: 80 3d 44 3a 12 00 00 cmpb $0x0,0x123a44 110f05: 74 13 je 110f1a <_RTEMS_tasks_Create_extension+0x86> 110f07: 31 d2 xor %edx,%edx 110f09: 8d 76 00 lea 0x0(%esi),%esi for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++) api->Notepads[i] = 0; 110f0c: c7 44 90 20 00 00 00 movl $0x0,0x20(%eax,%edx,4) 110f13: 00 api->event_condition = 0; _ASR_Initialize( &api->Signal ); created->task_variables = NULL; if ( rtems_configuration_get_notepads_enabled() ) { for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++) 110f14: 42 inc %edx 110f15: 83 fa 10 cmp $0x10,%edx 110f18: 75 f2 jne 110f0c <_RTEMS_tasks_Create_extension+0x78> api->Notepads[i] = 0; } return true; 110f1a: b0 01 mov $0x1,%al } 110f1c: 8b 5d fc mov -0x4(%ebp),%ebx 110f1f: c9 leave 110f20: c3 ret 110f21: 8d 76 00 lea 0x0(%esi),%esi to_allocate -= (RTEMS_NUMBER_NOTEPADS * sizeof(uint32_t)); api = _Workspace_Allocate( to_allocate ); if ( !api ) return false; 110f24: 31 c0 xor %eax,%eax for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++) api->Notepads[i] = 0; } return true; } 110f26: 8b 5d fc mov -0x4(%ebp),%ebx 110f29: c9 leave 110f2a: c3 ret =============================================================================== 00110e3c <_RTEMS_tasks_Delete_extension>: void _RTEMS_tasks_Delete_extension( Thread_Control *executing, Thread_Control *deleted ) { 110e3c: 55 push %ebp 110e3d: 89 e5 mov %esp,%ebp 110e3f: 56 push %esi 110e40: 53 push %ebx 110e41: 8b 75 0c mov 0xc(%ebp),%esi /* * Free per task variable memory */ tvp = deleted->task_variables; 110e44: 8b 86 f4 00 00 00 mov 0xf4(%esi),%eax deleted->task_variables = NULL; 110e4a: c7 86 f4 00 00 00 00 movl $0x0,0xf4(%esi) 110e51: 00 00 00 while (tvp) { 110e54: 85 c0 test %eax,%eax 110e56: 75 06 jne 110e5e <_RTEMS_tasks_Delete_extension+0x22> 110e58: eb 17 jmp 110e71 <_RTEMS_tasks_Delete_extension+0x35> 110e5a: 66 90 xchg %ax,%ax next = (rtems_task_variable_t *)tvp->next; _RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp ); tvp = next; 110e5c: 89 d8 mov %ebx,%eax */ tvp = deleted->task_variables; deleted->task_variables = NULL; while (tvp) { next = (rtems_task_variable_t *)tvp->next; 110e5e: 8b 18 mov (%eax),%ebx _RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp ); 110e60: 83 ec 08 sub $0x8,%esp 110e63: 50 push %eax 110e64: 56 push %esi 110e65: e8 56 01 00 00 call 110fc0 <_RTEMS_Tasks_Invoke_task_variable_dtor> * Free per task variable memory */ tvp = deleted->task_variables; deleted->task_variables = NULL; while (tvp) { 110e6a: 83 c4 10 add $0x10,%esp 110e6d: 85 db test %ebx,%ebx 110e6f: 75 eb jne 110e5c <_RTEMS_tasks_Delete_extension+0x20> /* * Free API specific memory */ (void) _Workspace_Free( deleted->API_Extensions[ THREAD_API_RTEMS ] ); 110e71: 83 ec 0c sub $0xc,%esp 110e74: ff b6 e8 00 00 00 pushl 0xe8(%esi) 110e7a: e8 25 db ff ff call 10e9a4 <_Workspace_Free> deleted->API_Extensions[ THREAD_API_RTEMS ] = NULL; 110e7f: c7 86 e8 00 00 00 00 movl $0x0,0xe8(%esi) 110e86: 00 00 00 110e89: 83 c4 10 add $0x10,%esp } 110e8c: 8d 65 f8 lea -0x8(%ebp),%esp 110e8f: 5b pop %ebx 110e90: 5e pop %esi 110e91: c9 leave 110e92: c3 ret =============================================================================== 00110dc0 <_RTEMS_tasks_Initialize_user_tasks>: * * Output parameters: NONE */ void _RTEMS_tasks_Initialize_user_tasks( void ) { 110dc0: 55 push %ebp 110dc1: 89 e5 mov %esp,%ebp 110dc3: 83 ec 08 sub $0x8,%esp if ( _RTEMS_tasks_Initialize_user_tasks_p ) 110dc6: a1 c0 3a 12 00 mov 0x123ac0,%eax 110dcb: 85 c0 test %eax,%eax 110dcd: 74 05 je 110dd4 <_RTEMS_tasks_Initialize_user_tasks+0x14> (*_RTEMS_tasks_Initialize_user_tasks_p)(); } 110dcf: c9 leave */ void _RTEMS_tasks_Initialize_user_tasks( void ) { if ( _RTEMS_tasks_Initialize_user_tasks_p ) (*_RTEMS_tasks_Initialize_user_tasks_p)(); 110dd0: ff e0 jmp *%eax 110dd2: 66 90 xchg %ax,%ax } 110dd4: c9 leave 110dd5: c3 ret =============================================================================== 0010ba80 <_RTEMS_tasks_Initialize_user_tasks_body>: * * Output parameters: NONE */ void _RTEMS_tasks_Initialize_user_tasks_body( void ) { 10ba80: 55 push %ebp 10ba81: 89 e5 mov %esp,%ebp 10ba83: 57 push %edi 10ba84: 56 push %esi 10ba85: 53 push %ebx 10ba86: 83 ec 1c sub $0x1c,%esp rtems_initialization_tasks_table *user_tasks; /* * Move information into local variables */ user_tasks = Configuration_RTEMS_API.User_initialization_tasks_table; 10ba89: 8b 1d 6c 3a 12 00 mov 0x123a6c,%ebx maximum = Configuration_RTEMS_API.number_of_initialization_tasks; 10ba8f: 8b 3d 68 3a 12 00 mov 0x123a68,%edi /* * Verify that we have a set of user tasks to iterate */ if ( !user_tasks ) 10ba95: 85 db test %ebx,%ebx 10ba97: 74 46 je 10badf <_RTEMS_tasks_Initialize_user_tasks_body+0x5f> return; /* * Now iterate over the initialization tasks and create/start them. */ for ( index=0 ; index < maximum ; index++ ) { 10ba99: 85 ff test %edi,%edi 10ba9b: 74 42 je 10badf <_RTEMS_tasks_Initialize_user_tasks_body+0x5f><== NEVER TAKEN 10ba9d: 31 f6 xor %esi,%esi 10ba9f: 90 nop return_value = rtems_task_create( 10baa0: 83 ec 08 sub $0x8,%esp 10baa3: 8d 45 e4 lea -0x1c(%ebp),%eax 10baa6: 50 push %eax 10baa7: ff 73 0c pushl 0xc(%ebx) 10baaa: ff 73 14 pushl 0x14(%ebx) 10baad: ff 73 04 pushl 0x4(%ebx) 10bab0: ff 73 08 pushl 0x8(%ebx) 10bab3: ff 33 pushl (%ebx) 10bab5: e8 92 fd ff ff call 10b84c user_tasks[ index ].stack_size, user_tasks[ index ].mode_set, user_tasks[ index ].attribute_set, &id ); if ( !rtems_is_status_successful( return_value ) ) 10baba: 83 c4 20 add $0x20,%esp 10babd: 85 c0 test %eax,%eax 10babf: 75 26 jne 10bae7 <_RTEMS_tasks_Initialize_user_tasks_body+0x67> _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value ); return_value = rtems_task_start( 10bac1: 51 push %ecx 10bac2: ff 73 18 pushl 0x18(%ebx) 10bac5: ff 73 10 pushl 0x10(%ebx) 10bac8: ff 75 e4 pushl -0x1c(%ebp) 10bacb: e8 24 00 00 00 call 10baf4 id, user_tasks[ index ].entry_point, user_tasks[ index ].argument ); if ( !rtems_is_status_successful( return_value ) ) 10bad0: 83 c4 10 add $0x10,%esp 10bad3: 85 c0 test %eax,%eax 10bad5: 75 10 jne 10bae7 <_RTEMS_tasks_Initialize_user_tasks_body+0x67> return; /* * Now iterate over the initialization tasks and create/start them. */ for ( index=0 ; index < maximum ; index++ ) { 10bad7: 46 inc %esi 10bad8: 83 c3 1c add $0x1c,%ebx 10badb: 39 f7 cmp %esi,%edi 10badd: 77 c1 ja 10baa0 <_RTEMS_tasks_Initialize_user_tasks_body+0x20><== NEVER TAKEN user_tasks[ index ].argument ); if ( !rtems_is_status_successful( return_value ) ) _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value ); } } 10badf: 8d 65 f4 lea -0xc(%ebp),%esp 10bae2: 5b pop %ebx 10bae3: 5e pop %esi 10bae4: 5f pop %edi 10bae5: c9 leave 10bae6: c3 ret id, user_tasks[ index ].entry_point, user_tasks[ index ].argument ); if ( !rtems_is_status_successful( return_value ) ) _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value ); 10bae7: 52 push %edx 10bae8: 50 push %eax 10bae9: 6a 01 push $0x1 10baeb: 6a 01 push $0x1 10baed: e8 02 0e 00 00 call 10c8f4 <_Internal_error_Occurred> =============================================================================== 00110d78 <_RTEMS_tasks_Switch_extension>: void _RTEMS_tasks_Switch_extension( Thread_Control *executing, Thread_Control *heir ) { 110d78: 55 push %ebp 110d79: 89 e5 mov %esp,%ebp /* * Per Task Variables */ tvp = executing->task_variables; 110d7b: 8b 45 08 mov 0x8(%ebp),%eax 110d7e: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax while (tvp) { 110d84: 85 c0 test %eax,%eax 110d86: 74 13 je 110d9b <_RTEMS_tasks_Switch_extension+0x23> tvp->tval = *tvp->ptr; 110d88: 8b 50 04 mov 0x4(%eax),%edx 110d8b: 8b 0a mov (%edx),%ecx 110d8d: 89 48 0c mov %ecx,0xc(%eax) *tvp->ptr = tvp->gval; 110d90: 8b 48 08 mov 0x8(%eax),%ecx 110d93: 89 0a mov %ecx,(%edx) tvp = (rtems_task_variable_t *)tvp->next; 110d95: 8b 00 mov (%eax),%eax /* * Per Task Variables */ tvp = executing->task_variables; while (tvp) { 110d97: 85 c0 test %eax,%eax 110d99: 75 ed jne 110d88 <_RTEMS_tasks_Switch_extension+0x10><== NEVER TAKEN tvp->tval = *tvp->ptr; *tvp->ptr = tvp->gval; tvp = (rtems_task_variable_t *)tvp->next; } tvp = heir->task_variables; 110d9b: 8b 45 0c mov 0xc(%ebp),%eax 110d9e: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax while (tvp) { 110da4: 85 c0 test %eax,%eax 110da6: 74 13 je 110dbb <_RTEMS_tasks_Switch_extension+0x43> tvp->gval = *tvp->ptr; 110da8: 8b 50 04 mov 0x4(%eax),%edx 110dab: 8b 0a mov (%edx),%ecx 110dad: 89 48 08 mov %ecx,0x8(%eax) *tvp->ptr = tvp->tval; 110db0: 8b 48 0c mov 0xc(%eax),%ecx 110db3: 89 0a mov %ecx,(%edx) tvp = (rtems_task_variable_t *)tvp->next; 110db5: 8b 00 mov (%eax),%eax *tvp->ptr = tvp->gval; tvp = (rtems_task_variable_t *)tvp->next; } tvp = heir->task_variables; while (tvp) { 110db7: 85 c0 test %eax,%eax 110db9: 75 ed jne 110da8 <_RTEMS_tasks_Switch_extension+0x30><== NEVER TAKEN tvp->gval = *tvp->ptr; *tvp->ptr = tvp->tval; tvp = (rtems_task_variable_t *)tvp->next; } } 110dbb: c9 leave 110dbc: c3 ret =============================================================================== 0010c4f0 <_Rate_monotonic_Initiate_statistics>: } void _Rate_monotonic_Initiate_statistics( Rate_monotonic_Control *the_period ) { 10c4f0: 55 push %ebp 10c4f1: 89 e5 mov %esp,%ebp 10c4f3: 57 push %edi 10c4f4: 56 push %esi 10c4f5: 53 push %ebx 10c4f6: 83 ec 28 sub $0x28,%esp 10c4f9: 8b 5d 08 mov 0x8(%ebp),%ebx Thread_Control *owning_thread = the_period->owner; 10c4fc: 8b 73 40 mov 0x40(%ebx),%esi * If using nanosecond statistics, we need to obtain the uptime. */ #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ Timestamp_Control uptime; _TOD_Get_uptime( &uptime ); 10c4ff: 8d 7d e0 lea -0x20(%ebp),%edi 10c502: 57 push %edi 10c503: e8 98 18 00 00 call 10dda0 <_TOD_Get_uptime> /* * Set the starting point and the CPU time used for the statistics. */ #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ the_period->time_period_initiated = uptime; 10c508: 8b 45 e0 mov -0x20(%ebp),%eax 10c50b: 8b 55 e4 mov -0x1c(%ebp),%edx 10c50e: 89 43 4c mov %eax,0x4c(%ebx) 10c511: 89 53 50 mov %edx,0x50(%ebx) #else the_period->time_period_initiated = _Watchdog_Ticks_since_boot; #endif the_period->cpu_usage_period_initiated = owning_thread->cpu_time_used; 10c514: 8b 86 84 00 00 00 mov 0x84(%esi),%eax 10c51a: 8b 96 88 00 00 00 mov 0x88(%esi),%edx 10c520: 89 43 44 mov %eax,0x44(%ebx) 10c523: 89 53 48 mov %edx,0x48(%ebx) * routine is invoked from rtems_rate_monotonic_period, the owner will * be the executing thread. When this routine is invoked from * _Rate_monotonic_Timeout, it will not. */ #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ if (owning_thread == _Thread_Executing) { 10c526: 83 c4 10 add $0x10,%esp 10c529: 39 35 f8 b6 12 00 cmp %esi,0x12b6f8 10c52f: 74 0b je 10c53c <_Rate_monotonic_Initiate_statistics+0x4c> ); _Timespec_Add_to( &the_period->cpu_usage_period_initiated, &ran ); } #endif } 10c531: 8d 65 f4 lea -0xc(%ebp),%esp 10c534: 5b pop %ebx 10c535: 5e pop %esi 10c536: 5f pop %edi 10c537: c9 leave 10c538: c3 ret 10c539: 8d 76 00 lea 0x0(%esi),%esi /* * Adjust the CPU time used to account for the time since last * context switch. */ _Timespec_Subtract( 10c53c: 50 push %eax &_Thread_Time_of_last_context_switch, &uptime, &ran 10c53d: 8d 75 d8 lea -0x28(%ebp),%esi /* * Adjust the CPU time used to account for the time since last * context switch. */ _Timespec_Subtract( 10c540: 56 push %esi 10c541: 57 push %edi 10c542: 68 0c b2 12 00 push $0x12b20c 10c547: e8 f0 39 00 00 call 10ff3c <_Timespec_Subtract> &_Thread_Time_of_last_context_switch, &uptime, &ran ); _Timespec_Add_to( &the_period->cpu_usage_period_initiated, &ran ); 10c54c: 59 pop %ecx 10c54d: 5f pop %edi 10c54e: 56 push %esi 10c54f: 83 c3 44 add $0x44,%ebx 10c552: 53 push %ebx 10c553: e8 e8 38 00 00 call 10fe40 <_Timespec_Add_to> 10c558: 83 c4 10 add $0x10,%esp } #endif } 10c55b: 8d 65 f4 lea -0xc(%ebp),%esp 10c55e: 5b pop %ebx 10c55f: 5e pop %esi 10c560: 5f pop %edi 10c561: c9 leave 10c562: c3 ret =============================================================================== 0010caac <_Rate_monotonic_Timeout>: void _Rate_monotonic_Timeout( Objects_Id id, void *ignored ) { 10caac: 55 push %ebp 10caad: 89 e5 mov %esp,%ebp 10caaf: 83 ec 2c sub $0x2c,%esp /* * When we get here, the Timer is already off the chain so we do not * have to worry about that -- hence no _Watchdog_Remove(). */ the_period = _Rate_monotonic_Get( id, &location ); 10cab2: 8d 45 f4 lea -0xc(%ebp),%eax 10cab5: 50 push %eax 10cab6: ff 75 08 pushl 0x8(%ebp) 10cab9: 68 60 b0 12 00 push $0x12b060 10cabe: e8 71 1d 00 00 call 10e834 <_Objects_Get> switch ( location ) { 10cac3: 83 c4 10 add $0x10,%esp 10cac6: 8b 55 f4 mov -0xc(%ebp),%edx 10cac9: 85 d2 test %edx,%edx 10cacb: 75 29 jne 10caf6 <_Rate_monotonic_Timeout+0x4a><== NEVER TAKEN case OBJECTS_LOCAL: the_thread = the_period->owner; 10cacd: 8b 50 40 mov 0x40(%eax),%edx if ( _States_Is_waiting_for_period( the_thread->current_state ) && 10cad0: f6 42 11 40 testb $0x40,0x11(%edx) 10cad4: 74 08 je 10cade <_Rate_monotonic_Timeout+0x32> 10cad6: 8b 48 08 mov 0x8(%eax),%ecx 10cad9: 39 4a 20 cmp %ecx,0x20(%edx) 10cadc: 74 4e je 10cb2c <_Rate_monotonic_Timeout+0x80> _Thread_Unblock( the_thread ); _Rate_monotonic_Initiate_statistics( the_period ); _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) { 10cade: 83 78 38 01 cmpl $0x1,0x38(%eax) 10cae2: 74 14 je 10caf8 <_Rate_monotonic_Timeout+0x4c> _Rate_monotonic_Initiate_statistics( the_period ); _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else the_period->state = RATE_MONOTONIC_EXPIRED; 10cae4: c7 40 38 04 00 00 00 movl $0x4,0x38(%eax) */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 10caeb: a1 50 b1 12 00 mov 0x12b150,%eax 10caf0: 48 dec %eax 10caf1: a3 50 b1 12 00 mov %eax,0x12b150 case OBJECTS_REMOTE: /* impossible */ #endif case OBJECTS_ERROR: break; } } 10caf6: c9 leave 10caf7: c3 ret _Rate_monotonic_Initiate_statistics( the_period ); _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) { the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING; 10caf8: c7 40 38 03 00 00 00 movl $0x3,0x38(%eax) _Rate_monotonic_Initiate_statistics( the_period ); 10caff: 83 ec 0c sub $0xc,%esp 10cb02: 50 push %eax 10cb03: 89 45 e4 mov %eax,-0x1c(%ebp) 10cb06: e8 e5 f9 ff ff call 10c4f0 <_Rate_monotonic_Initiate_statistics> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10cb0b: 8b 45 e4 mov -0x1c(%ebp),%eax 10cb0e: 8b 50 3c mov 0x3c(%eax),%edx 10cb11: 89 50 1c mov %edx,0x1c(%eax) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10cb14: 5a pop %edx 10cb15: 59 pop %ecx _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); 10cb16: 83 c0 10 add $0x10,%eax 10cb19: 50 push %eax 10cb1a: 68 20 b2 12 00 push $0x12b220 10cb1f: e8 f8 36 00 00 call 11021c <_Watchdog_Insert> 10cb24: 83 c4 10 add $0x10,%esp 10cb27: eb c2 jmp 10caeb <_Rate_monotonic_Timeout+0x3f> 10cb29: 8d 76 00 lea 0x0(%esi),%esi RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 10cb2c: 83 ec 08 sub $0x8,%esp 10cb2f: 68 f8 ff 03 10 push $0x1003fff8 10cb34: 52 push %edx 10cb35: 89 45 e4 mov %eax,-0x1c(%ebp) 10cb38: e8 0b 25 00 00 call 10f048 <_Thread_Clear_state> the_thread = the_period->owner; if ( _States_Is_waiting_for_period( the_thread->current_state ) && the_thread->Wait.id == the_period->Object.id ) { _Thread_Unblock( the_thread ); _Rate_monotonic_Initiate_statistics( the_period ); 10cb3d: 8b 45 e4 mov -0x1c(%ebp),%eax 10cb40: 89 04 24 mov %eax,(%esp) 10cb43: eb c1 jmp 10cb06 <_Rate_monotonic_Timeout+0x5a> =============================================================================== 0010c564 <_Rate_monotonic_Update_statistics>: void _Rate_monotonic_Update_statistics( Rate_monotonic_Control *the_period ) { 10c564: 55 push %ebp 10c565: 89 e5 mov %esp,%ebp 10c567: 57 push %edi 10c568: 56 push %esi 10c569: 53 push %ebx 10c56a: 83 ec 1c sub $0x1c,%esp 10c56d: 8b 5d 08 mov 0x8(%ebp),%ebx /* * Update the counts. */ stats = &the_period->Statistics; stats->count++; 10c570: ff 43 54 incl 0x54(%ebx) if ( the_period->state == RATE_MONOTONIC_EXPIRED ) 10c573: 83 7b 38 04 cmpl $0x4,0x38(%ebx) 10c577: 0f 84 bf 00 00 00 je 10c63c <_Rate_monotonic_Update_statistics+0xd8> stats->missed_count++; /* * Grab status for time statistics. */ valid_status = 10c57d: 51 push %ecx _Rate_monotonic_Get_status( the_period, &since_last_period, &executed ); 10c57e: 8d 7d e0 lea -0x20(%ebp),%edi stats->missed_count++; /* * Grab status for time statistics. */ valid_status = 10c581: 57 push %edi _Rate_monotonic_Get_status( the_period, &since_last_period, &executed ); 10c582: 8d 75 d8 lea -0x28(%ebp),%esi stats->missed_count++; /* * Grab status for time statistics. */ valid_status = 10c585: 56 push %esi 10c586: 53 push %ebx 10c587: e8 cc fe ff ff call 10c458 <_Rate_monotonic_Get_status> _Rate_monotonic_Get_status( the_period, &since_last_period, &executed ); if (!valid_status) 10c58c: 83 c4 10 add $0x10,%esp 10c58f: 84 c0 test %al,%al 10c591: 75 09 jne 10c59c <_Rate_monotonic_Update_statistics+0x38> stats->min_wall_time = since_last_period; if ( since_last_period > stats->max_wall_time ) stats->max_wall_time = since_last_period; #endif } 10c593: 8d 65 f4 lea -0xc(%ebp),%esp 10c596: 5b pop %ebx 10c597: 5e pop %esi 10c598: 5f pop %edi 10c599: c9 leave 10c59a: c3 ret 10c59b: 90 nop /* * Update CPU time */ #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timestamp_Add_to( &stats->total_cpu_time, &executed ); 10c59c: 83 ec 08 sub $0x8,%esp 10c59f: 57 push %edi 10c5a0: 8d 43 6c lea 0x6c(%ebx),%eax 10c5a3: 50 push %eax 10c5a4: e8 97 38 00 00 call 10fe40 <_Timespec_Add_to> if ( _Timestamp_Less_than( &executed, &stats->min_cpu_time ) ) 10c5a9: 58 pop %eax 10c5aa: 5a pop %edx 10c5ab: 8d 43 5c lea 0x5c(%ebx),%eax 10c5ae: 50 push %eax 10c5af: 57 push %edi 10c5b0: e8 63 39 00 00 call 10ff18 <_Timespec_Less_than> 10c5b5: 83 c4 10 add $0x10,%esp 10c5b8: 84 c0 test %al,%al 10c5ba: 74 0c je 10c5c8 <_Rate_monotonic_Update_statistics+0x64> stats->min_cpu_time = executed; 10c5bc: 8b 45 e0 mov -0x20(%ebp),%eax 10c5bf: 8b 55 e4 mov -0x1c(%ebp),%edx 10c5c2: 89 43 5c mov %eax,0x5c(%ebx) 10c5c5: 89 53 60 mov %edx,0x60(%ebx) if ( _Timestamp_Greater_than( &executed, &stats->max_cpu_time ) ) 10c5c8: 83 ec 08 sub $0x8,%esp 10c5cb: 8d 43 64 lea 0x64(%ebx),%eax 10c5ce: 50 push %eax 10c5cf: 57 push %edi 10c5d0: e8 1f 39 00 00 call 10fef4 <_Timespec_Greater_than> 10c5d5: 83 c4 10 add $0x10,%esp 10c5d8: 84 c0 test %al,%al 10c5da: 74 0c je 10c5e8 <_Rate_monotonic_Update_statistics+0x84> stats->max_cpu_time = executed; 10c5dc: 8b 45 e0 mov -0x20(%ebp),%eax 10c5df: 8b 55 e4 mov -0x1c(%ebp),%edx 10c5e2: 89 43 64 mov %eax,0x64(%ebx) 10c5e5: 89 53 68 mov %edx,0x68(%ebx) /* * Update Wall time */ #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timestamp_Add_to( &stats->total_wall_time, &since_last_period ); 10c5e8: 83 ec 08 sub $0x8,%esp 10c5eb: 56 push %esi 10c5ec: 8d 83 84 00 00 00 lea 0x84(%ebx),%eax 10c5f2: 50 push %eax 10c5f3: e8 48 38 00 00 call 10fe40 <_Timespec_Add_to> if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) ) 10c5f8: 5a pop %edx 10c5f9: 59 pop %ecx 10c5fa: 8d 43 74 lea 0x74(%ebx),%eax 10c5fd: 50 push %eax 10c5fe: 56 push %esi 10c5ff: e8 14 39 00 00 call 10ff18 <_Timespec_Less_than> 10c604: 83 c4 10 add $0x10,%esp 10c607: 84 c0 test %al,%al 10c609: 75 39 jne 10c644 <_Rate_monotonic_Update_statistics+0xe0> stats->min_wall_time = since_last_period; if ( _Timestamp_Greater_than( &since_last_period, &stats->max_wall_time ) ) 10c60b: 83 ec 08 sub $0x8,%esp 10c60e: 8d 43 7c lea 0x7c(%ebx),%eax 10c611: 50 push %eax 10c612: 56 push %esi 10c613: e8 dc 38 00 00 call 10fef4 <_Timespec_Greater_than> 10c618: 83 c4 10 add $0x10,%esp 10c61b: 84 c0 test %al,%al 10c61d: 0f 84 70 ff ff ff je 10c593 <_Rate_monotonic_Update_statistics+0x2f> stats->max_wall_time = since_last_period; 10c623: 8b 45 d8 mov -0x28(%ebp),%eax 10c626: 8b 55 dc mov -0x24(%ebp),%edx 10c629: 89 43 7c mov %eax,0x7c(%ebx) 10c62c: 89 93 80 00 00 00 mov %edx,0x80(%ebx) stats->min_wall_time = since_last_period; if ( since_last_period > stats->max_wall_time ) stats->max_wall_time = since_last_period; #endif } 10c632: 8d 65 f4 lea -0xc(%ebp),%esp 10c635: 5b pop %ebx 10c636: 5e pop %esi 10c637: 5f pop %edi 10c638: c9 leave 10c639: c3 ret 10c63a: 66 90 xchg %ax,%ax */ stats = &the_period->Statistics; stats->count++; if ( the_period->state == RATE_MONOTONIC_EXPIRED ) stats->missed_count++; 10c63c: ff 43 58 incl 0x58(%ebx) 10c63f: e9 39 ff ff ff jmp 10c57d <_Rate_monotonic_Update_statistics+0x19> */ #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timestamp_Add_to( &stats->total_wall_time, &since_last_period ); if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) ) stats->min_wall_time = since_last_period; 10c644: 8b 45 d8 mov -0x28(%ebp),%eax 10c647: 8b 55 dc mov -0x24(%ebp),%edx 10c64a: 89 43 74 mov %eax,0x74(%ebx) 10c64d: 89 53 78 mov %edx,0x78(%ebx) 10c650: eb b9 jmp 10c60b <_Rate_monotonic_Update_statistics+0xa7> =============================================================================== 0010d18c <_Scheduler_priority_Block>: #include void _Scheduler_priority_Block( Thread_Control *the_thread ) { 10d18c: 55 push %ebp 10d18d: 89 e5 mov %esp,%ebp 10d18f: 53 push %ebx 10d190: 8b 45 08 mov 0x8(%ebp),%eax ) { Scheduler_priority_Per_thread *sched_info; Chain_Control *ready; sched_info = (Scheduler_priority_Per_thread *) the_thread->scheduler_info; 10d193: 8b 88 8c 00 00 00 mov 0x8c(%eax),%ecx ready = sched_info->ready_chain; 10d199: 8b 11 mov (%ecx),%edx if ( _Chain_Has_only_one_node( ready ) ) { 10d19b: 8b 5a 08 mov 0x8(%edx),%ebx 10d19e: 39 1a cmp %ebx,(%edx) 10d1a0: 74 6e je 10d210 <_Scheduler_priority_Block+0x84> ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 10d1a2: 8b 08 mov (%eax),%ecx previous = the_node->previous; 10d1a4: 8b 50 04 mov 0x4(%eax),%edx next->previous = previous; 10d1a7: 89 51 04 mov %edx,0x4(%ecx) previous->next = next; 10d1aa: 89 0a mov %ecx,(%edx) _Scheduler_priority_Ready_queue_extract( the_thread ); /* TODO: flash critical section? */ if ( _Thread_Is_heir( the_thread ) ) 10d1ac: 3b 05 3c 83 12 00 cmp 0x12833c,%eax 10d1b2: 74 18 je 10d1cc <_Scheduler_priority_Block+0x40> _Scheduler_priority_Schedule_body(); if ( _Thread_Is_executing( the_thread ) ) 10d1b4: 3b 05 38 83 12 00 cmp 0x128338,%eax 10d1ba: 74 04 je 10d1c0 <_Scheduler_priority_Block+0x34> _Thread_Dispatch_necessary = true; } 10d1bc: 5b pop %ebx 10d1bd: c9 leave 10d1be: c3 ret 10d1bf: 90 nop if ( _Thread_Is_heir( the_thread ) ) _Scheduler_priority_Schedule_body(); if ( _Thread_Is_executing( the_thread ) ) _Thread_Dispatch_necessary = true; 10d1c0: c6 05 44 83 12 00 01 movb $0x1,0x128344 } 10d1c7: 5b pop %ebx 10d1c8: c9 leave 10d1c9: c3 ret 10d1ca: 66 90 xchg %ax,%ax RTEMS_INLINE_ROUTINE Priority_Control _Priority_bit_map_Get_highest( void ) { Priority_bit_map_Control minor; Priority_bit_map_Control major; _Bitfield_Find_first_bit( _Priority_Major_bit_map, major ); 10d1cc: 66 8b 1d 60 83 12 00 mov 0x128360,%bx 10d1d3: 31 d2 xor %edx,%edx 10d1d5: 89 d1 mov %edx,%ecx 10d1d7: 66 0f bc cb bsf %bx,%cx _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor ); 10d1db: 0f b7 c9 movzwl %cx,%ecx 10d1de: 66 8b 9c 09 80 83 12 mov 0x128380(%ecx,%ecx,1),%bx 10d1e5: 00 10d1e6: 66 0f bc d3 bsf %bx,%dx return (_Priority_Bits_index( major ) << 4) + 10d1ea: c1 e1 04 shl $0x4,%ecx 10d1ed: 0f b7 d2 movzwl %dx,%edx 10d1f0: 8d 14 11 lea (%ecx,%edx,1),%edx Chain_Control *the_ready_queue ) { Priority_Control index = _Priority_bit_map_Get_highest(); if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) ) 10d1f3: 8d 14 52 lea (%edx,%edx,2),%edx 10d1f6: c1 e2 02 shl $0x2,%edx 10d1f9: 03 15 80 39 12 00 add 0x123980,%edx 10d1ff: 8b 0a mov (%edx),%ecx RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 10d201: 83 c2 04 add $0x4,%edx 10d204: 39 d1 cmp %edx,%ecx 10d206: 74 44 je 10d24c <_Scheduler_priority_Block+0xc0><== NEVER TAKEN * * @param[in] the_thread - pointer to thread */ RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void) { _Thread_Heir = _Scheduler_priority_Ready_queue_first( 10d208: 89 0d 3c 83 12 00 mov %ecx,0x12833c 10d20e: eb a4 jmp 10d1b4 <_Scheduler_priority_Block+0x28> RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); 10d210: 8d 5a 04 lea 0x4(%edx),%ebx 10d213: 89 1a mov %ebx,(%edx) head->next = tail; head->previous = NULL; 10d215: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) tail->previous = head; 10d21c: 89 52 08 mov %edx,0x8(%edx) RTEMS_INLINE_ROUTINE void _Priority_bit_map_Remove ( Priority_bit_map_Information *the_priority_map ) { *the_priority_map->minor &= the_priority_map->block_minor; 10d21f: 8b 59 04 mov 0x4(%ecx),%ebx 10d222: 66 8b 13 mov (%ebx),%dx 10d225: 66 23 51 0e and 0xe(%ecx),%dx 10d229: 66 89 13 mov %dx,(%ebx) if ( *the_priority_map->minor == 0 ) 10d22c: 66 85 d2 test %dx,%dx 10d22f: 0f 85 77 ff ff ff jne 10d1ac <_Scheduler_priority_Block+0x20> _Priority_Major_bit_map &= the_priority_map->block_major; 10d235: 66 8b 15 60 83 12 00 mov 0x128360,%dx 10d23c: 23 51 0c and 0xc(%ecx),%edx 10d23f: 66 89 15 60 83 12 00 mov %dx,0x128360 10d246: e9 61 ff ff ff jmp 10d1ac <_Scheduler_priority_Block+0x20> 10d24b: 90 nop Priority_Control index = _Priority_bit_map_Get_highest(); if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) ) return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] ); return NULL; 10d24c: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 10d24e: eb b8 jmp 10d208 <_Scheduler_priority_Block+0x7c><== NOT EXECUTED =============================================================================== 0010d3a0 <_Scheduler_priority_Schedule>: #include #include #include void _Scheduler_priority_Schedule(void) { 10d3a0: 55 push %ebp 10d3a1: 89 e5 mov %esp,%ebp RTEMS_INLINE_ROUTINE Priority_Control _Priority_bit_map_Get_highest( void ) { Priority_bit_map_Control minor; Priority_bit_map_Control major; _Bitfield_Find_first_bit( _Priority_Major_bit_map, major ); 10d3a3: 66 8b 0d 60 83 12 00 mov 0x128360,%cx 10d3aa: 31 c0 xor %eax,%eax 10d3ac: 89 c2 mov %eax,%edx 10d3ae: 66 0f bc d1 bsf %cx,%dx _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor ); 10d3b2: 0f b7 d2 movzwl %dx,%edx 10d3b5: 66 8b 8c 12 80 83 12 mov 0x128380(%edx,%edx,1),%cx 10d3bc: 00 10d3bd: 66 0f bc c1 bsf %cx,%ax return (_Priority_Bits_index( major ) << 4) + 10d3c1: c1 e2 04 shl $0x4,%edx 10d3c4: 0f b7 c0 movzwl %ax,%eax 10d3c7: 8d 04 02 lea (%edx,%eax,1),%eax Chain_Control *the_ready_queue ) { Priority_Control index = _Priority_bit_map_Get_highest(); if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) ) 10d3ca: 8d 04 40 lea (%eax,%eax,2),%eax 10d3cd: c1 e0 02 shl $0x2,%eax 10d3d0: 03 05 80 39 12 00 add 0x123980,%eax _Scheduler_priority_Schedule_body(); } 10d3d6: 8b 10 mov (%eax),%edx RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 10d3d8: 83 c0 04 add $0x4,%eax 10d3db: 39 c2 cmp %eax,%edx 10d3dd: 74 09 je 10d3e8 <_Scheduler_priority_Schedule+0x48><== NEVER TAKEN * * @param[in] the_thread - pointer to thread */ RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void) { _Thread_Heir = _Scheduler_priority_Ready_queue_first( 10d3df: 89 15 3c 83 12 00 mov %edx,0x12833c 10d3e5: c9 leave 10d3e6: c3 ret 10d3e7: 90 nop Priority_Control index = _Priority_bit_map_Get_highest(); if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) ) return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] ); return NULL; 10d3e8: 31 d2 xor %edx,%edx <== NOT EXECUTED * * @param[in] the_thread - pointer to thread */ RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void) { _Thread_Heir = _Scheduler_priority_Ready_queue_first( 10d3ea: 89 15 3c 83 12 00 mov %edx,0x12833c <== NOT EXECUTED 10d3f0: c9 leave <== NOT EXECUTED 10d3f1: c3 ret <== NOT EXECUTED =============================================================================== 0010d4c4 <_Scheduler_priority_Yield>: * ready chain * select heir */ void _Scheduler_priority_Yield(void) { 10d4c4: 55 push %ebp 10d4c5: 89 e5 mov %esp,%ebp 10d4c7: 56 push %esi 10d4c8: 53 push %ebx Scheduler_priority_Per_thread *sched_info; ISR_Level level; Thread_Control *executing; Chain_Control *ready; executing = _Thread_Executing; 10d4c9: a1 38 83 12 00 mov 0x128338,%eax sched_info = (Scheduler_priority_Per_thread *) executing->scheduler_info; ready = sched_info->ready_chain; 10d4ce: 8b 90 8c 00 00 00 mov 0x8c(%eax),%edx 10d4d4: 8b 12 mov (%edx),%edx _ISR_Disable( level ); 10d4d6: 9c pushf 10d4d7: fa cli 10d4d8: 59 pop %ecx if ( !_Chain_Has_only_one_node( ready ) ) { 10d4d9: 8b 5a 08 mov 0x8(%edx),%ebx 10d4dc: 39 1a cmp %ebx,(%edx) 10d4de: 74 40 je 10d520 <_Scheduler_priority_Yield+0x5c> ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 10d4e0: 8b 30 mov (%eax),%esi previous = the_node->previous; 10d4e2: 8b 58 04 mov 0x4(%eax),%ebx next->previous = previous; 10d4e5: 89 5e 04 mov %ebx,0x4(%esi) previous->next = next; 10d4e8: 89 33 mov %esi,(%ebx) Chain_Control *the_chain, Chain_Node *the_node ) { Chain_Node *tail = _Chain_Tail( the_chain ); Chain_Node *old_last = tail->previous; 10d4ea: 8b 5a 08 mov 0x8(%edx),%ebx RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected( Chain_Control *the_chain, Chain_Node *the_node ) { Chain_Node *tail = _Chain_Tail( the_chain ); 10d4ed: 8d 72 04 lea 0x4(%edx),%esi 10d4f0: 89 30 mov %esi,(%eax) Chain_Node *old_last = tail->previous; the_node->next = tail; tail->previous = the_node; 10d4f2: 89 42 08 mov %eax,0x8(%edx) old_last->next = the_node; 10d4f5: 89 03 mov %eax,(%ebx) the_node->previous = old_last; 10d4f7: 89 58 04 mov %ebx,0x4(%eax) _Chain_Extract_unprotected( &executing->Object.Node ); _Chain_Append_unprotected( ready, &executing->Object.Node ); _ISR_Flash( level ); 10d4fa: 51 push %ecx 10d4fb: 9d popf 10d4fc: fa cli if ( _Thread_Is_heir( executing ) ) 10d4fd: 3b 05 3c 83 12 00 cmp 0x12833c,%eax 10d503: 74 0f je 10d514 <_Scheduler_priority_Yield+0x50> _Thread_Heir = (Thread_Control *) _Chain_First( ready ); _Thread_Dispatch_necessary = true; } else if ( !_Thread_Is_heir( executing ) ) _Thread_Dispatch_necessary = true; 10d505: c6 05 44 83 12 00 01 movb $0x1,0x128344 _ISR_Enable( level ); 10d50c: 51 push %ecx 10d50d: 9d popf } 10d50e: 5b pop %ebx 10d50f: 5e pop %esi 10d510: c9 leave 10d511: c3 ret 10d512: 66 90 xchg %ax,%ax _Chain_Append_unprotected( ready, &executing->Object.Node ); _ISR_Flash( level ); if ( _Thread_Is_heir( executing ) ) _Thread_Heir = (Thread_Control *) _Chain_First( ready ); 10d514: 8b 02 mov (%edx),%eax 10d516: a3 3c 83 12 00 mov %eax,0x12833c 10d51b: eb e8 jmp 10d505 <_Scheduler_priority_Yield+0x41> 10d51d: 8d 76 00 lea 0x0(%esi),%esi _Thread_Dispatch_necessary = true; } else if ( !_Thread_Is_heir( executing ) ) 10d520: 3b 05 3c 83 12 00 cmp 0x12833c,%eax 10d526: 75 dd jne 10d505 <_Scheduler_priority_Yield+0x41> 10d528: eb e2 jmp 10d50c <_Scheduler_priority_Yield+0x48> =============================================================================== 0010dadc <_TOD_Set>: */ void _TOD_Set( const struct timespec *time ) { 10dadc: 55 push %ebp 10dadd: 89 e5 mov %esp,%ebp 10dadf: 53 push %ebx 10dae0: 83 ec 04 sub $0x4,%esp 10dae3: 8b 5d 08 mov 0x8(%ebp),%ebx 10dae6: a1 10 aa 12 00 mov 0x12aa10,%eax 10daeb: 40 inc %eax 10daec: a3 10 aa 12 00 mov %eax,0x12aa10 long seconds; _Thread_Disable_dispatch(); _TOD_Deactivate(); seconds = _TOD_Seconds_since_epoch(); 10daf1: a1 a8 aa 12 00 mov 0x12aaa8,%eax if ( time->tv_sec < seconds ) 10daf6: 8b 13 mov (%ebx),%edx 10daf8: 39 d0 cmp %edx,%eax 10dafa: 7f 34 jg 10db30 <_TOD_Set+0x54> Watchdog_Adjust_directions direction, Watchdog_Interval units ) { _Watchdog_Adjust( &_Watchdog_Seconds_chain, direction, units ); 10dafc: 51 push %ecx _Watchdog_Adjust_seconds( WATCHDOG_BACKWARD, seconds - time->tv_sec ); else _Watchdog_Adjust_seconds( WATCHDOG_FORWARD, time->tv_sec - seconds ); 10dafd: 29 c2 sub %eax,%edx 10daff: 52 push %edx 10db00: 6a 00 push $0x0 10db02: 68 d4 aa 12 00 push $0x12aad4 10db07: e8 0c 25 00 00 call 110018 <_Watchdog_Adjust> 10db0c: 83 c4 10 add $0x10,%esp /* POSIX format TOD (timespec) */ _Timestamp_Set( &_TOD_Now, time->tv_sec, time->tv_nsec ); 10db0f: 8b 03 mov (%ebx),%eax 10db11: a3 a8 aa 12 00 mov %eax,0x12aaa8 10db16: 8b 43 04 mov 0x4(%ebx),%eax 10db19: a3 ac aa 12 00 mov %eax,0x12aaac _TOD_Is_set = true; 10db1e: c6 05 24 aa 12 00 01 movb $0x1,0x12aa24 _TOD_Activate(); _Thread_Enable_dispatch(); } 10db25: 8b 5d fc mov -0x4(%ebp),%ebx 10db28: c9 leave _Timestamp_Set( &_TOD_Now, time->tv_sec, time->tv_nsec ); _TOD_Is_set = true; _TOD_Activate(); _Thread_Enable_dispatch(); 10db29: e9 02 16 00 00 jmp 10f130 <_Thread_Enable_dispatch> 10db2e: 66 90 xchg %ax,%ax 10db30: 51 push %ecx _TOD_Deactivate(); seconds = _TOD_Seconds_since_epoch(); if ( time->tv_sec < seconds ) _Watchdog_Adjust_seconds( WATCHDOG_BACKWARD, seconds - time->tv_sec ); 10db31: 29 d0 sub %edx,%eax 10db33: 50 push %eax 10db34: 6a 01 push $0x1 10db36: 68 d4 aa 12 00 push $0x12aad4 10db3b: e8 d8 24 00 00 call 110018 <_Watchdog_Adjust> 10db40: 83 c4 10 add $0x10,%esp 10db43: eb ca jmp 10db0f <_TOD_Set+0x33> =============================================================================== 0010c1e8 <_TOD_To_seconds>: */ uint32_t _TOD_To_seconds( const rtems_time_of_day *the_tod ) { 10c1e8: 55 push %ebp 10c1e9: 89 e5 mov %esp,%ebp 10c1eb: 56 push %esi 10c1ec: 53 push %ebx 10c1ed: 8b 55 08 mov 0x8(%ebp),%edx uint32_t time; uint32_t year_mod_4; time = the_tod->day - 1; 10c1f0: 8b 72 08 mov 0x8(%edx),%esi 10c1f3: 4e dec %esi year_mod_4 = the_tod->year & 3; 10c1f4: 8b 02 mov (%edx),%eax if ( year_mod_4 == 0 ) 10c1f6: 89 c3 mov %eax,%ebx 10c1f8: 83 e3 03 and $0x3,%ebx 10c1fb: 74 67 je 10c264 <_TOD_To_seconds+0x7c> time += _TOD_Days_to_date[ 1 ][ the_tod->month ]; else time += _TOD_Days_to_date[ 0 ][ the_tod->month ]; 10c1fd: 8b 4a 04 mov 0x4(%edx),%ecx 10c200: 0f b7 8c 09 c0 42 12 movzwl 0x1242c0(%ecx,%ecx,1),%ecx 10c207: 00 10c208: 8d 34 31 lea (%ecx,%esi,1),%esi time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) * ( (TOD_DAYS_PER_YEAR * 4) + 1); time += _TOD_Days_since_last_leap_year[ year_mod_4 ]; 10c20b: 0f b7 8c 1b f4 42 12 movzwl 0x1242f4(%ebx,%ebx,1),%ecx 10c212: 00 if ( year_mod_4 == 0 ) time += _TOD_Days_to_date[ 1 ][ the_tod->month ]; else time += _TOD_Days_to_date[ 0 ][ the_tod->month ]; time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) * 10c213: 2d c4 07 00 00 sub $0x7c4,%eax 10c218: c1 e8 02 shr $0x2,%eax 10c21b: 8d 1c c0 lea (%eax,%eax,8),%ebx 10c21e: 8d 1c d8 lea (%eax,%ebx,8),%ebx 10c221: 8d 1c 9b lea (%ebx,%ebx,4),%ebx 10c224: 8d 04 98 lea (%eax,%ebx,4),%eax 10c227: 01 c1 add %eax,%ecx ( (TOD_DAYS_PER_YEAR * 4) + 1); time += _TOD_Days_since_last_leap_year[ year_mod_4 ]; 10c229: 01 f1 add %esi,%ecx time *= TOD_SECONDS_PER_DAY; 10c22b: 8d 04 89 lea (%ecx,%ecx,4),%eax 10c22e: 8d 04 81 lea (%ecx,%eax,4),%eax 10c231: 8d 04 c1 lea (%ecx,%eax,8),%eax 10c234: c1 e0 02 shl $0x2,%eax 10c237: 29 c8 sub %ecx,%eax 10c239: c1 e0 07 shl $0x7,%eax time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute) 10c23c: 8b 5a 14 mov 0x14(%edx),%ebx 10c23f: 8b 4a 0c mov 0xc(%edx),%ecx 10c242: 8d 0c 49 lea (%ecx,%ecx,2),%ecx 10c245: 8d 0c 89 lea (%ecx,%ecx,4),%ecx 10c248: c1 e1 02 shl $0x2,%ecx 10c24b: 03 4a 10 add 0x10(%edx),%ecx * TOD_SECONDS_PER_MINUTE; 10c24e: 8d 14 49 lea (%ecx,%ecx,2),%edx 10c251: 8d 14 92 lea (%edx,%edx,4),%edx time += the_tod->second; 10c254: 8d 94 93 00 e5 da 21 lea 0x21dae500(%ebx,%edx,4),%edx time += TOD_SECONDS_1970_THROUGH_1988; 10c25b: 8d 04 02 lea (%edx,%eax,1),%eax return( time ); } 10c25e: 5b pop %ebx 10c25f: 5e pop %esi 10c260: c9 leave 10c261: c3 ret 10c262: 66 90 xchg %ax,%ax time = the_tod->day - 1; year_mod_4 = the_tod->year & 3; if ( year_mod_4 == 0 ) time += _TOD_Days_to_date[ 1 ][ the_tod->month ]; 10c264: 8b 4a 04 mov 0x4(%edx),%ecx 10c267: 0f b7 8c 09 da 42 12 movzwl 0x1242da(%ecx,%ecx,1),%ecx 10c26e: 00 10c26f: 8d 34 31 lea (%ecx,%esi,1),%esi 10c272: eb 97 jmp 10c20b <_TOD_To_seconds+0x23> =============================================================================== 0010c274 <_TOD_Validate>: */ bool _TOD_Validate( const rtems_time_of_day *the_tod ) { 10c274: 55 push %ebp 10c275: 89 e5 mov %esp,%ebp 10c277: 53 push %ebx 10c278: 8b 4d 08 mov 0x8(%ebp),%ecx uint32_t days_in_month; uint32_t ticks_per_second; ticks_per_second = TOD_MICROSECONDS_PER_SECOND / rtems_configuration_get_microseconds_per_tick(); 10c27b: 8b 1d 6c 62 12 00 mov 0x12626c,%ebx if ((!the_tod) || 10c281: 85 c9 test %ecx,%ecx 10c283: 74 53 je 10c2d8 <_TOD_Validate+0x64> <== NEVER TAKEN ) { uint32_t days_in_month; uint32_t ticks_per_second; ticks_per_second = TOD_MICROSECONDS_PER_SECOND / 10c285: b8 40 42 0f 00 mov $0xf4240,%eax 10c28a: 31 d2 xor %edx,%edx 10c28c: f7 f3 div %ebx rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) || 10c28e: 3b 41 18 cmp 0x18(%ecx),%eax 10c291: 76 45 jbe 10c2d8 <_TOD_Validate+0x64> (the_tod->ticks >= ticks_per_second) || 10c293: 83 79 14 3b cmpl $0x3b,0x14(%ecx) 10c297: 77 3f ja 10c2d8 <_TOD_Validate+0x64> (the_tod->second >= TOD_SECONDS_PER_MINUTE) || 10c299: 83 79 10 3b cmpl $0x3b,0x10(%ecx) 10c29d: 77 39 ja 10c2d8 <_TOD_Validate+0x64> (the_tod->minute >= TOD_MINUTES_PER_HOUR) || 10c29f: 83 79 0c 17 cmpl $0x17,0xc(%ecx) 10c2a3: 77 33 ja 10c2d8 <_TOD_Validate+0x64> (the_tod->hour >= TOD_HOURS_PER_DAY) || (the_tod->month == 0) || 10c2a5: 8b 41 04 mov 0x4(%ecx),%eax rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) || (the_tod->ticks >= ticks_per_second) || (the_tod->second >= TOD_SECONDS_PER_MINUTE) || (the_tod->minute >= TOD_MINUTES_PER_HOUR) || (the_tod->hour >= TOD_HOURS_PER_DAY) || 10c2a8: 85 c0 test %eax,%eax 10c2aa: 74 2c je 10c2d8 <_TOD_Validate+0x64> <== NEVER TAKEN (the_tod->month == 0) || 10c2ac: 83 f8 0c cmp $0xc,%eax 10c2af: 77 27 ja 10c2d8 <_TOD_Validate+0x64> (the_tod->month > TOD_MONTHS_PER_YEAR) || (the_tod->year < TOD_BASE_YEAR) || 10c2b1: 8b 11 mov (%ecx),%edx (the_tod->ticks >= ticks_per_second) || (the_tod->second >= TOD_SECONDS_PER_MINUTE) || (the_tod->minute >= TOD_MINUTES_PER_HOUR) || (the_tod->hour >= TOD_HOURS_PER_DAY) || (the_tod->month == 0) || (the_tod->month > TOD_MONTHS_PER_YEAR) || 10c2b3: 81 fa c3 07 00 00 cmp $0x7c3,%edx 10c2b9: 76 1d jbe 10c2d8 <_TOD_Validate+0x64> (the_tod->year < TOD_BASE_YEAR) || (the_tod->day == 0) ) 10c2bb: 8b 49 08 mov 0x8(%ecx),%ecx (the_tod->second >= TOD_SECONDS_PER_MINUTE) || (the_tod->minute >= TOD_MINUTES_PER_HOUR) || (the_tod->hour >= TOD_HOURS_PER_DAY) || (the_tod->month == 0) || (the_tod->month > TOD_MONTHS_PER_YEAR) || (the_tod->year < TOD_BASE_YEAR) || 10c2be: 85 c9 test %ecx,%ecx 10c2c0: 74 16 je 10c2d8 <_TOD_Validate+0x64> <== NEVER TAKEN (the_tod->day == 0) ) return false; if ( (the_tod->year % 4) == 0 ) 10c2c2: 83 e2 03 and $0x3,%edx 10c2c5: 75 16 jne 10c2dd <_TOD_Validate+0x69> days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ]; 10c2c7: 8b 04 85 34 43 12 00 mov 0x124334(,%eax,4),%eax * false - if the the_tod is invalid * * NOTE: This routine only works for leap-years through 2099. */ bool _TOD_Validate( 10c2ce: 39 c8 cmp %ecx,%eax 10c2d0: 0f 93 c0 setae %al 10c2d3: eb 05 jmp 10c2da <_TOD_Validate+0x66> 10c2d5: 8d 76 00 lea 0x0(%esi),%esi (the_tod->hour >= TOD_HOURS_PER_DAY) || (the_tod->month == 0) || (the_tod->month > TOD_MONTHS_PER_YEAR) || (the_tod->year < TOD_BASE_YEAR) || (the_tod->day == 0) ) return false; 10c2d8: 31 c0 xor %eax,%eax if ( the_tod->day > days_in_month ) return false; return true; } 10c2da: 5b pop %ebx 10c2db: c9 leave 10c2dc: c3 ret return false; if ( (the_tod->year % 4) == 0 ) days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ]; else days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ]; 10c2dd: 8b 04 85 00 43 12 00 mov 0x124300(,%eax,4),%eax 10c2e4: eb e8 jmp 10c2ce <_TOD_Validate+0x5a> =============================================================================== 0010d578 <_Thread_Change_priority>: void _Thread_Change_priority( Thread_Control *the_thread, Priority_Control new_priority, bool prepend_it ) { 10d578: 55 push %ebp 10d579: 89 e5 mov %esp,%ebp 10d57b: 57 push %edi 10d57c: 56 push %esi 10d57d: 53 push %ebx 10d57e: 83 ec 28 sub $0x28,%esp 10d581: 8b 5d 08 mov 0x8(%ebp),%ebx 10d584: 8b 75 0c mov 0xc(%ebp),%esi 10d587: 8a 45 10 mov 0x10(%ebp),%al 10d58a: 88 45 e7 mov %al,-0x19(%ebp) States_Control state, original_state; /* * Save original state */ original_state = the_thread->current_state; 10d58d: 8b 7b 10 mov 0x10(%ebx),%edi /* * Set a transient state for the thread so it is pulled off the Ready chains. * This will prevent it from being scheduled no matter what happens in an * ISR. */ _Thread_Set_transient( the_thread ); 10d590: 53 push %ebx 10d591: e8 76 0c 00 00 call 10e20c <_Thread_Set_transient> /* * Do not bother recomputing all the priority related information if * we are not REALLY changing priority. */ if ( the_thread->current_priority != new_priority ) 10d596: 83 c4 10 add $0x10,%esp 10d599: 39 73 14 cmp %esi,0x14(%ebx) 10d59c: 74 0d je 10d5ab <_Thread_Change_priority+0x33> _Thread_Set_priority( the_thread, new_priority ); 10d59e: 83 ec 08 sub $0x8,%esp 10d5a1: 56 push %esi 10d5a2: 53 push %ebx 10d5a3: e8 10 0c 00 00 call 10e1b8 <_Thread_Set_priority> 10d5a8: 83 c4 10 add $0x10,%esp _ISR_Disable( level ); 10d5ab: 9c pushf 10d5ac: fa cli 10d5ad: 5e pop %esi /* * If the thread has more than STATES_TRANSIENT set, then it is blocked, * If it is blocked on a thread queue, then we need to requeue it. */ state = the_thread->current_state; 10d5ae: 8b 43 10 mov 0x10(%ebx),%eax if ( state != STATES_TRANSIENT ) { 10d5b1: 83 f8 04 cmp $0x4,%eax 10d5b4: 74 22 je 10d5d8 <_Thread_Change_priority+0x60> /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) 10d5b6: 83 e7 04 and $0x4,%edi 10d5b9: 74 11 je 10d5cc <_Thread_Change_priority+0x54><== ALWAYS TAKEN the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); _ISR_Enable( level ); 10d5bb: 56 push %esi 10d5bc: 9d popf if ( _States_Is_waiting_on_thread_queue( state ) ) { 10d5bd: a9 e0 be 03 00 test $0x3bee0,%eax 10d5c2: 75 60 jne 10d624 <_Thread_Change_priority+0xac> if ( !_Thread_Is_executing_also_the_heir() && _Thread_Executing->is_preemptible ) _Thread_Dispatch_necessary = true; _ISR_Enable( level ); } 10d5c4: 8d 65 f4 lea -0xc(%ebp),%esp 10d5c7: 5b pop %ebx 10d5c8: 5e pop %esi 10d5c9: 5f pop %edi 10d5ca: c9 leave 10d5cb: c3 ret RTEMS_INLINE_ROUTINE States_Control _States_Clear ( States_Control states_to_clear, States_Control current_state ) { return (current_state & ~states_to_clear); 10d5cc: 89 c2 mov %eax,%edx 10d5ce: 83 e2 fb and $0xfffffffb,%edx 10d5d1: 89 53 10 mov %edx,0x10(%ebx) 10d5d4: eb e5 jmp 10d5bb <_Thread_Change_priority+0x43> 10d5d6: 66 90 xchg %ax,%ax } return; } /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) { 10d5d8: 83 e7 04 and $0x4,%edi 10d5db: 75 1a jne 10d5f7 <_Thread_Change_priority+0x7f><== NEVER TAKEN * Interrupts are STILL disabled. * We now know the thread will be in the READY state when we remove * the TRANSIENT state. So we have to place it on the appropriate * Ready Queue with interrupts off. */ the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); 10d5dd: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) if ( prepend_it ) 10d5e4: 80 7d e7 00 cmpb $0x0,-0x19(%ebp) 10d5e8: 74 52 je 10d63c <_Thread_Change_priority+0xc4> */ RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first( Thread_Control *the_thread ) { _Scheduler.Operations.enqueue_first( the_thread ); 10d5ea: 83 ec 0c sub $0xc,%esp 10d5ed: 53 push %ebx 10d5ee: ff 15 a8 39 12 00 call *0x1239a8 10d5f4: 83 c4 10 add $0x10,%esp _Scheduler_Enqueue_first( the_thread ); else _Scheduler_Enqueue( the_thread ); } _ISR_Flash( level ); 10d5f7: 56 push %esi 10d5f8: 9d popf 10d5f9: fa cli * This kernel routine implements the scheduling decision logic for * the scheduler. It does NOT dispatch. */ RTEMS_INLINE_ROUTINE void _Scheduler_Schedule( void ) { _Scheduler.Operations.schedule(); 10d5fa: ff 15 88 39 12 00 call *0x123988 * is also the heir thread, and false otherwise. */ RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void ) { return ( _Thread_Executing == _Thread_Heir ); 10d600: a1 38 83 12 00 mov 0x128338,%eax * We altered the set of thread priorities. So let's figure out * who is the heir and if we need to switch to them. */ _Scheduler_Schedule(); if ( !_Thread_Is_executing_also_the_heir() && 10d605: 3b 05 3c 83 12 00 cmp 0x12833c,%eax 10d60b: 74 0d je 10d61a <_Thread_Change_priority+0xa2> 10d60d: 80 78 74 00 cmpb $0x0,0x74(%eax) 10d611: 74 07 je 10d61a <_Thread_Change_priority+0xa2> _Thread_Executing->is_preemptible ) _Thread_Dispatch_necessary = true; 10d613: c6 05 44 83 12 00 01 movb $0x1,0x128344 _ISR_Enable( level ); 10d61a: 56 push %esi 10d61b: 9d popf } 10d61c: 8d 65 f4 lea -0xc(%ebp),%esp 10d61f: 5b pop %ebx 10d620: 5e pop %esi 10d621: 5f pop %edi 10d622: c9 leave 10d623: c3 ret /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); _ISR_Enable( level ); if ( _States_Is_waiting_on_thread_queue( state ) ) { _Thread_queue_Requeue( the_thread->Wait.queue, the_thread ); 10d624: 89 5d 0c mov %ebx,0xc(%ebp) 10d627: 8b 43 44 mov 0x44(%ebx),%eax 10d62a: 89 45 08 mov %eax,0x8(%ebp) if ( !_Thread_Is_executing_also_the_heir() && _Thread_Executing->is_preemptible ) _Thread_Dispatch_necessary = true; _ISR_Enable( level ); } 10d62d: 8d 65 f4 lea -0xc(%ebp),%esp 10d630: 5b pop %ebx 10d631: 5e pop %esi 10d632: 5f pop %edi 10d633: c9 leave /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); _ISR_Enable( level ); if ( _States_Is_waiting_on_thread_queue( state ) ) { _Thread_queue_Requeue( the_thread->Wait.queue, the_thread ); 10d634: e9 e7 0a 00 00 jmp 10e120 <_Thread_queue_Requeue> 10d639: 8d 76 00 lea 0x0(%esi),%esi */ RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue( Thread_Control *the_thread ) { _Scheduler.Operations.enqueue( the_thread ); 10d63c: 83 ec 0c sub $0xc,%esp 10d63f: 53 push %ebx 10d640: ff 15 a4 39 12 00 call *0x1239a4 10d646: 83 c4 10 add $0x10,%esp 10d649: eb ac jmp 10d5f7 <_Thread_Change_priority+0x7f> =============================================================================== 0010d64c <_Thread_Clear_state>: */ void _Thread_Clear_state( Thread_Control *the_thread, States_Control state ) { 10d64c: 55 push %ebp 10d64d: 89 e5 mov %esp,%ebp 10d64f: 53 push %ebx 10d650: 83 ec 04 sub $0x4,%esp 10d653: 8b 55 08 mov 0x8(%ebp),%edx 10d656: 8b 45 0c mov 0xc(%ebp),%eax ISR_Level level; States_Control current_state; _ISR_Disable( level ); 10d659: 9c pushf 10d65a: fa cli 10d65b: 5b pop %ebx current_state = the_thread->current_state; 10d65c: 8b 4a 10 mov 0x10(%edx),%ecx if ( current_state & state ) { 10d65f: 85 c8 test %ecx,%eax 10d661: 74 0b je 10d66e <_Thread_Clear_state+0x22> 10d663: f7 d0 not %eax 10d665: 21 c8 and %ecx,%eax current_state = the_thread->current_state = _States_Clear( state, current_state ); 10d667: 89 42 10 mov %eax,0x10(%edx) if ( _States_Is_ready( current_state ) ) { 10d66a: 85 c0 test %eax,%eax 10d66c: 74 0a je 10d678 <_Thread_Clear_state+0x2c> _Scheduler_Unblock( the_thread ); } } _ISR_Enable( level ); 10d66e: 53 push %ebx 10d66f: 9d popf } 10d670: 8b 5d fc mov -0x4(%ebp),%ebx 10d673: c9 leave 10d674: c3 ret 10d675: 8d 76 00 lea 0x0(%esi),%esi */ RTEMS_INLINE_ROUTINE void _Scheduler_Unblock( Thread_Control *the_thread ) { _Scheduler.Operations.unblock( the_thread ); 10d678: 83 ec 0c sub $0xc,%esp 10d67b: 52 push %edx 10d67c: ff 15 94 39 12 00 call *0x123994 10d682: 83 c4 10 add $0x10,%esp 10d685: eb e7 jmp 10d66e <_Thread_Clear_state+0x22> =============================================================================== 0010d7fc <_Thread_Delay_ended>: void _Thread_Delay_ended( Objects_Id id, void *ignored __attribute__((unused)) ) { 10d7fc: 55 push %ebp 10d7fd: 89 e5 mov %esp,%ebp 10d7ff: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10d802: 8d 45 f4 lea -0xc(%ebp),%eax 10d805: 50 push %eax 10d806: ff 75 08 pushl 0x8(%ebp) 10d809: e8 c6 01 00 00 call 10d9d4 <_Thread_Get> switch ( location ) { 10d80e: 83 c4 10 add $0x10,%esp 10d811: 8b 55 f4 mov -0xc(%ebp),%edx 10d814: 85 d2 test %edx,%edx 10d816: 75 1c jne 10d834 <_Thread_Delay_ended+0x38><== NEVER TAKEN #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* impossible */ #endif break; case OBJECTS_LOCAL: _Thread_Clear_state( 10d818: 83 ec 08 sub $0x8,%esp 10d81b: 68 18 00 00 10 push $0x10000018 10d820: 50 push %eax 10d821: e8 26 fe ff ff call 10d64c <_Thread_Clear_state> 10d826: a1 90 7d 12 00 mov 0x127d90,%eax 10d82b: 48 dec %eax 10d82c: a3 90 7d 12 00 mov %eax,0x127d90 10d831: 83 c4 10 add $0x10,%esp | STATES_INTERRUPTIBLE_BY_SIGNAL ); _Thread_Unnest_dispatch(); break; } } 10d834: c9 leave 10d835: c3 ret =============================================================================== 0010d838 <_Thread_Dispatch>: * dispatch thread * no dispatch thread */ void _Thread_Dispatch( void ) { 10d838: 55 push %ebp 10d839: 89 e5 mov %esp,%ebp 10d83b: 57 push %edi 10d83c: 56 push %esi 10d83d: 53 push %ebx 10d83e: 83 ec 1c sub $0x1c,%esp Thread_Control *executing; Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; 10d841: 8b 1d 38 83 12 00 mov 0x128338,%ebx _ISR_Disable( level ); 10d847: 9c pushf 10d848: fa cli 10d849: 58 pop %eax while ( _Thread_Dispatch_necessary == true ) { 10d84a: 8a 15 44 83 12 00 mov 0x128344,%dl 10d850: 84 d2 test %dl,%dl 10d852: 0f 84 3c 01 00 00 je 10d994 <_Thread_Dispatch+0x15c> heir = _Thread_Heir; 10d858: 8b 35 3c 83 12 00 mov 0x12833c,%esi _Thread_Dispatch_disable_level = 1; 10d85e: c7 05 90 7d 12 00 01 movl $0x1,0x127d90 10d865: 00 00 00 _Thread_Dispatch_necessary = false; 10d868: c6 05 44 83 12 00 00 movb $0x0,0x128344 _Thread_Executing = heir; 10d86f: 89 35 38 83 12 00 mov %esi,0x128338 /* * When the heir and executing are the same, then we are being * requested to do the post switch dispatching. This is normally * done to dispatch signals. */ if ( heir == executing ) 10d875: 39 f3 cmp %esi,%ebx 10d877: 0f 84 17 01 00 00 je 10d994 <_Thread_Dispatch+0x15c> 10d87d: 8d 7d d8 lea -0x28(%ebp),%edi 10d880: e9 f5 00 00 00 jmp 10d97a <_Thread_Dispatch+0x142> 10d885: 8d 76 00 lea 0x0(%esi),%esi rtems_ada_self = heir->rtems_ada_self; #endif if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE ) heir->cpu_time_budget = _Thread_Ticks_per_timeslice; _ISR_Enable( level ); 10d888: 50 push %eax 10d889: 9d popf #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ { Timestamp_Control uptime, ran; _TOD_Get_uptime( &uptime ); 10d88a: 83 ec 0c sub $0xc,%esp 10d88d: 8d 45 e0 lea -0x20(%ebp),%eax 10d890: 50 push %eax 10d891: e8 2a 3a 00 00 call 1112c0 <_TOD_Get_uptime> _Timestamp_Subtract( 10d896: 83 c4 0c add $0xc,%esp 10d899: 57 push %edi 10d89a: 8d 45 e0 lea -0x20(%ebp),%eax 10d89d: 50 push %eax 10d89e: 68 4c 7e 12 00 push $0x127e4c 10d8a3: e8 98 0b 00 00 call 10e440 <_Timespec_Subtract> &_Thread_Time_of_last_context_switch, &uptime, &ran ); _Timestamp_Add_to( &executing->cpu_time_used, &ran ); 10d8a8: 58 pop %eax 10d8a9: 5a pop %edx 10d8aa: 57 push %edi 10d8ab: 8d 83 84 00 00 00 lea 0x84(%ebx),%eax 10d8b1: 50 push %eax 10d8b2: e8 4d 0b 00 00 call 10e404 <_Timespec_Add_to> _Thread_Time_of_last_context_switch = uptime; 10d8b7: 8b 45 e0 mov -0x20(%ebp),%eax 10d8ba: 8b 55 e4 mov -0x1c(%ebp),%edx 10d8bd: a3 4c 7e 12 00 mov %eax,0x127e4c 10d8c2: 89 15 50 7e 12 00 mov %edx,0x127e50 #endif /* * Switch libc's task specific data. */ if ( _Thread_libc_reent ) { 10d8c8: a1 24 7e 12 00 mov 0x127e24,%eax 10d8cd: 83 c4 10 add $0x10,%esp 10d8d0: 85 c0 test %eax,%eax 10d8d2: 74 10 je 10d8e4 <_Thread_Dispatch+0xac> <== NEVER TAKEN executing->libc_reent = *_Thread_libc_reent; 10d8d4: 8b 10 mov (%eax),%edx 10d8d6: 89 93 e4 00 00 00 mov %edx,0xe4(%ebx) *_Thread_libc_reent = heir->libc_reent; 10d8dc: 8b 96 e4 00 00 00 mov 0xe4(%esi),%edx 10d8e2: 89 10 mov %edx,(%eax) } _User_extensions_Thread_switch( executing, heir ); 10d8e4: 83 ec 08 sub $0x8,%esp 10d8e7: 56 push %esi 10d8e8: 53 push %ebx 10d8e9: e8 f2 0d 00 00 call 10e6e0 <_User_extensions_Thread_switch> if ( executing->fp_context != NULL ) _Context_Save_fp( &executing->fp_context ); #endif #endif _Context_Switch( &executing->Registers, &heir->Registers ); 10d8ee: 5a pop %edx 10d8ef: 59 pop %ecx 10d8f0: 81 c6 c8 00 00 00 add $0xc8,%esi 10d8f6: 56 push %esi 10d8f7: 8d 83 c8 00 00 00 lea 0xc8(%ebx),%eax 10d8fd: 50 push %eax 10d8fe: e8 ed 10 00 00 call 10e9f0 <_CPU_Context_switch> #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE ) if ( (executing->fp_context != NULL) && 10d903: 83 c4 10 add $0x10,%esp 10d906: 8b 83 e0 00 00 00 mov 0xe0(%ebx),%eax 10d90c: 85 c0 test %eax,%eax 10d90e: 74 36 je 10d946 <_Thread_Dispatch+0x10e> #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp ( const Thread_Control *the_thread ) { return ( the_thread == _Thread_Allocated_fp ); 10d910: a1 20 7e 12 00 mov 0x127e20,%eax 10d915: 39 c3 cmp %eax,%ebx 10d917: 74 2d je 10d946 <_Thread_Dispatch+0x10e> !_Thread_Is_allocated_fp( executing ) ) { if ( _Thread_Allocated_fp != NULL ) 10d919: 85 c0 test %eax,%eax 10d91b: 74 11 je 10d92e <_Thread_Dispatch+0xf6> _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 10d91d: 83 ec 0c sub $0xc,%esp 10d920: 05 e0 00 00 00 add $0xe0,%eax 10d925: 50 push %eax 10d926: e8 f9 10 00 00 call 10ea24 <_CPU_Context_save_fp> 10d92b: 83 c4 10 add $0x10,%esp _Context_Restore_fp( &executing->fp_context ); 10d92e: 83 ec 0c sub $0xc,%esp 10d931: 8d 83 e0 00 00 00 lea 0xe0(%ebx),%eax 10d937: 50 push %eax 10d938: e8 f1 10 00 00 call 10ea2e <_CPU_Context_restore_fp> _Thread_Allocated_fp = executing; 10d93d: 89 1d 20 7e 12 00 mov %ebx,0x127e20 10d943: 83 c4 10 add $0x10,%esp if ( executing->fp_context != NULL ) _Context_Restore_fp( &executing->fp_context ); #endif #endif executing = _Thread_Executing; 10d946: 8b 1d 38 83 12 00 mov 0x128338,%ebx _ISR_Disable( level ); 10d94c: 9c pushf 10d94d: fa cli 10d94e: 58 pop %eax Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; _ISR_Disable( level ); while ( _Thread_Dispatch_necessary == true ) { 10d94f: 8a 15 44 83 12 00 mov 0x128344,%dl 10d955: 84 d2 test %dl,%dl 10d957: 74 3b je 10d994 <_Thread_Dispatch+0x15c> heir = _Thread_Heir; 10d959: 8b 35 3c 83 12 00 mov 0x12833c,%esi _Thread_Dispatch_disable_level = 1; 10d95f: c7 05 90 7d 12 00 01 movl $0x1,0x127d90 10d966: 00 00 00 _Thread_Dispatch_necessary = false; 10d969: c6 05 44 83 12 00 00 movb $0x0,0x128344 _Thread_Executing = heir; 10d970: 89 35 38 83 12 00 mov %esi,0x128338 /* * When the heir and executing are the same, then we are being * requested to do the post switch dispatching. This is normally * done to dispatch signals. */ if ( heir == executing ) 10d976: 39 de cmp %ebx,%esi 10d978: 74 1a je 10d994 <_Thread_Dispatch+0x15c><== NEVER TAKEN */ #if __RTEMS_ADA__ executing->rtems_ada_self = rtems_ada_self; rtems_ada_self = heir->rtems_ada_self; #endif if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE ) 10d97a: 83 7e 7c 01 cmpl $0x1,0x7c(%esi) 10d97e: 0f 85 04 ff ff ff jne 10d888 <_Thread_Dispatch+0x50> heir->cpu_time_budget = _Thread_Ticks_per_timeslice; 10d984: 8b 15 60 7d 12 00 mov 0x127d60,%edx 10d98a: 89 56 78 mov %edx,0x78(%esi) 10d98d: e9 f6 fe ff ff jmp 10d888 <_Thread_Dispatch+0x50> 10d992: 66 90 xchg %ax,%ax _ISR_Disable( level ); } post_switch: _Thread_Dispatch_disable_level = 0; 10d994: c7 05 90 7d 12 00 00 movl $0x0,0x127d90 10d99b: 00 00 00 _ISR_Enable( level ); 10d99e: 50 push %eax 10d99f: 9d popf _API_extensions_Run_postswitch(); 10d9a0: e8 23 e5 ff ff call 10bec8 <_API_extensions_Run_postswitch> } 10d9a5: 8d 65 f4 lea -0xc(%ebp),%esp 10d9a8: 5b pop %ebx 10d9a9: 5e pop %esi 10d9aa: 5f pop %edi 10d9ab: c9 leave 10d9ac: c3 ret =============================================================================== 0010d9d4 <_Thread_Get>: */ Thread_Control *_Thread_Get ( Objects_Id id, Objects_Locations *location ) { 10d9d4: 55 push %ebp 10d9d5: 89 e5 mov %esp,%ebp 10d9d7: 53 push %ebx 10d9d8: 83 ec 04 sub $0x4,%esp 10d9db: 8b 45 08 mov 0x8(%ebp),%eax 10d9de: 8b 4d 0c mov 0xc(%ebp),%ecx uint32_t the_class; Objects_Information **api_information; Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { 10d9e1: 85 c0 test %eax,%eax 10d9e3: 74 47 je 10da2c <_Thread_Get+0x58> */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 10d9e5: 89 c2 mov %eax,%edx 10d9e7: c1 ea 18 shr $0x18,%edx 10d9ea: 83 e2 07 and $0x7,%edx */ RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid( uint32_t the_api ) { if ( !the_api || the_api > OBJECTS_APIS_LAST ) 10d9ed: 8d 5a ff lea -0x1(%edx),%ebx 10d9f0: 83 fb 02 cmp $0x2,%ebx 10d9f3: 77 27 ja 10da1c <_Thread_Get+0x48> */ RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class( Objects_Id id ) { return (uint32_t) 10d9f5: 89 c3 mov %eax,%ebx 10d9f7: c1 eb 1b shr $0x1b,%ebx *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 10d9fa: 4b dec %ebx 10d9fb: 75 1f jne 10da1c <_Thread_Get+0x48> *location = OBJECTS_ERROR; goto done; } #endif information = api_information[ the_class ]; 10d9fd: 8b 14 95 68 7d 12 00 mov 0x127d68(,%edx,4),%edx 10da04: 8b 52 04 mov 0x4(%edx),%edx if ( !information ) { 10da07: 85 d2 test %edx,%edx 10da09: 74 11 je 10da1c <_Thread_Get+0x48> *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 10da0b: 53 push %ebx 10da0c: 51 push %ecx 10da0d: 50 push %eax 10da0e: 52 push %edx 10da0f: e8 24 f4 ff ff call 10ce38 <_Objects_Get> 10da14: 83 c4 10 add $0x10,%esp done: return tp; } 10da17: 8b 5d fc mov -0x4(%ebp),%ebx 10da1a: c9 leave 10da1b: c3 ret } #endif information = api_information[ the_class ]; if ( !information ) { *location = OBJECTS_ERROR; 10da1c: c7 01 01 00 00 00 movl $0x1,(%ecx) { uint32_t the_api; uint32_t the_class; Objects_Information **api_information; Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; 10da22: 31 c0 xor %eax,%eax tp = (Thread_Control *) _Objects_Get( information, id, location ); done: return tp; } 10da24: 8b 5d fc mov -0x4(%ebp),%ebx 10da27: c9 leave 10da28: c3 ret 10da29: 8d 76 00 lea 0x0(%esi),%esi rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10da2c: a1 90 7d 12 00 mov 0x127d90,%eax 10da31: 40 inc %eax 10da32: a3 90 7d 12 00 mov %eax,0x127d90 Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { _Thread_Disable_dispatch(); *location = OBJECTS_LOCAL; 10da37: c7 01 00 00 00 00 movl $0x0,(%ecx) tp = _Thread_Executing; 10da3d: a1 38 83 12 00 mov 0x128338,%eax tp = (Thread_Control *) _Objects_Get( information, id, location ); done: return tp; } 10da42: 8b 5d fc mov -0x4(%ebp),%ebx 10da45: c9 leave 10da46: c3 ret =============================================================================== 001130a8 <_Thread_Handler>: * * Output parameters: NONE */ void _Thread_Handler( void ) { 1130a8: 55 push %ebp 1130a9: 89 e5 mov %esp,%ebp 1130ab: 53 push %ebx 1130ac: 83 ec 14 sub $0x14,%esp #if defined(EXECUTE_GLOBAL_CONSTRUCTORS) static char doneConstructors; char doneCons; #endif executing = _Thread_Executing; 1130af: 8b 1d 38 83 12 00 mov 0x128338,%ebx /* * have to put level into a register for those cpu's that use * inline asm here */ level = executing->Start.isr_level; 1130b5: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax _ISR_Set_level(level); 1130bb: 85 c0 test %eax,%eax 1130bd: 74 79 je 113138 <_Thread_Handler+0x90> 1130bf: fa cli #if defined(EXECUTE_GLOBAL_CONSTRUCTORS) doneCons = doneConstructors; 1130c0: a0 0c 7a 12 00 mov 0x127a0c,%al 1130c5: 88 45 f7 mov %al,-0x9(%ebp) doneConstructors = 1; 1130c8: c6 05 0c 7a 12 00 01 movb $0x1,0x127a0c #endif #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE ) if ( (executing->fp_context != NULL) && 1130cf: 8b 83 e0 00 00 00 mov 0xe0(%ebx),%eax 1130d5: 85 c0 test %eax,%eax 1130d7: 74 24 je 1130fd <_Thread_Handler+0x55> #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp ( const Thread_Control *the_thread ) { return ( the_thread == _Thread_Allocated_fp ); 1130d9: a1 20 7e 12 00 mov 0x127e20,%eax 1130de: 39 c3 cmp %eax,%ebx 1130e0: 74 1b je 1130fd <_Thread_Handler+0x55> !_Thread_Is_allocated_fp( executing ) ) { if ( _Thread_Allocated_fp != NULL ) 1130e2: 85 c0 test %eax,%eax 1130e4: 74 11 je 1130f7 <_Thread_Handler+0x4f> _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 1130e6: 83 ec 0c sub $0xc,%esp 1130e9: 05 e0 00 00 00 add $0xe0,%eax 1130ee: 50 push %eax 1130ef: e8 30 b9 ff ff call 10ea24 <_CPU_Context_save_fp> 1130f4: 83 c4 10 add $0x10,%esp _Thread_Allocated_fp = executing; 1130f7: 89 1d 20 7e 12 00 mov %ebx,0x127e20 /* * Take care that 'begin' extensions get to complete before * 'switch' extensions can run. This means must keep dispatch * disabled until all 'begin' extensions complete. */ _User_extensions_Thread_begin( executing ); 1130fd: 83 ec 0c sub $0xc,%esp 113100: 53 push %ebx 113101: e8 3e b4 ff ff call 10e544 <_User_extensions_Thread_begin> /* * At this point, the dispatch disable level BETTER be 1. */ _Thread_Enable_dispatch(); 113106: e8 a5 a8 ff ff call 10d9b0 <_Thread_Enable_dispatch> /* * _init could be a weak symbol and we SHOULD test it but it isn't * in any configuration I know of and it generates a warning on every * RTEMS target configuration. --joel (12 May 2007) */ if (!doneCons) /* && (volatile void *)_init) */ { 11310b: 83 c4 10 add $0x10,%esp 11310e: 80 7d f7 00 cmpb $0x0,-0x9(%ebp) 113112: 74 28 je 11313c <_Thread_Handler+0x94> INIT_NAME (); } #endif if ( executing->Start.prototype == THREAD_START_NUMERIC ) { 113114: 8b 83 94 00 00 00 mov 0x94(%ebx),%eax 11311a: 85 c0 test %eax,%eax 11311c: 74 2d je 11314b <_Thread_Handler+0xa3> (*(Thread_Entry_numeric) executing->Start.entry_point)( executing->Start.numeric_argument ); } #if defined(RTEMS_POSIX_API) else if ( executing->Start.prototype == THREAD_START_POINTER ) { 11311e: 48 dec %eax 11311f: 74 43 je 113164 <_Thread_Handler+0xbc> <== ALWAYS TAKEN * was placed in return_argument. This assumed that if it returned * anything (which is not supporting in all APIs), then it would be * able to fit in a (void *). */ _User_extensions_Thread_exitted( executing ); 113121: 83 ec 0c sub $0xc,%esp 113124: 53 push %ebx 113125: e8 56 b4 ff ff call 10e580 <_User_extensions_Thread_exitted> _Internal_error_Occurred( 11312a: 83 c4 0c add $0xc,%esp 11312d: 6a 05 push $0x5 11312f: 6a 01 push $0x1 113131: 6a 00 push $0x0 113133: e8 bc 97 ff ff call 10c8f4 <_Internal_error_Occurred> * have to put level into a register for those cpu's that use * inline asm here */ level = executing->Start.isr_level; _ISR_Set_level(level); 113138: fb sti 113139: eb 85 jmp 1130c0 <_Thread_Handler+0x18> 11313b: 90 nop * _init could be a weak symbol and we SHOULD test it but it isn't * in any configuration I know of and it generates a warning on every * RTEMS target configuration. --joel (12 May 2007) */ if (!doneCons) /* && (volatile void *)_init) */ { INIT_NAME (); 11313c: e8 3f c7 00 00 call 11f880 <__start_set_sysctl_set> } #endif if ( executing->Start.prototype == THREAD_START_NUMERIC ) { 113141: 8b 83 94 00 00 00 mov 0x94(%ebx),%eax 113147: 85 c0 test %eax,%eax 113149: 75 d3 jne 11311e <_Thread_Handler+0x76> executing->Wait.return_argument = (*(Thread_Entry_numeric) executing->Start.entry_point)( 11314b: 83 ec 0c sub $0xc,%esp 11314e: ff b3 9c 00 00 00 pushl 0x9c(%ebx) 113154: ff 93 90 00 00 00 call *0x90(%ebx) INIT_NAME (); } #endif if ( executing->Start.prototype == THREAD_START_NUMERIC ) { executing->Wait.return_argument = 11315a: 89 43 28 mov %eax,0x28(%ebx) 11315d: 83 c4 10 add $0x10,%esp 113160: eb bf jmp 113121 <_Thread_Handler+0x79> 113162: 66 90 xchg %ax,%ax ); } #if defined(RTEMS_POSIX_API) else if ( executing->Start.prototype == THREAD_START_POINTER ) { executing->Wait.return_argument = (*(Thread_Entry_pointer) executing->Start.entry_point)( 113164: 83 ec 0c sub $0xc,%esp 113167: ff b3 98 00 00 00 pushl 0x98(%ebx) 11316d: ff 93 90 00 00 00 call *0x90(%ebx) executing->Start.numeric_argument ); } #if defined(RTEMS_POSIX_API) else if ( executing->Start.prototype == THREAD_START_POINTER ) { executing->Wait.return_argument = 113173: 89 43 28 mov %eax,0x28(%ebx) 113176: 83 c4 10 add $0x10,%esp 113179: eb a6 jmp 113121 <_Thread_Handler+0x79> =============================================================================== 0010da48 <_Thread_Initialize>: Thread_CPU_budget_algorithms budget_algorithm, Thread_CPU_budget_algorithm_callout budget_callout, uint32_t isr_level, Objects_Name name ) { 10da48: 55 push %ebp 10da49: 89 e5 mov %esp,%ebp 10da4b: 57 push %edi 10da4c: 56 push %esi 10da4d: 53 push %ebx 10da4e: 83 ec 1c sub $0x1c,%esp 10da51: 8b 5d 0c mov 0xc(%ebp),%ebx 10da54: 8b 4d 10 mov 0x10(%ebp),%ecx 10da57: 8b 75 14 mov 0x14(%ebp),%esi 10da5a: 8b 7d 1c mov 0x1c(%ebp),%edi 10da5d: 8a 55 18 mov 0x18(%ebp),%dl 10da60: 8a 45 20 mov 0x20(%ebp),%al 10da63: 88 45 df mov %al,-0x21(%ebp) /* * Zero out all the allocated memory fields */ for ( i=0 ; i <= THREAD_API_LAST ; i++ ) the_thread->API_Extensions[i] = NULL; 10da66: c7 83 e8 00 00 00 00 movl $0x0,0xe8(%ebx) 10da6d: 00 00 00 10da70: c7 83 ec 00 00 00 00 movl $0x0,0xec(%ebx) 10da77: 00 00 00 extensions_area = NULL; the_thread->libc_reent = NULL; 10da7a: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx) 10da81: 00 00 00 if ( !actual_stack_size || actual_stack_size < stack_size ) return false; /* stack allocation failed */ stack = the_thread->Start.stack; #else if ( !stack_area ) { 10da84: 85 c9 test %ecx,%ecx 10da86: 0f 84 d3 01 00 00 je 10dc5f <_Thread_Initialize+0x217> stack = the_thread->Start.stack; the_thread->Start.core_allocated_stack = true; } else { stack = stack_area; actual_stack_size = stack_size; the_thread->Start.core_allocated_stack = false; 10da8c: c6 83 b4 00 00 00 00 movb $0x0,0xb4(%ebx) 10da93: 89 f0 mov %esi,%eax Stack_Control *the_stack, void *starting_address, size_t size ) { the_stack->area = starting_address; 10da95: 89 8b bc 00 00 00 mov %ecx,0xbc(%ebx) the_stack->size = size; 10da9b: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) /* * Allocate the floating point area for this thread */ #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( is_fp ) { 10daa1: 84 d2 test %dl,%dl 10daa3: 0f 85 4f 01 00 00 jne 10dbf8 <_Thread_Initialize+0x1b0> 10daa9: 31 c0 xor %eax,%eax extensions_area = NULL; the_thread->libc_reent = NULL; #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) fp_area = NULL; 10daab: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE ); if ( !fp_area ) goto failed; fp_area = _Context_Fp_start( fp_area, 0 ); } the_thread->fp_context = fp_area; 10dab2: 89 83 e0 00 00 00 mov %eax,0xe0(%ebx) the_thread->Start.fp_context = fp_area; 10dab8: 89 83 c0 00 00 00 mov %eax,0xc0(%ebx) Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 10dabe: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) the_watchdog->routine = routine; 10dac5: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx) the_watchdog->id = id; 10dacc: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx) the_watchdog->user_data = user_data; 10dad3: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) #endif /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 10dada: a1 30 7e 12 00 mov 0x127e30,%eax 10dadf: 85 c0 test %eax,%eax 10dae1: 0f 85 39 01 00 00 jne 10dc20 <_Thread_Initialize+0x1d8> (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) goto failed; } the_thread->extensions = (void **) extensions_area; 10dae7: c7 83 f0 00 00 00 00 movl $0x0,0xf0(%ebx) 10daee: 00 00 00 * Zero out all the allocated memory fields */ for ( i=0 ; i <= THREAD_API_LAST ; i++ ) the_thread->API_Extensions[i] = NULL; extensions_area = NULL; 10daf1: 31 f6 xor %esi,%esi /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 10daf3: 8a 45 df mov -0x21(%ebp),%al 10daf6: 88 83 a0 00 00 00 mov %al,0xa0(%ebx) the_thread->Start.budget_algorithm = budget_algorithm; 10dafc: 8b 45 24 mov 0x24(%ebp),%eax 10daff: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx) the_thread->Start.budget_callout = budget_callout; 10db05: 8b 45 28 mov 0x28(%ebp),%eax 10db08: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx) switch ( budget_algorithm ) { 10db0e: 83 7d 24 02 cmpl $0x2,0x24(%ebp) 10db12: 75 08 jne 10db1c <_Thread_Initialize+0xd4> case THREAD_CPU_BUDGET_ALGORITHM_NONE: case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE: break; #if defined(RTEMS_SCORE_THREAD_ENABLE_EXHAUST_TIMESLICE) case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE: the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice; 10db14: a1 60 7d 12 00 mov 0x127d60,%eax 10db19: 89 43 78 mov %eax,0x78(%ebx) case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: break; #endif } the_thread->Start.isr_level = isr_level; 10db1c: 8b 45 2c mov 0x2c(%ebp),%eax 10db1f: 89 83 ac 00 00 00 mov %eax,0xac(%ebx) the_thread->current_state = STATES_DORMANT; 10db25: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx) the_thread->Wait.queue = NULL; 10db2c: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) the_thread->resource_count = 0; 10db33: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx) the_thread->real_priority = priority; 10db3a: 89 7b 18 mov %edi,0x18(%ebx) the_thread->Start.initial_priority = priority; 10db3d: 89 bb b0 00 00 00 mov %edi,0xb0(%ebx) */ RTEMS_INLINE_ROUTINE void* _Scheduler_Allocate( Thread_Control *the_thread ) { return _Scheduler.Operations.allocate( the_thread ); 10db43: 83 ec 0c sub $0xc,%esp 10db46: 53 push %ebx 10db47: ff 15 98 39 12 00 call *0x123998 10db4d: 89 45 e4 mov %eax,-0x1c(%ebp) sched =_Scheduler_Allocate( the_thread ); if ( !sched ) 10db50: 83 c4 10 add $0x10,%esp 10db53: 85 c0 test %eax,%eax 10db55: 74 40 je 10db97 <_Thread_Initialize+0x14f> goto failed; _Thread_Set_priority( the_thread, priority ); 10db57: 83 ec 08 sub $0x8,%esp 10db5a: 57 push %edi 10db5b: 53 push %ebx 10db5c: e8 57 06 00 00 call 10e1b8 <_Thread_Set_priority> /* * Initialize the CPU usage statistics */ #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timestamp_Set_to_zero( &the_thread->cpu_time_used ); 10db61: c7 83 84 00 00 00 00 movl $0x0,0x84(%ebx) 10db68: 00 00 00 10db6b: c7 83 88 00 00 00 00 movl $0x0,0x88(%ebx) 10db72: 00 00 00 _Workspace_Free( sched ); _Thread_Stack_Free( the_thread ); return false; } 10db75: 8b 45 08 mov 0x8(%ebp),%eax 10db78: 8b 40 1c mov 0x1c(%eax),%eax Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 10db7b: 0f b7 53 08 movzwl 0x8(%ebx),%edx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10db7f: 89 1c 90 mov %ebx,(%eax,%edx,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 10db82: 8b 45 30 mov 0x30(%ebp),%eax 10db85: 89 43 0c mov %eax,0xc(%ebx) * enabled when we get here. We want to be able to run the * user extensions with dispatching enabled. The Allocator * Mutex provides sufficient protection to let the user extensions * run safely. */ extension_status = _User_extensions_Thread_create( the_thread ); 10db88: 89 1c 24 mov %ebx,(%esp) 10db8b: e8 7c 0a 00 00 call 10e60c <_User_extensions_Thread_create> if ( extension_status ) 10db90: 83 c4 10 add $0x10,%esp 10db93: 84 c0 test %al,%al 10db95: 75 55 jne 10dbec <_Thread_Initialize+0x1a4> return true; failed: _Workspace_Free( the_thread->libc_reent ); 10db97: 83 ec 0c sub $0xc,%esp 10db9a: ff b3 e4 00 00 00 pushl 0xe4(%ebx) 10dba0: e8 ff 0d 00 00 call 10e9a4 <_Workspace_Free> for ( i=0 ; i <= THREAD_API_LAST ; i++ ) _Workspace_Free( the_thread->API_Extensions[i] ); 10dba5: 5f pop %edi 10dba6: ff b3 e8 00 00 00 pushl 0xe8(%ebx) 10dbac: e8 f3 0d 00 00 call 10e9a4 <_Workspace_Free> 10dbb1: 59 pop %ecx 10dbb2: ff b3 ec 00 00 00 pushl 0xec(%ebx) 10dbb8: e8 e7 0d 00 00 call 10e9a4 <_Workspace_Free> _Workspace_Free( extensions_area ); 10dbbd: 89 34 24 mov %esi,(%esp) 10dbc0: e8 df 0d 00 00 call 10e9a4 <_Workspace_Free> #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) _Workspace_Free( fp_area ); 10dbc5: 5a pop %edx 10dbc6: ff 75 e0 pushl -0x20(%ebp) 10dbc9: e8 d6 0d 00 00 call 10e9a4 <_Workspace_Free> #endif _Workspace_Free( sched ); 10dbce: 58 pop %eax 10dbcf: ff 75 e4 pushl -0x1c(%ebp) 10dbd2: e8 cd 0d 00 00 call 10e9a4 <_Workspace_Free> _Thread_Stack_Free( the_thread ); 10dbd7: 89 1c 24 mov %ebx,(%esp) 10dbda: e8 c1 06 00 00 call 10e2a0 <_Thread_Stack_Free> return false; 10dbdf: 83 c4 10 add $0x10,%esp 10dbe2: 31 c0 xor %eax,%eax } 10dbe4: 8d 65 f4 lea -0xc(%ebp),%esp 10dbe7: 5b pop %ebx 10dbe8: 5e pop %esi 10dbe9: 5f pop %edi 10dbea: c9 leave 10dbeb: c3 ret * Mutex provides sufficient protection to let the user extensions * run safely. */ extension_status = _User_extensions_Thread_create( the_thread ); if ( extension_status ) return true; 10dbec: b0 01 mov $0x1,%al _Workspace_Free( sched ); _Thread_Stack_Free( the_thread ); return false; } 10dbee: 8d 65 f4 lea -0xc(%ebp),%esp 10dbf1: 5b pop %ebx 10dbf2: 5e pop %esi 10dbf3: 5f pop %edi 10dbf4: c9 leave 10dbf5: c3 ret 10dbf6: 66 90 xchg %ax,%ax /* * Allocate the floating point area for this thread */ #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( is_fp ) { fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE ); 10dbf8: 83 ec 0c sub $0xc,%esp 10dbfb: 6a 6c push $0x6c 10dbfd: e8 86 0d 00 00 call 10e988 <_Workspace_Allocate> 10dc02: 89 45 e0 mov %eax,-0x20(%ebp) if ( !fp_area ) 10dc05: 83 c4 10 add $0x10,%esp 10dc08: 85 c0 test %eax,%eax 10dc0a: 0f 85 a2 fe ff ff jne 10dab2 <_Thread_Initialize+0x6a> * Zero out all the allocated memory fields */ for ( i=0 ; i <= THREAD_API_LAST ; i++ ) the_thread->API_Extensions[i] = NULL; extensions_area = NULL; 10dc10: 31 f6 xor %esi,%esi size_t actual_stack_size = 0; void *stack = NULL; #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) void *fp_area; #endif void *sched = NULL; 10dc12: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) 10dc19: e9 79 ff ff ff jmp 10db97 <_Thread_Initialize+0x14f> 10dc1e: 66 90 xchg %ax,%ax /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { extensions_area = _Workspace_Allocate( 10dc20: 83 ec 0c sub $0xc,%esp 10dc23: 8d 04 85 04 00 00 00 lea 0x4(,%eax,4),%eax 10dc2a: 50 push %eax 10dc2b: e8 58 0d 00 00 call 10e988 <_Workspace_Allocate> 10dc30: 89 c6 mov %eax,%esi (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) 10dc32: 83 c4 10 add $0x10,%esp 10dc35: 85 c0 test %eax,%eax 10dc37: 74 5a je 10dc93 <_Thread_Initialize+0x24b> goto failed; } the_thread->extensions = (void **) extensions_area; 10dc39: 89 83 f0 00 00 00 mov %eax,0xf0(%ebx) 10dc3f: 8b 0d 30 7e 12 00 mov 0x127e30,%ecx * create the extension long after tasks have been created * so they cannot rely on the thread create user extension * call. */ if ( the_thread->extensions ) { for ( i = 0; i <= _Thread_Maximum_extensions ; i++ ) 10dc45: 31 d2 xor %edx,%edx (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) goto failed; } the_thread->extensions = (void **) extensions_area; 10dc47: 31 c0 xor %eax,%eax 10dc49: 8d 76 00 lea 0x0(%esi),%esi * so they cannot rely on the thread create user extension * call. */ if ( the_thread->extensions ) { for ( i = 0; i <= _Thread_Maximum_extensions ; i++ ) the_thread->extensions[i] = NULL; 10dc4c: c7 04 96 00 00 00 00 movl $0x0,(%esi,%edx,4) * create the extension long after tasks have been created * so they cannot rely on the thread create user extension * call. */ if ( the_thread->extensions ) { for ( i = 0; i <= _Thread_Maximum_extensions ; i++ ) 10dc53: 40 inc %eax 10dc54: 89 c2 mov %eax,%edx 10dc56: 39 c1 cmp %eax,%ecx 10dc58: 73 f2 jae 10dc4c <_Thread_Initialize+0x204> 10dc5a: e9 94 fe ff ff jmp 10daf3 <_Thread_Initialize+0xab> return false; /* stack allocation failed */ stack = the_thread->Start.stack; #else if ( !stack_area ) { actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size ); 10dc5f: 83 ec 08 sub $0x8,%esp 10dc62: 56 push %esi 10dc63: 53 push %ebx 10dc64: 88 55 d8 mov %dl,-0x28(%ebp) 10dc67: e8 d0 05 00 00 call 10e23c <_Thread_Stack_Allocate> if ( !actual_stack_size || actual_stack_size < stack_size ) 10dc6c: 83 c4 10 add $0x10,%esp 10dc6f: 85 c0 test %eax,%eax 10dc71: 8a 55 d8 mov -0x28(%ebp),%dl 10dc74: 74 16 je 10dc8c <_Thread_Initialize+0x244> 10dc76: 39 c6 cmp %eax,%esi 10dc78: 77 12 ja 10dc8c <_Thread_Initialize+0x244><== NEVER TAKEN return false; /* stack allocation failed */ stack = the_thread->Start.stack; 10dc7a: 8b 8b c4 00 00 00 mov 0xc4(%ebx),%ecx the_thread->Start.core_allocated_stack = true; 10dc80: c6 83 b4 00 00 00 01 movb $0x1,0xb4(%ebx) 10dc87: e9 09 fe ff ff jmp 10da95 <_Thread_Initialize+0x4d> stack = the_thread->Start.stack; #else if ( !stack_area ) { actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size ); if ( !actual_stack_size || actual_stack_size < stack_size ) return false; /* stack allocation failed */ 10dc8c: 31 c0 xor %eax,%eax 10dc8e: e9 51 ff ff ff jmp 10dbe4 <_Thread_Initialize+0x19c> size_t actual_stack_size = 0; void *stack = NULL; #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) void *fp_area; #endif void *sched = NULL; 10dc93: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) 10dc9a: e9 f8 fe ff ff jmp 10db97 <_Thread_Initialize+0x14f> =============================================================================== 00112560 <_Thread_Reset>: void _Thread_Reset( Thread_Control *the_thread, void *pointer_argument, Thread_Entry_numeric_type numeric_argument ) { 112560: 55 push %ebp 112561: 89 e5 mov %esp,%ebp 112563: 53 push %ebx 112564: 83 ec 10 sub $0x10,%esp 112567: 8b 5d 08 mov 0x8(%ebp),%ebx the_thread->resource_count = 0; 11256a: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx) the_thread->is_preemptible = the_thread->Start.is_preemptible; 112571: 8a 83 a0 00 00 00 mov 0xa0(%ebx),%al 112577: 88 43 74 mov %al,0x74(%ebx) the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 11257a: 8b 83 a4 00 00 00 mov 0xa4(%ebx),%eax 112580: 89 43 7c mov %eax,0x7c(%ebx) the_thread->budget_callout = the_thread->Start.budget_callout; 112583: 8b 83 a8 00 00 00 mov 0xa8(%ebx),%eax 112589: 89 83 80 00 00 00 mov %eax,0x80(%ebx) the_thread->Start.pointer_argument = pointer_argument; 11258f: 8b 45 0c mov 0xc(%ebp),%eax 112592: 89 83 98 00 00 00 mov %eax,0x98(%ebx) the_thread->Start.numeric_argument = numeric_argument; 112598: 8b 45 10 mov 0x10(%ebp),%eax 11259b: 89 83 9c 00 00 00 mov %eax,0x9c(%ebx) if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) { 1125a1: 53 push %ebx 1125a2: e8 f9 c5 ff ff call 10eba0 <_Thread_queue_Extract_with_proxy> 1125a7: 83 c4 10 add $0x10,%esp 1125aa: 84 c0 test %al,%al 1125ac: 75 06 jne 1125b4 <_Thread_Reset+0x54> if ( _Watchdog_Is_active( &the_thread->Timer ) ) 1125ae: 83 7b 50 02 cmpl $0x2,0x50(%ebx) 1125b2: 74 28 je 1125dc <_Thread_Reset+0x7c> (void) _Watchdog_Remove( &the_thread->Timer ); } if ( the_thread->current_priority != the_thread->Start.initial_priority ) { 1125b4: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax 1125ba: 39 43 14 cmp %eax,0x14(%ebx) 1125bd: 74 15 je 1125d4 <_Thread_Reset+0x74> the_thread->real_priority = the_thread->Start.initial_priority; 1125bf: 89 43 18 mov %eax,0x18(%ebx) _Thread_Set_priority( the_thread, the_thread->Start.initial_priority ); 1125c2: 89 45 0c mov %eax,0xc(%ebp) 1125c5: 89 5d 08 mov %ebx,0x8(%ebp) } } 1125c8: 8b 5d fc mov -0x4(%ebp),%ebx 1125cb: c9 leave (void) _Watchdog_Remove( &the_thread->Timer ); } if ( the_thread->current_priority != the_thread->Start.initial_priority ) { the_thread->real_priority = the_thread->Start.initial_priority; _Thread_Set_priority( the_thread, the_thread->Start.initial_priority ); 1125cc: e9 ab c7 ff ff jmp 10ed7c <_Thread_Set_priority> 1125d1: 8d 76 00 lea 0x0(%esi),%esi } } 1125d4: 8b 5d fc mov -0x4(%ebp),%ebx 1125d7: c9 leave 1125d8: c3 ret 1125d9: 8d 76 00 lea 0x0(%esi),%esi the_thread->Start.numeric_argument = numeric_argument; if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) { if ( _Watchdog_Is_active( &the_thread->Timer ) ) (void) _Watchdog_Remove( &the_thread->Timer ); 1125dc: 83 ec 0c sub $0xc,%esp 1125df: 8d 43 48 lea 0x48(%ebx),%eax 1125e2: 50 push %eax 1125e3: e8 7c ce ff ff call 10f464 <_Watchdog_Remove> 1125e8: 83 c4 10 add $0x10,%esp 1125eb: eb c7 jmp 1125b4 <_Thread_Reset+0x54> =============================================================================== 001114f0 <_Thread_Resume>: */ void _Thread_Resume( Thread_Control *the_thread, bool force ) { 1114f0: 55 push %ebp 1114f1: 89 e5 mov %esp,%ebp 1114f3: 53 push %ebx 1114f4: 83 ec 04 sub $0x4,%esp 1114f7: 8b 45 08 mov 0x8(%ebp),%eax ISR_Level level; States_Control current_state; _ISR_Disable( level ); 1114fa: 9c pushf 1114fb: fa cli 1114fc: 5b pop %ebx current_state = the_thread->current_state; 1114fd: 8b 50 10 mov 0x10(%eax),%edx if ( current_state & STATES_SUSPENDED ) { 111500: f6 c2 02 test $0x2,%dl 111503: 74 0a je 11150f <_Thread_Resume+0x1f> <== NEVER TAKEN 111505: 83 e2 fd and $0xfffffffd,%edx current_state = the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state); 111508: 89 50 10 mov %edx,0x10(%eax) if ( _States_Is_ready( current_state ) ) { 11150b: 85 d2 test %edx,%edx 11150d: 74 09 je 111518 <_Thread_Resume+0x28> _Scheduler_Unblock( the_thread ); } } _ISR_Enable( level ); 11150f: 53 push %ebx 111510: 9d popf } 111511: 8b 5d fc mov -0x4(%ebp),%ebx 111514: c9 leave 111515: c3 ret 111516: 66 90 xchg %ax,%ax */ RTEMS_INLINE_ROUTINE void _Scheduler_Unblock( Thread_Control *the_thread ) { _Scheduler.Operations.unblock( the_thread ); 111518: 83 ec 0c sub $0xc,%esp 11151b: 50 push %eax 11151c: ff 15 74 72 12 00 call *0x127274 111522: 83 c4 10 add $0x10,%esp 111525: eb e8 jmp 11150f <_Thread_Resume+0x1f> =============================================================================== 0010e23c <_Thread_Stack_Allocate>: size_t _Thread_Stack_Allocate( Thread_Control *the_thread, size_t stack_size ) { 10e23c: 55 push %ebp 10e23d: 89 e5 mov %esp,%ebp 10e23f: 53 push %ebx 10e240: 83 ec 04 sub $0x4,%esp the_stack_size = _Stack_Adjust_size( the_stack_size ); stack_addr = _Workspace_Allocate( the_stack_size ); } if ( !stack_addr ) the_stack_size = 0; 10e243: a1 70 3a 12 00 mov 0x123a70,%eax 10e248: 8b 5d 0c mov 0xc(%ebp),%ebx 10e24b: 39 c3 cmp %eax,%ebx 10e24d: 73 02 jae 10e251 <_Thread_Stack_Allocate+0x15> 10e24f: 89 c3 mov %eax,%ebx * Call ONLY the CPU table stack allocate hook, _or_ the * the RTEMS workspace allocate. This is so the stack free * routine can call the correct deallocation routine. */ if ( Configuration.stack_allocate_hook ) { 10e251: a1 a0 3a 12 00 mov 0x123aa0,%eax 10e256: 85 c0 test %eax,%eax 10e258: 74 32 je 10e28c <_Thread_Stack_Allocate+0x50> stack_addr = (*Configuration.stack_allocate_hook)( the_stack_size ); 10e25a: 83 ec 0c sub $0xc,%esp 10e25d: 53 push %ebx 10e25e: ff d0 call *%eax 10e260: 83 c4 10 add $0x10,%esp the_stack_size = _Stack_Adjust_size( the_stack_size ); stack_addr = _Workspace_Allocate( the_stack_size ); } if ( !stack_addr ) 10e263: 85 c0 test %eax,%eax 10e265: 74 11 je 10e278 <_Thread_Stack_Allocate+0x3c> the_stack_size = 0; the_thread->Start.stack = stack_addr; 10e267: 8b 55 08 mov 0x8(%ebp),%edx 10e26a: 89 82 c4 00 00 00 mov %eax,0xc4(%edx) return the_stack_size; } 10e270: 89 d8 mov %ebx,%eax 10e272: 8b 5d fc mov -0x4(%ebp),%ebx 10e275: c9 leave 10e276: c3 ret 10e277: 90 nop the_stack_size = _Stack_Adjust_size( the_stack_size ); stack_addr = _Workspace_Allocate( the_stack_size ); } if ( !stack_addr ) the_stack_size = 0; 10e278: 31 db xor %ebx,%ebx the_thread->Start.stack = stack_addr; 10e27a: 8b 55 08 mov 0x8(%ebp),%edx 10e27d: 89 82 c4 00 00 00 mov %eax,0xc4(%edx) return the_stack_size; } 10e283: 89 d8 mov %ebx,%eax 10e285: 8b 5d fc mov -0x4(%ebp),%ebx 10e288: c9 leave 10e289: c3 ret 10e28a: 66 90 xchg %ax,%ax RTEMS_INLINE_ROUTINE uint32_t _Stack_Adjust_size ( size_t size ) { return size + CPU_STACK_ALIGNMENT; 10e28c: 83 c3 10 add $0x10,%ebx * get and keep the stack adjust factor, the stack alignment, and * the context initialization sequence in sync. */ the_stack_size = _Stack_Adjust_size( the_stack_size ); stack_addr = _Workspace_Allocate( the_stack_size ); 10e28f: 83 ec 0c sub $0xc,%esp 10e292: 53 push %ebx 10e293: e8 f0 06 00 00 call 10e988 <_Workspace_Allocate> 10e298: 83 c4 10 add $0x10,%esp 10e29b: eb c6 jmp 10e263 <_Thread_Stack_Allocate+0x27> =============================================================================== 0010e2a0 <_Thread_Stack_Free>: */ void _Thread_Stack_Free( Thread_Control *the_thread ) { 10e2a0: 55 push %ebp 10e2a1: 89 e5 mov %esp,%ebp 10e2a3: 83 ec 08 sub $0x8,%esp 10e2a6: 8b 45 08 mov 0x8(%ebp),%eax #if defined(RTEMS_SCORE_THREAD_ENABLE_USER_PROVIDED_STACK_VIA_API) /* * If the API provided the stack space, then don't free it. */ if ( !the_thread->Start.core_allocated_stack ) 10e2a9: 80 b8 b4 00 00 00 00 cmpb $0x0,0xb4(%eax) 10e2b0: 74 16 je 10e2c8 <_Thread_Stack_Free+0x28> * Call ONLY the CPU table stack free hook, or the * the RTEMS workspace free. This is so the free * routine properly matches the allocation of the stack. */ if ( Configuration.stack_free_hook ) 10e2b2: 8b 15 a4 3a 12 00 mov 0x123aa4,%edx 10e2b8: 85 d2 test %edx,%edx 10e2ba: 74 10 je 10e2cc <_Thread_Stack_Free+0x2c> (*Configuration.stack_free_hook)( the_thread->Start.Initial_stack.area ); 10e2bc: 8b 80 bc 00 00 00 mov 0xbc(%eax),%eax 10e2c2: 89 45 08 mov %eax,0x8(%ebp) else _Workspace_Free( the_thread->Start.Initial_stack.area ); } 10e2c5: c9 leave * the RTEMS workspace free. This is so the free * routine properly matches the allocation of the stack. */ if ( Configuration.stack_free_hook ) (*Configuration.stack_free_hook)( the_thread->Start.Initial_stack.area ); 10e2c6: ff e2 jmp *%edx else _Workspace_Free( the_thread->Start.Initial_stack.area ); } 10e2c8: c9 leave 10e2c9: c3 ret 10e2ca: 66 90 xchg %ax,%ax */ if ( Configuration.stack_free_hook ) (*Configuration.stack_free_hook)( the_thread->Start.Initial_stack.area ); else _Workspace_Free( the_thread->Start.Initial_stack.area ); 10e2cc: 8b 80 bc 00 00 00 mov 0xbc(%eax),%eax 10e2d2: 89 45 08 mov %eax,0x8(%ebp) } 10e2d5: c9 leave */ if ( Configuration.stack_free_hook ) (*Configuration.stack_free_hook)( the_thread->Start.Initial_stack.area ); else _Workspace_Free( the_thread->Start.Initial_stack.area ); 10e2d6: e9 c9 06 00 00 jmp 10e9a4 <_Workspace_Free> =============================================================================== 001118d8 <_Thread_Suspend>: * select map */ void _Thread_Suspend( Thread_Control *the_thread ) { 1118d8: 55 push %ebp 1118d9: 89 e5 mov %esp,%ebp 1118db: 53 push %ebx 1118dc: 83 ec 04 sub $0x4,%esp 1118df: 8b 45 08 mov 0x8(%ebp),%eax ISR_Level level; _ISR_Disable( level ); 1118e2: 9c pushf 1118e3: fa cli 1118e4: 5b pop %ebx if ( !_States_Is_ready( the_thread->current_state ) ) { 1118e5: 8b 50 10 mov 0x10(%eax),%edx 1118e8: 85 d2 test %edx,%edx 1118ea: 74 10 je 1118fc <_Thread_Suspend+0x24> 1118ec: 83 ca 02 or $0x2,%edx 1118ef: 89 50 10 mov %edx,0x10(%eax) the_thread->current_state = _States_Set( STATES_SUSPENDED, the_thread->current_state ); _ISR_Enable( level ); 1118f2: 53 push %ebx 1118f3: 9d popf the_thread->current_state = STATES_SUSPENDED; _Scheduler_Block( the_thread ); _ISR_Enable( level ); } 1118f4: 8b 5d fc mov -0x4(%ebp),%ebx 1118f7: c9 leave 1118f8: c3 ret 1118f9: 8d 76 00 lea 0x0(%esi),%esi _States_Set( STATES_SUSPENDED, the_thread->current_state ); _ISR_Enable( level ); return; } the_thread->current_state = STATES_SUSPENDED; 1118fc: c7 40 10 02 00 00 00 movl $0x2,0x10(%eax) */ RTEMS_INLINE_ROUTINE void _Scheduler_Block( Thread_Control *the_thread ) { _Scheduler.Operations.block( the_thread ); 111903: 83 ec 0c sub $0xc,%esp 111906: 50 push %eax 111907: ff 15 90 39 12 00 call *0x123990 _Scheduler_Block( the_thread ); _ISR_Enable( level ); 11190d: 53 push %ebx 11190e: 9d popf 11190f: 83 c4 10 add $0x10,%esp } 111912: 8b 5d fc mov -0x4(%ebp),%ebx 111915: c9 leave 111916: c3 ret =============================================================================== 0010e398 <_Thread_Tickle_timeslice>: * * Output parameters: NONE */ void _Thread_Tickle_timeslice( void ) { 10e398: 55 push %ebp 10e399: 89 e5 mov %esp,%ebp 10e39b: 53 push %ebx 10e39c: 83 ec 04 sub $0x4,%esp Thread_Control *executing; executing = _Thread_Executing; 10e39f: 8b 1d 38 83 12 00 mov 0x128338,%ebx /* * If the thread is not preemptible or is not ready, then * just return. */ if ( !executing->is_preemptible ) 10e3a5: 80 7b 74 00 cmpb $0x0,0x74(%ebx) 10e3a9: 74 19 je 10e3c4 <_Thread_Tickle_timeslice+0x2c> return; if ( !_States_Is_ready( executing->current_state ) ) 10e3ab: 8b 43 10 mov 0x10(%ebx),%eax 10e3ae: 85 c0 test %eax,%eax 10e3b0: 75 12 jne 10e3c4 <_Thread_Tickle_timeslice+0x2c> /* * The cpu budget algorithm determines what happens next. */ switch ( executing->budget_algorithm ) { 10e3b2: 8b 43 7c mov 0x7c(%ebx),%eax 10e3b5: 83 f8 01 cmp $0x1,%eax 10e3b8: 72 0a jb 10e3c4 <_Thread_Tickle_timeslice+0x2c> 10e3ba: 83 f8 02 cmp $0x2,%eax 10e3bd: 76 29 jbe 10e3e8 <_Thread_Tickle_timeslice+0x50> 10e3bf: 83 f8 03 cmp $0x3,%eax 10e3c2: 74 08 je 10e3cc <_Thread_Tickle_timeslice+0x34><== ALWAYS TAKEN if ( --executing->cpu_time_budget == 0 ) (*executing->budget_callout)( executing ); break; #endif } } 10e3c4: 8b 5d fc mov -0x4(%ebp),%ebx 10e3c7: c9 leave 10e3c8: c3 ret 10e3c9: 8d 76 00 lea 0x0(%esi),%esi } break; #if defined(RTEMS_SCORE_THREAD_ENABLE_SCHEDULER_CALLOUT) case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: if ( --executing->cpu_time_budget == 0 ) 10e3cc: 8b 43 78 mov 0x78(%ebx),%eax 10e3cf: 48 dec %eax 10e3d0: 89 43 78 mov %eax,0x78(%ebx) 10e3d3: 85 c0 test %eax,%eax 10e3d5: 75 ed jne 10e3c4 <_Thread_Tickle_timeslice+0x2c> (*executing->budget_callout)( executing ); 10e3d7: 83 ec 0c sub $0xc,%esp 10e3da: 53 push %ebx 10e3db: ff 93 80 00 00 00 call *0x80(%ebx) 10e3e1: 83 c4 10 add $0x10,%esp 10e3e4: eb de jmp 10e3c4 <_Thread_Tickle_timeslice+0x2c> 10e3e6: 66 90 xchg %ax,%ax case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE: #if defined(RTEMS_SCORE_THREAD_ENABLE_EXHAUST_TIMESLICE) case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE: #endif if ( (int)(--executing->cpu_time_budget) <= 0 ) { 10e3e8: 8b 43 78 mov 0x78(%ebx),%eax 10e3eb: 48 dec %eax 10e3ec: 89 43 78 mov %eax,0x78(%ebx) 10e3ef: 85 c0 test %eax,%eax 10e3f1: 7f d1 jg 10e3c4 <_Thread_Tickle_timeslice+0x2c> * always operates on the scheduler that 'owns' the currently executing * thread. */ RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void ) { _Scheduler.Operations.yield(); 10e3f3: ff 15 8c 39 12 00 call *0x12398c * executing thread's timeslice is reset. Otherwise, the * currently executing thread is placed at the rear of the * FIFO for this priority and a new heir is selected. */ _Scheduler_Yield( ); executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 10e3f9: a1 60 7d 12 00 mov 0x127d60,%eax 10e3fe: 89 43 78 mov %eax,0x78(%ebx) 10e401: eb c1 jmp 10e3c4 <_Thread_Tickle_timeslice+0x2c> =============================================================================== 0010dd78 <_Thread_queue_Dequeue_priority>: */ Thread_Control *_Thread_queue_Dequeue_priority( Thread_queue_Control *the_thread_queue ) { 10dd78: 55 push %ebp 10dd79: 89 e5 mov %esp,%ebp 10dd7b: 57 push %edi 10dd7c: 56 push %esi 10dd7d: 53 push %ebx 10dd7e: 83 ec 2c sub $0x2c,%esp 10dd81: 8b 7d 08 mov 0x8(%ebp),%edi Chain_Node *new_second_node; Chain_Node *last_node; Chain_Node *next_node; Chain_Node *previous_node; _ISR_Disable( level ); 10dd84: 9c pushf 10dd85: fa cli 10dd86: 58 pop %eax 10dd87: 89 f9 mov %edi,%ecx for( index=0 ; 10dd89: 31 d2 xor %edx,%edx #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif return( the_thread ); } 10dd8b: 8b 19 mov (%ecx),%ebx RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 10dd8d: 8d 34 52 lea (%edx,%edx,2),%esi 10dd90: 8d 74 b7 04 lea 0x4(%edi,%esi,4),%esi _ISR_Disable( level ); for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) { 10dd94: 39 f3 cmp %esi,%ebx 10dd96: 75 18 jne 10ddb0 <_Thread_queue_Dequeue_priority+0x38> Chain_Node *previous_node; _ISR_Disable( level ); for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { 10dd98: 42 inc %edx 10dd99: 83 c1 0c add $0xc,%ecx Chain_Node *last_node; Chain_Node *next_node; Chain_Node *previous_node; _ISR_Disable( level ); for( index=0 ; 10dd9c: 83 fa 04 cmp $0x4,%edx 10dd9f: 75 ea jne 10dd8b <_Thread_queue_Dequeue_priority+0x13> } /* * We did not find a thread to unblock. */ _ISR_Enable( level ); 10dda1: 50 push %eax 10dda2: 9d popf return NULL; 10dda3: 31 f6 xor %esi,%esi #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif return( the_thread ); } 10dda5: 89 f0 mov %esi,%eax 10dda7: 8d 65 f4 lea -0xc(%ebp),%esp 10ddaa: 5b pop %ebx 10ddab: 5e pop %esi 10ddac: 5f pop %edi 10ddad: c9 leave 10ddae: c3 ret 10ddaf: 90 nop _ISR_Disable( level ); for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) { the_thread = (Thread_Control *) _Chain_First( 10ddb0: 89 de mov %ebx,%esi */ _ISR_Enable( level ); return NULL; dequeue: the_thread->Wait.queue = NULL; 10ddb2: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif return( the_thread ); } 10ddb9: 8b 53 38 mov 0x38(%ebx),%edx dequeue: the_thread->Wait.queue = NULL; new_first_node = _Chain_First( &the_thread->Wait.Block2n ); new_first_thread = (Thread_Control *) new_first_node; next_node = the_thread->Object.Node.next; 10ddbc: 8b 0b mov (%ebx),%ecx previous_node = the_thread->Object.Node.previous; 10ddbe: 8b 7b 04 mov 0x4(%ebx),%edi 10ddc1: 89 7d d4 mov %edi,-0x2c(%ebp) 10ddc4: 8d 7b 3c lea 0x3c(%ebx),%edi if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 10ddc7: 39 fa cmp %edi,%edx 10ddc9: 74 7f je 10de4a <_Thread_queue_Dequeue_priority+0xd2> #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif return( the_thread ); } 10ddcb: 8b 7b 40 mov 0x40(%ebx),%edi 10ddce: 89 7d e4 mov %edi,-0x1c(%ebp) next_node = the_thread->Object.Node.next; previous_node = the_thread->Object.Node.previous; if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { last_node = _Chain_Last( &the_thread->Wait.Block2n ); new_second_node = new_first_node->next; 10ddd1: 8b 3a mov (%edx),%edi 10ddd3: 89 7d e0 mov %edi,-0x20(%ebp) previous_node->next = new_first_node; 10ddd6: 8b 7d d4 mov -0x2c(%ebp),%edi 10ddd9: 89 17 mov %edx,(%edi) next_node->previous = new_first_node; 10dddb: 89 51 04 mov %edx,0x4(%ecx) new_first_node->next = next_node; 10ddde: 89 0a mov %ecx,(%edx) new_first_node->previous = previous_node; 10dde0: 89 7a 04 mov %edi,0x4(%edx) if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 10dde3: 8b 4b 40 mov 0x40(%ebx),%ecx 10dde6: 39 4b 38 cmp %ecx,0x38(%ebx) 10dde9: 74 17 je 10de02 <_Thread_queue_Dequeue_priority+0x8a> /* > two threads on 2-n */ head = _Chain_Head( &new_first_thread->Wait.Block2n ); 10ddeb: 8d 4a 38 lea 0x38(%edx),%ecx 10ddee: 8b 7d e0 mov -0x20(%ebp),%edi 10ddf1: 89 4f 04 mov %ecx,0x4(%edi) tail = _Chain_Tail( &new_first_thread->Wait.Block2n ); new_second_node->previous = head; head->next = new_second_node; 10ddf4: 89 7a 38 mov %edi,0x38(%edx) tail->previous = last_node; 10ddf7: 8b 4d e4 mov -0x1c(%ebp),%ecx 10ddfa: 89 4a 40 mov %ecx,0x40(%edx) new_first_node->previous = previous_node; if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { /* > two threads on 2-n */ head = _Chain_Head( &new_first_thread->Wait.Block2n ); tail = _Chain_Tail( &new_first_thread->Wait.Block2n ); 10ddfd: 83 c2 3c add $0x3c,%edx 10de00: 89 11 mov %edx,(%ecx) } else { previous_node->next = next_node; next_node->previous = previous_node; } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 10de02: 83 7b 50 02 cmpl $0x2,0x50(%ebx) 10de06: 74 18 je 10de20 <_Thread_queue_Dequeue_priority+0xa8> _ISR_Enable( level ); 10de08: 50 push %eax 10de09: 9d popf RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 10de0a: 83 ec 08 sub $0x8,%esp 10de0d: 68 f8 ff 03 10 push $0x1003fff8 10de12: 53 push %ebx 10de13: e8 34 f8 ff ff call 10d64c <_Thread_Clear_state> 10de18: 83 c4 10 add $0x10,%esp 10de1b: eb 88 jmp 10dda5 <_Thread_queue_Dequeue_priority+0x2d> 10de1d: 8d 76 00 lea 0x0(%esi),%esi RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 10de20: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 10de27: 50 push %eax 10de28: 9d popf (void) _Watchdog_Remove( &the_thread->Timer ); 10de29: 83 ec 0c sub $0xc,%esp 10de2c: 8d 43 48 lea 0x48(%ebx),%eax 10de2f: 50 push %eax 10de30: e8 2b 0a 00 00 call 10e860 <_Watchdog_Remove> 10de35: 58 pop %eax 10de36: 5a pop %edx 10de37: 68 f8 ff 03 10 push $0x1003fff8 10de3c: 53 push %ebx 10de3d: e8 0a f8 ff ff call 10d64c <_Thread_Clear_state> 10de42: 83 c4 10 add $0x10,%esp 10de45: e9 5b ff ff ff jmp 10dda5 <_Thread_queue_Dequeue_priority+0x2d> head->next = new_second_node; tail->previous = last_node; last_node->next = tail; } } else { previous_node->next = next_node; 10de4a: 8b 7d d4 mov -0x2c(%ebp),%edi 10de4d: 89 0f mov %ecx,(%edi) next_node->previous = previous_node; 10de4f: 89 79 04 mov %edi,0x4(%ecx) 10de52: eb ae jmp 10de02 <_Thread_queue_Dequeue_priority+0x8a> =============================================================================== 0010deec <_Thread_queue_Enqueue_priority>: Thread_blocking_operation_States _Thread_queue_Enqueue_priority ( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread, ISR_Level *level_p ) { 10deec: 55 push %ebp 10deed: 89 e5 mov %esp,%ebp 10deef: 57 push %edi 10def0: 56 push %esi 10def1: 53 push %ebx 10def2: 83 ec 0c sub $0xc,%esp 10def5: 8b 7d 0c mov 0xc(%ebp),%edi RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); 10def8: 8d 47 3c lea 0x3c(%edi),%eax 10defb: 89 47 38 mov %eax,0x38(%edi) head->next = tail; head->previous = NULL; 10defe: c7 47 3c 00 00 00 00 movl $0x0,0x3c(%edi) */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); 10df05: 8d 47 38 lea 0x38(%edi),%eax 10df08: 89 47 40 mov %eax,0x40(%edi) Priority_Control priority; States_Control block_state; _Chain_Initialize_empty( &the_thread->Wait.Block2n ); priority = the_thread->current_priority; 10df0b: 8b 57 14 mov 0x14(%edi),%edx RTEMS_INLINE_ROUTINE uint32_t _Thread_queue_Header_number ( Priority_Control the_priority ) { return (the_priority / TASK_QUEUE_DATA_PRIORITIES_PER_HEADER); 10df0e: 89 d0 mov %edx,%eax 10df10: c1 e8 06 shr $0x6,%eax header_index = _Thread_queue_Header_number( priority ); header = &the_thread_queue->Queues.Priority[ header_index ]; block_state = the_thread_queue->state; 10df13: 8b 4d 08 mov 0x8(%ebp),%ecx 10df16: 8b 59 38 mov 0x38(%ecx),%ebx if ( _Thread_queue_Is_reverse_search( priority ) ) 10df19: f6 c2 20 test $0x20,%dl 10df1c: 75 66 jne 10df84 <_Thread_queue_Enqueue_priority+0x98> * * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; } 10df1e: 8d 04 40 lea (%eax,%eax,2),%eax 10df21: 8d 04 81 lea (%ecx,%eax,4),%eax 10df24: 89 45 f0 mov %eax,-0x10(%ebp) RTEMS_INLINE_ROUTINE bool _Chain_Is_tail( Chain_Control *the_chain, const Chain_Node *the_node ) { return (the_node == _Chain_Tail(the_chain)); 10df27: 83 c0 04 add $0x4,%eax 10df2a: 89 7d e8 mov %edi,-0x18(%ebp) 10df2d: 89 c7 mov %eax,%edi if ( _Thread_queue_Is_reverse_search( priority ) ) goto restart_reverse_search; restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); 10df2f: 9c pushf 10df30: fa cli 10df31: 5e pop %esi 10df32: 89 75 ec mov %esi,-0x14(%ebp) * * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; } 10df35: 8b 4d f0 mov -0x10(%ebp),%ecx 10df38: 8b 01 mov (%ecx),%eax restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); search_thread = (Thread_Control *) _Chain_First( header ); while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { 10df3a: 39 f8 cmp %edi,%eax 10df3c: 75 18 jne 10df56 <_Thread_queue_Enqueue_priority+0x6a> 10df3e: e9 0e 01 00 00 jmp 10e051 <_Thread_queue_Enqueue_priority+0x165> 10df43: 90 nop break; search_priority = search_thread->current_priority; if ( priority <= search_priority ) break; #endif _ISR_Flash( level ); 10df44: 56 push %esi 10df45: 9d popf 10df46: fa cli if ( !_States_Are_set( search_thread->current_state, block_state) ) { 10df47: 85 58 10 test %ebx,0x10(%eax) 10df4a: 0f 84 ac 00 00 00 je 10dffc <_Thread_queue_Enqueue_priority+0x110> _ISR_Enable( level ); goto restart_forward_search; } search_thread = (Thread_Control *)search_thread->Object.Node.next; 10df50: 8b 00 mov (%eax),%eax restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); search_thread = (Thread_Control *) _Chain_First( header ); while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { 10df52: 39 f8 cmp %edi,%eax 10df54: 74 07 je 10df5d <_Thread_queue_Enqueue_priority+0x71> search_priority = search_thread->current_priority; 10df56: 8b 48 14 mov 0x14(%eax),%ecx if ( priority <= search_priority ) 10df59: 39 ca cmp %ecx,%edx 10df5b: 77 e7 ja 10df44 <_Thread_queue_Enqueue_priority+0x58> 10df5d: 8b 7d e8 mov -0x18(%ebp),%edi 10df60: 89 75 f0 mov %esi,-0x10(%ebp) } search_thread = (Thread_Control *)search_thread->Object.Node.next; } if ( the_thread_queue->sync_state != 10df63: 8b 75 08 mov 0x8(%ebp),%esi 10df66: 8b 5e 30 mov 0x30(%esi),%ebx 10df69: 83 fb 01 cmp $0x1,%ebx 10df6c: 0f 84 92 00 00 00 je 10e004 <_Thread_queue_Enqueue_priority+0x118> * For example, the blocking thread could have been given * the mutex by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ *level_p = level; 10df72: 8b 45 10 mov 0x10(%ebp),%eax 10df75: 8b 55 ec mov -0x14(%ebp),%edx 10df78: 89 10 mov %edx,(%eax) return the_thread_queue->sync_state; } 10df7a: 89 d8 mov %ebx,%eax 10df7c: 83 c4 0c add $0xc,%esp 10df7f: 5b pop %ebx 10df80: 5e pop %esi 10df81: 5f pop %edi 10df82: c9 leave 10df83: c3 ret 10df84: 8d 04 40 lea (%eax,%eax,2),%eax 10df87: 8b 4d 08 mov 0x8(%ebp),%ecx 10df8a: 8d 34 81 lea (%ecx,%eax,4),%esi 10df8d: 89 7d f0 mov %edi,-0x10(%ebp) the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; 10df90: 0f b6 0d 74 3a 12 00 movzbl 0x123a74,%ecx 10df97: 41 inc %ecx _ISR_Disable( level ); 10df98: 9c pushf 10df99: fa cli 10df9a: 5f pop %edi 10df9b: 89 7d ec mov %edi,-0x14(%ebp) * * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; } 10df9e: 8b 46 08 mov 0x8(%esi),%eax restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); search_thread = (Thread_Control *) _Chain_Last( header ); while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { 10dfa1: 39 f0 cmp %esi,%eax 10dfa3: 75 12 jne 10dfb7 <_Thread_queue_Enqueue_priority+0xcb> 10dfa5: eb 17 jmp 10dfbe <_Thread_queue_Enqueue_priority+0xd2> 10dfa7: 90 nop break; search_priority = search_thread->current_priority; if ( priority >= search_priority ) break; #endif _ISR_Flash( level ); 10dfa8: 57 push %edi 10dfa9: 9d popf 10dfaa: fa cli if ( !_States_Are_set( search_thread->current_state, block_state) ) { 10dfab: 85 58 10 test %ebx,0x10(%eax) 10dfae: 74 48 je 10dff8 <_Thread_queue_Enqueue_priority+0x10c><== NEVER TAKEN _ISR_Enable( level ); goto restart_reverse_search; } search_thread = (Thread_Control *) search_thread->Object.Node.previous; 10dfb0: 8b 40 04 mov 0x4(%eax),%eax restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); search_thread = (Thread_Control *) _Chain_Last( header ); while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { 10dfb3: 39 f0 cmp %esi,%eax 10dfb5: 74 07 je 10dfbe <_Thread_queue_Enqueue_priority+0xd2> search_priority = search_thread->current_priority; 10dfb7: 8b 48 14 mov 0x14(%eax),%ecx if ( priority >= search_priority ) 10dfba: 39 ca cmp %ecx,%edx 10dfbc: 72 ea jb 10dfa8 <_Thread_queue_Enqueue_priority+0xbc> 10dfbe: 89 7d e8 mov %edi,-0x18(%ebp) 10dfc1: 8b 7d f0 mov -0x10(%ebp),%edi } search_thread = (Thread_Control *) search_thread->Object.Node.previous; } if ( the_thread_queue->sync_state != 10dfc4: 8b 75 08 mov 0x8(%ebp),%esi 10dfc7: 8b 5e 30 mov 0x30(%esi),%ebx 10dfca: 83 fb 01 cmp $0x1,%ebx 10dfcd: 75 a3 jne 10df72 <_Thread_queue_Enqueue_priority+0x86> THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10dfcf: c7 46 30 00 00 00 00 movl $0x0,0x30(%esi) if ( priority == search_priority ) 10dfd6: 39 ca cmp %ecx,%edx 10dfd8: 74 53 je 10e02d <_Thread_queue_Enqueue_priority+0x141> goto equal_priority; search_node = (Chain_Node *) search_thread; next_node = search_node->next; 10dfda: 8b 10 mov (%eax),%edx the_node = (Chain_Node *) the_thread; the_node->next = next_node; 10dfdc: 89 17 mov %edx,(%edi) the_node->previous = search_node; 10dfde: 89 47 04 mov %eax,0x4(%edi) search_node->next = the_node; 10dfe1: 89 38 mov %edi,(%eax) next_node->previous = the_node; 10dfe3: 89 7a 04 mov %edi,0x4(%edx) the_thread->Wait.queue = the_thread_queue; 10dfe6: 89 77 44 mov %esi,0x44(%edi) _ISR_Enable( level ); 10dfe9: ff 75 e8 pushl -0x18(%ebp) 10dfec: 9d popf * * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; } 10dfed: 89 d8 mov %ebx,%eax 10dfef: 83 c4 0c add $0xc,%esp 10dff2: 5b pop %ebx 10dff3: 5e pop %esi 10dff4: 5f pop %edi 10dff5: c9 leave 10dff6: c3 ret 10dff7: 90 nop if ( priority >= search_priority ) break; #endif _ISR_Flash( level ); if ( !_States_Are_set( search_thread->current_state, block_state) ) { _ISR_Enable( level ); 10dff8: 57 push %edi <== NOT EXECUTED 10dff9: 9d popf <== NOT EXECUTED goto restart_reverse_search; 10dffa: eb 94 jmp 10df90 <_Thread_queue_Enqueue_priority+0xa4><== NOT EXECUTED if ( priority <= search_priority ) break; #endif _ISR_Flash( level ); if ( !_States_Are_set( search_thread->current_state, block_state) ) { _ISR_Enable( level ); 10dffc: 56 push %esi 10dffd: 9d popf goto restart_forward_search; 10dffe: e9 2c ff ff ff jmp 10df2f <_Thread_queue_Enqueue_priority+0x43> 10e003: 90 nop if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10e004: c7 46 30 00 00 00 00 movl $0x0,0x30(%esi) if ( priority == search_priority ) 10e00b: 39 ca cmp %ecx,%edx 10e00d: 74 1e je 10e02d <_Thread_queue_Enqueue_priority+0x141> goto equal_priority; search_node = (Chain_Node *) search_thread; previous_node = search_node->previous; 10e00f: 8b 50 04 mov 0x4(%eax),%edx the_node = (Chain_Node *) the_thread; the_node->next = search_node; 10e012: 89 07 mov %eax,(%edi) the_node->previous = previous_node; 10e014: 89 57 04 mov %edx,0x4(%edi) previous_node->next = the_node; 10e017: 89 3a mov %edi,(%edx) search_node->previous = the_node; 10e019: 89 78 04 mov %edi,0x4(%eax) the_thread->Wait.queue = the_thread_queue; 10e01c: 89 77 44 mov %esi,0x44(%edi) _ISR_Enable( level ); 10e01f: ff 75 f0 pushl -0x10(%ebp) 10e022: 9d popf * * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; } 10e023: 89 d8 mov %ebx,%eax 10e025: 83 c4 0c add $0xc,%esp 10e028: 5b pop %ebx 10e029: 5e pop %esi 10e02a: 5f pop %edi 10e02b: c9 leave 10e02c: c3 ret _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; equal_priority: /* add at end of priority group */ search_node = _Chain_Tail( &search_thread->Wait.Block2n ); previous_node = search_node->previous; 10e02d: 8b 50 40 mov 0x40(%eax),%edx the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; equal_priority: /* add at end of priority group */ search_node = _Chain_Tail( &search_thread->Wait.Block2n ); 10e030: 8d 48 3c lea 0x3c(%eax),%ecx 10e033: 89 0f mov %ecx,(%edi) previous_node = search_node->previous; the_node = (Chain_Node *) the_thread; the_node->next = search_node; the_node->previous = previous_node; 10e035: 89 57 04 mov %edx,0x4(%edi) previous_node->next = the_node; 10e038: 89 3a mov %edi,(%edx) search_node->previous = the_node; 10e03a: 89 78 40 mov %edi,0x40(%eax) the_thread->Wait.queue = the_thread_queue; 10e03d: 8b 45 08 mov 0x8(%ebp),%eax 10e040: 89 47 44 mov %eax,0x44(%edi) _ISR_Enable( level ); 10e043: ff 75 ec pushl -0x14(%ebp) 10e046: 9d popf return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 10e047: bb 01 00 00 00 mov $0x1,%ebx 10e04c: e9 29 ff ff ff jmp 10df7a <_Thread_queue_Enqueue_priority+0x8e> 10e051: 8b 7d e8 mov -0x18(%ebp),%edi 10e054: 89 75 f0 mov %esi,-0x10(%ebp) if ( _Thread_queue_Is_reverse_search( priority ) ) goto restart_reverse_search; restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; 10e057: b9 ff ff ff ff mov $0xffffffff,%ecx 10e05c: e9 02 ff ff ff jmp 10df63 <_Thread_queue_Enqueue_priority+0x77> =============================================================================== 00111780 <_Thread_queue_Extract>: void _Thread_queue_Extract( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 111780: 55 push %ebp 111781: 89 e5 mov %esp,%ebp 111783: 83 ec 08 sub $0x8,%esp 111786: 8b 45 08 mov 0x8(%ebp),%eax 111789: 8b 55 0c mov 0xc(%ebp),%edx /* * Can not use indirect function pointer here since Extract priority * is a macro and the underlying methods do not have the same signature. */ if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) 11178c: 83 78 34 01 cmpl $0x1,0x34(%eax) 111790: 74 0e je 1117a0 <_Thread_queue_Extract+0x20> _Thread_queue_Extract_priority( the_thread_queue, the_thread ); else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ _Thread_queue_Extract_fifo( the_thread_queue, the_thread ); 111792: 89 55 0c mov %edx,0xc(%ebp) 111795: 89 45 08 mov %eax,0x8(%ebp) } 111798: c9 leave * is a macro and the underlying methods do not have the same signature. */ if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) _Thread_queue_Extract_priority( the_thread_queue, the_thread ); else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ _Thread_queue_Extract_fifo( the_thread_queue, the_thread ); 111799: e9 de 19 00 00 jmp 11317c <_Thread_queue_Extract_fifo> 11179e: 66 90 xchg %ax,%ax /* * Can not use indirect function pointer here since Extract priority * is a macro and the underlying methods do not have the same signature. */ if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) _Thread_queue_Extract_priority( the_thread_queue, the_thread ); 1117a0: 51 push %ecx 1117a1: 6a 00 push $0x0 1117a3: 52 push %edx 1117a4: 50 push %eax 1117a5: e8 06 00 00 00 call 1117b0 <_Thread_queue_Extract_priority_helper> 1117aa: 83 c4 10 add $0x10,%esp else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ _Thread_queue_Extract_fifo( the_thread_queue, the_thread ); } 1117ad: c9 leave 1117ae: c3 ret =============================================================================== 0011317c <_Thread_queue_Extract_fifo>: void _Thread_queue_Extract_fifo( Thread_queue_Control *the_thread_queue __attribute__((unused)), Thread_Control *the_thread ) { 11317c: 55 push %ebp 11317d: 89 e5 mov %esp,%ebp 11317f: 53 push %ebx 113180: 83 ec 04 sub $0x4,%esp 113183: 8b 5d 0c mov 0xc(%ebp),%ebx ISR_Level level; _ISR_Disable( level ); 113186: 9c pushf 113187: fa cli 113188: 58 pop %eax if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 113189: f7 43 10 e0 be 03 00 testl $0x3bee0,0x10(%ebx) 113190: 74 2e je 1131c0 <_Thread_queue_Extract_fifo+0x44> ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 113192: 8b 0b mov (%ebx),%ecx previous = the_node->previous; 113194: 8b 53 04 mov 0x4(%ebx),%edx next->previous = previous; 113197: 89 51 04 mov %edx,0x4(%ecx) previous->next = next; 11319a: 89 0a mov %ecx,(%edx) return; } _Chain_Extract_unprotected( &the_thread->Object.Node ); the_thread->Wait.queue = NULL; 11319c: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 1131a3: 83 7b 50 02 cmpl $0x2,0x50(%ebx) 1131a7: 74 1f je 1131c8 <_Thread_queue_Extract_fifo+0x4c> _ISR_Enable( level ); 1131a9: 50 push %eax 1131aa: 9d popf RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 1131ab: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp) 1131b2: 89 5d 08 mov %ebx,0x8(%ebp) #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 1131b5: 8b 5d fc mov -0x4(%ebp),%ebx 1131b8: c9 leave 1131b9: e9 8e a4 ff ff jmp 10d64c <_Thread_Clear_state> 1131be: 66 90 xchg %ax,%ax ISR_Level level; _ISR_Disable( level ); if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { _ISR_Enable( level ); 1131c0: 50 push %eax 1131c1: 9d popf #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 1131c2: 8b 5d fc mov -0x4(%ebp),%ebx 1131c5: c9 leave 1131c6: c3 ret 1131c7: 90 nop 1131c8: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { _ISR_Enable( level ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 1131cf: 50 push %eax 1131d0: 9d popf (void) _Watchdog_Remove( &the_thread->Timer ); 1131d1: 83 ec 0c sub $0xc,%esp 1131d4: 8d 43 48 lea 0x48(%ebx),%eax 1131d7: 50 push %eax 1131d8: e8 83 b6 ff ff call 10e860 <_Watchdog_Remove> 1131dd: 83 c4 10 add $0x10,%esp 1131e0: eb c9 jmp 1131ab <_Thread_queue_Extract_fifo+0x2f> =============================================================================== 001117b0 <_Thread_queue_Extract_priority_helper>: void _Thread_queue_Extract_priority_helper( Thread_queue_Control *the_thread_queue __attribute__((unused)), Thread_Control *the_thread, bool requeuing ) { 1117b0: 55 push %ebp 1117b1: 89 e5 mov %esp,%ebp 1117b3: 57 push %edi 1117b4: 56 push %esi 1117b5: 53 push %ebx 1117b6: 83 ec 1c sub $0x1c,%esp 1117b9: 8b 5d 0c mov 0xc(%ebp),%ebx 1117bc: 8a 45 10 mov 0x10(%ebp),%al 1117bf: 88 45 e3 mov %al,-0x1d(%ebp) Chain_Node *new_first_node; Chain_Node *new_second_node; Chain_Node *last_node; the_node = (Chain_Node *) the_thread; _ISR_Disable( level ); 1117c2: 9c pushf 1117c3: fa cli 1117c4: 8f 45 e4 popl -0x1c(%ebp) if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 1117c7: f7 43 10 e0 be 03 00 testl $0x3bee0,0x10(%ebx) 1117ce: 74 6c je 11183c <_Thread_queue_Extract_priority_helper+0x8c> /* * The thread was actually waiting on a thread queue so let's remove it. */ next_node = the_node->next; 1117d0: 8b 13 mov (%ebx),%edx previous_node = the_node->previous; 1117d2: 8b 4b 04 mov 0x4(%ebx),%ecx #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 1117d5: 8b 43 38 mov 0x38(%ebx),%eax RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 1117d8: 8d 73 3c lea 0x3c(%ebx),%esi */ next_node = the_node->next; previous_node = the_node->previous; if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 1117db: 39 f0 cmp %esi,%eax 1117dd: 74 69 je 111848 <_Thread_queue_Extract_priority_helper+0x98> #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 1117df: 8b 7b 40 mov 0x40(%ebx),%edi if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { new_first_node = _Chain_First( &the_thread->Wait.Block2n ); new_first_thread = (Thread_Control *) new_first_node; last_node = _Chain_Last( &the_thread->Wait.Block2n ); new_second_node = new_first_node->next; 1117e2: 8b 30 mov (%eax),%esi previous_node->next = new_first_node; 1117e4: 89 01 mov %eax,(%ecx) next_node->previous = new_first_node; 1117e6: 89 42 04 mov %eax,0x4(%edx) new_first_node->next = next_node; 1117e9: 89 10 mov %edx,(%eax) new_first_node->previous = previous_node; 1117eb: 89 48 04 mov %ecx,0x4(%eax) if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 1117ee: 8b 53 40 mov 0x40(%ebx),%edx 1117f1: 39 53 38 cmp %edx,0x38(%ebx) 1117f4: 74 11 je 111807 <_Thread_queue_Extract_priority_helper+0x57> /* > two threads on 2-n */ head = _Chain_Head( &new_first_thread->Wait.Block2n ); 1117f6: 8d 50 38 lea 0x38(%eax),%edx 1117f9: 89 56 04 mov %edx,0x4(%esi) tail = _Chain_Tail( &new_first_thread->Wait.Block2n ); new_second_node->previous = head; head->next = new_second_node; 1117fc: 89 70 38 mov %esi,0x38(%eax) tail->previous = last_node; 1117ff: 89 78 40 mov %edi,0x40(%eax) new_first_node->previous = previous_node; if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { /* > two threads on 2-n */ head = _Chain_Head( &new_first_thread->Wait.Block2n ); tail = _Chain_Tail( &new_first_thread->Wait.Block2n ); 111802: 83 c0 3c add $0x3c,%eax 111805: 89 07 mov %eax,(%edi) /* * If we are not supposed to touch timers or the thread's state, return. */ if ( requeuing ) { 111807: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp) 11180b: 75 23 jne 111830 <_Thread_queue_Extract_priority_helper+0x80> _ISR_Enable( level ); return; } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 11180d: 83 7b 50 02 cmpl $0x2,0x50(%ebx) 111811: 74 3d je 111850 <_Thread_queue_Extract_priority_helper+0xa0> _ISR_Enable( level ); 111813: ff 75 e4 pushl -0x1c(%ebp) 111816: 9d popf 111817: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp) 11181e: 89 5d 08 mov %ebx,0x8(%ebp) #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 111821: 8d 65 f4 lea -0xc(%ebp),%esp 111824: 5b pop %ebx 111825: 5e pop %esi 111826: 5f pop %edi 111827: c9 leave 111828: e9 1f be ff ff jmp 10d64c <_Thread_Clear_state> 11182d: 8d 76 00 lea 0x0(%esi),%esi /* * If we are not supposed to touch timers or the thread's state, return. */ if ( requeuing ) { _ISR_Enable( level ); 111830: ff 75 e4 pushl -0x1c(%ebp) 111833: 9d popf #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 111834: 8d 65 f4 lea -0xc(%ebp),%esp 111837: 5b pop %ebx 111838: 5e pop %esi 111839: 5f pop %edi 11183a: c9 leave 11183b: c3 ret Chain_Node *last_node; the_node = (Chain_Node *) the_thread; _ISR_Disable( level ); if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { _ISR_Enable( level ); 11183c: ff 75 e4 pushl -0x1c(%ebp) 11183f: 9d popf #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 111840: 8d 65 f4 lea -0xc(%ebp),%esp 111843: 5b pop %ebx 111844: 5e pop %esi 111845: 5f pop %edi 111846: c9 leave 111847: c3 ret head->next = new_second_node; tail->previous = last_node; last_node->next = tail; } } else { previous_node->next = next_node; 111848: 89 11 mov %edx,(%ecx) next_node->previous = previous_node; 11184a: 89 4a 04 mov %ecx,0x4(%edx) 11184d: eb b8 jmp 111807 <_Thread_queue_Extract_priority_helper+0x57> 11184f: 90 nop 111850: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { _ISR_Enable( level ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 111857: ff 75 e4 pushl -0x1c(%ebp) 11185a: 9d popf (void) _Watchdog_Remove( &the_thread->Timer ); 11185b: 83 ec 0c sub $0xc,%esp 11185e: 8d 43 48 lea 0x48(%ebx),%eax 111861: 50 push %eax 111862: e8 f9 cf ff ff call 10e860 <_Watchdog_Remove> 111867: 83 c4 10 add $0x10,%esp 11186a: eb ab jmp 111817 <_Thread_queue_Extract_priority_helper+0x67> =============================================================================== 0010e064 <_Thread_queue_Extract_with_proxy>: */ bool _Thread_queue_Extract_with_proxy( Thread_Control *the_thread ) { 10e064: 55 push %ebp 10e065: 89 e5 mov %esp,%ebp 10e067: 83 ec 08 sub $0x8,%esp 10e06a: 8b 45 08 mov 0x8(%ebp),%eax States_Control state; state = the_thread->current_state; if ( _States_Is_waiting_on_thread_queue( state ) ) { 10e06d: f7 40 10 e0 be 03 00 testl $0x3bee0,0x10(%eax) 10e074: 75 06 jne 10e07c <_Thread_queue_Extract_with_proxy+0x18> #endif _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); return true; } return false; 10e076: 31 c0 xor %eax,%eax } 10e078: c9 leave 10e079: c3 ret 10e07a: 66 90 xchg %ax,%ax if ( proxy_extract_callout ) (*proxy_extract_callout)( the_thread ); } #endif _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 10e07c: 83 ec 08 sub $0x8,%esp 10e07f: 50 push %eax 10e080: ff 70 44 pushl 0x44(%eax) 10e083: e8 f8 36 00 00 call 111780 <_Thread_queue_Extract> return true; 10e088: 83 c4 10 add $0x10,%esp 10e08b: b0 01 mov $0x1,%al } return false; } 10e08d: c9 leave 10e08e: c3 ret =============================================================================== 0010febc <_Thread_queue_First>: */ Thread_Control *_Thread_queue_First( Thread_queue_Control *the_thread_queue ) { 10febc: 55 push %ebp 10febd: 89 e5 mov %esp,%ebp 10febf: 83 ec 08 sub $0x8,%esp 10fec2: 8b 45 08 mov 0x8(%ebp),%eax Thread_Control * (*first_p)(Thread_queue_Control *); if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) 10fec5: 83 78 34 01 cmpl $0x1,0x34(%eax) 10fec9: 74 0d je 10fed8 <_Thread_queue_First+0x1c> first_p = _Thread_queue_First_priority; else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ first_p = _Thread_queue_First_fifo; 10fecb: ba 04 37 11 00 mov $0x113704,%edx return (*first_p)( the_thread_queue ); 10fed0: 89 45 08 mov %eax,0x8(%ebp) } 10fed3: c9 leave if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) first_p = _Thread_queue_First_priority; else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ first_p = _Thread_queue_First_fifo; return (*first_p)( the_thread_queue ); 10fed4: ff e2 jmp *%edx 10fed6: 66 90 xchg %ax,%ax ) { Thread_Control * (*first_p)(Thread_queue_Control *); if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) first_p = _Thread_queue_First_priority; 10fed8: ba e4 fe 10 00 mov $0x10fee4,%edx else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ first_p = _Thread_queue_First_fifo; return (*first_p)( the_thread_queue ); 10fedd: 89 45 08 mov %eax,0x8(%ebp) } 10fee0: c9 leave if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) first_p = _Thread_queue_First_priority; else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ first_p = _Thread_queue_First_fifo; return (*first_p)( the_thread_queue ); 10fee1: ff e2 jmp *%edx =============================================================================== 00113704 <_Thread_queue_First_fifo>: */ Thread_Control *_Thread_queue_First_fifo( Thread_queue_Control *the_thread_queue ) { 113704: 55 push %ebp 113705: 89 e5 mov %esp,%ebp 113707: 8b 55 08 mov 0x8(%ebp),%edx if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) return (Thread_Control *) _Chain_First( &the_thread_queue->Queues.Fifo ); return NULL; } 11370a: 8b 02 mov (%edx),%eax 11370c: 83 c2 04 add $0x4,%edx Thread_Control *_Thread_queue_First_fifo( Thread_queue_Control *the_thread_queue ) { if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) 11370f: 39 d0 cmp %edx,%eax 113711: 74 05 je 113718 <_Thread_queue_First_fifo+0x14> return (Thread_Control *) _Chain_First( &the_thread_queue->Queues.Fifo ); return NULL; } 113713: c9 leave 113714: c3 ret 113715: 8d 76 00 lea 0x0(%esi),%esi ) { if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) return (Thread_Control *) _Chain_First( &the_thread_queue->Queues.Fifo ); return NULL; 113718: 31 c0 xor %eax,%eax } 11371a: c9 leave 11371b: c3 ret =============================================================================== 0010e090 <_Thread_queue_Flush>: #else Thread_queue_Flush_callout remote_extract_callout __attribute__((unused)), #endif uint32_t status ) { 10e090: 55 push %ebp 10e091: 89 e5 mov %esp,%ebp 10e093: 56 push %esi 10e094: 53 push %ebx 10e095: 8b 5d 08 mov 0x8(%ebp),%ebx 10e098: 8b 75 10 mov 0x10(%ebp),%esi Thread_Control *the_thread; while ( (the_thread = _Thread_queue_Dequeue( the_thread_queue )) ) { 10e09b: eb 06 jmp 10e0a3 <_Thread_queue_Flush+0x13> 10e09d: 8d 76 00 lea 0x0(%esi),%esi #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) ( *remote_extract_callout )( the_thread ); else #endif the_thread->Wait.return_code = status; 10e0a0: 89 70 34 mov %esi,0x34(%eax) uint32_t status ) { Thread_Control *the_thread; while ( (the_thread = _Thread_queue_Dequeue( the_thread_queue )) ) { 10e0a3: 83 ec 0c sub $0xc,%esp 10e0a6: 53 push %ebx 10e0a7: e8 80 fc ff ff call 10dd2c <_Thread_queue_Dequeue> 10e0ac: 83 c4 10 add $0x10,%esp 10e0af: 85 c0 test %eax,%eax 10e0b1: 75 ed jne 10e0a0 <_Thread_queue_Flush+0x10> ( *remote_extract_callout )( the_thread ); else #endif the_thread->Wait.return_code = status; } } 10e0b3: 8d 65 f8 lea -0x8(%ebp),%esp 10e0b6: 5b pop %ebx 10e0b7: 5e pop %esi 10e0b8: c9 leave 10e0b9: c3 ret =============================================================================== 0010e0bc <_Thread_queue_Initialize>: Thread_queue_Control *the_thread_queue, Thread_queue_Disciplines the_discipline, States_Control state, uint32_t timeout_status ) { 10e0bc: 55 push %ebp 10e0bd: 89 e5 mov %esp,%ebp 10e0bf: 56 push %esi 10e0c0: 53 push %ebx 10e0c1: 8b 45 08 mov 0x8(%ebp),%eax 10e0c4: 8b 55 0c mov 0xc(%ebp),%edx the_thread_queue->state = state; 10e0c7: 8b 4d 10 mov 0x10(%ebp),%ecx 10e0ca: 89 48 38 mov %ecx,0x38(%eax) the_thread_queue->discipline = the_discipline; 10e0cd: 89 50 34 mov %edx,0x34(%eax) the_thread_queue->timeout_status = timeout_status; 10e0d0: 8b 4d 14 mov 0x14(%ebp),%ecx 10e0d3: 89 48 3c mov %ecx,0x3c(%eax) the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10e0d6: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax) if ( the_discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) { 10e0dd: 83 fa 01 cmp $0x1,%edx 10e0e0: 74 16 je 10e0f8 <_Thread_queue_Initialize+0x3c> RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); 10e0e2: 8d 50 04 lea 0x4(%eax),%edx 10e0e5: 89 10 mov %edx,(%eax) head->next = tail; head->previous = NULL; 10e0e7: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) tail->previous = head; 10e0ee: 89 40 08 mov %eax,0x8(%eax) _Chain_Initialize_empty( &the_thread_queue->Queues.Priority[index] ); } else { /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ _Chain_Initialize_empty( &the_thread_queue->Queues.Fifo ); } } 10e0f1: 5b pop %ebx 10e0f2: 5e pop %esi 10e0f3: c9 leave 10e0f4: c3 ret 10e0f5: 8d 76 00 lea 0x0(%esi),%esi the_thread_queue->state = state; the_thread_queue->discipline = the_discipline; the_thread_queue->timeout_status = timeout_status; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; if ( the_discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) { 10e0f8: 89 c1 mov %eax,%ecx 10e0fa: 30 d2 xor %dl,%dl RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); 10e0fc: 8d 1c 52 lea (%edx,%edx,2),%ebx 10e0ff: 8d 1c 98 lea (%eax,%ebx,4),%ebx 10e102: 8d 73 04 lea 0x4(%ebx),%esi 10e105: 89 31 mov %esi,(%ecx) head->next = tail; head->previous = NULL; 10e107: c7 41 04 00 00 00 00 movl $0x0,0x4(%ecx) */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); 10e10e: 89 59 08 mov %ebx,0x8(%ecx) uint32_t index; for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++) 10e111: 42 inc %edx 10e112: 83 c1 0c add $0xc,%ecx the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; if ( the_discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) { uint32_t index; for( index=0 ; 10e115: 83 fa 04 cmp $0x4,%edx 10e118: 75 e2 jne 10e0fc <_Thread_queue_Initialize+0x40> _Chain_Initialize_empty( &the_thread_queue->Queues.Priority[index] ); } else { /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ _Chain_Initialize_empty( &the_thread_queue->Queues.Fifo ); } } 10e11a: 5b pop %ebx 10e11b: 5e pop %esi 10e11c: c9 leave 10e11d: c3 ret =============================================================================== 0011186c <_Thread_queue_Process_timeout>: #include void _Thread_queue_Process_timeout( Thread_Control *the_thread ) { 11186c: 55 push %ebp 11186d: 89 e5 mov %esp,%ebp 11186f: 83 ec 08 sub $0x8,%esp 111872: 8b 45 08 mov 0x8(%ebp),%eax Thread_queue_Control *the_thread_queue = the_thread->Wait.queue; 111875: 8b 50 44 mov 0x44(%eax),%edx * If it is not satisfied, then it is "nothing happened" and * this is the "timeout" transition. After a request is satisfied, * a timeout is not allowed to occur. */ if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SYNCHRONIZED && 111878: 8b 4a 30 mov 0x30(%edx),%ecx 11187b: 85 c9 test %ecx,%ecx 11187d: 74 08 je 111887 <_Thread_queue_Process_timeout+0x1b> 11187f: 3b 05 38 83 12 00 cmp 0x128338,%eax 111885: 74 15 je 11189c <_Thread_queue_Process_timeout+0x30><== ALWAYS TAKEN if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) { the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; } } else { the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 111887: 8b 4a 3c mov 0x3c(%edx),%ecx 11188a: 89 48 34 mov %ecx,0x34(%eax) _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 11188d: 83 ec 08 sub $0x8,%esp 111890: 50 push %eax 111891: 52 push %edx 111892: e8 e9 fe ff ff call 111780 <_Thread_queue_Extract> 111897: 83 c4 10 add $0x10,%esp } } 11189a: c9 leave 11189b: c3 ret * a timeout is not allowed to occur. */ if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SYNCHRONIZED && _Thread_Is_executing( the_thread ) ) { if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) { 11189c: 83 f9 03 cmp $0x3,%ecx 11189f: 74 f9 je 11189a <_Thread_queue_Process_timeout+0x2e> the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 1118a1: 8b 4a 3c mov 0x3c(%edx),%ecx 1118a4: 89 48 34 mov %ecx,0x34(%eax) the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; 1118a7: c7 42 30 02 00 00 00 movl $0x2,0x30(%edx) } } else { the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); } } 1118ae: c9 leave 1118af: c3 ret =============================================================================== 0010e120 <_Thread_queue_Requeue>: void _Thread_queue_Requeue( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 10e120: 55 push %ebp 10e121: 89 e5 mov %esp,%ebp 10e123: 57 push %edi 10e124: 56 push %esi 10e125: 53 push %ebx 10e126: 83 ec 1c sub $0x1c,%esp 10e129: 8b 75 08 mov 0x8(%ebp),%esi 10e12c: 8b 7d 0c mov 0xc(%ebp),%edi /* * Just in case the thread really wasn't blocked on a thread queue * when we get here. */ if ( !the_thread_queue ) 10e12f: 85 f6 test %esi,%esi 10e131: 74 06 je 10e139 <_Thread_queue_Requeue+0x19><== NEVER TAKEN /* * If queueing by FIFO, there is nothing to do. This only applies to * priority blocking discipline. */ if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) { 10e133: 83 7e 34 01 cmpl $0x1,0x34(%esi) 10e137: 74 0b je 10e144 <_Thread_queue_Requeue+0x24><== ALWAYS TAKEN _Thread_queue_Extract_priority_helper( tq, the_thread, true ); (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored ); } _ISR_Enable( level ); } } 10e139: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e13c: 5b pop %ebx <== NOT EXECUTED 10e13d: 5e pop %esi <== NOT EXECUTED 10e13e: 5f pop %edi <== NOT EXECUTED 10e13f: c9 leave <== NOT EXECUTED 10e140: c3 ret <== NOT EXECUTED 10e141: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) { Thread_queue_Control *tq = the_thread_queue; ISR_Level level; ISR_Level level_ignored; _ISR_Disable( level ); 10e144: 9c pushf 10e145: fa cli 10e146: 5b pop %ebx if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 10e147: f7 47 10 e0 be 03 00 testl $0x3bee0,0x10(%edi) 10e14e: 75 0c jne 10e15c <_Thread_queue_Requeue+0x3c><== ALWAYS TAKEN _Thread_queue_Enter_critical_section( tq ); _Thread_queue_Extract_priority_helper( tq, the_thread, true ); (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored ); } _ISR_Enable( level ); 10e150: 53 push %ebx 10e151: 9d popf } } 10e152: 8d 65 f4 lea -0xc(%ebp),%esp 10e155: 5b pop %ebx 10e156: 5e pop %esi 10e157: 5f pop %edi 10e158: c9 leave 10e159: c3 ret 10e15a: 66 90 xchg %ax,%ax RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 10e15c: c7 46 30 01 00 00 00 movl $0x1,0x30(%esi) ISR_Level level_ignored; _ISR_Disable( level ); if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { _Thread_queue_Enter_critical_section( tq ); _Thread_queue_Extract_priority_helper( tq, the_thread, true ); 10e163: 50 push %eax 10e164: 6a 01 push $0x1 10e166: 57 push %edi 10e167: 56 push %esi 10e168: e8 43 36 00 00 call 1117b0 <_Thread_queue_Extract_priority_helper> (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored ); 10e16d: 83 c4 0c add $0xc,%esp 10e170: 8d 45 e4 lea -0x1c(%ebp),%eax 10e173: 50 push %eax 10e174: 57 push %edi 10e175: 56 push %esi 10e176: e8 71 fd ff ff call 10deec <_Thread_queue_Enqueue_priority> 10e17b: 83 c4 10 add $0x10,%esp 10e17e: eb d0 jmp 10e150 <_Thread_queue_Requeue+0x30> =============================================================================== 0010e180 <_Thread_queue_Timeout>: void _Thread_queue_Timeout( Objects_Id id, void *ignored __attribute__((unused)) ) { 10e180: 55 push %ebp 10e181: 89 e5 mov %esp,%ebp 10e183: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10e186: 8d 45 f4 lea -0xc(%ebp),%eax 10e189: 50 push %eax 10e18a: ff 75 08 pushl 0x8(%ebp) 10e18d: e8 42 f8 ff ff call 10d9d4 <_Thread_Get> switch ( location ) { 10e192: 83 c4 10 add $0x10,%esp 10e195: 8b 55 f4 mov -0xc(%ebp),%edx 10e198: 85 d2 test %edx,%edx 10e19a: 75 17 jne 10e1b3 <_Thread_queue_Timeout+0x33><== NEVER TAKEN #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* impossible */ #endif break; case OBJECTS_LOCAL: _Thread_queue_Process_timeout( the_thread ); 10e19c: 83 ec 0c sub $0xc,%esp 10e19f: 50 push %eax 10e1a0: e8 c7 36 00 00 call 11186c <_Thread_queue_Process_timeout> */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 10e1a5: a1 90 7d 12 00 mov 0x127d90,%eax 10e1aa: 48 dec %eax 10e1ab: a3 90 7d 12 00 mov %eax,0x127d90 10e1b0: 83 c4 10 add $0x10,%esp _Thread_Unnest_dispatch(); break; } } 10e1b3: c9 leave 10e1b4: c3 ret =============================================================================== 00118db8 <_Timer_server_Body>: * @a arg points to the corresponding timer server control block. */ static rtems_task _Timer_server_Body( rtems_task_argument arg ) { 118db8: 55 push %ebp 118db9: 89 e5 mov %esp,%ebp 118dbb: 57 push %edi 118dbc: 56 push %esi 118dbd: 53 push %ebx 118dbe: 83 ec 4c sub $0x4c,%esp 118dc1: 8b 5d 08 mov 0x8(%ebp),%ebx ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 118dc4: 8d 45 e0 lea -0x20(%ebp),%eax 118dc7: 89 45 b4 mov %eax,-0x4c(%ebp) 118dca: 89 45 dc mov %eax,-0x24(%ebp) head->previous = NULL; 118dcd: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) tail->previous = head; 118dd4: 8d 4d dc lea -0x24(%ebp),%ecx 118dd7: 89 4d e4 mov %ecx,-0x1c(%ebp) ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 118dda: 8d 7d d0 lea -0x30(%ebp),%edi 118ddd: 8d 45 d4 lea -0x2c(%ebp),%eax 118de0: 89 45 b0 mov %eax,-0x50(%ebp) 118de3: 89 45 d0 mov %eax,-0x30(%ebp) head->previous = NULL; 118de6: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) tail->previous = head; 118ded: 89 7d d8 mov %edi,-0x28(%ebp) 118df0: 8d 73 30 lea 0x30(%ebx),%esi 118df3: 8d 4b 68 lea 0x68(%ebx),%ecx 118df6: 89 4d c4 mov %ecx,-0x3c(%ebp) 118df9: 8d 43 08 lea 0x8(%ebx),%eax 118dfc: 89 45 bc mov %eax,-0x44(%ebp) 118dff: 8d 53 40 lea 0x40(%ebx),%edx 118e02: 89 55 c0 mov %edx,-0x40(%ebp) 118e05: 8d 76 00 lea 0x0(%esi),%esi Chain_Control *tmp; /* * Afterwards all timer inserts are directed to this chain and the interval * and TOD chains will be no more modified by other parties. */ ts->insert_chain = insert_chain; 118e08: 8d 4d dc lea -0x24(%ebp),%ecx 118e0b: 89 4b 78 mov %ecx,0x78(%ebx) 118e0e: 66 90 xchg %ax,%ax static void _Timer_server_Process_interval_watchdogs( Timer_server_Watchdogs *watchdogs, Chain_Control *fire_chain ) { Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot; 118e10: a1 64 2b 14 00 mov 0x142b64,%eax /* * We assume adequate unsigned arithmetic here. */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; 118e15: 8b 53 3c mov 0x3c(%ebx),%edx watchdogs->last_snapshot = snapshot; 118e18: 89 43 3c mov %eax,0x3c(%ebx) _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 118e1b: 51 push %ecx 118e1c: 57 push %edi Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot; /* * We assume adequate unsigned arithmetic here. */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; 118e1d: 29 d0 sub %edx,%eax watchdogs->last_snapshot = snapshot; _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 118e1f: 50 push %eax 118e20: 56 push %esi 118e21: e8 9e 3f 00 00 call 11cdc4 <_Watchdog_Adjust_to_chain> static void _Timer_server_Process_tod_watchdogs( Timer_server_Watchdogs *watchdogs, Chain_Control *fire_chain ) { Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); 118e26: a1 c8 2a 14 00 mov 0x142ac8,%eax Watchdog_Interval last_snapshot = watchdogs->last_snapshot; 118e2b: 8b 53 74 mov 0x74(%ebx),%edx /* * Process the seconds chain. Start by checking that the Time * of Day (TOD) has not been set backwards. If it has then * we want to adjust the watchdogs->Chain to indicate this. */ if ( snapshot > last_snapshot ) { 118e2e: 83 c4 10 add $0x10,%esp 118e31: 39 d0 cmp %edx,%eax 118e33: 0f 87 af 00 00 00 ja 118ee8 <_Timer_server_Body+0x130> * TOD has been set forward. */ delta = snapshot - last_snapshot; _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); } else if ( snapshot < last_snapshot ) { 118e39: 0f 82 c9 00 00 00 jb 118f08 <_Timer_server_Body+0x150> */ delta = last_snapshot - snapshot; _Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta ); } watchdogs->last_snapshot = snapshot; 118e3f: 89 43 74 mov %eax,0x74(%ebx) 118e42: 66 90 xchg %ax,%ax } static void _Timer_server_Process_insertions( Timer_server_Control *ts ) { while ( true ) { Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain ); 118e44: 8b 43 78 mov 0x78(%ebx),%eax 118e47: 83 ec 0c sub $0xc,%esp 118e4a: 50 push %eax 118e4b: e8 0c 0a 00 00 call 11985c <_Chain_Get> if ( timer == NULL ) { 118e50: 83 c4 10 add $0x10,%esp 118e53: 85 c0 test %eax,%eax 118e55: 74 35 je 118e8c <_Timer_server_Body+0xd4><== ALWAYS TAKEN static void _Timer_server_Insert_timer( Timer_server_Control *ts, Timer_Control *timer ) { if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { 118e57: 8b 50 38 mov 0x38(%eax),%edx <== NOT EXECUTED 118e5a: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED 118e5d: 74 19 je 118e78 <_Timer_server_Body+0xc0><== NOT EXECUTED _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { 118e5f: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED 118e62: 75 e0 jne 118e44 <_Timer_server_Body+0x8c><== NOT EXECUTED _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker ); 118e64: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 118e67: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 118e6a: 50 push %eax <== NOT EXECUTED 118e6b: ff 75 c4 pushl -0x3c(%ebp) <== NOT EXECUTED 118e6e: e8 dd 3f 00 00 call 11ce50 <_Watchdog_Insert> <== NOT EXECUTED 118e73: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 118e76: eb cc jmp 118e44 <_Timer_server_Body+0x8c><== NOT EXECUTED Timer_server_Control *ts, Timer_Control *timer ) { if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); 118e78: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 118e7b: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 118e7e: 50 push %eax <== NOT EXECUTED 118e7f: 56 push %esi <== NOT EXECUTED 118e80: e8 cb 3f 00 00 call 11ce50 <_Watchdog_Insert> <== NOT EXECUTED 118e85: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 118e88: eb ba jmp 118e44 <_Timer_server_Body+0x8c><== NOT EXECUTED 118e8a: 66 90 xchg %ax,%ax <== NOT EXECUTED * of zero it will be processed in the next iteration of the timer server * body loop. */ _Timer_server_Process_insertions( ts ); _ISR_Disable( level ); 118e8c: 9c pushf 118e8d: fa cli 118e8e: 58 pop %eax tmp = ts->insert_chain; 118e8f: 8b 53 78 mov 0x78(%ebx),%edx if ( _Chain_Is_empty( insert_chain ) ) { 118e92: 8b 55 b4 mov -0x4c(%ebp),%edx 118e95: 39 55 dc cmp %edx,-0x24(%ebp) 118e98: 0f 84 86 00 00 00 je 118f24 <_Timer_server_Body+0x16c><== ALWAYS TAKEN 118e9e: b2 01 mov $0x1,%dl <== NOT EXECUTED ts->insert_chain = NULL; do_loop = false; } _ISR_Enable( level ); 118ea0: 50 push %eax 118ea1: 9d popf * Afterwards all timer inserts are directed to this chain and the interval * and TOD chains will be no more modified by other parties. */ ts->insert_chain = insert_chain; while ( do_loop ) { 118ea2: 84 d2 test %dl,%dl 118ea4: 0f 85 66 ff ff ff jne 118e10 <_Timer_server_Body+0x58><== NEVER TAKEN _Chain_Initialize_empty( &fire_chain ); while ( true ) { _Timer_server_Get_watchdogs_that_fire_now( ts, &insert_chain, &fire_chain ); if ( !_Chain_Is_empty( &fire_chain ) ) { 118eaa: 8b 4d b0 mov -0x50(%ebp),%ecx 118ead: 39 4d d0 cmp %ecx,-0x30(%ebp) 118eb0: 75 22 jne 118ed4 <_Timer_server_Body+0x11c> 118eb2: eb 7e jmp 118f32 <_Timer_server_Body+0x17a> Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *old_first = head->next; Chain_Node *new_first = old_first->next; 118eb4: 8b 10 mov (%eax),%edx head->next = new_first; 118eb6: 89 55 d0 mov %edx,-0x30(%ebp) new_first->previous = head; 118eb9: 89 7a 04 mov %edi,0x4(%edx) * service routine may remove a watchdog from the chain. */ _ISR_Disable( level ); watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain ); if ( watchdog != NULL ) { watchdog->state = WATCHDOG_INACTIVE; 118ebc: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax) _ISR_Enable( level ); 118ec3: 51 push %ecx 118ec4: 9d popf /* * The timer server may block here and wait for resources or time. * The system watchdogs are inactive and will remain inactive since * the active flag of the timer server is true. */ (*watchdog->routine)( watchdog->id, watchdog->user_data ); 118ec5: 83 ec 08 sub $0x8,%esp 118ec8: ff 70 24 pushl 0x24(%eax) 118ecb: ff 70 20 pushl 0x20(%eax) 118ece: ff 50 1c call *0x1c(%eax) } 118ed1: 83 c4 10 add $0x10,%esp /* * It is essential that interrupts are disable here since an interrupt * service routine may remove a watchdog from the chain. */ _ISR_Disable( level ); 118ed4: 9c pushf 118ed5: fa cli 118ed6: 59 pop %ecx initialized = false; } #endif return status; } 118ed7: 8b 45 d0 mov -0x30(%ebp),%eax */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected( Chain_Control *the_chain ) { if ( !_Chain_Is_empty(the_chain)) 118eda: 3b 45 b0 cmp -0x50(%ebp),%eax 118edd: 75 d5 jne 118eb4 <_Timer_server_Body+0xfc> watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain ); if ( watchdog != NULL ) { watchdog->state = WATCHDOG_INACTIVE; _ISR_Enable( level ); } else { _ISR_Enable( level ); 118edf: 51 push %ecx 118ee0: 9d popf 118ee1: e9 22 ff ff ff jmp 118e08 <_Timer_server_Body+0x50> 118ee6: 66 90 xchg %ax,%ax /* * This path is for normal forward movement and cases where the * TOD has been set forward. */ delta = snapshot - last_snapshot; _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 118ee8: 51 push %ecx 118ee9: 57 push %edi if ( snapshot > last_snapshot ) { /* * This path is for normal forward movement and cases where the * TOD has been set forward. */ delta = snapshot - last_snapshot; 118eea: 89 c1 mov %eax,%ecx 118eec: 29 d1 sub %edx,%ecx _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 118eee: 51 push %ecx 118eef: ff 75 c4 pushl -0x3c(%ebp) 118ef2: 89 45 b8 mov %eax,-0x48(%ebp) 118ef5: e8 ca 3e 00 00 call 11cdc4 <_Watchdog_Adjust_to_chain> 118efa: 83 c4 10 add $0x10,%esp 118efd: 8b 45 b8 mov -0x48(%ebp),%eax 118f00: e9 3a ff ff ff jmp 118e3f <_Timer_server_Body+0x87> 118f05: 8d 76 00 lea 0x0(%esi),%esi /* * The current TOD is before the last TOD which indicates that * TOD has been set backwards. */ delta = last_snapshot - snapshot; _Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta ); 118f08: 51 push %ecx } else if ( snapshot < last_snapshot ) { /* * The current TOD is before the last TOD which indicates that * TOD has been set backwards. */ delta = last_snapshot - snapshot; 118f09: 29 c2 sub %eax,%edx _Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta ); 118f0b: 52 push %edx 118f0c: 6a 01 push $0x1 118f0e: ff 75 c4 pushl -0x3c(%ebp) 118f11: 89 45 b8 mov %eax,-0x48(%ebp) 118f14: e8 33 3e 00 00 call 11cd4c <_Watchdog_Adjust> 118f19: 83 c4 10 add $0x10,%esp 118f1c: 8b 45 b8 mov -0x48(%ebp),%eax 118f1f: e9 1b ff ff ff jmp 118e3f <_Timer_server_Body+0x87> _Timer_server_Process_insertions( ts ); _ISR_Disable( level ); tmp = ts->insert_chain; if ( _Chain_Is_empty( insert_chain ) ) { ts->insert_chain = NULL; 118f24: c7 43 78 00 00 00 00 movl $0x0,0x78(%ebx) do_loop = false; 118f2b: 31 d2 xor %edx,%edx 118f2d: e9 6e ff ff ff jmp 118ea0 <_Timer_server_Body+0xe8> * the active flag of the timer server is true. */ (*watchdog->routine)( watchdog->id, watchdog->user_data ); } } else { ts->active = false; 118f32: c6 43 7c 00 movb $0x0,0x7c(%ebx) 118f36: a1 30 2a 14 00 mov 0x142a30,%eax 118f3b: 40 inc %eax 118f3c: a3 30 2a 14 00 mov %eax,0x142a30 /* * Block until there is something to do. */ _Thread_Disable_dispatch(); _Thread_Set_state( ts->thread, STATES_DELAYING ); 118f41: 83 ec 08 sub $0x8,%esp 118f44: 6a 08 push $0x8 118f46: ff 33 pushl (%ebx) 118f48: e8 e7 37 00 00 call 11c734 <_Thread_Set_state> _Timer_server_Reset_interval_system_watchdog( ts ); 118f4d: 89 d8 mov %ebx,%eax 118f4f: e8 c4 fd ff ff call 118d18 <_Timer_server_Reset_interval_system_watchdog> _Timer_server_Reset_tod_system_watchdog( ts ); 118f54: 89 d8 mov %ebx,%eax 118f56: e8 0d fe ff ff call 118d68 <_Timer_server_Reset_tod_system_watchdog> _Thread_Enable_dispatch(); 118f5b: e8 f4 2e 00 00 call 11be54 <_Thread_Enable_dispatch> ts->active = true; 118f60: c6 43 7c 01 movb $0x1,0x7c(%ebx) static void _Timer_server_Stop_interval_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog ); 118f64: 5a pop %edx 118f65: ff 75 bc pushl -0x44(%ebp) 118f68: e8 23 40 00 00 call 11cf90 <_Watchdog_Remove> static void _Timer_server_Stop_tod_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog ); 118f6d: 58 pop %eax 118f6e: ff 75 c0 pushl -0x40(%ebp) 118f71: e8 1a 40 00 00 call 11cf90 <_Watchdog_Remove> 118f76: 83 c4 10 add $0x10,%esp 118f79: e9 8a fe ff ff jmp 118e08 <_Timer_server_Body+0x50> =============================================================================== 00118f80 <_Timer_server_Schedule_operation_method>: static void _Timer_server_Schedule_operation_method( Timer_server_Control *ts, Timer_Control *timer ) { 118f80: 55 push %ebp 118f81: 89 e5 mov %esp,%ebp 118f83: 57 push %edi 118f84: 56 push %esi 118f85: 53 push %ebx 118f86: 83 ec 2c sub $0x2c,%esp 118f89: 8b 5d 08 mov 0x8(%ebp),%ebx 118f8c: 8b 45 0c mov 0xc(%ebp),%eax if ( ts->insert_chain == NULL ) { 118f8f: 8b 53 78 mov 0x78(%ebx),%edx 118f92: 85 d2 test %edx,%edx 118f94: 74 16 je 118fac <_Timer_server_Schedule_operation_method+0x2c><== ALWAYS TAKEN * server is not preemptible, so we must be in interrupt context here. No * thread dispatch will happen until the timer server finishes its * critical section. We have to use the protected chain methods because * we may be interrupted by a higher priority interrupt. */ _Chain_Append( ts->insert_chain, &timer->Object.Node ); 118f96: 8b 53 78 mov 0x78(%ebx),%edx <== NOT EXECUTED 118f99: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 118f9c: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } } 118f9f: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 118fa2: 5b pop %ebx <== NOT EXECUTED 118fa3: 5e pop %esi <== NOT EXECUTED 118fa4: 5f pop %edi <== NOT EXECUTED 118fa5: c9 leave <== NOT EXECUTED * server is not preemptible, so we must be in interrupt context here. No * thread dispatch will happen until the timer server finishes its * critical section. We have to use the protected chain methods because * we may be interrupted by a higher priority interrupt. */ _Chain_Append( ts->insert_chain, &timer->Object.Node ); 118fa6: e9 75 08 00 00 jmp 119820 <_Chain_Append> <== NOT EXECUTED 118fab: 90 nop <== NOT EXECUTED 118fac: 8b 15 30 2a 14 00 mov 0x142a30,%edx 118fb2: 42 inc %edx 118fb3: 89 15 30 2a 14 00 mov %edx,0x142a30 * being inserted. This could result in an integer overflow. */ _Thread_Disable_dispatch(); if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { 118fb9: 8b 50 38 mov 0x38(%eax),%edx 118fbc: 83 fa 01 cmp $0x1,%edx 118fbf: 74 7b je 11903c <_Timer_server_Schedule_operation_method+0xbc> _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); if ( !ts->active ) { _Timer_server_Reset_interval_system_watchdog( ts ); } } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { 118fc1: 83 fa 03 cmp $0x3,%edx 118fc4: 74 0e je 118fd4 <_Timer_server_Schedule_operation_method+0x54> * critical section. We have to use the protected chain methods because * we may be interrupted by a higher priority interrupt. */ _Chain_Append( ts->insert_chain, &timer->Object.Node ); } } 118fc6: 8d 65 f4 lea -0xc(%ebp),%esp 118fc9: 5b pop %ebx 118fca: 5e pop %esi 118fcb: 5f pop %edi 118fcc: c9 leave if ( !ts->active ) { _Timer_server_Reset_tod_system_watchdog( ts ); } } _Thread_Enable_dispatch(); 118fcd: e9 82 2e 00 00 jmp 11be54 <_Thread_Enable_dispatch> 118fd2: 66 90 xchg %ax,%ax } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { /* * We have to advance the last known seconds value of the server and update * the watchdog chain accordingly. */ _ISR_Disable( level ); 118fd4: 9c pushf 118fd5: fa cli 118fd6: 8f 45 e4 popl -0x1c(%ebp) snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); 118fd9: 8b 0d c8 2a 14 00 mov 0x142ac8,%ecx last_snapshot = ts->TOD_watchdogs.last_snapshot; 118fdf: 8b 53 74 mov 0x74(%ebx),%edx 118fe2: 89 55 d4 mov %edx,-0x2c(%ebp) initialized = false; } #endif return status; } 118fe5: 8b 53 68 mov 0x68(%ebx),%edx RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 118fe8: 8d 7b 6c lea 0x6c(%ebx),%edi * the watchdog chain accordingly. */ _ISR_Disable( level ); snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); last_snapshot = ts->TOD_watchdogs.last_snapshot; if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) { 118feb: 39 fa cmp %edi,%edx 118fed: 74 21 je 119010 <_Timer_server_Schedule_operation_method+0x90> first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain ); delta_interval = first_watchdog->delta_interval; 118fef: 8b 7a 10 mov 0x10(%edx),%edi if ( snapshot > last_snapshot ) { 118ff2: 3b 4d d4 cmp -0x2c(%ebp),%ecx 118ff5: 0f 86 a1 00 00 00 jbe 11909c <_Timer_server_Schedule_operation_method+0x11c> /* * We advanced in time. */ delta = snapshot - last_snapshot; 118ffb: 89 ce mov %ecx,%esi 118ffd: 2b 75 d4 sub -0x2c(%ebp),%esi 119000: 89 75 d4 mov %esi,-0x2c(%ebp) if (delta_interval > delta) { 119003: 39 f7 cmp %esi,%edi 119005: 0f 86 9b 00 00 00 jbe 1190a6 <_Timer_server_Schedule_operation_method+0x126><== NEVER TAKEN delta_interval -= delta; 11900b: 29 f7 sub %esi,%edi * Someone put us in the past. */ delta = last_snapshot - snapshot; delta_interval += delta; } first_watchdog->delta_interval = delta_interval; 11900d: 89 7a 10 mov %edi,0x10(%edx) } ts->TOD_watchdogs.last_snapshot = snapshot; 119010: 89 4b 74 mov %ecx,0x74(%ebx) _ISR_Enable( level ); 119013: ff 75 e4 pushl -0x1c(%ebp) 119016: 9d popf _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker ); 119017: 83 ec 08 sub $0x8,%esp 11901a: 83 c0 10 add $0x10,%eax 11901d: 50 push %eax 11901e: 8d 43 68 lea 0x68(%ebx),%eax 119021: 50 push %eax 119022: e8 29 3e 00 00 call 11ce50 <_Watchdog_Insert> if ( !ts->active ) { 119027: 8a 43 7c mov 0x7c(%ebx),%al 11902a: 83 c4 10 add $0x10,%esp 11902d: 84 c0 test %al,%al 11902f: 75 95 jne 118fc6 <_Timer_server_Schedule_operation_method+0x46> _Timer_server_Reset_tod_system_watchdog( ts ); 119031: 89 d8 mov %ebx,%eax 119033: e8 30 fd ff ff call 118d68 <_Timer_server_Reset_tod_system_watchdog> 119038: eb 8c jmp 118fc6 <_Timer_server_Schedule_operation_method+0x46> 11903a: 66 90 xchg %ax,%ax if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { /* * We have to advance the last known ticks value of the server and update * the watchdog chain accordingly. */ _ISR_Disable( level ); 11903c: 9c pushf 11903d: fa cli 11903e: 8f 45 e4 popl -0x1c(%ebp) snapshot = _Watchdog_Ticks_since_boot; 119041: 8b 0d 64 2b 14 00 mov 0x142b64,%ecx last_snapshot = ts->Interval_watchdogs.last_snapshot; 119047: 8b 7b 3c mov 0x3c(%ebx),%edi initialized = false; } #endif return status; } 11904a: 8b 53 30 mov 0x30(%ebx),%edx 11904d: 8d 73 34 lea 0x34(%ebx),%esi * the watchdog chain accordingly. */ _ISR_Disable( level ); snapshot = _Watchdog_Ticks_since_boot; last_snapshot = ts->Interval_watchdogs.last_snapshot; if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) { 119050: 39 f2 cmp %esi,%edx 119052: 74 10 je 119064 <_Timer_server_Schedule_operation_method+0xe4> first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain ); /* * We assume adequate unsigned arithmetic here. */ delta = snapshot - last_snapshot; 119054: 89 ce mov %ecx,%esi 119056: 29 fe sub %edi,%esi delta_interval = first_watchdog->delta_interval; 119058: 8b 7a 10 mov 0x10(%edx),%edi if (delta_interval > delta) { 11905b: 39 fe cmp %edi,%esi 11905d: 73 39 jae 119098 <_Timer_server_Schedule_operation_method+0x118> delta_interval -= delta; 11905f: 29 f7 sub %esi,%edi } else { delta_interval = 0; } first_watchdog->delta_interval = delta_interval; 119061: 89 7a 10 mov %edi,0x10(%edx) } ts->Interval_watchdogs.last_snapshot = snapshot; 119064: 89 4b 3c mov %ecx,0x3c(%ebx) _ISR_Enable( level ); 119067: ff 75 e4 pushl -0x1c(%ebp) 11906a: 9d popf _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); 11906b: 83 ec 08 sub $0x8,%esp 11906e: 83 c0 10 add $0x10,%eax 119071: 50 push %eax 119072: 8d 43 30 lea 0x30(%ebx),%eax 119075: 50 push %eax 119076: e8 d5 3d 00 00 call 11ce50 <_Watchdog_Insert> if ( !ts->active ) { 11907b: 8a 43 7c mov 0x7c(%ebx),%al 11907e: 83 c4 10 add $0x10,%esp 119081: 84 c0 test %al,%al 119083: 0f 85 3d ff ff ff jne 118fc6 <_Timer_server_Schedule_operation_method+0x46> _Timer_server_Reset_interval_system_watchdog( ts ); 119089: 89 d8 mov %ebx,%eax 11908b: e8 88 fc ff ff call 118d18 <_Timer_server_Reset_interval_system_watchdog> 119090: e9 31 ff ff ff jmp 118fc6 <_Timer_server_Schedule_operation_method+0x46> 119095: 8d 76 00 lea 0x0(%esi),%esi delta_interval = first_watchdog->delta_interval; if (delta_interval > delta) { delta_interval -= delta; } else { delta_interval = 0; 119098: 31 ff xor %edi,%edi 11909a: eb c5 jmp 119061 <_Timer_server_Schedule_operation_method+0xe1> } } else { /* * Someone put us in the past. */ delta = last_snapshot - snapshot; 11909c: 03 7d d4 add -0x2c(%ebp),%edi delta_interval += delta; 11909f: 29 cf sub %ecx,%edi 1190a1: e9 67 ff ff ff jmp 11900d <_Timer_server_Schedule_operation_method+0x8d> */ delta = snapshot - last_snapshot; if (delta_interval > delta) { delta_interval -= delta; } else { delta_interval = 0; 1190a6: 31 ff xor %edi,%edi <== NOT EXECUTED 1190a8: e9 60 ff ff ff jmp 11900d <_Timer_server_Schedule_operation_method+0x8d><== NOT EXECUTED =============================================================================== 0010fc38 <_Timespec_Divide>: const struct timespec *lhs, const struct timespec *rhs, uint32_t *ival_percentage, uint32_t *fval_percentage ) { 10fc38: 55 push %ebp 10fc39: 89 e5 mov %esp,%ebp 10fc3b: 57 push %edi 10fc3c: 56 push %esi 10fc3d: 53 push %ebx 10fc3e: 83 ec 2c sub $0x2c,%esp 10fc41: 8b 45 08 mov 0x8(%ebp),%eax 10fc44: 8b 4d 0c mov 0xc(%ebp),%ecx /* * For math simplicity just convert the timespec to nanoseconds * in a 64-bit integer. */ left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 10fc47: 8b 38 mov (%eax),%edi left += lhs->tv_nsec; 10fc49: 8b 70 04 mov 0x4(%eax),%esi right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 10fc4c: bb 00 ca 9a 3b mov $0x3b9aca00,%ebx 10fc51: 8b 01 mov (%ecx),%eax 10fc53: f7 eb imul %ebx 10fc55: 89 45 e0 mov %eax,-0x20(%ebp) 10fc58: 89 55 e4 mov %edx,-0x1c(%ebp) right += rhs->tv_nsec; 10fc5b: 8b 41 04 mov 0x4(%ecx),%eax 10fc5e: 99 cltd 10fc5f: 01 45 e0 add %eax,-0x20(%ebp) 10fc62: 11 55 e4 adc %edx,-0x1c(%ebp) if ( right == 0 ) { 10fc65: 8b 55 e4 mov -0x1c(%ebp),%edx 10fc68: 0b 55 e0 or -0x20(%ebp),%edx 10fc6b: 74 73 je 10fce0 <_Timespec_Divide+0xa8> /* * For math simplicity just convert the timespec to nanoseconds * in a 64-bit integer. */ left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 10fc6d: 89 f8 mov %edi,%eax 10fc6f: f7 eb imul %ebx 10fc71: 89 45 d0 mov %eax,-0x30(%ebp) 10fc74: 89 55 d4 mov %edx,-0x2c(%ebp) left += lhs->tv_nsec; 10fc77: 89 f7 mov %esi,%edi 10fc79: c1 ff 1f sar $0x1f,%edi 10fc7c: 01 75 d0 add %esi,-0x30(%ebp) 10fc7f: 11 7d d4 adc %edi,-0x2c(%ebp) * Put it back in the timespec result. * * TODO: Rounding on the last digit of the fval. */ answer = (left * 100000) / right; 10fc82: 69 4d d4 a0 86 01 00 imul $0x186a0,-0x2c(%ebp),%ecx 10fc89: bb a0 86 01 00 mov $0x186a0,%ebx 10fc8e: 8b 45 d0 mov -0x30(%ebp),%eax 10fc91: f7 e3 mul %ebx 10fc93: 8d 34 11 lea (%ecx,%edx,1),%esi 10fc96: ff 75 e4 pushl -0x1c(%ebp) 10fc99: ff 75 e0 pushl -0x20(%ebp) 10fc9c: 56 push %esi 10fc9d: 50 push %eax 10fc9e: e8 29 12 01 00 call 120ecc <__udivdi3> 10fca3: 83 c4 10 add $0x10,%esp 10fca6: 89 c3 mov %eax,%ebx 10fca8: 89 d6 mov %edx,%esi *ival_percentage = answer / 1000; 10fcaa: 6a 00 push $0x0 10fcac: 68 e8 03 00 00 push $0x3e8 10fcb1: 52 push %edx 10fcb2: 50 push %eax 10fcb3: e8 14 12 01 00 call 120ecc <__udivdi3> 10fcb8: 83 c4 10 add $0x10,%esp 10fcbb: 8b 55 10 mov 0x10(%ebp),%edx 10fcbe: 89 02 mov %eax,(%edx) *fval_percentage = answer % 1000; 10fcc0: 6a 00 push $0x0 10fcc2: 68 e8 03 00 00 push $0x3e8 10fcc7: 56 push %esi 10fcc8: 53 push %ebx 10fcc9: e8 0e 13 01 00 call 120fdc <__umoddi3> 10fcce: 83 c4 10 add $0x10,%esp 10fcd1: 8b 55 14 mov 0x14(%ebp),%edx 10fcd4: 89 02 mov %eax,(%edx) } 10fcd6: 8d 65 f4 lea -0xc(%ebp),%esp 10fcd9: 5b pop %ebx 10fcda: 5e pop %esi 10fcdb: 5f pop %edi 10fcdc: c9 leave 10fcdd: c3 ret 10fcde: 66 90 xchg %ax,%ax left += lhs->tv_nsec; right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; right += rhs->tv_nsec; if ( right == 0 ) { *ival_percentage = 0; 10fce0: 8b 45 10 mov 0x10(%ebp),%eax 10fce3: c7 00 00 00 00 00 movl $0x0,(%eax) *fval_percentage = 0; 10fce9: 8b 55 14 mov 0x14(%ebp),%edx 10fcec: c7 02 00 00 00 00 movl $0x0,(%edx) answer = (left * 100000) / right; *ival_percentage = answer / 1000; *fval_percentage = answer % 1000; } 10fcf2: 8d 65 f4 lea -0xc(%ebp),%esp 10fcf5: 5b pop %ebx 10fcf6: 5e pop %esi 10fcf7: 5f pop %edi 10fcf8: c9 leave 10fcf9: c3 ret =============================================================================== 0011ff98 <_Timespec_Is_valid>: #include bool _Timespec_Is_valid( const struct timespec *time ) { 11ff98: 55 push %ebp 11ff99: 89 e5 mov %esp,%ebp 11ff9b: 8b 45 08 mov 0x8(%ebp),%eax if ( !time ) 11ff9e: 85 c0 test %eax,%eax 11ffa0: 74 1a je 11ffbc <_Timespec_Is_valid+0x24> return false; if ( time->tv_sec < 0 ) 11ffa2: 8b 10 mov (%eax),%edx 11ffa4: 85 d2 test %edx,%edx 11ffa6: 78 14 js 11ffbc <_Timespec_Is_valid+0x24> return false; if ( time->tv_nsec < 0 ) 11ffa8: 8b 40 04 mov 0x4(%eax),%eax 11ffab: 85 c0 test %eax,%eax 11ffad: 78 0d js 11ffbc <_Timespec_Is_valid+0x24> #include #include #include bool _Timespec_Is_valid( 11ffaf: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax 11ffb4: 0f 96 c0 setbe %al if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) return false; return true; } 11ffb7: c9 leave 11ffb8: c3 ret 11ffb9: 8d 76 00 lea 0x0(%esi),%esi if ( time->tv_sec < 0 ) return false; if ( time->tv_nsec < 0 ) return false; 11ffbc: 31 c0 xor %eax,%eax if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) return false; return true; } 11ffbe: c9 leave 11ffbf: c3 ret =============================================================================== 00111918 <_Timespec_To_ticks>: */ uint32_t _Timespec_To_ticks( const struct timespec *time ) { 111918: 55 push %ebp 111919: 89 e5 mov %esp,%ebp 11191b: 56 push %esi 11191c: 53 push %ebx 11191d: 8b 5d 08 mov 0x8(%ebp),%ebx uint32_t ticks; if ( (time->tv_sec == 0) && (time->tv_nsec == 0) ) 111920: 8b 33 mov (%ebx),%esi 111922: 85 f6 test %esi,%esi 111924: 75 07 jne 11192d <_Timespec_To_ticks+0x15> 111926: 8b 43 04 mov 0x4(%ebx),%eax 111929: 85 c0 test %eax,%eax 11192b: 74 37 je 111964 <_Timespec_To_ticks+0x4c> return 0; ticks = time->tv_sec * TOD_TICKS_PER_SECOND; 11192d: e8 62 17 00 00 call 113094 111932: 89 c1 mov %eax,%ecx 111934: 0f af ce imul %esi,%ecx ticks += time->tv_nsec / rtems_configuration_get_nanoseconds_per_tick(); 111937: a1 8c 3a 12 00 mov 0x123a8c,%eax 11193c: 8d 04 80 lea (%eax,%eax,4),%eax 11193f: 8d 04 80 lea (%eax,%eax,4),%eax 111942: 8d 34 80 lea (%eax,%eax,4),%esi 111945: c1 e6 03 shl $0x3,%esi 111948: 8b 43 04 mov 0x4(%ebx),%eax 11194b: 31 d2 xor %edx,%edx 11194d: f7 f6 div %esi if (ticks) 11194f: 01 c8 add %ecx,%eax 111951: 74 05 je 111958 <_Timespec_To_ticks+0x40> return ticks; return 1; } 111953: 5b pop %ebx 111954: 5e pop %esi 111955: c9 leave 111956: c3 ret 111957: 90 nop ticks += time->tv_nsec / rtems_configuration_get_nanoseconds_per_tick(); if (ticks) return ticks; return 1; 111958: b8 01 00 00 00 mov $0x1,%eax } 11195d: 5b pop %ebx 11195e: 5e pop %esi 11195f: c9 leave 111960: c3 ret 111961: 8d 76 00 lea 0x0(%esi),%esi ) { uint32_t ticks; if ( (time->tv_sec == 0) && (time->tv_nsec == 0) ) return 0; 111964: 31 c0 xor %eax,%eax if (ticks) return ticks; return 1; } 111966: 5b pop %ebx 111967: 5e pop %esi 111968: c9 leave 111969: c3 ret =============================================================================== 0010e5bc <_User_extensions_Fatal>: void _User_extensions_Fatal ( Internal_errors_Source the_source, bool is_internal, Internal_errors_t the_error ) { 10e5bc: 55 push %ebp 10e5bd: 89 e5 mov %esp,%ebp 10e5bf: 57 push %edi 10e5c0: 56 push %esi 10e5c1: 53 push %ebx 10e5c2: 83 ec 1c sub $0x1c,%esp 10e5c5: 8b 75 08 mov 0x8(%ebp),%esi 10e5c8: 8b 7d 10 mov 0x10(%ebp),%edi 10e5cb: 8a 45 0c mov 0xc(%ebp),%al the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.fatal != NULL ) (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); } } 10e5ce: 8b 1d b4 7f 12 00 mov 0x127fb4,%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); 10e5d4: 81 fb ac 7f 12 00 cmp $0x127fac,%ebx 10e5da: 74 25 je 10e601 <_User_extensions_Fatal+0x45><== NEVER TAKEN the_node = the_node->previous ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.fatal != NULL ) (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); 10e5dc: 0f b6 c0 movzbl %al,%eax 10e5df: 89 45 e4 mov %eax,-0x1c(%ebp) 10e5e2: 66 90 xchg %ax,%ax !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.fatal != NULL ) 10e5e4: 8b 43 30 mov 0x30(%ebx),%eax 10e5e7: 85 c0 test %eax,%eax 10e5e9: 74 0b je 10e5f6 <_User_extensions_Fatal+0x3a> (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); 10e5eb: 52 push %edx 10e5ec: 57 push %edi 10e5ed: ff 75 e4 pushl -0x1c(%ebp) 10e5f0: 56 push %esi 10e5f1: ff d0 call *%eax 10e5f3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { 10e5f6: 8b 5b 04 mov 0x4(%ebx),%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); 10e5f9: 81 fb ac 7f 12 00 cmp $0x127fac,%ebx 10e5ff: 75 e3 jne 10e5e4 <_User_extensions_Fatal+0x28><== ALWAYS TAKEN the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.fatal != NULL ) (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); } } 10e601: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e604: 5b pop %ebx <== NOT EXECUTED 10e605: 5e pop %esi <== NOT EXECUTED 10e606: 5f pop %edi <== NOT EXECUTED 10e607: c9 leave <== NOT EXECUTED 10e608: c3 ret <== NOT EXECUTED =============================================================================== 0010e480 <_User_extensions_Handler_initialization>: #include #include #include void _User_extensions_Handler_initialization(void) { 10e480: 55 push %ebp 10e481: 89 e5 mov %esp,%ebp 10e483: 57 push %edi 10e484: 56 push %esi 10e485: 53 push %ebx 10e486: 83 ec 1c sub $0x1c,%esp User_extensions_Control *extension; uint32_t i; uint32_t number_of_extensions; User_extensions_Table *initial_extensions; number_of_extensions = Configuration.number_of_initial_extensions; 10e489: a1 b8 3a 12 00 mov 0x123ab8,%eax 10e48e: 89 45 dc mov %eax,-0x24(%ebp) initial_extensions = Configuration.User_extension_table; 10e491: 8b 35 bc 3a 12 00 mov 0x123abc,%esi Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 10e497: c7 05 ac 7f 12 00 b0 movl $0x127fb0,0x127fac 10e49e: 7f 12 00 head->previous = NULL; 10e4a1: c7 05 b0 7f 12 00 00 movl $0x0,0x127fb0 10e4a8: 00 00 00 tail->previous = head; 10e4ab: c7 05 b4 7f 12 00 ac movl $0x127fac,0x127fb4 10e4b2: 7f 12 00 ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 10e4b5: c7 05 94 7d 12 00 98 movl $0x127d98,0x127d94 10e4bc: 7d 12 00 head->previous = NULL; 10e4bf: c7 05 98 7d 12 00 00 movl $0x0,0x127d98 10e4c6: 00 00 00 tail->previous = head; 10e4c9: c7 05 9c 7d 12 00 94 movl $0x127d94,0x127d9c 10e4d0: 7d 12 00 _Chain_Initialize_empty( &_User_extensions_List ); _Chain_Initialize_empty( &_User_extensions_Switches_list ); if ( initial_extensions ) { 10e4d3: 85 f6 test %esi,%esi 10e4d5: 74 64 je 10e53b <_User_extensions_Handler_initialization+0xbb><== NEVER TAKEN extension = (User_extensions_Control *) _Workspace_Allocate_or_fatal_error( 10e4d7: 89 c2 mov %eax,%edx 10e4d9: 8d 04 40 lea (%eax,%eax,2),%eax 10e4dc: 8d 0c 82 lea (%edx,%eax,4),%ecx 10e4df: c1 e1 02 shl $0x2,%ecx 10e4e2: 83 ec 0c sub $0xc,%esp 10e4e5: 51 push %ecx 10e4e6: 89 4d d8 mov %ecx,-0x28(%ebp) 10e4e9: e8 ce 04 00 00 call 10e9bc <_Workspace_Allocate_or_fatal_error> 10e4ee: 89 c3 mov %eax,%ebx number_of_extensions * sizeof( User_extensions_Control ) ); memset ( 10e4f0: 31 c0 xor %eax,%eax 10e4f2: 8b 4d d8 mov -0x28(%ebp),%ecx 10e4f5: 89 df mov %ebx,%edi 10e4f7: f3 aa rep stos %al,%es:(%edi) extension, 0, number_of_extensions * sizeof( User_extensions_Control ) ); for ( i = 0 ; i < number_of_extensions ; i++ ) { 10e4f9: 83 c4 10 add $0x10,%esp 10e4fc: 8b 45 dc mov -0x24(%ebp),%eax 10e4ff: 85 c0 test %eax,%eax 10e501: 74 38 je 10e53b <_User_extensions_Handler_initialization+0xbb><== NEVER TAKEN 10e503: 89 75 e4 mov %esi,-0x1c(%ebp) 10e506: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) 10e50d: 8d 76 00 lea 0x0(%esi),%esi RTEMS_INLINE_ROUTINE void _User_extensions_Add_set_with_table( User_extensions_Control *extension, const User_extensions_Table *extension_table ) { extension->Callouts = *extension_table; 10e510: 8d 7b 14 lea 0x14(%ebx),%edi 10e513: 8b 75 e4 mov -0x1c(%ebp),%esi 10e516: b9 08 00 00 00 mov $0x8,%ecx 10e51b: f3 a5 rep movsl %ds:(%esi),%es:(%edi) _User_extensions_Add_set( extension ); 10e51d: 83 ec 0c sub $0xc,%esp 10e520: 53 push %ebx 10e521: e8 46 34 00 00 call 11196c <_User_extensions_Add_set> _User_extensions_Add_set_with_table (extension, &initial_extensions[i]); extension++; 10e526: 83 c3 34 add $0x34,%ebx extension, 0, number_of_extensions * sizeof( User_extensions_Control ) ); for ( i = 0 ; i < number_of_extensions ; i++ ) { 10e529: ff 45 e0 incl -0x20(%ebp) 10e52c: 83 45 e4 20 addl $0x20,-0x1c(%ebp) 10e530: 83 c4 10 add $0x10,%esp 10e533: 8b 45 e0 mov -0x20(%ebp),%eax 10e536: 39 45 dc cmp %eax,-0x24(%ebp) 10e539: 77 d5 ja 10e510 <_User_extensions_Handler_initialization+0x90> _User_extensions_Add_set_with_table (extension, &initial_extensions[i]); extension++; } } } 10e53b: 8d 65 f4 lea -0xc(%ebp),%esp 10e53e: 5b pop %ebx 10e53f: 5e pop %esi 10e540: 5f pop %edi 10e541: c9 leave 10e542: c3 ret =============================================================================== 0010fa00 <_User_extensions_Remove_set>: #include void _User_extensions_Remove_set ( User_extensions_Control *the_extension ) { 10fa00: 55 push %ebp 10fa01: 89 e5 mov %esp,%ebp 10fa03: 53 push %ebx 10fa04: 83 ec 10 sub $0x10,%esp 10fa07: 8b 5d 08 mov 0x8(%ebp),%ebx _Chain_Extract( &the_extension->Node ); 10fa0a: 53 push %ebx 10fa0b: e8 88 d9 ff ff call 10d398 <_Chain_Extract> /* * If a switch handler is present, remove it. */ if ( the_extension->Callouts.thread_switch != NULL ) 10fa10: 83 c4 10 add $0x10,%esp 10fa13: 8b 43 24 mov 0x24(%ebx),%eax 10fa16: 85 c0 test %eax,%eax 10fa18: 74 12 je 10fa2c <_User_extensions_Remove_set+0x2c> _Chain_Extract( &the_extension->Switch.Node ); 10fa1a: 83 c3 08 add $0x8,%ebx 10fa1d: 89 5d 08 mov %ebx,0x8(%ebp) } 10fa20: 8b 5d fc mov -0x4(%ebp),%ebx 10fa23: c9 leave /* * If a switch handler is present, remove it. */ if ( the_extension->Callouts.thread_switch != NULL ) _Chain_Extract( &the_extension->Switch.Node ); 10fa24: e9 6f d9 ff ff jmp 10d398 <_Chain_Extract> 10fa29: 8d 76 00 lea 0x0(%esi),%esi } 10fa2c: 8b 5d fc mov -0x4(%ebp),%ebx 10fa2f: c9 leave 10fa30: c3 ret =============================================================================== 0010e544 <_User_extensions_Thread_begin>: #include void _User_extensions_Thread_begin ( Thread_Control *executing ) { 10e544: 55 push %ebp 10e545: 89 e5 mov %esp,%ebp 10e547: 56 push %esi 10e548: 53 push %ebx 10e549: 8b 75 08 mov 0x8(%ebp),%esi the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.fatal != NULL ) (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); } } 10e54c: 8b 1d ac 7f 12 00 mov 0x127fac,%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); 10e552: 81 fb b0 7f 12 00 cmp $0x127fb0,%ebx 10e558: 74 1c je 10e576 <_User_extensions_Thread_begin+0x32><== NEVER TAKEN 10e55a: 66 90 xchg %ax,%ax !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_begin != NULL ) 10e55c: 8b 43 28 mov 0x28(%ebx),%eax 10e55f: 85 c0 test %eax,%eax 10e561: 74 09 je 10e56c <_User_extensions_Thread_begin+0x28> (*the_extension->Callouts.thread_begin)( executing ); 10e563: 83 ec 0c sub $0xc,%esp 10e566: 56 push %esi 10e567: ff d0 call *%eax 10e569: 83 c4 10 add $0x10,%esp Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { 10e56c: 8b 1b mov (%ebx),%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); 10e56e: 81 fb b0 7f 12 00 cmp $0x127fb0,%ebx 10e574: 75 e6 jne 10e55c <_User_extensions_Thread_begin+0x18> the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_begin != NULL ) (*the_extension->Callouts.thread_begin)( executing ); } } 10e576: 8d 65 f8 lea -0x8(%ebp),%esp 10e579: 5b pop %ebx 10e57a: 5e pop %esi 10e57b: c9 leave 10e57c: c3 ret =============================================================================== 0010e60c <_User_extensions_Thread_create>: #include bool _User_extensions_Thread_create ( Thread_Control *the_thread ) { 10e60c: 55 push %ebp 10e60d: 89 e5 mov %esp,%ebp 10e60f: 56 push %esi 10e610: 53 push %ebx 10e611: 8b 75 08 mov 0x8(%ebp),%esi return false; } } return true; } 10e614: 8b 1d ac 7f 12 00 mov 0x127fac,%ebx { Chain_Node *the_node; User_extensions_Control *the_extension; bool status; for ( the_node = _Chain_First( &_User_extensions_List ); 10e61a: 81 fb b0 7f 12 00 cmp $0x127fb0,%ebx 10e620: 74 26 je 10e648 <_User_extensions_Thread_create+0x3c><== NEVER TAKEN 10e622: 66 90 xchg %ax,%ax !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_create != NULL ) { 10e624: 8b 43 14 mov 0x14(%ebx),%eax 10e627: 85 c0 test %eax,%eax 10e629: 74 13 je 10e63e <_User_extensions_Thread_create+0x32> status = (*the_extension->Callouts.thread_create)( 10e62b: 83 ec 08 sub $0x8,%esp 10e62e: 56 push %esi 10e62f: ff 35 38 83 12 00 pushl 0x128338 10e635: ff d0 call *%eax _Thread_Executing, the_thread ); if ( !status ) 10e637: 83 c4 10 add $0x10,%esp 10e63a: 84 c0 test %al,%al 10e63c: 74 16 je 10e654 <_User_extensions_Thread_create+0x48> User_extensions_Control *the_extension; bool status; for ( the_node = _Chain_First( &_User_extensions_List ); !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { 10e63e: 8b 1b mov (%ebx),%ebx { Chain_Node *the_node; User_extensions_Control *the_extension; bool status; for ( the_node = _Chain_First( &_User_extensions_List ); 10e640: 81 fb b0 7f 12 00 cmp $0x127fb0,%ebx 10e646: 75 dc jne 10e624 <_User_extensions_Thread_create+0x18> if ( !status ) return false; } } return true; 10e648: b0 01 mov $0x1,%al } 10e64a: 8d 65 f8 lea -0x8(%ebp),%esp 10e64d: 5b pop %ebx 10e64e: 5e pop %esi 10e64f: c9 leave 10e650: c3 ret 10e651: 8d 76 00 lea 0x0(%esi),%esi status = (*the_extension->Callouts.thread_create)( _Thread_Executing, the_thread ); if ( !status ) return false; 10e654: 31 c0 xor %eax,%eax } } return true; } 10e656: 8d 65 f8 lea -0x8(%ebp),%esp 10e659: 5b pop %ebx 10e65a: 5e pop %esi 10e65b: c9 leave 10e65c: c3 ret =============================================================================== 0010e660 <_User_extensions_Thread_delete>: #include void _User_extensions_Thread_delete ( Thread_Control *the_thread ) { 10e660: 55 push %ebp 10e661: 89 e5 mov %esp,%ebp 10e663: 56 push %esi 10e664: 53 push %ebx 10e665: 8b 75 08 mov 0x8(%ebp),%esi (*the_extension->Callouts.thread_delete)( _Thread_Executing, the_thread ); } } 10e668: 8b 1d b4 7f 12 00 mov 0x127fb4,%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); 10e66e: 81 fb ac 7f 12 00 cmp $0x127fac,%ebx 10e674: 74 23 je 10e699 <_User_extensions_Thread_delete+0x39><== NEVER TAKEN 10e676: 66 90 xchg %ax,%ax !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_delete != NULL ) 10e678: 8b 43 20 mov 0x20(%ebx),%eax 10e67b: 85 c0 test %eax,%eax 10e67d: 74 0f je 10e68e <_User_extensions_Thread_delete+0x2e> (*the_extension->Callouts.thread_delete)( 10e67f: 83 ec 08 sub $0x8,%esp 10e682: 56 push %esi 10e683: ff 35 38 83 12 00 pushl 0x128338 10e689: ff d0 call *%eax 10e68b: 83 c4 10 add $0x10,%esp Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { 10e68e: 8b 5b 04 mov 0x4(%ebx),%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); 10e691: 81 fb ac 7f 12 00 cmp $0x127fac,%ebx 10e697: 75 df jne 10e678 <_User_extensions_Thread_delete+0x18> (*the_extension->Callouts.thread_delete)( _Thread_Executing, the_thread ); } } 10e699: 8d 65 f8 lea -0x8(%ebp),%esp 10e69c: 5b pop %ebx 10e69d: 5e pop %esi 10e69e: c9 leave 10e69f: c3 ret =============================================================================== 0010e580 <_User_extensions_Thread_exitted>: void _User_extensions_Thread_exitted ( Thread_Control *executing ) { 10e580: 55 push %ebp 10e581: 89 e5 mov %esp,%ebp 10e583: 56 push %esi 10e584: 53 push %ebx 10e585: 8b 75 08 mov 0x8(%ebp),%esi the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.fatal != NULL ) (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); } } 10e588: 8b 1d b4 7f 12 00 mov 0x127fb4,%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); 10e58e: 81 fb ac 7f 12 00 cmp $0x127fac,%ebx 10e594: 74 1d je 10e5b3 <_User_extensions_Thread_exitted+0x33><== NEVER TAKEN 10e596: 66 90 xchg %ax,%ax !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_exitted != NULL ) 10e598: 8b 43 2c mov 0x2c(%ebx),%eax 10e59b: 85 c0 test %eax,%eax 10e59d: 74 09 je 10e5a8 <_User_extensions_Thread_exitted+0x28> (*the_extension->Callouts.thread_exitted)( executing ); 10e59f: 83 ec 0c sub $0xc,%esp 10e5a2: 56 push %esi 10e5a3: ff d0 call *%eax 10e5a5: 83 c4 10 add $0x10,%esp Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { 10e5a8: 8b 5b 04 mov 0x4(%ebx),%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); 10e5ab: 81 fb ac 7f 12 00 cmp $0x127fac,%ebx 10e5b1: 75 e5 jne 10e598 <_User_extensions_Thread_exitted+0x18> the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_exitted != NULL ) (*the_extension->Callouts.thread_exitted)( executing ); } } 10e5b3: 8d 65 f8 lea -0x8(%ebp),%esp 10e5b6: 5b pop %ebx 10e5b7: 5e pop %esi 10e5b8: c9 leave 10e5b9: c3 ret =============================================================================== 0010f264 <_User_extensions_Thread_restart>: #include void _User_extensions_Thread_restart ( Thread_Control *the_thread ) { 10f264: 55 push %ebp 10f265: 89 e5 mov %esp,%ebp 10f267: 56 push %esi 10f268: 53 push %ebx 10f269: 8b 75 08 mov 0x8(%ebp),%esi (*the_extension->Callouts.thread_restart)( _Thread_Executing, the_thread ); } } 10f26c: 8b 1d cc a2 12 00 mov 0x12a2cc,%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); 10f272: 81 fb d0 a2 12 00 cmp $0x12a2d0,%ebx 10f278: 74 22 je 10f29c <_User_extensions_Thread_restart+0x38><== NEVER TAKEN 10f27a: 66 90 xchg %ax,%ax !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_restart != NULL ) 10f27c: 8b 43 1c mov 0x1c(%ebx),%eax 10f27f: 85 c0 test %eax,%eax 10f281: 74 0f je 10f292 <_User_extensions_Thread_restart+0x2e> (*the_extension->Callouts.thread_restart)( 10f283: 83 ec 08 sub $0x8,%esp 10f286: 56 push %esi 10f287: ff 35 58 a6 12 00 pushl 0x12a658 10f28d: ff d0 call *%eax 10f28f: 83 c4 10 add $0x10,%esp Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { 10f292: 8b 1b mov (%ebx),%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); 10f294: 81 fb d0 a2 12 00 cmp $0x12a2d0,%ebx 10f29a: 75 e0 jne 10f27c <_User_extensions_Thread_restart+0x18> (*the_extension->Callouts.thread_restart)( _Thread_Executing, the_thread ); } } 10f29c: 8d 65 f8 lea -0x8(%ebp),%esp 10f29f: 5b pop %ebx 10f2a0: 5e pop %esi 10f2a1: c9 leave 10f2a2: c3 ret =============================================================================== 0010e6a0 <_User_extensions_Thread_start>: #include void _User_extensions_Thread_start ( Thread_Control *the_thread ) { 10e6a0: 55 push %ebp 10e6a1: 89 e5 mov %esp,%ebp 10e6a3: 56 push %esi 10e6a4: 53 push %ebx 10e6a5: 8b 75 08 mov 0x8(%ebp),%esi (*the_extension->Callouts.thread_start)( _Thread_Executing, the_thread ); } } 10e6a8: 8b 1d ac 7f 12 00 mov 0x127fac,%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); 10e6ae: 81 fb b0 7f 12 00 cmp $0x127fb0,%ebx 10e6b4: 74 22 je 10e6d8 <_User_extensions_Thread_start+0x38><== NEVER TAKEN 10e6b6: 66 90 xchg %ax,%ax !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_start != NULL ) 10e6b8: 8b 43 18 mov 0x18(%ebx),%eax 10e6bb: 85 c0 test %eax,%eax 10e6bd: 74 0f je 10e6ce <_User_extensions_Thread_start+0x2e> (*the_extension->Callouts.thread_start)( 10e6bf: 83 ec 08 sub $0x8,%esp 10e6c2: 56 push %esi 10e6c3: ff 35 38 83 12 00 pushl 0x128338 10e6c9: ff d0 call *%eax 10e6cb: 83 c4 10 add $0x10,%esp Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { 10e6ce: 8b 1b mov (%ebx),%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); 10e6d0: 81 fb b0 7f 12 00 cmp $0x127fb0,%ebx 10e6d6: 75 e0 jne 10e6b8 <_User_extensions_Thread_start+0x18> (*the_extension->Callouts.thread_start)( _Thread_Executing, the_thread ); } } 10e6d8: 8d 65 f8 lea -0x8(%ebp),%esp 10e6db: 5b pop %ebx 10e6dc: 5e pop %esi 10e6dd: c9 leave 10e6de: c3 ret =============================================================================== 0010e6e0 <_User_extensions_Thread_switch>: void _User_extensions_Thread_switch ( Thread_Control *executing, Thread_Control *heir ) { 10e6e0: 55 push %ebp 10e6e1: 89 e5 mov %esp,%ebp 10e6e3: 57 push %edi 10e6e4: 56 push %esi 10e6e5: 53 push %ebx 10e6e6: 83 ec 0c sub $0xc,%esp 10e6e9: 8b 7d 08 mov 0x8(%ebp),%edi 10e6ec: 8b 75 0c mov 0xc(%ebp),%esi the_extension_switch = (User_extensions_Switch_control *) the_node; (*the_extension_switch->thread_switch)( executing, heir ); } } 10e6ef: 8b 1d 94 7d 12 00 mov 0x127d94,%ebx ) { Chain_Node *the_node; User_extensions_Switch_control *the_extension_switch; for ( the_node = _Chain_First( &_User_extensions_Switches_list ); 10e6f5: 81 fb 98 7d 12 00 cmp $0x127d98,%ebx 10e6fb: 74 18 je 10e715 <_User_extensions_Thread_switch+0x35><== NEVER TAKEN 10e6fd: 8d 76 00 lea 0x0(%esi),%esi !_Chain_Is_tail( &_User_extensions_Switches_list, the_node ) ; the_node = the_node->next ) { the_extension_switch = (User_extensions_Switch_control *) the_node; (*the_extension_switch->thread_switch)( executing, heir ); 10e700: 83 ec 08 sub $0x8,%esp 10e703: 56 push %esi 10e704: 57 push %edi 10e705: ff 53 08 call *0x8(%ebx) Chain_Node *the_node; User_extensions_Switch_control *the_extension_switch; for ( the_node = _Chain_First( &_User_extensions_Switches_list ); !_Chain_Is_tail( &_User_extensions_Switches_list, the_node ) ; the_node = the_node->next ) { 10e708: 8b 1b mov (%ebx),%ebx ) { Chain_Node *the_node; User_extensions_Switch_control *the_extension_switch; for ( the_node = _Chain_First( &_User_extensions_Switches_list ); 10e70a: 83 c4 10 add $0x10,%esp 10e70d: 81 fb 98 7d 12 00 cmp $0x127d98,%ebx 10e713: 75 eb jne 10e700 <_User_extensions_Thread_switch+0x20> the_extension_switch = (User_extensions_Switch_control *) the_node; (*the_extension_switch->thread_switch)( executing, heir ); } } 10e715: 8d 65 f4 lea -0xc(%ebp),%esp 10e718: 5b pop %ebx 10e719: 5e pop %esi 10e71a: 5f pop %edi 10e71b: c9 leave 10e71c: c3 ret =============================================================================== 00110018 <_Watchdog_Adjust>: void _Watchdog_Adjust( Chain_Control *header, Watchdog_Adjust_directions direction, Watchdog_Interval units ) { 110018: 55 push %ebp 110019: 89 e5 mov %esp,%ebp 11001b: 57 push %edi 11001c: 56 push %esi 11001d: 53 push %ebx 11001e: 83 ec 1c sub $0x1c,%esp 110021: 8b 75 08 mov 0x8(%ebp),%esi 110024: 8b 4d 0c mov 0xc(%ebp),%ecx 110027: 8b 5d 10 mov 0x10(%ebp),%ebx ISR_Level level; _ISR_Disable( level ); 11002a: 9c pushf 11002b: fa cli 11002c: 58 pop %eax } } _ISR_Enable( level ); } 11002d: 8b 16 mov (%esi),%edx RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 11002f: 8d 7e 04 lea 0x4(%esi),%edi 110032: 89 7d e4 mov %edi,-0x1c(%ebp) * hence the compiler must not assume *header to remain * unmodified across that call. * * Till Straumann, 7/2003 */ if ( !_Chain_Is_empty( header ) ) { 110035: 39 fa cmp %edi,%edx 110037: 74 3d je 110076 <_Watchdog_Adjust+0x5e> switch ( direction ) { 110039: 85 c9 test %ecx,%ecx 11003b: 75 43 jne 110080 <_Watchdog_Adjust+0x68> case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; break; case WATCHDOG_FORWARD: while ( units ) { 11003d: 85 db test %ebx,%ebx 11003f: 74 35 je 110076 <_Watchdog_Adjust+0x5e> <== NEVER TAKEN if ( units < _Watchdog_First( header )->delta_interval ) { 110041: 8b 7a 10 mov 0x10(%edx),%edi 110044: 39 fb cmp %edi,%ebx 110046: 73 0f jae 110057 <_Watchdog_Adjust+0x3f> <== ALWAYS TAKEN 110048: eb 3e jmp 110088 <_Watchdog_Adjust+0x70> <== NOT EXECUTED 11004a: 66 90 xchg %ax,%ax <== NOT EXECUTED switch ( direction ) { case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; break; case WATCHDOG_FORWARD: while ( units ) { 11004c: 29 fb sub %edi,%ebx 11004e: 74 26 je 110076 <_Watchdog_Adjust+0x5e> <== NEVER TAKEN if ( units < _Watchdog_First( header )->delta_interval ) { 110050: 8b 7a 10 mov 0x10(%edx),%edi 110053: 39 df cmp %ebx,%edi 110055: 77 31 ja 110088 <_Watchdog_Adjust+0x70> _Watchdog_First( header )->delta_interval -= units; break; } else { units -= _Watchdog_First( header )->delta_interval; _Watchdog_First( header )->delta_interval = 1; 110057: c7 42 10 01 00 00 00 movl $0x1,0x10(%edx) _ISR_Enable( level ); 11005e: 50 push %eax 11005f: 9d popf _Watchdog_Tickle( header ); 110060: 83 ec 0c sub $0xc,%esp 110063: 56 push %esi 110064: e8 d3 01 00 00 call 11023c <_Watchdog_Tickle> _ISR_Disable( level ); 110069: 9c pushf 11006a: fa cli 11006b: 58 pop %eax } } _ISR_Enable( level ); } 11006c: 8b 16 mov (%esi),%edx _Watchdog_Tickle( header ); _ISR_Disable( level ); if ( _Chain_Is_empty( header ) ) 11006e: 83 c4 10 add $0x10,%esp 110071: 39 55 e4 cmp %edx,-0x1c(%ebp) 110074: 75 d6 jne 11004c <_Watchdog_Adjust+0x34> } break; } } _ISR_Enable( level ); 110076: 50 push %eax 110077: 9d popf } 110078: 8d 65 f4 lea -0xc(%ebp),%esp 11007b: 5b pop %ebx 11007c: 5e pop %esi 11007d: 5f pop %edi 11007e: c9 leave 11007f: c3 ret * unmodified across that call. * * Till Straumann, 7/2003 */ if ( !_Chain_Is_empty( header ) ) { switch ( direction ) { 110080: 49 dec %ecx 110081: 75 f3 jne 110076 <_Watchdog_Adjust+0x5e> <== NEVER TAKEN case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; 110083: 01 5a 10 add %ebx,0x10(%edx) break; 110086: eb ee jmp 110076 <_Watchdog_Adjust+0x5e> case WATCHDOG_FORWARD: while ( units ) { if ( units < _Watchdog_First( header )->delta_interval ) { _Watchdog_First( header )->delta_interval -= units; 110088: 29 df sub %ebx,%edi 11008a: 89 7a 10 mov %edi,0x10(%edx) break; 11008d: eb e7 jmp 110076 <_Watchdog_Adjust+0x5e> =============================================================================== 0010e720 <_Watchdog_Insert>: void _Watchdog_Insert( Chain_Control *header, Watchdog_Control *the_watchdog ) { 10e720: 55 push %ebp 10e721: 89 e5 mov %esp,%ebp 10e723: 57 push %edi 10e724: 56 push %esi 10e725: 53 push %ebx 10e726: 83 ec 04 sub $0x4,%esp 10e729: 8b 5d 0c mov 0xc(%ebp),%ebx Watchdog_Control *after; uint32_t insert_isr_nest_level; Watchdog_Interval delta_interval; insert_isr_nest_level = _ISR_Nest_level; 10e72c: 8b 3d 34 83 12 00 mov 0x128334,%edi _ISR_Disable( level ); 10e732: 9c pushf 10e733: fa cli 10e734: 8f 45 f0 popl -0x10(%ebp) /* * Check to see if the watchdog has just been inserted by a * higher priority interrupt. If so, abandon this insert. */ if ( the_watchdog->state != WATCHDOG_INACTIVE ) { 10e737: 8b 43 08 mov 0x8(%ebx),%eax 10e73a: 85 c0 test %eax,%eax 10e73c: 0f 85 9e 00 00 00 jne 10e7e0 <_Watchdog_Insert+0xc0> _ISR_Enable( level ); return; } the_watchdog->state = WATCHDOG_BEING_INSERTED; 10e742: c7 43 08 01 00 00 00 movl $0x1,0x8(%ebx) _Watchdog_Sync_count++; 10e749: a1 c0 7e 12 00 mov 0x127ec0,%eax 10e74e: 40 inc %eax 10e74f: a3 c0 7e 12 00 mov %eax,0x127ec0 restart: delta_interval = the_watchdog->initial; 10e754: 8b 43 0c mov 0xc(%ebx),%eax RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First( Chain_Control *header ) { return ( (Watchdog_Control *) _Chain_First( header ) ); 10e757: 8b 4d 08 mov 0x8(%ebp),%ecx 10e75a: 8b 11 mov (%ecx),%edx for ( after = _Watchdog_First( header ) ; ; after = _Watchdog_Next( after ) ) { if ( delta_interval == 0 || !_Watchdog_Next( after ) ) 10e75c: 85 c0 test %eax,%eax 10e75e: 74 5d je 10e7bd <_Watchdog_Insert+0x9d> 10e760: 8b 32 mov (%edx),%esi 10e762: 85 f6 test %esi,%esi 10e764: 74 57 je 10e7bd <_Watchdog_Insert+0x9d> break; if ( delta_interval < after->delta_interval ) { 10e766: 8b 4a 10 mov 0x10(%edx),%ecx 10e769: 39 c8 cmp %ecx,%eax 10e76b: 73 22 jae 10e78f <_Watchdog_Insert+0x6f> 10e76d: eb 49 jmp 10e7b8 <_Watchdog_Insert+0x98> 10e76f: 90 nop if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { goto exit_insert; } if ( _Watchdog_Sync_level > insert_isr_nest_level ) { 10e770: 8b 35 44 7e 12 00 mov 0x127e44,%esi 10e776: 39 f7 cmp %esi,%edi 10e778: 72 72 jb 10e7ec <_Watchdog_Insert+0xcc> if ( delta_interval < after->delta_interval ) { after->delta_interval -= delta_interval; break; } delta_interval -= after->delta_interval; 10e77a: 29 c8 sub %ecx,%eax exit_insert: _Watchdog_Sync_level = insert_isr_nest_level; _Watchdog_Sync_count--; _ISR_Enable( level ); } 10e77c: 8b 12 mov (%edx),%edx for ( after = _Watchdog_First( header ) ; ; after = _Watchdog_Next( after ) ) { if ( delta_interval == 0 || !_Watchdog_Next( after ) ) 10e77e: 85 c0 test %eax,%eax 10e780: 74 3b je 10e7bd <_Watchdog_Insert+0x9d> 10e782: 8b 0a mov (%edx),%ecx 10e784: 85 c9 test %ecx,%ecx 10e786: 74 35 je 10e7bd <_Watchdog_Insert+0x9d> break; if ( delta_interval < after->delta_interval ) { 10e788: 8b 4a 10 mov 0x10(%edx),%ecx 10e78b: 39 c1 cmp %eax,%ecx 10e78d: 77 29 ja 10e7b8 <_Watchdog_Insert+0x98> break; } delta_interval -= after->delta_interval; _ISR_Flash( level ); 10e78f: ff 75 f0 pushl -0x10(%ebp) 10e792: 9d popf 10e793: fa cli if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { 10e794: 83 7b 08 01 cmpl $0x1,0x8(%ebx) 10e798: 74 d6 je 10e770 <_Watchdog_Insert+0x50> _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node ); the_watchdog->start_time = _Watchdog_Ticks_since_boot; exit_insert: _Watchdog_Sync_level = insert_isr_nest_level; 10e79a: 89 3d 44 7e 12 00 mov %edi,0x127e44 _Watchdog_Sync_count--; 10e7a0: a1 c0 7e 12 00 mov 0x127ec0,%eax 10e7a5: 48 dec %eax 10e7a6: a3 c0 7e 12 00 mov %eax,0x127ec0 _ISR_Enable( level ); 10e7ab: ff 75 f0 pushl -0x10(%ebp) 10e7ae: 9d popf } 10e7af: 58 pop %eax 10e7b0: 5b pop %ebx 10e7b1: 5e pop %esi 10e7b2: 5f pop %edi 10e7b3: c9 leave 10e7b4: c3 ret 10e7b5: 8d 76 00 lea 0x0(%esi),%esi if ( delta_interval == 0 || !_Watchdog_Next( after ) ) break; if ( delta_interval < after->delta_interval ) { after->delta_interval -= delta_interval; 10e7b8: 29 c1 sub %eax,%ecx 10e7ba: 89 4a 10 mov %ecx,0x10(%edx) RTEMS_INLINE_ROUTINE void _Watchdog_Activate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_ACTIVE; 10e7bd: c7 43 08 02 00 00 00 movl $0x2,0x8(%ebx) } } _Watchdog_Activate( the_watchdog ); the_watchdog->delta_interval = delta_interval; 10e7c4: 89 43 10 mov %eax,0x10(%ebx) _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node ); 10e7c7: 8b 42 04 mov 0x4(%edx),%eax Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 10e7ca: 89 43 04 mov %eax,0x4(%ebx) before_node = after_node->next; 10e7cd: 8b 10 mov (%eax),%edx after_node->next = the_node; 10e7cf: 89 18 mov %ebx,(%eax) the_node->next = before_node; 10e7d1: 89 13 mov %edx,(%ebx) before_node->previous = the_node; 10e7d3: 89 5a 04 mov %ebx,0x4(%edx) the_watchdog->start_time = _Watchdog_Ticks_since_boot; 10e7d6: a1 c4 7e 12 00 mov 0x127ec4,%eax 10e7db: 89 43 14 mov %eax,0x14(%ebx) 10e7de: eb ba jmp 10e79a <_Watchdog_Insert+0x7a> * Check to see if the watchdog has just been inserted by a * higher priority interrupt. If so, abandon this insert. */ if ( the_watchdog->state != WATCHDOG_INACTIVE ) { _ISR_Enable( level ); 10e7e0: ff 75 f0 pushl -0x10(%ebp) 10e7e3: 9d popf exit_insert: _Watchdog_Sync_level = insert_isr_nest_level; _Watchdog_Sync_count--; _ISR_Enable( level ); } 10e7e4: 58 pop %eax 10e7e5: 5b pop %ebx 10e7e6: 5e pop %esi 10e7e7: 5f pop %edi 10e7e8: c9 leave 10e7e9: c3 ret 10e7ea: 66 90 xchg %ax,%ax if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { goto exit_insert; } if ( _Watchdog_Sync_level > insert_isr_nest_level ) { _Watchdog_Sync_level = insert_isr_nest_level; 10e7ec: 89 3d 44 7e 12 00 mov %edi,0x127e44 goto restart; 10e7f2: e9 5d ff ff ff jmp 10e754 <_Watchdog_Insert+0x34> =============================================================================== 0010e860 <_Watchdog_Remove>: */ Watchdog_States _Watchdog_Remove( Watchdog_Control *the_watchdog ) { 10e860: 55 push %ebp 10e861: 89 e5 mov %esp,%ebp 10e863: 56 push %esi 10e864: 53 push %ebx 10e865: 8b 55 08 mov 0x8(%ebp),%edx ISR_Level level; Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); 10e868: 9c pushf 10e869: fa cli 10e86a: 59 pop %ecx previous_state = the_watchdog->state; 10e86b: 8b 42 08 mov 0x8(%edx),%eax switch ( previous_state ) { 10e86e: 83 f8 01 cmp $0x1,%eax 10e871: 74 4d je 10e8c0 <_Watchdog_Remove+0x60> 10e873: 73 0f jae 10e884 <_Watchdog_Remove+0x24> _Watchdog_Sync_level = _ISR_Nest_level; _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 10e875: 8b 1d c4 7e 12 00 mov 0x127ec4,%ebx 10e87b: 89 5a 18 mov %ebx,0x18(%edx) _ISR_Enable( level ); 10e87e: 51 push %ecx 10e87f: 9d popf return( previous_state ); } 10e880: 5b pop %ebx 10e881: 5e pop %esi 10e882: c9 leave 10e883: c3 ret Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); previous_state = the_watchdog->state; switch ( previous_state ) { 10e884: 83 f8 03 cmp $0x3,%eax 10e887: 77 ec ja 10e875 <_Watchdog_Remove+0x15> <== NEVER TAKEN break; case WATCHDOG_ACTIVE: case WATCHDOG_REMOVE_IT: the_watchdog->state = WATCHDOG_INACTIVE; 10e889: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx) } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; _ISR_Enable( level ); return( previous_state ); } 10e890: 8b 1a mov (%edx),%ebx case WATCHDOG_REMOVE_IT: the_watchdog->state = WATCHDOG_INACTIVE; next_watchdog = _Watchdog_Next( the_watchdog ); if ( _Watchdog_Next(next_watchdog) ) 10e892: 8b 33 mov (%ebx),%esi 10e894: 85 f6 test %esi,%esi 10e896: 74 06 je 10e89e <_Watchdog_Remove+0x3e> next_watchdog->delta_interval += the_watchdog->delta_interval; 10e898: 8b 72 10 mov 0x10(%edx),%esi 10e89b: 01 73 10 add %esi,0x10(%ebx) if ( _Watchdog_Sync_count ) 10e89e: 8b 35 c0 7e 12 00 mov 0x127ec0,%esi 10e8a4: 85 f6 test %esi,%esi 10e8a6: 74 0c je 10e8b4 <_Watchdog_Remove+0x54> _Watchdog_Sync_level = _ISR_Nest_level; 10e8a8: 8b 35 34 83 12 00 mov 0x128334,%esi 10e8ae: 89 35 44 7e 12 00 mov %esi,0x127e44 { Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; 10e8b4: 8b 72 04 mov 0x4(%edx),%esi next->previous = previous; 10e8b7: 89 73 04 mov %esi,0x4(%ebx) previous->next = next; 10e8ba: 89 1e mov %ebx,(%esi) 10e8bc: eb b7 jmp 10e875 <_Watchdog_Remove+0x15> 10e8be: 66 90 xchg %ax,%ax /* * It is not actually on the chain so just change the state and * the Insert operation we interrupted will be aborted. */ the_watchdog->state = WATCHDOG_INACTIVE; 10e8c0: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx) break; 10e8c7: eb ac jmp 10e875 <_Watchdog_Remove+0x15> =============================================================================== 0010fc0c <_Watchdog_Report>: void _Watchdog_Report( const char *name, Watchdog_Control *watch ) { 10fc0c: 55 push %ebp 10fc0d: 89 e5 mov %esp,%ebp 10fc0f: 57 push %edi 10fc10: 56 push %esi 10fc11: 53 push %ebx 10fc12: 83 ec 2c sub $0x2c,%esp 10fc15: 8b 55 08 mov 0x8(%ebp),%edx 10fc18: 8b 45 0c mov 0xc(%ebp),%eax printk( 10fc1b: 8b 78 24 mov 0x24(%eax),%edi 10fc1e: 8b 70 20 mov 0x20(%eax),%esi 10fc21: 8b 58 1c mov 0x1c(%eax),%ebx 10fc24: 8b 48 0c mov 0xc(%eax),%ecx 10fc27: 89 4d d4 mov %ecx,-0x2c(%ebp) 10fc2a: 8b 48 10 mov 0x10(%eax),%ecx 10fc2d: 89 4d e4 mov %ecx,-0x1c(%ebp) 10fc30: 85 d2 test %edx,%edx 10fc32: 74 2c je 10fc60 <_Watchdog_Report+0x54> 10fc34: b9 83 34 12 00 mov $0x123483,%ecx 10fc39: 83 ec 0c sub $0xc,%esp 10fc3c: 57 push %edi 10fc3d: 56 push %esi 10fc3e: 53 push %ebx 10fc3f: 50 push %eax 10fc40: ff 75 d4 pushl -0x2c(%ebp) 10fc43: ff 75 e4 pushl -0x1c(%ebp) 10fc46: 51 push %ecx 10fc47: 52 push %edx 10fc48: 68 d6 3e 12 00 push $0x123ed6 10fc4d: e8 46 9e ff ff call 109a98 10fc52: 83 c4 30 add $0x30,%esp watch, watch->routine, watch->id, watch->user_data ); } 10fc55: 8d 65 f4 lea -0xc(%ebp),%esp 10fc58: 5b pop %ebx 10fc59: 5e pop %esi 10fc5a: 5f pop %edi 10fc5b: c9 leave 10fc5c: c3 ret 10fc5d: 8d 76 00 lea 0x0(%esi),%esi void _Watchdog_Report( const char *name, Watchdog_Control *watch ) { printk( 10fc60: b9 49 3d 12 00 mov $0x123d49,%ecx 10fc65: 89 ca mov %ecx,%edx 10fc67: eb d0 jmp 10fc39 <_Watchdog_Report+0x2d> =============================================================================== 0010fb9c <_Watchdog_Report_chain>: void _Watchdog_Report_chain( const char *name, Chain_Control *header ) { 10fb9c: 55 push %ebp 10fb9d: 89 e5 mov %esp,%ebp 10fb9f: 57 push %edi 10fba0: 56 push %esi 10fba1: 53 push %ebx 10fba2: 83 ec 20 sub $0x20,%esp 10fba5: 8b 7d 08 mov 0x8(%ebp),%edi 10fba8: 8b 75 0c mov 0xc(%ebp),%esi ISR_Level level; Chain_Node *node; _ISR_Disable( level ); 10fbab: 9c pushf 10fbac: fa cli 10fbad: 8f 45 e4 popl -0x1c(%ebp) printk( "Watchdog Chain: %s %p\n", name, header ); 10fbb0: 56 push %esi 10fbb1: 57 push %edi 10fbb2: 68 a0 3e 12 00 push $0x123ea0 10fbb7: e8 dc 9e ff ff call 109a98 printk( "== end of %s \n", name ); } else { printk( "Chain is empty\n" ); } _ISR_Enable( level ); } 10fbbc: 8b 1e mov (%esi),%ebx RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 10fbbe: 83 c6 04 add $0x4,%esi ISR_Level level; Chain_Node *node; _ISR_Disable( level ); printk( "Watchdog Chain: %s %p\n", name, header ); if ( !_Chain_Is_empty( header ) ) { 10fbc1: 83 c4 10 add $0x10,%esp 10fbc4: 39 f3 cmp %esi,%ebx 10fbc6: 74 31 je 10fbf9 <_Watchdog_Report_chain+0x5d> node != _Chain_Tail(header) ; node = node->next ) { Watchdog_Control *watch = (Watchdog_Control *) node; _Watchdog_Report( NULL, watch ); 10fbc8: 83 ec 08 sub $0x8,%esp 10fbcb: 53 push %ebx 10fbcc: 6a 00 push $0x0 10fbce: e8 39 00 00 00 call 10fc0c <_Watchdog_Report> _ISR_Disable( level ); printk( "Watchdog Chain: %s %p\n", name, header ); if ( !_Chain_Is_empty( header ) ) { for ( node = _Chain_First( header ) ; node != _Chain_Tail(header) ; node = node->next ) 10fbd3: 8b 1b mov (%ebx),%ebx Chain_Node *node; _ISR_Disable( level ); printk( "Watchdog Chain: %s %p\n", name, header ); if ( !_Chain_Is_empty( header ) ) { for ( node = _Chain_First( header ) ; 10fbd5: 83 c4 10 add $0x10,%esp 10fbd8: 39 f3 cmp %esi,%ebx 10fbda: 75 ec jne 10fbc8 <_Watchdog_Report_chain+0x2c><== NEVER TAKEN { Watchdog_Control *watch = (Watchdog_Control *) node; _Watchdog_Report( NULL, watch ); } printk( "== end of %s \n", name ); 10fbdc: 83 ec 08 sub $0x8,%esp 10fbdf: 57 push %edi 10fbe0: 68 b7 3e 12 00 push $0x123eb7 10fbe5: e8 ae 9e ff ff call 109a98 10fbea: 83 c4 10 add $0x10,%esp } else { printk( "Chain is empty\n" ); } _ISR_Enable( level ); 10fbed: ff 75 e4 pushl -0x1c(%ebp) 10fbf0: 9d popf } 10fbf1: 8d 65 f4 lea -0xc(%ebp),%esp 10fbf4: 5b pop %ebx 10fbf5: 5e pop %esi 10fbf6: 5f pop %edi 10fbf7: c9 leave 10fbf8: c3 ret _Watchdog_Report( NULL, watch ); } printk( "== end of %s \n", name ); } else { printk( "Chain is empty\n" ); 10fbf9: 83 ec 0c sub $0xc,%esp 10fbfc: 68 c6 3e 12 00 push $0x123ec6 10fc01: e8 92 9e ff ff call 109a98 10fc06: 83 c4 10 add $0x10,%esp 10fc09: eb e2 jmp 10fbed <_Watchdog_Report_chain+0x51> =============================================================================== 0010e8cc <_Watchdog_Tickle>: */ void _Watchdog_Tickle( Chain_Control *header ) { 10e8cc: 55 push %ebp 10e8cd: 89 e5 mov %esp,%ebp 10e8cf: 57 push %edi 10e8d0: 56 push %esi 10e8d1: 53 push %ebx 10e8d2: 83 ec 1c sub $0x1c,%esp 10e8d5: 8b 7d 08 mov 0x8(%ebp),%edi * See the comment in watchdoginsert.c and watchdogadjust.c * about why it's safe not to declare header a pointer to * volatile data - till, 2003/7 */ _ISR_Disable( level ); 10e8d8: 9c pushf 10e8d9: fa cli 10e8da: 5e pop %esi } while ( !_Chain_Is_empty( header ) && (the_watchdog->delta_interval == 0) ); leave: _ISR_Enable(level); } 10e8db: 8b 1f mov (%edi),%ebx RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 10e8dd: 8d 47 04 lea 0x4(%edi),%eax 10e8e0: 89 45 e4 mov %eax,-0x1c(%ebp) * volatile data - till, 2003/7 */ _ISR_Disable( level ); if ( _Chain_Is_empty( header ) ) 10e8e3: 39 c3 cmp %eax,%ebx 10e8e5: 74 11 je 10e8f8 <_Watchdog_Tickle+0x2c> * to be inserted has already had its delta_interval adjusted to 0, and * so is added to the head of the chain with a delta_interval of 0. * * Steven Johnson - 12/2005 (gcc-3.2.3 -O3 on powerpc) */ if (the_watchdog->delta_interval != 0) { 10e8e7: 8b 43 10 mov 0x10(%ebx),%eax 10e8ea: 85 c0 test %eax,%eax 10e8ec: 74 34 je 10e922 <_Watchdog_Tickle+0x56> the_watchdog->delta_interval--; 10e8ee: 48 dec %eax 10e8ef: 89 43 10 mov %eax,0x10(%ebx) if ( the_watchdog->delta_interval != 0 ) 10e8f2: 85 c0 test %eax,%eax 10e8f4: 74 2c je 10e922 <_Watchdog_Tickle+0x56> 10e8f6: 66 90 xchg %ax,%ax the_watchdog = _Watchdog_First( header ); } while ( !_Chain_Is_empty( header ) && (the_watchdog->delta_interval == 0) ); leave: _ISR_Enable(level); 10e8f8: 56 push %esi 10e8f9: 9d popf } 10e8fa: 8d 65 f4 lea -0xc(%ebp),%esp 10e8fd: 5b pop %ebx 10e8fe: 5e pop %esi 10e8ff: 5f pop %edi 10e900: c9 leave 10e901: c3 ret _ISR_Enable( level ); switch( watchdog_state ) { case WATCHDOG_ACTIVE: (*the_watchdog->routine)( 10e902: 83 ec 08 sub $0x8,%esp 10e905: ff 73 24 pushl 0x24(%ebx) 10e908: ff 73 20 pushl 0x20(%ebx) 10e90b: ff 53 1c call *0x1c(%ebx) the_watchdog->id, the_watchdog->user_data ); break; 10e90e: 83 c4 10 add $0x10,%esp case WATCHDOG_REMOVE_IT: break; } _ISR_Disable( level ); 10e911: 9c pushf 10e912: fa cli 10e913: 5e pop %esi } while ( !_Chain_Is_empty( header ) && (the_watchdog->delta_interval == 0) ); leave: _ISR_Enable(level); } 10e914: 8b 1f mov (%edi),%ebx _ISR_Disable( level ); the_watchdog = _Watchdog_First( header ); } while ( !_Chain_Is_empty( header ) && (the_watchdog->delta_interval == 0) ); 10e916: 3b 5d e4 cmp -0x1c(%ebp),%ebx 10e919: 74 dd je 10e8f8 <_Watchdog_Tickle+0x2c> } _ISR_Disable( level ); the_watchdog = _Watchdog_First( header ); } while ( !_Chain_Is_empty( header ) && 10e91b: 8b 43 10 mov 0x10(%ebx),%eax 10e91e: 85 c0 test %eax,%eax 10e920: 75 d6 jne 10e8f8 <_Watchdog_Tickle+0x2c> if ( the_watchdog->delta_interval != 0 ) goto leave; } do { watchdog_state = _Watchdog_Remove( the_watchdog ); 10e922: 83 ec 0c sub $0xc,%esp 10e925: 53 push %ebx 10e926: e8 35 ff ff ff call 10e860 <_Watchdog_Remove> _ISR_Enable( level ); 10e92b: 56 push %esi 10e92c: 9d popf switch( watchdog_state ) { 10e92d: 83 c4 10 add $0x10,%esp 10e930: 83 f8 02 cmp $0x2,%eax 10e933: 75 dc jne 10e911 <_Watchdog_Tickle+0x45> <== NEVER TAKEN 10e935: eb cb jmp 10e902 <_Watchdog_Tickle+0x36> =============================================================================== 0010e938 <_Workspace_Handler_initialization>: /* * _Workspace_Handler_initialization */ void _Workspace_Handler_initialization(void) { 10e938: 55 push %ebp 10e939: 89 e5 mov %esp,%ebp 10e93b: 57 push %edi 10e93c: 53 push %ebx uintptr_t memory_available = 0; void *starting_address = Configuration.work_space_start; 10e93d: 8b 1d 80 3a 12 00 mov 0x123a80,%ebx uintptr_t size = Configuration.work_space_size; 10e943: 8b 15 84 3a 12 00 mov 0x123a84,%edx if ( Configuration.do_zero_of_workspace ) 10e949: 80 3d a8 3a 12 00 00 cmpb $0x0,0x123aa8 10e950: 75 1e jne 10e970 <_Workspace_Handler_initialization+0x38> memset( starting_address, 0, size ); memory_available = _Heap_Initialize( 10e952: 6a 04 push $0x4 10e954: 52 push %edx 10e955: 53 push %ebx 10e956: 68 c0 7d 12 00 push $0x127dc0 10e95b: e8 8c dd ff ff call 10c6ec <_Heap_Initialize> starting_address, size, CPU_HEAP_ALIGNMENT ); if ( memory_available == 0 ) 10e960: 83 c4 10 add $0x10,%esp 10e963: 85 c0 test %eax,%eax 10e965: 74 13 je 10e97a <_Workspace_Handler_initialization+0x42> _Internal_error_Occurred( INTERNAL_ERROR_CORE, true, INTERNAL_ERROR_TOO_LITTLE_WORKSPACE ); } 10e967: 8d 65 f8 lea -0x8(%ebp),%esp 10e96a: 5b pop %ebx 10e96b: 5f pop %edi 10e96c: c9 leave 10e96d: c3 ret 10e96e: 66 90 xchg %ax,%ax uintptr_t memory_available = 0; void *starting_address = Configuration.work_space_start; uintptr_t size = Configuration.work_space_size; if ( Configuration.do_zero_of_workspace ) memset( starting_address, 0, size ); 10e970: 31 c0 xor %eax,%eax 10e972: 89 df mov %ebx,%edi 10e974: 89 d1 mov %edx,%ecx 10e976: f3 aa rep stos %al,%es:(%edi) 10e978: eb d8 jmp 10e952 <_Workspace_Handler_initialization+0x1a> size, CPU_HEAP_ALIGNMENT ); if ( memory_available == 0 ) _Internal_error_Occurred( 10e97a: 50 push %eax 10e97b: 6a 02 push $0x2 10e97d: 6a 01 push $0x1 10e97f: 6a 00 push $0x0 10e981: e8 6e df ff ff call 10c8f4 <_Internal_error_Occurred> =============================================================================== 0010c4ac <_rename_r>: int _rename_r( struct _reent *ptr __attribute__((unused)), const char *old, const char *new ) { 10c4ac: 55 push %ebp 10c4ad: 89 e5 mov %esp,%ebp 10c4af: 57 push %edi 10c4b0: 56 push %esi 10c4b1: 53 push %ebx 10c4b2: 83 ec 78 sub $0x78,%esp 10c4b5: 8b 5d 0c mov 0xc(%ebp),%ebx /* * Get the parent node of the old path to be renamed. Find the parent path. */ old_parent_pathlen = rtems_filesystem_dirname ( old ); 10c4b8: 53 push %ebx 10c4b9: e8 52 ea ff ff call 10af10 if ( old_parent_pathlen == 0 ) 10c4be: 83 c4 10 add $0x10,%esp 10c4c1: 85 c0 test %eax,%eax 10c4c3: 0f 85 57 01 00 00 jne 10c620 <_rename_r+0x174> rtems_filesystem_get_start_loc( old, &i, &old_parent_loc ); 10c4c9: 52 push %edx 10c4ca: 8d 45 b8 lea -0x48(%ebp),%eax 10c4cd: 89 45 94 mov %eax,-0x6c(%ebp) 10c4d0: 50 push %eax 10c4d1: 8d 45 e4 lea -0x1c(%ebp),%eax 10c4d4: 50 push %eax 10c4d5: 53 push %ebx 10c4d6: e8 e1 03 00 00 call 10c8bc 10c4db: 83 c4 10 add $0x10,%esp 10c4de: 31 d2 xor %edx,%edx rtems_filesystem_location_info_t old_parent_loc; rtems_filesystem_location_info_t new_parent_loc; int i; int result; const char *name; bool free_old_parentloc = false; 10c4e0: c6 45 93 00 movb $0x0,-0x6d(%ebp) /* * Start from the parent to find the node that should be under it. */ old_loc = old_parent_loc; 10c4e4: 8d 7d cc lea -0x34(%ebp),%edi 10c4e7: b9 05 00 00 00 mov $0x5,%ecx 10c4ec: 8b 75 94 mov -0x6c(%ebp),%esi 10c4ef: f3 a5 rep movsl %ds:(%esi),%es:(%edi) name = old + old_parent_pathlen; 10c4f1: 01 d3 add %edx,%ebx 10c4f3: 89 5d e0 mov %ebx,-0x20(%ebp) name += rtems_filesystem_prefix_separators( name, strlen( name ) ); 10c4f6: be ff ff ff ff mov $0xffffffff,%esi 10c4fb: 89 f1 mov %esi,%ecx 10c4fd: 89 df mov %ebx,%edi 10c4ff: 31 c0 xor %eax,%eax 10c501: f2 ae repnz scas %es:(%edi),%al 10c503: f7 d1 not %ecx 10c505: 49 dec %ecx 10c506: 83 ec 08 sub $0x8,%esp 10c509: 51 push %ecx 10c50a: 53 push %ebx 10c50b: e8 44 ea ff ff call 10af54 10c510: 01 c3 add %eax,%ebx 10c512: 89 5d e0 mov %ebx,-0x20(%ebp) result = rtems_filesystem_evaluate_relative_path( name , strlen( name ), 10c515: 89 f1 mov %esi,%ecx 10c517: 89 df mov %ebx,%edi 10c519: 31 c0 xor %eax,%eax 10c51b: f2 ae repnz scas %es:(%edi),%al 10c51d: f7 d1 not %ecx 10c51f: 49 dec %ecx 10c520: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10c527: 8d 75 cc lea -0x34(%ebp),%esi 10c52a: 56 push %esi 10c52b: 6a 00 push $0x0 10c52d: 51 push %ecx 10c52e: 53 push %ebx 10c52f: e8 30 e9 ff ff call 10ae64 0, &old_loc, false ); if ( result != 0 ) { 10c534: 83 c4 20 add $0x20,%esp 10c537: 85 c0 test %eax,%eax 10c539: 0f 85 c9 00 00 00 jne 10c608 <_rename_r+0x15c> /* * Get the parent of the new node we are renaming to. */ rtems_filesystem_get_start_loc( new, &i, &new_parent_loc ); 10c53f: 50 push %eax 10c540: 8d 5d a4 lea -0x5c(%ebp),%ebx 10c543: 53 push %ebx 10c544: 8d 45 e4 lea -0x1c(%ebp),%eax 10c547: 50 push %eax 10c548: ff 75 10 pushl 0x10(%ebp) 10c54b: e8 6c 03 00 00 call 10c8bc result = (*new_parent_loc.ops->evalformake_h)( &new[i], &new_parent_loc, &name ); 10c550: 83 c4 0c add $0xc,%esp 10c553: 8d 45 e0 lea -0x20(%ebp),%eax 10c556: 50 push %eax 10c557: 53 push %ebx 10c558: 8b 45 10 mov 0x10(%ebp),%eax 10c55b: 03 45 e4 add -0x1c(%ebp),%eax 10c55e: 50 push %eax 10c55f: 8b 45 b0 mov -0x50(%ebp),%eax 10c562: ff 50 04 call *0x4(%eax) if ( result != 0 ) { 10c565: 83 c4 10 add $0x10,%esp 10c568: 85 c0 test %eax,%eax 10c56a: 0f 85 e0 00 00 00 jne 10c650 <_rename_r+0x1a4> /* * Check to see if the caller is trying to rename across file system * boundaries. */ if ( old_parent_loc.mt_entry != new_parent_loc.mt_entry ) { 10c570: 8b 45 b4 mov -0x4c(%ebp),%eax 10c573: 39 45 c8 cmp %eax,-0x38(%ebp) 10c576: 75 48 jne 10c5c0 <_rename_r+0x114> rtems_filesystem_freenode( &old_parent_loc ); rtems_filesystem_freenode( &old_loc ); rtems_set_errno_and_return_minus_one( EXDEV ); } result = (*new_parent_loc.ops->rename_h)( &old_parent_loc, &old_loc, &new_parent_loc, name ); 10c578: ff 75 e0 pushl -0x20(%ebp) 10c57b: 53 push %ebx 10c57c: 56 push %esi 10c57d: ff 75 94 pushl -0x6c(%ebp) 10c580: 8b 45 b0 mov -0x50(%ebp),%eax 10c583: ff 50 40 call *0x40(%eax) 10c586: 89 c7 mov %eax,%edi rtems_filesystem_freenode( &new_parent_loc ); 10c588: 89 1c 24 mov %ebx,(%esp) 10c58b: e8 f0 eb ff ff call 10b180 if ( free_old_parentloc ) 10c590: 83 c4 10 add $0x10,%esp 10c593: 80 7d 93 00 cmpb $0x0,-0x6d(%ebp) 10c597: 75 17 jne 10c5b0 <_rename_r+0x104> rtems_filesystem_freenode( &old_parent_loc ); rtems_filesystem_freenode( &old_loc ); 10c599: 83 ec 0c sub $0xc,%esp 10c59c: 56 push %esi 10c59d: e8 de eb ff ff call 10b180 return result; 10c5a2: 83 c4 10 add $0x10,%esp } 10c5a5: 89 f8 mov %edi,%eax 10c5a7: 8d 65 f4 lea -0xc(%ebp),%esp 10c5aa: 5b pop %ebx 10c5ab: 5e pop %esi 10c5ac: 5f pop %edi 10c5ad: c9 leave 10c5ae: c3 ret 10c5af: 90 nop result = (*new_parent_loc.ops->rename_h)( &old_parent_loc, &old_loc, &new_parent_loc, name ); rtems_filesystem_freenode( &new_parent_loc ); if ( free_old_parentloc ) rtems_filesystem_freenode( &old_parent_loc ); 10c5b0: 83 ec 0c sub $0xc,%esp 10c5b3: ff 75 94 pushl -0x6c(%ebp) 10c5b6: e8 c5 eb ff ff call 10b180 10c5bb: 83 c4 10 add $0x10,%esp 10c5be: eb d9 jmp 10c599 <_rename_r+0xed> * Check to see if the caller is trying to rename across file system * boundaries. */ if ( old_parent_loc.mt_entry != new_parent_loc.mt_entry ) { rtems_filesystem_freenode( &new_parent_loc ); 10c5c0: 83 ec 0c sub $0xc,%esp 10c5c3: 53 push %ebx 10c5c4: e8 b7 eb ff ff call 10b180 if ( free_old_parentloc ) 10c5c9: 83 c4 10 add $0x10,%esp 10c5cc: 80 7d 93 00 cmpb $0x0,-0x6d(%ebp) 10c5d0: 74 0e je 10c5e0 <_rename_r+0x134> rtems_filesystem_freenode( &old_parent_loc ); 10c5d2: 83 ec 0c sub $0xc,%esp 10c5d5: ff 75 94 pushl -0x6c(%ebp) 10c5d8: e8 a3 eb ff ff call 10b180 10c5dd: 83 c4 10 add $0x10,%esp rtems_filesystem_freenode( &old_loc ); 10c5e0: 83 ec 0c sub $0xc,%esp 10c5e3: 56 push %esi 10c5e4: e8 97 eb ff ff call 10b180 rtems_set_errno_and_return_minus_one( EXDEV ); 10c5e9: e8 d2 a8 00 00 call 116ec0 <__errno> 10c5ee: c7 00 12 00 00 00 movl $0x12,(%eax) 10c5f4: 83 c4 10 add $0x10,%esp 10c5f7: bf ff ff ff ff mov $0xffffffff,%edi if ( free_old_parentloc ) rtems_filesystem_freenode( &old_parent_loc ); rtems_filesystem_freenode( &old_loc ); return result; } 10c5fc: 89 f8 mov %edi,%eax 10c5fe: 8d 65 f4 lea -0xc(%ebp),%esp 10c601: 5b pop %ebx 10c602: 5e pop %esi 10c603: 5f pop %edi 10c604: c9 leave 10c605: c3 ret 10c606: 66 90 xchg %ax,%ax name += rtems_filesystem_prefix_separators( name, strlen( name ) ); result = rtems_filesystem_evaluate_relative_path( name , strlen( name ), 0, &old_loc, false ); if ( result != 0 ) { if ( free_old_parentloc ) 10c608: 80 7d 93 00 cmpb $0x0,-0x6d(%ebp) 10c60c: 75 78 jne 10c686 <_rename_r+0x1da> <== ALWAYS TAKEN rtems_filesystem_freenode( &old_parent_loc ); return -1; 10c60e: bf ff ff ff ff mov $0xffffffff,%edi <== NOT EXECUTED if ( free_old_parentloc ) rtems_filesystem_freenode( &old_parent_loc ); rtems_filesystem_freenode( &old_loc ); return result; } 10c613: 89 f8 mov %edi,%eax <== NOT EXECUTED 10c615: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c618: 5b pop %ebx <== NOT EXECUTED 10c619: 5e pop %esi <== NOT EXECUTED 10c61a: 5f pop %edi <== NOT EXECUTED 10c61b: c9 leave <== NOT EXECUTED 10c61c: c3 ret <== NOT EXECUTED 10c61d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED old_parent_pathlen = rtems_filesystem_dirname ( old ); if ( old_parent_pathlen == 0 ) rtems_filesystem_get_start_loc( old, &i, &old_parent_loc ); else { result = rtems_filesystem_evaluate_path( old, old_parent_pathlen, 10c620: 89 c2 mov %eax,%edx 10c622: 83 ec 0c sub $0xc,%esp 10c625: 6a 00 push $0x0 10c627: 8d 45 b8 lea -0x48(%ebp),%eax 10c62a: 89 45 94 mov %eax,-0x6c(%ebp) 10c62d: 50 push %eax 10c62e: 6a 02 push $0x2 10c630: 52 push %edx 10c631: 53 push %ebx 10c632: 89 55 8c mov %edx,-0x74(%ebp) 10c635: e8 92 e8 ff ff call 10aecc RTEMS_LIBIO_PERMS_WRITE, &old_parent_loc, false ); if ( result != 0 ) 10c63a: 83 c4 20 add $0x20,%esp 10c63d: 85 c0 test %eax,%eax 10c63f: 8b 55 8c mov -0x74(%ebp),%edx 10c642: 75 ca jne 10c60e <_rename_r+0x162> <== NEVER TAKEN return -1; free_old_parentloc = true; 10c644: c6 45 93 01 movb $0x1,-0x6d(%ebp) 10c648: e9 97 fe ff ff jmp 10c4e4 <_rename_r+0x38> 10c64d: 8d 76 00 lea 0x0(%esi),%esi rtems_filesystem_get_start_loc( new, &i, &new_parent_loc ); result = (*new_parent_loc.ops->evalformake_h)( &new[i], &new_parent_loc, &name ); if ( result != 0 ) { rtems_filesystem_freenode( &new_parent_loc ); 10c650: 83 ec 0c sub $0xc,%esp 10c653: 53 push %ebx 10c654: e8 27 eb ff ff call 10b180 if ( free_old_parentloc ) 10c659: 83 c4 10 add $0x10,%esp 10c65c: 80 7d 93 00 cmpb $0x0,-0x6d(%ebp) 10c660: 74 0e je 10c670 <_rename_r+0x1c4> <== NEVER TAKEN rtems_filesystem_freenode( &old_parent_loc ); 10c662: 83 ec 0c sub $0xc,%esp 10c665: ff 75 94 pushl -0x6c(%ebp) 10c668: e8 13 eb ff ff call 10b180 10c66d: 83 c4 10 add $0x10,%esp rtems_filesystem_freenode( &old_loc ); 10c670: 83 ec 0c sub $0xc,%esp 10c673: 56 push %esi 10c674: e8 07 eb ff ff call 10b180 return -1; 10c679: 83 c4 10 add $0x10,%esp 10c67c: bf ff ff ff ff mov $0xffffffff,%edi 10c681: e9 1f ff ff ff jmp 10c5a5 <_rename_r+0xf9> result = rtems_filesystem_evaluate_relative_path( name , strlen( name ), 0, &old_loc, false ); if ( result != 0 ) { if ( free_old_parentloc ) rtems_filesystem_freenode( &old_parent_loc ); 10c686: 83 ec 0c sub $0xc,%esp 10c689: ff 75 94 pushl -0x6c(%ebp) 10c68c: e8 ef ea ff ff call 10b180 10c691: 83 c4 10 add $0x10,%esp return -1; 10c694: bf ff ff ff ff mov $0xffffffff,%edi 10c699: e9 07 ff ff ff jmp 10c5a5 <_rename_r+0xf9> =============================================================================== 0010ad6c <_times>: #endif clock_t _times( struct tms *ptms ) { 10ad6c: 55 push %ebp 10ad6d: 89 e5 mov %esp,%ebp 10ad6f: 56 push %esi 10ad70: 53 push %ebx 10ad71: 83 ec 10 sub $0x10,%esp 10ad74: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_interval ticks; if ( !ptms ) 10ad77: 85 db test %ebx,%ebx 10ad79: 74 75 je 10adf0 <_times+0x84> /* * This call does not depend on TOD being initialized and can't fail. */ ticks = rtems_clock_get_ticks_since_boot(); 10ad7b: e8 84 04 00 00 call 10b204 10ad80: 89 c6 mov %eax,%esi { Timestamp_Control per_tick; uint32_t ticks; uint32_t fractional_ticks; _Timestamp_Set( 10ad82: 8b 0d ac 3d 12 00 mov 0x123dac,%ecx 10ad88: ba 83 de 1b 43 mov $0x431bde83,%edx 10ad8d: 89 c8 mov %ecx,%eax 10ad8f: f7 e2 mul %edx 10ad91: c1 ea 12 shr $0x12,%edx 10ad94: 89 55 e8 mov %edx,-0x18(%ebp) 10ad97: 8d 04 89 lea (%ecx,%ecx,4),%eax 10ad9a: 8d 04 80 lea (%eax,%eax,4),%eax 10ad9d: 8d 04 80 lea (%eax,%eax,4),%eax 10ada0: c1 e0 03 shl $0x3,%eax 10ada3: b9 00 ca 9a 3b mov $0x3b9aca00,%ecx 10ada8: 31 d2 xor %edx,%edx 10adaa: f7 f1 div %ecx 10adac: 89 55 ec mov %edx,-0x14(%ebp) TOD_MICROSECONDS_PER_SECOND, (rtems_configuration_get_nanoseconds_per_tick() % TOD_NANOSECONDS_PER_SECOND) ); _Timestamp_Divide( 10adaf: 8d 45 f0 lea -0x10(%ebp),%eax 10adb2: 50 push %eax 10adb3: 8d 45 f4 lea -0xc(%ebp),%eax 10adb6: 50 push %eax 10adb7: 8d 45 e8 lea -0x18(%ebp),%eax 10adba: 50 push %eax 10adbb: a1 58 86 12 00 mov 0x128658,%eax 10adc0: 05 84 00 00 00 add $0x84,%eax 10adc5: 50 push %eax 10adc6: e8 89 38 00 00 call 10e654 <_Timespec_Divide> &_Thread_Executing->cpu_time_used, &per_tick, &ticks, &fractional_ticks ); ptms->tms_utime = ticks; 10adcb: 8b 45 f4 mov -0xc(%ebp),%eax 10adce: 89 03 mov %eax,(%ebx) } #else ptms->tms_utime = _Thread_Executing->cpu_time_used; #endif ptms->tms_stime = ticks; 10add0: 89 73 04 mov %esi,0x4(%ebx) ptms->tms_cutime = 0; 10add3: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) ptms->tms_cstime = 0; 10adda: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) return ticks; 10ade1: 83 c4 10 add $0x10,%esp 10ade4: 89 f0 mov %esi,%eax } 10ade6: 8d 65 f8 lea -0x8(%ebp),%esp 10ade9: 5b pop %ebx 10adea: 5e pop %esi 10adeb: c9 leave 10adec: c3 ret 10aded: 8d 76 00 lea 0x0(%esi),%esi ) { rtems_interval ticks; if ( !ptms ) rtems_set_errno_and_return_minus_one( EFAULT ); 10adf0: e8 4b 87 00 00 call 113540 <__errno> 10adf5: c7 00 0e 00 00 00 movl $0xe,(%eax) 10adfb: b8 ff ff ff ff mov $0xffffffff,%eax ptms->tms_stime = ticks; ptms->tms_cutime = 0; ptms->tms_cstime = 0; return ticks; } 10ae00: 8d 65 f8 lea -0x8(%ebp),%esp 10ae03: 5b pop %ebx 10ae04: 5e pop %esi 10ae05: c9 leave 10ae06: c3 ret =============================================================================== 00109b3c : int access( const char *path, int amode ) { 109b3c: 55 push %ebp 109b3d: 89 e5 mov %esp,%ebp 109b3f: 53 push %ebx 109b40: 83 ec 5c sub $0x5c,%esp 109b43: 8b 5d 0c mov 0xc(%ebp),%ebx struct stat statbuf; if ( stat(path, &statbuf) ) 109b46: 8d 45 b0 lea -0x50(%ebp),%eax 109b49: 50 push %eax 109b4a: ff 75 08 pushl 0x8(%ebp) 109b4d: e8 42 17 00 00 call 10b294 109b52: 83 c4 10 add $0x10,%esp 109b55: 85 c0 test %eax,%eax 109b57: 75 1f jne 109b78 return -1; if ( amode & R_OK ) { 109b59: f6 c3 04 test $0x4,%bl 109b5c: 75 26 jne 109b84 if (!( statbuf.st_mode & S_IREAD )) return -1; } if ( amode & W_OK ) { 109b5e: f6 c3 02 test $0x2,%bl 109b61: 75 0d jne 109b70 if ( !( statbuf.st_mode & S_IWRITE ) ) return -1; } if ( amode & X_OK ) { 109b63: 83 e3 01 and $0x1,%ebx 109b66: 75 24 jne 109b8c if ( !( statbuf.st_mode & S_IEXEC ) ) return -1; } return 0; 109b68: 31 c0 xor %eax,%eax } 109b6a: 8b 5d fc mov -0x4(%ebp),%ebx 109b6d: c9 leave 109b6e: c3 ret 109b6f: 90 nop if (!( statbuf.st_mode & S_IREAD )) return -1; } if ( amode & W_OK ) { if ( !( statbuf.st_mode & S_IWRITE ) ) 109b70: f6 45 bc 80 testb $0x80,-0x44(%ebp) 109b74: 75 ed jne 109b63 109b76: 66 90 xchg %ax,%ax return -1; 109b78: b8 ff ff ff ff mov $0xffffffff,%eax if ( !( statbuf.st_mode & S_IEXEC ) ) return -1; } return 0; } 109b7d: 8b 5d fc mov -0x4(%ebp),%ebx 109b80: c9 leave 109b81: c3 ret 109b82: 66 90 xchg %ax,%ax if ( stat(path, &statbuf) ) return -1; if ( amode & R_OK ) { if (!( statbuf.st_mode & S_IREAD )) 109b84: f6 45 bd 01 testb $0x1,-0x43(%ebp) 109b88: 75 d4 jne 109b5e 109b8a: eb ec jmp 109b78 if ( !( statbuf.st_mode & S_IWRITE ) ) return -1; } if ( amode & X_OK ) { if ( !( statbuf.st_mode & S_IEXEC ) ) 109b8c: 8b 45 bc mov -0x44(%ebp),%eax 109b8f: 83 e0 40 and $0x40,%eax return -1; } return 0; 109b92: 83 f8 01 cmp $0x1,%eax 109b95: 19 c0 sbb %eax,%eax 109b97: eb d1 jmp 109b6a =============================================================================== 0010b5d4 : int adjtime( struct timeval *delta, struct timeval *olddelta ) { 10b5d4: 55 push %ebp 10b5d5: 89 e5 mov %esp,%ebp 10b5d7: 57 push %edi 10b5d8: 56 push %esi 10b5d9: 53 push %ebx 10b5da: 83 ec 1c sub $0x1c,%esp 10b5dd: 8b 5d 08 mov 0x8(%ebp),%ebx 10b5e0: 8b 75 0c mov 0xc(%ebp),%esi long adjustment; /* * Simple validations */ if ( !delta ) 10b5e3: 85 db test %ebx,%ebx 10b5e5: 0f 84 f1 00 00 00 je 10b6dc rtems_set_errno_and_return_minus_one( EINVAL ); if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND ) 10b5eb: 8b 53 04 mov 0x4(%ebx),%edx 10b5ee: 81 fa 3f 42 0f 00 cmp $0xf423f,%edx 10b5f4: 0f 87 e2 00 00 00 ja 10b6dc rtems_set_errno_and_return_minus_one( EINVAL ); if ( olddelta ) { 10b5fa: 85 f6 test %esi,%esi 10b5fc: 74 10 je 10b60e olddelta->tv_sec = 0; 10b5fe: c7 06 00 00 00 00 movl $0x0,(%esi) olddelta->tv_usec = 0; 10b604: c7 46 04 00 00 00 00 movl $0x0,0x4(%esi) 10b60b: 8b 53 04 mov 0x4(%ebx),%edx } /* convert delta to microseconds */ adjustment = (delta->tv_sec * TOD_MICROSECONDS_PER_SECOND); 10b60e: 8b 03 mov (%ebx),%eax 10b610: 8d 04 80 lea (%eax,%eax,4),%eax 10b613: 8d 04 80 lea (%eax,%eax,4),%eax 10b616: 8d 04 80 lea (%eax,%eax,4),%eax 10b619: 8d 04 80 lea (%eax,%eax,4),%eax 10b61c: 8d 04 80 lea (%eax,%eax,4),%eax 10b61f: 8d 04 80 lea (%eax,%eax,4),%eax 10b622: c1 e0 06 shl $0x6,%eax adjustment += delta->tv_usec; 10b625: 8d 04 02 lea (%edx,%eax,1),%eax /* too small to account for */ if ( adjustment < rtems_configuration_get_microseconds_per_tick() ) 10b628: 3b 05 6c 42 12 00 cmp 0x12426c,%eax 10b62e: 73 0c jae 10b63c /* set the user's output */ if ( olddelta ) *olddelta = *delta; return 0; 10b630: 31 c0 xor %eax,%eax } 10b632: 8d 65 f4 lea -0xc(%ebp),%esp 10b635: 5b pop %ebx 10b636: 5e pop %esi 10b637: 5f pop %edi 10b638: c9 leave 10b639: c3 ret 10b63a: 66 90 xchg %ax,%ax rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10b63c: a1 d0 86 12 00 mov 0x1286d0,%eax 10b641: 40 inc %eax 10b642: a3 d0 86 12 00 mov %eax,0x1286d0 * This prevents context switches while we are adjusting the TOD */ _Thread_Disable_dispatch(); _TOD_Get( &ts ); 10b647: 83 ec 0c sub $0xc,%esp 10b64a: 8d 7d e0 lea -0x20(%ebp),%edi 10b64d: 57 push %edi 10b64e: e8 85 17 00 00 call 10cdd8 <_TOD_Get> ts.tv_sec += delta->tv_sec; 10b653: 8b 03 mov (%ebx),%eax 10b655: 01 45 e0 add %eax,-0x20(%ebp) ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND; 10b658: 8b 43 04 mov 0x4(%ebx),%eax 10b65b: 8d 04 80 lea (%eax,%eax,4),%eax 10b65e: 8d 04 80 lea (%eax,%eax,4),%eax 10b661: 8d 04 80 lea (%eax,%eax,4),%eax 10b664: c1 e0 03 shl $0x3,%eax 10b667: 03 45 e4 add -0x1c(%ebp),%eax 10b66a: 89 45 e4 mov %eax,-0x1c(%ebp) /* if adjustment is too much positive */ while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) { 10b66d: 83 c4 10 add $0x10,%esp 10b670: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax 10b675: 76 18 jbe 10b68f 10b677: 8b 55 e0 mov -0x20(%ebp),%edx 10b67a: 66 90 xchg %ax,%ax ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND; 10b67c: 2d 00 ca 9a 3b sub $0x3b9aca00,%eax * At one point there was a static variable named adjustment * used by this implementation. I don't see any reason for it * to be here based upon the GNU/Linux documentation. */ int adjtime( 10b681: 42 inc %edx ts.tv_sec += delta->tv_sec; ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND; /* if adjustment is too much positive */ while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) { 10b682: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax 10b687: 77 f3 ja 10b67c <== NEVER TAKEN 10b689: 89 45 e4 mov %eax,-0x1c(%ebp) 10b68c: 89 55 e0 mov %edx,-0x20(%ebp) ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND; ts.tv_sec++; } /* if adjustment is too much negative */ while ( ts.tv_nsec <= (-1 * TOD_NANOSECONDS_PER_SECOND) ) { 10b68f: 3d 00 36 65 c4 cmp $0xc4653600,%eax 10b694: 77 19 ja 10b6af <== NEVER TAKEN 10b696: 8b 55 e0 mov -0x20(%ebp),%edx 10b699: 8d 76 00 lea 0x0(%esi),%esi ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND; 10b69c: 05 00 ca 9a 3b add $0x3b9aca00,%eax * At one point there was a static variable named adjustment * used by this implementation. I don't see any reason for it * to be here based upon the GNU/Linux documentation. */ int adjtime( 10b6a1: 4a dec %edx ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND; ts.tv_sec++; } /* if adjustment is too much negative */ while ( ts.tv_nsec <= (-1 * TOD_NANOSECONDS_PER_SECOND) ) { 10b6a2: 3d 00 36 65 c4 cmp $0xc4653600,%eax 10b6a7: 76 f3 jbe 10b69c 10b6a9: 89 45 e4 mov %eax,-0x1c(%ebp) 10b6ac: 89 55 e0 mov %edx,-0x20(%ebp) ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND; ts.tv_sec--; } _TOD_Set( &ts ); 10b6af: 83 ec 0c sub $0xc,%esp 10b6b2: 57 push %edi 10b6b3: e8 a8 17 00 00 call 10ce60 <_TOD_Set> _Thread_Enable_dispatch(); 10b6b8: e8 ab 2c 00 00 call 10e368 <_Thread_Enable_dispatch> /* set the user's output */ if ( olddelta ) 10b6bd: 83 c4 10 add $0x10,%esp 10b6c0: 85 f6 test %esi,%esi 10b6c2: 0f 84 68 ff ff ff je 10b630 *olddelta = *delta; 10b6c8: 8b 03 mov (%ebx),%eax 10b6ca: 8b 53 04 mov 0x4(%ebx),%edx 10b6cd: 89 06 mov %eax,(%esi) 10b6cf: 89 56 04 mov %edx,0x4(%esi) return 0; 10b6d2: 31 c0 xor %eax,%eax } 10b6d4: 8d 65 f4 lea -0xc(%ebp),%esp 10b6d7: 5b pop %ebx 10b6d8: 5e pop %esi 10b6d9: 5f pop %edi 10b6da: c9 leave 10b6db: c3 ret */ if ( !delta ) rtems_set_errno_and_return_minus_one( EINVAL ); if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND ) rtems_set_errno_and_return_minus_one( EINVAL ); 10b6dc: e8 43 86 00 00 call 113d24 <__errno> 10b6e1: c7 00 16 00 00 00 movl $0x16,(%eax) 10b6e7: b8 ff ff ff ff mov $0xffffffff,%eax 10b6ec: e9 41 ff ff ff jmp 10b632 =============================================================================== 0010bd14 : * operation(s) cannot be canceled */ int aio_cancel(int fildes, struct aiocb *aiocbp) { 10bd14: 55 push %ebp 10bd15: 89 e5 mov %esp,%ebp 10bd17: 57 push %edi 10bd18: 56 push %esi 10bd19: 53 push %ebx 10bd1a: 83 ec 18 sub $0x18,%esp 10bd1d: 8b 75 08 mov 0x8(%ebp),%esi 10bd20: 8b 5d 0c mov 0xc(%ebp),%ebx rtems_aio_request_chain *r_chain; int result; pthread_mutex_lock (&aio_request_queue.mutex); 10bd23: 68 00 aa 12 00 push $0x12aa00 10bd28: e8 bf 11 00 00 call 10ceec if (fcntl (fildes, F_GETFD) < 0) { 10bd2d: 5a pop %edx 10bd2e: 59 pop %ecx 10bd2f: 6a 01 push $0x1 10bd31: 56 push %esi 10bd32: e8 01 6b 00 00 call 112838 10bd37: 83 c4 10 add $0x10,%esp 10bd3a: 85 c0 test %eax,%eax 10bd3c: 0f 88 9b 01 00 00 js 10bedd pthread_mutex_unlock(&aio_request_queue.mutex); rtems_set_errno_and_return_minus_one (EBADF); } /* if aiocbp is NULL remove all request for given file descriptor */ if (aiocbp == NULL) { 10bd42: 85 db test %ebx,%ebx 10bd44: 0f 84 ea 00 00 00 je 10be34 pthread_mutex_unlock (&aio_request_queue.mutex); return AIO_CANCELED; } else { AIO_printf ("Cancel request\n"); if (aiocbp->aio_fildes != fildes) { 10bd4a: 8b 3b mov (%ebx),%edi 10bd4c: 39 f7 cmp %esi,%edi 10bd4e: 0f 85 b8 00 00 00 jne 10be0c pthread_mutex_unlock (&aio_request_queue.mutex); rtems_set_errno_and_return_minus_one (EINVAL); } r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0); 10bd54: 56 push %esi 10bd55: 6a 00 push $0x0 10bd57: 57 push %edi 10bd58: 68 48 aa 12 00 push $0x12aa48 10bd5d: e8 9e 03 00 00 call 10c100 10bd62: 89 c6 mov %eax,%esi if (r_chain == NULL) { 10bd64: 83 c4 10 add $0x10,%esp 10bd67: 85 c0 test %eax,%eax 10bd69: 74 3d je 10bda8 return AIO_ALLDONE; } } AIO_printf ("Request on [WQ]\n"); pthread_mutex_lock (&r_chain->mutex); 10bd6b: 8d 78 1c lea 0x1c(%eax),%edi 10bd6e: 83 ec 0c sub $0xc,%esp 10bd71: 57 push %edi 10bd72: e8 75 11 00 00 call 10ceec result = rtems_aio_remove_req (&r_chain->perfd, aiocbp); 10bd77: 58 pop %eax 10bd78: 5a pop %edx 10bd79: 53 push %ebx 10bd7a: 83 c6 08 add $0x8,%esi 10bd7d: 56 push %esi 10bd7e: e8 5d 07 00 00 call 10c4e0 10bd83: 89 c3 mov %eax,%ebx pthread_mutex_unlock (&r_chain->mutex); 10bd85: 89 3c 24 mov %edi,(%esp) 10bd88: e8 e7 11 00 00 call 10cf74 pthread_mutex_unlock (&aio_request_queue.mutex); 10bd8d: c7 04 24 00 aa 12 00 movl $0x12aa00,(%esp) 10bd94: e8 db 11 00 00 call 10cf74 return result; 10bd99: 83 c4 10 add $0x10,%esp } return AIO_ALLDONE; } 10bd9c: 89 d8 mov %ebx,%eax 10bd9e: 8d 65 f4 lea -0xc(%ebp),%esp 10bda1: 5b pop %ebx 10bda2: 5e pop %esi 10bda3: 5f pop %edi 10bda4: c9 leave 10bda5: c3 ret 10bda6: 66 90 xchg %ax,%ax rtems_set_errno_and_return_minus_one (EINVAL); } r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0); if (r_chain == NULL) { if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) { 10bda8: 81 3d 54 aa 12 00 58 cmpl $0x12aa58,0x12aa54 10bdaf: aa 12 00 10bdb2: 74 40 je 10bdf4 <== NEVER TAKEN r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0); 10bdb4: 51 push %ecx 10bdb5: 6a 00 push $0x0 10bdb7: 57 push %edi 10bdb8: 68 54 aa 12 00 push $0x12aa54 10bdbd: e8 3e 03 00 00 call 10c100 if (r_chain == NULL) { 10bdc2: 83 c4 10 add $0x10,%esp 10bdc5: 85 c0 test %eax,%eax 10bdc7: 74 43 je 10be0c rtems_set_errno_and_return_minus_one (EINVAL); } AIO_printf ("Request on [IQ]\n"); result = rtems_aio_remove_req (&r_chain->perfd, aiocbp); 10bdc9: 83 ec 08 sub $0x8,%esp 10bdcc: 53 push %ebx 10bdcd: 83 c0 08 add $0x8,%eax 10bdd0: 50 push %eax 10bdd1: e8 0a 07 00 00 call 10c4e0 10bdd6: 89 c3 mov %eax,%ebx pthread_mutex_unlock (&aio_request_queue.mutex); 10bdd8: c7 04 24 00 aa 12 00 movl $0x12aa00,(%esp) 10bddf: e8 90 11 00 00 call 10cf74 return result; 10bde4: 83 c4 10 add $0x10,%esp pthread_mutex_unlock (&r_chain->mutex); pthread_mutex_unlock (&aio_request_queue.mutex); return result; } return AIO_ALLDONE; } 10bde7: 89 d8 mov %ebx,%eax 10bde9: 8d 65 f4 lea -0xc(%ebp),%esp 10bdec: 5b pop %ebx 10bded: 5e pop %esi 10bdee: 5f pop %edi 10bdef: c9 leave 10bdf0: c3 ret 10bdf1: 8d 76 00 lea 0x0(%esi),%esi result = rtems_aio_remove_req (&r_chain->perfd, aiocbp); pthread_mutex_unlock (&aio_request_queue.mutex); return result; } else { pthread_mutex_unlock (&aio_request_queue.mutex); 10bdf4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bdf7: 68 00 aa 12 00 push $0x12aa00 <== NOT EXECUTED 10bdfc: e8 73 11 00 00 call 10cf74 <== NOT EXECUTED return AIO_ALLDONE; 10be01: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10be04: bb 02 00 00 00 mov $0x2,%ebx <== NOT EXECUTED 10be09: eb 91 jmp 10bd9c <== NOT EXECUTED 10be0b: 90 nop <== NOT EXECUTED r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0); if (r_chain == NULL) { if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) { r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0); if (r_chain == NULL) { pthread_mutex_unlock (&aio_request_queue.mutex); 10be0c: 83 ec 0c sub $0xc,%esp 10be0f: 68 00 aa 12 00 push $0x12aa00 10be14: e8 5b 11 00 00 call 10cf74 rtems_set_errno_and_return_minus_one (EINVAL); 10be19: e8 7a 9d 00 00 call 115b98 <__errno> 10be1e: c7 00 16 00 00 00 movl $0x16,(%eax) 10be24: 83 c4 10 add $0x10,%esp 10be27: bb ff ff ff ff mov $0xffffffff,%ebx 10be2c: e9 6b ff ff ff jmp 10bd9c 10be31: 8d 76 00 lea 0x0(%esi),%esi /* if aiocbp is NULL remove all request for given file descriptor */ if (aiocbp == NULL) { AIO_printf ("Cancel all requests\n"); r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0); 10be34: 50 push %eax 10be35: 6a 00 push $0x0 10be37: 56 push %esi 10be38: 68 48 aa 12 00 push $0x12aa48 10be3d: e8 be 02 00 00 call 10c100 10be42: 89 c3 mov %eax,%ebx if (r_chain == NULL) { 10be44: 83 c4 10 add $0x10,%esp 10be47: 85 c0 test %eax,%eax 10be49: 74 3d je 10be88 return AIO_ALLDONE; } AIO_printf ("Request chain on [WQ]\n"); pthread_mutex_lock (&r_chain->mutex); 10be4b: 8d 70 1c lea 0x1c(%eax),%esi 10be4e: 83 ec 0c sub $0xc,%esp 10be51: 56 push %esi 10be52: e8 95 10 00 00 call 10ceec */ RTEMS_INLINE_ROUTINE void rtems_chain_extract( rtems_chain_node *the_node ) { _Chain_Extract( the_node ); 10be57: 89 1c 24 mov %ebx,(%esp) 10be5a: e8 5d 2a 00 00 call 10e8bc <_Chain_Extract> rtems_chain_extract (&r_chain->next_fd); rtems_aio_remove_fd (r_chain); 10be5f: 89 1c 24 mov %ebx,(%esp) 10be62: e8 29 06 00 00 call 10c490 pthread_mutex_unlock (&r_chain->mutex); 10be67: 89 34 24 mov %esi,(%esp) 10be6a: e8 05 11 00 00 call 10cf74 pthread_mutex_unlock (&aio_request_queue.mutex); 10be6f: c7 04 24 00 aa 12 00 movl $0x12aa00,(%esp) 10be76: e8 f9 10 00 00 call 10cf74 return AIO_CANCELED; 10be7b: 83 c4 10 add $0x10,%esp 10be7e: 31 db xor %ebx,%ebx 10be80: e9 17 ff ff ff jmp 10bd9c 10be85: 8d 76 00 lea 0x0(%esi),%esi r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0); if (r_chain == NULL) { AIO_printf ("Request chain not on [WQ]\n"); if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) { 10be88: 81 3d 54 aa 12 00 58 cmpl $0x12aa58,0x12aa54 10be8f: aa 12 00 10be92: 0f 84 5c ff ff ff je 10bdf4 <== NEVER TAKEN r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0); 10be98: 57 push %edi 10be99: 6a 00 push $0x0 10be9b: 56 push %esi 10be9c: 68 54 aa 12 00 push $0x12aa54 10bea1: e8 5a 02 00 00 call 10c100 10bea6: 89 c3 mov %eax,%ebx if (r_chain == NULL) { 10bea8: 83 c4 10 add $0x10,%esp 10beab: 85 c0 test %eax,%eax 10bead: 74 53 je 10bf02 10beaf: 83 ec 0c sub $0xc,%esp 10beb2: 50 push %eax 10beb3: e8 04 2a 00 00 call 10e8bc <_Chain_Extract> } AIO_printf ("Request chain on [IQ]\n"); rtems_chain_extract (&r_chain->next_fd); rtems_aio_remove_fd (r_chain); 10beb8: 89 1c 24 mov %ebx,(%esp) 10bebb: e8 d0 05 00 00 call 10c490 pthread_mutex_destroy (&r_chain->mutex); 10bec0: 8d 73 1c lea 0x1c(%ebx),%esi 10bec3: 89 34 24 mov %esi,(%esp) 10bec6: e8 b5 0d 00 00 call 10cc80 pthread_cond_destroy (&r_chain->mutex); 10becb: 89 34 24 mov %esi,(%esp) 10bece: e8 69 0a 00 00 call 10c93c free (r_chain); 10bed3: 89 1c 24 mov %ebx,(%esp) 10bed6: e8 59 cc ff ff call 108b34 10bedb: eb 92 jmp 10be6f int result; pthread_mutex_lock (&aio_request_queue.mutex); if (fcntl (fildes, F_GETFD) < 0) { pthread_mutex_unlock(&aio_request_queue.mutex); 10bedd: 83 ec 0c sub $0xc,%esp 10bee0: 68 00 aa 12 00 push $0x12aa00 10bee5: e8 8a 10 00 00 call 10cf74 rtems_set_errno_and_return_minus_one (EBADF); 10beea: e8 a9 9c 00 00 call 115b98 <__errno> 10beef: c7 00 09 00 00 00 movl $0x9,(%eax) 10bef5: 83 c4 10 add $0x10,%esp 10bef8: bb ff ff ff ff mov $0xffffffff,%ebx 10befd: e9 9a fe ff ff jmp 10bd9c AIO_printf ("Request chain not on [WQ]\n"); if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) { r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0); if (r_chain == NULL) { pthread_mutex_unlock(&aio_request_queue.mutex); 10bf02: 83 ec 0c sub $0xc,%esp 10bf05: 68 00 aa 12 00 push $0x12aa00 10bf0a: e8 65 10 00 00 call 10cf74 return AIO_ALLDONE; 10bf0f: 83 c4 10 add $0x10,%esp 10bf12: b3 02 mov $0x2,%bl 10bf14: e9 83 fe ff ff jmp 10bd9c =============================================================================== 0010bf28 : int aio_fsync( int op, struct aiocb *aiocbp ) { 10bf28: 55 push %ebp 10bf29: 89 e5 mov %esp,%ebp 10bf2b: 53 push %ebx 10bf2c: 83 ec 04 sub $0x4,%esp 10bf2f: 8b 5d 0c mov 0xc(%ebp),%ebx rtems_aio_request *req; int mode; if (op != O_SYNC) 10bf32: 81 7d 08 00 20 00 00 cmpl $0x2000,0x8(%ebp) 10bf39: 75 41 jne 10bf7c rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); mode = fcntl (aiocbp->aio_fildes, F_GETFL); 10bf3b: 83 ec 08 sub $0x8,%esp 10bf3e: 6a 03 push $0x3 10bf40: ff 33 pushl (%ebx) 10bf42: e8 f1 68 00 00 call 112838 if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR))) 10bf47: 83 e0 03 and $0x3,%eax 10bf4a: 48 dec %eax 10bf4b: 83 c4 10 add $0x10,%esp 10bf4e: 83 f8 01 cmp $0x1,%eax 10bf51: 77 4d ja 10bfa0 rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); req = malloc (sizeof (rtems_aio_request)); 10bf53: 83 ec 0c sub $0xc,%esp 10bf56: 6a 18 push $0x18 10bf58: e8 eb d0 ff ff call 109048 if (req == NULL) 10bf5d: 83 c4 10 add $0x10,%esp 10bf60: 85 c0 test %eax,%eax 10bf62: 74 57 je 10bfbb <== NEVER TAKEN rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); req->aiocbp = aiocbp; 10bf64: 89 58 14 mov %ebx,0x14(%eax) req->aiocbp->aio_lio_opcode = LIO_SYNC; 10bf67: c7 43 2c 03 00 00 00 movl $0x3,0x2c(%ebx) return rtems_aio_enqueue (req); 10bf6e: 89 45 08 mov %eax,0x8(%ebp) } 10bf71: 8b 5d fc mov -0x4(%ebp),%ebx 10bf74: c9 leave rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); req->aiocbp = aiocbp; req->aiocbp->aio_lio_opcode = LIO_SYNC; return rtems_aio_enqueue (req); 10bf75: e9 d6 05 00 00 jmp 10c550 10bf7a: 66 90 xchg %ax,%ax { rtems_aio_request *req; int mode; if (op != O_SYNC) rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); 10bf7c: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx) 10bf83: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10bf8a: e8 09 9c 00 00 call 115b98 <__errno> 10bf8f: c7 00 16 00 00 00 movl $0x16,(%eax) req->aiocbp = aiocbp; req->aiocbp->aio_lio_opcode = LIO_SYNC; return rtems_aio_enqueue (req); } 10bf95: b8 ff ff ff ff mov $0xffffffff,%eax 10bf9a: 8b 5d fc mov -0x4(%ebp),%ebx 10bf9d: c9 leave 10bf9e: c3 ret 10bf9f: 90 nop if (op != O_SYNC) rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); mode = fcntl (aiocbp->aio_fildes, F_GETFL); if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR))) rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); 10bfa0: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx) 10bfa7: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10bfae: e8 e5 9b 00 00 call 115b98 <__errno> 10bfb3: c7 00 09 00 00 00 movl $0x9,(%eax) 10bfb9: eb da jmp 10bf95 req = malloc (sizeof (rtems_aio_request)); if (req == NULL) rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); 10bfbb: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) 10bfc2: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED 10bfc9: e8 ca 9b 00 00 call 115b98 <__errno> <== NOT EXECUTED 10bfce: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10bfd4: eb bf jmp 10bf95 <== NOT EXECUTED =============================================================================== 0010c760 : * 0 - otherwise */ int aio_read (struct aiocb *aiocbp) { 10c760: 55 push %ebp 10c761: 89 e5 mov %esp,%ebp 10c763: 53 push %ebx 10c764: 83 ec 0c sub $0xc,%esp 10c767: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_aio_request *req; int mode; mode = fcntl (aiocbp->aio_fildes, F_GETFL); 10c76a: 6a 03 push $0x3 10c76c: ff 33 pushl (%ebx) 10c76e: e8 c5 60 00 00 call 112838 if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR))) 10c773: 83 c4 10 add $0x10,%esp 10c776: 83 e0 03 and $0x3,%eax 10c779: 74 05 je 10c780 <== NEVER TAKEN 10c77b: 83 f8 02 cmp $0x2,%eax 10c77e: 75 38 jne 10c7b8 rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX) 10c780: 8b 53 14 mov 0x14(%ebx),%edx 10c783: 85 d2 test %edx,%edx 10c785: 75 55 jne 10c7dc rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); if (aiocbp->aio_offset < 0) 10c787: 8b 43 08 mov 0x8(%ebx),%eax 10c78a: 85 c0 test %eax,%eax 10c78c: 78 4e js 10c7dc rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); req = malloc (sizeof (rtems_aio_request)); 10c78e: 83 ec 0c sub $0xc,%esp 10c791: 6a 18 push $0x18 10c793: e8 b0 c8 ff ff call 109048 if (req == NULL) 10c798: 83 c4 10 add $0x10,%esp 10c79b: 85 c0 test %eax,%eax 10c79d: 74 58 je 10c7f7 <== NEVER TAKEN rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); req->aiocbp = aiocbp; 10c79f: 89 58 14 mov %ebx,0x14(%eax) req->aiocbp->aio_lio_opcode = LIO_READ; 10c7a2: c7 43 2c 01 00 00 00 movl $0x1,0x2c(%ebx) return rtems_aio_enqueue (req); 10c7a9: 89 45 08 mov %eax,0x8(%ebp) } 10c7ac: 8b 5d fc mov -0x4(%ebp),%ebx 10c7af: c9 leave rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); req->aiocbp = aiocbp; req->aiocbp->aio_lio_opcode = LIO_READ; return rtems_aio_enqueue (req); 10c7b0: e9 9b fd ff ff jmp 10c550 10c7b5: 8d 76 00 lea 0x0(%esi),%esi rtems_aio_request *req; int mode; mode = fcntl (aiocbp->aio_fildes, F_GETFL); if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR))) rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); 10c7b8: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx) 10c7bf: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10c7c6: e8 cd 93 00 00 call 115b98 <__errno> 10c7cb: c7 00 09 00 00 00 movl $0x9,(%eax) req->aiocbp = aiocbp; req->aiocbp->aio_lio_opcode = LIO_READ; return rtems_aio_enqueue (req); } 10c7d1: b8 ff ff ff ff mov $0xffffffff,%eax 10c7d6: 8b 5d fc mov -0x4(%ebp),%ebx 10c7d9: c9 leave 10c7da: c3 ret 10c7db: 90 nop if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX) rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); if (aiocbp->aio_offset < 0) rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); 10c7dc: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx) 10c7e3: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10c7ea: e8 a9 93 00 00 call 115b98 <__errno> 10c7ef: c7 00 16 00 00 00 movl $0x16,(%eax) 10c7f5: eb da jmp 10c7d1 req = malloc (sizeof (rtems_aio_request)); if (req == NULL) rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); 10c7f7: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED 10c7fe: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED 10c805: e8 8e 93 00 00 call 115b98 <__errno> <== NOT EXECUTED 10c80a: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10c810: eb bf jmp 10c7d1 <== NOT EXECUTED =============================================================================== 0010c820 : * 0 - otherwise */ int aio_write (struct aiocb *aiocbp) { 10c820: 55 push %ebp 10c821: 89 e5 mov %esp,%ebp 10c823: 53 push %ebx 10c824: 83 ec 0c sub $0xc,%esp 10c827: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_aio_request *req; int mode; mode = fcntl (aiocbp->aio_fildes, F_GETFL); 10c82a: 6a 03 push $0x3 10c82c: ff 33 pushl (%ebx) 10c82e: e8 05 60 00 00 call 112838 if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR))) 10c833: 83 e0 03 and $0x3,%eax 10c836: 48 dec %eax 10c837: 83 c4 10 add $0x10,%esp 10c83a: 83 f8 01 cmp $0x1,%eax 10c83d: 77 35 ja 10c874 rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX) 10c83f: 8b 53 14 mov 0x14(%ebx),%edx 10c842: 85 d2 test %edx,%edx 10c844: 75 52 jne 10c898 rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); if (aiocbp->aio_offset < 0) 10c846: 8b 43 08 mov 0x8(%ebx),%eax 10c849: 85 c0 test %eax,%eax 10c84b: 78 4b js 10c898 rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); req = malloc (sizeof (rtems_aio_request)); 10c84d: 83 ec 0c sub $0xc,%esp 10c850: 6a 18 push $0x18 10c852: e8 f1 c7 ff ff call 109048 if (req == NULL) 10c857: 83 c4 10 add $0x10,%esp 10c85a: 85 c0 test %eax,%eax 10c85c: 74 55 je 10c8b3 <== NEVER TAKEN rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); req->aiocbp = aiocbp; 10c85e: 89 58 14 mov %ebx,0x14(%eax) req->aiocbp->aio_lio_opcode = LIO_WRITE; 10c861: c7 43 2c 02 00 00 00 movl $0x2,0x2c(%ebx) return rtems_aio_enqueue (req); 10c868: 89 45 08 mov %eax,0x8(%ebp) } 10c86b: 8b 5d fc mov -0x4(%ebp),%ebx 10c86e: c9 leave rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); req->aiocbp = aiocbp; req->aiocbp->aio_lio_opcode = LIO_WRITE; return rtems_aio_enqueue (req); 10c86f: e9 dc fc ff ff jmp 10c550 rtems_aio_request *req; int mode; mode = fcntl (aiocbp->aio_fildes, F_GETFL); if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR))) rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); 10c874: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx) 10c87b: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10c882: e8 11 93 00 00 call 115b98 <__errno> 10c887: c7 00 09 00 00 00 movl $0x9,(%eax) req->aiocbp = aiocbp; req->aiocbp->aio_lio_opcode = LIO_WRITE; return rtems_aio_enqueue (req); } 10c88d: b8 ff ff ff ff mov $0xffffffff,%eax 10c892: 8b 5d fc mov -0x4(%ebp),%ebx 10c895: c9 leave 10c896: c3 ret 10c897: 90 nop if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX) rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); if (aiocbp->aio_offset < 0) rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); 10c898: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx) 10c89f: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10c8a6: e8 ed 92 00 00 call 115b98 <__errno> 10c8ab: c7 00 16 00 00 00 movl $0x16,(%eax) 10c8b1: eb da jmp 10c88d req = malloc (sizeof (rtems_aio_request)); if (req == NULL) rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); 10c8b3: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED 10c8ba: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED 10c8c1: e8 d2 92 00 00 call 115b98 <__errno> <== NOT EXECUTED 10c8c6: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10c8cc: eb bf jmp 10c88d <== NOT EXECUTED =============================================================================== 001092f0 : int cfsetospeed( struct termios *tp, speed_t speed ) { 1092f0: 55 push %ebp 1092f1: 89 e5 mov %esp,%ebp 1092f3: 83 ec 08 sub $0x8,%esp 1092f6: 8b 4d 08 mov 0x8(%ebp),%ecx 1092f9: 8b 55 0c mov 0xc(%ebp),%edx if ( speed & ~CBAUD ) 1092fc: f7 c2 f0 ef ff ff test $0xffffeff0,%edx 109302: 75 14 jne 109318 rtems_set_errno_and_return_minus_one( EINVAL ); tp->c_cflag = (tp->c_cflag & ~CBAUD) | speed; 109304: 8b 41 08 mov 0x8(%ecx),%eax 109307: 25 f0 ef ff ff and $0xffffeff0,%eax 10930c: 09 d0 or %edx,%eax 10930e: 89 41 08 mov %eax,0x8(%ecx) return 0; 109311: 31 c0 xor %eax,%eax } 109313: c9 leave 109314: c3 ret 109315: 8d 76 00 lea 0x0(%esi),%esi struct termios *tp, speed_t speed ) { if ( speed & ~CBAUD ) rtems_set_errno_and_return_minus_one( EINVAL ); 109318: e8 cb ba 00 00 call 114de8 <__errno> 10931d: c7 00 16 00 00 00 movl $0x16,(%eax) 109323: b8 ff ff ff ff mov $0xffffffff,%eax tp->c_cflag = (tp->c_cflag & ~CBAUD) | speed; return 0; } 109328: c9 leave 109329: c3 ret =============================================================================== 001106c8 : #include int chdir( const char *pathname ) { 1106c8: 55 push %ebp 1106c9: 89 e5 mov %esp,%ebp 1106cb: 57 push %edi 1106cc: 56 push %esi 1106cd: 83 ec 20 sub $0x20,%esp 1106d0: 8b 55 08 mov 0x8(%ebp),%edx rtems_filesystem_location_info_t loc; int result; if ( !pathname ) 1106d3: 85 d2 test %edx,%edx 1106d5: 74 75 je 11074c rtems_set_errno_and_return_minus_one( EFAULT ); /* * Get the node where we wish to go. */ result = rtems_filesystem_evaluate_path( 1106d7: 31 c0 xor %eax,%eax 1106d9: b9 ff ff ff ff mov $0xffffffff,%ecx 1106de: 89 d7 mov %edx,%edi 1106e0: f2 ae repnz scas %es:(%edi),%al 1106e2: f7 d1 not %ecx 1106e4: 49 dec %ecx 1106e5: 83 ec 0c sub $0xc,%esp 1106e8: 6a 01 push $0x1 1106ea: 8d 75 e4 lea -0x1c(%ebp),%esi 1106ed: 56 push %esi 1106ee: 6a 01 push $0x1 1106f0: 51 push %ecx 1106f1: 52 push %edx 1106f2: e8 11 7d ff ff call 108408 pathname, strlen( pathname ), RTEMS_LIBIO_PERMS_SEARCH, &loc, true ); if ( result != 0 ) 1106f7: 83 c4 20 add $0x20,%esp 1106fa: 85 c0 test %eax,%eax 1106fc: 74 0e je 11070c return -1; 1106fe: b8 ff ff ff ff mov $0xffffffff,%eax rtems_filesystem_freenode( &rtems_filesystem_current ); rtems_filesystem_current = loc; return 0; } 110703: 8d 65 f8 lea -0x8(%ebp),%esp 110706: 5e pop %esi 110707: 5f pop %edi 110708: c9 leave 110709: c3 ret 11070a: 66 90 xchg %ax,%ax return -1; /* * Verify you can change directory into this node. */ if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) { 11070c: 83 ec 0c sub $0xc,%esp 11070f: 56 push %esi 110710: 8b 45 f0 mov -0x10(%ebp),%eax 110713: ff 50 10 call *0x10(%eax) 110716: 83 c4 10 add $0x10,%esp 110719: 48 dec %eax 11071a: 75 48 jne 110764 rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( ENOTDIR ); } rtems_filesystem_freenode( &rtems_filesystem_current ); 11071c: 83 ec 0c sub $0xc,%esp 11071f: a1 d0 62 12 00 mov 0x1262d0,%eax 110724: 83 c0 04 add $0x4,%eax 110727: 50 push %eax 110728: e8 b3 7d ff ff call 1084e0 rtems_filesystem_current = loc; 11072d: 8b 3d d0 62 12 00 mov 0x1262d0,%edi 110733: 83 c7 04 add $0x4,%edi 110736: b9 05 00 00 00 mov $0x5,%ecx 11073b: f3 a5 rep movsl %ds:(%esi),%es:(%edi) return 0; 11073d: 83 c4 10 add $0x10,%esp 110740: 31 c0 xor %eax,%eax } 110742: 8d 65 f8 lea -0x8(%ebp),%esp 110745: 5e pop %esi 110746: 5f pop %edi 110747: c9 leave 110748: c3 ret 110749: 8d 76 00 lea 0x0(%esi),%esi { rtems_filesystem_location_info_t loc; int result; if ( !pathname ) rtems_set_errno_and_return_minus_one( EFAULT ); 11074c: e8 bb 33 00 00 call 113b0c <__errno> 110751: c7 00 0e 00 00 00 movl $0xe,(%eax) 110757: b8 ff ff ff ff mov $0xffffffff,%eax rtems_filesystem_freenode( &rtems_filesystem_current ); rtems_filesystem_current = loc; return 0; } 11075c: 8d 65 f8 lea -0x8(%ebp),%esp 11075f: 5e pop %esi 110760: 5f pop %edi 110761: c9 leave 110762: c3 ret 110763: 90 nop /* * Verify you can change directory into this node. */ if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) { rtems_filesystem_freenode( &loc ); 110764: 83 ec 0c sub $0xc,%esp 110767: 56 push %esi 110768: e8 73 7d ff ff call 1084e0 rtems_set_errno_and_return_minus_one( ENOTDIR ); 11076d: e8 9a 33 00 00 call 113b0c <__errno> 110772: c7 00 14 00 00 00 movl $0x14,(%eax) 110778: 83 c4 10 add $0x10,%esp 11077b: b8 ff ff ff ff mov $0xffffffff,%eax 110780: eb 81 jmp 110703 =============================================================================== 00108270 : #include int chroot( const char *pathname ) { 108270: 55 push %ebp 108271: 89 e5 mov %esp,%ebp 108273: 57 push %edi 108274: 56 push %esi 108275: 83 ec 20 sub $0x20,%esp int result; rtems_filesystem_location_info_t loc; /* an automatic call to new private env the first time */ if (rtems_current_user_env == &rtems_global_user_env) { 108278: 81 3d d0 62 12 00 c0 cmpl $0x1285c0,0x1262d0 10827f: 85 12 00 108282: 74 60 je 1082e4 rtems_libio_set_private_env(); /* try to set a new private env*/ if (rtems_current_user_env == &rtems_global_user_env) /* not ok */ rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = chdir(pathname); 108284: 83 ec 0c sub $0xc,%esp 108287: ff 75 08 pushl 0x8(%ebp) 10828a: e8 39 84 00 00 call 1106c8 if (result) { 10828f: 83 c4 10 add $0x10,%esp 108292: 85 c0 test %eax,%eax 108294: 75 72 jne 108308 rtems_set_errno_and_return_minus_one( errno ); } /* clone the new root location */ if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) { 108296: 83 ec 0c sub $0xc,%esp 108299: 6a 00 push $0x0 10829b: 8d 75 e4 lea -0x1c(%ebp),%esi 10829e: 56 push %esi 10829f: 6a 00 push $0x0 1082a1: 6a 01 push $0x1 1082a3: 68 d6 21 12 00 push $0x1221d6 1082a8: e8 5b 01 00 00 call 108408 1082ad: 83 c4 20 add $0x20,%esp 1082b0: 85 c0 test %eax,%eax 1082b2: 75 54 jne 108308 <== NEVER TAKEN /* our cwd has changed, though - but there is no easy way of return :-( */ rtems_set_errno_and_return_minus_one( errno ); } rtems_filesystem_freenode(&rtems_filesystem_root); 1082b4: 83 ec 0c sub $0xc,%esp 1082b7: a1 d0 62 12 00 mov 0x1262d0,%eax 1082bc: 83 c0 18 add $0x18,%eax 1082bf: 50 push %eax 1082c0: e8 1b 02 00 00 call 1084e0 rtems_filesystem_root = loc; 1082c5: 8b 3d d0 62 12 00 mov 0x1262d0,%edi 1082cb: 83 c7 18 add $0x18,%edi 1082ce: b9 05 00 00 00 mov $0x5,%ecx 1082d3: f3 a5 rep movsl %ds:(%esi),%es:(%edi) return 0; 1082d5: 83 c4 10 add $0x10,%esp 1082d8: 31 c0 xor %eax,%eax } 1082da: 8d 65 f8 lea -0x8(%ebp),%esp 1082dd: 5e pop %esi 1082de: 5f pop %edi 1082df: c9 leave 1082e0: c3 ret 1082e1: 8d 76 00 lea 0x0(%esi),%esi int result; rtems_filesystem_location_info_t loc; /* an automatic call to new private env the first time */ if (rtems_current_user_env == &rtems_global_user_env) { rtems_libio_set_private_env(); /* try to set a new private env*/ 1082e4: e8 a7 12 00 00 call 109590 if (rtems_current_user_env == &rtems_global_user_env) /* not ok */ 1082e9: 81 3d d0 62 12 00 c0 cmpl $0x1285c0,0x1262d0 1082f0: 85 12 00 1082f3: 75 8f jne 108284 rtems_set_errno_and_return_minus_one( ENOTSUP ); 1082f5: e8 12 b8 00 00 call 113b0c <__errno> 1082fa: c7 00 86 00 00 00 movl $0x86,(%eax) 108300: 83 c8 ff or $0xffffffff,%eax 108303: eb d5 jmp 1082da 108305: 8d 76 00 lea 0x0(%esi),%esi } /* clone the new root location */ if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) { /* our cwd has changed, though - but there is no easy way of return :-( */ rtems_set_errno_and_return_minus_one( errno ); 108308: e8 ff b7 00 00 call 113b0c <__errno> 10830d: 89 c6 mov %eax,%esi 10830f: e8 f8 b7 00 00 call 113b0c <__errno> 108314: 8b 00 mov (%eax),%eax 108316: 89 06 mov %eax,(%esi) 108318: b8 ff ff ff ff mov $0xffffffff,%eax 10831d: eb bb jmp 1082da =============================================================================== 0010b454 : int clock_gettime( clockid_t clock_id, struct timespec *tp ) { 10b454: 55 push %ebp 10b455: 89 e5 mov %esp,%ebp 10b457: 83 ec 08 sub $0x8,%esp 10b45a: 8b 45 08 mov 0x8(%ebp),%eax 10b45d: 8b 55 0c mov 0xc(%ebp),%edx if ( !tp ) 10b460: 85 d2 test %edx,%edx 10b462: 74 14 je 10b478 rtems_set_errno_and_return_minus_one( EINVAL ); if ( clock_id == CLOCK_REALTIME ) { 10b464: 83 f8 01 cmp $0x1,%eax 10b467: 74 47 je 10b4b0 _TOD_Get(tp); return 0; } #ifdef CLOCK_MONOTONIC if ( clock_id == CLOCK_MONOTONIC ) { 10b469: 83 f8 04 cmp $0x4,%eax 10b46c: 74 32 je 10b4a0 <== NEVER TAKEN return 0; } #endif #ifdef _POSIX_CPUTIME if ( clock_id == CLOCK_PROCESS_CPUTIME ) { 10b46e: 83 f8 02 cmp $0x2,%eax 10b471: 74 2d je 10b4a0 return 0; } #endif #ifdef _POSIX_THREAD_CPUTIME if ( clock_id == CLOCK_THREAD_CPUTIME ) 10b473: 83 f8 03 cmp $0x3,%eax 10b476: 74 14 je 10b48c rtems_set_errno_and_return_minus_one( ENOSYS ); #endif rtems_set_errno_and_return_minus_one( EINVAL ); 10b478: e8 ef 8d 00 00 call 11426c <__errno> 10b47d: c7 00 16 00 00 00 movl $0x16,(%eax) 10b483: b8 ff ff ff ff mov $0xffffffff,%eax return 0; } 10b488: c9 leave 10b489: c3 ret 10b48a: 66 90 xchg %ax,%ax } #endif #ifdef _POSIX_THREAD_CPUTIME if ( clock_id == CLOCK_THREAD_CPUTIME ) rtems_set_errno_and_return_minus_one( ENOSYS ); 10b48c: e8 db 8d 00 00 call 11426c <__errno> 10b491: c7 00 58 00 00 00 movl $0x58,(%eax) 10b497: b8 ff ff ff ff mov $0xffffffff,%eax #endif rtems_set_errno_and_return_minus_one( EINVAL ); return 0; } 10b49c: c9 leave 10b49d: c3 ret 10b49e: 66 90 xchg %ax,%ax } #endif #ifdef _POSIX_CPUTIME if ( clock_id == CLOCK_PROCESS_CPUTIME ) { _TOD_Get_uptime_as_timespec( tp ); 10b4a0: 83 ec 0c sub $0xc,%esp 10b4a3: 52 push %edx 10b4a4: e8 97 1e 00 00 call 10d340 <_TOD_Get_uptime_as_timespec> return 0; 10b4a9: 83 c4 10 add $0x10,%esp 10b4ac: 31 c0 xor %eax,%eax #endif rtems_set_errno_and_return_minus_one( EINVAL ); return 0; } 10b4ae: c9 leave 10b4af: c3 ret { if ( !tp ) rtems_set_errno_and_return_minus_one( EINVAL ); if ( clock_id == CLOCK_REALTIME ) { _TOD_Get(tp); 10b4b0: 83 ec 0c sub $0xc,%esp 10b4b3: 52 push %edx 10b4b4: e8 33 1e 00 00 call 10d2ec <_TOD_Get> return 0; 10b4b9: 83 c4 10 add $0x10,%esp 10b4bc: 31 c0 xor %eax,%eax #endif rtems_set_errno_and_return_minus_one( EINVAL ); return 0; } 10b4be: c9 leave 10b4bf: c3 ret =============================================================================== 0010b4c0 : int clock_settime( clockid_t clock_id, const struct timespec *tp ) { 10b4c0: 55 push %ebp 10b4c1: 89 e5 mov %esp,%ebp 10b4c3: 83 ec 08 sub $0x8,%esp 10b4c6: 8b 45 08 mov 0x8(%ebp),%eax 10b4c9: 8b 55 0c mov 0xc(%ebp),%edx if ( !tp ) 10b4cc: 85 d2 test %edx,%edx 10b4ce: 74 0f je 10b4df <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); if ( clock_id == CLOCK_REALTIME ) { 10b4d0: 83 f8 01 cmp $0x1,%eax 10b4d3: 74 1f je 10b4f4 _Thread_Disable_dispatch(); _TOD_Set( tp ); _Thread_Enable_dispatch(); } #ifdef _POSIX_CPUTIME else if ( clock_id == CLOCK_PROCESS_CPUTIME ) 10b4d5: 83 f8 02 cmp $0x2,%eax 10b4d8: 74 42 je 10b51c rtems_set_errno_and_return_minus_one( ENOSYS ); #endif #ifdef _POSIX_THREAD_CPUTIME else if ( clock_id == CLOCK_THREAD_CPUTIME ) 10b4da: 83 f8 03 cmp $0x3,%eax 10b4dd: 74 3d je 10b51c rtems_set_errno_and_return_minus_one( ENOSYS ); #endif else rtems_set_errno_and_return_minus_one( EINVAL ); 10b4df: e8 88 8d 00 00 call 11426c <__errno> 10b4e4: c7 00 16 00 00 00 movl $0x16,(%eax) 10b4ea: b8 ff ff ff ff mov $0xffffffff,%eax return 0; } 10b4ef: c9 leave 10b4f0: c3 ret 10b4f1: 8d 76 00 lea 0x0(%esi),%esi { if ( !tp ) rtems_set_errno_and_return_minus_one( EINVAL ); if ( clock_id == CLOCK_REALTIME ) { if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 ) 10b4f4: 81 3a ff e4 da 21 cmpl $0x21dae4ff,(%edx) 10b4fa: 76 e3 jbe 10b4df rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10b4fc: a1 b0 9d 12 00 mov 0x129db0,%eax 10b501: 40 inc %eax 10b502: a3 b0 9d 12 00 mov %eax,0x129db0 rtems_set_errno_and_return_minus_one( EINVAL ); _Thread_Disable_dispatch(); _TOD_Set( tp ); 10b507: 83 ec 0c sub $0xc,%esp 10b50a: 52 push %edx 10b50b: e8 88 1e 00 00 call 10d398 <_TOD_Set> _Thread_Enable_dispatch(); 10b510: e8 8b 33 00 00 call 10e8a0 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( ENOSYS ); #endif else rtems_set_errno_and_return_minus_one( EINVAL ); return 0; 10b515: 83 c4 10 add $0x10,%esp 10b518: 31 c0 xor %eax,%eax } 10b51a: c9 leave 10b51b: c3 ret else if ( clock_id == CLOCK_PROCESS_CPUTIME ) rtems_set_errno_and_return_minus_one( ENOSYS ); #endif #ifdef _POSIX_THREAD_CPUTIME else if ( clock_id == CLOCK_THREAD_CPUTIME ) rtems_set_errno_and_return_minus_one( ENOSYS ); 10b51c: e8 4b 8d 00 00 call 11426c <__errno> 10b521: c7 00 58 00 00 00 movl $0x58,(%eax) 10b527: b8 ff ff ff ff mov $0xffffffff,%eax #endif else rtems_set_errno_and_return_minus_one( EINVAL ); return 0; } 10b52c: c9 leave 10b52d: c3 ret =============================================================================== 0010fc3c : #include int close( int fd ) { 10fc3c: 55 push %ebp 10fc3d: 89 e5 mov %esp,%ebp 10fc3f: 53 push %ebx 10fc40: 83 ec 14 sub $0x14,%esp 10fc43: 8b 45 08 mov 0x8(%ebp),%eax rtems_libio_t *iop; rtems_status_code rc; rtems_libio_check_fd(fd); 10fc46: 3b 05 6c 39 12 00 cmp 0x12396c,%eax 10fc4c: 73 46 jae 10fc94 iop = rtems_libio_iop(fd); 10fc4e: c1 e0 03 shl $0x3,%eax 10fc51: 8d 1c c5 00 00 00 00 lea 0x0(,%eax,8),%ebx 10fc58: 29 c3 sub %eax,%ebx 10fc5a: 03 1d 20 7c 12 00 add 0x127c20,%ebx rtems_libio_check_is_open(iop); 10fc60: f6 43 15 01 testb $0x1,0x15(%ebx) 10fc64: 74 2e je 10fc94 rc = RTEMS_SUCCESSFUL; rc = (*iop->pathinfo.handlers->close_h)( iop ); 10fc66: 83 ec 0c sub $0xc,%esp 10fc69: 8b 43 20 mov 0x20(%ebx),%eax 10fc6c: 53 push %ebx 10fc6d: ff 50 04 call *0x4(%eax) rtems_filesystem_freenode( &iop->pathinfo ); 10fc70: 8d 53 18 lea 0x18(%ebx),%edx 10fc73: 89 14 24 mov %edx,(%esp) 10fc76: 89 45 f4 mov %eax,-0xc(%ebp) 10fc79: e8 22 84 ff ff call 1080a0 rtems_libio_free( iop ); 10fc7e: 89 1c 24 mov %ebx,(%esp) 10fc81: e8 26 02 00 00 call 10feac return rc; 10fc86: 83 c4 10 add $0x10,%esp 10fc89: 8b 45 f4 mov -0xc(%ebp),%eax } 10fc8c: 8b 5d fc mov -0x4(%ebp),%ebx 10fc8f: c9 leave 10fc90: c3 ret 10fc91: 8d 76 00 lea 0x0(%esi),%esi rtems_libio_t *iop; rtems_status_code rc; rtems_libio_check_fd(fd); iop = rtems_libio_iop(fd); rtems_libio_check_is_open(iop); 10fc94: e8 d7 35 00 00 call 113270 <__errno> 10fc99: c7 00 09 00 00 00 movl $0x9,(%eax) 10fc9f: b8 ff ff ff ff mov $0xffffffff,%eax 10fca4: eb e6 jmp 10fc8c =============================================================================== 0010820c : static char *ctermid_name = "/dev/console"; char *ctermid( char *s ) { 10820c: 55 push %ebp 10820d: 89 e5 mov %esp,%ebp 10820f: 57 push %edi 108210: 56 push %esi 108211: 8b 45 08 mov 0x8(%ebp),%eax if ( !s ) 108214: 85 c0 test %eax,%eax 108216: 74 14 je 10822c /* * We have no way of knowing the length of the user provided buffer. * It may not be large enough but there is no way to know that. :( * So this is a potential buffer owerrun that we can do nothing about. */ strcpy( s, ctermid_name ); 108218: be 03 df 11 00 mov $0x11df03,%esi 10821d: b9 0d 00 00 00 mov $0xd,%ecx 108222: 89 c7 mov %eax,%edi 108224: f3 a4 rep movsb %ds:(%esi),%es:(%edi) return s; } 108226: 5e pop %esi 108227: 5f pop %edi 108228: c9 leave 108229: c3 ret 10822a: 66 90 xchg %ax,%ax char *ctermid( char *s ) { if ( !s ) return ctermid_name; 10822c: b8 03 df 11 00 mov $0x11df03,%eax * It may not be large enough but there is no way to know that. :( * So this is a potential buffer owerrun that we can do nothing about. */ strcpy( s, ctermid_name ); return s; } 108231: 5e pop %esi 108232: 5f pop %edi 108233: c9 leave 108234: c3 ret =============================================================================== 0010ee88 : const char *pathname, size_t pathnamelen, int flags, rtems_filesystem_location_info_t *pathloc ) { 10ee88: 55 push %ebp 10ee89: 89 e5 mov %esp,%ebp 10ee8b: 57 push %edi 10ee8c: 56 push %esi 10ee8d: 53 push %ebx 10ee8e: 83 ec 1c sub $0x1c,%esp int i; rtems_device_name_t *device_name_table; /* see if 'flags' is valid */ if ( !rtems_libio_is_valid_perms( flags ) ) 10ee91: f7 45 10 f8 ff ff ff testl $0xfffffff8,0x10(%ebp) 10ee98: 0f 85 96 00 00 00 jne 10ef34 <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EPERM ); /* get the device name table */ device_name_table = (rtems_device_name_t *)pathloc->node_access; 10ee9e: 8b 45 14 mov 0x14(%ebp),%eax 10eea1: 8b 00 mov (%eax),%eax 10eea3: 89 45 e4 mov %eax,-0x1c(%ebp) if (!device_name_table) 10eea6: 85 c0 test %eax,%eax 10eea8: 0f 84 98 00 00 00 je 10ef46 rtems_set_errno_and_return_minus_one( EFAULT ); for (i = 0; i < rtems_device_table_size; i++) { 10eeae: 8b 15 10 15 12 00 mov 0x121510,%edx 10eeb4: 89 55 e0 mov %edx,-0x20(%ebp) 10eeb7: 85 d2 test %edx,%edx 10eeb9: 74 38 je 10eef3 <== NEVER TAKEN 10eebb: 31 c0 xor %eax,%eax 10eebd: 31 db xor %ebx,%ebx if (!device_name_table[i].device_name) 10eebf: 8d 04 80 lea (%eax,%eax,4),%eax 10eec2: 8b 55 e4 mov -0x1c(%ebp),%edx 10eec5: 8d 3c 82 lea (%edx,%eax,4),%edi 10eec8: 8b 37 mov (%edi),%esi 10eeca: 85 f6 test %esi,%esi 10eecc: 74 1d je 10eeeb continue; if (strncmp(pathname, device_name_table[i].device_name, pathnamelen) != 0) 10eece: 50 push %eax 10eecf: ff 75 0c pushl 0xc(%ebp) 10eed2: 56 push %esi 10eed3: ff 75 08 pushl 0x8(%ebp) 10eed6: e8 99 31 00 00 call 112074 10eedb: 83 c4 10 add $0x10,%esp 10eede: 85 c0 test %eax,%eax 10eee0: 75 09 jne 10eeeb continue; if (device_name_table[i].device_name[pathnamelen] != '\0') 10eee2: 8b 45 0c mov 0xc(%ebp),%eax 10eee5: 80 3c 06 00 cmpb $0x0,(%esi,%eax,1) 10eee9: 74 21 je 10ef0c <== ALWAYS TAKEN /* get the device name table */ device_name_table = (rtems_device_name_t *)pathloc->node_access; if (!device_name_table) rtems_set_errno_and_return_minus_one( EFAULT ); for (i = 0; i < rtems_device_table_size; i++) { 10eeeb: 43 inc %ebx 10eeec: 89 d8 mov %ebx,%eax 10eeee: 39 5d e0 cmp %ebx,-0x20(%ebp) 10eef1: 77 cc ja 10eebf pathloc->mt_entry = rtems_filesystem_root.mt_entry; return 0; } /* no such file or directory */ rtems_set_errno_and_return_minus_one( ENOENT ); 10eef3: e8 4c 25 00 00 call 111444 <__errno> 10eef8: c7 00 02 00 00 00 movl $0x2,(%eax) 10eefe: b8 ff ff ff ff mov $0xffffffff,%eax } 10ef03: 8d 65 f4 lea -0xc(%ebp),%esp 10ef06: 5b pop %ebx 10ef07: 5e pop %esi 10ef08: 5f pop %edi 10ef09: c9 leave 10ef0a: c3 ret 10ef0b: 90 nop if (device_name_table[i].device_name[pathnamelen] != '\0') continue; /* find the device, set proper values */ pathloc->node_access = (void *)&device_name_table[i]; 10ef0c: 8b 55 14 mov 0x14(%ebp),%edx 10ef0f: 89 3a mov %edi,(%edx) pathloc->handlers = &devFS_file_handlers; 10ef11: c7 42 08 80 34 12 00 movl $0x123480,0x8(%edx) pathloc->ops = &devFS_ops; 10ef18: c7 42 0c 20 34 12 00 movl $0x123420,0xc(%edx) pathloc->mt_entry = rtems_filesystem_root.mt_entry; 10ef1f: a1 f0 35 12 00 mov 0x1235f0,%eax 10ef24: 8b 40 28 mov 0x28(%eax),%eax 10ef27: 89 42 10 mov %eax,0x10(%edx) return 0; 10ef2a: 31 c0 xor %eax,%eax } /* no such file or directory */ rtems_set_errno_and_return_minus_one( ENOENT ); } 10ef2c: 8d 65 f4 lea -0xc(%ebp),%esp 10ef2f: 5b pop %ebx 10ef30: 5e pop %esi 10ef31: 5f pop %edi 10ef32: c9 leave 10ef33: c3 ret int i; rtems_device_name_t *device_name_table; /* see if 'flags' is valid */ if ( !rtems_libio_is_valid_perms( flags ) ) rtems_set_errno_and_return_minus_one( EPERM ); 10ef34: e8 0b 25 00 00 call 111444 <__errno> <== NOT EXECUTED 10ef39: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED 10ef3f: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10ef44: eb e6 jmp 10ef2c <== NOT EXECUTED /* get the device name table */ device_name_table = (rtems_device_name_t *)pathloc->node_access; if (!device_name_table) rtems_set_errno_and_return_minus_one( EFAULT ); 10ef46: e8 f9 24 00 00 call 111444 <__errno> 10ef4b: c7 00 0e 00 00 00 movl $0xe,(%eax) 10ef51: 83 c8 ff or $0xffffffff,%eax 10ef54: eb d6 jmp 10ef2c =============================================================================== 00107ae0 : int devFS_ioctl( rtems_libio_t *iop, uint32_t command, void *buffer ) { 107ae0: 55 push %ebp 107ae1: 89 e5 mov %esp,%ebp 107ae3: 83 ec 1c sub $0x1c,%esp 107ae6: 8b 55 08 mov 0x8(%ebp),%edx rtems_libio_ioctl_args_t args; rtems_status_code status; rtems_device_name_t *np; np = (rtems_device_name_t *)iop->pathinfo.node_access; 107ae9: 8b 42 18 mov 0x18(%edx),%eax args.iop = iop; 107aec: 89 55 e8 mov %edx,-0x18(%ebp) args.command = command; 107aef: 8b 55 0c mov 0xc(%ebp),%edx 107af2: 89 55 ec mov %edx,-0x14(%ebp) args.buffer = buffer; 107af5: 8b 55 10 mov 0x10(%ebp),%edx 107af8: 89 55 f0 mov %edx,-0x10(%ebp) status = rtems_io_control( np->major, np->minor, (void *) &args 107afb: 8d 55 e8 lea -0x18(%ebp),%edx args.iop = iop; args.command = command; args.buffer = buffer; status = rtems_io_control( 107afe: 52 push %edx 107aff: ff 70 0c pushl 0xc(%eax) 107b02: ff 70 08 pushl 0x8(%eax) 107b05: e8 16 40 00 00 call 10bb20 np->major, np->minor, (void *) &args ); if ( status ) 107b0a: 83 c4 10 add $0x10,%esp 107b0d: 85 c0 test %eax,%eax 107b0f: 75 07 jne 107b18 return rtems_deviceio_errno(status); return args.ioctl_return; 107b11: 8b 45 f4 mov -0xc(%ebp),%eax } 107b14: c9 leave 107b15: c3 ret 107b16: 66 90 xchg %ax,%ax np->minor, (void *) &args ); if ( status ) return rtems_deviceio_errno(status); 107b18: 83 ec 0c sub $0xc,%esp 107b1b: 50 push %eax 107b1c: e8 47 74 00 00 call 10ef68 107b21: 83 c4 10 add $0x10,%esp return args.ioctl_return; } 107b24: c9 leave 107b25: c3 ret =============================================================================== 00107924 : const char *path, mode_t mode, dev_t dev, rtems_filesystem_location_info_t *pathloc ) { 107924: 55 push %ebp 107925: 89 e5 mov %esp,%ebp 107927: 57 push %edi 107928: 56 push %esi 107929: 53 push %ebx 10792a: 83 ec 1c sub $0x1c,%esp 10792d: 8b 7d 08 mov 0x8(%ebp),%edi 107930: 8b 4d 10 mov 0x10(%ebp),%ecx 107933: 8b 55 14 mov 0x14(%ebp),%edx * condition and do not create the '/dev' and the 'path' * actually passed in is 'dev', not '/dev'. Just return 0 to * indicate we are OK. */ if ((path[0] == 'd') && (path[1] == 'e') && 107936: 80 3f 64 cmpb $0x64,(%edi) 107939: 0f 84 dd 00 00 00 je 107a1c (path[2] == 'v') && (path[3] == '\0')) return 0; /* must be a character device or a block device */ if (!S_ISBLK(mode) && !S_ISCHR(mode)) 10793f: 8b 45 0c mov 0xc(%ebp),%eax 107942: 25 00 f0 00 00 and $0xf000,%eax 107947: 3d 00 60 00 00 cmp $0x6000,%eax 10794c: 74 0b je 107959 10794e: 3d 00 20 00 00 cmp $0x2000,%eax 107953: 0f 85 e5 00 00 00 jne 107a3e ) { union __rtems_dev_t temp; temp.device = device; return temp.__overlay.major; 107959: 89 4d dc mov %ecx,-0x24(%ebp) dev_t device ) { union __rtems_dev_t temp; temp.device = device; 10795c: 89 55 d8 mov %edx,-0x28(%ebp) rtems_set_errno_and_return_minus_one( EINVAL ); else rtems_filesystem_split_dev_t(dev, major, minor); /* Find an empty slot in device name table */ device_name_table = (rtems_device_name_t *)pathloc->node_access; 10795f: 8b 45 18 mov 0x18(%ebp),%eax 107962: 8b 30 mov (%eax),%esi if (!device_name_table) 107964: 85 f6 test %esi,%esi 107966: 0f 84 f4 00 00 00 je 107a60 rtems_set_errno_and_return_minus_one( EFAULT ); for (slot = -1, i = 0; i < rtems_device_table_size; i++){ 10796c: 8b 15 10 15 12 00 mov 0x121510,%edx 107972: 85 d2 test %edx,%edx 107974: 0f 84 d6 00 00 00 je 107a50 10797a: 31 c0 xor %eax,%eax 10797c: c7 45 e0 ff ff ff ff movl $0xffffffff,-0x20(%ebp) 107983: 31 db xor %ebx,%ebx 107985: 89 7d e4 mov %edi,-0x1c(%ebp) 107988: 89 d7 mov %edx,%edi 10798a: eb 1a jmp 1079a6 if (device_name_table[i].device_name == NULL) slot = i; else if (strcmp(path, device_name_table[i].device_name) == 0) 10798c: 83 ec 08 sub $0x8,%esp 10798f: 50 push %eax 107990: ff 75 e4 pushl -0x1c(%ebp) 107993: e8 84 a6 00 00 call 11201c 107998: 83 c4 10 add $0x10,%esp 10799b: 85 c0 test %eax,%eax 10799d: 74 65 je 107a04 /* Find an empty slot in device name table */ device_name_table = (rtems_device_name_t *)pathloc->node_access; if (!device_name_table) rtems_set_errno_and_return_minus_one( EFAULT ); for (slot = -1, i = 0; i < rtems_device_table_size; i++){ 10799f: 43 inc %ebx 1079a0: 89 d8 mov %ebx,%eax 1079a2: 39 fb cmp %edi,%ebx 1079a4: 73 16 jae 1079bc if (device_name_table[i].device_name == NULL) 1079a6: 8d 04 80 lea (%eax,%eax,4),%eax 1079a9: 8b 04 86 mov (%esi,%eax,4),%eax 1079ac: 85 c0 test %eax,%eax 1079ae: 75 dc jne 10798c 1079b0: 89 5d e0 mov %ebx,-0x20(%ebp) /* Find an empty slot in device name table */ device_name_table = (rtems_device_name_t *)pathloc->node_access; if (!device_name_table) rtems_set_errno_and_return_minus_one( EFAULT ); for (slot = -1, i = 0; i < rtems_device_table_size; i++){ 1079b3: 43 inc %ebx 1079b4: 89 d8 mov %ebx,%eax 1079b6: 39 fb cmp %edi,%ebx 1079b8: 72 ec jb 1079a6 1079ba: 66 90 xchg %ax,%ax 1079bc: 8b 7d e4 mov -0x1c(%ebp),%edi else if (strcmp(path, device_name_table[i].device_name) == 0) rtems_set_errno_and_return_minus_one( EEXIST ); } if (slot == -1) 1079bf: 83 7d e0 ff cmpl $0xffffffff,-0x20(%ebp) 1079c3: 0f 84 87 00 00 00 je 107a50 <== NEVER TAKEN rtems_set_errno_and_return_minus_one( ENOMEM ); _ISR_Disable(level); 1079c9: 9c pushf 1079ca: fa cli 1079cb: 5b pop %ebx device_name_table[slot].device_name = (char *)path; 1079cc: 8b 55 e0 mov -0x20(%ebp),%edx 1079cf: 8d 04 92 lea (%edx,%edx,4),%eax 1079d2: 8d 14 86 lea (%esi,%eax,4),%edx 1079d5: 89 3a mov %edi,(%edx) device_name_table[slot].device_name_length = strlen(path); 1079d7: 31 c0 xor %eax,%eax 1079d9: b9 ff ff ff ff mov $0xffffffff,%ecx 1079de: f2 ae repnz scas %es:(%edi),%al 1079e0: f7 d1 not %ecx 1079e2: 49 dec %ecx 1079e3: 89 4a 04 mov %ecx,0x4(%edx) device_name_table[slot].major = major; 1079e6: 8b 45 dc mov -0x24(%ebp),%eax 1079e9: 89 42 08 mov %eax,0x8(%edx) device_name_table[slot].minor = minor; 1079ec: 8b 45 d8 mov -0x28(%ebp),%eax 1079ef: 89 42 0c mov %eax,0xc(%edx) device_name_table[slot].mode = mode; 1079f2: 8b 45 0c mov 0xc(%ebp),%eax 1079f5: 89 42 10 mov %eax,0x10(%edx) _ISR_Enable(level); 1079f8: 53 push %ebx 1079f9: 9d popf return 0; 1079fa: 31 c0 xor %eax,%eax } 1079fc: 8d 65 f4 lea -0xc(%ebp),%esp 1079ff: 5b pop %ebx 107a00: 5e pop %esi 107a01: 5f pop %edi 107a02: c9 leave 107a03: c3 ret for (slot = -1, i = 0; i < rtems_device_table_size; i++){ if (device_name_table[i].device_name == NULL) slot = i; else if (strcmp(path, device_name_table[i].device_name) == 0) rtems_set_errno_and_return_minus_one( EEXIST ); 107a04: e8 3b 9a 00 00 call 111444 <__errno> 107a09: c7 00 11 00 00 00 movl $0x11,(%eax) 107a0f: b8 ff ff ff ff mov $0xffffffff,%eax device_name_table[slot].minor = minor; device_name_table[slot].mode = mode; _ISR_Enable(level); return 0; } 107a14: 8d 65 f4 lea -0xc(%ebp),%esp 107a17: 5b pop %ebx 107a18: 5e pop %esi 107a19: 5f pop %edi 107a1a: c9 leave 107a1b: c3 ret * condition and do not create the '/dev' and the 'path' * actually passed in is 'dev', not '/dev'. Just return 0 to * indicate we are OK. */ if ((path[0] == 'd') && (path[1] == 'e') && 107a1c: 80 7f 01 65 cmpb $0x65,0x1(%edi) 107a20: 0f 85 19 ff ff ff jne 10793f <== NEVER TAKEN 107a26: 80 7f 02 76 cmpb $0x76,0x2(%edi) 107a2a: 0f 85 0f ff ff ff jne 10793f <== NEVER TAKEN (path[2] == 'v') && (path[3] == '\0')) 107a30: 80 7f 03 00 cmpb $0x0,0x3(%edi) 107a34: 0f 85 05 ff ff ff jne 10793f return 0; 107a3a: 31 c0 xor %eax,%eax 107a3c: eb be jmp 1079fc /* must be a character device or a block device */ if (!S_ISBLK(mode) && !S_ISCHR(mode)) rtems_set_errno_and_return_minus_one( EINVAL ); 107a3e: e8 01 9a 00 00 call 111444 <__errno> 107a43: c7 00 16 00 00 00 movl $0x16,(%eax) 107a49: b8 ff ff ff ff mov $0xffffffff,%eax 107a4e: eb ac jmp 1079fc if (strcmp(path, device_name_table[i].device_name) == 0) rtems_set_errno_and_return_minus_one( EEXIST ); } if (slot == -1) rtems_set_errno_and_return_minus_one( ENOMEM ); 107a50: e8 ef 99 00 00 call 111444 <__errno> 107a55: c7 00 0c 00 00 00 movl $0xc,(%eax) 107a5b: 83 c8 ff or $0xffffffff,%eax 107a5e: eb 9c jmp 1079fc rtems_filesystem_split_dev_t(dev, major, minor); /* Find an empty slot in device name table */ device_name_table = (rtems_device_name_t *)pathloc->node_access; if (!device_name_table) rtems_set_errno_and_return_minus_one( EFAULT ); 107a60: e8 df 99 00 00 call 111444 <__errno> 107a65: c7 00 0e 00 00 00 movl $0xe,(%eax) 107a6b: 83 c8 ff or $0xffffffff,%eax 107a6e: eb 8c jmp 1079fc =============================================================================== 00112670 : int device_ioctl( rtems_libio_t *iop, uint32_t command, void *buffer ) { 112670: 55 push %ebp 112671: 89 e5 mov %esp,%ebp 112673: 83 ec 1c sub $0x1c,%esp 112676: 8b 45 08 mov 0x8(%ebp),%eax rtems_libio_ioctl_args_t args; rtems_status_code status; IMFS_jnode_t *the_jnode; args.iop = iop; 112679: 89 45 e8 mov %eax,-0x18(%ebp) args.command = command; 11267c: 8b 55 0c mov 0xc(%ebp),%edx 11267f: 89 55 ec mov %edx,-0x14(%ebp) args.buffer = buffer; 112682: 8b 55 10 mov 0x10(%ebp),%edx 112685: 89 55 f0 mov %edx,-0x10(%ebp) the_jnode = iop->pathinfo.node_access; 112688: 8b 40 18 mov 0x18(%eax),%eax status = rtems_io_control( the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args 11268b: 8d 55 e8 lea -0x18(%ebp),%edx args.command = command; args.buffer = buffer; the_jnode = iop->pathinfo.node_access; status = rtems_io_control( 11268e: 52 push %edx 11268f: ff 70 54 pushl 0x54(%eax) 112692: ff 70 50 pushl 0x50(%eax) 112695: e8 fa 08 00 00 call 112f94 the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) 11269a: 83 c4 10 add $0x10,%esp 11269d: 85 c0 test %eax,%eax 11269f: 75 07 jne 1126a8 return rtems_deviceio_errno(status); return args.ioctl_return; 1126a1: 8b 45 f4 mov -0xc(%ebp),%eax } 1126a4: c9 leave 1126a5: c3 ret 1126a6: 66 90 xchg %ax,%ax the_jnode->info.device.minor, (void *) &args ); if ( status ) return rtems_deviceio_errno(status); 1126a8: 83 ec 0c sub $0xc,%esp 1126ab: 50 push %eax 1126ac: e8 33 0b 00 00 call 1131e4 1126b1: 83 c4 10 add $0x10,%esp return args.ioctl_return; } 1126b4: c9 leave 1126b5: c3 ret =============================================================================== 00108fa4 : /* * Drain output queue */ static void drainOutput (struct rtems_termios_tty *tty) { 108fa4: 55 push %ebp 108fa5: 89 e5 mov %esp,%ebp 108fa7: 53 push %ebx 108fa8: 83 ec 04 sub $0x4,%esp 108fab: 89 c3 mov %eax,%ebx rtems_interrupt_level level; rtems_status_code sc; if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) { 108fad: 8b 90 b4 00 00 00 mov 0xb4(%eax),%edx 108fb3: 85 d2 test %edx,%edx 108fb5: 74 4d je 109004 rtems_interrupt_disable (level); 108fb7: 9c pushf 108fb8: fa cli 108fb9: 58 pop %eax while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) { 108fba: 8b 8b 84 00 00 00 mov 0x84(%ebx),%ecx 108fc0: 8b 93 80 00 00 00 mov 0x80(%ebx),%edx 108fc6: 39 d1 cmp %edx,%ecx 108fc8: 74 38 je 109002 108fca: 66 90 xchg %ax,%ax tty->rawOutBufState = rob_wait; 108fcc: c7 83 94 00 00 00 02 movl $0x2,0x94(%ebx) 108fd3: 00 00 00 rtems_interrupt_enable (level); 108fd6: 50 push %eax 108fd7: 9d popf sc = rtems_semaphore_obtain( 108fd8: 50 push %eax 108fd9: 6a 00 push $0x0 108fdb: 6a 00 push $0x0 108fdd: ff b3 8c 00 00 00 pushl 0x8c(%ebx) 108fe3: e8 c8 26 00 00 call 10b6b0 tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) 108fe8: 83 c4 10 add $0x10,%esp 108feb: 85 c0 test %eax,%eax 108fed: 75 1a jne 109009 <== NEVER TAKEN rtems_fatal_error_occurred (sc); rtems_interrupt_disable (level); 108fef: 9c pushf 108ff0: fa cli 108ff1: 58 pop %eax rtems_interrupt_level level; rtems_status_code sc; if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) { rtems_interrupt_disable (level); while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) { 108ff2: 8b 8b 84 00 00 00 mov 0x84(%ebx),%ecx 108ff8: 8b 93 80 00 00 00 mov 0x80(%ebx),%edx 108ffe: 39 d1 cmp %edx,%ecx 109000: 75 ca jne 108fcc <== NEVER TAKEN tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); rtems_interrupt_disable (level); } rtems_interrupt_enable (level); 109002: 50 push %eax 109003: 9d popf } } 109004: 8b 5d fc mov -0x4(%ebp),%ebx 109007: c9 leave 109008: c3 ret tty->rawOutBufState = rob_wait; rtems_interrupt_enable (level); sc = rtems_semaphore_obtain( tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); 109009: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10900c: 50 push %eax <== NOT EXECUTED 10900d: e8 e2 2c 00 00 call 10bcf4 <== NOT EXECUTED =============================================================================== 00109d3c : /* * Echo a typed character */ static void echo (unsigned char c, struct rtems_termios_tty *tty) { 109d3c: 55 push %ebp 109d3d: 89 e5 mov %esp,%ebp 109d3f: 53 push %ebx 109d40: 83 ec 24 sub $0x24,%esp if ((tty->termios.c_lflag & ECHOCTL) && 109d43: f6 42 3d 02 testb $0x2,0x3d(%edx) 109d47: 74 1b je 109d64 <== NEVER TAKEN iscntrl(c) && (c != '\t') && (c != '\n')) { 109d49: 0f b6 c8 movzbl %al,%ecx * Echo a typed character */ static void echo (unsigned char c, struct rtems_termios_tty *tty) { if ((tty->termios.c_lflag & ECHOCTL) && 109d4c: 8b 1d 94 5a 12 00 mov 0x125a94,%ebx 109d52: f6 44 0b 01 20 testb $0x20,0x1(%ebx,%ecx,1) 109d57: 74 0b je 109d64 iscntrl(c) && (c != '\t') && (c != '\n')) { 109d59: 3c 09 cmp $0x9,%al 109d5b: 74 07 je 109d64 109d5d: 3c 0a cmp $0xa,%al 109d5f: 75 13 jne 109d74 109d61: 8d 76 00 lea 0x0(%esi),%esi echobuf[0] = '^'; echobuf[1] = c ^ 0x40; rtems_termios_puts (echobuf, 2, tty); tty->column += 2; } else { oproc (c, tty); 109d64: 0f b6 c0 movzbl %al,%eax 109d67: e8 94 fe ff ff call 109c00 } } 109d6c: 8b 5d fc mov -0x4(%ebp),%ebx 109d6f: c9 leave 109d70: c3 ret 109d71: 8d 76 00 lea 0x0(%esi),%esi { if ((tty->termios.c_lflag & ECHOCTL) && iscntrl(c) && (c != '\t') && (c != '\n')) { char echobuf[2]; echobuf[0] = '^'; 109d74: c6 45 f6 5e movb $0x5e,-0xa(%ebp) echobuf[1] = c ^ 0x40; 109d78: 83 f0 40 xor $0x40,%eax 109d7b: 88 45 f7 mov %al,-0x9(%ebp) rtems_termios_puts (echobuf, 2, tty); 109d7e: 53 push %ebx 109d7f: 52 push %edx 109d80: 6a 02 push $0x2 109d82: 8d 45 f6 lea -0xa(%ebp),%eax 109d85: 50 push %eax 109d86: 89 55 e4 mov %edx,-0x1c(%ebp) 109d89: e8 3e fd ff ff call 109acc tty->column += 2; 109d8e: 8b 55 e4 mov -0x1c(%ebp),%edx 109d91: 83 42 28 02 addl $0x2,0x28(%edx) */ static void echo (unsigned char c, struct rtems_termios_tty *tty) { if ((tty->termios.c_lflag & ECHOCTL) && iscntrl(c) && (c != '\t') && (c != '\n')) { 109d95: 83 c4 10 add $0x10,%esp rtems_termios_puts (echobuf, 2, tty); tty->column += 2; } else { oproc (c, tty); } } 109d98: 8b 5d fc mov -0x4(%ebp),%ebx 109d9b: c9 leave 109d9c: c3 ret =============================================================================== 00108f64 : void endgrent(void) { 108f64: 55 push %ebp 108f65: 89 e5 mov %esp,%ebp 108f67: 83 ec 08 sub $0x8,%esp if (group_fp != NULL) 108f6a: a1 00 93 12 00 mov 0x129300,%eax 108f6f: 85 c0 test %eax,%eax 108f71: 74 0c je 108f7f <== NEVER TAKEN fclose(group_fp); 108f73: 83 ec 0c sub $0xc,%esp 108f76: 50 push %eax 108f77: e8 ac b2 00 00 call 114228 108f7c: 83 c4 10 add $0x10,%esp } 108f7f: c9 leave 108f80: c3 ret =============================================================================== 00108e0c : void endpwent(void) { 108e0c: 55 push %ebp 108e0d: 89 e5 mov %esp,%ebp 108e0f: 83 ec 08 sub $0x8,%esp if (passwd_fp != NULL) 108e12: a1 e8 93 12 00 mov 0x1293e8,%eax 108e17: 85 c0 test %eax,%eax 108e19: 74 0c je 108e27 <== NEVER TAKEN fclose(passwd_fp); 108e1b: 83 ec 0c sub $0xc,%esp 108e1e: 50 push %eax 108e1f: e8 04 b4 00 00 call 114228 108e24: 83 c4 10 add $0x10,%esp } 108e27: c9 leave 108e28: c3 ret =============================================================================== 00109da0 : * FIXME: Needs support for WERASE and ECHOPRT. * FIXME: Some of the tests should check for IEXTEN, too. */ static void erase (struct rtems_termios_tty *tty, int lineFlag) { 109da0: 55 push %ebp 109da1: 89 e5 mov %esp,%ebp 109da3: 57 push %edi 109da4: 56 push %esi 109da5: 53 push %ebx 109da6: 83 ec 1c sub $0x1c,%esp 109da9: 89 c3 mov %eax,%ebx 109dab: 89 d7 mov %edx,%edi if (tty->ccount == 0) 109dad: 8b 48 20 mov 0x20(%eax),%ecx 109db0: 85 c9 test %ecx,%ecx 109db2: 0f 84 84 00 00 00 je 109e3c return; if (lineFlag) { 109db8: 85 d2 test %edx,%edx 109dba: 0f 85 84 00 00 00 jne 109e44 echo ('\n', tty); return; } } while (tty->ccount) { 109dc0: 8b 50 3c mov 0x3c(%eax),%edx 109dc3: 89 7d e4 mov %edi,-0x1c(%ebp) 109dc6: eb 1d jmp 109de5 rtems_termios_puts ("\b", 1, tty); tty->column--; } } else { if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) { 109dc8: 80 e6 02 and $0x2,%dh <== NOT EXECUTED 109dcb: 0f 85 37 01 00 00 jne 109f08 <== NOT EXECUTED 109dd1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if (tty->column) tty->column--; } } } if (!lineFlag) 109dd4: 8b 75 e4 mov -0x1c(%ebp),%esi 109dd7: 85 f6 test %esi,%esi 109dd9: 74 61 je 109e3c <== NEVER TAKEN echo ('\n', tty); return; } } while (tty->ccount) { 109ddb: 8b 4b 20 mov 0x20(%ebx),%ecx 109dde: 85 c9 test %ecx,%ecx 109de0: 74 5a je 109e3c } if (!(tty->termios.c_lflag & ECHOE)) { tty->ccount = 0; echo (tty->termios.c_cc[VKILL], tty); if (tty->termios.c_lflag & ECHOK) echo ('\n', tty); 109de2: 8b 53 3c mov 0x3c(%ebx),%edx return; } } while (tty->ccount) { unsigned char c = tty->cbuf[--tty->ccount]; 109de5: 8b 7b 1c mov 0x1c(%ebx),%edi 109de8: 49 dec %ecx 109de9: 89 4b 20 mov %ecx,0x20(%ebx) 109dec: 8a 04 0f mov (%edi,%ecx,1),%al if (tty->termios.c_lflag & ECHO) { 109def: f6 c2 08 test $0x8,%dl 109df2: 74 e0 je 109dd4 <== NEVER TAKEN if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) { 109df4: 8b 75 e4 mov -0x1c(%ebp),%esi 109df7: 85 f6 test %esi,%esi 109df9: 75 09 jne 109e04 109dfb: f6 c2 10 test $0x10,%dl 109dfe: 0f 84 f0 00 00 00 je 109ef4 <== NEVER TAKEN echo (tty->termios.c_cc[VERASE], tty); } else if (c == '\t') { 109e04: 3c 09 cmp $0x9,%al 109e06: 74 58 je 109e60 rtems_termios_puts ("\b", 1, tty); tty->column--; } } else { if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) { 109e08: 0f b6 c0 movzbl %al,%eax 109e0b: 8d 70 01 lea 0x1(%eax),%esi 109e0e: a1 94 5a 12 00 mov 0x125a94,%eax 109e13: f6 04 30 20 testb $0x20,(%eax,%esi,1) 109e17: 75 af jne 109dc8 <== NEVER TAKEN rtems_termios_puts ("\b \b", 3, tty); if (tty->column) tty->column--; } if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) { rtems_termios_puts ("\b \b", 3, tty); 109e19: 57 push %edi 109e1a: 53 push %ebx 109e1b: 6a 03 push $0x3 109e1d: 68 06 14 12 00 push $0x121406 109e22: e8 a5 fc ff ff call 109acc if (tty->column) 109e27: 8b 43 28 mov 0x28(%ebx),%eax 109e2a: 83 c4 10 add $0x10,%esp 109e2d: 85 c0 test %eax,%eax 109e2f: 74 a3 je 109dd4 <== NEVER TAKEN tty->column--; 109e31: 48 dec %eax 109e32: 89 43 28 mov %eax,0x28(%ebx) } } } if (!lineFlag) 109e35: 8b 75 e4 mov -0x1c(%ebp),%esi 109e38: 85 f6 test %esi,%esi 109e3a: 75 9f jne 109ddb break; } } 109e3c: 8d 65 f4 lea -0xc(%ebp),%esp 109e3f: 5b pop %ebx 109e40: 5e pop %esi 109e41: 5f pop %edi 109e42: c9 leave 109e43: c3 ret erase (struct rtems_termios_tty *tty, int lineFlag) { if (tty->ccount == 0) return; if (lineFlag) { if (!(tty->termios.c_lflag & ECHO)) { 109e44: 8b 50 3c mov 0x3c(%eax),%edx 109e47: f6 c2 08 test $0x8,%dl 109e4a: 0f 84 94 00 00 00 je 109ee4 <== NEVER TAKEN tty->ccount = 0; return; } if (!(tty->termios.c_lflag & ECHOE)) { 109e50: f6 c2 10 test $0x10,%dl 109e53: 0f 84 eb 00 00 00 je 109f44 <== NEVER TAKEN 109e59: 89 7d e4 mov %edi,-0x1c(%ebp) 109e5c: eb 87 jmp 109de5 109e5e: 66 90 xchg %ax,%ax if (tty->termios.c_lflag & ECHO) { if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) { echo (tty->termios.c_cc[VERASE], tty); } else if (c == '\t') { int col = tty->read_start_column; 109e60: 8b 73 2c mov 0x2c(%ebx),%esi int i = 0; /* * Find the character before the tab */ while (i != tty->ccount) { 109e63: 85 c9 test %ecx,%ecx 109e65: 74 46 je 109ead c = tty->cbuf[i++]; if (c == '\t') { col = (col | 7) + 1; } else if (iscntrl (c)) { 109e67: a1 94 5a 12 00 mov 0x125a94,%eax 109e6c: 89 45 dc mov %eax,-0x24(%ebp) if (tty->termios.c_lflag & ECHO) { if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) { echo (tty->termios.c_cc[VERASE], tty); } else if (c == '\t') { int col = tty->read_start_column; int i = 0; 109e6f: 31 c0 xor %eax,%eax while (i != tty->ccount) { c = tty->cbuf[i++]; if (c == '\t') { col = (col | 7) + 1; } else if (iscntrl (c)) { if (tty->termios.c_lflag & ECHOCTL) 109e71: 81 e2 00 02 00 00 and $0x200,%edx 109e77: 89 55 e0 mov %edx,-0x20(%ebp) 109e7a: 89 5d d8 mov %ebx,-0x28(%ebp) 109e7d: 8b 5d dc mov -0x24(%ebp),%ebx 109e80: eb 10 jmp 109e92 109e82: 66 90 xchg %ax,%ax 109e84: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED 109e87: 85 d2 test %edx,%edx <== NOT EXECUTED 109e89: 74 03 je 109e8e <== NOT EXECUTED col += 2; 109e8b: 83 c6 02 add $0x2,%esi <== NOT EXECUTED int i = 0; /* * Find the character before the tab */ while (i != tty->ccount) { 109e8e: 39 c1 cmp %eax,%ecx 109e90: 74 18 je 109eaa <== NEVER TAKEN c = tty->cbuf[i++]; 109e92: 8a 14 07 mov (%edi,%eax,1),%dl 109e95: 40 inc %eax if (c == '\t') { 109e96: 80 fa 09 cmp $0x9,%dl 109e99: 74 41 je 109edc col = (col | 7) + 1; } else if (iscntrl (c)) { 109e9b: 0f b6 d2 movzbl %dl,%edx 109e9e: f6 44 13 01 20 testb $0x20,0x1(%ebx,%edx,1) 109ea3: 75 df jne 109e84 <== NEVER TAKEN if (tty->termios.c_lflag & ECHOCTL) col += 2; } else { col++; 109ea5: 46 inc %esi int i = 0; /* * Find the character before the tab */ while (i != tty->ccount) { 109ea6: 39 c1 cmp %eax,%ecx 109ea8: 75 e8 jne 109e92 109eaa: 8b 5d d8 mov -0x28(%ebp),%ebx } /* * Back up over the tab */ while (tty->column > col) { 109ead: 3b 73 28 cmp 0x28(%ebx),%esi 109eb0: 0f 8d 1e ff ff ff jge 109dd4 <== NEVER TAKEN 109eb6: 66 90 xchg %ax,%ax rtems_termios_puts ("\b", 1, tty); 109eb8: 52 push %edx 109eb9: 53 push %ebx 109eba: 6a 01 push $0x1 109ebc: 68 08 14 12 00 push $0x121408 109ec1: e8 06 fc ff ff call 109acc tty->column--; 109ec6: 8b 43 28 mov 0x28(%ebx),%eax 109ec9: 48 dec %eax 109eca: 89 43 28 mov %eax,0x28(%ebx) } /* * Back up over the tab */ while (tty->column > col) { 109ecd: 83 c4 10 add $0x10,%esp 109ed0: 39 f0 cmp %esi,%eax 109ed2: 7f e4 jg 109eb8 109ed4: e9 fb fe ff ff jmp 109dd4 109ed9: 8d 76 00 lea 0x0(%esi),%esi * Find the character before the tab */ while (i != tty->ccount) { c = tty->cbuf[i++]; if (c == '\t') { col = (col | 7) + 1; 109edc: 83 ce 07 or $0x7,%esi 109edf: 46 inc %esi 109ee0: eb ac jmp 109e8e 109ee2: 66 90 xchg %ax,%ax { if (tty->ccount == 0) return; if (lineFlag) { if (!(tty->termios.c_lflag & ECHO)) { tty->ccount = 0; 109ee4: c7 40 20 00 00 00 00 movl $0x0,0x20(%eax) <== NOT EXECUTED } } if (!lineFlag) break; } } 109eeb: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109eee: 5b pop %ebx <== NOT EXECUTED 109eef: 5e pop %esi <== NOT EXECUTED 109ef0: 5f pop %edi <== NOT EXECUTED 109ef1: c9 leave <== NOT EXECUTED 109ef2: c3 ret <== NOT EXECUTED 109ef3: 90 nop <== NOT EXECUTED while (tty->ccount) { unsigned char c = tty->cbuf[--tty->ccount]; if (tty->termios.c_lflag & ECHO) { if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) { echo (tty->termios.c_cc[VERASE], tty); 109ef4: 0f b6 43 43 movzbl 0x43(%ebx),%eax <== NOT EXECUTED 109ef8: 89 da mov %ebx,%edx <== NOT EXECUTED } } if (!lineFlag) break; } } 109efa: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109efd: 5b pop %ebx <== NOT EXECUTED 109efe: 5e pop %esi <== NOT EXECUTED 109eff: 5f pop %edi <== NOT EXECUTED 109f00: c9 leave <== NOT EXECUTED while (tty->ccount) { unsigned char c = tty->cbuf[--tty->ccount]; if (tty->termios.c_lflag & ECHO) { if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) { echo (tty->termios.c_cc[VERASE], tty); 109f01: e9 36 fe ff ff jmp 109d3c <== NOT EXECUTED 109f06: 66 90 xchg %ax,%ax <== NOT EXECUTED tty->column--; } } else { if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) { rtems_termios_puts ("\b \b", 3, tty); 109f08: 50 push %eax <== NOT EXECUTED 109f09: 53 push %ebx <== NOT EXECUTED 109f0a: 6a 03 push $0x3 <== NOT EXECUTED 109f0c: 68 06 14 12 00 push $0x121406 <== NOT EXECUTED 109f11: e8 b6 fb ff ff call 109acc <== NOT EXECUTED if (tty->column) 109f16: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 109f19: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109f1c: 85 c0 test %eax,%eax <== NOT EXECUTED 109f1e: 74 04 je 109f24 <== NOT EXECUTED tty->column--; 109f20: 48 dec %eax <== NOT EXECUTED 109f21: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED } if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) { 109f24: a1 94 5a 12 00 mov 0x125a94,%eax <== NOT EXECUTED 109f29: f6 04 30 20 testb $0x20,(%eax,%esi,1) <== NOT EXECUTED 109f2d: 0f 84 e6 fe ff ff je 109e19 <== NOT EXECUTED 109f33: f6 43 3d 02 testb $0x2,0x3d(%ebx) <== NOT EXECUTED 109f37: 0f 85 dc fe ff ff jne 109e19 <== NOT EXECUTED 109f3d: e9 92 fe ff ff jmp 109dd4 <== NOT EXECUTED 109f42: 66 90 xchg %ax,%ax <== NOT EXECUTED if (!(tty->termios.c_lflag & ECHO)) { tty->ccount = 0; return; } if (!(tty->termios.c_lflag & ECHOE)) { tty->ccount = 0; 109f44: c7 40 20 00 00 00 00 movl $0x0,0x20(%eax) <== NOT EXECUTED echo (tty->termios.c_cc[VKILL], tty); 109f4b: 0f b6 40 44 movzbl 0x44(%eax),%eax <== NOT EXECUTED 109f4f: 89 da mov %ebx,%edx <== NOT EXECUTED 109f51: e8 e6 fd ff ff call 109d3c <== NOT EXECUTED if (tty->termios.c_lflag & ECHOK) 109f56: f6 43 3c 20 testb $0x20,0x3c(%ebx) <== NOT EXECUTED 109f5a: 0f 84 dc fe ff ff je 109e3c <== NOT EXECUTED echo ('\n', tty); 109f60: 89 da mov %ebx,%edx <== NOT EXECUTED 109f62: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 109f67: eb 91 jmp 109efa <== NOT EXECUTED =============================================================================== 00108b30 : #include int fchdir( int fd ) { 108b30: 55 push %ebp 108b31: 89 e5 mov %esp,%ebp 108b33: 57 push %edi 108b34: 56 push %esi 108b35: 53 push %ebx 108b36: 83 ec 4c sub $0x4c,%esp 108b39: 8b 45 08 mov 0x8(%ebp),%eax rtems_libio_t *iop; rtems_filesystem_location_info_t loc, saved; rtems_libio_check_fd( fd ); 108b3c: 3b 05 ac 4d 12 00 cmp 0x124dac,%eax 108b42: 0f 83 d0 00 00 00 jae 108c18 iop = rtems_libio_iop( fd ); 108b48: c1 e0 03 shl $0x3,%eax 108b4b: 8d 1c c5 00 00 00 00 lea 0x0(,%eax,8),%ebx 108b52: 29 c3 sub %eax,%ebx 108b54: 03 1d 60 90 12 00 add 0x129060,%ebx rtems_libio_check_is_open(iop); 108b5a: 8b 43 14 mov 0x14(%ebx),%eax 108b5d: f6 c4 01 test $0x1,%ah 108b60: 0f 84 b2 00 00 00 je 108c18 /* * Now process the fchmod(). */ rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ ); 108b66: a8 02 test $0x2,%al 108b68: 0f 84 be 00 00 00 je 108c2c /* * Verify you can change directory into this node. */ if ( (*iop->pathinfo.ops->node_type_h)( &iop->pathinfo ) != 108b6e: 83 ec 0c sub $0xc,%esp 108b71: 8b 43 24 mov 0x24(%ebx),%eax 108b74: 83 c3 18 add $0x18,%ebx 108b77: 53 push %ebx 108b78: ff 50 10 call *0x10(%eax) 108b7b: 83 c4 10 add $0x10,%esp 108b7e: 48 dec %eax 108b7f: 75 67 jne 108be8 * but note the race condition. Threads who * share their rtems_filesystem_current better * be synchronized! */ saved = rtems_filesystem_current; 108b81: a1 d0 6d 12 00 mov 0x126dd0,%eax 108b86: 8d 55 c0 lea -0x40(%ebp),%edx 108b89: 89 55 b4 mov %edx,-0x4c(%ebp) 108b8c: 8d 70 04 lea 0x4(%eax),%esi 108b8f: b9 05 00 00 00 mov $0x5,%ecx 108b94: 89 d7 mov %edx,%edi 108b96: f3 a5 rep movsl %ds:(%esi),%es:(%edi) rtems_filesystem_current = iop->pathinfo; 108b98: 8d 78 04 lea 0x4(%eax),%edi 108b9b: b1 05 mov $0x5,%cl 108b9d: 89 de mov %ebx,%esi 108b9f: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* clone the current node */ if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) { 108ba1: 83 ec 0c sub $0xc,%esp 108ba4: 6a 00 push $0x0 108ba6: 8d 75 d4 lea -0x2c(%ebp),%esi 108ba9: 56 push %esi 108baa: 6a 00 push $0x0 108bac: 6a 01 push $0x1 108bae: 68 d6 2c 12 00 push $0x122cd6 108bb3: e8 a0 fe ff ff call 108a58 108bb8: 83 c4 20 add $0x20,%esp 108bbb: 85 c0 test %eax,%eax 108bbd: 75 3d jne 108bfc /* cloning failed; restore original and bail out */ rtems_filesystem_current = saved; return -1; } /* release the old one */ rtems_filesystem_freenode( &saved ); 108bbf: 83 ec 0c sub $0xc,%esp 108bc2: 8d 45 c0 lea -0x40(%ebp),%eax 108bc5: 50 push %eax 108bc6: e8 61 01 00 00 call 108d2c rtems_filesystem_current = loc; 108bcb: 8b 3d d0 6d 12 00 mov 0x126dd0,%edi 108bd1: 83 c7 04 add $0x4,%edi 108bd4: b9 05 00 00 00 mov $0x5,%ecx 108bd9: f3 a5 rep movsl %ds:(%esi),%es:(%edi) return 0; 108bdb: 83 c4 10 add $0x10,%esp 108bde: 31 c0 xor %eax,%eax } 108be0: 8d 65 f4 lea -0xc(%ebp),%esp 108be3: 5b pop %ebx 108be4: 5e pop %esi 108be5: 5f pop %edi 108be6: c9 leave 108be7: c3 ret * Verify you can change directory into this node. */ if ( (*iop->pathinfo.ops->node_type_h)( &iop->pathinfo ) != RTEMS_FILESYSTEM_DIRECTORY ) { rtems_set_errno_and_return_minus_one( ENOTDIR ); 108be8: e8 33 b5 00 00 call 114120 <__errno> 108bed: c7 00 14 00 00 00 movl $0x14,(%eax) 108bf3: b8 ff ff ff ff mov $0xffffffff,%eax 108bf8: eb e6 jmp 108be0 108bfa: 66 90 xchg %ax,%ax rtems_filesystem_current = iop->pathinfo; /* clone the current node */ if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) { /* cloning failed; restore original and bail out */ rtems_filesystem_current = saved; 108bfc: 8b 3d d0 6d 12 00 mov 0x126dd0,%edi 108c02: 83 c7 04 add $0x4,%edi 108c05: b9 05 00 00 00 mov $0x5,%ecx 108c0a: 8b 75 b4 mov -0x4c(%ebp),%esi 108c0d: f3 a5 rep movsl %ds:(%esi),%es:(%edi) return -1; 108c0f: b8 ff ff ff ff mov $0xffffffff,%eax 108c14: eb ca jmp 108be0 108c16: 66 90 xchg %ax,%ax rtems_libio_t *iop; rtems_filesystem_location_info_t loc, saved; rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open(iop); 108c18: e8 03 b5 00 00 call 114120 <__errno> 108c1d: c7 00 09 00 00 00 movl $0x9,(%eax) 108c23: b8 ff ff ff ff mov $0xffffffff,%eax 108c28: eb b6 jmp 108be0 108c2a: 66 90 xchg %ax,%ax /* * Now process the fchmod(). */ rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ ); 108c2c: e8 ef b4 00 00 call 114120 <__errno> 108c31: c7 00 16 00 00 00 movl $0x16,(%eax) 108c37: b8 ff ff ff ff mov $0xffffffff,%eax 108c3c: eb a2 jmp 108be0 =============================================================================== 00108c40 : int fchmod( int fd, mode_t mode ) { 108c40: 55 push %ebp 108c41: 89 e5 mov %esp,%ebp 108c43: 83 ec 08 sub $0x8,%esp 108c46: 8b 45 08 mov 0x8(%ebp),%eax 108c49: 8b 4d 0c mov 0xc(%ebp),%ecx rtems_libio_t *iop; rtems_libio_check_fd( fd ); 108c4c: 3b 05 ac 4d 12 00 cmp 0x124dac,%eax 108c52: 73 38 jae 108c8c iop = rtems_libio_iop( fd ); 108c54: 8d 14 c5 00 00 00 00 lea 0x0(,%eax,8),%edx 108c5b: 8d 04 d5 00 00 00 00 lea 0x0(,%edx,8),%eax 108c62: 29 d0 sub %edx,%eax 108c64: 03 05 60 90 12 00 add 0x129060,%eax rtems_libio_check_is_open(iop); 108c6a: 8b 50 14 mov 0x14(%eax),%edx 108c6d: f6 c6 01 test $0x1,%dh 108c70: 74 1a je 108c8c /* * Now process the fchmod(). */ rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 108c72: 83 e2 04 and $0x4,%edx 108c75: 74 29 je 108ca0 return (*iop->pathinfo.handlers->fchmod_h)( &iop->pathinfo, mode ); 108c77: 8b 50 20 mov 0x20(%eax),%edx 108c7a: 89 4d 0c mov %ecx,0xc(%ebp) 108c7d: 83 c0 18 add $0x18,%eax 108c80: 89 45 08 mov %eax,0x8(%ebp) 108c83: 8b 42 1c mov 0x1c(%edx),%eax } 108c86: c9 leave * Now process the fchmod(). */ rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); return (*iop->pathinfo.handlers->fchmod_h)( &iop->pathinfo, mode ); 108c87: ff e0 jmp *%eax 108c89: 8d 76 00 lea 0x0(%esi),%esi { rtems_libio_t *iop; rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open(iop); 108c8c: e8 8f b4 00 00 call 114120 <__errno> 108c91: c7 00 09 00 00 00 movl $0x9,(%eax) */ rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); return (*iop->pathinfo.handlers->fchmod_h)( &iop->pathinfo, mode ); } 108c97: b8 ff ff ff ff mov $0xffffffff,%eax 108c9c: c9 leave 108c9d: c3 ret 108c9e: 66 90 xchg %ax,%ax /* * Now process the fchmod(). */ rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 108ca0: e8 7b b4 00 00 call 114120 <__errno> 108ca5: c7 00 16 00 00 00 movl $0x16,(%eax) 108cab: eb ea jmp 108c97 =============================================================================== 00108ae0 : int fcntl( int fd, int cmd, ... ) { 108ae0: 55 push %ebp 108ae1: 89 e5 mov %esp,%ebp 108ae3: 57 push %edi 108ae4: 56 push %esi 108ae5: 53 push %ebx 108ae6: 83 ec 1c sub $0x1c,%esp 108ae9: 8b 5d 08 mov 0x8(%ebp),%ebx 108aec: 8b 55 0c mov 0xc(%ebp),%edx int ret; va_list ap; va_start( ap, cmd ); 108aef: 8d 7d 10 lea 0x10(%ebp),%edi int fd2; int flags; int mask; int ret = 0; rtems_libio_check_fd( fd ); 108af2: 8b 0d ac 55 12 00 mov 0x1255ac,%ecx 108af8: 39 cb cmp %ecx,%ebx 108afa: 0f 83 5c 01 00 00 jae 108c5c iop = rtems_libio_iop( fd ); 108b00: a1 60 98 12 00 mov 0x129860,%eax 108b05: 8d 34 dd 00 00 00 00 lea 0x0(,%ebx,8),%esi 108b0c: 8d 1c f5 00 00 00 00 lea 0x0(,%esi,8),%ebx 108b13: 29 f3 sub %esi,%ebx 108b15: 8d 1c 18 lea (%eax,%ebx,1),%ebx rtems_libio_check_is_open(iop); 108b18: 8b 73 14 mov 0x14(%ebx),%esi 108b1b: f7 c6 00 01 00 00 test $0x100,%esi 108b21: 0f 84 35 01 00 00 je 108c5c /* * This switch should contain all the cases from POSIX. */ switch ( cmd ) { 108b27: 83 fa 09 cmp $0x9,%edx 108b2a: 76 10 jbe 108b3c errno = ENOTSUP; ret = -1; break; default: errno = EINVAL; 108b2c: e8 9f b8 00 00 call 1143d0 <__errno> 108b31: c7 00 16 00 00 00 movl $0x16,(%eax) 108b37: eb 16 jmp 108b4f 108b39: 8d 76 00 lea 0x0(%esi),%esi /* * This switch should contain all the cases from POSIX. */ switch ( cmd ) { 108b3c: ff 24 95 f0 2e 12 00 jmp *0x122ef0(,%edx,4) 108b43: 90 nop errno = ENOTSUP; ret = -1; break; case F_GETOWN: /* for sockets. */ errno = ENOTSUP; 108b44: e8 87 b8 00 00 call 1143d0 <__errno> 108b49: c7 00 86 00 00 00 movl $0x86,(%eax) if (ret >= 0) { int err = (*iop->pathinfo.handlers->fcntl_h)( cmd, iop ); if (err) { errno = err; ret = -1; 108b4f: be ff ff ff ff mov $0xffffffff,%esi va_list ap; va_start( ap, cmd ); ret = vfcntl(fd,cmd,ap); va_end(ap); return ret; } 108b54: 89 f0 mov %esi,%eax 108b56: 8d 65 f4 lea -0xc(%ebp),%esp 108b59: 5b pop %ebx 108b5a: 5e pop %esi 108b5b: 5f pop %edi 108b5c: c9 leave 108b5d: c3 ret 108b5e: 66 90 xchg %ax,%ax case F_GETFL: /* more flags (cloexec) */ ret = rtems_libio_to_fcntl_flags( iop->flags ); break; case F_SETFL: flags = rtems_libio_fcntl_flags( va_arg( ap, int ) ); 108b60: 83 ec 0c sub $0xc,%esp 108b63: ff 37 pushl (%edi) 108b65: 89 55 e0 mov %edx,-0x20(%ebp) 108b68: e8 33 05 00 00 call 1090a0 /* * XXX If we are turning on append, should we seek to the end? */ iop->flags = (iop->flags & ~mask) | (flags & mask); 108b6d: 25 01 02 00 00 and $0x201,%eax 108b72: 8b 4b 14 mov 0x14(%ebx),%ecx 108b75: 81 e1 fe fd ff ff and $0xfffffdfe,%ecx 108b7b: 09 c8 or %ecx,%eax 108b7d: 89 43 14 mov %eax,0x14(%ebx) 108b80: 83 c4 10 add $0x10,%esp rtems_libio_t *iop; rtems_libio_t *diop; int fd2; int flags; int mask; int ret = 0; 108b83: 31 f6 xor %esi,%esi 108b85: 8b 55 e0 mov -0x20(%ebp),%edx * If we got this far successfully, then we give the optional * filesystem specific handler a chance to process this. */ if (ret >= 0) { int err = (*iop->pathinfo.handlers->fcntl_h)( cmd, iop ); 108b88: 83 ec 08 sub $0x8,%esp 108b8b: 8b 43 20 mov 0x20(%ebx),%eax 108b8e: 53 push %ebx 108b8f: 52 push %edx 108b90: ff 50 30 call *0x30(%eax) 108b93: 89 c3 mov %eax,%ebx if (err) { 108b95: 83 c4 10 add $0x10,%esp 108b98: 85 c0 test %eax,%eax 108b9a: 74 b8 je 108b54 <== ALWAYS TAKEN errno = err; 108b9c: e8 2f b8 00 00 call 1143d0 <__errno> <== NOT EXECUTED 108ba1: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 108ba3: eb aa jmp 108b4f <== NOT EXECUTED 108ba5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED else iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC; break; case F_GETFL: /* more flags (cloexec) */ ret = rtems_libio_to_fcntl_flags( iop->flags ); 108ba8: 83 ec 0c sub $0xc,%esp 108bab: 56 push %esi 108bac: 89 55 e0 mov %edx,-0x20(%ebp) 108baf: e8 24 05 00 00 call 1090d8 108bb4: 89 c6 mov %eax,%esi 108bb6: 83 c4 10 add $0x10,%esp 108bb9: 8b 55 e0 mov -0x20(%ebp),%edx /* * If we got this far successfully, then we give the optional * filesystem specific handler a chance to process this. */ if (ret >= 0) { 108bbc: 85 f6 test %esi,%esi 108bbe: 79 c8 jns 108b88 <== ALWAYS TAKEN 108bc0: eb 92 jmp 108b54 <== NOT EXECUTED 108bc2: 66 90 xchg %ax,%ax <== NOT EXECUTED * if a new process is exec()'ed. Since RTEMS does not support * processes, then we can ignore this one except to make * F_GETFD work. */ if ( va_arg( ap, int ) ) 108bc4: 8b 07 mov (%edi),%eax 108bc6: 85 c0 test %eax,%eax 108bc8: 74 6a je 108c34 iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC; 108bca: 81 ce 00 08 00 00 or $0x800,%esi 108bd0: 89 73 14 mov %esi,0x14(%ebx) rtems_libio_t *iop; rtems_libio_t *diop; int fd2; int flags; int mask; int ret = 0; 108bd3: 31 f6 xor %esi,%esi 108bd5: eb b1 jmp 108b88 108bd7: 90 nop diop->pathinfo = iop->pathinfo; ret = (int) (diop - rtems_libio_iops); break; case F_GETFD: /* get f_flags */ ret = ((iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0); 108bd8: 31 c0 xor %eax,%eax 108bda: f7 c6 00 08 00 00 test $0x800,%esi 108be0: 0f 95 c0 setne %al 108be3: 89 c6 mov %eax,%esi 108be5: eb a1 jmp 108b88 108be7: 90 nop * This switch should contain all the cases from POSIX. */ switch ( cmd ) { case F_DUPFD: /* dup */ fd2 = va_arg( ap, int ); 108be8: 8b 3f mov (%edi),%edi if ( fd2 ) 108bea: 85 ff test %edi,%edi 108bec: 0f 84 82 00 00 00 je 108c74 diop = rtems_libio_iop( fd2 ); 108bf2: 39 f9 cmp %edi,%ecx 108bf4: 77 4e ja 108c44 <== ALWAYS TAKEN 108bf6: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) <== NOT EXECUTED 108bfd: 31 ff xor %edi,%edi <== NOT EXECUTED ret = -1; break; } } diop->flags = iop->flags; 108bff: 89 77 14 mov %esi,0x14(%edi) diop->pathinfo = iop->pathinfo; 108c02: 83 c7 18 add $0x18,%edi 108c05: 8d 73 18 lea 0x18(%ebx),%esi 108c08: b9 05 00 00 00 mov $0x5,%ecx 108c0d: f3 a5 rep movsl %ds:(%esi),%es:(%edi) ret = (int) (diop - rtems_libio_iops); 108c0f: 8b 4d e4 mov -0x1c(%ebp),%ecx 108c12: 29 c1 sub %eax,%ecx 108c14: 89 c8 mov %ecx,%eax 108c16: c1 f8 03 sar $0x3,%eax 108c19: 8d 0c c0 lea (%eax,%eax,8),%ecx 108c1c: 8d 0c c8 lea (%eax,%ecx,8),%ecx 108c1f: 8d 0c c8 lea (%eax,%ecx,8),%ecx 108c22: 8d 0c c8 lea (%eax,%ecx,8),%ecx 108c25: 89 ce mov %ecx,%esi 108c27: c1 e6 0f shl $0xf,%esi 108c2a: 01 f1 add %esi,%ecx 108c2c: 8d 34 c8 lea (%eax,%ecx,8),%esi 108c2f: f7 de neg %esi 108c31: eb 89 jmp 108bbc 108c33: 90 nop */ if ( va_arg( ap, int ) ) iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC; else iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC; 108c34: 81 e6 ff f7 ff ff and $0xfffff7ff,%esi 108c3a: 89 73 14 mov %esi,0x14(%ebx) rtems_libio_t *iop; rtems_libio_t *diop; int fd2; int flags; int mask; int ret = 0; 108c3d: 31 f6 xor %esi,%esi 108c3f: e9 44 ff ff ff jmp 108b88 switch ( cmd ) { case F_DUPFD: /* dup */ fd2 = va_arg( ap, int ); if ( fd2 ) diop = rtems_libio_iop( fd2 ); 108c44: 8d 0c fd 00 00 00 00 lea 0x0(,%edi,8),%ecx 108c4b: 8d 3c cd 00 00 00 00 lea 0x0(,%ecx,8),%edi 108c52: 29 cf sub %ecx,%edi 108c54: 8d 3c 38 lea (%eax,%edi,1),%edi 108c57: 89 7d e4 mov %edi,-0x1c(%ebp) 108c5a: eb a3 jmp 108bff int mask; int ret = 0; rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open(iop); 108c5c: e8 6f b7 00 00 call 1143d0 <__errno> 108c61: c7 00 09 00 00 00 movl $0x9,(%eax) 108c67: be ff ff ff ff mov $0xffffffff,%esi 108c6c: e9 e3 fe ff ff jmp 108b54 108c71: 8d 76 00 lea 0x0(%esi),%esi fd2 = va_arg( ap, int ); if ( fd2 ) diop = rtems_libio_iop( fd2 ); else { /* allocate a file control block */ diop = rtems_libio_allocate(); 108c74: 89 55 e0 mov %edx,-0x20(%ebp) 108c77: e8 a0 04 00 00 call 10911c 108c7c: 89 c7 mov %eax,%edi if ( diop == 0 ) { 108c7e: 85 c0 test %eax,%eax 108c80: 8b 55 e0 mov -0x20(%ebp),%edx 108c83: 0f 84 c6 fe ff ff je 108b4f <== NEVER TAKEN 108c89: 8b 73 14 mov 0x14(%ebx),%esi 108c8c: 89 45 e4 mov %eax,-0x1c(%ebp) 108c8f: a1 60 98 12 00 mov 0x129860,%eax 108c94: e9 66 ff ff ff jmp 108bff =============================================================================== 00108cbc : #include int fdatasync( int fd ) { 108cbc: 55 push %ebp 108cbd: 89 e5 mov %esp,%ebp 108cbf: 83 ec 08 sub $0x8,%esp 108cc2: 8b 45 08 mov 0x8(%ebp),%eax rtems_libio_t *iop; rtems_libio_check_fd( fd ); 108cc5: 3b 05 ac 55 12 00 cmp 0x1255ac,%eax 108ccb: 73 2f jae 108cfc iop = rtems_libio_iop( fd ); 108ccd: 8d 14 c5 00 00 00 00 lea 0x0(,%eax,8),%edx 108cd4: 8d 04 d5 00 00 00 00 lea 0x0(,%edx,8),%eax 108cdb: 29 d0 sub %edx,%eax 108cdd: 03 05 60 98 12 00 add 0x129860,%eax rtems_libio_check_is_open(iop); 108ce3: 8b 50 14 mov 0x14(%eax),%edx 108ce6: f6 c6 01 test $0x1,%dh 108ce9: 74 11 je 108cfc rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 108ceb: 83 e2 04 and $0x4,%edx 108cee: 74 20 je 108d10 /* * Now process the fdatasync(). */ return (*iop->pathinfo.handlers->fdatasync_h)( iop ); 108cf0: 8b 50 20 mov 0x20(%eax),%edx 108cf3: 89 45 08 mov %eax,0x8(%ebp) 108cf6: 8b 42 2c mov 0x2c(%edx),%eax } 108cf9: c9 leave /* * Now process the fdatasync(). */ return (*iop->pathinfo.handlers->fdatasync_h)( iop ); 108cfa: ff e0 jmp *%eax { rtems_libio_t *iop; rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open(iop); 108cfc: e8 cf b6 00 00 call 1143d0 <__errno> 108d01: c7 00 09 00 00 00 movl $0x9,(%eax) /* * Now process the fdatasync(). */ return (*iop->pathinfo.handlers->fdatasync_h)( iop ); } 108d07: b8 ff ff ff ff mov $0xffffffff,%eax 108d0c: c9 leave 108d0d: c3 ret 108d0e: 66 90 xchg %ax,%ax rtems_libio_t *iop; rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open(iop); rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 108d10: e8 bb b6 00 00 call 1143d0 <__errno> 108d15: c7 00 16 00 00 00 movl $0x16,(%eax) 108d1b: eb ea jmp 108d07 =============================================================================== 00111aa0 : */ int fifo_open( pipe_control_t **pipep, rtems_libio_t *iop ) { 111aa0: 55 push %ebp 111aa1: 89 e5 mov %esp,%ebp 111aa3: 57 push %edi 111aa4: 56 push %esi 111aa5: 53 push %ebx 111aa6: 83 ec 2c sub $0x2c,%esp 111aa9: 8b 75 08 mov 0x8(%ebp),%esi static rtems_status_code pipe_lock(void) { rtems_status_code sc = RTEMS_SUCCESSFUL; if (pipe_semaphore == RTEMS_ID_NONE) { 111aac: a1 0c a4 12 00 mov 0x12a40c,%eax 111ab1: 85 c0 test %eax,%eax 111ab3: 0f 84 8b 00 00 00 je 111b44 rtems_libio_unlock(); } if (sc == RTEMS_SUCCESSFUL) { sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 111ab9: 53 push %ebx 111aba: 6a 00 push $0x0 111abc: 6a 00 push $0x0 111abe: 50 push %eax 111abf: e8 10 ba ff ff call 10d4d4 } if (sc == RTEMS_SUCCESSFUL) { 111ac4: 83 c4 10 add $0x10,%esp 111ac7: 85 c0 test %eax,%eax 111ac9: 0f 85 4c 03 00 00 jne 111e1b <== NEVER TAKEN err = pipe_lock(); if (err) return err; pipe = *pipep; 111acf: 8b 1e mov (%esi),%ebx if (pipe == NULL) { 111ad1: 85 db test %ebx,%ebx 111ad3: 0f 84 df 01 00 00 je 111cb8 err = pipe_alloc(&pipe); if (err) goto out; } if (! PIPE_LOCK(pipe)) 111ad9: 52 push %edx 111ada: 6a 00 push $0x0 111adc: 6a 00 push $0x0 111ade: ff 73 28 pushl 0x28(%ebx) 111ae1: e8 ee b9 ff ff call 10d4d4 111ae6: 83 c4 10 add $0x10,%esp 111ae9: 83 f8 01 cmp $0x1,%eax 111aec: 19 ff sbb %edi,%edi 111aee: f7 d7 not %edi 111af0: 83 e7 fc and $0xfffffffc,%edi err = -EINTR; if (*pipep == NULL) { 111af3: 8b 06 mov (%esi),%eax 111af5: 85 c0 test %eax,%eax 111af7: 0f 84 d7 02 00 00 je 111dd4 else *pipep = pipe; } out: pipe_unlock(); 111afd: e8 aa fe ff ff call 1119ac pipe_control_t *pipe; unsigned int prevCounter; int err; err = pipe_new(pipep); if (err) 111b02: 85 ff test %edi,%edi 111b04: 75 32 jne 111b38 <== NEVER TAKEN return err; pipe = *pipep; 111b06: 8b 1e mov (%esi),%ebx switch (LIBIO_ACCMODE(iop)) { 111b08: 8b 55 0c mov 0xc(%ebp),%edx 111b0b: 8b 42 14 mov 0x14(%edx),%eax 111b0e: 83 e0 06 and $0x6,%eax 111b11: 83 f8 04 cmp $0x4,%eax 111b14: 74 6a je 111b80 111b16: 83 f8 06 cmp $0x6,%eax 111b19: 0f 84 59 01 00 00 je 111c78 111b1f: 83 f8 02 cmp $0x2,%eax 111b22: 0f 84 dc 00 00 00 je 111c04 <== ALWAYS TAKEN if (pipe->Writers ++ == 0) PIPE_WAKEUPREADERS(pipe); break; } PIPE_UNLOCK(pipe); 111b28: 83 ec 0c sub $0xc,%esp 111b2b: ff 73 28 pushl 0x28(%ebx) 111b2e: e8 9d ba ff ff call 10d5d0 return 0; 111b33: 83 c4 10 add $0x10,%esp 111b36: 31 ff xor %edi,%edi out_error: pipe_release(pipep, iop); return err; } 111b38: 89 f8 mov %edi,%eax 111b3a: 8d 65 f4 lea -0xc(%ebp),%esp 111b3d: 5b pop %ebx 111b3e: 5e pop %esi 111b3f: 5f pop %edi 111b40: c9 leave 111b41: c3 ret 111b42: 66 90 xchg %ax,%ax rtems_status_code rtems_libio_set_private_env(void); rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ; static inline void rtems_libio_lock( void ) { rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); 111b44: 50 push %eax 111b45: 6a 00 push $0x0 111b47: 6a 00 push $0x0 111b49: ff 35 28 a6 12 00 pushl 0x12a628 111b4f: e8 80 b9 ff ff call 10d4d4 rtems_status_code sc = RTEMS_SUCCESSFUL; if (pipe_semaphore == RTEMS_ID_NONE) { rtems_libio_lock(); if (pipe_semaphore == RTEMS_ID_NONE) { 111b54: 83 c4 10 add $0x10,%esp 111b57: 8b 3d 0c a4 12 00 mov 0x12a40c,%edi 111b5d: 85 ff test %edi,%edi 111b5f: 0f 84 83 02 00 00 je 111de8 <== ALWAYS TAKEN } static inline void rtems_libio_unlock( void ) { rtems_semaphore_release( rtems_libio_semaphore ); 111b65: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111b68: ff 35 28 a6 12 00 pushl 0x12a628 <== NOT EXECUTED 111b6e: e8 5d ba ff ff call 10d5d0 <== NOT EXECUTED 111b73: a1 0c a4 12 00 mov 0x12a40c,%eax <== NOT EXECUTED 111b78: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111b7b: e9 39 ff ff ff jmp 111ab9 <== NOT EXECUTED } while (prevCounter == pipe->writerCounter); } break; case LIBIO_FLAGS_WRITE: pipe->writerCounter ++; 111b80: ff 43 24 incl 0x24(%ebx) if (pipe->Writers ++ == 0) 111b83: 8b 43 14 mov 0x14(%ebx),%eax 111b86: 8d 50 01 lea 0x1(%eax),%edx 111b89: 89 53 14 mov %edx,0x14(%ebx) 111b8c: 85 c0 test %eax,%eax 111b8e: 0f 84 c4 02 00 00 je 111e58 <== ALWAYS TAKEN PIPE_WAKEUPREADERS(pipe); if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) { 111b94: 8b 4b 10 mov 0x10(%ebx),%ecx 111b97: 85 c9 test %ecx,%ecx 111b99: 75 8d jne 111b28 111b9b: 8b 55 0c mov 0xc(%ebp),%edx 111b9e: f6 42 14 01 testb $0x1,0x14(%edx) 111ba2: 0f 85 04 03 00 00 jne 111eac err = -ENXIO; goto out_error; } if (pipe->Readers == 0) { prevCounter = pipe->readerCounter; 111ba8: 8b 7b 20 mov 0x20(%ebx),%edi 111bab: eb 20 jmp 111bcd 111bad: 8d 76 00 lea 0x0(%esi),%esi err = -EINTR; do { PIPE_UNLOCK(pipe); if (! PIPE_WRITEWAIT(pipe)) goto out_error; if (! PIPE_LOCK(pipe)) 111bb0: 51 push %ecx 111bb1: 6a 00 push $0x0 111bb3: 6a 00 push $0x0 111bb5: ff 73 28 pushl 0x28(%ebx) 111bb8: e8 17 b9 ff ff call 10d4d4 111bbd: 83 c4 10 add $0x10,%esp 111bc0: 85 c0 test %eax,%eax 111bc2: 75 27 jne 111beb <== NEVER TAKEN goto out_error; } while (prevCounter == pipe->readerCounter); 111bc4: 39 7b 20 cmp %edi,0x20(%ebx) 111bc7: 0f 85 5b ff ff ff jne 111b28 <== ALWAYS TAKEN if (pipe->Readers == 0) { prevCounter = pipe->readerCounter; err = -EINTR; do { PIPE_UNLOCK(pipe); 111bcd: 83 ec 0c sub $0xc,%esp 111bd0: ff 73 28 pushl 0x28(%ebx) 111bd3: e8 f8 b9 ff ff call 10d5d0 if (! PIPE_WRITEWAIT(pipe)) 111bd8: 58 pop %eax 111bd9: 5a pop %edx 111bda: 6a 00 push $0x0 111bdc: ff 73 30 pushl 0x30(%ebx) 111bdf: e8 b0 1c 00 00 call 113894 111be4: 83 c4 10 add $0x10,%esp 111be7: 85 c0 test %eax,%eax 111be9: 74 c5 je 111bb0 <== ALWAYS TAKEN goto out_error; } if (pipe->Readers == 0) { prevCounter = pipe->readerCounter; err = -EINTR; 111beb: bf fc ff ff ff mov $0xfffffffc,%edi <== NOT EXECUTED PIPE_UNLOCK(pipe); return 0; out_error: pipe_release(pipep, iop); 111bf0: 83 ec 08 sub $0x8,%esp 111bf3: ff 75 0c pushl 0xc(%ebp) 111bf6: 56 push %esi 111bf7: e8 c8 fd ff ff call 1119c4 return err; 111bfc: 83 c4 10 add $0x10,%esp 111bff: e9 34 ff ff ff jmp 111b38 return err; pipe = *pipep; switch (LIBIO_ACCMODE(iop)) { case LIBIO_FLAGS_READ: pipe->readerCounter ++; 111c04: ff 43 20 incl 0x20(%ebx) if (pipe->Readers ++ == 0) 111c07: 8b 43 10 mov 0x10(%ebx),%eax 111c0a: 8d 50 01 lea 0x1(%eax),%edx 111c0d: 89 53 10 mov %edx,0x10(%ebx) 111c10: 85 c0 test %eax,%eax 111c12: 0f 84 10 02 00 00 je 111e28 <== ALWAYS TAKEN PIPE_WAKEUPWRITERS(pipe); if (pipe->Writers == 0) { 111c18: 8b 7b 14 mov 0x14(%ebx),%edi 111c1b: 85 ff test %edi,%edi 111c1d: 0f 85 05 ff ff ff jne 111b28 /* Not an error */ if (LIBIO_NODELAY(iop)) 111c23: 8b 45 0c mov 0xc(%ebp),%eax 111c26: f6 40 14 01 testb $0x1,0x14(%eax) 111c2a: 0f 85 f8 fe ff ff jne 111b28 break; prevCounter = pipe->writerCounter; 111c30: 8b 7b 24 mov 0x24(%ebx),%edi 111c33: eb 20 jmp 111c55 111c35: 8d 76 00 lea 0x0(%esi),%esi /* Wait until a writer opens the pipe */ do { PIPE_UNLOCK(pipe); if (! PIPE_READWAIT(pipe)) goto out_error; if (! PIPE_LOCK(pipe)) 111c38: 50 push %eax 111c39: 6a 00 push $0x0 111c3b: 6a 00 push $0x0 111c3d: ff 73 28 pushl 0x28(%ebx) 111c40: e8 8f b8 ff ff call 10d4d4 111c45: 83 c4 10 add $0x10,%esp 111c48: 85 c0 test %eax,%eax 111c4a: 75 9f jne 111beb <== NEVER TAKEN goto out_error; } while (prevCounter == pipe->writerCounter); 111c4c: 39 7b 24 cmp %edi,0x24(%ebx) 111c4f: 0f 85 d3 fe ff ff jne 111b28 <== ALWAYS TAKEN prevCounter = pipe->writerCounter; err = -EINTR; /* Wait until a writer opens the pipe */ do { PIPE_UNLOCK(pipe); 111c55: 83 ec 0c sub $0xc,%esp 111c58: ff 73 28 pushl 0x28(%ebx) 111c5b: e8 70 b9 ff ff call 10d5d0 if (! PIPE_READWAIT(pipe)) 111c60: 5a pop %edx 111c61: 59 pop %ecx 111c62: 6a 00 push $0x0 111c64: ff 73 2c pushl 0x2c(%ebx) 111c67: e8 28 1c 00 00 call 113894 111c6c: 83 c4 10 add $0x10,%esp 111c6f: 85 c0 test %eax,%eax 111c71: 74 c5 je 111c38 <== ALWAYS TAKEN 111c73: e9 73 ff ff ff jmp 111beb <== NOT EXECUTED } while (prevCounter == pipe->readerCounter); } break; case LIBIO_FLAGS_READ_WRITE: pipe->readerCounter ++; 111c78: ff 43 20 incl 0x20(%ebx) if (pipe->Readers ++ == 0) 111c7b: 8b 43 10 mov 0x10(%ebx),%eax 111c7e: 8d 50 01 lea 0x1(%eax),%edx 111c81: 89 53 10 mov %edx,0x10(%ebx) 111c84: 85 c0 test %eax,%eax 111c86: 0f 84 b4 01 00 00 je 111e40 <== ALWAYS TAKEN PIPE_WAKEUPWRITERS(pipe); pipe->writerCounter ++; 111c8c: ff 43 24 incl 0x24(%ebx) if (pipe->Writers ++ == 0) 111c8f: 8b 43 14 mov 0x14(%ebx),%eax 111c92: 8d 50 01 lea 0x1(%eax),%edx 111c95: 89 53 14 mov %edx,0x14(%ebx) 111c98: 85 c0 test %eax,%eax 111c9a: 0f 85 88 fe ff ff jne 111b28 <== NEVER TAKEN PIPE_WAKEUPREADERS(pipe); 111ca0: 83 ec 08 sub $0x8,%esp 111ca3: 8d 45 e4 lea -0x1c(%ebp),%eax 111ca6: 50 push %eax 111ca7: ff 73 2c pushl 0x2c(%ebx) 111caa: e8 81 1b 00 00 call 113830 111caf: 83 c4 10 add $0x10,%esp 111cb2: e9 71 fe ff ff jmp 111b28 111cb7: 90 nop { static char c = 'a'; pipe_control_t *pipe; int err = -ENOMEM; pipe = malloc(sizeof(pipe_control_t)); 111cb8: 83 ec 0c sub $0xc,%esp 111cbb: 6a 34 push $0x34 111cbd: e8 fe 83 ff ff call 10a0c0 111cc2: 89 c3 mov %eax,%ebx 111cc4: 89 45 d4 mov %eax,-0x2c(%ebp) if (pipe == NULL) 111cc7: 83 c4 10 add $0x10,%esp 111cca: 85 c0 test %eax,%eax 111ccc: 0f 84 32 02 00 00 je 111f04 return err; memset(pipe, 0, sizeof(pipe_control_t)); 111cd2: b9 34 00 00 00 mov $0x34,%ecx 111cd7: 31 c0 xor %eax,%eax 111cd9: 89 df mov %ebx,%edi 111cdb: f3 aa rep stos %al,%es:(%edi) pipe->Size = PIPE_BUF; 111cdd: c7 43 04 00 02 00 00 movl $0x200,0x4(%ebx) pipe->Buffer = malloc(pipe->Size); 111ce4: 83 ec 0c sub $0xc,%esp 111ce7: 68 00 02 00 00 push $0x200 111cec: e8 cf 83 ff ff call 10a0c0 111cf1: 89 03 mov %eax,(%ebx) if (! pipe->Buffer) 111cf3: 83 c4 10 add $0x10,%esp 111cf6: 85 c0 test %eax,%eax 111cf8: 0f 84 f8 01 00 00 je 111ef6 <== NEVER TAKEN goto err_buf; err = -ENOMEM; if (rtems_barrier_create( 111cfe: 8d 43 2c lea 0x2c(%ebx),%eax 111d01: 50 push %eax 111d02: 6a 00 push $0x0 111d04: 6a 00 push $0x0 rtems_build_name ('P', 'I', 'r', c), 111d06: 0f be 05 98 83 12 00 movsbl 0x128398,%eax if (! pipe->Buffer) goto err_buf; err = -ENOMEM; if (rtems_barrier_create( 111d0d: 0d 00 72 49 50 or $0x50497200,%eax 111d12: 50 push %eax 111d13: e8 9c 19 00 00 call 1136b4 111d18: 83 c4 10 add $0x10,%esp 111d1b: 85 c0 test %eax,%eax 111d1d: 0f 85 c3 01 00 00 jne 111ee6 rtems_build_name ('P', 'I', 'r', c), RTEMS_BARRIER_MANUAL_RELEASE, 0, &pipe->readBarrier) != RTEMS_SUCCESSFUL) goto err_rbar; if (rtems_barrier_create( 111d23: 8d 43 30 lea 0x30(%ebx),%eax 111d26: 50 push %eax 111d27: 6a 00 push $0x0 111d29: 6a 00 push $0x0 rtems_build_name ('P', 'I', 'w', c), 111d2b: 0f be 05 98 83 12 00 movsbl 0x128398,%eax if (rtems_barrier_create( rtems_build_name ('P', 'I', 'r', c), RTEMS_BARRIER_MANUAL_RELEASE, 0, &pipe->readBarrier) != RTEMS_SUCCESSFUL) goto err_rbar; if (rtems_barrier_create( 111d32: 0d 00 77 49 50 or $0x50497700,%eax 111d37: 50 push %eax 111d38: e8 77 19 00 00 call 1136b4 111d3d: 83 c4 10 add $0x10,%esp 111d40: 85 c0 test %eax,%eax 111d42: 0f 85 8d 01 00 00 jne 111ed5 rtems_build_name ('P', 'I', 'w', c), RTEMS_BARRIER_MANUAL_RELEASE, 0, &pipe->writeBarrier) != RTEMS_SUCCESSFUL) goto err_wbar; if (rtems_semaphore_create( 111d48: 83 ec 0c sub $0xc,%esp 111d4b: 8d 43 28 lea 0x28(%ebx),%eax 111d4e: 50 push %eax 111d4f: 6a 00 push $0x0 111d51: 6a 10 push $0x10 111d53: 6a 01 push $0x1 rtems_build_name ('P', 'I', 's', c), 1, 111d55: 0f be 05 98 83 12 00 movsbl 0x128398,%eax if (rtems_barrier_create( rtems_build_name ('P', 'I', 'w', c), RTEMS_BARRIER_MANUAL_RELEASE, 0, &pipe->writeBarrier) != RTEMS_SUCCESSFUL) goto err_wbar; if (rtems_semaphore_create( 111d5c: 0d 00 73 49 50 or $0x50497300,%eax 111d61: 50 push %eax 111d62: e8 f1 b4 ff ff call 10d258 111d67: 83 c4 20 add $0x20,%esp 111d6a: 85 c0 test %eax,%eax 111d6c: 0f 85 52 01 00 00 jne 111ec4 Objects_Id id, Objects_Locations *location ) { return (Barrier_Control *) _Objects_Get( &_Barrier_Information, id, location ); 111d72: 51 push %ecx /* Set barriers to be interruptible by signals. */ static void pipe_interruptible(pipe_control_t *pipe) { Objects_Locations location; _Barrier_Get(pipe->readBarrier, &location)->Barrier.Wait_queue.state 111d73: 8d 7d e0 lea -0x20(%ebp),%edi 111d76: 57 push %edi 111d77: ff 73 2c pushl 0x2c(%ebx) 111d7a: 68 80 b1 12 00 push $0x12b180 111d7f: e8 90 ce ff ff call 10ec14 <_Objects_Get> |= STATES_INTERRUPTIBLE_BY_SIGNAL; 111d84: 81 48 4c 00 00 00 10 orl $0x10000000,0x4c(%eax) _Thread_Enable_dispatch(); 111d8b: e8 2c da ff ff call 10f7bc <_Thread_Enable_dispatch> 111d90: 83 c4 0c add $0xc,%esp 111d93: 57 push %edi 111d94: ff 73 30 pushl 0x30(%ebx) 111d97: 68 80 b1 12 00 push $0x12b180 111d9c: e8 73 ce ff ff call 10ec14 <_Objects_Get> _Barrier_Get(pipe->writeBarrier, &location)->Barrier.Wait_queue.state |= STATES_INTERRUPTIBLE_BY_SIGNAL; 111da1: 81 48 4c 00 00 00 10 orl $0x10000000,0x4c(%eax) _Thread_Enable_dispatch(); 111da8: e8 0f da ff ff call 10f7bc <_Thread_Enable_dispatch> #ifdef RTEMS_POSIX_API pipe_interruptible(pipe); #endif *pipep = pipe; if (c ++ == 'z') 111dad: a0 98 83 12 00 mov 0x128398,%al 111db2: 8d 50 01 lea 0x1(%eax),%edx 111db5: 88 15 98 83 12 00 mov %dl,0x128398 111dbb: 83 c4 10 add $0x10,%esp 111dbe: 3c 7a cmp $0x7a,%al 111dc0: 0f 85 13 fd ff ff jne 111ad9 c = 'a'; 111dc6: c6 05 98 83 12 00 61 movb $0x61,0x128398 111dcd: e9 07 fd ff ff jmp 111ad9 111dd2: 66 90 xchg %ax,%ax if (! PIPE_LOCK(pipe)) err = -EINTR; if (*pipep == NULL) { if (err) 111dd4: 85 ff test %edi,%edi 111dd6: 0f 85 94 00 00 00 jne 111e70 <== NEVER TAKEN pipe_free(pipe); else *pipep = pipe; 111ddc: 89 1e mov %ebx,(%esi) } out: pipe_unlock(); 111dde: e8 c9 fb ff ff call 1119ac 111de3: e9 1e fd ff ff jmp 111b06 if (pipe_semaphore == RTEMS_ID_NONE) { rtems_libio_lock(); if (pipe_semaphore == RTEMS_ID_NONE) { sc = rtems_semaphore_create( 111de8: 83 ec 0c sub $0xc,%esp 111deb: 68 0c a4 12 00 push $0x12a40c 111df0: 6a 00 push $0x0 111df2: 6a 54 push $0x54 111df4: 6a 01 push $0x1 111df6: 68 45 50 49 50 push $0x50495045 111dfb: e8 58 b4 ff ff call 10d258 111e00: 89 c3 mov %eax,%ebx 111e02: 83 c4 14 add $0x14,%esp 111e05: ff 35 28 a6 12 00 pushl 0x12a628 111e0b: e8 c0 b7 ff ff call 10d5d0 } rtems_libio_unlock(); } if (sc == RTEMS_SUCCESSFUL) { 111e10: 83 c4 10 add $0x10,%esp 111e13: 85 db test %ebx,%ebx 111e15: 0f 84 f0 00 00 00 je 111f0b ) { pipe_control_t *pipe; int err = 0; err = pipe_lock(); 111e1b: bf f4 ff ff ff mov $0xfffffff4,%edi 111e20: e9 13 fd ff ff jmp 111b38 111e25: 8d 76 00 lea 0x0(%esi),%esi switch (LIBIO_ACCMODE(iop)) { case LIBIO_FLAGS_READ: pipe->readerCounter ++; if (pipe->Readers ++ == 0) PIPE_WAKEUPWRITERS(pipe); 111e28: 83 ec 08 sub $0x8,%esp 111e2b: 8d 45 e4 lea -0x1c(%ebp),%eax 111e2e: 50 push %eax 111e2f: ff 73 30 pushl 0x30(%ebx) 111e32: e8 f9 19 00 00 call 113830 111e37: 83 c4 10 add $0x10,%esp 111e3a: e9 d9 fd ff ff jmp 111c18 111e3f: 90 nop break; case LIBIO_FLAGS_READ_WRITE: pipe->readerCounter ++; if (pipe->Readers ++ == 0) PIPE_WAKEUPWRITERS(pipe); 111e40: 83 ec 08 sub $0x8,%esp 111e43: 8d 45 e4 lea -0x1c(%ebp),%eax 111e46: 50 push %eax 111e47: ff 73 30 pushl 0x30(%ebx) 111e4a: e8 e1 19 00 00 call 113830 111e4f: 83 c4 10 add $0x10,%esp 111e52: e9 35 fe ff ff jmp 111c8c 111e57: 90 nop case LIBIO_FLAGS_WRITE: pipe->writerCounter ++; if (pipe->Writers ++ == 0) PIPE_WAKEUPREADERS(pipe); 111e58: 83 ec 08 sub $0x8,%esp 111e5b: 8d 45 e4 lea -0x1c(%ebp),%eax 111e5e: 50 push %eax 111e5f: ff 73 2c pushl 0x2c(%ebx) 111e62: e8 c9 19 00 00 call 113830 111e67: 83 c4 10 add $0x10,%esp 111e6a: e9 25 fd ff ff jmp 111b94 111e6f: 90 nop /* Called with pipe_semaphore held. */ static inline void pipe_free( pipe_control_t *pipe ) { rtems_barrier_delete(pipe->readBarrier); 111e70: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111e73: ff 73 2c pushl 0x2c(%ebx) <== NOT EXECUTED 111e76: e8 25 19 00 00 call 1137a0 <== NOT EXECUTED rtems_barrier_delete(pipe->writeBarrier); 111e7b: 59 pop %ecx <== NOT EXECUTED 111e7c: ff 73 30 pushl 0x30(%ebx) <== NOT EXECUTED 111e7f: e8 1c 19 00 00 call 1137a0 <== NOT EXECUTED rtems_semaphore_delete(pipe->Semaphore); 111e84: 5a pop %edx <== NOT EXECUTED 111e85: ff 73 28 pushl 0x28(%ebx) <== NOT EXECUTED 111e88: e8 a3 b5 ff ff call 10d430 <== NOT EXECUTED free(pipe->Buffer); 111e8d: 58 pop %eax <== NOT EXECUTED 111e8e: ff 33 pushl (%ebx) <== NOT EXECUTED 111e90: e8 3b 7b ff ff call 1099d0 <== NOT EXECUTED free(pipe); 111e95: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 111e98: e8 33 7b ff ff call 1099d0 <== NOT EXECUTED 111e9d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED else *pipep = pipe; } out: pipe_unlock(); 111ea0: e8 07 fb ff ff call 1119ac 111ea5: e9 8e fc ff ff jmp 111b38 111eaa: 66 90 xchg %ax,%ax if (pipe->Writers ++ == 0) PIPE_WAKEUPREADERS(pipe); if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) { PIPE_UNLOCK(pipe); 111eac: 83 ec 0c sub $0xc,%esp 111eaf: ff 73 28 pushl 0x28(%ebx) 111eb2: e8 19 b7 ff ff call 10d5d0 err = -ENXIO; goto out_error; 111eb7: 83 c4 10 add $0x10,%esp if (pipe->Writers ++ == 0) PIPE_WAKEUPREADERS(pipe); if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) { PIPE_UNLOCK(pipe); err = -ENXIO; 111eba: bf fa ff ff ff mov $0xfffffffa,%edi goto out_error; 111ebf: e9 2c fd ff ff jmp 111bf0 if (c ++ == 'z') c = 'a'; return 0; err_sem: rtems_barrier_delete(pipe->writeBarrier); 111ec4: 83 ec 0c sub $0xc,%esp 111ec7: 8b 45 d4 mov -0x2c(%ebp),%eax 111eca: ff 70 30 pushl 0x30(%eax) 111ecd: e8 ce 18 00 00 call 1137a0 111ed2: 83 c4 10 add $0x10,%esp err_wbar: rtems_barrier_delete(pipe->readBarrier); 111ed5: 83 ec 0c sub $0xc,%esp 111ed8: 8b 55 d4 mov -0x2c(%ebp),%edx 111edb: ff 72 2c pushl 0x2c(%edx) 111ede: e8 bd 18 00 00 call 1137a0 111ee3: 83 c4 10 add $0x10,%esp err_rbar: free(pipe->Buffer); 111ee6: 83 ec 0c sub $0xc,%esp 111ee9: 8b 45 d4 mov -0x2c(%ebp),%eax 111eec: ff 30 pushl (%eax) 111eee: e8 dd 7a ff ff call 1099d0 111ef3: 83 c4 10 add $0x10,%esp err_buf: free(pipe); 111ef6: 83 ec 0c sub $0xc,%esp 111ef9: ff 75 d4 pushl -0x2c(%ebp) 111efc: e8 cf 7a ff ff call 1099d0 111f01: 83 c4 10 add $0x10,%esp ) { pipe_control_t *pipe; int err = 0; err = pipe_lock(); 111f04: bf f4 ff ff ff mov $0xfffffff4,%edi 111f09: eb 95 jmp 111ea0 } rtems_libio_unlock(); } if (sc == RTEMS_SUCCESSFUL) { 111f0b: a1 0c a4 12 00 mov 0x12a40c,%eax 111f10: e9 a4 fb ff ff jmp 111ab9 =============================================================================== 0010ffcc : const char *type; rtems_filesystem_fsmount_me_t mount_h; } find_arg; static bool find_handler(const rtems_filesystem_table_t *entry, void *arg) { 10ffcc: 55 push %ebp 10ffcd: 89 e5 mov %esp,%ebp 10ffcf: 56 push %esi 10ffd0: 53 push %ebx 10ffd1: 8b 75 08 mov 0x8(%ebp),%esi 10ffd4: 8b 5d 0c mov 0xc(%ebp),%ebx find_arg *fa = arg; if ( strcmp( entry->type, fa->type ) != 0 ) { 10ffd7: 83 ec 08 sub $0x8,%esp 10ffda: ff 33 pushl (%ebx) 10ffdc: ff 36 pushl (%esi) 10ffde: e8 f9 3e 00 00 call 113edc 10ffe3: 83 c4 10 add $0x10,%esp 10ffe6: 85 c0 test %eax,%eax 10ffe8: 75 12 jne 10fffc return false; } else { fa->mount_h = entry->mount_h; 10ffea: 8b 46 04 mov 0x4(%esi),%eax 10ffed: 89 43 04 mov %eax,0x4(%ebx) return true; 10fff0: b0 01 mov $0x1,%al } } 10fff2: 8d 65 f8 lea -0x8(%ebp),%esp 10fff5: 5b pop %ebx 10fff6: 5e pop %esi 10fff7: c9 leave 10fff8: c3 ret 10fff9: 8d 76 00 lea 0x0(%esi),%esi static bool find_handler(const rtems_filesystem_table_t *entry, void *arg) { find_arg *fa = arg; if ( strcmp( entry->type, fa->type ) != 0 ) { return false; 10fffc: 31 c0 xor %eax,%eax } else { fa->mount_h = entry->mount_h; return true; } } 10fffe: 8d 65 f8 lea -0x8(%ebp),%esp 110001: 5b pop %ebx 110002: 5e pop %esi 110003: c9 leave 110004: c3 ret =============================================================================== 00108d20 : long fpathconf( int fd, int name ) { 108d20: 55 push %ebp 108d21: 89 e5 mov %esp,%ebp 108d23: 83 ec 08 sub $0x8,%esp 108d26: 8b 45 08 mov 0x8(%ebp),%eax 108d29: 8b 55 0c mov 0xc(%ebp),%edx long return_value; rtems_libio_t *iop; rtems_filesystem_limits_and_options_t *the_limits; rtems_libio_check_fd(fd); 108d2c: 3b 05 ac 55 12 00 cmp 0x1255ac,%eax 108d32: 0f 83 ac 00 00 00 jae 108de4 iop = rtems_libio_iop(fd); 108d38: 8d 0c c5 00 00 00 00 lea 0x0(,%eax,8),%ecx 108d3f: 8d 04 cd 00 00 00 00 lea 0x0(,%ecx,8),%eax 108d46: 29 c8 sub %ecx,%eax 108d48: 03 05 60 98 12 00 add 0x129860,%eax rtems_libio_check_is_open(iop); 108d4e: 8b 48 14 mov 0x14(%eax),%ecx 108d51: f6 c5 01 test $0x1,%ch 108d54: 0f 84 8a 00 00 00 je 108de4 <== NEVER TAKEN rtems_libio_check_permissions(iop, LIBIO_FLAGS_READ); 108d5a: 83 e1 02 and $0x2,%ecx 108d5d: 74 08 je 108d67 /* * Now process the information request. */ the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options; 108d5f: 8b 40 28 mov 0x28(%eax),%eax switch ( name ) { 108d62: 83 fa 0b cmp $0xb,%edx 108d65: 76 15 jbe 108d7c break; case _PC_SYNC_IO: return_value = the_limits->posix_sync_io; break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 108d67: e8 64 b6 00 00 call 1143d0 <__errno> 108d6c: c7 00 16 00 00 00 movl $0x16,(%eax) 108d72: b8 ff ff ff ff mov $0xffffffff,%eax break; } return return_value; } 108d77: c9 leave 108d78: c3 ret 108d79: 8d 76 00 lea 0x0(%esi),%esi * Now process the information request. */ the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options; switch ( name ) { 108d7c: ff 24 95 18 2f 12 00 jmp *0x122f18(,%edx,4) 108d83: 90 nop break; case _PC_ASYNC_IO: return_value = the_limits->posix_async_io; break; case _PC_PRIO_IO: return_value = the_limits->posix_prio_io; 108d84: 8b 40 5c mov 0x5c(%eax),%eax rtems_set_errno_and_return_minus_one( EINVAL ); break; } return return_value; } 108d87: c9 leave 108d88: c3 ret 108d89: 8d 76 00 lea 0x0(%esi),%esi break; case _PC_VDISABLE: return_value = the_limits->posix_vdisable; break; case _PC_ASYNC_IO: return_value = the_limits->posix_async_io; 108d8c: 8b 40 50 mov 0x50(%eax),%eax rtems_set_errno_and_return_minus_one( EINVAL ); break; } return return_value; } 108d8f: c9 leave 108d90: c3 ret 108d91: 8d 76 00 lea 0x0(%esi),%esi break; case _PC_NO_TRUNC: return_value = the_limits->posix_no_trunc; break; case _PC_VDISABLE: return_value = the_limits->posix_vdisable; 108d94: 8b 40 64 mov 0x64(%eax),%eax rtems_set_errno_and_return_minus_one( EINVAL ); break; } return return_value; } 108d97: c9 leave 108d98: c3 ret 108d99: 8d 76 00 lea 0x0(%esi),%esi break; case _PC_CHOWN_RESTRICTED: return_value = the_limits->posix_chown_restrictions; break; case _PC_NO_TRUNC: return_value = the_limits->posix_no_trunc; 108d9c: 8b 40 58 mov 0x58(%eax),%eax rtems_set_errno_and_return_minus_one( EINVAL ); break; } return return_value; } 108d9f: c9 leave 108da0: c3 ret 108da1: 8d 76 00 lea 0x0(%esi),%esi break; case _PC_PIPE_BUF: return_value = the_limits->pipe_buf; break; case _PC_CHOWN_RESTRICTED: return_value = the_limits->posix_chown_restrictions; 108da4: 8b 40 54 mov 0x54(%eax),%eax rtems_set_errno_and_return_minus_one( EINVAL ); break; } return return_value; } 108da7: c9 leave 108da8: c3 ret 108da9: 8d 76 00 lea 0x0(%esi),%esi break; case _PC_PATH_MAX: return_value = the_limits->path_max; break; case _PC_PIPE_BUF: return_value = the_limits->pipe_buf; 108dac: 8b 40 4c mov 0x4c(%eax),%eax rtems_set_errno_and_return_minus_one( EINVAL ); break; } return return_value; } 108daf: c9 leave 108db0: c3 ret 108db1: 8d 76 00 lea 0x0(%esi),%esi break; case _PC_NAME_MAX: return_value = the_limits->name_max; break; case _PC_PATH_MAX: return_value = the_limits->path_max; 108db4: 8b 40 48 mov 0x48(%eax),%eax rtems_set_errno_and_return_minus_one( EINVAL ); break; } return return_value; } 108db7: c9 leave 108db8: c3 ret 108db9: 8d 76 00 lea 0x0(%esi),%esi break; case _PC_MAX_INPUT: return_value = the_limits->max_input; break; case _PC_NAME_MAX: return_value = the_limits->name_max; 108dbc: 8b 40 44 mov 0x44(%eax),%eax rtems_set_errno_and_return_minus_one( EINVAL ); break; } return return_value; } 108dbf: c9 leave 108dc0: c3 ret 108dc1: 8d 76 00 lea 0x0(%esi),%esi break; case _PC_MAX_CANON: return_value = the_limits->max_canon; break; case _PC_MAX_INPUT: return_value = the_limits->max_input; 108dc4: 8b 40 40 mov 0x40(%eax),%eax rtems_set_errno_and_return_minus_one( EINVAL ); break; } return return_value; } 108dc7: c9 leave 108dc8: c3 ret 108dc9: 8d 76 00 lea 0x0(%esi),%esi switch ( name ) { case _PC_LINK_MAX: return_value = the_limits->link_max; break; case _PC_MAX_CANON: return_value = the_limits->max_canon; 108dcc: 8b 40 3c mov 0x3c(%eax),%eax rtems_set_errno_and_return_minus_one( EINVAL ); break; } return return_value; } 108dcf: c9 leave 108dd0: c3 ret 108dd1: 8d 76 00 lea 0x0(%esi),%esi the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options; switch ( name ) { case _PC_LINK_MAX: return_value = the_limits->link_max; 108dd4: 8b 40 38 mov 0x38(%eax),%eax rtems_set_errno_and_return_minus_one( EINVAL ); break; } return return_value; } 108dd7: c9 leave 108dd8: c3 ret 108dd9: 8d 76 00 lea 0x0(%esi),%esi break; case _PC_PRIO_IO: return_value = the_limits->posix_prio_io; break; case _PC_SYNC_IO: return_value = the_limits->posix_sync_io; 108ddc: 8b 40 60 mov 0x60(%eax),%eax rtems_set_errno_and_return_minus_one( EINVAL ); break; } return return_value; } 108ddf: c9 leave 108de0: c3 ret 108de1: 8d 76 00 lea 0x0(%esi),%esi rtems_libio_t *iop; rtems_filesystem_limits_and_options_t *the_limits; rtems_libio_check_fd(fd); iop = rtems_libio_iop(fd); rtems_libio_check_is_open(iop); 108de4: e8 e7 b5 00 00 call 1143d0 <__errno> 108de9: c7 00 09 00 00 00 movl $0x9,(%eax) 108def: b8 ff ff ff ff mov $0xffffffff,%eax rtems_set_errno_and_return_minus_one( EINVAL ); break; } return return_value; } 108df4: c9 leave 108df5: c3 ret =============================================================================== 001080b4 : #include void free( void *ptr ) { 1080b4: 55 push %ebp 1080b5: 89 e5 mov %esp,%ebp 1080b7: 53 push %ebx 1080b8: 83 ec 04 sub $0x4,%esp 1080bb: 8b 5d 08 mov 0x8(%ebp),%ebx MSBUMP(free_calls, 1); 1080be: ff 05 4c 7c 12 00 incl 0x127c4c if ( !ptr ) 1080c4: 85 db test %ebx,%ebx 1080c6: 74 4b je 108113 return; /* * Do not attempt to free memory if in a critical section or ISR. */ if ( _System_state_Is_up(_System_state_Get()) && 1080c8: 83 3d 20 7f 12 00 03 cmpl $0x3,0x127f20 1080cf: 74 47 je 108118 <== ALWAYS TAKEN } /* * If configured, update the statistics */ if ( rtems_malloc_statistics_helpers ) 1080d1: a1 e8 5f 12 00 mov 0x125fe8,%eax 1080d6: 85 c0 test %eax,%eax 1080d8: 74 0a je 1080e4 (*rtems_malloc_statistics_helpers->at_free)(ptr); 1080da: 83 ec 0c sub $0xc,%esp 1080dd: 53 push %ebx 1080de: ff 50 08 call *0x8(%eax) 1080e1: 83 c4 10 add $0x10,%esp if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) { 1080e4: 83 ec 08 sub $0x8,%esp 1080e7: 53 push %ebx 1080e8: ff 35 b0 39 12 00 pushl 0x1239b0 1080ee: e8 31 50 00 00 call 10d124 <_Protected_heap_Free> 1080f3: 83 c4 10 add $0x10,%esp 1080f6: 84 c0 test %al,%al 1080f8: 75 19 jne 108113 printk( "Program heap: free of bad pointer %p -- range %p - %p \n", ptr, RTEMS_Malloc_Heap->area_begin, RTEMS_Malloc_Heap->area_end 1080fa: a1 b0 39 12 00 mov 0x1239b0,%eax */ if ( rtems_malloc_statistics_helpers ) (*rtems_malloc_statistics_helpers->at_free)(ptr); if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) { printk( "Program heap: free of bad pointer %p -- range %p - %p \n", 1080ff: ff 70 1c pushl 0x1c(%eax) 108102: ff 70 18 pushl 0x18(%eax) 108105: 53 push %ebx 108106: 68 10 13 12 00 push $0x121310 10810b: e8 8c 0d 00 00 call 108e9c 108110: 83 c4 10 add $0x10,%esp RTEMS_Malloc_Heap->area_begin, RTEMS_Malloc_Heap->area_end ); } } 108113: 8b 5d fc mov -0x4(%ebp),%ebx 108116: c9 leave 108117: c3 ret /* * Do not attempt to free memory if in a critical section or ISR. */ if ( _System_state_Is_up(_System_state_Get()) && !malloc_is_system_state_OK() ) { 108118: e8 3b 01 00 00 call 108258 return; /* * Do not attempt to free memory if in a critical section or ISR. */ if ( _System_state_Is_up(_System_state_Get()) && 10811d: 84 c0 test %al,%al 10811f: 75 b0 jne 1080d1 !malloc_is_system_state_OK() ) { malloc_deferred_free(ptr); 108121: 89 5d 08 mov %ebx,0x8(%ebp) RTEMS_Malloc_Heap->area_begin, RTEMS_Malloc_Heap->area_end ); } } 108124: 8b 5d fc mov -0x4(%ebp),%ebx 108127: c9 leave /* * Do not attempt to free memory if in a critical section or ISR. */ if ( _System_state_Is_up(_System_state_Get()) && !malloc_is_system_state_OK() ) { malloc_deferred_free(ptr); 108128: e9 97 01 00 00 jmp 1082c4 =============================================================================== 00109550 : * NOTE: this must be called with * thread dispatching disabled! */ static void free_user_env(void *venv) { 109550: 55 push %ebp 109551: 89 e5 mov %esp,%ebp 109553: 53 push %ebx 109554: 83 ec 04 sub $0x4,%esp 109557: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_user_env_t *env = (rtems_user_env_t*) venv ; if (env != &rtems_global_user_env 10955a: 81 fb c0 85 12 00 cmp $0x1285c0,%ebx 109560: 74 26 je 109588 <== NEVER TAKEN #ifdef HAVE_USERENV_REFCNT && --env->refcnt <= 0 #endif ) { rtems_filesystem_freenode( &env->current_directory); 109562: 83 ec 0c sub $0xc,%esp 109565: 8d 43 04 lea 0x4(%ebx),%eax 109568: 50 push %eax 109569: e8 72 ef ff ff call 1084e0 rtems_filesystem_freenode( &env->root_directory); 10956e: 8d 43 18 lea 0x18(%ebx),%eax 109571: 89 04 24 mov %eax,(%esp) 109574: e8 67 ef ff ff call 1084e0 free(env); 109579: 83 c4 10 add $0x10,%esp 10957c: 89 5d 08 mov %ebx,0x8(%ebp) } } 10957f: 8b 5d fc mov -0x4(%ebp),%ebx 109582: c9 leave && --env->refcnt <= 0 #endif ) { rtems_filesystem_freenode( &env->current_directory); rtems_filesystem_freenode( &env->root_directory); free(env); 109583: e9 6c ef ff ff jmp 1084f4 } } 109588: 8b 5d fc mov -0x4(%ebp),%ebx 10958b: c9 leave <== NOT EXECUTED 10958c: c3 ret <== NOT EXECUTED =============================================================================== 0011efbc : int fstat( int fd, struct stat *sbuf ) { 11efbc: 55 push %ebp 11efbd: 89 e5 mov %esp,%ebp 11efbf: 57 push %edi 11efc0: 53 push %ebx 11efc1: 8b 45 08 mov 0x8(%ebp),%eax 11efc4: 8b 5d 0c mov 0xc(%ebp),%ebx rtems_libio_t *iop; /* * Check to see if we were passed a valid pointer. */ if ( !sbuf ) 11efc7: 85 db test %ebx,%ebx 11efc9: 74 55 je 11f020 rtems_set_errno_and_return_minus_one( EFAULT ); /* * Now process the stat() request. */ iop = rtems_libio_iop( fd ); 11efcb: 3b 05 6c 39 12 00 cmp 0x12396c,%eax 11efd1: 73 39 jae 11f00c 11efd3: c1 e0 03 shl $0x3,%eax 11efd6: 8d 14 c5 00 00 00 00 lea 0x0(,%eax,8),%edx 11efdd: 29 c2 sub %eax,%edx 11efdf: 03 15 20 7c 12 00 add 0x127c20,%edx rtems_libio_check_fd( fd ); rtems_libio_check_is_open(iop); 11efe5: f6 42 15 01 testb $0x1,0x15(%edx) 11efe9: 74 21 je 11f00c /* * Zero out the stat structure so the various support * versions of stat don't have to. */ memset( sbuf, 0, sizeof(struct stat) ); 11efeb: b9 48 00 00 00 mov $0x48,%ecx 11eff0: 31 c0 xor %eax,%eax 11eff2: 89 df mov %ebx,%edi 11eff4: f3 aa rep stos %al,%es:(%edi) return (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, sbuf ); 11eff6: 8b 42 20 mov 0x20(%edx),%eax 11eff9: 89 5d 0c mov %ebx,0xc(%ebp) 11effc: 83 c2 18 add $0x18,%edx 11efff: 89 55 08 mov %edx,0x8(%ebp) 11f002: 8b 40 18 mov 0x18(%eax),%eax } 11f005: 5b pop %ebx 11f006: 5f pop %edi 11f007: c9 leave * Zero out the stat structure so the various support * versions of stat don't have to. */ memset( sbuf, 0, sizeof(struct stat) ); return (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, sbuf ); 11f008: ff e0 jmp *%eax 11f00a: 66 90 xchg %ax,%ax /* * Now process the stat() request. */ iop = rtems_libio_iop( fd ); rtems_libio_check_fd( fd ); rtems_libio_check_is_open(iop); 11f00c: e8 5f 42 ff ff call 113270 <__errno> 11f011: c7 00 09 00 00 00 movl $0x9,(%eax) * versions of stat don't have to. */ memset( sbuf, 0, sizeof(struct stat) ); return (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, sbuf ); } 11f017: b8 ff ff ff ff mov $0xffffffff,%eax 11f01c: 5b pop %ebx 11f01d: 5f pop %edi 11f01e: c9 leave 11f01f: c3 ret /* * Check to see if we were passed a valid pointer. */ if ( !sbuf ) rtems_set_errno_and_return_minus_one( EFAULT ); 11f020: e8 4b 42 ff ff call 113270 <__errno> 11f025: c7 00 0e 00 00 00 movl $0xe,(%eax) 11f02b: eb ea jmp 11f017 =============================================================================== 00108f14 : #include int fsync( int fd ) { 108f14: 55 push %ebp 108f15: 89 e5 mov %esp,%ebp 108f17: 83 ec 08 sub $0x8,%esp 108f1a: 8b 45 08 mov 0x8(%ebp),%eax rtems_libio_t *iop; rtems_libio_check_fd( fd ); 108f1d: 3b 05 ac 55 12 00 cmp 0x1255ac,%eax 108f23: 73 2f jae 108f54 iop = rtems_libio_iop( fd ); 108f25: 8d 14 c5 00 00 00 00 lea 0x0(,%eax,8),%edx 108f2c: 8d 04 d5 00 00 00 00 lea 0x0(,%edx,8),%eax 108f33: 29 d0 sub %edx,%eax 108f35: 03 05 60 98 12 00 add 0x129860,%eax rtems_libio_check_is_open(iop); 108f3b: 8b 50 14 mov 0x14(%eax),%edx 108f3e: f6 c6 01 test $0x1,%dh 108f41: 74 11 je 108f54 rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 108f43: 83 e2 04 and $0x4,%edx 108f46: 74 20 je 108f68 /* * Now process the fsync(). */ return (*iop->pathinfo.handlers->fsync_h)( iop ); 108f48: 8b 50 20 mov 0x20(%eax),%edx 108f4b: 89 45 08 mov %eax,0x8(%ebp) 108f4e: 8b 42 28 mov 0x28(%edx),%eax } 108f51: c9 leave /* * Now process the fsync(). */ return (*iop->pathinfo.handlers->fsync_h)( iop ); 108f52: ff e0 jmp *%eax { rtems_libio_t *iop; rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open(iop); 108f54: e8 77 b4 00 00 call 1143d0 <__errno> 108f59: c7 00 09 00 00 00 movl $0x9,(%eax) /* * Now process the fsync(). */ return (*iop->pathinfo.handlers->fsync_h)( iop ); } 108f5f: b8 ff ff ff ff mov $0xffffffff,%eax 108f64: c9 leave 108f65: c3 ret 108f66: 66 90 xchg %ax,%ax rtems_libio_t *iop; rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open(iop); rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 108f68: e8 63 b4 00 00 call 1143d0 <__errno> 108f6d: c7 00 16 00 00 00 movl $0x16,(%eax) 108f73: eb ea jmp 108f5f =============================================================================== 0010fcbc : int ftruncate( int fd, off_t length ) { 10fcbc: 55 push %ebp 10fcbd: 89 e5 mov %esp,%ebp 10fcbf: 57 push %edi 10fcc0: 56 push %esi 10fcc1: 53 push %ebx 10fcc2: 83 ec 3c sub $0x3c,%esp 10fcc5: 8b 45 08 mov 0x8(%ebp),%eax 10fcc8: 8b 55 0c mov 0xc(%ebp),%edx 10fccb: 8b 4d 10 mov 0x10(%ebp),%ecx 10fcce: 89 55 c0 mov %edx,-0x40(%ebp) 10fcd1: 89 4d c4 mov %ecx,-0x3c(%ebp) rtems_libio_t *iop; rtems_filesystem_location_info_t loc; rtems_libio_check_fd( fd ); 10fcd4: 3b 05 6c 39 12 00 cmp 0x12396c,%eax 10fcda: 73 58 jae 10fd34 iop = rtems_libio_iop( fd ); 10fcdc: c1 e0 03 shl $0x3,%eax 10fcdf: 8d 1c c5 00 00 00 00 lea 0x0(,%eax,8),%ebx 10fce6: 29 c3 sub %eax,%ebx 10fce8: 03 1d 20 7c 12 00 add 0x127c20,%ebx rtems_libio_check_is_open(iop); 10fcee: f6 43 15 01 testb $0x1,0x15(%ebx) 10fcf2: 74 40 je 10fd34 /* * Make sure we are not working on a directory */ loc = iop->pathinfo; 10fcf4: 8d 7d d4 lea -0x2c(%ebp),%edi 10fcf7: 8d 73 18 lea 0x18(%ebx),%esi 10fcfa: b9 05 00 00 00 mov $0x5,%ecx 10fcff: f3 a5 rep movsl %ds:(%esi),%es:(%edi) if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) 10fd01: 83 ec 0c sub $0xc,%esp 10fd04: 8d 45 d4 lea -0x2c(%ebp),%eax 10fd07: 50 push %eax 10fd08: 8b 45 e0 mov -0x20(%ebp),%eax 10fd0b: ff 50 10 call *0x10(%eax) 10fd0e: 83 c4 10 add $0x10,%esp 10fd11: 48 dec %eax 10fd12: 74 46 je 10fd5a rtems_set_errno_and_return_minus_one( EISDIR ); rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 10fd14: f6 43 14 04 testb $0x4,0x14(%ebx) 10fd18: 74 2e je 10fd48 return (*iop->pathinfo.handlers->ftruncate_h)( iop, length ); 10fd1a: 50 push %eax 10fd1b: 8b 43 20 mov 0x20(%ebx),%eax 10fd1e: ff 75 c4 pushl -0x3c(%ebp) 10fd21: ff 75 c0 pushl -0x40(%ebp) 10fd24: 53 push %ebx 10fd25: ff 50 20 call *0x20(%eax) 10fd28: 83 c4 10 add $0x10,%esp } 10fd2b: 8d 65 f4 lea -0xc(%ebp),%esp 10fd2e: 5b pop %ebx 10fd2f: 5e pop %esi 10fd30: 5f pop %edi 10fd31: c9 leave 10fd32: c3 ret 10fd33: 90 nop rtems_libio_t *iop; rtems_filesystem_location_info_t loc; rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open(iop); 10fd34: e8 37 35 00 00 call 113270 <__errno> 10fd39: c7 00 09 00 00 00 movl $0x9,(%eax) 10fd3f: b8 ff ff ff ff mov $0xffffffff,%eax 10fd44: eb e5 jmp 10fd2b 10fd46: 66 90 xchg %ax,%ax loc = iop->pathinfo; if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) rtems_set_errno_and_return_minus_one( EISDIR ); rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 10fd48: e8 23 35 00 00 call 113270 <__errno> 10fd4d: c7 00 16 00 00 00 movl $0x16,(%eax) 10fd53: b8 ff ff ff ff mov $0xffffffff,%eax 10fd58: eb d1 jmp 10fd2b * Make sure we are not working on a directory */ loc = iop->pathinfo; if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) rtems_set_errno_and_return_minus_one( EISDIR ); 10fd5a: e8 11 35 00 00 call 113270 <__errno> 10fd5f: c7 00 15 00 00 00 movl $0x15,(%eax) 10fd65: b8 ff ff ff ff mov $0xffffffff,%eax 10fd6a: eb bf jmp 10fd2b =============================================================================== 00108300 : #include #include int getchark(void) { 108300: 55 push %ebp 108301: 89 e5 mov %esp,%ebp 108303: 83 ec 08 sub $0x8,%esp if ( BSP_poll_char ) 108306: a1 8c 3e 12 00 mov 0x123e8c,%eax 10830b: 85 c0 test %eax,%eax 10830d: 74 05 je 108314 return (*BSP_poll_char)(); return -1; } 10830f: c9 leave #include int getchark(void) { if ( BSP_poll_char ) return (*BSP_poll_char)(); 108310: ff e0 jmp *%eax 108312: 66 90 xchg %ax,%ax return -1; } 108314: b8 ff ff ff ff mov $0xffffffff,%eax 108319: c9 leave 10831a: c3 ret =============================================================================== 001209b0 : int getdents( int dd_fd, char *dd_buf, int dd_len ) { 1209b0: 55 push %ebp 1209b1: 89 e5 mov %esp,%ebp 1209b3: 57 push %edi 1209b4: 56 push %esi 1209b5: 53 push %ebx 1209b6: 83 ec 2c sub $0x2c,%esp 1209b9: 8b 45 08 mov 0x8(%ebp),%eax rtems_filesystem_location_info_t loc; /* * Get the file control block structure associated with the file descriptor */ iop = rtems_libio_iop( dd_fd ); 1209bc: 3b 05 8c 64 12 00 cmp 0x12648c,%eax 1209c2: 73 4c jae 120a10 <== NEVER TAKEN 1209c4: c1 e0 03 shl $0x3,%eax 1209c7: 8d 1c c5 00 00 00 00 lea 0x0(,%eax,8),%ebx 1209ce: 29 c3 sub %eax,%ebx 1209d0: 03 1d 80 a8 12 00 add 0x12a880,%ebx /* * Make sure we are working on a directory */ loc = iop->pathinfo; 1209d6: 8d 7d d4 lea -0x2c(%ebp),%edi 1209d9: 8d 73 18 lea 0x18(%ebx),%esi 1209dc: b9 05 00 00 00 mov $0x5,%ecx 1209e1: f3 a5 rep movsl %ds:(%esi),%es:(%edi) if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) 1209e3: 83 ec 0c sub $0xc,%esp 1209e6: 8d 45 d4 lea -0x2c(%ebp),%eax 1209e9: 50 push %eax 1209ea: 8b 45 e0 mov -0x20(%ebp),%eax 1209ed: ff 50 10 call *0x10(%eax) 1209f0: 83 c4 10 add $0x10,%esp 1209f3: 48 dec %eax 1209f4: 75 1e jne 120a14 /* * Return the number of bytes that were actually transfered as a result * of the read attempt. */ return (*iop->pathinfo.handlers->read_h)( iop, dd_buf, dd_len ); 1209f6: 50 push %eax 1209f7: 8b 43 20 mov 0x20(%ebx),%eax 1209fa: ff 75 10 pushl 0x10(%ebp) 1209fd: ff 75 0c pushl 0xc(%ebp) 120a00: 53 push %ebx 120a01: ff 50 08 call *0x8(%eax) 120a04: 83 c4 10 add $0x10,%esp } 120a07: 8d 65 f4 lea -0xc(%ebp),%esp 120a0a: 5b pop %ebx 120a0b: 5e pop %esi 120a0c: 5f pop %edi 120a0d: c9 leave 120a0e: c3 ret 120a0f: 90 nop rtems_filesystem_location_info_t loc; /* * Get the file control block structure associated with the file descriptor */ iop = rtems_libio_iop( dd_fd ); 120a10: 31 db xor %ebx,%ebx 120a12: eb c2 jmp 1209d6 <== NOT EXECUTED /* * Make sure we are working on a directory */ loc = iop->pathinfo; if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) rtems_set_errno_and_return_minus_one( ENOTDIR ); 120a14: e8 a7 38 ff ff call 1142c0 <__errno> 120a19: c7 00 14 00 00 00 movl $0x14,(%eax) 120a1f: b8 ff ff ff ff mov $0xffffffff,%eax 120a24: eb e1 jmp 120a07 =============================================================================== 00108b34 : struct group *grp, char *buffer, size_t bufsize, struct group **result ) { 108b34: 55 push %ebp 108b35: 89 e5 mov %esp,%ebp 108b37: 57 push %edi 108b38: 56 push %esi 108b39: 53 push %ebx 108b3a: 83 ec 1c sub $0x1c,%esp 108b3d: 89 c3 mov %eax,%ebx 108b3f: 89 55 e4 mov %edx,-0x1c(%ebp) 108b42: 89 ce mov %ecx,%esi FILE *fp; int match; init_etc_passwd_group(); 108b44: e8 eb fe ff ff call 108a34 if ((fp = fopen("/etc/group", "r")) == NULL) 108b49: 83 ec 08 sub $0x8,%esp 108b4c: 68 d2 17 12 00 push $0x1217d2 108b51: 68 b9 2c 12 00 push $0x122cb9 108b56: e8 d1 bd 00 00 call 11492c 108b5b: 89 c7 mov %eax,%edi 108b5d: 83 c4 10 add $0x10,%esp 108b60: 85 c0 test %eax,%eax 108b62: 75 22 jne 108b86 108b64: e9 8b 00 00 00 jmp 108bf4 108b69: 8d 76 00 lea 0x0(%esi),%esi for(;;) { if (!scangr(fp, grp, buffer, bufsize)) goto error_einval; if (name) { match = (strcmp(grp->gr_name, name) == 0); 108b6c: 83 ec 08 sub $0x8,%esp 108b6f: 53 push %ebx 108b70: ff 36 pushl (%esi) 108b72: e8 35 cc 00 00 call 1157ac 108b77: 83 c4 10 add $0x10,%esp 108b7a: 85 c0 test %eax,%eax 108b7c: 0f 94 c0 sete %al 108b7f: 0f b6 c0 movzbl %al,%eax } else { match = (grp->gr_gid == gid); } if (match) { 108b82: 85 c0 test %eax,%eax 108b84: 75 2e jne 108bb4 if ((fp = fopen("/etc/group", "r")) == NULL) rtems_set_errno_and_return_minus_one( EINVAL ); for(;;) { if (!scangr(fp, grp, buffer, bufsize)) 108b86: 83 ec 0c sub $0xc,%esp 108b89: ff 75 0c pushl 0xc(%ebp) 108b8c: 8b 4d 08 mov 0x8(%ebp),%ecx 108b8f: 89 f2 mov %esi,%edx 108b91: 89 f8 mov %edi,%eax 108b93: e8 88 fc ff ff call 108820 108b98: 83 c4 10 add $0x10,%esp 108b9b: 85 c0 test %eax,%eax 108b9d: 74 31 je 108bd0 goto error_einval; if (name) { 108b9f: 85 db test %ebx,%ebx 108ba1: 75 c9 jne 108b6c match = (strcmp(grp->gr_name, name) == 0); } else { match = (grp->gr_gid == gid); 108ba3: 0f b7 46 08 movzwl 0x8(%esi),%eax 108ba7: 3b 45 e4 cmp -0x1c(%ebp),%eax 108baa: 0f 94 c0 sete %al 108bad: 0f b6 c0 movzbl %al,%eax } if (match) { 108bb0: 85 c0 test %eax,%eax 108bb2: 74 d2 je 108b86 fclose(fp); 108bb4: 83 ec 0c sub $0xc,%esp 108bb7: 57 push %edi 108bb8: e8 6b b6 00 00 call 114228 *result = grp; 108bbd: 8b 45 10 mov 0x10(%ebp),%eax 108bc0: 89 30 mov %esi,(%eax) return 0; 108bc2: 83 c4 10 add $0x10,%esp 108bc5: 31 c0 xor %eax,%eax } } error_einval: fclose(fp); rtems_set_errno_and_return_minus_one( EINVAL ); } 108bc7: 8d 65 f4 lea -0xc(%ebp),%esp 108bca: 5b pop %ebx 108bcb: 5e pop %esi 108bcc: 5f pop %edi 108bcd: c9 leave 108bce: c3 ret 108bcf: 90 nop *result = grp; return 0; } } error_einval: fclose(fp); 108bd0: 83 ec 0c sub $0xc,%esp 108bd3: 57 push %edi 108bd4: e8 4f b6 00 00 call 114228 rtems_set_errno_and_return_minus_one( EINVAL ); 108bd9: e8 f2 b4 00 00 call 1140d0 <__errno> 108bde: c7 00 16 00 00 00 movl $0x16,(%eax) 108be4: 83 c4 10 add $0x10,%esp 108be7: b8 ff ff ff ff mov $0xffffffff,%eax } 108bec: 8d 65 f4 lea -0xc(%ebp),%esp 108bef: 5b pop %ebx 108bf0: 5e pop %esi 108bf1: 5f pop %edi 108bf2: c9 leave 108bf3: c3 ret int match; init_etc_passwd_group(); if ((fp = fopen("/etc/group", "r")) == NULL) rtems_set_errno_and_return_minus_one( EINVAL ); 108bf4: e8 d7 b4 00 00 call 1140d0 <__errno> 108bf9: c7 00 16 00 00 00 movl $0x16,(%eax) 108bff: 83 c8 ff or $0xffffffff,%eax 108c02: eb c3 jmp 108bc7 =============================================================================== 00108e58 : } struct group *getgrnam( const char *name ) { 108e58: 55 push %ebp 108e59: 89 e5 mov %esp,%ebp 108e5b: 83 ec 24 sub $0x24,%esp struct group *p; if(getgrnam_r(name, &grent, grbuf, sizeof grbuf, &p)) 108e5e: 8d 45 f4 lea -0xc(%ebp),%eax 108e61: 50 push %eax 108e62: 68 c8 00 00 00 push $0xc8 108e67: 68 20 93 12 00 push $0x129320 108e6c: 68 04 93 12 00 push $0x129304 108e71: ff 75 08 pushl 0x8(%ebp) 108e74: e8 b3 ff ff ff call 108e2c 108e79: 83 c4 20 add $0x20,%esp 108e7c: 85 c0 test %eax,%eax 108e7e: 75 08 jne 108e88 return NULL; return p; 108e80: 8b 45 f4 mov -0xc(%ebp),%eax } 108e83: c9 leave 108e84: c3 ret 108e85: 8d 76 00 lea 0x0(%esi),%esi ) { struct group *p; if(getgrnam_r(name, &grent, grbuf, sizeof grbuf, &p)) return NULL; 108e88: 31 c0 xor %eax,%eax return p; } 108e8a: c9 leave 108e8b: c3 ret =============================================================================== 0010b234 : int getitimer( int which, struct itimerval *value ) { 10b234: 55 push %ebp 10b235: 89 e5 mov %esp,%ebp 10b237: 83 ec 08 sub $0x8,%esp if ( !value ) 10b23a: 8b 45 0c mov 0xc(%ebp),%eax 10b23d: 85 c0 test %eax,%eax 10b23f: 74 2f je 10b270 rtems_set_errno_and_return_minus_one( EFAULT ); switch ( which ) { 10b241: 83 7d 08 02 cmpl $0x2,0x8(%ebp) 10b245: 76 15 jbe 10b25c case ITIMER_PROF: rtems_set_errno_and_return_minus_one( ENOSYS ); default: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10b247: e8 34 87 00 00 call 113980 <__errno> 10b24c: c7 00 16 00 00 00 movl $0x16,(%eax) } 10b252: b8 ff ff ff ff mov $0xffffffff,%eax 10b257: c9 leave 10b258: c3 ret 10b259: 8d 76 00 lea 0x0(%esi),%esi switch ( which ) { case ITIMER_REAL: case ITIMER_VIRTUAL: case ITIMER_PROF: rtems_set_errno_and_return_minus_one( ENOSYS ); 10b25c: e8 1f 87 00 00 call 113980 <__errno> 10b261: c7 00 58 00 00 00 movl $0x58,(%eax) default: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 10b267: b8 ff ff ff ff mov $0xffffffff,%eax 10b26c: c9 leave 10b26d: c3 ret 10b26e: 66 90 xchg %ax,%ax int which, struct itimerval *value ) { if ( !value ) rtems_set_errno_and_return_minus_one( EFAULT ); 10b270: e8 0b 87 00 00 call 113980 <__errno> 10b275: c7 00 0e 00 00 00 movl $0xe,(%eax) 10b27b: eb d5 jmp 10b252 =============================================================================== 001085f8 : */ int getlogin_r( char *name, size_t namesize ) { 1085f8: 55 push %ebp 1085f9: 89 e5 mov %esp,%ebp 1085fb: 53 push %ebx 1085fc: 83 ec 04 sub $0x4,%esp 1085ff: 8b 5d 08 mov 0x8(%ebp),%ebx struct passwd *pw; char *pname; if ( !name ) 108602: 85 db test %ebx,%ebx 108604: 74 42 je 108648 return EFAULT; if ( namesize < LOGIN_NAME_MAX ) 108606: 83 7d 0c 08 cmpl $0x8,0xc(%ebp) 10860a: 77 0c ja 108618 return ERANGE; 10860c: b8 22 00 00 00 mov $0x22,%eax if ( pw ) pname = pw->pw_name; strncpy( name, pname, LOGIN_NAME_MAX ); return 0; } 108611: 8b 5d fc mov -0x4(%ebp),%ebx 108614: c9 leave 108615: c3 ret 108616: 66 90 xchg %ax,%ax return ERANGE; /* Set the pointer to a default name */ pname = ""; pw = getpwuid(getuid()); 108618: e8 e7 09 00 00 call 109004 10861d: 83 ec 0c sub $0xc,%esp 108620: 0f b7 c0 movzwl %ax,%eax 108623: 50 push %eax 108624: e8 37 07 00 00 call 108d60 if ( pw ) 108629: 83 c4 10 add $0x10,%esp 10862c: 85 c0 test %eax,%eax 10862e: 74 20 je 108650 pname = pw->pw_name; 108630: 8b 00 mov (%eax),%eax strncpy( name, pname, LOGIN_NAME_MAX ); 108632: 52 push %edx 108633: 6a 09 push $0x9 108635: 50 push %eax 108636: 53 push %ebx 108637: e8 f0 d2 00 00 call 11592c return 0; 10863c: 83 c4 10 add $0x10,%esp 10863f: 31 c0 xor %eax,%eax } 108641: 8b 5d fc mov -0x4(%ebp),%ebx 108644: c9 leave 108645: c3 ret 108646: 66 90 xchg %ax,%ax { struct passwd *pw; char *pname; if ( !name ) return EFAULT; 108648: b8 0e 00 00 00 mov $0xe,%eax 10864d: eb c2 jmp 108611 10864f: 90 nop if ( namesize < LOGIN_NAME_MAX ) return ERANGE; /* Set the pointer to a default name */ pname = ""; 108650: b8 09 2e 12 00 mov $0x122e09,%eax 108655: eb db jmp 108632 =============================================================================== 00108c04 : struct passwd *pwd, char *buffer, size_t bufsize, struct passwd **result ) { 108c04: 55 push %ebp 108c05: 89 e5 mov %esp,%ebp 108c07: 57 push %edi 108c08: 56 push %esi 108c09: 53 push %ebx 108c0a: 83 ec 1c sub $0x1c,%esp 108c0d: 89 c3 mov %eax,%ebx 108c0f: 89 55 e4 mov %edx,-0x1c(%ebp) 108c12: 89 ce mov %ecx,%esi FILE *fp; int match; init_etc_passwd_group(); 108c14: e8 1b fe ff ff call 108a34 if ((fp = fopen("/etc/passwd", "r")) == NULL) 108c19: 83 ec 08 sub $0x8,%esp 108c1c: 68 d2 17 12 00 push $0x1217d2 108c21: 68 ad 2c 12 00 push $0x122cad 108c26: e8 01 bd 00 00 call 11492c 108c2b: 89 c7 mov %eax,%edi 108c2d: 83 c4 10 add $0x10,%esp 108c30: 85 c0 test %eax,%eax 108c32: 75 22 jne 108c56 108c34: e9 8b 00 00 00 jmp 108cc4 108c39: 8d 76 00 lea 0x0(%esi),%esi for(;;) { if (!scanpw(fp, pwd, buffer, bufsize)) goto error_einval; if (name) { match = (strcmp(pwd->pw_name, name) == 0); 108c3c: 83 ec 08 sub $0x8,%esp 108c3f: 53 push %ebx 108c40: ff 36 pushl (%esi) 108c42: e8 65 cb 00 00 call 1157ac 108c47: 83 c4 10 add $0x10,%esp 108c4a: 85 c0 test %eax,%eax 108c4c: 0f 94 c0 sete %al 108c4f: 0f b6 c0 movzbl %al,%eax } else { match = (pwd->pw_uid == uid); } if (match) { 108c52: 85 c0 test %eax,%eax 108c54: 75 2e jne 108c84 if ((fp = fopen("/etc/passwd", "r")) == NULL) rtems_set_errno_and_return_minus_one( EINVAL ); for(;;) { if (!scanpw(fp, pwd, buffer, bufsize)) 108c56: 83 ec 0c sub $0xc,%esp 108c59: ff 75 0c pushl 0xc(%ebp) 108c5c: 8b 4d 08 mov 0x8(%ebp),%ecx 108c5f: 89 f2 mov %esi,%edx 108c61: 89 f8 mov %edi,%eax 108c63: e8 d0 fc ff ff call 108938 108c68: 83 c4 10 add $0x10,%esp 108c6b: 85 c0 test %eax,%eax 108c6d: 74 31 je 108ca0 goto error_einval; if (name) { 108c6f: 85 db test %ebx,%ebx 108c71: 75 c9 jne 108c3c match = (strcmp(pwd->pw_name, name) == 0); } else { match = (pwd->pw_uid == uid); 108c73: 0f b7 46 08 movzwl 0x8(%esi),%eax 108c77: 3b 45 e4 cmp -0x1c(%ebp),%eax 108c7a: 0f 94 c0 sete %al 108c7d: 0f b6 c0 movzbl %al,%eax } if (match) { 108c80: 85 c0 test %eax,%eax 108c82: 74 d2 je 108c56 fclose(fp); 108c84: 83 ec 0c sub $0xc,%esp 108c87: 57 push %edi 108c88: e8 9b b5 00 00 call 114228 *result = pwd; 108c8d: 8b 45 10 mov 0x10(%ebp),%eax 108c90: 89 30 mov %esi,(%eax) return 0; 108c92: 83 c4 10 add $0x10,%esp 108c95: 31 c0 xor %eax,%eax } } error_einval: fclose(fp); rtems_set_errno_and_return_minus_one( EINVAL ); } 108c97: 8d 65 f4 lea -0xc(%ebp),%esp 108c9a: 5b pop %ebx 108c9b: 5e pop %esi 108c9c: 5f pop %edi 108c9d: c9 leave 108c9e: c3 ret 108c9f: 90 nop *result = pwd; return 0; } } error_einval: fclose(fp); 108ca0: 83 ec 0c sub $0xc,%esp 108ca3: 57 push %edi 108ca4: e8 7f b5 00 00 call 114228 rtems_set_errno_and_return_minus_one( EINVAL ); 108ca9: e8 22 b4 00 00 call 1140d0 <__errno> 108cae: c7 00 16 00 00 00 movl $0x16,(%eax) 108cb4: 83 c4 10 add $0x10,%esp 108cb7: b8 ff ff ff ff mov $0xffffffff,%eax } 108cbc: 8d 65 f4 lea -0xc(%ebp),%esp 108cbf: 5b pop %ebx 108cc0: 5e pop %esi 108cc1: 5f pop %edi 108cc2: c9 leave 108cc3: c3 ret int match; init_etc_passwd_group(); if ((fp = fopen("/etc/passwd", "r")) == NULL) rtems_set_errno_and_return_minus_one( EINVAL ); 108cc4: e8 07 b4 00 00 call 1140d0 <__errno> 108cc9: c7 00 16 00 00 00 movl $0x16,(%eax) 108ccf: 83 c8 ff or $0xffffffff,%eax 108cd2: eb c3 jmp 108c97 =============================================================================== 00108d00 : } struct passwd *getpwnam( const char *name ) { 108d00: 55 push %ebp 108d01: 89 e5 mov %esp,%ebp 108d03: 83 ec 24 sub $0x24,%esp struct passwd *p; if(getpwnam_r(name, &pwent, pwbuf, sizeof pwbuf, &p)) 108d06: 8d 45 f4 lea -0xc(%ebp),%eax 108d09: 50 push %eax 108d0a: 68 c8 00 00 00 push $0xc8 108d0f: 68 20 94 12 00 push $0x129420 108d14: 68 ec 93 12 00 push $0x1293ec 108d19: ff 75 08 pushl 0x8(%ebp) 108d1c: e8 b3 ff ff ff call 108cd4 108d21: 83 c4 20 add $0x20,%esp 108d24: 85 c0 test %eax,%eax 108d26: 75 08 jne 108d30 return NULL; return p; 108d28: 8b 45 f4 mov -0xc(%ebp),%eax } 108d2b: c9 leave 108d2c: c3 ret 108d2d: 8d 76 00 lea 0x0(%esi),%esi ) { struct passwd *p; if(getpwnam_r(name, &pwent, pwbuf, sizeof pwbuf, &p)) return NULL; 108d30: 31 c0 xor %eax,%eax return p; } 108d32: c9 leave 108d33: c3 ret =============================================================================== 001126cc : rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode ) { 1126cc: 55 push %ebp 1126cd: 89 e5 mov %esp,%ebp 1126cf: 8b 45 08 mov 0x8(%ebp),%eax IMFS_jnode_t *the_jnode; /* Is the node a directory ? */ the_jnode = (IMFS_jnode_t *) iop->pathinfo.node_access; if ( the_jnode->type != IMFS_DIRECTORY ) 1126d2: 8b 50 18 mov 0x18(%eax),%edx 1126d5: 83 7a 4c 01 cmpl $0x1,0x4c(%edx) 1126d9: 74 09 je 1126e4 <== ALWAYS TAKEN return -1; /* It wasn't a directory --> return error */ 1126db: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED iop->offset = 0; return 0; } 1126e0: c9 leave <== NOT EXECUTED 1126e1: c3 ret <== NOT EXECUTED 1126e2: 66 90 xchg %ax,%ax <== NOT EXECUTED the_jnode = (IMFS_jnode_t *) iop->pathinfo.node_access; if ( the_jnode->type != IMFS_DIRECTORY ) return -1; /* It wasn't a directory --> return error */ iop->offset = 0; 1126e4: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) 1126eb: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax) return 0; 1126f2: 31 c0 xor %eax,%eax } 1126f4: c9 leave 1126f5: c3 ret =============================================================================== 001126f8 : ssize_t imfs_dir_read( rtems_libio_t *iop, void *buffer, size_t count ) { 1126f8: 55 push %ebp 1126f9: 89 e5 mov %esp,%ebp 1126fb: 57 push %edi 1126fc: 56 push %esi 1126fd: 53 push %ebx 1126fe: 81 ec 4c 01 00 00 sub $0x14c,%esp int current_entry; int first_entry; int last_entry; struct dirent tmp_dirent; the_jnode = (IMFS_jnode_t *)iop->pathinfo.node_access; 112704: 8b 55 08 mov 0x8(%ebp),%edx 112707: 8b 42 18 mov 0x18(%edx),%eax IMFS_create_orphan( the_jnode ); IMFS_check_node_remove( the_jnode ); return 0; } 11270a: 8b 58 50 mov 0x50(%eax),%ebx RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 11270d: 83 c0 54 add $0x54,%eax 112710: 89 85 cc fe ff ff mov %eax,-0x134(%ebp) struct dirent tmp_dirent; the_jnode = (IMFS_jnode_t *)iop->pathinfo.node_access; the_chain = &the_jnode->info.directory.Entries; if ( rtems_chain_is_empty( the_chain ) ) 112716: 39 c3 cmp %eax,%ebx 112718: 0f 84 2a 01 00 00 je 112848 /* Move to the first of the desired directory entries */ the_node = rtems_chain_first( the_chain ); bytes_transferred = 0; first_entry = iop->offset; 11271e: 8b 42 0c mov 0xc(%edx),%eax 112721: 89 85 d4 fe ff ff mov %eax,-0x12c(%ebp) /* protect against using sizes that are not exact multiples of the */ /* -dirent- size. These could result in unexpected results */ last_entry = first_entry + (count/sizeof(struct dirent)) * sizeof(struct dirent); 112727: ba f1 f0 f0 f0 mov $0xf0f0f0f1,%edx 11272c: 8b 45 10 mov 0x10(%ebp),%eax 11272f: f7 e2 mul %edx 112731: c1 ea 08 shr $0x8,%edx 112734: 89 d0 mov %edx,%eax 112736: c1 e0 04 shl $0x4,%eax 112739: c1 e2 08 shl $0x8,%edx 11273c: 8d 14 10 lea (%eax,%edx,1),%edx 11273f: 03 95 d4 fe ff ff add -0x12c(%ebp),%edx 112745: 89 95 d0 fe ff ff mov %edx,-0x130(%ebp) /* The directory was not empty so try to move to the desired entry in chain*/ for ( 11274b: 85 d2 test %edx,%edx 11274d: 0f 8e f5 00 00 00 jle 112848 <== NEVER TAKEN 112753: 31 d2 xor %edx,%edx 112755: c7 85 c8 fe ff ff 00 movl $0x0,-0x138(%ebp) 11275c: 00 00 00 tmp_dirent.d_off = current_entry; tmp_dirent.d_reclen = sizeof( struct dirent ); the_jnode = (IMFS_jnode_t *) the_node; tmp_dirent.d_ino = the_jnode->st_ino; tmp_dirent.d_namlen = strlen( the_jnode->name ); strcpy( tmp_dirent.d_name, the_jnode->name ); 11275f: 8d 85 d8 fe ff ff lea -0x128(%ebp),%eax 112765: 89 85 b4 fe ff ff mov %eax,-0x14c(%ebp) 11276b: eb 23 jmp 112790 11276d: 8d 76 00 lea 0x0(%esi),%esi ); iop->offset = iop->offset + sizeof(struct dirent); bytes_transferred = bytes_transferred + sizeof( struct dirent ); } the_node = the_node->next; 112770: 8b 1b mov (%ebx),%ebx * to the end of the exisiting file, the remaining entries will be placed in * the buffer and the returned value will be equal to -m actual- times the * size of a directory entry. */ ssize_t imfs_dir_read( 112772: 81 c2 10 01 00 00 add $0x110,%edx /* protect against using sizes that are not exact multiples of the */ /* -dirent- size. These could result in unexpected results */ last_entry = first_entry + (count/sizeof(struct dirent)) * sizeof(struct dirent); /* The directory was not empty so try to move to the desired entry in chain*/ for ( 112778: 39 95 d0 fe ff ff cmp %edx,-0x130(%ebp) 11277e: 0f 8e b4 00 00 00 jle 112838 <== NEVER TAKEN current_entry = 0; current_entry < last_entry; current_entry = current_entry + sizeof(struct dirent) ){ if ( rtems_chain_is_tail( the_chain, the_node ) ){ 112784: 3b 9d cc fe ff ff cmp -0x134(%ebp),%ebx 11278a: 0f 84 a8 00 00 00 je 112838 /* entry in the read */ return bytes_transferred; /* Indicate that there are no more */ /* entries to return */ } if( current_entry >= first_entry ) { 112790: 39 95 d4 fe ff ff cmp %edx,-0x12c(%ebp) 112796: 7f d8 jg 112770 /* Move the entry to the return buffer */ tmp_dirent.d_off = current_entry; 112798: 89 95 dc fe ff ff mov %edx,-0x124(%ebp) 11279e: 89 d0 mov %edx,%eax 1127a0: c1 f8 1f sar $0x1f,%eax 1127a3: 89 85 e0 fe ff ff mov %eax,-0x120(%ebp) tmp_dirent.d_reclen = sizeof( struct dirent ); 1127a9: 66 c7 85 e4 fe ff ff movw $0x110,-0x11c(%ebp) 1127b0: 10 01 the_jnode = (IMFS_jnode_t *) the_node; tmp_dirent.d_ino = the_jnode->st_ino; 1127b2: 8b 43 38 mov 0x38(%ebx),%eax 1127b5: 89 85 d8 fe ff ff mov %eax,-0x128(%ebp) tmp_dirent.d_namlen = strlen( the_jnode->name ); 1127bb: 8d 73 0c lea 0xc(%ebx),%esi 1127be: 31 c0 xor %eax,%eax 1127c0: b9 ff ff ff ff mov $0xffffffff,%ecx 1127c5: 89 f7 mov %esi,%edi 1127c7: f2 ae repnz scas %es:(%edi),%al 1127c9: f7 d1 not %ecx 1127cb: 49 dec %ecx 1127cc: 66 89 8d e6 fe ff ff mov %cx,-0x11a(%ebp) strcpy( tmp_dirent.d_name, the_jnode->name ); 1127d3: 83 ec 08 sub $0x8,%esp 1127d6: 56 push %esi 1127d7: 8d 85 e8 fe ff ff lea -0x118(%ebp),%eax 1127dd: 50 push %eax 1127de: 89 95 c4 fe ff ff mov %edx,-0x13c(%ebp) 1127e4: e8 4b 17 00 00 call 113f34 memcpy( 1127e9: 8b 45 0c mov 0xc(%ebp),%eax 1127ec: 03 85 c8 fe ff ff add -0x138(%ebp),%eax 1127f2: b9 44 00 00 00 mov $0x44,%ecx 1127f7: 89 c7 mov %eax,%edi 1127f9: 8b b5 b4 fe ff ff mov -0x14c(%ebp),%esi 1127ff: f3 a5 rep movsl %ds:(%esi),%es:(%edi) buffer + bytes_transferred, (void *)&tmp_dirent, sizeof( struct dirent ) ); iop->offset = iop->offset + sizeof(struct dirent); 112801: 8b 45 08 mov 0x8(%ebp),%eax 112804: 81 40 0c 10 01 00 00 addl $0x110,0xc(%eax) 11280b: 83 50 10 00 adcl $0x0,0x10(%eax) bytes_transferred = bytes_transferred + sizeof( struct dirent ); 11280f: 81 85 c8 fe ff ff 10 addl $0x110,-0x138(%ebp) 112816: 01 00 00 112819: 83 c4 10 add $0x10,%esp 11281c: 8b 95 c4 fe ff ff mov -0x13c(%ebp),%edx } the_node = the_node->next; 112822: 8b 1b mov (%ebx),%ebx * to the end of the exisiting file, the remaining entries will be placed in * the buffer and the returned value will be equal to -m actual- times the * size of a directory entry. */ ssize_t imfs_dir_read( 112824: 81 c2 10 01 00 00 add $0x110,%edx /* protect against using sizes that are not exact multiples of the */ /* -dirent- size. These could result in unexpected results */ last_entry = first_entry + (count/sizeof(struct dirent)) * sizeof(struct dirent); /* The directory was not empty so try to move to the desired entry in chain*/ for ( 11282a: 39 95 d0 fe ff ff cmp %edx,-0x130(%ebp) 112830: 0f 8f 4e ff ff ff jg 112784 <== NEVER TAKEN 112836: 66 90 xchg %ax,%ax current_entry = 0; current_entry < last_entry; current_entry = current_entry + sizeof(struct dirent) ){ if ( rtems_chain_is_tail( the_chain, the_node ) ){ 112838: 8b 85 c8 fe ff ff mov -0x138(%ebp),%eax the_node = the_node->next; } /* Success */ return bytes_transferred; } 11283e: 8d 65 f4 lea -0xc(%ebp),%esp 112841: 5b pop %ebx 112842: 5e pop %esi 112843: 5f pop %edi 112844: c9 leave 112845: c3 ret 112846: 66 90 xchg %ax,%ax the_jnode = (IMFS_jnode_t *)iop->pathinfo.node_access; the_chain = &the_jnode->info.directory.Entries; if ( rtems_chain_is_empty( the_chain ) ) return 0; 112848: 31 c0 xor %eax,%eax the_node = the_node->next; } /* Success */ return bytes_transferred; } 11284a: 8d 65 f4 lea -0xc(%ebp),%esp 11284d: 5b pop %ebx 11284e: 5e pop %esi 11284f: 5f pop %edi 112850: c9 leave 112851: c3 ret =============================================================================== 00112984 : int imfs_dir_rmnod( rtems_filesystem_location_info_t *parent_pathloc, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN */ ) { 112984: 55 push %ebp 112985: 89 e5 mov %esp,%ebp 112987: 53 push %ebx 112988: 83 ec 04 sub $0x4,%esp 11298b: 8b 45 0c mov 0xc(%ebp),%eax IMFS_jnode_t *the_jnode; the_jnode = (IMFS_jnode_t *) pathloc->node_access; 11298e: 8b 18 mov (%eax),%ebx RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 112990: 8d 53 54 lea 0x54(%ebx),%edx /* * You cannot remove a node that still has children */ if ( ! rtems_chain_is_empty( &the_jnode->info.directory.Entries ) ) 112993: 39 53 50 cmp %edx,0x50(%ebx) 112996: 75 44 jne 1129dc /* * You cannot remove the file system root node. */ if ( pathloc->mt_entry->mt_fs_root.node_access == pathloc->node_access ) 112998: 8b 40 10 mov 0x10(%eax),%eax 11299b: 3b 58 1c cmp 0x1c(%eax),%ebx 11299e: 74 24 je 1129c4 /* * You cannot remove a mountpoint. */ if ( the_jnode->info.directory.mt_fs != NULL ) 1129a0: 8b 4b 5c mov 0x5c(%ebx),%ecx 1129a3: 85 c9 test %ecx,%ecx 1129a5: 75 1d jne 1129c4 <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EBUSY ); IMFS_create_orphan( the_jnode ); 1129a7: 83 ec 0c sub $0xc,%esp 1129aa: 53 push %ebx 1129ab: e8 6c d0 ff ff call 10fa1c IMFS_check_node_remove( the_jnode ); 1129b0: 89 1c 24 mov %ebx,(%esp) 1129b3: e8 a8 d0 ff ff call 10fa60 return 0; 1129b8: 83 c4 10 add $0x10,%esp 1129bb: 31 c0 xor %eax,%eax } 1129bd: 8b 5d fc mov -0x4(%ebp),%ebx 1129c0: c9 leave 1129c1: c3 ret 1129c2: 66 90 xchg %ax,%ax /* * You cannot remove a mountpoint. */ if ( the_jnode->info.directory.mt_fs != NULL ) rtems_set_errno_and_return_minus_one( EBUSY ); 1129c4: e8 a7 08 00 00 call 113270 <__errno> 1129c9: c7 00 10 00 00 00 movl $0x10,(%eax) 1129cf: b8 ff ff ff ff mov $0xffffffff,%eax IMFS_create_orphan( the_jnode ); IMFS_check_node_remove( the_jnode ); return 0; } 1129d4: 8b 5d fc mov -0x4(%ebp),%ebx 1129d7: c9 leave 1129d8: c3 ret 1129d9: 8d 76 00 lea 0x0(%esi),%esi /* * You cannot remove a node that still has children */ if ( ! rtems_chain_is_empty( &the_jnode->info.directory.Entries ) ) rtems_set_errno_and_return_minus_one( ENOTEMPTY ); 1129dc: e8 8f 08 00 00 call 113270 <__errno> 1129e1: c7 00 5a 00 00 00 movl $0x5a,(%eax) 1129e7: b8 ff ff ff ff mov $0xffffffff,%eax 1129ec: eb cf jmp 1129bd =============================================================================== 00108a34 : /* * Initialize useable but dummy databases */ void init_etc_passwd_group(void) { 108a34: 55 push %ebp 108a35: 89 e5 mov %esp,%ebp 108a37: 53 push %ebx 108a38: 83 ec 04 sub $0x4,%esp FILE *fp; static char etc_passwd_initted = 0; if (etc_passwd_initted) 108a3b: 80 3d e8 94 12 00 00 cmpb $0x0,0x1294e8 108a42: 74 08 je 108a4c fprintf( fp, "root:x:0:root\n" "rtems:x:1:rtems\n" "tty:x:2:tty\n" ); fclose(fp); } } 108a44: 8b 5d fc mov -0x4(%ebp),%ebx 108a47: c9 leave 108a48: c3 ret 108a49: 8d 76 00 lea 0x0(%esi),%esi FILE *fp; static char etc_passwd_initted = 0; if (etc_passwd_initted) return; etc_passwd_initted = 1; 108a4c: c6 05 e8 94 12 00 01 movb $0x1,0x1294e8 mkdir("/etc", 0777); 108a53: 83 ec 08 sub $0x8,%esp 108a56: 68 ff 01 00 00 push $0x1ff 108a5b: 68 a8 2c 12 00 push $0x122ca8 108a60: e8 37 08 00 00 call 10929c /* * Initialize /etc/passwd */ if ((fp = fopen("/etc/passwd", "r")) != NULL) { 108a65: 59 pop %ecx 108a66: 5b pop %ebx 108a67: 68 d2 17 12 00 push $0x1217d2 108a6c: 68 ad 2c 12 00 push $0x122cad 108a71: e8 b6 be 00 00 call 11492c 108a76: 83 c4 10 add $0x10,%esp 108a79: 85 c0 test %eax,%eax 108a7b: 74 77 je 108af4 fclose(fp); 108a7d: 83 ec 0c sub $0xc,%esp 108a80: 50 push %eax 108a81: e8 a2 b7 00 00 call 114228 108a86: 83 c4 10 add $0x10,%esp } /* * Initialize /etc/group */ if ((fp = fopen("/etc/group", "r")) != NULL) { 108a89: 83 ec 08 sub $0x8,%esp 108a8c: 68 d2 17 12 00 push $0x1217d2 108a91: 68 b9 2c 12 00 push $0x122cb9 108a96: e8 91 be 00 00 call 11492c 108a9b: 83 c4 10 add $0x10,%esp 108a9e: 85 c0 test %eax,%eax 108aa0: 74 12 je 108ab4 fclose(fp); 108aa2: 83 ec 0c sub $0xc,%esp 108aa5: 50 push %eax 108aa6: e8 7d b7 00 00 call 114228 108aab: 83 c4 10 add $0x10,%esp fprintf( fp, "root:x:0:root\n" "rtems:x:1:rtems\n" "tty:x:2:tty\n" ); fclose(fp); } } 108aae: 8b 5d fc mov -0x4(%ebp),%ebx 108ab1: c9 leave 108ab2: c3 ret 108ab3: 90 nop * Initialize /etc/group */ if ((fp = fopen("/etc/group", "r")) != NULL) { fclose(fp); } else if ((fp = fopen("/etc/group", "w")) != NULL) { 108ab4: 83 ec 08 sub $0x8,%esp 108ab7: 68 b4 16 12 00 push $0x1216b4 108abc: 68 b9 2c 12 00 push $0x122cb9 108ac1: e8 66 be 00 00 call 11492c 108ac6: 89 c3 mov %eax,%ebx 108ac8: 83 c4 10 add $0x10,%esp 108acb: 85 c0 test %eax,%eax 108acd: 0f 84 71 ff ff ff je 108a44 <== NEVER TAKEN fprintf( fp, "root:x:0:root\n" 108ad3: 50 push %eax 108ad4: 6a 2a push $0x2a 108ad6: 6a 01 push $0x1 108ad8: 68 2c 2d 12 00 push $0x122d2c 108add: e8 1e c6 00 00 call 115100 "rtems:x:1:rtems\n" "tty:x:2:tty\n" ); fclose(fp); 108ae2: 89 1c 24 mov %ebx,(%esp) 108ae5: e8 3e b7 00 00 call 114228 108aea: 83 c4 10 add $0x10,%esp 108aed: e9 52 ff ff ff jmp 108a44 108af2: 66 90 xchg %ax,%ax * Initialize /etc/passwd */ if ((fp = fopen("/etc/passwd", "r")) != NULL) { fclose(fp); } else if ((fp = fopen("/etc/passwd", "w")) != NULL) { 108af4: 83 ec 08 sub $0x8,%esp 108af7: 68 b4 16 12 00 push $0x1216b4 108afc: 68 ad 2c 12 00 push $0x122cad 108b01: e8 26 be 00 00 call 11492c 108b06: 89 c3 mov %eax,%ebx 108b08: 83 c4 10 add $0x10,%esp 108b0b: 85 c0 test %eax,%eax 108b0d: 0f 84 76 ff ff ff je 108a89 <== NEVER TAKEN fprintf(fp, "root:*:0:0:root::/:/bin/sh\n" 108b13: 50 push %eax 108b14: 6a 66 push $0x66 108b16: 6a 01 push $0x1 108b18: 68 c4 2c 12 00 push $0x122cc4 108b1d: e8 de c5 00 00 call 115100 "rtems:*:1:1:RTEMS Application::/:/bin/sh\n" "tty:!:2:2:tty owner::/:/bin/false\n" ); fclose(fp); 108b22: 89 1c 24 mov %ebx,(%esp) 108b25: e8 fe b6 00 00 call 114228 108b2a: 83 c4 10 add $0x10,%esp 108b2d: e9 57 ff ff ff jmp 108a89 =============================================================================== 00109f6c : /* * Process a single input character */ static int iproc (unsigned char c, struct rtems_termios_tty *tty) { 109f6c: 55 push %ebp 109f6d: 89 e5 mov %esp,%ebp 109f6f: 56 push %esi 109f70: 53 push %ebx 109f71: 89 d6 mov %edx,%esi 109f73: 88 c3 mov %al,%bl if (tty->termios.c_iflag & ISTRIP) 109f75: 8b 42 30 mov 0x30(%edx),%eax 109f78: a8 20 test $0x20,%al 109f7a: 74 03 je 109f7f <== ALWAYS TAKEN c &= 0x7f; 109f7c: 83 e3 7f and $0x7f,%ebx <== NOT EXECUTED if (tty->termios.c_iflag & IUCLC) 109f7f: f6 c4 02 test $0x2,%ah 109f82: 74 18 je 109f9c c = tolower (c); 109f84: 0f b6 db movzbl %bl,%ebx 109f87: 8b 15 94 5a 12 00 mov 0x125a94,%edx 109f8d: 0f be 54 1a 01 movsbl 0x1(%edx,%ebx,1),%edx 109f92: 83 e2 03 and $0x3,%edx 109f95: 4a dec %edx 109f96: 0f 84 9c 00 00 00 je 10a038 if (c == '\r') { 109f9c: 80 fb 0d cmp $0xd,%bl 109f9f: 74 33 je 109fd4 if (tty->termios.c_iflag & IGNCR) return 0; if (tty->termios.c_iflag & ICRNL) c = '\n'; } else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) { 109fa1: 80 fb 0a cmp $0xa,%bl 109fa4: 0f 84 86 00 00 00 je 10a030 c = '\r'; } if ((c != '\0') && (tty->termios.c_lflag & ICANON)) { 109faa: 84 db test %bl,%bl 109fac: 75 3a jne 109fe8 <== ALWAYS TAKEN } /* * FIXME: Should do IMAXBEL handling somehow */ if (tty->ccount < (CBUFSIZE-1)) { 109fae: 8b 46 20 mov 0x20(%esi),%eax 109fb1: 8b 15 80 59 12 00 mov 0x125980,%edx 109fb7: 4a dec %edx 109fb8: 39 d0 cmp %edx,%eax 109fba: 7d 1c jge 109fd8 <== NEVER TAKEN if (tty->termios.c_lflag & ECHO) 109fbc: f6 46 3c 08 testb $0x8,0x3c(%esi) 109fc0: 75 7e jne 10a040 <== ALWAYS TAKEN echo (c, tty); tty->cbuf[tty->ccount++] = c; 109fc2: 8b 56 1c mov 0x1c(%esi),%edx 109fc5: 88 1c 02 mov %bl,(%edx,%eax,1) 109fc8: 40 inc %eax 109fc9: 89 46 20 mov %eax,0x20(%esi) } return 0; 109fcc: 31 c0 xor %eax,%eax } 109fce: 5b pop %ebx 109fcf: 5e pop %esi 109fd0: c9 leave 109fd1: c3 ret 109fd2: 66 90 xchg %ax,%ax if (tty->termios.c_iflag & IUCLC) c = tolower (c); if (c == '\r') { if (tty->termios.c_iflag & IGNCR) 109fd4: a8 80 test $0x80,%al 109fd6: 74 08 je 109fe0 <== ALWAYS TAKEN if (tty->ccount < (CBUFSIZE-1)) { if (tty->termios.c_lflag & ECHO) echo (c, tty); tty->cbuf[tty->ccount++] = c; } return 0; 109fd8: 31 c0 xor %eax,%eax } 109fda: 5b pop %ebx <== NOT EXECUTED 109fdb: 5e pop %esi <== NOT EXECUTED 109fdc: c9 leave <== NOT EXECUTED 109fdd: c3 ret <== NOT EXECUTED 109fde: 66 90 xchg %ax,%ax <== NOT EXECUTED c = tolower (c); if (c == '\r') { if (tty->termios.c_iflag & IGNCR) return 0; if (tty->termios.c_iflag & ICRNL) 109fe0: f6 c4 01 test $0x1,%ah 109fe3: 74 03 je 109fe8 <== NEVER TAKEN c = '\n'; 109fe5: b3 0a mov $0xa,%bl 109fe7: 90 nop } else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) { c = '\r'; } if ((c != '\0') && (tty->termios.c_lflag & ICANON)) { 109fe8: 8b 46 3c mov 0x3c(%esi),%eax 109feb: a8 02 test $0x2,%al 109fed: 74 bf je 109fae if (c == tty->termios.c_cc[VERASE]) { 109fef: 38 5e 43 cmp %bl,0x43(%esi) 109ff2: 0f 84 b0 00 00 00 je 10a0a8 erase (tty, 0); return 0; } else if (c == tty->termios.c_cc[VKILL]) { 109ff8: 38 5e 44 cmp %bl,0x44(%esi) 109ffb: 74 63 je 10a060 erase (tty, 1); return 0; } else if (c == tty->termios.c_cc[VEOF]) { 109ffd: 38 5e 45 cmp %bl,0x45(%esi) 10a000: 0f 84 96 00 00 00 je 10a09c <== NEVER TAKEN return 1; } else if (c == '\n') { 10a006: 80 fb 0a cmp $0xa,%bl 10a009: 74 69 je 10a074 if (tty->termios.c_lflag & (ECHO | ECHONL)) echo (c, tty); tty->cbuf[tty->ccount++] = c; return 1; } else if ((c == tty->termios.c_cc[VEOL]) || 10a00b: 38 5e 4c cmp %bl,0x4c(%esi) 10a00e: 74 05 je 10a015 <== NEVER TAKEN 10a010: 38 5e 51 cmp %bl,0x51(%esi) 10a013: 75 99 jne 109fae <== ALWAYS TAKEN (c == tty->termios.c_cc[VEOL2])) { if (tty->termios.c_lflag & ECHO) 10a015: a8 08 test $0x8,%al <== NOT EXECUTED 10a017: 75 3b jne 10a054 <== NOT EXECUTED echo (c, tty); tty->cbuf[tty->ccount++] = c; 10a019: 8b 46 20 mov 0x20(%esi),%eax <== NOT EXECUTED 10a01c: 8b 56 1c mov 0x1c(%esi),%edx <== NOT EXECUTED 10a01f: 88 1c 02 mov %bl,(%edx,%eax,1) <== NOT EXECUTED 10a022: 40 inc %eax <== NOT EXECUTED 10a023: 89 46 20 mov %eax,0x20(%esi) <== NOT EXECUTED return 1; 10a026: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10a02b: eb a1 jmp 109fce <== NOT EXECUTED 10a02d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if (c == '\r') { if (tty->termios.c_iflag & IGNCR) return 0; if (tty->termios.c_iflag & ICRNL) c = '\n'; } else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) { 10a030: a8 40 test $0x40,%al 10a032: 74 b4 je 109fe8 <== ALWAYS TAKEN c = '\r'; 10a034: b3 0d mov $0xd,%bl <== NOT EXECUTED 10a036: eb b0 jmp 109fe8 <== NOT EXECUTED { if (tty->termios.c_iflag & ISTRIP) c &= 0x7f; if (tty->termios.c_iflag & IUCLC) c = tolower (c); 10a038: 83 c3 20 add $0x20,%ebx 10a03b: e9 5c ff ff ff jmp 109f9c /* * FIXME: Should do IMAXBEL handling somehow */ if (tty->ccount < (CBUFSIZE-1)) { if (tty->termios.c_lflag & ECHO) echo (c, tty); 10a040: 0f b6 c3 movzbl %bl,%eax 10a043: 89 f2 mov %esi,%edx 10a045: e8 f2 fc ff ff call 109d3c 10a04a: 8b 46 20 mov 0x20(%esi),%eax 10a04d: e9 70 ff ff ff jmp 109fc2 10a052: 66 90 xchg %ax,%ax tty->cbuf[tty->ccount++] = c; return 1; } else if ((c == tty->termios.c_cc[VEOL]) || (c == tty->termios.c_cc[VEOL2])) { if (tty->termios.c_lflag & ECHO) echo (c, tty); 10a054: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED 10a057: 89 f2 mov %esi,%edx <== NOT EXECUTED 10a059: e8 de fc ff ff call 109d3c <== NOT EXECUTED 10a05e: eb b9 jmp 10a019 <== NOT EXECUTED if (c == tty->termios.c_cc[VERASE]) { erase (tty, 0); return 0; } else if (c == tty->termios.c_cc[VKILL]) { erase (tty, 1); 10a060: ba 01 00 00 00 mov $0x1,%edx 10a065: 89 f0 mov %esi,%eax 10a067: e8 34 fd ff ff call 109da0 return 0; 10a06c: 31 c0 xor %eax,%eax 10a06e: e9 5b ff ff ff jmp 109fce 10a073: 90 nop } else if (c == tty->termios.c_cc[VEOF]) { return 1; } else if (c == '\n') { if (tty->termios.c_lflag & (ECHO | ECHONL)) 10a074: a8 48 test $0x48,%al 10a076: 74 0c je 10a084 <== NEVER TAKEN echo (c, tty); 10a078: 89 f2 mov %esi,%edx 10a07a: b8 0a 00 00 00 mov $0xa,%eax 10a07f: e8 b8 fc ff ff call 109d3c tty->cbuf[tty->ccount++] = c; 10a084: 8b 46 20 mov 0x20(%esi),%eax 10a087: 8b 56 1c mov 0x1c(%esi),%edx 10a08a: c6 04 02 0a movb $0xa,(%edx,%eax,1) 10a08e: 40 inc %eax 10a08f: 89 46 20 mov %eax,0x20(%esi) return 1; 10a092: b8 01 00 00 00 mov $0x1,%eax 10a097: e9 32 ff ff ff jmp 109fce else if (c == tty->termios.c_cc[VKILL]) { erase (tty, 1); return 0; } else if (c == tty->termios.c_cc[VEOF]) { return 1; 10a09c: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10a0a1: e9 28 ff ff ff jmp 109fce <== NOT EXECUTED 10a0a6: 66 90 xchg %ax,%ax <== NOT EXECUTED c = '\r'; } if ((c != '\0') && (tty->termios.c_lflag & ICANON)) { if (c == tty->termios.c_cc[VERASE]) { erase (tty, 0); 10a0a8: 31 d2 xor %edx,%edx 10a0aa: 89 f0 mov %esi,%eax 10a0ac: e8 ef fc ff ff call 109da0 return 0; 10a0b1: 31 c0 xor %eax,%eax 10a0b3: e9 16 ff ff ff jmp 109fce =============================================================================== 001249b8 : int killinfo( pid_t pid, int sig, const union sigval *value ) { 1249b8: 55 push %ebp 1249b9: 89 e5 mov %esp,%ebp 1249bb: 57 push %edi 1249bc: 56 push %esi 1249bd: 53 push %ebx 1249be: 83 ec 3c sub $0x3c,%esp 1249c1: 8b 75 0c mov 0xc(%ebp),%esi 1249c4: 8b 7d 10 mov 0x10(%ebp),%edi POSIX_signals_Siginfo_node *psiginfo; /* * Only supported for the "calling process" (i.e. this node). */ if ( pid != getpid() ) 1249c7: e8 00 fd ff ff call 1246cc 1249cc: 3b 45 08 cmp 0x8(%ebp),%eax 1249cf: 0f 85 3f 02 00 00 jne 124c14 rtems_set_errno_and_return_minus_one( ESRCH ); /* * Validate the signal passed. */ if ( !sig ) 1249d5: 85 f6 test %esi,%esi 1249d7: 0f 84 4c 02 00 00 je 124c29 static inline bool is_valid_signo( int signo ) { return ((signo) >= 1 && (signo) <= 32 ); 1249dd: 8d 4e ff lea -0x1(%esi),%ecx rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 1249e0: 83 f9 1f cmp $0x1f,%ecx 1249e3: 0f 87 40 02 00 00 ja 124c29 rtems_set_errno_and_return_minus_one( EINVAL ); /* * If the signal is being ignored, then we are out of here. */ if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) 1249e9: 8d 04 76 lea (%esi,%esi,2),%eax 1249ec: 83 3c 85 28 f1 12 00 cmpl $0x1,0x12f128(,%eax,4) 1249f3: 01 1249f4: 0f 84 e6 01 00 00 je 124be0 /* * P1003.1c/Draft 10, p. 33 says that certain signals should always * be directed to the executing thread such as those caused by hardware * faults. */ if ( (sig == SIGFPE) || (sig == SIGILL) || (sig == SIGSEGV ) ) 1249fa: 83 fe 08 cmp $0x8,%esi 1249fd: 0f 84 c9 00 00 00 je 124acc 124a03: 83 fe 04 cmp $0x4,%esi 124a06: 0f 84 c0 00 00 00 je 124acc 124a0c: 83 fe 0b cmp $0xb,%esi 124a0f: 0f 84 b7 00 00 00 je 124acc static inline sigset_t signo_to_mask( uint32_t sig ) { return 1u << (sig - 1); 124a15: bb 01 00 00 00 mov $0x1,%ebx 124a1a: d3 e3 shl %cl,%ebx /* * Build up a siginfo structure */ siginfo = &siginfo_struct; siginfo->si_signo = sig; 124a1c: 89 75 dc mov %esi,-0x24(%ebp) siginfo->si_code = SI_USER; 124a1f: c7 45 e0 01 00 00 00 movl $0x1,-0x20(%ebp) if ( !value ) { 124a26: 85 ff test %edi,%edi 124a28: 0f 84 ba 01 00 00 je 124be8 siginfo->si_value.sival_int = 0; } else { siginfo->si_value = *value; 124a2e: 8b 07 mov (%edi),%eax 124a30: 89 45 e4 mov %eax,-0x1c(%ebp) 124a33: a1 10 eb 12 00 mov 0x12eb10,%eax 124a38: 40 inc %eax 124a39: a3 10 eb 12 00 mov %eax,0x12eb10 /* * Is the currently executing thread interested? If so then it will * get it an execute it as soon as the dispatcher executes. */ the_thread = _Thread_Executing; 124a3e: 8b 0d b8 f0 12 00 mov 0x12f0b8,%ecx api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( _POSIX_signals_Is_interested( api, mask ) ) { 124a44: 8b 81 ec 00 00 00 mov 0xec(%ecx),%eax 124a4a: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax 124a50: f7 d0 not %eax 124a52: 85 c3 test %eax,%ebx 124a54: 75 34 jne 124a8a } DEBUG_STEP("\n"); _Thread_Enable_dispatch(); return 0; } 124a56: a1 c0 f2 12 00 mov 0x12f2c0,%eax /* XXX violation of visibility -- need to define thread queue support */ the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo; for ( the_node = _Chain_First( the_chain ); 124a5b: 3d c4 f2 12 00 cmp $0x12f2c4,%eax 124a60: 75 1b jne 124a7d 124a62: e9 81 00 00 00 jmp 124ae8 124a67: 90 nop /* * Is this thread is blocked waiting for another signal but has * not blocked this one? */ if (~api->signals_blocked & mask) 124a68: 8b 92 d0 00 00 00 mov 0xd0(%edx),%edx 124a6e: f7 d2 not %edx 124a70: 85 d3 test %edx,%ebx 124a72: 75 16 jne 124a8a the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo; for ( the_node = _Chain_First( the_chain ); !_Chain_Is_tail( the_chain, the_node ) ; the_node = the_node->next ) { 124a74: 8b 00 mov (%eax),%eax /* XXX violation of visibility -- need to define thread queue support */ the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo; for ( the_node = _Chain_First( the_chain ); 124a76: 3d c4 f2 12 00 cmp $0x12f2c4,%eax 124a7b: 74 6b je 124ae8 <== ALWAYS TAKEN !_Chain_Is_tail( the_chain, the_node ) ; the_node = the_node->next ) { the_thread = (Thread_Control *)the_node; 124a7d: 89 c1 mov %eax,%ecx api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 124a7f: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx #endif /* * Is this thread is actually blocked waiting for the signal? */ if (the_thread->Wait.option & mask) 124a85: 85 58 30 test %ebx,0x30(%eax) 124a88: 74 de je 124a68 /* * Returns true if the signal was synchronously given to a thread * blocked waiting for the signal. */ if ( _POSIX_signals_Unblock_thread( the_thread, sig, siginfo ) ) { 124a8a: 50 push %eax mask = signo_to_mask( sig ); /* * Build up a siginfo structure */ siginfo = &siginfo_struct; 124a8b: 8d 45 dc lea -0x24(%ebp),%eax /* * Returns true if the signal was synchronously given to a thread * blocked waiting for the signal. */ if ( _POSIX_signals_Unblock_thread( the_thread, sig, siginfo ) ) { 124a8e: 50 push %eax 124a8f: 56 push %esi 124a90: 51 push %ecx 124a91: e8 d6 01 00 00 call 124c6c <_POSIX_signals_Unblock_thread> 124a96: 83 c4 10 add $0x10,%esp 124a99: 84 c0 test %al,%al 124a9b: 75 1f jne 124abc /* * We may have woken up a thread but we definitely need to post the * signal to the process wide information set. */ _POSIX_signals_Set_process_signals( mask ); 124a9d: 83 ec 0c sub $0xc,%esp 124aa0: 53 push %ebx 124aa1: e8 b2 01 00 00 call 124c58 <_POSIX_signals_Set_process_signals> if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) { 124aa6: 8d 1c 76 lea (%esi,%esi,2),%ebx 124aa9: c1 e3 02 shl $0x2,%ebx 124aac: 83 c4 10 add $0x10,%esp 124aaf: 83 bb 20 f1 12 00 02 cmpl $0x2,0x12f120(%ebx) 124ab6: 0f 84 e4 00 00 00 je 124ba0 _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); } DEBUG_STEP("\n"); _Thread_Enable_dispatch(); 124abc: e8 17 e0 fe ff call 112ad8 <_Thread_Enable_dispatch> return 0; 124ac1: 31 c0 xor %eax,%eax } 124ac3: 8d 65 f4 lea -0xc(%ebp),%esp 124ac6: 5b pop %ebx 124ac7: 5e pop %esi 124ac8: 5f pop %edi 124ac9: c9 leave 124aca: c3 ret 124acb: 90 nop * P1003.1c/Draft 10, p. 33 says that certain signals should always * be directed to the executing thread such as those caused by hardware * faults. */ if ( (sig == SIGFPE) || (sig == SIGILL) || (sig == SIGSEGV ) ) return pthread_kill( pthread_self(), sig ); 124acc: e8 7b 03 00 00 call 124e4c 124ad1: 83 ec 08 sub $0x8,%esp 124ad4: 56 push %esi 124ad5: 50 push %eax 124ad6: e8 b1 02 00 00 call 124d8c 124adb: 83 c4 10 add $0x10,%esp } DEBUG_STEP("\n"); _Thread_Enable_dispatch(); return 0; } 124ade: 8d 65 f4 lea -0xc(%ebp),%esp 124ae1: 5b pop %ebx 124ae2: 5e pop %esi 124ae3: 5f pop %edi 124ae4: c9 leave 124ae5: c3 ret 124ae6: 66 90 xchg %ax,%ax * NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL; interested_priority = PRIORITY_MAXIMUM + 1; 124ae8: 0f b6 05 54 a6 12 00 movzbl 0x12a654,%eax 124aef: 40 inc %eax 124af0: 89 45 d4 mov %eax,-0x2c(%ebp) * * NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL; 124af3: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp) interested_priority = PRIORITY_MAXIMUM + 1; for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) { 124afa: c7 45 cc 02 00 00 00 movl $0x2,-0x34(%ebp) 124b01: 89 5d d0 mov %ebx,-0x30(%ebp) 124b04: 89 75 c0 mov %esi,-0x40(%ebp) /* * This can occur when no one is interested and an API is not configured. */ if ( !_Objects_Information_table[ the_api ] ) 124b07: 8b 55 cc mov -0x34(%ebp),%edx 124b0a: 8b 04 95 e8 ea 12 00 mov 0x12eae8(,%edx,4),%eax 124b11: 85 c0 test %eax,%eax 124b13: 74 68 je 124b7d <== NEVER TAKEN continue; the_info = _Objects_Information_table[ the_api ][ 1 ]; 124b15: 8b 40 04 mov 0x4(%eax),%eax */ if ( !the_info ) continue; #endif maximum = the_info->maximum; 124b18: 0f b7 70 10 movzwl 0x10(%eax),%esi object_table = the_info->local_table; 124b1c: 8b 78 1c mov 0x1c(%eax),%edi for ( index = 1 ; index <= maximum ; index++ ) { 124b1f: 85 f6 test %esi,%esi 124b21: 74 5a je 124b7d 124b23: b8 01 00 00 00 mov $0x1,%eax the_thread = (Thread_Control *) object_table[ index ]; 124b28: 8b 14 87 mov (%edi,%eax,4),%edx if ( !the_thread ) 124b2b: 85 d2 test %edx,%edx 124b2d: 74 49 je 124b78 /* * If this thread is of lower priority than the interested thread, * go on to the next thread. */ if ( the_thread->current_priority > interested_priority ) 124b2f: 8b 4a 14 mov 0x14(%edx),%ecx 124b32: 3b 4d d4 cmp -0x2c(%ebp),%ecx 124b35: 77 41 ja 124b78 #if defined(RTEMS_DEBUG) if ( !api ) continue; #endif if ( !_POSIX_signals_Is_interested( api, mask ) ) 124b37: 8b 9a ec 00 00 00 mov 0xec(%edx),%ebx 124b3d: 8b 9b d0 00 00 00 mov 0xd0(%ebx),%ebx 124b43: f7 d3 not %ebx 124b45: 85 5d d0 test %ebx,-0x30(%ebp) 124b48: 74 2e je 124b78 * * NOTE: We initialized interested_priority to PRIORITY_MAXIMUM + 1 * so we never have to worry about deferencing a NULL * interested thread. */ if ( the_thread->current_priority < interested_priority ) { 124b4a: 3b 4d d4 cmp -0x2c(%ebp),%ecx 124b4d: 72 21 jb 124b70 * and blocking interruptibutable by signal. * * If the interested thread is ready, don't think about changing. */ if ( interested && !_States_Is_ready( interested->current_state ) ) { 124b4f: 8b 5d c8 mov -0x38(%ebp),%ebx 124b52: 85 db test %ebx,%ebx 124b54: 74 22 je 124b78 <== NEVER TAKEN 124b56: 8b 5d c8 mov -0x38(%ebp),%ebx 124b59: 8b 5b 10 mov 0x10(%ebx),%ebx 124b5c: 89 5d c4 mov %ebx,-0x3c(%ebp) 124b5f: 85 db test %ebx,%ebx 124b61: 74 15 je 124b78 <== NEVER TAKEN /* preferred ready over blocked */ DEBUG_STEP("5"); if ( _States_Is_ready( the_thread->current_state ) ) { 124b63: 8b 5a 10 mov 0x10(%edx),%ebx 124b66: 85 db test %ebx,%ebx 124b68: 0f 85 86 00 00 00 jne 124bf4 124b6e: 66 90 xchg %ax,%ax 124b70: 89 4d d4 mov %ecx,-0x2c(%ebp) 124b73: 89 55 c8 mov %edx,-0x38(%ebp) 124b76: 66 90 xchg %ax,%ax #endif maximum = the_info->maximum; object_table = the_info->local_table; for ( index = 1 ; index <= maximum ; index++ ) { 124b78: 40 inc %eax 124b79: 39 c6 cmp %eax,%esi 124b7b: 73 ab jae 124b28 * + rtems internal threads do not receive signals. */ interested = NULL; interested_priority = PRIORITY_MAXIMUM + 1; for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) { 124b7d: ff 45 cc incl -0x34(%ebp) 124b80: 83 7d cc 04 cmpl $0x4,-0x34(%ebp) 124b84: 75 81 jne 124b07 124b86: 8b 5d d0 mov -0x30(%ebp),%ebx 124b89: 8b 75 c0 mov -0x40(%ebp),%esi } } } } if ( interested ) { 124b8c: 8b 55 c8 mov -0x38(%ebp),%edx 124b8f: 85 d2 test %edx,%edx 124b91: 0f 84 06 ff ff ff je 124a9d 124b97: 8b 4d c8 mov -0x38(%ebp),%ecx 124b9a: e9 eb fe ff ff jmp 124a8a 124b9f: 90 nop _POSIX_signals_Set_process_signals( mask ); if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) { psiginfo = (POSIX_signals_Siginfo_node *) _Chain_Get( &_POSIX_signals_Inactive_siginfo ); 124ba0: 83 ec 0c sub $0xc,%esp 124ba3: 68 a0 f2 12 00 push $0x12f2a0 124ba8: e8 ef c4 fe ff call 11109c <_Chain_Get> if ( !psiginfo ) { 124bad: 83 c4 10 add $0x10,%esp 124bb0: 85 c0 test %eax,%eax 124bb2: 0f 84 86 00 00 00 je 124c3e _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EAGAIN ); } psiginfo->Info = *siginfo; 124bb8: 8d 78 08 lea 0x8(%eax),%edi 124bbb: 8d 75 dc lea -0x24(%ebp),%esi 124bbe: b9 03 00 00 00 mov $0x3,%ecx 124bc3: f3 a5 rep movsl %ds:(%esi),%es:(%edi) _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); 124bc5: 83 ec 08 sub $0x8,%esp 124bc8: 50 push %eax 124bc9: 81 c3 40 f3 12 00 add $0x12f340,%ebx 124bcf: 53 push %ebx 124bd0: e8 8b c4 fe ff call 111060 <_Chain_Append> 124bd5: 83 c4 10 add $0x10,%esp 124bd8: e9 df fe ff ff jmp 124abc 124bdd: 8d 76 00 lea 0x0(%esi),%esi /* * If the signal is being ignored, then we are out of here. */ if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) return 0; 124be0: 31 c0 xor %eax,%eax 124be2: e9 f7 fe ff ff jmp 124ade 124be7: 90 nop */ siginfo = &siginfo_struct; siginfo->si_signo = sig; siginfo->si_code = SI_USER; if ( !value ) { siginfo->si_value.sival_int = 0; 124be8: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) 124bef: e9 3f fe ff ff jmp 124a33 continue; } DEBUG_STEP("6"); /* prefer blocked/interruptible over blocked/not interruptible */ if ( !_States_Is_interruptible_by_signal(interested->current_state) ) { 124bf4: f7 45 c4 00 00 00 10 testl $0x10000000,-0x3c(%ebp) 124bfb: 0f 85 77 ff ff ff jne 124b78 DEBUG_STEP("7"); if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) { 124c01: 81 e3 00 00 00 10 and $0x10000000,%ebx 124c07: 0f 84 6b ff ff ff je 124b78 124c0d: e9 5e ff ff ff jmp 124b70 124c12: 66 90 xchg %ax,%ax /* * Only supported for the "calling process" (i.e. this node). */ if ( pid != getpid() ) rtems_set_errno_and_return_minus_one( ESRCH ); 124c14: e8 1f 38 ff ff call 118438 <__errno> 124c19: c7 00 03 00 00 00 movl $0x3,(%eax) 124c1f: b8 ff ff ff ff mov $0xffffffff,%eax 124c24: e9 b5 fe ff ff jmp 124ade */ if ( !sig ) rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) rtems_set_errno_and_return_minus_one( EINVAL ); 124c29: e8 0a 38 ff ff call 118438 <__errno> 124c2e: c7 00 16 00 00 00 movl $0x16,(%eax) 124c34: b8 ff ff ff ff mov $0xffffffff,%eax 124c39: e9 a0 fe ff ff jmp 124ade if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) { psiginfo = (POSIX_signals_Siginfo_node *) _Chain_Get( &_POSIX_signals_Inactive_siginfo ); if ( !psiginfo ) { _Thread_Enable_dispatch(); 124c3e: e8 95 de fe ff call 112ad8 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EAGAIN ); 124c43: e8 f0 37 ff ff call 118438 <__errno> 124c48: c7 00 0b 00 00 00 movl $0xb,(%eax) 124c4e: 83 c8 ff or $0xffffffff,%eax 124c51: e9 88 fe ff ff jmp 124ade =============================================================================== 0011f184 : extern void _wrapup_reent(struct _reent *); extern void _reclaim_reent(struct _reent *); void libc_wrapup(void) { 11f184: 55 push %ebp 11f185: 89 e5 mov %esp,%ebp 11f187: 53 push %ebx 11f188: 83 ec 04 sub $0x4,%esp /* * In case RTEMS is already down, don't do this. It could be * dangerous. */ if (!_System_state_Is_up(_System_state_Get())) 11f18b: 83 3d 20 7f 12 00 03 cmpl $0x3,0x127f20 11f192: 74 08 je 11f19c <== ALWAYS TAKEN */ fclose (stdin); fclose (stdout); fclose (stderr); } 11f194: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 11f197: c9 leave <== NOT EXECUTED 11f198: c3 ret <== NOT EXECUTED 11f199: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /* * This was already done if the user called exit() directly . _wrapup_reent(0); */ if (_REENT != _global_impure_ptr) { 11f19c: a1 a0 5a 12 00 mov 0x125aa0,%eax 11f1a1: 8b 1d e0 1e 12 00 mov 0x121ee0,%ebx 11f1a7: 39 d8 cmp %ebx,%eax 11f1a9: 74 14 je 11f1bf _wrapup_reent(_global_impure_ptr); 11f1ab: 83 ec 0c sub $0xc,%esp 11f1ae: 53 push %ebx 11f1af: e8 f8 05 00 00 call 11f7ac <_wrapup_reent> /* Don't reclaim this one, just in case we do printfs * on the way out to ROM. */ _reclaim_reent(&libc_global_reent); #endif _REENT = _global_impure_ptr; 11f1b4: 89 1d a0 5a 12 00 mov %ebx,0x125aa0 11f1ba: 83 c4 10 add $0x10,%esp 11f1bd: 89 d8 mov %ebx,%eax * * Should this be changed to do *all* file streams? * _fwalk (_REENT, fclose); */ fclose (stdin); 11f1bf: 83 ec 0c sub $0xc,%esp 11f1c2: ff 70 04 pushl 0x4(%eax) 11f1c5: e8 fe 41 ff ff call 1133c8 fclose (stdout); 11f1ca: 5a pop %edx 11f1cb: a1 a0 5a 12 00 mov 0x125aa0,%eax 11f1d0: ff 70 08 pushl 0x8(%eax) 11f1d3: e8 f0 41 ff ff call 1133c8 fclose (stderr); 11f1d8: 58 pop %eax 11f1d9: a1 a0 5a 12 00 mov 0x125aa0,%eax 11f1de: ff 70 0c pushl 0xc(%eax) 11f1e1: e8 e2 41 ff ff call 1133c8 11f1e6: 83 c4 10 add $0x10,%esp } 11f1e9: 8b 5d fc mov -0x4(%ebp),%ebx 11f1ec: c9 leave 11f1ed: c3 ret =============================================================================== 0010b578 : int link( const char *existing, const char *new ) { 10b578: 55 push %ebp 10b579: 89 e5 mov %esp,%ebp 10b57b: 57 push %edi 10b57c: 56 push %esi 10b57d: 53 push %ebx 10b57e: 83 ec 58 sub $0x58,%esp 10b581: 8b 55 08 mov 0x8(%ebp),%edx 10b584: 8b 5d 0c mov 0xc(%ebp),%ebx /* * Get the node we are linking to. */ result = rtems_filesystem_evaluate_path( existing, strlen( existing ), 10b587: 31 c0 xor %eax,%eax 10b589: b9 ff ff ff ff mov $0xffffffff,%ecx 10b58e: 89 d7 mov %edx,%edi 10b590: f2 ae repnz scas %es:(%edi),%al 10b592: f7 d1 not %ecx 10b594: 49 dec %ecx 10b595: 6a 01 push $0x1 10b597: 8d 75 cc lea -0x34(%ebp),%esi 10b59a: 56 push %esi 10b59b: 6a 00 push $0x0 10b59d: 51 push %ecx 10b59e: 52 push %edx 10b59f: e8 28 f9 ff ff call 10aecc 0, &existing_loc, true ); if ( result != 0 ) 10b5a4: 83 c4 20 add $0x20,%esp 10b5a7: 85 c0 test %eax,%eax 10b5a9: 74 0d je 10b5b8 return -1; 10b5ab: b8 ff ff ff ff mov $0xffffffff,%eax rtems_filesystem_freenode( &existing_loc ); rtems_filesystem_freenode( &parent_loc ); return result; } 10b5b0: 8d 65 f4 lea -0xc(%ebp),%esp 10b5b3: 5b pop %ebx 10b5b4: 5e pop %esi 10b5b5: 5f pop %edi 10b5b6: c9 leave 10b5b7: c3 ret /* * Get the parent of the node we are creating. */ rtems_filesystem_get_start_loc( new, &i, &parent_loc ); 10b5b8: 52 push %edx 10b5b9: 8d 7d b8 lea -0x48(%ebp),%edi 10b5bc: 57 push %edi 10b5bd: 8d 45 e4 lea -0x1c(%ebp),%eax 10b5c0: 50 push %eax 10b5c1: 53 push %ebx 10b5c2: e8 f5 12 00 00 call 10c8bc result = (*parent_loc.ops->evalformake_h)( &new[i], &parent_loc, &name_start ); 10b5c7: 83 c4 0c add $0xc,%esp 10b5ca: 8d 45 e0 lea -0x20(%ebp),%eax 10b5cd: 50 push %eax 10b5ce: 57 push %edi 10b5cf: 03 5d e4 add -0x1c(%ebp),%ebx 10b5d2: 53 push %ebx 10b5d3: 8b 45 c4 mov -0x3c(%ebp),%eax 10b5d6: ff 50 04 call *0x4(%eax) if ( result != 0 ) { 10b5d9: 83 c4 10 add $0x10,%esp 10b5dc: 85 c0 test %eax,%eax 10b5de: 75 61 jne 10b641 /* * Check to see if the caller is trying to link across file system * boundaries. */ if ( parent_loc.mt_entry != existing_loc.mt_entry ) { 10b5e0: 8b 45 dc mov -0x24(%ebp),%eax 10b5e3: 39 45 c8 cmp %eax,-0x38(%ebp) 10b5e6: 75 30 jne 10b618 rtems_filesystem_freenode( &existing_loc ); rtems_filesystem_freenode( &parent_loc ); rtems_set_errno_and_return_minus_one( EXDEV ); } result = (*parent_loc.ops->link_h)( &existing_loc, &parent_loc, name_start ); 10b5e8: 50 push %eax 10b5e9: ff 75 e0 pushl -0x20(%ebp) 10b5ec: 57 push %edi 10b5ed: 56 push %esi 10b5ee: 8b 45 c4 mov -0x3c(%ebp),%eax 10b5f1: ff 50 08 call *0x8(%eax) rtems_filesystem_freenode( &existing_loc ); 10b5f4: 89 34 24 mov %esi,(%esp) 10b5f7: 89 45 b4 mov %eax,-0x4c(%ebp) 10b5fa: e8 81 fb ff ff call 10b180 rtems_filesystem_freenode( &parent_loc ); 10b5ff: 89 3c 24 mov %edi,(%esp) 10b602: e8 79 fb ff ff call 10b180 return result; 10b607: 83 c4 10 add $0x10,%esp 10b60a: 8b 45 b4 mov -0x4c(%ebp),%eax } 10b60d: 8d 65 f4 lea -0xc(%ebp),%esp 10b610: 5b pop %ebx 10b611: 5e pop %esi 10b612: 5f pop %edi 10b613: c9 leave 10b614: c3 ret 10b615: 8d 76 00 lea 0x0(%esi),%esi * Check to see if the caller is trying to link across file system * boundaries. */ if ( parent_loc.mt_entry != existing_loc.mt_entry ) { rtems_filesystem_freenode( &existing_loc ); 10b618: 83 ec 0c sub $0xc,%esp 10b61b: 56 push %esi 10b61c: e8 5f fb ff ff call 10b180 rtems_filesystem_freenode( &parent_loc ); 10b621: 89 3c 24 mov %edi,(%esp) 10b624: e8 57 fb ff ff call 10b180 rtems_set_errno_and_return_minus_one( EXDEV ); 10b629: e8 92 b8 00 00 call 116ec0 <__errno> 10b62e: c7 00 12 00 00 00 movl $0x12,(%eax) 10b634: 83 c4 10 add $0x10,%esp 10b637: b8 ff ff ff ff mov $0xffffffff,%eax 10b63c: e9 6f ff ff ff jmp 10b5b0 rtems_filesystem_get_start_loc( new, &i, &parent_loc ); result = (*parent_loc.ops->evalformake_h)( &new[i], &parent_loc, &name_start ); if ( result != 0 ) { rtems_filesystem_freenode( &existing_loc ); 10b641: 83 ec 0c sub $0xc,%esp 10b644: 56 push %esi 10b645: e8 36 fb ff ff call 10b180 return -1; 10b64a: 83 c4 10 add $0x10,%esp 10b64d: b8 ff ff ff ff mov $0xffffffff,%eax 10b652: e9 59 ff ff ff jmp 10b5b0 =============================================================================== 0011f05c : off_t lseek( int fd, off_t offset, int whence ) { 11f05c: 55 push %ebp 11f05d: 89 e5 mov %esp,%ebp 11f05f: 57 push %edi 11f060: 56 push %esi 11f061: 53 push %ebx 11f062: 83 ec 1c sub $0x1c,%esp 11f065: 8b 5d 08 mov 0x8(%ebp),%ebx 11f068: 8b 55 0c mov 0xc(%ebp),%edx 11f06b: 8b 4d 10 mov 0x10(%ebp),%ecx 11f06e: 8b 45 14 mov 0x14(%ebp),%eax rtems_libio_t *iop; off_t old_offset; off_t status; rtems_libio_check_fd( fd ); 11f071: 3b 1d 6c 39 12 00 cmp 0x12396c,%ebx 11f077: 0f 83 b3 00 00 00 jae 11f130 <== NEVER TAKEN iop = rtems_libio_iop( fd ); 11f07d: 8d 34 dd 00 00 00 00 lea 0x0(,%ebx,8),%esi 11f084: 8d 1c f5 00 00 00 00 lea 0x0(,%esi,8),%ebx 11f08b: 29 f3 sub %esi,%ebx 11f08d: 03 1d 20 7c 12 00 add 0x127c20,%ebx rtems_libio_check_is_open(iop); 11f093: f6 43 15 01 testb $0x1,0x15(%ebx) 11f097: 0f 84 93 00 00 00 je 11f130 <== NEVER TAKEN /* * Now process the lseek(). */ old_offset = iop->offset; 11f09d: 8b 73 0c mov 0xc(%ebx),%esi 11f0a0: 8b 7b 10 mov 0x10(%ebx),%edi 11f0a3: 89 75 e0 mov %esi,-0x20(%ebp) 11f0a6: 89 7d e4 mov %edi,-0x1c(%ebp) switch ( whence ) { 11f0a9: 83 f8 01 cmp $0x1,%eax 11f0ac: 74 6e je 11f11c 11f0ae: 83 f8 02 cmp $0x2,%eax 11f0b1: 74 35 je 11f0e8 11f0b3: 85 c0 test %eax,%eax 11f0b5: 75 45 jne 11f0fc case SEEK_SET: iop->offset = offset; 11f0b7: 89 53 0c mov %edx,0xc(%ebx) 11f0ba: 89 4b 10 mov %ecx,0x10(%ebx) /* * At this time, handlers assume iop->offset has the desired * new offset. */ status = (*iop->pathinfo.handlers->lseek_h)( iop, offset, whence ); 11f0bd: 8b 73 20 mov 0x20(%ebx),%esi 11f0c0: 50 push %eax 11f0c1: 51 push %ecx 11f0c2: 52 push %edx 11f0c3: 53 push %ebx 11f0c4: ff 56 14 call *0x14(%esi) if ( status == (off_t) -1 ) 11f0c7: 83 c4 10 add $0x10,%esp 11f0ca: 89 c1 mov %eax,%ecx 11f0cc: 21 d1 and %edx,%ecx 11f0ce: 41 inc %ecx 11f0cf: 75 0c jne 11f0dd iop->offset = old_offset; 11f0d1: 8b 75 e0 mov -0x20(%ebp),%esi 11f0d4: 8b 7d e4 mov -0x1c(%ebp),%edi 11f0d7: 89 73 0c mov %esi,0xc(%ebx) 11f0da: 89 7b 10 mov %edi,0x10(%ebx) /* * So if the operation failed, we have to restore iop->offset. */ return status; } 11f0dd: 8d 65 f4 lea -0xc(%ebp),%esp 11f0e0: 5b pop %ebx 11f0e1: 5e pop %esi 11f0e2: 5f pop %edi 11f0e3: c9 leave 11f0e4: c3 ret 11f0e5: 8d 76 00 lea 0x0(%esi),%esi case SEEK_CUR: iop->offset += offset; break; case SEEK_END: iop->offset = iop->size + offset; 11f0e8: 89 d6 mov %edx,%esi 11f0ea: 89 cf mov %ecx,%edi 11f0ec: 03 73 04 add 0x4(%ebx),%esi 11f0ef: 13 7b 08 adc 0x8(%ebx),%edi 11f0f2: 89 73 0c mov %esi,0xc(%ebx) 11f0f5: 89 7b 10 mov %edi,0x10(%ebx) break; 11f0f8: eb c3 jmp 11f0bd 11f0fa: 66 90 xchg %ax,%ax default: rtems_set_errno_and_return_minus_one( EINVAL ); 11f0fc: e8 6f 41 ff ff call 113270 <__errno> 11f101: c7 00 16 00 00 00 movl $0x16,(%eax) 11f107: b8 ff ff ff ff mov $0xffffffff,%eax 11f10c: ba ff ff ff ff mov $0xffffffff,%edx /* * So if the operation failed, we have to restore iop->offset. */ return status; } 11f111: 8d 65 f4 lea -0xc(%ebp),%esp 11f114: 5b pop %ebx 11f115: 5e pop %esi 11f116: 5f pop %edi 11f117: c9 leave 11f118: c3 ret 11f119: 8d 76 00 lea 0x0(%esi),%esi case SEEK_SET: iop->offset = offset; break; case SEEK_CUR: iop->offset += offset; 11f11c: 8b 75 e0 mov -0x20(%ebp),%esi 11f11f: 8b 7d e4 mov -0x1c(%ebp),%edi 11f122: 01 d6 add %edx,%esi 11f124: 11 cf adc %ecx,%edi 11f126: 89 73 0c mov %esi,0xc(%ebx) 11f129: 89 7b 10 mov %edi,0x10(%ebx) break; 11f12c: eb 8f jmp 11f0bd 11f12e: 66 90 xchg %ax,%ax off_t old_offset; off_t status; rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open(iop); 11f130: e8 3b 41 ff ff call 113270 <__errno> 11f135: c7 00 09 00 00 00 movl $0x9,(%eax) 11f13b: b8 ff ff ff ff mov $0xffffffff,%eax 11f140: ba ff ff ff ff mov $0xffffffff,%edx 11f145: eb 96 jmp 11f0dd =============================================================================== 00109ecc : int _STAT_NAME( const char *path, struct stat *buf ) { 109ecc: 55 push %ebp 109ecd: 89 e5 mov %esp,%ebp 109ecf: 57 push %edi 109ed0: 56 push %esi 109ed1: 53 push %ebx 109ed2: 83 ec 3c sub $0x3c,%esp 109ed5: 8b 55 08 mov 0x8(%ebp),%edx 109ed8: 8b 75 0c mov 0xc(%ebp),%esi /* * Check to see if we were passed a valid pointer. */ if ( !buf ) 109edb: 85 f6 test %esi,%esi 109edd: 74 65 je 109f44 rtems_set_errno_and_return_minus_one( EFAULT ); status = rtems_filesystem_evaluate_path( path, strlen( path ), 109edf: b9 ff ff ff ff mov $0xffffffff,%ecx 109ee4: 89 d7 mov %edx,%edi 109ee6: 31 c0 xor %eax,%eax 109ee8: f2 ae repnz scas %es:(%edi),%al 109eea: f7 d1 not %ecx 109eec: 49 dec %ecx 109eed: 83 ec 0c sub $0xc,%esp 109ef0: 6a 00 push $0x0 109ef2: 8d 5d d4 lea -0x2c(%ebp),%ebx 109ef5: 53 push %ebx 109ef6: 6a 00 push $0x0 109ef8: 51 push %ecx 109ef9: 52 push %edx 109efa: e8 e5 f9 ff ff call 1098e4 0, &loc, _STAT_FOLLOW_LINKS ); if ( status != 0 ) 109eff: 83 c4 20 add $0x20,%esp 109f02: 85 c0 test %eax,%eax 109f04: 74 0e je 109f14 return -1; 109f06: b8 ff ff ff ff mov $0xffffffff,%eax status = (*loc.handlers->fstat_h)( &loc, buf ); rtems_filesystem_freenode( &loc ); return status; } 109f0b: 8d 65 f4 lea -0xc(%ebp),%esp 109f0e: 5b pop %ebx 109f0f: 5e pop %esi 109f10: 5f pop %edi 109f11: c9 leave 109f12: c3 ret 109f13: 90 nop /* * Zero out the stat structure so the various support * versions of stat don't have to. */ memset( buf, 0, sizeof(struct stat) ); 109f14: b9 48 00 00 00 mov $0x48,%ecx 109f19: 89 f7 mov %esi,%edi 109f1b: f3 aa rep stos %al,%es:(%edi) status = (*loc.handlers->fstat_h)( &loc, buf ); 109f1d: 83 ec 08 sub $0x8,%esp 109f20: 56 push %esi 109f21: 53 push %ebx 109f22: 8b 45 dc mov -0x24(%ebp),%eax 109f25: ff 50 18 call *0x18(%eax) rtems_filesystem_freenode( &loc ); 109f28: 89 1c 24 mov %ebx,(%esp) 109f2b: 89 45 c4 mov %eax,-0x3c(%ebp) 109f2e: e8 89 fa ff ff call 1099bc return status; 109f33: 83 c4 10 add $0x10,%esp 109f36: 8b 45 c4 mov -0x3c(%ebp),%eax } 109f39: 8d 65 f4 lea -0xc(%ebp),%esp 109f3c: 5b pop %ebx 109f3d: 5e pop %esi 109f3e: 5f pop %edi 109f3f: c9 leave 109f40: c3 ret 109f41: 8d 76 00 lea 0x0(%esi),%esi /* * Check to see if we were passed a valid pointer. */ if ( !buf ) rtems_set_errno_and_return_minus_one( EFAULT ); 109f44: e8 1f b5 00 00 call 115468 <__errno> 109f49: c7 00 0e 00 00 00 movl $0xe,(%eax) 109f4f: b8 ff ff ff ff mov $0xffffffff,%eax status = (*loc.handlers->fstat_h)( &loc, buf ); rtems_filesystem_freenode( &loc ); return status; } 109f54: 8d 65 f4 lea -0xc(%ebp),%esp 109f57: 5b pop %ebx 109f58: 5e pop %esi 109f59: 5f pop %edi 109f5a: c9 leave 109f5b: c3 ret =============================================================================== 00108388 : #include "malloc_p.h" void *malloc( size_t size ) { 108388: 55 push %ebp 108389: 89 e5 mov %esp,%ebp 10838b: 56 push %esi 10838c: 53 push %ebx 10838d: 8b 75 08 mov 0x8(%ebp),%esi void *return_this; MSBUMP(malloc_calls, 1); 108390: ff 05 44 7c 12 00 incl 0x127c44 /* * If some free's have been deferred, then do them now. */ malloc_deferred_frees_process(); 108396: e8 fd fe ff ff call 108298 /* * Validate the parameters */ if ( !size ) 10839b: 85 f6 test %esi,%esi 10839d: 74 5d je 1083fc return (void *) 0; /* * Do not attempt to allocate memory if not in correct system state. */ if ( _System_state_Is_up(_System_state_Get()) && 10839f: 83 3d 20 7f 12 00 03 cmpl $0x3,0x127f20 1083a6: 74 48 je 1083f0 RTEMS_INLINE_ROUTINE void *_Protected_heap_Allocate( Heap_Control *heap, uintptr_t size ) { return _Protected_heap_Allocate_aligned_with_boundary( heap, size, 0, 0 ); 1083a8: 6a 00 push $0x0 1083aa: 6a 00 push $0x0 1083ac: 56 push %esi 1083ad: ff 35 b0 39 12 00 pushl 0x1239b0 1083b3: e8 34 4d 00 00 call 10d0ec <_Protected_heap_Allocate_aligned_with_boundary> 1083b8: 89 c3 mov %eax,%ebx * If this fails then return a NULL pointer. */ return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size ); if ( !return_this ) { 1083ba: 83 c4 10 add $0x10,%esp 1083bd: 85 c0 test %eax,%eax 1083bf: 74 47 je 108408 } /* * If the user wants us to dirty the allocated memory, then do it. */ if ( rtems_malloc_dirty_helper ) 1083c1: a1 f0 5f 12 00 mov 0x125ff0,%eax 1083c6: 85 c0 test %eax,%eax 1083c8: 74 0a je 1083d4 (*rtems_malloc_dirty_helper)( return_this, size ); 1083ca: 83 ec 08 sub $0x8,%esp 1083cd: 56 push %esi 1083ce: 53 push %ebx 1083cf: ff d0 call *%eax 1083d1: 83 c4 10 add $0x10,%esp /* * If configured, update the statistics */ if ( rtems_malloc_statistics_helpers ) 1083d4: a1 e8 5f 12 00 mov 0x125fe8,%eax 1083d9: 85 c0 test %eax,%eax 1083db: 74 0a je 1083e7 (*rtems_malloc_statistics_helpers->at_malloc)(return_this); 1083dd: 83 ec 0c sub $0xc,%esp 1083e0: 53 push %ebx 1083e1: ff 50 04 call *0x4(%eax) 1083e4: 83 c4 10 add $0x10,%esp return return_this; } 1083e7: 89 d8 mov %ebx,%eax 1083e9: 8d 65 f8 lea -0x8(%ebp),%esp 1083ec: 5b pop %ebx 1083ed: 5e pop %esi 1083ee: c9 leave 1083ef: c3 ret /* * Do not attempt to allocate memory if not in correct system state. */ if ( _System_state_Is_up(_System_state_Get()) && !malloc_is_system_state_OK() ) 1083f0: e8 63 fe ff ff call 108258 return (void *) 0; /* * Do not attempt to allocate memory if not in correct system state. */ if ( _System_state_Is_up(_System_state_Get()) && 1083f5: 84 c0 test %al,%al 1083f7: 75 af jne 1083a8 <== ALWAYS TAKEN 1083f9: 8d 76 00 lea 0x0(%esi),%esi !malloc_is_system_state_OK() ) return NULL; 1083fc: 31 db xor %ebx,%ebx */ if ( rtems_malloc_statistics_helpers ) (*rtems_malloc_statistics_helpers->at_malloc)(return_this); return return_this; } 1083fe: 89 d8 mov %ebx,%eax 108400: 8d 65 f8 lea -0x8(%ebp),%esp 108403: 5b pop %ebx 108404: 5e pop %esi 108405: c9 leave 108406: c3 ret 108407: 90 nop */ return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size ); if ( !return_this ) { if (rtems_malloc_sbrk_helpers) 108408: a1 ec 5f 12 00 mov 0x125fec,%eax 10840d: 85 c0 test %eax,%eax 10840f: 74 12 je 108423 return_this = (*rtems_malloc_sbrk_helpers->extend)( size ); 108411: 83 ec 0c sub $0xc,%esp 108414: 56 push %esi 108415: ff 50 04 call *0x4(%eax) if ( !return_this ) { 108418: 83 c4 10 add $0x10,%esp 10841b: 85 c0 test %eax,%eax 10841d: 74 04 je 108423 10841f: 89 c3 mov %eax,%ebx 108421: eb 9e jmp 1083c1 errno = ENOMEM; 108423: e8 48 ae 00 00 call 113270 <__errno> 108428: c7 00 0c 00 00 00 movl $0xc,(%eax) return (void *) 0; 10842e: eb b7 jmp 1083e7 =============================================================================== 0010830c : #include "malloc_p.h" int malloc_get_statistics( rtems_malloc_statistics_t *stats ) { 10830c: 55 push %ebp 10830d: 89 e5 mov %esp,%ebp 10830f: 57 push %edi 108310: 56 push %esi 108311: 53 push %ebx 108312: 83 ec 0c sub $0xc,%esp 108315: 8b 5d 08 mov 0x8(%ebp),%ebx if ( !stats ) 108318: 85 db test %ebx,%ebx 10831a: 74 38 je 108354 return -1; _RTEMS_Lock_allocator(); 10831c: 83 ec 0c sub $0xc,%esp 10831f: ff 35 20 7e 12 00 pushl 0x127e20 108325: e8 76 3c 00 00 call 10bfa0 <_API_Mutex_Lock> *stats = rtems_malloc_statistics; 10832a: be 20 7c 12 00 mov $0x127c20,%esi 10832f: b9 0b 00 00 00 mov $0xb,%ecx 108334: 89 df mov %ebx,%edi 108336: f3 a5 rep movsl %ds:(%esi),%es:(%edi) _RTEMS_Unlock_allocator(); 108338: 58 pop %eax 108339: ff 35 20 7e 12 00 pushl 0x127e20 10833f: e8 a4 3c 00 00 call 10bfe8 <_API_Mutex_Unlock> return 0; 108344: 83 c4 10 add $0x10,%esp 108347: 31 c0 xor %eax,%eax } 108349: 8d 65 f4 lea -0xc(%ebp),%esp 10834c: 5b pop %ebx 10834d: 5e pop %esi 10834e: 5f pop %edi 10834f: c9 leave 108350: c3 ret 108351: 8d 76 00 lea 0x0(%esi),%esi int malloc_get_statistics( rtems_malloc_statistics_t *stats ) { if ( !stats ) return -1; 108354: b8 ff ff ff ff mov $0xffffffff,%eax _RTEMS_Lock_allocator(); *stats = rtems_malloc_statistics; _RTEMS_Unlock_allocator(); return 0; } 108359: 8d 65 f4 lea -0xc(%ebp),%esp 10835c: 5b pop %ebx 10835d: 5e pop %esi 10835e: 5f pop %edi 10835f: c9 leave 108360: c3 ret =============================================================================== 0010872c : } void *malloc_sbrk_extend_and_allocate( size_t size ) { 10872c: 55 push %ebp 10872d: 89 e5 mov %esp,%ebp 10872f: 56 push %esi 108730: 53 push %ebx 108731: 8b 75 08 mov 0x8(%ebp),%esi * Round to the "requested sbrk amount" so hopefully we won't have * to grow again for a while. This effectively does sbrk() calls * in "page" amounts. */ sbrk_amount = RTEMS_Malloc_Sbrk_amount; 108734: 8b 0d ac 75 12 00 mov 0x1275ac,%ecx if ( sbrk_amount == 0 ) 10873a: 85 c9 test %ecx,%ecx 10873c: 75 0a jne 108748 <== ALWAYS TAKEN the_size = ((size + sbrk_amount) / sbrk_amount * sbrk_amount); starting_address = (void *) sbrk(the_size); if ( starting_address == (void*) -1 ) return (void *) 0; 10873e: 31 c0 xor %eax,%eax MSBUMP(space_available, the_size); return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size ); return return_this; } 108740: 8d 65 f8 lea -0x8(%ebp),%esp 108743: 5b pop %ebx 108744: 5e pop %esi 108745: c9 leave 108746: c3 ret 108747: 90 nop sbrk_amount = RTEMS_Malloc_Sbrk_amount; if ( sbrk_amount == 0 ) return (void *) 0; the_size = ((size + sbrk_amount) / sbrk_amount * sbrk_amount); 108748: 8d 04 0e lea (%esi,%ecx,1),%eax 10874b: 31 d2 xor %edx,%edx 10874d: f7 f1 div %ecx 10874f: 89 c3 mov %eax,%ebx 108751: 0f af d9 imul %ecx,%ebx starting_address = (void *) sbrk(the_size); 108754: 83 ec 0c sub $0xc,%esp 108757: 53 push %ebx 108758: e8 ff 7c ff ff call 10045c if ( starting_address == (void*) -1 ) 10875d: 83 c4 10 add $0x10,%esp 108760: 83 f8 ff cmp $0xffffffff,%eax 108763: 74 d9 je 10873e return (void *) 0; if ( !_Protected_heap_Extend( 108765: 52 push %edx 108766: 53 push %ebx 108767: 50 push %eax 108768: ff 35 90 31 12 00 pushl 0x123190 10876e: e8 3d 4d 00 00 call 10d4b0 <_Protected_heap_Extend> 108773: 83 c4 10 add $0x10,%esp 108776: 84 c0 test %al,%al 108778: 74 1b je 108795 sbrk(-the_size); errno = ENOMEM; return (void *) 0; } MSBUMP(space_available, the_size); 10877a: 01 1d 80 75 12 00 add %ebx,0x127580 108780: 6a 00 push $0x0 108782: 6a 00 push $0x0 108784: 56 push %esi 108785: ff 35 90 31 12 00 pushl 0x123190 10878b: e8 e8 4c 00 00 call 10d478 <_Protected_heap_Allocate_aligned_with_boundary> return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size ); return return_this; 108790: 83 c4 10 add $0x10,%esp 108793: eb ab jmp 108740 if ( starting_address == (void*) -1 ) return (void *) 0; if ( !_Protected_heap_Extend( RTEMS_Malloc_Heap, starting_address, the_size) ) { sbrk(-the_size); 108795: 83 ec 0c sub $0xc,%esp 108798: f7 db neg %ebx 10879a: 53 push %ebx 10879b: e8 bc 7c ff ff call 10045c errno = ENOMEM; 1087a0: e8 3f b1 00 00 call 1138e4 <__errno> 1087a5: c7 00 0c 00 00 00 movl $0xc,(%eax) return (void *) 0; 1087ab: 83 c4 10 add $0x10,%esp 1087ae: 31 c0 xor %eax,%eax 1087b0: eb 8e jmp 108740 =============================================================================== 00111e24 : */ void memfile_free_blocks_in_table( block_p **block_table, int entries ) { 111e24: 55 push %ebp 111e25: 89 e5 mov %esp,%ebp 111e27: 57 push %edi 111e28: 56 push %esi 111e29: 53 push %ebx 111e2a: 83 ec 0c sub $0xc,%esp 111e2d: 8b 7d 0c mov 0xc(%ebp),%edi IMFS_assert( block_table ); /* * Now go through all the slots in the table and free the memory. */ b = *block_table; 111e30: 8b 45 08 mov 0x8(%ebp),%eax 111e33: 8b 30 mov (%eax),%esi for ( i=0 ; i<== NEVER TAKEN 111e39: 31 db xor %ebx,%ebx 111e3b: 90 nop if ( b[i] ) { 111e3c: 8b 04 9e mov (%esi,%ebx,4),%eax 111e3f: 85 c0 test %eax,%eax 111e41: 74 13 je 111e56 memfile_free_block( b[i] ); 111e43: 83 ec 0c sub $0xc,%esp 111e46: 50 push %eax 111e47: e8 bc ff ff ff call 111e08 b[i] = 0; 111e4c: c7 04 9e 00 00 00 00 movl $0x0,(%esi,%ebx,4) 111e53: 83 c4 10 add $0x10,%esp /* * Now go through all the slots in the table and free the memory. */ b = *block_table; for ( i=0 ; i 111e5b: 8b 45 08 mov 0x8(%ebp),%eax 111e5e: 8b 30 mov (%eax),%esi /* * Now that all the blocks in the block table are free, we can * free the block table itself. */ memfile_free_block( *block_table ); 111e60: 83 ec 0c sub $0xc,%esp 111e63: 56 push %esi 111e64: e8 9f ff ff ff call 111e08 *block_table = 0; 111e69: 8b 45 08 mov 0x8(%ebp),%eax 111e6c: c7 00 00 00 00 00 movl $0x0,(%eax) 111e72: 83 c4 10 add $0x10,%esp } 111e75: 8d 65 f4 lea -0xc(%ebp),%esp 111e78: 5b pop %ebx 111e79: 5e pop %esi 111e7a: 5f pop %edi 111e7b: c9 leave 111e7c: c3 ret =============================================================================== 001123a0 : */ int memfile_ftruncate( rtems_libio_t *iop, rtems_off64_t length ) { 1123a0: 55 push %ebp 1123a1: 89 e5 mov %esp,%ebp 1123a3: 53 push %ebx 1123a4: 83 ec 14 sub $0x14,%esp 1123a7: 8b 4d 08 mov 0x8(%ebp),%ecx 1123aa: 8b 45 0c mov 0xc(%ebp),%eax 1123ad: 8b 55 10 mov 0x10(%ebp),%edx IMFS_jnode_t *the_jnode; the_jnode = iop->pathinfo.node_access; 1123b0: 8b 59 18 mov 0x18(%ecx),%ebx * POSIX 1003.1b does not specify what happens if you truncate a file * and the new length is greater than the current size. We treat this * as an extend operation. */ if ( length > the_jnode->info.file.size ) 1123b3: 39 53 54 cmp %edx,0x54(%ebx) 1123b6: 7f 19 jg 1123d1 <== NEVER TAKEN 1123b8: 7d 12 jge 1123cc <== ALWAYS TAKEN return IMFS_memfile_extend( the_jnode, length ); 1123ba: 51 push %ecx 1123bb: 52 push %edx 1123bc: 50 push %eax 1123bd: 53 push %ebx 1123be: e8 45 fc ff ff call 112008 1123c3: 83 c4 10 add $0x10,%esp iop->size = the_jnode->info.file.size; IMFS_update_atime( the_jnode ); return 0; } 1123c6: 8b 5d fc mov -0x4(%ebp),%ebx 1123c9: c9 leave 1123ca: c3 ret 1123cb: 90 nop * POSIX 1003.1b does not specify what happens if you truncate a file * and the new length is greater than the current size. We treat this * as an extend operation. */ if ( length > the_jnode->info.file.size ) 1123cc: 39 43 50 cmp %eax,0x50(%ebx) 1123cf: 72 e9 jb 1123ba /* * The in-memory files do not currently reclaim memory until the file is * deleted. So we leave the previously allocated blocks in place for * future use and just set the length. */ the_jnode->info.file.size = length; 1123d1: 89 43 50 mov %eax,0x50(%ebx) 1123d4: 89 53 54 mov %edx,0x54(%ebx) iop->size = the_jnode->info.file.size; 1123d7: 89 41 04 mov %eax,0x4(%ecx) 1123da: 89 51 08 mov %edx,0x8(%ecx) IMFS_update_atime( the_jnode ); 1123dd: 83 ec 08 sub $0x8,%esp 1123e0: 6a 00 push $0x0 1123e2: 8d 45 f0 lea -0x10(%ebp),%eax 1123e5: 50 push %eax 1123e6: e8 45 5d ff ff call 108130 1123eb: 8b 45 f0 mov -0x10(%ebp),%eax 1123ee: 89 43 40 mov %eax,0x40(%ebx) return 0; 1123f1: 83 c4 10 add $0x10,%esp 1123f4: 31 c0 xor %eax,%eax } 1123f6: 8b 5d fc mov -0x4(%ebp),%ebx 1123f9: c9 leave 1123fa: c3 ret =============================================================================== 001123fc : rtems_off64_t memfile_lseek( rtems_libio_t *iop, rtems_off64_t offset, int whence ) { 1123fc: 55 push %ebp 1123fd: 89 e5 mov %esp,%ebp 1123ff: 57 push %edi 112400: 56 push %esi 112401: 53 push %ebx 112402: 83 ec 0c sub $0xc,%esp 112405: 8b 5d 08 mov 0x8(%ebp),%ebx IMFS_jnode_t *the_jnode; the_jnode = iop->pathinfo.node_access; 112408: 8b 73 18 mov 0x18(%ebx),%esi if (the_jnode->type == IMFS_LINEAR_FILE) { 11240b: 83 7e 4c 06 cmpl $0x6,0x4c(%esi) 11240f: 74 2f je 112440 if (iop->offset > the_jnode->info.linearfile.size) iop->offset = the_jnode->info.linearfile.size; } else { /* Must be a block file (IMFS_MEMORY_FILE). */ if (IMFS_memfile_extend( the_jnode, iop->offset )) 112411: 57 push %edi 112412: ff 73 10 pushl 0x10(%ebx) 112415: ff 73 0c pushl 0xc(%ebx) 112418: 56 push %esi 112419: e8 ea fb ff ff call 112008 11241e: 83 c4 10 add $0x10,%esp 112421: 85 c0 test %eax,%eax 112423: 75 45 jne 11246a rtems_set_errno_and_return_minus_one( ENOSPC ); iop->size = the_jnode->info.file.size; 112425: 8b 46 50 mov 0x50(%esi),%eax 112428: 8b 56 54 mov 0x54(%esi),%edx 11242b: 89 43 04 mov %eax,0x4(%ebx) 11242e: 89 53 08 mov %edx,0x8(%ebx) 112431: 8b 43 0c mov 0xc(%ebx),%eax 112434: 8b 53 10 mov 0x10(%ebx),%edx } return iop->offset; } 112437: 8d 65 f4 lea -0xc(%ebp),%esp 11243a: 5b pop %ebx 11243b: 5e pop %esi 11243c: 5f pop %edi 11243d: c9 leave 11243e: c3 ret 11243f: 90 nop IMFS_jnode_t *the_jnode; the_jnode = iop->pathinfo.node_access; if (the_jnode->type == IMFS_LINEAR_FILE) { if (iop->offset > the_jnode->info.linearfile.size) 112440: 8b 43 0c mov 0xc(%ebx),%eax 112443: 8b 53 10 mov 0x10(%ebx),%edx 112446: 8b 7e 50 mov 0x50(%esi),%edi 112449: 8b 4e 54 mov 0x54(%esi),%ecx 11244c: 39 ca cmp %ecx,%edx 11244e: 7c e7 jl 112437 <== NEVER TAKEN 112450: 7e 12 jle 112464 <== ALWAYS TAKEN iop->offset = the_jnode->info.linearfile.size; 112452: 89 7b 0c mov %edi,0xc(%ebx) <== NOT EXECUTED 112455: 89 4b 10 mov %ecx,0x10(%ebx) <== NOT EXECUTED 112458: 89 f8 mov %edi,%eax <== NOT EXECUTED 11245a: 89 ca mov %ecx,%edx <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSPC ); iop->size = the_jnode->info.file.size; } return iop->offset; } 11245c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11245f: 5b pop %ebx <== NOT EXECUTED 112460: 5e pop %esi <== NOT EXECUTED 112461: 5f pop %edi <== NOT EXECUTED 112462: c9 leave <== NOT EXECUTED 112463: c3 ret <== NOT EXECUTED IMFS_jnode_t *the_jnode; the_jnode = iop->pathinfo.node_access; if (the_jnode->type == IMFS_LINEAR_FILE) { if (iop->offset > the_jnode->info.linearfile.size) 112464: 39 f8 cmp %edi,%eax 112466: 76 cf jbe 112437 <== ALWAYS TAKEN 112468: eb e8 jmp 112452 <== NOT EXECUTED iop->offset = the_jnode->info.linearfile.size; } else { /* Must be a block file (IMFS_MEMORY_FILE). */ if (IMFS_memfile_extend( the_jnode, iop->offset )) rtems_set_errno_and_return_minus_one( ENOSPC ); 11246a: e8 01 0e 00 00 call 113270 <__errno> 11246f: c7 00 1c 00 00 00 movl $0x1c,(%eax) 112475: b8 ff ff ff ff mov $0xffffffff,%eax 11247a: ba ff ff ff ff mov $0xffffffff,%edx 11247f: eb b6 jmp 112437 =============================================================================== 001122f8 : rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode ) { 1122f8: 55 push %ebp 1122f9: 89 e5 mov %esp,%ebp 1122fb: 56 push %esi 1122fc: 53 push %ebx 1122fd: 8b 5d 08 mov 0x8(%ebp),%ebx IMFS_jnode_t *the_jnode; the_jnode = iop->pathinfo.node_access; 112300: 8b 73 18 mov 0x18(%ebx),%esi /* * Perform 'copy on write' for linear files */ if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND)) 112303: 8b 43 14 mov 0x14(%ebx),%eax 112306: a9 04 02 00 00 test $0x204,%eax 11230b: 74 06 je 112313 && (the_jnode->type == IMFS_LINEAR_FILE)) { 11230d: 83 7e 4c 06 cmpl $0x6,0x4c(%esi) 112311: 74 2d je 112340 <== NEVER TAKEN the_jnode->info.file.size = 0; the_jnode->info.file.indirect = 0; the_jnode->info.file.doubly_indirect = 0; the_jnode->info.file.triply_indirect = 0; if ((count != 0) && (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1)) 112313: 8b 56 50 mov 0x50(%esi),%edx 112316: 8b 4e 54 mov 0x54(%esi),%ecx return -1; } if (iop->flags & LIBIO_FLAGS_APPEND) 112319: f6 c4 02 test $0x2,%ah 11231c: 75 12 jne 112330 iop->offset = the_jnode->info.file.size; iop->size = the_jnode->info.file.size; 11231e: 89 53 04 mov %edx,0x4(%ebx) 112321: 89 4b 08 mov %ecx,0x8(%ebx) return 0; 112324: 31 c0 xor %eax,%eax } 112326: 8d 65 f8 lea -0x8(%ebp),%esp 112329: 5b pop %ebx 11232a: 5e pop %esi 11232b: c9 leave 11232c: c3 ret 11232d: 8d 76 00 lea 0x0(%esi),%esi if ((count != 0) && (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1)) return -1; } if (iop->flags & LIBIO_FLAGS_APPEND) iop->offset = the_jnode->info.file.size; 112330: 89 53 0c mov %edx,0xc(%ebx) 112333: 89 4b 10 mov %ecx,0x10(%ebx) 112336: 8b 56 50 mov 0x50(%esi),%edx 112339: 8b 4e 54 mov 0x54(%esi),%ecx 11233c: eb e0 jmp 11231e 11233e: 66 90 xchg %ax,%ax /* * Perform 'copy on write' for linear files */ if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND)) && (the_jnode->type == IMFS_LINEAR_FILE)) { uint32_t count = the_jnode->info.linearfile.size; 112340: 8b 46 50 mov 0x50(%esi),%eax <== NOT EXECUTED const unsigned char *buffer = the_jnode->info.linearfile.direct; 112343: 8b 56 58 mov 0x58(%esi),%edx <== NOT EXECUTED the_jnode->type = IMFS_MEMORY_FILE; 112346: c7 46 4c 05 00 00 00 movl $0x5,0x4c(%esi) <== NOT EXECUTED the_jnode->info.file.size = 0; 11234d: c7 46 50 00 00 00 00 movl $0x0,0x50(%esi) <== NOT EXECUTED 112354: c7 46 54 00 00 00 00 movl $0x0,0x54(%esi) <== NOT EXECUTED the_jnode->info.file.indirect = 0; 11235b: c7 46 58 00 00 00 00 movl $0x0,0x58(%esi) <== NOT EXECUTED the_jnode->info.file.doubly_indirect = 0; 112362: c7 46 5c 00 00 00 00 movl $0x0,0x5c(%esi) <== NOT EXECUTED the_jnode->info.file.triply_indirect = 0; 112369: c7 46 60 00 00 00 00 movl $0x0,0x60(%esi) <== NOT EXECUTED if ((count != 0) 112370: 85 c0 test %eax,%eax <== NOT EXECUTED 112372: 75 09 jne 11237d <== NOT EXECUTED 112374: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 112377: 31 d2 xor %edx,%edx <== NOT EXECUTED 112379: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 11237b: eb 9c jmp 112319 <== NOT EXECUTED && (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1)) 11237d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 112380: 50 push %eax <== NOT EXECUTED 112381: 52 push %edx <== NOT EXECUTED 112382: 6a 00 push $0x0 <== NOT EXECUTED 112384: 6a 00 push $0x0 <== NOT EXECUTED 112386: 56 push %esi <== NOT EXECUTED 112387: e8 94 fd ff ff call 112120 <== NOT EXECUTED 11238c: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 11238f: 40 inc %eax <== NOT EXECUTED 112390: 74 08 je 11239a <== NOT EXECUTED 112392: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 112395: e9 79 ff ff ff jmp 112313 <== NOT EXECUTED return -1; 11239a: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 11239d: eb 87 jmp 112326 <== NOT EXECUTED =============================================================================== 0010844c : int mknod( const char *pathname, mode_t mode, dev_t dev ) { 10844c: 55 push %ebp 10844d: 89 e5 mov %esp,%ebp 10844f: 57 push %edi 108450: 56 push %esi 108451: 53 push %ebx 108452: 83 ec 3c sub $0x3c,%esp 108455: 8b 7d 08 mov 0x8(%ebp),%edi 108458: 8b 5d 0c mov 0xc(%ebp),%ebx 10845b: 8b 55 10 mov 0x10(%ebp),%edx 10845e: 8b 4d 14 mov 0x14(%ebp),%ecx rtems_filesystem_location_info_t temp_loc; int i; const char *name_start; int result; if ( !(mode & (S_IFREG|S_IFCHR|S_IFBLK|S_IFIFO) ) ) 108461: f6 c7 f0 test $0xf0,%bh 108464: 75 1a jne 108480 rtems_set_errno_and_return_minus_one( EINVAL ); 108466: e8 05 ae 00 00 call 113270 <__errno> 10846b: c7 00 16 00 00 00 movl $0x16,(%eax) 108471: b8 ff ff ff ff mov $0xffffffff,%eax result = (*temp_loc.ops->mknod_h)( name_start, mode, dev, &temp_loc ); rtems_filesystem_freenode( &temp_loc ); return result; } 108476: 8d 65 f4 lea -0xc(%ebp),%esp 108479: 5b pop %ebx 10847a: 5e pop %esi 10847b: 5f pop %edi 10847c: c9 leave 10847d: c3 ret 10847e: 66 90 xchg %ax,%ax int result; if ( !(mode & (S_IFREG|S_IFCHR|S_IFBLK|S_IFIFO) ) ) rtems_set_errno_and_return_minus_one( EINVAL ); rtems_filesystem_get_start_loc( pathname, &i, &temp_loc ); 108480: 50 push %eax 108481: 8d 75 cc lea -0x34(%ebp),%esi 108484: 56 push %esi 108485: 8d 45 e4 lea -0x1c(%ebp),%eax 108488: 50 push %eax 108489: 57 push %edi 10848a: 89 55 c4 mov %edx,-0x3c(%ebp) 10848d: 89 4d c0 mov %ecx,-0x40(%ebp) 108490: e8 1f 0a 00 00 call 108eb4 result = (*temp_loc.ops->evalformake_h)( 108495: 83 c4 0c add $0xc,%esp 108498: 8d 45 e0 lea -0x20(%ebp),%eax 10849b: 50 push %eax 10849c: 56 push %esi 10849d: 03 7d e4 add -0x1c(%ebp),%edi 1084a0: 57 push %edi 1084a1: 8b 45 d8 mov -0x28(%ebp),%eax 1084a4: ff 50 04 call *0x4(%eax) &pathname[i], &temp_loc, &name_start ); if ( result != 0 ) 1084a7: 83 c4 10 add $0x10,%esp 1084aa: 85 c0 test %eax,%eax 1084ac: 8b 55 c4 mov -0x3c(%ebp),%edx 1084af: 8b 4d c0 mov -0x40(%ebp),%ecx 1084b2: 74 10 je 1084c4 return -1; 1084b4: b8 ff ff ff ff mov $0xffffffff,%eax result = (*temp_loc.ops->mknod_h)( name_start, mode, dev, &temp_loc ); rtems_filesystem_freenode( &temp_loc ); return result; } 1084b9: 8d 65 f4 lea -0xc(%ebp),%esp 1084bc: 5b pop %ebx 1084bd: 5e pop %esi 1084be: 5f pop %edi 1084bf: c9 leave 1084c0: c3 ret 1084c1: 8d 76 00 lea 0x0(%esi),%esi &name_start ); if ( result != 0 ) return -1; result = (*temp_loc.ops->mknod_h)( name_start, mode, dev, &temp_loc ); 1084c4: 83 ec 0c sub $0xc,%esp 1084c7: 56 push %esi 1084c8: 51 push %ecx 1084c9: 52 push %edx 1084ca: 53 push %ebx 1084cb: ff 75 e0 pushl -0x20(%ebp) 1084ce: 8b 45 d8 mov -0x28(%ebp),%eax 1084d1: ff 50 14 call *0x14(%eax) rtems_filesystem_freenode( &temp_loc ); 1084d4: 83 c4 14 add $0x14,%esp 1084d7: 56 push %esi 1084d8: 89 45 c4 mov %eax,-0x3c(%ebp) 1084db: e8 c0 fb ff ff call 1080a0 return result; 1084e0: 83 c4 10 add $0x10,%esp 1084e3: 8b 45 c4 mov -0x3c(%ebp),%eax } 1084e6: 8d 65 f4 lea -0xc(%ebp),%esp 1084e9: 5b pop %ebx 1084ea: 5e pop %esi 1084eb: 5f pop %edi 1084ec: c9 leave 1084ed: c3 ret =============================================================================== 00108574 : const char *target, const char *filesystemtype, rtems_filesystem_options_t options, const void *data ) { 108574: 55 push %ebp 108575: 89 e5 mov %esp,%ebp 108577: 57 push %edi 108578: 56 push %esi 108579: 53 push %ebx 10857a: 83 ec 4c sub $0x4c,%esp 10857d: 8b 75 10 mov 0x10(%ebp),%esi /* * Are the file system options valid? */ if ( options != RTEMS_FILESYSTEM_READ_ONLY && 108580: 83 7d 14 01 cmpl $0x1,0x14(%ebp) 108584: 0f 87 36 02 00 00 ja 1087c0 rtems_set_errno_and_return_minus_one( EINVAL ); /* * Get mount handler */ mount_h = rtems_filesystem_get_mount_handler( filesystemtype ); 10858a: 83 ec 0c sub $0xc,%esp 10858d: 56 push %esi 10858e: e8 19 7b 00 00 call 1100ac 108593: 89 45 b8 mov %eax,-0x48(%ebp) if ( !mount_h ) 108596: 83 c4 10 add $0x10,%esp 108599: 85 c0 test %eax,%eax 10859b: 0f 84 1f 02 00 00 je 1087c0 { rtems_filesystem_fsmount_me_t mount_h = NULL; rtems_filesystem_location_info_t loc; rtems_filesystem_mount_table_entry_t *mt_entry = NULL; rtems_filesystem_location_info_t *loc_to_free = NULL; bool has_target = target != NULL; 1085a1: 8b 45 0c mov 0xc(%ebp),%eax 1085a4: 85 c0 test %eax,%eax const char *target_or_null, const char *filesystemtype, size_t *target_length_ptr ) { const char *target = target_or_null != NULL ? target_or_null : "/"; 1085a6: 0f 95 45 b7 setne -0x49(%ebp) 1085aa: 0f 84 e8 01 00 00 je 108798 * 4) The mount point exists with the proper permissions to allow mounting * 5) The selected mount point already has a file system mounted to it * */ int mount( 1085b0: 31 c0 xor %eax,%eax 1085b2: b9 ff ff ff ff mov $0xffffffff,%ecx 1085b7: 8b 7d 0c mov 0xc(%ebp),%edi 1085ba: f2 ae repnz scas %es:(%edi),%al 1085bc: f7 d1 not %ecx 1085be: 8d 41 ff lea -0x1(%ecx),%eax 1085c1: 89 45 ac mov %eax,-0x54(%ebp) 1085c4: 89 4d bc mov %ecx,-0x44(%ebp) 1085c7: 8b 55 0c mov 0xc(%ebp),%edx 1085ca: 89 55 b0 mov %edx,-0x50(%ebp) const char *filesystemtype, size_t *target_length_ptr ) { const char *target = target_or_null != NULL ? target_or_null : "/"; size_t filesystemtype_size = strlen( filesystemtype ) + 1; 1085cd: ba ff ff ff ff mov $0xffffffff,%edx 1085d2: 31 c0 xor %eax,%eax 1085d4: 89 d1 mov %edx,%ecx 1085d6: 89 f7 mov %esi,%edi 1085d8: f2 ae repnz scas %es:(%edi),%al 1085da: f7 d1 not %ecx 1085dc: 89 4d c4 mov %ecx,-0x3c(%ebp) size_t source_size = source_or_null != NULL ? strlen( source_or_null ) + 1 : 0; 1085df: 8b 7d 08 mov 0x8(%ebp),%edi 1085e2: 85 ff test %edi,%edi 1085e4: 0f 84 ca 01 00 00 je 1087b4 1085ea: 89 d1 mov %edx,%ecx 1085ec: 8b 7d 08 mov 0x8(%ebp),%edi 1085ef: f2 ae repnz scas %es:(%edi),%al 1085f1: f7 d1 not %ecx 1085f3: 89 4d c0 mov %ecx,-0x40(%ebp) size_t target_size = strlen( target ) + 1; size_t size = sizeof( rtems_filesystem_mount_table_entry_t ) + filesystemtype_size + source_size + target_size; rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size ); 1085f6: 83 ec 08 sub $0x8,%esp size_t filesystemtype_size = strlen( filesystemtype ) + 1; size_t source_size = source_or_null != NULL ? strlen( source_or_null ) + 1 : 0; size_t target_size = strlen( target ) + 1; size_t size = sizeof( rtems_filesystem_mount_table_entry_t ) + filesystemtype_size + source_size + target_size; 1085f9: 8b 55 bc mov -0x44(%ebp),%edx 1085fc: 8b 7d c4 mov -0x3c(%ebp),%edi 1085ff: 8d 44 3a 74 lea 0x74(%edx,%edi,1),%eax const char *target = target_or_null != NULL ? target_or_null : "/"; size_t filesystemtype_size = strlen( filesystemtype ) + 1; size_t source_size = source_or_null != NULL ? strlen( source_or_null ) + 1 : 0; size_t target_size = strlen( target ) + 1; size_t size = sizeof( rtems_filesystem_mount_table_entry_t ) 108603: 03 45 c0 add -0x40(%ebp),%eax + filesystemtype_size + source_size + target_size; rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size ); 108606: 50 push %eax 108607: 6a 01 push $0x1 108609: e8 16 f9 ff ff call 107f24 10860e: 89 c3 mov %eax,%ebx if ( mt_entry != NULL ) { 108610: 83 c4 10 add $0x10,%esp 108613: 85 c0 test %eax,%eax 108615: 0f 84 65 01 00 00 je 108780 <== NEVER TAKEN char *str = (char *) mt_entry + sizeof( *mt_entry ); 10861b: 8d 40 74 lea 0x74(%eax),%eax memcpy( str, filesystemtype, filesystemtype_size ); 10861e: 89 c7 mov %eax,%edi 108620: 8b 4d c4 mov -0x3c(%ebp),%ecx 108623: f3 a4 rep movsb %ds:(%esi),%es:(%edi) 108625: 89 fa mov %edi,%edx mt_entry->type = str; 108627: 89 43 6c mov %eax,0x6c(%ebx) str += filesystemtype_size; memcpy( str, source_or_null, source_size ); 10862a: 8b 75 08 mov 0x8(%ebp),%esi 10862d: 8b 4d c0 mov -0x40(%ebp),%ecx 108630: f3 a4 rep movsb %ds:(%esi),%es:(%edi) 108632: 89 f8 mov %edi,%eax mt_entry->dev = str; 108634: 89 53 70 mov %edx,0x70(%ebx) str += source_size; memcpy( str, target, target_size ); 108637: 8b 75 b0 mov -0x50(%ebp),%esi 10863a: 8b 4d bc mov -0x44(%ebp),%ecx 10863d: f3 a4 rep movsb %ds:(%esi),%es:(%edi) mt_entry->target = str; 10863f: 89 43 68 mov %eax,0x68(%ebx) &target_length ); if ( !mt_entry ) rtems_set_errno_and_return_minus_one( ENOMEM ); mt_entry->mt_fs_root.mt_entry = mt_entry; 108642: 89 5b 2c mov %ebx,0x2c(%ebx) mt_entry->options = options; 108645: 8b 45 14 mov 0x14(%ebp),%eax 108648: 89 43 30 mov %eax,0x30(%ebx) mt_entry->pathconf_limits_and_options = rtems_filesystem_default_pathconf; 10864b: 8d 7b 38 lea 0x38(%ebx),%edi 10864e: be 60 13 12 00 mov $0x121360,%esi 108653: b1 0c mov $0xc,%cl 108655: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* * The mount_point should be a directory with read/write/execute * permissions in the existing tree. */ if ( has_target ) { 108657: 80 7d b7 00 cmpb $0x0,-0x49(%ebp) 10865b: 0f 85 83 00 00 00 jne 1086e4 } } else { /* * Do we already have a base file system ? */ if ( !rtems_chain_is_empty( &mount_chain ) ) { 108661: 81 3d 64 58 12 00 68 cmpl $0x125868,0x125864 108668: 58 12 00 10866b: 0f 85 67 01 00 00 jne 1087d8 <== NEVER TAKEN ) { rtems_filesystem_fsmount_me_t mount_h = NULL; rtems_filesystem_location_info_t loc; rtems_filesystem_mount_table_entry_t *mt_entry = NULL; rtems_filesystem_location_info_t *loc_to_free = NULL; 108671: 31 f6 xor %esi,%esi * mt_point_node.node_access will be left to null to indicate that this * is the root of the entire file system. */ } if ( (*mount_h)( mt_entry, data ) ) { 108673: 83 ec 08 sub $0x8,%esp 108676: ff 75 18 pushl 0x18(%ebp) 108679: 53 push %ebx 10867a: ff 55 b8 call *-0x48(%ebp) 10867d: 83 c4 10 add $0x10,%esp 108680: 85 c0 test %eax,%eax 108682: 0f 85 74 01 00 00 jne 1087fc rtems_status_code rtems_libio_set_private_env(void); rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ; static inline void rtems_libio_lock( void ) { rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); 108688: 56 push %esi 108689: 6a 00 push $0x0 10868b: 6a 00 push $0x0 10868d: ff 35 28 7c 12 00 pushl 0x127c28 108693: e8 18 30 00 00 call 10b6b0 108698: 5a pop %edx 108699: 59 pop %ecx 10869a: 53 push %ebx 10869b: 68 64 58 12 00 push $0x125864 1086a0: e8 33 39 00 00 call 10bfd8 <_Chain_Append> } static inline void rtems_libio_unlock( void ) { rtems_semaphore_release( rtems_libio_semaphore ); 1086a5: 58 pop %eax 1086a6: ff 35 28 7c 12 00 pushl 0x127c28 1086ac: e8 fb 30 00 00 call 10b7ac */ rtems_libio_lock(); rtems_chain_append( &mount_chain, &mt_entry->Node ); rtems_libio_unlock(); if ( !has_target ) 1086b1: 83 c4 10 add $0x10,%esp 1086b4: 80 7d b7 00 cmpb $0x0,-0x49(%ebp) 1086b8: 74 0a je 1086c4 rtems_filesystem_root = mt_entry->mt_fs_root; return 0; 1086ba: 31 c0 xor %eax,%eax if ( loc_to_free ) rtems_filesystem_freenode( loc_to_free ); return -1; } 1086bc: 8d 65 f4 lea -0xc(%ebp),%esp 1086bf: 5b pop %ebx 1086c0: 5e pop %esi 1086c1: 5f pop %edi 1086c2: c9 leave 1086c3: c3 ret rtems_libio_lock(); rtems_chain_append( &mount_chain, &mt_entry->Node ); rtems_libio_unlock(); if ( !has_target ) rtems_filesystem_root = mt_entry->mt_fs_root; 1086c4: 8b 3d 90 59 12 00 mov 0x125990,%edi 1086ca: 83 c7 18 add $0x18,%edi 1086cd: 8d 73 1c lea 0x1c(%ebx),%esi 1086d0: b9 05 00 00 00 mov $0x5,%ecx 1086d5: f3 a5 rep movsl %ds:(%esi),%es:(%edi) return 0; 1086d7: 31 c0 xor %eax,%eax if ( loc_to_free ) rtems_filesystem_freenode( loc_to_free ); return -1; } 1086d9: 8d 65 f4 lea -0xc(%ebp),%esp 1086dc: 5b pop %ebx 1086dd: 5e pop %esi 1086de: 5f pop %edi 1086df: c9 leave 1086e0: c3 ret 1086e1: 8d 76 00 lea 0x0(%esi),%esi * The mount_point should be a directory with read/write/execute * permissions in the existing tree. */ if ( has_target ) { if ( rtems_filesystem_evaluate_path( 1086e4: 83 ec 0c sub $0xc,%esp 1086e7: 6a 01 push $0x1 1086e9: 8d 75 d4 lea -0x2c(%ebp),%esi 1086ec: 56 push %esi 1086ed: 6a 07 push $0x7 1086ef: ff 75 ac pushl -0x54(%ebp) 1086f2: ff 75 0c pushl 0xc(%ebp) 1086f5: e8 ce f8 ff ff call 107fc8 1086fa: 83 c4 20 add $0x20,%esp 1086fd: 40 inc %eax 1086fe: 0f 84 df 00 00 00 je 1087e3 <== NEVER TAKEN /* * Test to see if it is a directory */ if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) { 108704: 83 ec 0c sub $0xc,%esp 108707: 56 push %esi 108708: 8b 45 e0 mov -0x20(%ebp),%eax 10870b: ff 50 10 call *0x10(%eax) 10870e: 83 c4 10 add $0x10,%esp 108711: 48 dec %eax 108712: 0f 85 0c 01 00 00 jne 108824 /* * You can only mount one file system onto a single mount point. */ if ( rtems_filesystem_mount_iterate( is_node_fs_root, loc.node_access ) ) { 108718: 83 ec 08 sub $0x8,%esp 10871b: ff 75 d4 pushl -0x2c(%ebp) 10871e: 68 f0 84 10 00 push $0x1084f0 108723: e8 dc fd ff ff call 108504 108728: 83 c4 10 add $0x10,%esp 10872b: 84 c0 test %al,%al 10872d: 0f 85 01 01 00 00 jne 108834 * may have been allocated in loc should not be sent to freenode * until the system is unmounted. It may be needed to correctly * traverse the tree. */ mt_entry->mt_point_node.node_access = loc.node_access; 108733: 8b 45 d4 mov -0x2c(%ebp),%eax 108736: 89 43 08 mov %eax,0x8(%ebx) mt_entry->mt_point_node.handlers = loc.handlers; 108739: 8b 45 dc mov -0x24(%ebp),%eax 10873c: 89 43 10 mov %eax,0x10(%ebx) mt_entry->mt_point_node.ops = loc.ops; 10873f: 8b 45 e0 mov -0x20(%ebp),%eax 108742: 89 43 14 mov %eax,0x14(%ebx) mt_entry->mt_point_node.mt_entry = loc.mt_entry; 108745: 8b 55 e4 mov -0x1c(%ebp),%edx 108748: 89 53 18 mov %edx,0x18(%ebx) /* * This link to the parent is only done when we are dealing with system * below the base file system */ if ( loc.ops->mount_h( mt_entry ) ) { 10874b: 83 ec 0c sub $0xc,%esp 10874e: 53 push %ebx 10874f: ff 50 20 call *0x20(%eax) 108752: 83 c4 10 add $0x10,%esp 108755: 85 c0 test %eax,%eax 108757: 0f 84 16 ff ff ff je 108673 <== ALWAYS TAKEN return 0; cleanup_and_bail: free( mt_entry ); 10875d: 83 ec 0c sub $0xc,%esp 108760: 53 push %ebx 108761: e8 4e f9 ff ff call 1080b4 108766: 83 c4 10 add $0x10,%esp if ( loc_to_free ) rtems_filesystem_freenode( loc_to_free ); 108769: 83 ec 0c sub $0xc,%esp 10876c: 56 push %esi 10876d: e8 2e f9 ff ff call 1080a0 108772: 83 c4 10 add $0x10,%esp return -1; 108775: b8 ff ff ff ff mov $0xffffffff,%eax 10877a: e9 3d ff ff ff jmp 1086bc 10877f: 90 nop target, filesystemtype, &target_length ); if ( !mt_entry ) rtems_set_errno_and_return_minus_one( ENOMEM ); 108780: e8 eb aa 00 00 call 113270 <__errno> <== NOT EXECUTED 108785: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 10878b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED if ( loc_to_free ) rtems_filesystem_freenode( loc_to_free ); return -1; } 108790: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 108793: 5b pop %ebx <== NOT EXECUTED 108794: 5e pop %esi <== NOT EXECUTED 108795: 5f pop %edi <== NOT EXECUTED 108796: c9 leave <== NOT EXECUTED 108797: c3 ret <== NOT EXECUTED const char *target_or_null, const char *filesystemtype, size_t *target_length_ptr ) { const char *target = target_or_null != NULL ? target_or_null : "/"; 108798: c7 45 bc 02 00 00 00 movl $0x2,-0x44(%ebp) 10879f: c7 45 ac 01 00 00 00 movl $0x1,-0x54(%ebp) 1087a6: c7 45 b0 07 13 12 00 movl $0x121307,-0x50(%ebp) 1087ad: e9 1b fe ff ff jmp 1085cd 1087b2: 66 90 xchg %ax,%ax size_t filesystemtype_size = strlen( filesystemtype ) + 1; size_t source_size = source_or_null != NULL ? strlen( source_or_null ) + 1 : 0; 1087b4: c7 45 c0 00 00 00 00 movl $0x0,-0x40(%ebp) 1087bb: e9 36 fe ff ff jmp 1085f6 /* * Get mount handler */ mount_h = rtems_filesystem_get_mount_handler( filesystemtype ); if ( !mount_h ) rtems_set_errno_and_return_minus_one( EINVAL ); 1087c0: e8 ab aa 00 00 call 113270 <__errno> 1087c5: c7 00 16 00 00 00 movl $0x16,(%eax) 1087cb: b8 ff ff ff ff mov $0xffffffff,%eax if ( loc_to_free ) rtems_filesystem_freenode( loc_to_free ); return -1; } 1087d0: 8d 65 f4 lea -0xc(%ebp),%esp 1087d3: 5b pop %ebx 1087d4: 5e pop %esi 1087d5: 5f pop %edi 1087d6: c9 leave 1087d7: c3 ret } else { /* * Do we already have a base file system ? */ if ( !rtems_chain_is_empty( &mount_chain ) ) { errno = EINVAL; 1087d8: e8 93 aa 00 00 call 113270 <__errno> <== NOT EXECUTED 1087dd: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED return 0; cleanup_and_bail: free( mt_entry ); 1087e3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1087e6: 53 push %ebx <== NOT EXECUTED 1087e7: e8 c8 f8 ff ff call 1080b4 <== NOT EXECUTED 1087ec: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if ( loc_to_free ) rtems_filesystem_freenode( loc_to_free ); return -1; 1087ef: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 1087f4: e9 c3 fe ff ff jmp 1086bc <== NOT EXECUTED 1087f9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if ( (*mount_h)( mt_entry, data ) ) { /* * Try to undo the mount operation */ loc.ops->unmount_h( mt_entry ); 1087fc: 83 ec 0c sub $0xc,%esp 1087ff: 53 push %ebx 108800: 8b 45 e0 mov -0x20(%ebp),%eax 108803: ff 50 28 call *0x28(%eax) return 0; cleanup_and_bail: free( mt_entry ); 108806: 89 1c 24 mov %ebx,(%esp) 108809: e8 a6 f8 ff ff call 1080b4 if ( loc_to_free ) 10880e: 83 c4 10 add $0x10,%esp 108811: 85 f6 test %esi,%esi 108813: 0f 85 50 ff ff ff jne 108769 <== ALWAYS TAKEN rtems_filesystem_freenode( loc_to_free ); return -1; 108819: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10881e: e9 99 fe ff ff jmp 1086bc <== NOT EXECUTED 108823: 90 nop <== NOT EXECUTED /* * Test to see if it is a directory */ if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) { errno = ENOTDIR; 108824: e8 47 aa 00 00 call 113270 <__errno> 108829: c7 00 14 00 00 00 movl $0x14,(%eax) goto cleanup_and_bail; 10882f: e9 29 ff ff ff jmp 10875d /* * You can only mount one file system onto a single mount point. */ if ( rtems_filesystem_mount_iterate( is_node_fs_root, loc.node_access ) ) { errno = EBUSY; 108834: e8 37 aa 00 00 call 113270 <__errno> 108839: c7 00 10 00 00 00 movl $0x10,(%eax) goto cleanup_and_bail; 10883f: e9 19 ff ff ff jmp 10875d =============================================================================== 00108b88 : const char *target, const char *filesystemtype, rtems_filesystem_options_t options, const void *data ) { 108b88: 55 push %ebp 108b89: 89 e5 mov %esp,%ebp 108b8b: 57 push %edi 108b8c: 56 push %esi 108b8d: 53 push %ebx 108b8e: 83 ec 1c sub $0x1c,%esp 108b91: 8b 45 08 mov 0x8(%ebp),%eax 108b94: 89 45 e4 mov %eax,-0x1c(%ebp) 108b97: 8b 5d 0c mov 0xc(%ebp),%ebx 108b9a: 8b 75 10 mov 0x10(%ebp),%esi 108b9d: 8b 7d 14 mov 0x14(%ebp),%edi 108ba0: 8b 45 18 mov 0x18(%ebp),%eax 108ba3: 89 45 e0 mov %eax,-0x20(%ebp) int rv = -1; if (target != NULL) { 108ba6: 85 db test %ebx,%ebx 108ba8: 74 3f je 108be9 rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO); 108baa: 83 ec 08 sub $0x8,%esp 108bad: 68 ff 01 00 00 push $0x1ff 108bb2: 53 push %ebx 108bb3: e8 08 0a 00 00 call 1095c0 if (rv == 0) { 108bb8: 83 c4 10 add $0x10,%esp 108bbb: 85 c0 test %eax,%eax 108bbd: 74 09 je 108bc8 <== ALWAYS TAKEN } else { errno = EINVAL; } return rv; } 108bbf: 8d 65 f4 lea -0xc(%ebp),%esp 108bc2: 5b pop %ebx 108bc3: 5e pop %esi 108bc4: 5f pop %edi 108bc5: c9 leave 108bc6: c3 ret 108bc7: 90 nop int rv = -1; if (target != NULL) { rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO); if (rv == 0) { rv = mount( 108bc8: 8b 45 e0 mov -0x20(%ebp),%eax 108bcb: 89 45 18 mov %eax,0x18(%ebp) 108bce: 89 7d 14 mov %edi,0x14(%ebp) 108bd1: 89 75 10 mov %esi,0x10(%ebp) 108bd4: 89 5d 0c mov %ebx,0xc(%ebp) 108bd7: 8b 45 e4 mov -0x1c(%ebp),%eax 108bda: 89 45 08 mov %eax,0x8(%ebp) } else { errno = EINVAL; } return rv; } 108bdd: 8d 65 f4 lea -0xc(%ebp),%esp 108be0: 5b pop %ebx 108be1: 5e pop %esi 108be2: 5f pop %edi 108be3: c9 leave int rv = -1; if (target != NULL) { rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO); if (rv == 0) { rv = mount( 108be4: e9 97 00 00 00 jmp 108c80 options, data ); } } else { errno = EINVAL; 108be9: e8 76 ad 00 00 call 113964 <__errno> 108bee: c7 00 16 00 00 00 movl $0x16,(%eax) const char *filesystemtype, rtems_filesystem_options_t options, const void *data ) { int rv = -1; 108bf4: b8 ff ff ff ff mov $0xffffffff,%eax 108bf9: eb c4 jmp 108bbf =============================================================================== 0010fb14 : int oflag, ... /* mode_t mode, */ /* struct mq_attr attr */ ) { 10fb14: 55 push %ebp 10fb15: 89 e5 mov %esp,%ebp 10fb17: 57 push %edi 10fb18: 56 push %esi 10fb19: 53 push %ebx 10fb1a: 83 ec 2c sub $0x2c,%esp 10fb1d: 8b 75 0c mov 0xc(%ebp),%esi rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10fb20: a1 f0 0e 13 00 mov 0x130ef0,%eax 10fb25: 40 inc %eax 10fb26: a3 f0 0e 13 00 mov %eax,0x130ef0 POSIX_Message_queue_Control_fd *the_mq_fd; Objects_Locations location; _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { 10fb2b: 89 f0 mov %esi,%eax 10fb2d: 25 00 02 00 00 and $0x200,%eax 10fb32: 89 45 d4 mov %eax,-0x2c(%ebp) 10fb35: 0f 85 c9 00 00 00 jne 10fc04 /* struct mq_attr attr */ ) { va_list arg; mode_t mode; struct mq_attr *attr = NULL; 10fb3b: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp) RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd * _POSIX_Message_queue_Allocate_fd( void ) { return (POSIX_Message_queue_Control_fd *) _Objects_Allocate( &_POSIX_Message_queue_Information_fds ); 10fb42: 83 ec 0c sub $0xc,%esp 10fb45: 68 20 14 13 00 push $0x131420 10fb4a: e8 55 2c 00 00 call 1127a4 <_Objects_Allocate> 10fb4f: 89 c3 mov %eax,%ebx attr = (struct mq_attr *) va_arg( arg, struct mq_attr * ); va_end(arg); } the_mq_fd = _POSIX_Message_queue_Allocate_fd(); if ( !the_mq_fd ) { 10fb51: 83 c4 10 add $0x10,%esp 10fb54: 85 c0 test %eax,%eax 10fb56: 0f 84 b4 00 00 00 je 10fc10 _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENFILE ); } the_mq_fd->oflag = oflag; 10fb5c: 89 70 14 mov %esi,0x14(%eax) status = _POSIX_Message_queue_Name_to_id( name, &the_mq_id ); 10fb5f: 83 ec 08 sub $0x8,%esp 10fb62: 8d 45 e4 lea -0x1c(%ebp),%eax 10fb65: 50 push %eax 10fb66: ff 75 08 pushl 0x8(%ebp) 10fb69: e8 c2 69 00 00 call 116530 <_POSIX_Message_queue_Name_to_id> 10fb6e: 89 c7 mov %eax,%edi * If the name to id translation worked, then the message queue exists * and we can just return a pointer to the id. Otherwise we may * need to check to see if this is a "message queue does not exist" * or some other miscellaneous error on the name. */ if ( status ) { 10fb70: 83 c4 10 add $0x10,%esp 10fb73: 85 c0 test %eax,%eax 10fb75: 75 59 jne 10fbd0 } else { /* name -> ID translation succeeded */ /* * Check for existence with creation. */ if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { 10fb77: 81 e6 00 0a 00 00 and $0xa00,%esi 10fb7d: 81 fe 00 0a 00 00 cmp $0xa00,%esi 10fb83: 0f 84 a7 00 00 00 je 10fc30 Objects_Id id, Objects_Locations *location ) { return (POSIX_Message_queue_Control *) _Objects_Get( &_POSIX_Message_queue_Information, id, location ); 10fb89: 50 push %eax /* * In this case we need to do an ID->pointer conversion to * check the mode. */ the_mq = _POSIX_Message_queue_Get( the_mq_id, &location ); 10fb8a: 8d 45 dc lea -0x24(%ebp),%eax 10fb8d: 50 push %eax 10fb8e: ff 75 e4 pushl -0x1c(%ebp) 10fb91: 68 80 12 13 00 push $0x131280 10fb96: e8 bd 30 00 00 call 112c58 <_Objects_Get> 10fb9b: 89 45 e0 mov %eax,-0x20(%ebp) the_mq->open_count += 1; 10fb9e: ff 40 18 incl 0x18(%eax) the_mq_fd->Queue = the_mq; 10fba1: 89 43 10 mov %eax,0x10(%ebx) Objects_Information *information, Objects_Control *the_object, const char *name ) { _Objects_Set_local_object( 10fba4: 0f b7 53 08 movzwl 0x8(%ebx),%edx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10fba8: a1 3c 14 13 00 mov 0x13143c,%eax 10fbad: 89 1c 90 mov %ebx,(%eax,%edx,4) the_object ); #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) /* ASSERT: information->is_string */ the_object->name.name_p = name; 10fbb0: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) _Objects_Open_string( &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object, NULL ); _Thread_Enable_dispatch(); 10fbb7: e8 94 3c 00 00 call 113850 <_Thread_Enable_dispatch> _Thread_Enable_dispatch(); 10fbbc: e8 8f 3c 00 00 call 113850 <_Thread_Enable_dispatch> return (mqd_t)the_mq_fd->Object.id; 10fbc1: 8b 43 08 mov 0x8(%ebx),%eax 10fbc4: 83 c4 10 add $0x10,%esp ); _Thread_Enable_dispatch(); return (mqd_t) the_mq_fd->Object.id; } 10fbc7: 8d 65 f4 lea -0xc(%ebp),%esp 10fbca: 5b pop %ebx 10fbcb: 5e pop %esi 10fbcc: 5f pop %edi 10fbcd: c9 leave 10fbce: c3 ret 10fbcf: 90 nop if ( status ) { /* * Unless provided a valid name that did not already exist * and we are willing to create then it is an error. */ if ( !( status == ENOENT && (oflag & O_CREAT) ) ) { 10fbd0: 83 f8 02 cmp $0x2,%eax 10fbd3: 0f 84 87 00 00 00 je 10fc60 RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Free_fd ( POSIX_Message_queue_Control_fd *the_mq_fd ) { _Objects_Free( &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object ); 10fbd9: 83 ec 08 sub $0x8,%esp 10fbdc: 53 push %ebx 10fbdd: 68 20 14 13 00 push $0x131420 10fbe2: e8 31 2f 00 00 call 112b18 <_Objects_Free> _POSIX_Message_queue_Free_fd( the_mq_fd ); _Thread_Enable_dispatch(); 10fbe7: e8 64 3c 00 00 call 113850 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one_cast( status, mqd_t ); 10fbec: e8 23 9c 00 00 call 119814 <__errno> 10fbf1: 89 38 mov %edi,(%eax) 10fbf3: 83 c4 10 add $0x10,%esp 10fbf6: b8 ff ff ff ff mov $0xffffffff,%eax ); _Thread_Enable_dispatch(); return (mqd_t) the_mq_fd->Object.id; } 10fbfb: 8d 65 f4 lea -0xc(%ebp),%esp 10fbfe: 5b pop %ebx 10fbff: 5e pop %esi 10fc00: 5f pop %edi 10fc01: c9 leave 10fc02: c3 ret 10fc03: 90 nop _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { va_start(arg, oflag); mode = (mode_t) va_arg( arg, unsigned int ); attr = (struct mq_attr *) va_arg( arg, struct mq_attr * ); 10fc04: 8b 45 14 mov 0x14(%ebp),%eax 10fc07: 89 45 d0 mov %eax,-0x30(%ebp) 10fc0a: e9 33 ff ff ff jmp 10fb42 10fc0f: 90 nop va_end(arg); } the_mq_fd = _POSIX_Message_queue_Allocate_fd(); if ( !the_mq_fd ) { _Thread_Enable_dispatch(); 10fc10: e8 3b 3c 00 00 call 113850 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( ENFILE ); 10fc15: e8 fa 9b 00 00 call 119814 <__errno> 10fc1a: c7 00 17 00 00 00 movl $0x17,(%eax) 10fc20: b8 ff ff ff ff mov $0xffffffff,%eax ); _Thread_Enable_dispatch(); return (mqd_t) the_mq_fd->Object.id; } 10fc25: 8d 65 f4 lea -0xc(%ebp),%esp 10fc28: 5b pop %ebx 10fc29: 5e pop %esi 10fc2a: 5f pop %edi 10fc2b: c9 leave 10fc2c: c3 ret 10fc2d: 8d 76 00 lea 0x0(%esi),%esi 10fc30: 83 ec 08 sub $0x8,%esp 10fc33: 53 push %ebx 10fc34: 68 20 14 13 00 push $0x131420 10fc39: e8 da 2e 00 00 call 112b18 <_Objects_Free> /* * Check for existence with creation. */ if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { _POSIX_Message_queue_Free_fd( the_mq_fd ); _Thread_Enable_dispatch(); 10fc3e: e8 0d 3c 00 00 call 113850 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one_cast( EEXIST, mqd_t ); 10fc43: e8 cc 9b 00 00 call 119814 <__errno> 10fc48: c7 00 11 00 00 00 movl $0x11,(%eax) 10fc4e: 83 c4 10 add $0x10,%esp 10fc51: b8 ff ff ff ff mov $0xffffffff,%eax ); _Thread_Enable_dispatch(); return (mqd_t) the_mq_fd->Object.id; } 10fc56: 8d 65 f4 lea -0xc(%ebp),%esp 10fc59: 5b pop %ebx 10fc5a: 5e pop %esi 10fc5b: 5f pop %edi 10fc5c: c9 leave 10fc5d: c3 ret 10fc5e: 66 90 xchg %ax,%ax if ( status ) { /* * Unless provided a valid name that did not already exist * and we are willing to create then it is an error. */ if ( !( status == ENOENT && (oflag & O_CREAT) ) ) { 10fc60: 8b 55 d4 mov -0x2c(%ebp),%edx 10fc63: 85 d2 test %edx,%edx 10fc65: 0f 84 6e ff ff ff je 10fbd9 /* * At this point, the message queue does not exist and everything has been * checked. We should go ahead and create a message queue. */ status = _POSIX_Message_queue_Create_support( 10fc6b: 8d 45 e0 lea -0x20(%ebp),%eax 10fc6e: 50 push %eax 10fc6f: ff 75 d0 pushl -0x30(%ebp) 10fc72: 6a 01 push $0x1 10fc74: ff 75 08 pushl 0x8(%ebp) 10fc77: e8 2c 67 00 00 call 1163a8 <_POSIX_Message_queue_Create_support> ); /* * errno was set by Create_support, so don't set it again. */ if ( status == -1 ) { 10fc7c: 83 c4 10 add $0x10,%esp 10fc7f: 40 inc %eax 10fc80: 74 26 je 10fca8 _POSIX_Message_queue_Free_fd( the_mq_fd ); _Thread_Enable_dispatch(); return (mqd_t) -1; } the_mq_fd->Queue = the_mq; 10fc82: 8b 45 e0 mov -0x20(%ebp),%eax 10fc85: 89 43 10 mov %eax,0x10(%ebx) Objects_Information *information, Objects_Control *the_object, const char *name ) { _Objects_Set_local_object( 10fc88: 0f b7 53 08 movzwl 0x8(%ebx),%edx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10fc8c: a1 3c 14 13 00 mov 0x13143c,%eax 10fc91: 89 1c 90 mov %ebx,(%eax,%edx,4) the_object ); #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) /* ASSERT: information->is_string */ the_object->name.name_p = name; 10fc94: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object, NULL ); _Thread_Enable_dispatch(); 10fc9b: e8 b0 3b 00 00 call 113850 <_Thread_Enable_dispatch> return (mqd_t) the_mq_fd->Object.id; 10fca0: 8b 43 08 mov 0x8(%ebx),%eax 10fca3: e9 1f ff ff ff jmp 10fbc7 10fca8: 83 ec 08 sub $0x8,%esp 10fcab: 53 push %ebx 10fcac: 68 20 14 13 00 push $0x131420 10fcb1: e8 62 2e 00 00 call 112b18 <_Objects_Free> /* * errno was set by Create_support, so don't set it again. */ if ( status == -1 ) { _POSIX_Message_queue_Free_fd( the_mq_fd ); _Thread_Enable_dispatch(); 10fcb6: e8 95 3b 00 00 call 113850 <_Thread_Enable_dispatch> return (mqd_t) -1; 10fcbb: 83 c4 10 add $0x10,%esp 10fcbe: b8 ff ff ff ff mov $0xffffffff,%eax 10fcc3: e9 ff fe ff ff jmp 10fbc7 =============================================================================== 0011fe04 : int nanosleep( const struct timespec *rqtp, struct timespec *rmtp ) { 11fe04: 55 push %ebp 11fe05: 89 e5 mov %esp,%ebp 11fe07: 56 push %esi 11fe08: 53 push %ebx 11fe09: 8b 75 08 mov 0x8(%ebp),%esi 11fe0c: 8b 5d 0c mov 0xc(%ebp),%ebx * Return EINVAL if the delay interval is negative. * * NOTE: This behavior is beyond the POSIX specification. * FSU and GNU/Linux pthreads shares this behavior. */ if ( !_Timespec_Is_valid( rqtp ) ) 11fe0f: 83 ec 0c sub $0xc,%esp 11fe12: 56 push %esi 11fe13: e8 80 01 00 00 call 11ff98 <_Timespec_Is_valid> 11fe18: 83 c4 10 add $0x10,%esp 11fe1b: 84 c0 test %al,%al 11fe1d: 0f 84 e1 00 00 00 je 11ff04 rtems_set_errno_and_return_minus_one( EINVAL ); ticks = _Timespec_To_ticks( rqtp ); 11fe23: 83 ec 0c sub $0xc,%esp 11fe26: 56 push %esi 11fe27: e8 6c 1f ff ff call 111d98 <_Timespec_To_ticks> 11fe2c: 89 c6 mov %eax,%esi * A nanosleep for zero time is implemented as a yield. * This behavior is also beyond the POSIX specification but is * consistent with the RTEMS API and yields desirable behavior. */ if ( !ticks ) { 11fe2e: 83 c4 10 add $0x10,%esp 11fe31: 85 c0 test %eax,%eax 11fe33: 75 37 jne 11fe6c 11fe35: a1 90 8c 12 00 mov 0x128c90,%eax 11fe3a: 40 inc %eax 11fe3b: a3 90 8c 12 00 mov %eax,0x128c90 * always operates on the scheduler that 'owns' the currently executing * thread. */ RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void ) { _Scheduler.Operations.yield(); 11fe40: ff 15 0c 48 12 00 call *0x12480c _Thread_Disable_dispatch(); _Scheduler_Yield(); _Thread_Enable_dispatch(); 11fe46: e8 75 df fe ff call 10ddc0 <_Thread_Enable_dispatch> if ( rmtp ) { 11fe4b: 85 db test %ebx,%ebx 11fe4d: 0f 84 93 00 00 00 je 11fee6 rmtp->tv_sec = 0; 11fe53: c7 03 00 00 00 00 movl $0x0,(%ebx) rmtp->tv_nsec = 0; 11fe59: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) } return 0; 11fe60: 31 c0 xor %eax,%eax rtems_set_errno_and_return_minus_one( EINTR ); #endif } return 0; } 11fe62: 8d 65 f8 lea -0x8(%ebp),%esp 11fe65: 5b pop %ebx 11fe66: 5e pop %esi 11fe67: c9 leave 11fe68: c3 ret 11fe69: 8d 76 00 lea 0x0(%esi),%esi 11fe6c: a1 90 8c 12 00 mov 0x128c90,%eax 11fe71: 40 inc %eax 11fe72: a3 90 8c 12 00 mov %eax,0x128c90 /* * Block for the desired amount of time */ _Thread_Disable_dispatch(); _Thread_Set_state( 11fe77: 83 ec 08 sub $0x8,%esp 11fe7a: 68 08 00 00 10 push $0x10000008 11fe7f: ff 35 38 92 12 00 pushl 0x129238 11fe85: e8 56 e7 fe ff call 10e5e0 <_Thread_Set_state> STATES_DELAYING | STATES_INTERRUPTIBLE_BY_SIGNAL ); _Watchdog_Initialize( &_Thread_Executing->Timer, _Thread_Delay_ended, _Thread_Executing->Object.id, 11fe8a: 8b 15 38 92 12 00 mov 0x129238,%edx _Thread_Disable_dispatch(); _Thread_Set_state( _Thread_Executing, STATES_DELAYING | STATES_INTERRUPTIBLE_BY_SIGNAL ); _Watchdog_Initialize( 11fe90: 8b 42 08 mov 0x8(%edx),%eax Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 11fe93: c7 42 50 00 00 00 00 movl $0x0,0x50(%edx) the_watchdog->routine = routine; 11fe9a: c7 42 64 0c dc 10 00 movl $0x10dc0c,0x64(%edx) the_watchdog->id = id; 11fea1: 89 42 68 mov %eax,0x68(%edx) the_watchdog->user_data = user_data; 11fea4: c7 42 6c 00 00 00 00 movl $0x0,0x6c(%edx) Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 11feab: 89 72 54 mov %esi,0x54(%edx) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 11feae: 58 pop %eax 11feaf: 59 pop %ecx &_Thread_Executing->Timer, _Thread_Delay_ended, _Thread_Executing->Object.id, NULL ); _Watchdog_Insert_ticks( &_Thread_Executing->Timer, ticks ); 11feb0: 83 c2 48 add $0x48,%edx 11feb3: 52 push %edx 11feb4: 68 60 8d 12 00 push $0x128d60 11feb9: e8 ea ec fe ff call 10eba8 <_Watchdog_Insert> _Thread_Enable_dispatch(); 11febe: e8 fd de fe ff call 10ddc0 <_Thread_Enable_dispatch> /* calculate time remaining */ if ( rmtp ) { 11fec3: 83 c4 10 add $0x10,%esp 11fec6: 85 db test %ebx,%ebx 11fec8: 74 1c je 11fee6 ticks -= _Thread_Executing->Timer.stop_time - _Thread_Executing->Timer.start_time; 11feca: a1 38 92 12 00 mov 0x129238,%eax 11fecf: 03 70 5c add 0x5c(%eax),%esi _Thread_Enable_dispatch(); /* calculate time remaining */ if ( rmtp ) { ticks -= 11fed2: 2b 70 60 sub 0x60(%eax),%esi _Thread_Executing->Timer.stop_time - _Thread_Executing->Timer.start_time; _Timespec_From_ticks( ticks, rmtp ); 11fed5: 83 ec 08 sub $0x8,%esp 11fed8: 53 push %ebx 11fed9: 56 push %esi 11feda: e8 71 00 00 00 call 11ff50 <_Timespec_From_ticks> */ #if defined(RTEMS_POSIX_API) /* * If there is time remaining, then we were interrupted by a signal. */ if ( ticks ) 11fedf: 83 c4 10 add $0x10,%esp 11fee2: 85 f6 test %esi,%esi 11fee4: 75 09 jne 11feef rtems_set_errno_and_return_minus_one( EINTR ); #endif } return 0; 11fee6: 31 c0 xor %eax,%eax } 11fee8: 8d 65 f8 lea -0x8(%ebp),%esp 11feeb: 5b pop %ebx 11feec: 5e pop %esi 11feed: c9 leave 11feee: c3 ret #if defined(RTEMS_POSIX_API) /* * If there is time remaining, then we were interrupted by a signal. */ if ( ticks ) rtems_set_errno_and_return_minus_one( EINTR ); 11feef: e8 1c 38 ff ff call 113710 <__errno> 11fef4: c7 00 04 00 00 00 movl $0x4,(%eax) 11fefa: b8 ff ff ff ff mov $0xffffffff,%eax 11feff: e9 5e ff ff ff jmp 11fe62 * * NOTE: This behavior is beyond the POSIX specification. * FSU and GNU/Linux pthreads shares this behavior. */ if ( !_Timespec_Is_valid( rqtp ) ) rtems_set_errno_and_return_minus_one( EINVAL ); 11ff04: e8 07 38 ff ff call 113710 <__errno> 11ff09: c7 00 16 00 00 00 movl $0x16,(%eax) 11ff0f: b8 ff ff ff ff mov $0xffffffff,%eax 11ff14: e9 49 ff ff ff jmp 11fe62 =============================================================================== 001088a8 : */ bool newlib_create_hook( rtems_tcb *current_task __attribute__((unused)), rtems_tcb *creating_task ) { 1088a8: 55 push %ebp 1088a9: 89 e5 mov %esp,%ebp 1088ab: 57 push %edi 1088ac: 56 push %esi 1088ad: 53 push %ebx 1088ae: 83 ec 0c sub $0xc,%esp struct _reent *ptr; if (_Thread_libc_reent == 0) 1088b1: a1 24 7e 12 00 mov 0x127e24,%eax 1088b6: 85 c0 test %eax,%eax 1088b8: 0f 84 52 02 00 00 je 108b10 ptr = (struct _reent *) calloc(1, sizeof(struct _reent)); #else /* It is OK to allocate from the workspace because these * hooks run with thread dispatching disabled. */ ptr = (struct _reent *) _Workspace_Allocate(sizeof(struct _reent)); 1088be: 83 ec 0c sub $0xc,%esp 1088c1: 68 24 04 00 00 push $0x424 1088c6: e8 bd 60 00 00 call 10e988 <_Workspace_Allocate> 1088cb: 89 c2 mov %eax,%edx #endif if (ptr) { 1088cd: 83 c4 10 add $0x10,%esp 1088d0: 85 c0 test %eax,%eax 1088d2: 0f 84 2c 02 00 00 je 108b04 _REENT_INIT_PTR((ptr)); /* GCC extension: structure constants */ 1088d8: c7 00 00 00 00 00 movl $0x0,(%eax) 1088de: 8d 98 ec 02 00 00 lea 0x2ec(%eax),%ebx 1088e4: 89 58 04 mov %ebx,0x4(%eax) 1088e7: 8d 80 54 03 00 00 lea 0x354(%eax),%eax 1088ed: 89 42 08 mov %eax,0x8(%edx) 1088f0: 8d 82 bc 03 00 00 lea 0x3bc(%edx),%eax 1088f6: 89 42 0c mov %eax,0xc(%edx) 1088f9: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx) 108900: 8d 72 14 lea 0x14(%edx),%esi 108903: 31 c0 xor %eax,%eax 108905: b9 19 00 00 00 mov $0x19,%ecx 10890a: 89 f7 mov %esi,%edi 10890c: f3 aa rep stos %al,%es:(%edi) 10890e: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx) 108915: c7 42 34 8a 10 12 00 movl $0x12108a,0x34(%edx) 10891c: c7 42 38 00 00 00 00 movl $0x0,0x38(%edx) 108923: c7 42 3c 00 00 00 00 movl $0x0,0x3c(%edx) 10892a: c7 42 40 00 00 00 00 movl $0x0,0x40(%edx) 108931: c7 42 44 00 00 00 00 movl $0x0,0x44(%edx) 108938: c7 42 48 00 00 00 00 movl $0x0,0x48(%edx) 10893f: c7 42 4c 00 00 00 00 movl $0x0,0x4c(%edx) 108946: c7 42 50 00 00 00 00 movl $0x0,0x50(%edx) 10894d: c7 42 54 00 00 00 00 movl $0x0,0x54(%edx) 108954: c7 42 58 00 00 00 00 movl $0x0,0x58(%edx) 10895b: c7 42 5c 00 00 00 00 movl $0x0,0x5c(%edx) 108962: c6 42 60 00 movb $0x0,0x60(%edx) 108966: 8d 72 7c lea 0x7c(%edx),%esi 108969: b1 24 mov $0x24,%cl 10896b: 89 f7 mov %esi,%edi 10896d: f3 aa rep stos %al,%es:(%edi) 10896f: c7 82 a0 00 00 00 00 movl $0x0,0xa0(%edx) 108976: 00 00 00 108979: c7 82 a4 00 00 00 01 movl $0x1,0xa4(%edx) 108980: 00 00 00 108983: c7 82 a8 00 00 00 00 movl $0x0,0xa8(%edx) 10898a: 00 00 00 10898d: 66 c7 82 ac 00 00 00 movw $0x330e,0xac(%edx) 108994: 0e 33 108996: 66 c7 82 ae 00 00 00 movw $0xabcd,0xae(%edx) 10899d: cd ab 10899f: 66 c7 82 b0 00 00 00 movw $0x1234,0xb0(%edx) 1089a6: 34 12 1089a8: 66 c7 82 b2 00 00 00 movw $0xe66d,0xb2(%edx) 1089af: 6d e6 1089b1: 66 c7 82 b4 00 00 00 movw $0xdeec,0xb4(%edx) 1089b8: ec de 1089ba: 66 c7 82 b6 00 00 00 movw $0x5,0xb6(%edx) 1089c1: 05 00 1089c3: 66 c7 82 b8 00 00 00 movw $0xb,0xb8(%edx) 1089ca: 0b 00 1089cc: c7 82 bc 00 00 00 00 movl $0x0,0xbc(%edx) 1089d3: 00 00 00 1089d6: c7 82 c0 00 00 00 00 movl $0x0,0xc0(%edx) 1089dd: 00 00 00 1089e0: c7 82 c4 00 00 00 00 movl $0x0,0xc4(%edx) 1089e7: 00 00 00 1089ea: c7 82 c8 00 00 00 00 movl $0x0,0xc8(%edx) 1089f1: 00 00 00 1089f4: c7 82 cc 00 00 00 00 movl $0x0,0xcc(%edx) 1089fb: 00 00 00 1089fe: c7 82 d0 00 00 00 00 movl $0x0,0xd0(%edx) 108a05: 00 00 00 108a08: c7 82 f8 00 00 00 00 movl $0x0,0xf8(%edx) 108a0f: 00 00 00 108a12: c7 82 fc 00 00 00 00 movl $0x0,0xfc(%edx) 108a19: 00 00 00 108a1c: c7 82 00 01 00 00 00 movl $0x0,0x100(%edx) 108a23: 00 00 00 108a26: c7 82 04 01 00 00 00 movl $0x0,0x104(%edx) 108a2d: 00 00 00 108a30: c7 82 08 01 00 00 00 movl $0x0,0x108(%edx) 108a37: 00 00 00 108a3a: c7 82 0c 01 00 00 00 movl $0x0,0x10c(%edx) 108a41: 00 00 00 108a44: c7 82 10 01 00 00 00 movl $0x0,0x110(%edx) 108a4b: 00 00 00 108a4e: c7 82 14 01 00 00 00 movl $0x0,0x114(%edx) 108a55: 00 00 00 108a58: c7 82 18 01 00 00 00 movl $0x0,0x118(%edx) 108a5f: 00 00 00 108a62: c7 82 1c 01 00 00 00 movl $0x0,0x11c(%edx) 108a69: 00 00 00 108a6c: c6 82 d4 00 00 00 00 movb $0x0,0xd4(%edx) 108a73: c6 82 dc 00 00 00 00 movb $0x0,0xdc(%edx) 108a7a: c7 82 f4 00 00 00 00 movl $0x0,0xf4(%edx) 108a81: 00 00 00 108a84: c7 82 48 01 00 00 00 movl $0x0,0x148(%edx) 108a8b: 00 00 00 108a8e: c7 82 4c 01 00 00 00 movl $0x0,0x14c(%edx) 108a95: 00 00 00 108a98: c7 82 50 01 00 00 00 movl $0x0,0x150(%edx) 108a9f: 00 00 00 108aa2: c7 82 54 01 00 00 00 movl $0x0,0x154(%edx) 108aa9: 00 00 00 108aac: c7 82 d4 02 00 00 00 movl $0x0,0x2d4(%edx) 108ab3: 00 00 00 108ab6: c7 82 d4 01 00 00 00 movl $0x0,0x1d4(%edx) 108abd: 00 00 00 108ac0: c7 82 dc 02 00 00 00 movl $0x0,0x2dc(%edx) 108ac7: 00 00 00 108aca: c7 82 e0 02 00 00 00 movl $0x0,0x2e0(%edx) 108ad1: 00 00 00 108ad4: c7 82 e4 02 00 00 00 movl $0x0,0x2e4(%edx) 108adb: 00 00 00 108ade: c7 82 e8 02 00 00 00 movl $0x0,0x2e8(%edx) 108ae5: 00 00 00 108ae8: 66 b9 38 01 mov $0x138,%cx 108aec: 89 df mov %ebx,%edi 108aee: f3 aa rep stos %al,%es:(%edi) creating_task->libc_reent = ptr; 108af0: 8b 45 0c mov 0xc(%ebp),%eax 108af3: 89 90 e4 00 00 00 mov %edx,0xe4(%eax) return TRUE; 108af9: b0 01 mov $0x1,%al } return FALSE; } 108afb: 8d 65 f4 lea -0xc(%ebp),%esp 108afe: 5b pop %ebx 108aff: 5e pop %esi 108b00: 5f pop %edi 108b01: c9 leave 108b02: c3 ret 108b03: 90 nop _REENT_INIT_PTR((ptr)); /* GCC extension: structure constants */ creating_task->libc_reent = ptr; return TRUE; } return FALSE; 108b04: 31 c0 xor %eax,%eax } 108b06: 8d 65 f4 lea -0xc(%ebp),%esp 108b09: 5b pop %ebx 108b0a: 5e pop %esi 108b0b: 5f pop %edi 108b0c: c9 leave 108b0d: c3 ret 108b0e: 66 90 xchg %ax,%ax { struct _reent *ptr; if (_Thread_libc_reent == 0) { _REENT = _global_impure_ptr; 108b10: a1 e0 1e 12 00 mov 0x121ee0,%eax 108b15: a3 a0 5a 12 00 mov %eax,0x125aa0 RTEMS_INLINE_ROUTINE void _Thread_Set_libc_reent ( struct _reent **libc_reent ) { _Thread_libc_reent = libc_reent; 108b1a: c7 05 24 7e 12 00 a0 movl $0x125aa0,0x127e24 108b21: 5a 12 00 108b24: e9 95 fd ff ff jmp 1088be =============================================================================== 00108b2c : void newlib_delete_hook( rtems_tcb *current_task, rtems_tcb *deleted_task ) { 108b2c: 55 push %ebp 108b2d: 89 e5 mov %esp,%ebp 108b2f: 57 push %edi 108b30: 56 push %esi 108b31: 53 push %ebx 108b32: 83 ec 0c sub $0xc,%esp 108b35: 8b 7d 08 mov 0x8(%ebp),%edi 108b38: 8b 5d 0c mov 0xc(%ebp),%ebx /* * The reentrancy structure was allocated by newlib using malloc() */ if (current_task == deleted_task) { 108b3b: 39 df cmp %ebx,%edi 108b3d: 74 55 je 108b94 ptr = _REENT; } else { ptr = deleted_task->libc_reent; 108b3f: 8b b3 e4 00 00 00 mov 0xe4(%ebx),%esi } if (ptr && ptr != _global_impure_ptr) { 108b45: 85 f6 test %esi,%esi 108b47: 74 21 je 108b6a <== NEVER TAKEN 108b49: 3b 35 e0 1e 12 00 cmp 0x121ee0,%esi 108b4f: 74 19 je 108b6a _reclaim_reent(ptr); */ /* * Just in case there are some buffers lying around. */ _fwalk(ptr, newlib_free_buffers); 108b51: 83 ec 08 sub $0x8,%esp 108b54: 68 4c 88 10 00 push $0x10884c 108b59: 56 push %esi 108b5a: e8 f9 ae 00 00 call 113a58 <_fwalk> #if REENT_MALLOCED free(ptr); #else _Workspace_Free(ptr); 108b5f: 89 34 24 mov %esi,(%esp) 108b62: e8 3d 5e 00 00 call 10e9a4 <_Workspace_Free> 108b67: 83 c4 10 add $0x10,%esp #endif } deleted_task->libc_reent = NULL; 108b6a: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx) 108b71: 00 00 00 /* * Require the switch back to another task to install its own */ if ( current_task == deleted_task ) { 108b74: 39 df cmp %ebx,%edi 108b76: 74 08 je 108b80 _REENT = 0; } } 108b78: 8d 65 f4 lea -0xc(%ebp),%esp 108b7b: 5b pop %ebx 108b7c: 5e pop %esi 108b7d: 5f pop %edi 108b7e: c9 leave 108b7f: c3 ret /* * Require the switch back to another task to install its own */ if ( current_task == deleted_task ) { _REENT = 0; 108b80: c7 05 a0 5a 12 00 00 movl $0x0,0x125aa0 108b87: 00 00 00 } } 108b8a: 8d 65 f4 lea -0xc(%ebp),%esp 108b8d: 5b pop %ebx 108b8e: 5e pop %esi 108b8f: 5f pop %edi 108b90: c9 leave 108b91: c3 ret 108b92: 66 90 xchg %ax,%ax /* * The reentrancy structure was allocated by newlib using malloc() */ if (current_task == deleted_task) { ptr = _REENT; 108b94: 8b 35 a0 5a 12 00 mov 0x125aa0,%esi 108b9a: eb a9 jmp 108b45 =============================================================================== 0010884c : */ int newlib_free_buffers( FILE *fp ) { 10884c: 55 push %ebp 10884d: 89 e5 mov %esp,%ebp 10884f: 53 push %ebx 108850: 83 ec 10 sub $0x10,%esp 108853: 8b 5d 08 mov 0x8(%ebp),%ebx switch ( fileno(fp) ) { 108856: 53 push %ebx 108857: e8 e8 ad 00 00 call 113644 10885c: 83 c4 10 add $0x10,%esp 10885f: 83 f8 02 cmp $0x2,%eax 108862: 76 14 jbe 108878 <== ALWAYS TAKEN fp->_flags &= ~__SMBF; fp->_bf._base = fp->_p = (unsigned char *) NULL; } break; default: fclose(fp); 108864: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108867: 53 push %ebx <== NOT EXECUTED 108868: e8 5b ab 00 00 call 1133c8 <== NOT EXECUTED 10886d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return 0; } 108870: 31 c0 xor %eax,%eax 108872: 8b 5d fc mov -0x4(%ebp),%ebx 108875: c9 leave 108876: c3 ret 108877: 90 nop { switch ( fileno(fp) ) { case 0: case 1: case 2: if (fp->_flags & __SMBF) { 108878: f6 43 0c 80 testb $0x80,0xc(%ebx) 10887c: 74 f2 je 108870 <== ALWAYS TAKEN free( fp->_bf._base ); 10887e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108881: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 108884: e8 2b f8 ff ff call 1080b4 <== NOT EXECUTED fp->_flags &= ~__SMBF; 108889: 66 81 63 0c 7f ff andw $0xff7f,0xc(%ebx) <== NOT EXECUTED fp->_bf._base = fp->_p = (unsigned char *) NULL; 10888f: c7 03 00 00 00 00 movl $0x0,(%ebx) <== NOT EXECUTED 108895: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) <== NOT EXECUTED 10889c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED break; default: fclose(fp); } return 0; } 10889f: 31 c0 xor %eax,%eax <== NOT EXECUTED 1088a1: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1088a4: c9 leave <== NOT EXECUTED 1088a5: c3 ret <== NOT EXECUTED =============================================================================== 00107cd4 : rtems_device_driver null_initialize( rtems_device_major_number major, rtems_device_minor_number minor __attribute__((unused)), void *pargp __attribute__((unused)) ) { 107cd4: 55 push %ebp 107cd5: 89 e5 mov %esp,%ebp 107cd7: 53 push %ebx 107cd8: 83 ec 04 sub $0x4,%esp 107cdb: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_device_driver status; if ( !initialized ) { 107cde: 80 3d 20 59 12 00 00 cmpb $0x0,0x125920 107ce5: 74 09 je 107cf0 NULL_major = major; } return RTEMS_SUCCESSFUL; } 107ce7: 31 c0 xor %eax,%eax 107ce9: 8b 5d fc mov -0x4(%ebp),%ebx 107cec: c9 leave 107ced: c3 ret 107cee: 66 90 xchg %ax,%ax ) { rtems_device_driver status; if ( !initialized ) { initialized = 1; 107cf0: c6 05 20 59 12 00 01 movb $0x1,0x125920 status = rtems_io_register_name( 107cf7: 50 push %eax 107cf8: 6a 00 push $0x0 107cfa: 53 push %ebx 107cfb: 68 9a d9 11 00 push $0x11d99a 107d00: e8 7b 01 00 00 call 107e80 "/dev/null", major, (rtems_device_minor_number) 0 ); if (status != RTEMS_SUCCESSFUL) 107d05: 83 c4 10 add $0x10,%esp 107d08: 85 c0 test %eax,%eax 107d0a: 75 0d jne 107d19 rtems_fatal_error_occurred(status); NULL_major = major; 107d0c: 89 1d 60 5c 12 00 mov %ebx,0x125c60 } return RTEMS_SUCCESSFUL; } 107d12: 31 c0 xor %eax,%eax 107d14: 8b 5d fc mov -0x4(%ebp),%ebx 107d17: c9 leave 107d18: c3 ret major, (rtems_device_minor_number) 0 ); if (status != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred(status); 107d19: 83 ec 0c sub $0xc,%esp 107d1c: 50 push %eax 107d1d: e8 ae 41 00 00 call 10bed0 =============================================================================== 00108bfc : int open( const char *pathname, int flags, ... ) { 108bfc: 55 push %ebp 108bfd: 89 e5 mov %esp,%ebp 108bff: 57 push %edi 108c00: 56 push %esi 108c01: 53 push %ebx 108c02: 83 ec 4c sub $0x4c,%esp /* * Set the Evaluation flags */ eval_flags = 0; status = flags + 1; 108c05: 8b 45 0c mov 0xc(%ebp),%eax 108c08: 40 inc %eax if ( ( status & _FREAD ) == _FREAD ) 108c09: 89 c3 mov %eax,%ebx 108c0b: 83 e3 01 and $0x1,%ebx eval_flags |= RTEMS_LIBIO_PERMS_READ; 108c0e: f7 db neg %ebx 108c10: 83 e3 04 and $0x4,%ebx if ( ( status & _FWRITE ) == _FWRITE ) 108c13: a8 02 test $0x2,%al 108c15: 74 03 je 108c1a eval_flags |= RTEMS_LIBIO_PERMS_WRITE; 108c17: 83 cb 02 or $0x2,%ebx va_start(ap, flags); mode = va_arg( ap, int ); 108c1a: 8b 45 10 mov 0x10(%ebp),%eax 108c1d: 89 45 c4 mov %eax,-0x3c(%ebp) * code does not require changes here since network file * descriptors are obtained using socket(), not open(). */ /* allocate a file control block */ iop = rtems_libio_allocate(); 108c20: e8 e3 71 00 00 call 10fe08 108c25: 89 c2 mov %eax,%edx if ( iop == 0 ) { 108c27: 85 c0 test %eax,%eax 108c29: 0f 84 c5 00 00 00 je 108cf4 } /* * See if the file exists. */ status = rtems_filesystem_evaluate_path( 108c2f: 31 f6 xor %esi,%esi 108c31: b9 ff ff ff ff mov $0xffffffff,%ecx 108c36: 8b 7d 08 mov 0x8(%ebp),%edi 108c39: 89 f0 mov %esi,%eax 108c3b: f2 ae repnz scas %es:(%edi),%al 108c3d: f7 d1 not %ecx 108c3f: 49 dec %ecx 108c40: 83 ec 0c sub $0xc,%esp 108c43: 6a 01 push $0x1 108c45: 8d 45 d4 lea -0x2c(%ebp),%eax 108c48: 89 45 b4 mov %eax,-0x4c(%ebp) 108c4b: 50 push %eax 108c4c: 53 push %ebx 108c4d: 51 push %ecx 108c4e: ff 75 08 pushl 0x8(%ebp) 108c51: 89 55 c0 mov %edx,-0x40(%ebp) 108c54: e8 6f f3 ff ff call 107fc8 108c59: 89 c3 mov %eax,%ebx pathname, strlen( pathname ), eval_flags, &loc, true ); if ( status == -1 ) { 108c5b: 83 c4 20 add $0x20,%esp 108c5e: 83 f8 ff cmp $0xffffffff,%eax 108c61: 8b 55 c0 mov -0x40(%ebp),%edx 108c64: 0f 84 de 00 00 00 je 108d48 if ( status != 0 ) { /* The file did not exist */ rc = EACCES; goto done; } } else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) { 108c6a: 8b 45 0c mov 0xc(%ebp),%eax 108c6d: 25 00 0a 00 00 and $0xa00,%eax 108c72: 3d 00 0a 00 00 cmp $0xa00,%eax 108c77: 0f 84 8b 00 00 00 je 108d08 /* * Fill in the file control block based on the loc structure * returned by successful path evaluation. */ iop->flags |= rtems_libio_fcntl_flags( flags ); 108c7d: 8b 5a 14 mov 0x14(%edx),%ebx 108c80: 83 ec 0c sub $0xc,%esp 108c83: ff 75 0c pushl 0xc(%ebp) 108c86: 89 55 c0 mov %edx,-0x40(%ebp) 108c89: e8 fe 70 00 00 call 10fd8c 108c8e: 09 d8 or %ebx,%eax 108c90: 8b 55 c0 mov -0x40(%ebp),%edx 108c93: 89 42 14 mov %eax,0x14(%edx) iop->pathinfo = loc; 108c96: 8d 7a 18 lea 0x18(%edx),%edi 108c99: b9 05 00 00 00 mov $0x5,%ecx 108c9e: 8b 75 b4 mov -0x4c(%ebp),%esi 108ca1: f3 a5 rep movsl %ds:(%esi),%es:(%edi) rc = (*iop->pathinfo.handlers->open_h)( iop, pathname, flags, mode ); 108ca3: 8b 42 20 mov 0x20(%edx),%eax 108ca6: ff 75 c4 pushl -0x3c(%ebp) 108ca9: ff 75 0c pushl 0xc(%ebp) 108cac: ff 75 08 pushl 0x8(%ebp) 108caf: 52 push %edx 108cb0: ff 10 call *(%eax) if ( rc ) { 108cb2: 83 c4 20 add $0x20,%esp 108cb5: 85 c0 test %eax,%eax 108cb7: 8b 55 c0 mov -0x40(%ebp),%edx 108cba: 75 78 jne 108d34 } /* * Optionally truncate the file. */ if ( (flags & O_TRUNC) == O_TRUNC ) { 108cbc: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp) 108cc3: 0f 85 9f 00 00 00 jne 108d68 if ( loc_to_free ) rtems_filesystem_freenode( loc_to_free ); rtems_set_errno_and_return_minus_one( rc ); } return iop - rtems_libio_iops; 108cc9: 2b 15 20 7c 12 00 sub 0x127c20,%edx 108ccf: c1 fa 03 sar $0x3,%edx 108cd2: 8d 04 d2 lea (%edx,%edx,8),%eax 108cd5: 8d 04 c2 lea (%edx,%eax,8),%eax 108cd8: 8d 04 c2 lea (%edx,%eax,8),%eax 108cdb: 8d 04 c2 lea (%edx,%eax,8),%eax 108cde: 89 c1 mov %eax,%ecx 108ce0: c1 e1 0f shl $0xf,%ecx 108ce3: 01 c8 add %ecx,%eax 108ce5: 8d 04 c2 lea (%edx,%eax,8),%eax 108ce8: f7 d8 neg %eax } 108cea: 8d 65 f4 lea -0xc(%ebp),%esp 108ced: 5b pop %ebx 108cee: 5e pop %esi 108cef: 5f pop %edi 108cf0: c9 leave 108cf1: c3 ret 108cf2: 66 90 xchg %ax,%ax */ /* allocate a file control block */ iop = rtems_libio_allocate(); if ( iop == 0 ) { rc = ENFILE; 108cf4: bb 17 00 00 00 mov $0x17,%ebx if ( rc ) { if ( iop ) rtems_libio_free( iop ); if ( loc_to_free ) rtems_filesystem_freenode( loc_to_free ); rtems_set_errno_and_return_minus_one( rc ); 108cf9: e8 72 a5 00 00 call 113270 <__errno> 108cfe: 89 18 mov %ebx,(%eax) 108d00: b8 ff ff ff ff mov $0xffffffff,%eax 108d05: eb e3 jmp 108cea 108d07: 90 nop } } else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) { /* We were trying to create a file that already exists */ rc = EEXIST; loc_to_free = &loc; 108d08: 8d 75 d4 lea -0x2c(%ebp),%esi goto done; } } else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) { /* We were trying to create a file that already exists */ rc = EEXIST; 108d0b: bb 11 00 00 00 mov $0x11,%ebx */ done: va_end(ap); if ( rc ) { if ( iop ) 108d10: 85 d2 test %edx,%edx 108d12: 74 0c je 108d20 rtems_libio_free( iop ); 108d14: 83 ec 0c sub $0xc,%esp 108d17: 52 push %edx 108d18: e8 8f 71 00 00 call 10feac 108d1d: 83 c4 10 add $0x10,%esp if ( loc_to_free ) 108d20: 85 f6 test %esi,%esi 108d22: 74 d5 je 108cf9 rtems_filesystem_freenode( loc_to_free ); 108d24: 83 ec 0c sub $0xc,%esp 108d27: 56 push %esi 108d28: e8 73 f3 ff ff call 1080a0 108d2d: 83 c4 10 add $0x10,%esp 108d30: eb c7 jmp 108cf9 108d32: 66 90 xchg %ax,%ax iop->flags |= rtems_libio_fcntl_flags( flags ); iop->pathinfo = loc; rc = (*iop->pathinfo.handlers->open_h)( iop, pathname, flags, mode ); if ( rc ) { rc = errno; 108d34: e8 37 a5 00 00 call 113270 <__errno> 108d39: 8b 18 mov (%eax),%ebx rc = EEXIST; loc_to_free = &loc; goto done; } loc_to_free = &loc; 108d3b: 8d 75 d4 lea -0x2c(%ebp),%esi iop->pathinfo = loc; rc = (*iop->pathinfo.handlers->open_h)( iop, pathname, flags, mode ); if ( rc ) { rc = errno; goto done; 108d3e: 8b 55 c0 mov -0x40(%ebp),%edx * Single exit and clean up path. */ done: va_end(ap); if ( rc ) { 108d41: 85 db test %ebx,%ebx 108d43: 74 84 je 108cc9 <== NEVER TAKEN 108d45: eb c9 jmp 108d10 108d47: 90 nop */ status = rtems_filesystem_evaluate_path( pathname, strlen( pathname ), eval_flags, &loc, true ); if ( status == -1 ) { if ( errno != ENOENT ) { 108d48: e8 23 a5 00 00 call 113270 <__errno> 108d4d: 83 38 02 cmpl $0x2,(%eax) 108d50: 8b 55 c0 mov -0x40(%ebp),%edx 108d53: 0f 84 9b 00 00 00 je 108df4 } /* Create the node for the new regular file */ rc = mknod( pathname, S_IFREG | mode, 0LL ); if ( rc ) { rc = errno; 108d59: e8 12 a5 00 00 call 113270 <__errno> 108d5e: 8b 18 mov (%eax),%ebx int mode; int rc; rtems_libio_t *iop = 0; int status; rtems_filesystem_location_info_t loc; rtems_filesystem_location_info_t *loc_to_free = NULL; 108d60: 31 f6 xor %esi,%esi /* Create the node for the new regular file */ rc = mknod( pathname, S_IFREG | mode, 0LL ); if ( rc ) { rc = errno; goto done; 108d62: 8b 55 c0 mov -0x40(%ebp),%edx 108d65: eb da jmp 108d41 108d67: 90 nop /* * Optionally truncate the file. */ if ( (flags & O_TRUNC) == O_TRUNC ) { rc = ftruncate( iop - rtems_libio_iops, 0 ); 108d68: 51 push %ecx 108d69: 6a 00 push $0x0 108d6b: 6a 00 push $0x0 108d6d: 89 d0 mov %edx,%eax 108d6f: 2b 05 20 7c 12 00 sub 0x127c20,%eax 108d75: c1 f8 03 sar $0x3,%eax 108d78: 8d 0c c0 lea (%eax,%eax,8),%ecx 108d7b: 8d 0c c8 lea (%eax,%ecx,8),%ecx 108d7e: 8d 0c c8 lea (%eax,%ecx,8),%ecx 108d81: 8d 0c c8 lea (%eax,%ecx,8),%ecx 108d84: 89 cb mov %ecx,%ebx 108d86: c1 e3 0f shl $0xf,%ebx 108d89: 01 d9 add %ebx,%ecx 108d8b: 8d 04 c8 lea (%eax,%ecx,8),%eax 108d8e: f7 d8 neg %eax 108d90: 50 push %eax 108d91: 89 55 c0 mov %edx,-0x40(%ebp) 108d94: e8 23 6f 00 00 call 10fcbc 108d99: 89 c3 mov %eax,%ebx if ( rc ) { 108d9b: 83 c4 10 add $0x10,%esp 108d9e: 85 c0 test %eax,%eax 108da0: 8b 55 c0 mov -0x40(%ebp),%edx 108da3: 0f 84 20 ff ff ff je 108cc9 if(errno) rc = errno; 108da9: e8 c2 a4 00 00 call 113270 <__errno> 108dae: 8b 00 mov (%eax),%eax 108db0: 85 c0 test %eax,%eax 108db2: 8b 55 c0 mov -0x40(%ebp),%edx 108db5: 0f 85 b2 00 00 00 jne 108e6d <== ALWAYS TAKEN close( iop - rtems_libio_iops ); 108dbb: 83 ec 0c sub $0xc,%esp 108dbe: 2b 15 20 7c 12 00 sub 0x127c20,%edx 108dc4: c1 fa 03 sar $0x3,%edx 108dc7: 8d 04 d2 lea (%edx,%edx,8),%eax 108dca: 8d 04 c2 lea (%edx,%eax,8),%eax 108dcd: 8d 04 c2 lea (%edx,%eax,8),%eax 108dd0: 8d 04 c2 lea (%edx,%eax,8),%eax 108dd3: 89 c1 mov %eax,%ecx 108dd5: c1 e1 0f shl $0xf,%ecx 108dd8: 01 c8 add %ecx,%eax 108dda: 8d 04 c2 lea (%edx,%eax,8),%eax 108ddd: f7 d8 neg %eax 108ddf: 50 push %eax 108de0: e8 57 6e 00 00 call 10fc3c 108de5: 83 c4 10 add $0x10,%esp /* those are released by close(): */ iop = 0; loc_to_free = NULL; 108de8: 31 f6 xor %esi,%esi rc = ftruncate( iop - rtems_libio_iops, 0 ); if ( rc ) { if(errno) rc = errno; close( iop - rtems_libio_iops ); /* those are released by close(): */ iop = 0; 108dea: 31 d2 xor %edx,%edx 108dec: e9 50 ff ff ff jmp 108d41 108df1: 8d 76 00 lea 0x0(%esi),%esi rc = errno; goto done; } /* If the file does not exist and we are not trying to create it--> error */ if ( !(flags & O_CREAT) ) { 108df4: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp) 108dfb: 75 0f jne 108e0c int mode; int rc; rtems_libio_t *iop = 0; int status; rtems_filesystem_location_info_t loc; rtems_filesystem_location_info_t *loc_to_free = NULL; 108dfd: 31 f6 xor %esi,%esi goto done; } /* If the file does not exist and we are not trying to create it--> error */ if ( !(flags & O_CREAT) ) { rc = ENOENT; 108dff: bb 02 00 00 00 mov $0x2,%ebx 108e04: e9 07 ff ff ff jmp 108d10 108e09: 8d 76 00 lea 0x0(%esi),%esi goto done; } /* Create the node for the new regular file */ rc = mknod( pathname, S_IFREG | mode, 0LL ); 108e0c: 6a 00 push $0x0 108e0e: 6a 00 push $0x0 108e10: 8b 45 c4 mov -0x3c(%ebp),%eax 108e13: 80 cc 80 or $0x80,%ah 108e16: 50 push %eax 108e17: ff 75 08 pushl 0x8(%ebp) 108e1a: 89 55 c0 mov %edx,-0x40(%ebp) 108e1d: e8 2a f6 ff ff call 10844c if ( rc ) { 108e22: 83 c4 10 add $0x10,%esp 108e25: 85 c0 test %eax,%eax 108e27: 8b 55 c0 mov -0x40(%ebp),%edx 108e2a: 0f 85 29 ff ff ff jne 108d59 <== NEVER TAKEN /* * After we do the mknod(), we have to evaluate the path to get the * "loc" structure needed to actually have the file itself open. * So we created it, and then we need to have "look it up." */ status = rtems_filesystem_evaluate_path( 108e30: 89 d9 mov %ebx,%ecx 108e32: 8b 7d 08 mov 0x8(%ebp),%edi 108e35: 89 f0 mov %esi,%eax 108e37: f2 ae repnz scas %es:(%edi),%al 108e39: f7 d1 not %ecx 108e3b: 49 dec %ecx 108e3c: 83 ec 0c sub $0xc,%esp 108e3f: 6a 01 push $0x1 108e41: 8d 45 d4 lea -0x2c(%ebp),%eax 108e44: 50 push %eax 108e45: 6a 00 push $0x0 108e47: 51 push %ecx 108e48: ff 75 08 pushl 0x8(%ebp) 108e4b: 89 55 c0 mov %edx,-0x40(%ebp) 108e4e: e8 75 f1 ff ff call 107fc8 pathname, strlen( pathname ), 0x0, &loc, true ); if ( status != 0 ) { /* The file did not exist */ 108e53: 83 c4 20 add $0x20,%esp 108e56: 85 c0 test %eax,%eax 108e58: 8b 55 c0 mov -0x40(%ebp),%edx 108e5b: 0f 84 1c fe ff ff je 108c7d <== ALWAYS TAKEN int mode; int rc; rtems_libio_t *iop = 0; int status; rtems_filesystem_location_info_t loc; rtems_filesystem_location_info_t *loc_to_free = NULL; 108e61: 31 f6 xor %esi,%esi * So we created it, and then we need to have "look it up." */ status = rtems_filesystem_evaluate_path( pathname, strlen( pathname ), 0x0, &loc, true ); if ( status != 0 ) { /* The file did not exist */ rc = EACCES; 108e63: bb 0d 00 00 00 mov $0xd,%ebx <== NOT EXECUTED 108e68: e9 a3 fe ff ff jmp 108d10 <== NOT EXECUTED * Optionally truncate the file. */ if ( (flags & O_TRUNC) == O_TRUNC ) { rc = ftruncate( iop - rtems_libio_iops, 0 ); if ( rc ) { if(errno) rc = errno; 108e6d: e8 fe a3 00 00 call 113270 <__errno> 108e72: 8b 18 mov (%eax),%ebx 108e74: 8b 55 c0 mov -0x40(%ebp),%edx 108e77: e9 3f ff ff ff jmp 108dbb =============================================================================== 00109c00 : /* * Handle output processing */ static void oproc (unsigned char c, struct rtems_termios_tty *tty) { 109c00: 55 push %ebp 109c01: 89 e5 mov %esp,%ebp 109c03: 56 push %esi 109c04: 53 push %ebx 109c05: 83 ec 10 sub $0x10,%esp 109c08: 88 45 f4 mov %al,-0xc(%ebp) int i; if (tty->termios.c_oflag & OPOST) { 109c0b: 8b 4a 34 mov 0x34(%edx),%ecx 109c0e: f6 c1 01 test $0x1,%cl 109c11: 74 31 je 109c44 <== NEVER TAKEN switch (c) { 109c13: 3c 09 cmp $0x9,%al 109c15: 0f 84 b1 00 00 00 je 109ccc 109c1b: 76 3f jbe 109c5c <== NEVER TAKEN 109c1d: 3c 0a cmp $0xa,%al 109c1f: 74 4f je 109c70 109c21: 3c 0d cmp $0xd,%al 109c23: 74 7f je 109ca4 <== NEVER TAKEN if (tty->column > 0) tty->column--; break; default: if (tty->termios.c_oflag & OLCUC) 109c25: 83 e1 02 and $0x2,%ecx 109c28: 0f 85 c6 00 00 00 jne 109cf4 <== NEVER TAKEN 109c2e: 8b 0d 94 5a 12 00 mov 0x125a94,%ecx c = toupper(c); if (!iscntrl(c)) 109c34: 0f b6 c0 movzbl %al,%eax 109c37: f6 44 01 01 20 testb $0x20,0x1(%ecx,%eax,1) 109c3c: 75 06 jne 109c44 <== NEVER TAKEN tty->column++; 109c3e: ff 42 28 incl 0x28(%edx) 109c41: 8d 76 00 lea 0x0(%esi),%esi break; } } rtems_termios_puts (&c, 1, tty); 109c44: 53 push %ebx 109c45: 52 push %edx 109c46: 6a 01 push $0x1 109c48: 8d 45 f4 lea -0xc(%ebp),%eax 109c4b: 50 push %eax 109c4c: e8 7b fe ff ff call 109acc 109c51: 83 c4 10 add $0x10,%esp } 109c54: 8d 65 f8 lea -0x8(%ebp),%esp 109c57: 5b pop %ebx 109c58: 5e pop %esi 109c59: c9 leave 109c5a: c3 ret 109c5b: 90 nop oproc (unsigned char c, struct rtems_termios_tty *tty) { int i; if (tty->termios.c_oflag & OPOST) { switch (c) { 109c5c: 3c 08 cmp $0x8,%al <== NOT EXECUTED 109c5e: 75 c5 jne 109c25 <== NOT EXECUTED } tty->column += i; break; case '\b': if (tty->column > 0) 109c60: 8b 42 28 mov 0x28(%edx),%eax <== NOT EXECUTED 109c63: 85 c0 test %eax,%eax <== NOT EXECUTED 109c65: 7e dd jle 109c44 <== NOT EXECUTED tty->column--; 109c67: 48 dec %eax <== NOT EXECUTED 109c68: 89 42 28 mov %eax,0x28(%edx) <== NOT EXECUTED 109c6b: eb d7 jmp 109c44 <== NOT EXECUTED 109c6d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED int i; if (tty->termios.c_oflag & OPOST) { switch (c) { case '\n': if (tty->termios.c_oflag & ONLRET) 109c70: f6 c1 20 test $0x20,%cl 109c73: 74 07 je 109c7c <== ALWAYS TAKEN tty->column = 0; 109c75: c7 42 28 00 00 00 00 movl $0x0,0x28(%edx) <== NOT EXECUTED if (tty->termios.c_oflag & ONLCR) { 109c7c: 83 e1 04 and $0x4,%ecx 109c7f: 74 c3 je 109c44 <== NEVER TAKEN rtems_termios_puts ("\r", 1, tty); 109c81: 51 push %ecx 109c82: 52 push %edx 109c83: 6a 01 push $0x1 109c85: 68 04 14 12 00 push $0x121404 109c8a: 89 55 f0 mov %edx,-0x10(%ebp) 109c8d: e8 3a fe ff ff call 109acc tty->column = 0; 109c92: 8b 55 f0 mov -0x10(%ebp),%edx 109c95: c7 42 28 00 00 00 00 movl $0x0,0x28(%edx) 109c9c: 83 c4 10 add $0x10,%esp 109c9f: eb a3 jmp 109c44 109ca1: 8d 76 00 lea 0x0(%esi),%esi } break; case '\r': if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0)) 109ca4: f6 c1 10 test $0x10,%cl <== NOT EXECUTED 109ca7: 74 07 je 109cb0 <== NOT EXECUTED 109ca9: 8b 42 28 mov 0x28(%edx),%eax <== NOT EXECUTED 109cac: 85 c0 test %eax,%eax <== NOT EXECUTED 109cae: 74 a4 je 109c54 <== NOT EXECUTED return; if (tty->termios.c_oflag & OCRNL) { 109cb0: f6 c1 08 test $0x8,%cl <== NOT EXECUTED 109cb3: 74 09 je 109cbe <== NOT EXECUTED c = '\n'; 109cb5: c6 45 f4 0a movb $0xa,-0xc(%ebp) <== NOT EXECUTED if (tty->termios.c_oflag & ONLRET) 109cb9: 83 e1 20 and $0x20,%ecx <== NOT EXECUTED 109cbc: 74 86 je 109c44 <== NOT EXECUTED tty->column = 0; break; } tty->column = 0; 109cbe: c7 42 28 00 00 00 00 movl $0x0,0x28(%edx) <== NOT EXECUTED break; 109cc5: e9 7a ff ff ff jmp 109c44 <== NOT EXECUTED 109cca: 66 90 xchg %ax,%ax <== NOT EXECUTED case '\t': i = 8 - (tty->column & 7); 109ccc: 8b 5a 28 mov 0x28(%edx),%ebx 109ccf: 89 de mov %ebx,%esi 109cd1: 83 e6 07 and $0x7,%esi 109cd4: b8 08 00 00 00 mov $0x8,%eax 109cd9: 29 f0 sub %esi,%eax if ((tty->termios.c_oflag & TABDLY) == XTABS) { 109cdb: 81 e1 00 18 00 00 and $0x1800,%ecx 109ce1: 81 f9 00 18 00 00 cmp $0x1800,%ecx 109ce7: 74 37 je 109d20 <== ALWAYS TAKEN tty->column += i; rtems_termios_puts ( " ", i, tty); return; } tty->column += i; 109ce9: 01 d8 add %ebx,%eax <== NOT EXECUTED 109ceb: 89 42 28 mov %eax,0x28(%edx) <== NOT EXECUTED break; 109cee: e9 51 ff ff ff jmp 109c44 <== NOT EXECUTED 109cf3: 90 nop <== NOT EXECUTED tty->column--; break; default: if (tty->termios.c_oflag & OLCUC) c = toupper(c); 109cf4: 8b 0d 94 5a 12 00 mov 0x125a94,%ecx <== NOT EXECUTED 109cfa: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 109cfd: 0f be 5c 01 01 movsbl 0x1(%ecx,%eax,1),%ebx <== NOT EXECUTED 109d02: 83 e3 03 and $0x3,%ebx <== NOT EXECUTED 109d05: 83 fb 02 cmp $0x2,%ebx <== NOT EXECUTED 109d08: 74 0e je 109d18 <== NOT EXECUTED 109d0a: 89 c3 mov %eax,%ebx <== NOT EXECUTED 109d0c: 88 d8 mov %bl,%al <== NOT EXECUTED 109d0e: 88 5d f4 mov %bl,-0xc(%ebp) <== NOT EXECUTED 109d11: e9 1e ff ff ff jmp 109c34 <== NOT EXECUTED 109d16: 66 90 xchg %ax,%ax <== NOT EXECUTED 109d18: 8d 58 e0 lea -0x20(%eax),%ebx <== NOT EXECUTED 109d1b: eb ef jmp 109d0c <== NOT EXECUTED 109d1d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED break; case '\t': i = 8 - (tty->column & 7); if ((tty->termios.c_oflag & TABDLY) == XTABS) { tty->column += i; 109d20: 8d 1c 18 lea (%eax,%ebx,1),%ebx 109d23: 89 5a 28 mov %ebx,0x28(%edx) rtems_termios_puts ( " ", i, tty); 109d26: 56 push %esi 109d27: 52 push %edx 109d28: 50 push %eax 109d29: 68 9c 0f 12 00 push $0x120f9c 109d2e: e8 99 fd ff ff call 109acc return; 109d33: 83 c4 10 add $0x10,%esp 109d36: e9 19 ff ff ff jmp 109c54 =============================================================================== 0010a038 : long pathconf( const char *path, int name ) { 10a038: 55 push %ebp 10a039: 89 e5 mov %esp,%ebp 10a03b: 56 push %esi 10a03c: 53 push %ebx int status; int fd; fd = open( path, O_RDONLY ); 10a03d: 83 ec 08 sub $0x8,%esp 10a040: 6a 00 push $0x0 10a042: ff 75 08 pushl 0x8(%ebp) 10a045: e8 4e fd ff ff call 109d98 10a04a: 89 c3 mov %eax,%ebx if ( fd == -1 ) 10a04c: 83 c4 10 add $0x10,%esp 10a04f: 83 f8 ff cmp $0xffffffff,%eax 10a052: 74 24 je 10a078 return -1; status = fpathconf( fd, name ); 10a054: 83 ec 08 sub $0x8,%esp 10a057: ff 75 0c pushl 0xc(%ebp) 10a05a: 50 push %eax 10a05b: e8 c0 ec ff ff call 108d20 10a060: 89 c6 mov %eax,%esi (void) close( fd ); 10a062: 89 1c 24 mov %ebx,(%esp) 10a065: e8 56 e8 ff ff call 1088c0 return status; 10a06a: 83 c4 10 add $0x10,%esp 10a06d: 89 f0 mov %esi,%eax } 10a06f: 8d 65 f8 lea -0x8(%ebp),%esp 10a072: 5b pop %ebx 10a073: 5e pop %esi 10a074: c9 leave 10a075: c3 ret 10a076: 66 90 xchg %ax,%ax int status; int fd; fd = open( path, O_RDONLY ); if ( fd == -1 ) return -1; 10a078: b8 ff ff ff ff mov $0xffffffff,%eax status = fpathconf( fd, name ); (void) close( fd ); return status; } 10a07d: 8d 65 f8 lea -0x8(%ebp),%esp 10a080: 5b pop %ebx 10a081: 5e pop %esi 10a082: c9 leave 10a083: c3 ret =============================================================================== 00110d7c : * Called by pipe() to create an anonymous pipe. */ int pipe_create( int filsdes[2] ) { 110d7c: 55 push %ebp 110d7d: 89 e5 mov %esp,%ebp 110d7f: 57 push %edi 110d80: 56 push %esi 110d81: 53 push %ebx 110d82: 83 ec 24 sub $0x24,%esp rtems_libio_t *iop; int err = 0; if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0) 110d85: 68 ff 01 00 00 push $0x1ff 110d8a: 68 6c 35 12 00 push $0x12356c 110d8f: e8 38 17 00 00 call 1124cc 110d94: 83 c4 10 add $0x10,%esp 110d97: 85 c0 test %eax,%eax 110d99: 74 0d je 110da8 <== ALWAYS TAKEN return -1; 110d9b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED unlink(fifopath); } if(err != 0) rtems_set_errno_and_return_minus_one(err); return 0; } 110da0: 8d 65 f4 lea -0xc(%ebp),%esp 110da3: 5b pop %ebx 110da4: 5e pop %esi 110da5: 5f pop %edi 110da6: c9 leave 110da7: c3 ret if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0) return -1; /* /tmp/.fifoXXXX */ char fifopath[15]; memcpy(fifopath, "/tmp/.fifo", 10); 110da8: 8d 5d d9 lea -0x27(%ebp),%ebx 110dab: be 71 35 12 00 mov $0x123571,%esi 110db0: b9 0a 00 00 00 mov $0xa,%ecx 110db5: 89 df mov %ebx,%edi 110db7: f3 a4 rep movsb %ds:(%esi),%es:(%edi) sprintf(fifopath + 10, "%04x", rtems_pipe_no ++); 110db9: 0f b7 05 6c 96 12 00 movzwl 0x12966c,%eax 110dc0: 8d 50 01 lea 0x1(%eax),%edx 110dc3: 66 89 15 6c 96 12 00 mov %dx,0x12966c 110dca: 51 push %ecx 110dcb: 50 push %eax 110dcc: 68 7c 35 12 00 push $0x12357c 110dd1: 8d 45 e3 lea -0x1d(%ebp),%eax 110dd4: 50 push %eax 110dd5: e8 d6 49 00 00 call 1157b0 /* Try creating FIFO file until find an available file name */ while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) { 110dda: 58 pop %eax 110ddb: 5a pop %edx 110ddc: 68 80 01 00 00 push $0x180 110de1: 53 push %ebx 110de2: e8 2d 14 00 00 call 112214 110de7: 83 c4 10 add $0x10,%esp 110dea: 85 c0 test %eax,%eax 110dec: 0f 85 a6 00 00 00 jne 110e98 return -1; /* sprintf(fifopath + 10, "%04x", rtems_pipe_no ++); */ } /* Non-blocking open to avoid waiting for writers */ filsdes[0] = open(fifopath, O_RDONLY | O_NONBLOCK); 110df2: 83 ec 08 sub $0x8,%esp 110df5: 68 00 40 00 00 push $0x4000 110dfa: 53 push %ebx 110dfb: e8 d0 90 ff ff call 109ed0 110e00: 8b 55 08 mov 0x8(%ebp),%edx 110e03: 89 02 mov %eax,(%edx) if (filsdes[0] < 0) { 110e05: 83 c4 10 add $0x10,%esp 110e08: 85 c0 test %eax,%eax 110e0a: 78 58 js 110e64 the file node will be deleted after it is closed by all. */ unlink(fifopath); } else { /* Reset open file to blocking mode */ iop = rtems_libio_iop(filsdes[0]); 110e0c: 3b 05 ac 55 12 00 cmp 0x1255ac,%eax 110e12: 72 3c jb 110e50 <== ALWAYS TAKEN 110e14: 31 d2 xor %edx,%edx iop->flags &= ~LIBIO_FLAGS_NO_DELAY; 110e16: 83 62 14 fe andl $0xfffffffe,0x14(%edx) filsdes[1] = open(fifopath, O_WRONLY); 110e1a: 83 ec 08 sub $0x8,%esp 110e1d: 6a 01 push $0x1 110e1f: 53 push %ebx 110e20: e8 ab 90 ff ff call 109ed0 110e25: 8b 55 08 mov 0x8(%ebp),%edx 110e28: 89 42 04 mov %eax,0x4(%edx) if (filsdes[1] < 0) { 110e2b: 83 c4 10 add $0x10,%esp 110e2e: 85 c0 test %eax,%eax 110e30: 78 4a js 110e7c int pipe_create( int filsdes[2] ) { rtems_libio_t *iop; int err = 0; 110e32: 31 f6 xor %esi,%esi if (filsdes[1] < 0) { err = errno; close(filsdes[0]); } unlink(fifopath); 110e34: 83 ec 0c sub $0xc,%esp 110e37: 53 push %ebx 110e38: e8 df b0 ff ff call 10bf1c 110e3d: 83 c4 10 add $0x10,%esp } if(err != 0) 110e40: 85 f6 test %esi,%esi 110e42: 75 63 jne 110ea7 rtems_set_errno_and_return_minus_one(err); return 0; 110e44: 31 c0 xor %eax,%eax } 110e46: 8d 65 f4 lea -0xc(%ebp),%esp 110e49: 5b pop %ebx 110e4a: 5e pop %esi 110e4b: 5f pop %edi 110e4c: c9 leave 110e4d: c3 ret 110e4e: 66 90 xchg %ax,%ax the file node will be deleted after it is closed by all. */ unlink(fifopath); } else { /* Reset open file to blocking mode */ iop = rtems_libio_iop(filsdes[0]); 110e50: c1 e0 03 shl $0x3,%eax 110e53: 8d 14 c5 00 00 00 00 lea 0x0(,%eax,8),%edx 110e5a: 29 c2 sub %eax,%edx 110e5c: 03 15 a0 98 12 00 add 0x1298a0,%edx 110e62: eb b2 jmp 110e16 } /* Non-blocking open to avoid waiting for writers */ filsdes[0] = open(fifopath, O_RDONLY | O_NONBLOCK); if (filsdes[0] < 0) { err = errno; 110e64: e8 af 3f 00 00 call 114e18 <__errno> 110e69: 8b 30 mov (%eax),%esi /* Delete file at errors, or else if pipe is successfully created the file node will be deleted after it is closed by all. */ unlink(fifopath); 110e6b: 83 ec 0c sub $0xc,%esp 110e6e: 53 push %ebx 110e6f: e8 a8 b0 ff ff call 10bf1c 110e74: 83 c4 10 add $0x10,%esp 110e77: eb c7 jmp 110e40 110e79: 8d 76 00 lea 0x0(%esi),%esi iop->flags &= ~LIBIO_FLAGS_NO_DELAY; filsdes[1] = open(fifopath, O_WRONLY); if (filsdes[1] < 0) { err = errno; 110e7c: e8 97 3f 00 00 call 114e18 <__errno> 110e81: 8b 30 mov (%eax),%esi close(filsdes[0]); 110e83: 83 ec 0c sub $0xc,%esp 110e86: 8b 45 08 mov 0x8(%ebp),%eax 110e89: ff 30 pushl (%eax) 110e8b: e8 a8 80 ff ff call 108f38 110e90: 83 c4 10 add $0x10,%esp 110e93: eb 9f jmp 110e34 110e95: 8d 76 00 lea 0x0(%esi),%esi memcpy(fifopath, "/tmp/.fifo", 10); sprintf(fifopath + 10, "%04x", rtems_pipe_no ++); /* Try creating FIFO file until find an available file name */ while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) { if (errno != EEXIST){ 110e98: e8 7b 3f 00 00 call 114e18 <__errno> return -1; 110e9d: b8 ff ff ff ff mov $0xffffffff,%eax 110ea2: e9 f9 fe ff ff jmp 110da0 close(filsdes[0]); } unlink(fifopath); } if(err != 0) rtems_set_errno_and_return_minus_one(err); 110ea7: e8 6c 3f 00 00 call 114e18 <__errno> 110eac: 89 30 mov %esi,(%eax) 110eae: b8 ff ff ff ff mov $0xffffffff,%eax 110eb3: e9 e8 fe ff ff jmp 110da0 =============================================================================== 001122d0 : pipe_control_t *pipe, uint32_t cmd, void *buffer, rtems_libio_t *iop ) { 1122d0: 55 push %ebp 1122d1: 89 e5 mov %esp,%ebp 1122d3: 56 push %esi 1122d4: 53 push %ebx 1122d5: 8b 75 08 mov 0x8(%ebp),%esi 1122d8: 8b 5d 10 mov 0x10(%ebp),%ebx if (cmd == FIONREAD) { 1122db: 81 7d 0c 7f 66 04 40 cmpl $0x4004667f,0xc(%ebp) 1122e2: 74 0c je 1122f0 *(unsigned int *)buffer = pipe->Length; PIPE_UNLOCK(pipe); return 0; } return -EINVAL; 1122e4: b8 ea ff ff ff mov $0xffffffea,%eax } 1122e9: 8d 65 f8 lea -0x8(%ebp),%esp 1122ec: 5b pop %ebx 1122ed: 5e pop %esi 1122ee: c9 leave 1122ef: c3 ret void *buffer, rtems_libio_t *iop ) { if (cmd == FIONREAD) { if (buffer == NULL) 1122f0: 85 db test %ebx,%ebx 1122f2: 75 07 jne 1122fb return -EFAULT; 1122f4: b8 f2 ff ff ff mov $0xfffffff2,%eax 1122f9: eb ee jmp 1122e9 if (! PIPE_LOCK(pipe)) 1122fb: 50 push %eax 1122fc: 6a 00 push $0x0 1122fe: 6a 00 push $0x0 112300: ff 76 28 pushl 0x28(%esi) 112303: e8 cc b1 ff ff call 10d4d4 112308: 83 c4 10 add $0x10,%esp 11230b: 85 c0 test %eax,%eax 11230d: 74 07 je 112316 <== ALWAYS TAKEN return -EINTR; 11230f: b8 fc ff ff ff mov $0xfffffffc,%eax <== NOT EXECUTED 112314: eb d3 jmp 1122e9 <== NOT EXECUTED /* Return length of pipe */ *(unsigned int *)buffer = pipe->Length; 112316: 8b 46 0c mov 0xc(%esi),%eax 112319: 89 03 mov %eax,(%ebx) PIPE_UNLOCK(pipe); 11231b: 83 ec 0c sub $0xc,%esp 11231e: ff 76 28 pushl 0x28(%esi) 112321: e8 aa b2 ff ff call 10d5d0 return 0; 112326: 83 c4 10 add $0x10,%esp 112329: 31 c0 xor %eax,%eax 11232b: eb bc jmp 1122e9 =============================================================================== 00111f18 : pipe_control_t *pipe, void *buffer, size_t count, rtems_libio_t *iop ) { 111f18: 55 push %ebp 111f19: 89 e5 mov %esp,%ebp 111f1b: 57 push %edi 111f1c: 56 push %esi 111f1d: 53 push %ebx 111f1e: 83 ec 30 sub $0x30,%esp 111f21: 8b 5d 08 mov 0x8(%ebp),%ebx int chunk, chunk1, read = 0, ret = 0; if (! PIPE_LOCK(pipe)) 111f24: 6a 00 push $0x0 111f26: 6a 00 push $0x0 111f28: ff 73 28 pushl 0x28(%ebx) 111f2b: e8 a4 b5 ff ff call 10d4d4 111f30: 83 c4 10 add $0x10,%esp 111f33: 85 c0 test %eax,%eax 111f35: 0f 85 ad 00 00 00 jne 111fe8 <== NEVER TAKEN return -EINTR; while (read < count) { 111f3b: 8b 55 10 mov 0x10(%ebp),%edx 111f3e: 85 d2 test %edx,%edx 111f40: 0f 84 7a 01 00 00 je 1120c0 <== NEVER TAKEN 111f46: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp) 111f4d: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) while (PIPE_EMPTY(pipe)) { 111f54: 8b 53 0c mov 0xc(%ebx),%edx 111f57: 85 d2 test %edx,%edx 111f59: 0f 85 99 00 00 00 jne 111ff8 /* Not an error */ if (pipe->Writers == 0) 111f5f: 8b 43 14 mov 0x14(%ebx),%eax 111f62: 85 c0 test %eax,%eax 111f64: 0f 84 fe 00 00 00 je 112068 goto out_locked; if (LIBIO_NODELAY(iop)) { 111f6a: 8b 45 14 mov 0x14(%ebp),%eax 111f6d: f6 40 14 01 testb $0x1,0x14(%eax) 111f71: 0f 85 f9 00 00 00 jne 112070 ret = -EAGAIN; goto out_locked; } /* Wait until pipe is no more empty or no writer exists */ pipe->waitingReaders ++; 111f77: ff 43 18 incl 0x18(%ebx) PIPE_UNLOCK(pipe); 111f7a: 83 ec 0c sub $0xc,%esp 111f7d: ff 73 28 pushl 0x28(%ebx) 111f80: e8 4b b6 ff ff call 10d5d0 if (! PIPE_READWAIT(pipe)) 111f85: 5e pop %esi 111f86: 5f pop %edi 111f87: 6a 00 push $0x0 111f89: ff 73 2c pushl 0x2c(%ebx) 111f8c: e8 03 19 00 00 call 113894 111f91: 83 c4 0c add $0xc,%esp 111f94: 83 f8 01 cmp $0x1,%eax 111f97: 19 f6 sbb %esi,%esi 111f99: f7 d6 not %esi 111f9b: 83 e6 fc and $0xfffffffc,%esi ret = -EINTR; if (! PIPE_LOCK(pipe)) { 111f9e: 6a 00 push $0x0 111fa0: 6a 00 push $0x0 111fa2: ff 73 28 pushl 0x28(%ebx) 111fa5: e8 2a b5 ff ff call 10d4d4 111faa: 83 c4 10 add $0x10,%esp 111fad: 85 c0 test %eax,%eax 111faf: 0f 85 c7 00 00 00 jne 11207c <== NEVER TAKEN /* WARN waitingReaders not restored! */ ret = -EINTR; goto out_nolock; } pipe->waitingReaders --; 111fb5: ff 4b 18 decl 0x18(%ebx) if (ret != 0) 111fb8: 85 f6 test %esi,%esi 111fba: 74 98 je 111f54 <== ALWAYS TAKEN PIPE_WAKEUPWRITERS(pipe); read += chunk; } out_locked: PIPE_UNLOCK(pipe); 111fbc: 83 ec 0c sub $0xc,%esp 111fbf: ff 73 28 pushl 0x28(%ebx) 111fc2: e8 09 b6 ff ff call 10d5d0 111fc7: 83 c4 10 add $0x10,%esp out_nolock: if (read > 0) 111fca: 8b 55 d4 mov -0x2c(%ebp),%edx 111fcd: 85 d2 test %edx,%edx 111fcf: 7e 0b jle 111fdc 111fd1: 8b 45 d4 mov -0x2c(%ebp),%eax return read; return ret; } 111fd4: 8d 65 f4 lea -0xc(%ebp),%esp 111fd7: 5b pop %ebx 111fd8: 5e pop %esi 111fd9: 5f pop %edi 111fda: c9 leave 111fdb: c3 ret PIPE_UNLOCK(pipe); out_nolock: if (read > 0) return read; return ret; 111fdc: 89 f0 mov %esi,%eax } 111fde: 8d 65 f4 lea -0xc(%ebp),%esp 111fe1: 5b pop %ebx 111fe2: 5e pop %esi 111fe3: 5f pop %edi 111fe4: c9 leave 111fe5: c3 ret 111fe6: 66 90 xchg %ax,%ax ) { int chunk, chunk1, read = 0, ret = 0; if (! PIPE_LOCK(pipe)) return -EINTR; 111fe8: b8 fc ff ff ff mov $0xfffffffc,%eax <== NOT EXECUTED out_nolock: if (read > 0) return read; return ret; } 111fed: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 111ff0: 5b pop %ebx <== NOT EXECUTED 111ff1: 5e pop %esi <== NOT EXECUTED 111ff2: 5f pop %edi <== NOT EXECUTED 111ff3: c9 leave <== NOT EXECUTED 111ff4: c3 ret <== NOT EXECUTED 111ff5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if (ret != 0) goto out_locked; } /* Read chunk bytes */ chunk = MIN(count - read, pipe->Length); 111ff8: 8b 45 10 mov 0x10(%ebp),%eax 111ffb: 2b 45 d0 sub -0x30(%ebp),%eax 111ffe: 89 55 cc mov %edx,-0x34(%ebp) 112001: 39 c2 cmp %eax,%edx 112003: 76 03 jbe 112008 112005: 89 45 cc mov %eax,-0x34(%ebp) chunk1 = pipe->Size - pipe->Start; 112008: 8b 73 08 mov 0x8(%ebx),%esi 11200b: 8b 43 04 mov 0x4(%ebx),%eax 11200e: 29 f0 sub %esi,%eax if (chunk > chunk1) { 112010: 39 45 cc cmp %eax,-0x34(%ebp) 112013: 7f 71 jg 112086 memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1); memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1); } else memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk); 112015: 8b 45 0c mov 0xc(%ebp),%eax 112018: 03 45 d0 add -0x30(%ebp),%eax 11201b: 03 33 add (%ebx),%esi 11201d: 89 c7 mov %eax,%edi 11201f: 8b 4d cc mov -0x34(%ebp),%ecx 112022: f3 a4 rep movsb %ds:(%esi),%es:(%edi) pipe->Start += chunk; 112024: 8b 45 cc mov -0x34(%ebp),%eax 112027: 03 43 08 add 0x8(%ebx),%eax pipe->Start %= pipe->Size; 11202a: 31 d2 xor %edx,%edx 11202c: f7 73 04 divl 0x4(%ebx) 11202f: 89 53 08 mov %edx,0x8(%ebx) pipe->Length -= chunk; 112032: 8b 43 0c mov 0xc(%ebx),%eax 112035: 2b 45 cc sub -0x34(%ebp),%eax 112038: 89 43 0c mov %eax,0xc(%ebx) /* For buffering optimization */ if (PIPE_EMPTY(pipe)) 11203b: 85 c0 test %eax,%eax 11203d: 75 07 jne 112046 pipe->Start = 0; 11203f: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) if (pipe->waitingWriters > 0) 112046: 8b 4b 1c mov 0x1c(%ebx),%ecx 112049: 85 c9 test %ecx,%ecx 11204b: 75 5f jne 1120ac PIPE_WAKEUPWRITERS(pipe); read += chunk; 11204d: 8b 45 cc mov -0x34(%ebp),%eax 112050: 01 45 d4 add %eax,-0x2c(%ebp) int chunk, chunk1, read = 0, ret = 0; if (! PIPE_LOCK(pipe)) return -EINTR; while (read < count) { 112053: 8b 45 d4 mov -0x2c(%ebp),%eax 112056: 89 45 d0 mov %eax,-0x30(%ebp) 112059: 8b 45 10 mov 0x10(%ebp),%eax 11205c: 39 45 d4 cmp %eax,-0x2c(%ebp) 11205f: 0f 82 ef fe ff ff jb 111f54 <== NEVER TAKEN 112065: 8d 76 00 lea 0x0(%esi),%esi while (PIPE_EMPTY(pipe)) { /* Not an error */ if (pipe->Writers == 0) 112068: 31 f6 xor %esi,%esi 11206a: e9 4d ff ff ff jmp 111fbc 11206f: 90 nop goto out_locked; if (LIBIO_NODELAY(iop)) { ret = -EAGAIN; 112070: be f5 ff ff ff mov $0xfffffff5,%esi 112075: e9 42 ff ff ff jmp 111fbc 11207a: 66 90 xchg %ax,%ax PIPE_UNLOCK(pipe); if (! PIPE_READWAIT(pipe)) ret = -EINTR; if (! PIPE_LOCK(pipe)) { /* WARN waitingReaders not restored! */ ret = -EINTR; 11207c: be fc ff ff ff mov $0xfffffffc,%esi <== NOT EXECUTED 112081: e9 44 ff ff ff jmp 111fca <== NOT EXECUTED /* Read chunk bytes */ chunk = MIN(count - read, pipe->Length); chunk1 = pipe->Size - pipe->Start; if (chunk > chunk1) { memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1); 112086: 8b 55 0c mov 0xc(%ebp),%edx 112089: 03 55 d0 add -0x30(%ebp),%edx 11208c: 03 33 add (%ebx),%esi 11208e: 89 d7 mov %edx,%edi 112090: 89 c1 mov %eax,%ecx 112092: f3 a4 rep movsb %ds:(%esi),%es:(%edi) memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1); 112094: 8b 55 d0 mov -0x30(%ebp),%edx 112097: 01 c2 add %eax,%edx 112099: 03 55 0c add 0xc(%ebp),%edx 11209c: 8b 4d cc mov -0x34(%ebp),%ecx 11209f: 29 c1 sub %eax,%ecx 1120a1: 8b 33 mov (%ebx),%esi 1120a3: 89 d7 mov %edx,%edi 1120a5: f3 a4 rep movsb %ds:(%esi),%es:(%edi) 1120a7: e9 78 ff ff ff jmp 112024 /* For buffering optimization */ if (PIPE_EMPTY(pipe)) pipe->Start = 0; if (pipe->waitingWriters > 0) PIPE_WAKEUPWRITERS(pipe); 1120ac: 83 ec 08 sub $0x8,%esp 1120af: 8d 45 e4 lea -0x1c(%ebp),%eax 1120b2: 50 push %eax 1120b3: ff 73 30 pushl 0x30(%ebx) 1120b6: e8 75 17 00 00 call 113830 1120bb: 83 c4 10 add $0x10,%esp 1120be: eb 8d jmp 11204d int chunk, chunk1, read = 0, ret = 0; if (! PIPE_LOCK(pipe)) return -EINTR; while (read < count) { 1120c0: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) <== NOT EXECUTED 1120c7: 31 f6 xor %esi,%esi <== NOT EXECUTED 1120c9: e9 ee fe ff ff jmp 111fbc <== NOT EXECUTED =============================================================================== 001119c4 : */ void pipe_release( pipe_control_t **pipep, rtems_libio_t *iop ) { 1119c4: 55 push %ebp 1119c5: 89 e5 mov %esp,%ebp 1119c7: 57 push %edi 1119c8: 56 push %esi 1119c9: 53 push %ebx 1119ca: 83 ec 1c sub $0x1c,%esp 1119cd: 8b 7d 08 mov 0x8(%ebp),%edi pipe_control_t *pipe = *pipep; 1119d0: 8b 1f mov (%edi),%ebx /* WARN pipe not released! */ if (!PIPE_LOCK(pipe)) rtems_fatal_error_occurred(0xdeadbeef); #endif mode = LIBIO_ACCMODE(iop); 1119d2: 8b 45 0c mov 0xc(%ebp),%eax 1119d5: 8b 40 14 mov 0x14(%eax),%eax 1119d8: 89 c6 mov %eax,%esi 1119da: 83 e6 06 and $0x6,%esi if (mode & LIBIO_FLAGS_READ) 1119dd: a8 02 test $0x2,%al 1119df: 74 03 je 1119e4 pipe->Readers --; 1119e1: ff 4b 10 decl 0x10(%ebx) if (mode & LIBIO_FLAGS_WRITE) 1119e4: f7 c6 04 00 00 00 test $0x4,%esi 1119ea: 74 03 je 1119ef pipe->Writers --; 1119ec: ff 4b 14 decl 0x14(%ebx) PIPE_UNLOCK(pipe); 1119ef: 83 ec 0c sub $0xc,%esp 1119f2: ff 73 28 pushl 0x28(%ebx) 1119f5: e8 d6 bb ff ff call 10d5d0 if (pipe->Readers == 0 && pipe->Writers == 0) { 1119fa: 83 c4 10 add $0x10,%esp 1119fd: 8b 53 10 mov 0x10(%ebx),%edx 111a00: 85 d2 test %edx,%edx 111a02: 74 2c je 111a30 *pipep = NULL; } else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE) /* Notify waiting Writers that all their partners left */ PIPE_WAKEUPWRITERS(pipe); else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ) 111a04: 8b 43 14 mov 0x14(%ebx),%eax 111a07: 85 c0 test %eax,%eax 111a09: 75 17 jne 111a22 <== NEVER TAKEN 111a0b: 83 fe 02 cmp $0x2,%esi 111a0e: 74 12 je 111a22 <== NEVER TAKEN PIPE_WAKEUPREADERS(pipe); 111a10: 83 ec 08 sub $0x8,%esp 111a13: 8d 45 e4 lea -0x1c(%ebp),%eax 111a16: 50 push %eax 111a17: ff 73 2c pushl 0x2c(%ebx) 111a1a: e8 11 1e 00 00 call 113830 111a1f: 83 c4 10 add $0x10,%esp pipe_unlock(); 111a22: e8 85 ff ff ff call 1119ac iop->flags &= ~LIBIO_FLAGS_OPEN; if(iop->pathinfo.ops->unlink_h(&iop->pathinfo)) return; #endif } 111a27: 8d 65 f4 lea -0xc(%ebp),%esp 111a2a: 5b pop %ebx 111a2b: 5e pop %esi 111a2c: 5f pop %edi 111a2d: c9 leave 111a2e: c3 ret 111a2f: 90 nop if (mode & LIBIO_FLAGS_WRITE) pipe->Writers --; PIPE_UNLOCK(pipe); if (pipe->Readers == 0 && pipe->Writers == 0) { 111a30: 8b 43 14 mov 0x14(%ebx),%eax 111a33: 85 c0 test %eax,%eax 111a35: 74 25 je 111a5c delfile = TRUE; #endif pipe_free(pipe); *pipep = NULL; } else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE) 111a37: 83 fe 04 cmp $0x4,%esi 111a3a: 74 e6 je 111a22 <== NEVER TAKEN /* Notify waiting Writers that all their partners left */ PIPE_WAKEUPWRITERS(pipe); 111a3c: 83 ec 08 sub $0x8,%esp 111a3f: 8d 45 e4 lea -0x1c(%ebp),%eax 111a42: 50 push %eax 111a43: ff 73 30 pushl 0x30(%ebx) 111a46: e8 e5 1d 00 00 call 113830 111a4b: 83 c4 10 add $0x10,%esp else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ) PIPE_WAKEUPREADERS(pipe); pipe_unlock(); 111a4e: e8 59 ff ff ff call 1119ac iop->flags &= ~LIBIO_FLAGS_OPEN; if(iop->pathinfo.ops->unlink_h(&iop->pathinfo)) return; #endif } 111a53: 8d 65 f4 lea -0xc(%ebp),%esp 111a56: 5b pop %ebx 111a57: 5e pop %esi 111a58: 5f pop %edi 111a59: c9 leave 111a5a: c3 ret 111a5b: 90 nop /* Called with pipe_semaphore held. */ static inline void pipe_free( pipe_control_t *pipe ) { rtems_barrier_delete(pipe->readBarrier); 111a5c: 83 ec 0c sub $0xc,%esp 111a5f: ff 73 2c pushl 0x2c(%ebx) 111a62: e8 39 1d 00 00 call 1137a0 rtems_barrier_delete(pipe->writeBarrier); 111a67: 5e pop %esi 111a68: ff 73 30 pushl 0x30(%ebx) 111a6b: e8 30 1d 00 00 call 1137a0 rtems_semaphore_delete(pipe->Semaphore); 111a70: 59 pop %ecx 111a71: ff 73 28 pushl 0x28(%ebx) 111a74: e8 b7 b9 ff ff call 10d430 free(pipe->Buffer); 111a79: 5a pop %edx 111a7a: ff 33 pushl (%ebx) 111a7c: e8 4f 7f ff ff call 1099d0 free(pipe); 111a81: 89 1c 24 mov %ebx,(%esp) 111a84: e8 47 7f ff ff call 1099d0 /* To delete an anonymous pipe file when all users closed it */ if (pipe->Anonymous) delfile = TRUE; #endif pipe_free(pipe); *pipep = NULL; 111a89: c7 07 00 00 00 00 movl $0x0,(%edi) 111a8f: 83 c4 10 add $0x10,%esp /* Notify waiting Writers that all their partners left */ PIPE_WAKEUPWRITERS(pipe); else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ) PIPE_WAKEUPREADERS(pipe); pipe_unlock(); 111a92: e8 15 ff ff ff call 1119ac iop->flags &= ~LIBIO_FLAGS_OPEN; if(iop->pathinfo.ops->unlink_h(&iop->pathinfo)) return; #endif } 111a97: 8d 65 f4 lea -0xc(%ebp),%esp 111a9a: 5b pop %ebx 111a9b: 5e pop %esi 111a9c: 5f pop %edi 111a9d: c9 leave 111a9e: c3 ret =============================================================================== 001120d0 : pipe_control_t *pipe, const void *buffer, size_t count, rtems_libio_t *iop ) { 1120d0: 55 push %ebp 1120d1: 89 e5 mov %esp,%ebp 1120d3: 57 push %edi 1120d4: 56 push %esi 1120d5: 53 push %ebx 1120d6: 83 ec 2c sub $0x2c,%esp 1120d9: 8b 5d 10 mov 0x10(%ebp),%ebx int chunk, chunk1, written = 0, ret = 0; /* Write nothing */ if (count == 0) 1120dc: 85 db test %ebx,%ebx 1120de: 75 0c jne 1120ec <== ALWAYS TAKEN return 0; 1120e0: 31 c0 xor %eax,%eax #endif if (written > 0) return written; return ret; } 1120e2: 8d 65 f4 lea -0xc(%ebp),%esp 1120e5: 5b pop %ebx 1120e6: 5e pop %esi 1120e7: 5f pop %edi 1120e8: c9 leave 1120e9: c3 ret 1120ea: 66 90 xchg %ax,%ax /* Write nothing */ if (count == 0) return 0; if (! PIPE_LOCK(pipe)) 1120ec: 56 push %esi 1120ed: 6a 00 push $0x0 1120ef: 6a 00 push $0x0 1120f1: 8b 45 08 mov 0x8(%ebp),%eax 1120f4: ff 70 28 pushl 0x28(%eax) 1120f7: e8 d8 b3 ff ff call 10d4d4 1120fc: 83 c4 10 add $0x10,%esp 1120ff: 85 c0 test %eax,%eax 112101: 0f 85 4a 01 00 00 jne 112251 <== NEVER TAKEN return -EINTR; if (pipe->Readers == 0) { 112107: 8b 45 08 mov 0x8(%ebp),%eax 11210a: 8b 48 10 mov 0x10(%eax),%ecx 11210d: 85 c9 test %ecx,%ecx 11210f: 0f 84 57 01 00 00 je 11226c ret = -EPIPE; goto out_locked; } /* Write of PIPE_BUF bytes or less shall not be interleaved */ chunk = count <= pipe->Size ? count : 1; 112115: 8b 48 04 mov 0x4(%eax),%ecx 112118: 39 cb cmp %ecx,%ebx 11211a: 0f 87 42 01 00 00 ja 112262 <== NEVER TAKEN 112120: 89 de mov %ebx,%esi 112122: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp) 112129: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) else memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk); pipe->Length += chunk; if (pipe->waitingReaders > 0) PIPE_WAKEUPREADERS(pipe); 112130: 89 5d c8 mov %ebx,-0x38(%ebp) 112133: 8b 5d 08 mov 0x8(%ebp),%ebx /* Write of PIPE_BUF bytes or less shall not be interleaved */ chunk = count <= pipe->Size ? count : 1; while (written < count) { while (PIPE_SPACE(pipe) < chunk) { 112136: 8b 43 0c mov 0xc(%ebx),%eax 112139: 89 ca mov %ecx,%edx 11213b: 29 c2 sub %eax,%edx 11213d: 39 f2 cmp %esi,%edx 11213f: 73 6f jae 1121b0 if (LIBIO_NODELAY(iop)) { 112141: 8b 45 14 mov 0x14(%ebp),%eax 112144: f6 40 14 01 testb $0x1,0x14(%eax) 112148: 0f 85 48 01 00 00 jne 112296 ret = -EAGAIN; goto out_locked; } /* Wait until there is chunk bytes space or no reader exists */ pipe->waitingWriters ++; 11214e: ff 43 1c incl 0x1c(%ebx) PIPE_UNLOCK(pipe); 112151: 83 ec 0c sub $0xc,%esp 112154: ff 73 28 pushl 0x28(%ebx) 112157: e8 74 b4 ff ff call 10d5d0 if (! PIPE_WRITEWAIT(pipe)) 11215c: 58 pop %eax 11215d: 5a pop %edx 11215e: 6a 00 push $0x0 112160: ff 73 30 pushl 0x30(%ebx) 112163: e8 2c 17 00 00 call 113894 112168: 83 c4 0c add $0xc,%esp 11216b: 83 f8 01 cmp $0x1,%eax 11216e: 19 ff sbb %edi,%edi 112170: f7 d7 not %edi 112172: 83 e7 fc and $0xfffffffc,%edi ret = -EINTR; if (! PIPE_LOCK(pipe)) { 112175: 6a 00 push $0x0 112177: 6a 00 push $0x0 112179: ff 73 28 pushl 0x28(%ebx) 11217c: e8 53 b3 ff ff call 10d4d4 112181: 83 c4 10 add $0x10,%esp 112184: 85 c0 test %eax,%eax 112186: 0f 85 03 01 00 00 jne 11228f <== NEVER TAKEN /* WARN waitingWriters not restored! */ ret = -EINTR; goto out_nolock; } pipe->waitingWriters --; 11218c: ff 4b 1c decl 0x1c(%ebx) if (ret != 0) 11218f: 85 ff test %edi,%edi 112191: 0f 85 95 00 00 00 jne 11222c <== NEVER TAKEN goto out_locked; if (pipe->Readers == 0) { 112197: 8b 7b 10 mov 0x10(%ebx),%edi 11219a: 85 ff test %edi,%edi 11219c: 0f 84 85 00 00 00 je 112227 <== NEVER TAKEN 1121a2: 8b 4b 04 mov 0x4(%ebx),%ecx /* Write of PIPE_BUF bytes or less shall not be interleaved */ chunk = count <= pipe->Size ? count : 1; while (written < count) { while (PIPE_SPACE(pipe) < chunk) { 1121a5: 8b 43 0c mov 0xc(%ebx),%eax 1121a8: 89 ca mov %ecx,%edx 1121aa: 29 c2 sub %eax,%edx 1121ac: 39 f2 cmp %esi,%edx 1121ae: 72 91 jb 112141 <== NEVER TAKEN ret = -EPIPE; goto out_locked; } } chunk = MIN(count - written, PIPE_SPACE(pipe)); 1121b0: 8b 75 c8 mov -0x38(%ebp),%esi 1121b3: 2b 75 d0 sub -0x30(%ebp),%esi 1121b6: 89 55 cc mov %edx,-0x34(%ebp) 1121b9: 39 f2 cmp %esi,%edx 1121bb: 76 03 jbe 1121c0 1121bd: 89 75 cc mov %esi,-0x34(%ebp) chunk1 = pipe->Size - PIPE_WSTART(pipe); 1121c0: 03 43 08 add 0x8(%ebx),%eax 1121c3: 31 d2 xor %edx,%edx 1121c5: f7 f1 div %ecx 1121c7: 89 c8 mov %ecx,%eax 1121c9: 29 d0 sub %edx,%eax if (chunk > chunk1) { 1121cb: 39 45 cc cmp %eax,-0x34(%ebp) 1121ce: 0f 8e c9 00 00 00 jle 11229d memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1); 1121d4: 03 13 add (%ebx),%edx 1121d6: 8b 75 0c mov 0xc(%ebp),%esi 1121d9: 03 75 d0 add -0x30(%ebp),%esi 1121dc: 89 d7 mov %edx,%edi 1121de: 89 c1 mov %eax,%ecx 1121e0: f3 a4 rep movsb %ds:(%esi),%es:(%edi) memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1); 1121e2: 8b 13 mov (%ebx),%edx 1121e4: 8b 4d cc mov -0x34(%ebp),%ecx 1121e7: 29 c1 sub %eax,%ecx 1121e9: 03 45 d0 add -0x30(%ebp),%eax 1121ec: 8b 75 0c mov 0xc(%ebp),%esi 1121ef: 01 c6 add %eax,%esi 1121f1: 89 d7 mov %edx,%edi 1121f3: f3 a4 rep movsb %ds:(%esi),%es:(%edi) } else memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk); pipe->Length += chunk; 1121f5: 8b 45 cc mov -0x34(%ebp),%eax 1121f8: 01 43 0c add %eax,0xc(%ebx) if (pipe->waitingReaders > 0) 1121fb: 83 7b 18 00 cmpl $0x0,0x18(%ebx) 1121ff: 0f 85 ac 00 00 00 jne 1122b1 PIPE_WAKEUPREADERS(pipe); written += chunk; 112205: 8b 45 cc mov -0x34(%ebp),%eax 112208: 01 45 d4 add %eax,-0x2c(%ebp) } /* Write of PIPE_BUF bytes or less shall not be interleaved */ chunk = count <= pipe->Size ? count : 1; while (written < count) { 11220b: 8b 45 d4 mov -0x2c(%ebp),%eax 11220e: 89 45 d0 mov %eax,-0x30(%ebp) 112211: 39 45 c8 cmp %eax,-0x38(%ebp) 112214: 0f 86 ad 00 00 00 jbe 1122c7 <== ALWAYS TAKEN 11221a: 8b 4b 04 mov 0x4(%ebx),%ecx <== NOT EXECUTED pipe->Length += chunk; if (pipe->waitingReaders > 0) PIPE_WAKEUPREADERS(pipe); written += chunk; /* Write of more than PIPE_BUF bytes can be interleaved */ chunk = 1; 11221d: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED 112222: e9 0f ff ff ff jmp 112136 <== NOT EXECUTED pipe->waitingWriters --; if (ret != 0) goto out_locked; if (pipe->Readers == 0) { ret = -EPIPE; 112227: bf e0 ff ff ff mov $0xffffffe0,%edi <== NOT EXECUTED /* Write of more than PIPE_BUF bytes can be interleaved */ chunk = 1; } out_locked: PIPE_UNLOCK(pipe); 11222c: 83 ec 0c sub $0xc,%esp 11222f: 8b 45 08 mov 0x8(%ebp),%eax 112232: ff 70 28 pushl 0x28(%eax) 112235: e8 96 b3 ff ff call 10d5d0 11223a: 83 c4 10 add $0x10,%esp out_nolock: #ifdef RTEMS_POSIX_API /* Signal SIGPIPE */ if (ret == -EPIPE) 11223d: 83 ff e0 cmp $0xffffffe0,%edi 112240: 74 38 je 11227a kill(getpid(), SIGPIPE); #endif if (written > 0) 112242: 8b 4d d4 mov -0x2c(%ebp),%ecx 112245: 85 c9 test %ecx,%ecx 112247: 7e 12 jle 11225b 112249: 8b 45 d4 mov -0x2c(%ebp),%eax 11224c: e9 91 fe ff ff jmp 1120e2 /* Write nothing */ if (count == 0) return 0; if (! PIPE_LOCK(pipe)) return -EINTR; 112251: b8 fc ff ff ff mov $0xfffffffc,%eax <== NOT EXECUTED 112256: e9 87 fe ff ff jmp 1120e2 <== NOT EXECUTED /* Signal SIGPIPE */ if (ret == -EPIPE) kill(getpid(), SIGPIPE); #endif if (written > 0) 11225b: 89 f8 mov %edi,%eax 11225d: e9 80 fe ff ff jmp 1120e2 ret = -EPIPE; goto out_locked; } /* Write of PIPE_BUF bytes or less shall not be interleaved */ chunk = count <= pipe->Size ? count : 1; 112262: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED 112267: e9 b6 fe ff ff jmp 112122 <== NOT EXECUTED if (! PIPE_LOCK(pipe)) return -EINTR; if (pipe->Readers == 0) { ret = -EPIPE; 11226c: bf e0 ff ff ff mov $0xffffffe0,%edi const void *buffer, size_t count, rtems_libio_t *iop ) { int chunk, chunk1, written = 0, ret = 0; 112271: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) 112278: eb b2 jmp 11222c out_nolock: #ifdef RTEMS_POSIX_API /* Signal SIGPIPE */ if (ret == -EPIPE) kill(getpid(), SIGPIPE); 11227a: e8 21 08 00 00 call 112aa0 11227f: 83 ec 08 sub $0x8,%esp 112282: 6a 0d push $0xd 112284: 50 push %eax 112285: e8 1a 0b 00 00 call 112da4 11228a: 83 c4 10 add $0x10,%esp 11228d: eb b3 jmp 112242 PIPE_UNLOCK(pipe); if (! PIPE_WRITEWAIT(pipe)) ret = -EINTR; if (! PIPE_LOCK(pipe)) { /* WARN waitingWriters not restored! */ ret = -EINTR; 11228f: bf fc ff ff ff mov $0xfffffffc,%edi <== NOT EXECUTED 112294: eb ac jmp 112242 <== NOT EXECUTED chunk = count <= pipe->Size ? count : 1; while (written < count) { while (PIPE_SPACE(pipe) < chunk) { if (LIBIO_NODELAY(iop)) { ret = -EAGAIN; 112296: bf f5 ff ff ff mov $0xfffffff5,%edi 11229b: eb 8f jmp 11222c if (chunk > chunk1) { memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1); memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1); } else memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk); 11229d: 03 13 add (%ebx),%edx 11229f: 8b 75 0c mov 0xc(%ebp),%esi 1122a2: 03 75 d0 add -0x30(%ebp),%esi 1122a5: 89 d7 mov %edx,%edi 1122a7: 8b 4d cc mov -0x34(%ebp),%ecx 1122aa: f3 a4 rep movsb %ds:(%esi),%es:(%edi) 1122ac: e9 44 ff ff ff jmp 1121f5 pipe->Length += chunk; if (pipe->waitingReaders > 0) PIPE_WAKEUPREADERS(pipe); 1122b1: 56 push %esi 1122b2: 56 push %esi 1122b3: 8d 45 e4 lea -0x1c(%ebp),%eax 1122b6: 50 push %eax 1122b7: ff 73 2c pushl 0x2c(%ebx) 1122ba: e8 71 15 00 00 call 113830 1122bf: 83 c4 10 add $0x10,%esp 1122c2: e9 3e ff ff ff jmp 112205 } /* Write of PIPE_BUF bytes or less shall not be interleaved */ chunk = count <= pipe->Size ? count : 1; while (written < count) { 1122c7: 31 ff xor %edi,%edi 1122c9: e9 5e ff ff ff jmp 11222c =============================================================================== 0010bad0 : int posix_memalign( void **pointer, size_t alignment, size_t size ) { 10bad0: 55 push %ebp 10bad1: 89 e5 mov %esp,%ebp 10bad3: 53 push %ebx 10bad4: 83 ec 04 sub $0x4,%esp 10bad7: 8b 45 0c mov 0xc(%ebp),%eax /* * Update call statistics */ MSBUMP(memalign_calls, 1); 10bada: ff 05 88 f1 12 00 incl 0x12f188 if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *))) 10bae0: 8d 50 ff lea -0x1(%eax),%edx 10bae3: 85 c2 test %eax,%edx 10bae5: 75 05 jne 10baec <== NEVER TAKEN 10bae7: 83 f8 03 cmp $0x3,%eax 10baea: 77 0c ja 10baf8 /* * rtems_memalign does all of the error checking work EXCEPT * for adding restrictionso on the alignment. */ return rtems_memalign( pointer, alignment, size ); } 10baec: b8 16 00 00 00 mov $0x16,%eax 10baf1: 5a pop %edx 10baf2: 5b pop %ebx 10baf3: c9 leave 10baf4: c3 ret 10baf5: 8d 76 00 lea 0x0(%esi),%esi 10baf8: 59 pop %ecx 10baf9: 5b pop %ebx 10bafa: c9 leave /* * rtems_memalign does all of the error checking work EXCEPT * for adding restrictionso on the alignment. */ return rtems_memalign( pointer, alignment, size ); 10bafb: e9 78 01 00 00 jmp 10bc78 =============================================================================== 00110950 : #include int pthread_attr_destroy( pthread_attr_t *attr ) { 110950: 55 push %ebp 110951: 89 e5 mov %esp,%ebp 110953: 8b 45 08 mov 0x8(%ebp),%eax if ( !attr || !attr->is_initialized ) 110956: 85 c0 test %eax,%eax 110958: 74 12 je 11096c 11095a: 8b 10 mov (%eax),%edx 11095c: 85 d2 test %edx,%edx 11095e: 74 0c je 11096c return EINVAL; attr->is_initialized = false; 110960: c7 00 00 00 00 00 movl $0x0,(%eax) return 0; 110966: 31 c0 xor %eax,%eax } 110968: c9 leave 110969: c3 ret 11096a: 66 90 xchg %ax,%ax int pthread_attr_destroy( pthread_attr_t *attr ) { if ( !attr || !attr->is_initialized ) return EINVAL; 11096c: b8 16 00 00 00 mov $0x16,%eax attr->is_initialized = false; return 0; } 110971: c9 leave 110972: c3 ret =============================================================================== 00110ff0 : int pthread_attr_getcputime( pthread_attr_t *attr, int *clock_allowed ) { 110ff0: 55 push %ebp 110ff1: 89 e5 mov %esp,%ebp 110ff3: 8b 45 08 mov 0x8(%ebp),%eax 110ff6: 8b 55 0c mov 0xc(%ebp),%edx if ( !attr || !attr->is_initialized || !clock_allowed ) 110ff9: 85 c0 test %eax,%eax 110ffb: 74 13 je 111010 <== NEVER TAKEN 110ffd: 8b 08 mov (%eax),%ecx 110fff: 85 c9 test %ecx,%ecx 111001: 74 0d je 111010 111003: 85 d2 test %edx,%edx 111005: 74 09 je 111010 return EINVAL; *clock_allowed = attr->cputime_clock_allowed; 111007: 8b 40 38 mov 0x38(%eax),%eax 11100a: 89 02 mov %eax,(%edx) return 0; 11100c: 31 c0 xor %eax,%eax } 11100e: c9 leave 11100f: c3 ret pthread_attr_t *attr, int *clock_allowed ) { if ( !attr || !attr->is_initialized || !clock_allowed ) return EINVAL; 111010: b8 16 00 00 00 mov $0x16,%eax *clock_allowed = attr->cputime_clock_allowed; return 0; } 111015: c9 leave 111016: c3 ret =============================================================================== 00110a9c : int pthread_attr_getstack( const pthread_attr_t *attr, void **stackaddr, size_t *stacksize ) { 110a9c: 55 push %ebp 110a9d: 89 e5 mov %esp,%ebp 110a9f: 53 push %ebx 110aa0: 8b 45 08 mov 0x8(%ebp),%eax 110aa3: 8b 55 0c mov 0xc(%ebp),%edx 110aa6: 8b 4d 10 mov 0x10(%ebp),%ecx if ( !attr || !attr->is_initialized || !stackaddr || !stacksize ) 110aa9: 85 c0 test %eax,%eax 110aab: 74 1f je 110acc 110aad: 8b 18 mov (%eax),%ebx 110aaf: 85 db test %ebx,%ebx 110ab1: 74 19 je 110acc 110ab3: 85 d2 test %edx,%edx 110ab5: 74 15 je 110acc 110ab7: 85 c9 test %ecx,%ecx 110ab9: 74 11 je 110acc return EINVAL; *stackaddr = attr->stackaddr; 110abb: 8b 58 04 mov 0x4(%eax),%ebx 110abe: 89 1a mov %ebx,(%edx) *stacksize = attr->stacksize; 110ac0: 8b 40 08 mov 0x8(%eax),%eax 110ac3: 89 01 mov %eax,(%ecx) return 0; 110ac5: 31 c0 xor %eax,%eax } 110ac7: 5b pop %ebx 110ac8: c9 leave 110ac9: c3 ret 110aca: 66 90 xchg %ax,%ax void **stackaddr, size_t *stacksize ) { if ( !attr || !attr->is_initialized || !stackaddr || !stacksize ) return EINVAL; 110acc: b8 16 00 00 00 mov $0x16,%eax *stackaddr = attr->stackaddr; *stacksize = attr->stacksize; return 0; } 110ad1: 5b pop %ebx 110ad2: c9 leave 110ad3: c3 ret =============================================================================== 00110b50 : int pthread_attr_setguardsize( pthread_attr_t *attr, size_t guardsize ) { 110b50: 55 push %ebp 110b51: 89 e5 mov %esp,%ebp 110b53: 8b 45 08 mov 0x8(%ebp),%eax if ( !attr || !attr->is_initialized ) 110b56: 85 c0 test %eax,%eax 110b58: 74 12 je 110b6c 110b5a: 8b 10 mov (%eax),%edx 110b5c: 85 d2 test %edx,%edx 110b5e: 74 0c je 110b6c return EINVAL; attr->guardsize = guardsize; 110b60: 8b 55 0c mov 0xc(%ebp),%edx 110b63: 89 50 34 mov %edx,0x34(%eax) return 0; 110b66: 31 c0 xor %eax,%eax } 110b68: c9 leave 110b69: c3 ret 110b6a: 66 90 xchg %ax,%ax pthread_attr_t *attr, size_t guardsize ) { if ( !attr || !attr->is_initialized ) return EINVAL; 110b6c: b8 16 00 00 00 mov $0x16,%eax attr->guardsize = guardsize; return 0; } 110b71: c9 leave 110b72: c3 ret =============================================================================== 00111b7c : int pthread_attr_setinheritsched( pthread_attr_t *attr, int inheritsched ) { 111b7c: 55 push %ebp 111b7d: 89 e5 mov %esp,%ebp 111b7f: 8b 45 08 mov 0x8(%ebp),%eax 111b82: 8b 55 0c mov 0xc(%ebp),%edx if ( !attr || !attr->is_initialized ) 111b85: 85 c0 test %eax,%eax 111b87: 74 1f je 111ba8 111b89: 8b 08 mov (%eax),%ecx 111b8b: 85 c9 test %ecx,%ecx 111b8d: 74 19 je 111ba8 return EINVAL; switch ( inheritsched ) { 111b8f: 8d 4a ff lea -0x1(%edx),%ecx 111b92: 83 f9 01 cmp $0x1,%ecx 111b95: 76 09 jbe 111ba0 case PTHREAD_EXPLICIT_SCHED: attr->inheritsched = inheritsched; return 0; default: return ENOTSUP; 111b97: b8 86 00 00 00 mov $0x86,%eax } } 111b9c: c9 leave 111b9d: c3 ret 111b9e: 66 90 xchg %ax,%ax return EINVAL; switch ( inheritsched ) { case PTHREAD_INHERIT_SCHED: case PTHREAD_EXPLICIT_SCHED: attr->inheritsched = inheritsched; 111ba0: 89 50 10 mov %edx,0x10(%eax) return 0; 111ba3: 31 c0 xor %eax,%eax default: return ENOTSUP; } } 111ba5: c9 leave 111ba6: c3 ret 111ba7: 90 nop pthread_attr_t *attr, int inheritsched ) { if ( !attr || !attr->is_initialized ) return EINVAL; 111ba8: b8 16 00 00 00 mov $0x16,%eax return 0; default: return ENOTSUP; } } 111bad: c9 leave 111bae: c3 ret =============================================================================== 00110ba8 : int pthread_attr_setschedparam( pthread_attr_t *attr, const struct sched_param *param ) { 110ba8: 55 push %ebp 110ba9: 89 e5 mov %esp,%ebp 110bab: 57 push %edi 110bac: 56 push %esi 110bad: 8b 7d 08 mov 0x8(%ebp),%edi 110bb0: 8b 75 0c mov 0xc(%ebp),%esi if ( !attr || !attr->is_initialized || !param ) 110bb3: 85 ff test %edi,%edi 110bb5: 74 1d je 110bd4 110bb7: 8b 07 mov (%edi),%eax 110bb9: 85 c0 test %eax,%eax 110bbb: 74 17 je 110bd4 110bbd: 85 f6 test %esi,%esi 110bbf: 74 13 je 110bd4 return EINVAL; attr->schedparam = *param; 110bc1: 83 c7 18 add $0x18,%edi 110bc4: b9 07 00 00 00 mov $0x7,%ecx 110bc9: f3 a5 rep movsl %ds:(%esi),%es:(%edi) return 0; 110bcb: 31 c0 xor %eax,%eax } 110bcd: 5e pop %esi 110bce: 5f pop %edi 110bcf: c9 leave 110bd0: c3 ret 110bd1: 8d 76 00 lea 0x0(%esi),%esi pthread_attr_t *attr, const struct sched_param *param ) { if ( !attr || !attr->is_initialized || !param ) return EINVAL; 110bd4: b8 16 00 00 00 mov $0x16,%eax attr->schedparam = *param; return 0; } 110bd9: 5e pop %esi 110bda: 5f pop %edi 110bdb: c9 leave 110bdc: c3 ret =============================================================================== 00110be0 : int pthread_attr_setschedpolicy( pthread_attr_t *attr, int policy ) { 110be0: 55 push %ebp 110be1: 89 e5 mov %esp,%ebp 110be3: 8b 45 08 mov 0x8(%ebp),%eax 110be6: 8b 55 0c mov 0xc(%ebp),%edx if ( !attr || !attr->is_initialized ) 110be9: 85 c0 test %eax,%eax 110beb: 74 23 je 110c10 110bed: 8b 08 mov (%eax),%ecx 110bef: 85 c9 test %ecx,%ecx 110bf1: 74 1d je 110c10 return EINVAL; switch ( policy ) { 110bf3: 85 d2 test %edx,%edx 110bf5: 78 0a js 110c01 110bf7: 83 fa 02 cmp $0x2,%edx 110bfa: 7e 0c jle 110c08 110bfc: 83 fa 04 cmp $0x4,%edx 110bff: 74 07 je 110c08 <== ALWAYS TAKEN case SCHED_SPORADIC: attr->schedpolicy = policy; return 0; default: return ENOTSUP; 110c01: b8 86 00 00 00 mov $0x86,%eax } } 110c06: c9 leave 110c07: c3 ret switch ( policy ) { case SCHED_OTHER: case SCHED_FIFO: case SCHED_RR: case SCHED_SPORADIC: attr->schedpolicy = policy; 110c08: 89 50 14 mov %edx,0x14(%eax) return 0; 110c0b: 31 c0 xor %eax,%eax default: return ENOTSUP; } } 110c0d: c9 leave 110c0e: c3 ret 110c0f: 90 nop pthread_attr_t *attr, int policy ) { if ( !attr || !attr->is_initialized ) return EINVAL; 110c10: b8 16 00 00 00 mov $0x16,%eax return 0; default: return ENOTSUP; } } 110c15: c9 leave 110c16: c3 ret =============================================================================== 00110c18 : int pthread_attr_setscope( pthread_attr_t *attr, int contentionscope ) { 110c18: 55 push %ebp 110c19: 89 e5 mov %esp,%ebp 110c1b: 8b 45 08 mov 0x8(%ebp),%eax 110c1e: 8b 55 0c mov 0xc(%ebp),%edx if ( !attr || !attr->is_initialized ) 110c21: 85 c0 test %eax,%eax 110c23: 74 1a je 110c3f 110c25: 8b 08 mov (%eax),%ecx 110c27: 85 c9 test %ecx,%ecx 110c29: 74 14 je 110c3f return EINVAL; switch ( contentionscope ) { 110c2b: 85 d2 test %edx,%edx 110c2d: 75 0d jne 110c3c case PTHREAD_SCOPE_PROCESS: attr->contentionscope = contentionscope; 110c2f: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) return 0; 110c36: 31 c0 xor %eax,%eax return ENOTSUP; default: return EINVAL; } } 110c38: c9 leave 110c39: c3 ret 110c3a: 66 90 xchg %ax,%ax ) { if ( !attr || !attr->is_initialized ) return EINVAL; switch ( contentionscope ) { 110c3c: 4a dec %edx 110c3d: 74 09 je 110c48 case PTHREAD_SCOPE_SYSTEM: return ENOTSUP; default: return EINVAL; 110c3f: b8 16 00 00 00 mov $0x16,%eax } } 110c44: c9 leave 110c45: c3 ret 110c46: 66 90 xchg %ax,%ax case PTHREAD_SCOPE_PROCESS: attr->contentionscope = contentionscope; return 0; case PTHREAD_SCOPE_SYSTEM: return ENOTSUP; 110c48: b8 86 00 00 00 mov $0x86,%eax default: return EINVAL; } } 110c4d: c9 leave 110c4e: c3 ret =============================================================================== 00110c74 : int pthread_attr_setstack( pthread_attr_t *attr, void *stackaddr, size_t stacksize ) { 110c74: 55 push %ebp 110c75: 89 e5 mov %esp,%ebp 110c77: 8b 45 08 mov 0x8(%ebp),%eax 110c7a: 8b 55 10 mov 0x10(%ebp),%edx if ( !attr || !attr->is_initialized ) 110c7d: 85 c0 test %eax,%eax 110c7f: 74 27 je 110ca8 110c81: 8b 08 mov (%eax),%ecx 110c83: 85 c9 test %ecx,%ecx 110c85: 74 21 je 110ca8 return EINVAL; if (stacksize < PTHREAD_MINIMUM_STACK_SIZE) 110c87: 8b 0d 18 e4 12 00 mov 0x12e418,%ecx 110c8d: d1 e1 shl %ecx 110c8f: 39 d1 cmp %edx,%ecx 110c91: 77 0d ja 110ca0 attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE; else attr->stacksize = stacksize; 110c93: 89 50 08 mov %edx,0x8(%eax) attr->stackaddr = stackaddr; 110c96: 8b 55 0c mov 0xc(%ebp),%edx 110c99: 89 50 04 mov %edx,0x4(%eax) return 0; 110c9c: 31 c0 xor %eax,%eax } 110c9e: c9 leave 110c9f: c3 ret { if ( !attr || !attr->is_initialized ) return EINVAL; if (stacksize < PTHREAD_MINIMUM_STACK_SIZE) attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE; 110ca0: 89 48 08 mov %ecx,0x8(%eax) 110ca3: eb f1 jmp 110c96 110ca5: 8d 76 00 lea 0x0(%esi),%esi void *stackaddr, size_t stacksize ) { if ( !attr || !attr->is_initialized ) return EINVAL; 110ca8: b8 16 00 00 00 mov $0x16,%eax else attr->stacksize = stacksize; attr->stackaddr = stackaddr; return 0; } 110cad: c9 leave 110cae: c3 ret =============================================================================== 00110c50 : int pthread_attr_setstackaddr( pthread_attr_t *attr, void *stackaddr ) { 110c50: 55 push %ebp 110c51: 89 e5 mov %esp,%ebp 110c53: 8b 45 08 mov 0x8(%ebp),%eax if ( !attr || !attr->is_initialized ) 110c56: 85 c0 test %eax,%eax 110c58: 74 12 je 110c6c 110c5a: 8b 10 mov (%eax),%edx 110c5c: 85 d2 test %edx,%edx 110c5e: 74 0c je 110c6c return EINVAL; attr->stackaddr = stackaddr; 110c60: 8b 55 0c mov 0xc(%ebp),%edx 110c63: 89 50 04 mov %edx,0x4(%eax) return 0; 110c66: 31 c0 xor %eax,%eax } 110c68: c9 leave 110c69: c3 ret 110c6a: 66 90 xchg %ax,%ax pthread_attr_t *attr, void *stackaddr ) { if ( !attr || !attr->is_initialized ) return EINVAL; 110c6c: b8 16 00 00 00 mov $0x16,%eax attr->stackaddr = stackaddr; return 0; } 110c71: c9 leave 110c72: c3 ret =============================================================================== 00111bb0 : int pthread_attr_setstacksize( pthread_attr_t *attr, size_t stacksize ) { 111bb0: 55 push %ebp 111bb1: 89 e5 mov %esp,%ebp 111bb3: 8b 45 08 mov 0x8(%ebp),%eax 111bb6: 8b 55 0c mov 0xc(%ebp),%edx if ( !attr || !attr->is_initialized ) 111bb9: 85 c0 test %eax,%eax 111bbb: 74 23 je 111be0 111bbd: 8b 08 mov (%eax),%ecx 111bbf: 85 c9 test %ecx,%ecx 111bc1: 74 1d je 111be0 return EINVAL; if (stacksize < PTHREAD_MINIMUM_STACK_SIZE) 111bc3: 8b 0d 98 4d 12 00 mov 0x124d98,%ecx 111bc9: d1 e1 shl %ecx 111bcb: 39 d1 cmp %edx,%ecx 111bcd: 77 09 ja 111bd8 attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE; else attr->stacksize = stacksize; 111bcf: 89 50 08 mov %edx,0x8(%eax) return 0; 111bd2: 31 c0 xor %eax,%eax } 111bd4: c9 leave 111bd5: c3 ret 111bd6: 66 90 xchg %ax,%ax { if ( !attr || !attr->is_initialized ) return EINVAL; if (stacksize < PTHREAD_MINIMUM_STACK_SIZE) attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE; 111bd8: 89 48 08 mov %ecx,0x8(%eax) else attr->stacksize = stacksize; return 0; 111bdb: 31 c0 xor %eax,%eax } 111bdd: c9 leave 111bde: c3 ret 111bdf: 90 nop pthread_attr_t *attr, size_t stacksize ) { if ( !attr || !attr->is_initialized ) return EINVAL; 111be0: b8 16 00 00 00 mov $0x16,%eax if (stacksize < PTHREAD_MINIMUM_STACK_SIZE) attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE; else attr->stacksize = stacksize; return 0; } 111be5: c9 leave 111be6: c3 ret =============================================================================== 0010b99c : int pthread_barrier_init( pthread_barrier_t *barrier, const pthread_barrierattr_t *attr, unsigned int count ) { 10b99c: 55 push %ebp 10b99d: 89 e5 mov %esp,%ebp 10b99f: 57 push %edi 10b9a0: 56 push %esi 10b9a1: 53 push %ebx 10b9a2: 83 ec 2c sub $0x2c,%esp 10b9a5: 8b 5d 08 mov 0x8(%ebp),%ebx 10b9a8: 8b 7d 0c mov 0xc(%ebp),%edi 10b9ab: 8b 75 10 mov 0x10(%ebp),%esi const pthread_barrierattr_t *the_attr; /* * Error check parameters */ if ( !barrier ) 10b9ae: 85 db test %ebx,%ebx 10b9b0: 0f 84 82 00 00 00 je 10ba38 return EINVAL; if ( count == 0 ) 10b9b6: 85 f6 test %esi,%esi 10b9b8: 74 7e je 10ba38 return EINVAL; /* * If the user passed in NULL, use the default attributes */ if ( attr ) { 10b9ba: 85 ff test %edi,%edi 10b9bc: 0f 84 92 00 00 00 je 10ba54 } /* * Now start error checking the attributes that we are going to use */ if ( !the_attr->is_initialized ) 10b9c2: 8b 17 mov (%edi),%edx 10b9c4: 85 d2 test %edx,%edx 10b9c6: 74 70 je 10ba38 return EINVAL; switch ( the_attr->process_shared ) { 10b9c8: 8b 47 04 mov 0x4(%edi),%eax 10b9cb: 85 c0 test %eax,%eax 10b9cd: 75 69 jne 10ba38 <== NEVER TAKEN } /* * Convert from POSIX attributes to Core Barrier attributes */ the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; 10b9cf: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) the_attributes.maximum_count = count; 10b9d6: 89 75 e4 mov %esi,-0x1c(%ebp) rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10b9d9: a1 90 85 12 00 mov 0x128590,%eax 10b9de: 40 inc %eax 10b9df: a3 90 85 12 00 mov %eax,0x128590 * the inactive chain of free barrier control blocks. */ RTEMS_INLINE_ROUTINE POSIX_Barrier_Control *_POSIX_Barrier_Allocate( void ) { return (POSIX_Barrier_Control *) _Objects_Allocate( &_POSIX_Barrier_Information ); 10b9e4: 83 ec 0c sub $0xc,%esp 10b9e7: 68 a0 89 12 00 push $0x1289a0 10b9ec: e8 f7 20 00 00 call 10dae8 <_Objects_Allocate> */ _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _POSIX_Barrier_Allocate(); if ( !the_barrier ) { 10b9f1: 83 c4 10 add $0x10,%esp 10b9f4: 85 c0 test %eax,%eax 10b9f6: 74 50 je 10ba48 _Thread_Enable_dispatch(); return EAGAIN; } _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 10b9f8: 83 ec 08 sub $0x8,%esp 10b9fb: 8d 55 e0 lea -0x20(%ebp),%edx 10b9fe: 52 push %edx 10b9ff: 8d 50 10 lea 0x10(%eax),%edx 10ba02: 52 push %edx 10ba03: 89 45 d4 mov %eax,-0x2c(%ebp) 10ba06: e8 d9 16 00 00 call 10d0e4 <_CORE_barrier_Initialize> uint32_t name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10ba0b: 8b 45 d4 mov -0x2c(%ebp),%eax 10ba0e: 8b 50 08 mov 0x8(%eax),%edx Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 10ba11: 0f b7 f2 movzwl %dx,%esi #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10ba14: 8b 0d bc 89 12 00 mov 0x1289bc,%ecx 10ba1a: 89 04 b1 mov %eax,(%ecx,%esi,4) _Objects_Get_index( the_object->id ), the_object ); /* ASSERT: information->is_string == false */ the_object->name.name_u32 = name; 10ba1d: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) ); /* * Exit the critical section and return the user an operational barrier */ *barrier = the_barrier->Object.id; 10ba24: 89 13 mov %edx,(%ebx) _Thread_Enable_dispatch(); 10ba26: e8 e9 30 00 00 call 10eb14 <_Thread_Enable_dispatch> return 0; 10ba2b: 83 c4 10 add $0x10,%esp 10ba2e: 31 c0 xor %eax,%eax } 10ba30: 8d 65 f4 lea -0xc(%ebp),%esp 10ba33: 5b pop %ebx 10ba34: 5e pop %esi 10ba35: 5f pop %edi 10ba36: c9 leave 10ba37: c3 ret switch ( the_attr->process_shared ) { case PTHREAD_PROCESS_PRIVATE: /* only supported values */ break; case PTHREAD_PROCESS_SHARED: default: return EINVAL; 10ba38: b8 16 00 00 00 mov $0x16,%eax * Exit the critical section and return the user an operational barrier */ *barrier = the_barrier->Object.id; _Thread_Enable_dispatch(); return 0; } 10ba3d: 8d 65 f4 lea -0xc(%ebp),%esp 10ba40: 5b pop %ebx 10ba41: 5e pop %esi 10ba42: 5f pop %edi 10ba43: c9 leave 10ba44: c3 ret 10ba45: 8d 76 00 lea 0x0(%esi),%esi _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _POSIX_Barrier_Allocate(); if ( !the_barrier ) { _Thread_Enable_dispatch(); 10ba48: e8 c7 30 00 00 call 10eb14 <_Thread_Enable_dispatch> return EAGAIN; 10ba4d: b8 0b 00 00 00 mov $0xb,%eax 10ba52: eb e9 jmp 10ba3d * If the user passed in NULL, use the default attributes */ if ( attr ) { the_attr = attr; } else { (void) pthread_barrierattr_init( &my_attr ); 10ba54: 83 ec 0c sub $0xc,%esp 10ba57: 8d 7d d8 lea -0x28(%ebp),%edi 10ba5a: 57 push %edi 10ba5b: e8 7c fe ff ff call 10b8dc 10ba60: 83 c4 10 add $0x10,%esp 10ba63: e9 5a ff ff ff jmp 10b9c2 =============================================================================== 0010ba68 : */ int pthread_barrier_wait( pthread_barrier_t *barrier ) { 10ba68: 55 push %ebp 10ba69: 89 e5 mov %esp,%ebp 10ba6b: 83 ec 18 sub $0x18,%esp 10ba6e: 8b 45 08 mov 0x8(%ebp),%eax POSIX_Barrier_Control *the_barrier = NULL; Objects_Locations location; if ( !barrier ) 10ba71: 85 c0 test %eax,%eax 10ba73: 74 4f je 10bac4 RTEMS_INLINE_ROUTINE POSIX_Barrier_Control *_POSIX_Barrier_Get ( pthread_barrier_t *barrier, Objects_Locations *location ) { return (POSIX_Barrier_Control *) _Objects_Get( 10ba75: 51 push %ecx return EINVAL; the_barrier = _POSIX_Barrier_Get( barrier, &location ); 10ba76: 8d 55 f4 lea -0xc(%ebp),%edx 10ba79: 52 push %edx 10ba7a: ff 30 pushl (%eax) 10ba7c: 68 a0 89 12 00 push $0x1289a0 10ba81: e8 16 25 00 00 call 10df9c <_Objects_Get> switch ( location ) { 10ba86: 83 c4 10 add $0x10,%esp 10ba89: 8b 55 f4 mov -0xc(%ebp),%edx 10ba8c: 85 d2 test %edx,%edx 10ba8e: 75 34 jne 10bac4 case OBJECTS_LOCAL: _CORE_barrier_Wait( 10ba90: 83 ec 0c sub $0xc,%esp 10ba93: 6a 00 push $0x0 10ba95: 6a 00 push $0x0 10ba97: 6a 01 push $0x1 10ba99: ff 70 08 pushl 0x8(%eax) 10ba9c: 83 c0 10 add $0x10,%eax 10ba9f: 50 push %eax 10baa0: e8 73 16 00 00 call 10d118 <_CORE_barrier_Wait> the_barrier->Object.id, true, 0, NULL ); _Thread_Enable_dispatch(); 10baa5: 83 c4 20 add $0x20,%esp 10baa8: e8 67 30 00 00 call 10eb14 <_Thread_Enable_dispatch> return _POSIX_Barrier_Translate_core_barrier_return_code( 10baad: 83 ec 0c sub $0xc,%esp _Thread_Executing->Wait.return_code ); 10bab0: a1 38 8b 12 00 mov 0x128b38,%eax true, 0, NULL ); _Thread_Enable_dispatch(); return _POSIX_Barrier_Translate_core_barrier_return_code( 10bab5: ff 70 34 pushl 0x34(%eax) 10bab8: e8 07 5c 00 00 call 1116c4 <_POSIX_Barrier_Translate_core_barrier_return_code> 10babd: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return EINVAL; } 10bac0: c9 leave 10bac1: c3 ret 10bac2: 66 90 xchg %ax,%ax #endif case OBJECTS_ERROR: break; } return EINVAL; 10bac4: b8 16 00 00 00 mov $0x16,%eax } 10bac9: c9 leave 10baca: c3 ret =============================================================================== 0010b894 : */ int pthread_barrierattr_destroy( pthread_barrierattr_t *attr ) { 10b894: 55 push %ebp 10b895: 89 e5 mov %esp,%ebp 10b897: 8b 45 08 mov 0x8(%ebp),%eax if ( !attr || attr->is_initialized == false ) 10b89a: 85 c0 test %eax,%eax 10b89c: 74 12 je 10b8b0 10b89e: 8b 10 mov (%eax),%edx 10b8a0: 85 d2 test %edx,%edx 10b8a2: 74 0c je 10b8b0 return EINVAL; attr->is_initialized = false; 10b8a4: c7 00 00 00 00 00 movl $0x0,(%eax) return 0; 10b8aa: 31 c0 xor %eax,%eax } 10b8ac: c9 leave 10b8ad: c3 ret 10b8ae: 66 90 xchg %ax,%ax int pthread_barrierattr_destroy( pthread_barrierattr_t *attr ) { if ( !attr || attr->is_initialized == false ) return EINVAL; 10b8b0: b8 16 00 00 00 mov $0x16,%eax attr->is_initialized = false; return 0; } 10b8b5: c9 leave 10b8b6: c3 ret =============================================================================== 0010b134 : */ int pthread_cancel( pthread_t thread ) { 10b134: 55 push %ebp 10b135: 89 e5 mov %esp,%ebp 10b137: 83 ec 18 sub $0x18,%esp /* * Don't even think about deleting a resource from an ISR. */ if ( _ISR_Is_in_progress() ) 10b13a: a1 54 96 12 00 mov 0x129654,%eax 10b13f: 85 c0 test %eax,%eax 10b141: 74 09 je 10b14c return EPROTO; 10b143: b8 47 00 00 00 mov $0x47,%eax case OBJECTS_ERROR: break; } return EINVAL; } 10b148: c9 leave 10b149: c3 ret 10b14a: 66 90 xchg %ax,%ax pthread_t id, Objects_Locations *location ) { return (Thread_Control *) _Objects_Get( &_POSIX_Threads_Information, (Objects_Id)id, location ); 10b14c: 51 push %ecx */ if ( _ISR_Is_in_progress() ) return EPROTO; the_thread = _POSIX_Threads_Get( thread, &location ); 10b14d: 8d 45 f4 lea -0xc(%ebp),%eax 10b150: 50 push %eax 10b151: ff 75 08 pushl 0x8(%ebp) 10b154: 68 40 93 12 00 push $0x129340 10b159: e8 22 21 00 00 call 10d280 <_Objects_Get> switch ( location ) { 10b15e: 83 c4 10 add $0x10,%esp 10b161: 8b 55 f4 mov -0xc(%ebp),%edx 10b164: 85 d2 test %edx,%edx 10b166: 75 20 jne 10b188 case OBJECTS_LOCAL: thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ]; thread_support->cancelation_requested = 1; 10b168: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx 10b16e: c7 82 e0 00 00 00 01 movl $0x1,0xe0(%edx) 10b175: 00 00 00 /* This enables dispatch implicitly */ _POSIX_Thread_Evaluate_cancellation_and_enable_dispatch( the_thread ); 10b178: 83 ec 0c sub $0xc,%esp 10b17b: 50 push %eax 10b17c: e8 7b 55 00 00 call 1106fc <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch> return 0; 10b181: 83 c4 10 add $0x10,%esp 10b184: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return EINVAL; } 10b186: c9 leave 10b187: c3 ret #endif case OBJECTS_ERROR: break; } return EINVAL; 10b188: b8 16 00 00 00 mov $0x16,%eax } 10b18d: c9 leave 10b18e: c3 ret =============================================================================== 0010afb4 : */ void pthread_cleanup_pop( int execute ) { 10afb4: 55 push %ebp 10afb5: 89 e5 mov %esp,%ebp 10afb7: 57 push %edi 10afb8: 56 push %esi 10afb9: 53 push %ebx 10afba: 83 ec 0c sub $0xc,%esp 10afbd: 8b 75 08 mov 0x8(%ebp),%esi POSIX_Cancel_Handler_control tmp_handler; Chain_Control *handler_stack; POSIX_API_Control *thread_support; ISR_Level level; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 10afc0: a1 78 87 12 00 mov 0x128778,%eax 10afc5: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10afcb: 8b 15 d0 81 12 00 mov 0x1281d0,%edx 10afd1: 42 inc %edx 10afd2: 89 15 d0 81 12 00 mov %edx,0x1281d0 * ensure that we do not get prempted and deleted while we are holding * memory that needs to be freed. */ _Thread_Disable_dispatch(); _ISR_Disable( level ); 10afd8: 9c pushf 10afd9: fa cli 10afda: 5b pop %ebx RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 10afdb: 8d 90 e8 00 00 00 lea 0xe8(%eax),%edx if ( _Chain_Is_empty( handler_stack ) ) { 10afe1: 39 90 e4 00 00 00 cmp %edx,0xe4(%eax) 10afe7: 74 47 je 10b030 _Thread_Enable_dispatch(); _ISR_Enable( level ); return; } handler = (POSIX_Cancel_Handler_control *) 10afe9: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 10afef: 8b 08 mov (%eax),%ecx previous = the_node->previous; 10aff1: 8b 50 04 mov 0x4(%eax),%edx next->previous = previous; 10aff4: 89 51 04 mov %edx,0x4(%ecx) previous->next = next; 10aff7: 89 0a mov %ecx,(%edx) _Chain_Tail( handler_stack )->previous; _Chain_Extract_unprotected( &handler->Node ); _ISR_Enable( level ); 10aff9: 53 push %ebx 10affa: 9d popf 10affb: 8b 58 08 mov 0x8(%eax),%ebx 10affe: 8b 78 0c mov 0xc(%eax),%edi tmp_handler = *handler; _Workspace_Free( handler ); 10b001: 83 ec 0c sub $0xc,%esp 10b004: 50 push %eax 10b005: e8 62 3a 00 00 call 10ea6c <_Workspace_Free> _Thread_Enable_dispatch(); 10b00a: e8 69 2a 00 00 call 10da78 <_Thread_Enable_dispatch> if ( execute ) 10b00f: 83 c4 10 add $0x10,%esp 10b012: 85 f6 test %esi,%esi 10b014: 75 0a jne 10b020 (*tmp_handler.routine)( tmp_handler.arg ); } 10b016: 8d 65 f4 lea -0xc(%ebp),%esp 10b019: 5b pop %ebx 10b01a: 5e pop %esi 10b01b: 5f pop %edi 10b01c: c9 leave 10b01d: c3 ret 10b01e: 66 90 xchg %ax,%ax _Workspace_Free( handler ); _Thread_Enable_dispatch(); if ( execute ) (*tmp_handler.routine)( tmp_handler.arg ); 10b020: 89 7d 08 mov %edi,0x8(%ebp) 10b023: 89 d8 mov %ebx,%eax } 10b025: 8d 65 f4 lea -0xc(%ebp),%esp 10b028: 5b pop %ebx 10b029: 5e pop %esi 10b02a: 5f pop %edi 10b02b: c9 leave _Workspace_Free( handler ); _Thread_Enable_dispatch(); if ( execute ) (*tmp_handler.routine)( tmp_handler.arg ); 10b02c: ff e0 jmp *%eax 10b02e: 66 90 xchg %ax,%ax _Thread_Disable_dispatch(); _ISR_Disable( level ); if ( _Chain_Is_empty( handler_stack ) ) { _Thread_Enable_dispatch(); 10b030: e8 43 2a 00 00 call 10da78 <_Thread_Enable_dispatch> _ISR_Enable( level ); 10b035: 53 push %ebx 10b036: 9d popf _Thread_Enable_dispatch(); if ( execute ) (*tmp_handler.routine)( tmp_handler.arg ); } 10b037: 8d 65 f4 lea -0xc(%ebp),%esp 10b03a: 5b pop %ebx 10b03b: 5e pop %esi 10b03c: 5f pop %edi 10b03d: c9 leave 10b03e: c3 ret =============================================================================== 0010b360 : void pthread_cleanup_push( void (*routine)( void * ), void *arg ) { 10b360: 55 push %ebp 10b361: 89 e5 mov %esp,%ebp 10b363: 56 push %esi 10b364: 53 push %ebx 10b365: 8b 5d 08 mov 0x8(%ebp),%ebx 10b368: 8b 75 0c mov 0xc(%ebp),%esi /* * The POSIX standard does not address what to do when the routine * is NULL. It also does not address what happens when we cannot * allocate memory or anything else bad happens. */ if ( !routine ) 10b36b: 85 db test %ebx,%ebx 10b36d: 74 4d je 10b3bc rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10b36f: a1 30 98 12 00 mov 0x129830,%eax 10b374: 40 inc %eax 10b375: a3 30 98 12 00 mov %eax,0x129830 return; _Thread_Disable_dispatch(); handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) ); 10b37a: 83 ec 0c sub $0xc,%esp 10b37d: 6a 10 push $0x10 10b37f: e8 28 42 00 00 call 10f5ac <_Workspace_Allocate> if ( handler ) { 10b384: 83 c4 10 add $0x10,%esp 10b387: 85 c0 test %eax,%eax 10b389: 74 25 je 10b3b0 <== NEVER TAKEN thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 10b38b: 8b 15 d8 9d 12 00 mov 0x129dd8,%edx handler_stack = &thread_support->Cancellation_Handlers; 10b391: 8b 92 ec 00 00 00 mov 0xec(%edx),%edx 10b397: 81 c2 e4 00 00 00 add $0xe4,%edx handler->routine = routine; 10b39d: 89 58 08 mov %ebx,0x8(%eax) handler->arg = arg; 10b3a0: 89 70 0c mov %esi,0xc(%eax) _Chain_Append( handler_stack, &handler->Node ); 10b3a3: 83 ec 08 sub $0x8,%esp 10b3a6: 50 push %eax 10b3a7: 52 push %edx 10b3a8: e8 bf 17 00 00 call 10cb6c <_Chain_Append> 10b3ad: 83 c4 10 add $0x10,%esp } _Thread_Enable_dispatch(); } 10b3b0: 8d 65 f8 lea -0x8(%ebp),%esp 10b3b3: 5b pop %ebx 10b3b4: 5e pop %esi 10b3b5: c9 leave handler->routine = routine; handler->arg = arg; _Chain_Append( handler_stack, &handler->Node ); } _Thread_Enable_dispatch(); 10b3b6: e9 89 31 00 00 jmp 10e544 <_Thread_Enable_dispatch> 10b3bb: 90 nop } 10b3bc: 8d 65 f8 lea -0x8(%ebp),%esp 10b3bf: 5b pop %ebx 10b3c0: 5e pop %esi 10b3c1: c9 leave 10b3c2: c3 ret =============================================================================== 0010c054 : */ int pthread_cond_destroy( pthread_cond_t *cond ) { 10c054: 55 push %ebp 10c055: 89 e5 mov %esp,%ebp 10c057: 53 push %ebx 10c058: 83 ec 1c sub $0x1c,%esp POSIX_Condition_variables_Control *the_cond; Objects_Locations location; the_cond = _POSIX_Condition_variables_Get( cond, &location ); 10c05b: 8d 45 f4 lea -0xc(%ebp),%eax 10c05e: 50 push %eax 10c05f: ff 75 08 pushl 0x8(%ebp) 10c062: e8 65 00 00 00 call 10c0cc <_POSIX_Condition_variables_Get> 10c067: 89 c3 mov %eax,%ebx switch ( location ) { 10c069: 83 c4 10 add $0x10,%esp 10c06c: 8b 4d f4 mov -0xc(%ebp),%ecx 10c06f: 85 c9 test %ecx,%ecx 10c071: 75 25 jne 10c098 case OBJECTS_LOCAL: if ( _Thread_queue_First( &the_cond->Wait_queue ) ) { 10c073: 83 ec 0c sub $0xc,%esp 10c076: 8d 40 18 lea 0x18(%eax),%eax 10c079: 50 push %eax 10c07a: e8 3d 3e 00 00 call 10febc <_Thread_queue_First> 10c07f: 83 c4 10 add $0x10,%esp 10c082: 85 c0 test %eax,%eax 10c084: 74 1e je 10c0a4 _Thread_Enable_dispatch(); 10c086: e8 51 37 00 00 call 10f7dc <_Thread_Enable_dispatch> return EBUSY; 10c08b: b8 10 00 00 00 mov $0x10,%eax case OBJECTS_ERROR: break; } return EINVAL; } 10c090: 8b 5d fc mov -0x4(%ebp),%ebx 10c093: c9 leave 10c094: c3 ret 10c095: 8d 76 00 lea 0x0(%esi),%esi #endif case OBJECTS_ERROR: break; } return EINVAL; 10c098: b8 16 00 00 00 mov $0x16,%eax } 10c09d: 8b 5d fc mov -0x4(%ebp),%ebx 10c0a0: c9 leave 10c0a1: c3 ret 10c0a2: 66 90 xchg %ax,%ax if ( _Thread_queue_First( &the_cond->Wait_queue ) ) { _Thread_Enable_dispatch(); return EBUSY; } _Objects_Close( 10c0a4: 83 ec 08 sub $0x8,%esp 10c0a7: 53 push %ebx 10c0a8: 68 40 9a 12 00 push $0x129a40 10c0ad: e8 7a 27 00 00 call 10e82c <_Objects_Close> RTEMS_INLINE_ROUTINE void _POSIX_Condition_variables_Free ( POSIX_Condition_variables_Control *the_condition_variable ) { _Objects_Free( 10c0b2: 58 pop %eax 10c0b3: 5a pop %edx 10c0b4: 53 push %ebx 10c0b5: 68 40 9a 12 00 push $0x129a40 10c0ba: e8 65 2a 00 00 call 10eb24 <_Objects_Free> &_POSIX_Condition_variables_Information, &the_cond->Object ); _POSIX_Condition_variables_Free( the_cond ); _Thread_Enable_dispatch(); 10c0bf: e8 18 37 00 00 call 10f7dc <_Thread_Enable_dispatch> return 0; 10c0c4: 83 c4 10 add $0x10,%esp 10c0c7: 31 c0 xor %eax,%eax 10c0c9: eb d2 jmp 10c09d =============================================================================== 0010c120 : int pthread_cond_init( pthread_cond_t *cond, const pthread_condattr_t *attr ) { 10c120: 55 push %ebp 10c121: 89 e5 mov %esp,%ebp 10c123: 53 push %ebx 10c124: 83 ec 14 sub $0x14,%esp 10c127: 8b 5d 0c mov 0xc(%ebp),%ebx POSIX_Condition_variables_Control *the_cond; const pthread_condattr_t *the_attr; if ( attr ) the_attr = attr; 10c12a: 85 db test %ebx,%ebx 10c12c: 0f 84 86 00 00 00 je 10c1b8 else the_attr = &_POSIX_Condition_variables_Default_attributes; /* * Be careful about attributes when global!!! */ if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED ) 10c132: 83 7b 04 01 cmpl $0x1,0x4(%ebx) 10c136: 74 06 je 10c13e <== NEVER TAKEN return EINVAL; if ( !the_attr->is_initialized ) 10c138: 8b 03 mov (%ebx),%eax 10c13a: 85 c0 test %eax,%eax 10c13c: 75 0a jne 10c148 return EINVAL; 10c13e: b8 16 00 00 00 mov $0x16,%eax *cond = the_cond->Object.id; _Thread_Enable_dispatch(); return 0; } 10c143: 8b 5d fc mov -0x4(%ebp),%ebx 10c146: c9 leave 10c147: c3 ret rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10c148: a1 90 95 12 00 mov 0x129590,%eax 10c14d: 40 inc %eax 10c14e: a3 90 95 12 00 mov %eax,0x129590 RTEMS_INLINE_ROUTINE POSIX_Condition_variables_Control *_POSIX_Condition_variables_Allocate( void ) { return (POSIX_Condition_variables_Control *) _Objects_Allocate( &_POSIX_Condition_variables_Information ); 10c153: 83 ec 0c sub $0xc,%esp 10c156: 68 40 9a 12 00 push $0x129a40 10c15b: e8 50 26 00 00 call 10e7b0 <_Objects_Allocate> _Thread_Disable_dispatch(); the_cond = _POSIX_Condition_variables_Allocate(); if ( !the_cond ) { 10c160: 83 c4 10 add $0x10,%esp 10c163: 85 c0 test %eax,%eax 10c165: 74 5d je 10c1c4 _Thread_Enable_dispatch(); return ENOMEM; } the_cond->process_shared = the_attr->process_shared; 10c167: 8b 53 04 mov 0x4(%ebx),%edx 10c16a: 89 50 10 mov %edx,0x10(%eax) the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX; 10c16d: c7 40 14 00 00 00 00 movl $0x0,0x14(%eax) _Thread_queue_Initialize( 10c174: 6a 74 push $0x74 10c176: 68 00 08 00 10 push $0x10000800 10c17b: 6a 00 push $0x0 10c17d: 8d 50 18 lea 0x18(%eax),%edx 10c180: 52 push %edx 10c181: 89 45 f4 mov %eax,-0xc(%ebp) 10c184: e8 af 3d 00 00 call 10ff38 <_Thread_queue_Initialize> uint32_t name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10c189: 8b 45 f4 mov -0xc(%ebp),%eax 10c18c: 8b 50 08 mov 0x8(%eax),%edx Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 10c18f: 0f b7 da movzwl %dx,%ebx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10c192: 8b 0d 5c 9a 12 00 mov 0x129a5c,%ecx 10c198: 89 04 99 mov %eax,(%ecx,%ebx,4) _Objects_Get_index( the_object->id ), the_object ); /* ASSERT: information->is_string == false */ the_object->name.name_u32 = name; 10c19b: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) &_POSIX_Condition_variables_Information, &the_cond->Object, 0 ); *cond = the_cond->Object.id; 10c1a2: 8b 45 08 mov 0x8(%ebp),%eax 10c1a5: 89 10 mov %edx,(%eax) _Thread_Enable_dispatch(); 10c1a7: e8 30 36 00 00 call 10f7dc <_Thread_Enable_dispatch> return 0; 10c1ac: 83 c4 10 add $0x10,%esp 10c1af: 31 c0 xor %eax,%eax } 10c1b1: 8b 5d fc mov -0x4(%ebp),%ebx 10c1b4: c9 leave 10c1b5: c3 ret 10c1b6: 66 90 xchg %ax,%ax { POSIX_Condition_variables_Control *the_cond; const pthread_condattr_t *the_attr; if ( attr ) the_attr = attr; else the_attr = &_POSIX_Condition_variables_Default_attributes; 10c1b8: bb 3c 3b 12 00 mov $0x123b3c,%ebx 10c1bd: e9 70 ff ff ff jmp 10c132 10c1c2: 66 90 xchg %ax,%ax _Thread_Disable_dispatch(); the_cond = _POSIX_Condition_variables_Allocate(); if ( !the_cond ) { _Thread_Enable_dispatch(); 10c1c4: e8 13 36 00 00 call 10f7dc <_Thread_Enable_dispatch> return ENOMEM; 10c1c9: b8 0c 00 00 00 mov $0xc,%eax 10c1ce: e9 70 ff ff ff jmp 10c143 =============================================================================== 0010bfb0 : */ int pthread_condattr_destroy( pthread_condattr_t *attr ) { 10bfb0: 55 push %ebp 10bfb1: 89 e5 mov %esp,%ebp 10bfb3: 8b 45 08 mov 0x8(%ebp),%eax if ( !attr || attr->is_initialized == false ) 10bfb6: 85 c0 test %eax,%eax 10bfb8: 74 12 je 10bfcc 10bfba: 8b 10 mov (%eax),%edx 10bfbc: 85 d2 test %edx,%edx 10bfbe: 74 0c je 10bfcc <== NEVER TAKEN return EINVAL; attr->is_initialized = false; 10bfc0: c7 00 00 00 00 00 movl $0x0,(%eax) return 0; 10bfc6: 31 c0 xor %eax,%eax } 10bfc8: c9 leave 10bfc9: c3 ret 10bfca: 66 90 xchg %ax,%ax int pthread_condattr_destroy( pthread_condattr_t *attr ) { if ( !attr || attr->is_initialized == false ) return EINVAL; 10bfcc: b8 16 00 00 00 mov $0x16,%eax attr->is_initialized = false; return 0; } 10bfd1: c9 leave 10bfd2: c3 ret =============================================================================== 0010bfd4 : int pthread_condattr_getpshared( const pthread_condattr_t *attr, int *pshared ) { 10bfd4: 55 push %ebp 10bfd5: 89 e5 mov %esp,%ebp 10bfd7: 8b 45 08 mov 0x8(%ebp),%eax if ( !attr ) 10bfda: 85 c0 test %eax,%eax 10bfdc: 74 0e je 10bfec return EINVAL; *pshared = attr->process_shared; 10bfde: 8b 50 04 mov 0x4(%eax),%edx 10bfe1: 8b 45 0c mov 0xc(%ebp),%eax 10bfe4: 89 10 mov %edx,(%eax) return 0; 10bfe6: 31 c0 xor %eax,%eax } 10bfe8: c9 leave 10bfe9: c3 ret 10bfea: 66 90 xchg %ax,%ax const pthread_condattr_t *attr, int *pshared ) { if ( !attr ) return EINVAL; 10bfec: b8 16 00 00 00 mov $0x16,%eax *pshared = attr->process_shared; return 0; } 10bff1: c9 leave 10bff2: c3 ret =============================================================================== 0010bff4 : */ int pthread_condattr_init( pthread_condattr_t *attr ) { 10bff4: 55 push %ebp 10bff5: 89 e5 mov %esp,%ebp 10bff7: 8b 45 08 mov 0x8(%ebp),%eax if ( !attr ) 10bffa: 85 c0 test %eax,%eax 10bffc: 74 16 je 10c014 <== NEVER TAKEN return EINVAL; *attr = _POSIX_Condition_variables_Default_attributes; 10bffe: 8b 15 3c 3b 12 00 mov 0x123b3c,%edx 10c004: 8b 0d 40 3b 12 00 mov 0x123b40,%ecx 10c00a: 89 10 mov %edx,(%eax) 10c00c: 89 48 04 mov %ecx,0x4(%eax) return 0; 10c00f: 31 c0 xor %eax,%eax } 10c011: c9 leave 10c012: c3 ret 10c013: 90 nop int pthread_condattr_init( pthread_condattr_t *attr ) { if ( !attr ) return EINVAL; 10c014: b8 16 00 00 00 mov $0x16,%eax *attr = _POSIX_Condition_variables_Default_attributes; return 0; } 10c019: c9 leave 10c01a: c3 ret =============================================================================== 0010c01c : int pthread_condattr_setpshared( pthread_condattr_t *attr, int pshared ) { 10c01c: 55 push %ebp 10c01d: 89 e5 mov %esp,%ebp 10c01f: 8b 45 08 mov 0x8(%ebp),%eax 10c022: 8b 55 0c mov 0xc(%ebp),%edx if ( !attr ) 10c025: 85 c0 test %eax,%eax 10c027: 74 05 je 10c02e return EINVAL; switch ( pshared ) { 10c029: 83 fa 01 cmp $0x1,%edx 10c02c: 76 0a jbe 10c038 case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; return 0; default: return EINVAL; 10c02e: b8 16 00 00 00 mov $0x16,%eax } } 10c033: c9 leave 10c034: c3 ret 10c035: 8d 76 00 lea 0x0(%esi),%esi return EINVAL; switch ( pshared ) { case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; 10c038: 89 50 04 mov %edx,0x4(%eax) return 0; 10c03b: 31 c0 xor %eax,%eax default: return EINVAL; } } 10c03d: c9 leave 10c03e: c3 ret =============================================================================== 0010b6d8 : pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)( void * ), void *arg ) { 10b6d8: 55 push %ebp 10b6d9: 89 e5 mov %esp,%ebp 10b6db: 57 push %edi 10b6dc: 56 push %esi 10b6dd: 53 push %ebx 10b6de: 83 ec 5c sub $0x5c,%esp 10b6e1: 8b 5d 0c mov 0xc(%ebp),%ebx int schedpolicy = SCHED_RR; struct sched_param schedparam; Objects_Name name; int rc; if ( !start_routine ) 10b6e4: 8b 75 10 mov 0x10(%ebp),%esi 10b6e7: 85 f6 test %esi,%esi 10b6e9: 0f 84 8d 01 00 00 je 10b87c return EFAULT; the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes; 10b6ef: 85 db test %ebx,%ebx 10b6f1: 74 65 je 10b758 if ( !the_attr->is_initialized ) 10b6f3: 8b 0b mov (%ebx),%ecx 10b6f5: 85 c9 test %ecx,%ecx 10b6f7: 74 1e je 10b717 * stack space if it is allowed to allocate it itself. * * NOTE: If the user provides the stack we will let it drop below * twice the minimum. */ if ( the_attr->stackaddr && !_Stack_Is_enough(the_attr->stacksize) ) 10b6f9: 8b 53 04 mov 0x4(%ebx),%edx 10b6fc: 85 d2 test %edx,%edx 10b6fe: 74 0a je 10b70a 10b700: a1 98 4d 12 00 mov 0x124d98,%eax 10b705: 39 43 08 cmp %eax,0x8(%ebx) 10b708: 72 0d jb 10b717 * If inheritsched is set to PTHREAD_INHERIT_SCHED, then this thread * inherits scheduling attributes from the creating thread. If it is * PTHREAD_EXPLICIT_SCHED, then scheduling parameters come from the * attributes structure. */ switch ( the_attr->inheritsched ) { 10b70a: 8b 43 10 mov 0x10(%ebx),%eax 10b70d: 83 f8 01 cmp $0x1,%eax 10b710: 74 4e je 10b760 10b712: 83 f8 02 cmp $0x2,%eax 10b715: 74 11 je 10b728 /* * Interpret the scheduling parameters. */ if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) ) return EINVAL; 10b717: ba 16 00 00 00 mov $0x16,%edx */ *thread = the_thread->Object.id; _RTEMS_Unlock_allocator(); return 0; } 10b71c: 89 d0 mov %edx,%eax 10b71e: 8d 65 f4 lea -0xc(%ebp),%esp 10b721: 5b pop %ebx 10b722: 5e pop %esi 10b723: 5f pop %edi 10b724: c9 leave 10b725: c3 ret 10b726: 66 90 xchg %ax,%ax schedpolicy = api->schedpolicy; schedparam = api->schedparam; break; case PTHREAD_EXPLICIT_SCHED: schedpolicy = the_attr->schedpolicy; 10b728: 8b 4b 14 mov 0x14(%ebx),%ecx 10b72b: 89 4d b0 mov %ecx,-0x50(%ebp) schedparam = the_attr->schedparam; 10b72e: 8d 45 c4 lea -0x3c(%ebp),%eax 10b731: 89 45 b4 mov %eax,-0x4c(%ebp) 10b734: 8d 73 18 lea 0x18(%ebx),%esi 10b737: b9 07 00 00 00 mov $0x7,%ecx 10b73c: 89 c7 mov %eax,%edi 10b73e: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* * Check the contentionscope since rtems only supports PROCESS wide * contention (i.e. no system wide contention). */ if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS ) 10b740: 8b 43 0c mov 0xc(%ebx),%eax 10b743: 85 c0 test %eax,%eax 10b745: 74 49 je 10b790 <== ALWAYS TAKEN return ENOTSUP; 10b747: ba 86 00 00 00 mov $0x86,%edx */ *thread = the_thread->Object.id; _RTEMS_Unlock_allocator(); return 0; } 10b74c: 89 d0 mov %edx,%eax 10b74e: 8d 65 f4 lea -0xc(%ebp),%esp 10b751: 5b pop %ebx 10b752: 5e pop %esi 10b753: 5f pop %edi 10b754: c9 leave 10b755: c3 ret 10b756: 66 90 xchg %ax,%ax int rc; if ( !start_routine ) return EFAULT; the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes; 10b758: bb 00 27 12 00 mov $0x122700,%ebx 10b75d: eb 94 jmp 10b6f3 10b75f: 90 nop * PTHREAD_EXPLICIT_SCHED, then scheduling parameters come from the * attributes structure. */ switch ( the_attr->inheritsched ) { case PTHREAD_INHERIT_SCHED: api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 10b760: a1 38 96 12 00 mov 0x129638,%eax 10b765: 8b b0 ec 00 00 00 mov 0xec(%eax),%esi schedpolicy = api->schedpolicy; 10b76b: 8b 8e 84 00 00 00 mov 0x84(%esi),%ecx 10b771: 89 4d b0 mov %ecx,-0x50(%ebp) schedparam = api->schedparam; 10b774: 8d 45 c4 lea -0x3c(%ebp),%eax 10b777: 89 45 b4 mov %eax,-0x4c(%ebp) 10b77a: 81 c6 88 00 00 00 add $0x88,%esi 10b780: b9 07 00 00 00 mov $0x7,%ecx 10b785: 89 c7 mov %eax,%edi 10b787: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* * Check the contentionscope since rtems only supports PROCESS wide * contention (i.e. no system wide contention). */ if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS ) 10b789: 8b 43 0c mov 0xc(%ebx),%eax 10b78c: 85 c0 test %eax,%eax 10b78e: 75 b7 jne 10b747 return ENOTSUP; /* * Interpret the scheduling parameters. */ if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) ) 10b790: 83 ec 0c sub $0xc,%esp 10b793: ff 75 c4 pushl -0x3c(%ebp) 10b796: e8 b5 62 00 00 call 111a50 <_POSIX_Priority_Is_valid> 10b79b: 83 c4 10 add $0x10,%esp 10b79e: 84 c0 test %al,%al 10b7a0: 0f 84 71 ff ff ff je 10b717 <== NEVER TAKEN return EINVAL; core_priority = _POSIX_Priority_To_core( schedparam.sched_priority ); 10b7a6: 8b 7d c4 mov -0x3c(%ebp),%edi RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core( int priority ) { return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1); 10b7a9: 0f b6 35 9c 4d 12 00 movzbl 0x124d9c,%esi /* * Set the core scheduling policy information. */ rc = _POSIX_Thread_Translate_sched_param( 10b7b0: 8d 45 e0 lea -0x20(%ebp),%eax 10b7b3: 50 push %eax 10b7b4: 8d 45 e4 lea -0x1c(%ebp),%eax 10b7b7: 50 push %eax 10b7b8: ff 75 b4 pushl -0x4c(%ebp) 10b7bb: ff 75 b0 pushl -0x50(%ebp) 10b7be: e8 a9 62 00 00 call 111a6c <_POSIX_Thread_Translate_sched_param> 10b7c3: 89 c2 mov %eax,%edx schedpolicy, &schedparam, &budget_algorithm, &budget_callout ); if ( rc ) 10b7c5: 83 c4 10 add $0x10,%esp 10b7c8: 85 c0 test %eax,%eax 10b7ca: 0f 85 4c ff ff ff jne 10b71c #endif /* * Lock the allocator mutex for protection */ _RTEMS_Lock_allocator(); 10b7d0: 83 ec 0c sub $0xc,%esp 10b7d3: ff 35 40 91 12 00 pushl 0x129140 10b7d9: 89 45 a0 mov %eax,-0x60(%ebp) 10b7dc: e8 b3 17 00 00 call 10cf94 <_API_Mutex_Lock> * _POSIX_Threads_Allocate */ RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void ) { return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information ); 10b7e1: c7 04 24 20 93 12 00 movl $0x129320,(%esp) 10b7e8: e8 cb 21 00 00 call 10d9b8 <_Objects_Allocate> 10b7ed: 89 45 ac mov %eax,-0x54(%ebp) * Allocate the thread control block. * * NOTE: Global threads are not currently supported. */ the_thread = _POSIX_Threads_Allocate(); if ( !the_thread ) { 10b7f0: 83 c4 10 add $0x10,%esp 10b7f3: 85 c0 test %eax,%eax 10b7f5: 8b 55 a0 mov -0x60(%ebp),%edx 10b7f8: 0f 84 0f 01 00 00 je 10b90d /* * Initialize the core thread for this task. */ name.name_p = NULL; /* posix threads don't have a name by default */ status = _Thread_Initialize( 10b7fe: 8b 4d e0 mov -0x20(%ebp),%ecx 10b801: 8b 45 e4 mov -0x1c(%ebp),%eax 10b804: 89 45 a4 mov %eax,-0x5c(%ebp) 10b807: 8b 43 08 mov 0x8(%ebx),%eax 10b80a: 89 45 a8 mov %eax,-0x58(%ebp) 10b80d: a1 98 4d 12 00 mov 0x124d98,%eax 10b812: d1 e0 shl %eax 10b814: 3b 45 a8 cmp -0x58(%ebp),%eax 10b817: 73 03 jae 10b81c 10b819: 8b 45 a8 mov -0x58(%ebp),%eax 10b81c: 83 ec 04 sub $0x4,%esp 10b81f: 6a 00 push $0x0 10b821: 6a 00 push $0x0 10b823: 51 push %ecx 10b824: ff 75 a4 pushl -0x5c(%ebp) 10b827: 6a 01 push $0x1 10b829: 81 e6 ff 00 00 00 and $0xff,%esi 10b82f: 29 fe sub %edi,%esi 10b831: 56 push %esi 10b832: 6a 01 push $0x1 10b834: 50 push %eax 10b835: ff 73 04 pushl 0x4(%ebx) 10b838: ff 75 ac pushl -0x54(%ebp) 10b83b: 68 20 93 12 00 push $0x129320 10b840: 89 55 a0 mov %edx,-0x60(%ebp) 10b843: e8 34 32 00 00 call 10ea7c <_Thread_Initialize> budget_callout, 0, /* isr level */ name /* posix threads don't have a name */ ); if ( !status ) { 10b848: 83 c4 30 add $0x30,%esp 10b84b: 84 c0 test %al,%al 10b84d: 8b 55 a0 mov -0x60(%ebp),%edx 10b850: 75 34 jne 10b886 RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free ( Thread_Control *the_pthread ) { _Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object ); 10b852: 83 ec 08 sub $0x8,%esp 10b855: ff 75 ac pushl -0x54(%ebp) 10b858: 68 20 93 12 00 push $0x129320 10b85d: e8 ca 24 00 00 call 10dd2c <_Objects_Free> _POSIX_Threads_Free( the_thread ); _RTEMS_Unlock_allocator(); 10b862: 59 pop %ecx 10b863: ff 35 40 91 12 00 pushl 0x129140 10b869: e8 6e 17 00 00 call 10cfdc <_API_Mutex_Unlock> return EAGAIN; 10b86e: 83 c4 10 add $0x10,%esp 10b871: ba 0b 00 00 00 mov $0xb,%edx 10b876: e9 a1 fe ff ff jmp 10b71c 10b87b: 90 nop struct sched_param schedparam; Objects_Name name; int rc; if ( !start_routine ) return EFAULT; 10b87c: ba 0e 00 00 00 mov $0xe,%edx 10b881: e9 96 fe ff ff jmp 10b71c } /* * finish initializing the per API structure */ api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10b886: 8b 4d ac mov -0x54(%ebp),%ecx 10b889: 8b 89 ec 00 00 00 mov 0xec(%ecx),%ecx 10b88f: 89 4d a8 mov %ecx,-0x58(%ebp) api->Attributes = *the_attr; 10b892: b9 10 00 00 00 mov $0x10,%ecx 10b897: 8b 7d a8 mov -0x58(%ebp),%edi 10b89a: 89 de mov %ebx,%esi 10b89c: f3 a5 rep movsl %ds:(%esi),%es:(%edi) api->detachstate = the_attr->detachstate; 10b89e: 8b 43 3c mov 0x3c(%ebx),%eax 10b8a1: 8b 4d a8 mov -0x58(%ebp),%ecx 10b8a4: 89 41 40 mov %eax,0x40(%ecx) api->schedpolicy = schedpolicy; 10b8a7: 8b 45 b0 mov -0x50(%ebp),%eax 10b8aa: 89 81 84 00 00 00 mov %eax,0x84(%ecx) api->schedparam = schedparam; 10b8b0: 89 cf mov %ecx,%edi 10b8b2: 81 c7 88 00 00 00 add $0x88,%edi 10b8b8: b9 07 00 00 00 mov $0x7,%ecx 10b8bd: 8b 75 b4 mov -0x4c(%ebp),%esi 10b8c0: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* * POSIX threads are allocated and started in one operation. */ status = _Thread_Start( 10b8c2: 83 ec 0c sub $0xc,%esp 10b8c5: 6a 00 push $0x0 10b8c7: ff 75 14 pushl 0x14(%ebp) 10b8ca: ff 75 10 pushl 0x10(%ebp) 10b8cd: 6a 01 push $0x1 10b8cf: ff 75 ac pushl -0x54(%ebp) 10b8d2: 89 55 a0 mov %edx,-0x60(%ebp) 10b8d5: e8 92 3a 00 00 call 10f36c <_Thread_Start> _RTEMS_Unlock_allocator(); return EINVAL; } #endif if ( schedpolicy == SCHED_SPORADIC ) { 10b8da: 83 c4 20 add $0x20,%esp 10b8dd: 83 7d b0 04 cmpl $0x4,-0x50(%ebp) 10b8e1: 8b 55 a0 mov -0x60(%ebp),%edx 10b8e4: 74 42 je 10b928 } /* * Return the id and indicate we successfully created the thread */ *thread = the_thread->Object.id; 10b8e6: 8b 45 ac mov -0x54(%ebp),%eax 10b8e9: 8b 48 08 mov 0x8(%eax),%ecx 10b8ec: 8b 45 08 mov 0x8(%ebp),%eax 10b8ef: 89 08 mov %ecx,(%eax) _RTEMS_Unlock_allocator(); 10b8f1: 83 ec 0c sub $0xc,%esp 10b8f4: ff 35 40 91 12 00 pushl 0x129140 10b8fa: 89 55 a0 mov %edx,-0x60(%ebp) 10b8fd: e8 da 16 00 00 call 10cfdc <_API_Mutex_Unlock> return 0; 10b902: 83 c4 10 add $0x10,%esp 10b905: 8b 55 a0 mov -0x60(%ebp),%edx 10b908: e9 0f fe ff ff jmp 10b71c * * NOTE: Global threads are not currently supported. */ the_thread = _POSIX_Threads_Allocate(); if ( !the_thread ) { _RTEMS_Unlock_allocator(); 10b90d: 83 ec 0c sub $0xc,%esp 10b910: ff 35 40 91 12 00 pushl 0x129140 10b916: e8 c1 16 00 00 call 10cfdc <_API_Mutex_Unlock> return EAGAIN; 10b91b: 83 c4 10 add $0x10,%esp 10b91e: ba 0b 00 00 00 mov $0xb,%edx 10b923: e9 f4 fd ff ff jmp 10b71c return EINVAL; } #endif if ( schedpolicy == SCHED_SPORADIC ) { _Watchdog_Insert_ticks( 10b928: 83 ec 0c sub $0xc,%esp &api->Sporadic_timer, _Timespec_To_ticks( &api->schedparam.sched_ss_repl_period ) 10b92b: 8b 45 a8 mov -0x58(%ebp),%eax 10b92e: 05 90 00 00 00 add $0x90,%eax return EINVAL; } #endif if ( schedpolicy == SCHED_SPORADIC ) { _Watchdog_Insert_ticks( 10b933: 50 push %eax 10b934: e8 c3 3b 00 00 call 10f4fc <_Timespec_To_ticks> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10b939: 8b 4d a8 mov -0x58(%ebp),%ecx 10b93c: 89 81 b4 00 00 00 mov %eax,0xb4(%ecx) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10b942: 58 pop %eax 10b943: 5a pop %edx 10b944: 89 c8 mov %ecx,%eax 10b946: 05 a8 00 00 00 add $0xa8,%eax 10b94b: 50 push %eax 10b94c: 68 60 91 12 00 push $0x129160 10b951: e8 d6 3e 00 00 call 10f82c <_Watchdog_Insert> 10b956: 83 c4 10 add $0x10,%esp 10b959: 8b 55 a0 mov -0x60(%ebp),%edx 10b95c: eb 88 jmp 10b8e6 =============================================================================== 00112dd4 : } void pthread_exit( void *value_ptr ) { 112dd4: 55 push %ebp 112dd5: 89 e5 mov %esp,%ebp 112dd7: 83 ec 10 sub $0x10,%esp _POSIX_Thread_Exit( _Thread_Executing, value_ptr ); 112dda: ff 75 08 pushl 0x8(%ebp) 112ddd: ff 35 38 83 12 00 pushl 0x128338 112de3: e8 88 ff ff ff call 112d70 <_POSIX_Thread_Exit> 112de8: 83 c4 10 add $0x10,%esp } 112deb: c9 leave <== NOT EXECUTED 112dec: c3 ret <== NOT EXECUTED =============================================================================== 0010d8d0 : int pthread_getschedparam( pthread_t thread, int *policy, struct sched_param *param ) { 10d8d0: 55 push %ebp 10d8d1: 89 e5 mov %esp,%ebp 10d8d3: 57 push %edi 10d8d4: 56 push %esi 10d8d5: 53 push %ebx 10d8d6: 83 ec 1c sub $0x1c,%esp 10d8d9: 8b 7d 0c mov 0xc(%ebp),%edi 10d8dc: 8b 5d 10 mov 0x10(%ebp),%ebx Objects_Locations location; POSIX_API_Control *api; register Thread_Control *the_thread; if ( !policy || !param ) 10d8df: 85 ff test %edi,%edi 10d8e1: 74 69 je 10d94c 10d8e3: 85 db test %ebx,%ebx 10d8e5: 74 65 je 10d94c pthread_t id, Objects_Locations *location ) { return (Thread_Control *) _Objects_Get( &_POSIX_Threads_Information, (Objects_Id)id, location ); 10d8e7: 51 push %ecx return EINVAL; the_thread = _POSIX_Threads_Get( thread, &location ); 10d8e8: 8d 45 e4 lea -0x1c(%ebp),%eax 10d8eb: 50 push %eax 10d8ec: ff 75 08 pushl 0x8(%ebp) 10d8ef: 68 80 cf 12 00 push $0x12cf80 10d8f4: e8 ff 23 00 00 call 10fcf8 <_Objects_Get> switch ( location ) { 10d8f9: 83 c4 10 add $0x10,%esp 10d8fc: 8b 55 e4 mov -0x1c(%ebp),%edx 10d8ff: 85 d2 test %edx,%edx 10d901: 75 39 jne 10d93c case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10d903: 8b b0 ec 00 00 00 mov 0xec(%eax),%esi if ( policy ) *policy = api->schedpolicy; 10d909: 8b 96 84 00 00 00 mov 0x84(%esi),%edx 10d90f: 89 17 mov %edx,(%edi) if ( param ) { *param = api->schedparam; 10d911: 81 c6 88 00 00 00 add $0x88,%esi 10d917: b9 07 00 00 00 mov $0x7,%ecx 10d91c: 89 df mov %ebx,%edi 10d91e: f3 a5 rep movsl %ds:(%esi),%es:(%edi) RTEMS_INLINE_ROUTINE int _POSIX_Priority_From_core( Priority_Control priority ) { return (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1); 10d920: 0f b6 15 9c 89 12 00 movzbl 0x12899c,%edx 10d927: 2b 50 14 sub 0x14(%eax),%edx 10d92a: 89 13 mov %edx,(%ebx) param->sched_priority = _POSIX_Priority_From_core( the_thread->current_priority ); } _Thread_Enable_dispatch(); 10d92c: e8 3f 2f 00 00 call 110870 <_Thread_Enable_dispatch> return 0; 10d931: 31 c0 xor %eax,%eax break; } return ESRCH; } 10d933: 8d 65 f4 lea -0xc(%ebp),%esp 10d936: 5b pop %ebx 10d937: 5e pop %esi 10d938: 5f pop %edi 10d939: c9 leave 10d93a: c3 ret 10d93b: 90 nop #endif case OBJECTS_ERROR: break; } return ESRCH; 10d93c: b8 03 00 00 00 mov $0x3,%eax } 10d941: 8d 65 f4 lea -0xc(%ebp),%esp 10d944: 5b pop %ebx 10d945: 5e pop %esi 10d946: 5f pop %edi 10d947: c9 leave 10d948: c3 ret 10d949: 8d 76 00 lea 0x0(%esi),%esi Objects_Locations location; POSIX_API_Control *api; register Thread_Control *the_thread; if ( !policy || !param ) return EINVAL; 10d94c: b8 16 00 00 00 mov $0x16,%eax break; } return ESRCH; } 10d951: 8d 65 f4 lea -0xc(%ebp),%esp 10d954: 5b pop %ebx 10d955: 5e pop %esi 10d956: 5f pop %edi 10d957: c9 leave 10d958: c3 ret =============================================================================== 0010b6b8 : */ void *pthread_getspecific( pthread_key_t key ) { 10b6b8: 55 push %ebp 10b6b9: 89 e5 mov %esp,%ebp 10b6bb: 83 ec 2c sub $0x2c,%esp uint32_t api; uint32_t index; Objects_Locations location; void *key_data; the_key = _POSIX_Keys_Get( key, &location ); 10b6be: 8d 45 f4 lea -0xc(%ebp),%eax pthread_key_t id, Objects_Locations *location ) { return (POSIX_Keys_Control *) _Objects_Get( &_POSIX_Keys_Information, (Objects_Id) id, location ); 10b6c1: 50 push %eax 10b6c2: ff 75 08 pushl 0x8(%ebp) 10b6c5: 68 20 a1 12 00 push $0x12a120 10b6ca: e8 9d 25 00 00 call 10dc6c <_Objects_Get> switch ( location ) { 10b6cf: 83 c4 10 add $0x10,%esp 10b6d2: 8b 55 f4 mov -0xc(%ebp),%edx 10b6d5: 85 d2 test %edx,%edx 10b6d7: 75 2b jne 10b704 case OBJECTS_LOCAL: api = _Objects_Get_API( _Thread_Executing->Object.id ); 10b6d9: 8b 15 58 a2 12 00 mov 0x12a258,%edx 10b6df: 8b 4a 08 mov 0x8(%edx),%ecx */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 10b6e2: 89 ca mov %ecx,%edx 10b6e4: c1 ea 18 shr $0x18,%edx 10b6e7: 83 e2 07 and $0x7,%edx index = _Objects_Get_index( _Thread_Executing->Object.id ); 10b6ea: 0f b7 c9 movzwl %cx,%ecx key_data = (void *) the_key->Values[ api ][ index ]; 10b6ed: 8b 44 90 14 mov 0x14(%eax,%edx,4),%eax 10b6f1: 8b 04 88 mov (%eax,%ecx,4),%eax _Thread_Enable_dispatch(); 10b6f4: 89 45 e4 mov %eax,-0x1c(%ebp) 10b6f7: e8 e8 30 00 00 call 10e7e4 <_Thread_Enable_dispatch> return key_data; 10b6fc: 8b 45 e4 mov -0x1c(%ebp),%eax case OBJECTS_ERROR: break; } return NULL; } 10b6ff: c9 leave 10b700: c3 ret 10b701: 8d 76 00 lea 0x0(%esi),%esi #endif case OBJECTS_ERROR: break; } return NULL; 10b704: 31 c0 xor %eax,%eax } 10b706: c9 leave 10b707: c3 ret =============================================================================== 00111118 : int pthread_join( pthread_t thread, void **value_ptr ) { 111118: 55 push %ebp 111119: 89 e5 mov %esp,%ebp 11111b: 53 push %ebx 11111c: 83 ec 18 sub $0x18,%esp 11111f: 8b 5d 0c mov 0xc(%ebp),%ebx register Thread_Control *the_thread; POSIX_API_Control *api; Objects_Locations location; void *return_pointer; the_thread = _POSIX_Threads_Get( thread, &location ); 111122: 8d 45 f4 lea -0xc(%ebp),%eax 111125: 50 push %eax 111126: ff 75 08 pushl 0x8(%ebp) 111129: 68 40 2a 13 00 push $0x132a40 11112e: e8 09 24 00 00 call 11353c <_Objects_Get> switch ( location ) { 111133: 83 c4 10 add $0x10,%esp 111136: 8b 55 f4 mov -0xc(%ebp),%edx 111139: 85 d2 test %edx,%edx 11113b: 74 0b je 111148 #endif case OBJECTS_ERROR: break; } return ESRCH; 11113d: b8 03 00 00 00 mov $0x3,%eax } 111142: 8b 5d fc mov -0x4(%ebp),%ebx 111145: c9 leave 111146: c3 ret 111147: 90 nop the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 111148: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx if ( api->detachstate == PTHREAD_CREATE_DETACHED ) { 11114e: 8b 4a 40 mov 0x40(%edx),%ecx 111151: 85 c9 test %ecx,%ecx 111153: 74 43 je 111198 RTEMS_INLINE_ROUTINE bool _Thread_Is_executing ( const Thread_Control *the_thread ) { return ( the_thread == _Thread_Executing ); 111155: 8b 0d 58 2d 13 00 mov 0x132d58,%ecx _Thread_Enable_dispatch(); return EINVAL; } if ( _Thread_Is_executing( the_thread ) ) { 11115b: 39 c8 cmp %ecx,%eax 11115d: 74 49 je 1111a8 /* * Put ourself on the threads join list */ _Thread_Executing->Wait.return_argument = &return_pointer; 11115f: 8d 45 f0 lea -0x10(%ebp),%eax 111162: 89 41 28 mov %eax,0x28(%ecx) RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 111165: c7 42 74 01 00 00 00 movl $0x1,0x74(%edx) _Thread_queue_Enter_critical_section( &api->Join_List ); _Thread_queue_Enqueue( &api->Join_List, WATCHDOG_NO_TIMEOUT ); 11116c: 50 push %eax 11116d: 68 84 48 11 00 push $0x114884 111172: 6a 00 push $0x0 111174: 83 c2 44 add $0x44,%edx 111177: 52 push %edx 111178: e8 db 33 00 00 call 114558 <_Thread_queue_Enqueue_with_handler> _Thread_Enable_dispatch(); 11117d: e8 32 2f 00 00 call 1140b4 <_Thread_Enable_dispatch> if ( value_ptr ) 111182: 83 c4 10 add $0x10,%esp 111185: 85 db test %ebx,%ebx 111187: 74 2b je 1111b4 *value_ptr = return_pointer; 111189: 8b 45 f0 mov -0x10(%ebp),%eax 11118c: 89 03 mov %eax,(%ebx) return 0; 11118e: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return ESRCH; } 111190: 8b 5d fc mov -0x4(%ebp),%ebx 111193: c9 leave 111194: c3 ret 111195: 8d 76 00 lea 0x0(%esi),%esi case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( api->detachstate == PTHREAD_CREATE_DETACHED ) { _Thread_Enable_dispatch(); 111198: e8 17 2f 00 00 call 1140b4 <_Thread_Enable_dispatch> return EINVAL; 11119d: b8 16 00 00 00 mov $0x16,%eax case OBJECTS_ERROR: break; } return ESRCH; } 1111a2: 8b 5d fc mov -0x4(%ebp),%ebx 1111a5: c9 leave 1111a6: c3 ret 1111a7: 90 nop _Thread_Enable_dispatch(); return EINVAL; } if ( _Thread_Is_executing( the_thread ) ) { _Thread_Enable_dispatch(); 1111a8: e8 07 2f 00 00 call 1140b4 <_Thread_Enable_dispatch> return EDEADLK; 1111ad: b8 2d 00 00 00 mov $0x2d,%eax 1111b2: eb 8e jmp 111142 _Thread_Enable_dispatch(); if ( value_ptr ) *value_ptr = return_pointer; return 0; 1111b4: 31 c0 xor %eax,%eax 1111b6: eb 8a jmp 111142 =============================================================================== 0010b544 : int pthread_key_create( pthread_key_t *key, void (*destructor)( void * ) ) { 10b544: 55 push %ebp 10b545: 89 e5 mov %esp,%ebp 10b547: 57 push %edi 10b548: 56 push %esi 10b549: 53 push %ebx 10b54a: 83 ec 28 sub $0x28,%esp 10b54d: a1 b0 9c 12 00 mov 0x129cb0,%eax 10b552: 40 inc %eax 10b553: a3 b0 9c 12 00 mov %eax,0x129cb0 * the inactive chain of free keys control blocks. */ RTEMS_INLINE_ROUTINE POSIX_Keys_Control *_POSIX_Keys_Allocate( void ) { return (POSIX_Keys_Control *) _Objects_Allocate( &_POSIX_Keys_Information ); 10b558: 68 20 a1 12 00 push $0x12a120 10b55d: e8 56 22 00 00 call 10d7b8 <_Objects_Allocate> 10b562: 89 c6 mov %eax,%esi _Thread_Disable_dispatch(); the_key = _POSIX_Keys_Allocate(); if ( !the_key ) { 10b564: 83 c4 10 add $0x10,%esp 10b567: 85 c0 test %eax,%eax 10b569: 74 79 je 10b5e4 _Thread_Enable_dispatch(); return EAGAIN; } the_key->destructor = destructor; 10b56b: 8b 45 0c mov 0xc(%ebp),%eax 10b56e: 89 46 10 mov %eax,0x10(%esi) * This is a bit more complex than one might initially expect because * APIs are optional. * * NOTE: Currently RTEMS Classic API tasks are always enabled. */ for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) { 10b571: bb 01 00 00 00 mov $0x1,%ebx the_key->Values[ the_api ] = NULL; 10b576: c7 44 9e 14 00 00 00 movl $0x0,0x14(%esi,%ebx,4) 10b57d: 00 INTERNAL_ERROR_IMPLEMENTATION_KEY_CREATE_INCONSISTENCY ); #endif bytes_to_allocate = sizeof( void * ) * (_Objects_Information_table[ the_api ][ 1 ]->maximum + 1); 10b57e: 8b 04 9d 88 9c 12 00 mov 0x129c88(,%ebx,4),%eax 10b585: 8b 40 04 mov 0x4(%eax),%eax 10b588: 0f b7 40 10 movzwl 0x10(%eax),%eax true, INTERNAL_ERROR_IMPLEMENTATION_KEY_CREATE_INCONSISTENCY ); #endif bytes_to_allocate = sizeof( void * ) * 10b58c: 8d 0c 85 04 00 00 00 lea 0x4(,%eax,4),%ecx (_Objects_Information_table[ the_api ][ 1 ]->maximum + 1); table = _Workspace_Allocate( bytes_to_allocate ); 10b593: 83 ec 0c sub $0xc,%esp 10b596: 51 push %ecx 10b597: 89 4d e4 mov %ecx,-0x1c(%ebp) 10b59a: e8 25 43 00 00 call 10f8c4 <_Workspace_Allocate> if ( !table ) { 10b59f: 83 c4 10 add $0x10,%esp 10b5a2: 85 c0 test %eax,%eax 10b5a4: 8b 4d e4 mov -0x1c(%ebp),%ecx 10b5a7: 74 4f je 10b5f8 _POSIX_Keys_Free( the_key ); _Thread_Enable_dispatch(); return ENOMEM; } the_key->Values[ the_api ] = table; 10b5a9: 89 44 9e 14 mov %eax,0x14(%esi,%ebx,4) memset( table, '\0', bytes_to_allocate ); 10b5ad: 89 c7 mov %eax,%edi 10b5af: 31 c0 xor %eax,%eax 10b5b1: f3 aa rep stos %al,%es:(%edi) * This is a bit more complex than one might initially expect because * APIs are optional. * * NOTE: Currently RTEMS Classic API tasks are always enabled. */ for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) { 10b5b3: 43 inc %ebx 10b5b4: 83 fb 04 cmp $0x4,%ebx 10b5b7: 75 bd jne 10b576 uint32_t name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10b5b9: 8b 46 08 mov 0x8(%esi),%eax Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 10b5bc: 0f b7 c8 movzwl %ax,%ecx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10b5bf: 8b 15 3c a1 12 00 mov 0x12a13c,%edx 10b5c5: 89 34 8a mov %esi,(%edx,%ecx,4) _Objects_Get_index( the_object->id ), the_object ); /* ASSERT: information->is_string == false */ the_object->name.name_u32 = name; 10b5c8: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi) the_key->Values[ the_api ] = table; memset( table, '\0', bytes_to_allocate ); } _Objects_Open_u32( &_POSIX_Keys_Information, &the_key->Object, 0 ); *key = the_key->Object.id; 10b5cf: 8b 55 08 mov 0x8(%ebp),%edx 10b5d2: 89 02 mov %eax,(%edx) _Thread_Enable_dispatch(); 10b5d4: e8 0b 32 00 00 call 10e7e4 <_Thread_Enable_dispatch> return 0; 10b5d9: 31 c0 xor %eax,%eax } 10b5db: 8d 65 f4 lea -0xc(%ebp),%esp 10b5de: 5b pop %ebx 10b5df: 5e pop %esi 10b5e0: 5f pop %edi 10b5e1: c9 leave 10b5e2: c3 ret 10b5e3: 90 nop _Thread_Disable_dispatch(); the_key = _POSIX_Keys_Allocate(); if ( !the_key ) { _Thread_Enable_dispatch(); 10b5e4: e8 fb 31 00 00 call 10e7e4 <_Thread_Enable_dispatch> return EAGAIN; 10b5e9: b8 0b 00 00 00 mov $0xb,%eax _Objects_Open_u32( &_POSIX_Keys_Information, &the_key->Object, 0 ); *key = the_key->Object.id; _Thread_Enable_dispatch(); return 0; } 10b5ee: 8d 65 f4 lea -0xc(%ebp),%esp 10b5f1: 5b pop %ebx 10b5f2: 5e pop %esi 10b5f3: 5f pop %edi 10b5f4: c9 leave 10b5f5: c3 ret 10b5f6: 66 90 xchg %ax,%ax bytes_to_allocate = sizeof( void * ) * (_Objects_Information_table[ the_api ][ 1 ]->maximum + 1); table = _Workspace_Allocate( bytes_to_allocate ); if ( !table ) { _POSIX_Keys_Free_memory( the_key ); 10b5f8: 83 ec 0c sub $0xc,%esp 10b5fb: 56 push %esi 10b5fc: e8 87 00 00 00 call 10b688 <_POSIX_Keys_Free_memory> */ RTEMS_INLINE_ROUTINE void _POSIX_Keys_Free ( POSIX_Keys_Control *the_key ) { _Objects_Free( &_POSIX_Keys_Information, &the_key->Object ); 10b601: 58 pop %eax 10b602: 5a pop %edx 10b603: 56 push %esi 10b604: 68 20 a1 12 00 push $0x12a120 10b609: e8 1e 25 00 00 call 10db2c <_Objects_Free> _POSIX_Keys_Free( the_key ); _Thread_Enable_dispatch(); 10b60e: e8 d1 31 00 00 call 10e7e4 <_Thread_Enable_dispatch> return ENOMEM; 10b613: 83 c4 10 add $0x10,%esp 10b616: b8 0c 00 00 00 mov $0xc,%eax _Objects_Open_u32( &_POSIX_Keys_Information, &the_key->Object, 0 ); *key = the_key->Object.id; _Thread_Enable_dispatch(); return 0; } 10b61b: 8d 65 f4 lea -0xc(%ebp),%esp 10b61e: 5b pop %ebx 10b61f: 5e pop %esi 10b620: 5f pop %edi 10b621: c9 leave 10b622: c3 ret =============================================================================== 0010b624 : * 17.1.3 Thread-Specific Data Key Deletion, P1003.1c/Draft 10, p. 167 */ int pthread_key_delete( pthread_key_t key ) { 10b624: 55 push %ebp 10b625: 89 e5 mov %esp,%ebp 10b627: 53 push %ebx 10b628: 83 ec 18 sub $0x18,%esp POSIX_Keys_Control *the_key; Objects_Locations location; the_key = _POSIX_Keys_Get( key, &location ); 10b62b: 8d 45 f4 lea -0xc(%ebp),%eax pthread_key_t id, Objects_Locations *location ) { return (POSIX_Keys_Control *) _Objects_Get( &_POSIX_Keys_Information, (Objects_Id) id, location ); 10b62e: 50 push %eax 10b62f: ff 75 08 pushl 0x8(%ebp) 10b632: 68 20 a1 12 00 push $0x12a120 10b637: e8 30 26 00 00 call 10dc6c <_Objects_Get> 10b63c: 89 c3 mov %eax,%ebx switch ( location ) { 10b63e: 83 c4 10 add $0x10,%esp 10b641: 8b 4d f4 mov -0xc(%ebp),%ecx 10b644: 85 c9 test %ecx,%ecx 10b646: 75 34 jne 10b67c case OBJECTS_LOCAL: _Objects_Close( &_POSIX_Keys_Information, &the_key->Object ); 10b648: 83 ec 08 sub $0x8,%esp 10b64b: 50 push %eax 10b64c: 68 20 a1 12 00 push $0x12a120 10b651: e8 de 21 00 00 call 10d834 <_Objects_Close> _POSIX_Keys_Free_memory( the_key ); 10b656: 89 1c 24 mov %ebx,(%esp) 10b659: e8 2a 00 00 00 call 10b688 <_POSIX_Keys_Free_memory> */ RTEMS_INLINE_ROUTINE void _POSIX_Keys_Free ( POSIX_Keys_Control *the_key ) { _Objects_Free( &_POSIX_Keys_Information, &the_key->Object ); 10b65e: 58 pop %eax 10b65f: 5a pop %edx 10b660: 53 push %ebx 10b661: 68 20 a1 12 00 push $0x12a120 10b666: e8 c1 24 00 00 call 10db2c <_Objects_Free> /* * NOTE: The destructor is not called and it is the responsibility * of the application to free the memory. */ _POSIX_Keys_Free( the_key ); _Thread_Enable_dispatch(); 10b66b: e8 74 31 00 00 call 10e7e4 <_Thread_Enable_dispatch> return 0; 10b670: 83 c4 10 add $0x10,%esp 10b673: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return EINVAL; } 10b675: 8b 5d fc mov -0x4(%ebp),%ebx 10b678: c9 leave 10b679: c3 ret 10b67a: 66 90 xchg %ax,%ax #endif case OBJECTS_ERROR: break; } return EINVAL; 10b67c: b8 16 00 00 00 mov $0x16,%eax } 10b681: 8b 5d fc mov -0x4(%ebp),%ebx 10b684: c9 leave 10b685: c3 ret =============================================================================== 00124d8c : int pthread_kill( pthread_t thread, int sig ) { 124d8c: 55 push %ebp 124d8d: 89 e5 mov %esp,%ebp 124d8f: 57 push %edi 124d90: 56 push %esi 124d91: 53 push %ebx 124d92: 83 ec 1c sub $0x1c,%esp 124d95: 8b 5d 0c mov 0xc(%ebp),%ebx POSIX_API_Control *api; Thread_Control *the_thread; Objects_Locations location; if ( !sig ) 124d98: 85 db test %ebx,%ebx 124d9a: 0f 84 84 00 00 00 je 124e24 static inline bool is_valid_signo( int signo ) { return ((signo) >= 1 && (signo) <= 32 ); 124da0: 8d 7b ff lea -0x1(%ebx),%edi rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 124da3: 83 ff 1f cmp $0x1f,%edi 124da6: 77 7c ja 124e24 pthread_t id, Objects_Locations *location ) { return (Thread_Control *) _Objects_Get( &_POSIX_Threads_Information, (Objects_Id)id, location ); 124da8: 56 push %esi rtems_set_errno_and_return_minus_one( EINVAL ); the_thread = _POSIX_Threads_Get( thread, &location ); 124da9: 8d 45 e4 lea -0x1c(%ebp),%eax 124dac: 50 push %eax 124dad: ff 75 08 pushl 0x8(%ebp) 124db0: 68 a0 ed 12 00 push $0x12eda0 124db5: e8 26 d1 fe ff call 111ee0 <_Objects_Get> 124dba: 89 c6 mov %eax,%esi switch ( location ) { 124dbc: 83 c4 10 add $0x10,%esp 124dbf: 8b 4d e4 mov -0x1c(%ebp),%ecx 124dc2: 85 c9 test %ecx,%ecx 124dc4: 75 72 jne 124e38 case OBJECTS_LOCAL: /* * If sig == 0 then just validate arguments */ api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 124dc6: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx if ( sig ) { if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) { 124dcc: 8d 04 5b lea (%ebx,%ebx,2),%eax 124dcf: 83 3c 85 28 f1 12 00 cmpl $0x1,0x12f128(,%eax,4) 124dd6: 01 124dd7: 74 2d je 124e06 static inline sigset_t signo_to_mask( uint32_t sig ) { return 1u << (sig - 1); 124dd9: b8 01 00 00 00 mov $0x1,%eax 124dde: 89 f9 mov %edi,%ecx 124de0: d3 e0 shl %cl,%eax return 0; } /* XXX critical section */ api->signals_pending |= signo_to_mask( sig ); 124de2: 09 82 d4 00 00 00 or %eax,0xd4(%edx) (void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL ); 124de8: 52 push %edx 124de9: 6a 00 push $0x0 124deb: 53 push %ebx 124dec: 56 push %esi 124ded: e8 7a fe ff ff call 124c6c <_POSIX_signals_Unblock_thread> if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 124df2: 83 c4 10 add $0x10,%esp 124df5: a1 b4 f0 12 00 mov 0x12f0b4,%eax 124dfa: 85 c0 test %eax,%eax 124dfc: 74 08 je 124e06 124dfe: 3b 35 b8 f0 12 00 cmp 0x12f0b8,%esi 124e04: 74 12 je 124e18 _Thread_Dispatch_necessary = true; } _Thread_Enable_dispatch(); 124e06: e8 cd dc fe ff call 112ad8 <_Thread_Enable_dispatch> return 0; 124e0b: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( ESRCH ); } 124e0d: 8d 65 f4 lea -0xc(%ebp),%esp 124e10: 5b pop %ebx 124e11: 5e pop %esi 124e12: 5f pop %edi 124e13: c9 leave 124e14: c3 ret 124e15: 8d 76 00 lea 0x0(%esi),%esi api->signals_pending |= signo_to_mask( sig ); (void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL ); if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) _Thread_Dispatch_necessary = true; 124e18: c6 05 c4 f0 12 00 01 movb $0x1,0x12f0c4 124e1f: eb e5 jmp 124e06 124e21: 8d 76 00 lea 0x0(%esi),%esi if ( !sig ) rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) rtems_set_errno_and_return_minus_one( EINVAL ); 124e24: e8 0f 36 ff ff call 118438 <__errno> 124e29: c7 00 16 00 00 00 movl $0x16,(%eax) 124e2f: b8 ff ff ff ff mov $0xffffffff,%eax 124e34: eb d7 jmp 124e0d 124e36: 66 90 xchg %ax,%ax #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( ESRCH ); 124e38: e8 fb 35 ff ff call 118438 <__errno> 124e3d: c7 00 03 00 00 00 movl $0x3,(%eax) 124e43: b8 ff ff ff ff mov $0xffffffff,%eax 124e48: eb c3 jmp 124e0d =============================================================================== 0010d19c : int pthread_mutex_getprioceiling( pthread_mutex_t *mutex, int *prioceiling ) { 10d19c: 55 push %ebp 10d19d: 89 e5 mov %esp,%ebp 10d19f: 53 push %ebx 10d1a0: 83 ec 14 sub $0x14,%esp 10d1a3: 8b 5d 0c mov 0xc(%ebp),%ebx register POSIX_Mutex_Control *the_mutex; Objects_Locations location; if ( !prioceiling ) 10d1a6: 85 db test %ebx,%ebx 10d1a8: 74 19 je 10d1c3 return EINVAL; the_mutex = _POSIX_Mutex_Get( mutex, &location ); 10d1aa: 83 ec 08 sub $0x8,%esp 10d1ad: 8d 45 f4 lea -0xc(%ebp),%eax 10d1b0: 50 push %eax 10d1b1: ff 75 08 pushl 0x8(%ebp) 10d1b4: e8 3b ff ff ff call 10d0f4 <_POSIX_Mutex_Get> switch ( location ) { 10d1b9: 83 c4 10 add $0x10,%esp 10d1bc: 8b 55 f4 mov -0xc(%ebp),%edx 10d1bf: 85 d2 test %edx,%edx 10d1c1: 74 0d je 10d1d0 #endif case OBJECTS_ERROR: break; } return EINVAL; 10d1c3: b8 16 00 00 00 mov $0x16,%eax } 10d1c8: 8b 5d fc mov -0x4(%ebp),%ebx 10d1cb: c9 leave 10d1cc: c3 ret 10d1cd: 8d 76 00 lea 0x0(%esi),%esi RTEMS_INLINE_ROUTINE int _POSIX_Priority_From_core( Priority_Control priority ) { return (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1); 10d1d0: 0f b6 15 9c 89 12 00 movzbl 0x12899c,%edx 10d1d7: 2b 50 60 sub 0x60(%eax),%edx 10d1da: 89 13 mov %edx,(%ebx) case OBJECTS_LOCAL: *prioceiling = _POSIX_Priority_From_core( the_mutex->Mutex.Attributes.priority_ceiling ); _Thread_Enable_dispatch(); 10d1dc: e8 8f 36 00 00 call 110870 <_Thread_Enable_dispatch> return 0; 10d1e1: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return EINVAL; } 10d1e3: 8b 5d fc mov -0x4(%ebp),%ebx 10d1e6: c9 leave 10d1e7: c3 ret =============================================================================== 0010d1e8 : int pthread_mutex_init( pthread_mutex_t *mutex, const pthread_mutexattr_t *attr ) { 10d1e8: 55 push %ebp 10d1e9: 89 e5 mov %esp,%ebp 10d1eb: 57 push %edi 10d1ec: 56 push %esi 10d1ed: 53 push %ebx 10d1ee: 83 ec 1c sub $0x1c,%esp 10d1f1: 8b 75 08 mov 0x8(%ebp),%esi 10d1f4: 8b 5d 0c mov 0xc(%ebp),%ebx POSIX_Mutex_Control *the_mutex; CORE_mutex_Attributes *the_mutex_attr; const pthread_mutexattr_t *the_attr; CORE_mutex_Disciplines the_discipline; if ( attr ) the_attr = attr; 10d1f7: 85 db test %ebx,%ebx 10d1f9: 0f 84 09 01 00 00 je 10d308 else the_attr = &_POSIX_Mutex_Default_attributes; /* Check for NULL mutex */ if ( !mutex ) 10d1ff: 85 f6 test %esi,%esi 10d201: 0f 84 e5 00 00 00 je 10d2ec } } } #endif if ( !the_attr->is_initialized ) 10d207: 8b 13 mov (%ebx),%edx 10d209: 85 d2 test %edx,%edx 10d20b: 0f 84 db 00 00 00 je 10d2ec return EINVAL; /* * We only support process private mutexes. */ if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED ) 10d211: 8b 43 04 mov 0x4(%ebx),%eax 10d214: 83 f8 01 cmp $0x1,%eax 10d217: 0f 84 f7 00 00 00 je 10d314 return ENOSYS; if ( the_attr->process_shared != PTHREAD_PROCESS_PRIVATE ) 10d21d: 85 c0 test %eax,%eax 10d21f: 0f 85 c7 00 00 00 jne 10d2ec return EINVAL; /* * Determine the discipline of the mutex */ switch ( the_attr->protocol ) { 10d225: 8b 43 0c mov 0xc(%ebx),%eax 10d228: 83 f8 01 cmp $0x1,%eax 10d22b: 0f 84 eb 00 00 00 je 10d31c 10d231: 83 f8 02 cmp $0x2,%eax 10d234: 0f 84 c2 00 00 00 je 10d2fc 10d23a: 85 c0 test %eax,%eax 10d23c: 0f 85 aa 00 00 00 jne 10d2ec case PTHREAD_PRIO_NONE: the_discipline = CORE_MUTEX_DISCIPLINES_FIFO; 10d242: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) } /* * Validate the priority ceiling field -- should always be valid. */ if ( !_POSIX_Priority_Is_valid( the_attr->prio_ceiling ) ) 10d249: 83 ec 0c sub $0xc,%esp 10d24c: ff 73 08 pushl 0x8(%ebx) 10d24f: e8 58 03 00 00 call 10d5ac <_POSIX_Priority_Is_valid> 10d254: 83 c4 10 add $0x10,%esp 10d257: 84 c0 test %al,%al 10d259: 0f 84 8d 00 00 00 je 10d2ec #if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES) /* * Validate the mutex type and set appropriate SuperCore mutex * attributes. */ switch ( the_attr->type ) { 10d25f: 83 7b 10 03 cmpl $0x3,0x10(%ebx) 10d263: 0f 87 83 00 00 00 ja 10d2ec 10d269: a1 f0 cc 12 00 mov 0x12ccf0,%eax 10d26e: 40 inc %eax 10d26f: a3 f0 cc 12 00 mov %eax,0x12ccf0 * _POSIX_Mutex_Allocate */ RTEMS_INLINE_ROUTINE POSIX_Mutex_Control *_POSIX_Mutex_Allocate( void ) { return (POSIX_Mutex_Control *) _Objects_Allocate( &_POSIX_Mutex_Information ); 10d274: 83 ec 0c sub $0xc,%esp 10d277: 68 c0 d0 12 00 push $0x12d0c0 10d27c: e8 c3 25 00 00 call 10f844 <_Objects_Allocate> 10d281: 89 c7 mov %eax,%edi */ _Thread_Disable_dispatch(); the_mutex = _POSIX_Mutex_Allocate(); if ( !the_mutex ) { 10d283: 83 c4 10 add $0x10,%esp 10d286: 85 c0 test %eax,%eax 10d288: 0f 84 9a 00 00 00 je 10d328 _Thread_Enable_dispatch(); return EAGAIN; } the_mutex->process_shared = the_attr->process_shared; 10d28e: 8b 43 04 mov 0x4(%ebx),%eax 10d291: 89 47 10 mov %eax,0x10(%edi) the_mutex_attr = &the_mutex->Mutex.Attributes; 10d294: 8d 57 54 lea 0x54(%edi),%edx if ( the_attr->recursive ) the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; 10d297: 31 c0 xor %eax,%eax 10d299: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 10d29d: 0f 94 c0 sete %al 10d2a0: 89 47 54 mov %eax,0x54(%edi) else the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_IS_ERROR; the_mutex_attr->only_owner_release = true; 10d2a3: c6 47 58 01 movb $0x1,0x58(%edi) RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core( int priority ) { return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1); 10d2a7: 0f b6 05 9c 89 12 00 movzbl 0x12899c,%eax 10d2ae: 2b 43 08 sub 0x8(%ebx),%eax 10d2b1: 89 47 60 mov %eax,0x60(%edi) the_mutex_attr->priority_ceiling = _POSIX_Priority_To_core( the_attr->prio_ceiling ); the_mutex_attr->discipline = the_discipline; 10d2b4: 8b 45 e4 mov -0x1c(%ebp),%eax 10d2b7: 89 47 5c mov %eax,0x5c(%edi) /* * Must be initialized to unlocked. */ _CORE_mutex_Initialize( 10d2ba: 50 push %eax 10d2bb: 6a 01 push $0x1 10d2bd: 52 push %edx 10d2be: 8d 47 14 lea 0x14(%edi),%eax 10d2c1: 50 push %eax 10d2c2: e8 09 1d 00 00 call 10efd0 <_CORE_mutex_Initialize> uint32_t name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10d2c7: 8b 47 08 mov 0x8(%edi),%eax Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 10d2ca: 0f b7 c8 movzwl %ax,%ecx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10d2cd: 8b 15 dc d0 12 00 mov 0x12d0dc,%edx 10d2d3: 89 3c 8a mov %edi,(%edx,%ecx,4) _Objects_Get_index( the_object->id ), the_object ); /* ASSERT: information->is_string == false */ the_object->name.name_u32 = name; 10d2d6: c7 47 0c 00 00 00 00 movl $0x0,0xc(%edi) CORE_MUTEX_UNLOCKED ); _Objects_Open_u32( &_POSIX_Mutex_Information, &the_mutex->Object, 0 ); *mutex = the_mutex->Object.id; 10d2dd: 89 06 mov %eax,(%esi) _Thread_Enable_dispatch(); 10d2df: e8 8c 35 00 00 call 110870 <_Thread_Enable_dispatch> return 0; 10d2e4: 83 c4 10 add $0x10,%esp 10d2e7: 31 c0 xor %eax,%eax 10d2e9: eb 06 jmp 10d2f1 10d2eb: 90 nop case PTHREAD_MUTEX_ERRORCHECK: case PTHREAD_MUTEX_DEFAULT: break; default: return EINVAL; 10d2ec: b8 16 00 00 00 mov $0x16,%eax *mutex = the_mutex->Object.id; _Thread_Enable_dispatch(); return 0; } 10d2f1: 8d 65 f4 lea -0xc(%ebp),%esp 10d2f4: 5b pop %ebx 10d2f5: 5e pop %esi 10d2f6: 5f pop %edi 10d2f7: c9 leave 10d2f8: c3 ret 10d2f9: 8d 76 00 lea 0x0(%esi),%esi break; case PTHREAD_PRIO_INHERIT: the_discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; break; case PTHREAD_PRIO_PROTECT: the_discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING; 10d2fc: c7 45 e4 03 00 00 00 movl $0x3,-0x1c(%ebp) break; 10d303: e9 41 ff ff ff jmp 10d249 CORE_mutex_Attributes *the_mutex_attr; const pthread_mutexattr_t *the_attr; CORE_mutex_Disciplines the_discipline; if ( attr ) the_attr = attr; else the_attr = &_POSIX_Mutex_Default_attributes; 10d308: bb 40 d1 12 00 mov $0x12d140,%ebx 10d30d: e9 ed fe ff ff jmp 10d1ff 10d312: 66 90 xchg %ax,%ax /* * We only support process private mutexes. */ if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED ) return ENOSYS; 10d314: b8 58 00 00 00 mov $0x58,%eax 10d319: eb d6 jmp 10d2f1 10d31b: 90 nop switch ( the_attr->protocol ) { case PTHREAD_PRIO_NONE: the_discipline = CORE_MUTEX_DISCIPLINES_FIFO; break; case PTHREAD_PRIO_INHERIT: the_discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 10d31c: c7 45 e4 02 00 00 00 movl $0x2,-0x1c(%ebp) 10d323: e9 21 ff ff ff jmp 10d249 _Thread_Disable_dispatch(); the_mutex = _POSIX_Mutex_Allocate(); if ( !the_mutex ) { _Thread_Enable_dispatch(); 10d328: e8 43 35 00 00 call 110870 <_Thread_Enable_dispatch> return EAGAIN; 10d32d: b8 0b 00 00 00 mov $0xb,%eax 10d332: eb bd jmp 10d2f1 =============================================================================== 0010d440 : int pthread_mutex_timedlock( pthread_mutex_t *mutex, const struct timespec *abstime ) { 10d440: 55 push %ebp 10d441: 89 e5 mov %esp,%ebp 10d443: 56 push %esi 10d444: 53 push %ebx 10d445: 83 ec 18 sub $0x18,%esp 10d448: 8b 75 08 mov 0x8(%ebp),%esi * * If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID, * POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW, * then we should not wait. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); 10d44b: 8d 45 f4 lea -0xc(%ebp),%eax 10d44e: 50 push %eax 10d44f: ff 75 0c pushl 0xc(%ebp) 10d452: e8 cd 00 00 00 call 10d524 <_POSIX_Absolute_timeout_to_ticks> 10d457: 89 c3 mov %eax,%ebx if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE ) 10d459: 83 c4 10 add $0x10,%esp 10d45c: 83 f8 03 cmp $0x3,%eax 10d45f: 74 2f je 10d490 do_wait = false; lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks ); 10d461: 50 push %eax 10d462: ff 75 f4 pushl -0xc(%ebp) 10d465: 6a 00 push $0x0 10d467: 56 push %esi 10d468: e8 db fe ff ff call 10d348 <_POSIX_Mutex_Lock_support> * This service only gives us the option to block. We used a polling * attempt to lock if the abstime was not in the future. If we did * not obtain the mutex, then not look at the status immediately, * make sure the right reason is returned. */ if ( !do_wait && (lock_status == EBUSY) ) { 10d46d: 83 c4 10 add $0x10,%esp 10d470: 83 f8 10 cmp $0x10,%eax 10d473: 74 07 je 10d47c <== ALWAYS TAKEN status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; } return lock_status; } 10d475: 8d 65 f8 lea -0x8(%ebp),%esp 10d478: 5b pop %ebx 10d479: 5e pop %esi 10d47a: c9 leave 10d47b: c3 ret * attempt to lock if the abstime was not in the future. If we did * not obtain the mutex, then not look at the status immediately, * make sure the right reason is returned. */ if ( !do_wait && (lock_status == EBUSY) ) { if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) 10d47c: 85 db test %ebx,%ebx 10d47e: 74 28 je 10d4a8 <== NEVER TAKEN return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || 10d480: 4b dec %ebx 10d481: 83 fb 01 cmp $0x1,%ebx 10d484: 77 ef ja 10d475 <== NEVER TAKEN status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; 10d486: b8 74 00 00 00 mov $0x74,%eax 10d48b: eb e8 jmp 10d475 10d48d: 8d 76 00 lea 0x0(%esi),%esi */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE ) do_wait = false; lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks ); 10d490: 52 push %edx 10d491: ff 75 f4 pushl -0xc(%ebp) 10d494: 6a 01 push $0x1 10d496: 56 push %esi 10d497: e8 ac fe ff ff call 10d348 <_POSIX_Mutex_Lock_support> 10d49c: 83 c4 10 add $0x10,%esp status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; } return lock_status; } 10d49f: 8d 65 f8 lea -0x8(%ebp),%esp 10d4a2: 5b pop %ebx 10d4a3: 5e pop %esi 10d4a4: c9 leave 10d4a5: c3 ret 10d4a6: 66 90 xchg %ax,%ax * not obtain the mutex, then not look at the status immediately, * make sure the right reason is returned. */ if ( !do_wait && (lock_status == EBUSY) ) { if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) return EINVAL; 10d4a8: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED 10d4ad: eb c6 jmp 10d475 <== NOT EXECUTED =============================================================================== 0010cf24 : */ int pthread_mutexattr_destroy( pthread_mutexattr_t *attr ) { 10cf24: 55 push %ebp 10cf25: 89 e5 mov %esp,%ebp 10cf27: 8b 45 08 mov 0x8(%ebp),%eax if ( !attr || !attr->is_initialized ) 10cf2a: 85 c0 test %eax,%eax 10cf2c: 74 12 je 10cf40 10cf2e: 8b 10 mov (%eax),%edx 10cf30: 85 d2 test %edx,%edx 10cf32: 74 0c je 10cf40 return EINVAL; attr->is_initialized = false; 10cf34: c7 00 00 00 00 00 movl $0x0,(%eax) return 0; 10cf3a: 31 c0 xor %eax,%eax } 10cf3c: c9 leave 10cf3d: c3 ret 10cf3e: 66 90 xchg %ax,%ax int pthread_mutexattr_destroy( pthread_mutexattr_t *attr ) { if ( !attr || !attr->is_initialized ) return EINVAL; 10cf40: b8 16 00 00 00 mov $0x16,%eax attr->is_initialized = false; return 0; } 10cf45: c9 leave 10cf46: c3 ret =============================================================================== 0010cfec : int pthread_mutexattr_setprioceiling( pthread_mutexattr_t *attr, int prioceiling ) { 10cfec: 55 push %ebp 10cfed: 89 e5 mov %esp,%ebp 10cfef: 56 push %esi 10cff0: 53 push %ebx 10cff1: 8b 5d 08 mov 0x8(%ebp),%ebx 10cff4: 8b 75 0c mov 0xc(%ebp),%esi if ( !attr || !attr->is_initialized ) 10cff7: 85 db test %ebx,%ebx 10cff9: 74 06 je 10d001 <== NEVER TAKEN 10cffb: 8b 03 mov (%ebx),%eax 10cffd: 85 c0 test %eax,%eax 10cfff: 75 0f jne 10d010 return EINVAL; if ( !_POSIX_Priority_Is_valid( prioceiling ) ) return EINVAL; 10d001: b8 16 00 00 00 mov $0x16,%eax attr->prio_ceiling = prioceiling; return 0; } 10d006: 8d 65 f8 lea -0x8(%ebp),%esp 10d009: 5b pop %ebx 10d00a: 5e pop %esi 10d00b: c9 leave 10d00c: c3 ret 10d00d: 8d 76 00 lea 0x0(%esi),%esi ) { if ( !attr || !attr->is_initialized ) return EINVAL; if ( !_POSIX_Priority_Is_valid( prioceiling ) ) 10d010: 83 ec 0c sub $0xc,%esp 10d013: 56 push %esi 10d014: e8 93 05 00 00 call 10d5ac <_POSIX_Priority_Is_valid> 10d019: 83 c4 10 add $0x10,%esp 10d01c: 84 c0 test %al,%al 10d01e: 74 e1 je 10d001 return EINVAL; attr->prio_ceiling = prioceiling; 10d020: 89 73 08 mov %esi,0x8(%ebx) return 0; 10d023: 31 c0 xor %eax,%eax } 10d025: 8d 65 f8 lea -0x8(%ebp),%esp 10d028: 5b pop %ebx 10d029: 5e pop %esi 10d02a: c9 leave 10d02b: c3 ret =============================================================================== 0010d054 : int pthread_mutexattr_setpshared( pthread_mutexattr_t *attr, int pshared ) { 10d054: 55 push %ebp 10d055: 89 e5 mov %esp,%ebp 10d057: 8b 45 08 mov 0x8(%ebp),%eax 10d05a: 8b 55 0c mov 0xc(%ebp),%edx if ( !attr || !attr->is_initialized ) 10d05d: 85 c0 test %eax,%eax 10d05f: 74 0b je 10d06c 10d061: 8b 08 mov (%eax),%ecx 10d063: 85 c9 test %ecx,%ecx 10d065: 74 05 je 10d06c return EINVAL; switch ( pshared ) { 10d067: 83 fa 01 cmp $0x1,%edx 10d06a: 76 08 jbe 10d074 <== ALWAYS TAKEN case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; return 0; default: return EINVAL; 10d06c: b8 16 00 00 00 mov $0x16,%eax } } 10d071: c9 leave 10d072: c3 ret 10d073: 90 nop return EINVAL; switch ( pshared ) { case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; 10d074: 89 50 04 mov %edx,0x4(%eax) return 0; 10d077: 31 c0 xor %eax,%eax default: return EINVAL; } } 10d079: c9 leave 10d07a: c3 ret =============================================================================== 0010b248 : #if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES) int pthread_mutexattr_settype( pthread_mutexattr_t *attr, int type ) { 10b248: 55 push %ebp 10b249: 89 e5 mov %esp,%ebp 10b24b: 8b 45 08 mov 0x8(%ebp),%eax 10b24e: 8b 55 0c mov 0xc(%ebp),%edx if ( !attr || !attr->is_initialized ) 10b251: 85 c0 test %eax,%eax 10b253: 74 0b je 10b260 10b255: 8b 08 mov (%eax),%ecx 10b257: 85 c9 test %ecx,%ecx 10b259: 74 05 je 10b260 <== NEVER TAKEN return EINVAL; switch ( type ) { 10b25b: 83 fa 03 cmp $0x3,%edx 10b25e: 76 08 jbe 10b268 case PTHREAD_MUTEX_DEFAULT: attr->type = type; return 0; default: return EINVAL; 10b260: b8 16 00 00 00 mov $0x16,%eax } } 10b265: c9 leave 10b266: c3 ret 10b267: 90 nop switch ( type ) { case PTHREAD_MUTEX_NORMAL: case PTHREAD_MUTEX_RECURSIVE: case PTHREAD_MUTEX_ERRORCHECK: case PTHREAD_MUTEX_DEFAULT: attr->type = type; 10b268: 89 50 10 mov %edx,0x10(%eax) return 0; 10b26b: 31 c0 xor %eax,%eax default: return EINVAL; } } 10b26d: c9 leave 10b26e: c3 ret =============================================================================== 0010bd9c : int pthread_once( pthread_once_t *once_control, void (*init_routine)(void) ) { 10bd9c: 55 push %ebp 10bd9d: 89 e5 mov %esp,%ebp 10bd9f: 57 push %edi 10bda0: 56 push %esi 10bda1: 53 push %ebx 10bda2: 83 ec 1c sub $0x1c,%esp 10bda5: 8b 5d 08 mov 0x8(%ebp),%ebx 10bda8: 8b 75 0c mov 0xc(%ebp),%esi if ( !once_control || !init_routine ) 10bdab: 85 db test %ebx,%ebx 10bdad: 74 51 je 10be00 10bdaf: 85 f6 test %esi,%esi 10bdb1: 74 4d je 10be00 return EINVAL; if ( !once_control->init_executed ) { 10bdb3: 8b 7b 04 mov 0x4(%ebx),%edi 10bdb6: 85 ff test %edi,%edi 10bdb8: 74 0a je 10bdc4 once_control->init_executed = true; (*init_routine)(); } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); } return 0; 10bdba: 31 c0 xor %eax,%eax } 10bdbc: 8d 65 f4 lea -0xc(%ebp),%esp 10bdbf: 5b pop %ebx 10bdc0: 5e pop %esi 10bdc1: 5f pop %edi 10bdc2: c9 leave 10bdc3: c3 ret if ( !once_control || !init_routine ) return EINVAL; if ( !once_control->init_executed ) { rtems_mode saveMode; rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode); 10bdc4: 51 push %ecx 10bdc5: 8d 7d e4 lea -0x1c(%ebp),%edi 10bdc8: 57 push %edi 10bdc9: 68 00 01 00 00 push $0x100 10bdce: 68 00 01 00 00 push $0x100 10bdd3: e8 ec 0b 00 00 call 10c9c4 if ( !once_control->init_executed ) { 10bdd8: 83 c4 10 add $0x10,%esp 10bddb: 8b 53 04 mov 0x4(%ebx),%edx 10bdde: 85 d2 test %edx,%edx 10bde0: 74 2e je 10be10 <== ALWAYS TAKEN once_control->is_initialized = true; once_control->init_executed = true; (*init_routine)(); } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); 10bde2: 50 push %eax 10bde3: 57 push %edi 10bde4: 68 00 01 00 00 push $0x100 10bde9: ff 75 e4 pushl -0x1c(%ebp) 10bdec: e8 d3 0b 00 00 call 10c9c4 10bdf1: 83 c4 10 add $0x10,%esp } return 0; 10bdf4: 31 c0 xor %eax,%eax } 10bdf6: 8d 65 f4 lea -0xc(%ebp),%esp 10bdf9: 5b pop %ebx 10bdfa: 5e pop %esi 10bdfb: 5f pop %edi 10bdfc: c9 leave 10bdfd: c3 ret 10bdfe: 66 90 xchg %ax,%ax pthread_once_t *once_control, void (*init_routine)(void) ) { if ( !once_control || !init_routine ) return EINVAL; 10be00: b8 16 00 00 00 mov $0x16,%eax (*init_routine)(); } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); } return 0; } 10be05: 8d 65 f4 lea -0xc(%ebp),%esp 10be08: 5b pop %ebx 10be09: 5e pop %esi 10be0a: 5f pop %edi 10be0b: c9 leave 10be0c: c3 ret 10be0d: 8d 76 00 lea 0x0(%esi),%esi if ( !once_control->init_executed ) { rtems_mode saveMode; rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode); if ( !once_control->init_executed ) { once_control->is_initialized = true; 10be10: c7 03 01 00 00 00 movl $0x1,(%ebx) once_control->init_executed = true; 10be16: c7 43 04 01 00 00 00 movl $0x1,0x4(%ebx) (*init_routine)(); 10be1d: ff d6 call *%esi 10be1f: eb c1 jmp 10bde2 =============================================================================== 0010c480 : */ int pthread_rwlock_destroy( pthread_rwlock_t *rwlock ) { 10c480: 55 push %ebp 10c481: 89 e5 mov %esp,%ebp 10c483: 53 push %ebx 10c484: 83 ec 14 sub $0x14,%esp 10c487: 8b 45 08 mov 0x8(%ebp),%eax POSIX_RWLock_Control *the_rwlock = NULL; Objects_Locations location; if ( !rwlock ) 10c48a: 85 c0 test %eax,%eax 10c48c: 74 42 je 10c4d0 RTEMS_INLINE_ROUTINE POSIX_RWLock_Control *_POSIX_RWLock_Get ( pthread_rwlock_t *RWLock, Objects_Locations *location ) { return (POSIX_RWLock_Control *) _Objects_Get( 10c48e: 53 push %ebx return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); 10c48f: 8d 55 f4 lea -0xc(%ebp),%edx 10c492: 52 push %edx 10c493: ff 30 pushl (%eax) 10c495: 68 80 b9 12 00 push $0x12b980 10c49a: e8 d9 2b 00 00 call 10f078 <_Objects_Get> 10c49f: 89 c3 mov %eax,%ebx switch ( location ) { 10c4a1: 83 c4 10 add $0x10,%esp 10c4a4: 8b 4d f4 mov -0xc(%ebp),%ecx 10c4a7: 85 c9 test %ecx,%ecx 10c4a9: 75 25 jne 10c4d0 case OBJECTS_LOCAL: /* * If there is at least one thread waiting, then do not delete it. */ if ( _Thread_queue_First( &the_rwlock->RWLock.Wait_queue ) != NULL ) { 10c4ab: 83 ec 0c sub $0xc,%esp 10c4ae: 8d 40 10 lea 0x10(%eax),%eax 10c4b1: 50 push %eax 10c4b2: e8 05 3f 00 00 call 1103bc <_Thread_queue_First> 10c4b7: 83 c4 10 add $0x10,%esp 10c4ba: 85 c0 test %eax,%eax 10c4bc: 74 1e je 10c4dc _Thread_Enable_dispatch(); 10c4be: e8 2d 37 00 00 call 10fbf0 <_Thread_Enable_dispatch> return EBUSY; 10c4c3: b8 10 00 00 00 mov $0x10,%eax case OBJECTS_ERROR: break; } return EINVAL; } 10c4c8: 8b 5d fc mov -0x4(%ebp),%ebx 10c4cb: c9 leave 10c4cc: c3 ret 10c4cd: 8d 76 00 lea 0x0(%esi),%esi #endif case OBJECTS_ERROR: break; } return EINVAL; 10c4d0: b8 16 00 00 00 mov $0x16,%eax } 10c4d5: 8b 5d fc mov -0x4(%ebp),%ebx 10c4d8: c9 leave 10c4d9: c3 ret 10c4da: 66 90 xchg %ax,%ax /* * POSIX doesn't require behavior when it is locked. */ _Objects_Close( &_POSIX_RWLock_Information, &the_rwlock->Object ); 10c4dc: 83 ec 08 sub $0x8,%esp 10c4df: 53 push %ebx 10c4e0: 68 80 b9 12 00 push $0x12b980 10c4e5: e8 56 27 00 00 call 10ec40 <_Objects_Close> */ RTEMS_INLINE_ROUTINE void _POSIX_RWLock_Free ( POSIX_RWLock_Control *the_RWLock ) { _Objects_Free( &_POSIX_RWLock_Information, &the_RWLock->Object ); 10c4ea: 58 pop %eax 10c4eb: 5a pop %edx 10c4ec: 53 push %ebx 10c4ed: 68 80 b9 12 00 push $0x12b980 10c4f2: e8 41 2a 00 00 call 10ef38 <_Objects_Free> _POSIX_RWLock_Free( the_rwlock ); _Thread_Enable_dispatch(); 10c4f7: e8 f4 36 00 00 call 10fbf0 <_Thread_Enable_dispatch> return 0; 10c4fc: 83 c4 10 add $0x10,%esp 10c4ff: 31 c0 xor %eax,%eax 10c501: eb d2 jmp 10c4d5 =============================================================================== 0010c504 : int pthread_rwlock_init( pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr ) { 10c504: 55 push %ebp 10c505: 89 e5 mov %esp,%ebp 10c507: 56 push %esi 10c508: 53 push %ebx 10c509: 83 ec 20 sub $0x20,%esp 10c50c: 8b 5d 08 mov 0x8(%ebp),%ebx 10c50f: 8b 75 0c mov 0xc(%ebp),%esi const pthread_rwlockattr_t *the_attr; /* * Error check parameters */ if ( !rwlock ) 10c512: 85 db test %ebx,%ebx 10c514: 74 15 je 10c52b return EINVAL; /* * If the user passed in NULL, use the default attributes */ if ( attr ) { 10c516: 85 f6 test %esi,%esi 10c518: 0f 84 8e 00 00 00 je 10c5ac } /* * Now start error checking the attributes that we are going to use */ if ( !the_attr->is_initialized ) 10c51e: 8b 16 mov (%esi),%edx 10c520: 85 d2 test %edx,%edx 10c522: 74 07 je 10c52b <== NEVER TAKEN return EINVAL; switch ( the_attr->process_shared ) { 10c524: 8b 46 04 mov 0x4(%esi),%eax 10c527: 85 c0 test %eax,%eax 10c529: 74 0d je 10c538 <== ALWAYS TAKEN case PTHREAD_PROCESS_PRIVATE: /* only supported values */ break; case PTHREAD_PROCESS_SHARED: default: return EINVAL; 10c52b: b8 16 00 00 00 mov $0x16,%eax *rwlock = the_rwlock->Object.id; _Thread_Enable_dispatch(); return 0; } 10c530: 8d 65 f8 lea -0x8(%ebp),%esp 10c533: 5b pop %ebx 10c534: 5e pop %esi 10c535: c9 leave 10c536: c3 ret 10c537: 90 nop */ RTEMS_INLINE_ROUTINE void _CORE_RWLock_Initialize_attributes( CORE_RWLock_Attributes *the_attributes ) { the_attributes->XXX = 0; 10c538: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10c53f: a1 30 b7 12 00 mov 0x12b730,%eax 10c544: 40 inc %eax 10c545: a3 30 b7 12 00 mov %eax,0x12b730 * the inactive chain of free RWLock control blocks. */ RTEMS_INLINE_ROUTINE POSIX_RWLock_Control *_POSIX_RWLock_Allocate( void ) { return (POSIX_RWLock_Control *) _Objects_Allocate( &_POSIX_RWLock_Information ); 10c54a: 83 ec 0c sub $0xc,%esp 10c54d: 68 80 b9 12 00 push $0x12b980 10c552: e8 6d 26 00 00 call 10ebc4 <_Objects_Allocate> */ _Thread_Disable_dispatch(); /* prevents deletion */ the_rwlock = _POSIX_RWLock_Allocate(); if ( !the_rwlock ) { 10c557: 83 c4 10 add $0x10,%esp 10c55a: 85 c0 test %eax,%eax 10c55c: 74 42 je 10c5a0 _Thread_Enable_dispatch(); return EAGAIN; } _CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes ); 10c55e: 83 ec 08 sub $0x8,%esp 10c561: 8d 55 f4 lea -0xc(%ebp),%edx 10c564: 52 push %edx 10c565: 8d 50 10 lea 0x10(%eax),%edx 10c568: 52 push %edx 10c569: 89 45 e4 mov %eax,-0x1c(%ebp) 10c56c: e8 3b 1e 00 00 call 10e3ac <_CORE_RWLock_Initialize> uint32_t name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10c571: 8b 45 e4 mov -0x1c(%ebp),%eax 10c574: 8b 50 08 mov 0x8(%eax),%edx Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 10c577: 0f b7 f2 movzwl %dx,%esi #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10c57a: 8b 0d 9c b9 12 00 mov 0x12b99c,%ecx 10c580: 89 04 b1 mov %eax,(%ecx,%esi,4) _Objects_Get_index( the_object->id ), the_object ); /* ASSERT: information->is_string == false */ the_object->name.name_u32 = name; 10c583: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) &_POSIX_RWLock_Information, &the_rwlock->Object, 0 ); *rwlock = the_rwlock->Object.id; 10c58a: 89 13 mov %edx,(%ebx) _Thread_Enable_dispatch(); 10c58c: e8 5f 36 00 00 call 10fbf0 <_Thread_Enable_dispatch> return 0; 10c591: 83 c4 10 add $0x10,%esp 10c594: 31 c0 xor %eax,%eax } 10c596: 8d 65 f8 lea -0x8(%ebp),%esp 10c599: 5b pop %ebx 10c59a: 5e pop %esi 10c59b: c9 leave 10c59c: c3 ret 10c59d: 8d 76 00 lea 0x0(%esi),%esi _Thread_Disable_dispatch(); /* prevents deletion */ the_rwlock = _POSIX_RWLock_Allocate(); if ( !the_rwlock ) { _Thread_Enable_dispatch(); 10c5a0: e8 4b 36 00 00 call 10fbf0 <_Thread_Enable_dispatch> return EAGAIN; 10c5a5: b8 0b 00 00 00 mov $0xb,%eax 10c5aa: eb 84 jmp 10c530 * If the user passed in NULL, use the default attributes */ if ( attr ) { the_attr = attr; } else { (void) pthread_rwlockattr_init( &default_attr ); 10c5ac: 83 ec 0c sub $0xc,%esp 10c5af: 8d 75 ec lea -0x14(%ebp),%esi 10c5b2: 56 push %esi 10c5b3: e8 84 09 00 00 call 10cf3c 10c5b8: 83 c4 10 add $0x10,%esp 10c5bb: e9 5e ff ff ff jmp 10c51e =============================================================================== 0010c628 : int pthread_rwlock_timedrdlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) { 10c628: 55 push %ebp 10c629: 89 e5 mov %esp,%ebp 10c62b: 56 push %esi 10c62c: 53 push %ebx 10c62d: 83 ec 20 sub $0x20,%esp 10c630: 8b 5d 08 mov 0x8(%ebp),%ebx Objects_Locations location; Watchdog_Interval ticks; bool do_wait = true; POSIX_Absolute_timeout_conversion_results_t status; if ( !rwlock ) 10c633: 85 db test %ebx,%ebx 10c635: 74 7d je 10c6b4 * * If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID, * POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW, * then we should not wait. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); 10c637: 83 ec 08 sub $0x8,%esp 10c63a: 8d 45 f0 lea -0x10(%ebp),%eax 10c63d: 50 push %eax 10c63e: ff 75 0c pushl 0xc(%ebp) 10c641: e8 de 62 00 00 call 112924 <_POSIX_Absolute_timeout_to_ticks> 10c646: 89 c6 mov %eax,%esi 10c648: 83 c4 0c add $0xc,%esp if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE ) do_wait = false; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); 10c64b: 8d 45 f4 lea -0xc(%ebp),%eax 10c64e: 50 push %eax 10c64f: ff 33 pushl (%ebx) 10c651: 68 80 b9 12 00 push $0x12b980 10c656: e8 1d 2a 00 00 call 10f078 <_Objects_Get> switch ( location ) { 10c65b: 83 c4 10 add $0x10,%esp 10c65e: 8b 55 f4 mov -0xc(%ebp),%edx 10c661: 85 d2 test %edx,%edx 10c663: 75 4f jne 10c6b4 int _EXFUN(pthread_rwlock_init, (pthread_rwlock_t *__rwlock, _CONST pthread_rwlockattr_t *__attr)); int _EXFUN(pthread_rwlock_destroy, (pthread_rwlock_t *__rwlock)); int _EXFUN(pthread_rwlock_rdlock,(pthread_rwlock_t *__rwlock)); int _EXFUN(pthread_rwlock_tryrdlock,(pthread_rwlock_t *__rwlock)); int _EXFUN(pthread_rwlock_timedrdlock, 10c665: 83 fe 03 cmp $0x3,%esi 10c668: 0f 94 c2 sete %dl case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_reading( 10c66b: 83 ec 0c sub $0xc,%esp 10c66e: 6a 00 push $0x0 10c670: ff 75 f0 pushl -0x10(%ebp) 10c673: 0f b6 ca movzbl %dl,%ecx 10c676: 51 push %ecx 10c677: ff 33 pushl (%ebx) 10c679: 83 c0 10 add $0x10,%eax 10c67c: 50 push %eax 10c67d: 88 55 e4 mov %dl,-0x1c(%ebp) 10c680: e8 5b 1d 00 00 call 10e3e0 <_CORE_RWLock_Obtain_for_reading> do_wait, ticks, NULL ); _Thread_Enable_dispatch(); 10c685: 83 c4 20 add $0x20,%esp 10c688: e8 63 35 00 00 call 10fbf0 <_Thread_Enable_dispatch> if ( !do_wait ) { 10c68d: 8a 55 e4 mov -0x1c(%ebp),%dl 10c690: 84 d2 test %dl,%dl 10c692: 75 40 jne 10c6d4 if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) { 10c694: a1 d8 bc 12 00 mov 0x12bcd8,%eax 10c699: 8b 40 34 mov 0x34(%eax),%eax 10c69c: 83 f8 02 cmp $0x2,%eax 10c69f: 74 1f je 10c6c0 status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; } } return _POSIX_RWLock_Translate_core_RWLock_return_code( 10c6a1: 83 ec 0c sub $0xc,%esp 10c6a4: 50 push %eax 10c6a5: e8 ee 00 00 00 call 10c798 <_POSIX_RWLock_Translate_core_RWLock_return_code> 10c6aa: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return EINVAL; } 10c6ad: 8d 65 f8 lea -0x8(%ebp),%esp 10c6b0: 5b pop %ebx 10c6b1: 5e pop %esi 10c6b2: c9 leave 10c6b3: c3 ret _Thread_Enable_dispatch(); if ( !do_wait ) { if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) { if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) return EINVAL; 10c6b4: b8 16 00 00 00 mov $0x16,%eax case OBJECTS_ERROR: break; } return EINVAL; } 10c6b9: 8d 65 f8 lea -0x8(%ebp),%esp 10c6bc: 5b pop %ebx 10c6bd: 5e pop %esi 10c6be: c9 leave 10c6bf: c3 ret ); _Thread_Enable_dispatch(); if ( !do_wait ) { if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) { if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) 10c6c0: 85 f6 test %esi,%esi 10c6c2: 74 f0 je 10c6b4 <== NEVER TAKEN return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || 10c6c4: 4e dec %esi 10c6c5: 83 fe 01 cmp $0x1,%esi 10c6c8: 77 d7 ja 10c6a1 <== NEVER TAKEN status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; 10c6ca: b8 74 00 00 00 mov $0x74,%eax 10c6cf: eb e8 jmp 10c6b9 10c6d1: 8d 76 00 lea 0x0(%esi),%esi ticks, NULL ); _Thread_Enable_dispatch(); if ( !do_wait ) { 10c6d4: a1 d8 bc 12 00 mov 0x12bcd8,%eax 10c6d9: 8b 40 34 mov 0x34(%eax),%eax 10c6dc: eb c3 jmp 10c6a1 =============================================================================== 0010c6e0 : int pthread_rwlock_timedwrlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) { 10c6e0: 55 push %ebp 10c6e1: 89 e5 mov %esp,%ebp 10c6e3: 56 push %esi 10c6e4: 53 push %ebx 10c6e5: 83 ec 20 sub $0x20,%esp 10c6e8: 8b 5d 08 mov 0x8(%ebp),%ebx Objects_Locations location; Watchdog_Interval ticks; bool do_wait = true; POSIX_Absolute_timeout_conversion_results_t status; if ( !rwlock ) 10c6eb: 85 db test %ebx,%ebx 10c6ed: 74 7d je 10c76c * * If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID, * POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW, * then we should not wait. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); 10c6ef: 83 ec 08 sub $0x8,%esp 10c6f2: 8d 45 f0 lea -0x10(%ebp),%eax 10c6f5: 50 push %eax 10c6f6: ff 75 0c pushl 0xc(%ebp) 10c6f9: e8 26 62 00 00 call 112924 <_POSIX_Absolute_timeout_to_ticks> 10c6fe: 89 c6 mov %eax,%esi 10c700: 83 c4 0c add $0xc,%esp if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE ) do_wait = false; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); 10c703: 8d 45 f4 lea -0xc(%ebp),%eax 10c706: 50 push %eax 10c707: ff 33 pushl (%ebx) 10c709: 68 80 b9 12 00 push $0x12b980 10c70e: e8 65 29 00 00 call 10f078 <_Objects_Get> switch ( location ) { 10c713: 83 c4 10 add $0x10,%esp 10c716: 8b 55 f4 mov -0xc(%ebp),%edx 10c719: 85 d2 test %edx,%edx 10c71b: 75 4f jne 10c76c (pthread_rwlock_t *__rwlock, _CONST struct timespec *__abstime)); int _EXFUN(pthread_rwlock_unlock,(pthread_rwlock_t *__rwlock)); int _EXFUN(pthread_rwlock_wrlock,(pthread_rwlock_t *__rwlock)); int _EXFUN(pthread_rwlock_trywrlock,(pthread_rwlock_t *__rwlock)); int _EXFUN(pthread_rwlock_timedwrlock, 10c71d: 83 fe 03 cmp $0x3,%esi 10c720: 0f 94 c2 sete %dl case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_writing( 10c723: 83 ec 0c sub $0xc,%esp 10c726: 6a 00 push $0x0 10c728: ff 75 f0 pushl -0x10(%ebp) 10c72b: 0f b6 ca movzbl %dl,%ecx 10c72e: 51 push %ecx 10c72f: ff 33 pushl (%ebx) 10c731: 83 c0 10 add $0x10,%eax 10c734: 50 push %eax 10c735: 88 55 e4 mov %dl,-0x1c(%ebp) 10c738: e8 6b 1d 00 00 call 10e4a8 <_CORE_RWLock_Obtain_for_writing> do_wait, ticks, NULL ); _Thread_Enable_dispatch(); 10c73d: 83 c4 20 add $0x20,%esp 10c740: e8 ab 34 00 00 call 10fbf0 <_Thread_Enable_dispatch> if ( !do_wait && 10c745: 8a 55 e4 mov -0x1c(%ebp),%dl 10c748: 84 d2 test %dl,%dl 10c74a: 75 40 jne 10c78c (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { 10c74c: a1 d8 bc 12 00 mov 0x12bcd8,%eax 10c751: 8b 40 34 mov 0x34(%eax),%eax ticks, NULL ); _Thread_Enable_dispatch(); if ( !do_wait && 10c754: 83 f8 02 cmp $0x2,%eax 10c757: 74 1f je 10c778 if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; } return _POSIX_RWLock_Translate_core_RWLock_return_code( 10c759: 83 ec 0c sub $0xc,%esp 10c75c: 50 push %eax 10c75d: e8 36 00 00 00 call 10c798 <_POSIX_RWLock_Translate_core_RWLock_return_code> 10c762: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return EINVAL; } 10c765: 8d 65 f8 lea -0x8(%ebp),%esp 10c768: 5b pop %ebx 10c769: 5e pop %esi 10c76a: c9 leave 10c76b: c3 ret _Thread_Enable_dispatch(); if ( !do_wait && (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) return EINVAL; 10c76c: b8 16 00 00 00 mov $0x16,%eax case OBJECTS_ERROR: break; } return EINVAL; } 10c771: 8d 65 f8 lea -0x8(%ebp),%esp 10c774: 5b pop %ebx 10c775: 5e pop %esi 10c776: c9 leave 10c777: c3 ret ); _Thread_Enable_dispatch(); if ( !do_wait && (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) 10c778: 85 f6 test %esi,%esi 10c77a: 74 f0 je 10c76c <== NEVER TAKEN return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || 10c77c: 4e dec %esi 10c77d: 83 fe 01 cmp $0x1,%esi 10c780: 77 d7 ja 10c759 <== NEVER TAKEN status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; 10c782: b8 74 00 00 00 mov $0x74,%eax 10c787: eb e8 jmp 10c771 10c789: 8d 76 00 lea 0x0(%esi),%esi ticks, NULL ); _Thread_Enable_dispatch(); if ( !do_wait && 10c78c: a1 d8 bc 12 00 mov 0x12bcd8,%eax 10c791: 8b 40 34 mov 0x34(%eax),%eax 10c794: eb c3 jmp 10c759 =============================================================================== 0010cef4 : */ int pthread_rwlockattr_destroy( pthread_rwlockattr_t *attr ) { 10cef4: 55 push %ebp 10cef5: 89 e5 mov %esp,%ebp 10cef7: 8b 45 08 mov 0x8(%ebp),%eax if ( !attr || attr->is_initialized == false ) 10cefa: 85 c0 test %eax,%eax 10cefc: 74 12 je 10cf10 10cefe: 8b 10 mov (%eax),%edx 10cf00: 85 d2 test %edx,%edx 10cf02: 74 0c je 10cf10 return EINVAL; attr->is_initialized = false; 10cf04: c7 00 00 00 00 00 movl $0x0,(%eax) return 0; 10cf0a: 31 c0 xor %eax,%eax } 10cf0c: c9 leave 10cf0d: c3 ret 10cf0e: 66 90 xchg %ax,%ax int pthread_rwlockattr_destroy( pthread_rwlockattr_t *attr ) { if ( !attr || attr->is_initialized == false ) return EINVAL; 10cf10: b8 16 00 00 00 mov $0x16,%eax attr->is_initialized = false; return 0; } 10cf15: c9 leave 10cf16: c3 ret =============================================================================== 0010cf60 : int pthread_rwlockattr_setpshared( pthread_rwlockattr_t *attr, int pshared ) { 10cf60: 55 push %ebp 10cf61: 89 e5 mov %esp,%ebp 10cf63: 8b 45 08 mov 0x8(%ebp),%eax 10cf66: 8b 55 0c mov 0xc(%ebp),%edx if ( !attr ) 10cf69: 85 c0 test %eax,%eax 10cf6b: 74 0b je 10cf78 return EINVAL; if ( !attr->is_initialized ) 10cf6d: 8b 08 mov (%eax),%ecx 10cf6f: 85 c9 test %ecx,%ecx 10cf71: 74 05 je 10cf78 return EINVAL; switch ( pshared ) { 10cf73: 83 fa 01 cmp $0x1,%edx 10cf76: 76 08 jbe 10cf80 <== ALWAYS TAKEN case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; return 0; default: return EINVAL; 10cf78: b8 16 00 00 00 mov $0x16,%eax } } 10cf7d: c9 leave 10cf7e: c3 ret 10cf7f: 90 nop return EINVAL; switch ( pshared ) { case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; 10cf80: 89 50 04 mov %edx,0x4(%eax) return 0; 10cf83: 31 c0 xor %eax,%eax default: return EINVAL; } } 10cf85: c9 leave 10cf86: c3 ret =============================================================================== 0010b214 : int pthread_setcancelstate( int state, int *oldstate ) { 10b214: 55 push %ebp 10b215: 89 e5 mov %esp,%ebp 10b217: 53 push %ebx 10b218: 83 ec 04 sub $0x4,%esp 10b21b: 8b 55 08 mov 0x8(%ebp),%edx 10b21e: 8b 45 0c mov 0xc(%ebp),%eax * Don't even think about deleting a resource from an ISR. * Besides this request is supposed to be for _Thread_Executing * and the ISR context is not a thread. */ if ( _ISR_Is_in_progress() ) 10b221: 8b 0d 54 96 12 00 mov 0x129654,%ecx 10b227: 85 c9 test %ecx,%ecx 10b229: 75 15 jne 10b240 return EPROTO; if ( !oldstate ) 10b22b: 85 c0 test %eax,%eax 10b22d: 74 05 je 10b234 return EINVAL; if ( state != PTHREAD_CANCEL_ENABLE && state != PTHREAD_CANCEL_DISABLE ) 10b22f: 83 fa 01 cmp $0x1,%edx 10b232: 76 18 jbe 10b24c return EINVAL; 10b234: b8 16 00 00 00 mov $0x16,%eax /* * _Thread_Enable_dispatch is invoked by above call. */ return 0; } 10b239: 8b 5d fc mov -0x4(%ebp),%ebx 10b23c: c9 leave 10b23d: c3 ret 10b23e: 66 90 xchg %ax,%ax * Besides this request is supposed to be for _Thread_Executing * and the ISR context is not a thread. */ if ( _ISR_Is_in_progress() ) return EPROTO; 10b240: b8 47 00 00 00 mov $0x47,%eax /* * _Thread_Enable_dispatch is invoked by above call. */ return 0; } 10b245: 8b 5d fc mov -0x4(%ebp),%ebx 10b248: c9 leave 10b249: c3 ret 10b24a: 66 90 xchg %ax,%ax return EINVAL; if ( state != PTHREAD_CANCEL_ENABLE && state != PTHREAD_CANCEL_DISABLE ) return EINVAL; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 10b24c: 8b 0d 58 96 12 00 mov 0x129658,%ecx 10b252: 8b 89 ec 00 00 00 mov 0xec(%ecx),%ecx rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10b258: 8b 1d b0 90 12 00 mov 0x1290b0,%ebx 10b25e: 43 inc %ebx 10b25f: 89 1d b0 90 12 00 mov %ebx,0x1290b0 _Thread_Disable_dispatch(); *oldstate = thread_support->cancelability_state; 10b265: 8b 99 d8 00 00 00 mov 0xd8(%ecx),%ebx 10b26b: 89 18 mov %ebx,(%eax) thread_support->cancelability_state = state; 10b26d: 89 91 d8 00 00 00 mov %edx,0xd8(%ecx) _POSIX_Thread_Evaluate_cancellation_and_enable_dispatch(_Thread_Executing); 10b273: 83 ec 0c sub $0xc,%esp 10b276: ff 35 58 96 12 00 pushl 0x129658 10b27c: e8 7b 54 00 00 call 1106fc <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch> /* * _Thread_Enable_dispatch is invoked by above call. */ return 0; 10b281: 83 c4 10 add $0x10,%esp 10b284: 31 c0 xor %eax,%eax } 10b286: 8b 5d fc mov -0x4(%ebp),%ebx 10b289: c9 leave 10b28a: c3 ret =============================================================================== 0010b28c : int pthread_setcanceltype( int type, int *oldtype ) { 10b28c: 55 push %ebp 10b28d: 89 e5 mov %esp,%ebp 10b28f: 53 push %ebx 10b290: 83 ec 04 sub $0x4,%esp 10b293: 8b 55 08 mov 0x8(%ebp),%edx 10b296: 8b 45 0c mov 0xc(%ebp),%eax * Don't even think about deleting a resource from an ISR. * Besides this request is supposed to be for _Thread_Executing * and the ISR context is not a thread. */ if ( _ISR_Is_in_progress() ) 10b299: 8b 0d 54 96 12 00 mov 0x129654,%ecx 10b29f: 85 c9 test %ecx,%ecx 10b2a1: 75 15 jne 10b2b8 return EPROTO; if ( !oldtype ) 10b2a3: 85 c0 test %eax,%eax 10b2a5: 74 05 je 10b2ac return EINVAL; if ( type != PTHREAD_CANCEL_DEFERRED && type != PTHREAD_CANCEL_ASYNCHRONOUS ) 10b2a7: 83 fa 01 cmp $0x1,%edx 10b2aa: 76 18 jbe 10b2c4 return EINVAL; 10b2ac: b8 16 00 00 00 mov $0x16,%eax /* * _Thread_Enable_dispatch is invoked by above call. */ return 0; } 10b2b1: 8b 5d fc mov -0x4(%ebp),%ebx 10b2b4: c9 leave 10b2b5: c3 ret 10b2b6: 66 90 xchg %ax,%ax * Besides this request is supposed to be for _Thread_Executing * and the ISR context is not a thread. */ if ( _ISR_Is_in_progress() ) return EPROTO; 10b2b8: b8 47 00 00 00 mov $0x47,%eax /* * _Thread_Enable_dispatch is invoked by above call. */ return 0; } 10b2bd: 8b 5d fc mov -0x4(%ebp),%ebx 10b2c0: c9 leave 10b2c1: c3 ret 10b2c2: 66 90 xchg %ax,%ax return EINVAL; if ( type != PTHREAD_CANCEL_DEFERRED && type != PTHREAD_CANCEL_ASYNCHRONOUS ) return EINVAL; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 10b2c4: 8b 0d 58 96 12 00 mov 0x129658,%ecx 10b2ca: 8b 89 ec 00 00 00 mov 0xec(%ecx),%ecx 10b2d0: 8b 1d b0 90 12 00 mov 0x1290b0,%ebx 10b2d6: 43 inc %ebx 10b2d7: 89 1d b0 90 12 00 mov %ebx,0x1290b0 _Thread_Disable_dispatch(); *oldtype = thread_support->cancelability_type; 10b2dd: 8b 99 dc 00 00 00 mov 0xdc(%ecx),%ebx 10b2e3: 89 18 mov %ebx,(%eax) thread_support->cancelability_type = type; 10b2e5: 89 91 dc 00 00 00 mov %edx,0xdc(%ecx) _POSIX_Thread_Evaluate_cancellation_and_enable_dispatch(_Thread_Executing); 10b2eb: 83 ec 0c sub $0xc,%esp 10b2ee: ff 35 58 96 12 00 pushl 0x129658 10b2f4: e8 03 54 00 00 call 1106fc <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch> /* * _Thread_Enable_dispatch is invoked by above call. */ return 0; 10b2f9: 83 c4 10 add $0x10,%esp 10b2fc: 31 c0 xor %eax,%eax } 10b2fe: 8b 5d fc mov -0x4(%ebp),%ebx 10b301: c9 leave 10b302: c3 ret =============================================================================== 0010dd14 : int pthread_setschedparam( pthread_t thread, int policy, struct sched_param *param ) { 10dd14: 55 push %ebp 10dd15: 89 e5 mov %esp,%ebp 10dd17: 57 push %edi 10dd18: 56 push %esi 10dd19: 53 push %ebx 10dd1a: 83 ec 2c sub $0x2c,%esp 10dd1d: 8b 75 10 mov 0x10(%ebp),%esi int rc; /* * Check all the parameters */ if ( !param ) 10dd20: 85 f6 test %esi,%esi 10dd22: 0f 84 cc 00 00 00 je 10ddf4 return EINVAL; rc = _POSIX_Thread_Translate_sched_param( 10dd28: 8d 45 e0 lea -0x20(%ebp),%eax 10dd2b: 50 push %eax 10dd2c: 8d 45 e4 lea -0x1c(%ebp),%eax 10dd2f: 50 push %eax 10dd30: 56 push %esi 10dd31: ff 75 0c pushl 0xc(%ebp) 10dd34: e8 17 5c 00 00 call 113950 <_POSIX_Thread_Translate_sched_param> 10dd39: 89 c3 mov %eax,%ebx policy, param, &budget_algorithm, &budget_callout ); if ( rc ) 10dd3b: 83 c4 10 add $0x10,%esp 10dd3e: 85 c0 test %eax,%eax 10dd40: 74 0a je 10dd4c case OBJECTS_ERROR: break; } return ESRCH; } 10dd42: 89 d8 mov %ebx,%eax 10dd44: 8d 65 f4 lea -0xc(%ebp),%esp 10dd47: 5b pop %ebx 10dd48: 5e pop %esi 10dd49: 5f pop %edi 10dd4a: c9 leave 10dd4b: c3 ret 10dd4c: 50 push %eax return rc; /* * Actually change the scheduling policy and parameters */ the_thread = _POSIX_Threads_Get( thread, &location ); 10dd4d: 8d 45 dc lea -0x24(%ebp),%eax 10dd50: 50 push %eax 10dd51: ff 75 08 pushl 0x8(%ebp) 10dd54: 68 80 cf 12 00 push $0x12cf80 10dd59: e8 9a 1f 00 00 call 10fcf8 <_Objects_Get> 10dd5e: 89 c2 mov %eax,%edx switch ( location ) { 10dd60: 83 c4 10 add $0x10,%esp 10dd63: 8b 7d dc mov -0x24(%ebp),%edi 10dd66: 85 ff test %edi,%edi 10dd68: 0f 85 96 00 00 00 jne 10de04 case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10dd6e: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax 10dd74: 89 45 d4 mov %eax,-0x2c(%ebp) if ( api->schedpolicy == SCHED_SPORADIC ) 10dd77: 83 b8 84 00 00 00 04 cmpl $0x4,0x84(%eax) 10dd7e: 0f 84 cc 00 00 00 je 10de50 (void) _Watchdog_Remove( &api->Sporadic_timer ); api->schedpolicy = policy; 10dd84: 8b 45 0c mov 0xc(%ebp),%eax 10dd87: 8b 4d d4 mov -0x2c(%ebp),%ecx 10dd8a: 89 81 84 00 00 00 mov %eax,0x84(%ecx) api->schedparam = *param; 10dd90: 89 cf mov %ecx,%edi 10dd92: 81 c7 88 00 00 00 add $0x88,%edi 10dd98: b9 07 00 00 00 mov $0x7,%ecx 10dd9d: f3 a5 rep movsl %ds:(%esi),%es:(%edi) the_thread->budget_algorithm = budget_algorithm; 10dd9f: 8b 45 e4 mov -0x1c(%ebp),%eax 10dda2: 89 42 7c mov %eax,0x7c(%edx) the_thread->budget_callout = budget_callout; 10dda5: 8b 45 e0 mov -0x20(%ebp),%eax 10dda8: 89 82 80 00 00 00 mov %eax,0x80(%edx) switch ( api->schedpolicy ) { 10ddae: 8b 75 0c mov 0xc(%ebp),%esi 10ddb1: 85 f6 test %esi,%esi 10ddb3: 78 2e js 10dde3 <== NEVER TAKEN 10ddb5: 83 7d 0c 02 cmpl $0x2,0xc(%ebp) 10ddb9: 7f 59 jg 10de14 case SCHED_OTHER: case SCHED_FIFO: case SCHED_RR: the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice; 10ddbb: a1 c0 cc 12 00 mov 0x12ccc0,%eax 10ddc0: 89 42 78 mov %eax,0x78(%edx) 10ddc3: 0f b6 05 9c 89 12 00 movzbl 0x12899c,%eax 10ddca: 8b 4d d4 mov -0x2c(%ebp),%ecx 10ddcd: 2b 81 88 00 00 00 sub 0x88(%ecx),%eax the_thread->real_priority = 10ddd3: 89 42 18 mov %eax,0x18(%edx) _POSIX_Priority_To_core( api->schedparam.sched_priority ); _Thread_Change_priority( 10ddd6: 51 push %ecx 10ddd7: 6a 01 push $0x1 10ddd9: 50 push %eax 10ddda: 52 push %edx 10dddb: e8 58 26 00 00 call 110438 <_Thread_Change_priority> the_thread, the_thread->real_priority, true ); break; 10dde0: 83 c4 10 add $0x10,%esp _Watchdog_Remove( &api->Sporadic_timer ); _POSIX_Threads_Sporadic_budget_TSR( 0, the_thread ); break; } _Thread_Enable_dispatch(); 10dde3: e8 88 2a 00 00 call 110870 <_Thread_Enable_dispatch> case OBJECTS_ERROR: break; } return ESRCH; } 10dde8: 89 d8 mov %ebx,%eax 10ddea: 8d 65 f4 lea -0xc(%ebp),%esp 10dded: 5b pop %ebx 10ddee: 5e pop %esi 10ddef: 5f pop %edi 10ddf0: c9 leave 10ddf1: c3 ret 10ddf2: 66 90 xchg %ax,%ax /* * Check all the parameters */ if ( !param ) return EINVAL; 10ddf4: bb 16 00 00 00 mov $0x16,%ebx case OBJECTS_ERROR: break; } return ESRCH; } 10ddf9: 89 d8 mov %ebx,%eax 10ddfb: 8d 65 f4 lea -0xc(%ebp),%esp 10ddfe: 5b pop %ebx 10ddff: 5e pop %esi 10de00: 5f pop %edi 10de01: c9 leave 10de02: c3 ret 10de03: 90 nop #endif case OBJECTS_ERROR: break; } return ESRCH; 10de04: bb 03 00 00 00 mov $0x3,%ebx } 10de09: 89 d8 mov %ebx,%eax 10de0b: 8d 65 f4 lea -0xc(%ebp),%esp 10de0e: 5b pop %ebx 10de0f: 5e pop %esi 10de10: 5f pop %edi 10de11: c9 leave 10de12: c3 ret 10de13: 90 nop api->schedpolicy = policy; api->schedparam = *param; the_thread->budget_algorithm = budget_algorithm; the_thread->budget_callout = budget_callout; switch ( api->schedpolicy ) { 10de14: 83 7d 0c 04 cmpl $0x4,0xc(%ebp) 10de18: 75 c9 jne 10dde3 <== NEVER TAKEN true ); break; case SCHED_SPORADIC: api->ss_high_priority = api->schedparam.sched_priority; 10de1a: 8b 4d d4 mov -0x2c(%ebp),%ecx 10de1d: 8b 81 88 00 00 00 mov 0x88(%ecx),%eax 10de23: 89 81 a4 00 00 00 mov %eax,0xa4(%ecx) _Watchdog_Remove( &api->Sporadic_timer ); 10de29: 83 ec 0c sub $0xc,%esp 10de2c: 89 c8 mov %ecx,%eax 10de2e: 05 a8 00 00 00 add $0xa8,%eax 10de33: 50 push %eax 10de34: 89 55 d0 mov %edx,-0x30(%ebp) 10de37: e8 38 3a 00 00 call 111874 <_Watchdog_Remove> _POSIX_Threads_Sporadic_budget_TSR( 0, the_thread ); 10de3c: 58 pop %eax 10de3d: 5a pop %edx 10de3e: 8b 55 d0 mov -0x30(%ebp),%edx 10de41: 52 push %edx 10de42: 6a 00 push $0x0 10de44: e8 af fd ff ff call 10dbf8 <_POSIX_Threads_Sporadic_budget_TSR> break; 10de49: 83 c4 10 add $0x10,%esp 10de4c: eb 95 jmp 10dde3 10de4e: 66 90 xchg %ax,%ax case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( api->schedpolicy == SCHED_SPORADIC ) (void) _Watchdog_Remove( &api->Sporadic_timer ); 10de50: 83 ec 0c sub $0xc,%esp 10de53: 05 a8 00 00 00 add $0xa8,%eax 10de58: 50 push %eax 10de59: 89 55 d0 mov %edx,-0x30(%ebp) 10de5c: e8 13 3a 00 00 call 111874 <_Watchdog_Remove> 10de61: 83 c4 10 add $0x10,%esp 10de64: 8b 55 d0 mov -0x30(%ebp),%edx 10de67: e9 18 ff ff ff jmp 10dd84 =============================================================================== 00111d14 : int pthread_sigmask( int how, const sigset_t *set, sigset_t *oset ) { 111d14: 55 push %ebp 111d15: 89 e5 mov %esp,%ebp 111d17: 56 push %esi 111d18: 53 push %ebx 111d19: 8b 4d 08 mov 0x8(%ebp),%ecx 111d1c: 8b 55 0c mov 0xc(%ebp),%edx 111d1f: 8b 5d 10 mov 0x10(%ebp),%ebx POSIX_API_Control *api; if ( !set && !oset ) 111d22: 85 d2 test %edx,%edx 111d24: 0f 84 8a 00 00 00 je 111db4 rtems_set_errno_and_return_minus_one( EINVAL ); api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 111d2a: a1 58 a3 12 00 mov 0x12a358,%eax 111d2f: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax if ( oset ) 111d35: 85 db test %ebx,%ebx 111d37: 74 0c je 111d45 *oset = api->signals_blocked; 111d39: 8b b0 d0 00 00 00 mov 0xd0(%eax),%esi 111d3f: 89 33 mov %esi,(%ebx) if ( !set ) 111d41: 85 d2 test %edx,%edx 111d43: 74 3b je 111d80 return 0; switch ( how ) { 111d45: 83 f9 01 cmp $0x1,%ecx 111d48: 74 5e je 111da8 111d4a: 83 f9 02 cmp $0x2,%ecx 111d4d: 74 39 je 111d88 111d4f: 85 c9 test %ecx,%ecx 111d51: 75 41 jne 111d94 break; case SIG_UNBLOCK: api->signals_blocked &= ~*set; break; case SIG_SETMASK: api->signals_blocked = *set; 111d53: 8b 12 mov (%edx),%edx 111d55: 89 90 d0 00 00 00 mov %edx,0xd0(%eax) /* XXX are there critical section problems here? */ /* XXX evaluate the new set */ if ( ~api->signals_blocked & (api->signals_pending | _POSIX_signals_Pending) ) { 111d5b: 8b 15 c8 a5 12 00 mov 0x12a5c8,%edx 111d61: 0b 90 d4 00 00 00 or 0xd4(%eax),%edx /* XXX are there critical section problems here? */ /* XXX evaluate the new set */ if ( ~api->signals_blocked & 111d67: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax 111d6d: f7 d0 not %eax 111d6f: 85 c2 test %eax,%edx 111d71: 74 0d je 111d80 (api->signals_pending | _POSIX_signals_Pending) ) { _Thread_Dispatch(); 111d73: e8 b0 c9 ff ff call 10e728 <_Thread_Dispatch> } return 0; 111d78: 31 c0 xor %eax,%eax } 111d7a: 5b pop %ebx 111d7b: 5e pop %esi 111d7c: c9 leave 111d7d: c3 ret 111d7e: 66 90 xchg %ax,%ax if ( ~api->signals_blocked & (api->signals_pending | _POSIX_signals_Pending) ) { _Thread_Dispatch(); } return 0; 111d80: 31 c0 xor %eax,%eax } 111d82: 5b pop %ebx 111d83: 5e pop %esi 111d84: c9 leave 111d85: c3 ret 111d86: 66 90 xchg %ax,%ax switch ( how ) { case SIG_BLOCK: api->signals_blocked |= *set; break; case SIG_UNBLOCK: api->signals_blocked &= ~*set; 111d88: 8b 12 mov (%edx),%edx 111d8a: f7 d2 not %edx 111d8c: 21 90 d0 00 00 00 and %edx,0xd0(%eax) break; 111d92: eb c7 jmp 111d5b case SIG_SETMASK: api->signals_blocked = *set; break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 111d94: e8 d3 24 00 00 call 11426c <__errno> 111d99: c7 00 16 00 00 00 movl $0x16,(%eax) 111d9f: b8 ff ff ff ff mov $0xffffffff,%eax (api->signals_pending | _POSIX_signals_Pending) ) { _Thread_Dispatch(); } return 0; } 111da4: 5b pop %ebx 111da5: 5e pop %esi 111da6: c9 leave 111da7: c3 ret if ( !set ) return 0; switch ( how ) { case SIG_BLOCK: api->signals_blocked |= *set; 111da8: 8b 12 mov (%edx),%edx 111daa: 09 90 d0 00 00 00 or %edx,0xd0(%eax) break; 111db0: eb a9 jmp 111d5b 111db2: 66 90 xchg %ax,%ax sigset_t *oset ) { POSIX_API_Control *api; if ( !set && !oset ) 111db4: 85 db test %ebx,%ebx 111db6: 74 dc je 111d94 rtems_set_errno_and_return_minus_one( EINVAL ); api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 111db8: a1 58 a3 12 00 mov 0x12a358,%eax 111dbd: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax 111dc3: e9 71 ff ff ff jmp 111d39 =============================================================================== 0010bb84 : * * 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183 */ void pthread_testcancel( void ) { 10bb84: 55 push %ebp 10bb85: 89 e5 mov %esp,%ebp 10bb87: 83 ec 08 sub $0x8,%esp * Don't even think about deleting a resource from an ISR. * Besides this request is supposed to be for _Thread_Executing * and the ISR context is not a thread. */ if ( _ISR_Is_in_progress() ) 10bb8a: 8b 0d d4 9d 12 00 mov 0x129dd4,%ecx 10bb90: 85 c9 test %ecx,%ecx 10bb92: 75 44 jne 10bbd8 <== NEVER TAKEN return; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 10bb94: a1 d8 9d 12 00 mov 0x129dd8,%eax 10bb99: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax 10bb9f: 8b 15 30 98 12 00 mov 0x129830,%edx 10bba5: 42 inc %edx 10bba6: 89 15 30 98 12 00 mov %edx,0x129830 _Thread_Disable_dispatch(); if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 10bbac: 8b 90 d8 00 00 00 mov 0xd8(%eax),%edx 10bbb2: 85 d2 test %edx,%edx 10bbb4: 75 26 jne 10bbdc <== NEVER TAKEN 10bbb6: 8b 80 e0 00 00 00 mov 0xe0(%eax),%eax 10bbbc: 85 c0 test %eax,%eax 10bbbe: 74 1c je 10bbdc thread_support->cancelation_requested ) cancel = true; _Thread_Enable_dispatch(); 10bbc0: e8 7f 29 00 00 call 10e544 <_Thread_Enable_dispatch> if ( cancel ) _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED ); 10bbc5: 83 ec 08 sub $0x8,%esp 10bbc8: 6a ff push $0xffffffff 10bbca: ff 35 d8 9d 12 00 pushl 0x129dd8 10bbd0: e8 73 5b 00 00 call 111748 <_POSIX_Thread_Exit> 10bbd5: 83 c4 10 add $0x10,%esp } 10bbd8: c9 leave 10bbd9: c3 ret 10bbda: 66 90 xchg %ax,%ax 10bbdc: c9 leave _Thread_Disable_dispatch(); if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && thread_support->cancelation_requested ) cancel = true; _Thread_Enable_dispatch(); 10bbdd: e9 62 29 00 00 jmp 10e544 <_Thread_Enable_dispatch> =============================================================================== 0011f20c : ssize_t read( int fd, void *buffer, size_t count ) { 11f20c: 55 push %ebp 11f20d: 89 e5 mov %esp,%ebp 11f20f: 53 push %ebx 11f210: 83 ec 04 sub $0x4,%esp 11f213: 8b 4d 08 mov 0x8(%ebp),%ecx 11f216: 8b 45 0c mov 0xc(%ebp),%eax 11f219: 8b 55 10 mov 0x10(%ebp),%edx ssize_t rc; rtems_libio_t *iop; rtems_libio_check_fd( fd ); 11f21c: 3b 0d 6c 39 12 00 cmp 0x12396c,%ecx 11f222: 73 50 jae 11f274 <== NEVER TAKEN iop = rtems_libio_iop( fd ); 11f224: c1 e1 03 shl $0x3,%ecx 11f227: 8d 1c cd 00 00 00 00 lea 0x0(,%ecx,8),%ebx 11f22e: 29 cb sub %ecx,%ebx 11f230: 03 1d 20 7c 12 00 add 0x127c20,%ebx rtems_libio_check_is_open( iop ); 11f236: 8b 4b 14 mov 0x14(%ebx),%ecx 11f239: f6 c5 01 test $0x1,%ch 11f23c: 74 36 je 11f274 rtems_libio_check_buffer( buffer ); 11f23e: 85 c0 test %eax,%eax 11f240: 74 46 je 11f288 <== NEVER TAKEN rtems_libio_check_count( count ); 11f242: 85 d2 test %edx,%edx 11f244: 74 26 je 11f26c rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ ); 11f246: 83 e1 02 and $0x2,%ecx 11f249: 74 3d je 11f288 /* * Now process the read(). */ rc = (*iop->pathinfo.handlers->read_h)( iop, buffer, count ); 11f24b: 51 push %ecx 11f24c: 8b 4b 20 mov 0x20(%ebx),%ecx 11f24f: 52 push %edx 11f250: 50 push %eax 11f251: 53 push %ebx 11f252: ff 51 08 call *0x8(%ecx) if ( rc > 0 ) 11f255: 83 c4 10 add $0x10,%esp 11f258: 85 c0 test %eax,%eax 11f25a: 7e 0b jle 11f267 iop->offset += rc; 11f25c: 89 c1 mov %eax,%ecx 11f25e: c1 f9 1f sar $0x1f,%ecx 11f261: 01 43 0c add %eax,0xc(%ebx) 11f264: 11 4b 10 adc %ecx,0x10(%ebx) return rc; } 11f267: 8b 5d fc mov -0x4(%ebp),%ebx 11f26a: c9 leave 11f26b: c3 ret rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open( iop ); rtems_libio_check_buffer( buffer ); rtems_libio_check_count( count ); 11f26c: 31 c0 xor %eax,%eax if ( rc > 0 ) iop->offset += rc; return rc; } 11f26e: 8b 5d fc mov -0x4(%ebp),%ebx 11f271: c9 leave 11f272: c3 ret 11f273: 90 nop ssize_t rc; rtems_libio_t *iop; rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open( iop ); 11f274: e8 f7 3f ff ff call 113270 <__errno> 11f279: c7 00 09 00 00 00 movl $0x9,(%eax) 11f27f: b8 ff ff ff ff mov $0xffffffff,%eax 11f284: eb e1 jmp 11f267 11f286: 66 90 xchg %ax,%ax rtems_libio_check_buffer( buffer ); rtems_libio_check_count( count ); rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ ); 11f288: e8 e3 3f ff ff call 113270 <__errno> 11f28d: c7 00 16 00 00 00 movl $0x16,(%eax) 11f293: b8 ff ff ff ff mov $0xffffffff,%eax 11f298: eb cd jmp 11f267 =============================================================================== 0010b068 : ssize_t readlink( const char *pathname, char *buf, size_t bufsize ) { 10b068: 55 push %ebp 10b069: 89 e5 mov %esp,%ebp 10b06b: 57 push %edi 10b06c: 56 push %esi 10b06d: 53 push %ebx 10b06e: 83 ec 3c sub $0x3c,%esp 10b071: 8b 55 08 mov 0x8(%ebp),%edx 10b074: 8b 5d 0c mov 0xc(%ebp),%ebx rtems_filesystem_location_info_t loc; int result; if (!buf) 10b077: 85 db test %ebx,%ebx 10b079: 74 6d je 10b0e8 rtems_set_errno_and_return_minus_one( EFAULT ); result = rtems_filesystem_evaluate_path( pathname, strlen( pathname ), 10b07b: 31 c0 xor %eax,%eax 10b07d: b9 ff ff ff ff mov $0xffffffff,%ecx 10b082: 89 d7 mov %edx,%edi 10b084: f2 ae repnz scas %es:(%edi),%al 10b086: f7 d1 not %ecx 10b088: 49 dec %ecx 10b089: 83 ec 0c sub $0xc,%esp 10b08c: 6a 00 push $0x0 10b08e: 8d 75 d4 lea -0x2c(%ebp),%esi 10b091: 56 push %esi 10b092: 6a 00 push $0x0 10b094: 51 push %ecx 10b095: 52 push %edx 10b096: e8 79 ee ff ff call 109f14 0, &loc, false ); if ( result != 0 ) 10b09b: 83 c4 20 add $0x20,%esp 10b09e: 85 c0 test %eax,%eax 10b0a0: 74 0e je 10b0b0 <== ALWAYS TAKEN return -1; 10b0a2: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED result = (*loc.ops->readlink_h)( &loc, buf, bufsize ); rtems_filesystem_freenode( &loc ); return result; } 10b0a7: 8d 65 f4 lea -0xc(%ebp),%esp 10b0aa: 5b pop %ebx 10b0ab: 5e pop %esi 10b0ac: 5f pop %edi 10b0ad: c9 leave 10b0ae: c3 ret 10b0af: 90 nop result = rtems_filesystem_evaluate_path( pathname, strlen( pathname ), 0, &loc, false ); if ( result != 0 ) return -1; if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_SYM_LINK ){ 10b0b0: 83 ec 0c sub $0xc,%esp 10b0b3: 56 push %esi 10b0b4: 8b 45 e0 mov -0x20(%ebp),%eax 10b0b7: ff 50 10 call *0x10(%eax) 10b0ba: 83 c4 10 add $0x10,%esp 10b0bd: 83 f8 04 cmp $0x4,%eax 10b0c0: 75 3e jne 10b100 rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( EINVAL ); } result = (*loc.ops->readlink_h)( &loc, buf, bufsize ); 10b0c2: 50 push %eax 10b0c3: ff 75 10 pushl 0x10(%ebp) 10b0c6: 53 push %ebx 10b0c7: 56 push %esi 10b0c8: 8b 45 e0 mov -0x20(%ebp),%eax 10b0cb: ff 50 3c call *0x3c(%eax) rtems_filesystem_freenode( &loc ); 10b0ce: 89 34 24 mov %esi,(%esp) 10b0d1: 89 45 c4 mov %eax,-0x3c(%ebp) 10b0d4: e8 13 ef ff ff call 109fec return result; 10b0d9: 83 c4 10 add $0x10,%esp 10b0dc: 8b 45 c4 mov -0x3c(%ebp),%eax } 10b0df: 8d 65 f4 lea -0xc(%ebp),%esp 10b0e2: 5b pop %ebx 10b0e3: 5e pop %esi 10b0e4: 5f pop %edi 10b0e5: c9 leave 10b0e6: c3 ret 10b0e7: 90 nop { rtems_filesystem_location_info_t loc; int result; if (!buf) rtems_set_errno_and_return_minus_one( EFAULT ); 10b0e8: e8 af ac 00 00 call 115d9c <__errno> 10b0ed: c7 00 0e 00 00 00 movl $0xe,(%eax) 10b0f3: b8 ff ff ff ff mov $0xffffffff,%eax result = (*loc.ops->readlink_h)( &loc, buf, bufsize ); rtems_filesystem_freenode( &loc ); return result; } 10b0f8: 8d 65 f4 lea -0xc(%ebp),%esp 10b0fb: 5b pop %ebx 10b0fc: 5e pop %esi 10b0fd: 5f pop %edi 10b0fe: c9 leave 10b0ff: c3 ret 0, &loc, false ); if ( result != 0 ) return -1; if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_SYM_LINK ){ rtems_filesystem_freenode( &loc ); 10b100: 83 ec 0c sub $0xc,%esp 10b103: 56 push %esi 10b104: e8 e3 ee ff ff call 109fec rtems_set_errno_and_return_minus_one( EINVAL ); 10b109: e8 8e ac 00 00 call 115d9c <__errno> 10b10e: c7 00 16 00 00 00 movl $0x16,(%eax) 10b114: 83 c4 10 add $0x10,%esp 10b117: b8 ff ff ff ff mov $0xffffffff,%eax 10b11c: eb 89 jmp 10b0a7 =============================================================================== 00109d2c : ssize_t readv( int fd, const struct iovec *iov, int iovcnt ) { 109d2c: 55 push %ebp 109d2d: 89 e5 mov %esp,%ebp 109d2f: 57 push %edi 109d30: 56 push %esi 109d31: 53 push %ebx 109d32: 83 ec 1c sub $0x1c,%esp 109d35: 8b 45 08 mov 0x8(%ebp),%eax 109d38: 8b 5d 0c mov 0xc(%ebp),%ebx int v; int bytes; rtems_libio_t *iop; bool all_zeros; rtems_libio_check_fd( fd ); 109d3b: 3b 05 ac 4f 12 00 cmp 0x124fac,%eax 109d41: 0f 83 ef 00 00 00 jae 109e36 iop = rtems_libio_iop( fd ); 109d47: c1 e0 03 shl $0x3,%eax 109d4a: 8d 34 c5 00 00 00 00 lea 0x0(,%eax,8),%esi 109d51: 29 c6 sub %eax,%esi 109d53: 03 35 60 92 12 00 add 0x129260,%esi rtems_libio_check_is_open( iop ); 109d59: 8b 46 14 mov 0x14(%esi),%eax 109d5c: f6 c4 01 test $0x1,%ah 109d5f: 0f 84 d1 00 00 00 je 109e36 rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ ); 109d65: a8 02 test $0x2,%al 109d67: 0f 84 97 00 00 00 je 109e04 <== NEVER TAKEN /* * Argument validation on IO vector */ if ( !iov ) 109d6d: 85 db test %ebx,%ebx 109d6f: 0f 84 8f 00 00 00 je 109e04 rtems_set_errno_and_return_minus_one( EINVAL ); if ( iovcnt <= 0 ) 109d75: 8b 7d 10 mov 0x10(%ebp),%edi 109d78: 85 ff test %edi,%edi 109d7a: 0f 8e 84 00 00 00 jle 109e04 rtems_set_errno_and_return_minus_one( EINVAL ); if ( iovcnt > IOV_MAX ) 109d80: 81 7d 10 00 04 00 00 cmpl $0x400,0x10(%ebp) 109d87: 7f 7b jg 109e04 <== NEVER TAKEN 109d89: c6 45 e4 01 movb $0x1,-0x1c(%ebp) 109d8d: 31 c0 xor %eax,%eax 109d8f: 31 d2 xor %edx,%edx 109d91: eb 03 jmp 109d96 109d93: 90 nop if ( iov[v].iov_base == 0 ) rtems_set_errno_and_return_minus_one( EINVAL ); /* check for wrap */ old = total; total += iov[v].iov_len; 109d94: 89 fa mov %edi,%edx /* * iov[v].iov_len cannot be less than 0 because size_t is unsigned. * So we only check for zero. */ if ( iov[v].iov_base == 0 ) 109d96: 8b 0c c3 mov (%ebx,%eax,8),%ecx 109d99: 85 c9 test %ecx,%ecx 109d9b: 74 67 je 109e04 rtems_set_errno_and_return_minus_one( EINVAL ); /* check for wrap */ old = total; total += iov[v].iov_len; 109d9d: 8b 4c c3 04 mov 0x4(%ebx,%eax,8),%ecx 109da1: 8d 3c 0a lea (%edx,%ecx,1),%edi if ( total < old ) 109da4: 39 fa cmp %edi,%edx 109da6: 7f 5c jg 109e04 rtems_set_errno_and_return_minus_one( EINVAL ); if ( iov[v].iov_len ) 109da8: 85 c9 test %ecx,%ecx 109daa: 74 04 je 109db0 all_zeros = false; 109dac: c6 45 e4 00 movb $0x0,-0x1c(%ebp) * are obvious errors in the iovec. So this extra loop ensures * that we do not do anything if there is an argument error. */ all_zeros = true; for ( total=0, v=0 ; v < iovcnt ; v++ ) { 109db0: 40 inc %eax 109db1: 39 45 10 cmp %eax,0x10(%ebp) 109db4: 7f de jg 109d94 /* * A readv with all zeros logically has no effect. Even though * OpenGroup didn't address this case as they did with writev(), * we will handle it the same way for symmetry. */ if ( all_zeros == true ) { 109db6: 80 7d e4 00 cmpb $0x0,-0x1c(%ebp) 109dba: 75 68 jne 109e24 109dbc: 31 ff xor %edi,%edi 109dbe: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) 109dc5: eb 1d jmp 109de4 109dc7: 90 nop ); if ( bytes < 0 ) return -1; if ( bytes > 0 ) { 109dc8: 74 0e je 109dd8 <== NEVER TAKEN iop->offset += bytes; 109dca: 89 c1 mov %eax,%ecx 109dcc: c1 f9 1f sar $0x1f,%ecx 109dcf: 01 46 0c add %eax,0xc(%esi) 109dd2: 11 4e 10 adc %ecx,0x10(%esi) total += bytes; 109dd5: 01 45 e4 add %eax,-0x1c(%ebp) } if (bytes != iov[ v ].iov_len) 109dd8: 3b 44 fb 04 cmp 0x4(%ebx,%edi,8),%eax 109ddc: 75 38 jne 109e16 <== NEVER TAKEN } /* * Now process the readv(). */ for ( total=0, v=0 ; v < iovcnt ; v++ ) { 109dde: 47 inc %edi 109ddf: 39 7d 10 cmp %edi,0x10(%ebp) 109de2: 7e 32 jle 109e16 bytes = (*iop->pathinfo.handlers->read_h)( 109de4: 50 push %eax 109de5: 8b 46 20 mov 0x20(%esi),%eax 109de8: ff 74 fb 04 pushl 0x4(%ebx,%edi,8) 109dec: ff 34 fb pushl (%ebx,%edi,8) 109def: 56 push %esi 109df0: ff 50 08 call *0x8(%eax) iop, iov[v].iov_base, iov[v].iov_len ); if ( bytes < 0 ) 109df3: 83 c4 10 add $0x10,%esp 109df6: 83 f8 00 cmp $0x0,%eax 109df9: 7d cd jge 109dc8 <== ALWAYS TAKEN return -1; 109dfb: c7 45 e4 ff ff ff ff movl $0xffffffff,-0x1c(%ebp) <== NOT EXECUTED 109e02: eb 12 jmp 109e16 <== NOT EXECUTED /* check for wrap */ old = total; total += iov[v].iov_len; if ( total < old ) rtems_set_errno_and_return_minus_one( EINVAL ); 109e04: e8 f7 a1 00 00 call 114000 <__errno> 109e09: c7 00 16 00 00 00 movl $0x16,(%eax) 109e0f: c7 45 e4 ff ff ff ff movl $0xffffffff,-0x1c(%ebp) if (bytes != iov[ v ].iov_len) break; } return total; } 109e16: 8b 45 e4 mov -0x1c(%ebp),%eax 109e19: 8d 65 f4 lea -0xc(%ebp),%esp 109e1c: 5b pop %ebx 109e1d: 5e pop %esi 109e1e: 5f pop %edi 109e1f: c9 leave 109e20: c3 ret 109e21: 8d 76 00 lea 0x0(%esi),%esi * A readv with all zeros logically has no effect. Even though * OpenGroup didn't address this case as they did with writev(), * we will handle it the same way for symmetry. */ if ( all_zeros == true ) { return 0; 109e24: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) if (bytes != iov[ v ].iov_len) break; } return total; } 109e2b: 8b 45 e4 mov -0x1c(%ebp),%eax 109e2e: 8d 65 f4 lea -0xc(%ebp),%esp 109e31: 5b pop %ebx 109e32: 5e pop %esi 109e33: 5f pop %edi 109e34: c9 leave 109e35: c3 ret rtems_libio_t *iop; bool all_zeros; rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open( iop ); 109e36: e8 c5 a1 00 00 call 114000 <__errno> 109e3b: c7 00 09 00 00 00 movl $0x9,(%eax) 109e41: c7 45 e4 ff ff ff ff movl $0xffffffff,-0x1c(%ebp) 109e48: eb cc jmp 109e16 =============================================================================== 0011f328 : void *realloc( void *ptr, size_t size ) { 11f328: 55 push %ebp 11f329: 89 e5 mov %esp,%ebp 11f32b: 57 push %edi 11f32c: 56 push %esi 11f32d: 53 push %ebx 11f32e: 83 ec 2c sub $0x2c,%esp 11f331: 8b 5d 08 mov 0x8(%ebp),%ebx 11f334: 8b 75 0c mov 0xc(%ebp),%esi uintptr_t old_size; char *new_area; MSBUMP(realloc_calls, 1); 11f337: ff 05 50 7c 12 00 incl 0x127c50 /* * Do not attempt to allocate memory if in a critical section or ISR. */ if (_System_state_Is_up(_System_state_Get())) { 11f33d: 83 3d 20 7f 12 00 03 cmpl $0x3,0x127f20 11f344: 74 72 je 11f3b8 <== ALWAYS TAKEN } /* * Continue with realloc(). */ if ( !ptr ) 11f346: 85 db test %ebx,%ebx 11f348: 74 5e je 11f3a8 return malloc( size ); if ( !size ) { 11f34a: 85 f6 test %esi,%esi 11f34c: 74 3a je 11f388 <== NEVER TAKEN free( ptr ); return (void *) 0; } if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) { 11f34e: 52 push %edx 11f34f: 8d 45 e4 lea -0x1c(%ebp),%eax 11f352: 50 push %eax 11f353: 53 push %ebx 11f354: ff 35 b0 39 12 00 pushl 0x1239b0 11f35a: e8 49 01 00 00 call 11f4a8 <_Protected_heap_Get_block_size> 11f35f: 83 c4 10 add $0x10,%esp 11f362: 84 c0 test %al,%al 11f364: 74 32 je 11f398 } /* * Now resize it. */ if ( _Protected_heap_Resize_block( RTEMS_Malloc_Heap, ptr, size ) ) { 11f366: 50 push %eax 11f367: 56 push %esi 11f368: 53 push %ebx 11f369: ff 35 b0 39 12 00 pushl 0x1239b0 11f36f: e8 6c 01 00 00 call 11f4e0 <_Protected_heap_Resize_block> 11f374: 83 c4 10 add $0x10,%esp 11f377: 84 c0 test %al,%al 11f379: 74 5d je 11f3d8 memcpy( new_area, ptr, (size < old_size) ? size : old_size ); free( ptr ); return new_area; } 11f37b: 89 d8 mov %ebx,%eax 11f37d: 8d 65 f4 lea -0xc(%ebp),%esp 11f380: 5b pop %ebx 11f381: 5e pop %esi 11f382: 5f pop %edi 11f383: c9 leave 11f384: c3 ret 11f385: 8d 76 00 lea 0x0(%esi),%esi */ if ( !ptr ) return malloc( size ); if ( !size ) { free( ptr ); 11f388: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11f38b: 53 push %ebx <== NOT EXECUTED 11f38c: e8 23 8d fe ff call 1080b4 <== NOT EXECUTED return (void *) 0; 11f391: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11f394: 31 db xor %ebx,%ebx <== NOT EXECUTED 11f396: eb e3 jmp 11f37b <== NOT EXECUTED } if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) { errno = EINVAL; 11f398: e8 d3 3e ff ff call 113270 <__errno> 11f39d: c7 00 16 00 00 00 movl $0x16,(%eax) return (void *) 0; 11f3a3: 31 db xor %ebx,%ebx 11f3a5: eb d4 jmp 11f37b 11f3a7: 90 nop /* * Continue with realloc(). */ if ( !ptr ) return malloc( size ); 11f3a8: 83 ec 0c sub $0xc,%esp 11f3ab: 56 push %esi 11f3ac: e8 d7 8f fe ff call 108388 11f3b1: 89 c3 mov %eax,%ebx 11f3b3: 83 c4 10 add $0x10,%esp 11f3b6: eb c3 jmp 11f37b /* * Do not attempt to allocate memory if in a critical section or ISR. */ if (_System_state_Is_up(_System_state_Get())) { if (_Thread_Dispatch_disable_level > 0) 11f3b8: a1 90 7d 12 00 mov 0x127d90,%eax 11f3bd: 85 c0 test %eax,%eax 11f3bf: 74 04 je 11f3c5 <== ALWAYS TAKEN new_area = malloc( size ); MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */ if ( !new_area ) { return (void *) 0; 11f3c1: 31 db xor %ebx,%ebx 11f3c3: eb b6 jmp 11f37b if (_System_state_Is_up(_System_state_Get())) { if (_Thread_Dispatch_disable_level > 0) return (void *) 0; if (_ISR_Nest_level > 0) 11f3c5: 8b 0d 34 83 12 00 mov 0x128334,%ecx 11f3cb: 85 c9 test %ecx,%ecx 11f3cd: 0f 84 73 ff ff ff je 11f346 <== ALWAYS TAKEN new_area = malloc( size ); MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */ if ( !new_area ) { return (void *) 0; 11f3d3: 31 db xor %ebx,%ebx 11f3d5: eb a4 jmp 11f37b <== NOT EXECUTED 11f3d7: 90 nop <== NOT EXECUTED * There used to be a free on this error case but it is wrong to * free the memory per OpenGroup Single UNIX Specification V2 * and the C Standard. */ new_area = malloc( size ); 11f3d8: 83 ec 0c sub $0xc,%esp 11f3db: 56 push %esi 11f3dc: e8 a7 8f fe ff call 108388 MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */ 11f3e1: ff 0d 44 7c 12 00 decl 0x127c44 if ( !new_area ) { 11f3e7: 83 c4 10 add $0x10,%esp 11f3ea: 85 c0 test %eax,%eax 11f3ec: 74 d3 je 11f3c1 return (void *) 0; } memcpy( new_area, ptr, (size < old_size) ? size : old_size ); 11f3ee: 8b 55 e4 mov -0x1c(%ebp),%edx 11f3f1: 89 f1 mov %esi,%ecx 11f3f3: 39 d6 cmp %edx,%esi 11f3f5: 76 02 jbe 11f3f9 <== NEVER TAKEN 11f3f7: 89 d1 mov %edx,%ecx 11f3f9: 89 c7 mov %eax,%edi 11f3fb: 89 de mov %ebx,%esi 11f3fd: f3 a4 rep movsb %ds:(%esi),%es:(%edi) free( ptr ); 11f3ff: 83 ec 0c sub $0xc,%esp 11f402: 53 push %ebx 11f403: 89 45 d4 mov %eax,-0x2c(%ebp) 11f406: e8 a9 8c fe ff call 1080b4 return new_area; 11f40b: 83 c4 10 add $0x10,%esp 11f40e: 8b 45 d4 mov -0x2c(%ebp),%eax 11f411: 89 c3 mov %eax,%ebx 11f413: e9 63 ff ff ff jmp 11f37b =============================================================================== 00109300 : #include int rmdir( const char *pathname ) { 109300: 55 push %ebp 109301: 89 e5 mov %esp,%ebp 109303: 57 push %edi 109304: 56 push %esi 109305: 53 push %ebx 109306: 83 ec 58 sub $0x58,%esp 109309: 8b 5d 08 mov 0x8(%ebp),%ebx /* * Get the parent node of the node we wish to remove. Find the parent path. */ parentpathlen = rtems_filesystem_dirname ( pathname ); 10930c: 53 push %ebx 10930d: e8 46 f1 ff ff call 108458 if ( parentpathlen == 0 ) 109312: 83 c4 10 add $0x10,%esp 109315: 85 c0 test %eax,%eax 109317: 0f 85 0f 01 00 00 jne 10942c rtems_filesystem_get_start_loc( pathname, &i, &parentloc ); 10931d: 50 push %eax 10931e: 8d 45 d0 lea -0x30(%ebp),%eax 109321: 89 45 b4 mov %eax,-0x4c(%ebp) 109324: 50 push %eax 109325: 8d 45 e4 lea -0x1c(%ebp),%eax 109328: 50 push %eax 109329: 53 push %ebx 10932a: e8 45 01 00 00 call 109474 10932f: 83 c4 10 add $0x10,%esp 109332: 31 d2 xor %edx,%edx const char *name; rtems_filesystem_location_info_t parentloc; rtems_filesystem_location_info_t loc; int i; int result; bool free_parentloc = false; 109334: c6 45 b3 00 movb $0x0,-0x4d(%ebp) /* * Start from the parent to find the node that should be under it. */ loc = parentloc; 109338: 8d 7d bc lea -0x44(%ebp),%edi 10933b: b9 05 00 00 00 mov $0x5,%ecx 109340: 8b 75 b4 mov -0x4c(%ebp),%esi 109343: f3 a5 rep movsl %ds:(%esi),%es:(%edi) name = pathname + parentpathlen; 109345: 01 d3 add %edx,%ebx name += rtems_filesystem_prefix_separators( name, strlen( name ) ); 109347: be ff ff ff ff mov $0xffffffff,%esi 10934c: 89 f1 mov %esi,%ecx 10934e: 89 df mov %ebx,%edi 109350: 31 c0 xor %eax,%eax 109352: f2 ae repnz scas %es:(%edi),%al 109354: f7 d1 not %ecx 109356: 49 dec %ecx 109357: 83 ec 08 sub $0x8,%esp 10935a: 51 push %ecx 10935b: 53 push %ebx 10935c: e8 3b f1 ff ff call 10849c 109361: 01 c3 add %eax,%ebx result = rtems_filesystem_evaluate_relative_path( name , strlen( name ), 109363: 89 f1 mov %esi,%ecx 109365: 89 df mov %ebx,%edi 109367: 31 c0 xor %eax,%eax 109369: f2 ae repnz scas %es:(%edi),%al 10936b: f7 d1 not %ecx 10936d: 49 dec %ecx 10936e: c7 04 24 00 00 00 00 movl $0x0,(%esp) 109375: 8d 75 bc lea -0x44(%ebp),%esi 109378: 56 push %esi 109379: 6a 00 push $0x0 10937b: 51 push %ecx 10937c: 53 push %ebx 10937d: e8 2a f0 ff ff call 1083ac 0, &loc, false ); if ( result != 0 ) { 109382: 83 c4 20 add $0x20,%esp 109385: 85 c0 test %eax,%eax 109387: 75 5b jne 1093e4 } /* * Verify you can remove this node as a directory. */ if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) { 109389: 83 ec 0c sub $0xc,%esp 10938c: 56 push %esi 10938d: 8b 45 c8 mov -0x38(%ebp),%eax 109390: ff 50 10 call *0x10(%eax) 109393: 83 c4 10 add $0x10,%esp 109396: 48 dec %eax 109397: 75 5f jne 1093f8 /* * Use the filesystems rmnod to remove the node. */ result = (*loc.handlers->rmnod_h)( &parentloc, &loc ); 109399: 83 ec 08 sub $0x8,%esp 10939c: 56 push %esi 10939d: ff 75 b4 pushl -0x4c(%ebp) 1093a0: 8b 45 c4 mov -0x3c(%ebp),%eax 1093a3: ff 50 34 call *0x34(%eax) rtems_filesystem_freenode( &loc ); 1093a6: 89 34 24 mov %esi,(%esp) 1093a9: 89 45 ac mov %eax,-0x54(%ebp) 1093ac: e8 3b f1 ff ff call 1084ec if ( free_parentloc ) 1093b1: 83 c4 10 add $0x10,%esp 1093b4: 80 7d b3 00 cmpb $0x0,-0x4d(%ebp) 1093b8: 8b 45 ac mov -0x54(%ebp),%eax 1093bb: 75 0b jne 1093c8 rtems_filesystem_freenode( &parentloc ); return result; } 1093bd: 8d 65 f4 lea -0xc(%ebp),%esp 1093c0: 5b pop %ebx 1093c1: 5e pop %esi 1093c2: 5f pop %edi 1093c3: c9 leave 1093c4: c3 ret 1093c5: 8d 76 00 lea 0x0(%esi),%esi result = (*loc.handlers->rmnod_h)( &parentloc, &loc ); rtems_filesystem_freenode( &loc ); if ( free_parentloc ) rtems_filesystem_freenode( &parentloc ); 1093c8: 83 ec 0c sub $0xc,%esp 1093cb: ff 75 b4 pushl -0x4c(%ebp) 1093ce: e8 19 f1 ff ff call 1084ec 1093d3: 83 c4 10 add $0x10,%esp 1093d6: 8b 45 ac mov -0x54(%ebp),%eax return result; } 1093d9: 8d 65 f4 lea -0xc(%ebp),%esp 1093dc: 5b pop %ebx 1093dd: 5e pop %esi 1093de: 5f pop %edi 1093df: c9 leave 1093e0: c3 ret 1093e1: 8d 76 00 lea 0x0(%esi),%esi name += rtems_filesystem_prefix_separators( name, strlen( name ) ); result = rtems_filesystem_evaluate_relative_path( name , strlen( name ), 0, &loc, false ); if ( result != 0 ) { if ( free_parentloc ) 1093e4: 80 7d b3 00 cmpb $0x0,-0x4d(%ebp) 1093e8: 75 6f jne 109459 rtems_filesystem_freenode( &parentloc ); return -1; 1093ea: b8 ff ff ff ff mov $0xffffffff,%eax rtems_filesystem_freenode( &loc ); if ( free_parentloc ) rtems_filesystem_freenode( &parentloc ); return result; } 1093ef: 8d 65 f4 lea -0xc(%ebp),%esp 1093f2: 5b pop %ebx 1093f3: 5e pop %esi 1093f4: 5f pop %edi 1093f5: c9 leave 1093f6: c3 ret 1093f7: 90 nop /* * Verify you can remove this node as a directory. */ if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) { rtems_filesystem_freenode( &loc ); 1093f8: 83 ec 0c sub $0xc,%esp 1093fb: 56 push %esi 1093fc: e8 eb f0 ff ff call 1084ec if ( free_parentloc ) 109401: 83 c4 10 add $0x10,%esp 109404: 80 7d b3 00 cmpb $0x0,-0x4d(%ebp) 109408: 74 0e je 109418 <== NEVER TAKEN rtems_filesystem_freenode( &parentloc ); 10940a: 83 ec 0c sub $0xc,%esp 10940d: ff 75 b4 pushl -0x4c(%ebp) 109410: e8 d7 f0 ff ff call 1084ec 109415: 83 c4 10 add $0x10,%esp rtems_set_errno_and_return_minus_one( ENOTDIR ); 109418: e8 eb a6 00 00 call 113b08 <__errno> 10941d: c7 00 14 00 00 00 movl $0x14,(%eax) 109423: b8 ff ff ff ff mov $0xffffffff,%eax 109428: eb 93 jmp 1093bd 10942a: 66 90 xchg %ax,%ax parentpathlen = rtems_filesystem_dirname ( pathname ); if ( parentpathlen == 0 ) rtems_filesystem_get_start_loc( pathname, &i, &parentloc ); else { result = rtems_filesystem_evaluate_path(pathname, parentpathlen, 10942c: 89 c2 mov %eax,%edx 10942e: 83 ec 0c sub $0xc,%esp 109431: 6a 00 push $0x0 109433: 8d 45 d0 lea -0x30(%ebp),%eax 109436: 89 45 b4 mov %eax,-0x4c(%ebp) 109439: 50 push %eax 10943a: 6a 02 push $0x2 10943c: 52 push %edx 10943d: 53 push %ebx 10943e: 89 55 ac mov %edx,-0x54(%ebp) 109441: e8 ce ef ff ff call 108414 RTEMS_LIBIO_PERMS_WRITE, &parentloc, false ); if ( result != 0 ) 109446: 83 c4 20 add $0x20,%esp 109449: 85 c0 test %eax,%eax 10944b: 8b 55 ac mov -0x54(%ebp),%edx 10944e: 75 9a jne 1093ea <== NEVER TAKEN return -1; free_parentloc = true; 109450: c6 45 b3 01 movb $0x1,-0x4d(%ebp) 109454: e9 df fe ff ff jmp 109338 result = rtems_filesystem_evaluate_relative_path( name , strlen( name ), 0, &loc, false ); if ( result != 0 ) { if ( free_parentloc ) rtems_filesystem_freenode( &parentloc ); 109459: 83 ec 0c sub $0xc,%esp 10945c: ff 75 b4 pushl -0x4c(%ebp) 10945f: e8 88 f0 ff ff call 1084ec 109464: 83 c4 10 add $0x10,%esp return -1; 109467: b8 ff ff ff ff mov $0xffffffff,%eax 10946c: e9 4c ff ff ff jmp 1093bd =============================================================================== 0010c550 : * errno - otherwise */ int rtems_aio_enqueue (rtems_aio_request *req) { 10c550: 55 push %ebp 10c551: 89 e5 mov %esp,%ebp 10c553: 57 push %edi 10c554: 56 push %esi 10c555: 53 push %ebx 10c556: 83 ec 58 sub $0x58,%esp 10c559: 8b 5d 08 mov 0x8(%ebp),%ebx struct sched_param param; /* The queue should be initialized */ AIO_assert (aio_request_queue.initialized == AIO_QUEUE_INITIALIZED); result = pthread_mutex_lock (&aio_request_queue.mutex); 10c55c: 68 00 aa 12 00 push $0x12aa00 10c561: e8 86 09 00 00 call 10ceec 10c566: 89 c6 mov %eax,%esi if (result != 0) { 10c568: 83 c4 10 add $0x10,%esp 10c56b: 85 c0 test %eax,%eax 10c56d: 0f 85 c1 00 00 00 jne 10c634 <== NEVER TAKEN return result; } /* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined, we can use aio_reqprio to lower the priority of the request */ pthread_getschedparam (pthread_self(), &policy, ¶m); 10c573: e8 24 12 00 00 call 10d79c 10c578: 51 push %ecx 10c579: 8d 55 c4 lea -0x3c(%ebp),%edx 10c57c: 52 push %edx 10c57d: 8d 55 e0 lea -0x20(%ebp),%edx 10c580: 52 push %edx 10c581: 50 push %eax 10c582: e8 e1 0d 00 00 call 10d368 req->caller_thread = pthread_self (); 10c587: e8 10 12 00 00 call 10d79c 10c58c: 89 43 10 mov %eax,0x10(%ebx) req->priority = param.sched_priority - req->aiocbp->aio_reqprio; 10c58f: 8b 43 14 mov 0x14(%ebx),%eax 10c592: 8b 55 c4 mov -0x3c(%ebp),%edx 10c595: 2b 50 14 sub 0x14(%eax),%edx 10c598: 89 53 0c mov %edx,0xc(%ebx) req->policy = policy; 10c59b: 8b 55 e0 mov -0x20(%ebp),%edx 10c59e: 89 53 08 mov %edx,0x8(%ebx) req->aiocbp->error_code = EINPROGRESS; 10c5a1: c7 40 30 77 00 00 00 movl $0x77,0x30(%eax) req->aiocbp->return_value = 0; 10c5a8: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax) if ((aio_request_queue.idle_threads == 0) && 10c5af: 83 c4 10 add $0x10,%esp 10c5b2: 8b 15 68 aa 12 00 mov 0x12aa68,%edx 10c5b8: 85 d2 test %edx,%edx 10c5ba: 75 0d jne 10c5c9 <== NEVER TAKEN 10c5bc: 83 3d 64 aa 12 00 04 cmpl $0x4,0x12aa64 10c5c3: 0f 8e 83 00 00 00 jle 10c64c else { /* the maximum number of threads has been already created even though some of them might be idle. The request belongs to one of the active fd chain */ r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, 10c5c9: 51 push %ecx 10c5ca: 6a 00 push $0x0 10c5cc: ff 30 pushl (%eax) 10c5ce: 68 48 aa 12 00 push $0x12aa48 10c5d3: e8 28 fb ff ff call 10c100 10c5d8: 89 c7 mov %eax,%edi req->aiocbp->aio_fildes, 0); if (r_chain != NULL) 10c5da: 83 c4 10 add $0x10,%esp 10c5dd: 85 c0 test %eax,%eax 10c5df: 0f 84 df 00 00 00 je 10c6c4 { pthread_mutex_lock (&r_chain->mutex); 10c5e5: 8d 57 1c lea 0x1c(%edi),%edx 10c5e8: 83 ec 0c sub $0xc,%esp 10c5eb: 52 push %edx 10c5ec: 89 55 b4 mov %edx,-0x4c(%ebp) 10c5ef: e8 f8 08 00 00 call 10ceec rtems_aio_insert_prio (&r_chain->perfd, req); 10c5f4: 58 pop %eax 10c5f5: 5a pop %edx 10c5f6: 53 push %ebx 10c5f7: 8d 47 08 lea 0x8(%edi),%eax 10c5fa: 50 push %eax 10c5fb: e8 48 fe ff ff call 10c448 pthread_cond_signal (&r_chain->cond); 10c600: 83 c7 20 add $0x20,%edi 10c603: 89 3c 24 mov %edi,(%esp) 10c606: e8 b1 04 00 00 call 10cabc pthread_mutex_unlock (&r_chain->mutex); 10c60b: 8b 55 b4 mov -0x4c(%ebp),%edx 10c60e: 89 14 24 mov %edx,(%esp) 10c611: e8 5e 09 00 00 call 10cf74 10c616: 83 c4 10 add $0x10,%esp if (aio_request_queue.idle_threads > 0) pthread_cond_signal (&aio_request_queue.new_req); } } pthread_mutex_unlock (&aio_request_queue.mutex); 10c619: 83 ec 0c sub $0xc,%esp 10c61c: 68 00 aa 12 00 push $0x12aa00 10c621: e8 4e 09 00 00 call 10cf74 return 0; 10c626: 83 c4 10 add $0x10,%esp } 10c629: 89 f0 mov %esi,%eax 10c62b: 8d 65 f4 lea -0xc(%ebp),%esp 10c62e: 5b pop %ebx 10c62f: 5e pop %esi 10c630: 5f pop %edi 10c631: c9 leave 10c632: c3 ret 10c633: 90 nop /* The queue should be initialized */ AIO_assert (aio_request_queue.initialized == AIO_QUEUE_INITIALIZED); result = pthread_mutex_lock (&aio_request_queue.mutex); if (result != 0) { free (req); 10c634: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c637: 53 push %ebx <== NOT EXECUTED 10c638: e8 f7 c4 ff ff call 108b34 <== NOT EXECUTED return result; 10c63d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } pthread_mutex_unlock (&aio_request_queue.mutex); return 0; } 10c640: 89 f0 mov %esi,%eax <== NOT EXECUTED 10c642: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c645: 5b pop %ebx <== NOT EXECUTED 10c646: 5e pop %esi <== NOT EXECUTED 10c647: 5f pop %edi <== NOT EXECUTED 10c648: c9 leave <== NOT EXECUTED 10c649: c3 ret <== NOT EXECUTED 10c64a: 66 90 xchg %ax,%ax <== NOT EXECUTED if ((aio_request_queue.idle_threads == 0) && aio_request_queue.active_threads < AIO_MAX_THREADS) /* we still have empty places on the active_threads chain */ { chain = &aio_request_queue.work_req; r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1); 10c64c: 57 push %edi 10c64d: 6a 01 push $0x1 10c64f: ff 30 pushl (%eax) 10c651: 68 48 aa 12 00 push $0x12aa48 10c656: e8 a5 fa ff ff call 10c100 10c65b: 89 c7 mov %eax,%edi if (r_chain->new_fd == 1) { 10c65d: 83 c4 10 add $0x10,%esp 10c660: 83 78 18 01 cmpl $0x1,0x18(%eax) 10c664: 0f 85 7b ff ff ff jne 10c5e5 RTEMS_INLINE_ROUTINE void _Chain_Prepend( Chain_Control *the_chain, Chain_Node *the_node ) { _Chain_Insert(_Chain_Head(the_chain), the_node); 10c66a: 83 ec 08 sub $0x8,%esp 10c66d: 53 push %ebx 10c66e: 8d 40 08 lea 0x8(%eax),%eax 10c671: 50 push %eax 10c672: e8 81 22 00 00 call 10e8f8 <_Chain_Insert> rtems_chain_prepend (&r_chain->perfd, &req->next_prio); r_chain->new_fd = 0; 10c677: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi) pthread_mutex_init (&r_chain->mutex, NULL); 10c67e: 5a pop %edx 10c67f: 59 pop %ecx 10c680: 6a 00 push $0x0 10c682: 8d 47 1c lea 0x1c(%edi),%eax 10c685: 50 push %eax 10c686: e8 15 07 00 00 call 10cda0 pthread_cond_init (&r_chain->cond, NULL); 10c68b: 5b pop %ebx 10c68c: 58 pop %eax 10c68d: 6a 00 push $0x0 10c68f: 8d 47 20 lea 0x20(%edi),%eax 10c692: 50 push %eax 10c693: e8 70 03 00 00 call 10ca08 AIO_printf ("New thread \n"); result = pthread_create (&thid, &aio_request_queue.attr, 10c698: 57 push %edi 10c699: 68 fc c1 10 00 push $0x10c1fc 10c69e: 68 08 aa 12 00 push $0x12aa08 10c6a3: 8d 45 e4 lea -0x1c(%ebp),%eax 10c6a6: 50 push %eax 10c6a7: e8 34 0a 00 00 call 10d0e0 10c6ac: 89 c3 mov %eax,%ebx rtems_aio_handle, (void *) r_chain); if (result != 0) { 10c6ae: 83 c4 20 add $0x20,%esp 10c6b1: 85 c0 test %eax,%eax 10c6b3: 0f 85 8e 00 00 00 jne 10c747 <== NEVER TAKEN pthread_mutex_unlock (&aio_request_queue.mutex); return result; } ++aio_request_queue.active_threads; 10c6b9: ff 05 64 aa 12 00 incl 0x12aa64 10c6bf: e9 55 ff ff ff jmp 10c619 } else { /* or to the idle chain */ chain = &aio_request_queue.idle_req; r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1); 10c6c4: 57 push %edi 10c6c5: 6a 01 push $0x1 10c6c7: 8b 43 14 mov 0x14(%ebx),%eax 10c6ca: ff 30 pushl (%eax) 10c6cc: 68 54 aa 12 00 push $0x12aa54 10c6d1: e8 2a fa ff ff call 10c100 10c6d6: 89 c7 mov %eax,%edi if (r_chain->new_fd == 1) { 10c6d8: 83 c4 10 add $0x10,%esp 10c6db: 83 78 18 01 cmpl $0x1,0x18(%eax) 10c6df: 74 33 je 10c714 r_chain->new_fd = 0; pthread_mutex_init (&r_chain->mutex, NULL); pthread_cond_init (&r_chain->cond, NULL); } else /* just insert the request in the existing fd chain */ rtems_aio_insert_prio (&r_chain->perfd, req); 10c6e1: 83 ec 08 sub $0x8,%esp 10c6e4: 53 push %ebx 10c6e5: 83 c7 08 add $0x8,%edi 10c6e8: 57 push %edi 10c6e9: e8 5a fd ff ff call 10c448 10c6ee: 83 c4 10 add $0x10,%esp if (aio_request_queue.idle_threads > 0) 10c6f1: 8b 0d 68 aa 12 00 mov 0x12aa68,%ecx 10c6f7: 85 c9 test %ecx,%ecx 10c6f9: 0f 8e 1a ff ff ff jle 10c619 <== ALWAYS TAKEN pthread_cond_signal (&aio_request_queue.new_req); 10c6ff: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c702: 68 04 aa 12 00 push $0x12aa04 <== NOT EXECUTED 10c707: e8 b0 03 00 00 call 10cabc <== NOT EXECUTED 10c70c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c70f: e9 05 ff ff ff jmp 10c619 <== NOT EXECUTED 10c714: 83 ec 08 sub $0x8,%esp 10c717: 53 push %ebx 10c718: 8d 40 08 lea 0x8(%eax),%eax 10c71b: 50 push %eax 10c71c: e8 d7 21 00 00 call 10e8f8 <_Chain_Insert> if (r_chain->new_fd == 1) { /* If this is a new fd chain we signal the idle threads that might be waiting for requests */ AIO_printf (" New chain on waiting queue \n "); rtems_chain_prepend (&r_chain->perfd, &req->next_prio); r_chain->new_fd = 0; 10c721: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi) pthread_mutex_init (&r_chain->mutex, NULL); 10c728: 5a pop %edx 10c729: 59 pop %ecx 10c72a: 6a 00 push $0x0 10c72c: 8d 47 1c lea 0x1c(%edi),%eax 10c72f: 50 push %eax 10c730: e8 6b 06 00 00 call 10cda0 pthread_cond_init (&r_chain->cond, NULL); 10c735: 5b pop %ebx 10c736: 58 pop %eax 10c737: 6a 00 push $0x0 10c739: 83 c7 20 add $0x20,%edi 10c73c: 57 push %edi 10c73d: e8 c6 02 00 00 call 10ca08 10c742: 83 c4 10 add $0x10,%esp 10c745: eb aa jmp 10c6f1 AIO_printf ("New thread \n"); result = pthread_create (&thid, &aio_request_queue.attr, rtems_aio_handle, (void *) r_chain); if (result != 0) { pthread_mutex_unlock (&aio_request_queue.mutex); 10c747: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c74a: 68 00 aa 12 00 push $0x12aa00 <== NOT EXECUTED 10c74f: e8 20 08 00 00 call 10cf74 <== NOT EXECUTED return result; 10c754: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c757: 89 de mov %ebx,%esi <== NOT EXECUTED 10c759: e9 cb fe ff ff jmp 10c629 <== NOT EXECUTED =============================================================================== 0010c1fc : * NULL - if error */ static void * rtems_aio_handle (void *arg) { 10c1fc: 55 push %ebp 10c1fd: 89 e5 mov %esp,%ebp 10c1ff: 57 push %edi 10c200: 56 push %esi 10c201: 53 push %ebx 10c202: 83 ec 4c sub $0x4c,%esp rtems_aio_request_chain *r_chain = arg; 10c205: 8b 7d 08 mov 0x8(%ebp),%edi 10c208: 8d 47 1c lea 0x1c(%edi),%eax 10c20b: 89 45 b4 mov %eax,-0x4c(%ebp) 10c20e: 66 90 xchg %ax,%ax /* acquire the mutex of the current fd chain. we don't need to lock the queue mutex since we can add requests to idle fd chains or even active ones if the working request has been extracted from the chain */ result = pthread_mutex_lock (&r_chain->mutex); 10c210: 83 ec 0c sub $0xc,%esp 10c213: ff 75 b4 pushl -0x4c(%ebp) 10c216: e8 d1 0c 00 00 call 10ceec if (result != 0) 10c21b: 83 c4 10 add $0x10,%esp 10c21e: 85 c0 test %eax,%eax 10c220: 0f 85 2a 01 00 00 jne 10c350 <== NEVER TAKEN } } AIO_printf ("Thread finished\n"); return NULL; } 10c226: 8b 5f 08 mov 0x8(%edi),%ebx RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 10c229: 8d 47 0c lea 0xc(%edi),%eax /* If the locked chain is not empty, take the first request extract it, unlock the chain and process the request, in this way the user can supply more requests to this fd chain */ if (!rtems_chain_is_empty (chain)) { 10c22c: 39 c3 cmp %eax,%ebx 10c22e: 0f 84 d0 00 00 00 je 10c304 node = rtems_chain_first (chain); req = (rtems_aio_request *) node; /* See _POSIX_PRIORITIZE_IO and _POSIX_PRIORITY_SCHEDULING discussion in rtems_aio_enqueue () */ pthread_getschedparam (pthread_self(), &policy, ¶m); 10c234: e8 63 15 00 00 call 10d79c 10c239: 52 push %edx 10c23a: 8d 55 c0 lea -0x40(%ebp),%edx 10c23d: 52 push %edx 10c23e: 8d 55 e4 lea -0x1c(%ebp),%edx 10c241: 52 push %edx 10c242: 50 push %eax 10c243: e8 20 11 00 00 call 10d368 param.sched_priority = req->priority; 10c248: 8b 43 0c mov 0xc(%ebx),%eax 10c24b: 89 45 c0 mov %eax,-0x40(%ebp) pthread_setschedparam (pthread_self(), req->policy, ¶m); 10c24e: 8b 73 08 mov 0x8(%ebx),%esi 10c251: e8 46 15 00 00 call 10d79c 10c256: 83 c4 0c add $0xc,%esp 10c259: 8d 55 c0 lea -0x40(%ebp),%edx 10c25c: 52 push %edx 10c25d: 56 push %esi 10c25e: 50 push %eax 10c25f: e8 48 15 00 00 call 10d7ac */ RTEMS_INLINE_ROUTINE void rtems_chain_extract( rtems_chain_node *the_node ) { _Chain_Extract( the_node ); 10c264: 89 1c 24 mov %ebx,(%esp) 10c267: e8 50 26 00 00 call 10e8bc <_Chain_Extract> rtems_chain_extract (node); pthread_mutex_unlock (&r_chain->mutex); 10c26c: 5e pop %esi 10c26d: ff 75 b4 pushl -0x4c(%ebp) 10c270: e8 ff 0c 00 00 call 10cf74 switch (req->aiocbp->aio_lio_opcode) { 10c275: 8b 73 14 mov 0x14(%ebx),%esi 10c278: 83 c4 10 add $0x10,%esp 10c27b: 8b 46 2c mov 0x2c(%esi),%eax 10c27e: 83 f8 02 cmp $0x2,%eax 10c281: 74 21 je 10c2a4 10c283: 83 f8 03 cmp $0x3,%eax 10c286: 74 6c je 10c2f4 <== NEVER TAKEN 10c288: 48 dec %eax 10c289: 74 4d je 10c2d8 <== ALWAYS TAKEN default: result = -1; } if (result == -1) { req->aiocbp->return_value = -1; 10c28b: c7 46 34 ff ff ff ff movl $0xffffffff,0x34(%esi) <== NOT EXECUTED req->aiocbp->error_code = errno; 10c292: e8 01 99 00 00 call 115b98 <__errno> <== NOT EXECUTED 10c297: 8b 00 mov (%eax),%eax <== NOT EXECUTED 10c299: 89 46 30 mov %eax,0x30(%esi) <== NOT EXECUTED 10c29c: e9 6f ff ff ff jmp 10c210 <== NOT EXECUTED 10c2a1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED req->aiocbp->aio_nbytes, req->aiocbp->aio_offset); break; case LIO_WRITE: AIO_printf ("write\n"); result = pwrite (req->aiocbp->aio_fildes, 10c2a4: 83 ec 0c sub $0xc,%esp 10c2a7: ff 76 08 pushl 0x8(%esi) 10c2aa: ff 76 04 pushl 0x4(%esi) 10c2ad: ff 76 10 pushl 0x10(%esi) 10c2b0: ff 76 0c pushl 0xc(%esi) 10c2b3: ff 36 pushl (%esi) 10c2b5: e8 76 a3 00 00 call 116630 (void *) req->aiocbp->aio_buf, req->aiocbp->aio_nbytes, req->aiocbp->aio_offset); break; 10c2ba: 83 c4 20 add $0x20,%esp break; default: result = -1; } if (result == -1) { 10c2bd: 83 f8 ff cmp $0xffffffff,%eax 10c2c0: 0f 84 78 01 00 00 je 10c43e <== NEVER TAKEN req->aiocbp->return_value = -1; req->aiocbp->error_code = errno; } else { req->aiocbp->return_value = result; 10c2c6: 8b 53 14 mov 0x14(%ebx),%edx 10c2c9: 89 42 34 mov %eax,0x34(%edx) req->aiocbp->error_code = 0; 10c2cc: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx) 10c2d3: e9 38 ff ff ff jmp 10c210 pthread_mutex_unlock (&r_chain->mutex); switch (req->aiocbp->aio_lio_opcode) { case LIO_READ: AIO_printf ("read\n"); result = pread (req->aiocbp->aio_fildes, 10c2d8: 83 ec 0c sub $0xc,%esp 10c2db: ff 76 08 pushl 0x8(%esi) 10c2de: ff 76 04 pushl 0x4(%esi) 10c2e1: ff 76 10 pushl 0x10(%esi) 10c2e4: ff 76 0c pushl 0xc(%esi) 10c2e7: ff 36 pushl (%esi) 10c2e9: e8 8e a2 00 00 call 11657c (void *) req->aiocbp->aio_buf, req->aiocbp->aio_nbytes, req->aiocbp->aio_offset); break; 10c2ee: 83 c4 20 add $0x20,%esp 10c2f1: eb ca jmp 10c2bd 10c2f3: 90 nop req->aiocbp->aio_nbytes, req->aiocbp->aio_offset); break; case LIO_SYNC: AIO_printf ("sync\n"); result = fsync (req->aiocbp->aio_fildes); 10c2f4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c2f7: ff 36 pushl (%esi) <== NOT EXECUTED 10c2f9: e8 16 67 00 00 call 112a14 <== NOT EXECUTED break; 10c2fe: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c301: eb ba jmp 10c2bd <== NOT EXECUTED 10c303: 90 nop <== NOT EXECUTED struct timespec timeout; AIO_printf ("Chain is empty [WQ], wait for work\n"); pthread_mutex_unlock (&r_chain->mutex); 10c304: 83 ec 0c sub $0xc,%esp 10c307: ff 75 b4 pushl -0x4c(%ebp) 10c30a: e8 65 0c 00 00 call 10cf74 pthread_mutex_lock (&aio_request_queue.mutex); 10c30f: c7 04 24 00 aa 12 00 movl $0x12aa00,(%esp) 10c316: e8 d1 0b 00 00 call 10ceec if (rtems_chain_is_empty (chain)) 10c31b: 83 c4 10 add $0x10,%esp 10c31e: 3b 5f 08 cmp 0x8(%edi),%ebx 10c321: 74 39 je 10c35c <== ALWAYS TAKEN } } /* If there was a request added in the initial fd chain then release the mutex and process it */ pthread_mutex_unlock (&aio_request_queue.mutex); 10c323: 83 ec 0c sub $0xc,%esp 10c326: 68 00 aa 12 00 push $0x12aa00 10c32b: e8 44 0c 00 00 call 10cf74 10c330: 83 c4 10 add $0x10,%esp 10c333: e9 d8 fe ff ff jmp 10c210 /* If no new fd chain was added in the idle requests then this thread is finished */ if (result == ETIMEDOUT) { AIO_printf ("Etimeout\n"); --aio_request_queue.idle_threads; 10c338: ff 0d 68 aa 12 00 decl 0x12aa68 pthread_mutex_unlock (&aio_request_queue.mutex); 10c33e: 83 ec 0c sub $0xc,%esp 10c341: 68 00 aa 12 00 push $0x12aa00 10c346: e8 29 0c 00 00 call 10cf74 return NULL; 10c34b: 83 c4 10 add $0x10,%esp 10c34e: 66 90 xchg %ax,%ax } } AIO_printf ("Thread finished\n"); return NULL; } 10c350: 31 c0 xor %eax,%eax 10c352: 8d 65 f4 lea -0xc(%ebp),%esp 10c355: 5b pop %ebx 10c356: 5e pop %esi 10c357: 5f pop %edi 10c358: c9 leave 10c359: c3 ret 10c35a: 66 90 xchg %ax,%ax pthread_mutex_unlock (&r_chain->mutex); pthread_mutex_lock (&aio_request_queue.mutex); if (rtems_chain_is_empty (chain)) { clock_gettime (CLOCK_REALTIME, &timeout); 10c35c: 83 ec 08 sub $0x8,%esp 10c35f: 8d 45 dc lea -0x24(%ebp),%eax 10c362: 50 push %eax 10c363: 6a 01 push $0x1 10c365: e8 66 05 00 00 call 10c8d0 timeout.tv_sec += 3; 10c36a: 83 45 dc 03 addl $0x3,-0x24(%ebp) timeout.tv_nsec = 0; 10c36e: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) result = pthread_cond_timedwait (&r_chain->cond, 10c375: 8d 5f 20 lea 0x20(%edi),%ebx 10c378: 83 c4 0c add $0xc,%esp 10c37b: 8d 55 dc lea -0x24(%ebp),%edx 10c37e: 52 push %edx 10c37f: 68 00 aa 12 00 push $0x12aa00 10c384: 53 push %ebx 10c385: e8 b6 07 00 00 call 10cb40 &aio_request_queue.mutex, &timeout); /* If no requests were added to the chain we delete the fd chain from the queue and start working with idle fd chains */ if (result == ETIMEDOUT) { 10c38a: 83 c4 10 add $0x10,%esp 10c38d: 83 f8 74 cmp $0x74,%eax 10c390: 75 91 jne 10c323 <== NEVER TAKEN 10c392: 83 ec 0c sub $0xc,%esp 10c395: 57 push %edi 10c396: e8 21 25 00 00 call 10e8bc <_Chain_Extract> rtems_chain_extract (&r_chain->next_fd); pthread_mutex_destroy (&r_chain->mutex); 10c39b: 59 pop %ecx 10c39c: ff 75 b4 pushl -0x4c(%ebp) 10c39f: e8 dc 08 00 00 call 10cc80 pthread_cond_destroy (&r_chain->cond); 10c3a4: 89 1c 24 mov %ebx,(%esp) 10c3a7: e8 90 05 00 00 call 10c93c free (r_chain); 10c3ac: 89 3c 24 mov %edi,(%esp) 10c3af: e8 80 c7 ff ff call 108b34 } } AIO_printf ("Thread finished\n"); return NULL; } 10c3b4: 8b 3d 54 aa 12 00 mov 0x12aa54,%edi pthread_cond_destroy (&r_chain->cond); free (r_chain); /* If the idle chain is empty sleep for 3 seconds and wait for a signal. The thread now becomes idle. */ if (rtems_chain_is_empty (&aio_request_queue.idle_req)) { 10c3ba: 83 c4 10 add $0x10,%esp 10c3bd: 81 ff 58 aa 12 00 cmp $0x12aa58,%edi 10c3c3: 74 2b je 10c3f0 } } /* Otherwise move this chain to the working chain and start the loop all over again */ AIO_printf ("Work on idle\n"); --aio_request_queue.idle_threads; 10c3c5: ff 0d 68 aa 12 00 decl 0x12aa68 ++aio_request_queue.active_threads; 10c3cb: ff 05 64 aa 12 00 incl 0x12aa64 10c3d1: 83 ec 0c sub $0xc,%esp 10c3d4: 57 push %edi 10c3d5: e8 e2 24 00 00 call 10e8bc <_Chain_Extract> node = rtems_chain_first (&aio_request_queue.idle_req); rtems_chain_extract (node); r_chain = (rtems_aio_request_chain *) node; rtems_aio_move_to_work (r_chain); 10c3da: 89 3c 24 mov %edi,(%esp) 10c3dd: e8 de fd ff ff call 10c1c0 10c3e2: 83 c4 10 add $0x10,%esp 10c3e5: 8d 47 1c lea 0x1c(%edi),%eax 10c3e8: 89 45 b4 mov %eax,-0x4c(%ebp) 10c3eb: e9 33 ff ff ff jmp 10c323 /* If the idle chain is empty sleep for 3 seconds and wait for a signal. The thread now becomes idle. */ if (rtems_chain_is_empty (&aio_request_queue.idle_req)) { AIO_printf ("Chain is empty [IQ], wait for work\n"); ++aio_request_queue.idle_threads; 10c3f0: ff 05 68 aa 12 00 incl 0x12aa68 --aio_request_queue.active_threads; 10c3f6: ff 0d 64 aa 12 00 decl 0x12aa64 clock_gettime (CLOCK_REALTIME, &timeout); 10c3fc: 52 push %edx 10c3fd: 52 push %edx 10c3fe: 8d 45 dc lea -0x24(%ebp),%eax 10c401: 50 push %eax 10c402: 6a 01 push $0x1 10c404: e8 c7 04 00 00 call 10c8d0 timeout.tv_sec += 3; 10c409: 83 45 dc 03 addl $0x3,-0x24(%ebp) timeout.tv_nsec = 0; 10c40d: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) result = pthread_cond_timedwait (&aio_request_queue.new_req, 10c414: 83 c4 0c add $0xc,%esp 10c417: 8d 55 dc lea -0x24(%ebp),%edx 10c41a: 52 push %edx 10c41b: 68 00 aa 12 00 push $0x12aa00 10c420: 68 04 aa 12 00 push $0x12aa04 10c425: e8 16 07 00 00 call 10cb40 &aio_request_queue.mutex, &timeout); /* If no new fd chain was added in the idle requests then this thread is finished */ if (result == ETIMEDOUT) { 10c42a: 83 c4 10 add $0x10,%esp 10c42d: 83 f8 74 cmp $0x74,%eax 10c430: 0f 84 02 ff ff ff je 10c338 <== ALWAYS TAKEN 10c436: 8b 3d 54 aa 12 00 mov 0x12aa54,%edi <== NOT EXECUTED 10c43c: eb 87 jmp 10c3c5 <== NOT EXECUTED break; default: result = -1; } if (result == -1) { 10c43e: 8b 73 14 mov 0x14(%ebx),%esi <== NOT EXECUTED 10c441: e9 45 fe ff ff jmp 10c28b <== NOT EXECUTED =============================================================================== 0010bfd8 : * 0 - if initialization succeeded */ int rtems_aio_init (void) { 10bfd8: 55 push %ebp 10bfd9: 89 e5 mov %esp,%ebp 10bfdb: 53 push %ebx 10bfdc: 83 ec 10 sub $0x10,%esp int result = 0; result = pthread_attr_init (&aio_request_queue.attr); 10bfdf: 68 08 aa 12 00 push $0x12aa08 10bfe4: e8 a3 10 00 00 call 10d08c 10bfe9: 89 c3 mov %eax,%ebx if (result != 0) 10bfeb: 83 c4 10 add $0x10,%esp 10bfee: 85 c0 test %eax,%eax 10bff0: 74 0a je 10bffc <== ALWAYS TAKEN aio_request_queue.active_threads = 0; aio_request_queue.idle_threads = 0; aio_request_queue.initialized = AIO_QUEUE_INITIALIZED; return result; } 10bff2: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10bff4: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10bff7: c9 leave <== NOT EXECUTED 10bff8: c3 ret <== NOT EXECUTED 10bff9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED result = pthread_attr_init (&aio_request_queue.attr); if (result != 0) return result; result = 10bffc: 83 ec 08 sub $0x8,%esp 10bfff: 6a 00 push $0x0 10c001: 68 08 aa 12 00 push $0x12aa08 10c006: e8 ad 10 00 00 call 10d0b8 pthread_attr_setdetachstate (&aio_request_queue.attr, PTHREAD_CREATE_DETACHED); if (result != 0) 10c00b: 83 c4 10 add $0x10,%esp 10c00e: 85 c0 test %eax,%eax 10c010: 0f 85 96 00 00 00 jne 10c0ac <== NEVER TAKEN pthread_attr_destroy (&aio_request_queue.attr); result = pthread_mutex_init (&aio_request_queue.mutex, NULL); 10c016: 83 ec 08 sub $0x8,%esp 10c019: 6a 00 push $0x0 10c01b: 68 00 aa 12 00 push $0x12aa00 10c020: e8 7b 0d 00 00 call 10cda0 if (result != 0) 10c025: 83 c4 10 add $0x10,%esp 10c028: 85 c0 test %eax,%eax 10c02a: 0f 85 b8 00 00 00 jne 10c0e8 <== NEVER TAKEN pthread_attr_destroy (&aio_request_queue.attr); result = pthread_cond_init (&aio_request_queue.new_req, NULL); 10c030: 83 ec 08 sub $0x8,%esp 10c033: 6a 00 push $0x0 10c035: 68 04 aa 12 00 push $0x12aa04 10c03a: e8 c9 09 00 00 call 10ca08 10c03f: 89 c3 mov %eax,%ebx if (result != 0) { 10c041: 83 c4 10 add $0x10,%esp 10c044: 85 c0 test %eax,%eax 10c046: 75 7c jne 10c0c4 <== NEVER TAKEN ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 10c048: c7 05 48 aa 12 00 4c movl $0x12aa4c,0x12aa48 10c04f: aa 12 00 head->previous = NULL; 10c052: c7 05 4c aa 12 00 00 movl $0x0,0x12aa4c 10c059: 00 00 00 tail->previous = head; 10c05c: c7 05 50 aa 12 00 48 movl $0x12aa48,0x12aa50 10c063: aa 12 00 ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 10c066: c7 05 54 aa 12 00 58 movl $0x12aa58,0x12aa54 10c06d: aa 12 00 head->previous = NULL; 10c070: c7 05 58 aa 12 00 00 movl $0x0,0x12aa58 10c077: 00 00 00 tail->previous = head; 10c07a: c7 05 5c aa 12 00 54 movl $0x12aa54,0x12aa5c 10c081: aa 12 00 } rtems_chain_initialize_empty (&aio_request_queue.work_req); rtems_chain_initialize_empty (&aio_request_queue.idle_req); aio_request_queue.active_threads = 0; 10c084: c7 05 64 aa 12 00 00 movl $0x0,0x12aa64 10c08b: 00 00 00 aio_request_queue.idle_threads = 0; 10c08e: c7 05 68 aa 12 00 00 movl $0x0,0x12aa68 10c095: 00 00 00 aio_request_queue.initialized = AIO_QUEUE_INITIALIZED; 10c098: c7 05 60 aa 12 00 0b movl $0xb00b,0x12aa60 10c09f: b0 00 00 return result; } 10c0a2: 89 d8 mov %ebx,%eax 10c0a4: 8b 5d fc mov -0x4(%ebp),%ebx 10c0a7: c9 leave 10c0a8: c3 ret 10c0a9: 8d 76 00 lea 0x0(%esi),%esi result = pthread_attr_setdetachstate (&aio_request_queue.attr, PTHREAD_CREATE_DETACHED); if (result != 0) pthread_attr_destroy (&aio_request_queue.attr); 10c0ac: 83 ec 0c sub $0xc,%esp 10c0af: 68 08 aa 12 00 push $0x12aa08 <== NOT EXECUTED 10c0b4: e8 af 0f 00 00 call 10d068 <== NOT EXECUTED 10c0b9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c0bc: e9 55 ff ff ff jmp 10c016 <== NOT EXECUTED 10c0c1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED pthread_attr_destroy (&aio_request_queue.attr); result = pthread_cond_init (&aio_request_queue.new_req, NULL); if (result != 0) { pthread_mutex_destroy (&aio_request_queue.mutex); 10c0c4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c0c7: 68 00 aa 12 00 push $0x12aa00 <== NOT EXECUTED 10c0cc: e8 af 0b 00 00 call 10cc80 <== NOT EXECUTED pthread_attr_destroy (&aio_request_queue.attr); 10c0d1: c7 04 24 08 aa 12 00 movl $0x12aa08,(%esp) <== NOT EXECUTED 10c0d8: e8 8b 0f 00 00 call 10d068 <== NOT EXECUTED 10c0dd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c0e0: e9 63 ff ff ff jmp 10c048 <== NOT EXECUTED 10c0e5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED pthread_attr_destroy (&aio_request_queue.attr); result = pthread_mutex_init (&aio_request_queue.mutex, NULL); if (result != 0) pthread_attr_destroy (&aio_request_queue.attr); 10c0e8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c0eb: 68 08 aa 12 00 push $0x12aa08 <== NOT EXECUTED 10c0f0: e8 73 0f 00 00 call 10d068 <== NOT EXECUTED 10c0f5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c0f8: e9 33 ff ff ff jmp 10c030 <== NOT EXECUTED =============================================================================== 0010c448 : * NONE */ void rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req) { 10c448: 55 push %ebp 10c449: 89 e5 mov %esp,%ebp 10c44b: 56 push %esi 10c44c: 53 push %ebx 10c44d: 8b 55 08 mov 0x8(%ebp),%edx 10c450: 8b 75 0c mov 0xc(%ebp),%esi } } AIO_printf ("Thread finished\n"); return NULL; } 10c453: 8b 02 mov (%edx),%eax 10c455: 8d 4a 04 lea 0x4(%edx),%ecx rtems_chain_node *node; AIO_printf ("FD exists \n"); node = rtems_chain_first (chain); if (rtems_chain_is_empty (chain)) { 10c458: 39 c8 cmp %ecx,%eax 10c45a: 74 27 je 10c483 <== NEVER TAKEN rtems_chain_prepend (chain, &req->next_prio); } else { AIO_printf ("Add by priority \n"); int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio; while (req->aiocbp->aio_reqprio > prio && 10c45c: 8b 56 14 mov 0x14(%esi),%edx 10c45f: 8b 5a 14 mov 0x14(%edx),%ebx if (rtems_chain_is_empty (chain)) { AIO_printf ("First in chain \n"); rtems_chain_prepend (chain, &req->next_prio); } else { AIO_printf ("Add by priority \n"); int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio; 10c462: 8b 50 14 mov 0x14(%eax),%edx while (req->aiocbp->aio_reqprio > prio && 10c465: 39 5a 14 cmp %ebx,0x14(%edx) 10c468: 7c 06 jl 10c470 <== NEVER TAKEN 10c46a: eb 0e jmp 10c47a 10c46c: 39 c8 cmp %ecx,%eax <== NOT EXECUTED 10c46e: 74 1c je 10c48c <== NOT EXECUTED } } AIO_printf ("Thread finished\n"); return NULL; } 10c470: 8b 00 mov (%eax),%eax <== NOT EXECUTED int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio; while (req->aiocbp->aio_reqprio > prio && !rtems_chain_is_tail (chain, node)) { node = rtems_chain_next (node); prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio; 10c472: 8b 50 14 mov 0x14(%eax),%edx <== NOT EXECUTED rtems_chain_prepend (chain, &req->next_prio); } else { AIO_printf ("Add by priority \n"); int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio; while (req->aiocbp->aio_reqprio > prio && 10c475: 39 5a 14 cmp %ebx,0x14(%edx) <== NOT EXECUTED 10c478: 7c f2 jl 10c46c <== NOT EXECUTED RTEMS_INLINE_ROUTINE void rtems_chain_insert( rtems_chain_node *after_node, rtems_chain_node *the_node ) { _Chain_Insert( after_node, the_node ); 10c47a: 89 75 0c mov %esi,0xc(%ebp) 10c47d: 8b 40 04 mov 0x4(%eax),%eax 10c480: 89 45 08 mov %eax,0x8(%ebp) } rtems_chain_insert (node->previous, &req->next_prio); } } 10c483: 5b pop %ebx 10c484: 5e pop %esi 10c485: c9 leave 10c486: e9 6d 24 00 00 jmp 10e8f8 <_Chain_Insert> 10c48b: 90 nop } } AIO_printf ("Thread finished\n"); return NULL; } 10c48c: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10c48e: eb ea jmp 10c47a <== NOT EXECUTED =============================================================================== 0010c1c0 : * NONE */ void rtems_aio_move_to_work (rtems_aio_request_chain *r_chain) { 10c1c0: 55 push %ebp 10c1c1: 89 e5 mov %esp,%ebp 10c1c3: 83 ec 08 sub $0x8,%esp 10c1c6: 8b 4d 08 mov 0x8(%ebp),%ecx } } AIO_printf ("Thread finished\n"); return NULL; } 10c1c9: a1 48 aa 12 00 mov 0x12aa48,%eax rtems_chain_node *node; node = rtems_chain_first (&aio_request_queue.work_req); temp = (rtems_aio_request_chain *) node; while (temp->fildes < r_chain->fildes && 10c1ce: 8b 51 14 mov 0x14(%ecx),%edx 10c1d1: 39 50 14 cmp %edx,0x14(%eax) 10c1d4: 7c 09 jl 10c1df <== ALWAYS TAKEN 10c1d6: eb 13 jmp 10c1eb <== NOT EXECUTED } } AIO_printf ("Thread finished\n"); return NULL; } 10c1d8: 8b 00 mov (%eax),%eax rtems_chain_node *node; node = rtems_chain_first (&aio_request_queue.work_req); temp = (rtems_aio_request_chain *) node; while (temp->fildes < r_chain->fildes && 10c1da: 39 50 14 cmp %edx,0x14(%eax) 10c1dd: 7d 0c jge 10c1eb 10c1df: 3d 4c aa 12 00 cmp $0x12aa4c,%eax 10c1e4: 75 f2 jne 10c1d8 <== ALWAYS TAKEN 10c1e6: b8 4c aa 12 00 mov $0x12aa4c,%eax <== NOT EXECUTED 10c1eb: 83 ec 08 sub $0x8,%esp 10c1ee: 51 push %ecx 10c1ef: ff 70 04 pushl 0x4(%eax) 10c1f2: e8 01 27 00 00 call 10e8f8 <_Chain_Insert> 10c1f7: 83 c4 10 add $0x10,%esp node = rtems_chain_next (node); temp = (rtems_aio_request_chain *) node; } rtems_chain_insert (rtems_chain_previous (node), &r_chain->next_fd); } 10c1fa: c9 leave 10c1fb: c3 ret =============================================================================== 0010c490 : * Output parameters: * NONE */ void rtems_aio_remove_fd (rtems_aio_request_chain *r_chain) { 10c490: 55 push %ebp 10c491: 89 e5 mov %esp,%ebp 10c493: 57 push %edi 10c494: 56 push %esi 10c495: 53 push %ebx 10c496: 83 ec 0c sub $0xc,%esp 10c499: 8b 7d 08 mov 0x8(%ebp),%edi } } AIO_printf ("Thread finished\n"); return NULL; } 10c49c: 8b 5f 08 mov 0x8(%edi),%ebx RTEMS_INLINE_ROUTINE bool _Chain_Is_tail( Chain_Control *the_chain, const Chain_Node *the_node ) { return (the_node == _Chain_Tail(the_chain)); 10c49f: 83 c7 0c add $0xc,%edi rtems_chain_control *chain; rtems_chain_node *node; chain = &r_chain->perfd; node = rtems_chain_first (chain); while (!rtems_chain_is_tail (chain, node)) 10c4a2: 39 fb cmp %edi,%ebx 10c4a4: 75 04 jne 10c4aa <== ALWAYS TAKEN 10c4a6: eb 2d jmp 10c4d5 <== NOT EXECUTED { rtems_chain_extract (node); rtems_aio_request *req = (rtems_aio_request *) node; node = rtems_chain_next (node); 10c4a8: 89 f3 mov %esi,%ebx */ RTEMS_INLINE_ROUTINE void rtems_chain_extract( rtems_chain_node *the_node ) { _Chain_Extract( the_node ); 10c4aa: 83 ec 0c sub $0xc,%esp 10c4ad: 53 push %ebx 10c4ae: e8 09 24 00 00 call 10e8bc <_Chain_Extract> } } AIO_printf ("Thread finished\n"); return NULL; } 10c4b3: 8b 33 mov (%ebx),%esi while (!rtems_chain_is_tail (chain, node)) { rtems_chain_extract (node); rtems_aio_request *req = (rtems_aio_request *) node; node = rtems_chain_next (node); req->aiocbp->error_code = ECANCELED; 10c4b5: 8b 43 14 mov 0x14(%ebx),%eax 10c4b8: c7 40 30 8c 00 00 00 movl $0x8c,0x30(%eax) req->aiocbp->return_value = -1; 10c4bf: c7 40 34 ff ff ff ff movl $0xffffffff,0x34(%eax) free (req); 10c4c6: 89 1c 24 mov %ebx,(%esp) 10c4c9: e8 66 c6 ff ff call 108b34 rtems_chain_control *chain; rtems_chain_node *node; chain = &r_chain->perfd; node = rtems_chain_first (chain); while (!rtems_chain_is_tail (chain, node)) 10c4ce: 83 c4 10 add $0x10,%esp 10c4d1: 39 fe cmp %edi,%esi 10c4d3: 75 d3 jne 10c4a8 node = rtems_chain_next (node); req->aiocbp->error_code = ECANCELED; req->aiocbp->return_value = -1; free (req); } } 10c4d5: 8d 65 f4 lea -0xc(%ebp),%esp 10c4d8: 5b pop %ebx 10c4d9: 5e pop %esi 10c4da: 5f pop %edi 10c4db: c9 leave 10c4dc: c3 ret =============================================================================== 0010c4e0 : * AIO_NOTCANCELED - if request was not canceled * AIO_CANCELED - if request was canceled */ int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp) { 10c4e0: 55 push %ebp 10c4e1: 89 e5 mov %esp,%ebp 10c4e3: 53 push %ebx 10c4e4: 83 ec 04 sub $0x4,%esp 10c4e7: 8b 55 08 mov 0x8(%ebp),%edx 10c4ea: 8b 4d 0c mov 0xc(%ebp),%ecx } } AIO_printf ("Thread finished\n"); return NULL; } 10c4ed: 8b 02 mov (%edx),%eax RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 10c4ef: 83 c2 04 add $0x4,%edx * AIO_CANCELED - if request was canceled */ int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp) { if (rtems_chain_is_empty (chain)) 10c4f2: 39 d0 cmp %edx,%eax 10c4f4: 74 4e je 10c544 return AIO_ALLDONE; rtems_chain_node *node = rtems_chain_first (chain); rtems_aio_request *current; current = (rtems_aio_request *) node; 10c4f6: 89 c3 mov %eax,%ebx while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) { 10c4f8: 39 48 14 cmp %ecx,0x14(%eax) 10c4fb: 75 0a jne 10c507 <== NEVER TAKEN 10c4fd: eb 19 jmp 10c518 10c4ff: 90 nop node = rtems_chain_next (node); current = (rtems_aio_request *) node; 10c500: 89 c3 mov %eax,%ebx <== NOT EXECUTED rtems_chain_node *node = rtems_chain_first (chain); rtems_aio_request *current; current = (rtems_aio_request *) node; while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) { 10c502: 39 48 14 cmp %ecx,0x14(%eax) <== NOT EXECUTED 10c505: 74 11 je 10c518 <== NOT EXECUTED } } AIO_printf ("Thread finished\n"); return NULL; } 10c507: 8b 00 mov (%eax),%eax <== NOT EXECUTED rtems_chain_node *node = rtems_chain_first (chain); rtems_aio_request *current; current = (rtems_aio_request *) node; while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) { 10c509: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10c50b: 75 f3 jne 10c500 <== NOT EXECUTED node = rtems_chain_next (node); current = (rtems_aio_request *) node; } if (rtems_chain_is_tail (chain, node)) return AIO_NOTCANCELED; 10c50d: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED current->aiocbp->return_value = -1; free (current); } return AIO_CANCELED; } 10c512: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c515: c9 leave <== NOT EXECUTED 10c516: c3 ret <== NOT EXECUTED 10c517: 90 nop <== NOT EXECUTED 10c518: 83 ec 0c sub $0xc,%esp 10c51b: 50 push %eax 10c51c: e8 9b 23 00 00 call 10e8bc <_Chain_Extract> if (rtems_chain_is_tail (chain, node)) return AIO_NOTCANCELED; else { rtems_chain_extract (node); current->aiocbp->error_code = ECANCELED; 10c521: 8b 43 14 mov 0x14(%ebx),%eax 10c524: c7 40 30 8c 00 00 00 movl $0x8c,0x30(%eax) current->aiocbp->return_value = -1; 10c52b: c7 40 34 ff ff ff ff movl $0xffffffff,0x34(%eax) free (current); 10c532: 89 1c 24 mov %ebx,(%esp) 10c535: e8 fa c5 ff ff call 108b34 } return AIO_CANCELED; 10c53a: 83 c4 10 add $0x10,%esp 10c53d: 31 c0 xor %eax,%eax } 10c53f: 8b 5d fc mov -0x4(%ebp),%ebx 10c542: c9 leave 10c543: c3 ret */ int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp) { if (rtems_chain_is_empty (chain)) return AIO_ALLDONE; 10c544: b8 02 00 00 00 mov $0x2,%eax current->aiocbp->return_value = -1; free (current); } return AIO_CANCELED; } 10c549: 8b 5d fc mov -0x4(%ebp),%ebx 10c54c: c9 leave 10c54d: c3 ret =============================================================================== 0010c100 : * */ rtems_aio_request_chain * rtems_aio_search_fd (rtems_chain_control *chain, int fildes, int create) { 10c100: 55 push %ebp 10c101: 89 e5 mov %esp,%ebp 10c103: 57 push %edi 10c104: 56 push %esi 10c105: 53 push %ebx 10c106: 83 ec 1c sub $0x1c,%esp 10c109: 8b 75 08 mov 0x8(%ebp),%esi 10c10c: 8b 5d 0c mov 0xc(%ebp),%ebx } } AIO_printf ("Thread finished\n"); return NULL; } 10c10f: 8b 06 mov (%esi),%eax rtems_chain_node *node; node = rtems_chain_first (chain); r_chain = (rtems_aio_request_chain *) node; while (r_chain->fildes < fildes && !rtems_chain_is_tail (chain, node)) { 10c111: 8b 50 14 mov 0x14(%eax),%edx 10c114: 39 d3 cmp %edx,%ebx 10c116: 7e 28 jle 10c140 RTEMS_INLINE_ROUTINE bool _Chain_Is_tail( Chain_Control *the_chain, const Chain_Node *the_node ) { return (the_node == _Chain_Tail(the_chain)); 10c118: 8d 4e 04 lea 0x4(%esi),%ecx 10c11b: eb 0c jmp 10c129 10c11d: 8d 76 00 lea 0x0(%esi),%esi } } AIO_printf ("Thread finished\n"); return NULL; } 10c120: 8b 00 mov (%eax),%eax rtems_chain_node *node; node = rtems_chain_first (chain); r_chain = (rtems_aio_request_chain *) node; while (r_chain->fildes < fildes && !rtems_chain_is_tail (chain, node)) { 10c122: 8b 50 14 mov 0x14(%eax),%edx 10c125: 39 da cmp %ebx,%edx 10c127: 7d 17 jge 10c140 10c129: 39 c8 cmp %ecx,%eax 10c12b: 75 f3 jne 10c120 10c12d: 89 c7 mov %eax,%edi } if (r_chain->fildes == fildes) r_chain->new_fd = 0; else { if (create == 0) 10c12f: 8b 45 10 mov 0x10(%ebp),%eax 10c132: 85 c0 test %eax,%eax 10c134: 75 1f jne 10c155 r_chain = NULL; 10c136: 31 c0 xor %eax,%eax r_chain->new_fd = 1; r_chain->fildes = fildes; } } return r_chain; } 10c138: 8d 65 f4 lea -0xc(%ebp),%esp 10c13b: 5b pop %ebx 10c13c: 5e pop %esi 10c13d: 5f pop %edi 10c13e: c9 leave 10c13f: c3 ret } } AIO_printf ("Thread finished\n"); return NULL; } 10c140: 89 c7 mov %eax,%edi while (r_chain->fildes < fildes && !rtems_chain_is_tail (chain, node)) { node = rtems_chain_next (node); r_chain = (rtems_aio_request_chain *) node; } if (r_chain->fildes == fildes) 10c142: 39 d3 cmp %edx,%ebx 10c144: 75 e9 jne 10c12f r_chain->new_fd = 0; 10c146: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) r_chain->new_fd = 1; r_chain->fildes = fildes; } } return r_chain; } 10c14d: 8d 65 f4 lea -0xc(%ebp),%esp 10c150: 5b pop %ebx 10c151: 5e pop %esi 10c152: 5f pop %edi 10c153: c9 leave 10c154: c3 ret r_chain->new_fd = 0; else { if (create == 0) r_chain = NULL; else { r_chain = malloc (sizeof (rtems_aio_request_chain)); 10c155: 83 ec 0c sub $0xc,%esp 10c158: 6a 24 push $0x24 10c15a: e8 e9 ce ff ff call 109048 10c15f: 89 c2 mov %eax,%edx RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); 10c161: 8d 4a 0c lea 0xc(%edx),%ecx 10c164: 89 4a 08 mov %ecx,0x8(%edx) head->next = tail; head->previous = NULL; 10c167: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx) */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); 10c16e: 8d 4a 08 lea 0x8(%edx),%ecx 10c171: 89 4a 10 mov %ecx,0x10(%edx) RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 10c174: 8d 4e 04 lea 0x4(%esi),%ecx rtems_chain_initialize_empty (&r_chain->perfd); if (rtems_chain_is_empty (chain)) 10c177: 83 c4 10 add $0x10,%esp 10c17a: 39 0e cmp %ecx,(%esi) 10c17c: 74 27 je 10c1a5 RTEMS_INLINE_ROUTINE void rtems_chain_insert( rtems_chain_node *after_node, rtems_chain_node *the_node ) { _Chain_Insert( after_node, the_node ); 10c17e: 83 ec 08 sub $0x8,%esp 10c181: 52 push %edx 10c182: ff 77 04 pushl 0x4(%edi) 10c185: 89 45 e4 mov %eax,-0x1c(%ebp) 10c188: 89 55 e0 mov %edx,-0x20(%ebp) 10c18b: e8 68 27 00 00 call 10e8f8 <_Chain_Insert> 10c190: 83 c4 10 add $0x10,%esp 10c193: 8b 55 e0 mov -0x20(%ebp),%edx 10c196: 8b 45 e4 mov -0x1c(%ebp),%eax rtems_chain_prepend (chain, &r_chain->next_fd); else rtems_chain_insert (rtems_chain_previous (node), &r_chain->next_fd); r_chain->new_fd = 1; 10c199: c7 42 18 01 00 00 00 movl $0x1,0x18(%edx) r_chain->fildes = fildes; 10c1a0: 89 5a 14 mov %ebx,0x14(%edx) 10c1a3: eb a8 jmp 10c14d RTEMS_INLINE_ROUTINE void _Chain_Prepend( Chain_Control *the_chain, Chain_Node *the_node ) { _Chain_Insert(_Chain_Head(the_chain), the_node); 10c1a5: 83 ec 08 sub $0x8,%esp 10c1a8: 52 push %edx 10c1a9: 56 push %esi 10c1aa: 89 45 e4 mov %eax,-0x1c(%ebp) 10c1ad: 89 55 e0 mov %edx,-0x20(%ebp) 10c1b0: e8 43 27 00 00 call 10e8f8 <_Chain_Insert> 10c1b5: 83 c4 10 add $0x10,%esp 10c1b8: 8b 45 e4 mov -0x1c(%ebp),%eax 10c1bb: 8b 55 e0 mov -0x20(%ebp),%edx 10c1be: eb d9 jmp 10c199 =============================================================================== 001087ec : uint32_t rtems_assoc_local_by_name( const rtems_assoc_t *ap, const char *name ) { 1087ec: 55 push %ebp 1087ed: 89 e5 mov %esp,%ebp 1087ef: 83 ec 10 sub $0x10,%esp const rtems_assoc_t *nap; nap = rtems_assoc_ptr_by_name(ap, name); 1087f2: ff 75 0c pushl 0xc(%ebp) 1087f5: ff 75 08 pushl 0x8(%ebp) 1087f8: e8 13 02 00 00 call 108a10 if (nap) 1087fd: 83 c4 10 add $0x10,%esp 108800: 85 c0 test %eax,%eax 108802: 74 08 je 10880c return nap->local_value; 108804: 8b 40 04 mov 0x4(%eax),%eax return 0; } 108807: c9 leave 108808: c3 ret 108809: 8d 76 00 lea 0x0(%esi),%esi nap = rtems_assoc_ptr_by_name(ap, name); if (nap) return nap->local_value; return 0; 10880c: 31 c0 xor %eax,%eax } 10880e: c9 leave 10880f: c3 ret =============================================================================== 0010fbc0 : uint32_t rtems_assoc_local_by_remote( const rtems_assoc_t *ap, uint32_t remote_value ) { 10fbc0: 55 push %ebp 10fbc1: 89 e5 mov %esp,%ebp 10fbc3: 83 ec 10 sub $0x10,%esp const rtems_assoc_t *nap; nap = rtems_assoc_ptr_by_remote(ap, remote_value); 10fbc6: ff 75 0c pushl 0xc(%ebp) 10fbc9: ff 75 08 pushl 0x8(%ebp) 10fbcc: e8 13 00 00 00 call 10fbe4 if (nap) 10fbd1: 83 c4 10 add $0x10,%esp 10fbd4: 85 c0 test %eax,%eax 10fbd6: 74 08 je 10fbe0 return nap->local_value; 10fbd8: 8b 40 04 mov 0x4(%eax),%eax return 0; } 10fbdb: c9 leave 10fbdc: c3 ret 10fbdd: 8d 76 00 lea 0x0(%esi),%esi nap = rtems_assoc_ptr_by_remote(ap, remote_value); if (nap) return nap->local_value; return 0; 10fbe0: 31 c0 xor %eax,%eax } 10fbe2: c9 leave 10fbe3: c3 ret =============================================================================== 00112a5c : uint32_t rtems_assoc_local_by_remote_bitfield( const rtems_assoc_t *ap, uint32_t remote_value ) { 112a5c: 55 push %ebp 112a5d: 89 e5 mov %esp,%ebp 112a5f: 57 push %edi 112a60: 56 push %esi 112a61: 53 push %ebx 112a62: 83 ec 1c sub $0x1c,%esp 112a65: 8b 7d 0c mov 0xc(%ebp),%edi 112a68: be 20 00 00 00 mov $0x20,%esi uint32_t b; uint32_t local_value = 0; 112a6d: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) for (b = 1; b; b <<= 1) { 112a74: bb 01 00 00 00 mov $0x1,%ebx 112a79: eb 06 jmp 112a81 112a7b: 90 nop 112a7c: d1 e3 shl %ebx 112a7e: 4e dec %esi 112a7f: 74 1b je 112a9c if (b & remote_value) 112a81: 85 fb test %edi,%ebx 112a83: 74 f7 je 112a7c local_value |= rtems_assoc_local_by_remote(ap, b); 112a85: 83 ec 08 sub $0x8,%esp 112a88: 53 push %ebx 112a89: ff 75 08 pushl 0x8(%ebp) 112a8c: e8 2f d1 ff ff call 10fbc0 112a91: 09 45 e4 or %eax,-0x1c(%ebp) 112a94: 83 c4 10 add $0x10,%esp ) { uint32_t b; uint32_t local_value = 0; for (b = 1; b; b <<= 1) { 112a97: d1 e3 shl %ebx 112a99: 4e dec %esi 112a9a: 75 e5 jne 112a81 <== ALWAYS TAKEN if (b & remote_value) local_value |= rtems_assoc_local_by_remote(ap, b); } return local_value; } 112a9c: 8b 45 e4 mov -0x1c(%ebp),%eax 112a9f: 8d 65 f4 lea -0xc(%ebp),%esp 112aa2: 5b pop %ebx 112aa3: 5e pop %esi 112aa4: 5f pop %edi 112aa5: c9 leave 112aa6: c3 ret =============================================================================== 00114d04 : const char *rtems_assoc_name_by_local( const rtems_assoc_t *ap, uint32_t local_value ) { 114d04: 55 push %ebp 114d05: 89 e5 mov %esp,%ebp 114d07: 53 push %ebx 114d08: 83 ec 0c sub $0xc,%esp 114d0b: 8b 5d 0c mov 0xc(%ebp),%ebx const rtems_assoc_t *nap; nap = rtems_assoc_ptr_by_local(ap, local_value); 114d0e: 53 push %ebx 114d0f: ff 75 08 pushl 0x8(%ebp) 114d12: e8 1d 00 00 00 call 114d34 if (nap) 114d17: 83 c4 10 add $0x10,%esp 114d1a: 85 c0 test %eax,%eax 114d1c: 74 0a je 114d28 return nap->name; 114d1e: 8b 00 mov (%eax),%eax return rtems_assoc_name_bad(local_value); } 114d20: 8b 5d fc mov -0x4(%ebp),%ebx 114d23: c9 leave 114d24: c3 ret 114d25: 8d 76 00 lea 0x0(%esi),%esi nap = rtems_assoc_ptr_by_local(ap, local_value); if (nap) return nap->name; return rtems_assoc_name_bad(local_value); 114d28: 89 5d 08 mov %ebx,0x8(%ebp) } 114d2b: 8b 5d fc mov -0x4(%ebp),%ebx 114d2e: c9 leave nap = rtems_assoc_ptr_by_local(ap, local_value); if (nap) return nap->name; return rtems_assoc_name_bad(local_value); 114d2f: e9 78 30 00 00 jmp 117dac =============================================================================== 00108988 : const char *rtems_assoc_name_by_remote( const rtems_assoc_t *ap, uint32_t remote_value ) { 108988: 55 push %ebp 108989: 89 e5 mov %esp,%ebp 10898b: 53 push %ebx 10898c: 83 ec 0c sub $0xc,%esp 10898f: 8b 5d 0c mov 0xc(%ebp),%ebx const rtems_assoc_t *nap; nap = rtems_assoc_ptr_by_remote(ap, remote_value); 108992: 53 push %ebx 108993: ff 75 08 pushl 0x8(%ebp) 108996: e8 ed 00 00 00 call 108a88 if (nap) 10899b: 83 c4 10 add $0x10,%esp 10899e: 85 c0 test %eax,%eax 1089a0: 74 0a je 1089ac return nap->name; 1089a2: 8b 00 mov (%eax),%eax return rtems_assoc_name_bad(remote_value); } 1089a4: 8b 5d fc mov -0x4(%ebp),%ebx 1089a7: c9 leave 1089a8: c3 ret 1089a9: 8d 76 00 lea 0x0(%esi),%esi nap = rtems_assoc_ptr_by_remote(ap, remote_value); if (nap) return nap->name; return rtems_assoc_name_bad(remote_value); 1089ac: 89 5d 08 mov %ebx,0x8(%ebp) } 1089af: 8b 5d fc mov -0x4(%ebp),%ebx 1089b2: c9 leave nap = rtems_assoc_ptr_by_remote(ap, remote_value); if (nap) return nap->name; return rtems_assoc_name_bad(remote_value); 1089b3: e9 f8 7e 00 00 jmp 1108b0 =============================================================================== 00114d34 : const rtems_assoc_t *rtems_assoc_ptr_by_local( const rtems_assoc_t *ap, uint32_t local_value ) { 114d34: 55 push %ebp 114d35: 89 e5 mov %esp,%ebp 114d37: 57 push %edi 114d38: 56 push %esi 114d39: 53 push %ebx 114d3a: 8b 45 08 mov 0x8(%ebp),%eax 114d3d: 8b 55 0c mov 0xc(%ebp),%edx const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) 114d40: 8b 30 mov (%eax),%esi 114d42: 85 f6 test %esi,%esi 114d44: 74 3e je 114d84 114d46: bf b8 7c 12 00 mov $0x127cb8,%edi 114d4b: b9 0a 00 00 00 mov $0xa,%ecx 114d50: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) 114d52: 74 18 je 114d6c const rtems_assoc_t *rtems_assoc_ptr_by_local( const rtems_assoc_t *ap, uint32_t local_value ) { const rtems_assoc_t *default_ap = 0; 114d54: 31 c9 xor %ecx,%ecx 114d56: eb 09 jmp 114d61 if (rtems_assoc_is_default(ap)) default_ap = ap++; for ( ; ap->name; ap++) 114d58: 83 c0 0c add $0xc,%eax 114d5b: 8b 18 mov (%eax),%ebx 114d5d: 85 db test %ebx,%ebx 114d5f: 74 1b je 114d7c if (ap->local_value == local_value) 114d61: 39 50 04 cmp %edx,0x4(%eax) 114d64: 75 f2 jne 114d58 return ap; return default_ap; } 114d66: 5b pop %ebx 114d67: 5e pop %esi 114d68: 5f pop %edi 114d69: c9 leave 114d6a: c3 ret 114d6b: 90 nop ) { const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) default_ap = ap++; 114d6c: 8d 58 0c lea 0xc(%eax),%ebx for ( ; ap->name; ap++) 114d6f: 8b 70 0c mov 0xc(%eax),%esi 114d72: 85 f6 test %esi,%esi 114d74: 74 f0 je 114d66 <== NEVER TAKEN 114d76: 89 c1 mov %eax,%ecx 114d78: 89 d8 mov %ebx,%eax 114d7a: eb e5 jmp 114d61 114d7c: 89 c8 mov %ecx,%eax if (ap->local_value == local_value) return ap; return default_ap; } 114d7e: 5b pop %ebx 114d7f: 5e pop %esi 114d80: 5f pop %edi 114d81: c9 leave 114d82: c3 ret 114d83: 90 nop const rtems_assoc_t *rtems_assoc_ptr_by_local( const rtems_assoc_t *ap, uint32_t local_value ) { const rtems_assoc_t *default_ap = 0; 114d84: 31 c0 xor %eax,%eax for ( ; ap->name; ap++) if (ap->local_value == local_value) return ap; return default_ap; } 114d86: 5b pop %ebx 114d87: 5e pop %esi 114d88: 5f pop %edi 114d89: c9 leave 114d8a: c3 ret =============================================================================== 00108a10 : const rtems_assoc_t *rtems_assoc_ptr_by_name( const rtems_assoc_t *ap, const char *name ) { 108a10: 55 push %ebp 108a11: 89 e5 mov %esp,%ebp 108a13: 57 push %edi 108a14: 56 push %esi 108a15: 53 push %ebx 108a16: 83 ec 0c sub $0xc,%esp 108a19: 8b 5d 08 mov 0x8(%ebp),%ebx const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) 108a1c: 8b 03 mov (%ebx),%eax 108a1e: 85 c0 test %eax,%eax 108a20: 74 5a je 108a7c 108a22: bf 7d 0b 12 00 mov $0x120b7d,%edi 108a27: b9 0a 00 00 00 mov $0xa,%ecx 108a2c: 89 c6 mov %eax,%esi 108a2e: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) 108a30: 74 2e je 108a60 const rtems_assoc_t *rtems_assoc_ptr_by_name( const rtems_assoc_t *ap, const char *name ) { const rtems_assoc_t *default_ap = 0; 108a32: 31 f6 xor %esi,%esi 108a34: eb 0b jmp 108a41 108a36: 66 90 xchg %ax,%ax if (rtems_assoc_is_default(ap)) default_ap = ap++; for ( ; ap->name; ap++) 108a38: 83 c3 0c add $0xc,%ebx 108a3b: 8b 03 mov (%ebx),%eax 108a3d: 85 c0 test %eax,%eax 108a3f: 74 2f je 108a70 if (strcmp(ap->name, name) == 0) 108a41: 83 ec 08 sub $0x8,%esp 108a44: ff 75 0c pushl 0xc(%ebp) 108a47: 50 push %eax 108a48: e8 8f c0 00 00 call 114adc 108a4d: 83 c4 10 add $0x10,%esp 108a50: 85 c0 test %eax,%eax 108a52: 75 e4 jne 108a38 return ap; return default_ap; } 108a54: 89 d8 mov %ebx,%eax 108a56: 8d 65 f4 lea -0xc(%ebp),%esp 108a59: 5b pop %ebx 108a5a: 5e pop %esi 108a5b: 5f pop %edi 108a5c: c9 leave 108a5d: c3 ret 108a5e: 66 90 xchg %ax,%ax ) { const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) default_ap = ap++; 108a60: 8d 53 0c lea 0xc(%ebx),%edx for ( ; ap->name; ap++) 108a63: 8b 43 0c mov 0xc(%ebx),%eax 108a66: 85 c0 test %eax,%eax 108a68: 74 ea je 108a54 <== NEVER TAKEN 108a6a: 89 de mov %ebx,%esi 108a6c: 89 d3 mov %edx,%ebx 108a6e: eb d1 jmp 108a41 108a70: 89 f3 mov %esi,%ebx if (strcmp(ap->name, name) == 0) return ap; return default_ap; } 108a72: 89 d8 mov %ebx,%eax 108a74: 8d 65 f4 lea -0xc(%ebp),%esp 108a77: 5b pop %ebx 108a78: 5e pop %esi 108a79: 5f pop %edi 108a7a: c9 leave 108a7b: c3 ret const rtems_assoc_t *rtems_assoc_ptr_by_name( const rtems_assoc_t *ap, const char *name ) { const rtems_assoc_t *default_ap = 0; 108a7c: 31 db xor %ebx,%ebx for ( ; ap->name; ap++) if (strcmp(ap->name, name) == 0) return ap; return default_ap; } 108a7e: 89 d8 mov %ebx,%eax 108a80: 8d 65 f4 lea -0xc(%ebp),%esp 108a83: 5b pop %ebx 108a84: 5e pop %esi 108a85: 5f pop %edi 108a86: c9 leave 108a87: c3 ret =============================================================================== 0010fbe4 : const rtems_assoc_t *rtems_assoc_ptr_by_remote( const rtems_assoc_t *ap, uint32_t remote_value ) { 10fbe4: 55 push %ebp 10fbe5: 89 e5 mov %esp,%ebp 10fbe7: 57 push %edi 10fbe8: 56 push %esi 10fbe9: 53 push %ebx 10fbea: 8b 45 08 mov 0x8(%ebp),%eax 10fbed: 8b 55 0c mov 0xc(%ebp),%edx const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) 10fbf0: 8b 30 mov (%eax),%esi 10fbf2: 85 f6 test %esi,%esi 10fbf4: 74 3e je 10fc34 10fbf6: bf 18 19 12 00 mov $0x121918,%edi 10fbfb: b9 0a 00 00 00 mov $0xa,%ecx 10fc00: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) 10fc02: 74 18 je 10fc1c const rtems_assoc_t *rtems_assoc_ptr_by_remote( const rtems_assoc_t *ap, uint32_t remote_value ) { const rtems_assoc_t *default_ap = 0; 10fc04: 31 c9 xor %ecx,%ecx 10fc06: eb 09 jmp 10fc11 if (rtems_assoc_is_default(ap)) default_ap = ap++; for ( ; ap->name; ap++) 10fc08: 83 c0 0c add $0xc,%eax 10fc0b: 8b 18 mov (%eax),%ebx 10fc0d: 85 db test %ebx,%ebx 10fc0f: 74 1b je 10fc2c if (ap->remote_value == remote_value) 10fc11: 39 50 08 cmp %edx,0x8(%eax) 10fc14: 75 f2 jne 10fc08 return ap; return default_ap; } 10fc16: 5b pop %ebx 10fc17: 5e pop %esi 10fc18: 5f pop %edi 10fc19: c9 leave 10fc1a: c3 ret 10fc1b: 90 nop ) { const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) default_ap = ap++; 10fc1c: 8d 58 0c lea 0xc(%eax),%ebx for ( ; ap->name; ap++) 10fc1f: 8b 70 0c mov 0xc(%eax),%esi 10fc22: 85 f6 test %esi,%esi 10fc24: 74 f0 je 10fc16 <== NEVER TAKEN 10fc26: 89 c1 mov %eax,%ecx 10fc28: 89 d8 mov %ebx,%eax 10fc2a: eb e5 jmp 10fc11 10fc2c: 89 c8 mov %ecx,%eax if (ap->remote_value == remote_value) return ap; return default_ap; } 10fc2e: 5b pop %ebx 10fc2f: 5e pop %esi 10fc30: 5f pop %edi 10fc31: c9 leave 10fc32: c3 ret 10fc33: 90 nop const rtems_assoc_t *rtems_assoc_ptr_by_remote( const rtems_assoc_t *ap, uint32_t remote_value ) { const rtems_assoc_t *default_ap = 0; 10fc34: 31 c0 xor %eax,%eax for ( ; ap->name; ap++) if (ap->remote_value == remote_value) return ap; return default_ap; } 10fc36: 5b pop %ebx 10fc37: 5e pop %esi 10fc38: 5f pop %edi 10fc39: c9 leave 10fc3a: c3 ret =============================================================================== 00108b2c : uint32_t rtems_assoc_remote_by_local( const rtems_assoc_t *ap, uint32_t local_value ) { 108b2c: 55 push %ebp 108b2d: 89 e5 mov %esp,%ebp 108b2f: 83 ec 10 sub $0x10,%esp const rtems_assoc_t *nap; nap = rtems_assoc_ptr_by_local(ap, local_value); 108b32: ff 75 0c pushl 0xc(%ebp) 108b35: ff 75 08 pushl 0x8(%ebp) 108b38: e8 7b fe ff ff call 1089b8 if (nap) 108b3d: 83 c4 10 add $0x10,%esp 108b40: 85 c0 test %eax,%eax 108b42: 74 08 je 108b4c return nap->remote_value; 108b44: 8b 40 08 mov 0x8(%eax),%eax return 0; } 108b47: c9 leave 108b48: c3 ret 108b49: 8d 76 00 lea 0x0(%esi),%esi nap = rtems_assoc_ptr_by_local(ap, local_value); if (nap) return nap->remote_value; return 0; 108b4c: 31 c0 xor %eax,%eax } 108b4e: c9 leave 108b4f: c3 ret =============================================================================== 00108ae0 : uint32_t rtems_assoc_remote_by_local_bitfield( const rtems_assoc_t *ap, uint32_t local_value ) { 108ae0: 55 push %ebp 108ae1: 89 e5 mov %esp,%ebp 108ae3: 57 push %edi 108ae4: 56 push %esi 108ae5: 53 push %ebx 108ae6: 83 ec 1c sub $0x1c,%esp 108ae9: 8b 7d 0c mov 0xc(%ebp),%edi 108aec: be 20 00 00 00 mov $0x20,%esi uint32_t b; uint32_t remote_value = 0; 108af1: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) for (b = 1; b; b <<= 1) 108af8: bb 01 00 00 00 mov $0x1,%ebx 108afd: eb 06 jmp 108b05 108aff: 90 nop 108b00: d1 e3 shl %ebx 108b02: 4e dec %esi 108b03: 74 1b je 108b20 if (b & local_value) 108b05: 85 fb test %edi,%ebx 108b07: 74 f7 je 108b00 remote_value |= rtems_assoc_remote_by_local(ap, b); 108b09: 83 ec 08 sub $0x8,%esp 108b0c: 53 push %ebx 108b0d: ff 75 08 pushl 0x8(%ebp) 108b10: e8 17 00 00 00 call 108b2c 108b15: 09 45 e4 or %eax,-0x1c(%ebp) 108b18: 83 c4 10 add $0x10,%esp ) { uint32_t b; uint32_t remote_value = 0; for (b = 1; b; b <<= 1) 108b1b: d1 e3 shl %ebx 108b1d: 4e dec %esi 108b1e: 75 e5 jne 108b05 <== ALWAYS TAKEN if (b & local_value) remote_value |= rtems_assoc_remote_by_local(ap, b); return remote_value; } 108b20: 8b 45 e4 mov -0x1c(%ebp),%eax 108b23: 8d 65 f4 lea -0xc(%ebp),%esp 108b26: 5b pop %ebx 108b27: 5e pop %esi 108b28: 5f pop %edi 108b29: c9 leave 108b2a: c3 ret =============================================================================== 00108b50 : uint32_t rtems_assoc_remote_by_name( const rtems_assoc_t *ap, const char *name ) { 108b50: 55 push %ebp 108b51: 89 e5 mov %esp,%ebp 108b53: 83 ec 10 sub $0x10,%esp const rtems_assoc_t *nap; nap = rtems_assoc_ptr_by_name(ap, name); 108b56: ff 75 0c pushl 0xc(%ebp) 108b59: ff 75 08 pushl 0x8(%ebp) 108b5c: e8 af fe ff ff call 108a10 if (nap) 108b61: 83 c4 10 add $0x10,%esp 108b64: 85 c0 test %eax,%eax 108b66: 74 08 je 108b70 return nap->remote_value; 108b68: 8b 40 08 mov 0x8(%eax),%eax return 0; } 108b6b: c9 leave 108b6c: c3 ret 108b6d: 8d 76 00 lea 0x0(%esi),%esi nap = rtems_assoc_ptr_by_name(ap, name); if (nap) return nap->remote_value; return 0; 108b70: 31 c0 xor %eax,%eax } 108b72: c9 leave 108b73: c3 ret =============================================================================== 001136b4 : rtems_name name, rtems_attribute attribute_set, uint32_t maximum_waiters, rtems_id *id ) { 1136b4: 55 push %ebp 1136b5: 89 e5 mov %esp,%ebp 1136b7: 57 push %edi 1136b8: 56 push %esi 1136b9: 53 push %ebx 1136ba: 83 ec 2c sub $0x2c,%esp 1136bd: 8b 5d 08 mov 0x8(%ebp),%ebx 1136c0: 8b 7d 0c mov 0xc(%ebp),%edi 1136c3: 8b 45 10 mov 0x10(%ebp),%eax 1136c6: 8b 75 14 mov 0x14(%ebp),%esi Barrier_Control *the_barrier; CORE_barrier_Attributes the_attributes; if ( !rtems_is_name_valid( name ) ) 1136c9: 85 db test %ebx,%ebx 1136cb: 0f 84 87 00 00 00 je 113758 return RTEMS_INVALID_NAME; if ( !id ) 1136d1: 85 f6 test %esi,%esi 1136d3: 0f 84 bf 00 00 00 je 113798 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; /* Initialize core barrier attributes */ if ( _Attributes_Is_barrier_automatic( attribute_set ) ) { 1136d9: f7 c7 10 00 00 00 test $0x10,%edi 1136df: 0f 84 83 00 00 00 je 113768 the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; 1136e5: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) if ( maximum_waiters == 0 ) 1136ec: 85 c0 test %eax,%eax 1136ee: 0f 84 80 00 00 00 je 113774 <== NEVER TAKEN return RTEMS_INVALID_NUMBER; } else the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE; the_attributes.maximum_count = maximum_waiters; 1136f4: 89 45 e4 mov %eax,-0x1c(%ebp) 1136f7: a1 90 a7 12 00 mov 0x12a790,%eax 1136fc: 40 inc %eax 1136fd: a3 90 a7 12 00 mov %eax,0x12a790 * This function allocates a barrier control block from * the inactive chain of free barrier control blocks. */ RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Allocate( void ) { return (Barrier_Control *) _Objects_Allocate( &_Barrier_Information ); 113702: 83 ec 0c sub $0xc,%esp 113705: 68 80 b1 12 00 push $0x12b180 11370a: e8 51 b0 ff ff call 10e760 <_Objects_Allocate> _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _Barrier_Allocate(); if ( !the_barrier ) { 11370f: 83 c4 10 add $0x10,%esp 113712: 85 c0 test %eax,%eax 113714: 74 6e je 113784 _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_barrier->attribute_set = attribute_set; 113716: 89 78 10 mov %edi,0x10(%eax) _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 113719: 83 ec 08 sub $0x8,%esp 11371c: 8d 55 e0 lea -0x20(%ebp),%edx 11371f: 52 push %edx 113720: 8d 50 14 lea 0x14(%eax),%edx 113723: 52 push %edx 113724: 89 45 d4 mov %eax,-0x2c(%ebp) 113727: e8 c0 07 00 00 call 113eec <_CORE_barrier_Initialize> Objects_Name name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 11372c: 8b 45 d4 mov -0x2c(%ebp),%eax 11372f: 8b 50 08 mov 0x8(%eax),%edx Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 113732: 0f b7 fa movzwl %dx,%edi #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 113735: 8b 0d 9c b1 12 00 mov 0x12b19c,%ecx 11373b: 89 04 b9 mov %eax,(%ecx,%edi,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 11373e: 89 58 0c mov %ebx,0xc(%eax) &_Barrier_Information, &the_barrier->Object, (Objects_Name) name ); *id = the_barrier->Object.id; 113741: 89 16 mov %edx,(%esi) _Thread_Enable_dispatch(); 113743: e8 74 c0 ff ff call 10f7bc <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 113748: 83 c4 10 add $0x10,%esp 11374b: 31 c0 xor %eax,%eax } 11374d: 8d 65 f4 lea -0xc(%ebp),%esp 113750: 5b pop %ebx 113751: 5e pop %esi 113752: 5f pop %edi 113753: c9 leave 113754: c3 ret 113755: 8d 76 00 lea 0x0(%esi),%esi { Barrier_Control *the_barrier; CORE_barrier_Attributes the_attributes; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 113758: b8 03 00 00 00 mov $0x3,%eax *id = the_barrier->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 11375d: 8d 65 f4 lea -0xc(%ebp),%esp 113760: 5b pop %ebx 113761: 5e pop %esi 113762: 5f pop %edi 113763: c9 leave 113764: c3 ret 113765: 8d 76 00 lea 0x0(%esi),%esi if ( _Attributes_Is_barrier_automatic( attribute_set ) ) { the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; if ( maximum_waiters == 0 ) return RTEMS_INVALID_NUMBER; } else the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE; 113768: c7 45 e0 01 00 00 00 movl $0x1,-0x20(%ebp) 11376f: eb 83 jmp 1136f4 113771: 8d 76 00 lea 0x0(%esi),%esi /* Initialize core barrier attributes */ if ( _Attributes_Is_barrier_automatic( attribute_set ) ) { the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; if ( maximum_waiters == 0 ) return RTEMS_INVALID_NUMBER; 113774: b8 0a 00 00 00 mov $0xa,%eax *id = the_barrier->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 113779: 8d 65 f4 lea -0xc(%ebp),%esp 11377c: 5b pop %ebx 11377d: 5e pop %esi 11377e: 5f pop %edi 11377f: c9 leave 113780: c3 ret 113781: 8d 76 00 lea 0x0(%esi),%esi _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _Barrier_Allocate(); if ( !the_barrier ) { _Thread_Enable_dispatch(); 113784: e8 33 c0 ff ff call 10f7bc <_Thread_Enable_dispatch> return RTEMS_TOO_MANY; 113789: b8 05 00 00 00 mov $0x5,%eax *id = the_barrier->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 11378e: 8d 65 f4 lea -0xc(%ebp),%esp 113791: 5b pop %ebx 113792: 5e pop %esi 113793: 5f pop %edi 113794: c9 leave 113795: c3 ret 113796: 66 90 xchg %ax,%ax if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !id ) return RTEMS_INVALID_ADDRESS; 113798: b8 09 00 00 00 mov $0x9,%eax 11379d: eb ae jmp 11374d =============================================================================== 00107d4c : const char *rtems_bsp_cmdline_get_param( const char *name, char *value, size_t length ) { 107d4c: 55 push %ebp 107d4d: 89 e5 mov %esp,%ebp 107d4f: 57 push %edi 107d50: 56 push %esi 107d51: 53 push %ebx 107d52: 83 ec 1c sub $0x1c,%esp 107d55: 8b 45 08 mov 0x8(%ebp),%eax 107d58: 8b 5d 0c mov 0xc(%ebp),%ebx 107d5b: 8b 75 10 mov 0x10(%ebp),%esi const char *p; if ( !name ) 107d5e: 85 c0 test %eax,%eax 107d60: 75 0a jne 107d6c value[0] = '\0'; p = rtems_bsp_cmdline_get_param_raw( name ); if ( !p ) return NULL; 107d62: 31 c0 xor %eax,%eax copy_string( p, value, length ); return value; } 107d64: 8d 65 f4 lea -0xc(%ebp),%esp 107d67: 5b pop %ebx 107d68: 5e pop %esi 107d69: 5f pop %edi 107d6a: c9 leave 107d6b: c3 ret const char *p; if ( !name ) return NULL; if ( !value ) 107d6c: 85 db test %ebx,%ebx 107d6e: 74 f2 je 107d62 return NULL; if ( !length ) 107d70: 85 f6 test %esi,%esi 107d72: 74 ee je 107d62 return NULL; value[0] = '\0'; 107d74: c6 03 00 movb $0x0,(%ebx) p = rtems_bsp_cmdline_get_param_raw( name ); 107d77: 83 ec 0c sub $0xc,%esp 107d7a: 50 push %eax 107d7b: e8 4c 00 00 00 call 107dcc if ( !p ) 107d80: 83 c4 10 add $0x10,%esp 107d83: 85 c0 test %eax,%eax 107d85: 74 db je 107d62 int i; int quotes; const char *p = start; quotes=0; for (i=0 ; *p && i<== NEVER TAKEN 107d8d: 4e dec %esi 107d8e: 89 75 e4 mov %esi,-0x1c(%ebp) 107d91: 74 34 je 107dc7 <== NEVER TAKEN 107d93: 31 f6 xor %esi,%esi 107d95: 31 d2 xor %edx,%edx 107d97: 31 ff xor %edi,%edi 107d99: eb 24 jmp 107dbf 107d9b: 90 nop if ( *p == '\"' ) { quotes++; } else if ( ((quotes % 2) == 0) && *p == ' ' ) 107d9c: f7 c7 01 00 00 00 test $0x1,%edi 107da2: 75 05 jne 107da9 107da4: 80 f9 20 cmp $0x20,%cl 107da7: 74 1e je 107dc7 break; value[i++] = *p++; 107da9: 88 0c 33 mov %cl,(%ebx,%esi,1) 107dac: 42 inc %edx value[i] = '\0'; 107dad: c6 04 13 00 movb $0x0,(%ebx,%edx,1) int i; int quotes; const char *p = start; quotes=0; for (i=0 ; *p && i 107db8: 3b 55 e4 cmp -0x1c(%ebp),%edx 107dbb: 73 0a jae 107dc7 107dbd: 89 d6 mov %edx,%esi if ( *p == '\"' ) { 107dbf: 80 f9 22 cmp $0x22,%cl 107dc2: 75 d8 jne 107d9c quotes++; 107dc4: 47 inc %edi 107dc5: eb e2 jmp 107da9 int i; int quotes; const char *p = start; quotes=0; for (i=0 ; *p && i =============================================================================== 00107dcc : extern const char *bsp_boot_cmdline; const char *rtems_bsp_cmdline_get_param_raw( const char *name ) { 107dcc: 55 push %ebp 107dcd: 89 e5 mov %esp,%ebp 107dcf: 83 ec 08 sub $0x8,%esp 107dd2: 8b 45 08 mov 0x8(%ebp),%eax const char *p; if ( !name ) 107dd5: 85 c0 test %eax,%eax 107dd7: 75 07 jne 107de0 return NULL; if ( !bsp_boot_cmdline ) return NULL; 107dd9: 31 c0 xor %eax,%eax p = strstr(bsp_boot_cmdline, name); /* printf( "raw: %p (%s)\n", p, p ); */ return p; } 107ddb: c9 leave 107ddc: c3 ret 107ddd: 8d 76 00 lea 0x0(%esi),%esi const char *p; if ( !name ) return NULL; if ( !bsp_boot_cmdline ) 107de0: 8b 15 38 85 12 00 mov 0x128538,%edx 107de6: 85 d2 test %edx,%edx 107de8: 74 ef je 107dd9 return NULL; p = strstr(bsp_boot_cmdline, name); 107dea: 83 ec 08 sub $0x8,%esp 107ded: 50 push %eax 107dee: 52 push %edx 107def: e8 a8 cd 00 00 call 114b9c 107df4: 83 c4 10 add $0x10,%esp /* printf( "raw: %p (%s)\n", p, p ); */ return p; } 107df7: c9 leave 107df8: c3 ret =============================================================================== 0010c140 : rtems_chain_control *chain, rtems_chain_node *node, rtems_id task, rtems_event_set events ) { 10c140: 55 push %ebp 10c141: 89 e5 mov %esp,%ebp 10c143: 56 push %esi 10c144: 53 push %ebx 10c145: 8b 5d 10 mov 0x10(%ebp),%ebx 10c148: 8b 75 14 mov 0x14(%ebp),%esi RTEMS_INLINE_ROUTINE bool rtems_chain_append_with_empty_check( rtems_chain_control *chain, rtems_chain_node *node ) { return _Chain_Append_with_empty_check( chain, node ); 10c14b: 83 ec 08 sub $0x8,%esp 10c14e: ff 75 0c pushl 0xc(%ebp) 10c151: ff 75 08 pushl 0x8(%ebp) 10c154: e8 eb 04 00 00 call 10c644 <_Chain_Append_with_empty_check> rtems_status_code sc = RTEMS_SUCCESSFUL; bool was_empty = rtems_chain_append_with_empty_check( chain, node ); if ( was_empty ) { 10c159: 83 c4 10 add $0x10,%esp 10c15c: 84 c0 test %al,%al 10c15e: 75 0c jne 10c16c <== ALWAYS TAKEN sc = rtems_event_send( task, events ); } return sc; } 10c160: 31 c0 xor %eax,%eax 10c162: 8d 65 f8 lea -0x8(%ebp),%esp 10c165: 5b pop %ebx <== NOT EXECUTED 10c166: 5e pop %esi <== NOT EXECUTED 10c167: c9 leave <== NOT EXECUTED 10c168: c3 ret <== NOT EXECUTED 10c169: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED { rtems_status_code sc = RTEMS_SUCCESSFUL; bool was_empty = rtems_chain_append_with_empty_check( chain, node ); if ( was_empty ) { sc = rtems_event_send( task, events ); 10c16c: 89 75 0c mov %esi,0xc(%ebp) 10c16f: 89 5d 08 mov %ebx,0x8(%ebp) } return sc; } 10c172: 8d 65 f8 lea -0x8(%ebp),%esp 10c175: 5b pop %ebx 10c176: 5e pop %esi 10c177: c9 leave { rtems_status_code sc = RTEMS_SUCCESSFUL; bool was_empty = rtems_chain_append_with_empty_check( chain, node ); if ( was_empty ) { sc = rtems_event_send( task, events ); 10c178: e9 af f5 ff ff jmp 10b72c =============================================================================== 0010c180 : rtems_chain_control *chain, rtems_id task, rtems_event_set events, rtems_chain_node **node ) { 10c180: 55 push %ebp 10c181: 89 e5 mov %esp,%ebp 10c183: 56 push %esi 10c184: 53 push %ebx 10c185: 8b 5d 0c mov 0xc(%ebp),%ebx 10c188: 8b 75 10 mov 0x10(%ebp),%esi RTEMS_INLINE_ROUTINE bool rtems_chain_get_with_empty_check( rtems_chain_control *chain, rtems_chain_node **node ) { return _Chain_Get_with_empty_check( chain, node ); 10c18b: 83 ec 08 sub $0x8,%esp 10c18e: ff 75 14 pushl 0x14(%ebp) 10c191: ff 75 08 pushl 0x8(%ebp) 10c194: e8 13 05 00 00 call 10c6ac <_Chain_Get_with_empty_check> rtems_status_code sc = RTEMS_SUCCESSFUL; bool is_empty = rtems_chain_get_with_empty_check( chain, node ); if ( is_empty ) { 10c199: 83 c4 10 add $0x10,%esp 10c19c: 84 c0 test %al,%al 10c19e: 75 0c jne 10c1ac sc = rtems_event_send( task, events ); } return sc; } 10c1a0: 31 c0 xor %eax,%eax 10c1a2: 8d 65 f8 lea -0x8(%ebp),%esp 10c1a5: 5b pop %ebx 10c1a6: 5e pop %esi 10c1a7: c9 leave 10c1a8: c3 ret 10c1a9: 8d 76 00 lea 0x0(%esi),%esi { rtems_status_code sc = RTEMS_SUCCESSFUL; bool is_empty = rtems_chain_get_with_empty_check( chain, node ); if ( is_empty ) { sc = rtems_event_send( task, events ); 10c1ac: 89 75 0c mov %esi,0xc(%ebp) 10c1af: 89 5d 08 mov %ebx,0x8(%ebp) } return sc; } 10c1b2: 8d 65 f8 lea -0x8(%ebp),%esp 10c1b5: 5b pop %ebx 10c1b6: 5e pop %esi 10c1b7: c9 leave { rtems_status_code sc = RTEMS_SUCCESSFUL; bool is_empty = rtems_chain_get_with_empty_check( chain, node ); if ( is_empty ) { sc = rtems_event_send( task, events ); 10c1b8: e9 6f f5 ff ff jmp 10b72c =============================================================================== 0010c1c0 : rtems_chain_control *chain, rtems_event_set events, rtems_interval timeout, rtems_chain_node **node_ptr ) { 10c1c0: 55 push %ebp 10c1c1: 89 e5 mov %esp,%ebp 10c1c3: 57 push %edi 10c1c4: 56 push %esi 10c1c5: 53 push %ebx 10c1c6: 83 ec 1c sub $0x1c,%esp 10c1c9: 8b 75 08 mov 0x8(%ebp),%esi while ( sc == RTEMS_SUCCESSFUL && (node = rtems_chain_get( chain )) == NULL ) { rtems_event_set out; sc = rtems_event_receive( 10c1cc: 8d 7d e4 lea -0x1c(%ebp),%edi 10c1cf: 90 nop */ RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get( rtems_chain_control *the_chain ) { return _Chain_Get( the_chain ); 10c1d0: 83 ec 0c sub $0xc,%esp 10c1d3: 56 push %esi 10c1d4: e8 0f 05 00 00 call 10c6e8 <_Chain_Get> 10c1d9: 89 c3 mov %eax,%ebx rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_chain_node *node = NULL; while ( sc == RTEMS_SUCCESSFUL && (node = rtems_chain_get( chain )) == NULL 10c1db: 83 c4 10 add $0x10,%esp 10c1de: 85 c0 test %eax,%eax 10c1e0: 75 22 jne 10c204 ) { rtems_event_set out; sc = rtems_event_receive( 10c1e2: 57 push %edi 10c1e3: ff 75 10 pushl 0x10(%ebp) 10c1e6: 6a 00 push $0x0 10c1e8: ff 75 0c pushl 0xc(%ebp) 10c1eb: e8 b4 f3 ff ff call 10b5a4 ) { rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_chain_node *node = NULL; while ( 10c1f0: 83 c4 10 add $0x10,%esp 10c1f3: 85 c0 test %eax,%eax 10c1f5: 74 d9 je 10c1d0 <== NEVER TAKEN timeout, &out ); } *node_ptr = node; 10c1f7: 8b 55 14 mov 0x14(%ebp),%edx 10c1fa: 89 1a mov %ebx,(%edx) return sc; } 10c1fc: 8d 65 f4 lea -0xc(%ebp),%esp 10c1ff: 5b pop %ebx 10c200: 5e pop %esi 10c201: 5f pop %edi 10c202: c9 leave 10c203: c3 ret rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_chain_node *node = NULL; while ( sc == RTEMS_SUCCESSFUL && (node = rtems_chain_get( chain )) == NULL 10c204: 31 c0 xor %eax,%eax timeout, &out ); } *node_ptr = node; 10c206: 8b 55 14 mov 0x14(%ebp),%edx 10c209: 89 1a mov %ebx,(%edx) return sc; } 10c20b: 8d 65 f4 lea -0xc(%ebp),%esp 10c20e: 5b pop %ebx 10c20f: 5e pop %esi 10c210: 5f pop %edi 10c211: c9 leave 10c212: c3 ret =============================================================================== 0010c214 : rtems_chain_control *chain, rtems_chain_node *node, rtems_id task, rtems_event_set events ) { 10c214: 55 push %ebp 10c215: 89 e5 mov %esp,%ebp 10c217: 56 push %esi 10c218: 53 push %ebx 10c219: 8b 5d 10 mov 0x10(%ebp),%ebx 10c21c: 8b 75 14 mov 0x14(%ebp),%esi RTEMS_INLINE_ROUTINE bool rtems_chain_prepend_with_empty_check( rtems_chain_control *chain, rtems_chain_node *node ) { return _Chain_Prepend_with_empty_check( chain, node ); 10c21f: 83 ec 08 sub $0x8,%esp 10c222: ff 75 0c pushl 0xc(%ebp) 10c225: ff 75 08 pushl 0x8(%ebp) 10c228: e8 ff 04 00 00 call 10c72c <_Chain_Prepend_with_empty_check> rtems_status_code sc = RTEMS_SUCCESSFUL; bool was_empty = rtems_chain_prepend_with_empty_check( chain, node ); if (was_empty) { 10c22d: 83 c4 10 add $0x10,%esp 10c230: 84 c0 test %al,%al 10c232: 75 0c jne 10c240 <== ALWAYS TAKEN sc = rtems_event_send( task, events ); } return sc; } 10c234: 31 c0 xor %eax,%eax 10c236: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10c239: 5b pop %ebx <== NOT EXECUTED 10c23a: 5e pop %esi <== NOT EXECUTED 10c23b: c9 leave <== NOT EXECUTED 10c23c: c3 ret <== NOT EXECUTED 10c23d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED { rtems_status_code sc = RTEMS_SUCCESSFUL; bool was_empty = rtems_chain_prepend_with_empty_check( chain, node ); if (was_empty) { sc = rtems_event_send( task, events ); 10c240: 89 75 0c mov %esi,0xc(%ebp) 10c243: 89 5d 08 mov %ebx,0x8(%ebp) } return sc; } 10c246: 8d 65 f8 lea -0x8(%ebp),%esp 10c249: 5b pop %ebx 10c24a: 5e pop %esi 10c24b: c9 leave { rtems_status_code sc = RTEMS_SUCCESSFUL; bool was_empty = rtems_chain_prepend_with_empty_check( chain, node ); if (was_empty) { sc = rtems_event_send( task, events ); 10c24c: e9 db f4 ff ff jmp 10b72c =============================================================================== 00115a60 : rtems_status_code rtems_clock_get( rtems_clock_get_options option, void *time_buffer ) { 115a60: 55 push %ebp 115a61: 89 e5 mov %esp,%ebp 115a63: 53 push %ebx 115a64: 83 ec 04 sub $0x4,%esp 115a67: 8b 45 08 mov 0x8(%ebp),%eax 115a6a: 8b 5d 0c mov 0xc(%ebp),%ebx if ( !time_buffer ) 115a6d: 85 db test %ebx,%ebx 115a6f: 74 3b je 115aac return RTEMS_INVALID_ADDRESS; if ( option == RTEMS_CLOCK_GET_TOD ) 115a71: 85 c0 test %eax,%eax 115a73: 74 2b je 115aa0 return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer ); if ( option == RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH ) 115a75: 83 f8 01 cmp $0x1,%eax 115a78: 74 3e je 115ab8 return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer); if ( option == RTEMS_CLOCK_GET_TICKS_SINCE_BOOT ) { 115a7a: 83 f8 02 cmp $0x2,%eax 115a7d: 74 45 je 115ac4 *interval = rtems_clock_get_ticks_since_boot(); return RTEMS_SUCCESSFUL; } if ( option == RTEMS_CLOCK_GET_TICKS_PER_SECOND ) { 115a7f: 83 f8 03 cmp $0x3,%eax 115a82: 74 4c je 115ad0 *interval = rtems_clock_get_ticks_per_second(); return RTEMS_SUCCESSFUL; } if ( option == RTEMS_CLOCK_GET_TIME_VALUE ) 115a84: 83 f8 04 cmp $0x4,%eax 115a87: 74 0b je 115a94 return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer ); return RTEMS_INVALID_NUMBER; 115a89: b8 0a 00 00 00 mov $0xa,%eax } 115a8e: 5a pop %edx 115a8f: 5b pop %ebx 115a90: c9 leave 115a91: c3 ret 115a92: 66 90 xchg %ax,%ax *interval = rtems_clock_get_ticks_per_second(); return RTEMS_SUCCESSFUL; } if ( option == RTEMS_CLOCK_GET_TIME_VALUE ) return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer ); 115a94: 89 5d 08 mov %ebx,0x8(%ebp) return RTEMS_INVALID_NUMBER; } 115a97: 59 pop %ecx 115a98: 5b pop %ebx 115a99: c9 leave *interval = rtems_clock_get_ticks_per_second(); return RTEMS_SUCCESSFUL; } if ( option == RTEMS_CLOCK_GET_TIME_VALUE ) return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer ); 115a9a: e9 41 01 00 00 jmp 115be0 115a9f: 90 nop { if ( !time_buffer ) return RTEMS_INVALID_ADDRESS; if ( option == RTEMS_CLOCK_GET_TOD ) return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer ); 115aa0: 89 5d 08 mov %ebx,0x8(%ebp) if ( option == RTEMS_CLOCK_GET_TIME_VALUE ) return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer ); return RTEMS_INVALID_NUMBER; } 115aa3: 58 pop %eax 115aa4: 5b pop %ebx 115aa5: c9 leave { if ( !time_buffer ) return RTEMS_INVALID_ADDRESS; if ( option == RTEMS_CLOCK_GET_TOD ) return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer ); 115aa6: e9 81 00 00 00 jmp 115b2c 115aab: 90 nop rtems_clock_get_options option, void *time_buffer ) { if ( !time_buffer ) return RTEMS_INVALID_ADDRESS; 115aac: b8 09 00 00 00 mov $0x9,%eax if ( option == RTEMS_CLOCK_GET_TIME_VALUE ) return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer ); return RTEMS_INVALID_NUMBER; } 115ab1: 5a pop %edx 115ab2: 5b pop %ebx 115ab3: c9 leave 115ab4: c3 ret 115ab5: 8d 76 00 lea 0x0(%esi),%esi if ( option == RTEMS_CLOCK_GET_TOD ) return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer ); if ( option == RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH ) return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer); 115ab8: 89 5d 08 mov %ebx,0x8(%ebp) if ( option == RTEMS_CLOCK_GET_TIME_VALUE ) return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer ); return RTEMS_INVALID_NUMBER; } 115abb: 5b pop %ebx 115abc: 5b pop %ebx 115abd: c9 leave if ( option == RTEMS_CLOCK_GET_TOD ) return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer ); if ( option == RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH ) return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer); 115abe: e9 19 00 00 00 jmp 115adc 115ac3: 90 nop if ( option == RTEMS_CLOCK_GET_TICKS_SINCE_BOOT ) { rtems_interval *interval = (rtems_interval *)time_buffer; *interval = rtems_clock_get_ticks_since_boot(); 115ac4: e8 57 00 00 00 call 115b20 115ac9: 89 03 mov %eax,(%ebx) return RTEMS_SUCCESSFUL; 115acb: 31 c0 xor %eax,%eax 115acd: eb bf jmp 115a8e 115acf: 90 nop } if ( option == RTEMS_CLOCK_GET_TICKS_PER_SECOND ) { rtems_interval *interval = (rtems_interval *)time_buffer; *interval = rtems_clock_get_ticks_per_second(); 115ad0: e8 37 00 00 00 call 115b0c 115ad5: 89 03 mov %eax,(%ebx) return RTEMS_SUCCESSFUL; 115ad7: 31 c0 xor %eax,%eax 115ad9: eb b3 jmp 115a8e =============================================================================== 00115be0 : #include rtems_status_code rtems_clock_get_tod_timeval( struct timeval *time ) { 115be0: 55 push %ebp 115be1: 89 e5 mov %esp,%ebp 115be3: 56 push %esi 115be4: 53 push %ebx 115be5: 83 ec 10 sub $0x10,%esp 115be8: 8b 5d 08 mov 0x8(%ebp),%ebx if ( !time ) 115beb: 85 db test %ebx,%ebx 115bed: 74 51 je 115c40 return RTEMS_INVALID_ADDRESS; if ( !_TOD_Is_set ) 115bef: 80 3d 44 2a 14 00 00 cmpb $0x0,0x142a44 115bf6: 75 0c jne 115c04 return RTEMS_NOT_DEFINED; 115bf8: b8 0b 00 00 00 mov $0xb,%eax _TOD_Get_timeval( time ); return RTEMS_SUCCESSFUL; } 115bfd: 8d 65 f8 lea -0x8(%ebp),%esp 115c00: 5b pop %ebx 115c01: 5e pop %esi 115c02: c9 leave 115c03: c3 ret { ISR_Level level; struct timespec now; suseconds_t useconds; _ISR_Disable(level); 115c04: 9c pushf 115c05: fa cli 115c06: 5e pop %esi _TOD_Get( &now ); 115c07: 83 ec 0c sub $0xc,%esp 115c0a: 8d 45 f0 lea -0x10(%ebp),%eax 115c0d: 50 push %eax 115c0e: e8 1d 44 00 00 call 11a030 <_TOD_Get> _ISR_Enable(level); 115c13: 56 push %esi 115c14: 9d popf useconds = (suseconds_t)now.tv_nsec; 115c15: 8b 4d f4 mov -0xc(%ebp),%ecx useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND; time->tv_sec = now.tv_sec; 115c18: 8b 45 f0 mov -0x10(%ebp),%eax 115c1b: 89 03 mov %eax,(%ebx) _ISR_Disable(level); _TOD_Get( &now ); _ISR_Enable(level); useconds = (suseconds_t)now.tv_nsec; useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND; 115c1d: b8 d3 4d 62 10 mov $0x10624dd3,%eax 115c22: f7 e9 imul %ecx 115c24: 89 d0 mov %edx,%eax 115c26: c1 f8 06 sar $0x6,%eax 115c29: c1 f9 1f sar $0x1f,%ecx 115c2c: 29 c8 sub %ecx,%eax 115c2e: 89 43 04 mov %eax,0x4(%ebx) if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; _TOD_Get_timeval( time ); return RTEMS_SUCCESSFUL; 115c31: 83 c4 10 add $0x10,%esp 115c34: 31 c0 xor %eax,%eax } 115c36: 8d 65 f8 lea -0x8(%ebp),%esp 115c39: 5b pop %ebx 115c3a: 5e pop %esi 115c3b: c9 leave 115c3c: c3 ret 115c3d: 8d 76 00 lea 0x0(%esi),%esi rtems_status_code rtems_clock_get_tod_timeval( struct timeval *time ) { if ( !time ) return RTEMS_INVALID_ADDRESS; 115c40: b8 09 00 00 00 mov $0x9,%eax 115c45: eb b6 jmp 115bfd =============================================================================== 0010b1d4 : * error code - if unsuccessful */ rtems_status_code rtems_clock_get_uptime( struct timespec *uptime ) { 10b1d4: 55 push %ebp 10b1d5: 89 e5 mov %esp,%ebp 10b1d7: 83 ec 08 sub $0x8,%esp 10b1da: 8b 45 08 mov 0x8(%ebp),%eax if ( !uptime ) 10b1dd: 85 c0 test %eax,%eax 10b1df: 74 13 je 10b1f4 return RTEMS_INVALID_ADDRESS; _TOD_Get_uptime_as_timespec( uptime ); 10b1e1: 83 ec 0c sub $0xc,%esp 10b1e4: 50 push %eax 10b1e5: e8 76 16 00 00 call 10c860 <_TOD_Get_uptime_as_timespec> return RTEMS_SUCCESSFUL; 10b1ea: 83 c4 10 add $0x10,%esp 10b1ed: 31 c0 xor %eax,%eax } 10b1ef: c9 leave 10b1f0: c3 ret 10b1f1: 8d 76 00 lea 0x0(%esi),%esi rtems_status_code rtems_clock_get_uptime( struct timespec *uptime ) { if ( !uptime ) return RTEMS_INVALID_ADDRESS; 10b1f4: b8 09 00 00 00 mov $0x9,%eax _TOD_Get_uptime_as_timespec( uptime ); return RTEMS_SUCCESSFUL; } 10b1f9: c9 leave 10b1fa: c3 ret =============================================================================== 0010c124 : */ rtems_status_code rtems_clock_set( rtems_time_of_day *time_buffer ) { 10c124: 55 push %ebp 10c125: 89 e5 mov %esp,%ebp 10c127: 53 push %ebx 10c128: 83 ec 14 sub $0x14,%esp 10c12b: 8b 5d 08 mov 0x8(%ebp),%ebx struct timespec newtime; if ( !time_buffer ) 10c12e: 85 db test %ebx,%ebx 10c130: 74 66 je 10c198 return RTEMS_INVALID_ADDRESS; if ( _TOD_Validate( time_buffer ) ) { 10c132: 83 ec 0c sub $0xc,%esp 10c135: 53 push %ebx 10c136: e8 39 01 00 00 call 10c274 <_TOD_Validate> 10c13b: 83 c4 10 add $0x10,%esp 10c13e: 84 c0 test %al,%al 10c140: 75 0a jne 10c14c _Thread_Disable_dispatch(); _TOD_Set( &newtime ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INVALID_CLOCK; 10c142: b8 14 00 00 00 mov $0x14,%eax } 10c147: 8b 5d fc mov -0x4(%ebp),%ebx 10c14a: c9 leave 10c14b: c3 ret if ( !time_buffer ) return RTEMS_INVALID_ADDRESS; if ( _TOD_Validate( time_buffer ) ) { newtime.tv_sec = _TOD_To_seconds( time_buffer ); 10c14c: 83 ec 0c sub $0xc,%esp 10c14f: 53 push %ebx 10c150: e8 93 00 00 00 call 10c1e8 <_TOD_To_seconds> 10c155: 89 45 f0 mov %eax,-0x10(%ebp) newtime.tv_nsec = time_buffer->ticks * 10c158: 8b 43 18 mov 0x18(%ebx),%eax 10c15b: 0f af 05 6c 62 12 00 imul 0x12626c,%eax 10c162: 8d 04 80 lea (%eax,%eax,4),%eax 10c165: 8d 04 80 lea (%eax,%eax,4),%eax 10c168: 8d 04 80 lea (%eax,%eax,4),%eax 10c16b: c1 e0 03 shl $0x3,%eax 10c16e: 89 45 f4 mov %eax,-0xc(%ebp) rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10c171: a1 10 aa 12 00 mov 0x12aa10,%eax 10c176: 40 inc %eax 10c177: a3 10 aa 12 00 mov %eax,0x12aa10 rtems_configuration_get_nanoseconds_per_tick(); _Thread_Disable_dispatch(); _TOD_Set( &newtime ); 10c17c: 8d 45 f0 lea -0x10(%ebp),%eax 10c17f: 89 04 24 mov %eax,(%esp) 10c182: e8 55 19 00 00 call 10dadc <_TOD_Set> _Thread_Enable_dispatch(); 10c187: e8 a4 2f 00 00 call 10f130 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10c18c: 83 c4 10 add $0x10,%esp 10c18f: 31 c0 xor %eax,%eax } return RTEMS_INVALID_CLOCK; } 10c191: 8b 5d fc mov -0x4(%ebp),%ebx 10c194: c9 leave 10c195: c3 ret 10c196: 66 90 xchg %ax,%ax ) { struct timespec newtime; if ( !time_buffer ) return RTEMS_INVALID_ADDRESS; 10c198: b8 09 00 00 00 mov $0x9,%eax _TOD_Set( &newtime ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INVALID_CLOCK; } 10c19d: 8b 5d fc mov -0x4(%ebp),%ebx 10c1a0: c9 leave 10c1a1: c3 ret =============================================================================== 0010afd0 : * * NOTE: This routine only works for leap-years through 2099. */ rtems_status_code rtems_clock_tick( void ) { 10afd0: 55 push %ebp 10afd1: 89 e5 mov %esp,%ebp 10afd3: 83 ec 08 sub $0x8,%esp _TOD_Tickle_ticks(); 10afd6: e8 39 15 00 00 call 10c514 <_TOD_Tickle_ticks> */ RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_ticks( void ) { _Watchdog_Tickle( &_Watchdog_Ticks_chain ); 10afdb: 83 ec 0c sub $0xc,%esp 10afde: 68 60 7e 12 00 push $0x127e60 10afe3: e8 e4 38 00 00 call 10e8cc <_Watchdog_Tickle> _Watchdog_Tickle_ticks(); _Thread_Tickle_timeslice(); 10afe8: e8 ab 33 00 00 call 10e398 <_Thread_Tickle_timeslice> * otherwise. */ RTEMS_INLINE_ROUTINE bool _Thread_Is_context_switch_necessary( void ) { return ( _Thread_Dispatch_necessary ); 10afed: a0 44 83 12 00 mov 0x128344,%al if ( _Thread_Is_context_switch_necessary() && 10aff2: 83 c4 10 add $0x10,%esp 10aff5: 84 c0 test %al,%al 10aff7: 74 09 je 10b002 * otherwise. */ RTEMS_INLINE_ROUTINE bool _Thread_Is_dispatching_enabled( void ) { return ( _Thread_Dispatch_disable_level == 0 ); 10aff9: a1 90 7d 12 00 mov 0x127d90,%eax 10affe: 85 c0 test %eax,%eax 10b000: 74 06 je 10b008 _Thread_Is_dispatching_enabled() ) _Thread_Dispatch(); return RTEMS_SUCCESSFUL; } 10b002: 31 c0 xor %eax,%eax 10b004: c9 leave 10b005: c3 ret 10b006: 66 90 xchg %ax,%ax _Thread_Tickle_timeslice(); if ( _Thread_Is_context_switch_necessary() && _Thread_Is_dispatching_enabled() ) _Thread_Dispatch(); 10b008: e8 2b 28 00 00 call 10d838 <_Thread_Dispatch> return RTEMS_SUCCESSFUL; } 10b00d: 31 c0 xor %eax,%eax 10b00f: c9 leave 10b010: c3 ret =============================================================================== 00108400 : void rtems_cpu_usage_report_with_plugin( void *context, rtems_printk_plugin_t print ) { 108400: 55 push %ebp 108401: 89 e5 mov %esp,%ebp 108403: 57 push %edi 108404: 56 push %esi 108405: 53 push %ebx 108406: 83 ec 6c sub $0x6c,%esp 108409: 8b 7d 08 mov 0x8(%ebp),%edi Timestamp_Control uptime, total, ran, last_context_switch; #else uint32_t total_units = 0; #endif if ( !print ) 10840c: 8b 45 0c mov 0xc(%ebp),%eax 10840f: 85 c0 test %eax,%eax 108411: 0f 84 6f 01 00 00 je 108586 <== NEVER TAKEN * When not using nanosecond CPU usage resolution, we have to count * the number of "ticks" we gave credit for to give the user a rough * guideline as to what each number means proportionally. */ #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ last_context_switch = _Thread_Time_of_last_context_switch; 108417: a1 cc aa 12 00 mov 0x12aacc,%eax 10841c: 8b 15 d0 aa 12 00 mov 0x12aad0,%edx 108422: 89 45 c0 mov %eax,-0x40(%ebp) 108425: 89 55 c4 mov %edx,-0x3c(%ebp) _TOD_Get_uptime( &uptime ); 108428: 83 ec 0c sub $0xc,%esp 10842b: 8d 45 d8 lea -0x28(%ebp),%eax 10842e: 50 push %eax 10842f: e8 20 56 00 00 call 10da54 <_TOD_Get_uptime> _Timestamp_Subtract( &CPU_usage_Uptime_at_last_reset, &uptime, &total ); 108434: 83 c4 0c add $0xc,%esp 108437: 8d 55 d0 lea -0x30(%ebp),%edx 10843a: 52 push %edx 10843b: 8d 4d d8 lea -0x28(%ebp),%ecx 10843e: 51 push %ecx 10843f: 68 60 b0 12 00 push $0x12b060 108444: e8 b3 78 00 00 call 10fcfc <_Timespec_Subtract> } } } #endif (*print)( 108449: 5b pop %ebx 10844a: 5e pop %esi 10844b: 68 30 3a 12 00 push $0x123a30 108450: 57 push %edi 108451: ff 55 0c call *0xc(%ebp) 108454: 83 c4 10 add $0x10,%esp " ID | NAME | TICKS | PERCENT\n" #endif "------------+----------------------------------------+---------------+---------\n" ); for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { 108457: c7 45 a4 01 00 00 00 movl $0x1,-0x5c(%ebp) #if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG) if ( !_Objects_Information_table[ api_index ] ) continue; #endif information = _Objects_Information_table[ api_index ][ 1 ]; 10845e: 8b 5d a4 mov -0x5c(%ebp),%ebx 108461: 8b 04 9d e8 a9 12 00 mov 0x12a9e8(,%ebx,4),%eax 108468: 8b 70 04 mov 0x4(%eax),%esi if ( information ) { 10846b: 85 f6 test %esi,%esi 10846d: 0f 84 e9 00 00 00 je 10855c <== NEVER TAKEN for ( i=1 ; i <= information->maximum ; i++ ) { 108473: 66 83 7e 10 00 cmpw $0x0,0x10(%esi) 108478: 0f 84 de 00 00 00 je 10855c 10847e: bb 01 00 00 00 mov $0x1,%ebx 108483: 89 5d 94 mov %ebx,-0x6c(%ebp) 108486: eb 4a jmp 1084d2 108488: 8d 55 c8 lea -0x38(%ebp),%edx if ( _Thread_Executing->Object.id == the_thread->Object.id ) { Timestamp_Control used; _Timestamp_Subtract( &last_context_switch, &uptime, &used ); _Timestamp_Add_to( &ran, &used ); }; _Timestamp_Divide( &ran, &total, &ival, &fval ); 10848b: 8d 45 e0 lea -0x20(%ebp),%eax 10848e: 50 push %eax 10848f: 8d 4d e4 lea -0x1c(%ebp),%ecx 108492: 51 push %ecx 108493: 8d 5d d0 lea -0x30(%ebp),%ebx 108496: 53 push %ebx 108497: 52 push %edx 108498: e8 9b 77 00 00 call 10fc38 <_Timespec_Divide> /* * Print the information */ (*print)( context, 10849d: 58 pop %eax 10849e: 5a pop %edx 10849f: ff 75 e0 pushl -0x20(%ebp) 1084a2: ff 75 e4 pushl -0x1c(%ebp) 1084a5: ba d3 4d 62 10 mov $0x10624dd3,%edx 1084aa: 8b 45 cc mov -0x34(%ebp),%eax 1084ad: f7 e2 mul %edx 1084af: c1 ea 06 shr $0x6,%edx 1084b2: 52 push %edx 1084b3: ff 75 c8 pushl -0x38(%ebp) 1084b6: 68 a3 3c 12 00 push $0x123ca3 1084bb: 57 push %edi 1084bc: ff 55 0c call *0xc(%ebp) 1084bf: 83 c4 20 add $0x20,%esp continue; #endif information = _Objects_Information_table[ api_index ][ 1 ]; if ( information ) { for ( i=1 ; i <= information->maximum ; i++ ) { 1084c2: ff 45 94 incl -0x6c(%ebp) 1084c5: 0f b7 46 10 movzwl 0x10(%esi),%eax 1084c9: 3b 45 94 cmp -0x6c(%ebp),%eax 1084cc: 0f 82 8a 00 00 00 jb 10855c the_thread = (Thread_Control *)information->local_table[ i ]; 1084d2: 8b 46 1c mov 0x1c(%esi),%eax 1084d5: 8b 4d 94 mov -0x6c(%ebp),%ecx 1084d8: 8b 14 88 mov (%eax,%ecx,4),%edx if ( !the_thread ) 1084db: 85 d2 test %edx,%edx 1084dd: 74 e3 je 1084c2 <== NEVER TAKEN continue; rtems_object_get_name( the_thread->Object.id, sizeof(name), name ); 1084df: 51 push %ecx 1084e0: 8d 5d ab lea -0x55(%ebp),%ebx 1084e3: 53 push %ebx 1084e4: 6a 0d push $0xd 1084e6: ff 72 08 pushl 0x8(%edx) 1084e9: 89 55 a0 mov %edx,-0x60(%ebp) 1084ec: e8 17 42 00 00 call 10c708 (*print)( 1084f1: 53 push %ebx 1084f2: 8b 55 a0 mov -0x60(%ebp),%edx 1084f5: ff 72 08 pushl 0x8(%edx) 1084f8: 68 90 3c 12 00 push $0x123c90 1084fd: 57 push %edi 1084fe: ff 55 0c call *0xc(%ebp) #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ /* * If this is the currently executing thread, account for time * since the last context switch. */ ran = the_thread->cpu_time_used; 108501: 8b 55 a0 mov -0x60(%ebp),%edx 108504: 8b 8a 84 00 00 00 mov 0x84(%edx),%ecx 10850a: 8b 9a 88 00 00 00 mov 0x88(%edx),%ebx 108510: 89 4d c8 mov %ecx,-0x38(%ebp) 108513: 89 5d cc mov %ebx,-0x34(%ebp) if ( _Thread_Executing->Object.id == the_thread->Object.id ) { 108516: 83 c4 20 add $0x20,%esp 108519: a1 f8 af 12 00 mov 0x12aff8,%eax 10851e: 8b 5a 08 mov 0x8(%edx),%ebx 108521: 39 58 08 cmp %ebx,0x8(%eax) 108524: 0f 85 5e ff ff ff jne 108488 Timestamp_Control used; _Timestamp_Subtract( &last_context_switch, &uptime, &used ); 10852a: 50 push %eax 10852b: 8d 45 b8 lea -0x48(%ebp),%eax 10852e: 50 push %eax 10852f: 8d 55 d8 lea -0x28(%ebp),%edx 108532: 52 push %edx 108533: 8d 4d c0 lea -0x40(%ebp),%ecx 108536: 51 push %ecx 108537: e8 c0 77 00 00 call 10fcfc <_Timespec_Subtract> _Timestamp_Add_to( &ran, &used ); 10853c: 59 pop %ecx 10853d: 5b pop %ebx 10853e: 8d 5d b8 lea -0x48(%ebp),%ebx 108541: 53 push %ebx 108542: 8d 55 c8 lea -0x38(%ebp),%edx 108545: 52 push %edx 108546: 89 55 a0 mov %edx,-0x60(%ebp) 108549: e8 ae 76 00 00 call 10fbfc <_Timespec_Add_to> 10854e: 83 c4 10 add $0x10,%esp 108551: 8b 55 a0 mov -0x60(%ebp),%edx 108554: e9 32 ff ff ff jmp 10848b 108559: 8d 76 00 lea 0x0(%esi),%esi " ID | NAME | TICKS | PERCENT\n" #endif "------------+----------------------------------------+---------------+---------\n" ); for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { 10855c: ff 45 a4 incl -0x5c(%ebp) 10855f: 83 7d a4 04 cmpl $0x4,-0x5c(%ebp) 108563: 0f 85 f5 fe ff ff jne 10845e } } } #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ (*print)( 108569: ba d3 4d 62 10 mov $0x10624dd3,%edx 10856e: 8b 45 d4 mov -0x2c(%ebp),%eax 108571: f7 e2 mul %edx 108573: c1 ea 06 shr $0x6,%edx 108576: 52 push %edx 108577: ff 75 d0 pushl -0x30(%ebp) 10857a: 68 a4 3b 12 00 push $0x123ba4 10857f: 57 push %edi 108580: ff 55 0c call *0xc(%ebp) 108583: 83 c4 10 add $0x10,%esp "-------------------------------------------------------------------------------\n", _Watchdog_Ticks_since_boot - CPU_usage_Ticks_at_last_reset, total_units ); #endif } 108586: 8d 65 f4 lea -0xc(%ebp),%esp 108589: 5b pop %ebx 10858a: 5e pop %esi 10858b: 5f pop %edi 10858c: c9 leave 10858d: c3 ret =============================================================================== 001131e4 : [RTEMS_IO_ERROR] = EIO, [RTEMS_PROXY_BLOCKING] = EIO }; int rtems_deviceio_errno(rtems_status_code sc) { 1131e4: 55 push %ebp 1131e5: 89 e5 mov %esp,%ebp 1131e7: 53 push %ebx 1131e8: 83 ec 04 sub $0x4,%esp 1131eb: 8b 45 08 mov 0x8(%ebp),%eax if (sc == RTEMS_SUCCESSFUL) { 1131ee: 85 c0 test %eax,%eax 1131f0: 75 06 jne 1131f8 return 0; 1131f2: 31 c0 xor %eax,%eax errno = eno; return -1; } } 1131f4: 5a pop %edx 1131f5: 5b pop %ebx 1131f6: c9 leave 1131f7: c3 ret if (sc == RTEMS_SUCCESSFUL) { return 0; } else { int eno = EINVAL; if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) { 1131f8: 83 f8 1c cmp $0x1c,%eax 1131fb: 77 17 ja 113214 <== NEVER TAKEN eno = status_code_to_errno [sc]; 1131fd: 8b 1c 85 c0 1b 12 00 mov 0x121bc0(,%eax,4),%ebx } errno = eno; 113204: e8 67 00 00 00 call 113270 <__errno> 113209: 89 18 mov %ebx,(%eax) return -1; 11320b: b8 ff ff ff ff mov $0xffffffff,%eax 113210: eb e2 jmp 1131f4 113212: 66 90 xchg %ax,%ax int rtems_deviceio_errno(rtems_status_code sc) { if (sc == RTEMS_SUCCESSFUL) { return 0; } else { int eno = EINVAL; 113214: bb 16 00 00 00 mov $0x16,%ebx <== NOT EXECUTED 113219: eb e9 jmp 113204 <== NOT EXECUTED =============================================================================== 0010b19c : rtems_status_code rtems_event_send( rtems_id id, rtems_event_set event_in ) { 10b19c: 55 push %ebp 10b19d: 89 e5 mov %esp,%ebp 10b19f: 53 push %ebx 10b1a0: 83 ec 1c sub $0x1c,%esp register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; the_thread = _Thread_Get( id, &location ); 10b1a3: 8d 45 f4 lea -0xc(%ebp),%eax 10b1a6: 50 push %eax 10b1a7: ff 75 08 pushl 0x8(%ebp) 10b1aa: e8 25 28 00 00 call 10d9d4 <_Thread_Get> switch ( location ) { 10b1af: 83 c4 10 add $0x10,%esp 10b1b2: 8b 55 f4 mov -0xc(%ebp),%edx 10b1b5: 85 d2 test %edx,%edx 10b1b7: 75 2b jne 10b1e4 case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; 10b1b9: 8b 90 e8 00 00 00 mov 0xe8(%eax),%edx rtems_event_set *the_event_set ) { ISR_Level level; _ISR_Disable( level ); 10b1bf: 9c pushf 10b1c0: fa cli 10b1c1: 59 pop %ecx *the_event_set |= the_new_events; 10b1c2: 8b 5d 0c mov 0xc(%ebp),%ebx 10b1c5: 09 1a or %ebx,(%edx) _ISR_Enable( level ); 10b1c7: 51 push %ecx 10b1c8: 9d popf _Event_sets_Post( event_in, &api->pending_events ); _Event_Surrender( the_thread ); 10b1c9: 83 ec 0c sub $0xc,%esp 10b1cc: 50 push %eax 10b1cd: e8 1e 00 00 00 call 10b1f0 <_Event_Surrender> _Thread_Enable_dispatch(); 10b1d2: e8 d9 27 00 00 call 10d9b0 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10b1d7: 83 c4 10 add $0x10,%esp 10b1da: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b1dc: 8b 5d fc mov -0x4(%ebp),%ebx 10b1df: c9 leave 10b1e0: c3 ret 10b1e1: 8d 76 00 lea 0x0(%esi),%esi case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10b1e4: b8 04 00 00 00 mov $0x4,%eax } 10b1e9: 8b 5d fc mov -0x4(%ebp),%ebx 10b1ec: c9 leave 10b1ed: c3 ret =============================================================================== 0010d000 : #include rtems_status_code rtems_extension_delete( rtems_id id ) { 10d000: 55 push %ebp 10d001: 89 e5 mov %esp,%ebp 10d003: 53 push %ebx 10d004: 83 ec 18 sub $0x18,%esp Extension_Control *the_extension; Objects_Locations location; the_extension = _Extension_Get( id, &location ); 10d007: 8d 45 f4 lea -0xc(%ebp),%eax Objects_Id id, Objects_Locations *location ) { return (Extension_Control *) _Objects_Get( &_Extension_Information, id, location ); 10d00a: 50 push %eax 10d00b: ff 75 08 pushl 0x8(%ebp) 10d00e: 68 20 b6 12 00 push $0x12b620 10d013: e8 28 12 00 00 call 10e240 <_Objects_Get> 10d018: 89 c3 mov %eax,%ebx switch ( location ) { 10d01a: 83 c4 10 add $0x10,%esp 10d01d: 8b 55 f4 mov -0xc(%ebp),%edx 10d020: 85 d2 test %edx,%edx 10d022: 75 38 jne 10d05c case OBJECTS_LOCAL: _User_extensions_Remove_set( &the_extension->Extension ); 10d024: 83 ec 0c sub $0xc,%esp 10d027: 8d 40 10 lea 0x10(%eax),%eax 10d02a: 50 push %eax 10d02b: e8 d0 29 00 00 call 10fa00 <_User_extensions_Remove_set> _Objects_Close( &_Extension_Information, &the_extension->Object ); 10d030: 59 pop %ecx 10d031: 58 pop %eax 10d032: 53 push %ebx 10d033: 68 20 b6 12 00 push $0x12b620 10d038: e8 cb 0d 00 00 call 10de08 <_Objects_Close> RTEMS_INLINE_ROUTINE void _Extension_Free ( Extension_Control *the_extension ) { _Objects_Free( &_Extension_Information, &the_extension->Object ); 10d03d: 58 pop %eax 10d03e: 5a pop %edx 10d03f: 53 push %ebx 10d040: 68 20 b6 12 00 push $0x12b620 10d045: e8 b6 10 00 00 call 10e100 <_Objects_Free> _Extension_Free( the_extension ); _Thread_Enable_dispatch(); 10d04a: e8 69 1d 00 00 call 10edb8 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10d04f: 83 c4 10 add $0x10,%esp 10d052: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10d054: 8b 5d fc mov -0x4(%ebp),%ebx 10d057: c9 leave 10d058: c3 ret 10d059: 8d 76 00 lea 0x0(%esi),%esi #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10d05c: b8 04 00 00 00 mov $0x4,%eax } 10d061: 8b 5d fc mov -0x4(%ebp),%ebx 10d064: c9 leave 10d065: c3 ret =============================================================================== 0010800c : int rtems_filesystem_dirname( const char *pathname ) { 10800c: 55 push %ebp 10800d: 89 e5 mov %esp,%ebp 10800f: 57 push %edi 108010: 56 push %esi 108011: 53 push %ebx 108012: 83 ec 0c sub $0xc,%esp 108015: 8b 5d 08 mov 0x8(%ebp),%ebx int len = strlen( pathname ); 108018: 31 c0 xor %eax,%eax 10801a: b9 ff ff ff ff mov $0xffffffff,%ecx 10801f: 89 df mov %ebx,%edi 108021: f2 ae repnz scas %es:(%edi),%al 108023: f7 d1 not %ecx while ( len ) { 108025: 89 ce mov %ecx,%esi 108027: 4e dec %esi 108028: 75 06 jne 108030 <== ALWAYS TAKEN 10802a: eb 19 jmp 108045 <== NOT EXECUTED 10802c: 85 f6 test %esi,%esi 10802e: 74 15 je 108045 len--; 108030: 4e dec %esi if ( rtems_filesystem_is_separator( pathname[len] ) ) 108031: 83 ec 0c sub $0xc,%esp 108034: 0f be 04 33 movsbl (%ebx,%esi,1),%eax 108038: 50 push %eax 108039: e8 da 0e 00 00 call 108f18 10803e: 83 c4 10 add $0x10,%esp 108041: 85 c0 test %eax,%eax 108043: 74 e7 je 10802c break; } return len; } 108045: 89 f0 mov %esi,%eax 108047: 8d 65 f4 lea -0xc(%ebp),%esp 10804a: 5b pop %ebx 10804b: 5e pop %esi 10804c: 5f pop %edi 10804d: c9 leave 10804e: c3 ret =============================================================================== 001100ac : rtems_filesystem_fsmount_me_t rtems_filesystem_get_mount_handler( const char *type ) { 1100ac: 55 push %ebp 1100ad: 89 e5 mov %esp,%ebp 1100af: 83 ec 18 sub $0x18,%esp 1100b2: 8b 45 08 mov 0x8(%ebp),%eax find_arg fa = { 1100b5: 89 45 f0 mov %eax,-0x10(%ebp) 1100b8: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) .type = type, .mount_h = NULL }; if ( type != NULL ) { 1100bf: 85 c0 test %eax,%eax 1100c1: 74 19 je 1100dc <== NEVER TAKEN rtems_filesystem_iterate( find_handler, &fa ); 1100c3: 83 ec 08 sub $0x8,%esp 1100c6: 8d 45 f0 lea -0x10(%ebp),%eax 1100c9: 50 push %eax 1100ca: 68 cc ff 10 00 push $0x10ffcc 1100cf: e8 34 ff ff ff call 110008 1100d4: 8b 45 f4 mov -0xc(%ebp),%eax 1100d7: 83 c4 10 add $0x10,%esp } return fa.mount_h; } 1100da: c9 leave 1100db: c3 ret find_arg fa = { .type = type, .mount_h = NULL }; if ( type != NULL ) { 1100dc: 31 c0 xor %eax,%eax rtems_filesystem_iterate( find_handler, &fa ); } return fa.mount_h; } 1100de: c9 leave <== NOT EXECUTED 1100df: c3 ret <== NOT EXECUTED =============================================================================== 00110268 : #include "rtems/libio_.h" void rtems_filesystem_get_sym_start_loc(const char *path, int *index, rtems_filesystem_location_info_t *loc) { 110268: 55 push %ebp 110269: 89 e5 mov %esp,%ebp 11026b: 57 push %edi 11026c: 56 push %esi 11026d: 53 push %ebx 11026e: 83 ec 18 sub $0x18,%esp 110271: 8b 5d 0c mov 0xc(%ebp),%ebx if (rtems_filesystem_is_separator(path[0])) { 110274: 8b 45 08 mov 0x8(%ebp),%eax 110277: 0f be 00 movsbl (%eax),%eax 11027a: 50 push %eax 11027b: e8 98 8c ff ff call 108f18 110280: 83 c4 10 add $0x10,%esp 110283: 85 c0 test %eax,%eax 110285: 75 11 jne 110298 *loc = rtems_filesystem_root; *index = 1; } else { *index = 0; 110287: c7 03 00 00 00 00 movl $0x0,(%ebx) } } 11028d: 8d 65 f4 lea -0xc(%ebp),%esp 110290: 5b pop %ebx 110291: 5e pop %esi 110292: 5f pop %edi 110293: c9 leave 110294: c3 ret 110295: 8d 76 00 lea 0x0(%esi),%esi void rtems_filesystem_get_sym_start_loc(const char *path, int *index, rtems_filesystem_location_info_t *loc) { if (rtems_filesystem_is_separator(path[0])) { *loc = rtems_filesystem_root; 110298: 8b 35 90 59 12 00 mov 0x125990,%esi 11029e: 83 c6 18 add $0x18,%esi 1102a1: b9 05 00 00 00 mov $0x5,%ecx 1102a6: 8b 7d 10 mov 0x10(%ebp),%edi 1102a9: f3 a5 rep movsl %ds:(%esi),%es:(%edi) *index = 1; 1102ab: c7 03 01 00 00 00 movl $0x1,(%ebx) } else { *index = 0; } } 1102b1: 8d 65 f4 lea -0xc(%ebp),%esp 1102b4: 5b pop %ebx 1102b5: 5e pop %esi 1102b6: 5f pop %edi 1102b7: c9 leave 1102b8: c3 ret =============================================================================== 00107e3c : * configuration is a single instantiation of the IMFS or miniIMFS with * a single "/dev" directory in it. */ void rtems_filesystem_initialize( void ) { 107e3c: 55 push %ebp 107e3d: 89 e5 mov %esp,%ebp 107e3f: 57 push %edi 107e40: 56 push %esi 107e41: 53 push %ebx 107e42: 83 ec 2c sub $0x2c,%esp /* * Set the default umask to "022". */ rtems_filesystem_umask = 022; 107e45: a1 90 59 12 00 mov 0x125990,%eax 107e4a: c7 40 2c 12 00 00 00 movl $0x12,0x2c(%eax) /* * mount the first filesystem. */ if ( rtems_filesystem_mount_table_size == 0 ) 107e51: a1 20 f9 11 00 mov 0x11f920,%eax 107e56: 85 c0 test %eax,%eax 107e58: 0f 84 9f 00 00 00 je 107efd <== NEVER TAKEN rtems_fatal_error_occurred( 0xABCD0001 ); mt = &rtems_filesystem_mount_table[0]; 107e5e: a1 74 39 12 00 mov 0x123974,%eax status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL ); 107e63: 83 ec 0c sub $0xc,%esp 107e66: 6a 00 push $0x0 107e68: ff 70 04 pushl 0x4(%eax) 107e6b: ff 30 pushl (%eax) 107e6d: ff 70 0c pushl 0xc(%eax) 107e70: ff 70 08 pushl 0x8(%eax) 107e73: e8 fc 06 00 00 call 108574 if ( status == -1 ) 107e78: 83 c4 20 add $0x20,%esp 107e7b: 40 inc %eax 107e7c: 0f 84 95 00 00 00 je 107f17 <== NEVER TAKEN rtems_fatal_error_occurred( 0xABCD0002 ); rtems_filesystem_link_counts = 0; 107e82: a1 90 59 12 00 mov 0x125990,%eax 107e87: 66 c7 40 30 00 00 movw $0x0,0x30(%eax) * gonna hit performance. * * Till Straumann, 10/25/2002 */ /* Clone the root pathloc */ rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0); 107e8d: 83 ec 0c sub $0xc,%esp 107e90: 6a 00 push $0x0 107e92: 8d 5d d4 lea -0x2c(%ebp),%ebx 107e95: 53 push %ebx 107e96: 6a 00 push $0x0 107e98: 6a 01 push $0x1 107e9a: 68 07 13 12 00 push $0x121307 107e9f: e8 24 01 00 00 call 107fc8 rtems_filesystem_root = loc; 107ea4: 8b 3d 90 59 12 00 mov 0x125990,%edi 107eaa: 83 c7 18 add $0x18,%edi 107ead: b9 05 00 00 00 mov $0x5,%ecx 107eb2: 89 de mov %ebx,%esi 107eb4: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* One more clone for the current node */ rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0); 107eb6: 83 c4 14 add $0x14,%esp 107eb9: 6a 00 push $0x0 107ebb: 53 push %ebx 107ebc: 6a 00 push $0x0 107ebe: 6a 01 push $0x1 107ec0: 68 07 13 12 00 push $0x121307 107ec5: e8 fe 00 00 00 call 107fc8 rtems_filesystem_current = loc; 107eca: 8b 3d 90 59 12 00 mov 0x125990,%edi 107ed0: 83 c7 04 add $0x4,%edi 107ed3: b9 05 00 00 00 mov $0x5,%ecx 107ed8: 89 de mov %ebx,%esi 107eda: f3 a5 rep movsl %ds:(%esi),%es:(%edi) * * NOTE: UNIX root is 755 and owned by root/root (0/0). It is actually * created that way by the IMFS. */ status = mkdir( "/dev", 0777); 107edc: 83 c4 18 add $0x18,%esp 107edf: 68 ff 01 00 00 push $0x1ff 107ee4: 68 09 13 12 00 push $0x121309 107ee9: e8 42 05 00 00 call 108430 if ( status != 0 ) 107eee: 83 c4 10 add $0x10,%esp 107ef1: 85 c0 test %eax,%eax 107ef3: 75 15 jne 107f0a <== 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. */ } 107ef5: 8d 65 f4 lea -0xc(%ebp),%esp 107ef8: 5b pop %ebx 107ef9: 5e pop %esi 107efa: 5f pop %edi 107efb: c9 leave 107efc: c3 ret /* * mount the first filesystem. */ if ( rtems_filesystem_mount_table_size == 0 ) rtems_fatal_error_occurred( 0xABCD0001 ); 107efd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107f00: 68 01 00 cd ab push $0xabcd0001 <== NOT EXECUTED 107f05: e8 ea 3d 00 00 call 10bcf4 <== NOT EXECUTED * created that way by the IMFS. */ status = mkdir( "/dev", 0777); if ( status != 0 ) rtems_fatal_error_occurred( 0xABCD0003 ); 107f0a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107f0d: 68 03 00 cd ab push $0xabcd0003 <== NOT EXECUTED 107f12: e8 dd 3d 00 00 call 10bcf4 <== NOT EXECUTED mt = &rtems_filesystem_mount_table[0]; status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL ); if ( status == -1 ) rtems_fatal_error_occurred( 0xABCD0002 ); 107f17: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107f1a: 68 02 00 cd ab push $0xabcd0002 <== NOT EXECUTED 107f1f: e8 d0 3d 00 00 call 10bcf4 <== NOT EXECUTED =============================================================================== 00110008 : bool rtems_filesystem_iterate( rtems_per_filesystem_routine routine, void *routine_arg ) { 110008: 55 push %ebp 110009: 89 e5 mov %esp,%ebp 11000b: 57 push %edi 11000c: 56 push %esi 11000d: 53 push %ebx 11000e: 83 ec 1c sub $0x1c,%esp 110011: 8b 75 08 mov 0x8(%ebp),%esi 110014: 8b 7d 0c mov 0xc(%ebp),%edi const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0]; rtems_chain_node *node = NULL; bool stop = false; while ( table_entry->type && !stop ) { 110017: 8b 1d 00 f9 11 00 mov 0x11f900,%ebx 11001d: 85 db test %ebx,%ebx 11001f: 74 24 je 110045 <== NEVER TAKEN 110021: bb 00 f9 11 00 mov $0x11f900,%ebx 110026: eb 04 jmp 11002c 110028: 84 c0 test %al,%al 11002a: 75 70 jne 11009c stop = (*routine)( table_entry, routine_arg ); 11002c: 83 ec 08 sub $0x8,%esp 11002f: 57 push %edi 110030: 53 push %ebx 110031: ff d6 call *%esi 110033: 88 c2 mov %al,%dl ++table_entry; 110035: 83 c3 08 add $0x8,%ebx { const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0]; rtems_chain_node *node = NULL; bool stop = false; while ( table_entry->type && !stop ) { 110038: 83 c4 10 add $0x10,%esp 11003b: 8b 0b mov (%ebx),%ecx 11003d: 85 c9 test %ecx,%ecx 11003f: 75 e7 jne 110028 stop = (*routine)( table_entry, routine_arg ); ++table_entry; } if ( !stop ) { 110041: 84 c0 test %al,%al 110043: 75 57 jne 11009c rtems_status_code rtems_libio_set_private_env(void); rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ; static inline void rtems_libio_lock( void ) { rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); 110045: 50 push %eax 110046: 6a 00 push $0x0 110048: 6a 00 push $0x0 11004a: ff 35 28 7c 12 00 pushl 0x127c28 110050: e8 5b b6 ff ff call 10b6b0 } } rtems_libio_unlock(); rtems_set_errno_and_return_minus_one( ENOENT ); } 110055: 8b 1d b8 59 12 00 mov 0x1259b8,%ebx ++table_entry; } if ( !stop ) { rtems_libio_lock(); for ( 11005b: 83 c4 10 add $0x10,%esp 11005e: 81 fb bc 59 12 00 cmp $0x1259bc,%ebx 110064: 75 06 jne 11006c 110066: eb 3e jmp 1100a6 node = rtems_chain_first( &filesystem_chain ); !rtems_chain_is_tail( &filesystem_chain, node ) && !stop; 110068: 84 c0 test %al,%al 11006a: 75 19 jne 110085 <== NEVER TAKEN node = rtems_chain_next( node ) ) { const filesystem_node *fsn = (filesystem_node *) node; stop = (*routine)( &fsn->entry, routine_arg ); 11006c: 83 ec 08 sub $0x8,%esp 11006f: 57 push %edi 110070: 8d 43 08 lea 0x8(%ebx),%eax 110073: 50 push %eax 110074: ff d6 call *%esi 110076: 88 c2 mov %al,%dl } } rtems_libio_unlock(); rtems_set_errno_and_return_minus_one( ENOENT ); } 110078: 8b 1b mov (%ebx),%ebx ++table_entry; } if ( !stop ) { rtems_libio_lock(); for ( 11007a: 83 c4 10 add $0x10,%esp 11007d: 81 fb bc 59 12 00 cmp $0x1259bc,%ebx 110083: 75 e3 jne 110068 } static inline void rtems_libio_unlock( void ) { rtems_semaphore_release( rtems_libio_semaphore ); 110085: 83 ec 0c sub $0xc,%esp 110088: ff 35 28 7c 12 00 pushl 0x127c28 11008e: 88 55 e4 mov %dl,-0x1c(%ebp) 110091: e8 16 b7 ff ff call 10b7ac 110096: 83 c4 10 add $0x10,%esp 110099: 8a 55 e4 mov -0x1c(%ebp),%dl } rtems_libio_unlock(); } return stop; } 11009c: 88 d0 mov %dl,%al 11009e: 8d 65 f4 lea -0xc(%ebp),%esp 1100a1: 5b pop %ebx 1100a2: 5e pop %esi 1100a3: 5f pop %edi 1100a4: c9 leave 1100a5: c3 ret ++table_entry; } if ( !stop ) { rtems_libio_lock(); for ( 1100a6: 31 d2 xor %edx,%edx 1100a8: eb db jmp 110085 =============================================================================== 00108504 : bool rtems_filesystem_mount_iterate( rtems_per_filesystem_mount_routine routine, void *routine_arg ) { 108504: 55 push %ebp 108505: 89 e5 mov %esp,%ebp 108507: 57 push %edi 108508: 56 push %esi 108509: 53 push %ebx 10850a: 83 ec 20 sub $0x20,%esp 10850d: 8b 75 08 mov 0x8(%ebp),%esi 108510: 8b 7d 0c mov 0xc(%ebp),%edi rtems_status_code rtems_libio_set_private_env(void); rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ; static inline void rtems_libio_lock( void ) { rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); 108513: 6a 00 push $0x0 108515: 6a 00 push $0x0 108517: ff 35 28 7c 12 00 pushl 0x127c28 10851d: e8 8e 31 00 00 call 10b6b0 stop = (*routine)( mt_entry, routine_arg ); } rtems_libio_unlock(); return stop; } 108522: 8b 1d 64 58 12 00 mov 0x125864,%ebx { rtems_chain_node *node = NULL; bool stop = false; rtems_libio_lock(); for ( 108528: 83 c4 10 add $0x10,%esp 10852b: 81 fb 68 58 12 00 cmp $0x125868,%ebx 108531: 75 09 jne 10853c <== ALWAYS TAKEN 108533: eb 3b jmp 108570 <== NOT EXECUTED 108535: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED node = rtems_chain_first( &mount_chain ); !rtems_chain_is_tail( &mount_chain, node ) && !stop; 108538: 84 c0 test %al,%al 10853a: 75 16 jne 108552 <== NEVER TAKEN node = rtems_chain_next( node ) ) { const rtems_filesystem_mount_table_entry_t *mt_entry = (rtems_filesystem_mount_table_entry_t *) node; stop = (*routine)( mt_entry, routine_arg ); 10853c: 83 ec 08 sub $0x8,%esp 10853f: 57 push %edi 108540: 53 push %ebx 108541: ff d6 call *%esi 108543: 88 c2 mov %al,%dl } rtems_libio_unlock(); return stop; } 108545: 8b 1b mov (%ebx),%ebx { rtems_chain_node *node = NULL; bool stop = false; rtems_libio_lock(); for ( 108547: 83 c4 10 add $0x10,%esp 10854a: 81 fb 68 58 12 00 cmp $0x125868,%ebx 108550: 75 e6 jne 108538 } static inline void rtems_libio_unlock( void ) { rtems_semaphore_release( rtems_libio_semaphore ); 108552: 83 ec 0c sub $0xc,%esp 108555: ff 35 28 7c 12 00 pushl 0x127c28 10855b: 88 55 e4 mov %dl,-0x1c(%ebp) 10855e: e8 49 32 00 00 call 10b7ac stop = (*routine)( mt_entry, routine_arg ); } rtems_libio_unlock(); return stop; } 108563: 8a 55 e4 mov -0x1c(%ebp),%dl 108566: 88 d0 mov %dl,%al 108568: 8d 65 f4 lea -0xc(%ebp),%esp 10856b: 5b pop %ebx 10856c: 5e pop %esi 10856d: 5f pop %edi 10856e: c9 leave 10856f: c3 ret rtems_per_filesystem_mount_routine routine, void *routine_arg ) { rtems_chain_node *node = NULL; bool stop = false; 108570: 31 d2 xor %edx,%edx <== NOT EXECUTED 108572: eb de jmp 108552 <== NOT EXECUTED =============================================================================== 00108050 : int rtems_filesystem_prefix_separators( const char *pathname, int pathnamelen ) { 108050: 55 push %ebp 108051: 89 e5 mov %esp,%ebp 108053: 57 push %edi 108054: 56 push %esi 108055: 53 push %ebx 108056: 83 ec 0c sub $0xc,%esp 108059: 8b 75 08 mov 0x8(%ebp),%esi 10805c: 8b 7d 0c mov 0xc(%ebp),%edi /* * Eat any separators at start of the path. */ int stripped = 0; while ( *pathname && pathnamelen && rtems_filesystem_is_separator( *pathname ) ) 10805f: 8a 06 mov (%esi),%al 108061: 84 c0 test %al,%al 108063: 74 34 je 108099 <== NEVER TAKEN 108065: 85 ff test %edi,%edi 108067: 74 30 je 108099 <== NEVER TAKEN 108069: 31 db xor %ebx,%ebx 10806b: eb 0f jmp 10807c 10806d: 8d 76 00 lea 0x0(%esi),%esi { pathname++; pathnamelen--; stripped++; 108070: 43 inc %ebx { /* * Eat any separators at start of the path. */ int stripped = 0; while ( *pathname && pathnamelen && rtems_filesystem_is_separator( *pathname ) ) 108071: 8a 04 1e mov (%esi,%ebx,1),%al 108074: 84 c0 test %al,%al 108076: 74 17 je 10808f <== NEVER TAKEN 108078: 39 df cmp %ebx,%edi 10807a: 74 13 je 10808f <== NEVER TAKEN 10807c: 83 ec 0c sub $0xc,%esp 10807f: 0f be c0 movsbl %al,%eax 108082: 50 push %eax 108083: e8 90 0e 00 00 call 108f18 108088: 83 c4 10 add $0x10,%esp 10808b: 85 c0 test %eax,%eax 10808d: 75 e1 jne 108070 pathname++; pathnamelen--; stripped++; } return stripped; } 10808f: 89 d8 mov %ebx,%eax 108091: 8d 65 f4 lea -0xc(%ebp),%esp 108094: 5b pop %ebx 108095: 5e pop %esi 108096: 5f pop %edi 108097: c9 leave 108098: c3 ret ) { /* * Eat any separators at start of the path. */ int stripped = 0; 108099: 31 db xor %ebx,%ebx 10809b: eb f2 jmp 10808f <== NOT EXECUTED =============================================================================== 001100e0 : int rtems_filesystem_register( const char *type, rtems_filesystem_fsmount_me_t mount_h ) { 1100e0: 55 push %ebp 1100e1: 89 e5 mov %esp,%ebp 1100e3: 57 push %edi 1100e4: 56 push %esi 1100e5: 53 push %ebx 1100e6: 83 ec 28 sub $0x28,%esp size_t type_size = strlen(type) + 1; 1100e9: 31 c0 xor %eax,%eax 1100eb: b9 ff ff ff ff mov $0xffffffff,%ecx 1100f0: 8b 7d 08 mov 0x8(%ebp),%edi 1100f3: f2 ae repnz scas %es:(%edi),%al 1100f5: f7 d1 not %ecx size_t fsn_size = sizeof( filesystem_node ) + type_size; 1100f7: 8d 41 10 lea 0x10(%ecx),%eax filesystem_node *fsn = malloc( fsn_size ); 1100fa: 50 push %eax 1100fb: 89 4d e4 mov %ecx,-0x1c(%ebp) 1100fe: e8 85 82 ff ff call 108388 110103: 89 c3 mov %eax,%ebx char *type_storage = (char *) fsn + sizeof( *fsn ); if ( fsn == NULL ) 110105: 83 c4 10 add $0x10,%esp 110108: 85 c0 test %eax,%eax 11010a: 8b 4d e4 mov -0x1c(%ebp),%ecx 11010d: 0f 84 8e 00 00 00 je 1101a1 ) { size_t type_size = strlen(type) + 1; size_t fsn_size = sizeof( filesystem_node ) + type_size; filesystem_node *fsn = malloc( fsn_size ); char *type_storage = (char *) fsn + sizeof( *fsn ); 110113: 8d 40 10 lea 0x10(%eax),%eax if ( fsn == NULL ) rtems_set_errno_and_return_minus_one( ENOMEM ); memcpy(type_storage, type, type_size); 110116: 89 c7 mov %eax,%edi 110118: 8b 75 08 mov 0x8(%ebp),%esi 11011b: f3 a4 rep movsb %ds:(%esi),%es:(%edi) fsn->entry.type = type_storage; 11011d: 89 43 08 mov %eax,0x8(%ebx) fsn->entry.mount_h = mount_h; 110120: 8b 45 0c mov 0xc(%ebp),%eax 110123: 89 43 0c mov %eax,0xc(%ebx) rtems_status_code rtems_libio_set_private_env(void); rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ; static inline void rtems_libio_lock( void ) { rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); 110126: 50 push %eax 110127: 6a 00 push $0x0 110129: 6a 00 push $0x0 11012b: ff 35 28 7c 12 00 pushl 0x127c28 110131: e8 7a b5 ff ff call 10b6b0 rtems_libio_lock(); if ( rtems_filesystem_get_mount_handler( type ) == NULL ) { 110136: 5f pop %edi 110137: ff 75 08 pushl 0x8(%ebp) 11013a: e8 6d ff ff ff call 1100ac 11013f: 83 c4 10 add $0x10,%esp 110142: 85 c0 test %eax,%eax 110144: 75 2a jne 110170 110146: 83 ec 08 sub $0x8,%esp 110149: 53 push %ebx 11014a: 68 b8 59 12 00 push $0x1259b8 11014f: e8 84 be ff ff call 10bfd8 <_Chain_Append> } static inline void rtems_libio_unlock( void ) { rtems_semaphore_release( rtems_libio_semaphore ); 110154: 5e pop %esi 110155: ff 35 28 7c 12 00 pushl 0x127c28 11015b: e8 4c b6 ff ff call 10b7ac 110160: 83 c4 10 add $0x10,%esp rtems_set_errno_and_return_minus_one( EINVAL ); } rtems_libio_unlock(); return 0; 110163: 31 c0 xor %eax,%eax } 110165: 8d 65 f4 lea -0xc(%ebp),%esp 110168: 5b pop %ebx 110169: 5e pop %esi 11016a: 5f pop %edi 11016b: c9 leave 11016c: c3 ret 11016d: 8d 76 00 lea 0x0(%esi),%esi 110170: 83 ec 0c sub $0xc,%esp 110173: ff 35 28 7c 12 00 pushl 0x127c28 110179: e8 2e b6 ff ff call 10b7ac rtems_libio_lock(); if ( rtems_filesystem_get_mount_handler( type ) == NULL ) { rtems_chain_append( &filesystem_chain, &fsn->node ); } else { rtems_libio_unlock(); free( fsn ); 11017e: 89 1c 24 mov %ebx,(%esp) 110181: e8 2e 7f ff ff call 1080b4 rtems_set_errno_and_return_minus_one( EINVAL ); 110186: e8 e5 30 00 00 call 113270 <__errno> 11018b: c7 00 16 00 00 00 movl $0x16,(%eax) 110191: 83 c4 10 add $0x10,%esp 110194: b8 ff ff ff ff mov $0xffffffff,%eax } rtems_libio_unlock(); return 0; } 110199: 8d 65 f4 lea -0xc(%ebp),%esp 11019c: 5b pop %ebx 11019d: 5e pop %esi 11019e: 5f pop %edi 11019f: c9 leave 1101a0: c3 ret size_t fsn_size = sizeof( filesystem_node ) + type_size; filesystem_node *fsn = malloc( fsn_size ); char *type_storage = (char *) fsn + sizeof( *fsn ); if ( fsn == NULL ) rtems_set_errno_and_return_minus_one( ENOMEM ); 1101a1: e8 ca 30 00 00 call 113270 <__errno> 1101a6: c7 00 0c 00 00 00 movl $0xc,(%eax) 1101ac: b8 ff ff ff ff mov $0xffffffff,%eax 1101b1: eb b2 jmp 110165 =============================================================================== 001101b4 : int rtems_filesystem_unregister( const char *type ) { 1101b4: 55 push %ebp 1101b5: 89 e5 mov %esp,%ebp 1101b7: 56 push %esi 1101b8: 53 push %ebx 1101b9: 8b 75 08 mov 0x8(%ebp),%esi rtems_chain_node *node = NULL; if ( type == NULL ) { 1101bc: 85 f6 test %esi,%esi 1101be: 0f 84 94 00 00 00 je 110258 rtems_status_code rtems_libio_set_private_env(void); rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ; static inline void rtems_libio_lock( void ) { rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); 1101c4: 51 push %ecx 1101c5: 6a 00 push $0x0 1101c7: 6a 00 push $0x0 1101c9: ff 35 28 7c 12 00 pushl 0x127c28 1101cf: e8 dc b4 ff ff call 10b6b0 } } rtems_libio_unlock(); rtems_set_errno_and_return_minus_one( ENOENT ); } 1101d4: 8b 1d b8 59 12 00 mov 0x1259b8,%ebx if ( type == NULL ) { rtems_set_errno_and_return_minus_one( EINVAL ); } rtems_libio_lock(); for ( 1101da: 83 c4 10 add $0x10,%esp 1101dd: 81 fb bc 59 12 00 cmp $0x1259bc,%ebx 1101e3: 75 0d jne 1101f2 1101e5: eb 49 jmp 110230 1101e7: 90 nop } } rtems_libio_unlock(); rtems_set_errno_and_return_minus_one( ENOENT ); } 1101e8: 8b 1b mov (%ebx),%ebx if ( type == NULL ) { rtems_set_errno_and_return_minus_one( EINVAL ); } rtems_libio_lock(); for ( 1101ea: 81 fb bc 59 12 00 cmp $0x1259bc,%ebx 1101f0: 74 3e je 110230 <== ALWAYS TAKEN !rtems_chain_is_tail( &filesystem_chain, node ); node = rtems_chain_next( node ) ) { filesystem_node *fsn = (filesystem_node *) node; if ( strcmp( fsn->entry.type, type ) == 0 ) { 1101f2: 83 ec 08 sub $0x8,%esp 1101f5: 56 push %esi 1101f6: ff 73 08 pushl 0x8(%ebx) 1101f9: e8 de 3c 00 00 call 113edc 1101fe: 83 c4 10 add $0x10,%esp 110201: 85 c0 test %eax,%eax 110203: 75 e3 jne 1101e8 */ RTEMS_INLINE_ROUTINE void rtems_chain_extract( rtems_chain_node *the_node ) { _Chain_Extract( the_node ); 110205: 83 ec 0c sub $0xc,%esp 110208: 53 push %ebx 110209: e8 ee bd ff ff call 10bffc <_Chain_Extract> rtems_chain_extract( node ); free( fsn ); 11020e: 89 1c 24 mov %ebx,(%esp) 110211: e8 9e 7e ff ff call 1080b4 } static inline void rtems_libio_unlock( void ) { rtems_semaphore_release( rtems_libio_semaphore ); 110216: 5a pop %edx 110217: ff 35 28 7c 12 00 pushl 0x127c28 11021d: e8 8a b5 ff ff call 10b7ac 110222: 83 c4 10 add $0x10,%esp rtems_libio_unlock(); return 0; 110225: 31 c0 xor %eax,%eax } } rtems_libio_unlock(); rtems_set_errno_and_return_minus_one( ENOENT ); } 110227: 8d 65 f8 lea -0x8(%ebp),%esp 11022a: 5b pop %ebx 11022b: 5e pop %esi 11022c: c9 leave 11022d: c3 ret 11022e: 66 90 xchg %ax,%ax 110230: 83 ec 0c sub $0xc,%esp 110233: ff 35 28 7c 12 00 pushl 0x127c28 110239: e8 6e b5 ff ff call 10b7ac return 0; } } rtems_libio_unlock(); rtems_set_errno_and_return_minus_one( ENOENT ); 11023e: e8 2d 30 00 00 call 113270 <__errno> 110243: c7 00 02 00 00 00 movl $0x2,(%eax) 110249: 83 c4 10 add $0x10,%esp 11024c: b8 ff ff ff ff mov $0xffffffff,%eax } 110251: 8d 65 f8 lea -0x8(%ebp),%esp 110254: 5b pop %ebx 110255: 5e pop %esi 110256: c9 leave 110257: c3 ret ) { rtems_chain_node *node = NULL; if ( type == NULL ) { rtems_set_errno_and_return_minus_one( EINVAL ); 110258: e8 13 30 00 00 call 113270 <__errno> 11025d: c7 00 16 00 00 00 movl $0x16,(%eax) 110263: 83 c8 ff or $0xffffffff,%eax 110266: eb e9 jmp 110251 =============================================================================== 0010897c : int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *)) { 10897c: 55 push %ebp 10897d: 89 e5 mov %esp,%ebp 10897f: 56 push %esi 108980: 53 push %ebx 108981: 8b 75 0c mov 0xc(%ebp),%esi * pointer to the buffer that will hold the value of the key itself. * We have to to this, because the others functions on this interface * deal with the value of the key, as used with the POSIX API. */ /* Do not pull your hair, trust me this works. :-) */ __gthread_key_t new_key = (__gthread_key_t) malloc( sizeof( *new_key ) ); 108984: 83 ec 0c sub $0xc,%esp 108987: 6a 08 push $0x8 108989: e8 c6 03 00 00 call 108d54 10898e: 89 c3 mov %eax,%ebx *key = new_key; 108990: 8b 45 08 mov 0x8(%ebp),%eax 108993: 89 18 mov %ebx,(%eax) new_key->val = NULL; 108995: c7 03 00 00 00 00 movl $0x0,(%ebx) new_key->dtor = dtor; 10899b: 89 73 04 mov %esi,0x4(%ebx) "gxx_wrappers: create key=%x, dtor=%x, new_key=%x\n", key, dtor, new_key ); #endif /* register with RTEMS the buffer that will hold the key values */ status = rtems_task_variable_add( RTEMS_SELF, (void **)new_key, dtor ); 10899e: 83 c4 0c add $0xc,%esp 1089a1: 56 push %esi 1089a2: 53 push %ebx 1089a3: 6a 00 push $0x0 1089a5: e8 a6 3c 00 00 call 10c650 if ( status == RTEMS_SUCCESSFUL ) 1089aa: 83 c4 10 add $0x10,%esp 1089ad: 85 c0 test %eax,%eax 1089af: 75 0b jne 1089bc <== NEVER TAKEN return 0; 1089b1: 31 c0 xor %eax,%eax free( new_key ); return -1; } 1089b3: 8d 65 f8 lea -0x8(%ebp),%esp 1089b6: 5b pop %ebx 1089b7: 5e pop %esi 1089b8: c9 leave 1089b9: c3 ret 1089ba: 66 90 xchg %ax,%ax /* register with RTEMS the buffer that will hold the key values */ status = rtems_task_variable_add( RTEMS_SELF, (void **)new_key, dtor ); if ( status == RTEMS_SUCCESSFUL ) return 0; free( new_key ); 1089bc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1089bf: 53 push %ebx <== NOT EXECUTED 1089c0: e8 3f fe ff ff call 108804 <== NOT EXECUTED return -1; 1089c5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1089c8: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 1089cd: eb e4 jmp 1089b3 <== NOT EXECUTED =============================================================================== 001089e0 : int rtems_gxx_key_delete (__gthread_key_t key) { 1089e0: 55 push %ebp 1089e1: 89 e5 mov %esp,%ebp 1089e3: 53 push %ebx 1089e4: 83 ec 0c sub $0xc,%esp 1089e7: 8b 5d 08 mov 0x8(%ebp),%ebx #ifdef DEBUG_GXX_WRAPPERS printk( "gxx_wrappers: delete key=%x\n", key ); #endif /* register with RTEMS the buffer that will hold the key values */ status = rtems_task_variable_delete( RTEMS_SELF, (void **)key ); 1089ea: 53 push %ebx 1089eb: 6a 00 push $0x0 1089ed: e8 22 3d 00 00 call 10c714 if ( status == RTEMS_SUCCESSFUL ) { 1089f2: 83 c4 10 add $0x10,%esp 1089f5: 85 c0 test %eax,%eax 1089f7: 75 11 jne 108a0a <== NEVER TAKEN /* Hmm - hopefully all tasks using this key have gone away... */ if ( key ) free( *(void **)key ); 1089f9: 85 db test %ebx,%ebx 1089fb: 74 0d je 108a0a <== NEVER TAKEN 1089fd: 83 ec 0c sub $0xc,%esp 108a00: ff 33 pushl (%ebx) 108a02: e8 fd fd ff ff call 108804 108a07: 83 c4 10 add $0x10,%esp return 0; } key = NULL; return 0; } 108a0a: 31 c0 xor %eax,%eax 108a0c: 8b 5d fc mov -0x4(%ebp),%ebx 108a0f: c9 leave 108a10: c3 ret =============================================================================== 00108900 : /* uncomment this if you need to debug this interface */ /*#define DEBUG_GXX_WRAPPERS 1*/ int rtems_gxx_once(__gthread_once_t *once, void (*func) (void)) { 108900: 55 push %ebp 108901: 89 e5 mov %esp,%ebp 108903: 56 push %esi 108904: 53 push %ebx 108905: 83 ec 10 sub $0x10,%esp 108908: 8b 5d 08 mov 0x8(%ebp),%ebx #ifdef DEBUG_GXX_WRAPPERS printk( "gxx_wrappers: once=%x, func=%x\n", *once, func ); #endif if ( *(volatile __gthread_once_t *)once == 0 ) { 10890b: 8b 03 mov (%ebx),%eax 10890d: 85 c0 test %eax,%eax 10890f: 74 0b je 10891c rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); if ( o == 0 ) (*func)(); } return 0; } 108911: 31 c0 xor %eax,%eax 108913: 8d 65 f8 lea -0x8(%ebp),%esp 108916: 5b pop %ebx 108917: 5e pop %esi 108918: c9 leave 108919: c3 ret 10891a: 66 90 xchg %ax,%ax if ( *(volatile __gthread_once_t *)once == 0 ) { rtems_mode saveMode; __gthread_once_t o; rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode); 10891c: 51 push %ecx 10891d: 8d 75 f4 lea -0xc(%ebp),%esi 108920: 56 push %esi 108921: 68 00 01 00 00 push $0x100 108926: 68 00 01 00 00 push $0x100 10892b: e8 48 3b 00 00 call 10c478 if ( (o = *(volatile __gthread_once_t *)once) == 0 ) { 108930: 8b 03 mov (%ebx),%eax 108932: 83 c4 10 add $0x10,%esp 108935: 85 c0 test %eax,%eax 108937: 75 27 jne 108960 <== NEVER TAKEN *(volatile __gthread_once_t *)once = 1; 108939: c7 03 01 00 00 00 movl $0x1,(%ebx) } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); 10893f: 52 push %edx 108940: 56 push %esi 108941: 68 00 01 00 00 push $0x100 108946: ff 75 f4 pushl -0xc(%ebp) 108949: e8 2a 3b 00 00 call 10c478 if ( o == 0 ) (*func)(); 10894e: ff 55 0c call *0xc(%ebp) 108951: 83 c4 10 add $0x10,%esp } return 0; } 108954: 31 c0 xor %eax,%eax 108956: 8d 65 f8 lea -0x8(%ebp),%esp 108959: 5b pop %ebx 10895a: 5e pop %esi 10895b: c9 leave 10895c: c3 ret 10895d: 8d 76 00 lea 0x0(%esi),%esi rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode); if ( (o = *(volatile __gthread_once_t *)once) == 0 ) { *(volatile __gthread_once_t *)once = 1; } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); 108960: 50 push %eax <== NOT EXECUTED 108961: 56 push %esi <== NOT EXECUTED 108962: 68 00 01 00 00 push $0x100 <== NOT EXECUTED 108967: ff 75 f4 pushl -0xc(%ebp) <== NOT EXECUTED 10896a: e8 09 3b 00 00 call 10c478 <== NOT EXECUTED 10896f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if ( o == 0 ) (*func)(); } return 0; } 108972: 31 c0 xor %eax,%eax <== NOT EXECUTED 108974: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 108977: 5b pop %ebx <== NOT EXECUTED 108978: 5e pop %esi <== NOT EXECUTED 108979: c9 leave <== NOT EXECUTED 10897a: c3 ret <== NOT EXECUTED =============================================================================== 00108a70 : #endif return p; } int rtems_gxx_setspecific(__gthread_key_t key, const void *ptr) { 108a70: 55 push %ebp 108a71: 89 e5 mov %esp,%ebp 108a73: 53 push %ebx 108a74: 83 ec 08 sub $0x8,%esp 108a77: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_task_self() ); #endif /* register with RTEMS the buffer that will hold the key values */ status = rtems_task_variable_add( RTEMS_SELF, (void **)key, key->dtor ); 108a7a: ff 73 04 pushl 0x4(%ebx) 108a7d: 53 push %ebx 108a7e: 6a 00 push $0x0 108a80: e8 cb 3b 00 00 call 10c650 if ( status == RTEMS_SUCCESSFUL ) { 108a85: 83 c4 10 add $0x10,%esp 108a88: 85 c0 test %eax,%eax 108a8a: 75 0c jne 108a98 <== NEVER TAKEN /* now let's set the proper value */ key->val = (void *)ptr; 108a8c: 8b 45 0c mov 0xc(%ebp),%eax 108a8f: 89 03 mov %eax,(%ebx) return 0; 108a91: 31 c0 xor %eax,%eax } return -1; } 108a93: 8b 5d fc mov -0x4(%ebp),%ebx 108a96: c9 leave 108a97: c3 ret if ( status == RTEMS_SUCCESSFUL ) { /* now let's set the proper value */ key->val = (void *)ptr; return 0; } return -1; 108a98: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED } 108a9d: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 108aa0: c9 leave <== NOT EXECUTED 108aa1: c3 ret <== NOT EXECUTED =============================================================================== 0010bc38 : void *rtems_heap_allocate_aligned_with_boundary( size_t size, uintptr_t alignment, uintptr_t boundary ) { 10bc38: 55 push %ebp 10bc39: 89 e5 mov %esp,%ebp 10bc3b: 83 ec 08 sub $0x8,%esp if ( 10bc3e: 83 3d 60 f4 12 00 03 cmpl $0x3,0x12f460 10bc45: 74 21 je 10bc68 <== ALWAYS TAKEN && !malloc_is_system_state_OK() ) { return NULL; } malloc_deferred_frees_process(); 10bc47: e8 e0 ef ff ff call 10ac2c /* FIXME: Statistics, boundary checks */ return _Protected_heap_Allocate_aligned_with_boundary( 10bc4c: ff 75 10 pushl 0x10(%ebp) 10bc4f: ff 75 0c pushl 0xc(%ebp) 10bc52: ff 75 08 pushl 0x8(%ebp) 10bc55: ff 35 b0 a5 12 00 pushl 0x12a5b0 10bc5b: e8 f0 4d 00 00 call 110a50 <_Protected_heap_Allocate_aligned_with_boundary> 10bc60: 83 c4 10 add $0x10,%esp RTEMS_Malloc_Heap, size, alignment, boundary ); } 10bc63: c9 leave 10bc64: c3 ret 10bc65: 8d 76 00 lea 0x0(%esi),%esi uintptr_t boundary ) { if ( _System_state_Is_up( _System_state_Get() ) && !malloc_is_system_state_OK() 10bc68: e8 7f ef ff ff call 10abec 10bc6d: 84 c0 test %al,%al 10bc6f: 75 d6 jne 10bc47 ) { return NULL; 10bc71: 31 c0 xor %eax,%eax RTEMS_Malloc_Heap, size, alignment, boundary ); } 10bc73: c9 leave 10bc74: c3 ret =============================================================================== 00112f54 : rtems_status_code rtems_io_close( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 112f54: 55 push %ebp 112f55: 89 e5 mov %esp,%ebp 112f57: 53 push %ebx 112f58: 83 ec 04 sub $0x4,%esp 112f5b: 8b 45 08 mov 0x8(%ebp),%eax rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 112f5e: 39 05 00 88 12 00 cmp %eax,0x128800 112f64: 76 1a jbe 112f80 return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].close_entry; 112f66: 8d 14 40 lea (%eax,%eax,2),%edx 112f69: c1 e2 03 shl $0x3,%edx 112f6c: 03 15 04 88 12 00 add 0x128804,%edx 112f72: 8b 52 08 mov 0x8(%edx),%edx return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 112f75: 85 d2 test %edx,%edx 112f77: 74 13 je 112f8c } 112f79: 59 pop %ecx 112f7a: 5b pop %ebx 112f7b: c9 leave if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].close_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 112f7c: ff e2 jmp *%edx 112f7e: 66 90 xchg %ax,%ax ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; 112f80: b8 0a 00 00 00 mov $0xa,%eax callout = _IO_Driver_address_table[major].close_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; } 112f85: 5a pop %edx 112f86: 5b pop %ebx 112f87: c9 leave 112f88: c3 ret 112f89: 8d 76 00 lea 0x0(%esi),%esi if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].close_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 112f8c: 31 c0 xor %eax,%eax } 112f8e: 5a pop %edx 112f8f: 5b pop %ebx 112f90: c9 leave 112f91: c3 ret =============================================================================== 00112f94 : rtems_status_code rtems_io_control( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 112f94: 55 push %ebp 112f95: 89 e5 mov %esp,%ebp 112f97: 53 push %ebx 112f98: 83 ec 04 sub $0x4,%esp 112f9b: 8b 45 08 mov 0x8(%ebp),%eax rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 112f9e: 39 05 00 88 12 00 cmp %eax,0x128800 112fa4: 76 1a jbe 112fc0 return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].control_entry; 112fa6: 8d 14 40 lea (%eax,%eax,2),%edx 112fa9: c1 e2 03 shl $0x3,%edx 112fac: 03 15 04 88 12 00 add 0x128804,%edx 112fb2: 8b 52 14 mov 0x14(%edx),%edx return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 112fb5: 85 d2 test %edx,%edx 112fb7: 74 13 je 112fcc } 112fb9: 59 pop %ecx 112fba: 5b pop %ebx 112fbb: c9 leave if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].control_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 112fbc: ff e2 jmp *%edx 112fbe: 66 90 xchg %ax,%ax ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; 112fc0: b8 0a 00 00 00 mov $0xa,%eax callout = _IO_Driver_address_table[major].control_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; } 112fc5: 5a pop %edx 112fc6: 5b pop %ebx 112fc7: c9 leave 112fc8: c3 ret 112fc9: 8d 76 00 lea 0x0(%esi),%esi if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].control_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 112fcc: 31 c0 xor %eax,%eax } 112fce: 5a pop %edx 112fcf: 5b pop %ebx 112fd0: c9 leave 112fd1: c3 ret =============================================================================== 00111044 : rtems_status_code rtems_io_initialize( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 111044: 55 push %ebp 111045: 89 e5 mov %esp,%ebp 111047: 53 push %ebx 111048: 83 ec 04 sub $0x4,%esp 11104b: 8b 45 08 mov 0x8(%ebp),%eax rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 11104e: 39 05 00 88 12 00 cmp %eax,0x128800 111054: 76 1a jbe 111070 return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].initialization_entry; 111056: 8d 14 40 lea (%eax,%eax,2),%edx 111059: c1 e2 03 shl $0x3,%edx 11105c: 03 15 04 88 12 00 add 0x128804,%edx 111062: 8b 12 mov (%edx),%edx return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 111064: 85 d2 test %edx,%edx 111066: 74 14 je 11107c } 111068: 59 pop %ecx 111069: 5b pop %ebx 11106a: c9 leave if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].initialization_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 11106b: ff e2 jmp *%edx 11106d: 8d 76 00 lea 0x0(%esi),%esi ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; 111070: b8 0a 00 00 00 mov $0xa,%eax callout = _IO_Driver_address_table[major].initialization_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; } 111075: 5a pop %edx 111076: 5b pop %ebx 111077: c9 leave 111078: c3 ret 111079: 8d 76 00 lea 0x0(%esi),%esi if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].initialization_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 11107c: 31 c0 xor %eax,%eax } 11107e: 5a pop %edx 11107f: 5b pop %ebx 111080: c9 leave 111081: c3 ret =============================================================================== 00107d60 : rtems_status_code rtems_io_lookup_name( const char *name, rtems_driver_name_t *device_info ) { 107d60: 55 push %ebp 107d61: 89 e5 mov %esp,%ebp 107d63: 57 push %edi 107d64: 56 push %esi 107d65: 53 push %ebx 107d66: 83 ec 48 sub $0x48,%esp 107d69: 8b 75 08 mov 0x8(%ebp),%esi IMFS_jnode_t *the_jnode; rtems_filesystem_location_info_t loc; int result; rtems_filesystem_node_types_t node_type; result = rtems_filesystem_evaluate_path( 107d6c: b9 ff ff ff ff mov $0xffffffff,%ecx 107d71: 89 f7 mov %esi,%edi 107d73: 31 c0 xor %eax,%eax 107d75: f2 ae repnz scas %es:(%edi),%al 107d77: f7 d1 not %ecx 107d79: 49 dec %ecx 107d7a: 6a 01 push $0x1 107d7c: 8d 5d d4 lea -0x2c(%ebp),%ebx 107d7f: 53 push %ebx 107d80: 6a 00 push $0x0 107d82: 51 push %ecx 107d83: 56 push %esi 107d84: e8 3f 02 00 00 call 107fc8 107d89: 89 c7 mov %eax,%edi name, strlen( name ), 0x00, &loc, true ); the_jnode = loc.node_access; 107d8b: 8b 55 d4 mov -0x2c(%ebp),%edx 107d8e: 89 55 c4 mov %edx,-0x3c(%ebp) node_type = (*loc.ops->node_type_h)( &loc ); 107d91: 83 c4 14 add $0x14,%esp 107d94: 53 push %ebx 107d95: 8b 45 e0 mov -0x20(%ebp),%eax 107d98: ff 50 10 call *0x10(%eax) if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) { 107d9b: 83 c4 10 add $0x10,%esp 107d9e: 85 ff test %edi,%edi 107da0: 75 05 jne 107da7 <== NEVER TAKEN 107da2: 83 f8 02 cmp $0x2,%eax 107da5: 74 19 je 107dc0 rtems_filesystem_freenode( &loc ); 107da7: 83 ec 0c sub $0xc,%esp 107daa: 53 push %ebx 107dab: e8 f0 02 00 00 call 1080a0 return RTEMS_UNSATISFIED; 107db0: 83 c4 10 add $0x10,%esp 107db3: b8 0d 00 00 00 mov $0xd,%eax device_info->minor = the_jnode->info.device.minor; rtems_filesystem_freenode( &loc ); return RTEMS_SUCCESSFUL; } 107db8: 8d 65 f4 lea -0xc(%ebp),%esp 107dbb: 5b pop %ebx 107dbc: 5e pop %esi 107dbd: 5f pop %edi 107dbe: c9 leave 107dbf: c3 ret if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) { rtems_filesystem_freenode( &loc ); return RTEMS_UNSATISFIED; } device_info->device_name = (char *) name; 107dc0: 8b 7d 0c mov 0xc(%ebp),%edi 107dc3: 89 37 mov %esi,(%edi) device_info->device_name_length = strlen( name ); 107dc5: b9 ff ff ff ff mov $0xffffffff,%ecx 107dca: 89 f7 mov %esi,%edi 107dcc: 31 c0 xor %eax,%eax 107dce: f2 ae repnz scas %es:(%edi),%al 107dd0: f7 d1 not %ecx 107dd2: 49 dec %ecx 107dd3: 8b 45 0c mov 0xc(%ebp),%eax 107dd6: 89 48 04 mov %ecx,0x4(%eax) device_info->major = the_jnode->info.device.major; 107dd9: 8b 55 c4 mov -0x3c(%ebp),%edx 107ddc: 8b 42 50 mov 0x50(%edx),%eax 107ddf: 8b 7d 0c mov 0xc(%ebp),%edi 107de2: 89 47 08 mov %eax,0x8(%edi) device_info->minor = the_jnode->info.device.minor; 107de5: 8b 42 54 mov 0x54(%edx),%eax 107de8: 89 47 0c mov %eax,0xc(%edi) rtems_filesystem_freenode( &loc ); 107deb: 83 ec 0c sub $0xc,%esp 107dee: 53 push %ebx 107def: e8 ac 02 00 00 call 1080a0 return RTEMS_SUCCESSFUL; 107df4: 83 c4 10 add $0x10,%esp 107df7: 31 c0 xor %eax,%eax 107df9: eb bd jmp 107db8 =============================================================================== 00112fd4 : rtems_status_code rtems_io_open( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 112fd4: 55 push %ebp 112fd5: 89 e5 mov %esp,%ebp 112fd7: 53 push %ebx 112fd8: 83 ec 04 sub $0x4,%esp 112fdb: 8b 45 08 mov 0x8(%ebp),%eax rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 112fde: 39 05 00 88 12 00 cmp %eax,0x128800 112fe4: 76 1a jbe 113000 return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].open_entry; 112fe6: 8d 14 40 lea (%eax,%eax,2),%edx 112fe9: c1 e2 03 shl $0x3,%edx 112fec: 03 15 04 88 12 00 add 0x128804,%edx 112ff2: 8b 52 04 mov 0x4(%edx),%edx return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 112ff5: 85 d2 test %edx,%edx 112ff7: 74 13 je 11300c } 112ff9: 59 pop %ecx 112ffa: 5b pop %ebx 112ffb: c9 leave if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].open_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 112ffc: ff e2 jmp *%edx 112ffe: 66 90 xchg %ax,%ax ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; 113000: b8 0a 00 00 00 mov $0xa,%eax callout = _IO_Driver_address_table[major].open_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; } 113005: 5a pop %edx 113006: 5b pop %ebx 113007: c9 leave 113008: c3 ret 113009: 8d 76 00 lea 0x0(%esi),%esi if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].open_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 11300c: 31 c0 xor %eax,%eax } 11300e: 5a pop %edx 11300f: 5b pop %ebx 113010: c9 leave 113011: c3 ret =============================================================================== 00113014 : rtems_status_code rtems_io_read( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 113014: 55 push %ebp 113015: 89 e5 mov %esp,%ebp 113017: 53 push %ebx 113018: 83 ec 04 sub $0x4,%esp 11301b: 8b 45 08 mov 0x8(%ebp),%eax rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 11301e: 39 05 00 88 12 00 cmp %eax,0x128800 113024: 76 1a jbe 113040 return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].read_entry; 113026: 8d 14 40 lea (%eax,%eax,2),%edx 113029: c1 e2 03 shl $0x3,%edx 11302c: 03 15 04 88 12 00 add 0x128804,%edx 113032: 8b 52 0c mov 0xc(%edx),%edx return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 113035: 85 d2 test %edx,%edx 113037: 74 13 je 11304c } 113039: 59 pop %ecx 11303a: 5b pop %ebx 11303b: c9 leave if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].read_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 11303c: ff e2 jmp *%edx 11303e: 66 90 xchg %ax,%ax ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; 113040: b8 0a 00 00 00 mov $0xa,%eax callout = _IO_Driver_address_table[major].read_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; } 113045: 5a pop %edx 113046: 5b pop %ebx 113047: c9 leave 113048: c3 ret 113049: 8d 76 00 lea 0x0(%esi),%esi if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].read_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 11304c: 31 c0 xor %eax,%eax } 11304e: 5a pop %edx 11304f: 5b pop %ebx 113050: c9 leave 113051: c3 ret =============================================================================== 0010cec0 : rtems_status_code rtems_io_register_driver( rtems_device_major_number major, const rtems_driver_address_table *driver_table, rtems_device_major_number *registered_major ) { 10cec0: 55 push %ebp 10cec1: 89 e5 mov %esp,%ebp 10cec3: 57 push %edi 10cec4: 56 push %esi 10cec5: 53 push %ebx 10cec6: 83 ec 0c sub $0xc,%esp 10cec9: 8b 5d 08 mov 0x8(%ebp),%ebx 10cecc: 8b 75 0c mov 0xc(%ebp),%esi 10cecf: 8b 55 10 mov 0x10(%ebp),%edx rtems_device_major_number major_limit = _IO_Number_of_drivers; 10ced2: a1 00 c5 12 00 mov 0x12c500,%eax if ( rtems_interrupt_is_in_progress() ) 10ced7: 8b 0d 34 c0 12 00 mov 0x12c034,%ecx 10cedd: 85 c9 test %ecx,%ecx 10cedf: 0f 85 ab 00 00 00 jne 10cf90 return RTEMS_CALLED_FROM_ISR; if ( registered_major == NULL ) 10cee5: 85 d2 test %edx,%edx 10cee7: 0f 84 e7 00 00 00 je 10cfd4 return RTEMS_INVALID_ADDRESS; /* Set it to an invalid value */ *registered_major = major_limit; 10ceed: 89 02 mov %eax,(%edx) if ( driver_table == NULL ) 10ceef: 85 f6 test %esi,%esi 10cef1: 0f 84 dd 00 00 00 je 10cfd4 static inline bool rtems_io_is_empty_table( const rtems_driver_address_table *table ) { return table->initialization_entry == NULL && table->open_entry == NULL; 10cef7: 8b 3e mov (%esi),%edi 10cef9: 85 ff test %edi,%edi 10cefb: 0f 84 c7 00 00 00 je 10cfc8 return RTEMS_INVALID_ADDRESS; if ( rtems_io_is_empty_table( driver_table ) ) return RTEMS_INVALID_ADDRESS; if ( major >= major_limit ) 10cf01: 39 d8 cmp %ebx,%eax 10cf03: 76 7b jbe 10cf80 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10cf05: a1 90 ba 12 00 mov 0x12ba90,%eax 10cf0a: 40 inc %eax 10cf0b: a3 90 ba 12 00 mov %eax,0x12ba90 return RTEMS_INVALID_NUMBER; _Thread_Disable_dispatch(); if ( major == 0 ) { 10cf10: 85 db test %ebx,%ebx 10cf12: 0f 85 88 00 00 00 jne 10cfa0 static rtems_status_code rtems_io_obtain_major_number( rtems_device_major_number *major ) { rtems_device_major_number n = _IO_Number_of_drivers; 10cf18: 8b 0d 00 c5 12 00 mov 0x12c500,%ecx rtems_device_major_number m = 0; /* major is error checked by caller */ for ( m = 0; m < n; ++m ) { 10cf1e: 85 c9 test %ecx,%ecx 10cf20: 0f 84 bb 00 00 00 je 10cfe1 <== NEVER TAKEN 10cf26: 8b 3d 04 c5 12 00 mov 0x12c504,%edi 10cf2c: 89 f8 mov %edi,%eax 10cf2e: eb 08 jmp 10cf38 10cf30: 43 inc %ebx 10cf31: 83 c0 18 add $0x18,%eax 10cf34: 39 d9 cmp %ebx,%ecx 10cf36: 76 0b jbe 10cf43 static inline bool rtems_io_is_empty_table( const rtems_driver_address_table *table ) { return table->initialization_entry == NULL && table->open_entry == NULL; 10cf38: 83 38 00 cmpl $0x0,(%eax) 10cf3b: 75 f3 jne 10cf30 10cf3d: 83 78 04 00 cmpl $0x0,0x4(%eax) 10cf41: 75 ed jne 10cf30 if ( rtems_io_is_empty_table( table ) ) break; } /* Assigns invalid value in case of failure */ *major = m; 10cf43: 89 1a mov %ebx,(%edx) if ( m != n ) 10cf45: 39 d9 cmp %ebx,%ecx 10cf47: 0f 84 9b 00 00 00 je 10cfe8 10cf4d: 8d 04 5b lea (%ebx,%ebx,2),%eax 10cf50: c1 e0 03 shl $0x3,%eax } *registered_major = major; } _IO_Driver_address_table [major] = *driver_table; 10cf53: 01 c7 add %eax,%edi 10cf55: b9 06 00 00 00 mov $0x6,%ecx 10cf5a: f3 a5 rep movsl %ds:(%esi),%es:(%edi) _Thread_Enable_dispatch(); 10cf5c: e8 6b 1d 00 00 call 10eccc <_Thread_Enable_dispatch> return rtems_io_initialize( major, 0, NULL ); 10cf61: c7 45 10 00 00 00 00 movl $0x0,0x10(%ebp) 10cf68: c7 45 0c 00 00 00 00 movl $0x0,0xc(%ebp) 10cf6f: 89 5d 08 mov %ebx,0x8(%ebp) } 10cf72: 83 c4 0c add $0xc,%esp 10cf75: 5b pop %ebx 10cf76: 5e pop %esi 10cf77: 5f pop %edi 10cf78: c9 leave _IO_Driver_address_table [major] = *driver_table; _Thread_Enable_dispatch(); return rtems_io_initialize( major, 0, NULL ); 10cf79: e9 72 7e 00 00 jmp 114df0 10cf7e: 66 90 xchg %ax,%ax if ( rtems_io_is_empty_table( driver_table ) ) return RTEMS_INVALID_ADDRESS; if ( major >= major_limit ) return RTEMS_INVALID_NUMBER; 10cf80: b8 0a 00 00 00 mov $0xa,%eax _IO_Driver_address_table [major] = *driver_table; _Thread_Enable_dispatch(); return rtems_io_initialize( major, 0, NULL ); } 10cf85: 83 c4 0c add $0xc,%esp 10cf88: 5b pop %ebx 10cf89: 5e pop %esi 10cf8a: 5f pop %edi 10cf8b: c9 leave 10cf8c: c3 ret 10cf8d: 8d 76 00 lea 0x0(%esi),%esi ) { rtems_device_major_number major_limit = _IO_Number_of_drivers; if ( rtems_interrupt_is_in_progress() ) return RTEMS_CALLED_FROM_ISR; 10cf90: b8 12 00 00 00 mov $0x12,%eax _IO_Driver_address_table [major] = *driver_table; _Thread_Enable_dispatch(); return rtems_io_initialize( major, 0, NULL ); } 10cf95: 83 c4 0c add $0xc,%esp 10cf98: 5b pop %ebx 10cf99: 5e pop %esi 10cf9a: 5f pop %edi 10cf9b: c9 leave 10cf9c: c3 ret 10cf9d: 8d 76 00 lea 0x0(%esi),%esi _Thread_Enable_dispatch(); return sc; } major = *registered_major; } else { rtems_driver_address_table *const table = _IO_Driver_address_table + major; 10cfa0: 8d 04 5b lea (%ebx,%ebx,2),%eax 10cfa3: c1 e0 03 shl $0x3,%eax 10cfa6: 8b 0d 04 c5 12 00 mov 0x12c504,%ecx 10cfac: 01 c1 add %eax,%ecx static inline bool rtems_io_is_empty_table( const rtems_driver_address_table *table ) { return table->initialization_entry == NULL && table->open_entry == NULL; 10cfae: 8b 39 mov (%ecx),%edi 10cfb0: 85 ff test %edi,%edi 10cfb2: 74 40 je 10cff4 major = *registered_major; } else { rtems_driver_address_table *const table = _IO_Driver_address_table + major; if ( !rtems_io_is_empty_table( table ) ) { _Thread_Enable_dispatch(); 10cfb4: e8 13 1d 00 00 call 10eccc <_Thread_Enable_dispatch> return RTEMS_RESOURCE_IN_USE; 10cfb9: b8 0c 00 00 00 mov $0xc,%eax _IO_Driver_address_table [major] = *driver_table; _Thread_Enable_dispatch(); return rtems_io_initialize( major, 0, NULL ); } 10cfbe: 83 c4 0c add $0xc,%esp 10cfc1: 5b pop %ebx 10cfc2: 5e pop %esi 10cfc3: 5f pop %edi 10cfc4: c9 leave 10cfc5: c3 ret 10cfc6: 66 90 xchg %ax,%ax static inline bool rtems_io_is_empty_table( const rtems_driver_address_table *table ) { return table->initialization_entry == NULL && table->open_entry == NULL; 10cfc8: 8b 4e 04 mov 0x4(%esi),%ecx 10cfcb: 85 c9 test %ecx,%ecx 10cfcd: 0f 85 2e ff ff ff jne 10cf01 10cfd3: 90 nop if ( driver_table == NULL ) return RTEMS_INVALID_ADDRESS; if ( rtems_io_is_empty_table( driver_table ) ) return RTEMS_INVALID_ADDRESS; 10cfd4: b8 09 00 00 00 mov $0x9,%eax _IO_Driver_address_table [major] = *driver_table; _Thread_Enable_dispatch(); return rtems_io_initialize( major, 0, NULL ); } 10cfd9: 83 c4 0c add $0xc,%esp 10cfdc: 5b pop %ebx 10cfdd: 5e pop %esi 10cfde: 5f pop %edi 10cfdf: c9 leave 10cfe0: c3 ret if ( rtems_io_is_empty_table( table ) ) break; } /* Assigns invalid value in case of failure */ *major = m; 10cfe1: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED 10cfe7: 90 nop <== NOT EXECUTED if ( major == 0 ) { rtems_status_code sc = rtems_io_obtain_major_number( registered_major ); if ( sc != RTEMS_SUCCESSFUL ) { _Thread_Enable_dispatch(); 10cfe8: e8 df 1c 00 00 call 10eccc <_Thread_Enable_dispatch> *major = m; if ( m != n ) return RTEMS_SUCCESSFUL; return RTEMS_TOO_MANY; 10cfed: b8 05 00 00 00 mov $0x5,%eax if ( major == 0 ) { rtems_status_code sc = rtems_io_obtain_major_number( registered_major ); if ( sc != RTEMS_SUCCESSFUL ) { _Thread_Enable_dispatch(); return sc; 10cff2: eb 91 jmp 10cf85 static inline bool rtems_io_is_empty_table( const rtems_driver_address_table *table ) { return table->initialization_entry == NULL && table->open_entry == NULL; 10cff4: 8b 49 04 mov 0x4(%ecx),%ecx 10cff7: 85 c9 test %ecx,%ecx 10cff9: 75 b9 jne 10cfb4 if ( !rtems_io_is_empty_table( table ) ) { _Thread_Enable_dispatch(); return RTEMS_RESOURCE_IN_USE; } *registered_major = major; 10cffb: 89 1a mov %ebx,(%edx) 10cffd: 8b 3d 04 c5 12 00 mov 0x12c504,%edi 10d003: e9 4b ff ff ff jmp 10cf53 =============================================================================== 0010d008 : */ rtems_status_code rtems_io_unregister_driver( rtems_device_major_number major ) { 10d008: 55 push %ebp 10d009: 89 e5 mov %esp,%ebp 10d00b: 57 push %edi 10d00c: 83 ec 04 sub $0x4,%esp 10d00f: 8b 45 08 mov 0x8(%ebp),%eax if ( rtems_interrupt_is_in_progress() ) 10d012: 8b 0d 34 c0 12 00 mov 0x12c034,%ecx 10d018: 85 c9 test %ecx,%ecx 10d01a: 75 44 jne 10d060 return RTEMS_CALLED_FROM_ISR; if ( major < _IO_Number_of_drivers ) { 10d01c: 39 05 00 c5 12 00 cmp %eax,0x12c500 10d022: 77 0c ja 10d030 _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_UNSATISFIED; 10d024: b8 0d 00 00 00 mov $0xd,%eax } 10d029: 5a pop %edx 10d02a: 5f pop %edi 10d02b: c9 leave 10d02c: c3 ret 10d02d: 8d 76 00 lea 0x0(%esi),%esi 10d030: 8b 15 90 ba 12 00 mov 0x12ba90,%edx 10d036: 42 inc %edx 10d037: 89 15 90 ba 12 00 mov %edx,0x12ba90 return RTEMS_CALLED_FROM_ISR; if ( major < _IO_Number_of_drivers ) { _Thread_Disable_dispatch(); memset( &_IO_Driver_address_table[major], 10d03d: 8d 14 40 lea (%eax,%eax,2),%edx 10d040: c1 e2 03 shl $0x3,%edx if ( rtems_interrupt_is_in_progress() ) return RTEMS_CALLED_FROM_ISR; if ( major < _IO_Number_of_drivers ) { _Thread_Disable_dispatch(); memset( 10d043: 03 15 04 c5 12 00 add 0x12c504,%edx 10d049: b9 18 00 00 00 mov $0x18,%ecx 10d04e: 31 c0 xor %eax,%eax 10d050: 89 d7 mov %edx,%edi 10d052: f3 aa rep stos %al,%es:(%edi) &_IO_Driver_address_table[major], 0, sizeof( rtems_driver_address_table ) ); _Thread_Enable_dispatch(); 10d054: e8 73 1c 00 00 call 10eccc <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10d059: 31 c0 xor %eax,%eax } return RTEMS_UNSATISFIED; } 10d05b: 5a pop %edx 10d05c: 5f pop %edi 10d05d: c9 leave 10d05e: c3 ret 10d05f: 90 nop rtems_status_code rtems_io_unregister_driver( rtems_device_major_number major ) { if ( rtems_interrupt_is_in_progress() ) return RTEMS_CALLED_FROM_ISR; 10d060: b8 12 00 00 00 mov $0x12,%eax return RTEMS_SUCCESSFUL; } return RTEMS_UNSATISFIED; } 10d065: 5a pop %edx 10d066: 5f pop %edi 10d067: c9 leave 10d068: c3 ret =============================================================================== 00113054 : rtems_status_code rtems_io_write( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 113054: 55 push %ebp 113055: 89 e5 mov %esp,%ebp 113057: 53 push %ebx 113058: 83 ec 04 sub $0x4,%esp 11305b: 8b 45 08 mov 0x8(%ebp),%eax rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 11305e: 39 05 00 88 12 00 cmp %eax,0x128800 113064: 76 1a jbe 113080 return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].write_entry; 113066: 8d 14 40 lea (%eax,%eax,2),%edx 113069: c1 e2 03 shl $0x3,%edx 11306c: 03 15 04 88 12 00 add 0x128804,%edx 113072: 8b 52 10 mov 0x10(%edx),%edx return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 113075: 85 d2 test %edx,%edx 113077: 74 13 je 11308c } 113079: 59 pop %ecx 11307a: 5b pop %ebx 11307b: c9 leave if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].write_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 11307c: ff e2 jmp *%edx 11307e: 66 90 xchg %ax,%ax ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; 113080: b8 0a 00 00 00 mov $0xa,%eax callout = _IO_Driver_address_table[major].write_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; } 113085: 5a pop %edx 113086: 5b pop %ebx 113087: c9 leave 113088: c3 ret 113089: 8d 76 00 lea 0x0(%esi),%esi if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].write_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 11308c: 31 c0 xor %eax,%eax } 11308e: 5a pop %edx 11308f: 5b pop %ebx 113090: c9 leave 113091: c3 ret =============================================================================== 0010dfb8 : #include #include void rtems_iterate_over_all_threads(rtems_per_thread_routine routine) { 10dfb8: 55 push %ebp 10dfb9: 89 e5 mov %esp,%ebp 10dfbb: 57 push %edi 10dfbc: 56 push %esi 10dfbd: 53 push %ebx 10dfbe: 83 ec 1c sub $0x1c,%esp 10dfc1: 8b 7d 08 mov 0x8(%ebp),%edi uint32_t i; uint32_t api_index; Thread_Control *the_thread; Objects_Information *information; if ( !routine ) 10dfc4: 85 ff test %edi,%edi 10dfc6: 74 49 je 10e011 <== NEVER TAKEN 10dfc8: c7 45 e4 01 00 00 00 movl $0x1,-0x1c(%ebp) #if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG) if ( !_Objects_Information_table[ api_index ] ) continue; #endif information = _Objects_Information_table[ api_index ][ 1 ]; 10dfcf: 8b 55 e4 mov -0x1c(%ebp),%edx 10dfd2: 8b 04 95 e8 a9 12 00 mov 0x12a9e8(,%edx,4),%eax 10dfd9: 8b 70 04 mov 0x4(%eax),%esi if ( !information ) 10dfdc: 85 f6 test %esi,%esi 10dfde: 74 28 je 10e008 continue; for ( i=1 ; i <= information->maximum ; i++ ) { 10dfe0: 66 83 7e 10 00 cmpw $0x0,0x10(%esi) 10dfe5: 74 21 je 10e008 10dfe7: bb 01 00 00 00 mov $0x1,%ebx the_thread = (Thread_Control *)information->local_table[ i ]; 10dfec: 8b 46 1c mov 0x1c(%esi),%eax 10dfef: 8b 04 98 mov (%eax,%ebx,4),%eax if ( !the_thread ) 10dff2: 85 c0 test %eax,%eax 10dff4: 74 09 je 10dfff <== NEVER TAKEN continue; (*routine)(the_thread); 10dff6: 83 ec 0c sub $0xc,%esp 10dff9: 50 push %eax 10dffa: ff d7 call *%edi 10dffc: 83 c4 10 add $0x10,%esp information = _Objects_Information_table[ api_index ][ 1 ]; if ( !information ) continue; for ( i=1 ; i <= information->maximum ; i++ ) { 10dfff: 43 inc %ebx 10e000: 0f b7 46 10 movzwl 0x10(%esi),%eax 10e004: 39 d8 cmp %ebx,%eax 10e006: 73 e4 jae 10dfec Objects_Information *information; if ( !routine ) return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { 10e008: ff 45 e4 incl -0x1c(%ebp) 10e00b: 83 7d e4 04 cmpl $0x4,-0x1c(%ebp) 10e00f: 75 be jne 10dfcf (*routine)(the_thread); } } } 10e011: 8d 65 f4 lea -0xc(%ebp),%esp 10e014: 5b pop %ebx 10e015: 5e pop %esi 10e016: 5f pop %edi 10e017: c9 leave 10e018: c3 ret =============================================================================== 0010feac : */ void rtems_libio_free( rtems_libio_t *iop ) { 10feac: 55 push %ebp 10fead: 89 e5 mov %esp,%ebp 10feaf: 53 push %ebx 10feb0: 83 ec 08 sub $0x8,%esp 10feb3: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_status_code rtems_libio_set_private_env(void); rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ; static inline void rtems_libio_lock( void ) { rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); 10feb6: 6a 00 push $0x0 10feb8: 6a 00 push $0x0 10feba: ff 35 28 7c 12 00 pushl 0x127c28 10fec0: e8 eb b7 ff ff call 10b6b0 rtems_libio_lock(); if (iop->sem) 10fec5: 8b 43 2c mov 0x2c(%ebx),%eax 10fec8: 83 c4 10 add $0x10,%esp 10fecb: 85 c0 test %eax,%eax 10fecd: 74 0c je 10fedb <== NEVER TAKEN rtems_semaphore_delete(iop->sem); 10fecf: 83 ec 0c sub $0xc,%esp 10fed2: 50 push %eax 10fed3: e8 34 b7 ff ff call 10b60c 10fed8: 83 c4 10 add $0x10,%esp iop->flags &= ~LIBIO_FLAGS_OPEN; 10fedb: 81 63 14 ff fe ff ff andl $0xfffffeff,0x14(%ebx) iop->data1 = rtems_libio_iop_freelist; 10fee2: a1 24 7c 12 00 mov 0x127c24,%eax 10fee7: 89 43 34 mov %eax,0x34(%ebx) rtems_libio_iop_freelist = iop; 10feea: 89 1d 24 7c 12 00 mov %ebx,0x127c24 } static inline void rtems_libio_unlock( void ) { rtems_semaphore_release( rtems_libio_semaphore ); 10fef0: a1 28 7c 12 00 mov 0x127c28,%eax 10fef5: 89 45 08 mov %eax,0x8(%ebp) rtems_libio_unlock(); } 10fef8: 8b 5d fc mov -0x4(%ebp),%ebx 10fefb: c9 leave 10fefc: e9 ab b8 ff ff jmp 10b7ac =============================================================================== 001081b0 : * * Called by BSP startup code to initialize the libio subsystem. */ void rtems_libio_init( void ) { 1081b0: 55 push %ebp 1081b1: 89 e5 mov %esp,%ebp 1081b3: 53 push %ebx 1081b4: 83 ec 04 sub $0x4,%esp rtems_status_code rc; uint32_t i; rtems_libio_t *iop; if (rtems_libio_number_iops > 0) 1081b7: 8b 1d 6c 39 12 00 mov 0x12396c,%ebx 1081bd: 85 db test %ebx,%ebx 1081bf: 74 50 je 108211 <== NEVER TAKEN { rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops, 1081c1: 83 ec 08 sub $0x8,%esp 1081c4: 6a 38 push $0x38 1081c6: 53 push %ebx 1081c7: e8 58 fd ff ff call 107f24 1081cc: 89 c2 mov %eax,%edx 1081ce: a3 20 7c 12 00 mov %eax,0x127c20 sizeof(rtems_libio_t)); if (rtems_libio_iops == NULL) 1081d3: 83 c4 10 add $0x10,%esp 1081d6: 85 c0 test %eax,%eax 1081d8: 74 74 je 10824e rtems_fatal_error_occurred(RTEMS_NO_MEMORY); iop = rtems_libio_iop_freelist = rtems_libio_iops; 1081da: a3 24 7c 12 00 mov %eax,0x127c24 for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++) 1081df: 83 fb 01 cmp $0x1,%ebx 1081e2: 76 26 jbe 10820a <== NEVER TAKEN * rtems_libio_init * * Called by BSP startup code to initialize the libio subsystem. */ void rtems_libio_init( void ) 1081e4: 8d 50 38 lea 0x38(%eax),%edx 1081e7: b9 01 00 00 00 mov $0x1,%ecx if (rtems_libio_iops == NULL) rtems_fatal_error_occurred(RTEMS_NO_MEMORY); iop = rtems_libio_iop_freelist = rtems_libio_iops; for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++) iop->data1 = iop + 1; 1081ec: 89 52 fc mov %edx,-0x4(%edx) 1081ef: 41 inc %ecx 1081f0: 83 c2 38 add $0x38,%edx sizeof(rtems_libio_t)); if (rtems_libio_iops == NULL) rtems_fatal_error_occurred(RTEMS_NO_MEMORY); iop = rtems_libio_iop_freelist = rtems_libio_iops; for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++) 1081f3: 39 d9 cmp %ebx,%ecx 1081f5: 75 f5 jne 1081ec * rtems_libio_init * * Called by BSP startup code to initialize the libio subsystem. */ void rtems_libio_init( void ) 1081f7: 8d 0c cd f8 ff ff ff lea -0x8(,%ecx,8),%ecx 1081fe: 8d 14 cd 00 00 00 00 lea 0x0(,%ecx,8),%edx 108205: 29 ca sub %ecx,%edx sizeof(rtems_libio_t)); if (rtems_libio_iops == NULL) rtems_fatal_error_occurred(RTEMS_NO_MEMORY); iop = rtems_libio_iop_freelist = rtems_libio_iops; for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++) 108207: 8d 14 10 lea (%eax,%edx,1),%edx iop->data1 = iop + 1; iop->data1 = NULL; 10820a: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx) /* * Create the binary semaphore used to provide mutual exclusion * on the IOP Table. */ rc = rtems_semaphore_create( 108211: 83 ec 0c sub $0xc,%esp 108214: 68 28 7c 12 00 push $0x127c28 108219: 6a 00 push $0x0 10821b: 6a 54 push $0x54 10821d: 6a 01 push $0x1 10821f: 68 4f 49 42 4c push $0x4c42494f 108224: e8 0b 32 00 00 call 10b434 1, RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &rtems_libio_semaphore ); if ( rc != RTEMS_SUCCESSFUL ) 108229: 83 c4 20 add $0x20,%esp 10822c: 85 c0 test %eax,%eax 10822e: 75 15 jne 108245 <== NEVER TAKEN /* * Initialize the base file system infrastructure. */ if (rtems_fs_init_helper) 108230: a1 68 39 12 00 mov 0x123968,%eax 108235: 85 c0 test %eax,%eax 108237: 74 07 je 108240 <== NEVER TAKEN (* rtems_fs_init_helper)(); } 108239: 8b 5d fc mov -0x4(%ebp),%ebx 10823c: c9 leave /* * Initialize the base file system infrastructure. */ if (rtems_fs_init_helper) (* rtems_fs_init_helper)(); 10823d: ff e0 jmp *%eax 10823f: 90 nop } 108240: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 108243: c9 leave <== NOT EXECUTED 108244: c3 ret <== NOT EXECUTED RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &rtems_libio_semaphore ); if ( rc != RTEMS_SUCCESSFUL ) rtems_fatal_error_occurred( rc ); 108245: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108248: 50 push %eax <== NOT EXECUTED 108249: e8 a6 3a 00 00 call 10bcf4 <== NOT EXECUTED if (rtems_libio_number_iops > 0) { rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops, sizeof(rtems_libio_t)); if (rtems_libio_iops == NULL) rtems_fatal_error_occurred(RTEMS_NO_MEMORY); 10824e: 83 ec 0c sub $0xc,%esp 108251: 6a 1a push $0x1a 108253: e8 9c 3a 00 00 call 10bcf4 =============================================================================== 0010ff68 : */ int rtems_libio_is_file_open( void *node_access ) { 10ff68: 55 push %ebp 10ff69: 89 e5 mov %esp,%ebp 10ff6b: 53 push %ebx 10ff6c: 83 ec 08 sub $0x8,%esp 10ff6f: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_status_code rtems_libio_set_private_env(void); rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ; static inline void rtems_libio_lock( void ) { rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); 10ff72: 6a 00 push $0x0 10ff74: 6a 00 push $0x0 10ff76: ff 35 28 7c 12 00 pushl 0x127c28 10ff7c: e8 2f b7 ff ff call 10b6b0 /* * Look for any active file descriptor entry. */ for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){ 10ff81: a1 20 7c 12 00 mov 0x127c20,%eax 10ff86: 8b 0d 6c 39 12 00 mov 0x12396c,%ecx 10ff8c: 83 c4 10 add $0x10,%esp 10ff8f: 85 c9 test %ecx,%ecx 10ff91: 74 18 je 10ffab <== NEVER TAKEN 10ff93: 31 d2 xor %edx,%edx 10ff95: eb 04 jmp 10ff9b 10ff97: 90 nop 10ff98: 83 c0 38 add $0x38,%eax if ((iop->flags & LIBIO_FLAGS_OPEN) != 0) { 10ff9b: f6 40 15 01 testb $0x1,0x15(%eax) 10ff9f: 74 05 je 10ffa6 /* * Check if this node is under the file system that we * are trying to dismount. */ if ( iop->pathinfo.node_access == node_access ) { 10ffa1: 39 58 18 cmp %ebx,0x18(%eax) 10ffa4: 74 1e je 10ffc4 /* * Look for any active file descriptor entry. */ for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){ 10ffa6: 42 inc %edx 10ffa7: 39 ca cmp %ecx,%edx 10ffa9: 72 ed jb 10ff98 int rtems_libio_is_file_open( void *node_access ) { rtems_libio_t *iop; int result=0; 10ffab: 31 db xor %ebx,%ebx } static inline void rtems_libio_unlock( void ) { rtems_semaphore_release( rtems_libio_semaphore ); 10ffad: 83 ec 0c sub $0xc,%esp 10ffb0: ff 35 28 7c 12 00 pushl 0x127c28 10ffb6: e8 f1 b7 ff ff call 10b7ac } rtems_libio_unlock(); return result; } 10ffbb: 89 d8 mov %ebx,%eax 10ffbd: 8b 5d fc mov -0x4(%ebp),%ebx 10ffc0: c9 leave 10ffc1: c3 ret 10ffc2: 66 90 xchg %ax,%ax * Check if this node is under the file system that we * are trying to dismount. */ if ( iop->pathinfo.node_access == node_access ) { result = 1; 10ffc4: bb 01 00 00 00 mov $0x1,%ebx 10ffc9: eb e2 jmp 10ffad =============================================================================== 0010ff04 : */ int rtems_libio_is_open_files_in_fs( rtems_filesystem_mount_table_entry_t * fs_mt_entry ) { 10ff04: 55 push %ebp 10ff05: 89 e5 mov %esp,%ebp 10ff07: 53 push %ebx 10ff08: 83 ec 08 sub $0x8,%esp 10ff0b: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_status_code rtems_libio_set_private_env(void); rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ; static inline void rtems_libio_lock( void ) { rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); 10ff0e: 6a 00 push $0x0 10ff10: 6a 00 push $0x0 10ff12: ff 35 28 7c 12 00 pushl 0x127c28 10ff18: e8 93 b7 ff ff call 10b6b0 /* * Look for any active file descriptor entry. */ for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){ 10ff1d: a1 20 7c 12 00 mov 0x127c20,%eax 10ff22: 8b 0d 6c 39 12 00 mov 0x12396c,%ecx 10ff28: 83 c4 10 add $0x10,%esp 10ff2b: 85 c9 test %ecx,%ecx 10ff2d: 74 18 je 10ff47 <== NEVER TAKEN 10ff2f: 31 d2 xor %edx,%edx 10ff31: eb 04 jmp 10ff37 10ff33: 90 nop 10ff34: 83 c0 38 add $0x38,%eax if ((iop->flags & LIBIO_FLAGS_OPEN) != 0) { 10ff37: f6 40 15 01 testb $0x1,0x15(%eax) 10ff3b: 74 05 je 10ff42 /* * Check if this node is under the file system that we * are trying to dismount. */ if ( iop->pathinfo.mt_entry == fs_mt_entry ) { 10ff3d: 39 58 28 cmp %ebx,0x28(%eax) 10ff40: 74 1e je 10ff60 /* * Look for any active file descriptor entry. */ for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){ 10ff42: 42 inc %edx 10ff43: 39 ca cmp %ecx,%edx 10ff45: 72 ed jb 10ff34 int rtems_libio_is_open_files_in_fs( rtems_filesystem_mount_table_entry_t * fs_mt_entry ) { rtems_libio_t *iop; int result = 0; 10ff47: 31 db xor %ebx,%ebx } static inline void rtems_libio_unlock( void ) { rtems_semaphore_release( rtems_libio_semaphore ); 10ff49: 83 ec 0c sub $0xc,%esp 10ff4c: ff 35 28 7c 12 00 pushl 0x127c28 10ff52: e8 55 b8 ff ff call 10b7ac } rtems_libio_unlock(); return result; } 10ff57: 89 d8 mov %ebx,%eax 10ff59: 8b 5d fc mov -0x4(%ebp),%ebx 10ff5c: c9 leave 10ff5d: c3 ret 10ff5e: 66 90 xchg %ax,%ax * Check if this node is under the file system that we * are trying to dismount. */ if ( iop->pathinfo.mt_entry == fs_mt_entry ) { result = 1; 10ff60: bb 01 00 00 00 mov $0x1,%ebx 10ff65: eb e2 jmp 10ff49 =============================================================================== 00109590 : rtems_status_code rtems_libio_set_private_env(void) { 109590: 55 push %ebp 109591: 89 e5 mov %esp,%ebp 109593: 57 push %edi 109594: 56 push %esi 109595: 53 push %ebx 109596: 83 ec 5c sub $0x5c,%esp rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_id task_id = rtems_task_self(); 109599: e8 0e 2e 00 00 call 10c3ac 10959e: 89 45 b4 mov %eax,-0x4c(%ebp) rtems_filesystem_location_info_t root_loc; rtems_filesystem_location_info_t current_loc; rtems_user_env_t *new_env = NULL; int rv = 0; rv = rtems_filesystem_evaluate_path("/", 1, 0, &root_loc, 0); 1095a1: 83 ec 0c sub $0xc,%esp 1095a4: 6a 00 push $0x0 1095a6: 8d 5d d4 lea -0x2c(%ebp),%ebx 1095a9: 53 push %ebx 1095aa: 6a 00 push $0x0 1095ac: 6a 01 push $0x1 1095ae: 68 47 1c 12 00 push $0x121c47 1095b3: e8 50 ee ff ff call 108408 if (rv != 0) 1095b8: 83 c4 20 add $0x20,%esp 1095bb: 85 c0 test %eax,%eax 1095bd: 74 0d je 1095cc <== ALWAYS TAKEN error_1: rtems_filesystem_freenode(&root_loc); error_0: return RTEMS_NO_MEMORY; 1095bf: b8 1a 00 00 00 mov $0x1a,%eax } 1095c4: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1095c7: 5b pop %ebx <== NOT EXECUTED 1095c8: 5e pop %esi <== NOT EXECUTED 1095c9: 5f pop %edi <== NOT EXECUTED 1095ca: c9 leave <== NOT EXECUTED 1095cb: c3 ret <== NOT EXECUTED rv = rtems_filesystem_evaluate_path("/", 1, 0, &root_loc, 0); if (rv != 0) goto error_0; rv = rtems_filesystem_evaluate_path("/", 1, 0, ¤t_loc, 0); 1095cc: 83 ec 0c sub $0xc,%esp 1095cf: 6a 00 push $0x0 1095d1: 8d 45 c0 lea -0x40(%ebp),%eax 1095d4: 89 45 a4 mov %eax,-0x5c(%ebp) 1095d7: 50 push %eax 1095d8: 6a 00 push $0x0 1095da: 6a 01 push $0x1 1095dc: 68 47 1c 12 00 push $0x121c47 1095e1: e8 22 ee ff ff call 108408 if (rv != 0) 1095e6: 83 c4 20 add $0x20,%esp 1095e9: 85 c0 test %eax,%eax 1095eb: 0f 85 9a 00 00 00 jne 10968b <== NEVER TAKEN * Bharath: I'm not sure if the check can be reduced to * if( rtems_current_user_env->task_id != task_id ) { */ if ( rtems_current_user_env == &rtems_global_user_env 1095f1: 8b 15 d0 62 12 00 mov 0x1262d0,%edx /* * Bharath: I'm not sure if the check can be reduced to * if( rtems_current_user_env->task_id != task_id ) { */ if ( 1095f7: 81 fa c0 85 12 00 cmp $0x1285c0,%edx 1095fd: 74 07 je 109606 rtems_current_user_env == &rtems_global_user_env || rtems_current_user_env->task_id != task_id 1095ff: 8b 45 b4 mov -0x4c(%ebp),%eax 109602: 39 02 cmp %eax,(%edx) 109604: 74 3a je 109640 ) { new_env = malloc(sizeof(rtems_user_env_t)); 109606: 83 ec 0c sub $0xc,%esp 109609: 6a 48 push $0x48 10960b: e8 14 f4 ff ff call 108a24 109610: 89 c2 mov %eax,%edx 109612: 89 c6 mov %eax,%esi if (new_env == NULL) 109614: 83 c4 10 add $0x10,%esp 109617: 85 c0 test %eax,%eax 109619: 74 61 je 10967c #ifdef HAVE_USERENV_REFCNT new_env->refcnt = 1; #endif sc = rtems_task_variable_add( 10961b: 50 push %eax 10961c: 68 50 95 10 00 push $0x109550 109621: 68 d0 62 12 00 push $0x1262d0 109626: 6a 00 push $0x0 109628: 89 55 b0 mov %edx,-0x50(%ebp) 10962b: e8 00 2e 00 00 call 10c430 RTEMS_SELF, (void*)&rtems_current_user_env, (void(*)(void *))free_user_env ); if (sc != RTEMS_SUCCESSFUL) 109630: 83 c4 10 add $0x10,%esp 109633: 85 c0 test %eax,%eax 109635: 8b 55 b0 mov -0x50(%ebp),%edx 109638: 75 36 jne 109670 goto error_3; rtems_current_user_env = new_env; 10963a: 89 15 d0 62 12 00 mov %edx,0x1262d0 } /* Inherit the global values */ *rtems_current_user_env = rtems_global_user_env; 109640: be c0 85 12 00 mov $0x1285c0,%esi 109645: b9 12 00 00 00 mov $0x12,%ecx 10964a: 89 d7 mov %edx,%edi 10964c: f3 a5 rep movsl %ds:(%esi),%es:(%edi) rtems_current_user_env->task_id = task_id; 10964e: 8b 75 b4 mov -0x4c(%ebp),%esi 109651: 89 32 mov %esi,(%edx) * Clone the pathlocs. In contrast to most other code we must _not_ free the * original locs because what we are trying to do here is forking off clones. * The reason is a pathloc can be allocated by the file system and needs to * be freed when deleting the environment. */ rtems_filesystem_root = root_loc; 109653: 8d 7a 18 lea 0x18(%edx),%edi 109656: b1 05 mov $0x5,%cl 109658: 89 de mov %ebx,%esi 10965a: f3 a5 rep movsl %ds:(%esi),%es:(%edi) rtems_filesystem_current = current_loc; 10965c: 8d 7a 04 lea 0x4(%edx),%edi 10965f: b1 05 mov $0x5,%cl 109661: 8b 75 a4 mov -0x5c(%ebp),%esi 109664: f3 a5 rep movsl %ds:(%esi),%es:(%edi) return RTEMS_SUCCESSFUL; 109666: 31 c0 xor %eax,%eax error_1: rtems_filesystem_freenode(&root_loc); error_0: return RTEMS_NO_MEMORY; } 109668: 8d 65 f4 lea -0xc(%ebp),%esp 10966b: 5b pop %ebx 10966c: 5e pop %esi 10966d: 5f pop %edi 10966e: c9 leave 10966f: c3 ret rtems_filesystem_current = current_loc; return RTEMS_SUCCESSFUL; error_3: free(new_env); 109670: 83 ec 0c sub $0xc,%esp 109673: 56 push %esi 109674: e8 7b ee ff ff call 1084f4 109679: 83 c4 10 add $0x10,%esp error_2: rtems_filesystem_freenode(¤t_loc); 10967c: 83 ec 0c sub $0xc,%esp 10967f: 8d 45 c0 lea -0x40(%ebp),%eax 109682: 50 push %eax 109683: e8 58 ee ff ff call 1084e0 109688: 83 c4 10 add $0x10,%esp error_1: rtems_filesystem_freenode(&root_loc); 10968b: 83 ec 0c sub $0xc,%esp 10968e: 53 push %ebx 10968f: e8 4c ee ff ff call 1084e0 109694: 83 c4 10 add $0x10,%esp error_0: return RTEMS_NO_MEMORY; 109697: b8 1a 00 00 00 mov $0x1a,%eax } 10969c: 8d 65 f4 lea -0xc(%ebp),%esp 10969f: 5b pop %ebx 1096a0: 5e pop %esi 1096a1: 5f pop %edi 1096a2: c9 leave 1096a3: c3 ret =============================================================================== 001096a4 : * b) mutex access to rtems_filesystem_current, rtems_filesytem_root * while changing any of those (chdir(), chroot()). */ rtems_status_code rtems_libio_share_private_env(rtems_id task_id) { 1096a4: 55 push %ebp 1096a5: 89 e5 mov %esp,%ebp 1096a7: 56 push %esi 1096a8: 53 push %ebx 1096a9: 83 ec 20 sub $0x20,%esp 1096ac: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_id current_task_id; /* * get current task id */ current_task_id = rtems_task_self(); 1096af: e8 f8 2c 00 00 call 10c3ac 1096b4: 89 c6 mov %eax,%esi /* * If this was an attempt to share the task with self, * if somebody wanted to do it... Lets tell them, its shared */ if( task_id == current_task_id ) 1096b6: 39 c3 cmp %eax,%ebx 1096b8: 74 32 je 1096ec <== NEVER TAKEN return RTEMS_SUCCESSFUL; /* * Try to get the requested user environment */ sc = rtems_task_variable_get( 1096ba: 52 push %edx task_id, (void*)&rtems_current_user_env, (void*)&shared_user_env ); 1096bb: 8d 45 f4 lea -0xc(%ebp),%eax if( task_id == current_task_id ) return RTEMS_SUCCESSFUL; /* * Try to get the requested user environment */ sc = rtems_task_variable_get( 1096be: 50 push %eax 1096bf: 68 d0 62 12 00 push $0x1262d0 1096c4: 53 push %ebx 1096c5: e8 2a 2e 00 00 call 10c4f4 (void*)&shared_user_env ); /* * If it was not successful, return the error code */ if (sc != RTEMS_SUCCESSFUL) 1096ca: 83 c4 10 add $0x10,%esp 1096cd: 85 c0 test %eax,%eax 1096cf: 75 13 jne 1096e4 * If we have a current environment in place, we need to * free it, since we will be sharing the variable with the * shared_user_env */ if (rtems_current_user_env->task_id==current_task_id) { 1096d1: 8b 15 d0 62 12 00 mov 0x1262d0,%edx 1096d7: 39 32 cmp %esi,(%edx) 1096d9: 74 1d je 1096f8 rtems_user_env_t *tmp = rtems_current_user_env; free_user_env( tmp ); } /* the current_user_env is the same pointer that remote env */ rtems_current_user_env = shared_user_env; 1096db: 8b 55 f4 mov -0xc(%ebp),%edx 1096de: 89 15 d0 62 12 00 mov %edx,0x1262d0 #ifdef HAVE_USERENV_REFCNT rtems_current_user_env->refcnt++; #endif return RTEMS_SUCCESSFUL; } 1096e4: 8d 65 f8 lea -0x8(%ebp),%esp 1096e7: 5b pop %ebx 1096e8: 5e pop %esi 1096e9: c9 leave 1096ea: c3 ret 1096eb: 90 nop * If this was an attempt to share the task with self, * if somebody wanted to do it... Lets tell them, its shared */ if( task_id == current_task_id ) return RTEMS_SUCCESSFUL; 1096ec: 31 c0 xor %eax,%eax #ifdef HAVE_USERENV_REFCNT rtems_current_user_env->refcnt++; #endif return RTEMS_SUCCESSFUL; } 1096ee: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1096f1: 5b pop %ebx <== NOT EXECUTED 1096f2: 5e pop %esi <== NOT EXECUTED 1096f3: c9 leave <== NOT EXECUTED 1096f4: c3 ret <== NOT EXECUTED 1096f5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED * shared_user_env */ if (rtems_current_user_env->task_id==current_task_id) { rtems_user_env_t *tmp = rtems_current_user_env; free_user_env( tmp ); 1096f8: 83 ec 0c sub $0xc,%esp 1096fb: 52 push %edx 1096fc: 89 45 e4 mov %eax,-0x1c(%ebp) 1096ff: e8 4c fe ff ff call 109550 109704: 83 c4 10 add $0x10,%esp 109707: 8b 45 e4 mov -0x1c(%ebp),%eax 10970a: eb cf jmp 1096db =============================================================================== 0010fdc4 : */ uint32_t rtems_libio_to_fcntl_flags( uint32_t flags ) { 10fdc4: 55 push %ebp 10fdc5: 89 e5 mov %esp,%ebp 10fdc7: 8b 55 08 mov 0x8(%ebp),%edx uint32_t fcntl_flags = 0; if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) { 10fdca: 89 d0 mov %edx,%eax 10fdcc: 83 e0 06 and $0x6,%eax 10fdcf: 83 f8 06 cmp $0x6,%eax 10fdd2: 74 2c je 10fe00 fcntl_flags |= O_RDWR; } else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) { 10fdd4: f6 c2 02 test $0x2,%dl 10fdd7: 75 23 jne 10fdfc <== ALWAYS TAKEN ) { uint32_t fcntl_flags = 0; if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) { fcntl_flags |= O_RDWR; 10fdd9: 31 c0 xor %eax,%eax 10fddb: f6 c2 04 test $0x4,%dl <== NOT EXECUTED 10fdde: 0f 95 c0 setne %al <== NOT EXECUTED fcntl_flags |= O_RDONLY; } else if ( (flags & LIBIO_FLAGS_WRITE) == LIBIO_FLAGS_WRITE) { fcntl_flags |= O_WRONLY; } if ( (flags & LIBIO_FLAGS_NO_DELAY) == LIBIO_FLAGS_NO_DELAY ) { 10fde1: f6 c2 01 test $0x1,%dl 10fde4: 74 03 je 10fde9 fcntl_flags |= O_NONBLOCK; 10fde6: 80 cc 40 or $0x40,%ah } if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) { 10fde9: f6 c6 02 test $0x2,%dh 10fdec: 74 03 je 10fdf1 fcntl_flags |= O_APPEND; 10fdee: 83 c8 08 or $0x8,%eax } if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) { 10fdf1: 80 e6 04 and $0x4,%dh 10fdf4: 74 03 je 10fdf9 fcntl_flags |= O_CREAT; 10fdf6: 80 cc 02 or $0x2,%ah } return fcntl_flags; } 10fdf9: c9 leave 10fdfa: c3 ret 10fdfb: 90 nop uint32_t fcntl_flags = 0; if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) { fcntl_flags |= O_RDWR; } else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) { fcntl_flags |= O_RDONLY; 10fdfc: 31 c0 xor %eax,%eax 10fdfe: eb e1 jmp 10fde1 ) { uint32_t fcntl_flags = 0; if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) { fcntl_flags |= O_RDWR; 10fe00: b8 02 00 00 00 mov $0x2,%eax 10fe05: eb da jmp 10fde1 =============================================================================== 0010af10 : * size and thus we skip updating the statistics. */ static void rtems_malloc_statistics_at_free( void *pointer ) { 10af10: 55 push %ebp 10af11: 89 e5 mov %esp,%ebp 10af13: 83 ec 1c sub $0x1c,%esp uintptr_t size; if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) { 10af16: 8d 45 f4 lea -0xc(%ebp),%eax 10af19: 50 push %eax 10af1a: ff 75 08 pushl 0x8(%ebp) 10af1d: ff 35 b0 a5 12 00 pushl 0x12a5b0 10af23: e8 d0 5b 00 00 call 110af8 <_Protected_heap_Get_block_size> 10af28: 83 c4 10 add $0x10,%esp 10af2b: 84 c0 test %al,%al 10af2d: 74 11 je 10af40 <== NEVER TAKEN MSBUMP(lifetime_freed, size); 10af2f: 8b 45 f4 mov -0xc(%ebp),%eax 10af32: 31 d2 xor %edx,%edx 10af34: 01 05 a4 f1 12 00 add %eax,0x12f1a4 10af3a: 11 15 a8 f1 12 00 adc %edx,0x12f1a8 } } 10af40: c9 leave 10af41: c3 ret =============================================================================== 0010af44 : } static void rtems_malloc_statistics_at_malloc( void *pointer ) { 10af44: 55 push %ebp 10af45: 89 e5 mov %esp,%ebp 10af47: 83 ec 18 sub $0x18,%esp 10af4a: 8b 45 08 mov 0x8(%ebp),%eax uintptr_t actual_size = 0; 10af4d: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) uint32_t current_depth; rtems_malloc_statistics_t *s = &rtems_malloc_statistics; if ( !pointer ) 10af54: 85 c0 test %eax,%eax 10af56: 74 43 je 10af9b <== NEVER TAKEN return; _Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &actual_size); 10af58: 52 push %edx 10af59: 8d 55 f4 lea -0xc(%ebp),%edx 10af5c: 52 push %edx 10af5d: 50 push %eax 10af5e: ff 35 b0 a5 12 00 pushl 0x12a5b0 10af64: e8 8f 5b 00 00 call 110af8 <_Protected_heap_Get_block_size> MSBUMP(lifetime_allocated, actual_size); 10af69: 8b 45 f4 mov -0xc(%ebp),%eax 10af6c: 31 d2 xor %edx,%edx 10af6e: 03 05 9c f1 12 00 add 0x12f19c,%eax 10af74: 13 15 a0 f1 12 00 adc 0x12f1a0,%edx 10af7a: a3 9c f1 12 00 mov %eax,0x12f19c 10af7f: 89 15 a0 f1 12 00 mov %edx,0x12f1a0 current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed); 10af85: 2b 05 a4 f1 12 00 sub 0x12f1a4,%eax if (current_depth > s->max_depth) 10af8b: 83 c4 10 add $0x10,%esp 10af8e: 3b 05 98 f1 12 00 cmp 0x12f198,%eax 10af94: 76 05 jbe 10af9b s->max_depth = current_depth; 10af96: a3 98 f1 12 00 mov %eax,0x12f198 } 10af9b: c9 leave 10af9c: c3 ret =============================================================================== 00113dc8 : int rtems_memalign( void **pointer, size_t alignment, size_t size ) { 113dc8: 55 push %ebp 113dc9: 89 e5 mov %esp,%ebp 113dcb: 53 push %ebx 113dcc: 83 ec 14 sub $0x14,%esp 113dcf: 8b 5d 08 mov 0x8(%ebp),%ebx void *return_this; /* * Parameter error checks */ if ( !pointer ) 113dd2: 85 db test %ebx,%ebx 113dd4: 74 5b je 113e31 return EINVAL; *pointer = NULL; 113dd6: c7 03 00 00 00 00 movl $0x0,(%ebx) /* * Do not attempt to allocate memory if not in correct system state. */ if ( _System_state_Is_up(_System_state_Get()) && 113ddc: 83 3d 20 bc 12 00 03 cmpl $0x3,0x12bc20 113de3: 74 43 je 113e28 <== ALWAYS TAKEN return EINVAL; /* * If some free's have been deferred, then do them now. */ malloc_deferred_frees_process(); 113de5: e8 76 53 ff ff call 109160 Heap_Control *heap, uintptr_t size, uintptr_t alignment ) { return 113dea: 6a 00 push $0x0 113dec: ff 75 0c pushl 0xc(%ebp) 113def: ff 75 10 pushl 0x10(%ebp) 113df2: ff 35 f0 75 12 00 pushl 0x1275f0 113df8: e8 8b a5 ff ff call 10e388 <_Protected_heap_Allocate_aligned_with_boundary> return_this = _Protected_heap_Allocate_aligned( RTEMS_Malloc_Heap, size, alignment ); if ( !return_this ) 113dfd: 83 c4 10 add $0x10,%esp 113e00: 85 c0 test %eax,%eax 113e02: 74 38 je 113e3c return ENOMEM; /* * If configured, update the more involved statistics */ if ( rtems_malloc_statistics_helpers ) 113e04: 8b 15 48 9c 12 00 mov 0x129c48,%edx 113e0a: 85 d2 test %edx,%edx 113e0c: 74 10 je 113e1e (*rtems_malloc_statistics_helpers->at_malloc)(pointer); 113e0e: 83 ec 0c sub $0xc,%esp 113e11: 53 push %ebx 113e12: 89 45 f4 mov %eax,-0xc(%ebp) 113e15: ff 52 04 call *0x4(%edx) 113e18: 83 c4 10 add $0x10,%esp 113e1b: 8b 45 f4 mov -0xc(%ebp),%eax *pointer = return_this; 113e1e: 89 03 mov %eax,(%ebx) return 0; 113e20: 31 c0 xor %eax,%eax } 113e22: 8b 5d fc mov -0x4(%ebp),%ebx 113e25: c9 leave 113e26: c3 ret 113e27: 90 nop /* * Do not attempt to allocate memory if not in correct system state. */ if ( _System_state_Is_up(_System_state_Get()) && !malloc_is_system_state_OK() ) 113e28: e8 f3 52 ff ff call 109120 *pointer = NULL; /* * Do not attempt to allocate memory if not in correct system state. */ if ( _System_state_Is_up(_System_state_Get()) && 113e2d: 84 c0 test %al,%al 113e2f: 75 b4 jne 113de5 <== ALWAYS TAKEN !malloc_is_system_state_OK() ) return EINVAL; 113e31: b8 16 00 00 00 mov $0x16,%eax if ( rtems_malloc_statistics_helpers ) (*rtems_malloc_statistics_helpers->at_malloc)(pointer); *pointer = return_this; return 0; } 113e36: 8b 5d fc mov -0x4(%ebp),%ebx 113e39: c9 leave 113e3a: c3 ret 113e3b: 90 nop RTEMS_Malloc_Heap, size, alignment ); if ( !return_this ) return ENOMEM; 113e3c: b8 0c 00 00 00 mov $0xc,%eax 113e41: eb df jmp 113e22 =============================================================================== 001163bc : rtems_id id, const void *buffer, size_t size, uint32_t *count ) { 1163bc: 55 push %ebp 1163bd: 89 e5 mov %esp,%ebp 1163bf: 57 push %edi 1163c0: 56 push %esi 1163c1: 53 push %ebx 1163c2: 83 ec 1c sub $0x1c,%esp 1163c5: 8b 7d 08 mov 0x8(%ebp),%edi 1163c8: 8b 5d 0c mov 0xc(%ebp),%ebx 1163cb: 8b 75 14 mov 0x14(%ebp),%esi register Message_queue_Control *the_message_queue; Objects_Locations location; CORE_message_queue_Status core_status; if ( !buffer ) 1163ce: 85 db test %ebx,%ebx 1163d0: 74 62 je 116434 return RTEMS_INVALID_ADDRESS; if ( !count ) 1163d2: 85 f6 test %esi,%esi 1163d4: 74 5e je 116434 Objects_Id id, Objects_Locations *location ) { return (Message_queue_Control *) _Objects_Get( &_Message_queue_Information, id, location ); 1163d6: 51 push %ecx return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); 1163d7: 8d 45 e4 lea -0x1c(%ebp),%eax 1163da: 50 push %eax 1163db: 57 push %edi 1163dc: 68 20 34 14 00 push $0x143420 1163e1: e8 f6 4e 00 00 call 11b2dc <_Objects_Get> switch ( location ) { 1163e6: 83 c4 10 add $0x10,%esp 1163e9: 8b 55 e4 mov -0x1c(%ebp),%edx 1163ec: 85 d2 test %edx,%edx 1163ee: 74 10 je 116400 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 1163f0: b8 04 00 00 00 mov $0x4,%eax } 1163f5: 8d 65 f4 lea -0xc(%ebp),%esp 1163f8: 5b pop %ebx 1163f9: 5e pop %esi 1163fa: 5f pop %edi 1163fb: c9 leave 1163fc: c3 ret 1163fd: 8d 76 00 lea 0x0(%esi),%esi the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: core_status = _CORE_message_queue_Broadcast( 116400: 83 ec 08 sub $0x8,%esp 116403: 56 push %esi 116404: 6a 00 push $0x0 116406: 57 push %edi 116407: ff 75 10 pushl 0x10(%ebp) 11640a: 53 push %ebx 11640b: 83 c0 14 add $0x14,%eax 11640e: 50 push %eax 11640f: e8 c8 34 00 00 call 1198dc <_CORE_message_queue_Broadcast> 116414: 89 c3 mov %eax,%ebx NULL, #endif count ); _Thread_Enable_dispatch(); 116416: 83 c4 20 add $0x20,%esp 116419: e8 36 5a 00 00 call 11be54 <_Thread_Enable_dispatch> return 11641e: 83 ec 0c sub $0xc,%esp 116421: 53 push %ebx 116422: e8 69 03 00 00 call 116790 <_Message_queue_Translate_core_message_queue_return_code> 116427: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11642a: 8d 65 f4 lea -0xc(%ebp),%esp 11642d: 5b pop %ebx 11642e: 5e pop %esi 11642f: 5f pop %edi 116430: c9 leave 116431: c3 ret 116432: 66 90 xchg %ax,%ax if ( !buffer ) return RTEMS_INVALID_ADDRESS; if ( !count ) return RTEMS_INVALID_ADDRESS; 116434: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 116439: 8d 65 f4 lea -0xc(%ebp),%esp 11643c: 5b pop %ebx 11643d: 5e pop %esi 11643e: 5f pop %edi 11643f: c9 leave 116440: c3 ret =============================================================================== 00113858 : uint32_t count, size_t max_message_size, rtems_attribute attribute_set, rtems_id *id ) { 113858: 55 push %ebp 113859: 89 e5 mov %esp,%ebp 11385b: 57 push %edi 11385c: 56 push %esi 11385d: 53 push %ebx 11385e: 83 ec 2c sub $0x2c,%esp 113861: 8b 5d 08 mov 0x8(%ebp),%ebx 113864: 8b 75 0c mov 0xc(%ebp),%esi 113867: 8b 4d 10 mov 0x10(%ebp),%ecx 11386a: 8b 7d 18 mov 0x18(%ebp),%edi CORE_message_queue_Attributes the_msgq_attributes; #if defined(RTEMS_MULTIPROCESSING) bool is_global; #endif if ( !rtems_is_name_valid( name ) ) 11386d: 85 db test %ebx,%ebx 11386f: 74 2f je 1138a0 return RTEMS_INVALID_NAME; if ( !id ) 113871: 85 ff test %edi,%edi 113873: 0f 84 a3 00 00 00 je 11391c if ( (is_global = _Attributes_Is_global( attribute_set ) ) && !_System_state_Is_multiprocessing ) return RTEMS_MP_NOT_CONFIGURED; #endif if ( count == 0 ) 113879: 85 f6 test %esi,%esi 11387b: 74 13 je 113890 return RTEMS_INVALID_NUMBER; if ( max_message_size == 0 ) 11387d: 85 c9 test %ecx,%ecx 11387f: 75 2f jne 1138b0 return RTEMS_INVALID_SIZE; 113881: b8 08 00 00 00 mov $0x8,%eax ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 113886: 8d 65 f4 lea -0xc(%ebp),%esp 113889: 5b pop %ebx 11388a: 5e pop %esi 11388b: 5f pop %edi 11388c: c9 leave 11388d: c3 ret 11388e: 66 90 xchg %ax,%ax !_System_state_Is_multiprocessing ) return RTEMS_MP_NOT_CONFIGURED; #endif if ( count == 0 ) return RTEMS_INVALID_NUMBER; 113890: b8 0a 00 00 00 mov $0xa,%eax ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 113895: 8d 65 f4 lea -0xc(%ebp),%esp 113898: 5b pop %ebx 113899: 5e pop %esi 11389a: 5f pop %edi 11389b: c9 leave 11389c: c3 ret 11389d: 8d 76 00 lea 0x0(%esi),%esi #if defined(RTEMS_MULTIPROCESSING) bool is_global; #endif if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 1138a0: b8 03 00 00 00 mov $0x3,%eax ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 1138a5: 8d 65 f4 lea -0xc(%ebp),%esp 1138a8: 5b pop %ebx 1138a9: 5e pop %esi 1138aa: 5f pop %edi 1138ab: c9 leave 1138ac: c3 ret 1138ad: 8d 76 00 lea 0x0(%esi),%esi rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 1138b0: a1 30 07 13 00 mov 0x130730,%eax 1138b5: 40 inc %eax 1138b6: a3 30 07 13 00 mov %eax,0x130730 #endif #endif _Thread_Disable_dispatch(); /* protects object pointer */ the_message_queue = _Message_queue_Allocate(); 1138bb: 89 4d d4 mov %ecx,-0x2c(%ebp) 1138be: e8 09 60 00 00 call 1198cc <_Message_queue_Allocate> 1138c3: 89 c2 mov %eax,%edx if ( !the_message_queue ) { 1138c5: 85 c0 test %eax,%eax 1138c7: 8b 4d d4 mov -0x2c(%ebp),%ecx 1138ca: 74 7c je 113948 _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_message_queue->attribute_set = attribute_set; 1138cc: 8b 45 14 mov 0x14(%ebp),%eax 1138cf: 89 42 10 mov %eax,0x10(%edx) if (_Attributes_Is_priority( attribute_set ) ) the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY; 1138d2: a8 04 test $0x4,%al 1138d4: 0f 95 c0 setne %al 1138d7: 0f b6 c0 movzbl %al,%eax 1138da: 89 45 e4 mov %eax,-0x1c(%ebp) else the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO; if ( ! _CORE_message_queue_Initialize( 1138dd: 51 push %ecx 1138de: 56 push %esi 1138df: 8d 45 e4 lea -0x1c(%ebp),%eax 1138e2: 50 push %eax 1138e3: 8d 42 14 lea 0x14(%edx),%eax 1138e6: 50 push %eax 1138e7: 89 55 d4 mov %edx,-0x2c(%ebp) 1138ea: e8 2d 11 00 00 call 114a1c <_CORE_message_queue_Initialize> 1138ef: 83 c4 10 add $0x10,%esp 1138f2: 84 c0 test %al,%al 1138f4: 8b 55 d4 mov -0x2c(%ebp),%edx 1138f7: 75 2f jne 113928 */ RTEMS_INLINE_ROUTINE void _Message_queue_Free ( Message_queue_Control *the_message_queue ) { _Objects_Free( &_Message_queue_Information, &the_message_queue->Object ); 1138f9: 83 ec 08 sub $0x8,%esp 1138fc: 52 push %edx 1138fd: 68 20 11 13 00 push $0x131120 113902: e8 b1 1f 00 00 call 1158b8 <_Objects_Free> _Objects_MP_Close( &_Message_queue_Information, the_message_queue->Object.id); #endif _Message_queue_Free( the_message_queue ); _Thread_Enable_dispatch(); 113907: e8 e4 2c 00 00 call 1165f0 <_Thread_Enable_dispatch> return RTEMS_UNSATISFIED; 11390c: 83 c4 10 add $0x10,%esp 11390f: b8 0d 00 00 00 mov $0xd,%eax 113914: e9 6d ff ff ff jmp 113886 113919: 8d 76 00 lea 0x0(%esi),%esi if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !id ) return RTEMS_INVALID_ADDRESS; 11391c: b8 09 00 00 00 mov $0x9,%eax 113921: e9 60 ff ff ff jmp 113886 113926: 66 90 xchg %ax,%ax Objects_Name name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 113928: 8b 42 08 mov 0x8(%edx),%eax Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 11392b: 0f b7 f0 movzwl %ax,%esi #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 11392e: 8b 0d 3c 11 13 00 mov 0x13113c,%ecx 113934: 89 14 b1 mov %edx,(%ecx,%esi,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 113937: 89 5a 0c mov %ebx,0xc(%edx) &_Message_queue_Information, &the_message_queue->Object, (Objects_Name) name ); *id = the_message_queue->Object.id; 11393a: 89 07 mov %eax,(%edi) name, 0 ); #endif _Thread_Enable_dispatch(); 11393c: e8 af 2c 00 00 call 1165f0 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 113941: 31 c0 xor %eax,%eax 113943: e9 3e ff ff ff jmp 113886 _Thread_Disable_dispatch(); /* protects object pointer */ the_message_queue = _Message_queue_Allocate(); if ( !the_message_queue ) { _Thread_Enable_dispatch(); 113948: e8 a3 2c 00 00 call 1165f0 <_Thread_Enable_dispatch> return RTEMS_TOO_MANY; 11394d: b8 05 00 00 00 mov $0x5,%eax 113952: e9 2f ff ff ff jmp 113886 =============================================================================== 00116544 : */ rtems_status_code rtems_message_queue_delete( rtems_id id ) { 116544: 55 push %ebp 116545: 89 e5 mov %esp,%ebp 116547: 53 push %ebx 116548: 83 ec 18 sub $0x18,%esp register Message_queue_Control *the_message_queue; Objects_Locations location; the_message_queue = _Message_queue_Get( id, &location ); 11654b: 8d 45 f4 lea -0xc(%ebp),%eax Objects_Id id, Objects_Locations *location ) { return (Message_queue_Control *) _Objects_Get( &_Message_queue_Information, id, location ); 11654e: 50 push %eax 11654f: ff 75 08 pushl 0x8(%ebp) 116552: 68 20 34 14 00 push $0x143420 116557: e8 80 4d 00 00 call 11b2dc <_Objects_Get> 11655c: 89 c3 mov %eax,%ebx switch ( location ) { 11655e: 83 c4 10 add $0x10,%esp 116561: 8b 4d f4 mov -0xc(%ebp),%ecx 116564: 85 c9 test %ecx,%ecx 116566: 75 3c jne 1165a4 case OBJECTS_LOCAL: _Objects_Close( &_Message_queue_Information, 116568: 83 ec 08 sub $0x8,%esp 11656b: 50 push %eax 11656c: 68 20 34 14 00 push $0x143420 116571: e8 f2 48 00 00 call 11ae68 <_Objects_Close> &the_message_queue->Object ); _CORE_message_queue_Close( 116576: 83 c4 0c add $0xc,%esp 116579: 6a 05 push $0x5 11657b: 6a 00 push $0x0 11657d: 8d 43 14 lea 0x14(%ebx),%eax 116580: 50 push %eax 116581: e8 da 33 00 00 call 119960 <_CORE_message_queue_Close> */ RTEMS_INLINE_ROUTINE void _Message_queue_Free ( Message_queue_Control *the_message_queue ) { _Objects_Free( &_Message_queue_Information, &the_message_queue->Object ); 116586: 58 pop %eax 116587: 5a pop %edx 116588: 53 push %ebx 116589: 68 20 34 14 00 push $0x143420 11658e: e8 cd 4b 00 00 call 11b160 <_Objects_Free> 0, /* Not used */ 0 ); } #endif _Thread_Enable_dispatch(); 116593: e8 bc 58 00 00 call 11be54 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 116598: 83 c4 10 add $0x10,%esp 11659b: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11659d: 8b 5d fc mov -0x4(%ebp),%ebx 1165a0: c9 leave 1165a1: c3 ret 1165a2: 66 90 xchg %ax,%ax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 1165a4: b8 04 00 00 00 mov $0x4,%eax } 1165a9: 8b 5d fc mov -0x4(%ebp),%ebx 1165ac: c9 leave 1165ad: c3 ret =============================================================================== 001165b0 : rtems_status_code rtems_message_queue_flush( rtems_id id, uint32_t *count ) { 1165b0: 55 push %ebp 1165b1: 89 e5 mov %esp,%ebp 1165b3: 53 push %ebx 1165b4: 83 ec 14 sub $0x14,%esp 1165b7: 8b 5d 0c mov 0xc(%ebp),%ebx register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 1165ba: 85 db test %ebx,%ebx 1165bc: 74 46 je 116604 Objects_Id id, Objects_Locations *location ) { return (Message_queue_Control *) _Objects_Get( &_Message_queue_Information, id, location ); 1165be: 51 push %ecx return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); 1165bf: 8d 45 f4 lea -0xc(%ebp),%eax 1165c2: 50 push %eax 1165c3: ff 75 08 pushl 0x8(%ebp) 1165c6: 68 20 34 14 00 push $0x143420 1165cb: e8 0c 4d 00 00 call 11b2dc <_Objects_Get> switch ( location ) { 1165d0: 83 c4 10 add $0x10,%esp 1165d3: 8b 55 f4 mov -0xc(%ebp),%edx 1165d6: 85 d2 test %edx,%edx 1165d8: 74 0a je 1165e4 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 1165da: b8 04 00 00 00 mov $0x4,%eax } 1165df: 8b 5d fc mov -0x4(%ebp),%ebx 1165e2: c9 leave 1165e3: c3 ret the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: *count = _CORE_message_queue_Flush( &the_message_queue->message_queue ); 1165e4: 83 ec 0c sub $0xc,%esp 1165e7: 83 c0 14 add $0x14,%eax 1165ea: 50 push %eax 1165eb: e8 ac 33 00 00 call 11999c <_CORE_message_queue_Flush> 1165f0: 89 03 mov %eax,(%ebx) _Thread_Enable_dispatch(); 1165f2: e8 5d 58 00 00 call 11be54 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 1165f7: 83 c4 10 add $0x10,%esp 1165fa: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1165fc: 8b 5d fc mov -0x4(%ebp),%ebx 1165ff: c9 leave 116600: c3 ret 116601: 8d 76 00 lea 0x0(%esi),%esi { register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) return RTEMS_INVALID_ADDRESS; 116604: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 116609: 8b 5d fc mov -0x4(%ebp),%ebx 11660c: c9 leave 11660d: c3 ret =============================================================================== 00116610 : rtems_status_code rtems_message_queue_get_number_pending( rtems_id id, uint32_t *count ) { 116610: 55 push %ebp 116611: 89 e5 mov %esp,%ebp 116613: 53 push %ebx 116614: 83 ec 14 sub $0x14,%esp 116617: 8b 5d 0c mov 0xc(%ebp),%ebx register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 11661a: 85 db test %ebx,%ebx 11661c: 74 3a je 116658 11661e: 51 push %ecx return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); 11661f: 8d 45 f4 lea -0xc(%ebp),%eax 116622: 50 push %eax 116623: ff 75 08 pushl 0x8(%ebp) 116626: 68 20 34 14 00 push $0x143420 11662b: e8 ac 4c 00 00 call 11b2dc <_Objects_Get> switch ( location ) { 116630: 83 c4 10 add $0x10,%esp 116633: 8b 55 f4 mov -0xc(%ebp),%edx 116636: 85 d2 test %edx,%edx 116638: 74 0a je 116644 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 11663a: b8 04 00 00 00 mov $0x4,%eax } 11663f: 8b 5d fc mov -0x4(%ebp),%ebx 116642: c9 leave 116643: c3 ret the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: *count = the_message_queue->message_queue.number_of_pending_messages; 116644: 8b 40 5c mov 0x5c(%eax),%eax 116647: 89 03 mov %eax,(%ebx) _Thread_Enable_dispatch(); 116649: e8 06 58 00 00 call 11be54 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 11664e: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 116650: 8b 5d fc mov -0x4(%ebp),%ebx 116653: c9 leave 116654: c3 ret 116655: 8d 76 00 lea 0x0(%esi),%esi { register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) return RTEMS_INVALID_ADDRESS; 116658: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11665d: 8b 5d fc mov -0x4(%ebp),%ebx 116660: c9 leave 116661: c3 ret =============================================================================== 0011397c : void *buffer, size_t *size, rtems_option option_set, rtems_interval timeout ) { 11397c: 55 push %ebp 11397d: 89 e5 mov %esp,%ebp 11397f: 56 push %esi 113980: 53 push %ebx 113981: 83 ec 10 sub $0x10,%esp 113984: 8b 5d 0c mov 0xc(%ebp),%ebx 113987: 8b 75 10 mov 0x10(%ebp),%esi register Message_queue_Control *the_message_queue; Objects_Locations location; bool wait; if ( !buffer ) 11398a: 85 db test %ebx,%ebx 11398c: 74 6e je 1139fc return RTEMS_INVALID_ADDRESS; if ( !size ) 11398e: 85 f6 test %esi,%esi 113990: 74 6a je 1139fc Objects_Id id, Objects_Locations *location ) { return (Message_queue_Control *) _Objects_Get( &_Message_queue_Information, id, location ); 113992: 51 push %ecx return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); 113993: 8d 45 f4 lea -0xc(%ebp),%eax 113996: 50 push %eax 113997: ff 75 08 pushl 0x8(%ebp) 11399a: 68 20 11 13 00 push $0x131120 11399f: e8 54 20 00 00 call 1159f8 <_Objects_Get> switch ( location ) { 1139a4: 83 c4 10 add $0x10,%esp 1139a7: 8b 55 f4 mov -0xc(%ebp),%edx 1139aa: 85 d2 test %edx,%edx 1139ac: 75 42 jne 1139f0 if ( _Options_Is_no_wait( option_set ) ) wait = false; else wait = true; _CORE_message_queue_Seize( 1139ae: 83 ec 08 sub $0x8,%esp 1139b1: ff 75 18 pushl 0x18(%ebp) */ RTEMS_INLINE_ROUTINE bool _Options_Is_no_wait ( rtems_option option_set ) { return (option_set & RTEMS_NO_WAIT) ? true : false; 1139b4: 8b 55 14 mov 0x14(%ebp),%edx 1139b7: 83 e2 01 and $0x1,%edx 1139ba: 83 f2 01 xor $0x1,%edx 1139bd: 52 push %edx 1139be: 56 push %esi 1139bf: 53 push %ebx 1139c0: ff 70 08 pushl 0x8(%eax) 1139c3: 83 c0 14 add $0x14,%eax 1139c6: 50 push %eax 1139c7: e8 00 11 00 00 call 114acc <_CORE_message_queue_Seize> buffer, size, wait, timeout ); _Thread_Enable_dispatch(); 1139cc: 83 c4 20 add $0x20,%esp 1139cf: e8 1c 2c 00 00 call 1165f0 <_Thread_Enable_dispatch> return _Message_queue_Translate_core_message_queue_return_code( 1139d4: 83 ec 0c sub $0xc,%esp _Thread_Executing->Wait.return_code 1139d7: a1 d8 0c 13 00 mov 0x130cd8,%eax size, wait, timeout ); _Thread_Enable_dispatch(); return _Message_queue_Translate_core_message_queue_return_code( 1139dc: ff 70 34 pushl 0x34(%eax) 1139df: e8 a0 00 00 00 call 113a84 <_Message_queue_Translate_core_message_queue_return_code> 1139e4: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1139e7: 8d 65 f8 lea -0x8(%ebp),%esp 1139ea: 5b pop %ebx 1139eb: 5e pop %esi 1139ec: c9 leave 1139ed: c3 ret 1139ee: 66 90 xchg %ax,%ax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 1139f0: b8 04 00 00 00 mov $0x4,%eax } 1139f5: 8d 65 f8 lea -0x8(%ebp),%esp 1139f8: 5b pop %ebx 1139f9: 5e pop %esi 1139fa: c9 leave 1139fb: c3 ret if ( !buffer ) return RTEMS_INVALID_ADDRESS; if ( !size ) return RTEMS_INVALID_ADDRESS; 1139fc: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 113a01: 8d 65 f8 lea -0x8(%ebp),%esp 113a04: 5b pop %ebx 113a05: 5e pop %esi 113a06: c9 leave 113a07: c3 ret =============================================================================== 0010b3a8 : rtems_status_code rtems_message_queue_send( rtems_id id, const void *buffer, size_t size ) { 10b3a8: 55 push %ebp 10b3a9: 89 e5 mov %esp,%ebp 10b3ab: 56 push %esi 10b3ac: 53 push %ebx 10b3ad: 83 ec 10 sub $0x10,%esp 10b3b0: 8b 75 08 mov 0x8(%ebp),%esi 10b3b3: 8b 5d 0c mov 0xc(%ebp),%ebx register Message_queue_Control *the_message_queue; Objects_Locations location; CORE_message_queue_Status status; if ( !buffer ) 10b3b6: 85 db test %ebx,%ebx 10b3b8: 74 5e je 10b418 Objects_Id id, Objects_Locations *location ) { return (Message_queue_Control *) _Objects_Get( &_Message_queue_Information, id, location ); 10b3ba: 51 push %ecx return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); 10b3bb: 8d 45 f4 lea -0xc(%ebp),%eax 10b3be: 50 push %eax 10b3bf: 56 push %esi 10b3c0: 68 80 87 12 00 push $0x128780 10b3c5: e8 6e 1a 00 00 call 10ce38 <_Objects_Get> switch ( location ) { 10b3ca: 83 c4 10 add $0x10,%esp 10b3cd: 8b 55 f4 mov -0xc(%ebp),%edx 10b3d0: 85 d2 test %edx,%edx 10b3d2: 74 0c je 10b3e0 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10b3d4: b8 04 00 00 00 mov $0x4,%eax } 10b3d9: 8d 65 f8 lea -0x8(%ebp),%esp 10b3dc: 5b pop %ebx 10b3dd: 5e pop %esi 10b3de: c9 leave 10b3df: c3 ret CORE_message_queue_API_mp_support_callout api_message_queue_mp_support, bool wait, Watchdog_Interval timeout ) { return _CORE_message_queue_Submit( 10b3e0: 6a 00 push $0x0 10b3e2: 6a 00 push $0x0 10b3e4: 68 ff ff ff 7f push $0x7fffffff 10b3e9: 6a 00 push $0x0 10b3eb: 56 push %esi 10b3ec: ff 75 10 pushl 0x10(%ebp) 10b3ef: 53 push %ebx the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: status = _CORE_message_queue_Send( 10b3f0: 83 c0 14 add $0x14,%eax 10b3f3: 50 push %eax 10b3f4: e8 3f 0c 00 00 call 10c038 <_CORE_message_queue_Submit> 10b3f9: 89 c3 mov %eax,%ebx MESSAGE_QUEUE_MP_HANDLER, false, /* sender does not block */ 0 /* no timeout */ ); _Thread_Enable_dispatch(); 10b3fb: 83 c4 20 add $0x20,%esp 10b3fe: e8 ad 25 00 00 call 10d9b0 <_Thread_Enable_dispatch> /* * Since this API does not allow for blocking sends, we can directly * return the returned status. */ return _Message_queue_Translate_core_message_queue_return_code(status); 10b403: 83 ec 0c sub $0xc,%esp 10b406: 53 push %ebx 10b407: e8 18 00 00 00 call 10b424 <_Message_queue_Translate_core_message_queue_return_code> 10b40c: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b40f: 8d 65 f8 lea -0x8(%ebp),%esp 10b412: 5b pop %ebx 10b413: 5e pop %esi 10b414: c9 leave 10b415: c3 ret 10b416: 66 90 xchg %ax,%ax register Message_queue_Control *the_message_queue; Objects_Locations location; CORE_message_queue_Status status; if ( !buffer ) return RTEMS_INVALID_ADDRESS; 10b418: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b41d: 8d 65 f8 lea -0x8(%ebp),%esp 10b420: 5b pop %ebx 10b421: 5e pop %esi 10b422: c9 leave 10b423: c3 ret =============================================================================== 001167a0 : rtems_status_code rtems_message_queue_urgent( rtems_id id, const void *buffer, size_t size ) { 1167a0: 55 push %ebp 1167a1: 89 e5 mov %esp,%ebp 1167a3: 56 push %esi 1167a4: 53 push %ebx 1167a5: 83 ec 10 sub $0x10,%esp 1167a8: 8b 75 08 mov 0x8(%ebp),%esi 1167ab: 8b 5d 0c mov 0xc(%ebp),%ebx register Message_queue_Control *the_message_queue; Objects_Locations location; CORE_message_queue_Status status; if ( !buffer ) 1167ae: 85 db test %ebx,%ebx 1167b0: 74 5e je 116810 1167b2: 51 push %ecx return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); 1167b3: 8d 45 f4 lea -0xc(%ebp),%eax 1167b6: 50 push %eax 1167b7: 56 push %esi 1167b8: 68 20 34 14 00 push $0x143420 1167bd: e8 1a 4b 00 00 call 11b2dc <_Objects_Get> switch ( location ) { 1167c2: 83 c4 10 add $0x10,%esp 1167c5: 8b 55 f4 mov -0xc(%ebp),%edx 1167c8: 85 d2 test %edx,%edx 1167ca: 74 0c je 1167d8 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 1167cc: b8 04 00 00 00 mov $0x4,%eax } 1167d1: 8d 65 f8 lea -0x8(%ebp),%esp 1167d4: 5b pop %ebx 1167d5: 5e pop %esi 1167d6: c9 leave 1167d7: c3 ret CORE_message_queue_API_mp_support_callout api_message_queue_mp_support, bool wait, Watchdog_Interval timeout ) { return _CORE_message_queue_Submit( 1167d8: 6a 00 push $0x0 1167da: 6a 00 push $0x0 1167dc: 68 00 00 00 80 push $0x80000000 1167e1: 6a 00 push $0x0 1167e3: 56 push %esi 1167e4: ff 75 10 pushl 0x10(%ebp) 1167e7: 53 push %ebx the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: status = _CORE_message_queue_Urgent( 1167e8: 83 c0 14 add $0x14,%eax 1167eb: 50 push %eax 1167ec: e8 eb 33 00 00 call 119bdc <_CORE_message_queue_Submit> 1167f1: 89 c3 mov %eax,%ebx id, MESSAGE_QUEUE_MP_HANDLER, false, /* sender does not block */ 0 /* no timeout */ ); _Thread_Enable_dispatch(); 1167f3: 83 c4 20 add $0x20,%esp 1167f6: e8 59 56 00 00 call 11be54 <_Thread_Enable_dispatch> /* * Since this API does not allow for blocking sends, we can directly * return the returned status. */ return _Message_queue_Translate_core_message_queue_return_code(status); 1167fb: 83 ec 0c sub $0xc,%esp 1167fe: 53 push %ebx 1167ff: e8 8c ff ff ff call 116790 <_Message_queue_Translate_core_message_queue_return_code> 116804: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 116807: 8d 65 f8 lea -0x8(%ebp),%esp 11680a: 5b pop %ebx 11680b: 5e pop %esi 11680c: c9 leave 11680d: c3 ret 11680e: 66 90 xchg %ax,%ax register Message_queue_Control *the_message_queue; Objects_Locations location; CORE_message_queue_Status status; if ( !buffer ) return RTEMS_INVALID_ADDRESS; 116810: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 116815: 8d 65 f8 lea -0x8(%ebp),%esp 116818: 5b pop %ebx 116819: 5e pop %esi 11681a: c9 leave 11681b: c3 ret =============================================================================== 001124cc : return (retval); } int rtems_mkdir(const char *path, mode_t mode) { 1124cc: 55 push %ebp 1124cd: 89 e5 mov %esp,%ebp 1124cf: 57 push %edi 1124d0: 56 push %esi 1124d1: 53 push %ebx 1124d2: 83 ec 78 sub $0x78,%esp int success = 0; char *dup_path = strdup(path); 1124d5: ff 75 08 pushl 0x8(%ebp) 1124d8: e8 c7 35 00 00 call 115aa4 1124dd: 89 c7 mov %eax,%edi if (dup_path != NULL) { 1124df: 83 c4 10 add $0x10,%esp 1124e2: 85 c0 test %eax,%eax 1124e4: 0f 84 0a 01 00 00 je 1125f4 <== NEVER TAKEN char *p; p = path; oumask = 0; retval = 1; if (p[0] == '/') /* Skip leading '/'. */ 1124ea: 8a 10 mov (%eax),%dl 1124ec: 80 fa 2f cmp $0x2f,%dl 1124ef: 0f 84 0f 01 00 00 je 112604 1124f5: 89 c3 mov %eax,%ebx 1124f7: c7 45 94 00 00 00 00 movl $0x0,-0x6c(%ebp) 1124fe: b8 01 00 00 00 mov $0x1,%eax ++p; for (first = 1, last = 0; !last ; ++p) { if (p[0] == '\0') 112503: 84 d2 test %dl,%dl 112505: 74 11 je 112518 <== NEVER TAKEN 112507: 90 nop last = 1; else if (p[0] != '/') 112508: 80 fa 2f cmp $0x2f,%dl 11250b: 0f 84 83 00 00 00 je 112594 p = path; oumask = 0; retval = 1; if (p[0] == '/') /* Skip leading '/'. */ ++p; for (first = 1, last = 0; !last ; ++p) { 112511: 43 inc %ebx 112512: 8a 13 mov (%ebx),%dl if (p[0] == '\0') 112514: 84 d2 test %dl,%dl 112516: 75 f0 jne 112508 last = 1; else if (p[0] != '/') continue; *p = '\0'; 112518: c6 03 00 movb $0x0,(%ebx) 11251b: be 01 00 00 00 mov $0x1,%esi if (!last && p[1] == '\0') last = 1; if (first) { 112520: 85 c0 test %eax,%eax 112522: 75 54 jne 112578 oumask = umask(0); numask = oumask & ~(S_IWUSR | S_IXUSR); (void)umask(numask); first = 0; } if (last) 112524: 85 f6 test %esi,%esi 112526: 75 3c jne 112564 (void)umask(oumask); if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) { 112528: b8 ff 01 00 00 mov $0x1ff,%eax 11252d: 83 ec 08 sub $0x8,%esp 112530: 50 push %eax 112531: 57 push %edi 112532: e8 cd 71 ff ff call 109704 112537: 83 c4 10 add $0x10,%esp 11253a: 85 c0 test %eax,%eax 11253c: 78 6a js 1125a8 } else { retval = 0; break; } } if (!last) 11253e: 85 f6 test %esi,%esi 112540: 75 0a jne 11254c *p = '/'; 112542: c6 03 2f movb $0x2f,(%ebx) 112545: 31 c0 xor %eax,%eax 112547: eb c8 jmp 112511 112549: 8d 76 00 lea 0x0(%esi),%esi int success = 0; char *dup_path = strdup(path); if (dup_path != NULL) { success = build(dup_path, mode); free(dup_path); 11254c: 83 ec 0c sub $0xc,%esp 11254f: 57 push %edi 112550: e8 b7 6b ff ff call 10910c 112555: 83 c4 10 add $0x10,%esp } return success != 0 ? 0 : -1; 112558: 31 c0 xor %eax,%eax } 11255a: 8d 65 f4 lea -0xc(%ebp),%esp 11255d: 5b pop %ebx 11255e: 5e pop %esi 11255f: 5f pop %edi 112560: c9 leave 112561: c3 ret 112562: 66 90 xchg %ax,%ax numask = oumask & ~(S_IWUSR | S_IXUSR); (void)umask(numask); first = 0; } if (last) (void)umask(oumask); 112564: 83 ec 0c sub $0xc,%esp 112567: ff 75 94 pushl -0x6c(%ebp) 11256a: e8 81 01 00 00 call 1126f0 11256f: 83 c4 10 add $0x10,%esp if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) { 112572: 8b 45 0c mov 0xc(%ebp),%eax 112575: eb b6 jmp 11252d 112577: 90 nop * mkdir [-m mode] dir * * We change the user's umask and then restore it, * instead of doing chmod's. */ oumask = umask(0); 112578: 83 ec 0c sub $0xc,%esp 11257b: 6a 00 push $0x0 11257d: e8 6e 01 00 00 call 1126f0 112582: 89 45 94 mov %eax,-0x6c(%ebp) numask = oumask & ~(S_IWUSR | S_IXUSR); 112585: 24 3f and $0x3f,%al (void)umask(numask); 112587: 89 04 24 mov %eax,(%esp) 11258a: e8 61 01 00 00 call 1126f0 11258f: 83 c4 10 add $0x10,%esp 112592: eb 90 jmp 112524 for (first = 1, last = 0; !last ; ++p) { if (p[0] == '\0') last = 1; else if (p[0] != '/') continue; *p = '\0'; 112594: c6 03 00 movb $0x0,(%ebx) if (!last && p[1] == '\0') 112597: 31 d2 xor %edx,%edx 112599: 80 7b 01 00 cmpb $0x0,0x1(%ebx) 11259d: 0f 94 c2 sete %dl 1125a0: 89 d6 mov %edx,%esi 1125a2: e9 79 ff ff ff jmp 112520 1125a7: 90 nop first = 0; } if (last) (void)umask(oumask); if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) { if (errno == EEXIST || errno == EISDIR) { 1125a8: e8 6b 28 00 00 call 114e18 <__errno> 1125ad: 83 38 11 cmpl $0x11,(%eax) 1125b0: 74 0a je 1125bc 1125b2: e8 61 28 00 00 call 114e18 <__errno> 1125b7: 83 38 15 cmpl $0x15,(%eax) 1125ba: 75 53 jne 11260f <== ALWAYS TAKEN if (stat(path, &sb) < 0) { 1125bc: 83 ec 08 sub $0x8,%esp 1125bf: 8d 45 a0 lea -0x60(%ebp),%eax 1125c2: 50 push %eax 1125c3: 57 push %edi 1125c4: e8 7f 00 00 00 call 112648 1125c9: 83 c4 10 add $0x10,%esp 1125cc: 85 c0 test %eax,%eax 1125ce: 78 3f js 11260f <== NEVER TAKEN retval = 0; break; } else if (!S_ISDIR(sb.st_mode)) { 1125d0: 8b 45 ac mov -0x54(%ebp),%eax 1125d3: 25 00 f0 00 00 and $0xf000,%eax 1125d8: 3d 00 40 00 00 cmp $0x4000,%eax 1125dd: 0f 84 5b ff ff ff je 11253e if (last) 1125e3: 85 f6 test %esi,%esi 1125e5: 74 53 je 11263a errno = EEXIST; 1125e7: e8 2c 28 00 00 call 114e18 <__errno> 1125ec: c7 00 11 00 00 00 movl $0x11,(%eax) 1125f2: eb 2d jmp 112621 if (dup_path != NULL) { success = build(dup_path, mode); free(dup_path); } return success != 0 ? 0 : -1; 1125f4: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED } 1125f9: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1125fc: 5b pop %ebx <== NOT EXECUTED 1125fd: 5e pop %esi <== NOT EXECUTED 1125fe: 5f pop %edi <== NOT EXECUTED 1125ff: c9 leave <== NOT EXECUTED 112600: c3 ret <== NOT EXECUTED 112601: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED p = path; oumask = 0; retval = 1; if (p[0] == '/') /* Skip leading '/'. */ ++p; 112604: 8d 58 01 lea 0x1(%eax),%ebx 112607: 8a 50 01 mov 0x1(%eax),%dl 11260a: e9 e8 fe ff ff jmp 1124f7 } } if (!last) *p = '/'; } if (!first && !last) 11260f: 85 f6 test %esi,%esi 112611: 75 0e jne 112621 <== ALWAYS TAKEN (void)umask(oumask); 112613: 83 ec 0c sub $0xc,%esp 112616: ff 75 94 pushl -0x6c(%ebp) 112619: e8 d2 00 00 00 call 1126f0 11261e: 83 c4 10 add $0x10,%esp int success = 0; char *dup_path = strdup(path); if (dup_path != NULL) { success = build(dup_path, mode); free(dup_path); 112621: 83 ec 0c sub $0xc,%esp 112624: 57 push %edi 112625: e8 e2 6a ff ff call 10910c 11262a: 83 c4 10 add $0x10,%esp } return success != 0 ? 0 : -1; 11262d: b8 ff ff ff ff mov $0xffffffff,%eax } 112632: 8d 65 f4 lea -0xc(%ebp),%esp 112635: 5b pop %ebx 112636: 5e pop %esi 112637: 5f pop %edi 112638: c9 leave 112639: c3 ret break; } else if (!S_ISDIR(sb.st_mode)) { if (last) errno = EEXIST; else errno = ENOTDIR; 11263a: e8 d9 27 00 00 call 114e18 <__errno> 11263f: c7 00 14 00 00 00 movl $0x14,(%eax) 112645: eb cc jmp 112613 =============================================================================== 0010b978 : }; const char *rtems_object_get_api_name( int api ) { 10b978: 55 push %ebp 10b979: 89 e5 mov %esp,%ebp 10b97b: 83 ec 10 sub $0x10,%esp const rtems_assoc_t *api_assoc; api_assoc = rtems_assoc_ptr_by_local( rtems_objects_api_assoc, api ); 10b97e: ff 75 08 pushl 0x8(%ebp) 10b981: 68 40 7c 12 00 push $0x127c40 10b986: e8 d9 49 00 00 call 110364 if ( api_assoc ) 10b98b: 83 c4 10 add $0x10,%esp 10b98e: 85 c0 test %eax,%eax 10b990: 74 06 je 10b998 return api_assoc->name; 10b992: 8b 00 mov (%eax),%eax return "BAD CLASS"; } 10b994: c9 leave 10b995: c3 ret 10b996: 66 90 xchg %ax,%ax const rtems_assoc_t *api_assoc; api_assoc = rtems_assoc_ptr_by_local( rtems_objects_api_assoc, api ); if ( api_assoc ) return api_assoc->name; return "BAD CLASS"; 10b998: b8 63 2c 12 00 mov $0x122c63,%eax } 10b99d: c9 leave 10b99e: c3 ret =============================================================================== 0010cf60 : rtems_status_code rtems_object_get_class_information( int the_api, int the_class, rtems_object_api_class_information *info ) { 10cf60: 55 push %ebp 10cf61: 89 e5 mov %esp,%ebp 10cf63: 57 push %edi 10cf64: 56 push %esi 10cf65: 53 push %ebx 10cf66: 83 ec 0c sub $0xc,%esp 10cf69: 8b 5d 10 mov 0x10(%ebp),%ebx int i; /* * Validate parameters and look up information structure. */ if ( !info ) 10cf6c: 85 db test %ebx,%ebx 10cf6e: 74 60 je 10cfd0 return RTEMS_INVALID_ADDRESS; obj_info = _Objects_Get_information( the_api, the_class ); 10cf70: 83 ec 08 sub $0x8,%esp 10cf73: 0f b7 45 0c movzwl 0xc(%ebp),%eax 10cf77: 50 push %eax 10cf78: ff 75 08 pushl 0x8(%ebp) 10cf7b: e8 4c 1b 00 00 call 10eacc <_Objects_Get_information> if ( !obj_info ) 10cf80: 83 c4 10 add $0x10,%esp 10cf83: 85 c0 test %eax,%eax 10cf85: 74 59 je 10cfe0 return RTEMS_INVALID_NUMBER; /* * Return information about this object class to the user. */ info->minimum_id = obj_info->minimum_id; 10cf87: 8b 50 08 mov 0x8(%eax),%edx 10cf8a: 89 13 mov %edx,(%ebx) info->maximum_id = obj_info->maximum_id; 10cf8c: 8b 50 0c mov 0xc(%eax),%edx 10cf8f: 89 53 04 mov %edx,0x4(%ebx) info->auto_extend = obj_info->auto_extend; 10cf92: 8a 50 12 mov 0x12(%eax),%dl 10cf95: 88 53 0c mov %dl,0xc(%ebx) info->maximum = obj_info->maximum; 10cf98: 0f b7 70 10 movzwl 0x10(%eax),%esi 10cf9c: 89 73 08 mov %esi,0x8(%ebx) for ( unallocated=0, i=1 ; i <= info->maximum ; i++ ) 10cf9f: 85 f6 test %esi,%esi 10cfa1: 74 44 je 10cfe7 <== NEVER TAKEN 10cfa3: 8b 78 1c mov 0x1c(%eax),%edi 10cfa6: b9 01 00 00 00 mov $0x1,%ecx 10cfab: b8 01 00 00 00 mov $0x1,%eax 10cfb0: 31 d2 xor %edx,%edx 10cfb2: 66 90 xchg %ax,%ax if ( !obj_info->local_table[i] ) unallocated++; 10cfb4: 83 3c 8f 01 cmpl $0x1,(%edi,%ecx,4) 10cfb8: 83 d2 00 adc $0x0,%edx info->minimum_id = obj_info->minimum_id; info->maximum_id = obj_info->maximum_id; info->auto_extend = obj_info->auto_extend; info->maximum = obj_info->maximum; for ( unallocated=0, i=1 ; i <= info->maximum ; i++ ) 10cfbb: 40 inc %eax 10cfbc: 89 c1 mov %eax,%ecx 10cfbe: 39 c6 cmp %eax,%esi 10cfc0: 73 f2 jae 10cfb4 if ( !obj_info->local_table[i] ) unallocated++; info->unallocated = unallocated; 10cfc2: 89 53 10 mov %edx,0x10(%ebx) return RTEMS_SUCCESSFUL; 10cfc5: 31 c0 xor %eax,%eax } 10cfc7: 8d 65 f4 lea -0xc(%ebp),%esp 10cfca: 5b pop %ebx 10cfcb: 5e pop %esi 10cfcc: 5f pop %edi 10cfcd: c9 leave 10cfce: c3 ret 10cfcf: 90 nop /* * Validate parameters and look up information structure. */ if ( !info ) return RTEMS_INVALID_ADDRESS; 10cfd0: b8 09 00 00 00 mov $0x9,%eax unallocated++; info->unallocated = unallocated; return RTEMS_SUCCESSFUL; } 10cfd5: 8d 65 f4 lea -0xc(%ebp),%esp 10cfd8: 5b pop %ebx 10cfd9: 5e pop %esi 10cfda: 5f pop %edi 10cfdb: c9 leave 10cfdc: c3 ret 10cfdd: 8d 76 00 lea 0x0(%esi),%esi if ( !info ) return RTEMS_INVALID_ADDRESS; obj_info = _Objects_Get_information( the_api, the_class ); if ( !obj_info ) return RTEMS_INVALID_NUMBER; 10cfe0: b8 0a 00 00 00 mov $0xa,%eax 10cfe5: eb e0 jmp 10cfc7 info->minimum_id = obj_info->minimum_id; info->maximum_id = obj_info->maximum_id; info->auto_extend = obj_info->auto_extend; info->maximum = obj_info->maximum; for ( unallocated=0, i=1 ; i <= info->maximum ; i++ ) 10cfe7: 31 d2 xor %edx,%edx 10cfe9: eb d7 jmp 10cfc2 =============================================================================== 0010c520 : rtems_status_code rtems_object_get_classic_name( rtems_id id, rtems_name *name ) { 10c520: 55 push %ebp 10c521: 89 e5 mov %esp,%ebp 10c523: 53 push %ebx 10c524: 83 ec 14 sub $0x14,%esp 10c527: 8b 5d 0c mov 0xc(%ebp),%ebx Objects_Name_or_id_lookup_errors status; Objects_Name name_u; if ( !name ) 10c52a: 85 db test %ebx,%ebx 10c52c: 74 26 je 10c554 return RTEMS_INVALID_ADDRESS; status = _Objects_Id_to_name( id, &name_u ); 10c52e: 83 ec 08 sub $0x8,%esp 10c531: 8d 45 f4 lea -0xc(%ebp),%eax 10c534: 50 push %eax 10c535: ff 75 08 pushl 0x8(%ebp) 10c538: e8 a7 1b 00 00 call 10e0e4 <_Objects_Id_to_name> *name = name_u.name_u32; 10c53d: 8b 55 f4 mov -0xc(%ebp),%edx 10c540: 89 13 mov %edx,(%ebx) return _Status_Object_name_errors_to_status[ status ]; 10c542: 8b 04 85 4c 38 12 00 mov 0x12384c(,%eax,4),%eax 10c549: 83 c4 10 add $0x10,%esp } 10c54c: 8b 5d fc mov -0x4(%ebp),%ebx 10c54f: c9 leave 10c550: c3 ret 10c551: 8d 76 00 lea 0x0(%esi),%esi { Objects_Name_or_id_lookup_errors status; Objects_Name name_u; if ( !name ) return RTEMS_INVALID_ADDRESS; 10c554: b8 09 00 00 00 mov $0x9,%eax status = _Objects_Id_to_name( id, &name_u ); *name = name_u.name_u32; return _Status_Object_name_errors_to_status[ status ]; } 10c559: 8b 5d fc mov -0x4(%ebp),%ebx 10c55c: c9 leave 10c55d: c3 ret =============================================================================== 0010b9ac : */ rtems_status_code rtems_object_set_name( rtems_id id, const char *name ) { 10b9ac: 55 push %ebp 10b9ad: 89 e5 mov %esp,%ebp 10b9af: 57 push %edi 10b9b0: 56 push %esi 10b9b1: 53 push %ebx 10b9b2: 83 ec 1c sub $0x1c,%esp 10b9b5: 8b 75 08 mov 0x8(%ebp),%esi 10b9b8: 8b 7d 0c mov 0xc(%ebp),%edi Objects_Information *information; Objects_Locations location; Objects_Control *the_object; Objects_Id tmpId; if ( !name ) 10b9bb: 85 ff test %edi,%edi 10b9bd: 74 61 je 10ba20 return RTEMS_INVALID_ADDRESS; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10b9bf: 85 f6 test %esi,%esi 10b9c1: 74 35 je 10b9f8 information = _Objects_Get_information_id( tmpId ); 10b9c3: 83 ec 0c sub $0xc,%esp 10b9c6: 56 push %esi 10b9c7: e8 24 19 00 00 call 10d2f0 <_Objects_Get_information_id> 10b9cc: 89 c3 mov %eax,%ebx if ( !information ) 10b9ce: 83 c4 10 add $0x10,%esp 10b9d1: 85 c0 test %eax,%eax 10b9d3: 74 16 je 10b9eb return RTEMS_INVALID_ID; the_object = _Objects_Get( information, tmpId, &location ); 10b9d5: 50 push %eax 10b9d6: 8d 45 e4 lea -0x1c(%ebp),%eax 10b9d9: 50 push %eax 10b9da: 56 push %esi 10b9db: 53 push %ebx 10b9dc: e8 c7 1a 00 00 call 10d4a8 <_Objects_Get> switch ( location ) { 10b9e1: 83 c4 10 add $0x10,%esp 10b9e4: 8b 4d e4 mov -0x1c(%ebp),%ecx 10b9e7: 85 c9 test %ecx,%ecx 10b9e9: 74 19 je 10ba04 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10b9eb: b8 04 00 00 00 mov $0x4,%eax } 10b9f0: 8d 65 f4 lea -0xc(%ebp),%esp 10b9f3: 5b pop %ebx 10b9f4: 5e pop %esi 10b9f5: 5f pop %edi 10b9f6: c9 leave 10b9f7: c3 ret Objects_Id tmpId; if ( !name ) return RTEMS_INVALID_ADDRESS; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10b9f8: a1 f8 a5 12 00 mov 0x12a5f8,%eax 10b9fd: 8b 70 08 mov 0x8(%eax),%esi 10ba00: eb c1 jmp 10b9c3 10ba02: 66 90 xchg %ax,%ax the_object = _Objects_Get( information, tmpId, &location ); switch ( location ) { case OBJECTS_LOCAL: _Objects_Set_name( information, the_object, name ); 10ba04: 52 push %edx 10ba05: 57 push %edi 10ba06: 50 push %eax 10ba07: 53 push %ebx 10ba08: e8 83 1c 00 00 call 10d690 <_Objects_Set_name> _Thread_Enable_dispatch(); 10ba0d: e8 ea 26 00 00 call 10e0fc <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10ba12: 83 c4 10 add $0x10,%esp 10ba15: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10ba17: 8d 65 f4 lea -0xc(%ebp),%esp 10ba1a: 5b pop %ebx 10ba1b: 5e pop %esi 10ba1c: 5f pop %edi 10ba1d: c9 leave 10ba1e: c3 ret 10ba1f: 90 nop Objects_Locations location; Objects_Control *the_object; Objects_Id tmpId; if ( !name ) return RTEMS_INVALID_ADDRESS; 10ba20: b8 09 00 00 00 mov $0x9,%eax 10ba25: eb c9 jmp 10b9f0 =============================================================================== 0011681c : uint32_t length, uint32_t buffer_size, rtems_attribute attribute_set, rtems_id *id ) { 11681c: 55 push %ebp 11681d: 89 e5 mov %esp,%ebp 11681f: 57 push %edi 116820: 56 push %esi 116821: 53 push %ebx 116822: 83 ec 1c sub $0x1c,%esp 116825: 8b 5d 08 mov 0x8(%ebp),%ebx 116828: 8b 75 0c mov 0xc(%ebp),%esi 11682b: 8b 55 10 mov 0x10(%ebp),%edx 11682e: 8b 7d 14 mov 0x14(%ebp),%edi register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) 116831: 85 db test %ebx,%ebx 116833: 74 47 je 11687c return RTEMS_INVALID_NAME; if ( !starting_address ) 116835: 85 f6 test %esi,%esi 116837: 74 23 je 11685c return RTEMS_INVALID_ADDRESS; if ( !id ) 116839: 8b 45 1c mov 0x1c(%ebp),%eax 11683c: 85 c0 test %eax,%eax 11683e: 74 1c je 11685c <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || 116840: 85 d2 test %edx,%edx 116842: 74 28 je 11686c 116844: 85 ff test %edi,%edi 116846: 74 24 je 11686c 116848: 39 fa cmp %edi,%edx 11684a: 72 20 jb 11686c 11684c: f7 c7 03 00 00 00 test $0x3,%edi 116852: 75 18 jne 11686c !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; if ( !_Addresses_Is_aligned( starting_address ) ) 116854: f7 c6 03 00 00 00 test $0x3,%esi 11685a: 74 30 je 11688c return RTEMS_INVALID_ADDRESS; 11685c: b8 09 00 00 00 mov $0x9,%eax ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 116861: 8d 65 f4 lea -0xc(%ebp),%esp 116864: 5b pop %ebx 116865: 5e pop %esi 116866: 5f pop %edi 116867: c9 leave 116868: c3 ret 116869: 8d 76 00 lea 0x0(%esi),%esi if ( !id ) return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; 11686c: b8 08 00 00 00 mov $0x8,%eax ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 116871: 8d 65 f4 lea -0xc(%ebp),%esp 116874: 5b pop %ebx 116875: 5e pop %esi 116876: 5f pop %edi 116877: c9 leave 116878: c3 ret 116879: 8d 76 00 lea 0x0(%esi),%esi ) { register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 11687c: b8 03 00 00 00 mov $0x3,%eax ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 116881: 8d 65 f4 lea -0xc(%ebp),%esp 116884: 5b pop %ebx 116885: 5e pop %esi 116886: 5f pop %edi 116887: c9 leave 116888: c3 ret 116889: 8d 76 00 lea 0x0(%esi),%esi 11688c: a1 30 2a 14 00 mov 0x142a30,%eax 116891: 40 inc %eax 116892: a3 30 2a 14 00 mov %eax,0x142a30 * This function allocates a partition control block from * the inactive chain of free partition control blocks. */ RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Allocate ( void ) { return (Partition_Control *) _Objects_Allocate( &_Partition_Information ); 116897: 83 ec 0c sub $0xc,%esp 11689a: 68 c0 28 14 00 push $0x1428c0 11689f: 89 55 e0 mov %edx,-0x20(%ebp) 1168a2: e8 45 45 00 00 call 11adec <_Objects_Allocate> 1168a7: 89 45 e4 mov %eax,-0x1c(%ebp) _Thread_Disable_dispatch(); /* prevents deletion */ the_partition = _Partition_Allocate(); if ( !the_partition ) { 1168aa: 83 c4 10 add $0x10,%esp 1168ad: 85 c0 test %eax,%eax 1168af: 8b 55 e0 mov -0x20(%ebp),%edx 1168b2: 74 58 je 11690c _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_partition->starting_address = starting_address; 1168b4: 8b 45 e4 mov -0x1c(%ebp),%eax 1168b7: 89 70 10 mov %esi,0x10(%eax) the_partition->length = length; 1168ba: 89 50 14 mov %edx,0x14(%eax) the_partition->buffer_size = buffer_size; 1168bd: 89 78 18 mov %edi,0x18(%eax) the_partition->attribute_set = attribute_set; 1168c0: 8b 4d 18 mov 0x18(%ebp),%ecx 1168c3: 89 48 1c mov %ecx,0x1c(%eax) the_partition->number_of_used_blocks = 0; 1168c6: c7 40 20 00 00 00 00 movl $0x0,0x20(%eax) _Chain_Initialize( &the_partition->Memory, starting_address, 1168cd: 57 push %edi 1168ce: 89 d0 mov %edx,%eax 1168d0: 31 d2 xor %edx,%edx 1168d2: f7 f7 div %edi 1168d4: 50 push %eax 1168d5: 56 push %esi 1168d6: 8b 45 e4 mov -0x1c(%ebp),%eax 1168d9: 83 c0 24 add $0x24,%eax 1168dc: 50 push %eax 1168dd: e8 9e 2f 00 00 call 119880 <_Chain_Initialize> Objects_Name name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 1168e2: 8b 7d e4 mov -0x1c(%ebp),%edi 1168e5: 8b 47 08 mov 0x8(%edi),%eax Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 1168e8: 0f b7 f0 movzwl %ax,%esi #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 1168eb: 8b 15 dc 28 14 00 mov 0x1428dc,%edx 1168f1: 89 3c b2 mov %edi,(%edx,%esi,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 1168f4: 89 5f 0c mov %ebx,0xc(%edi) &_Partition_Information, &the_partition->Object, (Objects_Name) name ); *id = the_partition->Object.id; 1168f7: 8b 55 1c mov 0x1c(%ebp),%edx 1168fa: 89 02 mov %eax,(%edx) name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 1168fc: e8 53 55 00 00 call 11be54 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 116901: 83 c4 10 add $0x10,%esp 116904: 31 c0 xor %eax,%eax 116906: e9 66 ff ff ff jmp 116871 11690b: 90 nop _Thread_Disable_dispatch(); /* prevents deletion */ the_partition = _Partition_Allocate(); if ( !the_partition ) { _Thread_Enable_dispatch(); 11690c: e8 43 55 00 00 call 11be54 <_Thread_Enable_dispatch> return RTEMS_TOO_MANY; 116911: b8 05 00 00 00 mov $0x5,%eax 116916: e9 56 ff ff ff jmp 116871 =============================================================================== 00116988 : rtems_status_code rtems_partition_get_buffer( rtems_id id, void **buffer ) { 116988: 55 push %ebp 116989: 89 e5 mov %esp,%ebp 11698b: 56 push %esi 11698c: 53 push %ebx 11698d: 83 ec 20 sub $0x20,%esp 116990: 8b 5d 0c mov 0xc(%ebp),%ebx register Partition_Control *the_partition; Objects_Locations location; void *the_buffer; if ( !buffer ) 116993: 85 db test %ebx,%ebx 116995: 74 59 je 1169f0 Objects_Id id, Objects_Locations *location ) { return (Partition_Control *) _Objects_Get( &_Partition_Information, id, location ); 116997: 52 push %edx return RTEMS_INVALID_ADDRESS; the_partition = _Partition_Get( id, &location ); 116998: 8d 45 f4 lea -0xc(%ebp),%eax 11699b: 50 push %eax 11699c: ff 75 08 pushl 0x8(%ebp) 11699f: 68 c0 28 14 00 push $0x1428c0 1169a4: e8 33 49 00 00 call 11b2dc <_Objects_Get> 1169a9: 89 c6 mov %eax,%esi switch ( location ) { 1169ab: 83 c4 10 add $0x10,%esp 1169ae: 8b 45 f4 mov -0xc(%ebp),%eax 1169b1: 85 c0 test %eax,%eax 1169b3: 75 2f jne 1169e4 */ RTEMS_INLINE_ROUTINE void *_Partition_Allocate_buffer ( Partition_Control *the_partition ) { return _Chain_Get( &the_partition->Memory ); 1169b5: 83 ec 0c sub $0xc,%esp 1169b8: 8d 46 24 lea 0x24(%esi),%eax 1169bb: 50 push %eax 1169bc: e8 9b 2e 00 00 call 11985c <_Chain_Get> case OBJECTS_LOCAL: the_buffer = _Partition_Allocate_buffer( the_partition ); if ( the_buffer ) { 1169c1: 83 c4 10 add $0x10,%esp 1169c4: 85 c0 test %eax,%eax 1169c6: 74 34 je 1169fc the_partition->number_of_used_blocks += 1; 1169c8: ff 46 20 incl 0x20(%esi) _Thread_Enable_dispatch(); 1169cb: 89 45 e4 mov %eax,-0x1c(%ebp) 1169ce: e8 81 54 00 00 call 11be54 <_Thread_Enable_dispatch> *buffer = the_buffer; 1169d3: 8b 45 e4 mov -0x1c(%ebp),%eax 1169d6: 89 03 mov %eax,(%ebx) return RTEMS_SUCCESSFUL; 1169d8: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1169da: 8d 65 f8 lea -0x8(%ebp),%esp 1169dd: 5b pop %ebx 1169de: 5e pop %esi 1169df: c9 leave 1169e0: c3 ret 1169e1: 8d 76 00 lea 0x0(%esi),%esi case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 1169e4: b8 04 00 00 00 mov $0x4,%eax } 1169e9: 8d 65 f8 lea -0x8(%ebp),%esp 1169ec: 5b pop %ebx 1169ed: 5e pop %esi 1169ee: c9 leave 1169ef: c3 ret register Partition_Control *the_partition; Objects_Locations location; void *the_buffer; if ( !buffer ) return RTEMS_INVALID_ADDRESS; 1169f0: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1169f5: 8d 65 f8 lea -0x8(%ebp),%esp 1169f8: 5b pop %ebx 1169f9: 5e pop %esi 1169fa: c9 leave 1169fb: c3 ret the_partition->number_of_used_blocks += 1; _Thread_Enable_dispatch(); *buffer = the_buffer; return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 1169fc: e8 53 54 00 00 call 11be54 <_Thread_Enable_dispatch> return RTEMS_UNSATISFIED; 116a01: b8 0d 00 00 00 mov $0xd,%eax 116a06: eb e1 jmp 1169e9 =============================================================================== 00116a2c : rtems_status_code rtems_partition_return_buffer( rtems_id id, void *buffer ) { 116a2c: 55 push %ebp 116a2d: 89 e5 mov %esp,%ebp 116a2f: 56 push %esi 116a30: 53 push %ebx 116a31: 83 ec 14 sub $0x14,%esp 116a34: 8b 75 0c mov 0xc(%ebp),%esi register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); 116a37: 8d 45 f4 lea -0xc(%ebp),%eax Objects_Id id, Objects_Locations *location ) { return (Partition_Control *) _Objects_Get( &_Partition_Information, id, location ); 116a3a: 50 push %eax 116a3b: ff 75 08 pushl 0x8(%ebp) 116a3e: 68 c0 28 14 00 push $0x1428c0 116a43: e8 94 48 00 00 call 11b2dc <_Objects_Get> 116a48: 89 c3 mov %eax,%ebx switch ( location ) { 116a4a: 83 c4 10 add $0x10,%esp 116a4d: 8b 45 f4 mov -0xc(%ebp),%eax 116a50: 85 c0 test %eax,%eax 116a52: 74 0c je 116a60 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 116a54: b8 04 00 00 00 mov $0x4,%eax } 116a59: 8d 65 f8 lea -0x8(%ebp),%esp 116a5c: 5b pop %ebx 116a5d: 5e pop %esi 116a5e: c9 leave 116a5f: c3 ret ) { void *starting; void *ending; starting = the_partition->starting_address; 116a60: 8b 43 10 mov 0x10(%ebx),%eax ending = _Addresses_Add_offset( starting, the_partition->length ); 116a63: 8b 53 14 mov 0x14(%ebx),%edx const void *address, const void *base, const void *limit ) { return (address >= base && address <= limit); 116a66: 39 c6 cmp %eax,%esi 116a68: 72 3a jb 116aa4 RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset ( const void *base, uintptr_t offset ) { return (void *)((uintptr_t)base + offset); 116a6a: 8d 14 10 lea (%eax,%edx,1),%edx const void *address, const void *base, const void *limit ) { return (address >= base && address <= limit); 116a6d: 39 d6 cmp %edx,%esi 116a6f: 77 33 ja 116aa4 <== NEVER TAKEN RTEMS_INLINE_ROUTINE int32_t _Addresses_Subtract ( const void *left, const void *right ) { return (int32_t) ((const char *) left - (const char *) right); 116a71: 89 f2 mov %esi,%edx 116a73: 29 c2 sub %eax,%edx 116a75: 89 d0 mov %edx,%eax offset = (uint32_t) _Addresses_Subtract( the_buffer, the_partition->starting_address ); return ((offset % the_partition->buffer_size) == 0); 116a77: 31 d2 xor %edx,%edx 116a79: f7 73 18 divl 0x18(%ebx) starting = the_partition->starting_address; ending = _Addresses_Add_offset( starting, the_partition->length ); return ( _Addresses_Is_in_range( the_buffer, starting, ending ) && 116a7c: 85 d2 test %edx,%edx 116a7e: 75 24 jne 116aa4 RTEMS_INLINE_ROUTINE void _Partition_Free_buffer ( Partition_Control *the_partition, Chain_Node *the_buffer ) { _Chain_Append( &the_partition->Memory, the_buffer ); 116a80: 83 ec 08 sub $0x8,%esp 116a83: 56 push %esi 116a84: 8d 43 24 lea 0x24(%ebx),%eax 116a87: 50 push %eax 116a88: e8 93 2d 00 00 call 119820 <_Chain_Append> switch ( location ) { case OBJECTS_LOCAL: if ( _Partition_Is_buffer_valid( buffer, the_partition ) ) { _Partition_Free_buffer( the_partition, buffer ); the_partition->number_of_used_blocks -= 1; 116a8d: ff 4b 20 decl 0x20(%ebx) _Thread_Enable_dispatch(); 116a90: e8 bf 53 00 00 call 11be54 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 116a95: 83 c4 10 add $0x10,%esp 116a98: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 116a9a: 8d 65 f8 lea -0x8(%ebp),%esp 116a9d: 5b pop %ebx 116a9e: 5e pop %esi 116a9f: c9 leave 116aa0: c3 ret 116aa1: 8d 76 00 lea 0x0(%esi),%esi _Partition_Free_buffer( the_partition, buffer ); the_partition->number_of_used_blocks -= 1; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 116aa4: e8 ab 53 00 00 call 11be54 <_Thread_Enable_dispatch> return RTEMS_INVALID_ADDRESS; 116aa9: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 116aae: 8d 65 f8 lea -0x8(%ebp),%esp 116ab1: 5b pop %ebx 116ab2: 5e pop %esi 116ab3: c9 leave 116ab4: c3 ret =============================================================================== 00115e50 : void *internal_start, void *external_start, uint32_t length, rtems_id *id ) { 115e50: 55 push %ebp 115e51: 89 e5 mov %esp,%ebp 115e53: 57 push %edi 115e54: 56 push %esi 115e55: 53 push %ebx 115e56: 83 ec 1c sub $0x1c,%esp 115e59: 8b 5d 08 mov 0x8(%ebp),%ebx 115e5c: 8b 55 0c mov 0xc(%ebp),%edx 115e5f: 8b 7d 10 mov 0x10(%ebp),%edi 115e62: 8b 75 18 mov 0x18(%ebp),%esi register Dual_ported_memory_Control *the_port; if ( !rtems_is_name_valid( name ) ) 115e65: 85 db test %ebx,%ebx 115e67: 74 1b je 115e84 return RTEMS_INVALID_NAME; if ( !id ) 115e69: 85 f6 test %esi,%esi 115e6b: 74 08 je 115e75 * id - port id * RTEMS_SUCCESSFUL - if successful * error code - if unsuccessful */ rtems_status_code rtems_port_create( 115e6d: 89 f8 mov %edi,%eax 115e6f: 09 d0 or %edx,%eax return RTEMS_INVALID_NAME; if ( !id ) return RTEMS_INVALID_ADDRESS; if ( !_Addresses_Is_aligned( internal_start ) || 115e71: a8 03 test $0x3,%al 115e73: 74 1f je 115e94 !_Addresses_Is_aligned( external_start ) ) return RTEMS_INVALID_ADDRESS; 115e75: b8 09 00 00 00 mov $0x9,%eax ); *id = the_port->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 115e7a: 8d 65 f4 lea -0xc(%ebp),%esp 115e7d: 5b pop %ebx 115e7e: 5e pop %esi 115e7f: 5f pop %edi 115e80: c9 leave 115e81: c3 ret 115e82: 66 90 xchg %ax,%ax ) { register Dual_ported_memory_Control *the_port; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 115e84: b8 03 00 00 00 mov $0x3,%eax ); *id = the_port->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 115e89: 8d 65 f4 lea -0xc(%ebp),%esp 115e8c: 5b pop %ebx 115e8d: 5e pop %esi 115e8e: 5f pop %edi 115e8f: c9 leave 115e90: c3 ret 115e91: 8d 76 00 lea 0x0(%esi),%esi rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 115e94: a1 30 2a 14 00 mov 0x142a30,%eax 115e99: 40 inc %eax 115e9a: a3 30 2a 14 00 mov %eax,0x142a30 */ RTEMS_INLINE_ROUTINE Dual_ported_memory_Control *_Dual_ported_memory_Allocate ( void ) { return (Dual_ported_memory_Control *) _Objects_Allocate( &_Dual_ported_memory_Information ); 115e9f: 83 ec 0c sub $0xc,%esp 115ea2: 68 80 28 14 00 push $0x142880 115ea7: 89 55 e4 mov %edx,-0x1c(%ebp) 115eaa: e8 3d 4f 00 00 call 11adec <_Objects_Allocate> _Thread_Disable_dispatch(); /* to prevent deletion */ the_port = _Dual_ported_memory_Allocate(); if ( !the_port ) { 115eaf: 83 c4 10 add $0x10,%esp 115eb2: 85 c0 test %eax,%eax 115eb4: 8b 55 e4 mov -0x1c(%ebp),%edx 115eb7: 74 33 je 115eec _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_port->internal_base = internal_start; 115eb9: 89 50 10 mov %edx,0x10(%eax) the_port->external_base = external_start; 115ebc: 89 78 14 mov %edi,0x14(%eax) the_port->length = length - 1; 115ebf: 8b 55 14 mov 0x14(%ebp),%edx 115ec2: 4a dec %edx 115ec3: 89 50 18 mov %edx,0x18(%eax) Objects_Name name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 115ec6: 8b 50 08 mov 0x8(%eax),%edx Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 115ec9: 0f b7 fa movzwl %dx,%edi #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 115ecc: 8b 0d 9c 28 14 00 mov 0x14289c,%ecx 115ed2: 89 04 b9 mov %eax,(%ecx,%edi,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 115ed5: 89 58 0c mov %ebx,0xc(%eax) &_Dual_ported_memory_Information, &the_port->Object, (Objects_Name) name ); *id = the_port->Object.id; 115ed8: 89 16 mov %edx,(%esi) _Thread_Enable_dispatch(); 115eda: e8 75 5f 00 00 call 11be54 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 115edf: 31 c0 xor %eax,%eax } 115ee1: 8d 65 f4 lea -0xc(%ebp),%esp 115ee4: 5b pop %ebx 115ee5: 5e pop %esi 115ee6: 5f pop %edi 115ee7: c9 leave 115ee8: c3 ret 115ee9: 8d 76 00 lea 0x0(%esi),%esi _Thread_Disable_dispatch(); /* to prevent deletion */ the_port = _Dual_ported_memory_Allocate(); if ( !the_port ) { _Thread_Enable_dispatch(); 115eec: e8 63 5f 00 00 call 11be54 <_Thread_Enable_dispatch> return RTEMS_TOO_MANY; 115ef1: b8 05 00 00 00 mov $0x5,%eax 115ef6: eb 82 jmp 115e7a =============================================================================== 00115ef8 : */ rtems_status_code rtems_port_delete( rtems_id id ) { 115ef8: 55 push %ebp 115ef9: 89 e5 mov %esp,%ebp 115efb: 83 ec 2c sub $0x2c,%esp register Dual_ported_memory_Control *the_port; Objects_Locations location; the_port = _Dual_ported_memory_Get( id, &location ); 115efe: 8d 45 f4 lea -0xc(%ebp),%eax Objects_Id id, Objects_Locations *location ) { return (Dual_ported_memory_Control *) _Objects_Get( &_Dual_ported_memory_Information, id, location ); 115f01: 50 push %eax 115f02: ff 75 08 pushl 0x8(%ebp) 115f05: 68 80 28 14 00 push $0x142880 115f0a: e8 cd 53 00 00 call 11b2dc <_Objects_Get> switch ( location ) { 115f0f: 83 c4 10 add $0x10,%esp 115f12: 8b 4d f4 mov -0xc(%ebp),%ecx 115f15: 85 c9 test %ecx,%ecx 115f17: 75 2f jne 115f48 case OBJECTS_LOCAL: _Objects_Close( &_Dual_ported_memory_Information, &the_port->Object ); 115f19: 83 ec 08 sub $0x8,%esp 115f1c: 50 push %eax 115f1d: 68 80 28 14 00 push $0x142880 115f22: 89 45 e4 mov %eax,-0x1c(%ebp) 115f25: e8 3e 4f 00 00 call 11ae68 <_Objects_Close> */ RTEMS_INLINE_ROUTINE void _Dual_ported_memory_Free ( Dual_ported_memory_Control *the_port ) { _Objects_Free( &_Dual_ported_memory_Information, &the_port->Object ); 115f2a: 58 pop %eax 115f2b: 5a pop %edx 115f2c: 8b 45 e4 mov -0x1c(%ebp),%eax 115f2f: 50 push %eax 115f30: 68 80 28 14 00 push $0x142880 115f35: e8 26 52 00 00 call 11b160 <_Objects_Free> _Dual_ported_memory_Free( the_port ); _Thread_Enable_dispatch(); 115f3a: e8 15 5f 00 00 call 11be54 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 115f3f: 83 c4 10 add $0x10,%esp 115f42: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 115f44: c9 leave 115f45: c3 ret 115f46: 66 90 xchg %ax,%ax #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 115f48: b8 04 00 00 00 mov $0x4,%eax } 115f4d: c9 leave 115f4e: c3 ret =============================================================================== 00115f50 : rtems_status_code rtems_port_external_to_internal( rtems_id id, void *external, void **internal ) { 115f50: 55 push %ebp 115f51: 89 e5 mov %esp,%ebp 115f53: 56 push %esi 115f54: 53 push %ebx 115f55: 83 ec 10 sub $0x10,%esp 115f58: 8b 75 0c mov 0xc(%ebp),%esi 115f5b: 8b 5d 10 mov 0x10(%ebp),%ebx register Dual_ported_memory_Control *the_port; Objects_Locations location; uint32_t ending; if ( !internal ) 115f5e: 85 db test %ebx,%ebx 115f60: 74 4e je 115fb0 Objects_Id id, Objects_Locations *location ) { return (Dual_ported_memory_Control *) _Objects_Get( &_Dual_ported_memory_Information, id, location ); 115f62: 51 push %ecx return RTEMS_INVALID_ADDRESS; the_port = _Dual_ported_memory_Get( id, &location ); 115f63: 8d 45 f4 lea -0xc(%ebp),%eax 115f66: 50 push %eax 115f67: ff 75 08 pushl 0x8(%ebp) 115f6a: 68 80 28 14 00 push $0x142880 115f6f: e8 68 53 00 00 call 11b2dc <_Objects_Get> switch ( location ) { 115f74: 83 c4 10 add $0x10,%esp 115f77: 8b 55 f4 mov -0xc(%ebp),%edx 115f7a: 85 d2 test %edx,%edx 115f7c: 74 0e je 115f8c #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 115f7e: b8 04 00 00 00 mov $0x4,%eax } 115f83: 8d 65 f8 lea -0x8(%ebp),%esp 115f86: 5b pop %ebx 115f87: 5e pop %esi 115f88: c9 leave 115f89: c3 ret 115f8a: 66 90 xchg %ax,%ax RTEMS_INLINE_ROUTINE int32_t _Addresses_Subtract ( const void *left, const void *right ) { return (int32_t) ((const char *) left - (const char *) right); 115f8c: 89 f2 mov %esi,%edx 115f8e: 2b 50 14 sub 0x14(%eax),%edx the_port = _Dual_ported_memory_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: ending = _Addresses_Subtract( external, the_port->external_base ); if ( ending > the_port->length ) 115f91: 3b 50 18 cmp 0x18(%eax),%edx 115f94: 77 16 ja 115fac RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset ( const void *base, uintptr_t offset ) { return (void *)((uintptr_t)base + offset); 115f96: 03 50 10 add 0x10(%eax),%edx 115f99: 89 13 mov %edx,(%ebx) *internal = external; else *internal = _Addresses_Add_offset( the_port->internal_base, ending ); _Thread_Enable_dispatch(); 115f9b: e8 b4 5e 00 00 call 11be54 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 115fa0: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 115fa2: 8d 65 f8 lea -0x8(%ebp),%esp 115fa5: 5b pop %ebx 115fa6: 5e pop %esi 115fa7: c9 leave 115fa8: c3 ret 115fa9: 8d 76 00 lea 0x0(%esi),%esi the_port = _Dual_ported_memory_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: ending = _Addresses_Subtract( external, the_port->external_base ); if ( ending > the_port->length ) *internal = external; 115fac: 89 33 mov %esi,(%ebx) 115fae: eb eb jmp 115f9b register Dual_ported_memory_Control *the_port; Objects_Locations location; uint32_t ending; if ( !internal ) return RTEMS_INVALID_ADDRESS; 115fb0: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 115fb5: 8d 65 f8 lea -0x8(%ebp),%esp 115fb8: 5b pop %ebx 115fb9: 5e pop %esi 115fba: c9 leave 115fbb: c3 ret =============================================================================== 00115fe0 : rtems_status_code rtems_port_internal_to_external( rtems_id id, void *internal, void **external ) { 115fe0: 55 push %ebp 115fe1: 89 e5 mov %esp,%ebp 115fe3: 56 push %esi 115fe4: 53 push %ebx 115fe5: 83 ec 10 sub $0x10,%esp 115fe8: 8b 75 0c mov 0xc(%ebp),%esi 115feb: 8b 5d 10 mov 0x10(%ebp),%ebx register Dual_ported_memory_Control *the_port; Objects_Locations location; uint32_t ending; if ( !external ) 115fee: 85 db test %ebx,%ebx 115ff0: 74 4e je 116040 <== NEVER TAKEN 115ff2: 51 push %ecx return RTEMS_INVALID_ADDRESS; the_port = _Dual_ported_memory_Get( id, &location ); 115ff3: 8d 45 f4 lea -0xc(%ebp),%eax 115ff6: 50 push %eax 115ff7: ff 75 08 pushl 0x8(%ebp) 115ffa: 68 80 28 14 00 push $0x142880 115fff: e8 d8 52 00 00 call 11b2dc <_Objects_Get> switch ( location ) { 116004: 83 c4 10 add $0x10,%esp 116007: 8b 55 f4 mov -0xc(%ebp),%edx 11600a: 85 d2 test %edx,%edx 11600c: 74 0e je 11601c #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 11600e: b8 04 00 00 00 mov $0x4,%eax } 116013: 8d 65 f8 lea -0x8(%ebp),%esp 116016: 5b pop %ebx 116017: 5e pop %esi 116018: c9 leave 116019: c3 ret 11601a: 66 90 xchg %ax,%ax RTEMS_INLINE_ROUTINE int32_t _Addresses_Subtract ( const void *left, const void *right ) { return (int32_t) ((const char *) left - (const char *) right); 11601c: 89 f2 mov %esi,%edx 11601e: 2b 50 10 sub 0x10(%eax),%edx the_port = _Dual_ported_memory_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: ending = _Addresses_Subtract( internal, the_port->internal_base ); if ( ending > the_port->length ) 116021: 3b 50 18 cmp 0x18(%eax),%edx 116024: 77 16 ja 11603c RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset ( const void *base, uintptr_t offset ) { return (void *)((uintptr_t)base + offset); 116026: 03 50 14 add 0x14(%eax),%edx 116029: 89 13 mov %edx,(%ebx) *external = internal; else *external = _Addresses_Add_offset( the_port->external_base, ending ); _Thread_Enable_dispatch(); 11602b: e8 24 5e 00 00 call 11be54 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 116030: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 116032: 8d 65 f8 lea -0x8(%ebp),%esp 116035: 5b pop %ebx 116036: 5e pop %esi 116037: c9 leave 116038: c3 ret 116039: 8d 76 00 lea 0x0(%esi),%esi switch ( location ) { case OBJECTS_LOCAL: ending = _Addresses_Subtract( internal, the_port->internal_base ); if ( ending > the_port->length ) *external = internal; 11603c: 89 33 mov %esi,(%ebx) 11603e: eb eb jmp 11602b register Dual_ported_memory_Control *the_port; Objects_Locations location; uint32_t ending; if ( !external ) return RTEMS_INVALID_ADDRESS; 116040: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 116045: 8d 65 f8 lea -0x8(%ebp),%esp 116048: 5b pop %ebx 116049: 5e pop %esi 11604a: c9 leave 11604b: c3 ret =============================================================================== 00107830 : void rtems_print_buffer( const unsigned char *buffer, int length ) { 107830: 55 push %ebp 107831: 89 e5 mov %esp,%ebp 107833: 57 push %edi 107834: 56 push %esi 107835: 53 push %ebx 107836: 81 ec 9c 00 00 00 sub $0x9c,%esp 10783c: 8b 75 0c mov 0xc(%ebp),%esi int i, mod, max; if ( !length ) return; 10783f: 85 f6 test %esi,%esi 107841: 0f 84 00 01 00 00 je 107947 mod = length % 16; 107847: 89 f0 mov %esi,%eax 107849: 25 0f 00 00 80 and $0x8000000f,%eax 10784e: 89 85 60 ff ff ff mov %eax,-0xa0(%ebp) 107854: 0f 88 21 02 00 00 js 107a7b 10785a: 8b 85 60 ff ff ff mov -0xa0(%ebp),%eax 107860: 89 85 58 ff ff ff mov %eax,-0xa8(%ebp) max = length - mod; 107866: 29 c6 sub %eax,%esi 107868: 89 b5 5c ff ff ff mov %esi,-0xa4(%ebp) for ( i=0 ; i 107876: c7 85 64 ff ff ff 00 movl $0x0,-0x9c(%ebp) 10787d: 00 00 00 107880: 8d 9d 70 ff ff ff lea -0x90(%ebp),%ebx 107886: 66 90 xchg %ax,%ax static inline void Dump_Line( const unsigned char *buffer, int length ); void rtems_print_buffer( 107888: 8b 75 08 mov 0x8(%ebp),%esi 10788b: 03 b5 64 ff ff ff add -0x9c(%ebp),%esi { int i; char line_buffer[120]; line_buffer[0] = '\0'; 107891: c6 85 70 ff ff ff 00 movb $0x0,-0x90(%ebp) for( i=0 ; i int i; char line_buffer[120]; line_buffer[0] = '\0'; for( i=0 ; i sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] ); for( ; i<16 ; i++ ) strcat( line_buffer, " " ); strcat( line_buffer, "|" ); 1078b6: 31 c0 xor %eax,%eax 1078b8: b9 ff ff ff ff mov $0xffffffff,%ecx 1078bd: 89 df mov %ebx,%edi 1078bf: f2 ae repnz scas %es:(%edi),%al 1078c1: f7 d1 not %ecx 1078c3: 66 c7 44 0b ff 7c 00 movw $0x7c,-0x1(%ebx,%ecx,1) for( i=0 ; i 1078e3: b8 2e 00 00 00 mov $0x2e,%eax 1078e8: 50 push %eax 1078e9: 53 push %ebx 1078ea: 68 db 13 12 00 push $0x1213db 1078ef: 53 push %ebx 1078f0: e8 63 c5 00 00 call 113e58 for( ; i<16 ; i++ ) strcat( line_buffer, " " ); strcat( line_buffer, "|" ); for( i=0 ; i isprint( buffer[ i ] ) ? buffer[ i ] : '.' ); for( ; i<16 ; i++ ) strcat( line_buffer, " " ); strcat( line_buffer, "|\n" ); 1078fe: 31 c0 xor %eax,%eax 107900: b9 ff ff ff ff mov $0xffffffff,%ecx 107905: 89 df mov %ebx,%edi 107907: f2 ae repnz scas %es:(%edi),%al 107909: f7 d1 not %ecx 10790b: 8d 44 0b ff lea -0x1(%ebx,%ecx,1),%eax 10790f: 66 c7 00 7c 0a movw $0xa7c,(%eax) 107914: c6 40 02 00 movb $0x0,0x2(%eax) printk( line_buffer ); 107918: 83 ec 0c sub $0xc,%esp 10791b: 53 push %ebx 10791c: e8 17 18 00 00 call 109138 mod = length % 16; max = length - mod; for ( i=0 ; i Dump_Line( &buffer[ i ], 16 ); if ( mod ) 10793d: 8b 8d 60 ff ff ff mov -0xa0(%ebp),%ecx 107943: 85 c9 test %ecx,%ecx 107945: 75 08 jne 10794f Dump_Line( &buffer[ max ], mod ); } 107947: 8d 65 f4 lea -0xc(%ebp),%esp 10794a: 5b pop %ebx 10794b: 5e pop %esi 10794c: 5f pop %edi 10794d: c9 leave 10794e: c3 ret for ( i=0 ; i 10796d: 31 ff xor %edi,%edi 10796f: 8d 9d 70 ff ff ff lea -0x90(%ebp),%ebx 107975: 8d 76 00 lea 0x0(%esi),%esi sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] ); 107978: 0f b6 04 3e movzbl (%esi,%edi,1),%eax 10797c: 50 push %eax 10797d: 53 push %ebx 10797e: 68 d3 13 12 00 push $0x1213d3 107983: 53 push %ebx 107984: e8 cf c4 00 00 call 113e58 int i; char line_buffer[120]; line_buffer[0] = '\0'; for( i=0 ; i sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] ); for( ; i<16 ; i++ ) 107995: 83 bd 60 ff ff ff 0f cmpl $0xf,-0xa0(%ebp) 10799c: 0f 8f 02 01 00 00 jg 107aa4 <== NEVER TAKEN 1079a2: 8b 95 60 ff ff ff mov -0xa0(%ebp),%edx strcat( line_buffer, " " ); 1079a8: 31 c0 xor %eax,%eax 1079aa: 66 90 xchg %ax,%ax 1079ac: b9 ff ff ff ff mov $0xffffffff,%ecx 1079b1: 89 df mov %ebx,%edi 1079b3: f2 ae repnz scas %es:(%edi),%al 1079b5: f7 d1 not %ecx 1079b7: c7 44 0b ff 20 20 20 movl $0x202020,-0x1(%ebx,%ecx,1) 1079be: 00 line_buffer[0] = '\0'; for( i=0 ; i strcat( line_buffer, " " ); strcat( line_buffer, "|" ); 1079c5: 31 c0 xor %eax,%eax 1079c7: b9 ff ff ff ff mov $0xffffffff,%ecx 1079cc: 89 df mov %ebx,%edi 1079ce: f2 ae repnz scas %es:(%edi),%al 1079d0: f7 d1 not %ecx 1079d2: 66 c7 44 0b ff 7c 00 movw $0x7c,-0x1(%ebx,%ecx,1) for( i=0 ; i 1079e7: 31 ff xor %edi,%edi 1079e9: 8d 76 00 lea 0x0(%esi),%esi sprintf( line_buffer, "%s%c", line_buffer, isprint( buffer[ i ] ) ? buffer[ i ] : '.' ); 1079ec: 0f b6 04 3e movzbl (%esi,%edi,1),%eax 1079f0: 8b 15 14 5c 12 00 mov 0x125c14,%edx 1079f6: 0f be 54 02 01 movsbl 0x1(%edx,%eax,1),%edx for( ; i<16 ; i++ ) strcat( line_buffer, " " ); strcat( line_buffer, "|" ); for( i=0 ; i 107a03: b8 2e 00 00 00 mov $0x2e,%eax 107a08: 50 push %eax 107a09: 53 push %ebx 107a0a: 68 db 13 12 00 push $0x1213db 107a0f: 53 push %ebx 107a10: e8 43 c4 00 00 call 113e58 for( ; i<16 ; i++ ) strcat( line_buffer, " " ); strcat( line_buffer, "|" ); for( i=0 ; i sprintf( line_buffer, "%s%c", line_buffer, isprint( buffer[ i ] ) ? buffer[ i ] : '.' ); for( ; i<16 ; i++ ) 107a21: 83 bd 60 ff ff ff 0f cmpl $0xf,-0xa0(%ebp) 107a28: 7f 23 jg 107a4d <== NEVER TAKEN strcat( line_buffer, " " ); 107a2a: ba ff ff ff ff mov $0xffffffff,%edx 107a2f: 31 c0 xor %eax,%eax 107a31: 8b b5 58 ff ff ff mov -0xa8(%ebp),%esi 107a37: 90 nop 107a38: 89 d1 mov %edx,%ecx 107a3a: 89 df mov %ebx,%edi 107a3c: f2 ae repnz scas %es:(%edi),%al 107a3e: f7 d1 not %ecx 107a40: 66 c7 44 0b ff 20 00 movw $0x20,-0x1(%ebx,%ecx,1) strcat( line_buffer, "|" ); for( i=0 ; i strcat( line_buffer, " " ); strcat( line_buffer, "|\n" ); 107a4d: 31 c0 xor %eax,%eax 107a4f: b9 ff ff ff ff mov $0xffffffff,%ecx 107a54: 89 df mov %ebx,%edi 107a56: f2 ae repnz scas %es:(%edi),%al 107a58: f7 d1 not %ecx 107a5a: 8d 44 0b ff lea -0x1(%ebx,%ecx,1),%eax 107a5e: 66 c7 00 7c 0a movw $0xa7c,(%eax) 107a63: c6 40 02 00 movb $0x0,0x2(%eax) printk( line_buffer ); 107a67: 83 ec 0c sub $0xc,%esp 107a6a: 53 push %ebx 107a6b: e8 c8 16 00 00 call 109138 107a70: 83 c4 10 add $0x10,%esp for ( i=0 ; i for( ; i<16 ; i++ ) strcat( line_buffer, " " ); strcat( line_buffer, "|" ); for( i=0 ; i int i; char line_buffer[120]; line_buffer[0] = '\0'; for( i=0 ; i sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] ); for( ; i<16 ; i++ ) strcat( line_buffer, " " ); strcat( line_buffer, "|" ); 107aa4: 31 c0 xor %eax,%eax 107aa6: 83 c9 ff or $0xffffffff,%ecx <== NOT EXECUTED 107aa9: 89 df mov %ebx,%edi <== NOT EXECUTED 107aab: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED 107aad: f7 d1 not %ecx <== NOT EXECUTED 107aaf: 66 c7 44 0b ff 7c 00 movw $0x7c,-0x1(%ebx,%ecx,1) <== NOT EXECUTED 107ab6: e9 2c ff ff ff jmp 1079e7 <== NOT EXECUTED =============================================================================== 00116ab8 : */ rtems_status_code rtems_rate_monotonic_cancel( rtems_id id ) { 116ab8: 55 push %ebp 116ab9: 89 e5 mov %esp,%ebp 116abb: 53 push %ebx 116abc: 83 ec 18 sub $0x18,%esp Rate_monotonic_Control *the_period; Objects_Locations location; the_period = _Rate_monotonic_Get( id, &location ); 116abf: 8d 45 f4 lea -0xc(%ebp),%eax Objects_Id id, Objects_Locations *location ) { return (Rate_monotonic_Control *) _Objects_Get( &_Rate_monotonic_Information, id, location ); 116ac2: 50 push %eax 116ac3: ff 75 08 pushl 0x8(%ebp) 116ac6: 68 00 29 14 00 push $0x142900 116acb: e8 0c 48 00 00 call 11b2dc <_Objects_Get> 116ad0: 89 c3 mov %eax,%ebx switch ( location ) { 116ad2: 83 c4 10 add $0x10,%esp 116ad5: 8b 45 f4 mov -0xc(%ebp),%eax 116ad8: 85 c0 test %eax,%eax 116ada: 74 0c je 116ae8 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 116adc: b8 04 00 00 00 mov $0x4,%eax } 116ae1: 8b 5d fc mov -0x4(%ebp),%ebx 116ae4: c9 leave 116ae5: c3 ret 116ae6: 66 90 xchg %ax,%ax the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Thread_Is_executing( the_period->owner ) ) { 116ae8: a1 d8 2f 14 00 mov 0x142fd8,%eax 116aed: 39 43 40 cmp %eax,0x40(%ebx) 116af0: 74 12 je 116b04 _Thread_Enable_dispatch(); 116af2: e8 5d 53 00 00 call 11be54 <_Thread_Enable_dispatch> return RTEMS_NOT_OWNER_OF_RESOURCE; 116af7: b8 17 00 00 00 mov $0x17,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 116afc: 8b 5d fc mov -0x4(%ebp),%ebx 116aff: c9 leave 116b00: c3 ret 116b01: 8d 76 00 lea 0x0(%esi),%esi case OBJECTS_LOCAL: if ( !_Thread_Is_executing( the_period->owner ) ) { _Thread_Enable_dispatch(); return RTEMS_NOT_OWNER_OF_RESOURCE; } (void) _Watchdog_Remove( &the_period->Timer ); 116b04: 83 ec 0c sub $0xc,%esp 116b07: 8d 43 10 lea 0x10(%ebx),%eax 116b0a: 50 push %eax 116b0b: e8 80 64 00 00 call 11cf90 <_Watchdog_Remove> the_period->state = RATE_MONOTONIC_INACTIVE; 116b10: c7 43 38 00 00 00 00 movl $0x0,0x38(%ebx) _Thread_Enable_dispatch(); 116b17: e8 38 53 00 00 call 11be54 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 116b1c: 83 c4 10 add $0x10,%esp 116b1f: 31 c0 xor %eax,%eax 116b21: eb be jmp 116ae1 =============================================================================== 0010c340 : rtems_status_code rtems_rate_monotonic_create( rtems_name name, rtems_id *id ) { 10c340: 55 push %ebp 10c341: 89 e5 mov %esp,%ebp 10c343: 57 push %edi 10c344: 56 push %esi 10c345: 53 push %ebx 10c346: 83 ec 1c sub $0x1c,%esp 10c349: 8b 5d 08 mov 0x8(%ebp),%ebx 10c34c: 8b 75 0c mov 0xc(%ebp),%esi Rate_monotonic_Control *the_period; if ( !rtems_is_name_valid( name ) ) 10c34f: 85 db test %ebx,%ebx 10c351: 0f 84 a9 00 00 00 je 10c400 return RTEMS_INVALID_NAME; if ( !id ) 10c357: 85 f6 test %esi,%esi 10c359: 0f 84 c5 00 00 00 je 10c424 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10c35f: a1 50 b1 12 00 mov 0x12b150,%eax 10c364: 40 inc %eax 10c365: a3 50 b1 12 00 mov %eax,0x12b150 * the inactive chain of free period control blocks. */ RTEMS_INLINE_ROUTINE Rate_monotonic_Control *_Rate_monotonic_Allocate( void ) { return (Rate_monotonic_Control *) _Objects_Allocate( &_Rate_monotonic_Information ); 10c36a: 83 ec 0c sub $0xc,%esp 10c36d: 68 60 b0 12 00 push $0x12b060 10c372: e8 21 1f 00 00 call 10e298 <_Objects_Allocate> 10c377: 89 c2 mov %eax,%edx _Thread_Disable_dispatch(); /* to prevent deletion */ the_period = _Rate_monotonic_Allocate(); if ( !the_period ) { 10c379: 83 c4 10 add $0x10,%esp 10c37c: 85 c0 test %eax,%eax 10c37e: 0f 84 8c 00 00 00 je 10c410 _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_period->owner = _Thread_Executing; 10c384: a1 f8 b6 12 00 mov 0x12b6f8,%eax 10c389: 89 42 40 mov %eax,0x40(%edx) the_period->state = RATE_MONOTONIC_INACTIVE; 10c38c: c7 42 38 00 00 00 00 movl $0x0,0x38(%edx) Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 10c393: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx) the_watchdog->routine = routine; 10c39a: c7 42 2c 00 00 00 00 movl $0x0,0x2c(%edx) the_watchdog->id = id; 10c3a1: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx) the_watchdog->user_data = user_data; 10c3a8: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx) _Watchdog_Initialize( &the_period->Timer, NULL, 0, NULL ); _Rate_monotonic_Reset_statistics( the_period ); 10c3af: 8d 42 54 lea 0x54(%edx),%eax 10c3b2: 89 45 e4 mov %eax,-0x1c(%ebp) 10c3b5: b9 38 00 00 00 mov $0x38,%ecx 10c3ba: 31 c0 xor %eax,%eax 10c3bc: 8b 7d e4 mov -0x1c(%ebp),%edi 10c3bf: f3 aa rep stos %al,%es:(%edi) 10c3c1: c7 42 5c ff ff ff 7f movl $0x7fffffff,0x5c(%edx) 10c3c8: c7 42 60 ff ff ff 7f movl $0x7fffffff,0x60(%edx) 10c3cf: c7 42 74 ff ff ff 7f movl $0x7fffffff,0x74(%edx) 10c3d6: c7 42 78 ff ff ff 7f movl $0x7fffffff,0x78(%edx) Objects_Name name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10c3dd: 8b 42 08 mov 0x8(%edx),%eax Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 10c3e0: 0f b7 f8 movzwl %ax,%edi #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10c3e3: 8b 0d 7c b0 12 00 mov 0x12b07c,%ecx 10c3e9: 89 14 b9 mov %edx,(%ecx,%edi,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 10c3ec: 89 5a 0c mov %ebx,0xc(%edx) &_Rate_monotonic_Information, &the_period->Object, (Objects_Name) name ); *id = the_period->Object.id; 10c3ef: 89 06 mov %eax,(%esi) _Thread_Enable_dispatch(); 10c3f1: e8 b6 2f 00 00 call 10f3ac <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10c3f6: 31 c0 xor %eax,%eax } 10c3f8: 8d 65 f4 lea -0xc(%ebp),%esp 10c3fb: 5b pop %ebx 10c3fc: 5e pop %esi 10c3fd: 5f pop %edi 10c3fe: c9 leave 10c3ff: c3 ret ) { Rate_monotonic_Control *the_period; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 10c400: b8 03 00 00 00 mov $0x3,%eax ); *id = the_period->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10c405: 8d 65 f4 lea -0xc(%ebp),%esp 10c408: 5b pop %ebx 10c409: 5e pop %esi 10c40a: 5f pop %edi 10c40b: c9 leave 10c40c: c3 ret 10c40d: 8d 76 00 lea 0x0(%esi),%esi _Thread_Disable_dispatch(); /* to prevent deletion */ the_period = _Rate_monotonic_Allocate(); if ( !the_period ) { _Thread_Enable_dispatch(); 10c410: e8 97 2f 00 00 call 10f3ac <_Thread_Enable_dispatch> return RTEMS_TOO_MANY; 10c415: b8 05 00 00 00 mov $0x5,%eax ); *id = the_period->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10c41a: 8d 65 f4 lea -0xc(%ebp),%esp 10c41d: 5b pop %ebx 10c41e: 5e pop %esi 10c41f: 5f pop %edi 10c420: c9 leave 10c421: c3 ret 10c422: 66 90 xchg %ax,%ax if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !id ) return RTEMS_INVALID_ADDRESS; 10c424: b8 09 00 00 00 mov $0x9,%eax ); *id = the_period->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10c429: 8d 65 f4 lea -0xc(%ebp),%esp 10c42c: 5b pop %ebx 10c42d: 5e pop %esi 10c42e: 5f pop %edi 10c42f: c9 leave 10c430: c3 ret =============================================================================== 00112900 : rtems_status_code rtems_rate_monotonic_get_status( rtems_id id, rtems_rate_monotonic_period_status *status ) { 112900: 55 push %ebp 112901: 89 e5 mov %esp,%ebp 112903: 53 push %ebx 112904: 83 ec 24 sub $0x24,%esp 112907: 8b 5d 0c mov 0xc(%ebp),%ebx Objects_Locations location; Rate_monotonic_Period_time_t since_last_period; Rate_monotonic_Control *the_period; bool valid_status; if ( !status ) 11290a: 85 db test %ebx,%ebx 11290c: 0f 84 92 00 00 00 je 1129a4 112912: 50 push %eax return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); 112913: 8d 45 f4 lea -0xc(%ebp),%eax 112916: 50 push %eax 112917: ff 75 08 pushl 0x8(%ebp) 11291a: 68 60 b0 12 00 push $0x12b060 11291f: e8 10 bf ff ff call 10e834 <_Objects_Get> switch ( location ) { 112924: 83 c4 10 add $0x10,%esp 112927: 8b 4d f4 mov -0xc(%ebp),%ecx 11292a: 85 c9 test %ecx,%ecx 11292c: 74 0a je 112938 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 11292e: b8 04 00 00 00 mov $0x4,%eax } 112933: 8b 5d fc mov -0x4(%ebp),%ebx 112936: c9 leave 112937: c3 ret the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: status->owner = the_period->owner->Object.id; 112938: 8b 50 40 mov 0x40(%eax),%edx 11293b: 8b 52 08 mov 0x8(%edx),%edx 11293e: 89 13 mov %edx,(%ebx) status->state = the_period->state; 112940: 8b 50 38 mov 0x38(%eax),%edx 112943: 89 53 04 mov %edx,0x4(%ebx) /* * If the period is inactive, there is no information. */ if ( status->state == RATE_MONOTONIC_INACTIVE ) { 112946: 85 d2 test %edx,%edx 112948: 75 2a jne 112974 #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timespec_Set_to_zero( &status->since_last_period ); 11294a: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) 112951: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) _Timespec_Set_to_zero( &status->executed_since_last_period ); 112958: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) 11295f: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx) status->since_last_period = since_last_period; status->executed_since_last_period = executed; #endif } _Thread_Enable_dispatch(); 112966: e8 41 ca ff ff call 10f3ac <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 11296b: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11296d: 8b 5d fc mov -0x4(%ebp),%ebx 112970: c9 leave 112971: c3 ret 112972: 66 90 xchg %ax,%ax } else { /* * Grab the current status. */ valid_status = 112974: 52 push %edx _Rate_monotonic_Get_status( 112975: 8d 55 ec lea -0x14(%ebp),%edx } else { /* * Grab the current status. */ valid_status = 112978: 52 push %edx _Rate_monotonic_Get_status( 112979: 8d 55 e4 lea -0x1c(%ebp),%edx } else { /* * Grab the current status. */ valid_status = 11297c: 52 push %edx 11297d: 50 push %eax 11297e: e8 d5 9a ff ff call 10c458 <_Rate_monotonic_Get_status> _Rate_monotonic_Get_status( the_period, &since_last_period, &executed ); if (!valid_status) { 112983: 83 c4 10 add $0x10,%esp 112986: 84 c0 test %al,%al 112988: 74 26 je 1129b0 _Thread_Enable_dispatch(); return RTEMS_NOT_DEFINED; } #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timestamp_To_timespec( 11298a: 8b 45 e4 mov -0x1c(%ebp),%eax 11298d: 8b 55 e8 mov -0x18(%ebp),%edx 112990: 89 43 08 mov %eax,0x8(%ebx) 112993: 89 53 0c mov %edx,0xc(%ebx) &since_last_period, &status->since_last_period ); _Timestamp_To_timespec( 112996: 8b 45 ec mov -0x14(%ebp),%eax 112999: 8b 55 f0 mov -0x10(%ebp),%edx 11299c: 89 43 10 mov %eax,0x10(%ebx) 11299f: 89 53 14 mov %edx,0x14(%ebx) 1129a2: eb c2 jmp 112966 Rate_monotonic_Period_time_t since_last_period; Rate_monotonic_Control *the_period; bool valid_status; if ( !status ) return RTEMS_INVALID_ADDRESS; 1129a4: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1129a9: 8b 5d fc mov -0x4(%ebp),%ebx 1129ac: c9 leave 1129ad: c3 ret 1129ae: 66 90 xchg %ax,%ax valid_status = _Rate_monotonic_Get_status( the_period, &since_last_period, &executed ); if (!valid_status) { _Thread_Enable_dispatch(); 1129b0: e8 f7 c9 ff ff call 10f3ac <_Thread_Enable_dispatch> return RTEMS_NOT_DEFINED; 1129b5: b8 0b 00 00 00 mov $0xb,%eax 1129ba: e9 74 ff ff ff jmp 112933 =============================================================================== 0010c654 : rtems_status_code rtems_rate_monotonic_period( rtems_id id, rtems_interval length ) { 10c654: 55 push %ebp 10c655: 89 e5 mov %esp,%ebp 10c657: 57 push %edi 10c658: 56 push %esi 10c659: 53 push %ebx 10c65a: 83 ec 30 sub $0x30,%esp 10c65d: 8b 5d 08 mov 0x8(%ebp),%ebx 10c660: 8b 75 0c mov 0xc(%ebp),%esi Objects_Locations location; rtems_status_code return_value; rtems_rate_monotonic_period_states local_state; ISR_Level level; the_period = _Rate_monotonic_Get( id, &location ); 10c663: 8d 45 e4 lea -0x1c(%ebp),%eax Objects_Id id, Objects_Locations *location ) { return (Rate_monotonic_Control *) _Objects_Get( &_Rate_monotonic_Information, id, location ); 10c666: 50 push %eax 10c667: 53 push %ebx 10c668: 68 60 b0 12 00 push $0x12b060 10c66d: e8 c2 21 00 00 call 10e834 <_Objects_Get> switch ( location ) { 10c672: 83 c4 10 add $0x10,%esp 10c675: 8b 55 e4 mov -0x1c(%ebp),%edx 10c678: 85 d2 test %edx,%edx 10c67a: 74 10 je 10c68c #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10c67c: b8 04 00 00 00 mov $0x4,%eax } 10c681: 8d 65 f4 lea -0xc(%ebp),%esp 10c684: 5b pop %ebx 10c685: 5e pop %esi 10c686: 5f pop %edi 10c687: c9 leave 10c688: c3 ret 10c689: 8d 76 00 lea 0x0(%esi),%esi the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Thread_Is_executing( the_period->owner ) ) { 10c68c: 8b 15 f8 b6 12 00 mov 0x12b6f8,%edx 10c692: 39 50 40 cmp %edx,0x40(%eax) 10c695: 74 15 je 10c6ac _Thread_Enable_dispatch(); 10c697: e8 10 2d 00 00 call 10f3ac <_Thread_Enable_dispatch> return RTEMS_NOT_OWNER_OF_RESOURCE; 10c69c: b8 17 00 00 00 mov $0x17,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10c6a1: 8d 65 f4 lea -0xc(%ebp),%esp 10c6a4: 5b pop %ebx 10c6a5: 5e pop %esi 10c6a6: 5f pop %edi 10c6a7: c9 leave 10c6a8: c3 ret 10c6a9: 8d 76 00 lea 0x0(%esi),%esi if ( !_Thread_Is_executing( the_period->owner ) ) { _Thread_Enable_dispatch(); return RTEMS_NOT_OWNER_OF_RESOURCE; } if ( length == RTEMS_PERIOD_STATUS ) { 10c6ac: 85 f6 test %esi,%esi 10c6ae: 75 1c jne 10c6cc switch ( the_period->state ) { 10c6b0: 8b 40 38 mov 0x38(%eax),%eax 10c6b3: 83 f8 04 cmp $0x4,%eax 10c6b6: 77 6c ja 10c724 <== NEVER TAKEN 10c6b8: 8b 04 85 1c 3d 12 00 mov 0x123d1c(,%eax,4),%eax case RATE_MONOTONIC_ACTIVE: default: /* unreached -- only to remove warnings */ return_value = RTEMS_SUCCESSFUL; break; } _Thread_Enable_dispatch(); 10c6bf: 89 45 d4 mov %eax,-0x2c(%ebp) 10c6c2: e8 e5 2c 00 00 call 10f3ac <_Thread_Enable_dispatch> return( return_value ); 10c6c7: 8b 45 d4 mov -0x2c(%ebp),%eax 10c6ca: eb b5 jmp 10c681 } _ISR_Disable( level ); 10c6cc: 9c pushf 10c6cd: fa cli 10c6ce: 5f pop %edi if ( the_period->state == RATE_MONOTONIC_INACTIVE ) { 10c6cf: 8b 50 38 mov 0x38(%eax),%edx 10c6d2: 85 d2 test %edx,%edx 10c6d4: 74 52 je 10c728 _Watchdog_Insert_ticks( &the_period->Timer, length ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } if ( the_period->state == RATE_MONOTONIC_ACTIVE ) { 10c6d6: 83 fa 02 cmp $0x2,%edx 10c6d9: 0f 84 9e 00 00 00 je 10c77d _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } if ( the_period->state == RATE_MONOTONIC_EXPIRED ) { 10c6df: 83 fa 04 cmp $0x4,%edx 10c6e2: 75 98 jne 10c67c <== NEVER TAKEN /* * Update statistics from the concluding period */ _Rate_monotonic_Update_statistics( the_period ); 10c6e4: 83 ec 0c sub $0xc,%esp 10c6e7: 50 push %eax 10c6e8: 89 45 d4 mov %eax,-0x2c(%ebp) 10c6eb: e8 74 fe ff ff call 10c564 <_Rate_monotonic_Update_statistics> _ISR_Enable( level ); 10c6f0: 57 push %edi 10c6f1: 9d popf the_period->state = RATE_MONOTONIC_ACTIVE; 10c6f2: 8b 45 d4 mov -0x2c(%ebp),%eax 10c6f5: c7 40 38 02 00 00 00 movl $0x2,0x38(%eax) the_period->next_length = length; 10c6fc: 89 70 3c mov %esi,0x3c(%eax) Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10c6ff: 89 70 1c mov %esi,0x1c(%eax) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10c702: 5b pop %ebx 10c703: 5e pop %esi _Watchdog_Insert_ticks( &the_period->Timer, length ); 10c704: 83 c0 10 add $0x10,%eax 10c707: 50 push %eax 10c708: 68 20 b2 12 00 push $0x12b220 10c70d: e8 0a 3b 00 00 call 11021c <_Watchdog_Insert> _Thread_Enable_dispatch(); 10c712: e8 95 2c 00 00 call 10f3ac <_Thread_Enable_dispatch> return RTEMS_TIMEOUT; 10c717: 83 c4 10 add $0x10,%esp 10c71a: b8 06 00 00 00 mov $0x6,%eax 10c71f: e9 5d ff ff ff jmp 10c681 _Thread_Enable_dispatch(); return RTEMS_NOT_OWNER_OF_RESOURCE; } if ( length == RTEMS_PERIOD_STATUS ) { switch ( the_period->state ) { 10c724: 31 c0 xor %eax,%eax 10c726: eb 97 jmp 10c6bf <== NOT EXECUTED return( return_value ); } _ISR_Disable( level ); if ( the_period->state == RATE_MONOTONIC_INACTIVE ) { _ISR_Enable( level ); 10c728: 57 push %edi 10c729: 9d popf /* * Baseline statistics information for the beginning of a period. */ _Rate_monotonic_Initiate_statistics( the_period ); 10c72a: 83 ec 0c sub $0xc,%esp 10c72d: 50 push %eax 10c72e: 89 45 d4 mov %eax,-0x2c(%ebp) 10c731: e8 ba fd ff ff call 10c4f0 <_Rate_monotonic_Initiate_statistics> the_period->state = RATE_MONOTONIC_ACTIVE; 10c736: 8b 45 d4 mov -0x2c(%ebp),%eax 10c739: c7 40 38 02 00 00 00 movl $0x2,0x38(%eax) Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 10c740: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) the_watchdog->routine = routine; 10c747: c7 40 2c ac ca 10 00 movl $0x10caac,0x2c(%eax) the_watchdog->id = id; 10c74e: 89 58 30 mov %ebx,0x30(%eax) the_watchdog->user_data = user_data; 10c751: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax) _Rate_monotonic_Timeout, id, NULL ); the_period->next_length = length; 10c758: 89 70 3c mov %esi,0x3c(%eax) Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10c75b: 89 70 1c mov %esi,0x1c(%eax) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10c75e: 5e pop %esi 10c75f: 5f pop %edi _Watchdog_Insert_ticks( &the_period->Timer, length ); 10c760: 83 c0 10 add $0x10,%eax 10c763: 50 push %eax 10c764: 68 20 b2 12 00 push $0x12b220 10c769: e8 ae 3a 00 00 call 11021c <_Watchdog_Insert> _Thread_Enable_dispatch(); 10c76e: e8 39 2c 00 00 call 10f3ac <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10c773: 83 c4 10 add $0x10,%esp 10c776: 31 c0 xor %eax,%eax 10c778: e9 04 ff ff ff jmp 10c681 if ( the_period->state == RATE_MONOTONIC_ACTIVE ) { /* * Update statistics from the concluding period. */ _Rate_monotonic_Update_statistics( the_period ); 10c77d: 83 ec 0c sub $0xc,%esp 10c780: 50 push %eax 10c781: 89 45 d4 mov %eax,-0x2c(%ebp) 10c784: e8 db fd ff ff call 10c564 <_Rate_monotonic_Update_statistics> /* * This tells the _Rate_monotonic_Timeout that this task is * in the process of blocking on the period and that we * may be changing the length of the next period. */ the_period->state = RATE_MONOTONIC_OWNER_IS_BLOCKING; 10c789: 8b 45 d4 mov -0x2c(%ebp),%eax 10c78c: c7 40 38 01 00 00 00 movl $0x1,0x38(%eax) the_period->next_length = length; 10c793: 89 70 3c mov %esi,0x3c(%eax) _ISR_Enable( level ); 10c796: 57 push %edi 10c797: 9d popf _Thread_Executing->Wait.id = the_period->Object.id; 10c798: 8b 15 f8 b6 12 00 mov 0x12b6f8,%edx 10c79e: 8b 48 08 mov 0x8(%eax),%ecx 10c7a1: 89 4a 20 mov %ecx,0x20(%edx) _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 10c7a4: 59 pop %ecx 10c7a5: 5b pop %ebx 10c7a6: 68 00 40 00 00 push $0x4000 10c7ab: 52 push %edx 10c7ac: 89 45 d4 mov %eax,-0x2c(%ebp) 10c7af: e8 18 34 00 00 call 10fbcc <_Thread_Set_state> /* * Did the watchdog timer expire while we were actually blocking * on it? */ _ISR_Disable( level ); 10c7b4: 9c pushf 10c7b5: fa cli 10c7b6: 59 pop %ecx local_state = the_period->state; 10c7b7: 8b 45 d4 mov -0x2c(%ebp),%eax 10c7ba: 8b 50 38 mov 0x38(%eax),%edx the_period->state = RATE_MONOTONIC_ACTIVE; 10c7bd: c7 40 38 02 00 00 00 movl $0x2,0x38(%eax) _ISR_Enable( level ); 10c7c4: 51 push %ecx 10c7c5: 9d popf /* * If it did, then we want to unblock ourself and continue as * if nothing happen. The period was reset in the timeout routine. */ if ( local_state == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING ) 10c7c6: 83 c4 10 add $0x10,%esp 10c7c9: 83 fa 03 cmp $0x3,%edx 10c7cc: 74 0c je 10c7da _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); _Thread_Enable_dispatch(); 10c7ce: e8 d9 2b 00 00 call 10f3ac <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10c7d3: 31 c0 xor %eax,%eax 10c7d5: e9 a7 fe ff ff jmp 10c681 /* * If it did, then we want to unblock ourself and continue as * if nothing happen. The period was reset in the timeout routine. */ if ( local_state == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING ) _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 10c7da: 57 push %edi 10c7db: 57 push %edi 10c7dc: 68 00 40 00 00 push $0x4000 10c7e1: ff 35 f8 b6 12 00 pushl 0x12b6f8 10c7e7: e8 5c 28 00 00 call 10f048 <_Thread_Clear_state> 10c7ec: 83 c4 10 add $0x10,%esp 10c7ef: eb dd jmp 10c7ce =============================================================================== 0010c7f4 : */ void rtems_rate_monotonic_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) { 10c7f4: 55 push %ebp 10c7f5: 89 e5 mov %esp,%ebp 10c7f7: 57 push %edi 10c7f8: 56 push %esi 10c7f9: 53 push %ebx 10c7fa: 81 ec 8c 00 00 00 sub $0x8c,%esp 10c800: 8b 75 08 mov 0x8(%ebp),%esi rtems_id id; rtems_rate_monotonic_period_statistics the_stats; rtems_rate_monotonic_period_status the_status; char name[5]; if ( !print ) 10c803: 8b 7d 0c mov 0xc(%ebp),%edi 10c806: 85 ff test %edi,%edi 10c808: 0f 84 be 00 00 00 je 10c8cc <== NEVER TAKEN return; (*print)( context, "Period information by period\n" ); 10c80e: 83 ec 08 sub $0x8,%esp 10c811: 68 30 3d 12 00 push $0x123d30 10c816: 56 push %esi 10c817: ff 55 0c call *0xc(%ebp) #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ (*print)( context, "--- CPU times are in seconds ---\n" ); 10c81a: 59 pop %ecx 10c81b: 5b pop %ebx 10c81c: 68 68 3d 12 00 push $0x123d68 10c821: 56 push %esi 10c822: ff 55 0c call *0xc(%ebp) (*print)( context, "--- Wall times are in seconds ---\n" ); 10c825: 58 pop %eax 10c826: 5a pop %edx 10c827: 68 8c 3d 12 00 push $0x123d8c 10c82c: 56 push %esi 10c82d: ff 55 0c call *0xc(%ebp) Be sure to test the various cases. (*print)( context,"\ 1234567890123456789012345678901234567890123456789012345678901234567890123456789\ \n"); */ (*print)( context, " ID OWNER COUNT MISSED " 10c830: 5b pop %ebx 10c831: 5f pop %edi 10c832: 68 b0 3d 12 00 push $0x123db0 10c837: 56 push %esi 10c838: ff 55 0c call *0xc(%ebp) #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ " " #endif " WALL TIME\n" ); (*print)( context, " " 10c83b: 5a pop %edx 10c83c: 59 pop %ecx 10c83d: 68 fc 3d 12 00 push $0x123dfc 10c842: 56 push %esi 10c843: ff 55 0c call *0xc(%ebp) /* * Cycle through all possible ids and try to report on each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; 10c846: 8b 1d 68 b0 12 00 mov 0x12b068,%ebx 10c84c: 83 c4 10 add $0x10,%esp 10c84f: 3b 1d 6c b0 12 00 cmp 0x12b06c,%ebx 10c855: 77 75 ja 10c8cc <== NEVER TAKEN 10c857: 8d 7d 88 lea -0x78(%ebp),%edi 10c85a: eb 09 jmp 10c865 id <= _Rate_monotonic_Information.maximum_id ; id++ ) { 10c85c: 43 inc %ebx /* * Cycle through all possible ids and try to report on each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; 10c85d: 39 1d 6c b0 12 00 cmp %ebx,0x12b06c 10c863: 72 67 jb 10c8cc id <= _Rate_monotonic_Information.maximum_id ; id++ ) { status = rtems_rate_monotonic_get_statistics( id, &the_stats ); 10c865: 83 ec 08 sub $0x8,%esp 10c868: 57 push %edi 10c869: 53 push %ebx 10c86a: e8 e5 5f 00 00 call 112854 if ( status != RTEMS_SUCCESSFUL ) 10c86f: 83 c4 10 add $0x10,%esp 10c872: 85 c0 test %eax,%eax 10c874: 75 e6 jne 10c85c #if defined(RTEMS_DEBUG) status = rtems_rate_monotonic_get_status( id, &the_status ); if ( status != RTEMS_SUCCESSFUL ) continue; #else (void) rtems_rate_monotonic_get_status( id, &the_status ); 10c876: 83 ec 08 sub $0x8,%esp 10c879: 8d 45 c0 lea -0x40(%ebp),%eax 10c87c: 50 push %eax 10c87d: 53 push %ebx 10c87e: e8 7d 60 00 00 call 112900 #endif rtems_object_get_name( the_status.owner, sizeof(name), name ); 10c883: 83 c4 0c add $0xc,%esp 10c886: 8d 55 e3 lea -0x1d(%ebp),%edx 10c889: 52 push %edx 10c88a: 6a 05 push $0x5 10c88c: ff 75 c0 pushl -0x40(%ebp) 10c88f: e8 b4 02 00 00 call 10cb48 /* * Print part of report line that is not dependent on granularity */ (*print)( context, 10c894: 59 pop %ecx 10c895: 58 pop %eax 10c896: ff 75 8c pushl -0x74(%ebp) 10c899: ff 75 88 pushl -0x78(%ebp) 10c89c: 8d 45 e3 lea -0x1d(%ebp),%eax 10c89f: 50 push %eax 10c8a0: 53 push %ebx 10c8a1: 68 4e 3d 12 00 push $0x123d4e 10c8a6: 56 push %esi 10c8a7: ff 55 0c call *0xc(%ebp) ); /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { 10c8aa: 8b 45 88 mov -0x78(%ebp),%eax 10c8ad: 83 c4 20 add $0x20,%esp 10c8b0: 85 c0 test %eax,%eax 10c8b2: 75 20 jne 10c8d4 (*print)( context, "\n" ); 10c8b4: 83 ec 08 sub $0x8,%esp 10c8b7: 68 31 1e 12 00 push $0x121e31 10c8bc: 56 push %esi 10c8bd: ff 55 0c call *0xc(%ebp) continue; 10c8c0: 83 c4 10 add $0x10,%esp * Cycle through all possible ids and try to report on each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; id <= _Rate_monotonic_Information.maximum_id ; id++ ) { 10c8c3: 43 inc %ebx /* * Cycle through all possible ids and try to report on each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; 10c8c4: 39 1d 6c b0 12 00 cmp %ebx,0x12b06c 10c8ca: 73 99 jae 10c865 <== ALWAYS TAKEN the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall ); #endif } } } 10c8cc: 8d 65 f4 lea -0xc(%ebp),%esp 10c8cf: 5b pop %ebx 10c8d0: 5e pop %esi 10c8d1: 5f pop %edi 10c8d2: c9 leave 10c8d3: c3 ret struct timespec cpu_average; struct timespec *min_cpu = &the_stats.min_cpu_time; struct timespec *max_cpu = &the_stats.max_cpu_time; struct timespec *total_cpu = &the_stats.total_cpu_time; _Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average ); 10c8d4: 52 push %edx 10c8d5: 8d 55 d8 lea -0x28(%ebp),%edx 10c8d8: 52 push %edx 10c8d9: 50 push %eax 10c8da: 8d 45 a0 lea -0x60(%ebp),%eax 10c8dd: 50 push %eax 10c8de: e8 99 35 00 00 call 10fe7c <_Timespec_Divide_by_integer> (*print)( context, 10c8e3: b9 d3 4d 62 10 mov $0x10624dd3,%ecx 10c8e8: 8b 45 dc mov -0x24(%ebp),%eax 10c8eb: f7 e9 imul %ecx 10c8ed: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp) 10c8f3: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax 10c8f9: c1 f8 06 sar $0x6,%eax 10c8fc: 8b 55 dc mov -0x24(%ebp),%edx 10c8ff: c1 fa 1f sar $0x1f,%edx 10c902: 29 d0 sub %edx,%eax 10c904: 50 push %eax 10c905: ff 75 d8 pushl -0x28(%ebp) 10c908: 8b 45 9c mov -0x64(%ebp),%eax 10c90b: f7 e9 imul %ecx 10c90d: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp) 10c913: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax 10c919: c1 f8 06 sar $0x6,%eax 10c91c: 8b 55 9c mov -0x64(%ebp),%edx 10c91f: c1 fa 1f sar $0x1f,%edx 10c922: 29 d0 sub %edx,%eax 10c924: 50 push %eax 10c925: ff 75 98 pushl -0x68(%ebp) 10c928: 8b 45 94 mov -0x6c(%ebp),%eax 10c92b: f7 e9 imul %ecx 10c92d: 89 85 70 ff ff ff mov %eax,-0x90(%ebp) 10c933: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp) 10c939: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax 10c93f: c1 f8 06 sar $0x6,%eax 10c942: 8b 55 94 mov -0x6c(%ebp),%edx 10c945: c1 fa 1f sar $0x1f,%edx 10c948: 29 d0 sub %edx,%eax 10c94a: 50 push %eax 10c94b: ff 75 90 pushl -0x70(%ebp) 10c94e: 68 48 3e 12 00 push $0x123e48 10c953: 56 push %esi 10c954: 89 4d 84 mov %ecx,-0x7c(%ebp) 10c957: ff 55 0c call *0xc(%ebp) struct timespec wall_average; struct timespec *min_wall = &the_stats.min_wall_time; struct timespec *max_wall = &the_stats.max_wall_time; struct timespec *total_wall = &the_stats.total_wall_time; _Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average); 10c95a: 83 c4 2c add $0x2c,%esp 10c95d: 8d 55 d8 lea -0x28(%ebp),%edx 10c960: 52 push %edx 10c961: ff 75 88 pushl -0x78(%ebp) 10c964: 8d 45 b8 lea -0x48(%ebp),%eax 10c967: 50 push %eax 10c968: e8 0f 35 00 00 call 10fe7c <_Timespec_Divide_by_integer> (*print)( context, 10c96d: 8b 4d 84 mov -0x7c(%ebp),%ecx 10c970: 8b 45 dc mov -0x24(%ebp),%eax 10c973: f7 e9 imul %ecx 10c975: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp) 10c97b: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax 10c981: c1 f8 06 sar $0x6,%eax 10c984: 8b 55 dc mov -0x24(%ebp),%edx 10c987: c1 fa 1f sar $0x1f,%edx 10c98a: 29 d0 sub %edx,%eax 10c98c: 50 push %eax 10c98d: ff 75 d8 pushl -0x28(%ebp) 10c990: 8b 45 b4 mov -0x4c(%ebp),%eax 10c993: f7 e9 imul %ecx 10c995: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp) 10c99b: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax 10c9a1: c1 f8 06 sar $0x6,%eax 10c9a4: 8b 55 b4 mov -0x4c(%ebp),%edx 10c9a7: c1 fa 1f sar $0x1f,%edx 10c9aa: 29 d0 sub %edx,%eax 10c9ac: 50 push %eax 10c9ad: ff 75 b0 pushl -0x50(%ebp) 10c9b0: 8b 45 ac mov -0x54(%ebp),%eax 10c9b3: f7 e9 imul %ecx 10c9b5: 89 85 70 ff ff ff mov %eax,-0x90(%ebp) 10c9bb: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp) 10c9c1: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax 10c9c7: c1 f8 06 sar $0x6,%eax 10c9ca: 8b 55 ac mov -0x54(%ebp),%edx 10c9cd: c1 fa 1f sar $0x1f,%edx 10c9d0: 29 d0 sub %edx,%eax 10c9d2: 50 push %eax 10c9d3: ff 75 a8 pushl -0x58(%ebp) 10c9d6: 68 68 3e 12 00 push $0x123e68 10c9db: 56 push %esi 10c9dc: ff 55 0c call *0xc(%ebp) 10c9df: 83 c4 30 add $0x30,%esp 10c9e2: e9 75 fe ff ff jmp 10c85c =============================================================================== 0010ca00 : /* * rtems_rate_monotonic_reset_all_statistics */ void rtems_rate_monotonic_reset_all_statistics( void ) { 10ca00: 55 push %ebp 10ca01: 89 e5 mov %esp,%ebp 10ca03: 53 push %ebx 10ca04: 83 ec 04 sub $0x4,%esp 10ca07: a1 50 b1 12 00 mov 0x12b150,%eax 10ca0c: 40 inc %eax 10ca0d: a3 50 b1 12 00 mov %eax,0x12b150 /* * Cycle through all possible ids and try to reset each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; 10ca12: 8b 1d 68 b0 12 00 mov 0x12b068,%ebx 10ca18: 3b 1d 6c b0 12 00 cmp 0x12b06c,%ebx 10ca1e: 77 15 ja 10ca35 <== NEVER TAKEN id <= _Rate_monotonic_Information.maximum_id ; id++ ) { (void) rtems_rate_monotonic_reset_statistics( id ); 10ca20: 83 ec 0c sub $0xc,%esp 10ca23: 53 push %ebx 10ca24: e8 17 00 00 00 call 10ca40 * Cycle through all possible ids and try to reset each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; id <= _Rate_monotonic_Information.maximum_id ; id++ ) { 10ca29: 43 inc %ebx /* * Cycle through all possible ids and try to reset each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; 10ca2a: 83 c4 10 add $0x10,%esp 10ca2d: 39 1d 6c b0 12 00 cmp %ebx,0x12b06c 10ca33: 73 eb jae 10ca20 /* * Done so exit thread dispatching disabled critical section. */ _Thread_Enable_dispatch(); } 10ca35: 8b 5d fc mov -0x4(%ebp),%ebx 10ca38: c9 leave } /* * Done so exit thread dispatching disabled critical section. */ _Thread_Enable_dispatch(); 10ca39: e9 6e 29 00 00 jmp 10f3ac <_Thread_Enable_dispatch> =============================================================================== 0010ca40 : */ rtems_status_code rtems_rate_monotonic_reset_statistics( rtems_id id ) { 10ca40: 55 push %ebp 10ca41: 89 e5 mov %esp,%ebp 10ca43: 57 push %edi 10ca44: 53 push %ebx 10ca45: 83 ec 14 sub $0x14,%esp Objects_Locations location; Rate_monotonic_Control *the_period; the_period = _Rate_monotonic_Get( id, &location ); 10ca48: 8d 45 f4 lea -0xc(%ebp),%eax 10ca4b: 50 push %eax 10ca4c: ff 75 08 pushl 0x8(%ebp) 10ca4f: 68 60 b0 12 00 push $0x12b060 10ca54: e8 db 1d 00 00 call 10e834 <_Objects_Get> 10ca59: 89 c2 mov %eax,%edx switch ( location ) { 10ca5b: 83 c4 10 add $0x10,%esp 10ca5e: 8b 45 f4 mov -0xc(%ebp),%eax 10ca61: 85 c0 test %eax,%eax 10ca63: 75 3b jne 10caa0 case OBJECTS_LOCAL: _Rate_monotonic_Reset_statistics( the_period ); 10ca65: 8d 5a 54 lea 0x54(%edx),%ebx 10ca68: b9 38 00 00 00 mov $0x38,%ecx 10ca6d: 31 c0 xor %eax,%eax 10ca6f: 89 df mov %ebx,%edi 10ca71: f3 aa rep stos %al,%es:(%edi) 10ca73: c7 42 5c ff ff ff 7f movl $0x7fffffff,0x5c(%edx) 10ca7a: c7 42 60 ff ff ff 7f movl $0x7fffffff,0x60(%edx) 10ca81: c7 42 74 ff ff ff 7f movl $0x7fffffff,0x74(%edx) 10ca88: c7 42 78 ff ff ff 7f movl $0x7fffffff,0x78(%edx) _Thread_Enable_dispatch(); 10ca8f: e8 18 29 00 00 call 10f3ac <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10ca94: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10ca96: 8d 65 f8 lea -0x8(%ebp),%esp 10ca99: 5b pop %ebx 10ca9a: 5f pop %edi 10ca9b: c9 leave 10ca9c: c3 ret 10ca9d: 8d 76 00 lea 0x0(%esi),%esi #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10caa0: b8 04 00 00 00 mov $0x4,%eax } 10caa5: 8d 65 f8 lea -0x8(%ebp),%esp 10caa8: 5b pop %ebx 10caa9: 5f pop %edi 10caaa: c9 leave 10caab: c3 ret =============================================================================== 0011724c : uintptr_t length, uintptr_t page_size, rtems_attribute attribute_set, rtems_id *id ) { 11724c: 55 push %ebp 11724d: 89 e5 mov %esp,%ebp 11724f: 57 push %edi 117250: 56 push %esi 117251: 53 push %ebx 117252: 83 ec 1c sub $0x1c,%esp 117255: 8b 7d 08 mov 0x8(%ebp),%edi 117258: 8b 75 0c mov 0xc(%ebp),%esi rtems_status_code return_status; Region_Control *the_region; if ( !rtems_is_name_valid( name ) ) 11725b: 85 ff test %edi,%edi 11725d: 0f 84 c1 00 00 00 je 117324 return RTEMS_INVALID_NAME; if ( !starting_address ) 117263: 85 f6 test %esi,%esi 117265: 0f 84 e1 00 00 00 je 11734c return RTEMS_INVALID_ADDRESS; if ( !id ) 11726b: 8b 45 1c mov 0x1c(%ebp),%eax 11726e: 85 c0 test %eax,%eax 117270: 0f 84 d6 00 00 00 je 11734c return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); /* to prevent deletion */ 117276: 83 ec 0c sub $0xc,%esp 117279: ff 35 e0 2a 14 00 pushl 0x142ae0 11727f: e8 24 25 00 00 call 1197a8 <_API_Mutex_Lock> * This function allocates a region control block from * the inactive chain of free region control blocks. */ RTEMS_INLINE_ROUTINE Region_Control *_Region_Allocate( void ) { return (Region_Control *) _Objects_Allocate( &_Region_Information ); 117284: c7 04 24 40 29 14 00 movl $0x142940,(%esp) 11728b: e8 5c 3b 00 00 call 11adec <_Objects_Allocate> 117290: 89 c3 mov %eax,%ebx the_region = _Region_Allocate(); if ( !the_region ) 117292: 83 c4 10 add $0x10,%esp 117295: 85 c0 test %eax,%eax 117297: 0f 84 bf 00 00 00 je 11735c return_status = RTEMS_TOO_MANY; else { the_region->maximum_segment_size = _Heap_Initialize( 11729d: ff 75 14 pushl 0x14(%ebp) 1172a0: ff 75 10 pushl 0x10(%ebp) 1172a3: 56 push %esi 1172a4: 8d 40 68 lea 0x68(%eax),%eax 1172a7: 50 push %eax 1172a8: e8 4b 37 00 00 call 11a9f8 <_Heap_Initialize> 1172ad: 89 43 5c mov %eax,0x5c(%ebx) &the_region->Memory, starting_address, length, page_size ); if ( !the_region->maximum_segment_size ) { 1172b0: 83 c4 10 add $0x10,%esp 1172b3: 85 c0 test %eax,%eax 1172b5: 74 7d je 117334 return_status = RTEMS_INVALID_SIZE; } else { the_region->starting_address = starting_address; 1172b7: 89 73 50 mov %esi,0x50(%ebx) the_region->length = length; 1172ba: 8b 45 10 mov 0x10(%ebp),%eax 1172bd: 89 43 54 mov %eax,0x54(%ebx) the_region->page_size = page_size; 1172c0: 8b 55 14 mov 0x14(%ebp),%edx 1172c3: 89 53 58 mov %edx,0x58(%ebx) the_region->attribute_set = attribute_set; 1172c6: 8b 45 18 mov 0x18(%ebp),%eax 1172c9: 89 43 60 mov %eax,0x60(%ebx) the_region->number_of_used_blocks = 0; 1172cc: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx) _Thread_queue_Initialize( 1172d3: 6a 06 push $0x6 1172d5: 6a 40 push $0x40 1172d7: a8 04 test $0x4,%al 1172d9: 0f 95 c0 setne %al 1172dc: 0f b6 c0 movzbl %al,%eax 1172df: 50 push %eax 1172e0: 8d 43 10 lea 0x10(%ebx),%eax 1172e3: 50 push %eax 1172e4: e8 77 52 00 00 call 11c560 <_Thread_queue_Initialize> Objects_Name name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 1172e9: 8b 43 08 mov 0x8(%ebx),%eax Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 1172ec: 0f b7 c8 movzwl %ax,%ecx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 1172ef: 8b 15 5c 29 14 00 mov 0x14295c,%edx 1172f5: 89 1c 8a mov %ebx,(%edx,%ecx,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 1172f8: 89 7b 0c mov %edi,0xc(%ebx) &_Region_Information, &the_region->Object, (Objects_Name) name ); *id = the_region->Object.id; 1172fb: 8b 55 1c mov 0x1c(%ebp),%edx 1172fe: 89 02 mov %eax,(%edx) 117300: 83 c4 10 add $0x10,%esp return_status = RTEMS_SUCCESSFUL; 117303: 31 c0 xor %eax,%eax } } _RTEMS_Unlock_allocator(); 117305: 83 ec 0c sub $0xc,%esp 117308: ff 35 e0 2a 14 00 pushl 0x142ae0 11730e: 89 45 e4 mov %eax,-0x1c(%ebp) 117311: e8 da 24 00 00 call 1197f0 <_API_Mutex_Unlock> return return_status; 117316: 83 c4 10 add $0x10,%esp 117319: 8b 45 e4 mov -0x1c(%ebp),%eax } 11731c: 8d 65 f4 lea -0xc(%ebp),%esp 11731f: 5b pop %ebx 117320: 5e pop %esi 117321: 5f pop %edi 117322: c9 leave 117323: c3 ret { rtems_status_code return_status; Region_Control *the_region; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 117324: b8 03 00 00 00 mov $0x3,%eax } } _RTEMS_Unlock_allocator(); return return_status; } 117329: 8d 65 f4 lea -0xc(%ebp),%esp 11732c: 5b pop %ebx 11732d: 5e pop %esi 11732e: 5f pop %edi 11732f: c9 leave 117330: c3 ret 117331: 8d 76 00 lea 0x0(%esi),%esi */ RTEMS_INLINE_ROUTINE void _Region_Free ( Region_Control *the_region ) { _Objects_Free( &_Region_Information, &the_region->Object ); 117334: 83 ec 08 sub $0x8,%esp 117337: 53 push %ebx 117338: 68 40 29 14 00 push $0x142940 11733d: e8 1e 3e 00 00 call 11b160 <_Objects_Free> 117342: 83 c4 10 add $0x10,%esp &the_region->Memory, starting_address, length, page_size ); if ( !the_region->maximum_segment_size ) { _Region_Free( the_region ); return_status = RTEMS_INVALID_SIZE; 117345: b8 08 00 00 00 mov $0x8,%eax 11734a: eb b9 jmp 117305 if ( !starting_address ) return RTEMS_INVALID_ADDRESS; if ( !id ) return RTEMS_INVALID_ADDRESS; 11734c: b8 09 00 00 00 mov $0x9,%eax } } _RTEMS_Unlock_allocator(); return return_status; } 117351: 8d 65 f4 lea -0xc(%ebp),%esp 117354: 5b pop %ebx 117355: 5e pop %esi 117356: 5f pop %edi 117357: c9 leave 117358: c3 ret 117359: 8d 76 00 lea 0x0(%esi),%esi _RTEMS_Lock_allocator(); /* to prevent deletion */ the_region = _Region_Allocate(); if ( !the_region ) return_status = RTEMS_TOO_MANY; 11735c: b8 05 00 00 00 mov $0x5,%eax 117361: eb a2 jmp 117305 =============================================================================== 00117364 : */ rtems_status_code rtems_region_delete( rtems_id id ) { 117364: 55 push %ebp 117365: 89 e5 mov %esp,%ebp 117367: 53 push %ebx 117368: 83 ec 30 sub $0x30,%esp Objects_Locations location; rtems_status_code return_status; Region_Control *the_region; _RTEMS_Lock_allocator(); 11736b: ff 35 e0 2a 14 00 pushl 0x142ae0 117371: e8 32 24 00 00 call 1197a8 <_API_Mutex_Lock> Objects_Id id, Objects_Locations *location ) { return (Region_Control *) _Objects_Get_no_protection( &_Region_Information, id, location ); 117376: 83 c4 0c add $0xc,%esp the_region = _Region_Get( id, &location ); 117379: 8d 45 f4 lea -0xc(%ebp),%eax 11737c: 50 push %eax 11737d: ff 75 08 pushl 0x8(%ebp) 117380: 68 40 29 14 00 push $0x142940 117385: e8 16 3f 00 00 call 11b2a0 <_Objects_Get_no_protection> switch ( location ) { 11738a: 83 c4 10 add $0x10,%esp 11738d: 8b 5d f4 mov -0xc(%ebp),%ebx 117390: 85 db test %ebx,%ebx 117392: 74 1c je 1173b0 break; #endif case OBJECTS_ERROR: default: return_status = RTEMS_INVALID_ID; 117394: bb 04 00 00 00 mov $0x4,%ebx break; } _RTEMS_Unlock_allocator(); 117399: 83 ec 0c sub $0xc,%esp 11739c: ff 35 e0 2a 14 00 pushl 0x142ae0 1173a2: e8 49 24 00 00 call 1197f0 <_API_Mutex_Unlock> return return_status; } 1173a7: 89 d8 mov %ebx,%eax 1173a9: 8b 5d fc mov -0x4(%ebp),%ebx 1173ac: c9 leave 1173ad: c3 ret 1173ae: 66 90 xchg %ax,%ax the_region = _Region_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: _Region_Debug_Walk( the_region, 5 ); if ( the_region->number_of_used_blocks != 0 ) 1173b0: 8b 48 64 mov 0x64(%eax),%ecx 1173b3: 85 c9 test %ecx,%ecx 1173b5: 74 09 je 1173c0 return_status = RTEMS_RESOURCE_IN_USE; 1173b7: bb 0c 00 00 00 mov $0xc,%ebx 1173bc: eb db jmp 117399 1173be: 66 90 xchg %ax,%ax else { _Objects_Close( &_Region_Information, &the_region->Object ); 1173c0: 83 ec 08 sub $0x8,%esp 1173c3: 50 push %eax 1173c4: 68 40 29 14 00 push $0x142940 1173c9: 89 45 e4 mov %eax,-0x1c(%ebp) 1173cc: e8 97 3a 00 00 call 11ae68 <_Objects_Close> */ RTEMS_INLINE_ROUTINE void _Region_Free ( Region_Control *the_region ) { _Objects_Free( &_Region_Information, &the_region->Object ); 1173d1: 58 pop %eax 1173d2: 5a pop %edx 1173d3: 8b 45 e4 mov -0x1c(%ebp),%eax 1173d6: 50 push %eax 1173d7: 68 40 29 14 00 push $0x142940 1173dc: e8 7f 3d 00 00 call 11b160 <_Objects_Free> 1173e1: 83 c4 10 add $0x10,%esp _Region_Free( the_region ); return_status = RTEMS_SUCCESSFUL; 1173e4: 31 db xor %ebx,%ebx 1173e6: eb b1 jmp 117399 =============================================================================== 001173e8 : rtems_status_code rtems_region_extend( rtems_id id, void *starting_address, uintptr_t length ) { 1173e8: 55 push %ebp 1173e9: 89 e5 mov %esp,%ebp 1173eb: 56 push %esi 1173ec: 53 push %ebx 1173ed: 83 ec 10 sub $0x10,%esp 1173f0: 8b 5d 0c mov 0xc(%ebp),%ebx bool extend_ok; Objects_Locations location; rtems_status_code return_status; Region_Control *the_region; if ( !starting_address ) 1173f3: 85 db test %ebx,%ebx 1173f5: 74 75 je 11746c return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); /* to prevent deletion */ 1173f7: 83 ec 0c sub $0xc,%esp 1173fa: ff 35 e0 2a 14 00 pushl 0x142ae0 117400: e8 a3 23 00 00 call 1197a8 <_API_Mutex_Lock> Objects_Id id, Objects_Locations *location ) { return (Region_Control *) _Objects_Get_no_protection( &_Region_Information, id, location ); 117405: 83 c4 0c add $0xc,%esp the_region = _Region_Get( id, &location ); 117408: 8d 45 f0 lea -0x10(%ebp),%eax 11740b: 50 push %eax 11740c: ff 75 08 pushl 0x8(%ebp) 11740f: 68 40 29 14 00 push $0x142940 117414: e8 87 3e 00 00 call 11b2a0 <_Objects_Get_no_protection> 117419: 89 c6 mov %eax,%esi switch ( location ) { 11741b: 83 c4 10 add $0x10,%esp 11741e: 8b 45 f0 mov -0x10(%ebp),%eax 117421: 85 c0 test %eax,%eax 117423: 74 1f je 117444 break; #endif case OBJECTS_ERROR: default: return_status = RTEMS_INVALID_ID; 117425: bb 04 00 00 00 mov $0x4,%ebx break; } _RTEMS_Unlock_allocator(); 11742a: 83 ec 0c sub $0xc,%esp 11742d: ff 35 e0 2a 14 00 pushl 0x142ae0 117433: e8 b8 23 00 00 call 1197f0 <_API_Mutex_Unlock> return return_status; 117438: 83 c4 10 add $0x10,%esp } 11743b: 89 d8 mov %ebx,%eax 11743d: 8d 65 f8 lea -0x8(%ebp),%esp 117440: 5b pop %ebx 117441: 5e pop %esi 117442: c9 leave 117443: c3 ret the_region = _Region_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: extend_ok = _Heap_Extend( 117444: 8d 45 f4 lea -0xc(%ebp),%eax 117447: 50 push %eax 117448: ff 75 10 pushl 0x10(%ebp) 11744b: 53 push %ebx 11744c: 8d 46 68 lea 0x68(%esi),%eax 11744f: 50 push %eax 117450: e8 97 2f 00 00 call 11a3ec <_Heap_Extend> starting_address, length, &amount_extended ); if ( extend_ok ) { 117455: 83 c4 10 add $0x10,%esp 117458: 84 c0 test %al,%al 11745a: 74 20 je 11747c the_region->length += amount_extended; 11745c: 8b 45 f4 mov -0xc(%ebp),%eax 11745f: 01 46 54 add %eax,0x54(%esi) the_region->maximum_segment_size += amount_extended; 117462: 01 46 5c add %eax,0x5c(%esi) return_status = RTEMS_SUCCESSFUL; 117465: 31 db xor %ebx,%ebx 117467: eb c1 jmp 11742a 117469: 8d 76 00 lea 0x0(%esi),%esi Objects_Locations location; rtems_status_code return_status; Region_Control *the_region; if ( !starting_address ) return RTEMS_INVALID_ADDRESS; 11746c: bb 09 00 00 00 mov $0x9,%ebx break; } _RTEMS_Unlock_allocator(); return return_status; } 117471: 89 d8 mov %ebx,%eax 117473: 8d 65 f8 lea -0x8(%ebp),%esp 117476: 5b pop %ebx 117477: 5e pop %esi 117478: c9 leave 117479: c3 ret 11747a: 66 90 xchg %ax,%ax if ( extend_ok ) { the_region->length += amount_extended; the_region->maximum_segment_size += amount_extended; return_status = RTEMS_SUCCESSFUL; } else { return_status = RTEMS_INVALID_ADDRESS; 11747c: bb 09 00 00 00 mov $0x9,%ebx 117481: eb a7 jmp 11742a =============================================================================== 00117484 : rtems_status_code rtems_region_get_free_information( rtems_id id, Heap_Information_block *the_info ) { 117484: 55 push %ebp 117485: 89 e5 mov %esp,%ebp 117487: 53 push %ebx 117488: 83 ec 14 sub $0x14,%esp 11748b: 8b 5d 0c mov 0xc(%ebp),%ebx Objects_Locations location; rtems_status_code return_status; register Region_Control *the_region; if ( !the_info ) 11748e: 85 db test %ebx,%ebx 117490: 74 76 je 117508 return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); 117492: 83 ec 0c sub $0xc,%esp 117495: ff 35 e0 2a 14 00 pushl 0x142ae0 11749b: e8 08 23 00 00 call 1197a8 <_API_Mutex_Lock> 1174a0: 83 c4 0c add $0xc,%esp the_region = _Region_Get( id, &location ); 1174a3: 8d 45 f4 lea -0xc(%ebp),%eax 1174a6: 50 push %eax 1174a7: ff 75 08 pushl 0x8(%ebp) 1174aa: 68 40 29 14 00 push $0x142940 1174af: e8 ec 3d 00 00 call 11b2a0 <_Objects_Get_no_protection> switch ( location ) { 1174b4: 83 c4 10 add $0x10,%esp 1174b7: 8b 55 f4 mov -0xc(%ebp),%edx 1174ba: 85 d2 test %edx,%edx 1174bc: 74 1e je 1174dc break; #endif case OBJECTS_ERROR: default: return_status = RTEMS_INVALID_ID; 1174be: bb 04 00 00 00 mov $0x4,%ebx break; } _RTEMS_Unlock_allocator(); 1174c3: 83 ec 0c sub $0xc,%esp 1174c6: ff 35 e0 2a 14 00 pushl 0x142ae0 1174cc: e8 1f 23 00 00 call 1197f0 <_API_Mutex_Unlock> return return_status; 1174d1: 83 c4 10 add $0x10,%esp } 1174d4: 89 d8 mov %ebx,%eax 1174d6: 8b 5d fc mov -0x4(%ebp),%ebx 1174d9: c9 leave 1174da: c3 ret 1174db: 90 nop the_region = _Region_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: the_info->Used.number = 0; 1174dc: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) the_info->Used.total = 0; 1174e3: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx) the_info->Used.largest = 0; 1174ea: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) _Heap_Get_free_information( &the_region->Memory, &the_info->Free ); 1174f1: 83 ec 08 sub $0x8,%esp 1174f4: 53 push %ebx 1174f5: 83 c0 68 add $0x68,%eax 1174f8: 50 push %eax 1174f9: e8 d6 32 00 00 call 11a7d4 <_Heap_Get_free_information> return_status = RTEMS_SUCCESSFUL; break; 1174fe: 83 c4 10 add $0x10,%esp the_info->Used.total = 0; the_info->Used.largest = 0; _Heap_Get_free_information( &the_region->Memory, &the_info->Free ); return_status = RTEMS_SUCCESSFUL; 117501: 31 db xor %ebx,%ebx break; 117503: eb be jmp 1174c3 117505: 8d 76 00 lea 0x0(%esi),%esi Objects_Locations location; rtems_status_code return_status; register Region_Control *the_region; if ( !the_info ) return RTEMS_INVALID_ADDRESS; 117508: bb 09 00 00 00 mov $0x9,%ebx break; } _RTEMS_Unlock_allocator(); return return_status; } 11750d: 89 d8 mov %ebx,%eax 11750f: 8b 5d fc mov -0x4(%ebp),%ebx 117512: c9 leave 117513: c3 ret =============================================================================== 0011758c : uintptr_t size, rtems_option option_set, rtems_interval timeout, void **segment ) { 11758c: 55 push %ebp 11758d: 89 e5 mov %esp,%ebp 11758f: 57 push %edi 117590: 56 push %esi 117591: 53 push %ebx 117592: 83 ec 2c sub $0x2c,%esp 117595: 8b 75 0c mov 0xc(%ebp),%esi 117598: 8b 5d 18 mov 0x18(%ebp),%ebx Objects_Locations location; rtems_status_code return_status; Region_Control *the_region; void *the_segment; if ( !segment ) 11759b: 85 db test %ebx,%ebx 11759d: 0f 84 a1 00 00 00 je 117644 return RTEMS_INVALID_ADDRESS; *segment = NULL; 1175a3: c7 03 00 00 00 00 movl $0x0,(%ebx) if ( size == 0 ) 1175a9: 85 f6 test %esi,%esi 1175ab: 75 0f jne 1175bc return RTEMS_INVALID_SIZE; 1175ad: b8 08 00 00 00 mov $0x8,%eax break; } _RTEMS_Unlock_allocator(); return return_status; } 1175b2: 8d 65 f4 lea -0xc(%ebp),%esp 1175b5: 5b pop %ebx 1175b6: 5e pop %esi 1175b7: 5f pop %edi 1175b8: c9 leave 1175b9: c3 ret 1175ba: 66 90 xchg %ax,%ax *segment = NULL; if ( size == 0 ) return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); 1175bc: 83 ec 0c sub $0xc,%esp 1175bf: ff 35 e0 2a 14 00 pushl 0x142ae0 1175c5: e8 de 21 00 00 call 1197a8 <_API_Mutex_Lock> executing = _Thread_Executing; 1175ca: a1 d8 2f 14 00 mov 0x142fd8,%eax 1175cf: 89 45 d4 mov %eax,-0x2c(%ebp) 1175d2: 83 c4 0c add $0xc,%esp the_region = _Region_Get( id, &location ); 1175d5: 8d 45 e4 lea -0x1c(%ebp),%eax 1175d8: 50 push %eax 1175d9: ff 75 08 pushl 0x8(%ebp) 1175dc: 68 40 29 14 00 push $0x142940 1175e1: e8 ba 3c 00 00 call 11b2a0 <_Objects_Get_no_protection> 1175e6: 89 c7 mov %eax,%edi switch ( location ) { 1175e8: 83 c4 10 add $0x10,%esp 1175eb: 8b 45 e4 mov -0x1c(%ebp),%eax 1175ee: 85 c0 test %eax,%eax 1175f0: 75 2a jne 11761c case OBJECTS_LOCAL: if ( size > the_region->maximum_segment_size ) 1175f2: 3b 77 5c cmp 0x5c(%edi),%esi 1175f5: 76 2d jbe 117624 return_status = RTEMS_INVALID_SIZE; 1175f7: b8 08 00 00 00 mov $0x8,%eax default: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 1175fc: 83 ec 0c sub $0xc,%esp 1175ff: ff 35 e0 2a 14 00 pushl 0x142ae0 117605: 89 45 d0 mov %eax,-0x30(%ebp) 117608: e8 e3 21 00 00 call 1197f0 <_API_Mutex_Unlock> return return_status; 11760d: 83 c4 10 add $0x10,%esp 117610: 8b 45 d0 mov -0x30(%ebp),%eax } 117613: 8d 65 f4 lea -0xc(%ebp),%esp 117616: 5b pop %ebx 117617: 5e pop %esi 117618: 5f pop %edi 117619: c9 leave 11761a: c3 ret 11761b: 90 nop break; #endif case OBJECTS_ERROR: default: return_status = RTEMS_INVALID_ID; 11761c: b8 04 00 00 00 mov $0x4,%eax 117621: eb d9 jmp 1175fc 117623: 90 nop * @brief See _Heap_Allocate_aligned_with_boundary() with alignment and * boundary equals zero. */ RTEMS_INLINE_ROUTINE void *_Heap_Allocate( Heap_Control *heap, uintptr_t size ) { return _Heap_Allocate_aligned_with_boundary( heap, size, 0, 0 ); 117624: 6a 00 push $0x0 117626: 6a 00 push $0x0 117628: 56 push %esi RTEMS_INLINE_ROUTINE void *_Region_Allocate_segment ( Region_Control *the_region, uintptr_t size ) { return _Heap_Allocate( &the_region->Memory, size ); 117629: 8d 47 68 lea 0x68(%edi),%eax 11762c: 50 push %eax 11762d: e8 e6 2b 00 00 call 11a218 <_Heap_Allocate_aligned_with_boundary> the_segment = _Region_Allocate_segment( the_region, size ); _Region_Debug_Walk( the_region, 2 ); if ( the_segment ) { 117632: 83 c4 10 add $0x10,%esp 117635: 85 c0 test %eax,%eax 117637: 74 17 je 117650 the_region->number_of_used_blocks += 1; 117639: ff 47 64 incl 0x64(%edi) *segment = the_segment; 11763c: 89 03 mov %eax,(%ebx) return_status = RTEMS_SUCCESSFUL; 11763e: 31 c0 xor %eax,%eax 117640: eb ba jmp 1175fc 117642: 66 90 xchg %ax,%ax rtems_status_code return_status; Region_Control *the_region; void *the_segment; if ( !segment ) return RTEMS_INVALID_ADDRESS; 117644: b8 09 00 00 00 mov $0x9,%eax 117649: e9 64 ff ff ff jmp 1175b2 11764e: 66 90 xchg %ax,%ax if ( the_segment ) { the_region->number_of_used_blocks += 1; *segment = the_segment; return_status = RTEMS_SUCCESSFUL; } else if ( _Options_Is_no_wait( option_set ) ) { 117650: f6 45 10 01 testb $0x1,0x10(%ebp) 117654: 74 07 je 11765d return_status = RTEMS_UNSATISFIED; 117656: b8 0d 00 00 00 mov $0xd,%eax 11765b: eb 9f jmp 1175fc rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 11765d: a1 30 2a 14 00 mov 0x142a30,%eax 117662: 40 inc %eax 117663: a3 30 2a 14 00 mov %eax,0x142a30 * Switch from using the memory allocation mutex to using a * dispatching disabled critical section. We have to do this * because this thread is going to block. */ _Thread_Disable_dispatch(); _RTEMS_Unlock_allocator(); 117668: 83 ec 0c sub $0xc,%esp 11766b: ff 35 e0 2a 14 00 pushl 0x142ae0 117671: e8 7a 21 00 00 call 1197f0 <_API_Mutex_Unlock> executing->Wait.queue = &the_region->Wait_queue; 117676: 8d 47 10 lea 0x10(%edi),%eax 117679: 8b 55 d4 mov -0x2c(%ebp),%edx 11767c: 89 42 44 mov %eax,0x44(%edx) executing->Wait.id = id; 11767f: 8b 4d 08 mov 0x8(%ebp),%ecx 117682: 89 4a 20 mov %ecx,0x20(%edx) executing->Wait.count = size; 117685: 89 72 24 mov %esi,0x24(%edx) executing->Wait.return_argument = segment; 117688: 89 5a 28 mov %ebx,0x28(%edx) RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 11768b: c7 47 40 01 00 00 00 movl $0x1,0x40(%edi) _Thread_queue_Enter_critical_section( &the_region->Wait_queue ); _Thread_queue_Enqueue( &the_region->Wait_queue, timeout ); 117692: 83 c4 0c add $0xc,%esp 117695: 68 24 c6 11 00 push $0x11c624 11769a: ff 75 14 pushl 0x14(%ebp) 11769d: 50 push %eax 11769e: e8 55 4c 00 00 call 11c2f8 <_Thread_queue_Enqueue_with_handler> _Thread_Enable_dispatch(); 1176a3: e8 ac 47 00 00 call 11be54 <_Thread_Enable_dispatch> return (rtems_status_code) executing->Wait.return_code; 1176a8: 8b 55 d4 mov -0x2c(%ebp),%edx 1176ab: 8b 42 34 mov 0x34(%edx),%eax 1176ae: 83 c4 10 add $0x10,%esp 1176b1: e9 fc fe ff ff jmp 1175b2 =============================================================================== 0011776c : rtems_id id, void *segment, uintptr_t size, uintptr_t *old_size ) { 11776c: 55 push %ebp 11776d: 89 e5 mov %esp,%ebp 11776f: 56 push %esi 117770: 53 push %ebx 117771: 83 ec 20 sub $0x20,%esp 117774: 8b 5d 14 mov 0x14(%ebp),%ebx uintptr_t osize; rtems_status_code return_status; Heap_Resize_status status; register Region_Control *the_region; if ( !old_size ) 117777: 85 db test %ebx,%ebx 117779: 0f 84 89 00 00 00 je 117808 return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); 11777f: 83 ec 0c sub $0xc,%esp 117782: ff 35 e0 2a 14 00 pushl 0x142ae0 117788: e8 1b 20 00 00 call 1197a8 <_API_Mutex_Lock> 11778d: 83 c4 0c add $0xc,%esp the_region = _Region_Get( id, &location ); 117790: 8d 45 f0 lea -0x10(%ebp),%eax 117793: 50 push %eax 117794: ff 75 08 pushl 0x8(%ebp) 117797: 68 40 29 14 00 push $0x142940 11779c: e8 ff 3a 00 00 call 11b2a0 <_Objects_Get_no_protection> 1177a1: 89 c6 mov %eax,%esi switch ( location ) { 1177a3: 83 c4 10 add $0x10,%esp 1177a6: 8b 45 f0 mov -0x10(%ebp),%eax 1177a9: 85 c0 test %eax,%eax 1177ab: 74 1f je 1177cc default: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 1177ad: 83 ec 0c sub $0xc,%esp 1177b0: ff 35 e0 2a 14 00 pushl 0x142ae0 1177b6: e8 35 20 00 00 call 1197f0 <_API_Mutex_Unlock> return return_status; 1177bb: 83 c4 10 add $0x10,%esp 1177be: b8 04 00 00 00 mov $0x4,%eax } 1177c3: 8d 65 f8 lea -0x8(%ebp),%esp 1177c6: 5b pop %ebx 1177c7: 5e pop %esi 1177c8: c9 leave 1177c9: c3 ret 1177ca: 66 90 xchg %ax,%ax case OBJECTS_LOCAL: _Region_Debug_Walk( the_region, 7 ); status = _Heap_Resize_block( 1177cc: 83 ec 0c sub $0xc,%esp 1177cf: 8d 45 f4 lea -0xc(%ebp),%eax 1177d2: 50 push %eax 1177d3: 8d 45 ec lea -0x14(%ebp),%eax 1177d6: 50 push %eax 1177d7: ff 75 10 pushl 0x10(%ebp) 1177da: ff 75 0c pushl 0xc(%ebp) 1177dd: 8d 46 68 lea 0x68(%esi),%eax 1177e0: 50 push %eax 1177e1: e8 1a 34 00 00 call 11ac00 <_Heap_Resize_block> segment, (uint32_t) size, &osize, &avail_size ); *old_size = (uint32_t) osize; 1177e6: 8b 55 ec mov -0x14(%ebp),%edx 1177e9: 89 13 mov %edx,(%ebx) _Region_Debug_Walk( the_region, 8 ); if ( status == HEAP_RESIZE_SUCCESSFUL ) 1177eb: 83 c4 20 add $0x20,%esp 1177ee: 85 c0 test %eax,%eax 1177f0: 75 22 jne 117814 _Region_Process_queue( the_region ); /* unlocks allocator */ 1177f2: 83 ec 0c sub $0xc,%esp 1177f5: 56 push %esi 1177f6: e8 d5 7c 00 00 call 11f4d0 <_Region_Process_queue> 1177fb: 83 c4 10 add $0x10,%esp else _RTEMS_Unlock_allocator(); if (status == HEAP_RESIZE_SUCCESSFUL) return RTEMS_SUCCESSFUL; 1177fe: 31 c0 xor %eax,%eax break; } _RTEMS_Unlock_allocator(); return return_status; } 117800: 8d 65 f8 lea -0x8(%ebp),%esp 117803: 5b pop %ebx 117804: 5e pop %esi 117805: c9 leave 117806: c3 ret 117807: 90 nop rtems_status_code return_status; Heap_Resize_status status; register Region_Control *the_region; if ( !old_size ) return RTEMS_INVALID_ADDRESS; 117808: b8 09 00 00 00 mov $0x9,%eax break; } _RTEMS_Unlock_allocator(); return return_status; } 11780d: 8d 65 f8 lea -0x8(%ebp),%esp 117810: 5b pop %ebx 117811: 5e pop %esi 117812: c9 leave 117813: c3 ret _Region_Debug_Walk( the_region, 8 ); if ( status == HEAP_RESIZE_SUCCESSFUL ) _Region_Process_queue( the_region ); /* unlocks allocator */ else _RTEMS_Unlock_allocator(); 117814: 83 ec 0c sub $0xc,%esp 117817: ff 35 e0 2a 14 00 pushl 0x142ae0 11781d: 89 45 e4 mov %eax,-0x1c(%ebp) 117820: e8 cb 1f 00 00 call 1197f0 <_API_Mutex_Unlock> if (status == HEAP_RESIZE_SUCCESSFUL) return RTEMS_SUCCESSFUL; if (status == HEAP_RESIZE_UNSATISFIED) 117825: 83 c4 10 add $0x10,%esp return RTEMS_UNSATISFIED; 117828: 8b 45 e4 mov -0x1c(%ebp),%eax 11782b: 48 dec %eax 11782c: 0f 94 c0 sete %al 11782f: 0f b6 c0 movzbl %al,%eax 117832: 8d 04 85 09 00 00 00 lea 0x9(,%eax,4),%eax break; } _RTEMS_Unlock_allocator(); return return_status; } 117839: 8d 65 f8 lea -0x8(%ebp),%esp 11783c: 5b pop %ebx 11783d: 5e pop %esi 11783e: c9 leave 11783f: c3 ret =============================================================================== 00117840 : rtems_status_code rtems_region_return_segment( rtems_id id, void *segment ) { 117840: 55 push %ebp 117841: 89 e5 mov %esp,%ebp 117843: 53 push %ebx 117844: 83 ec 20 sub $0x20,%esp uint32_t size; #endif int status; register Region_Control *the_region; _RTEMS_Lock_allocator(); 117847: ff 35 e0 2a 14 00 pushl 0x142ae0 11784d: e8 56 1f 00 00 call 1197a8 <_API_Mutex_Lock> 117852: 83 c4 0c add $0xc,%esp the_region = _Region_Get( id, &location ); 117855: 8d 45 f4 lea -0xc(%ebp),%eax 117858: 50 push %eax 117859: ff 75 08 pushl 0x8(%ebp) 11785c: 68 40 29 14 00 push $0x142940 117861: e8 3a 3a 00 00 call 11b2a0 <_Objects_Get_no_protection> 117866: 89 c3 mov %eax,%ebx switch ( location ) { 117868: 83 c4 10 add $0x10,%esp 11786b: 8b 45 f4 mov -0xc(%ebp),%eax 11786e: 85 c0 test %eax,%eax 117870: 75 1e jne 117890 RTEMS_INLINE_ROUTINE bool _Region_Free_segment ( Region_Control *the_region, void *the_segment ) { return _Heap_Free( &the_region->Memory, the_segment ); 117872: 83 ec 08 sub $0x8,%esp 117875: ff 75 0c pushl 0xc(%ebp) 117878: 8d 43 68 lea 0x68(%ebx),%eax 11787b: 50 push %eax 11787c: e8 03 2e 00 00 call 11a684 <_Heap_Free> #endif status = _Region_Free_segment( the_region, segment ); _Region_Debug_Walk( the_region, 4 ); if ( !status ) 117881: 83 c4 10 add $0x10,%esp 117884: 84 c0 test %al,%al 117886: 75 28 jne 1178b0 return_status = RTEMS_INVALID_ADDRESS; 117888: bb 09 00 00 00 mov $0x9,%ebx 11788d: eb 06 jmp 117895 11788f: 90 nop break; #endif case OBJECTS_ERROR: default: return_status = RTEMS_INVALID_ID; 117890: bb 04 00 00 00 mov $0x4,%ebx break; } _RTEMS_Unlock_allocator(); 117895: 83 ec 0c sub $0xc,%esp 117898: ff 35 e0 2a 14 00 pushl 0x142ae0 11789e: e8 4d 1f 00 00 call 1197f0 <_API_Mutex_Unlock> return return_status; 1178a3: 83 c4 10 add $0x10,%esp } 1178a6: 89 d8 mov %ebx,%eax 1178a8: 8b 5d fc mov -0x4(%ebp),%ebx 1178ab: c9 leave 1178ac: c3 ret 1178ad: 8d 76 00 lea 0x0(%esi),%esi _Region_Debug_Walk( the_region, 4 ); if ( !status ) return_status = RTEMS_INVALID_ADDRESS; else { the_region->number_of_used_blocks -= 1; 1178b0: ff 4b 64 decl 0x64(%ebx) _Region_Process_queue(the_region); /* unlocks allocator */ 1178b3: 83 ec 0c sub $0xc,%esp 1178b6: 53 push %ebx 1178b7: e8 14 7c 00 00 call 11f4d0 <_Region_Process_queue> return RTEMS_SUCCESSFUL; 1178bc: 83 c4 10 add $0x10,%esp 1178bf: 31 db xor %ebx,%ebx break; } _RTEMS_Unlock_allocator(); return return_status; } 1178c1: 89 d8 mov %ebx,%eax 1178c3: 8b 5d fc mov -0x4(%ebp),%ebx 1178c6: c9 leave 1178c7: c3 ret =============================================================================== 0010b434 : uint32_t count, rtems_attribute attribute_set, rtems_task_priority priority_ceiling, rtems_id *id ) { 10b434: 55 push %ebp 10b435: 89 e5 mov %esp,%ebp 10b437: 57 push %edi 10b438: 56 push %esi 10b439: 53 push %ebx 10b43a: 83 ec 3c sub $0x3c,%esp 10b43d: 8b 75 08 mov 0x8(%ebp),%esi 10b440: 8b 5d 10 mov 0x10(%ebp),%ebx 10b443: 8b 7d 18 mov 0x18(%ebp),%edi register Semaphore_Control *the_semaphore; CORE_mutex_Attributes the_mutex_attr; CORE_semaphore_Attributes the_semaphore_attr; CORE_mutex_Status mutex_status; if ( !rtems_is_name_valid( name ) ) 10b446: 85 f6 test %esi,%esi 10b448: 74 4a je 10b494 return RTEMS_INVALID_NAME; if ( !id ) 10b44a: 85 ff test %edi,%edi 10b44c: 0f 84 f6 00 00 00 je 10b548 return RTEMS_NOT_DEFINED; } else #endif if ( _Attributes_Is_inherit_priority( attribute_set ) || 10b452: 89 da mov %ebx,%edx 10b454: 81 e2 c0 00 00 00 and $0xc0,%edx 10b45a: 74 48 je 10b4a4 */ RTEMS_INLINE_ROUTINE bool _Attributes_Is_binary_semaphore( rtems_attribute attribute_set ) { return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_BINARY_SEMAPHORE); 10b45c: 89 d8 mov %ebx,%eax 10b45e: 83 e0 30 and $0x30,%eax _Attributes_Is_priority_ceiling( attribute_set ) ) { if ( ! (_Attributes_Is_binary_semaphore( attribute_set ) && 10b461: 83 f8 10 cmp $0x10,%eax 10b464: 74 0e je 10b474 } if ( _Attributes_Is_inherit_priority( attribute_set ) && _Attributes_Is_priority_ceiling( attribute_set ) ) return RTEMS_NOT_DEFINED; 10b466: b8 0b 00 00 00 mov $0xb,%eax 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10b46b: 8d 65 f4 lea -0xc(%ebp),%esp 10b46e: 5b pop %ebx 10b46f: 5e pop %esi 10b470: 5f pop %edi 10b471: c9 leave 10b472: c3 ret 10b473: 90 nop #endif if ( _Attributes_Is_inherit_priority( attribute_set ) || _Attributes_Is_priority_ceiling( attribute_set ) ) { if ( ! (_Attributes_Is_binary_semaphore( attribute_set ) && 10b474: f6 c3 04 test $0x4,%bl 10b477: 74 ed je 10b466 _Attributes_Is_priority( attribute_set ) ) ) return RTEMS_NOT_DEFINED; } if ( _Attributes_Is_inherit_priority( attribute_set ) && 10b479: 81 fa c0 00 00 00 cmp $0xc0,%edx 10b47f: 74 e5 je 10b466 10b481: b9 10 00 00 00 mov $0x10,%ecx _Attributes_Is_priority_ceiling( attribute_set ) ) return RTEMS_NOT_DEFINED; if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) ) 10b486: 83 7d 0c 01 cmpl $0x1,0xc(%ebp) 10b48a: 76 1f jbe 10b4ab return RTEMS_INVALID_NUMBER; 10b48c: b8 0a 00 00 00 mov $0xa,%eax 10b491: eb d8 jmp 10b46b 10b493: 90 nop CORE_mutex_Attributes the_mutex_attr; CORE_semaphore_Attributes the_semaphore_attr; CORE_mutex_Status mutex_status; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 10b494: b8 03 00 00 00 mov $0x3,%eax 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10b499: 8d 65 f4 lea -0xc(%ebp),%esp 10b49c: 5b pop %ebx 10b49d: 5e pop %esi 10b49e: 5f pop %edi 10b49f: c9 leave 10b4a0: c3 ret 10b4a1: 8d 76 00 lea 0x0(%esi),%esi if ( _Attributes_Is_inherit_priority( attribute_set ) && _Attributes_Is_priority_ceiling( attribute_set ) ) return RTEMS_NOT_DEFINED; if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) ) 10b4a4: 89 d9 mov %ebx,%ecx 10b4a6: 83 e1 30 and $0x30,%ecx 10b4a9: 75 db jne 10b486 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10b4ab: a1 90 7d 12 00 mov 0x127d90,%eax 10b4b0: 40 inc %eax 10b4b1: a3 90 7d 12 00 mov %eax,0x127d90 * This function allocates a semaphore control block from * the inactive chain of free semaphore control blocks. */ RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Allocate( void ) { return (Semaphore_Control *) _Objects_Allocate( &_Semaphore_Information ); 10b4b6: 83 ec 0c sub $0xc,%esp 10b4b9: 68 e0 7c 12 00 push $0x127ce0 10b4be: 89 4d c4 mov %ecx,-0x3c(%ebp) 10b4c1: e8 be 14 00 00 call 10c984 <_Objects_Allocate> 10b4c6: 89 c2 mov %eax,%edx _Thread_Disable_dispatch(); /* prevents deletion */ the_semaphore = _Semaphore_Allocate(); if ( !the_semaphore ) { 10b4c8: 83 c4 10 add $0x10,%esp 10b4cb: 85 c0 test %eax,%eax 10b4cd: 8b 4d c4 mov -0x3c(%ebp),%ecx 10b4d0: 0f 84 ba 00 00 00 je 10b590 _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_semaphore->attribute_set = attribute_set; 10b4d6: 89 58 10 mov %ebx,0x10(%eax) /* * Initialize it as a counting semaphore. */ if ( _Attributes_Is_counting_semaphore( attribute_set ) ) { 10b4d9: 85 c9 test %ecx,%ecx 10b4db: 74 77 je 10b554 /* * It is either simple binary semaphore or a more powerful mutex * style binary semaphore. This is the mutex style. */ if ( _Attributes_Is_priority( attribute_set ) ) the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY; 10b4dd: 31 c0 xor %eax,%eax 10b4df: f6 c3 04 test $0x4,%bl 10b4e2: 0f 95 c0 setne %al 10b4e5: 89 45 d8 mov %eax,-0x28(%ebp) else the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_FIFO; if ( _Attributes_Is_binary_semaphore( attribute_set ) ) { 10b4e8: 83 f9 10 cmp $0x10,%ecx 10b4eb: 0f 84 ae 00 00 00 je 10b59f the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING; the_mutex_attr.only_owner_release = true; } } } else /* must be simple binary semaphore */ { the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_BLOCKS; 10b4f1: c7 45 d0 02 00 00 00 movl $0x2,-0x30(%ebp) the_mutex_attr.only_owner_release = false; 10b4f8: c6 45 d4 00 movb $0x0,-0x2c(%ebp) } mutex_status = _CORE_mutex_Initialize( 10b4fc: 50 push %eax 10b4fd: 31 c0 xor %eax,%eax 10b4ff: 83 7d 0c 01 cmpl $0x1,0xc(%ebp) 10b503: 0f 94 c0 sete %al 10b506: 50 push %eax 10b507: 8d 45 d0 lea -0x30(%ebp),%eax 10b50a: 50 push %eax 10b50b: 8d 42 14 lea 0x14(%edx),%eax 10b50e: 50 push %eax 10b50f: 89 55 c4 mov %edx,-0x3c(%ebp) 10b512: e8 65 0c 00 00 call 10c17c <_CORE_mutex_Initialize> &the_semaphore->Core_control.mutex, &the_mutex_attr, (count == 1) ? CORE_MUTEX_UNLOCKED : CORE_MUTEX_LOCKED ); if ( mutex_status == CORE_MUTEX_STATUS_CEILING_VIOLATED ) { 10b517: 83 c4 10 add $0x10,%esp 10b51a: 83 f8 06 cmp $0x6,%eax 10b51d: 8b 55 c4 mov -0x3c(%ebp),%edx 10b520: 0f 84 a9 00 00 00 je 10b5cf Objects_Name name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10b526: 8b 42 08 mov 0x8(%edx),%eax Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 10b529: 0f b7 d8 movzwl %ax,%ebx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10b52c: 8b 0d fc 7c 12 00 mov 0x127cfc,%ecx 10b532: 89 14 99 mov %edx,(%ecx,%ebx,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 10b535: 89 72 0c mov %esi,0xc(%edx) &_Semaphore_Information, &the_semaphore->Object, (Objects_Name) name ); *id = the_semaphore->Object.id; 10b538: 89 07 mov %eax,(%edi) the_semaphore->Object.id, name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 10b53a: e8 71 24 00 00 call 10d9b0 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10b53f: 31 c0 xor %eax,%eax 10b541: e9 25 ff ff ff jmp 10b46b 10b546: 66 90 xchg %ax,%ax if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !id ) return RTEMS_INVALID_ADDRESS; 10b548: b8 09 00 00 00 mov $0x9,%eax 10b54d: e9 19 ff ff ff jmp 10b46b 10b552: 66 90 xchg %ax,%ax */ if ( _Attributes_Is_counting_semaphore( attribute_set ) ) { /* * This effectively disables limit checking. */ the_semaphore_attr.maximum_count = 0xFFFFFFFF; 10b554: c7 45 e0 ff ff ff ff movl $0xffffffff,-0x20(%ebp) if ( _Attributes_Is_priority( attribute_set ) ) the_semaphore_attr.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY; 10b55b: 31 c0 xor %eax,%eax 10b55d: f6 c3 04 test $0x4,%bl 10b560: 0f 95 c0 setne %al 10b563: 89 45 e4 mov %eax,-0x1c(%ebp) the_semaphore_attr.discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO; /* * The following are just to make Purify happy. */ the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; 10b566: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp) the_mutex_attr.priority_ceiling = PRIORITY_MINIMUM; 10b56d: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp) _CORE_semaphore_Initialize( 10b574: 51 push %ecx 10b575: ff 75 0c pushl 0xc(%ebp) 10b578: 8d 45 e0 lea -0x20(%ebp),%eax 10b57b: 50 push %eax 10b57c: 8d 42 14 lea 0x14(%edx),%eax 10b57f: 50 push %eax 10b580: 89 55 c4 mov %edx,-0x3c(%ebp) 10b583: e8 84 0e 00 00 call 10c40c <_CORE_semaphore_Initialize> 10b588: 83 c4 10 add $0x10,%esp 10b58b: 8b 55 c4 mov -0x3c(%ebp),%edx 10b58e: eb 96 jmp 10b526 _Thread_Disable_dispatch(); /* prevents deletion */ the_semaphore = _Semaphore_Allocate(); if ( !the_semaphore ) { _Thread_Enable_dispatch(); 10b590: e8 1b 24 00 00 call 10d9b0 <_Thread_Enable_dispatch> return RTEMS_TOO_MANY; 10b595: b8 05 00 00 00 mov $0x5,%eax 10b59a: e9 cc fe ff ff jmp 10b46b the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY; else the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_FIFO; if ( _Attributes_Is_binary_semaphore( attribute_set ) ) { the_mutex_attr.priority_ceiling = priority_ceiling; 10b59f: 8b 45 14 mov 0x14(%ebp),%eax 10b5a2: 89 45 dc mov %eax,-0x24(%ebp) the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; 10b5a5: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp) the_mutex_attr.only_owner_release = false; 10b5ac: c6 45 d4 00 movb $0x0,-0x2c(%ebp) if ( the_mutex_attr.discipline == CORE_MUTEX_DISCIPLINES_PRIORITY ) { 10b5b0: 83 7d d8 01 cmpl $0x1,-0x28(%ebp) 10b5b4: 0f 85 42 ff ff ff jne 10b4fc if ( _Attributes_Is_inherit_priority( attribute_set ) ) { 10b5ba: f6 c3 40 test $0x40,%bl 10b5bd: 74 30 je 10b5ef the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 10b5bf: c7 45 d8 02 00 00 00 movl $0x2,-0x28(%ebp) the_mutex_attr.only_owner_release = true; 10b5c6: c6 45 d4 01 movb $0x1,-0x2c(%ebp) 10b5ca: e9 2d ff ff ff jmp 10b4fc */ RTEMS_INLINE_ROUTINE void _Semaphore_Free ( Semaphore_Control *the_semaphore ) { _Objects_Free( &_Semaphore_Information, &the_semaphore->Object ); 10b5cf: 83 ec 08 sub $0x8,%esp 10b5d2: 52 push %edx 10b5d3: 68 e0 7c 12 00 push $0x127ce0 10b5d8: e8 1b 17 00 00 call 10ccf8 <_Objects_Free> (count == 1) ? CORE_MUTEX_UNLOCKED : CORE_MUTEX_LOCKED ); if ( mutex_status == CORE_MUTEX_STATUS_CEILING_VIOLATED ) { _Semaphore_Free( the_semaphore ); _Thread_Enable_dispatch(); 10b5dd: e8 ce 23 00 00 call 10d9b0 <_Thread_Enable_dispatch> return RTEMS_INVALID_PRIORITY; 10b5e2: 83 c4 10 add $0x10,%esp 10b5e5: b8 13 00 00 00 mov $0x13,%eax 10b5ea: e9 7c fe ff ff jmp 10b46b if ( the_mutex_attr.discipline == CORE_MUTEX_DISCIPLINES_PRIORITY ) { if ( _Attributes_Is_inherit_priority( attribute_set ) ) { the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; the_mutex_attr.only_owner_release = true; } else if ( _Attributes_Is_priority_ceiling( attribute_set ) ) { 10b5ef: 81 e3 80 00 00 00 and $0x80,%ebx 10b5f5: 0f 84 01 ff ff ff je 10b4fc the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING; 10b5fb: c7 45 d8 03 00 00 00 movl $0x3,-0x28(%ebp) the_mutex_attr.only_owner_release = true; 10b602: c6 45 d4 01 movb $0x1,-0x2c(%ebp) 10b606: e9 f1 fe ff ff jmp 10b4fc =============================================================================== 0010b60c : #endif rtems_status_code rtems_semaphore_delete( rtems_id id ) { 10b60c: 55 push %ebp 10b60d: 89 e5 mov %esp,%ebp 10b60f: 53 push %ebx 10b610: 83 ec 18 sub $0x18,%esp register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); 10b613: 8d 45 f4 lea -0xc(%ebp),%eax Objects_Id id, Objects_Locations *location ) { return (Semaphore_Control *) _Objects_Get( &_Semaphore_Information, id, location ); 10b616: 50 push %eax 10b617: ff 75 08 pushl 0x8(%ebp) 10b61a: 68 e0 7c 12 00 push $0x127ce0 10b61f: e8 14 18 00 00 call 10ce38 <_Objects_Get> 10b624: 89 c3 mov %eax,%ebx switch ( location ) { 10b626: 83 c4 10 add $0x10,%esp 10b629: 8b 4d f4 mov -0xc(%ebp),%ecx 10b62c: 85 c9 test %ecx,%ecx 10b62e: 74 0c je 10b63c case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10b630: b8 04 00 00 00 mov $0x4,%eax } 10b635: 8b 5d fc mov -0x4(%ebp),%ebx 10b638: c9 leave 10b639: c3 ret 10b63a: 66 90 xchg %ax,%ax */ RTEMS_INLINE_ROUTINE bool _Attributes_Is_counting_semaphore( rtems_attribute attribute_set ) { return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_COUNTING_SEMAPHORE); 10b63c: 8b 40 10 mov 0x10(%eax),%eax the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 10b63f: 83 e0 30 and $0x30,%eax 10b642: 74 58 je 10b69c if ( _CORE_mutex_Is_locked( &the_semaphore->Core_control.mutex ) && 10b644: 8b 53 64 mov 0x64(%ebx),%edx 10b647: 85 d2 test %edx,%edx 10b649: 75 15 jne 10b660 10b64b: 83 f8 20 cmp $0x20,%eax 10b64e: 74 10 je 10b660 !_Attributes_Is_simple_binary_semaphore( the_semaphore->attribute_set ) ) { _Thread_Enable_dispatch(); 10b650: e8 5b 23 00 00 call 10d9b0 <_Thread_Enable_dispatch> return RTEMS_RESOURCE_IN_USE; 10b655: b8 0c 00 00 00 mov $0xc,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b65a: 8b 5d fc mov -0x4(%ebp),%ebx 10b65d: c9 leave 10b65e: c3 ret 10b65f: 90 nop !_Attributes_Is_simple_binary_semaphore( the_semaphore->attribute_set ) ) { _Thread_Enable_dispatch(); return RTEMS_RESOURCE_IN_USE; } _CORE_mutex_Flush( 10b660: 50 push %eax 10b661: 6a 04 push $0x4 10b663: 6a 00 push $0x0 10b665: 8d 43 14 lea 0x14(%ebx),%eax 10b668: 50 push %eax 10b669: e8 02 0b 00 00 call 10c170 <_CORE_mutex_Flush> 10b66e: 83 c4 10 add $0x10,%esp SEMAPHORE_MP_OBJECT_WAS_DELETED, CORE_SEMAPHORE_WAS_DELETED ); } _Objects_Close( &_Semaphore_Information, &the_semaphore->Object ); 10b671: 83 ec 08 sub $0x8,%esp 10b674: 53 push %ebx 10b675: 68 e0 7c 12 00 push $0x127ce0 10b67a: e8 81 13 00 00 call 10ca00 <_Objects_Close> */ RTEMS_INLINE_ROUTINE void _Semaphore_Free ( Semaphore_Control *the_semaphore ) { _Objects_Free( &_Semaphore_Information, &the_semaphore->Object ); 10b67f: 58 pop %eax 10b680: 5a pop %edx 10b681: 53 push %ebx 10b682: 68 e0 7c 12 00 push $0x127ce0 10b687: e8 6c 16 00 00 call 10ccf8 <_Objects_Free> 0, /* Not used */ 0 /* Not used */ ); } #endif _Thread_Enable_dispatch(); 10b68c: e8 1f 23 00 00 call 10d9b0 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10b691: 83 c4 10 add $0x10,%esp 10b694: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b696: 8b 5d fc mov -0x4(%ebp),%ebx 10b699: c9 leave 10b69a: c3 ret 10b69b: 90 nop &the_semaphore->Core_control.mutex, SEMAPHORE_MP_OBJECT_WAS_DELETED, CORE_MUTEX_WAS_DELETED ); } else { _CORE_semaphore_Flush( 10b69c: 51 push %ecx 10b69d: 6a 02 push $0x2 10b69f: 6a 00 push $0x0 10b6a1: 8d 43 14 lea 0x14(%ebx),%eax 10b6a4: 50 push %eax 10b6a5: e8 56 0d 00 00 call 10c400 <_CORE_semaphore_Flush> 10b6aa: 83 c4 10 add $0x10,%esp 10b6ad: eb c2 jmp 10b671 =============================================================================== 0010b6b0 : rtems_status_code rtems_semaphore_obtain( rtems_id id, rtems_option option_set, rtems_interval timeout ) { 10b6b0: 55 push %ebp 10b6b1: 89 e5 mov %esp,%ebp 10b6b3: 57 push %edi 10b6b4: 56 push %esi 10b6b5: 53 push %ebx 10b6b6: 83 ec 1c sub $0x1c,%esp 10b6b9: 8b 5d 08 mov 0x8(%ebp),%ebx 10b6bc: 8b 75 0c mov 0xc(%ebp),%esi 10b6bf: 8b 7d 10 mov 0x10(%ebp),%edi register Semaphore_Control *the_semaphore; Objects_Locations location; ISR_Level level; the_semaphore = _Semaphore_Get_interrupt_disable( id, &location, &level ); 10b6c2: 8d 45 e0 lea -0x20(%ebp),%eax Objects_Locations *location, ISR_Level *level ) { return (Semaphore_Control *) _Objects_Get_isr_disable( &_Semaphore_Information, id, location, level ); 10b6c5: 50 push %eax 10b6c6: 8d 45 e4 lea -0x1c(%ebp),%eax 10b6c9: 50 push %eax 10b6ca: 53 push %ebx 10b6cb: 68 e0 7c 12 00 push $0x127ce0 10b6d0: e8 0b 17 00 00 call 10cde0 <_Objects_Get_isr_disable> switch ( location ) { 10b6d5: 83 c4 10 add $0x10,%esp 10b6d8: 8b 4d e4 mov -0x1c(%ebp),%ecx 10b6db: 85 c9 test %ecx,%ecx 10b6dd: 74 0d je 10b6ec case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10b6df: b8 04 00 00 00 mov $0x4,%eax } 10b6e4: 8d 65 f4 lea -0xc(%ebp),%esp 10b6e7: 5b pop %ebx 10b6e8: 5e pop %esi 10b6e9: 5f pop %edi 10b6ea: c9 leave 10b6eb: c3 ret the_semaphore = _Semaphore_Get_interrupt_disable( id, &location, &level ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 10b6ec: f6 40 10 30 testb $0x30,0x10(%eax) 10b6f0: 74 36 je 10b728 _CORE_mutex_Seize( 10b6f2: 83 ec 0c sub $0xc,%esp 10b6f5: ff 75 e0 pushl -0x20(%ebp) 10b6f8: 57 push %edi */ RTEMS_INLINE_ROUTINE bool _Options_Is_no_wait ( rtems_option option_set ) { return (option_set & RTEMS_NO_WAIT) ? true : false; 10b6f9: 83 e6 01 and $0x1,%esi 10b6fc: 83 f6 01 xor $0x1,%esi 10b6ff: 56 push %esi 10b700: 53 push %ebx 10b701: 83 c0 14 add $0x14,%eax 10b704: 50 push %eax 10b705: e8 6a 0b 00 00 call 10c274 <_CORE_mutex_Seize> id, ((_Options_Is_no_wait( option_set )) ? false : true), timeout, level ); return _Semaphore_Translate_core_mutex_return_code( 10b70a: 83 c4 14 add $0x14,%esp _Thread_Executing->Wait.return_code ); 10b70d: a1 38 83 12 00 mov 0x128338,%eax id, ((_Options_Is_no_wait( option_set )) ? false : true), timeout, level ); return _Semaphore_Translate_core_mutex_return_code( 10b712: ff 70 34 pushl 0x34(%eax) 10b715: e8 12 01 00 00 call 10b82c <_Semaphore_Translate_core_mutex_return_code> 10b71a: 83 c4 10 add $0x10,%esp break; } return RTEMS_INVALID_ID; } 10b71d: 8d 65 f4 lea -0xc(%ebp),%esp 10b720: 5b pop %ebx 10b721: 5e pop %esi 10b722: 5f pop %edi 10b723: c9 leave 10b724: c3 ret 10b725: 8d 76 00 lea 0x0(%esi),%esi { Thread_Control *executing; /* disabled when you get here */ executing = _Thread_Executing; 10b728: 8b 15 38 83 12 00 mov 0x128338,%edx executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 10b72e: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx) if ( the_semaphore->count != 0 ) { 10b735: 8b 48 5c mov 0x5c(%eax),%ecx 10b738: 85 c9 test %ecx,%ecx 10b73a: 75 2c jne 10b768 the_semaphore->count -= 1; _ISR_Enable( *level_p ); return; } if ( !wait ) { 10b73c: 83 e6 01 and $0x1,%esi 10b73f: 74 33 je 10b774 _ISR_Enable( *level_p ); 10b741: ff 75 e0 pushl -0x20(%ebp) 10b744: 9d popf executing->Wait.return_code = CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT; 10b745: c7 42 34 01 00 00 00 movl $0x1,0x34(%edx) id, ((_Options_Is_no_wait( option_set )) ? false : true), timeout, &level ); return _Semaphore_Translate_core_semaphore_return_code( 10b74c: 83 ec 0c sub $0xc,%esp _Thread_Executing->Wait.return_code ); 10b74f: a1 38 83 12 00 mov 0x128338,%eax id, ((_Options_Is_no_wait( option_set )) ? false : true), timeout, &level ); return _Semaphore_Translate_core_semaphore_return_code( 10b754: ff 70 34 pushl 0x34(%eax) 10b757: e8 e0 00 00 00 call 10b83c <_Semaphore_Translate_core_semaphore_return_code> 10b75c: 83 c4 10 add $0x10,%esp break; } return RTEMS_INVALID_ID; } 10b75f: 8d 65 f4 lea -0xc(%ebp),%esp 10b762: 5b pop %ebx 10b763: 5e pop %esi 10b764: 5f pop %edi 10b765: c9 leave 10b766: c3 ret 10b767: 90 nop /* disabled when you get here */ executing = _Thread_Executing; executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL; if ( the_semaphore->count != 0 ) { the_semaphore->count -= 1; 10b768: 49 dec %ecx 10b769: 89 48 5c mov %ecx,0x5c(%eax) _ISR_Enable( *level_p ); 10b76c: ff 75 e0 pushl -0x20(%ebp) 10b76f: 9d popf 10b770: eb da jmp 10b74c 10b772: 66 90 xchg %ax,%ax 10b774: 8b 0d 90 7d 12 00 mov 0x127d90,%ecx 10b77a: 41 inc %ecx 10b77b: 89 0d 90 7d 12 00 mov %ecx,0x127d90 RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 10b781: c7 40 44 01 00 00 00 movl $0x1,0x44(%eax) return; } _Thread_Disable_dispatch(); _Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue ); executing->Wait.queue = &the_semaphore->Wait_queue; 10b788: 83 c0 14 add $0x14,%eax 10b78b: 89 42 44 mov %eax,0x44(%edx) executing->Wait.id = id; 10b78e: 89 5a 20 mov %ebx,0x20(%edx) _ISR_Enable( *level_p ); 10b791: ff 75 e0 pushl -0x20(%ebp) 10b794: 9d popf _Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout ); 10b795: 52 push %edx 10b796: 68 80 e1 10 00 push $0x10e180 10b79b: 57 push %edi 10b79c: 50 push %eax 10b79d: e8 b2 26 00 00 call 10de54 <_Thread_queue_Enqueue_with_handler> _Thread_Enable_dispatch(); 10b7a2: e8 09 22 00 00 call 10d9b0 <_Thread_Enable_dispatch> 10b7a7: 83 c4 10 add $0x10,%esp 10b7aa: eb a0 jmp 10b74c =============================================================================== 0010b7ac : #endif rtems_status_code rtems_semaphore_release( rtems_id id ) { 10b7ac: 55 push %ebp 10b7ad: 89 e5 mov %esp,%ebp 10b7af: 53 push %ebx 10b7b0: 83 ec 18 sub $0x18,%esp 10b7b3: 8b 5d 08 mov 0x8(%ebp),%ebx register Semaphore_Control *the_semaphore; Objects_Locations location; CORE_mutex_Status mutex_status; CORE_semaphore_Status semaphore_status; the_semaphore = _Semaphore_Get( id, &location ); 10b7b6: 8d 45 f4 lea -0xc(%ebp),%eax Objects_Id id, Objects_Locations *location ) { return (Semaphore_Control *) _Objects_Get( &_Semaphore_Information, id, location ); 10b7b9: 50 push %eax 10b7ba: 53 push %ebx 10b7bb: 68 e0 7c 12 00 push $0x127ce0 10b7c0: e8 73 16 00 00 call 10ce38 <_Objects_Get> switch ( location ) { 10b7c5: 83 c4 10 add $0x10,%esp 10b7c8: 8b 55 f4 mov -0xc(%ebp),%edx 10b7cb: 85 d2 test %edx,%edx 10b7cd: 74 0d je 10b7dc case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10b7cf: b8 04 00 00 00 mov $0x4,%eax } 10b7d4: 8b 5d fc mov -0x4(%ebp),%ebx 10b7d7: c9 leave 10b7d8: c3 ret 10b7d9: 8d 76 00 lea 0x0(%esi),%esi the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 10b7dc: f6 40 10 30 testb $0x30,0x10(%eax) 10b7e0: 75 26 jne 10b808 MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); return _Semaphore_Translate_core_mutex_return_code( mutex_status ); } else { semaphore_status = _CORE_semaphore_Surrender( 10b7e2: 52 push %edx 10b7e3: 6a 00 push $0x0 10b7e5: 53 push %ebx 10b7e6: 83 c0 14 add $0x14,%eax 10b7e9: 50 push %eax 10b7ea: e8 5d 0c 00 00 call 10c44c <_CORE_semaphore_Surrender> 10b7ef: 89 c3 mov %eax,%ebx &the_semaphore->Core_control.semaphore, id, MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); 10b7f1: e8 ba 21 00 00 call 10d9b0 <_Thread_Enable_dispatch> return 10b7f6: 89 1c 24 mov %ebx,(%esp) 10b7f9: e8 3e 00 00 00 call 10b83c <_Semaphore_Translate_core_semaphore_return_code> 10b7fe: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b801: 8b 5d fc mov -0x4(%ebp),%ebx 10b804: c9 leave 10b805: c3 ret 10b806: 66 90 xchg %ax,%ax the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { mutex_status = _CORE_mutex_Surrender( 10b808: 51 push %ecx 10b809: 6a 00 push $0x0 10b80b: 53 push %ebx 10b80c: 83 c0 14 add $0x14,%eax 10b80f: 50 push %eax 10b810: e8 ff 0a 00 00 call 10c314 <_CORE_mutex_Surrender> 10b815: 89 c3 mov %eax,%ebx &the_semaphore->Core_control.mutex, id, MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); 10b817: e8 94 21 00 00 call 10d9b0 <_Thread_Enable_dispatch> return _Semaphore_Translate_core_mutex_return_code( mutex_status ); 10b81c: 89 1c 24 mov %ebx,(%esp) 10b81f: e8 08 00 00 00 call 10b82c <_Semaphore_Translate_core_mutex_return_code> 10b824: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b827: 8b 5d fc mov -0x4(%ebp),%ebx 10b82a: c9 leave 10b82b: c3 ret =============================================================================== 00117d60 : rtems_status_code rtems_signal_send( rtems_id id, rtems_signal_set signal_set ) { 117d60: 55 push %ebp 117d61: 89 e5 mov %esp,%ebp 117d63: 53 push %ebx 117d64: 83 ec 14 sub $0x14,%esp 117d67: 8b 5d 0c mov 0xc(%ebp),%ebx register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; ASR_Information *asr; if ( !signal_set ) 117d6a: 85 db test %ebx,%ebx 117d6c: 75 0a jne 117d78 return RTEMS_INVALID_NUMBER; 117d6e: b8 0a 00 00 00 mov $0xa,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 117d73: 8b 5d fc mov -0x4(%ebp),%ebx 117d76: c9 leave 117d77: c3 ret ASR_Information *asr; if ( !signal_set ) return RTEMS_INVALID_NUMBER; the_thread = _Thread_Get( id, &location ); 117d78: 83 ec 08 sub $0x8,%esp 117d7b: 8d 45 f4 lea -0xc(%ebp),%eax 117d7e: 50 push %eax 117d7f: ff 75 08 pushl 0x8(%ebp) 117d82: e8 f1 40 00 00 call 11be78 <_Thread_Get> switch ( location ) { 117d87: 83 c4 10 add $0x10,%esp 117d8a: 8b 55 f4 mov -0xc(%ebp),%edx 117d8d: 85 d2 test %edx,%edx 117d8f: 74 0b je 117d9c case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 117d91: b8 04 00 00 00 mov $0x4,%eax } 117d96: 8b 5d fc mov -0x4(%ebp),%ebx 117d99: c9 leave 117d9a: c3 ret 117d9b: 90 nop the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; 117d9c: 8b 90 e8 00 00 00 mov 0xe8(%eax),%edx asr = &api->Signal; if ( ! _ASR_Is_null_handler( asr->handler ) ) { 117da2: 8b 4a 0c mov 0xc(%edx),%ecx 117da5: 85 c9 test %ecx,%ecx 117da7: 74 3f je 117de8 if ( asr->is_enabled ) { 117da9: 80 7a 08 00 cmpb $0x0,0x8(%edx) 117dad: 74 25 je 117dd4 rtems_signal_set *signal_set ) { ISR_Level _level; _ISR_Disable( _level ); 117daf: 9c pushf 117db0: fa cli 117db1: 59 pop %ecx *signal_set |= signals; 117db2: 09 5a 14 or %ebx,0x14(%edx) _ISR_Enable( _level ); 117db5: 51 push %ecx 117db6: 9d popf _ASR_Post_signals( signal_set, &asr->signals_posted ); if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 117db7: 8b 15 d4 2f 14 00 mov 0x142fd4,%edx 117dbd: 85 d2 test %edx,%edx 117dbf: 74 1b je 117ddc 117dc1: 3b 05 d8 2f 14 00 cmp 0x142fd8,%eax 117dc7: 75 13 jne 117ddc <== NEVER TAKEN _Thread_Dispatch_necessary = true; 117dc9: c6 05 e4 2f 14 00 01 movb $0x1,0x142fe4 117dd0: eb 0a jmp 117ddc 117dd2: 66 90 xchg %ax,%ax rtems_signal_set *signal_set ) { ISR_Level _level; _ISR_Disable( _level ); 117dd4: 9c pushf 117dd5: fa cli 117dd6: 58 pop %eax *signal_set |= signals; 117dd7: 09 5a 18 or %ebx,0x18(%edx) _ISR_Enable( _level ); 117dda: 50 push %eax 117ddb: 9d popf } else { _ASR_Post_signals( signal_set, &asr->signals_pending ); } _Thread_Enable_dispatch(); 117ddc: e8 73 40 00 00 call 11be54 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 117de1: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 117de3: 8b 5d fc mov -0x4(%ebp),%ebx 117de6: c9 leave 117de7: c3 ret _ASR_Post_signals( signal_set, &asr->signals_pending ); } _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 117de8: e8 67 40 00 00 call 11be54 <_Thread_Enable_dispatch> return RTEMS_NOT_DEFINED; 117ded: b8 0b 00 00 00 mov $0xb,%eax 117df2: e9 7c ff ff ff jmp 117d73 =============================================================================== 00107ff0 : * rtems_stack_checker_Begin_extension */ void rtems_stack_checker_begin_extension( Thread_Control *the_thread ) { 107ff0: 55 push %ebp 107ff1: 89 e5 mov %esp,%ebp 107ff3: 57 push %edi 107ff4: 56 push %esi 107ff5: 8b 45 08 mov 0x8(%ebp),%eax Stack_check_Control *the_pattern; if ( the_thread->Object.id == 0 ) /* skip system tasks */ 107ff8: 8b 48 08 mov 0x8(%eax),%ecx 107ffb: 85 c9 test %ecx,%ecx 107ffd: 74 15 je 108014 <== NEVER TAKEN return; the_pattern = Stack_check_Get_pattern_area(&the_thread->Start.Initial_stack); *the_pattern = Stack_check_Pattern; 107fff: 8b b8 bc 00 00 00 mov 0xbc(%eax),%edi 108005: 83 c7 08 add $0x8,%edi 108008: be 20 a9 12 00 mov $0x12a920,%esi 10800d: b9 04 00 00 00 mov $0x4,%ecx 108012: f3 a5 rep movsl %ds:(%esi),%es:(%edi) } 108014: 5e pop %esi 108015: 5f pop %edi 108016: c9 leave 108017: c3 ret =============================================================================== 00107fc8 : */ bool rtems_stack_checker_create_extension( Thread_Control *running __attribute__((unused)), Thread_Control *the_thread ) { 107fc8: 55 push %ebp 107fc9: 89 e5 mov %esp,%ebp 107fcb: 57 push %edi 107fcc: 8b 7d 0c mov 0xc(%ebp),%edi Stack_check_Initialize(); 107fcf: e8 88 ff ff ff call 107f5c if (the_thread) 107fd4: 85 ff test %edi,%edi 107fd6: 74 12 je 107fea <== NEVER TAKEN Stack_check_Dope_stack(&the_thread->Start.Initial_stack); 107fd8: 8b 8f b8 00 00 00 mov 0xb8(%edi),%ecx 107fde: 8b 97 bc 00 00 00 mov 0xbc(%edi),%edx 107fe4: b0 a5 mov $0xa5,%al 107fe6: 89 d7 mov %edx,%edi 107fe8: f3 aa rep stos %al,%es:(%edi) return true; } 107fea: b0 01 mov $0x1,%al 107fec: 5f pop %edi 107fed: c9 leave 107fee: c3 ret =============================================================================== 0010812c : /* * Check if blown */ bool rtems_stack_checker_is_blown( void ) { 10812c: 55 push %ebp 10812d: 89 e5 mov %esp,%ebp 10812f: 57 push %edi 108130: 56 push %esi Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack; 108131: a1 d8 b0 12 00 mov 0x12b0d8,%eax ) { #if defined(__GNUC__) void *sp = __builtin_frame_address(0); if ( sp < the_stack->area ) { 108136: 8b b0 bc 00 00 00 mov 0xbc(%eax),%esi 10813c: 39 f5 cmp %esi,%ebp 10813e: 72 3c jb 10817c <== NEVER TAKEN return false; } if ( sp > (the_stack->area + the_stack->size) ) { 108140: 8b 80 b8 00 00 00 mov 0xb8(%eax),%eax 108146: 8d 04 06 lea (%esi,%eax,1),%eax } /* * Check if blown */ bool rtems_stack_checker_is_blown( void ) 108149: 39 c5 cmp %eax,%ebp 10814b: 0f 96 c0 setbe %al /* * The stack checker must be initialized before the pattern is there * to check. */ if ( Stack_check_Initialized ) { 10814e: 8b 15 c8 a5 12 00 mov 0x12a5c8,%edx 108154: 85 d2 test %edx,%edx 108156: 74 30 je 108188 <== NEVER TAKEN pattern_ok = (!memcmp( 108158: 83 c6 08 add $0x8,%esi 10815b: bf 20 a9 12 00 mov $0x12a920,%edi 108160: b9 10 00 00 00 mov $0x10,%ecx 108165: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) 108167: 0f 94 c2 sete %dl /* * Let's report as much as we can. */ if ( !sp_ok || !pattern_ok ) { 10816a: 84 c0 test %al,%al 10816c: 74 1e je 10818c <== NEVER TAKEN 10816e: 84 d2 test %dl,%dl 108170: 74 1a je 10818c <== NEVER TAKEN /* * The Stack Pointer and the Pattern Area are OK so return false. */ return false; } 108172: 31 c0 xor %eax,%eax 108174: 8d 65 f8 lea -0x8(%ebp),%esp 108177: 5e pop %esi 108178: 5f pop %edi 108179: c9 leave 10817a: c3 ret 10817b: 90 nop { #if defined(__GNUC__) void *sp = __builtin_frame_address(0); if ( sp < the_stack->area ) { return false; 10817c: 31 c0 xor %eax,%eax /* * The stack checker must be initialized before the pattern is there * to check. */ if ( Stack_check_Initialized ) { 10817e: 8b 15 c8 a5 12 00 mov 0x12a5c8,%edx <== NOT EXECUTED 108184: 85 d2 test %edx,%edx <== NOT EXECUTED 108186: 75 d0 jne 108158 <== NOT EXECUTED */ bool rtems_stack_checker_is_blown( void ) { Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack; bool sp_ok; bool pattern_ok = true; 108188: b2 01 mov $0x1,%dl <== NOT EXECUTED 10818a: eb de jmp 10816a <== NOT EXECUTED /* * Let's report as much as we can. */ if ( !sp_ok || !pattern_ok ) { Stack_check_report_blown_task( _Thread_Executing, pattern_ok ); 10818c: 57 push %edi <== NOT EXECUTED 10818d: 57 push %edi <== NOT EXECUTED 10818e: 0f b6 d2 movzbl %dl,%edx <== NOT EXECUTED 108191: 52 push %edx <== NOT EXECUTED 108192: ff 35 d8 b0 12 00 pushl 0x12b0d8 <== NOT EXECUTED 108198: e8 7b fe ff ff call 108018 <== NOT EXECUTED =============================================================================== 00108208 : void rtems_stack_checker_report_usage( void ) { 108208: 55 push %ebp <== NOT EXECUTED 108209: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10820b: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED rtems_stack_checker_report_usage_with_plugin( NULL, printk_plugin ); 10820e: 68 1c 9c 10 00 push $0x109c1c <== NOT EXECUTED 108213: 6a 00 push $0x0 <== NOT EXECUTED 108215: e8 86 ff ff ff call 1081a0 <== NOT EXECUTED 10821a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10821d: c9 leave <== NOT EXECUTED 10821e: c3 ret <== NOT EXECUTED =============================================================================== 001081a0 : void rtems_stack_checker_report_usage_with_plugin( void *context, rtems_printk_plugin_t print ) { 1081a0: 55 push %ebp <== NOT EXECUTED 1081a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1081a3: 56 push %esi <== NOT EXECUTED 1081a4: 53 push %ebx <== NOT EXECUTED 1081a5: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 1081a8: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED if ( !print ) 1081ab: 85 db test %ebx,%ebx <== NOT EXECUTED 1081ad: 74 50 je 1081ff <== NOT EXECUTED return; print_context = context; 1081af: 89 35 c0 a5 12 00 mov %esi,0x12a5c0 <== NOT EXECUTED print_handler = print; 1081b5: 89 1d c4 a5 12 00 mov %ebx,0x12a5c4 <== NOT EXECUTED (*print)( context, "Stack usage by thread\n"); 1081bb: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1081be: 68 28 3e 12 00 push $0x123e28 <== NOT EXECUTED 1081c3: 56 push %esi <== NOT EXECUTED 1081c4: ff d3 call *%ebx <== NOT EXECUTED (*print)( context, 1081c6: 59 pop %ecx <== NOT EXECUTED 1081c7: 58 pop %eax <== NOT EXECUTED 1081c8: 68 ac 3e 12 00 push $0x123eac <== NOT EXECUTED 1081cd: 56 push %esi <== NOT EXECUTED 1081ce: ff d3 call *%ebx <== NOT EXECUTED " ID NAME LOW HIGH CURRENT AVAILABLE USED\n" ); /* iterate over all threads and dump the usage */ rtems_iterate_over_all_threads( Stack_check_Dump_threads_usage ); 1081d0: c7 04 24 f0 7d 10 00 movl $0x107df0,(%esp) <== NOT EXECUTED 1081d7: e8 ac 70 00 00 call 10f288 <== NOT EXECUTED #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE) /* dump interrupt stack info if any */ Stack_check_Dump_threads_usage((Thread_Control *) -1); 1081dc: c7 04 24 ff ff ff ff movl $0xffffffff,(%esp) <== NOT EXECUTED 1081e3: e8 08 fc ff ff call 107df0 <== NOT EXECUTED #endif print_context = NULL; 1081e8: c7 05 c0 a5 12 00 00 movl $0x0,0x12a5c0 <== NOT EXECUTED 1081ef: 00 00 00 print_handler = NULL; 1081f2: c7 05 c4 a5 12 00 00 movl $0x0,0x12a5c4 <== NOT EXECUTED 1081f9: 00 00 00 1081fc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 1081ff: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 108202: 5b pop %ebx <== NOT EXECUTED 108203: 5e pop %esi <== NOT EXECUTED 108204: c9 leave <== NOT EXECUTED 108205: c3 ret <== NOT EXECUTED =============================================================================== 001080d4 : */ void rtems_stack_checker_switch_extension( Thread_Control *running __attribute__((unused)), Thread_Control *heir __attribute__((unused)) ) { 1080d4: 55 push %ebp 1080d5: 89 e5 mov %esp,%ebp 1080d7: 57 push %edi 1080d8: 56 push %esi 1080d9: 8b 45 08 mov 0x8(%ebp),%eax Stack_Control *the_stack = &running->Start.Initial_stack; void *pattern; bool sp_ok; bool pattern_ok = true; pattern = Stack_check_Get_pattern_area(the_stack); 1080dc: 8b 90 bc 00 00 00 mov 0xbc(%eax),%edx 1080e2: 8d 72 08 lea 0x8(%edx),%esi ) { #if defined(__GNUC__) void *sp = __builtin_frame_address(0); if ( sp < the_stack->area ) { 1080e5: 39 d5 cmp %edx,%ebp 1080e7: 72 0a jb 1080f3 <== NEVER TAKEN return false; } if ( sp > (the_stack->area + the_stack->size) ) { 1080e9: 03 90 b8 00 00 00 add 0xb8(%eax),%edx 1080ef: 39 d5 cmp %edx,%ebp 1080f1: 76 1d jbe 108110 <== ALWAYS TAKEN /* * Check for an out of bounds stack pointer or an overwrite */ sp_ok = Stack_check_Frame_pointer_in_range( the_stack ); pattern_ok = (!memcmp( pattern, 1080f3: bf 20 a9 12 00 mov $0x12a920,%edi <== NOT EXECUTED 1080f8: b9 10 00 00 00 mov $0x10,%ecx <== NOT EXECUTED 1080fd: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) <== NOT EXECUTED 1080ff: 0f 94 c2 sete %dl <== NOT EXECUTED (void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES)); if ( !sp_ok || !pattern_ok ) { Stack_check_report_blown_task( running, pattern_ok ); 108102: 56 push %esi <== NOT EXECUTED 108103: 56 push %esi <== NOT EXECUTED 108104: 0f b6 d2 movzbl %dl,%edx <== NOT EXECUTED 108107: 52 push %edx <== NOT EXECUTED 108108: 50 push %eax <== NOT EXECUTED 108109: e8 0a ff ff ff call 108018 <== NOT EXECUTED 10810e: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * Check for an out of bounds stack pointer or an overwrite */ sp_ok = Stack_check_Frame_pointer_in_range( the_stack ); pattern_ok = (!memcmp( pattern, 108110: bf 20 a9 12 00 mov $0x12a920,%edi 108115: b9 10 00 00 00 mov $0x10,%ecx (void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES)); if ( !sp_ok || !pattern_ok ) { 10811a: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) 10811c: 75 07 jne 108125 <== NEVER TAKEN Stack_check_report_blown_task( running, pattern_ok ); } } 10811e: 8d 65 f8 lea -0x8(%ebp),%esp 108121: 5e pop %esi 108122: 5f pop %edi 108123: c9 leave 108124: c3 ret sp_ok = Stack_check_Frame_pointer_in_range( the_stack ); pattern_ok = (!memcmp( pattern, (void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES)); if ( !sp_ok || !pattern_ok ) { 108125: 31 d2 xor %edx,%edx <== NOT EXECUTED 108127: eb d9 jmp 108102 <== NOT EXECUTED =============================================================================== 00110b60 : rtems_status_code rtems_string_to_double ( const char *s, double *n, char **endptr ) { 110b60: 55 push %ebp 110b61: 89 e5 mov %esp,%ebp 110b63: 57 push %edi 110b64: 56 push %esi 110b65: 53 push %ebx 110b66: 83 ec 2c sub $0x2c,%esp 110b69: 8b 75 08 mov 0x8(%ebp),%esi 110b6c: 8b 5d 0c mov 0xc(%ebp),%ebx 110b6f: 8b 7d 10 mov 0x10(%ebp),%edi double result; char *end; if ( !n ) 110b72: 85 db test %ebx,%ebx 110b74: 0f 84 b2 00 00 00 je 110c2c return RTEMS_INVALID_ADDRESS; errno = 0; 110b7a: e8 15 2f 00 00 call 113a94 <__errno> 110b7f: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 110b85: c7 03 00 00 00 00 movl $0x0,(%ebx) 110b8b: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) result = strtod( s, &end ); 110b92: 83 ec 08 sub $0x8,%esp 110b95: 8d 45 e4 lea -0x1c(%ebp),%eax 110b98: 50 push %eax 110b99: 56 push %esi 110b9a: e8 f9 58 00 00 call 116498 if ( endptr ) 110b9f: 83 c4 10 add $0x10,%esp 110ba2: 85 ff test %edi,%edi 110ba4: 0f 84 92 00 00 00 je 110c3c *endptr = end; 110baa: 8b 45 e4 mov -0x1c(%ebp),%eax 110bad: 89 07 mov %eax,(%edi) if ( end == s ) 110baf: 39 c6 cmp %eax,%esi 110bb1: 74 69 je 110c1c return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 110bb3: dd 5d c8 fstpl -0x38(%ebp) 110bb6: e8 d9 2e 00 00 call 113a94 <__errno> 110bbb: 83 38 22 cmpl $0x22,(%eax) 110bbe: dd 45 c8 fldl -0x38(%ebp) 110bc1: 74 0d je 110bd0 (( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL ))) return RTEMS_INVALID_NUMBER; *n = result; 110bc3: dd 1b fstpl (%ebx) return RTEMS_SUCCESSFUL; 110bc5: 31 c0 xor %eax,%eax } 110bc7: 8d 65 f4 lea -0xc(%ebp),%esp 110bca: 5b pop %ebx 110bcb: 5e pop %esi 110bcc: 5f pop %edi 110bcd: c9 leave 110bce: c3 ret 110bcf: 90 nop *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 110bd0: d9 ee fldz 110bd2: d9 c9 fxch %st(1) 110bd4: dd e1 fucom %st(1) 110bd6: df e0 fnstsw %ax 110bd8: dd d9 fstp %st(1) 110bda: 80 e4 45 and $0x45,%ah 110bdd: 80 fc 40 cmp $0x40,%ah 110be0: 74 26 je 110c08 <== NEVER TAKEN (( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL ))) 110be2: dd 05 90 61 12 00 fldl 0x126190 110be8: d9 c9 fxch %st(1) 110bea: dd e1 fucom %st(1) 110bec: df e0 fnstsw %ax 110bee: dd d9 fstp %st(1) 110bf0: f6 c4 45 test $0x45,%ah 110bf3: 74 17 je 110c0c <== ALWAYS TAKEN 110bf5: dd 05 98 61 12 00 fldl 0x126198 <== NOT EXECUTED 110bfb: dd e9 fucomp %st(1) <== NOT EXECUTED 110bfd: df e0 fnstsw %ax <== NOT EXECUTED 110bff: f6 c4 45 test $0x45,%ah <== NOT EXECUTED 110c02: 75 bf jne 110bc3 <== NOT EXECUTED 110c04: dd d8 fstp %st(0) <== NOT EXECUTED 110c06: eb 06 jmp 110c0e <== NOT EXECUTED 110c08: dd d8 fstp %st(0) <== NOT EXECUTED 110c0a: eb 02 jmp 110c0e <== NOT EXECUTED 110c0c: dd d8 fstp %st(0) return RTEMS_INVALID_NUMBER; 110c0e: b8 0a 00 00 00 mov $0xa,%eax *n = result; return RTEMS_SUCCESSFUL; } 110c13: 8d 65 f4 lea -0xc(%ebp),%esp 110c16: 5b pop %ebx 110c17: 5e pop %esi 110c18: 5f pop %edi 110c19: c9 leave 110c1a: c3 ret 110c1b: 90 nop 110c1c: dd d8 fstp %st(0) if ( endptr ) *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; 110c1e: b8 0b 00 00 00 mov $0xb,%eax return RTEMS_INVALID_NUMBER; *n = result; return RTEMS_SUCCESSFUL; } 110c23: 8d 65 f4 lea -0xc(%ebp),%esp 110c26: 5b pop %ebx 110c27: 5e pop %esi 110c28: 5f pop %edi 110c29: c9 leave 110c2a: c3 ret 110c2b: 90 nop { double result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 110c2c: b8 09 00 00 00 mov $0x9,%eax return RTEMS_INVALID_NUMBER; *n = result; return RTEMS_SUCCESSFUL; } 110c31: 8d 65 f4 lea -0xc(%ebp),%esp 110c34: 5b pop %ebx 110c35: 5e pop %esi 110c36: 5f pop %edi 110c37: c9 leave 110c38: c3 ret 110c39: 8d 76 00 lea 0x0(%esi),%esi errno = 0; *n = 0; result = strtod( s, &end ); if ( endptr ) 110c3c: 8b 45 e4 mov -0x1c(%ebp),%eax 110c3f: e9 6b ff ff ff jmp 110baf =============================================================================== 00110c44 : rtems_status_code rtems_string_to_float ( const char *s, float *n, char **endptr ) { 110c44: 55 push %ebp 110c45: 89 e5 mov %esp,%ebp 110c47: 57 push %edi 110c48: 56 push %esi 110c49: 53 push %ebx 110c4a: 83 ec 2c sub $0x2c,%esp 110c4d: 8b 75 08 mov 0x8(%ebp),%esi 110c50: 8b 5d 0c mov 0xc(%ebp),%ebx 110c53: 8b 7d 10 mov 0x10(%ebp),%edi float result; char *end; if ( !n ) 110c56: 85 db test %ebx,%ebx 110c58: 0f 84 aa 00 00 00 je 110d08 return RTEMS_INVALID_ADDRESS; errno = 0; 110c5e: e8 31 2e 00 00 call 113a94 <__errno> 110c63: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 110c69: c7 03 00 00 00 00 movl $0x0,(%ebx) result = strtof( s, &end ); 110c6f: 83 ec 08 sub $0x8,%esp 110c72: 8d 45 e4 lea -0x1c(%ebp),%eax 110c75: 50 push %eax 110c76: 56 push %esi 110c77: e8 38 58 00 00 call 1164b4 if ( endptr ) 110c7c: 83 c4 10 add $0x10,%esp 110c7f: 85 ff test %edi,%edi 110c81: 0f 84 91 00 00 00 je 110d18 *endptr = end; 110c87: 8b 45 e4 mov -0x1c(%ebp),%eax 110c8a: 89 07 mov %eax,(%edi) if ( end == s ) 110c8c: 39 c6 cmp %eax,%esi 110c8e: 74 68 je 110cf8 return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 110c90: d9 5d c8 fstps -0x38(%ebp) 110c93: e8 fc 2d 00 00 call 113a94 <__errno> 110c98: 83 38 22 cmpl $0x22,(%eax) 110c9b: d9 45 c8 flds -0x38(%ebp) 110c9e: 74 0c je 110cac (( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF ))) return RTEMS_INVALID_NUMBER; *n = result; 110ca0: d9 1b fstps (%ebx) return RTEMS_SUCCESSFUL; 110ca2: 31 c0 xor %eax,%eax } 110ca4: 8d 65 f4 lea -0xc(%ebp),%esp 110ca7: 5b pop %ebx 110ca8: 5e pop %esi 110ca9: 5f pop %edi 110caa: c9 leave 110cab: c3 ret *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 110cac: d9 ee fldz 110cae: d9 c9 fxch %st(1) 110cb0: dd e1 fucom %st(1) 110cb2: df e0 fnstsw %ax 110cb4: dd d9 fstp %st(1) 110cb6: 80 e4 45 and $0x45,%ah 110cb9: 80 fc 40 cmp $0x40,%ah 110cbc: 74 26 je 110ce4 <== NEVER TAKEN (( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF ))) 110cbe: d9 05 a0 61 12 00 flds 0x1261a0 110cc4: d9 c9 fxch %st(1) 110cc6: dd e1 fucom %st(1) 110cc8: df e0 fnstsw %ax 110cca: dd d9 fstp %st(1) 110ccc: f6 c4 45 test $0x45,%ah 110ccf: 74 17 je 110ce8 <== ALWAYS TAKEN 110cd1: d9 05 a4 61 12 00 flds 0x1261a4 <== NOT EXECUTED 110cd7: dd e9 fucomp %st(1) <== NOT EXECUTED 110cd9: df e0 fnstsw %ax <== NOT EXECUTED 110cdb: f6 c4 45 test $0x45,%ah <== NOT EXECUTED 110cde: 75 c0 jne 110ca0 <== NOT EXECUTED 110ce0: dd d8 fstp %st(0) <== NOT EXECUTED 110ce2: eb 06 jmp 110cea <== NOT EXECUTED 110ce4: dd d8 fstp %st(0) <== NOT EXECUTED 110ce6: eb 02 jmp 110cea <== NOT EXECUTED 110ce8: dd d8 fstp %st(0) return RTEMS_INVALID_NUMBER; 110cea: b8 0a 00 00 00 mov $0xa,%eax *n = result; return RTEMS_SUCCESSFUL; } 110cef: 8d 65 f4 lea -0xc(%ebp),%esp 110cf2: 5b pop %ebx 110cf3: 5e pop %esi 110cf4: 5f pop %edi 110cf5: c9 leave 110cf6: c3 ret 110cf7: 90 nop 110cf8: dd d8 fstp %st(0) if ( endptr ) *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; 110cfa: b8 0b 00 00 00 mov $0xb,%eax return RTEMS_INVALID_NUMBER; *n = result; return RTEMS_SUCCESSFUL; } 110cff: 8d 65 f4 lea -0xc(%ebp),%esp 110d02: 5b pop %ebx 110d03: 5e pop %esi 110d04: 5f pop %edi 110d05: c9 leave 110d06: c3 ret 110d07: 90 nop { float result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 110d08: b8 09 00 00 00 mov $0x9,%eax return RTEMS_INVALID_NUMBER; *n = result; return RTEMS_SUCCESSFUL; } 110d0d: 8d 65 f4 lea -0xc(%ebp),%esp 110d10: 5b pop %ebx 110d11: 5e pop %esi 110d12: 5f pop %edi 110d13: c9 leave 110d14: c3 ret 110d15: 8d 76 00 lea 0x0(%esi),%esi errno = 0; *n = 0; result = strtof( s, &end ); if ( endptr ) 110d18: 8b 45 e4 mov -0x1c(%ebp),%eax 110d1b: e9 6c ff ff ff jmp 110c8c =============================================================================== 00110d20 : const char *s, int *n, char **endptr, int base ) { 110d20: 55 push %ebp 110d21: 89 e5 mov %esp,%ebp 110d23: 57 push %edi 110d24: 56 push %esi 110d25: 53 push %ebx 110d26: 83 ec 2c sub $0x2c,%esp 110d29: 8b 75 08 mov 0x8(%ebp),%esi 110d2c: 8b 5d 0c mov 0xc(%ebp),%ebx 110d2f: 8b 7d 10 mov 0x10(%ebp),%edi long result; char *end; if ( !n ) 110d32: 85 db test %ebx,%ebx 110d34: 0f 84 82 00 00 00 je 110dbc return RTEMS_INVALID_ADDRESS; errno = 0; 110d3a: e8 55 2d 00 00 call 113a94 <__errno> 110d3f: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 110d45: c7 03 00 00 00 00 movl $0x0,(%ebx) result = strtol( s, &end, base ); 110d4b: 50 push %eax 110d4c: ff 75 14 pushl 0x14(%ebp) 110d4f: 8d 45 e4 lea -0x1c(%ebp),%eax 110d52: 50 push %eax 110d53: 56 push %esi 110d54: e8 1b 59 00 00 call 116674 110d59: 89 c2 mov %eax,%edx if ( endptr ) 110d5b: 83 c4 10 add $0x10,%esp 110d5e: 85 ff test %edi,%edi 110d60: 74 6a je 110dcc *endptr = end; 110d62: 8b 45 e4 mov -0x1c(%ebp),%eax 110d65: 89 07 mov %eax,(%edi) if ( end == s ) 110d67: 39 c6 cmp %eax,%esi 110d69: 74 41 je 110dac return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 110d6b: 89 55 d4 mov %edx,-0x2c(%ebp) 110d6e: e8 21 2d 00 00 call 113a94 <__errno> 110d73: 83 38 22 cmpl $0x22,(%eax) 110d76: 8b 55 d4 mov -0x2c(%ebp),%edx 110d79: 74 0d je 110d88 errno = ERANGE; return RTEMS_INVALID_NUMBER; } #endif *n = result; 110d7b: 89 13 mov %edx,(%ebx) return RTEMS_SUCCESSFUL; 110d7d: 31 c0 xor %eax,%eax } 110d7f: 8d 65 f4 lea -0xc(%ebp),%esp 110d82: 5b pop %ebx 110d83: 5e pop %esi 110d84: 5f pop %edi 110d85: c9 leave 110d86: c3 ret 110d87: 90 nop *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 110d88: 85 d2 test %edx,%edx 110d8a: 74 10 je 110d9c <== NEVER TAKEN (( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN ))) 110d8c: 81 fa ff ff ff 7f cmp $0x7fffffff,%edx 110d92: 74 08 je 110d9c <== ALWAYS TAKEN 110d94: 81 fa 00 00 00 80 cmp $0x80000000,%edx <== NOT EXECUTED 110d9a: 75 df jne 110d7b <== NOT EXECUTED return RTEMS_INVALID_NUMBER; 110d9c: b8 0a 00 00 00 mov $0xa,%eax #endif *n = result; return RTEMS_SUCCESSFUL; } 110da1: 8d 65 f4 lea -0xc(%ebp),%esp 110da4: 5b pop %ebx 110da5: 5e pop %esi 110da6: 5f pop %edi 110da7: c9 leave 110da8: c3 ret 110da9: 8d 76 00 lea 0x0(%esi),%esi if ( endptr ) *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; 110dac: b8 0b 00 00 00 mov $0xb,%eax #endif *n = result; return RTEMS_SUCCESSFUL; } 110db1: 8d 65 f4 lea -0xc(%ebp),%esp 110db4: 5b pop %ebx 110db5: 5e pop %esi 110db6: 5f pop %edi 110db7: c9 leave 110db8: c3 ret 110db9: 8d 76 00 lea 0x0(%esi),%esi { long result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 110dbc: b8 09 00 00 00 mov $0x9,%eax #endif *n = result; return RTEMS_SUCCESSFUL; } 110dc1: 8d 65 f4 lea -0xc(%ebp),%esp 110dc4: 5b pop %ebx 110dc5: 5e pop %esi 110dc6: 5f pop %edi 110dc7: c9 leave 110dc8: c3 ret 110dc9: 8d 76 00 lea 0x0(%esi),%esi errno = 0; *n = 0; result = strtol( s, &end, base ); if ( endptr ) 110dcc: 8b 45 e4 mov -0x1c(%ebp),%eax 110dcf: eb 96 jmp 110d67 =============================================================================== 00110ea0 : const char *s, long *n, char **endptr, int base ) { 110ea0: 55 push %ebp 110ea1: 89 e5 mov %esp,%ebp 110ea3: 57 push %edi 110ea4: 56 push %esi 110ea5: 53 push %ebx 110ea6: 83 ec 2c sub $0x2c,%esp 110ea9: 8b 75 08 mov 0x8(%ebp),%esi 110eac: 8b 5d 0c mov 0xc(%ebp),%ebx 110eaf: 8b 7d 10 mov 0x10(%ebp),%edi long result; char *end; if ( !n ) 110eb2: 85 db test %ebx,%ebx 110eb4: 0f 84 82 00 00 00 je 110f3c return RTEMS_INVALID_ADDRESS; errno = 0; 110eba: e8 d5 2b 00 00 call 113a94 <__errno> 110ebf: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 110ec5: c7 03 00 00 00 00 movl $0x0,(%ebx) result = strtol( s, &end, base ); 110ecb: 50 push %eax 110ecc: ff 75 14 pushl 0x14(%ebp) 110ecf: 8d 45 e4 lea -0x1c(%ebp),%eax 110ed2: 50 push %eax 110ed3: 56 push %esi 110ed4: e8 9b 57 00 00 call 116674 110ed9: 89 c2 mov %eax,%edx if ( endptr ) 110edb: 83 c4 10 add $0x10,%esp 110ede: 85 ff test %edi,%edi 110ee0: 74 6a je 110f4c *endptr = end; 110ee2: 8b 45 e4 mov -0x1c(%ebp),%eax 110ee5: 89 07 mov %eax,(%edi) if ( end == s ) 110ee7: 39 c6 cmp %eax,%esi 110ee9: 74 41 je 110f2c return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 110eeb: 89 55 d4 mov %edx,-0x2c(%ebp) 110eee: e8 a1 2b 00 00 call 113a94 <__errno> 110ef3: 83 38 22 cmpl $0x22,(%eax) 110ef6: 8b 55 d4 mov -0x2c(%ebp),%edx 110ef9: 74 0d je 110f08 (( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN ))) return RTEMS_INVALID_NUMBER; *n = result; 110efb: 89 13 mov %edx,(%ebx) return RTEMS_SUCCESSFUL; 110efd: 31 c0 xor %eax,%eax } 110eff: 8d 65 f4 lea -0xc(%ebp),%esp 110f02: 5b pop %ebx 110f03: 5e pop %esi 110f04: 5f pop %edi 110f05: c9 leave 110f06: c3 ret 110f07: 90 nop *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 110f08: 85 d2 test %edx,%edx 110f0a: 74 10 je 110f1c <== NEVER TAKEN (( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN ))) 110f0c: 81 fa ff ff ff 7f cmp $0x7fffffff,%edx 110f12: 74 08 je 110f1c 110f14: 81 fa 00 00 00 80 cmp $0x80000000,%edx 110f1a: 75 df jne 110efb <== NEVER TAKEN return RTEMS_INVALID_NUMBER; 110f1c: b8 0a 00 00 00 mov $0xa,%eax *n = result; return RTEMS_SUCCESSFUL; } 110f21: 8d 65 f4 lea -0xc(%ebp),%esp 110f24: 5b pop %ebx 110f25: 5e pop %esi 110f26: 5f pop %edi 110f27: c9 leave 110f28: c3 ret 110f29: 8d 76 00 lea 0x0(%esi),%esi if ( endptr ) *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; 110f2c: b8 0b 00 00 00 mov $0xb,%eax return RTEMS_INVALID_NUMBER; *n = result; return RTEMS_SUCCESSFUL; } 110f31: 8d 65 f4 lea -0xc(%ebp),%esp 110f34: 5b pop %ebx 110f35: 5e pop %esi 110f36: 5f pop %edi 110f37: c9 leave 110f38: c3 ret 110f39: 8d 76 00 lea 0x0(%esi),%esi { long result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 110f3c: b8 09 00 00 00 mov $0x9,%eax return RTEMS_INVALID_NUMBER; *n = result; return RTEMS_SUCCESSFUL; } 110f41: 8d 65 f4 lea -0xc(%ebp),%esp 110f44: 5b pop %ebx 110f45: 5e pop %esi 110f46: 5f pop %edi 110f47: c9 leave 110f48: c3 ret 110f49: 8d 76 00 lea 0x0(%esi),%esi errno = 0; *n = 0; result = strtol( s, &end, base ); if ( endptr ) 110f4c: 8b 45 e4 mov -0x1c(%ebp),%eax 110f4f: eb 96 jmp 110ee7 =============================================================================== 00110dd4 : const char *s, long long *n, char **endptr, int base ) { 110dd4: 55 push %ebp 110dd5: 89 e5 mov %esp,%ebp 110dd7: 57 push %edi 110dd8: 56 push %esi 110dd9: 53 push %ebx 110dda: 83 ec 2c sub $0x2c,%esp 110ddd: 8b 5d 0c mov 0xc(%ebp),%ebx 110de0: 8b 7d 10 mov 0x10(%ebp),%edi long long result; char *end; if ( !n ) 110de3: 85 db test %ebx,%ebx 110de5: 0f 84 9d 00 00 00 je 110e88 return RTEMS_INVALID_ADDRESS; errno = 0; 110deb: e8 a4 2c 00 00 call 113a94 <__errno> 110df0: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 110df6: c7 03 00 00 00 00 movl $0x0,(%ebx) 110dfc: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) result = strtoll( s, &end, base ); 110e03: 50 push %eax 110e04: ff 75 14 pushl 0x14(%ebp) 110e07: 8d 45 e4 lea -0x1c(%ebp),%eax 110e0a: 50 push %eax 110e0b: ff 75 08 pushl 0x8(%ebp) 110e0e: e8 7d 58 00 00 call 116690 110e13: 89 c6 mov %eax,%esi if ( endptr ) 110e15: 83 c4 10 add $0x10,%esp 110e18: 85 ff test %edi,%edi 110e1a: 74 7c je 110e98 *endptr = end; 110e1c: 8b 45 e4 mov -0x1c(%ebp),%eax 110e1f: 89 07 mov %eax,(%edi) if ( end == s ) 110e21: 39 45 08 cmp %eax,0x8(%ebp) 110e24: 74 52 je 110e78 return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 110e26: 89 55 d4 mov %edx,-0x2c(%ebp) 110e29: e8 66 2c 00 00 call 113a94 <__errno> 110e2e: 83 38 22 cmpl $0x22,(%eax) 110e31: 8b 55 d4 mov -0x2c(%ebp),%edx 110e34: 74 12 je 110e48 (( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN ))) return RTEMS_INVALID_NUMBER; *n = result; 110e36: 89 33 mov %esi,(%ebx) 110e38: 89 53 04 mov %edx,0x4(%ebx) return RTEMS_SUCCESSFUL; 110e3b: 31 c0 xor %eax,%eax } 110e3d: 8d 65 f4 lea -0xc(%ebp),%esp 110e40: 5b pop %ebx 110e41: 5e pop %esi 110e42: 5f pop %edi 110e43: c9 leave 110e44: c3 ret 110e45: 8d 76 00 lea 0x0(%esi),%esi *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 110e48: 89 d0 mov %edx,%eax 110e4a: 09 f0 or %esi,%eax 110e4c: 74 1a je 110e68 <== NEVER TAKEN (( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN ))) 110e4e: 89 d1 mov %edx,%ecx 110e50: 81 f1 ff ff ff 7f xor $0x7fffffff,%ecx 110e56: 89 f0 mov %esi,%eax 110e58: f7 d0 not %eax 110e5a: 09 c1 or %eax,%ecx 110e5c: 74 0a je 110e68 110e5e: 8d 82 00 00 00 80 lea -0x80000000(%edx),%eax 110e64: 09 f0 or %esi,%eax 110e66: 75 ce jne 110e36 <== NEVER TAKEN return RTEMS_INVALID_NUMBER; 110e68: b8 0a 00 00 00 mov $0xa,%eax *n = result; return RTEMS_SUCCESSFUL; } 110e6d: 8d 65 f4 lea -0xc(%ebp),%esp 110e70: 5b pop %ebx 110e71: 5e pop %esi 110e72: 5f pop %edi 110e73: c9 leave 110e74: c3 ret 110e75: 8d 76 00 lea 0x0(%esi),%esi if ( endptr ) *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; 110e78: b8 0b 00 00 00 mov $0xb,%eax return RTEMS_INVALID_NUMBER; *n = result; return RTEMS_SUCCESSFUL; } 110e7d: 8d 65 f4 lea -0xc(%ebp),%esp 110e80: 5b pop %ebx 110e81: 5e pop %esi 110e82: 5f pop %edi 110e83: c9 leave 110e84: c3 ret 110e85: 8d 76 00 lea 0x0(%esi),%esi { long long result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 110e88: b8 09 00 00 00 mov $0x9,%eax return RTEMS_INVALID_NUMBER; *n = result; return RTEMS_SUCCESSFUL; } 110e8d: 8d 65 f4 lea -0xc(%ebp),%esp 110e90: 5b pop %ebx 110e91: 5e pop %esi 110e92: 5f pop %edi 110e93: c9 leave 110e94: c3 ret 110e95: 8d 76 00 lea 0x0(%esi),%esi errno = 0; *n = 0; result = strtoll( s, &end, base ); if ( endptr ) 110e98: 8b 45 e4 mov -0x1c(%ebp),%eax 110e9b: eb 84 jmp 110e21 =============================================================================== 00110f6c : const char *s, unsigned char *n, char **endptr, int base ) { 110f6c: 55 push %ebp 110f6d: 89 e5 mov %esp,%ebp 110f6f: 57 push %edi 110f70: 56 push %esi 110f71: 53 push %ebx 110f72: 83 ec 2c sub $0x2c,%esp 110f75: 8b 75 08 mov 0x8(%ebp),%esi 110f78: 8b 5d 0c mov 0xc(%ebp),%ebx 110f7b: 8b 7d 10 mov 0x10(%ebp),%edi unsigned long result; char *end; if ( !n ) 110f7e: 85 db test %ebx,%ebx 110f80: 0f 84 92 00 00 00 je 111018 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; errno = 0; 110f86: e8 09 2b 00 00 call 113a94 <__errno> 110f8b: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 110f91: c6 03 00 movb $0x0,(%ebx) result = strtoul( s, &end, base ); 110f94: 50 push %eax 110f95: ff 75 14 pushl 0x14(%ebp) 110f98: 8d 45 e4 lea -0x1c(%ebp),%eax 110f9b: 50 push %eax 110f9c: 56 push %esi 110f9d: e8 8e 5b 00 00 call 116b30 110fa2: 89 c2 mov %eax,%edx if ( endptr ) 110fa4: 83 c4 10 add $0x10,%esp 110fa7: 85 ff test %edi,%edi 110fa9: 74 7d je 111028 <== NEVER TAKEN *endptr = end; 110fab: 8b 45 e4 mov -0x1c(%ebp),%eax 110fae: 89 07 mov %eax,(%edi) if ( end == s ) 110fb0: 39 c6 cmp %eax,%esi 110fb2: 74 54 je 111008 <== NEVER TAKEN return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 110fb4: 89 55 d4 mov %edx,-0x2c(%ebp) 110fb7: e8 d8 2a 00 00 call 113a94 <__errno> 110fbc: 83 38 22 cmpl $0x22,(%eax) 110fbf: 8b 55 d4 mov -0x2c(%ebp),%edx 110fc2: 74 14 je 110fd8 <== NEVER TAKEN (( result == 0 ) || ( result == ULONG_MAX ))) return RTEMS_INVALID_NUMBER; #if (UCHAR_MAX < ULONG_MAX) if ( result > UCHAR_MAX ) { 110fc4: 81 fa ff 00 00 00 cmp $0xff,%edx 110fca: 77 24 ja 110ff0 <== NEVER TAKEN errno = ERANGE; return RTEMS_INVALID_NUMBER; } #endif *n = result; 110fcc: 88 13 mov %dl,(%ebx) return RTEMS_SUCCESSFUL; 110fce: 31 c0 xor %eax,%eax } 110fd0: 8d 65 f4 lea -0xc(%ebp),%esp 110fd3: 5b pop %ebx 110fd4: 5e pop %esi 110fd5: 5f pop %edi 110fd6: c9 leave 110fd7: c3 ret if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && (( result == 0 ) || ( result == ULONG_MAX ))) 110fd8: 8d 42 ff lea -0x1(%edx),%eax <== NOT EXECUTED *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 110fdb: 83 f8 fd cmp $0xfffffffd,%eax <== NOT EXECUTED 110fde: 76 e4 jbe 110fc4 <== NOT EXECUTED (( result == 0 ) || ( result == ULONG_MAX ))) return RTEMS_INVALID_NUMBER; 110fe0: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED #endif *n = result; return RTEMS_SUCCESSFUL; } 110fe5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 110fe8: 5b pop %ebx <== NOT EXECUTED 110fe9: 5e pop %esi <== NOT EXECUTED 110fea: 5f pop %edi <== NOT EXECUTED 110feb: c9 leave <== NOT EXECUTED 110fec: c3 ret <== NOT EXECUTED 110fed: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED (( result == 0 ) || ( result == ULONG_MAX ))) return RTEMS_INVALID_NUMBER; #if (UCHAR_MAX < ULONG_MAX) if ( result > UCHAR_MAX ) { errno = ERANGE; 110ff0: e8 9f 2a 00 00 call 113a94 <__errno> <== NOT EXECUTED 110ff5: c7 00 22 00 00 00 movl $0x22,(%eax) <== NOT EXECUTED return RTEMS_INVALID_NUMBER; 110ffb: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED #endif *n = result; return RTEMS_SUCCESSFUL; } 111000: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 111003: 5b pop %ebx <== NOT EXECUTED 111004: 5e pop %esi <== NOT EXECUTED 111005: 5f pop %edi <== NOT EXECUTED 111006: c9 leave <== NOT EXECUTED 111007: c3 ret <== NOT EXECUTED if ( endptr ) *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; 111008: b8 0b 00 00 00 mov $0xb,%eax #endif *n = result; return RTEMS_SUCCESSFUL; } 11100d: 8d 65 f4 lea -0xc(%ebp),%esp 111010: 5b pop %ebx 111011: 5e pop %esi 111012: 5f pop %edi 111013: c9 leave 111014: c3 ret 111015: 8d 76 00 lea 0x0(%esi),%esi { unsigned long result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 111018: b8 09 00 00 00 mov $0x9,%eax #endif *n = result; return RTEMS_SUCCESSFUL; } 11101d: 8d 65 f4 lea -0xc(%ebp),%esp 111020: 5b pop %ebx 111021: 5e pop %esi 111022: 5f pop %edi 111023: c9 leave 111024: c3 ret 111025: 8d 76 00 lea 0x0(%esi),%esi errno = 0; *n = 0; result = strtoul( s, &end, base ); if ( endptr ) 111028: 8b 45 e4 mov -0x1c(%ebp),%eax 11102b: eb 83 jmp 110fb0 =============================================================================== 00111030 : const char *s, unsigned int *n, char **endptr, int base ) { 111030: 55 push %ebp 111031: 89 e5 mov %esp,%ebp 111033: 57 push %edi 111034: 56 push %esi 111035: 53 push %ebx 111036: 83 ec 2c sub $0x2c,%esp 111039: 8b 75 08 mov 0x8(%ebp),%esi 11103c: 8b 5d 0c mov 0xc(%ebp),%ebx 11103f: 8b 7d 10 mov 0x10(%ebp),%edi unsigned long result; char *end; if ( !n ) 111042: 85 db test %ebx,%ebx 111044: 74 76 je 1110bc return RTEMS_INVALID_ADDRESS; errno = 0; 111046: e8 49 2a 00 00 call 113a94 <__errno> 11104b: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 111051: c7 03 00 00 00 00 movl $0x0,(%ebx) result = strtoul( s, &end, base ); 111057: 50 push %eax 111058: ff 75 14 pushl 0x14(%ebp) 11105b: 8d 45 e4 lea -0x1c(%ebp),%eax 11105e: 50 push %eax 11105f: 56 push %esi 111060: e8 cb 5a 00 00 call 116b30 111065: 89 c2 mov %eax,%edx if ( endptr ) 111067: 83 c4 10 add $0x10,%esp 11106a: 85 ff test %edi,%edi 11106c: 74 5e je 1110cc *endptr = end; 11106e: 8b 45 e4 mov -0x1c(%ebp),%eax 111071: 89 07 mov %eax,(%edi) if ( end == s ) 111073: 39 c6 cmp %eax,%esi 111075: 74 35 je 1110ac return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 111077: 89 55 d4 mov %edx,-0x2c(%ebp) 11107a: e8 15 2a 00 00 call 113a94 <__errno> 11107f: 83 38 22 cmpl $0x22,(%eax) 111082: 8b 55 d4 mov -0x2c(%ebp),%edx 111085: 74 0d je 111094 errno = ERANGE; return RTEMS_INVALID_NUMBER; } #endif *n = result; 111087: 89 13 mov %edx,(%ebx) return RTEMS_SUCCESSFUL; 111089: 31 c0 xor %eax,%eax } 11108b: 8d 65 f4 lea -0xc(%ebp),%esp 11108e: 5b pop %ebx 11108f: 5e pop %esi 111090: 5f pop %edi 111091: c9 leave 111092: c3 ret 111093: 90 nop if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && (( result == 0 ) || ( result == ULONG_MAX ))) 111094: 8d 42 ff lea -0x1(%edx),%eax *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 111097: 83 f8 fd cmp $0xfffffffd,%eax 11109a: 76 eb jbe 111087 <== NEVER TAKEN (( result == 0 ) || ( result == ULONG_MAX ))) return RTEMS_INVALID_NUMBER; 11109c: b8 0a 00 00 00 mov $0xa,%eax #endif *n = result; return RTEMS_SUCCESSFUL; } 1110a1: 8d 65 f4 lea -0xc(%ebp),%esp 1110a4: 5b pop %ebx 1110a5: 5e pop %esi 1110a6: 5f pop %edi 1110a7: c9 leave 1110a8: c3 ret 1110a9: 8d 76 00 lea 0x0(%esi),%esi if ( endptr ) *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; 1110ac: b8 0b 00 00 00 mov $0xb,%eax #endif *n = result; return RTEMS_SUCCESSFUL; } 1110b1: 8d 65 f4 lea -0xc(%ebp),%esp 1110b4: 5b pop %ebx 1110b5: 5e pop %esi 1110b6: 5f pop %edi 1110b7: c9 leave 1110b8: c3 ret 1110b9: 8d 76 00 lea 0x0(%esi),%esi { unsigned long result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 1110bc: b8 09 00 00 00 mov $0x9,%eax #endif *n = result; return RTEMS_SUCCESSFUL; } 1110c1: 8d 65 f4 lea -0xc(%ebp),%esp 1110c4: 5b pop %ebx 1110c5: 5e pop %esi 1110c6: 5f pop %edi 1110c7: c9 leave 1110c8: c3 ret 1110c9: 8d 76 00 lea 0x0(%esi),%esi errno = 0; *n = 0; result = strtoul( s, &end, base ); if ( endptr ) 1110cc: 8b 45 e4 mov -0x1c(%ebp),%eax 1110cf: eb a2 jmp 111073 =============================================================================== 0011119c : const char *s, unsigned long *n, char **endptr, int base ) { 11119c: 55 push %ebp 11119d: 89 e5 mov %esp,%ebp 11119f: 57 push %edi 1111a0: 56 push %esi 1111a1: 53 push %ebx 1111a2: 83 ec 2c sub $0x2c,%esp 1111a5: 8b 75 08 mov 0x8(%ebp),%esi 1111a8: 8b 5d 0c mov 0xc(%ebp),%ebx 1111ab: 8b 7d 10 mov 0x10(%ebp),%edi unsigned long result; char *end; if ( !n ) 1111ae: 85 db test %ebx,%ebx 1111b0: 74 76 je 111228 return RTEMS_INVALID_ADDRESS; errno = 0; 1111b2: e8 dd 28 00 00 call 113a94 <__errno> 1111b7: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 1111bd: c7 03 00 00 00 00 movl $0x0,(%ebx) result = strtoul( s, &end, base ); 1111c3: 50 push %eax 1111c4: ff 75 14 pushl 0x14(%ebp) 1111c7: 8d 45 e4 lea -0x1c(%ebp),%eax 1111ca: 50 push %eax 1111cb: 56 push %esi 1111cc: e8 5f 59 00 00 call 116b30 1111d1: 89 c2 mov %eax,%edx if ( endptr ) 1111d3: 83 c4 10 add $0x10,%esp 1111d6: 85 ff test %edi,%edi 1111d8: 74 5e je 111238 *endptr = end; 1111da: 8b 45 e4 mov -0x1c(%ebp),%eax 1111dd: 89 07 mov %eax,(%edi) if ( end == s ) 1111df: 39 c6 cmp %eax,%esi 1111e1: 74 35 je 111218 return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 1111e3: 89 55 d4 mov %edx,-0x2c(%ebp) 1111e6: e8 a9 28 00 00 call 113a94 <__errno> 1111eb: 83 38 22 cmpl $0x22,(%eax) 1111ee: 8b 55 d4 mov -0x2c(%ebp),%edx 1111f1: 74 0d je 111200 (( result == 0 ) || ( result == ULONG_MAX ))) return RTEMS_INVALID_NUMBER; *n = result; 1111f3: 89 13 mov %edx,(%ebx) return RTEMS_SUCCESSFUL; 1111f5: 31 c0 xor %eax,%eax } 1111f7: 8d 65 f4 lea -0xc(%ebp),%esp 1111fa: 5b pop %ebx 1111fb: 5e pop %esi 1111fc: 5f pop %edi 1111fd: c9 leave 1111fe: c3 ret 1111ff: 90 nop if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && (( result == 0 ) || ( result == ULONG_MAX ))) 111200: 8d 42 ff lea -0x1(%edx),%eax *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 111203: 83 f8 fd cmp $0xfffffffd,%eax 111206: 76 eb jbe 1111f3 <== NEVER TAKEN (( result == 0 ) || ( result == ULONG_MAX ))) return RTEMS_INVALID_NUMBER; 111208: b8 0a 00 00 00 mov $0xa,%eax *n = result; return RTEMS_SUCCESSFUL; } 11120d: 8d 65 f4 lea -0xc(%ebp),%esp 111210: 5b pop %ebx 111211: 5e pop %esi 111212: 5f pop %edi 111213: c9 leave 111214: c3 ret 111215: 8d 76 00 lea 0x0(%esi),%esi if ( endptr ) *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; 111218: b8 0b 00 00 00 mov $0xb,%eax return RTEMS_INVALID_NUMBER; *n = result; return RTEMS_SUCCESSFUL; } 11121d: 8d 65 f4 lea -0xc(%ebp),%esp 111220: 5b pop %ebx 111221: 5e pop %esi 111222: 5f pop %edi 111223: c9 leave 111224: c3 ret 111225: 8d 76 00 lea 0x0(%esi),%esi { unsigned long result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 111228: b8 09 00 00 00 mov $0x9,%eax return RTEMS_INVALID_NUMBER; *n = result; return RTEMS_SUCCESSFUL; } 11122d: 8d 65 f4 lea -0xc(%ebp),%esp 111230: 5b pop %ebx 111231: 5e pop %esi 111232: 5f pop %edi 111233: c9 leave 111234: c3 ret 111235: 8d 76 00 lea 0x0(%esi),%esi errno = 0; *n = 0; result = strtoul( s, &end, base ); if ( endptr ) 111238: 8b 45 e4 mov -0x1c(%ebp),%eax 11123b: eb a2 jmp 1111df =============================================================================== 001110d4 : const char *s, unsigned long long *n, char **endptr, int base ) { 1110d4: 55 push %ebp 1110d5: 89 e5 mov %esp,%ebp 1110d7: 57 push %edi 1110d8: 56 push %esi 1110d9: 53 push %ebx 1110da: 83 ec 2c sub $0x2c,%esp 1110dd: 8b 7d 08 mov 0x8(%ebp),%edi 1110e0: 8b 5d 0c mov 0xc(%ebp),%ebx 1110e3: 8b 75 10 mov 0x10(%ebp),%esi unsigned long long result; char *end; if ( !n ) 1110e6: 85 db test %ebx,%ebx 1110e8: 0f 84 96 00 00 00 je 111184 return RTEMS_INVALID_ADDRESS; errno = 0; 1110ee: e8 a1 29 00 00 call 113a94 <__errno> 1110f3: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 1110f9: c7 03 00 00 00 00 movl $0x0,(%ebx) 1110ff: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) result = strtoull( s, &end, base ); 111106: 50 push %eax 111107: ff 75 14 pushl 0x14(%ebp) 11110a: 8d 45 e4 lea -0x1c(%ebp),%eax 11110d: 50 push %eax 11110e: 57 push %edi 11110f: e8 38 5a 00 00 call 116b4c 111114: 89 d1 mov %edx,%ecx 111116: 89 c2 mov %eax,%edx if ( endptr ) 111118: 83 c4 10 add $0x10,%esp 11111b: 85 f6 test %esi,%esi 11111d: 74 75 je 111194 *endptr = end; 11111f: 8b 45 e4 mov -0x1c(%ebp),%eax 111122: 89 06 mov %eax,(%esi) if ( end == s ) 111124: 39 c7 cmp %eax,%edi 111126: 74 4c je 111174 return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 111128: 89 55 d4 mov %edx,-0x2c(%ebp) 11112b: 89 4d d0 mov %ecx,-0x30(%ebp) 11112e: e8 61 29 00 00 call 113a94 <__errno> 111133: 83 38 22 cmpl $0x22,(%eax) 111136: 8b 55 d4 mov -0x2c(%ebp),%edx 111139: 8b 4d d0 mov -0x30(%ebp),%ecx 11113c: 74 12 je 111150 (( result == 0 ) || ( result == ULONG_LONG_MAX ))) return RTEMS_INVALID_NUMBER; *n = result; 11113e: 89 13 mov %edx,(%ebx) 111140: 89 4b 04 mov %ecx,0x4(%ebx) return RTEMS_SUCCESSFUL; 111143: 31 c0 xor %eax,%eax } 111145: 8d 65 f4 lea -0xc(%ebp),%esp 111148: 5b pop %ebx 111149: 5e pop %esi 11114a: 5f pop %edi 11114b: c9 leave 11114c: c3 ret 11114d: 8d 76 00 lea 0x0(%esi),%esi if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && (( result == 0 ) || ( result == ULONG_LONG_MAX ))) 111150: 89 d6 mov %edx,%esi 111152: 89 cf mov %ecx,%edi 111154: 83 c6 ff add $0xffffffff,%esi 111157: 83 d7 ff adc $0xffffffff,%edi *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 11115a: 83 ff ff cmp $0xffffffff,%edi 11115d: 72 df jb 11113e <== NEVER TAKEN 11115f: 83 fe fd cmp $0xfffffffd,%esi 111162: 76 da jbe 11113e <== NEVER TAKEN (( result == 0 ) || ( result == ULONG_LONG_MAX ))) return RTEMS_INVALID_NUMBER; 111164: b8 0a 00 00 00 mov $0xa,%eax *n = result; return RTEMS_SUCCESSFUL; } 111169: 8d 65 f4 lea -0xc(%ebp),%esp 11116c: 5b pop %ebx 11116d: 5e pop %esi 11116e: 5f pop %edi 11116f: c9 leave 111170: c3 ret 111171: 8d 76 00 lea 0x0(%esi),%esi if ( endptr ) *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; 111174: b8 0b 00 00 00 mov $0xb,%eax return RTEMS_INVALID_NUMBER; *n = result; return RTEMS_SUCCESSFUL; } 111179: 8d 65 f4 lea -0xc(%ebp),%esp 11117c: 5b pop %ebx 11117d: 5e pop %esi 11117e: 5f pop %edi 11117f: c9 leave 111180: c3 ret 111181: 8d 76 00 lea 0x0(%esi),%esi { unsigned long long result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 111184: b8 09 00 00 00 mov $0x9,%eax return RTEMS_INVALID_NUMBER; *n = result; return RTEMS_SUCCESSFUL; } 111189: 8d 65 f4 lea -0xc(%ebp),%esp 11118c: 5b pop %ebx 11118d: 5e pop %esi 11118e: 5f pop %edi 11118f: c9 leave 111190: c3 ret 111191: 8d 76 00 lea 0x0(%esi),%esi errno = 0; *n = 0; result = strtoull( s, &end, base ); if ( endptr ) 111194: 8b 45 e4 mov -0x1c(%ebp),%eax 111197: eb 8b jmp 111124 =============================================================================== 00107e24 : int rtems_tarfs_load( char *mountpoint, uint8_t *tar_image, size_t tar_size ) { 107e24: 55 push %ebp 107e25: 89 e5 mov %esp,%ebp 107e27: 57 push %edi 107e28: 56 push %esi 107e29: 53 push %ebx 107e2a: 81 ec d8 01 00 00 sub $0x1d8,%esp int offset; unsigned long nblocks; IMFS_jnode_t *node; int status; status = rtems_filesystem_evaluate_path( 107e30: 31 c0 xor %eax,%eax 107e32: b9 ff ff ff ff mov $0xffffffff,%ecx 107e37: 8b 7d 08 mov 0x8(%ebp),%edi 107e3a: f2 ae repnz scas %es:(%edi),%al 107e3c: f7 d1 not %ecx 107e3e: 49 dec %ecx 107e3f: 6a 00 push $0x0 107e41: 8d 45 d0 lea -0x30(%ebp),%eax 107e44: 89 85 2c fe ff ff mov %eax,-0x1d4(%ebp) 107e4a: 50 push %eax 107e4b: 6a 00 push $0x0 107e4d: 51 push %ecx 107e4e: ff 75 08 pushl 0x8(%ebp) 107e51: e8 9a 0a 00 00 call 1088f0 107e56: 89 85 44 fe ff ff mov %eax,-0x1bc(%ebp) strlen(mountpoint), 0, &root_loc, 0 ); if (status != 0) 107e5c: 83 c4 20 add $0x20,%esp 107e5f: 85 c0 test %eax,%eax 107e61: 0f 85 61 01 00 00 jne 107fc8 return -1; if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops) 107e67: 8b 45 dc mov -0x24(%ebp),%eax 107e6a: 3d 80 6d 12 00 cmp $0x126d80,%eax 107e6f: 0f 85 47 01 00 00 jne 107fbc 107e75: 31 db xor %ebx,%ebx * should not have this path. */ else if (linkflag == REGTYPE) { const char *name; loc = root_loc; 107e77: 8d 45 bc lea -0x44(%ebp),%eax 107e7a: 89 85 30 fe ff ff mov %eax,-0x1d0(%ebp) * - For directories, just create directories as usual. IMFS * will take care of the rest. * - For files, create a file node with special tarfs properties. */ if (linkflag == DIRTYPE) { strcpy(full_filename, mountpoint); 107e80: 8d 95 58 fe ff ff lea -0x1a8(%ebp),%edx 107e86: 89 95 34 fe ff ff mov %edx,-0x1cc(%ebp) 107e8c: eb 15 jmp 107ea3 107e8e: 66 90 xchg %ax,%ax * IMFS_create_node was ONLY passed a NULL when we created the * root node. We added a new IMFS_create_root_node() so this * path no longer existed. The result was simpler code which * should not have this path. */ else if (linkflag == REGTYPE) { 107e90: 80 bd 53 fe ff ff 30 cmpb $0x30,-0x1ad(%ebp) 107e97: 0f 84 43 01 00 00 je 107fe0 0 ); if (status != 0) return -1; if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops) 107e9d: 8b 9d 54 fe ff ff mov -0x1ac(%ebp),%ebx /* * Create an IMFS node structure pointing to tar image memory. */ offset = 0; while (1) { if (offset + 512 > tar_size) 107ea3: 8d 83 00 02 00 00 lea 0x200(%ebx),%eax 107ea9: 89 85 54 fe ff ff mov %eax,-0x1ac(%ebp) 107eaf: 8b 55 10 mov 0x10(%ebp),%edx 107eb2: 39 d0 cmp %edx,%eax 107eb4: 0f 87 18 01 00 00 ja 107fd2 <== NEVER TAKEN break; /* * Read a header. */ hdr_ptr = (char *) &tar_image[offset]; 107eba: 03 5d 0c add 0xc(%ebp),%ebx offset += 512; if (strncmp(&hdr_ptr[257], "ustar", 5)) 107ebd: 8d b3 01 01 00 00 lea 0x101(%ebx),%esi 107ec3: bf c8 6d 12 00 mov $0x126dc8,%edi 107ec8: b9 05 00 00 00 mov $0x5,%ecx 107ecd: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) 107ecf: 0f 85 fd 00 00 00 jne 107fd2 break; strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE); 107ed5: 57 push %edi 107ed6: 6a 63 push $0x63 107ed8: 53 push %ebx 107ed9: 8d 85 58 ff ff ff lea -0xa8(%ebp),%eax 107edf: 50 push %eax 107ee0: e8 a7 fd 00 00 call 117c8c filename[MAX_NAME_FIELD_SIZE] = '\0'; 107ee5: c6 45 bb 00 movb $0x0,-0x45(%ebp) linkflag = hdr_ptr[156]; 107ee9: 8a 93 9c 00 00 00 mov 0x9c(%ebx),%dl 107eef: 88 95 53 fe ff ff mov %dl,-0x1ad(%ebp) file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8); 107ef5: 59 pop %ecx 107ef6: 5e pop %esi 107ef7: 6a 08 push $0x8 107ef9: 8d 43 64 lea 0x64(%ebx),%eax 107efc: 50 push %eax 107efd: e8 8e 7c 00 00 call 10fb90 <_rtems_octal2ulong> 107f02: 89 85 48 fe ff ff mov %eax,-0x1b8(%ebp) file_size = _rtems_octal2ulong(&hdr_ptr[124], 12); 107f08: 58 pop %eax 107f09: 5a pop %edx 107f0a: 6a 0c push $0xc 107f0c: 8d 43 7c lea 0x7c(%ebx),%eax 107f0f: 50 push %eax 107f10: e8 7b 7c 00 00 call 10fb90 <_rtems_octal2ulong> 107f15: 89 85 4c fe ff ff mov %eax,-0x1b4(%ebp) hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8); 107f1b: 5e pop %esi 107f1c: 5f pop %edi 107f1d: 6a 08 push $0x8 107f1f: 8d 83 94 00 00 00 lea 0x94(%ebx),%eax 107f25: 50 push %eax 107f26: e8 65 7c 00 00 call 10fb90 <_rtems_octal2ulong> 107f2b: 89 c6 mov %eax,%esi if (_rtems_tar_header_checksum(hdr_ptr) != hdr_chksum) 107f2d: 89 1c 24 mov %ebx,(%esp) 107f30: e8 2f 81 00 00 call 110064 <_rtems_tar_header_checksum> 107f35: 83 c4 10 add $0x10,%esp 107f38: 39 f0 cmp %esi,%eax 107f3a: 0f 85 92 00 00 00 jne 107fd2 <== NEVER TAKEN * Generate an IMFS node depending on the file type. * - For directories, just create directories as usual. IMFS * will take care of the rest. * - For files, create a file node with special tarfs properties. */ if (linkflag == DIRTYPE) { 107f40: 80 bd 53 fe ff ff 35 cmpb $0x35,-0x1ad(%ebp) 107f47: 0f 85 43 ff ff ff jne 107e90 strcpy(full_filename, mountpoint); 107f4d: 83 ec 08 sub $0x8,%esp 107f50: ff 75 08 pushl 0x8(%ebp) 107f53: 8d 85 58 fe ff ff lea -0x1a8(%ebp),%eax 107f59: 50 push %eax 107f5a: e8 c5 f9 00 00 call 117924 if (full_filename[strlen(full_filename)-1] != '/') 107f5f: 31 c0 xor %eax,%eax 107f61: b9 ff ff ff ff mov $0xffffffff,%ecx 107f66: 8b bd 34 fe ff ff mov -0x1cc(%ebp),%edi 107f6c: f2 ae repnz scas %es:(%edi),%al 107f6e: f7 d1 not %ecx 107f70: 49 dec %ecx 107f71: 83 c4 10 add $0x10,%esp 107f74: 80 bc 0d 57 fe ff ff cmpb $0x2f,-0x1a9(%ebp,%ecx,1) 107f7b: 2f 107f7c: 74 0a je 107f88 <== ALWAYS TAKEN strcat(full_filename, "/"); 107f7e: 66 c7 84 0d 58 fe ff movw $0x2f,-0x1a8(%ebp,%ecx,1) <== NOT EXECUTED 107f85: ff 2f 00 strcat(full_filename, filename); 107f88: 83 ec 08 sub $0x8,%esp 107f8b: 8d 95 58 ff ff ff lea -0xa8(%ebp),%edx 107f91: 52 push %edx 107f92: 8d 85 58 fe ff ff lea -0x1a8(%ebp),%eax 107f98: 50 push %eax 107f99: e8 d2 f7 00 00 call 117770 mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO); 107f9e: 5a pop %edx 107f9f: 59 pop %ecx 107fa0: 68 ff 01 00 00 push $0x1ff 107fa5: 8d 95 58 fe ff ff lea -0x1a8(%ebp),%edx 107fab: 52 push %edx 107fac: e8 fb 10 00 00 call 1090ac 107fb1: 83 c4 10 add $0x10,%esp 107fb4: e9 e4 fe ff ff jmp 107e9d 107fb9: 8d 76 00 lea 0x0(%esi),%esi 0 ); if (status != 0) return -1; if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops) 107fbc: 3d 00 78 12 00 cmp $0x127800,%eax 107fc1: 0f 84 ae fe ff ff je 107e75 <== NEVER TAKEN 107fc7: 90 nop return -1; 107fc8: c7 85 44 fe ff ff ff movl $0xffffffff,-0x1bc(%ebp) 107fcf: ff ff ff nblocks = (((file_size) + 511) & ~511) / 512; offset += 512 * nblocks; } } return status; } 107fd2: 8b 85 44 fe ff ff mov -0x1bc(%ebp),%eax 107fd8: 8d 65 f4 lea -0xc(%ebp),%esp 107fdb: 5b pop %ebx 107fdc: 5e pop %esi 107fdd: 5f pop %edi 107fde: c9 leave 107fdf: c3 ret * should not have this path. */ else if (linkflag == REGTYPE) { const char *name; loc = root_loc; 107fe0: 8b bd 30 fe ff ff mov -0x1d0(%ebp),%edi 107fe6: 8b b5 2c fe ff ff mov -0x1d4(%ebp),%esi 107fec: b9 05 00 00 00 mov $0x5,%ecx 107ff1: f3 a5 rep movsl %ds:(%esi),%es:(%edi) if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) { 107ff3: 50 push %eax 107ff4: 8d 45 e4 lea -0x1c(%ebp),%eax 107ff7: 50 push %eax 107ff8: 8d 55 bc lea -0x44(%ebp),%edx 107ffb: 52 push %edx 107ffc: 8d 85 58 ff ff ff lea -0xa8(%ebp),%eax 108002: 50 push %eax 108003: e8 3c 88 00 00 call 110844 108008: 83 c4 10 add $0x10,%esp 10800b: 85 c0 test %eax,%eax 10800d: 74 1d je 10802c <== ALWAYS TAKEN ); node->info.linearfile.size = file_size; node->info.linearfile.direct = &tar_image[offset]; } nblocks = (((file_size) + 511) & ~511) / 512; 10800f: 8b 85 4c fe ff ff mov -0x1b4(%ebp),%eax 108015: 05 ff 01 00 00 add $0x1ff,%eax offset += 512 * nblocks; 10801a: 25 00 fe ff ff and $0xfffffe00,%eax 10801f: 01 85 54 fe ff ff add %eax,-0x1ac(%ebp) 108025: e9 73 fe ff ff jmp 107e9d 10802a: 66 90 xchg %ax,%ax else if (linkflag == REGTYPE) { const char *name; loc = root_loc; if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) { node = IMFS_create_node( 10802c: 83 ec 0c sub $0xc,%esp 10802f: 6a 00 push $0x0 &loc, IMFS_LINEAR_FILE, (char *)name, (file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG, 108031: 8b 85 48 fe ff ff mov -0x1b8(%ebp),%eax 108037: 25 ff 01 00 00 and $0x1ff,%eax else if (linkflag == REGTYPE) { const char *name; loc = root_loc; if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) { node = IMFS_create_node( 10803c: 80 cc 80 or $0x80,%ah 10803f: 50 push %eax 108040: ff 75 e4 pushl -0x1c(%ebp) 108043: 6a 06 push $0x6 108045: 8d 55 bc lea -0x44(%ebp),%edx 108048: 52 push %edx 108049: e8 fe 81 00 00 call 11024c &loc, IMFS_LINEAR_FILE, (char *)name, (file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG, NULL ); node->info.linearfile.size = file_size; 10804e: 8b 95 4c fe ff ff mov -0x1b4(%ebp),%edx 108054: 89 50 50 mov %edx,0x50(%eax) 108057: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) node->info.linearfile.direct = &tar_image[offset]; 10805e: 8b 55 0c mov 0xc(%ebp),%edx 108061: 03 95 54 fe ff ff add -0x1ac(%ebp),%edx 108067: 89 50 58 mov %edx,0x58(%eax) 10806a: 83 c4 20 add $0x20,%esp 10806d: eb a0 jmp 10800f =============================================================================== 0010b84c : size_t stack_size, rtems_mode initial_modes, rtems_attribute attribute_set, rtems_id *id ) { 10b84c: 55 push %ebp 10b84d: 89 e5 mov %esp,%ebp 10b84f: 57 push %edi 10b850: 56 push %esi 10b851: 53 push %ebx 10b852: 83 ec 1c sub $0x1c,%esp 10b855: 8b 5d 08 mov 0x8(%ebp),%ebx 10b858: 8b 7d 0c mov 0xc(%ebp),%edi 10b85b: 8b 75 1c mov 0x1c(%ebp),%esi Priority_Control core_priority; RTEMS_API_Control *api; ASR_Information *asr; if ( !id ) 10b85e: 85 f6 test %esi,%esi 10b860: 0f 84 3e 01 00 00 je 10b9a4 return RTEMS_INVALID_ADDRESS; if ( !rtems_is_name_valid( name ) ) 10b866: 85 db test %ebx,%ebx 10b868: 0f 84 d2 00 00 00 je 10b940 /* * Validate the RTEMS API priority and convert it to the core priority range. */ if ( !_Attributes_Is_system_task( the_attribute_set ) ) { 10b86e: f7 45 18 00 80 00 00 testl $0x8000,0x18(%ebp) 10b875: 75 17 jne 10b88e */ RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid ( rtems_task_priority the_priority ) { return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) && 10b877: 85 ff test %edi,%edi 10b879: 0f 84 b1 00 00 00 je 10b930 ( the_priority <= RTEMS_MAXIMUM_PRIORITY ) ); 10b87f: 0f b6 05 74 3a 12 00 movzbl 0x123a74,%eax */ RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid ( rtems_task_priority the_priority ) { return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) && 10b886: 39 c7 cmp %eax,%edi 10b888: 0f 87 a2 00 00 00 ja 10b930 */ /* * Lock the allocator mutex for protection */ _RTEMS_Lock_allocator(); 10b88e: 83 ec 0c sub $0xc,%esp 10b891: ff 35 40 7e 12 00 pushl 0x127e40 10b897: e8 c4 06 00 00 call 10bf60 <_API_Mutex_Lock> * This function allocates a task control block from * the inactive chain of free task control blocks. */ RTEMS_INLINE_ROUTINE Thread_Control *_RTEMS_tasks_Allocate( void ) { return (Thread_Control *) _Objects_Allocate( &_RTEMS_tasks_Information ); 10b89c: c7 04 24 20 7d 12 00 movl $0x127d20,(%esp) 10b8a3: e8 dc 10 00 00 call 10c984 <_Objects_Allocate> 10b8a8: 89 c2 mov %eax,%edx * the event of an error. */ the_thread = _RTEMS_tasks_Allocate(); if ( !the_thread ) { 10b8aa: 83 c4 10 add $0x10,%esp 10b8ad: 85 c0 test %eax,%eax 10b8af: 0f 84 cf 00 00 00 je 10b984 /* * Initialize the core thread for this task. */ status = _Thread_Initialize( 10b8b5: 50 push %eax 10b8b6: 53 push %ebx */ RTEMS_INLINE_ROUTINE ISR_Level _Modes_Get_interrupt_level ( Modes_Control mode_set ) { return ( mode_set & RTEMS_INTERRUPT_MASK ); 10b8b7: 8b 45 14 mov 0x14(%ebp),%eax 10b8ba: 83 e0 01 and $0x1,%eax 10b8bd: 50 push %eax 10b8be: 6a 00 push $0x0 10b8c0: 31 c0 xor %eax,%eax 10b8c2: f7 45 14 00 02 00 00 testl $0x200,0x14(%ebp) 10b8c9: 0f 95 c0 setne %al 10b8cc: 50 push %eax 10b8cd: 31 c0 xor %eax,%eax 10b8cf: f7 45 14 00 01 00 00 testl $0x100,0x14(%ebp) 10b8d6: 0f 94 c0 sete %al 10b8d9: 50 push %eax 10b8da: 57 push %edi */ RTEMS_INLINE_ROUTINE bool _Attributes_Is_floating_point( rtems_attribute attribute_set ) { return ( attribute_set & RTEMS_FLOATING_POINT ) ? true : false; 10b8db: 8b 45 18 mov 0x18(%ebp),%eax 10b8de: 83 e0 01 and $0x1,%eax 10b8e1: 50 push %eax 10b8e2: ff 75 10 pushl 0x10(%ebp) 10b8e5: 6a 00 push $0x0 10b8e7: 52 push %edx 10b8e8: 68 20 7d 12 00 push $0x127d20 10b8ed: 89 55 e4 mov %edx,-0x1c(%ebp) 10b8f0: e8 53 21 00 00 call 10da48 <_Thread_Initialize> NULL, /* no budget algorithm callout */ _Modes_Get_interrupt_level(initial_modes), (Objects_Name) name ); if ( !status ) { 10b8f5: 83 c4 30 add $0x30,%esp 10b8f8: 84 c0 test %al,%al 10b8fa: 8b 55 e4 mov -0x1c(%ebp),%edx 10b8fd: 74 51 je 10b950 _RTEMS_Unlock_allocator(); return RTEMS_UNSATISFIED; } api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; asr = &api->Signal; 10b8ff: 8b 82 e8 00 00 00 mov 0xe8(%edx),%eax * id - thread id * RTEMS_SUCCESSFUL - if successful * error code - if unsuccessful */ rtems_status_code rtems_task_create( 10b905: f7 45 14 00 04 00 00 testl $0x400,0x14(%ebp) } api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; asr = &api->Signal; asr->is_enabled = _Modes_Is_asr_disabled(initial_modes) ? false : true; 10b90c: 0f 94 40 08 sete 0x8(%eax) *id = the_thread->Object.id; 10b910: 8b 42 08 mov 0x8(%edx),%eax 10b913: 89 06 mov %eax,(%esi) ); } #endif _RTEMS_Unlock_allocator(); 10b915: 83 ec 0c sub $0xc,%esp 10b918: ff 35 40 7e 12 00 pushl 0x127e40 10b91e: e8 85 06 00 00 call 10bfa8 <_API_Mutex_Unlock> return RTEMS_SUCCESSFUL; 10b923: 83 c4 10 add $0x10,%esp 10b926: 31 c0 xor %eax,%eax } 10b928: 8d 65 f4 lea -0xc(%ebp),%esp 10b92b: 5b pop %ebx 10b92c: 5e pop %esi 10b92d: 5f pop %edi 10b92e: c9 leave 10b92f: c3 ret * Validate the RTEMS API priority and convert it to the core priority range. */ if ( !_Attributes_Is_system_task( the_attribute_set ) ) { if ( !_RTEMS_tasks_Priority_is_valid( initial_priority ) ) return RTEMS_INVALID_PRIORITY; 10b930: b8 13 00 00 00 mov $0x13,%eax } #endif _RTEMS_Unlock_allocator(); return RTEMS_SUCCESSFUL; } 10b935: 8d 65 f4 lea -0xc(%ebp),%esp 10b938: 5b pop %ebx 10b939: 5e pop %esi 10b93a: 5f pop %edi 10b93b: c9 leave 10b93c: c3 ret 10b93d: 8d 76 00 lea 0x0(%esi),%esi if ( !id ) return RTEMS_INVALID_ADDRESS; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 10b940: b8 03 00 00 00 mov $0x3,%eax } #endif _RTEMS_Unlock_allocator(); return RTEMS_SUCCESSFUL; } 10b945: 8d 65 f4 lea -0xc(%ebp),%esp 10b948: 5b pop %ebx 10b949: 5e pop %esi 10b94a: 5f pop %edi 10b94b: c9 leave 10b94c: c3 ret 10b94d: 8d 76 00 lea 0x0(%esi),%esi */ RTEMS_INLINE_ROUTINE void _RTEMS_tasks_Free ( Thread_Control *the_task ) { _Objects_Free( 10b950: 83 ec 0c sub $0xc,%esp 10b953: ff 72 08 pushl 0x8(%edx) 10b956: e8 0d 14 00 00 call 10cd68 <_Objects_Get_information_id> 10b95b: 5a pop %edx 10b95c: 59 pop %ecx 10b95d: 8b 55 e4 mov -0x1c(%ebp),%edx 10b960: 52 push %edx 10b961: 50 push %eax 10b962: e8 91 13 00 00 call 10ccf8 <_Objects_Free> #if defined(RTEMS_MULTIPROCESSING) if ( is_global ) _Objects_MP_Free_global_object( the_global_object ); #endif _RTEMS_tasks_Free( the_thread ); _RTEMS_Unlock_allocator(); 10b967: 58 pop %eax 10b968: ff 35 40 7e 12 00 pushl 0x127e40 10b96e: e8 35 06 00 00 call 10bfa8 <_API_Mutex_Unlock> return RTEMS_UNSATISFIED; 10b973: 83 c4 10 add $0x10,%esp 10b976: b8 0d 00 00 00 mov $0xd,%eax } #endif _RTEMS_Unlock_allocator(); return RTEMS_SUCCESSFUL; } 10b97b: 8d 65 f4 lea -0xc(%ebp),%esp 10b97e: 5b pop %ebx 10b97f: 5e pop %esi 10b980: 5f pop %edi 10b981: c9 leave 10b982: c3 ret 10b983: 90 nop */ the_thread = _RTEMS_tasks_Allocate(); if ( !the_thread ) { _RTEMS_Unlock_allocator(); 10b984: 83 ec 0c sub $0xc,%esp 10b987: ff 35 40 7e 12 00 pushl 0x127e40 10b98d: e8 16 06 00 00 call 10bfa8 <_API_Mutex_Unlock> return RTEMS_TOO_MANY; 10b992: 83 c4 10 add $0x10,%esp 10b995: b8 05 00 00 00 mov $0x5,%eax } #endif _RTEMS_Unlock_allocator(); return RTEMS_SUCCESSFUL; } 10b99a: 8d 65 f4 lea -0xc(%ebp),%esp 10b99d: 5b pop %ebx 10b99e: 5e pop %esi 10b99f: 5f pop %edi 10b9a0: c9 leave 10b9a1: c3 ret 10b9a2: 66 90 xchg %ax,%ax RTEMS_API_Control *api; ASR_Information *asr; if ( !id ) return RTEMS_INVALID_ADDRESS; 10b9a4: b8 09 00 00 00 mov $0x9,%eax 10b9a9: eb 8a jmp 10b935 =============================================================================== 0010b9ac : */ rtems_status_code rtems_task_delete( rtems_id id ) { 10b9ac: 55 push %ebp 10b9ad: 89 e5 mov %esp,%ebp 10b9af: 53 push %ebx 10b9b0: 83 ec 20 sub $0x20,%esp register Thread_Control *the_thread; Objects_Locations location; Objects_Information *the_information; _RTEMS_Lock_allocator(); 10b9b3: ff 35 40 7e 12 00 pushl 0x127e40 10b9b9: e8 a2 05 00 00 call 10bf60 <_API_Mutex_Lock> the_thread = _Thread_Get( id, &location ); 10b9be: 5a pop %edx 10b9bf: 59 pop %ecx 10b9c0: 8d 45 f4 lea -0xc(%ebp),%eax 10b9c3: 50 push %eax 10b9c4: ff 75 08 pushl 0x8(%ebp) 10b9c7: e8 08 20 00 00 call 10d9d4 <_Thread_Get> 10b9cc: 89 c3 mov %eax,%ebx switch ( location ) { 10b9ce: 83 c4 10 add $0x10,%esp 10b9d1: 8b 45 f4 mov -0xc(%ebp),%eax 10b9d4: 85 c0 test %eax,%eax 10b9d6: 75 44 jne 10ba1c case OBJECTS_LOCAL: the_information = _Objects_Get_information_id( the_thread->Object.id ); 10b9d8: 83 ec 0c sub $0xc,%esp 10b9db: ff 73 08 pushl 0x8(%ebx) 10b9de: e8 85 13 00 00 call 10cd68 <_Objects_Get_information_id> 0 /* Not used */ ); } #endif _Thread_Close( the_information, the_thread ); 10b9e3: 5a pop %edx 10b9e4: 59 pop %ecx 10b9e5: 53 push %ebx 10b9e6: 50 push %eax 10b9e7: e8 9c 1c 00 00 call 10d688 <_Thread_Close> 10b9ec: 58 pop %eax 10b9ed: ff 73 08 pushl 0x8(%ebx) 10b9f0: e8 73 13 00 00 call 10cd68 <_Objects_Get_information_id> 10b9f5: 5a pop %edx 10b9f6: 59 pop %ecx 10b9f7: 53 push %ebx 10b9f8: 50 push %eax 10b9f9: e8 fa 12 00 00 call 10ccf8 <_Objects_Free> _RTEMS_tasks_Free( the_thread ); _RTEMS_Unlock_allocator(); 10b9fe: 58 pop %eax 10b9ff: ff 35 40 7e 12 00 pushl 0x127e40 10ba05: e8 9e 05 00 00 call 10bfa8 <_API_Mutex_Unlock> _Thread_Enable_dispatch(); 10ba0a: e8 a1 1f 00 00 call 10d9b0 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10ba0f: 83 c4 10 add $0x10,%esp 10ba12: 31 c0 xor %eax,%eax break; } _RTEMS_Unlock_allocator(); return RTEMS_INVALID_ID; } 10ba14: 8b 5d fc mov -0x4(%ebp),%ebx 10ba17: c9 leave 10ba18: c3 ret 10ba19: 8d 76 00 lea 0x0(%esi),%esi case OBJECTS_ERROR: break; } _RTEMS_Unlock_allocator(); 10ba1c: 83 ec 0c sub $0xc,%esp 10ba1f: ff 35 40 7e 12 00 pushl 0x127e40 10ba25: e8 7e 05 00 00 call 10bfa8 <_API_Mutex_Unlock> return RTEMS_INVALID_ID; 10ba2a: 83 c4 10 add $0x10,%esp 10ba2d: b8 04 00 00 00 mov $0x4,%eax } 10ba32: 8b 5d fc mov -0x4(%ebp),%ebx 10ba35: c9 leave 10ba36: c3 ret =============================================================================== 0010d4e4 : rtems_status_code rtems_task_get_note( rtems_id id, uint32_t notepad, uint32_t *note ) { 10d4e4: 55 push %ebp 10d4e5: 89 e5 mov %esp,%ebp 10d4e7: 56 push %esi 10d4e8: 53 push %ebx 10d4e9: 83 ec 10 sub $0x10,%esp 10d4ec: 8b 45 08 mov 0x8(%ebp),%eax 10d4ef: 8b 75 0c mov 0xc(%ebp),%esi 10d4f2: 8b 5d 10 mov 0x10(%ebp),%ebx register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) 10d4f5: 80 3d 04 79 12 00 00 cmpb $0x0,0x127904 10d4fc: 74 6e je 10d56c return RTEMS_NOT_CONFIGURED; if ( !note ) 10d4fe: 85 db test %ebx,%ebx 10d500: 74 7e je 10d580 /* * NOTE: There is no check for < RTEMS_NOTEPAD_FIRST because that would * be checking an unsigned number for being negative. */ if ( notepad > RTEMS_NOTEPAD_LAST ) 10d502: 83 fe 0f cmp $0xf,%esi 10d505: 77 3d ja 10d544 /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 10d507: 85 c0 test %eax,%eax 10d509: 74 45 je 10d550 _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { 10d50b: 8b 15 38 c5 12 00 mov 0x12c538,%edx /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 10d511: 3b 42 08 cmp 0x8(%edx),%eax 10d514: 74 40 je 10d556 api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); 10d516: 83 ec 08 sub $0x8,%esp 10d519: 8d 55 f4 lea -0xc(%ebp),%edx 10d51c: 52 push %edx 10d51d: 50 push %eax 10d51e: e8 f9 22 00 00 call 10f81c <_Thread_Get> switch ( location ) { 10d523: 83 c4 10 add $0x10,%esp 10d526: 8b 55 f4 mov -0xc(%ebp),%edx 10d529: 85 d2 test %edx,%edx 10d52b: 75 4b jne 10d578 case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 10d52d: 8b 80 e8 00 00 00 mov 0xe8(%eax),%eax 10d533: 8b 44 b0 20 mov 0x20(%eax,%esi,4),%eax 10d537: 89 03 mov %eax,(%ebx) _Thread_Enable_dispatch(); 10d539: e8 ba 22 00 00 call 10f7f8 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10d53e: 31 c0 xor %eax,%eax 10d540: eb 07 jmp 10d549 10d542: 66 90 xchg %ax,%ax * NOTE: There is no check for < RTEMS_NOTEPAD_FIRST because that would * be checking an unsigned number for being negative. */ if ( notepad > RTEMS_NOTEPAD_LAST ) return RTEMS_INVALID_NUMBER; 10d544: b8 0a 00 00 00 mov $0xa,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10d549: 8d 65 f8 lea -0x8(%ebp),%esp 10d54c: 5b pop %ebx 10d54d: 5e pop %esi 10d54e: c9 leave 10d54f: c3 ret /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 10d550: 8b 15 38 c5 12 00 mov 0x12c538,%edx _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 10d556: 8b 82 e8 00 00 00 mov 0xe8(%edx),%eax 10d55c: 8b 44 b0 20 mov 0x20(%eax,%esi,4),%eax 10d560: 89 03 mov %eax,(%ebx) return RTEMS_SUCCESSFUL; 10d562: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10d564: 8d 65 f8 lea -0x8(%ebp),%esp 10d567: 5b pop %ebx 10d568: 5e pop %esi 10d569: c9 leave 10d56a: c3 ret 10d56b: 90 nop register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) return RTEMS_NOT_CONFIGURED; 10d56c: b8 16 00 00 00 mov $0x16,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10d571: 8d 65 f8 lea -0x8(%ebp),%esp 10d574: 5b pop %ebx 10d575: 5e pop %esi 10d576: c9 leave 10d577: c3 ret case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10d578: b8 04 00 00 00 mov $0x4,%eax 10d57d: eb ca jmp 10d549 10d57f: 90 nop if ( !rtems_configuration_get_notepads_enabled() ) return RTEMS_NOT_CONFIGURED; if ( !note ) return RTEMS_INVALID_ADDRESS; 10d580: b8 09 00 00 00 mov $0x9,%eax 10d585: eb c2 jmp 10d549 =============================================================================== 00118144 : */ rtems_status_code rtems_task_is_suspended( rtems_id id ) { 118144: 55 push %ebp 118145: 89 e5 mov %esp,%ebp 118147: 83 ec 20 sub $0x20,%esp register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 11814a: 8d 45 f4 lea -0xc(%ebp),%eax 11814d: 50 push %eax 11814e: ff 75 08 pushl 0x8(%ebp) 118151: e8 22 3d 00 00 call 11be78 <_Thread_Get> switch ( location ) { 118156: 83 c4 10 add $0x10,%esp 118159: 8b 55 f4 mov -0xc(%ebp),%edx 11815c: 85 d2 test %edx,%edx 11815e: 74 08 je 118168 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 118160: b8 04 00 00 00 mov $0x4,%eax } 118165: c9 leave 118166: c3 ret 118167: 90 nop the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { 118168: f6 40 10 02 testb $0x2,0x10(%eax) 11816c: 74 0e je 11817c _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 11816e: e8 e1 3c 00 00 call 11be54 <_Thread_Enable_dispatch> return RTEMS_ALREADY_SUSPENDED; 118173: b8 0f 00 00 00 mov $0xf,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 118178: c9 leave 118179: c3 ret 11817a: 66 90 xchg %ax,%ax the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { _Thread_Enable_dispatch(); 11817c: e8 d3 3c 00 00 call 11be54 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 118181: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 118183: c9 leave 118184: c3 ret =============================================================================== 00112df0 : rtems_status_code rtems_task_mode( rtems_mode mode_set, rtems_mode mask, rtems_mode *previous_mode_set ) { 112df0: 55 push %ebp 112df1: 89 e5 mov %esp,%ebp 112df3: 57 push %edi 112df4: 56 push %esi 112df5: 53 push %ebx 112df6: 83 ec 1c sub $0x1c,%esp 112df9: 8b 4d 10 mov 0x10(%ebp),%ecx ASR_Information *asr; bool is_asr_enabled = false; bool needs_asr_dispatching = false; rtems_mode old_mode; if ( !previous_mode_set ) 112dfc: 85 c9 test %ecx,%ecx 112dfe: 0f 84 40 01 00 00 je 112f44 return RTEMS_INVALID_ADDRESS; executing = _Thread_Executing; 112e04: 8b 1d 38 83 12 00 mov 0x128338,%ebx api = executing->API_Extensions[ THREAD_API_RTEMS ]; 112e0a: 8b bb e8 00 00 00 mov 0xe8(%ebx),%edi asr = &api->Signal; old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT; 112e10: 80 7b 74 01 cmpb $0x1,0x74(%ebx) 112e14: 19 f6 sbb %esi,%esi 112e16: 81 e6 00 01 00 00 and $0x100,%esi if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) 112e1c: 8b 53 7c mov 0x7c(%ebx),%edx 112e1f: 85 d2 test %edx,%edx 112e21: 0f 85 f1 00 00 00 jne 112f18 old_mode |= RTEMS_NO_TIMESLICE; else old_mode |= RTEMS_TIMESLICE; old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR; 112e27: 80 7f 08 01 cmpb $0x1,0x8(%edi) 112e2b: 19 d2 sbb %edx,%edx 112e2d: 81 e2 00 04 00 00 and $0x400,%edx old_mode |= _ISR_Get_level(); 112e33: 89 55 e4 mov %edx,-0x1c(%ebp) 112e36: 89 4d e0 mov %ecx,-0x20(%ebp) 112e39: e8 4e bf ff ff call 10ed8c <_CPU_ISR_Get_level> if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) old_mode |= RTEMS_NO_TIMESLICE; else old_mode |= RTEMS_TIMESLICE; old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR; 112e3e: 8b 55 e4 mov -0x1c(%ebp),%edx 112e41: 09 d0 or %edx,%eax old_mode |= _ISR_Get_level(); 112e43: 09 f0 or %esi,%eax 112e45: 8b 4d e0 mov -0x20(%ebp),%ecx 112e48: 89 01 mov %eax,(%ecx) *previous_mode_set = old_mode; /* * These are generic thread scheduling characteristics. */ if ( mask & RTEMS_PREEMPT_MASK ) 112e4a: f7 45 0c 00 01 00 00 testl $0x100,0xc(%ebp) 112e51: 74 0b je 112e5e executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false; 112e53: f7 45 08 00 01 00 00 testl $0x100,0x8(%ebp) 112e5a: 0f 94 43 74 sete 0x74(%ebx) if ( mask & RTEMS_TIMESLICE_MASK ) { 112e5e: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp) 112e65: 74 1c je 112e83 if ( _Modes_Is_timeslice(mode_set) ) { 112e67: f7 45 08 00 02 00 00 testl $0x200,0x8(%ebp) 112e6e: 0f 84 b8 00 00 00 je 112f2c executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; 112e74: c7 43 7c 01 00 00 00 movl $0x1,0x7c(%ebx) executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 112e7b: a1 60 7d 12 00 mov 0x127d60,%eax 112e80: 89 43 78 mov %eax,0x78(%ebx) } /* * Set the new interrupt level */ if ( mask & RTEMS_INTERRUPT_MASK ) 112e83: f6 45 0c 01 testb $0x1,0xc(%ebp) 112e87: 74 0b je 112e94 */ RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level ( Modes_Control mode_set ) { _ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) ); 112e89: f6 45 08 01 testb $0x1,0x8(%ebp) 112e8d: 0f 84 91 00 00 00 je 112f24 112e93: fa cli * This is specific to the RTEMS API */ is_asr_enabled = false; needs_asr_dispatching = false; if ( mask & RTEMS_ASR_MASK ) { 112e94: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp) 112e9b: 74 3f je 112edc * Output: * *previous_mode_set - previous mode set * always return RTEMS_SUCCESSFUL; */ rtems_status_code rtems_task_mode( 112e9d: f7 45 08 00 04 00 00 testl $0x400,0x8(%ebp) 112ea4: 0f 94 c0 sete %al is_asr_enabled = false; needs_asr_dispatching = false; if ( mask & RTEMS_ASR_MASK ) { is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true; if ( is_asr_enabled != asr->is_enabled ) { 112ea7: 38 47 08 cmp %al,0x8(%edi) 112eaa: 74 30 je 112edc asr->is_enabled = is_asr_enabled; 112eac: 88 47 08 mov %al,0x8(%edi) ) { rtems_signal_set _signals; ISR_Level _level; _ISR_Disable( _level ); 112eaf: 9c pushf 112eb0: fa cli 112eb1: 58 pop %eax _signals = information->signals_pending; 112eb2: 8b 57 18 mov 0x18(%edi),%edx information->signals_pending = information->signals_posted; 112eb5: 8b 4f 14 mov 0x14(%edi),%ecx 112eb8: 89 4f 18 mov %ecx,0x18(%edi) information->signals_posted = _signals; 112ebb: 89 57 14 mov %edx,0x14(%edi) _ISR_Enable( _level ); 112ebe: 50 push %eax 112ebf: 9d popf /* * This is specific to the RTEMS API */ is_asr_enabled = false; needs_asr_dispatching = false; 112ec0: 8b 47 14 mov 0x14(%edi),%eax 112ec3: 85 c0 test %eax,%eax 112ec5: 0f 95 c0 setne %al needs_asr_dispatching = true; } } } if ( _System_state_Is_up( _System_state_Get() ) ) { 112ec8: 83 3d 20 7f 12 00 03 cmpl $0x3,0x127f20 112ecf: 74 16 je 112ee7 <== ALWAYS TAKEN if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) ) _Thread_Dispatch(); } return RTEMS_SUCCESSFUL; 112ed1: 31 c0 xor %eax,%eax } 112ed3: 83 c4 1c add $0x1c,%esp 112ed6: 5b pop %ebx 112ed7: 5e pop %esi 112ed8: 5f pop %edi 112ed9: c9 leave 112eda: c3 ret 112edb: 90 nop /* * This is specific to the RTEMS API */ is_asr_enabled = false; needs_asr_dispatching = false; 112edc: 31 c0 xor %eax,%eax needs_asr_dispatching = true; } } } if ( _System_state_Is_up( _System_state_Get() ) ) { 112ede: 83 3d 20 7f 12 00 03 cmpl $0x3,0x127f20 112ee5: 75 ea jne 112ed1 <== NEVER TAKEN bool are_signals_pending ) { Thread_Control *executing; executing = _Thread_Executing; 112ee7: 8b 15 38 83 12 00 mov 0x128338,%edx if ( are_signals_pending || 112eed: 84 c0 test %al,%al 112eef: 75 0e jne 112eff 112ef1: 3b 15 3c 83 12 00 cmp 0x12833c,%edx 112ef7: 74 d8 je 112ed1 (!_Thread_Is_heir( executing ) && executing->is_preemptible) ) { 112ef9: 80 7a 74 00 cmpb $0x0,0x74(%edx) 112efd: 74 d2 je 112ed1 <== NEVER TAKEN _Thread_Dispatch_necessary = true; 112eff: c6 05 44 83 12 00 01 movb $0x1,0x128344 if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) ) _Thread_Dispatch(); 112f06: e8 2d a9 ff ff call 10d838 <_Thread_Dispatch> } return RTEMS_SUCCESSFUL; 112f0b: 31 c0 xor %eax,%eax } 112f0d: 83 c4 1c add $0x1c,%esp 112f10: 5b pop %ebx 112f11: 5e pop %esi 112f12: 5f pop %edi 112f13: c9 leave 112f14: c3 ret 112f15: 8d 76 00 lea 0x0(%esi),%esi old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT; if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) old_mode |= RTEMS_NO_TIMESLICE; else old_mode |= RTEMS_TIMESLICE; 112f18: 81 ce 00 02 00 00 or $0x200,%esi 112f1e: e9 04 ff ff ff jmp 112e27 112f23: 90 nop 112f24: fb sti 112f25: e9 6a ff ff ff jmp 112e94 112f2a: 66 90 xchg %ax,%ax if ( mask & RTEMS_TIMESLICE_MASK ) { if ( _Modes_Is_timeslice(mode_set) ) { executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; executing->cpu_time_budget = _Thread_Ticks_per_timeslice; } else executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; 112f2c: c7 43 7c 00 00 00 00 movl $0x0,0x7c(%ebx) } /* * Set the new interrupt level */ if ( mask & RTEMS_INTERRUPT_MASK ) 112f33: f6 45 0c 01 testb $0x1,0xc(%ebp) 112f37: 0f 84 57 ff ff ff je 112e94 112f3d: e9 47 ff ff ff jmp 112e89 112f42: 66 90 xchg %ax,%ax bool is_asr_enabled = false; bool needs_asr_dispatching = false; rtems_mode old_mode; if ( !previous_mode_set ) return RTEMS_INVALID_ADDRESS; 112f44: b8 09 00 00 00 mov $0x9,%eax if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) ) _Thread_Dispatch(); } return RTEMS_SUCCESSFUL; } 112f49: 83 c4 1c add $0x1c,%esp 112f4c: 5b pop %ebx 112f4d: 5e pop %esi 112f4e: 5f pop %edi 112f4f: c9 leave 112f50: c3 ret =============================================================================== 0010ecdc : */ rtems_status_code rtems_task_resume( rtems_id id ) { 10ecdc: 55 push %ebp 10ecdd: 89 e5 mov %esp,%ebp 10ecdf: 83 ec 20 sub $0x20,%esp register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10ece2: 8d 45 f4 lea -0xc(%ebp),%eax 10ece5: 50 push %eax 10ece6: ff 75 08 pushl 0x8(%ebp) 10ece9: e8 1e 20 00 00 call 110d0c <_Thread_Get> switch ( location ) { 10ecee: 83 c4 10 add $0x10,%esp 10ecf1: 8b 55 f4 mov -0xc(%ebp),%edx 10ecf4: 85 d2 test %edx,%edx 10ecf6: 74 08 je 10ed00 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10ecf8: b8 04 00 00 00 mov $0x4,%eax } 10ecfd: c9 leave 10ecfe: c3 ret 10ecff: 90 nop the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( _States_Is_suspended( the_thread->current_state ) ) { 10ed00: f6 40 10 02 testb $0x2,0x10(%eax) 10ed04: 75 0e jne 10ed14 _Thread_Resume( the_thread, true ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 10ed06: e8 dd 1f 00 00 call 110ce8 <_Thread_Enable_dispatch> return RTEMS_INCORRECT_STATE; 10ed0b: b8 0e 00 00 00 mov $0xe,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10ed10: c9 leave 10ed11: c3 ret 10ed12: 66 90 xchg %ax,%ax the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( _States_Is_suspended( the_thread->current_state ) ) { _Thread_Resume( the_thread, true ); 10ed14: 83 ec 08 sub $0x8,%esp 10ed17: 6a 01 push $0x1 10ed19: 50 push %eax 10ed1a: e8 d1 27 00 00 call 1114f0 <_Thread_Resume> _Thread_Enable_dispatch(); 10ed1f: e8 c4 1f 00 00 call 110ce8 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10ed24: 83 c4 10 add $0x10,%esp 10ed27: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10ed29: c9 leave 10ed2a: c3 ret =============================================================================== 0010d65c : rtems_status_code rtems_task_set_note( rtems_id id, uint32_t notepad, uint32_t note ) { 10d65c: 55 push %ebp 10d65d: 89 e5 mov %esp,%ebp 10d65f: 56 push %esi 10d660: 53 push %ebx 10d661: 83 ec 10 sub $0x10,%esp 10d664: 8b 45 08 mov 0x8(%ebp),%eax 10d667: 8b 5d 0c mov 0xc(%ebp),%ebx 10d66a: 8b 75 10 mov 0x10(%ebp),%esi register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) 10d66d: 80 3d 04 79 12 00 00 cmpb $0x0,0x127904 10d674: 74 66 je 10d6dc /* * NOTE: There is no check for < RTEMS_NOTEPAD_FIRST because that would * be checking an unsigned number for being negative. */ if ( notepad > RTEMS_NOTEPAD_LAST ) 10d676: 83 fb 0f cmp $0xf,%ebx 10d679: 77 39 ja 10d6b4 /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 10d67b: 85 c0 test %eax,%eax 10d67d: 74 41 je 10d6c0 _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { 10d67f: 8b 15 38 c5 12 00 mov 0x12c538,%edx /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 10d685: 3b 42 08 cmp 0x8(%edx),%eax 10d688: 74 3c je 10d6c6 api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; api->Notepads[ notepad ] = note; return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); 10d68a: 83 ec 08 sub $0x8,%esp 10d68d: 8d 55 f4 lea -0xc(%ebp),%edx 10d690: 52 push %edx 10d691: 50 push %eax 10d692: e8 85 21 00 00 call 10f81c <_Thread_Get> switch ( location ) { 10d697: 83 c4 10 add $0x10,%esp 10d69a: 8b 55 f4 mov -0xc(%ebp),%edx 10d69d: 85 d2 test %edx,%edx 10d69f: 75 47 jne 10d6e8 case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; api->Notepads[ notepad ] = note; 10d6a1: 8b 80 e8 00 00 00 mov 0xe8(%eax),%eax 10d6a7: 89 74 98 20 mov %esi,0x20(%eax,%ebx,4) _Thread_Enable_dispatch(); 10d6ab: e8 48 21 00 00 call 10f7f8 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10d6b0: 31 c0 xor %eax,%eax 10d6b2: eb 05 jmp 10d6b9 * NOTE: There is no check for < RTEMS_NOTEPAD_FIRST because that would * be checking an unsigned number for being negative. */ if ( notepad > RTEMS_NOTEPAD_LAST ) return RTEMS_INVALID_NUMBER; 10d6b4: b8 0a 00 00 00 mov $0xa,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10d6b9: 8d 65 f8 lea -0x8(%ebp),%esp 10d6bc: 5b pop %ebx 10d6bd: 5e pop %esi 10d6be: c9 leave 10d6bf: c3 ret /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 10d6c0: 8b 15 38 c5 12 00 mov 0x12c538,%edx _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; api->Notepads[ notepad ] = note; 10d6c6: 8b 82 e8 00 00 00 mov 0xe8(%edx),%eax 10d6cc: 89 74 98 20 mov %esi,0x20(%eax,%ebx,4) return RTEMS_SUCCESSFUL; 10d6d0: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10d6d2: 8d 65 f8 lea -0x8(%ebp),%esp 10d6d5: 5b pop %ebx 10d6d6: 5e pop %esi 10d6d7: c9 leave 10d6d8: c3 ret 10d6d9: 8d 76 00 lea 0x0(%esi),%esi register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) return RTEMS_NOT_CONFIGURED; 10d6dc: b8 16 00 00 00 mov $0x16,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10d6e1: 8d 65 f8 lea -0x8(%ebp),%esp 10d6e4: 5b pop %ebx 10d6e5: 5e pop %esi 10d6e6: c9 leave 10d6e7: c3 ret case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10d6e8: b8 04 00 00 00 mov $0x4,%eax } 10d6ed: 8d 65 f8 lea -0x8(%ebp),%esp 10d6f0: 5b pop %ebx 10d6f1: 5e pop %esi 10d6f2: c9 leave 10d6f3: c3 ret =============================================================================== 0010f9a0 : rtems_status_code rtems_task_set_priority( rtems_id id, rtems_task_priority new_priority, rtems_task_priority *old_priority ) { 10f9a0: 55 push %ebp 10f9a1: 89 e5 mov %esp,%ebp 10f9a3: 56 push %esi 10f9a4: 53 push %ebx 10f9a5: 83 ec 10 sub $0x10,%esp 10f9a8: 8b 5d 0c mov 0xc(%ebp),%ebx 10f9ab: 8b 75 10 mov 0x10(%ebp),%esi register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && 10f9ae: 85 db test %ebx,%ebx 10f9b0: 74 0b je 10f9bd RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid ( rtems_task_priority the_priority ) { return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) && ( the_priority <= RTEMS_MAXIMUM_PRIORITY ) ); 10f9b2: 0f b6 05 34 7a 12 00 movzbl 0x127a34,%eax */ RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid ( rtems_task_priority the_priority ) { return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) && 10f9b9: 39 c3 cmp %eax,%ebx 10f9bb: 77 5f ja 10fa1c !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; if ( !old_priority ) 10f9bd: 85 f6 test %esi,%esi 10f9bf: 74 67 je 10fa28 return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); 10f9c1: 83 ec 08 sub $0x8,%esp 10f9c4: 8d 45 f4 lea -0xc(%ebp),%eax 10f9c7: 50 push %eax 10f9c8: ff 75 08 pushl 0x8(%ebp) 10f9cb: e8 7c 21 00 00 call 111b4c <_Thread_Get> switch ( location ) { 10f9d0: 83 c4 10 add $0x10,%esp 10f9d3: 8b 55 f4 mov -0xc(%ebp),%edx 10f9d6: 85 d2 test %edx,%edx 10f9d8: 75 36 jne 10fa10 case OBJECTS_LOCAL: /* XXX need helper to "convert" from core priority */ *old_priority = the_thread->current_priority; 10f9da: 8b 50 14 mov 0x14(%eax),%edx 10f9dd: 89 16 mov %edx,(%esi) if ( new_priority != RTEMS_CURRENT_PRIORITY ) { 10f9df: 85 db test %ebx,%ebx 10f9e1: 74 1c je 10f9ff the_thread->real_priority = new_priority; 10f9e3: 89 58 18 mov %ebx,0x18(%eax) if ( the_thread->resource_count == 0 || 10f9e6: 8b 48 1c mov 0x1c(%eax),%ecx 10f9e9: 85 c9 test %ecx,%ecx 10f9eb: 74 05 je 10f9f2 10f9ed: 3b 58 14 cmp 0x14(%eax),%ebx 10f9f0: 73 0d jae 10f9ff <== ALWAYS TAKEN the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, false ); 10f9f2: 52 push %edx 10f9f3: 6a 00 push $0x0 10f9f5: 53 push %ebx 10f9f6: 50 push %eax 10f9f7: e8 f4 1c 00 00 call 1116f0 <_Thread_Change_priority> 10f9fc: 83 c4 10 add $0x10,%esp } _Thread_Enable_dispatch(); 10f9ff: e8 24 21 00 00 call 111b28 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10fa04: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10fa06: 8d 65 f8 lea -0x8(%ebp),%esp 10fa09: 5b pop %ebx 10fa0a: 5e pop %esi 10fa0b: c9 leave 10fa0c: c3 ret 10fa0d: 8d 76 00 lea 0x0(%esi),%esi case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10fa10: b8 04 00 00 00 mov $0x4,%eax } 10fa15: 8d 65 f8 lea -0x8(%ebp),%esp 10fa18: 5b pop %ebx 10fa19: 5e pop %esi 10fa1a: c9 leave 10fa1b: c3 ret register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; 10fa1c: b8 13 00 00 00 mov $0x13,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10fa21: 8d 65 f8 lea -0x8(%ebp),%esp 10fa24: 5b pop %ebx 10fa25: 5e pop %esi 10fa26: c9 leave 10fa27: c3 ret if ( new_priority != RTEMS_CURRENT_PRIORITY && !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; if ( !old_priority ) return RTEMS_INVALID_ADDRESS; 10fa28: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10fa2d: 8d 65 f8 lea -0x8(%ebp),%esp 10fa30: 5b pop %ebx 10fa31: 5e pop %esi 10fa32: c9 leave 10fa33: c3 ret =============================================================================== 0010baf4 : rtems_status_code rtems_task_start( rtems_id id, rtems_task_entry entry_point, rtems_task_argument argument ) { 10baf4: 55 push %ebp 10baf5: 89 e5 mov %esp,%ebp 10baf7: 53 push %ebx 10baf8: 83 ec 14 sub $0x14,%esp 10bafb: 8b 5d 0c mov 0xc(%ebp),%ebx register Thread_Control *the_thread; Objects_Locations location; if ( entry_point == NULL ) 10bafe: 85 db test %ebx,%ebx 10bb00: 74 4e je 10bb50 return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); 10bb02: 83 ec 08 sub $0x8,%esp 10bb05: 8d 45 f4 lea -0xc(%ebp),%eax 10bb08: 50 push %eax 10bb09: ff 75 08 pushl 0x8(%ebp) 10bb0c: e8 c3 1e 00 00 call 10d9d4 <_Thread_Get> switch ( location ) { 10bb11: 83 c4 10 add $0x10,%esp 10bb14: 8b 55 f4 mov -0xc(%ebp),%edx 10bb17: 85 d2 test %edx,%edx 10bb19: 75 29 jne 10bb44 case OBJECTS_LOCAL: if ( _Thread_Start( 10bb1b: 83 ec 0c sub $0xc,%esp 10bb1e: ff 75 10 pushl 0x10(%ebp) 10bb21: 6a 00 push $0x0 10bb23: 53 push %ebx 10bb24: 6a 00 push $0x0 10bb26: 50 push %eax 10bb27: e8 0c 28 00 00 call 10e338 <_Thread_Start> 10bb2c: 83 c4 20 add $0x20,%esp 10bb2f: 84 c0 test %al,%al 10bb31: 75 29 jne 10bb5c the_thread, THREAD_START_NUMERIC, entry_point, NULL, argument ) ) { _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 10bb33: e8 78 1e 00 00 call 10d9b0 <_Thread_Enable_dispatch> return RTEMS_INCORRECT_STATE; 10bb38: b8 0e 00 00 00 mov $0xe,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10bb3d: 8b 5d fc mov -0x4(%ebp),%ebx 10bb40: c9 leave 10bb41: c3 ret 10bb42: 66 90 xchg %ax,%ax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10bb44: b8 04 00 00 00 mov $0x4,%eax } 10bb49: 8b 5d fc mov -0x4(%ebp),%ebx 10bb4c: c9 leave 10bb4d: c3 ret 10bb4e: 66 90 xchg %ax,%ax { register Thread_Control *the_thread; Objects_Locations location; if ( entry_point == NULL ) return RTEMS_INVALID_ADDRESS; 10bb50: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10bb55: 8b 5d fc mov -0x4(%ebp),%ebx 10bb58: c9 leave 10bb59: c3 ret 10bb5a: 66 90 xchg %ax,%ax switch ( location ) { case OBJECTS_LOCAL: if ( _Thread_Start( the_thread, THREAD_START_NUMERIC, entry_point, NULL, argument ) ) { _Thread_Enable_dispatch(); 10bb5c: e8 4f 1e 00 00 call 10d9b0 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10bb61: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10bb63: 8b 5d fc mov -0x4(%ebp),%ebx 10bb66: c9 leave 10bb67: c3 ret =============================================================================== 00110f70 : */ rtems_status_code rtems_task_suspend( rtems_id id ) { 110f70: 55 push %ebp 110f71: 89 e5 mov %esp,%ebp 110f73: 83 ec 20 sub $0x20,%esp register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 110f76: 8d 45 f4 lea -0xc(%ebp),%eax 110f79: 50 push %eax 110f7a: ff 75 08 pushl 0x8(%ebp) 110f7d: e8 52 ca ff ff call 10d9d4 <_Thread_Get> switch ( location ) { 110f82: 83 c4 10 add $0x10,%esp 110f85: 8b 55 f4 mov -0xc(%ebp),%edx 110f88: 85 d2 test %edx,%edx 110f8a: 74 08 je 110f94 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 110f8c: b8 04 00 00 00 mov $0x4,%eax } 110f91: c9 leave 110f92: c3 ret 110f93: 90 nop the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { 110f94: f6 40 10 02 testb $0x2,0x10(%eax) 110f98: 74 0e je 110fa8 _Thread_Suspend( the_thread ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 110f9a: e8 11 ca ff ff call 10d9b0 <_Thread_Enable_dispatch> return RTEMS_ALREADY_SUSPENDED; 110f9f: b8 0f 00 00 00 mov $0xf,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 110fa4: c9 leave 110fa5: c3 ret 110fa6: 66 90 xchg %ax,%ax the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { _Thread_Suspend( the_thread ); 110fa8: 83 ec 0c sub $0xc,%esp 110fab: 50 push %eax 110fac: e8 27 09 00 00 call 1118d8 <_Thread_Suspend> _Thread_Enable_dispatch(); 110fb1: e8 fa c9 ff ff call 10d9b0 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 110fb6: 83 c4 10 add $0x10,%esp 110fb9: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 110fbb: c9 leave 110fbc: c3 ret =============================================================================== 0010c650 : rtems_status_code rtems_task_variable_add( rtems_id tid, void **ptr, void (*dtor)(void *) ) { 10c650: 55 push %ebp 10c651: 89 e5 mov %esp,%ebp 10c653: 57 push %edi 10c654: 56 push %esi 10c655: 53 push %ebx 10c656: 83 ec 1c sub $0x1c,%esp 10c659: 8b 5d 0c mov 0xc(%ebp),%ebx 10c65c: 8b 7d 10 mov 0x10(%ebp),%edi Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *new; if ( !ptr ) 10c65f: 85 db test %ebx,%ebx 10c661: 0f 84 9d 00 00 00 je 10c704 return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); 10c667: 83 ec 08 sub $0x8,%esp 10c66a: 8d 45 e4 lea -0x1c(%ebp),%eax 10c66d: 50 push %eax 10c66e: ff 75 08 pushl 0x8(%ebp) 10c671: e8 6e 20 00 00 call 10e6e4 <_Thread_Get> 10c676: 89 c6 mov %eax,%esi switch (location) { 10c678: 83 c4 10 add $0x10,%esp 10c67b: 8b 45 e4 mov -0x1c(%ebp),%eax 10c67e: 85 c0 test %eax,%eax 10c680: 74 0e je 10c690 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10c682: b8 04 00 00 00 mov $0x4,%eax } 10c687: 8d 65 f4 lea -0xc(%ebp),%esp 10c68a: 5b pop %ebx 10c68b: 5e pop %esi 10c68c: 5f pop %edi 10c68d: c9 leave 10c68e: c3 ret 10c68f: 90 nop case OBJECTS_LOCAL: /* * Figure out if the variable is already in this task's list. */ tvp = the_thread->task_variables; 10c690: 8b 86 f4 00 00 00 mov 0xf4(%esi),%eax while (tvp) { 10c696: 85 c0 test %eax,%eax 10c698: 75 44 jne 10c6de 10c69a: 66 90 xchg %ax,%ax /* * Now allocate memory for this task variable. */ new = (rtems_task_variable_t *) _Workspace_Allocate(sizeof(rtems_task_variable_t)); 10c69c: 83 ec 0c sub $0xc,%esp 10c69f: 6a 14 push $0x14 10c6a1: e8 f2 2f 00 00 call 10f698 <_Workspace_Allocate> if (new == NULL) { 10c6a6: 83 c4 10 add $0x10,%esp 10c6a9: 85 c0 test %eax,%eax 10c6ab: 74 4b je 10c6f8 _Thread_Enable_dispatch(); return RTEMS_NO_MEMORY; } new->gval = *ptr; 10c6ad: 8b 13 mov (%ebx),%edx 10c6af: 89 50 08 mov %edx,0x8(%eax) new->ptr = ptr; 10c6b2: 89 58 04 mov %ebx,0x4(%eax) new->dtor = dtor; 10c6b5: 89 78 10 mov %edi,0x10(%eax) new->next = (struct rtems_task_variable_tt *)the_thread->task_variables; 10c6b8: 8b 96 f4 00 00 00 mov 0xf4(%esi),%edx 10c6be: 89 10 mov %edx,(%eax) the_thread->task_variables = new; 10c6c0: 89 86 f4 00 00 00 mov %eax,0xf4(%esi) _Thread_Enable_dispatch(); 10c6c6: e8 f5 1f 00 00 call 10e6c0 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10c6cb: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10c6cd: 8d 65 f4 lea -0xc(%ebp),%esp 10c6d0: 5b pop %ebx 10c6d1: 5e pop %esi 10c6d2: 5f pop %edi 10c6d3: c9 leave 10c6d4: c3 ret 10c6d5: 8d 76 00 lea 0x0(%esi),%esi if (tvp->ptr == ptr) { tvp->dtor = dtor; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; 10c6d8: 8b 00 mov (%eax),%eax case OBJECTS_LOCAL: /* * Figure out if the variable is already in this task's list. */ tvp = the_thread->task_variables; while (tvp) { 10c6da: 85 c0 test %eax,%eax 10c6dc: 74 be je 10c69c if (tvp->ptr == ptr) { 10c6de: 39 58 04 cmp %ebx,0x4(%eax) 10c6e1: 75 f5 jne 10c6d8 tvp->dtor = dtor; 10c6e3: 89 78 10 mov %edi,0x10(%eax) _Thread_Enable_dispatch(); 10c6e6: e8 d5 1f 00 00 call 10e6c0 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10c6eb: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10c6ed: 8d 65 f4 lea -0xc(%ebp),%esp 10c6f0: 5b pop %ebx 10c6f1: 5e pop %esi 10c6f2: 5f pop %edi 10c6f3: c9 leave 10c6f4: c3 ret 10c6f5: 8d 76 00 lea 0x0(%esi),%esi * Now allocate memory for this task variable. */ new = (rtems_task_variable_t *) _Workspace_Allocate(sizeof(rtems_task_variable_t)); if (new == NULL) { _Thread_Enable_dispatch(); 10c6f8: e8 c3 1f 00 00 call 10e6c0 <_Thread_Enable_dispatch> return RTEMS_NO_MEMORY; 10c6fd: b8 1a 00 00 00 mov $0x1a,%eax 10c702: eb 83 jmp 10c687 Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *new; if ( !ptr ) return RTEMS_INVALID_ADDRESS; 10c704: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10c709: 8d 65 f4 lea -0xc(%ebp),%esp 10c70c: 5b pop %ebx 10c70d: 5e pop %esi 10c70e: 5f pop %edi 10c70f: c9 leave 10c710: c3 ret =============================================================================== 0010c714 : rtems_status_code rtems_task_variable_delete( rtems_id tid, void **ptr ) { 10c714: 55 push %ebp 10c715: 89 e5 mov %esp,%ebp 10c717: 53 push %ebx 10c718: 83 ec 14 sub $0x14,%esp 10c71b: 8b 5d 0c mov 0xc(%ebp),%ebx Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *prev; if ( !ptr ) 10c71e: 85 db test %ebx,%ebx 10c720: 74 76 je 10c798 return RTEMS_INVALID_ADDRESS; prev = NULL; the_thread = _Thread_Get (tid, &location); 10c722: 83 ec 08 sub $0x8,%esp 10c725: 8d 45 f4 lea -0xc(%ebp),%eax 10c728: 50 push %eax 10c729: ff 75 08 pushl 0x8(%ebp) 10c72c: e8 b3 1f 00 00 call 10e6e4 <_Thread_Get> switch (location) { 10c731: 83 c4 10 add $0x10,%esp 10c734: 8b 55 f4 mov -0xc(%ebp),%edx 10c737: 85 d2 test %edx,%edx 10c739: 74 0d je 10c748 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10c73b: b8 04 00 00 00 mov $0x4,%eax } 10c740: 8b 5d fc mov -0x4(%ebp),%ebx 10c743: c9 leave 10c744: c3 ret 10c745: 8d 76 00 lea 0x0(%esi),%esi the_thread = _Thread_Get (tid, &location); switch (location) { case OBJECTS_LOCAL: tvp = the_thread->task_variables; 10c748: 8b 88 f4 00 00 00 mov 0xf4(%eax),%ecx while (tvp) { 10c74e: 85 c9 test %ecx,%ecx 10c750: 74 17 je 10c769 if (tvp->ptr == ptr) { 10c752: 39 59 04 cmp %ebx,0x4(%ecx) 10c755: 75 0c jne 10c763 10c757: eb 49 jmp 10c7a2 10c759: 8d 76 00 lea 0x0(%esi),%esi 10c75c: 39 5a 04 cmp %ebx,0x4(%edx) 10c75f: 74 17 je 10c778 10c761: 89 d1 mov %edx,%ecx _RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } prev = tvp; tvp = (rtems_task_variable_t *)tvp->next; 10c763: 8b 11 mov (%ecx),%edx the_thread = _Thread_Get (tid, &location); switch (location) { case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { 10c765: 85 d2 test %edx,%edx 10c767: 75 f3 jne 10c75c <== ALWAYS TAKEN return RTEMS_SUCCESSFUL; } prev = tvp; tvp = (rtems_task_variable_t *)tvp->next; } _Thread_Enable_dispatch(); 10c769: e8 52 1f 00 00 call 10e6c0 <_Thread_Enable_dispatch> return RTEMS_INVALID_ADDRESS; 10c76e: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10c773: 8b 5d fc mov -0x4(%ebp),%ebx 10c776: c9 leave 10c777: c3 ret case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { if (tvp->ptr == ptr) { if (prev) prev->next = tvp->next; 10c778: 8b 1a mov (%edx),%ebx 10c77a: 89 19 mov %ebx,(%ecx) else the_thread->task_variables = (rtems_task_variable_t *)tvp->next; _RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp ); 10c77c: 83 ec 08 sub $0x8,%esp 10c77f: 52 push %edx 10c780: 50 push %eax 10c781: e8 b2 00 00 00 call 10c838 <_RTEMS_Tasks_Invoke_task_variable_dtor> _Thread_Enable_dispatch(); 10c786: e8 35 1f 00 00 call 10e6c0 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10c78b: 83 c4 10 add $0x10,%esp 10c78e: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10c790: 8b 5d fc mov -0x4(%ebp),%ebx 10c793: c9 leave 10c794: c3 ret 10c795: 8d 76 00 lea 0x0(%esi),%esi Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *prev; if ( !ptr ) return RTEMS_INVALID_ADDRESS; 10c798: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10c79d: 8b 5d fc mov -0x4(%ebp),%ebx 10c7a0: c9 leave 10c7a1: c3 ret while (tvp) { if (tvp->ptr == ptr) { if (prev) prev->next = tvp->next; else the_thread->task_variables = (rtems_task_variable_t *)tvp->next; 10c7a2: 8b 11 mov (%ecx),%edx 10c7a4: 89 90 f4 00 00 00 mov %edx,0xf4(%eax) 10c7aa: 89 ca mov %ecx,%edx 10c7ac: eb ce jmp 10c77c =============================================================================== 0010c7b0 : rtems_status_code rtems_task_variable_get( rtems_id tid, void **ptr, void **result ) { 10c7b0: 55 push %ebp 10c7b1: 89 e5 mov %esp,%ebp 10c7b3: 56 push %esi 10c7b4: 53 push %ebx 10c7b5: 83 ec 10 sub $0x10,%esp 10c7b8: 8b 5d 0c mov 0xc(%ebp),%ebx 10c7bb: 8b 75 10 mov 0x10(%ebp),%esi Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp; if ( !ptr ) 10c7be: 85 db test %ebx,%ebx 10c7c0: 74 56 je 10c818 return RTEMS_INVALID_ADDRESS; if ( !result ) 10c7c2: 85 f6 test %esi,%esi 10c7c4: 74 52 je 10c818 return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); 10c7c6: 83 ec 08 sub $0x8,%esp 10c7c9: 8d 45 f4 lea -0xc(%ebp),%eax 10c7cc: 50 push %eax 10c7cd: ff 75 08 pushl 0x8(%ebp) 10c7d0: e8 0f 1f 00 00 call 10e6e4 <_Thread_Get> switch (location) { 10c7d5: 83 c4 10 add $0x10,%esp 10c7d8: 8b 55 f4 mov -0xc(%ebp),%edx 10c7db: 85 d2 test %edx,%edx 10c7dd: 75 2d jne 10c80c case OBJECTS_LOCAL: /* * Figure out if the variable is in this task's list. */ tvp = the_thread->task_variables; 10c7df: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax while (tvp) { 10c7e5: 85 c0 test %eax,%eax 10c7e7: 75 09 jne 10c7f2 10c7e9: eb 39 jmp 10c824 10c7eb: 90 nop */ *result = tvp->tval; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; 10c7ec: 8b 00 mov (%eax),%eax case OBJECTS_LOCAL: /* * Figure out if the variable is in this task's list. */ tvp = the_thread->task_variables; while (tvp) { 10c7ee: 85 c0 test %eax,%eax 10c7f0: 74 32 je 10c824 <== NEVER TAKEN if (tvp->ptr == ptr) { 10c7f2: 39 58 04 cmp %ebx,0x4(%eax) 10c7f5: 75 f5 jne 10c7ec /* * Should this return the current (i.e not the * saved) value if `tid' is the current task? */ *result = tvp->tval; 10c7f7: 8b 40 0c mov 0xc(%eax),%eax 10c7fa: 89 06 mov %eax,(%esi) _Thread_Enable_dispatch(); 10c7fc: e8 bf 1e 00 00 call 10e6c0 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10c801: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10c803: 8d 65 f8 lea -0x8(%ebp),%esp 10c806: 5b pop %ebx 10c807: 5e pop %esi 10c808: c9 leave 10c809: c3 ret 10c80a: 66 90 xchg %ax,%ax #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10c80c: b8 04 00 00 00 mov $0x4,%eax } 10c811: 8d 65 f8 lea -0x8(%ebp),%esp 10c814: 5b pop %ebx 10c815: 5e pop %esi 10c816: c9 leave 10c817: c3 ret if ( !ptr ) return RTEMS_INVALID_ADDRESS; if ( !result ) return RTEMS_INVALID_ADDRESS; 10c818: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10c81d: 8d 65 f8 lea -0x8(%ebp),%esp 10c820: 5b pop %ebx 10c821: 5e pop %esi 10c822: c9 leave 10c823: c3 ret _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; } _Thread_Enable_dispatch(); 10c824: e8 97 1e 00 00 call 10e6c0 <_Thread_Enable_dispatch> return RTEMS_INVALID_ADDRESS; 10c829: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10c82e: 8d 65 f8 lea -0x8(%ebp),%esp 10c831: 5b pop %ebx 10c832: 5e pop %esi 10c833: c9 leave 10c834: c3 ret =============================================================================== 0010c9c0 : */ rtems_status_code rtems_task_wake_when( rtems_time_of_day *time_buffer ) { 10c9c0: 55 push %ebp 10c9c1: 89 e5 mov %esp,%ebp 10c9c3: 53 push %ebx 10c9c4: 83 ec 14 sub $0x14,%esp 10c9c7: 8b 5d 08 mov 0x8(%ebp),%ebx Watchdog_Interval seconds; if ( !_TOD_Is_set ) 10c9ca: 80 3d c4 aa 12 00 00 cmpb $0x0,0x12aac4 10c9d1: 0f 84 a9 00 00 00 je 10ca80 return RTEMS_NOT_DEFINED; if ( !time_buffer ) 10c9d7: 85 db test %ebx,%ebx 10c9d9: 0f 84 ad 00 00 00 je 10ca8c return RTEMS_INVALID_ADDRESS; time_buffer->ticks = 0; 10c9df: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) if ( !_TOD_Validate( time_buffer ) ) 10c9e6: 83 ec 0c sub $0xc,%esp 10c9e9: 53 push %ebx 10c9ea: e8 d1 f3 ff ff call 10bdc0 <_TOD_Validate> 10c9ef: 83 c4 10 add $0x10,%esp 10c9f2: 84 c0 test %al,%al 10c9f4: 75 0a jne 10ca00 return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( time_buffer ); if ( seconds <= _TOD_Seconds_since_epoch() ) return RTEMS_INVALID_CLOCK; 10c9f6: b8 14 00 00 00 mov $0x14,%eax &_Thread_Executing->Timer, seconds - _TOD_Seconds_since_epoch() ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10c9fb: 8b 5d fc mov -0x4(%ebp),%ebx 10c9fe: c9 leave 10c9ff: c3 ret time_buffer->ticks = 0; if ( !_TOD_Validate( time_buffer ) ) return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( time_buffer ); 10ca00: 83 ec 0c sub $0xc,%esp 10ca03: 53 push %ebx 10ca04: e8 2b f3 ff ff call 10bd34 <_TOD_To_seconds> if ( seconds <= _TOD_Seconds_since_epoch() ) 10ca09: 83 c4 10 add $0x10,%esp 10ca0c: 3b 05 48 ab 12 00 cmp 0x12ab48,%eax 10ca12: 76 e2 jbe 10c9f6 10ca14: 8b 15 b0 aa 12 00 mov 0x12aab0,%edx 10ca1a: 42 inc %edx 10ca1b: 89 15 b0 aa 12 00 mov %edx,0x12aab0 return RTEMS_INVALID_CLOCK; _Thread_Disable_dispatch(); _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME ); 10ca21: 83 ec 08 sub $0x8,%esp 10ca24: 6a 10 push $0x10 10ca26: ff 35 58 b0 12 00 pushl 0x12b058 10ca2c: 89 45 f4 mov %eax,-0xc(%ebp) 10ca2f: e8 ec 26 00 00 call 10f120 <_Thread_Set_state> _Watchdog_Initialize( &_Thread_Executing->Timer, _Thread_Delay_ended, _Thread_Executing->Object.id, 10ca34: 8b 15 58 b0 12 00 mov 0x12b058,%edx if ( seconds <= _TOD_Seconds_since_epoch() ) return RTEMS_INVALID_CLOCK; _Thread_Disable_dispatch(); _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME ); _Watchdog_Initialize( 10ca3a: 8b 4a 08 mov 0x8(%edx),%ecx Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 10ca3d: c7 42 50 00 00 00 00 movl $0x0,0x50(%edx) the_watchdog->routine = routine; 10ca44: c7 42 64 4c e7 10 00 movl $0x10e74c,0x64(%edx) the_watchdog->id = id; 10ca4b: 89 4a 68 mov %ecx,0x68(%edx) the_watchdog->user_data = user_data; 10ca4e: c7 42 6c 00 00 00 00 movl $0x0,0x6c(%edx) &_Thread_Executing->Timer, _Thread_Delay_ended, _Thread_Executing->Object.id, NULL ); _Watchdog_Insert_seconds( 10ca55: 8b 45 f4 mov -0xc(%ebp),%eax 10ca58: 2b 05 48 ab 12 00 sub 0x12ab48,%eax 10ca5e: 89 42 54 mov %eax,0x54(%edx) ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 10ca61: 58 pop %eax 10ca62: 59 pop %ecx 10ca63: 83 c2 48 add $0x48,%edx 10ca66: 52 push %edx 10ca67: 68 74 ab 12 00 push $0x12ab74 10ca6c: e8 77 2c 00 00 call 10f6e8 <_Watchdog_Insert> &_Thread_Executing->Timer, seconds - _TOD_Seconds_since_epoch() ); _Thread_Enable_dispatch(); 10ca71: e8 8a 1e 00 00 call 10e900 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10ca76: 83 c4 10 add $0x10,%esp 10ca79: 31 c0 xor %eax,%eax 10ca7b: e9 7b ff ff ff jmp 10c9fb ) { Watchdog_Interval seconds; if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; 10ca80: b8 0b 00 00 00 mov $0xb,%eax &_Thread_Executing->Timer, seconds - _TOD_Seconds_since_epoch() ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10ca85: 8b 5d fc mov -0x4(%ebp),%ebx 10ca88: c9 leave 10ca89: c3 ret 10ca8a: 66 90 xchg %ax,%ax if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; if ( !time_buffer ) return RTEMS_INVALID_ADDRESS; 10ca8c: b8 09 00 00 00 mov $0x9,%eax &_Thread_Executing->Timer, seconds - _TOD_Seconds_since_epoch() ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10ca91: 8b 5d fc mov -0x4(%ebp),%ebx 10ca94: c9 leave 10ca95: c3 ret =============================================================================== 0010a8cc : #include int rtems_termios_baud_to_index( rtems_termios_baud_t termios_baud ) { 10a8cc: 55 push %ebp 10a8cd: 89 e5 mov %esp,%ebp 10a8cf: 8b 45 08 mov 0x8(%ebp),%eax int baud_index; switch (termios_baud) { 10a8d2: 83 f8 09 cmp $0x9,%eax 10a8d5: 0f 84 f1 00 00 00 je 10a9cc 10a8db: 7e 37 jle 10a914 10a8dd: 83 f8 0e cmp $0xe,%eax 10a8e0: 0f 84 f6 00 00 00 je 10a9dc 10a8e6: 7e 5c jle 10a944 10a8e8: 3d 02 10 00 00 cmp $0x1002,%eax 10a8ed: 0f 84 01 01 00 00 je 10a9f4 10a8f3: 0f 8e 97 00 00 00 jle 10a990 10a8f9: 3d 03 10 00 00 cmp $0x1003,%eax 10a8fe: 0f 84 e0 00 00 00 je 10a9e4 10a904: 3d 04 10 00 00 cmp $0x1004,%eax 10a909: 75 51 jne 10a95c <== NEVER TAKEN case B19200: baud_index = 14; break; case B38400: baud_index = 15; break; case B57600: baud_index = 16; break; case B115200: baud_index = 17; break; case B230400: baud_index = 18; break; case B460800: baud_index = 19; break; 10a90b: b8 13 00 00 00 mov $0x13,%eax default: baud_index = -1; break; } return baud_index; } 10a910: c9 leave 10a911: c3 ret 10a912: 66 90 xchg %ax,%ax rtems_termios_baud_t termios_baud ) { int baud_index; switch (termios_baud) { 10a914: 83 f8 04 cmp $0x4,%eax 10a917: 0f 84 b7 00 00 00 je 10a9d4 10a91d: 7f 45 jg 10a964 10a91f: 83 f8 01 cmp $0x1,%eax 10a922: 0f 84 8c 00 00 00 je 10a9b4 10a928: 0f 8e de 00 00 00 jle 10aa0c 10a92e: 83 f8 02 cmp $0x2,%eax 10a931: 0f 84 c5 00 00 00 je 10a9fc 10a937: 83 f8 03 cmp $0x3,%eax 10a93a: 75 20 jne 10a95c <== NEVER TAKEN case B0: baud_index = 0; break; case B50: baud_index = 1; break; case B75: baud_index = 2; break; case B110: baud_index = 3; break; 10a93c: b8 03 00 00 00 mov $0x3,%eax case B460800: baud_index = 19; break; default: baud_index = -1; break; } return baud_index; } 10a941: c9 leave 10a942: c3 ret 10a943: 90 nop rtems_termios_baud_t termios_baud ) { int baud_index; switch (termios_baud) { 10a944: 83 f8 0b cmp $0xb,%eax 10a947: 0f 84 9f 00 00 00 je 10a9ec 10a94d: 7c 39 jl 10a988 10a94f: 83 f8 0c cmp $0xc,%eax 10a952: 74 50 je 10a9a4 10a954: 83 f8 0d cmp $0xd,%eax 10a957: 74 62 je 10a9bb <== ALWAYS TAKEN 10a959: 8d 76 00 lea 0x0(%esi),%esi case B38400: baud_index = 15; break; case B57600: baud_index = 16; break; case B115200: baud_index = 17; break; case B230400: baud_index = 18; break; case B460800: baud_index = 19; break; default: baud_index = -1; break; 10a95c: b8 ff ff ff ff mov $0xffffffff,%eax } return baud_index; } 10a961: c9 leave 10a962: c3 ret 10a963: 90 nop rtems_termios_baud_t termios_baud ) { int baud_index; switch (termios_baud) { 10a964: 83 f8 06 cmp $0x6,%eax 10a967: 74 43 je 10a9ac 10a969: 7c 15 jl 10a980 10a96b: 83 f8 07 cmp $0x7,%eax 10a96e: 0f 84 90 00 00 00 je 10aa04 10a974: 83 f8 08 cmp $0x8,%eax 10a977: 75 e3 jne 10a95c <== NEVER TAKEN case B110: baud_index = 3; break; case B134: baud_index = 4; break; case B150: baud_index = 5; break; case B200: baud_index = 6; break; case B300: baud_index = 7; break; case B600: baud_index = 8; break; 10a979: b8 08 00 00 00 mov $0x8,%eax case B460800: baud_index = 19; break; default: baud_index = -1; break; } return baud_index; } 10a97e: c9 leave 10a97f: c3 ret case B0: baud_index = 0; break; case B50: baud_index = 1; break; case B75: baud_index = 2; break; case B110: baud_index = 3; break; case B134: baud_index = 4; break; case B150: baud_index = 5; break; 10a980: b8 05 00 00 00 mov $0x5,%eax case B460800: baud_index = 19; break; default: baud_index = -1; break; } return baud_index; } 10a985: c9 leave 10a986: c3 ret 10a987: 90 nop case B150: baud_index = 5; break; case B200: baud_index = 6; break; case B300: baud_index = 7; break; case B600: baud_index = 8; break; case B1200: baud_index = 9; break; case B1800: baud_index = 10; break; 10a988: b8 0a 00 00 00 mov $0xa,%eax case B460800: baud_index = 19; break; default: baud_index = -1; break; } return baud_index; } 10a98d: c9 leave 10a98e: c3 ret 10a98f: 90 nop rtems_termios_baud_t termios_baud ) { int baud_index; switch (termios_baud) { 10a990: 83 f8 0f cmp $0xf,%eax 10a993: 74 2f je 10a9c4 10a995: 3d 01 10 00 00 cmp $0x1001,%eax 10a99a: 75 c0 jne 10a95c <== NEVER TAKEN case B2400: baud_index = 11; break; case B4800: baud_index = 12; break; case B9600: baud_index = 13; break; case B19200: baud_index = 14; break; case B38400: baud_index = 15; break; case B57600: baud_index = 16; break; 10a99c: b8 10 00 00 00 mov $0x10,%eax case B460800: baud_index = 19; break; default: baud_index = -1; break; } return baud_index; } 10a9a1: c9 leave 10a9a2: c3 ret 10a9a3: 90 nop case B300: baud_index = 7; break; case B600: baud_index = 8; break; case B1200: baud_index = 9; break; case B1800: baud_index = 10; break; case B2400: baud_index = 11; break; case B4800: baud_index = 12; break; 10a9a4: b8 0c 00 00 00 mov $0xc,%eax case B460800: baud_index = 19; break; default: baud_index = -1; break; } return baud_index; } 10a9a9: c9 leave 10a9aa: c3 ret 10a9ab: 90 nop case B50: baud_index = 1; break; case B75: baud_index = 2; break; case B110: baud_index = 3; break; case B134: baud_index = 4; break; case B150: baud_index = 5; break; case B200: baud_index = 6; break; 10a9ac: b8 06 00 00 00 mov $0x6,%eax case B460800: baud_index = 19; break; default: baud_index = -1; break; } return baud_index; } 10a9b1: c9 leave 10a9b2: c3 ret 10a9b3: 90 nop { int baud_index; switch (termios_baud) { case B0: baud_index = 0; break; case B50: baud_index = 1; break; 10a9b4: b8 01 00 00 00 mov $0x1,%eax case B460800: baud_index = 19; break; default: baud_index = -1; break; } return baud_index; } 10a9b9: c9 leave 10a9ba: c3 ret case B600: baud_index = 8; break; case B1200: baud_index = 9; break; case B1800: baud_index = 10; break; case B2400: baud_index = 11; break; case B4800: baud_index = 12; break; case B9600: baud_index = 13; break; 10a9bb: b8 0d 00 00 00 mov $0xd,%eax case B460800: baud_index = 19; break; default: baud_index = -1; break; } return baud_index; } 10a9c0: c9 leave 10a9c1: c3 ret 10a9c2: 66 90 xchg %ax,%ax case B1800: baud_index = 10; break; case B2400: baud_index = 11; break; case B4800: baud_index = 12; break; case B9600: baud_index = 13; break; case B19200: baud_index = 14; break; case B38400: baud_index = 15; break; 10a9c4: b8 0f 00 00 00 mov $0xf,%eax case B460800: baud_index = 19; break; default: baud_index = -1; break; } return baud_index; } 10a9c9: c9 leave 10a9ca: c3 ret 10a9cb: 90 nop case B134: baud_index = 4; break; case B150: baud_index = 5; break; case B200: baud_index = 6; break; case B300: baud_index = 7; break; case B600: baud_index = 8; break; case B1200: baud_index = 9; break; 10a9cc: b8 09 00 00 00 mov $0x9,%eax case B460800: baud_index = 19; break; default: baud_index = -1; break; } return baud_index; } 10a9d1: c9 leave 10a9d2: c3 ret 10a9d3: 90 nop switch (termios_baud) { case B0: baud_index = 0; break; case B50: baud_index = 1; break; case B75: baud_index = 2; break; case B110: baud_index = 3; break; case B134: baud_index = 4; break; 10a9d4: b8 04 00 00 00 mov $0x4,%eax case B460800: baud_index = 19; break; default: baud_index = -1; break; } return baud_index; } 10a9d9: c9 leave 10a9da: c3 ret 10a9db: 90 nop case B1200: baud_index = 9; break; case B1800: baud_index = 10; break; case B2400: baud_index = 11; break; case B4800: baud_index = 12; break; case B9600: baud_index = 13; break; case B19200: baud_index = 14; break; 10a9dc: b8 0e 00 00 00 mov $0xe,%eax case B460800: baud_index = 19; break; default: baud_index = -1; break; } return baud_index; } 10a9e1: c9 leave 10a9e2: c3 ret 10a9e3: 90 nop case B9600: baud_index = 13; break; case B19200: baud_index = 14; break; case B38400: baud_index = 15; break; case B57600: baud_index = 16; break; case B115200: baud_index = 17; break; case B230400: baud_index = 18; break; 10a9e4: b8 12 00 00 00 mov $0x12,%eax case B460800: baud_index = 19; break; default: baud_index = -1; break; } return baud_index; } 10a9e9: c9 leave 10a9ea: c3 ret 10a9eb: 90 nop case B200: baud_index = 6; break; case B300: baud_index = 7; break; case B600: baud_index = 8; break; case B1200: baud_index = 9; break; case B1800: baud_index = 10; break; case B2400: baud_index = 11; break; 10a9ec: b8 0b 00 00 00 mov $0xb,%eax case B460800: baud_index = 19; break; default: baud_index = -1; break; } return baud_index; } 10a9f1: c9 leave 10a9f2: c3 ret 10a9f3: 90 nop case B4800: baud_index = 12; break; case B9600: baud_index = 13; break; case B19200: baud_index = 14; break; case B38400: baud_index = 15; break; case B57600: baud_index = 16; break; case B115200: baud_index = 17; break; 10a9f4: b8 11 00 00 00 mov $0x11,%eax case B460800: baud_index = 19; break; default: baud_index = -1; break; } return baud_index; } 10a9f9: c9 leave 10a9fa: c3 ret 10a9fb: 90 nop int baud_index; switch (termios_baud) { case B0: baud_index = 0; break; case B50: baud_index = 1; break; case B75: baud_index = 2; break; 10a9fc: b8 02 00 00 00 mov $0x2,%eax case B460800: baud_index = 19; break; default: baud_index = -1; break; } return baud_index; } 10aa01: c9 leave 10aa02: c3 ret 10aa03: 90 nop case B75: baud_index = 2; break; case B110: baud_index = 3; break; case B134: baud_index = 4; break; case B150: baud_index = 5; break; case B200: baud_index = 6; break; case B300: baud_index = 7; break; 10aa04: b8 07 00 00 00 mov $0x7,%eax case B460800: baud_index = 19; break; default: baud_index = -1; break; } return baud_index; } 10aa09: c9 leave 10aa0a: c3 ret 10aa0b: 90 nop rtems_termios_baud_t termios_baud ) { int baud_index; switch (termios_baud) { 10aa0c: 85 c0 test %eax,%eax 10aa0e: 0f 85 48 ff ff ff jne 10a95c case B0: baud_index = 0; break; 10aa14: 31 c0 xor %eax,%eax case B460800: baud_index = 19; break; default: baud_index = -1; break; } return baud_index; } 10aa16: c9 leave 10aa17: c3 ret =============================================================================== 00108f38 : extern rtems_assoc_t termios_assoc_table[]; int32_t rtems_termios_baud_to_number( int termios_baud ) { 108f38: 55 push %ebp 108f39: 89 e5 mov %esp,%ebp 108f3b: 53 push %ebx 108f3c: 83 ec 0c sub $0xc,%esp 108f3f: 8b 5d 08 mov 0x8(%ebp),%ebx int baud; baud = rtems_assoc_local_by_remote( termios_assoc_table, termios_baud ); 108f42: 53 push %ebx 108f43: 68 80 58 12 00 push $0x125880 108f48: e8 73 6c 00 00 call 10fbc0 if ( baud == 0 && termios_baud != 0 ) 108f4d: 83 c4 10 add $0x10,%esp 108f50: 85 c0 test %eax,%eax 108f52: 74 08 je 108f5c return -1; return baud; } 108f54: 8b 5d fc mov -0x4(%ebp),%ebx 108f57: c9 leave 108f58: c3 ret 108f59: 8d 76 00 lea 0x0(%esi),%esi ) { int baud; baud = rtems_assoc_local_by_remote( termios_assoc_table, termios_baud ); if ( baud == 0 && termios_baud != 0 ) 108f5c: 83 fb 01 cmp $0x1,%ebx 108f5f: 19 c0 sbb %eax,%eax 108f61: f7 d0 not %eax 108f63: eb ef jmp 108f54 =============================================================================== 001094bc : } } rtems_status_code rtems_termios_close (void *arg) { 1094bc: 55 push %ebp 1094bd: 89 e5 mov %esp,%ebp 1094bf: 56 push %esi 1094c0: 53 push %ebx 1094c1: 8b 75 08 mov 0x8(%ebp),%esi rtems_libio_open_close_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 1094c4: 8b 06 mov (%esi),%eax 1094c6: 8b 58 34 mov 0x34(%eax),%ebx rtems_status_code sc; sc = rtems_semaphore_obtain( 1094c9: 52 push %edx 1094ca: 6a 00 push $0x0 1094cc: 6a 00 push $0x0 1094ce: ff 35 6c 7c 12 00 pushl 0x127c6c 1094d4: e8 d7 21 00 00 call 10b6b0 rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) 1094d9: 83 c4 10 add $0x10,%esp 1094dc: 85 c0 test %eax,%eax 1094de: 0f 85 9a 01 00 00 jne 10967e <== NEVER TAKEN rtems_fatal_error_occurred (sc); if (--tty->refcount == 0) { 1094e4: 8b 43 08 mov 0x8(%ebx),%eax 1094e7: 48 dec %eax 1094e8: 89 43 08 mov %eax,0x8(%ebx) 1094eb: 85 c0 test %eax,%eax 1094ed: 0f 85 bf 00 00 00 jne 1095b2 if (rtems_termios_linesw[tty->t_line].l_close != NULL) { 1094f3: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax 1094f9: c1 e0 05 shl $0x5,%eax 1094fc: 8b 80 04 79 12 00 mov 0x127904(%eax),%eax 109502: 85 c0 test %eax,%eax 109504: 0f 84 0a 01 00 00 je 109614 /* * call discipline-specific close */ sc = rtems_termios_linesw[tty->t_line].l_close(tty); 10950a: 83 ec 0c sub $0xc,%esp 10950d: 53 push %ebx 10950e: ff d0 call *%eax 109510: 83 c4 10 add $0x10,%esp } drainOutput (tty); rtems_semaphore_release (tty->osem); } if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 109513: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) 10951a: 0f 84 2c 01 00 00 je 10964c <== NEVER TAKEN rtems_fatal_error_occurred (sc); sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT ); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); } if (tty->device.lastClose) 109520: 8b 83 9c 00 00 00 mov 0x9c(%ebx),%eax 109526: 85 c0 test %eax,%eax 109528: 74 0d je 109537 (*tty->device.lastClose)(tty->major, tty->minor, arg); 10952a: 51 push %ecx 10952b: 56 push %esi 10952c: ff 73 10 pushl 0x10(%ebx) 10952f: ff 73 0c pushl 0xc(%ebx) 109532: ff d0 call *%eax 109534: 83 c4 10 add $0x10,%esp if (tty->forw == NULL) { 109537: 8b 03 mov (%ebx),%eax 109539: 85 c0 test %eax,%eax 10953b: 0f 84 b7 00 00 00 je 1095f8 rtems_termios_ttyTail = tty->back; if ( rtems_termios_ttyTail != NULL ) { rtems_termios_ttyTail->forw = NULL; } } else { tty->forw->back = tty->back; 109541: 8b 53 04 mov 0x4(%ebx),%edx 109544: 89 50 04 mov %edx,0x4(%eax) 109547: 8b 53 04 mov 0x4(%ebx),%edx } if (tty->back == NULL) { 10954a: 85 d2 test %edx,%edx 10954c: 0f 84 8a 00 00 00 je 1095dc <== ALWAYS TAKEN rtems_termios_ttyHead = tty->forw; if ( rtems_termios_ttyHead != NULL ) { rtems_termios_ttyHead->back = NULL; } } else { tty->back->forw = tty->forw; 109552: 89 02 mov %eax,(%edx) } rtems_semaphore_delete (tty->isem); 109554: 83 ec 0c sub $0xc,%esp 109557: ff 73 14 pushl 0x14(%ebx) 10955a: e8 ad 20 00 00 call 10b60c rtems_semaphore_delete (tty->osem); 10955f: 5a pop %edx 109560: ff 73 18 pushl 0x18(%ebx) 109563: e8 a4 20 00 00 call 10b60c rtems_semaphore_delete (tty->rawOutBuf.Semaphore); 109568: 58 pop %eax 109569: ff b3 8c 00 00 00 pushl 0x8c(%ebx) 10956f: e8 98 20 00 00 call 10b60c if ((tty->device.pollRead == NULL) || 109574: 83 c4 10 add $0x10,%esp 109577: 8b b3 a0 00 00 00 mov 0xa0(%ebx),%esi 10957d: 85 f6 test %esi,%esi 10957f: 74 4b je 1095cc 109581: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) 109588: 74 42 je 1095cc (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)) rtems_semaphore_delete (tty->rawInBuf.Semaphore); free (tty->rawInBuf.theBuf); 10958a: 83 ec 0c sub $0xc,%esp 10958d: ff 73 58 pushl 0x58(%ebx) 109590: e8 1f eb ff ff call 1080b4 free (tty->rawOutBuf.theBuf); 109595: 59 pop %ecx 109596: ff 73 7c pushl 0x7c(%ebx) 109599: e8 16 eb ff ff call 1080b4 free (tty->cbuf); 10959e: 5a pop %edx 10959f: ff 73 1c pushl 0x1c(%ebx) 1095a2: e8 0d eb ff ff call 1080b4 free (tty); 1095a7: 89 1c 24 mov %ebx,(%esp) 1095aa: e8 05 eb ff ff call 1080b4 1095af: 83 c4 10 add $0x10,%esp } rtems_semaphore_release (rtems_termios_ttyMutex); 1095b2: 83 ec 0c sub $0xc,%esp 1095b5: ff 35 6c 7c 12 00 pushl 0x127c6c 1095bb: e8 ec 21 00 00 call 10b7ac return RTEMS_SUCCESSFUL; } 1095c0: 31 c0 xor %eax,%eax 1095c2: 8d 65 f8 lea -0x8(%ebp),%esp 1095c5: 5b pop %ebx 1095c6: 5e pop %esi 1095c7: c9 leave 1095c8: c3 ret 1095c9: 8d 76 00 lea 0x0(%esi),%esi rtems_semaphore_delete (tty->isem); rtems_semaphore_delete (tty->osem); rtems_semaphore_delete (tty->rawOutBuf.Semaphore); if ((tty->device.pollRead == NULL) || (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)) rtems_semaphore_delete (tty->rawInBuf.Semaphore); 1095cc: 83 ec 0c sub $0xc,%esp 1095cf: ff 73 68 pushl 0x68(%ebx) 1095d2: e8 35 20 00 00 call 10b60c 1095d7: 83 c4 10 add $0x10,%esp 1095da: eb ae jmp 10958a } else { tty->forw->back = tty->back; } if (tty->back == NULL) { rtems_termios_ttyHead = tty->forw; 1095dc: a3 74 7c 12 00 mov %eax,0x127c74 if ( rtems_termios_ttyHead != NULL ) { 1095e1: 85 c0 test %eax,%eax 1095e3: 0f 84 6b ff ff ff je 109554 rtems_termios_ttyHead->back = NULL; 1095e9: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) 1095f0: e9 5f ff ff ff jmp 109554 1095f5: 8d 76 00 lea 0x0(%esi),%esi rtems_fatal_error_occurred (sc); } if (tty->device.lastClose) (*tty->device.lastClose)(tty->major, tty->minor, arg); if (tty->forw == NULL) { rtems_termios_ttyTail = tty->back; 1095f8: 8b 53 04 mov 0x4(%ebx),%edx 1095fb: 89 15 70 7c 12 00 mov %edx,0x127c70 if ( rtems_termios_ttyTail != NULL ) { 109601: 85 d2 test %edx,%edx 109603: 74 d7 je 1095dc rtems_termios_ttyTail->forw = NULL; 109605: c7 02 00 00 00 00 movl $0x0,(%edx) 10960b: 8b 03 mov (%ebx),%eax 10960d: e9 40 ff ff ff jmp 109552 109612: 66 90 xchg %ax,%ax sc = rtems_termios_linesw[tty->t_line].l_close(tty); } else { /* * default: just flush output buffer */ sc = rtems_semaphore_obtain(tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 109614: 50 push %eax 109615: 6a 00 push $0x0 109617: 6a 00 push $0x0 109619: ff 73 18 pushl 0x18(%ebx) 10961c: e8 8f 20 00 00 call 10b6b0 if (sc != RTEMS_SUCCESSFUL) { 109621: 83 c4 10 add $0x10,%esp 109624: 85 c0 test %eax,%eax 109626: 75 56 jne 10967e <== NEVER TAKEN rtems_fatal_error_occurred (sc); } drainOutput (tty); 109628: 89 d8 mov %ebx,%eax 10962a: e8 75 f9 ff ff call 108fa4 rtems_semaphore_release (tty->osem); 10962f: 83 ec 0c sub $0xc,%esp 109632: ff 73 18 pushl 0x18(%ebx) 109635: e8 72 21 00 00 call 10b7ac 10963a: 83 c4 10 add $0x10,%esp } if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 10963d: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) 109644: 0f 85 d6 fe ff ff jne 109520 10964a: 66 90 xchg %ax,%ax /* * send "terminate" to I/O tasks */ sc = rtems_event_send( tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT ); 10964c: 83 ec 08 sub $0x8,%esp 10964f: 6a 01 push $0x1 109651: ff b3 c4 00 00 00 pushl 0xc4(%ebx) 109657: e8 40 1b 00 00 call 10b19c if (sc != RTEMS_SUCCESSFUL) 10965c: 83 c4 10 add $0x10,%esp 10965f: 85 c0 test %eax,%eax 109661: 75 1b jne 10967e <== NEVER TAKEN rtems_fatal_error_occurred (sc); sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT ); 109663: 83 ec 08 sub $0x8,%esp 109666: 6a 01 push $0x1 109668: ff b3 c8 00 00 00 pushl 0xc8(%ebx) 10966e: e8 29 1b 00 00 call 10b19c if (sc != RTEMS_SUCCESSFUL) 109673: 83 c4 10 add $0x10,%esp 109676: 85 c0 test %eax,%eax 109678: 0f 84 a2 fe ff ff je 109520 <== ALWAYS TAKEN rtems_fatal_error_occurred (sc); 10967e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109681: 50 push %eax <== NOT EXECUTED 109682: e8 6d 26 00 00 call 10bcf4 <== NOT EXECUTED =============================================================================== 0010ab64 : * for each transmitted character. * It returns number of characters left to transmit */ int rtems_termios_dequeue_characters (void *ttyp, int len) { 10ab64: 55 push %ebp 10ab65: 89 e5 mov %esp,%ebp 10ab67: 83 ec 08 sub $0x8,%esp 10ab6a: 8b 45 08 mov 0x8(%ebp),%eax rtems_status_code sc; /* * sum up character count already sent */ tty->t_dqlen += len; 10ab6d: 8b 55 0c mov 0xc(%ebp),%edx 10ab70: 01 90 90 00 00 00 add %edx,0x90(%eax) if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 10ab76: 83 b8 b4 00 00 00 02 cmpl $0x2,0xb4(%eax) 10ab7d: 74 2d je 10abac if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); return 0; /* nothing to output in IRQ... */ } if (tty->t_line == PPPDISC ) { 10ab7f: 83 b8 cc 00 00 00 05 cmpl $0x5,0xcc(%eax) 10ab86: 74 0c je 10ab94 rtems_termios_linesw[tty->t_line].l_start(tty); } return 0; /* nothing to output in IRQ... */ } return rtems_termios_refill_transmitter(tty); 10ab88: 89 45 08 mov %eax,0x8(%ebp) } 10ab8b: c9 leave rtems_termios_linesw[tty->t_line].l_start(tty); } return 0; /* nothing to output in IRQ... */ } return rtems_termios_refill_transmitter(tty); 10ab8c: e9 27 fd ff ff jmp 10a8b8 10ab91: 8d 76 00 lea 0x0(%esi),%esi if (tty->t_line == PPPDISC ) { /* * call any line discipline start function */ if (rtems_termios_linesw[tty->t_line].l_start != NULL) { 10ab94: 8b 15 b4 79 12 00 mov 0x1279b4,%edx 10ab9a: 85 d2 test %edx,%edx 10ab9c: 74 09 je 10aba7 <== NEVER TAKEN rtems_termios_linesw[tty->t_line].l_start(tty); 10ab9e: 83 ec 0c sub $0xc,%esp 10aba1: 50 push %eax 10aba2: ff d2 call *%edx 10aba4: 83 c4 10 add $0x10,%esp } return 0; /* nothing to output in IRQ... */ } return rtems_termios_refill_transmitter(tty); } 10aba7: 31 c0 xor %eax,%eax 10aba9: c9 leave 10abaa: c3 ret 10abab: 90 nop if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { /* * send wake up to transmitter task */ sc = rtems_event_send(tty->txTaskId, TERMIOS_TX_START_EVENT); 10abac: 83 ec 08 sub $0x8,%esp 10abaf: 6a 02 push $0x2 10abb1: ff b0 c8 00 00 00 pushl 0xc8(%eax) 10abb7: e8 e0 05 00 00 call 10b19c if (sc != RTEMS_SUCCESSFUL) 10abbc: 83 c4 10 add $0x10,%esp 10abbf: 85 c0 test %eax,%eax 10abc1: 74 e4 je 10aba7 <== ALWAYS TAKEN rtems_fatal_error_occurred (sc); 10abc3: 83 ec 0c sub $0xc,%esp 10abc6: 50 push %eax <== NOT EXECUTED 10abc7: e8 28 11 00 00 call 10bcf4 <== NOT EXECUTED =============================================================================== 0010a540 : * device receive interrupt handler. * Returns the number of characters dropped because of overflow. */ int rtems_termios_enqueue_raw_characters (void *ttyp, char *buf, int len) { 10a540: 55 push %ebp 10a541: 89 e5 mov %esp,%ebp 10a543: 57 push %edi 10a544: 56 push %esi 10a545: 53 push %ebx 10a546: 83 ec 3c sub $0x3c,%esp 10a549: 8b 5d 08 mov 0x8(%ebp),%ebx 10a54c: 8b 75 0c mov 0xc(%ebp),%esi char c; int dropped = 0; bool flow_rcv = false; /* true, if flow control char received */ rtems_interrupt_level level; if (rtems_termios_linesw[tty->t_line].l_rint != NULL) { 10a54f: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax 10a555: c1 e0 05 shl $0x5,%eax 10a558: 8b 80 10 79 12 00 mov 0x127910(%eax),%eax 10a55e: 85 c0 test %eax,%eax 10a560: 0f 84 8a 00 00 00 je 10a5f0 while (len--) { 10a566: 8b 4d 10 mov 0x10(%ebp),%ecx 10a569: 85 c9 test %ecx,%ecx 10a56b: 74 2a je 10a597 <== NEVER TAKEN 10a56d: 31 ff xor %edi,%edi 10a56f: eb 12 jmp 10a583 10a571: 8d 76 00 lea 0x0(%esi),%esi 10a574: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax 10a57a: c1 e0 05 shl $0x5,%eax 10a57d: 8b 80 10 79 12 00 mov 0x127910(%eax),%eax c = *buf++; rtems_termios_linesw[tty->t_line].l_rint(c,tty); 10a583: 83 ec 08 sub $0x8,%esp 10a586: 53 push %ebx 10a587: 0f be 14 3e movsbl (%esi,%edi,1),%edx 10a58b: 52 push %edx 10a58c: ff d0 call *%eax 10a58e: 47 inc %edi int dropped = 0; bool flow_rcv = false; /* true, if flow control char received */ rtems_interrupt_level level; if (rtems_termios_linesw[tty->t_line].l_rint != NULL) { while (len--) { 10a58f: 83 c4 10 add $0x10,%esp 10a592: 3b 7d 10 cmp 0x10(%ebp),%edi 10a595: 75 dd jne 10a574 } /* * check to see if rcv wakeup callback was set */ if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) { 10a597: 8b 93 e4 00 00 00 mov 0xe4(%ebx),%edx 10a59d: 85 d2 test %edx,%edx 10a59f: 75 3b jne 10a5dc <== NEVER TAKEN 10a5a1: 8b 83 dc 00 00 00 mov 0xdc(%ebx),%eax 10a5a7: 85 c0 test %eax,%eax 10a5a9: 74 31 je 10a5dc <== NEVER TAKEN (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg); 10a5ab: 83 ec 08 sub $0x8,%esp 10a5ae: ff b3 e0 00 00 00 pushl 0xe0(%ebx) 10a5b4: 8d 53 30 lea 0x30(%ebx),%edx 10a5b7: 52 push %edx 10a5b8: ff d0 call *%eax tty->tty_rcvwakeup = 1; 10a5ba: c7 83 e4 00 00 00 01 movl $0x1,0xe4(%ebx) 10a5c1: 00 00 00 10a5c4: 83 c4 10 add $0x10,%esp } return 0; 10a5c7: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) } tty->rawInBufDropped += dropped; rtems_semaphore_release (tty->rawInBuf.Semaphore); return dropped; } 10a5ce: 8b 45 e0 mov -0x20(%ebp),%eax 10a5d1: 8d 65 f4 lea -0xc(%ebp),%esp 10a5d4: 5b pop %ebx 10a5d5: 5e pop %esi 10a5d6: 5f pop %edi 10a5d7: c9 leave 10a5d8: c3 ret 10a5d9: 8d 76 00 lea 0x0(%esi),%esi */ if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) { (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg); tty->tty_rcvwakeup = 1; } return 0; 10a5dc: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED } tty->rawInBufDropped += dropped; rtems_semaphore_release (tty->rawInBuf.Semaphore); return dropped; } 10a5e3: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 10a5e6: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a5e9: 5b pop %ebx <== NOT EXECUTED 10a5ea: 5e pop %esi <== NOT EXECUTED 10a5eb: 5f pop %edi <== NOT EXECUTED 10a5ec: c9 leave <== NOT EXECUTED 10a5ed: c3 ret <== NOT EXECUTED 10a5ee: 66 90 xchg %ax,%ax <== NOT EXECUTED char c; int dropped = 0; bool flow_rcv = false; /* true, if flow control char received */ rtems_interrupt_level level; if (rtems_termios_linesw[tty->t_line].l_rint != NULL) { 10a5f0: 8b 7d 10 mov 0x10(%ebp),%edi 10a5f3: c6 45 db 00 movb $0x0,-0x25(%ebp) 10a5f7: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) /* * check to see if rcv wakeup callback was set */ if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) { (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg); 10a5fe: 8d 43 30 lea 0x30(%ebx),%eax 10a601: 89 45 d0 mov %eax,-0x30(%ebp) if ((tty->flow_ctrl & FL_OSTOP) || (tty->rawOutBufState == rob_idle)) { /* if tx is stopped due to XOFF or out of data */ /* call write function here */ tty->flow_ctrl |= FL_ISNTXOF; (*tty->device.write)(tty->minor, 10a604: 8d 53 4a lea 0x4a(%ebx),%edx 10a607: 89 55 cc mov %edx,-0x34(%ebp) tty->tty_rcvwakeup = 1; } return 0; } while (len--) { 10a60a: 85 ff test %edi,%edi 10a60c: 0f 84 0b 01 00 00 je 10a71d <== NEVER TAKEN 10a612: 66 90 xchg %ax,%ax c = *buf++; 10a614: 8a 06 mov (%esi),%al 10a616: 88 45 e7 mov %al,-0x19(%ebp) 10a619: 46 inc %esi /* FIXME: implement IXANY: any character restarts output */ /* if incoming XON/XOFF controls outgoing stream: */ if (tty->flow_ctrl & FL_MDXON) { 10a61a: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 10a620: f6 c4 02 test $0x2,%ah 10a623: 74 1c je 10a641 /* if received char is V_STOP and V_START (both are equal value) */ if (c == tty->termios.c_cc[VSTOP]) { 10a625: 0f be 45 e7 movsbl -0x19(%ebp),%eax 10a629: 0f b6 53 4a movzbl 0x4a(%ebx),%edx 10a62d: 39 d0 cmp %edx,%eax 10a62f: 0f 84 07 01 00 00 je 10a73c /* stop output */ tty->flow_ctrl |= FL_ORCVXOF; } flow_rcv = true; } else if (c == tty->termios.c_cc[VSTART]) { 10a635: 0f b6 53 49 movzbl 0x49(%ebx),%edx 10a639: 39 d0 cmp %edx,%eax 10a63b: 0f 84 4f 01 00 00 je 10a790 <== NEVER TAKEN /* restart output */ tty->flow_ctrl &= ~FL_ORCVXOF; flow_rcv = true; } } if (flow_rcv) { 10a641: 80 7d db 00 cmpb $0x0,-0x25(%ebp) 10a645: 0f 85 0c 01 00 00 jne 10a757 <== NEVER TAKEN } /* reenable interrupts */ rtems_interrupt_enable(level); } } else { newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size; 10a64b: 8b 43 60 mov 0x60(%ebx),%eax 10a64e: 8b 53 64 mov 0x64(%ebx),%edx 10a651: 89 55 dc mov %edx,-0x24(%ebp) 10a654: 40 inc %eax 10a655: 31 d2 xor %edx,%edx 10a657: f7 75 dc divl -0x24(%ebp) 10a65a: 89 d1 mov %edx,%ecx /* if chars_in_buffer > highwater */ rtems_interrupt_disable(level); 10a65c: 9c pushf 10a65d: fa cli 10a65e: 8f 45 d4 popl -0x2c(%ebp) if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size) 10a661: 8b 43 5c mov 0x5c(%ebx),%eax 10a664: 89 45 c4 mov %eax,-0x3c(%ebp) 10a667: 8b 43 64 mov 0x64(%ebx),%eax % tty->rawInBuf.Size) > tty->highwater) && 10a66a: 8b 53 64 mov 0x64(%ebx),%edx 10a66d: 89 55 dc mov %edx,-0x24(%ebp) } } else { newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size; /* if chars_in_buffer > highwater */ rtems_interrupt_disable(level); if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size) 10a670: 2b 45 c4 sub -0x3c(%ebp),%eax 10a673: 01 c8 add %ecx,%eax % tty->rawInBuf.Size) > tty->highwater) && 10a675: 31 d2 xor %edx,%edx 10a677: f7 75 dc divl -0x24(%ebp) } } else { newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size; /* if chars_in_buffer > highwater */ rtems_interrupt_disable(level); if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size) 10a67a: 3b 93 c0 00 00 00 cmp 0xc0(%ebx),%edx 10a680: 76 46 jbe 10a6c8 <== ALWAYS TAKEN % tty->rawInBuf.Size) > tty->highwater) && !(tty->flow_ctrl & FL_IREQXOF)) { 10a682: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED } else { newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size; /* if chars_in_buffer > highwater */ rtems_interrupt_disable(level); if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size) % tty->rawInBuf.Size) > tty->highwater) && 10a688: a8 01 test $0x1,%al <== NOT EXECUTED 10a68a: 75 3c jne 10a6c8 <== NOT EXECUTED !(tty->flow_ctrl & FL_IREQXOF)) { /* incoming data stream should be stopped */ tty->flow_ctrl |= FL_IREQXOF; 10a68c: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10a692: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10a695: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF)) 10a69b: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10a6a1: 25 02 04 00 00 and $0x402,%eax <== NOT EXECUTED 10a6a6: 3d 00 04 00 00 cmp $0x400,%eax <== NOT EXECUTED 10a6ab: 0f 84 22 01 00 00 je 10a7d3 <== NOT EXECUTED /* call write function here */ tty->flow_ctrl |= FL_ISNTXOF; (*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1); } } else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) { 10a6b1: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10a6b7: 25 04 01 00 00 and $0x104,%eax <== NOT EXECUTED 10a6bc: 3d 00 01 00 00 cmp $0x100,%eax <== NOT EXECUTED 10a6c1: 0f 84 50 01 00 00 je 10a817 <== NOT EXECUTED 10a6c7: 90 nop <== NOT EXECUTED } } } /* reenable interrupts */ rtems_interrupt_enable(level); 10a6c8: ff 75 d4 pushl -0x2c(%ebp) 10a6cb: 9d popf if (newTail == tty->rawInBuf.Head) { 10a6cc: 8b 43 5c mov 0x5c(%ebx),%eax 10a6cf: 39 c8 cmp %ecx,%eax 10a6d1: 0f 84 b1 00 00 00 je 10a788 <== NEVER TAKEN dropped++; } else { tty->rawInBuf.theBuf[newTail] = c; 10a6d7: 8b 43 58 mov 0x58(%ebx),%eax 10a6da: 8a 55 e7 mov -0x19(%ebp),%dl 10a6dd: 88 14 08 mov %dl,(%eax,%ecx,1) tty->rawInBuf.Tail = newTail; 10a6e0: 89 4b 60 mov %ecx,0x60(%ebx) /* * check to see if rcv wakeup callback was set */ if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) { 10a6e3: 8b 83 e4 00 00 00 mov 0xe4(%ebx),%eax 10a6e9: 85 c0 test %eax,%eax 10a6eb: 75 27 jne 10a714 <== NEVER TAKEN 10a6ed: 8b 83 dc 00 00 00 mov 0xdc(%ebx),%eax 10a6f3: 85 c0 test %eax,%eax 10a6f5: 74 1d je 10a714 <== ALWAYS TAKEN (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg); 10a6f7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a6fa: ff b3 e0 00 00 00 pushl 0xe0(%ebx) <== NOT EXECUTED 10a700: ff 75 d0 pushl -0x30(%ebp) <== NOT EXECUTED 10a703: ff d0 call *%eax <== NOT EXECUTED tty->tty_rcvwakeup = 1; 10a705: c7 83 e4 00 00 00 01 movl $0x1,0xe4(%ebx) <== NOT EXECUTED 10a70c: 00 00 00 10a70f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a712: 66 90 xchg %ax,%ax <== NOT EXECUTED 10a714: 4f dec %edi tty->tty_rcvwakeup = 1; } return 0; } while (len--) { 10a715: 85 ff test %edi,%edi 10a717: 0f 85 f7 fe ff ff jne 10a614 <== NEVER TAKEN } } } } tty->rawInBufDropped += dropped; 10a71d: 8b 45 e0 mov -0x20(%ebp),%eax 10a720: 01 43 78 add %eax,0x78(%ebx) rtems_semaphore_release (tty->rawInBuf.Semaphore); 10a723: 83 ec 0c sub $0xc,%esp 10a726: ff 73 68 pushl 0x68(%ebx) 10a729: e8 7e 10 00 00 call 10b7ac return dropped; 10a72e: 83 c4 10 add $0x10,%esp } 10a731: 8b 45 e0 mov -0x20(%ebp),%eax 10a734: 8d 65 f4 lea -0xc(%ebp),%esp 10a737: 5b pop %ebx 10a738: 5e pop %esi 10a739: 5f pop %edi 10a73a: c9 leave 10a73b: c3 ret /* FIXME: implement IXANY: any character restarts output */ /* if incoming XON/XOFF controls outgoing stream: */ if (tty->flow_ctrl & FL_MDXON) { /* if received char is V_STOP and V_START (both are equal value) */ if (c == tty->termios.c_cc[VSTOP]) { if (c == tty->termios.c_cc[VSTART]) { 10a73c: 0f b6 53 49 movzbl 0x49(%ebx),%edx 10a740: 39 d0 cmp %edx,%eax 10a742: 74 7e je 10a7c2 <== NEVER TAKEN tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF; } else { /* VSTOP received (other code than VSTART) */ /* stop output */ tty->flow_ctrl |= FL_ORCVXOF; 10a744: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 10a74a: 83 c8 10 or $0x10,%eax 10a74d: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) int dropped = 0; bool flow_rcv = false; /* true, if flow control char received */ rtems_interrupt_level level; if (rtems_termios_linesw[tty->t_line].l_rint != NULL) { while (len--) { 10a753: c6 45 db 01 movb $0x1,-0x25(%ebp) flow_rcv = true; } } if (flow_rcv) { /* restart output according to FL_ORCVXOF flag */ if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) { 10a757: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 10a75d: 83 e0 30 and $0x30,%eax 10a760: 83 f8 20 cmp $0x20,%eax 10a763: 75 af jne 10a714 <== ALWAYS TAKEN /* disable interrupts */ rtems_interrupt_disable(level); 10a765: 9c pushf <== NOT EXECUTED 10a766: fa cli <== NOT EXECUTED 10a767: 5a pop %edx <== NOT EXECUTED tty->flow_ctrl &= ~FL_OSTOP; 10a768: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10a76e: 83 e0 df and $0xffffffdf,%eax <== NOT EXECUTED 10a771: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED /* check for chars in output buffer (or rob_state?) */ if (tty->rawOutBufState != rob_idle) { 10a777: 8b 83 94 00 00 00 mov 0x94(%ebx),%eax <== NOT EXECUTED 10a77d: 85 c0 test %eax,%eax <== NOT EXECUTED 10a77f: 75 20 jne 10a7a1 <== NOT EXECUTED /* if chars available, call write function... */ (*tty->device.write)( tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1); } /* reenable interrupts */ rtems_interrupt_enable(level); 10a781: 52 push %edx <== NOT EXECUTED 10a782: 9d popf <== NOT EXECUTED /* * check to see if rcv wakeup callback was set */ if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) { (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg); tty->tty_rcvwakeup = 1; 10a783: 4f dec %edi <== NOT EXECUTED 10a784: eb 8f jmp 10a715 <== NOT EXECUTED 10a786: 66 90 xchg %ax,%ax <== NOT EXECUTED /* reenable interrupts */ rtems_interrupt_enable(level); if (newTail == tty->rawInBuf.Head) { dropped++; 10a788: ff 45 e0 incl -0x20(%ebp) <== NOT EXECUTED /* * check to see if rcv wakeup callback was set */ if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) { (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg); tty->tty_rcvwakeup = 1; 10a78b: 4f dec %edi <== NOT EXECUTED 10a78c: eb 87 jmp 10a715 <== NOT EXECUTED 10a78e: 66 90 xchg %ax,%ax <== NOT EXECUTED flow_rcv = true; } else if (c == tty->termios.c_cc[VSTART]) { /* VSTART received */ /* restart output */ tty->flow_ctrl &= ~FL_ORCVXOF; 10a790: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10a796: 83 e0 ef and $0xffffffef,%eax <== NOT EXECUTED 10a799: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED 10a79f: eb b2 jmp 10a753 <== NOT EXECUTED tty->flow_ctrl &= ~FL_OSTOP; /* check for chars in output buffer (or rob_state?) */ if (tty->rawOutBufState != rob_idle) { /* if chars available, call write function... */ (*tty->device.write)( tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1); 10a7a1: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax <== NOT EXECUTED rtems_interrupt_disable(level); tty->flow_ctrl &= ~FL_OSTOP; /* check for chars in output buffer (or rob_state?) */ if (tty->rawOutBufState != rob_idle) { /* if chars available, call write function... */ (*tty->device.write)( 10a7a7: 51 push %ecx <== NOT EXECUTED 10a7a8: 6a 01 push $0x1 <== NOT EXECUTED 10a7aa: 03 43 7c add 0x7c(%ebx),%eax <== NOT EXECUTED 10a7ad: 50 push %eax <== NOT EXECUTED 10a7ae: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 10a7b1: 89 55 c8 mov %edx,-0x38(%ebp) <== NOT EXECUTED 10a7b4: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED 10a7ba: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a7bd: 8b 55 c8 mov -0x38(%ebp),%edx <== NOT EXECUTED 10a7c0: eb bf jmp 10a781 <== NOT EXECUTED /* if received char is V_STOP and V_START (both are equal value) */ if (c == tty->termios.c_cc[VSTOP]) { if (c == tty->termios.c_cc[VSTART]) { /* received VSTOP and VSTART==VSTOP? */ /* then toggle "stop output" status */ tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF; 10a7c2: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10a7c8: 83 f0 10 xor $0x10,%eax <== NOT EXECUTED 10a7cb: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED 10a7d1: eb 80 jmp 10a753 <== NOT EXECUTED !(tty->flow_ctrl & FL_IREQXOF)) { /* incoming data stream should be stopped */ tty->flow_ctrl |= FL_IREQXOF; if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF)) == (FL_MDXOF ) ) { if ((tty->flow_ctrl & FL_OSTOP) || 10a7d3: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10a7d9: a8 20 test $0x20,%al <== NOT EXECUTED 10a7db: 75 0e jne 10a7eb <== NOT EXECUTED 10a7dd: 8b 83 94 00 00 00 mov 0x94(%ebx),%eax <== NOT EXECUTED 10a7e3: 85 c0 test %eax,%eax <== NOT EXECUTED 10a7e5: 0f 85 dd fe ff ff jne 10a6c8 <== NOT EXECUTED (tty->rawOutBufState == rob_idle)) { /* if tx is stopped due to XOFF or out of data */ /* call write function here */ tty->flow_ctrl |= FL_ISNTXOF; 10a7eb: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10a7f1: 83 c8 02 or $0x2,%eax <== NOT EXECUTED 10a7f4: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED (*tty->device.write)(tty->minor, 10a7fa: 52 push %edx <== NOT EXECUTED 10a7fb: 6a 01 push $0x1 <== NOT EXECUTED 10a7fd: ff 75 cc pushl -0x34(%ebp) <== NOT EXECUTED 10a800: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 10a803: 89 4d c8 mov %ecx,-0x38(%ebp) <== NOT EXECUTED 10a806: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED 10a80c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a80f: 8b 4d c8 mov -0x38(%ebp),%ecx <== NOT EXECUTED 10a812: e9 b1 fe ff ff jmp 10a6c8 <== NOT EXECUTED (void *)&(tty->termios.c_cc[VSTOP]), 1); } } else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) { tty->flow_ctrl |= FL_IRTSOFF; 10a817: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10a81d: 83 c8 04 or $0x4,%eax <== NOT EXECUTED 10a820: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED /* deactivate RTS line */ if (tty->device.stopRemoteTx != NULL) { 10a826: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax <== NOT EXECUTED 10a82c: 85 c0 test %eax,%eax <== NOT EXECUTED 10a82e: 0f 84 94 fe ff ff je 10a6c8 <== NOT EXECUTED tty->device.stopRemoteTx(tty->minor); 10a834: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a837: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 10a83a: 89 4d c8 mov %ecx,-0x38(%ebp) <== NOT EXECUTED 10a83d: ff d0 call *%eax <== NOT EXECUTED 10a83f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a842: 8b 4d c8 mov -0x38(%ebp),%ecx <== NOT EXECUTED 10a845: e9 7e fe ff ff jmp 10a6c8 <== NOT EXECUTED =============================================================================== 00108f68 : struct rtems_termios_tty *rtems_termios_ttyTail; rtems_id rtems_termios_ttyMutex; void rtems_termios_initialize (void) { 108f68: 55 push %ebp 108f69: 89 e5 mov %esp,%ebp 108f6b: 83 ec 08 sub $0x8,%esp rtems_status_code sc; /* * Create the mutex semaphore for the tty list */ if (!rtems_termios_ttyMutex) { 108f6e: a1 6c 7c 12 00 mov 0x127c6c,%eax 108f73: 85 c0 test %eax,%eax 108f75: 74 05 je 108f7c RTEMS_NO_PRIORITY, &rtems_termios_ttyMutex); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); } } 108f77: c9 leave 108f78: c3 ret 108f79: 8d 76 00 lea 0x0(%esi),%esi /* * Create the mutex semaphore for the tty list */ if (!rtems_termios_ttyMutex) { sc = rtems_semaphore_create ( 108f7c: 83 ec 0c sub $0xc,%esp 108f7f: 68 6c 7c 12 00 push $0x127c6c 108f84: 6a 00 push $0x0 108f86: 6a 54 push $0x54 108f88: 6a 01 push $0x1 108f8a: 68 69 6d 52 54 push $0x54526d69 108f8f: e8 a0 24 00 00 call 10b434 rtems_build_name ('T', 'R', 'm', 'i'), 1, RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &rtems_termios_ttyMutex); if (sc != RTEMS_SUCCESSFUL) 108f94: 83 c4 20 add $0x20,%esp 108f97: 85 c0 test %eax,%eax 108f99: 74 dc je 108f77 rtems_fatal_error_occurred (sc); 108f9b: 83 ec 0c sub $0xc,%esp 108f9e: 50 push %eax 108f9f: e8 50 2d 00 00 call 10bcf4 =============================================================================== 001096a8 : } } rtems_status_code rtems_termios_ioctl (void *arg) { 1096a8: 55 push %ebp 1096a9: 89 e5 mov %esp,%ebp 1096ab: 57 push %edi 1096ac: 56 push %esi 1096ad: 53 push %ebx 1096ae: 83 ec 20 sub $0x20,%esp 1096b1: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_libio_ioctl_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 1096b4: 8b 03 mov (%ebx),%eax 1096b6: 8b 40 34 mov 0x34(%eax),%eax 1096b9: 89 45 e4 mov %eax,-0x1c(%ebp) struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer; 1096bc: 8b 73 08 mov 0x8(%ebx),%esi rtems_status_code sc; args->ioctl_return = 0; 1096bf: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 1096c6: 6a 00 push $0x0 1096c8: 6a 00 push $0x0 1096ca: ff 70 18 pushl 0x18(%eax) 1096cd: e8 de 1f 00 00 call 10b6b0 1096d2: 89 45 e0 mov %eax,-0x20(%ebp) if (sc != RTEMS_SUCCESSFUL) { 1096d5: 83 c4 10 add $0x10,%esp 1096d8: 85 c0 test %eax,%eax 1096da: 75 24 jne 109700 <== NEVER TAKEN args->ioctl_return = sc; return sc; } switch (args->command) { 1096dc: 8b 43 04 mov 0x4(%ebx),%eax 1096df: 83 f8 04 cmp $0x4,%eax 1096e2: 74 70 je 109754 1096e4: 77 2a ja 109710 1096e6: 83 f8 02 cmp $0x2,%eax 1096e9: 0f 84 9d 00 00 00 je 10978c 1096ef: 0f 86 3f 02 00 00 jbe 109934 if (tty->device.setAttributes) (*tty->device.setAttributes)(tty->minor, &tty->termios); break; case RTEMS_IO_TCDRAIN: drainOutput (tty); 1096f5: 8b 45 e4 mov -0x1c(%ebp),%eax 1096f8: e8 a7 f8 ff ff call 108fa4 break; 1096fd: eb 69 jmp 109768 1096ff: 90 nop rtems_status_code sc; args->ioctl_return = 0; sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) { args->ioctl_return = sc; 109700: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED } rtems_semaphore_release (tty->osem); args->ioctl_return = sc; return sc; } 109703: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 109706: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109709: 5b pop %ebx <== NOT EXECUTED 10970a: 5e pop %esi <== NOT EXECUTED 10970b: 5f pop %edi <== NOT EXECUTED 10970c: c9 leave <== NOT EXECUTED 10970d: c3 ret <== NOT EXECUTED 10970e: 66 90 xchg %ax,%ax <== NOT EXECUTED sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) { args->ioctl_return = sc; return sc; } switch (args->command) { 109710: 3d 7f 66 04 40 cmp $0x4004667f,%eax 109715: 0f 84 f1 01 00 00 je 10990c <== NEVER TAKEN 10971b: 0f 87 33 02 00 00 ja 109954 109721: 83 f8 05 cmp $0x5,%eax 109724: 0f 84 ae 02 00 00 je 1099d8 default: if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) { 10972a: 8b 55 e4 mov -0x1c(%ebp),%edx 10972d: 8b 82 cc 00 00 00 mov 0xcc(%edx),%eax 109733: c1 e0 05 shl $0x5,%eax 109736: 8b 80 18 79 12 00 mov 0x127918(%eax),%eax 10973c: 85 c0 test %eax,%eax 10973e: 0f 84 b8 02 00 00 je 1099fc <== NEVER TAKEN sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args); 109744: 83 ec 08 sub $0x8,%esp 109747: 53 push %ebx 109748: 52 push %edx 109749: ff d0 call *%eax 10974b: 89 45 e0 mov %eax,-0x20(%ebp) 10974e: 83 c4 10 add $0x10,%esp 109751: eb 15 jmp 109768 109753: 90 nop case RTEMS_IO_SNDWAKEUP: tty->tty_snd = *wakeup; break; case RTEMS_IO_RCVWAKEUP: tty->tty_rcv = *wakeup; 109754: 8b 06 mov (%esi),%eax 109756: 8b 56 04 mov 0x4(%esi),%edx 109759: 8b 4d e4 mov -0x1c(%ebp),%ecx 10975c: 89 81 dc 00 00 00 mov %eax,0xdc(%ecx) 109762: 89 91 e0 00 00 00 mov %edx,0xe0(%ecx) *(int *)args->buffer = tty->ccount - tty->cindex + rawnc; } break; } rtems_semaphore_release (tty->osem); 109768: 83 ec 0c sub $0xc,%esp 10976b: 8b 45 e4 mov -0x1c(%ebp),%eax 10976e: ff 70 18 pushl 0x18(%eax) 109771: e8 36 20 00 00 call 10b7ac args->ioctl_return = sc; 109776: 8b 55 e0 mov -0x20(%ebp),%edx 109779: 89 53 0c mov %edx,0xc(%ebx) return sc; 10977c: 83 c4 10 add $0x10,%esp } 10977f: 8b 45 e0 mov -0x20(%ebp),%eax 109782: 8d 65 f4 lea -0xc(%ebp),%esp 109785: 5b pop %ebx 109786: 5e pop %esi 109787: 5f pop %edi 109788: c9 leave 109789: c3 ret 10978a: 66 90 xchg %ax,%ax case RTEMS_IO_GET_ATTRIBUTES: *(struct termios *)args->buffer = tty->termios; break; case RTEMS_IO_SET_ATTRIBUTES: tty->termios = *(struct termios *)args->buffer; 10978c: 8b 73 08 mov 0x8(%ebx),%esi 10978f: 8b 4d e4 mov -0x1c(%ebp),%ecx 109792: 83 c1 30 add $0x30,%ecx 109795: 89 4d dc mov %ecx,-0x24(%ebp) 109798: b9 09 00 00 00 mov $0x9,%ecx 10979d: 8b 7d dc mov -0x24(%ebp),%edi 1097a0: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* * check for flow control options to be switched off */ /* check for outgoing XON/XOFF flow control switched off */ if (( tty->flow_ctrl & FL_MDXON) && 1097a2: 8b 55 e4 mov -0x1c(%ebp),%edx 1097a5: 8b 82 b8 00 00 00 mov 0xb8(%edx),%eax 1097ab: f6 c4 02 test $0x2,%ah 1097ae: 74 44 je 1097f4 1097b0: f6 42 31 04 testb $0x4,0x31(%edx) 1097b4: 75 3e jne 1097f4 !(tty->termios.c_iflag & IXON)) { /* clear related flags in flow_ctrl */ tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF); 1097b6: 8b 82 b8 00 00 00 mov 0xb8(%edx),%eax 1097bc: 25 ef fd ff ff and $0xfffffdef,%eax 1097c1: 89 82 b8 00 00 00 mov %eax,0xb8(%edx) /* has output been stopped due to received XOFF? */ if (tty->flow_ctrl & FL_OSTOP) { 1097c7: 8b 82 b8 00 00 00 mov 0xb8(%edx),%eax 1097cd: a8 20 test $0x20,%al 1097cf: 74 23 je 1097f4 <== ALWAYS TAKEN /* disable interrupts */ rtems_interrupt_disable(level); 1097d1: 9c pushf <== NOT EXECUTED 1097d2: fa cli <== NOT EXECUTED 1097d3: 5e pop %esi <== NOT EXECUTED tty->flow_ctrl &= ~FL_OSTOP; 1097d4: 8b 82 b8 00 00 00 mov 0xb8(%edx),%eax <== NOT EXECUTED 1097da: 83 e0 df and $0xffffffdf,%eax <== NOT EXECUTED 1097dd: 89 82 b8 00 00 00 mov %eax,0xb8(%edx) <== NOT EXECUTED /* check for chars in output buffer (or rob_state?) */ if (tty->rawOutBufState != rob_idle) { 1097e3: 8b ba 94 00 00 00 mov 0x94(%edx),%edi <== NOT EXECUTED 1097e9: 85 ff test %edi,%edi <== NOT EXECUTED 1097eb: 0f 85 bb 02 00 00 jne 109aac <== NOT EXECUTED /* if chars available, call write function... */ (*tty->device.write)( tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1); } /* reenable interrupts */ rtems_interrupt_enable(level); 1097f1: 56 push %esi <== NOT EXECUTED 1097f2: 9d popf <== NOT EXECUTED 1097f3: 90 nop <== NOT EXECUTED } } /* check for incoming XON/XOFF flow control switched off */ if (( tty->flow_ctrl & FL_MDXOF) && !(tty->termios.c_iflag & IXOFF)) { 1097f4: 8b 4d e4 mov -0x1c(%ebp),%ecx 1097f7: 8b 81 b8 00 00 00 mov 0xb8(%ecx),%eax 1097fd: f6 c4 04 test $0x4,%ah 109800: 74 24 je 109826 109802: f6 41 31 10 testb $0x10,0x31(%ecx) 109806: 75 1e jne 109826 /* clear related flags in flow_ctrl */ tty->flow_ctrl &= ~(FL_MDXOF); 109808: 8b 81 b8 00 00 00 mov 0xb8(%ecx),%eax 10980e: 80 e4 fb and $0xfb,%ah 109811: 89 81 b8 00 00 00 mov %eax,0xb8(%ecx) /* FIXME: what happens, if we had sent XOFF but not yet XON? */ tty->flow_ctrl &= ~(FL_ISNTXOF); 109817: 8b 81 b8 00 00 00 mov 0xb8(%ecx),%eax 10981d: 83 e0 fd and $0xfffffffd,%eax 109820: 89 81 b8 00 00 00 mov %eax,0xb8(%ecx) } /* check for incoming RTS/CTS flow control switched off */ if (( tty->flow_ctrl & FL_MDRTS) && !(tty->termios.c_cflag & CRTSCTS)) { 109826: 8b 55 e4 mov -0x1c(%ebp),%edx 109829: 8b 82 b8 00 00 00 mov 0xb8(%edx),%eax 10982f: f6 c4 01 test $0x1,%ah 109832: 0f 84 bc 01 00 00 je 1099f4 <== ALWAYS TAKEN 109838: 8b 4d e4 mov -0x1c(%ebp),%ecx <== NOT EXECUTED 10983b: 8b 41 38 mov 0x38(%ecx),%eax <== NOT EXECUTED 10983e: 85 c0 test %eax,%eax <== NOT EXECUTED 109840: 0f 88 12 02 00 00 js 109a58 <== NOT EXECUTED /* clear related flags in flow_ctrl */ tty->flow_ctrl &= ~(FL_MDRTS); 109846: 8b 91 b8 00 00 00 mov 0xb8(%ecx),%edx <== NOT EXECUTED 10984c: 80 e6 fe and $0xfe,%dh <== NOT EXECUTED 10984f: 89 91 b8 00 00 00 mov %edx,0xb8(%ecx) <== NOT EXECUTED /* restart remote Tx, if it was stopped */ if ((tty->flow_ctrl & FL_IRTSOFF) && (tty->device.startRemoteTx != NULL)) { 109855: 8b 91 b8 00 00 00 mov 0xb8(%ecx),%edx <== NOT EXECUTED 10985b: 83 e2 04 and $0x4,%edx <== NOT EXECUTED 10985e: 74 1b je 10987b <== NOT EXECUTED 109860: 8b 91 b0 00 00 00 mov 0xb0(%ecx),%edx <== NOT EXECUTED 109866: 85 d2 test %edx,%edx <== NOT EXECUTED 109868: 74 11 je 10987b <== NOT EXECUTED tty->device.startRemoteTx(tty->minor); 10986a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10986d: ff 71 10 pushl 0x10(%ecx) <== NOT EXECUTED 109870: ff d2 call *%edx <== NOT EXECUTED 109872: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED 109875: 8b 42 38 mov 0x38(%edx),%eax <== NOT EXECUTED 109878: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } tty->flow_ctrl &= ~(FL_IRTSOFF); 10987b: 8b 4d e4 mov -0x1c(%ebp),%ecx <== NOT EXECUTED 10987e: 8b 91 b8 00 00 00 mov 0xb8(%ecx),%edx <== NOT EXECUTED 109884: 83 e2 fb and $0xfffffffb,%edx <== NOT EXECUTED 109887: 89 91 b8 00 00 00 mov %edx,0xb8(%ecx) <== NOT EXECUTED /* * check for flow control options to be switched on */ /* check for incoming RTS/CTS flow control switched on */ if (tty->termios.c_cflag & CRTSCTS) { 10988d: 85 c0 test %eax,%eax 10988f: 0f 88 c3 01 00 00 js 109a58 <== NEVER TAKEN tty->flow_ctrl |= FL_MDRTS; } /* check for incoming XON/XOF flow control switched on */ if (tty->termios.c_iflag & IXOFF) { 109895: 8b 4d e4 mov -0x1c(%ebp),%ecx 109898: 8b 41 30 mov 0x30(%ecx),%eax 10989b: f6 c4 10 test $0x10,%ah 10989e: 74 0f je 1098af tty->flow_ctrl |= FL_MDXOF; 1098a0: 8b 91 b8 00 00 00 mov 0xb8(%ecx),%edx 1098a6: 80 ce 04 or $0x4,%dh 1098a9: 89 91 b8 00 00 00 mov %edx,0xb8(%ecx) } /* check for outgoing XON/XOF flow control switched on */ if (tty->termios.c_iflag & IXON) { 1098af: f6 c4 04 test $0x4,%ah 1098b2: 74 12 je 1098c6 tty->flow_ctrl |= FL_MDXON; 1098b4: 8b 55 e4 mov -0x1c(%ebp),%edx 1098b7: 8b 82 b8 00 00 00 mov 0xb8(%edx),%eax 1098bd: 80 cc 02 or $0x2,%ah 1098c0: 89 82 b8 00 00 00 mov %eax,0xb8(%edx) tty->termios = *(struct termios *)args->buffer; /* check for and process change in flow control options */ termios_set_flowctrl(tty); if (tty->termios.c_lflag & ICANON) { 1098c6: 8b 4d e4 mov -0x1c(%ebp),%ecx 1098c9: f6 41 3c 02 testb $0x2,0x3c(%ecx) 1098cd: 0f 84 41 01 00 00 je 109a14 tty->rawInBufSemaphoreOptions = RTEMS_WAIT; 1098d3: c7 41 6c 00 00 00 00 movl $0x0,0x6c(%ecx) tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT; 1098da: c7 41 70 00 00 00 00 movl $0x0,0x70(%ecx) tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; 1098e1: c7 41 74 00 00 00 00 movl $0x0,0x74(%ecx) } else { tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT; } } } if (tty->device.setAttributes) 1098e8: 8b 55 e4 mov -0x1c(%ebp),%edx 1098eb: 8b 82 a8 00 00 00 mov 0xa8(%edx),%eax 1098f1: 85 c0 test %eax,%eax 1098f3: 0f 84 6f fe ff ff je 109768 <== NEVER TAKEN (*tty->device.setAttributes)(tty->minor, &tty->termios); 1098f9: 83 ec 08 sub $0x8,%esp 1098fc: ff 75 dc pushl -0x24(%ebp) 1098ff: ff 72 10 pushl 0x10(%edx) 109902: ff d0 call *%eax 109904: 83 c4 10 add $0x10,%esp 109907: e9 5c fe ff ff jmp 109768 case TIOCGETD: *(int*)(args->buffer)=tty->t_line; break; #endif case FIONREAD: { int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head; 10990c: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED 10990f: 8b 42 60 mov 0x60(%edx),%eax <== NOT EXECUTED 109912: 89 d1 mov %edx,%ecx <== NOT EXECUTED 109914: 8b 52 5c mov 0x5c(%edx),%edx <== NOT EXECUTED if ( rawnc < 0 ) 109917: 29 d0 sub %edx,%eax <== NOT EXECUTED 109919: 0f 88 e9 00 00 00 js 109a08 <== NOT EXECUTED rawnc += tty->rawInBuf.Size; /* Half guess that this is the right operation */ *(int *)args->buffer = tty->ccount - tty->cindex + rawnc; 10991f: 8b 53 08 mov 0x8(%ebx),%edx <== NOT EXECUTED 109922: 8b 4d e4 mov -0x1c(%ebp),%ecx <== NOT EXECUTED 109925: 03 41 20 add 0x20(%ecx),%eax <== NOT EXECUTED 109928: 2b 41 24 sub 0x24(%ecx),%eax <== NOT EXECUTED 10992b: 89 02 mov %eax,(%edx) <== NOT EXECUTED } break; 10992d: e9 36 fe ff ff jmp 109768 <== NOT EXECUTED 109932: 66 90 xchg %ax,%ax <== NOT EXECUTED sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) { args->ioctl_return = sc; return sc; } switch (args->command) { 109934: 48 dec %eax 109935: 0f 85 ef fd ff ff jne 10972a <== NEVER TAKEN sc = RTEMS_INVALID_NUMBER; } break; case RTEMS_IO_GET_ATTRIBUTES: *(struct termios *)args->buffer = tty->termios; 10993b: 8b 43 08 mov 0x8(%ebx),%eax 10993e: 8b 75 e4 mov -0x1c(%ebp),%esi 109941: 83 c6 30 add $0x30,%esi 109944: b9 09 00 00 00 mov $0x9,%ecx 109949: 89 c7 mov %eax,%edi 10994b: f3 a5 rep movsl %ds:(%esi),%es:(%edi) break; 10994d: e9 16 fe ff ff jmp 109768 109952: 66 90 xchg %ax,%ax sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) { args->ioctl_return = sc; return sc; } switch (args->command) { 109954: 3d 1a 74 04 40 cmp $0x4004741a,%eax 109959: 74 69 je 1099c4 10995b: 3d 1b 74 04 80 cmp $0x8004741b,%eax 109960: 0f 85 c4 fd ff ff jne 10972a <== NEVER TAKEN #if 1 /* FIXME */ case TIOCSETD: /* * close old line discipline */ if (rtems_termios_linesw[tty->t_line].l_close != NULL) { 109966: 8b 55 e4 mov -0x1c(%ebp),%edx 109969: 8b 82 cc 00 00 00 mov 0xcc(%edx),%eax 10996f: c1 e0 05 shl $0x5,%eax 109972: 8b 80 04 79 12 00 mov 0x127904(%eax),%eax 109978: 85 c0 test %eax,%eax 10997a: 74 0c je 109988 sc = rtems_termios_linesw[tty->t_line].l_close(tty); 10997c: 83 ec 0c sub $0xc,%esp 10997f: 52 push %edx 109980: ff d0 call *%eax 109982: 89 45 e0 mov %eax,-0x20(%ebp) 109985: 83 c4 10 add $0x10,%esp } tty->t_line=*(int*)(args->buffer); 109988: 8b 43 08 mov 0x8(%ebx),%eax 10998b: 8b 00 mov (%eax),%eax 10998d: 8b 4d e4 mov -0x1c(%ebp),%ecx 109990: 89 81 cc 00 00 00 mov %eax,0xcc(%ecx) tty->t_sc = NULL; /* ensure that no more valid data */ 109996: c7 81 d0 00 00 00 00 movl $0x0,0xd0(%ecx) 10999d: 00 00 00 /* * open new line discipline */ if (rtems_termios_linesw[tty->t_line].l_open != NULL) { 1099a0: c1 e0 05 shl $0x5,%eax 1099a3: 8b 80 00 79 12 00 mov 0x127900(%eax),%eax 1099a9: 85 c0 test %eax,%eax 1099ab: 0f 84 b7 fd ff ff je 109768 <== NEVER TAKEN sc = rtems_termios_linesw[tty->t_line].l_open(tty); 1099b1: 83 ec 0c sub $0xc,%esp 1099b4: 51 push %ecx 1099b5: ff d0 call *%eax 1099b7: 89 45 e0 mov %eax,-0x20(%ebp) 1099ba: 83 c4 10 add $0x10,%esp 1099bd: e9 a6 fd ff ff jmp 109768 1099c2: 66 90 xchg %ax,%ax } break; case TIOCGETD: *(int*)(args->buffer)=tty->t_line; 1099c4: 8b 43 08 mov 0x8(%ebx),%eax 1099c7: 8b 4d e4 mov -0x1c(%ebp),%ecx 1099ca: 8b 91 cc 00 00 00 mov 0xcc(%ecx),%edx 1099d0: 89 10 mov %edx,(%eax) break; 1099d2: e9 91 fd ff ff jmp 109768 1099d7: 90 nop case RTEMS_IO_TCDRAIN: drainOutput (tty); break; case RTEMS_IO_SNDWAKEUP: tty->tty_snd = *wakeup; 1099d8: 8b 06 mov (%esi),%eax 1099da: 8b 56 04 mov 0x4(%esi),%edx 1099dd: 8b 4d e4 mov -0x1c(%ebp),%ecx 1099e0: 89 81 d4 00 00 00 mov %eax,0xd4(%ecx) 1099e6: 89 91 d8 00 00 00 mov %edx,0xd8(%ecx) break; 1099ec: e9 77 fd ff ff jmp 109768 1099f1: 8d 76 00 lea 0x0(%esi),%esi /* FIXME: what happens, if we had sent XOFF but not yet XON? */ tty->flow_ctrl &= ~(FL_ISNTXOF); } /* check for incoming RTS/CTS flow control switched off */ if (( tty->flow_ctrl & FL_MDRTS) && !(tty->termios.c_cflag & CRTSCTS)) { 1099f4: 8b 42 38 mov 0x38(%edx),%eax 1099f7: e9 91 fe ff ff jmp 10988d default: if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) { sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args); } else { sc = RTEMS_INVALID_NUMBER; 1099fc: c7 45 e0 0a 00 00 00 movl $0xa,-0x20(%ebp) <== NOT EXECUTED 109a03: e9 60 fd ff ff jmp 109768 <== NOT EXECUTED break; #endif case FIONREAD: { int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head; if ( rawnc < 0 ) rawnc += tty->rawInBuf.Size; 109a08: 8b 51 64 mov 0x64(%ecx),%edx <== NOT EXECUTED 109a0b: 01 d0 add %edx,%eax <== NOT EXECUTED 109a0d: e9 0d ff ff ff jmp 10991f <== NOT EXECUTED 109a12: 66 90 xchg %ax,%ax <== NOT EXECUTED if (tty->termios.c_lflag & ICANON) { tty->rawInBufSemaphoreOptions = RTEMS_WAIT; tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT; tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; } else { tty->vtimeTicks = tty->termios.c_cc[VTIME] * 109a14: 8b 45 e4 mov -0x1c(%ebp),%eax 109a17: 0f b6 70 46 movzbl 0x46(%eax),%esi rtems_clock_get_ticks_per_second() / 10; 109a1b: e8 74 15 00 00 call 10af94 if (tty->termios.c_lflag & ICANON) { tty->rawInBufSemaphoreOptions = RTEMS_WAIT; tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT; tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; } else { tty->vtimeTicks = tty->termios.c_cc[VTIME] * 109a20: 0f af c6 imul %esi,%eax rtems_clock_get_ticks_per_second() / 10; 109a23: ba cd cc cc cc mov $0xcccccccd,%edx 109a28: f7 e2 mul %edx 109a2a: c1 ea 03 shr $0x3,%edx if (tty->termios.c_lflag & ICANON) { tty->rawInBufSemaphoreOptions = RTEMS_WAIT; tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT; tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; } else { tty->vtimeTicks = tty->termios.c_cc[VTIME] * 109a2d: 8b 4d e4 mov -0x1c(%ebp),%ecx 109a30: 89 51 54 mov %edx,0x54(%ecx) rtems_clock_get_ticks_per_second() / 10; if (tty->termios.c_cc[VTIME]) { 109a33: 80 79 46 00 cmpb $0x0,0x46(%ecx) 109a37: 74 36 je 109a6f tty->rawInBufSemaphoreOptions = RTEMS_WAIT; 109a39: c7 41 6c 00 00 00 00 movl $0x0,0x6c(%ecx) tty->rawInBufSemaphoreTimeout = tty->vtimeTicks; 109a40: 89 51 70 mov %edx,0x70(%ecx) if (tty->termios.c_cc[VMIN]) 109a43: 80 79 47 00 cmpb $0x0,0x47(%ecx) 109a47: 74 49 je 109a92 tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; 109a49: c7 41 74 00 00 00 00 movl $0x0,0x74(%ecx) 109a50: e9 93 fe ff ff jmp 1098e8 109a55: 8d 76 00 lea 0x0(%esi),%esi /* * check for flow control options to be switched on */ /* check for incoming RTS/CTS flow control switched on */ if (tty->termios.c_cflag & CRTSCTS) { tty->flow_ctrl |= FL_MDRTS; 109a58: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED 109a5b: 8b 82 b8 00 00 00 mov 0xb8(%edx),%eax <== NOT EXECUTED 109a61: 80 cc 01 or $0x1,%ah <== NOT EXECUTED 109a64: 89 82 b8 00 00 00 mov %eax,0xb8(%edx) <== NOT EXECUTED 109a6a: e9 26 fe ff ff jmp 109895 <== NOT EXECUTED if (tty->termios.c_cc[VMIN]) tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; else tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks; } else { if (tty->termios.c_cc[VMIN]) { 109a6f: 8b 55 e4 mov -0x1c(%ebp),%edx 109a72: 80 7a 47 00 cmpb $0x0,0x47(%edx) 109a76: 74 25 je 109a9d <== ALWAYS TAKEN tty->rawInBufSemaphoreOptions = RTEMS_WAIT; 109a78: c7 42 6c 00 00 00 00 movl $0x0,0x6c(%edx) <== NOT EXECUTED tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT; 109a7f: c7 42 70 00 00 00 00 movl $0x0,0x70(%edx) <== NOT EXECUTED tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; 109a86: c7 42 74 00 00 00 00 movl $0x0,0x74(%edx) <== NOT EXECUTED 109a8d: e9 56 fe ff ff jmp 1098e8 <== NOT EXECUTED tty->rawInBufSemaphoreOptions = RTEMS_WAIT; tty->rawInBufSemaphoreTimeout = tty->vtimeTicks; if (tty->termios.c_cc[VMIN]) tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; else tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks; 109a92: 8b 45 e4 mov -0x1c(%ebp),%eax 109a95: 89 50 74 mov %edx,0x74(%eax) 109a98: e9 4b fe ff ff jmp 1098e8 if (tty->termios.c_cc[VMIN]) { tty->rawInBufSemaphoreOptions = RTEMS_WAIT; tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT; tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; } else { tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT; 109a9d: 8b 4d e4 mov -0x1c(%ebp),%ecx 109aa0: c7 41 6c 01 00 00 00 movl $0x1,0x6c(%ecx) 109aa7: e9 3c fe ff ff jmp 1098e8 tty->flow_ctrl &= ~FL_OSTOP; /* check for chars in output buffer (or rob_state?) */ if (tty->rawOutBufState != rob_idle) { /* if chars available, call write function... */ (*tty->device.write)( tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1); 109aac: 8b 82 84 00 00 00 mov 0x84(%edx),%eax <== NOT EXECUTED rtems_interrupt_disable(level); tty->flow_ctrl &= ~FL_OSTOP; /* check for chars in output buffer (or rob_state?) */ if (tty->rawOutBufState != rob_idle) { /* if chars available, call write function... */ (*tty->device.write)( 109ab2: 51 push %ecx <== NOT EXECUTED 109ab3: 6a 01 push $0x1 <== NOT EXECUTED 109ab5: 03 42 7c add 0x7c(%edx),%eax <== NOT EXECUTED 109ab8: 50 push %eax <== NOT EXECUTED 109ab9: ff 72 10 pushl 0x10(%edx) <== NOT EXECUTED 109abc: ff 92 a4 00 00 00 call *0xa4(%edx) <== NOT EXECUTED 109ac2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109ac5: e9 27 fd ff ff jmp 1097f1 <== NOT EXECUTED =============================================================================== 0010aa84 : extern rtems_assoc_t termios_assoc_table[]; int rtems_termios_number_to_baud( int32_t baud ) { 10aa84: 55 push %ebp 10aa85: 89 e5 mov %esp,%ebp 10aa87: 53 push %ebx 10aa88: 83 ec 0c sub $0xc,%esp 10aa8b: 8b 5d 08 mov 0x8(%ebp),%ebx int termios_baud; termios_baud = rtems_assoc_remote_by_local( termios_assoc_table, baud ); 10aa8e: 53 push %ebx 10aa8f: 68 c0 81 12 00 push $0x1281c0 10aa94: e8 27 6f 00 00 call 1119c0 if ( termios_baud == 0 && baud != 0 ) 10aa99: 83 c4 10 add $0x10,%esp 10aa9c: 85 c0 test %eax,%eax 10aa9e: 74 08 je 10aaa8 return -1; return termios_baud; } 10aaa0: 8b 5d fc mov -0x4(%ebp),%ebx 10aaa3: c9 leave 10aaa4: c3 ret 10aaa5: 8d 76 00 lea 0x0(%esi),%esi ) { int termios_baud; termios_baud = rtems_assoc_remote_by_local( termios_assoc_table, baud ); if ( termios_baud == 0 && baud != 0 ) 10aaa8: 85 db test %ebx,%ebx 10aaaa: 74 f4 je 10aaa0 return -1; 10aaac: b8 ff ff ff ff mov $0xffffffff,%eax 10aab1: eb ed jmp 10aaa0 =============================================================================== 00109014 : rtems_device_major_number major, rtems_device_minor_number minor, void *arg, const rtems_termios_callbacks *callbacks ) { 109014: 55 push %ebp 109015: 89 e5 mov %esp,%ebp 109017: 57 push %edi 109018: 56 push %esi 109019: 53 push %ebx 10901a: 83 ec 40 sub $0x40,%esp 10901d: 8b 55 08 mov 0x8(%ebp),%edx struct rtems_termios_tty *tty; /* * See if the device has already been opened */ sc = rtems_semaphore_obtain( 109020: 6a 00 push $0x0 109022: 6a 00 push $0x0 109024: ff 35 6c 7c 12 00 pushl 0x127c6c 10902a: 89 55 dc mov %edx,-0x24(%ebp) 10902d: e8 7e 26 00 00 call 10b6b0 109032: 89 45 e4 mov %eax,-0x1c(%ebp) rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) 109035: 83 c4 10 add $0x10,%esp 109038: 85 c0 test %eax,%eax 10903a: 8b 55 dc mov -0x24(%ebp),%edx 10903d: 75 6d jne 1090ac <== NEVER TAKEN return sc; for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) { 10903f: 8b 35 74 7c 12 00 mov 0x127c74,%esi 109045: 85 f6 test %esi,%esi 109047: 0f 84 a7 00 00 00 je 1090f4 10904d: 89 f3 mov %esi,%ebx 10904f: 8b 45 0c mov 0xc(%ebp),%eax 109052: eb 0a jmp 10905e 109054: 8b 1b mov (%ebx),%ebx 109056: 85 db test %ebx,%ebx 109058: 0f 84 96 00 00 00 je 1090f4 <== ALWAYS TAKEN if ((tty->major == major) && (tty->minor == minor)) 10905e: 39 53 0c cmp %edx,0xc(%ebx) 109061: 75 f1 jne 109054 109063: 39 43 10 cmp %eax,0x10(%ebx) 109066: 75 ec jne 109054 <== NEVER TAKEN */ if (c++ == 'z') c = 'a'; } args->iop->data1 = tty; 109068: 8b 75 10 mov 0x10(%ebp),%esi 10906b: 8b 06 mov (%esi),%eax 10906d: 89 58 34 mov %ebx,0x34(%eax) if (!tty->refcount++) { 109070: 8b 43 08 mov 0x8(%ebx),%eax 109073: 8d 48 01 lea 0x1(%eax),%ecx 109076: 89 4b 08 mov %ecx,0x8(%ebx) 109079: 85 c0 test %eax,%eax 10907b: 75 1e jne 10909b if (tty->device.firstOpen) 10907d: 8b 83 98 00 00 00 mov 0x98(%ebx),%eax 109083: 85 c0 test %eax,%eax 109085: 74 0b je 109092 (*tty->device.firstOpen)(major, minor, arg); 109087: 57 push %edi 109088: 56 push %esi 109089: ff 75 0c pushl 0xc(%ebp) 10908c: 52 push %edx 10908d: ff d0 call *%eax 10908f: 83 c4 10 add $0x10,%esp /* * start I/O tasks, if needed */ if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 109092: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) 109099: 74 1c je 1090b7 tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); } } rtems_semaphore_release (rtems_termios_ttyMutex); 10909b: 83 ec 0c sub $0xc,%esp 10909e: ff 35 6c 7c 12 00 pushl 0x127c6c 1090a4: e8 03 27 00 00 call 10b7ac return RTEMS_SUCCESSFUL; 1090a9: 83 c4 10 add $0x10,%esp } 1090ac: 8b 45 e4 mov -0x1c(%ebp),%eax 1090af: 8d 65 f4 lea -0xc(%ebp),%esp 1090b2: 5b pop %ebx 1090b3: 5e pop %esi 1090b4: 5f pop %edi 1090b5: c9 leave 1090b6: c3 ret /* * start I/O tasks, if needed */ if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { sc = rtems_task_start( 1090b7: 56 push %esi 1090b8: 53 push %ebx 1090b9: 68 4c a8 10 00 push $0x10a84c 1090be: ff b3 c4 00 00 00 pushl 0xc4(%ebx) 1090c4: e8 2b 2a 00 00 call 10baf4 tty->rxTaskId, rtems_termios_rxdaemon, (rtems_task_argument)tty); if (sc != RTEMS_SUCCESSFUL) 1090c9: 83 c4 10 add $0x10,%esp 1090cc: 85 c0 test %eax,%eax 1090ce: 0f 85 3f 03 00 00 jne 109413 <== NEVER TAKEN rtems_fatal_error_occurred (sc); sc = rtems_task_start( 1090d4: 51 push %ecx 1090d5: 53 push %ebx 1090d6: 68 fc aa 10 00 push $0x10aafc 1090db: ff b3 c8 00 00 00 pushl 0xc8(%ebx) 1090e1: e8 0e 2a 00 00 call 10baf4 tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty); if (sc != RTEMS_SUCCESSFUL) 1090e6: 83 c4 10 add $0x10,%esp 1090e9: 85 c0 test %eax,%eax 1090eb: 74 ae je 10909b <== ALWAYS TAKEN 1090ed: e9 21 03 00 00 jmp 109413 <== NOT EXECUTED 1090f2: 66 90 xchg %ax,%ax <== NOT EXECUTED static char c = 'a'; /* * Create a new device */ tty = calloc (1, sizeof (struct rtems_termios_tty)); 1090f4: 83 ec 08 sub $0x8,%esp 1090f7: 68 e8 00 00 00 push $0xe8 1090fc: 6a 01 push $0x1 1090fe: 89 55 dc mov %edx,-0x24(%ebp) 109101: e8 1e ee ff ff call 107f24 109106: 89 45 e0 mov %eax,-0x20(%ebp) 109109: 89 c3 mov %eax,%ebx if (tty == NULL) { 10910b: 83 c4 10 add $0x10,%esp 10910e: 85 c0 test %eax,%eax 109110: 8b 55 dc mov -0x24(%ebp),%edx 109113: 0f 84 75 02 00 00 je 10938e return RTEMS_NO_MEMORY; } /* * allocate raw input buffer */ tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE; 109119: a1 84 59 12 00 mov 0x125984,%eax 10911e: 8b 4d e0 mov -0x20(%ebp),%ecx 109121: 89 41 64 mov %eax,0x64(%ecx) tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size); 109124: 8b 41 64 mov 0x64(%ecx),%eax 109127: 83 ec 0c sub $0xc,%esp 10912a: 50 push %eax 10912b: 89 55 dc mov %edx,-0x24(%ebp) 10912e: e8 55 f2 ff ff call 108388 109133: 89 45 c4 mov %eax,-0x3c(%ebp) 109136: 8b 7d e0 mov -0x20(%ebp),%edi 109139: 89 47 58 mov %eax,0x58(%edi) if (tty->rawInBuf.theBuf == NULL) { 10913c: 83 c4 10 add $0x10,%esp 10913f: 85 c0 test %eax,%eax 109141: 8b 55 dc mov -0x24(%ebp),%edx 109144: 0f 84 61 02 00 00 je 1093ab return RTEMS_NO_MEMORY; } /* * allocate raw output buffer */ tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE; 10914a: a1 88 59 12 00 mov 0x125988,%eax 10914f: 8b 4d e0 mov -0x20(%ebp),%ecx 109152: 89 81 88 00 00 00 mov %eax,0x88(%ecx) tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size); 109158: 8b 81 88 00 00 00 mov 0x88(%ecx),%eax 10915e: 83 ec 0c sub $0xc,%esp 109161: 50 push %eax 109162: 89 55 dc mov %edx,-0x24(%ebp) 109165: e8 1e f2 ff ff call 108388 10916a: 89 c7 mov %eax,%edi 10916c: 8b 45 e0 mov -0x20(%ebp),%eax 10916f: 89 78 7c mov %edi,0x7c(%eax) if (tty->rawOutBuf.theBuf == NULL) { 109172: 83 c4 10 add $0x10,%esp 109175: 85 ff test %edi,%edi 109177: 8b 55 dc mov -0x24(%ebp),%edx 10917a: 0f 84 4f 02 00 00 je 1093cf <== NEVER TAKEN return RTEMS_NO_MEMORY; } /* * allocate cooked buffer */ tty->cbuf = malloc (CBUFSIZE); 109180: 83 ec 0c sub $0xc,%esp 109183: ff 35 80 59 12 00 pushl 0x125980 109189: 89 55 dc mov %edx,-0x24(%ebp) 10918c: e8 f7 f1 ff ff call 108388 109191: 8b 4d e0 mov -0x20(%ebp),%ecx 109194: 89 41 1c mov %eax,0x1c(%ecx) if (tty->cbuf == NULL) { 109197: 83 c4 10 add $0x10,%esp 10919a: 85 c0 test %eax,%eax 10919c: 8b 55 dc mov -0x24(%ebp),%edx 10919f: 0f 84 77 02 00 00 je 10941c return RTEMS_NO_MEMORY; } /* * Initialize wakeup callbacks */ tty->tty_snd.sw_pfn = NULL; 1091a5: 8b 7d e0 mov -0x20(%ebp),%edi 1091a8: c7 87 d4 00 00 00 00 movl $0x0,0xd4(%edi) 1091af: 00 00 00 tty->tty_snd.sw_arg = NULL; 1091b2: c7 87 d8 00 00 00 00 movl $0x0,0xd8(%edi) 1091b9: 00 00 00 tty->tty_rcv.sw_pfn = NULL; 1091bc: c7 87 dc 00 00 00 00 movl $0x0,0xdc(%edi) 1091c3: 00 00 00 tty->tty_rcv.sw_arg = NULL; 1091c6: c7 87 e0 00 00 00 00 movl $0x0,0xe0(%edi) 1091cd: 00 00 00 tty->tty_rcvwakeup = 0; 1091d0: c7 87 e4 00 00 00 00 movl $0x0,0xe4(%edi) 1091d7: 00 00 00 /* * link tty */ tty->forw = rtems_termios_ttyHead; 1091da: 89 37 mov %esi,(%edi) tty->back = NULL; 1091dc: c7 47 04 00 00 00 00 movl $0x0,0x4(%edi) if (rtems_termios_ttyHead != NULL) 1091e3: 85 f6 test %esi,%esi 1091e5: 74 03 je 1091ea rtems_termios_ttyHead->back = tty; 1091e7: 89 7e 04 mov %edi,0x4(%esi) rtems_termios_ttyHead = tty; 1091ea: 8b 45 e0 mov -0x20(%ebp),%eax 1091ed: a3 74 7c 12 00 mov %eax,0x127c74 if (rtems_termios_ttyTail == NULL) 1091f2: 8b 0d 70 7c 12 00 mov 0x127c70,%ecx 1091f8: 85 c9 test %ecx,%ecx 1091fa: 0f 84 af 02 00 00 je 1094af rtems_termios_ttyTail = tty; tty->minor = minor; 109200: 8b 75 0c mov 0xc(%ebp),%esi 109203: 8b 4d e0 mov -0x20(%ebp),%ecx 109206: 89 71 10 mov %esi,0x10(%ecx) tty->major = major; 109209: 89 51 0c mov %edx,0xc(%ecx) /* * Set up mutex semaphores */ sc = rtems_semaphore_create ( 10920c: 83 ec 0c sub $0xc,%esp 10920f: 89 c8 mov %ecx,%eax 109211: 83 c0 14 add $0x14,%eax 109214: 50 push %eax 109215: 6a 00 push $0x0 109217: 6a 54 push $0x54 109219: 6a 01 push $0x1 rtems_build_name ('T', 'R', 'i', c), 10921b: 0f be 05 8c 59 12 00 movsbl 0x12598c,%eax tty->major = major; /* * Set up mutex semaphores */ sc = rtems_semaphore_create ( 109222: 0d 00 69 52 54 or $0x54526900,%eax 109227: 50 push %eax 109228: 89 55 dc mov %edx,-0x24(%ebp) 10922b: e8 04 22 00 00 call 10b434 rtems_build_name ('T', 'R', 'i', c), 1, RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &tty->isem); if (sc != RTEMS_SUCCESSFUL) 109230: 83 c4 20 add $0x20,%esp 109233: 85 c0 test %eax,%eax 109235: 8b 55 dc mov -0x24(%ebp),%edx 109238: 0f 85 d5 01 00 00 jne 109413 rtems_fatal_error_occurred (sc); sc = rtems_semaphore_create ( 10923e: 83 ec 0c sub $0xc,%esp 109241: 8b 45 e0 mov -0x20(%ebp),%eax 109244: 83 c0 18 add $0x18,%eax 109247: 50 push %eax 109248: 6a 00 push $0x0 10924a: 6a 54 push $0x54 10924c: 6a 01 push $0x1 rtems_build_name ('T', 'R', 'o', c), 10924e: 0f be 05 8c 59 12 00 movsbl 0x12598c,%eax RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &tty->isem); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); sc = rtems_semaphore_create ( 109255: 0d 00 6f 52 54 or $0x54526f00,%eax 10925a: 50 push %eax 10925b: 89 55 dc mov %edx,-0x24(%ebp) 10925e: e8 d1 21 00 00 call 10b434 rtems_build_name ('T', 'R', 'o', c), 1, RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &tty->osem); if (sc != RTEMS_SUCCESSFUL) 109263: 83 c4 20 add $0x20,%esp 109266: 85 c0 test %eax,%eax 109268: 8b 55 dc mov -0x24(%ebp),%edx 10926b: 0f 85 a2 01 00 00 jne 109413 rtems_fatal_error_occurred (sc); sc = rtems_semaphore_create ( 109271: 83 ec 0c sub $0xc,%esp 109274: 8b 45 e0 mov -0x20(%ebp),%eax 109277: 05 8c 00 00 00 add $0x8c,%eax 10927c: 50 push %eax 10927d: 6a 00 push $0x0 10927f: 6a 20 push $0x20 109281: 6a 00 push $0x0 rtems_build_name ('T', 'R', 'x', c), 109283: 0f be 05 8c 59 12 00 movsbl 0x12598c,%eax RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &tty->osem); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); sc = rtems_semaphore_create ( 10928a: 0d 00 78 52 54 or $0x54527800,%eax 10928f: 50 push %eax 109290: 89 55 dc mov %edx,-0x24(%ebp) 109293: e8 9c 21 00 00 call 10b434 rtems_build_name ('T', 'R', 'x', c), 0, RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_FIFO, RTEMS_NO_PRIORITY, &tty->rawOutBuf.Semaphore); if (sc != RTEMS_SUCCESSFUL) 109298: 83 c4 20 add $0x20,%esp 10929b: 85 c0 test %eax,%eax 10929d: 8b 55 dc mov -0x24(%ebp),%edx 1092a0: 0f 85 6d 01 00 00 jne 109413 rtems_fatal_error_occurred (sc); tty->rawOutBufState = rob_idle; 1092a6: 8b 7d e0 mov -0x20(%ebp),%edi 1092a9: c7 87 94 00 00 00 00 movl $0x0,0x94(%edi) 1092b0: 00 00 00 /* * Set callbacks */ tty->device = *callbacks; 1092b3: 81 c7 98 00 00 00 add $0x98,%edi 1092b9: b9 08 00 00 00 mov $0x8,%ecx 1092be: 8b 75 14 mov 0x14(%ebp),%esi 1092c1: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* * Create I/O tasks */ if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 1092c3: 8b 7d e0 mov -0x20(%ebp),%edi 1092c6: 83 bf b4 00 00 00 02 cmpl $0x2,0xb4(%edi) 1092cd: 0f 84 64 01 00 00 je 109437 <== NEVER TAKEN &tty->rxTaskId); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); } if ((tty->device.pollRead == NULL) || 1092d3: 8b 45 e0 mov -0x20(%ebp),%eax 1092d6: 8b 88 a0 00 00 00 mov 0xa0(%eax),%ecx 1092dc: 85 c9 test %ecx,%ecx 1092de: 0f 84 fc 00 00 00 je 1093e0 1092e4: 83 b8 b4 00 00 00 02 cmpl $0x2,0xb4(%eax) 1092eb: 0f 84 ef 00 00 00 je 1093e0 <== NEVER TAKEN } /* * Set default parameters */ tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL; 1092f1: 8b 4d e0 mov -0x20(%ebp),%ecx 1092f4: c7 41 30 02 25 00 00 movl $0x2502,0x30(%ecx) tty->termios.c_oflag = OPOST | ONLCR | XTABS; 1092fb: c7 41 34 05 18 00 00 movl $0x1805,0x34(%ecx) tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL; 109302: c7 41 38 bd 08 00 00 movl $0x8bd,0x38(%ecx) tty->termios.c_lflag = 109309: c7 41 3c 3b 82 00 00 movl $0x823b,0x3c(%ecx) ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL; tty->termios.c_cc[VINTR] = '\003'; 109310: c6 41 41 03 movb $0x3,0x41(%ecx) tty->termios.c_cc[VQUIT] = '\034'; 109314: c6 41 42 1c movb $0x1c,0x42(%ecx) tty->termios.c_cc[VERASE] = '\177'; 109318: c6 41 43 7f movb $0x7f,0x43(%ecx) tty->termios.c_cc[VKILL] = '\025'; 10931c: c6 41 44 15 movb $0x15,0x44(%ecx) tty->termios.c_cc[VEOF] = '\004'; 109320: c6 41 45 04 movb $0x4,0x45(%ecx) tty->termios.c_cc[VEOL] = '\000'; 109324: c6 41 4c 00 movb $0x0,0x4c(%ecx) tty->termios.c_cc[VEOL2] = '\000'; 109328: c6 41 51 00 movb $0x0,0x51(%ecx) tty->termios.c_cc[VSTART] = '\021'; 10932c: c6 41 49 11 movb $0x11,0x49(%ecx) tty->termios.c_cc[VSTOP] = '\023'; 109330: c6 41 4a 13 movb $0x13,0x4a(%ecx) tty->termios.c_cc[VSUSP] = '\032'; 109334: c6 41 4b 1a movb $0x1a,0x4b(%ecx) tty->termios.c_cc[VREPRINT] = '\022'; 109338: c6 41 4d 12 movb $0x12,0x4d(%ecx) tty->termios.c_cc[VDISCARD] = '\017'; 10933c: c6 41 4e 0f movb $0xf,0x4e(%ecx) tty->termios.c_cc[VWERASE] = '\027'; 109340: c6 41 4f 17 movb $0x17,0x4f(%ecx) tty->termios.c_cc[VLNEXT] = '\026'; 109344: c6 41 50 16 movb $0x16,0x50(%ecx) /* start with no flow control, clear flow control flags */ tty->flow_ctrl = 0; 109348: c7 81 b8 00 00 00 00 movl $0x0,0xb8(%ecx) 10934f: 00 00 00 /* * set low/highwater mark for XON/XOFF support */ tty->lowwater = tty->rawInBuf.Size * 1/2; 109352: 8b 41 64 mov 0x64(%ecx),%eax 109355: d1 e8 shr %eax 109357: 89 81 bc 00 00 00 mov %eax,0xbc(%ecx) tty->highwater = tty->rawInBuf.Size * 3/4; 10935d: 8b 41 64 mov 0x64(%ecx),%eax 109360: 8d 04 40 lea (%eax,%eax,2),%eax 109363: c1 e8 02 shr $0x2,%eax 109366: 89 81 c0 00 00 00 mov %eax,0xc0(%ecx) /* * Bump name characer */ if (c++ == 'z') 10936c: a0 8c 59 12 00 mov 0x12598c,%al 109371: 8d 48 01 lea 0x1(%eax),%ecx 109374: 88 0d 8c 59 12 00 mov %cl,0x12598c 10937a: 3c 7a cmp $0x7a,%al 10937c: 0f 85 e6 fc ff ff jne 109068 c = 'a'; 109382: c6 05 8c 59 12 00 61 movb $0x61,0x12598c 109389: e9 da fc ff ff jmp 109068 /* * Create a new device */ tty = calloc (1, sizeof (struct rtems_termios_tty)); if (tty == NULL) { rtems_semaphore_release (rtems_termios_ttyMutex); 10938e: 83 ec 0c sub $0xc,%esp 109391: ff 35 6c 7c 12 00 pushl 0x127c6c 109397: e8 10 24 00 00 call 10b7ac return RTEMS_NO_MEMORY; 10939c: 83 c4 10 add $0x10,%esp 10939f: c7 45 e4 1a 00 00 00 movl $0x1a,-0x1c(%ebp) 1093a6: e9 01 fd ff ff jmp 1090ac * allocate raw input buffer */ tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE; tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size); if (tty->rawInBuf.theBuf == NULL) { free(tty); 1093ab: 83 ec 0c sub $0xc,%esp 1093ae: 57 push %edi */ tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE; tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size); if (tty->rawOutBuf.theBuf == NULL) { free((void *)(tty->rawInBuf.theBuf)); free(tty); 1093af: e8 00 ed ff ff call 1080b4 rtems_semaphore_release (rtems_termios_ttyMutex); 1093b4: 5f pop %edi 1093b5: ff 35 6c 7c 12 00 pushl 0x127c6c 1093bb: e8 ec 23 00 00 call 10b7ac return RTEMS_NO_MEMORY; 1093c0: 83 c4 10 add $0x10,%esp 1093c3: c7 45 e4 1a 00 00 00 movl $0x1a,-0x1c(%ebp) 1093ca: e9 dd fc ff ff jmp 1090ac * allocate raw output buffer */ tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE; tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size); if (tty->rawOutBuf.theBuf == NULL) { free((void *)(tty->rawInBuf.theBuf)); 1093cf: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1093d2: ff 75 c4 pushl -0x3c(%ebp) <== NOT EXECUTED 1093d5: e8 da ec ff ff call 1080b4 <== NOT EXECUTED free(tty); 1093da: 58 pop %eax <== NOT EXECUTED 1093db: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 1093de: eb cf jmp 1093af <== NOT EXECUTED rtems_fatal_error_occurred (sc); } if ((tty->device.pollRead == NULL) || (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){ sc = rtems_semaphore_create ( 1093e0: 83 ec 0c sub $0xc,%esp 1093e3: 8b 45 e0 mov -0x20(%ebp),%eax 1093e6: 83 c0 68 add $0x68,%eax 1093e9: 50 push %eax 1093ea: 6a 00 push $0x0 1093ec: 6a 24 push $0x24 1093ee: 6a 00 push $0x0 rtems_build_name ('T', 'R', 'r', c), 1093f0: 0f be 05 8c 59 12 00 movsbl 0x12598c,%eax rtems_fatal_error_occurred (sc); } if ((tty->device.pollRead == NULL) || (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){ sc = rtems_semaphore_create ( 1093f7: 0d 00 72 52 54 or $0x54527200,%eax 1093fc: 50 push %eax 1093fd: 89 55 dc mov %edx,-0x24(%ebp) 109400: e8 2f 20 00 00 call 10b434 rtems_build_name ('T', 'R', 'r', c), 0, RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &tty->rawInBuf.Semaphore); if (sc != RTEMS_SUCCESSFUL) 109405: 83 c4 20 add $0x20,%esp 109408: 85 c0 test %eax,%eax 10940a: 8b 55 dc mov -0x24(%ebp),%edx 10940d: 0f 84 de fe ff ff je 1092f1 rtems_fatal_error_occurred (sc); sc = rtems_task_start( tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); 109413: 83 ec 0c sub $0xc,%esp 109416: 50 push %eax 109417: e8 d8 28 00 00 call 10bcf4 /* * allocate cooked buffer */ tty->cbuf = malloc (CBUFSIZE); if (tty->cbuf == NULL) { free((void *)(tty->rawOutBuf.theBuf)); 10941c: 83 ec 0c sub $0xc,%esp 10941f: 57 push %edi 109420: e8 8f ec ff ff call 1080b4 free((void *)(tty->rawInBuf.theBuf)); 109425: 5e pop %esi 109426: ff 75 c4 pushl -0x3c(%ebp) 109429: e8 86 ec ff ff call 1080b4 free(tty); 10942e: 5b pop %ebx 10942f: ff 75 e0 pushl -0x20(%ebp) 109432: e9 78 ff ff ff jmp 1093af /* * Create I/O tasks */ if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { sc = rtems_task_create ( 109437: 50 push %eax 109438: 50 push %eax 109439: 89 f8 mov %edi,%eax 10943b: 05 c8 00 00 00 add $0xc8,%eax 109440: 50 push %eax 109441: 6a 00 push $0x0 109443: 68 00 05 00 00 push $0x500 109448: 68 00 04 00 00 push $0x400 10944d: 6a 0a push $0xa rtems_build_name ('T', 'x', 'T', c), 10944f: 0f be 05 8c 59 12 00 movsbl 0x12598c,%eax /* * Create I/O tasks */ if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { sc = rtems_task_create ( 109456: 0d 00 54 78 54 or $0x54785400,%eax 10945b: 50 push %eax 10945c: 89 55 dc mov %edx,-0x24(%ebp) 10945f: e8 e8 23 00 00 call 10b84c TERMIOS_TXTASK_STACKSIZE, RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR, RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL, &tty->txTaskId); if (sc != RTEMS_SUCCESSFUL) 109464: 83 c4 20 add $0x20,%esp 109467: 85 c0 test %eax,%eax 109469: 8b 55 dc mov -0x24(%ebp),%edx 10946c: 75 a5 jne 109413 <== NEVER TAKEN rtems_fatal_error_occurred (sc); sc = rtems_task_create ( 10946e: 56 push %esi 10946f: 56 push %esi 109470: 8b 45 e0 mov -0x20(%ebp),%eax 109473: 05 c4 00 00 00 add $0xc4,%eax 109478: 50 push %eax 109479: 6a 00 push $0x0 10947b: 68 00 05 00 00 push $0x500 109480: 68 00 04 00 00 push $0x400 109485: 6a 09 push $0x9 rtems_build_name ('R', 'x', 'T', c), 109487: 0f be 05 8c 59 12 00 movsbl 0x12598c,%eax RTEMS_NO_ASR, RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL, &tty->txTaskId); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); sc = rtems_task_create ( 10948e: 0d 00 54 78 52 or $0x52785400,%eax 109493: 50 push %eax 109494: 89 55 dc mov %edx,-0x24(%ebp) 109497: e8 b0 23 00 00 call 10b84c TERMIOS_RXTASK_STACKSIZE, RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR, RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL, &tty->rxTaskId); if (sc != RTEMS_SUCCESSFUL) 10949c: 83 c4 20 add $0x20,%esp 10949f: 85 c0 test %eax,%eax 1094a1: 8b 55 dc mov -0x24(%ebp),%edx 1094a4: 0f 84 29 fe ff ff je 1092d3 1094aa: e9 64 ff ff ff jmp 109413 <== NOT EXECUTED tty->back = NULL; if (rtems_termios_ttyHead != NULL) rtems_termios_ttyHead->back = tty; rtems_termios_ttyHead = tty; if (rtems_termios_ttyTail == NULL) rtems_termios_ttyTail = tty; 1094af: a3 70 7c 12 00 mov %eax,0x127c70 1094b4: e9 47 fd ff ff jmp 109200 =============================================================================== 00109acc : * Send characters to device-specific code */ void rtems_termios_puts ( const void *_buf, int len, struct rtems_termios_tty *tty) { 109acc: 55 push %ebp 109acd: 89 e5 mov %esp,%ebp 109acf: 57 push %edi 109ad0: 56 push %esi 109ad1: 53 push %ebx 109ad2: 83 ec 1c sub $0x1c,%esp 109ad5: 8b 45 08 mov 0x8(%ebp),%eax 109ad8: 8b 55 0c mov 0xc(%ebp),%edx 109adb: 89 55 e4 mov %edx,-0x1c(%ebp) 109ade: 8b 5d 10 mov 0x10(%ebp),%ebx const unsigned char *buf = _buf; 109ae1: 89 c6 mov %eax,%esi unsigned int newHead; rtems_interrupt_level level; rtems_status_code sc; if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) { 109ae3: 8b 8b b4 00 00 00 mov 0xb4(%ebx),%ecx 109ae9: 85 c9 test %ecx,%ecx 109aeb: 0f 84 eb 00 00 00 je 109bdc (*tty->device.write)(tty->minor, (void *)buf, len); return; } newHead = tty->rawOutBuf.Head; 109af1: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax 109af7: 89 45 e0 mov %eax,-0x20(%ebp) while (len) { 109afa: 8b 55 e4 mov -0x1c(%ebp),%edx 109afd: 85 d2 test %edx,%edx 109aff: 0f 84 cf 00 00 00 je 109bd4 <== NEVER TAKEN 109b05: 8d 76 00 lea 0x0(%esi),%esi * len -= ncopy * * To minimize latency, the memcpy should be done * with interrupts enabled. */ newHead = (newHead + 1) % tty->rawOutBuf.Size; 109b08: 8b 45 e0 mov -0x20(%ebp),%eax 109b0b: 40 inc %eax 109b0c: 8b 8b 88 00 00 00 mov 0x88(%ebx),%ecx 109b12: 31 d2 xor %edx,%edx 109b14: f7 f1 div %ecx 109b16: 89 55 dc mov %edx,-0x24(%ebp) 109b19: 89 55 e0 mov %edx,-0x20(%ebp) rtems_interrupt_disable (level); 109b1c: 9c pushf 109b1d: fa cli 109b1e: 5f pop %edi while (newHead == tty->rawOutBuf.Tail) { 109b1f: 8b 93 84 00 00 00 mov 0x84(%ebx),%edx 109b25: 3b 55 e0 cmp -0x20(%ebp),%edx 109b28: 75 3e jne 109b68 109b2a: 89 f8 mov %edi,%eax 109b2c: 89 f7 mov %esi,%edi 109b2e: 89 d6 mov %edx,%esi tty->rawOutBufState = rob_wait; 109b30: c7 83 94 00 00 00 02 movl $0x2,0x94(%ebx) 109b37: 00 00 00 rtems_interrupt_enable (level); 109b3a: 50 push %eax 109b3b: 9d popf sc = rtems_semaphore_obtain( 109b3c: 50 push %eax 109b3d: 6a 00 push $0x0 109b3f: 6a 00 push $0x0 109b41: ff b3 8c 00 00 00 pushl 0x8c(%ebx) 109b47: e8 64 1b 00 00 call 10b6b0 tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) 109b4c: 83 c4 10 add $0x10,%esp 109b4f: 85 c0 test %eax,%eax 109b51: 0f 85 a0 00 00 00 jne 109bf7 <== NEVER TAKEN rtems_fatal_error_occurred (sc); rtems_interrupt_disable (level); 109b57: 9c pushf 109b58: fa cli 109b59: 58 pop %eax * To minimize latency, the memcpy should be done * with interrupts enabled. */ newHead = (newHead + 1) % tty->rawOutBuf.Size; rtems_interrupt_disable (level); while (newHead == tty->rawOutBuf.Tail) { 109b5a: 8b 93 84 00 00 00 mov 0x84(%ebx),%edx 109b60: 39 f2 cmp %esi,%edx 109b62: 74 cc je 109b30 <== NEVER TAKEN 109b64: 89 fe mov %edi,%esi 109b66: 89 c7 mov %eax,%edi tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); rtems_interrupt_disable (level); } tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++; 109b68: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax 109b6e: 8b 4b 7c mov 0x7c(%ebx),%ecx 109b71: 8a 16 mov (%esi),%dl 109b73: 88 14 01 mov %dl,(%ecx,%eax,1) tty->rawOutBuf.Head = newHead; 109b76: 8b 45 dc mov -0x24(%ebp),%eax 109b79: 89 83 80 00 00 00 mov %eax,0x80(%ebx) if (tty->rawOutBufState == rob_idle) { 109b7f: 8b 8b 94 00 00 00 mov 0x94(%ebx),%ecx 109b85: 85 c9 test %ecx,%ecx 109b87: 75 23 jne 109bac /* check, whether XOFF has been received */ if (!(tty->flow_ctrl & FL_ORCVXOF)) { 109b89: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 109b8f: a8 10 test $0x10,%al 109b91: 74 26 je 109bb9 <== ALWAYS TAKEN (*tty->device.write)(tty->minor, (char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1); } else { /* remember that output has been stopped due to flow ctrl*/ tty->flow_ctrl |= FL_OSTOP; 109b93: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 109b99: 83 c8 20 or $0x20,%eax 109b9c: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED } tty->rawOutBufState = rob_busy; 109ba2: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx) 109ba9: 00 00 00 } rtems_interrupt_enable (level); 109bac: 57 push %edi 109bad: 9d popf if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) { (*tty->device.write)(tty->minor, (void *)buf, len); return; } newHead = tty->rawOutBuf.Head; while (len) { 109bae: ff 4d e4 decl -0x1c(%ebp) 109bb1: 74 21 je 109bd4 tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); rtems_interrupt_disable (level); } tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++; 109bb3: 46 inc %esi 109bb4: e9 4f ff ff ff jmp 109b08 tty->rawOutBuf.Head = newHead; if (tty->rawOutBufState == rob_idle) { /* check, whether XOFF has been received */ if (!(tty->flow_ctrl & FL_ORCVXOF)) { (*tty->device.write)(tty->minor, (char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1); 109bb9: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++; tty->rawOutBuf.Head = newHead; if (tty->rawOutBufState == rob_idle) { /* check, whether XOFF has been received */ if (!(tty->flow_ctrl & FL_ORCVXOF)) { (*tty->device.write)(tty->minor, 109bbf: 52 push %edx 109bc0: 6a 01 push $0x1 109bc2: 03 43 7c add 0x7c(%ebx),%eax 109bc5: 50 push %eax 109bc6: ff 73 10 pushl 0x10(%ebx) 109bc9: ff 93 a4 00 00 00 call *0xa4(%ebx) 109bcf: 83 c4 10 add $0x10,%esp 109bd2: eb ce jmp 109ba2 tty->rawOutBufState = rob_busy; } rtems_interrupt_enable (level); len--; } } 109bd4: 8d 65 f4 lea -0xc(%ebp),%esp 109bd7: 5b pop %ebx 109bd8: 5e pop %esi 109bd9: 5f pop %edi 109bda: c9 leave 109bdb: c3 ret unsigned int newHead; rtems_interrupt_level level; rtems_status_code sc; if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) { (*tty->device.write)(tty->minor, (void *)buf, len); 109bdc: 89 55 10 mov %edx,0x10(%ebp) 109bdf: 89 45 0c mov %eax,0xc(%ebp) 109be2: 8b 43 10 mov 0x10(%ebx),%eax 109be5: 89 45 08 mov %eax,0x8(%ebp) 109be8: 8b 83 a4 00 00 00 mov 0xa4(%ebx),%eax tty->rawOutBufState = rob_busy; } rtems_interrupt_enable (level); len--; } } 109bee: 8d 65 f4 lea -0xc(%ebp),%esp 109bf1: 5b pop %ebx 109bf2: 5e pop %esi 109bf3: 5f pop %edi 109bf4: c9 leave unsigned int newHead; rtems_interrupt_level level; rtems_status_code sc; if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) { (*tty->device.write)(tty->minor, (void *)buf, len); 109bf5: ff e0 jmp *%eax tty->rawOutBufState = rob_wait; rtems_interrupt_enable (level); sc = rtems_semaphore_obtain( tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); 109bf7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109bfa: 50 push %eax <== NOT EXECUTED 109bfb: e8 f4 20 00 00 call 10bcf4 <== NOT EXECUTED =============================================================================== 0010a1d8 : return RTEMS_SUCCESSFUL; } rtems_status_code rtems_termios_read (void *arg) { 10a1d8: 55 push %ebp 10a1d9: 89 e5 mov %esp,%ebp 10a1db: 57 push %edi 10a1dc: 56 push %esi 10a1dd: 53 push %ebx 10a1de: 83 ec 30 sub $0x30,%esp rtems_libio_rw_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 10a1e1: 8b 55 08 mov 0x8(%ebp),%edx 10a1e4: 8b 02 mov (%edx),%eax 10a1e6: 8b 58 34 mov 0x34(%eax),%ebx uint32_t count = args->count; 10a1e9: 8b 4a 10 mov 0x10(%edx),%ecx 10a1ec: 89 4d dc mov %ecx,-0x24(%ebp) char *buffer = args->buffer; 10a1ef: 8b 42 0c mov 0xc(%edx),%eax 10a1f2: 89 45 d8 mov %eax,-0x28(%ebp) rtems_status_code sc; sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 10a1f5: 6a 00 push $0x0 10a1f7: 6a 00 push $0x0 10a1f9: ff 73 14 pushl 0x14(%ebx) 10a1fc: e8 af 14 00 00 call 10b6b0 10a201: 89 45 e0 mov %eax,-0x20(%ebp) if (sc != RTEMS_SUCCESSFUL) 10a204: 83 c4 10 add $0x10,%esp 10a207: 85 c0 test %eax,%eax 10a209: 75 35 jne 10a240 <== NEVER TAKEN return sc; if (rtems_termios_linesw[tty->t_line].l_read != NULL) { 10a20b: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax 10a211: c1 e0 05 shl $0x5,%eax 10a214: 8b 80 08 79 12 00 mov 0x127908(%eax),%eax 10a21a: 85 c0 test %eax,%eax 10a21c: 74 2e je 10a24c sc = rtems_termios_linesw[tty->t_line].l_read(tty,args); 10a21e: 83 ec 08 sub $0x8,%esp 10a221: ff 75 08 pushl 0x8(%ebp) 10a224: 53 push %ebx 10a225: ff d0 call *%eax 10a227: 89 45 e0 mov %eax,-0x20(%ebp) tty->tty_rcvwakeup = 0; 10a22a: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx) 10a231: 00 00 00 rtems_semaphore_release (tty->isem); 10a234: 59 pop %ecx 10a235: ff 73 14 pushl 0x14(%ebx) 10a238: e8 6f 15 00 00 call 10b7ac return sc; 10a23d: 83 c4 10 add $0x10,%esp } args->bytes_moved = args->count - count; tty->tty_rcvwakeup = 0; rtems_semaphore_release (tty->isem); return sc; } 10a240: 8b 45 e0 mov -0x20(%ebp),%eax 10a243: 8d 65 f4 lea -0xc(%ebp),%esp 10a246: 5b pop %ebx 10a247: 5e pop %esi 10a248: 5f pop %edi 10a249: c9 leave 10a24a: c3 ret 10a24b: 90 nop tty->tty_rcvwakeup = 0; rtems_semaphore_release (tty->isem); return sc; } if (tty->cindex == tty->ccount) { 10a24c: 8b 53 20 mov 0x20(%ebx),%edx 10a24f: 39 53 24 cmp %edx,0x24(%ebx) 10a252: 74 5f je 10a2b3 <== ALWAYS TAKEN sc = fillBufferQueue (tty); if (sc != RTEMS_SUCCESSFUL) tty->cindex = tty->ccount = 0; } while (count && (tty->cindex < tty->ccount)) { 10a254: 8b 45 dc mov -0x24(%ebp),%eax 10a257: 85 c0 test %eax,%eax 10a259: 74 29 je 10a284 <== NEVER TAKEN 10a25b: 8b 43 24 mov 0x24(%ebx),%eax 10a25e: 3b 43 20 cmp 0x20(%ebx),%eax 10a261: 7d 21 jge 10a284 <== NEVER TAKEN 10a263: 8b 55 d8 mov -0x28(%ebp),%edx 10a266: 8b 7d dc mov -0x24(%ebp),%edi 10a269: eb 06 jmp 10a271 10a26b: 90 nop 10a26c: 39 43 20 cmp %eax,0x20(%ebx) 10a26f: 7e 10 jle 10a281 *buffer++ = tty->cbuf[tty->cindex++]; 10a271: 8b 73 1c mov 0x1c(%ebx),%esi 10a274: 8a 0c 06 mov (%esi,%eax,1),%cl 10a277: 88 0a mov %cl,(%edx) 10a279: 42 inc %edx 10a27a: 40 inc %eax 10a27b: 89 43 24 mov %eax,0x24(%ebx) sc = fillBufferQueue (tty); if (sc != RTEMS_SUCCESSFUL) tty->cindex = tty->ccount = 0; } while (count && (tty->cindex < tty->ccount)) { 10a27e: 4f dec %edi 10a27f: 75 eb jne 10a26c 10a281: 89 7d dc mov %edi,-0x24(%ebp) *buffer++ = tty->cbuf[tty->cindex++]; count--; } args->bytes_moved = args->count - count; 10a284: 8b 55 08 mov 0x8(%ebp),%edx 10a287: 8b 42 10 mov 0x10(%edx),%eax 10a28a: 2b 45 dc sub -0x24(%ebp),%eax 10a28d: 89 42 18 mov %eax,0x18(%edx) tty->tty_rcvwakeup = 0; 10a290: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx) 10a297: 00 00 00 rtems_semaphore_release (tty->isem); 10a29a: 83 ec 0c sub $0xc,%esp 10a29d: ff 73 14 pushl 0x14(%ebx) 10a2a0: e8 07 15 00 00 call 10b7ac return sc; 10a2a5: 83 c4 10 add $0x10,%esp } 10a2a8: 8b 45 e0 mov -0x20(%ebp),%eax 10a2ab: 8d 65 f4 lea -0xc(%ebp),%esp 10a2ae: 5b pop %ebx 10a2af: 5e pop %esi 10a2b0: 5f pop %edi 10a2b1: c9 leave 10a2b2: c3 ret rtems_semaphore_release (tty->isem); return sc; } if (tty->cindex == tty->ccount) { tty->cindex = tty->ccount = 0; 10a2b3: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) 10a2ba: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) tty->read_start_column = tty->column; 10a2c1: 8b 43 28 mov 0x28(%ebx),%eax 10a2c4: 89 43 2c mov %eax,0x2c(%ebx) if (tty->device.pollRead != NULL && 10a2c7: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax 10a2cd: 85 c0 test %eax,%eax 10a2cf: 74 0e je 10a2df 10a2d1: 8b 93 b4 00 00 00 mov 0xb4(%ebx),%edx 10a2d7: 85 d2 test %edx,%edx 10a2d9: 0f 84 82 01 00 00 je 10a461 * Fill the input buffer from the raw input queue */ static rtems_status_code fillBufferQueue (struct rtems_termios_tty *tty) { rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout; 10a2df: 8b 73 74 mov 0x74(%ebx),%esi rtems_status_code sc; int wait = (int)1; 10a2e2: c7 45 e4 01 00 00 00 movl $0x1,-0x1c(%ebp) if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF)) == (FL_MDXON | FL_ISNTXOF)) && ((tty->rawOutBufState == rob_idle) || (tty->flow_ctrl & FL_OSTOP))) { /* XON should be sent now... */ (*tty->device.write)( 10a2e9: 8d 4b 49 lea 0x49(%ebx),%ecx 10a2ec: 89 4d d4 mov %ecx,-0x2c(%ebp) 10a2ef: 90 nop while ( wait ) { /* * Process characters read from raw queue */ while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) && 10a2f0: 8b 53 5c mov 0x5c(%ebx),%edx 10a2f3: 8b 43 60 mov 0x60(%ebx),%eax 10a2f6: 39 c2 cmp %eax,%edx 10a2f8: 0f 84 06 01 00 00 je 10a404 (tty->ccount < (CBUFSIZE-1))) { 10a2fe: a1 80 59 12 00 mov 0x125980,%eax 10a303: 48 dec %eax while ( wait ) { /* * Process characters read from raw queue */ while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) && 10a304: 3b 43 20 cmp 0x20(%ebx),%eax 10a307: 7f 3c jg 10a345 <== ALWAYS TAKEN 10a309: e9 f6 00 00 00 jmp 10a404 <== NOT EXECUTED 10a30e: 66 90 xchg %ax,%ax <== NOT EXECUTED } } /* continue processing new character */ if (tty->termios.c_lflag & ICANON) { if (siproc (c, tty)) 10a310: 0f b6 c1 movzbl %cl,%eax 10a313: 89 da mov %ebx,%edx 10a315: e8 9e fd ff ff call 10a0b8 10a31a: 85 c0 test %eax,%eax 10a31c: 74 07 je 10a325 wait = 0; } else { siproc (c, tty); if (tty->ccount >= tty->termios.c_cc[VMIN]) wait = 0; 10a31e: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) } timeout = tty->rawInBufSemaphoreTimeout; 10a325: 8b 73 70 mov 0x70(%ebx),%esi while ( wait ) { /* * Process characters read from raw queue */ while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) && 10a328: 8b 53 5c mov 0x5c(%ebx),%edx 10a32b: 8b 43 60 mov 0x60(%ebx),%eax 10a32e: 39 c2 cmp %eax,%edx 10a330: 0f 84 ce 00 00 00 je 10a404 (tty->ccount < (CBUFSIZE-1))) { 10a336: a1 80 59 12 00 mov 0x125980,%eax 10a33b: 48 dec %eax while ( wait ) { /* * Process characters read from raw queue */ while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) && 10a33c: 39 43 20 cmp %eax,0x20(%ebx) 10a33f: 0f 8d bf 00 00 00 jge 10a404 <== NEVER TAKEN (tty->ccount < (CBUFSIZE-1))) { unsigned char c; unsigned int newHead; newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size; 10a345: 8b 43 5c mov 0x5c(%ebx),%eax 10a348: 8b 4b 64 mov 0x64(%ebx),%ecx 10a34b: 40 inc %eax 10a34c: 31 d2 xor %edx,%edx 10a34e: f7 f1 div %ecx c = tty->rawInBuf.theBuf[newHead]; 10a350: 8b 43 58 mov 0x58(%ebx),%eax 10a353: 8a 0c 10 mov (%eax,%edx,1),%cl tty->rawInBuf.Head = newHead; 10a356: 89 53 5c mov %edx,0x5c(%ebx) if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size) 10a359: 8b 43 60 mov 0x60(%ebx),%eax 10a35c: 8b 7b 64 mov 0x64(%ebx),%edi % tty->rawInBuf.Size) 10a35f: 8b 73 64 mov 0x64(%ebx),%esi unsigned int newHead; newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size; c = tty->rawInBuf.theBuf[newHead]; tty->rawInBuf.Head = newHead; if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size) 10a362: 8d 04 07 lea (%edi,%eax,1),%eax 10a365: 29 d0 sub %edx,%eax % tty->rawInBuf.Size) 10a367: 31 d2 xor %edx,%edx 10a369: f7 f6 div %esi unsigned int newHead; newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size; c = tty->rawInBuf.theBuf[newHead]; tty->rawInBuf.Head = newHead; if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size) 10a36b: 3b 93 bc 00 00 00 cmp 0xbc(%ebx),%edx 10a371: 73 5d jae 10a3d0 <== NEVER TAKEN % tty->rawInBuf.Size) < tty->lowwater) { tty->flow_ctrl &= ~FL_IREQXOF; 10a373: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 10a379: 83 e0 fe and $0xfffffffe,%eax 10a37c: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) /* if tx stopped and XON should be sent... */ if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF)) 10a382: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 10a388: 25 02 02 00 00 and $0x202,%eax 10a38d: 3d 02 02 00 00 cmp $0x202,%eax 10a392: 0f 84 94 00 00 00 je 10a42c <== NEVER TAKEN && ((tty->rawOutBufState == rob_idle) || (tty->flow_ctrl & FL_OSTOP))) { /* XON should be sent now... */ (*tty->device.write)( tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1); } else if (tty->flow_ctrl & FL_MDRTS) { 10a398: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 10a39e: f6 c4 01 test $0x1,%ah 10a3a1: 74 2d je 10a3d0 <== ALWAYS TAKEN tty->flow_ctrl &= ~FL_IRTSOFF; 10a3a3: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10a3a9: 83 e0 fb and $0xfffffffb,%eax <== NOT EXECUTED 10a3ac: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED /* activate RTS line */ if (tty->device.startRemoteTx != NULL) { 10a3b2: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax <== NOT EXECUTED 10a3b8: 85 c0 test %eax,%eax <== NOT EXECUTED 10a3ba: 74 14 je 10a3d0 <== NOT EXECUTED tty->device.startRemoteTx(tty->minor); 10a3bc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a3bf: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 10a3c2: 88 4d d0 mov %cl,-0x30(%ebp) <== NOT EXECUTED 10a3c5: ff d0 call *%eax <== NOT EXECUTED 10a3c7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a3ca: 8a 4d d0 mov -0x30(%ebp),%cl <== NOT EXECUTED 10a3cd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED } } } /* continue processing new character */ if (tty->termios.c_lflag & ICANON) { 10a3d0: f6 43 3c 02 testb $0x2,0x3c(%ebx) 10a3d4: 0f 85 36 ff ff ff jne 10a310 <== ALWAYS TAKEN if (siproc (c, tty)) wait = 0; } else { siproc (c, tty); 10a3da: 0f b6 c1 movzbl %cl,%eax <== NOT EXECUTED 10a3dd: 89 da mov %ebx,%edx <== NOT EXECUTED 10a3df: e8 d4 fc ff ff call 10a0b8 <== NOT EXECUTED if (tty->ccount >= tty->termios.c_cc[VMIN]) 10a3e4: 0f b6 43 47 movzbl 0x47(%ebx),%eax <== NOT EXECUTED 10a3e8: 39 43 20 cmp %eax,0x20(%ebx) <== NOT EXECUTED 10a3eb: 0f 8d 2d ff ff ff jge 10a31e <== NOT EXECUTED wait = 0; } timeout = tty->rawInBufSemaphoreTimeout; 10a3f1: 8b 73 70 mov 0x70(%ebx),%esi <== NOT EXECUTED while ( wait ) { /* * Process characters read from raw queue */ while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) && 10a3f4: 8b 53 5c mov 0x5c(%ebx),%edx <== NOT EXECUTED 10a3f7: 8b 43 60 mov 0x60(%ebx),%eax <== NOT EXECUTED 10a3fa: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10a3fc: 0f 85 34 ff ff ff jne 10a336 <== NOT EXECUTED 10a402: 66 90 xchg %ax,%ax <== NOT EXECUTED } /* * Wait for characters */ if ( wait ) { 10a404: 8b 4d e4 mov -0x1c(%ebp),%ecx 10a407: 85 c9 test %ecx,%ecx 10a409: 0f 84 45 fe ff ff je 10a254 sc = rtems_semaphore_obtain( 10a40f: 52 push %edx 10a410: 56 push %esi 10a411: ff 73 6c pushl 0x6c(%ebx) 10a414: ff 73 68 pushl 0x68(%ebx) 10a417: e8 94 12 00 00 call 10b6b0 tty->rawInBuf.Semaphore, tty->rawInBufSemaphoreOptions, timeout); if (sc != RTEMS_SUCCESSFUL) 10a41c: 83 c4 10 add $0x10,%esp 10a41f: 85 c0 test %eax,%eax 10a421: 0f 84 c9 fe ff ff je 10a2f0 <== ALWAYS TAKEN 10a427: e9 28 fe ff ff jmp 10a254 <== NOT EXECUTED < tty->lowwater) { tty->flow_ctrl &= ~FL_IREQXOF; /* if tx stopped and XON should be sent... */ if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF)) == (FL_MDXON | FL_ISNTXOF)) && ((tty->rawOutBufState == rob_idle) 10a42c: 8b bb 94 00 00 00 mov 0x94(%ebx),%edi <== NOT EXECUTED 10a432: 85 ff test %edi,%edi <== NOT EXECUTED 10a434: 74 0e je 10a444 <== NOT EXECUTED || (tty->flow_ctrl & FL_OSTOP))) { 10a436: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10a43c: a8 20 test $0x20,%al <== NOT EXECUTED 10a43e: 0f 84 54 ff ff ff je 10a398 <== NOT EXECUTED /* XON should be sent now... */ (*tty->device.write)( 10a444: 56 push %esi <== NOT EXECUTED 10a445: 6a 01 push $0x1 <== NOT EXECUTED 10a447: ff 75 d4 pushl -0x2c(%ebp) <== NOT EXECUTED 10a44a: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 10a44d: 88 4d d0 mov %cl,-0x30(%ebp) <== NOT EXECUTED 10a450: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED 10a456: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a459: 8a 4d d0 mov -0x30(%ebp),%cl <== NOT EXECUTED 10a45c: e9 6f ff ff ff jmp 10a3d0 <== NOT EXECUTED static rtems_status_code fillBufferPoll (struct rtems_termios_tty *tty) { int n; if (tty->termios.c_lflag & ICANON) { 10a461: f6 43 3c 02 testb $0x2,0x3c(%ebx) 10a465: 75 1d jne 10a484 <== NEVER TAKEN 10a467: eb 39 jmp 10a4a2 10a469: 8d 76 00 lea 0x0(%esi),%esi for (;;) { n = (*tty->device.pollRead)(tty->minor); if (n < 0) { rtems_task_wake_after (1); } else { if (siproc (n, tty)) 10a46c: 0f b6 c0 movzbl %al,%eax 10a46f: 89 da mov %ebx,%edx 10a471: e8 42 fc ff ff call 10a0b8 10a476: 85 c0 test %eax,%eax 10a478: 0f 85 d6 fd ff ff jne 10a254 <== NEVER TAKEN static rtems_status_code fillBufferPoll (struct rtems_termios_tty *tty) { int n; if (tty->termios.c_lflag & ICANON) { 10a47e: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax for (;;) { n = (*tty->device.pollRead)(tty->minor); 10a484: 83 ec 0c sub $0xc,%esp 10a487: ff 73 10 pushl 0x10(%ebx) 10a48a: ff d0 call *%eax if (n < 0) { 10a48c: 83 c4 10 add $0x10,%esp 10a48f: 85 c0 test %eax,%eax 10a491: 79 d9 jns 10a46c <== NEVER TAKEN rtems_task_wake_after (1); 10a493: 83 ec 0c sub $0xc,%esp 10a496: 6a 01 push $0x1 10a498: e8 cb 16 00 00 call 10bb68 10a49d: 83 c4 10 add $0x10,%esp 10a4a0: eb dc jmp 10a47e } } } else { rtems_interval then, now; then = rtems_clock_get_ticks_since_boot(); 10a4a2: e8 01 0b 00 00 call 10afa8 10a4a7: 89 c6 mov %eax,%esi 10a4a9: 8d 76 00 lea 0x0(%esi),%esi for (;;) { n = (*tty->device.pollRead)(tty->minor); 10a4ac: 83 ec 0c sub $0xc,%esp 10a4af: ff 73 10 pushl 0x10(%ebx) 10a4b2: ff 93 a0 00 00 00 call *0xa0(%ebx) if (n < 0) { 10a4b8: 83 c4 10 add $0x10,%esp 10a4bb: 85 c0 test %eax,%eax 10a4bd: 78 25 js 10a4e4 break; } } rtems_task_wake_after (1); } else { siproc (n, tty); 10a4bf: 0f b6 c0 movzbl %al,%eax 10a4c2: 89 da mov %ebx,%edx 10a4c4: e8 ef fb ff ff call 10a0b8 if (tty->ccount >= tty->termios.c_cc[VMIN]) 10a4c9: 8a 43 47 mov 0x47(%ebx),%al 10a4cc: 0f b6 d0 movzbl %al,%edx 10a4cf: 39 53 20 cmp %edx,0x20(%ebx) 10a4d2: 0f 8d 7c fd ff ff jge 10a254 <== NEVER TAKEN break; if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME]) 10a4d8: 84 c0 test %al,%al 10a4da: 74 d0 je 10a4ac <== NEVER TAKEN 10a4dc: 80 7b 46 00 cmpb $0x0,0x46(%ebx) 10a4e0: 74 ca je 10a4ac <== NEVER TAKEN 10a4e2: eb be jmp 10a4a2 then = rtems_clock_get_ticks_since_boot(); for (;;) { n = (*tty->device.pollRead)(tty->minor); if (n < 0) { if (tty->termios.c_cc[VMIN]) { 10a4e4: 80 7b 47 00 cmpb $0x0,0x47(%ebx) 10a4e8: 74 1d je 10a507 <== NEVER TAKEN if (tty->termios.c_cc[VTIME] && tty->ccount) { 10a4ea: 80 7b 46 00 cmpb $0x0,0x46(%ebx) 10a4ee: 74 08 je 10a4f8 <== NEVER TAKEN 10a4f0: 8b 43 20 mov 0x20(%ebx),%eax 10a4f3: 85 c0 test %eax,%eax 10a4f5: 75 1a jne 10a511 10a4f7: 90 nop now = rtems_clock_get_ticks_since_boot(); if ((now - then) > tty->vtimeTicks) { break; } } rtems_task_wake_after (1); 10a4f8: 83 ec 0c sub $0xc,%esp 10a4fb: 6a 01 push $0x1 10a4fd: e8 66 16 00 00 call 10bb68 10a502: 83 c4 10 add $0x10,%esp 10a505: eb a5 jmp 10a4ac if ((now - then) > tty->vtimeTicks) { break; } } } else { if (!tty->termios.c_cc[VTIME]) 10a507: 80 7b 46 00 cmpb $0x0,0x46(%ebx) <== NOT EXECUTED 10a50b: 0f 84 43 fd ff ff je 10a254 <== NOT EXECUTED break; now = rtems_clock_get_ticks_since_boot(); 10a511: e8 92 0a 00 00 call 10afa8 if ((now - then) > tty->vtimeTicks) { 10a516: 29 f0 sub %esi,%eax 10a518: 3b 43 54 cmp 0x54(%ebx),%eax 10a51b: 76 db jbe 10a4f8 10a51d: e9 32 fd ff ff jmp 10a254 =============================================================================== 0010a8b8 : * in task-driven mode, this function is called in Tx task context * in interrupt-driven mode, this function is called in TxIRQ context */ int rtems_termios_refill_transmitter (struct rtems_termios_tty *tty) { 10a8b8: 55 push %ebp 10a8b9: 89 e5 mov %esp,%ebp 10a8bb: 57 push %edi 10a8bc: 56 push %esi 10a8bd: 53 push %ebx 10a8be: 83 ec 0c sub $0xc,%esp 10a8c1: 8b 5d 08 mov 0x8(%ebp),%ebx int nToSend; rtems_interrupt_level level; int len; /* check for XOF/XON to send */ if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF)) 10a8c4: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 10a8ca: 25 03 04 00 00 and $0x403,%eax 10a8cf: 3d 01 04 00 00 cmp $0x401,%eax 10a8d4: 0f 84 62 01 00 00 je 10aa3c <== NEVER TAKEN tty->flow_ctrl |= FL_ISNTXOF; rtems_interrupt_enable(level); nToSend = 1; } else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF)) == FL_ISNTXOF) { 10a8da: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 10a8e0: 83 e0 03 and $0x3,%eax 10a8e3: 83 f8 02 cmp $0x2,%eax 10a8e6: 0f 84 8c 01 00 00 je 10aa78 <== NEVER TAKEN tty->flow_ctrl &= ~FL_ISNTXOF; rtems_interrupt_enable(level); nToSend = 1; } else { if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) { 10a8ec: 8b 93 80 00 00 00 mov 0x80(%ebx),%edx 10a8f2: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax 10a8f8: 39 c2 cmp %eax,%edx 10a8fa: 0f 84 a4 00 00 00 je 10a9a4 rtems_semaphore_release (tty->rawOutBuf.Semaphore); } return 0; } rtems_interrupt_disable(level); 10a900: 9c pushf 10a901: fa cli 10a902: 58 pop %eax len = tty->t_dqlen; 10a903: 8b b3 90 00 00 00 mov 0x90(%ebx),%esi tty->t_dqlen = 0; 10a909: c7 83 90 00 00 00 00 movl $0x0,0x90(%ebx) 10a910: 00 00 00 rtems_interrupt_enable(level); 10a913: 50 push %eax 10a914: 9d popf newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size; 10a915: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax 10a91b: 8b 8b 88 00 00 00 mov 0x88(%ebx),%ecx 10a921: 8d 04 06 lea (%esi,%eax,1),%eax 10a924: 31 d2 xor %edx,%edx 10a926: f7 f1 div %ecx 10a928: 89 d6 mov %edx,%esi tty->rawOutBuf.Tail = newTail; 10a92a: 89 93 84 00 00 00 mov %edx,0x84(%ebx) if (tty->rawOutBufState == rob_wait) { 10a930: 83 bb 94 00 00 00 02 cmpl $0x2,0x94(%ebx) 10a937: 0f 84 e7 00 00 00 je 10aa24 * wake up any pending writer task */ rtems_semaphore_release (tty->rawOutBuf.Semaphore); } if (newTail == tty->rawOutBuf.Head) { 10a93d: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax 10a943: 39 f0 cmp %esi,%eax 10a945: 74 79 je 10a9c0 if ( tty->tty_snd.sw_pfn != NULL) { (*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg); } } /* check, whether output should stop due to received XOFF */ else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF)) 10a947: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 10a94d: 25 10 02 00 00 and $0x210,%eax 10a952: 3d 10 02 00 00 cmp $0x210,%eax 10a957: 0f 84 57 01 00 00 je 10aab4 <== NEVER TAKEN nToSend = 0; } else { /* * Buffer not empty, start tranmitter */ if (newTail > tty->rawOutBuf.Head) 10a95d: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax 10a963: 39 c6 cmp %eax,%esi 10a965: 0f 87 91 00 00 00 ja 10a9fc nToSend = tty->rawOutBuf.Size - newTail; else nToSend = tty->rawOutBuf.Head - newTail; 10a96b: 8b bb 80 00 00 00 mov 0x80(%ebx),%edi 10a971: 29 f7 sub %esi,%edi /* when flow control XON or XOF, don't send blocks of data */ /* to allow fast reaction on incoming flow ctrl and low latency*/ /* for outgoing flow control */ if (tty->flow_ctrl & (FL_MDXON | FL_MDXOF)) { 10a973: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 10a979: f6 c4 06 test $0x6,%ah 10a97c: 0f 85 91 00 00 00 jne 10aa13 10a982: 89 f8 mov %edi,%eax nToSend = 1; } tty->rawOutBufState = rob_busy; /*apm*/ 10a984: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx) 10a98b: 00 00 00 (*tty->device.write)( 10a98e: 52 push %edx 10a98f: 50 push %eax 10a990: 8b 43 7c mov 0x7c(%ebx),%eax 10a993: 01 f0 add %esi,%eax 10a995: 50 push %eax 10a996: ff 73 10 pushl 0x10(%ebx) 10a999: ff 93 a4 00 00 00 call *0xa4(%ebx) 10a99f: 83 c4 10 add $0x10,%esp 10a9a2: eb 48 jmp 10a9ec } else { if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) { /* * buffer was empty */ if (tty->rawOutBufState == rob_wait) { 10a9a4: 83 bb 94 00 00 00 02 cmpl $0x2,0x94(%ebx) 10a9ab: 0f 84 2b 01 00 00 je 10aadc <== NEVER TAKEN /* * this should never happen... */ rtems_semaphore_release (tty->rawOutBuf.Semaphore); } return 0; 10a9b1: 31 ff xor %edi,%edi tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend); } tty->rawOutBuf.Tail = newTail; /*apm*/ } return nToSend; } 10a9b3: 89 f8 mov %edi,%eax 10a9b5: 8d 65 f4 lea -0xc(%ebp),%esp 10a9b8: 5b pop %ebx 10a9b9: 5e pop %esi 10a9ba: 5f pop %edi 10a9bb: c9 leave 10a9bc: c3 ret 10a9bd: 8d 76 00 lea 0x0(%esi),%esi if (newTail == tty->rawOutBuf.Head) { /* * Buffer has become empty */ tty->rawOutBufState = rob_idle; 10a9c0: c7 83 94 00 00 00 00 movl $0x0,0x94(%ebx) 10a9c7: 00 00 00 nToSend = 0; /* * check to see if snd wakeup callback was set */ if ( tty->tty_snd.sw_pfn != NULL) { 10a9ca: 8b 83 d4 00 00 00 mov 0xd4(%ebx),%eax 10a9d0: 85 c0 test %eax,%eax 10a9d2: 0f 84 1c 01 00 00 je 10aaf4 <== ALWAYS TAKEN (*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg); 10a9d8: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a9db: ff b3 d8 00 00 00 pushl 0xd8(%ebx) <== NOT EXECUTED 10a9e1: 8d 53 30 lea 0x30(%ebx),%edx <== NOT EXECUTED 10a9e4: 52 push %edx <== NOT EXECUTED 10a9e5: ff d0 call *%eax <== NOT EXECUTED 10a9e7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if (newTail == tty->rawOutBuf.Head) { /* * Buffer has become empty */ tty->rawOutBufState = rob_idle; nToSend = 0; 10a9ea: 31 ff xor %edi,%edi <== NOT EXECUTED } tty->rawOutBufState = rob_busy; /*apm*/ (*tty->device.write)( tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend); } tty->rawOutBuf.Tail = newTail; /*apm*/ 10a9ec: 89 b3 84 00 00 00 mov %esi,0x84(%ebx) } return nToSend; } 10a9f2: 89 f8 mov %edi,%eax 10a9f4: 8d 65 f4 lea -0xc(%ebp),%esp 10a9f7: 5b pop %ebx 10a9f8: 5e pop %esi 10a9f9: 5f pop %edi 10a9fa: c9 leave 10a9fb: c3 ret } else { /* * Buffer not empty, start tranmitter */ if (newTail > tty->rawOutBuf.Head) nToSend = tty->rawOutBuf.Size - newTail; 10a9fc: 8b bb 88 00 00 00 mov 0x88(%ebx),%edi 10aa02: 29 f7 sub %esi,%edi else nToSend = tty->rawOutBuf.Head - newTail; /* when flow control XON or XOF, don't send blocks of data */ /* to allow fast reaction on incoming flow ctrl and low latency*/ /* for outgoing flow control */ if (tty->flow_ctrl & (FL_MDXON | FL_MDXOF)) { 10aa04: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 10aa0a: f6 c4 06 test $0x6,%ah 10aa0d: 0f 84 6f ff ff ff je 10a982 <== ALWAYS TAKEN 10aa13: b8 01 00 00 00 mov $0x1,%eax nToSend = 1; 10aa18: bf 01 00 00 00 mov $0x1,%edi 10aa1d: e9 62 ff ff ff jmp 10a984 10aa22: 66 90 xchg %ax,%ax tty->rawOutBuf.Tail = newTail; if (tty->rawOutBufState == rob_wait) { /* * wake up any pending writer task */ rtems_semaphore_release (tty->rawOutBuf.Semaphore); 10aa24: 83 ec 0c sub $0xc,%esp 10aa27: ff b3 8c 00 00 00 pushl 0x8c(%ebx) 10aa2d: e8 7a 0d 00 00 call 10b7ac 10aa32: 83 c4 10 add $0x10,%esp 10aa35: e9 03 ff ff ff jmp 10a93d 10aa3a: 66 90 xchg %ax,%ax /* check for XOF/XON to send */ if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF)) == (FL_MDXOF | FL_IREQXOF)) { /* XOFF should be sent now... */ (*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1); 10aa3c: 56 push %esi <== NOT EXECUTED 10aa3d: 6a 01 push $0x1 <== NOT EXECUTED 10aa3f: 8d 43 4a lea 0x4a(%ebx),%eax <== NOT EXECUTED 10aa42: 50 push %eax <== NOT EXECUTED 10aa43: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 10aa46: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED rtems_interrupt_disable(level); 10aa4c: 9c pushf <== NOT EXECUTED 10aa4d: fa cli <== NOT EXECUTED 10aa4e: 5a pop %edx <== NOT EXECUTED tty->t_dqlen--; 10aa4f: ff 8b 90 00 00 00 decl 0x90(%ebx) <== NOT EXECUTED tty->flow_ctrl |= FL_ISNTXOF; 10aa55: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10aa5b: 83 c8 02 or $0x2,%eax <== NOT EXECUTED 10aa5e: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED rtems_interrupt_enable(level); 10aa64: 52 push %edx <== NOT EXECUTED 10aa65: 9d popf <== NOT EXECUTED 10aa66: 83 c4 10 add $0x10,%esp <== NOT EXECUTED nToSend = 1; 10aa69: bf 01 00 00 00 mov $0x1,%edi <== NOT EXECUTED tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend); } tty->rawOutBuf.Tail = newTail; /*apm*/ } return nToSend; } 10aa6e: 89 f8 mov %edi,%eax <== NOT EXECUTED 10aa70: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10aa73: 5b pop %ebx <== NOT EXECUTED 10aa74: 5e pop %esi <== NOT EXECUTED 10aa75: 5f pop %edi <== NOT EXECUTED 10aa76: c9 leave <== NOT EXECUTED 10aa77: c3 ret <== NOT EXECUTED * FIXME: this .write call will generate another * dequeue callback. This will advance the "Tail" in the data * buffer, although the corresponding data is not yet out! * Therefore the dequeue "length" should be reduced by 1 */ (*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1); 10aa78: 51 push %ecx <== NOT EXECUTED 10aa79: 6a 01 push $0x1 <== NOT EXECUTED 10aa7b: 8d 43 49 lea 0x49(%ebx),%eax <== NOT EXECUTED 10aa7e: 50 push %eax <== NOT EXECUTED 10aa7f: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 10aa82: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED rtems_interrupt_disable(level); 10aa88: 9c pushf <== NOT EXECUTED 10aa89: fa cli <== NOT EXECUTED 10aa8a: 5a pop %edx <== NOT EXECUTED tty->t_dqlen--; 10aa8b: ff 8b 90 00 00 00 decl 0x90(%ebx) <== NOT EXECUTED tty->flow_ctrl &= ~FL_ISNTXOF; 10aa91: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10aa97: 83 e0 fd and $0xfffffffd,%eax <== NOT EXECUTED 10aa9a: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED rtems_interrupt_enable(level); 10aaa0: 52 push %edx <== NOT EXECUTED 10aaa1: 9d popf <== NOT EXECUTED 10aaa2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED nToSend = 1; 10aaa5: bf 01 00 00 00 mov $0x1,%edi <== NOT EXECUTED tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend); } tty->rawOutBuf.Tail = newTail; /*apm*/ } return nToSend; } 10aaaa: 89 f8 mov %edi,%eax <== NOT EXECUTED 10aaac: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10aaaf: 5b pop %ebx <== NOT EXECUTED 10aab0: 5e pop %esi <== NOT EXECUTED 10aab1: 5f pop %edi <== NOT EXECUTED 10aab2: c9 leave <== NOT EXECUTED 10aab3: c3 ret <== NOT EXECUTED /* check, whether output should stop due to received XOFF */ else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF)) == (FL_MDXON | FL_ORCVXOF)) { /* Buffer not empty, but output stops due to XOFF */ /* set flag, that output has been stopped */ rtems_interrupt_disable(level); 10aab4: 9c pushf <== NOT EXECUTED 10aab5: fa cli <== NOT EXECUTED 10aab6: 5a pop %edx <== NOT EXECUTED tty->flow_ctrl |= FL_OSTOP; 10aab7: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10aabd: 83 c8 20 or $0x20,%eax <== NOT EXECUTED 10aac0: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED tty->rawOutBufState = rob_busy; /*apm*/ 10aac6: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx) <== NOT EXECUTED 10aacd: 00 00 00 rtems_interrupt_enable(level); 10aad0: 52 push %edx <== NOT EXECUTED 10aad1: 9d popf <== NOT EXECUTED nToSend = 0; 10aad2: 31 ff xor %edi,%edi <== NOT EXECUTED 10aad4: e9 13 ff ff ff jmp 10a9ec <== NOT EXECUTED 10aad9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED */ if (tty->rawOutBufState == rob_wait) { /* * this should never happen... */ rtems_semaphore_release (tty->rawOutBuf.Semaphore); 10aadc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aadf: ff b3 8c 00 00 00 pushl 0x8c(%ebx) <== NOT EXECUTED 10aae5: e8 c2 0c 00 00 call 10b7ac <== NOT EXECUTED 10aaea: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return 0; 10aaed: 31 ff xor %edi,%edi <== NOT EXECUTED 10aaef: e9 bf fe ff ff jmp 10a9b3 <== NOT EXECUTED if (newTail == tty->rawOutBuf.Head) { /* * Buffer has become empty */ tty->rawOutBufState = rob_idle; nToSend = 0; 10aaf4: 31 ff xor %edi,%edi 10aaf6: e9 f1 fe ff ff jmp 10a9ec =============================================================================== 0010a84c : /* * this task actually processes any receive events */ static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument) { 10a84c: 55 push %ebp 10a84d: 89 e5 mov %esp,%ebp 10a84f: 57 push %edi 10a850: 56 push %esi 10a851: 53 push %ebx 10a852: 83 ec 1c sub $0x1c,%esp 10a855: 8b 5d 08 mov 0x8(%ebp),%ebx 10a858: 8d 75 e0 lea -0x20(%ebp),%esi 10a85b: 8d 7d e7 lea -0x19(%ebp),%edi 10a85e: eb 14 jmp 10a874 } /* * do something */ c = tty->device.pollRead(tty->minor); 10a860: 83 ec 0c sub $0xc,%esp 10a863: ff 73 10 pushl 0x10(%ebx) 10a866: ff 93 a0 00 00 00 call *0xa0(%ebx) if (c != EOF) { 10a86c: 83 c4 10 add $0x10,%esp 10a86f: 83 f8 ff cmp $0xffffffff,%eax 10a872: 75 30 jne 10a8a4 while (1) { /* * wait for rtems event */ rtems_event_receive( 10a874: 56 push %esi 10a875: 6a 00 push $0x0 10a877: 6a 02 push $0x2 10a879: 6a 03 push $0x3 10a87b: e8 94 07 00 00 call 10b014 (TERMIOS_RX_PROC_EVENT | TERMIOS_RX_TERMINATE_EVENT), RTEMS_EVENT_ANY | RTEMS_WAIT, RTEMS_NO_TIMEOUT, &the_event ); if ((the_event & TERMIOS_RX_TERMINATE_EVENT) != 0) { 10a880: 83 c4 10 add $0x10,%esp 10a883: f6 45 e0 01 testb $0x1,-0x20(%ebp) 10a887: 74 d7 je 10a860 <== ALWAYS TAKEN tty->rxTaskId = 0; 10a889: c7 83 c4 00 00 00 00 movl $0x0,0xc4(%ebx) <== NOT EXECUTED 10a890: 00 00 00 rtems_task_delete(RTEMS_SELF); 10a893: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a896: 6a 00 push $0x0 <== NOT EXECUTED 10a898: e8 0f 11 00 00 call 10b9ac <== NOT EXECUTED 10a89d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a8a0: eb be jmp 10a860 <== NOT EXECUTED 10a8a2: 66 90 xchg %ax,%ax <== NOT EXECUTED c = tty->device.pollRead(tty->minor); if (c != EOF) { /* * pollRead did call enqueue on its own */ c_buf = c; 10a8a4: 88 45 e7 mov %al,-0x19(%ebp) rtems_termios_enqueue_raw_characters ( tty,&c_buf,1); 10a8a7: 50 push %eax 10a8a8: 6a 01 push $0x1 10a8aa: 57 push %edi 10a8ab: 53 push %ebx 10a8ac: e8 8f fc ff ff call 10a540 10a8b1: 83 c4 10 add $0x10,%esp 10a8b4: eb be jmp 10a874 =============================================================================== 0010aafc : /* * this task actually processes any transmit events */ static rtems_task rtems_termios_txdaemon(rtems_task_argument argument) { 10aafc: 55 push %ebp 10aafd: 89 e5 mov %esp,%ebp 10aaff: 56 push %esi 10ab00: 53 push %ebx 10ab01: 83 ec 10 sub $0x10,%esp 10ab04: 8b 5d 08 mov 0x8(%ebp),%ebx 10ab07: 8d 75 f4 lea -0xc(%ebp),%esi 10ab0a: eb 28 jmp 10ab34 } /* * call any line discipline start function */ if (rtems_termios_linesw[tty->t_line].l_start != NULL) { 10ab0c: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax 10ab12: c1 e0 05 shl $0x5,%eax 10ab15: 8b 80 14 79 12 00 mov 0x127914(%eax),%eax 10ab1b: 85 c0 test %eax,%eax 10ab1d: 74 09 je 10ab28 <== ALWAYS TAKEN rtems_termios_linesw[tty->t_line].l_start(tty); 10ab1f: 83 ec 0c sub $0xc,%esp 10ab22: 53 push %ebx <== NOT EXECUTED 10ab23: ff d0 call *%eax <== NOT EXECUTED 10ab25: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } /* * try to push further characters to device */ rtems_termios_refill_transmitter(tty); 10ab28: 83 ec 0c sub $0xc,%esp 10ab2b: 53 push %ebx 10ab2c: e8 87 fd ff ff call 10a8b8 } 10ab31: 83 c4 10 add $0x10,%esp while (1) { /* * wait for rtems event */ rtems_event_receive( 10ab34: 56 push %esi 10ab35: 6a 00 push $0x0 10ab37: 6a 02 push $0x2 10ab39: 6a 03 push $0x3 10ab3b: e8 d4 04 00 00 call 10b014 (TERMIOS_TX_START_EVENT | TERMIOS_TX_TERMINATE_EVENT), RTEMS_EVENT_ANY | RTEMS_WAIT, RTEMS_NO_TIMEOUT, &the_event ); if ((the_event & TERMIOS_TX_TERMINATE_EVENT) != 0) { 10ab40: 83 c4 10 add $0x10,%esp 10ab43: f6 45 f4 01 testb $0x1,-0xc(%ebp) 10ab47: 74 c3 je 10ab0c <== ALWAYS TAKEN tty->txTaskId = 0; 10ab49: c7 83 c8 00 00 00 00 movl $0x0,0xc8(%ebx) <== NOT EXECUTED 10ab50: 00 00 00 rtems_task_delete(RTEMS_SELF); 10ab53: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ab56: 6a 00 push $0x0 <== NOT EXECUTED 10ab58: e8 4f 0e 00 00 call 10b9ac <== NOT EXECUTED 10ab5d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ab60: eb aa jmp 10ab0c <== NOT EXECUTED =============================================================================== 0010a10c : rtems_termios_puts (&c, 1, tty); } rtems_status_code rtems_termios_write (void *arg) { 10a10c: 55 push %ebp 10a10d: 89 e5 mov %esp,%ebp 10a10f: 57 push %edi 10a110: 56 push %esi 10a111: 53 push %ebx 10a112: 83 ec 20 sub $0x20,%esp 10a115: 8b 7d 08 mov 0x8(%ebp),%edi rtems_libio_rw_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 10a118: 8b 07 mov (%edi),%eax 10a11a: 8b 70 34 mov 0x34(%eax),%esi rtems_status_code sc; sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 10a11d: 6a 00 push $0x0 10a11f: 6a 00 push $0x0 10a121: ff 76 18 pushl 0x18(%esi) 10a124: e8 87 15 00 00 call 10b6b0 10a129: 89 45 e4 mov %eax,-0x1c(%ebp) if (sc != RTEMS_SUCCESSFUL) 10a12c: 83 c4 10 add $0x10,%esp 10a12f: 85 c0 test %eax,%eax 10a131: 75 29 jne 10a15c <== NEVER TAKEN return sc; if (rtems_termios_linesw[tty->t_line].l_write != NULL) { 10a133: 8b 86 cc 00 00 00 mov 0xcc(%esi),%eax 10a139: c1 e0 05 shl $0x5,%eax 10a13c: 8b 80 0c 79 12 00 mov 0x12790c(%eax),%eax 10a142: 85 c0 test %eax,%eax 10a144: 74 22 je 10a168 sc = rtems_termios_linesw[tty->t_line].l_write(tty,args); 10a146: 83 ec 08 sub $0x8,%esp 10a149: 57 push %edi 10a14a: 56 push %esi 10a14b: ff d0 call *%eax 10a14d: 89 45 e4 mov %eax,-0x1c(%ebp) rtems_semaphore_release (tty->osem); 10a150: 5f pop %edi 10a151: ff 76 18 pushl 0x18(%esi) 10a154: e8 53 16 00 00 call 10b7ac return sc; 10a159: 83 c4 10 add $0x10,%esp rtems_termios_puts (args->buffer, args->count, tty); args->bytes_moved = args->count; } rtems_semaphore_release (tty->osem); return sc; } 10a15c: 8b 45 e4 mov -0x1c(%ebp),%eax 10a15f: 8d 65 f4 lea -0xc(%ebp),%esp 10a162: 5b pop %ebx 10a163: 5e pop %esi 10a164: 5f pop %edi 10a165: c9 leave 10a166: c3 ret 10a167: 90 nop if (rtems_termios_linesw[tty->t_line].l_write != NULL) { sc = rtems_termios_linesw[tty->t_line].l_write(tty,args); rtems_semaphore_release (tty->osem); return sc; } if (tty->termios.c_oflag & OPOST) { 10a168: f6 46 34 01 testb $0x1,0x34(%esi) 10a16c: 74 4e je 10a1bc <== NEVER TAKEN uint32_t count = args->count; 10a16e: 8b 47 10 mov 0x10(%edi),%eax 10a171: 89 45 e0 mov %eax,-0x20(%ebp) char *buffer = args->buffer; 10a174: 8b 47 0c mov 0xc(%edi),%eax while (count--) 10a177: 8b 5d e0 mov -0x20(%ebp),%ebx 10a17a: 85 db test %ebx,%ebx 10a17c: 74 56 je 10a1d4 <== NEVER TAKEN 10a17e: 31 db xor %ebx,%ebx 10a180: 89 7d dc mov %edi,-0x24(%ebp) 10a183: 89 c7 mov %eax,%edi 10a185: 8d 76 00 lea 0x0(%esi),%esi oproc (*buffer++, tty); 10a188: 0f b6 04 1f movzbl (%edi,%ebx,1),%eax 10a18c: 89 f2 mov %esi,%edx 10a18e: e8 6d fa ff ff call 109c00 10a193: 43 inc %ebx return sc; } if (tty->termios.c_oflag & OPOST) { uint32_t count = args->count; char *buffer = args->buffer; while (count--) 10a194: 39 5d e0 cmp %ebx,-0x20(%ebp) 10a197: 75 ef jne 10a188 10a199: 8b 7d dc mov -0x24(%ebp),%edi 10a19c: 8b 47 10 mov 0x10(%edi),%eax oproc (*buffer++, tty); args->bytes_moved = args->count; 10a19f: 89 47 18 mov %eax,0x18(%edi) } else { rtems_termios_puts (args->buffer, args->count, tty); args->bytes_moved = args->count; } rtems_semaphore_release (tty->osem); 10a1a2: 83 ec 0c sub $0xc,%esp 10a1a5: ff 76 18 pushl 0x18(%esi) 10a1a8: e8 ff 15 00 00 call 10b7ac return sc; 10a1ad: 83 c4 10 add $0x10,%esp } 10a1b0: 8b 45 e4 mov -0x1c(%ebp),%eax 10a1b3: 8d 65 f4 lea -0xc(%ebp),%esp 10a1b6: 5b pop %ebx 10a1b7: 5e pop %esi 10a1b8: 5f pop %edi 10a1b9: c9 leave 10a1ba: c3 ret 10a1bb: 90 nop char *buffer = args->buffer; while (count--) oproc (*buffer++, tty); args->bytes_moved = args->count; } else { rtems_termios_puts (args->buffer, args->count, tty); 10a1bc: 51 push %ecx <== NOT EXECUTED 10a1bd: 56 push %esi <== NOT EXECUTED 10a1be: ff 77 10 pushl 0x10(%edi) <== NOT EXECUTED 10a1c1: ff 77 0c pushl 0xc(%edi) <== NOT EXECUTED 10a1c4: e8 03 f9 ff ff call 109acc <== NOT EXECUTED args->bytes_moved = args->count; 10a1c9: 8b 47 10 mov 0x10(%edi),%eax <== NOT EXECUTED 10a1cc: 89 47 18 mov %eax,0x18(%edi) <== NOT EXECUTED 10a1cf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a1d2: eb ce jmp 10a1a2 <== NOT EXECUTED return sc; } if (tty->termios.c_oflag & OPOST) { uint32_t count = args->count; char *buffer = args->buffer; while (count--) 10a1d4: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a1d6: eb c7 jmp 10a19f <== NOT EXECUTED =============================================================================== 001186d4 : */ rtems_status_code rtems_timer_cancel( rtems_id id ) { 1186d4: 55 push %ebp 1186d5: 89 e5 mov %esp,%ebp 1186d7: 83 ec 1c sub $0x1c,%esp Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); 1186da: 8d 45 f4 lea -0xc(%ebp),%eax Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) _Objects_Get( &_Timer_Information, id, location ); 1186dd: 50 push %eax 1186de: ff 75 08 pushl 0x8(%ebp) 1186e1: 68 60 34 14 00 push $0x143460 1186e6: e8 f1 2b 00 00 call 11b2dc <_Objects_Get> switch ( location ) { 1186eb: 83 c4 10 add $0x10,%esp 1186ee: 8b 55 f4 mov -0xc(%ebp),%edx 1186f1: 85 d2 test %edx,%edx 1186f3: 74 07 je 1186fc #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 1186f5: b8 04 00 00 00 mov $0x4,%eax } 1186fa: c9 leave 1186fb: c3 ret the_timer = _Timer_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Timer_Is_dormant_class( the_timer->the_class ) ) 1186fc: 83 78 38 04 cmpl $0x4,0x38(%eax) 118700: 74 0f je 118711 <== NEVER TAKEN (void) _Watchdog_Remove( &the_timer->Ticker ); 118702: 83 ec 0c sub $0xc,%esp 118705: 83 c0 10 add $0x10,%eax 118708: 50 push %eax 118709: e8 82 48 00 00 call 11cf90 <_Watchdog_Remove> 11870e: 83 c4 10 add $0x10,%esp _Thread_Enable_dispatch(); 118711: e8 3e 37 00 00 call 11be54 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 118716: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 118718: c9 leave 118719: c3 ret =============================================================================== 0010bff0 : rtems_status_code rtems_timer_create( rtems_name name, rtems_id *id ) { 10bff0: 55 push %ebp 10bff1: 89 e5 mov %esp,%ebp 10bff3: 57 push %edi 10bff4: 56 push %esi 10bff5: 53 push %ebx 10bff6: 83 ec 0c sub $0xc,%esp 10bff9: 8b 5d 08 mov 0x8(%ebp),%ebx 10bffc: 8b 75 0c mov 0xc(%ebp),%esi Timer_Control *the_timer; if ( !rtems_is_name_valid( name ) ) 10bfff: 85 db test %ebx,%ebx 10c001: 74 6d je 10c070 return RTEMS_INVALID_NAME; if ( !id ) 10c003: 85 f6 test %esi,%esi 10c005: 0f 84 89 00 00 00 je 10c094 10c00b: a1 10 98 12 00 mov 0x129810,%eax 10c010: 40 inc %eax 10c011: a3 10 98 12 00 mov %eax,0x129810 * This function allocates a timer control block from * the inactive chain of free timer control blocks. */ RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Allocate( void ) { return (Timer_Control *) _Objects_Allocate( &_Timer_Information ); 10c016: 83 ec 0c sub $0xc,%esp 10c019: 68 40 a2 12 00 push $0x12a240 10c01e: e8 31 0f 00 00 call 10cf54 <_Objects_Allocate> _Thread_Disable_dispatch(); /* to prevent deletion */ the_timer = _Timer_Allocate(); if ( !the_timer ) { 10c023: 83 c4 10 add $0x10,%esp 10c026: 85 c0 test %eax,%eax 10c028: 74 56 je 10c080 _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_timer->the_class = TIMER_DORMANT; 10c02a: c7 40 38 04 00 00 00 movl $0x4,0x38(%eax) Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 10c031: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) the_watchdog->routine = routine; 10c038: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax) the_watchdog->id = id; 10c03f: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax) the_watchdog->user_data = user_data; 10c046: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax) Objects_Name name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10c04d: 8b 50 08 mov 0x8(%eax),%edx Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 10c050: 0f b7 fa movzwl %dx,%edi #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10c053: 8b 0d 5c a2 12 00 mov 0x12a25c,%ecx 10c059: 89 04 b9 mov %eax,(%ecx,%edi,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 10c05c: 89 58 0c mov %ebx,0xc(%eax) &_Timer_Information, &the_timer->Object, (Objects_Name) name ); *id = the_timer->Object.id; 10c05f: 89 16 mov %edx,(%esi) _Thread_Enable_dispatch(); 10c061: e8 1a 1f 00 00 call 10df80 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10c066: 31 c0 xor %eax,%eax } 10c068: 8d 65 f4 lea -0xc(%ebp),%esp 10c06b: 5b pop %ebx 10c06c: 5e pop %esi 10c06d: 5f pop %edi 10c06e: c9 leave 10c06f: c3 ret ) { Timer_Control *the_timer; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 10c070: b8 03 00 00 00 mov $0x3,%eax ); *id = the_timer->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10c075: 8d 65 f4 lea -0xc(%ebp),%esp 10c078: 5b pop %ebx 10c079: 5e pop %esi 10c07a: 5f pop %edi 10c07b: c9 leave 10c07c: c3 ret 10c07d: 8d 76 00 lea 0x0(%esi),%esi _Thread_Disable_dispatch(); /* to prevent deletion */ the_timer = _Timer_Allocate(); if ( !the_timer ) { _Thread_Enable_dispatch(); 10c080: e8 fb 1e 00 00 call 10df80 <_Thread_Enable_dispatch> return RTEMS_TOO_MANY; 10c085: b8 05 00 00 00 mov $0x5,%eax ); *id = the_timer->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10c08a: 8d 65 f4 lea -0xc(%ebp),%esp 10c08d: 5b pop %ebx 10c08e: 5e pop %esi 10c08f: 5f pop %edi 10c090: c9 leave 10c091: c3 ret 10c092: 66 90 xchg %ax,%ax if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !id ) return RTEMS_INVALID_ADDRESS; 10c094: b8 09 00 00 00 mov $0x9,%eax ); *id = the_timer->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10c099: 8d 65 f4 lea -0xc(%ebp),%esp 10c09c: 5b pop %ebx 10c09d: 5e pop %esi 10c09e: 5f pop %edi 10c09f: c9 leave 10c0a0: c3 ret =============================================================================== 001187d0 : */ rtems_status_code rtems_timer_delete( rtems_id id ) { 1187d0: 55 push %ebp 1187d1: 89 e5 mov %esp,%ebp 1187d3: 53 push %ebx 1187d4: 83 ec 18 sub $0x18,%esp Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); 1187d7: 8d 45 f4 lea -0xc(%ebp),%eax Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) _Objects_Get( &_Timer_Information, id, location ); 1187da: 50 push %eax 1187db: ff 75 08 pushl 0x8(%ebp) 1187de: 68 60 34 14 00 push $0x143460 1187e3: e8 f4 2a 00 00 call 11b2dc <_Objects_Get> 1187e8: 89 c3 mov %eax,%ebx switch ( location ) { 1187ea: 83 c4 10 add $0x10,%esp 1187ed: 8b 4d f4 mov -0xc(%ebp),%ecx 1187f0: 85 c9 test %ecx,%ecx 1187f2: 75 38 jne 11882c case OBJECTS_LOCAL: _Objects_Close( &_Timer_Information, &the_timer->Object ); 1187f4: 83 ec 08 sub $0x8,%esp 1187f7: 50 push %eax 1187f8: 68 60 34 14 00 push $0x143460 1187fd: e8 66 26 00 00 call 11ae68 <_Objects_Close> (void) _Watchdog_Remove( &the_timer->Ticker ); 118802: 8d 43 10 lea 0x10(%ebx),%eax 118805: 89 04 24 mov %eax,(%esp) 118808: e8 83 47 00 00 call 11cf90 <_Watchdog_Remove> */ RTEMS_INLINE_ROUTINE void _Timer_Free ( Timer_Control *the_timer ) { _Objects_Free( &_Timer_Information, &the_timer->Object ); 11880d: 58 pop %eax 11880e: 5a pop %edx 11880f: 53 push %ebx 118810: 68 60 34 14 00 push $0x143460 118815: e8 46 29 00 00 call 11b160 <_Objects_Free> _Timer_Free( the_timer ); _Thread_Enable_dispatch(); 11881a: e8 35 36 00 00 call 11be54 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 11881f: 83 c4 10 add $0x10,%esp 118822: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 118824: 8b 5d fc mov -0x4(%ebp),%ebx 118827: c9 leave 118828: c3 ret 118829: 8d 76 00 lea 0x0(%esi),%esi #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 11882c: b8 04 00 00 00 mov $0x4,%eax } 118831: 8b 5d fc mov -0x4(%ebp),%ebx 118834: c9 leave 118835: c3 ret =============================================================================== 0010c0a4 : rtems_id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 10c0a4: 55 push %ebp 10c0a5: 89 e5 mov %esp,%ebp 10c0a7: 57 push %edi 10c0a8: 56 push %esi 10c0a9: 53 push %ebx 10c0aa: 83 ec 2c sub $0x2c,%esp 10c0ad: 8b 5d 0c mov 0xc(%ebp),%ebx 10c0b0: 8b 75 10 mov 0x10(%ebp),%esi Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( ticks == 0 ) 10c0b3: 85 db test %ebx,%ebx 10c0b5: 0f 84 99 00 00 00 je 10c154 return RTEMS_INVALID_NUMBER; if ( !routine ) 10c0bb: 85 f6 test %esi,%esi 10c0bd: 0f 84 b1 00 00 00 je 10c174 Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) _Objects_Get( &_Timer_Information, id, location ); 10c0c3: 57 push %edi return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); 10c0c4: 8d 45 e4 lea -0x1c(%ebp),%eax 10c0c7: 50 push %eax 10c0c8: ff 75 08 pushl 0x8(%ebp) 10c0cb: 68 40 a2 12 00 push $0x12a240 10c0d0: e8 33 13 00 00 call 10d408 <_Objects_Get> 10c0d5: 89 c7 mov %eax,%edi switch ( location ) { 10c0d7: 83 c4 10 add $0x10,%esp 10c0da: 8b 4d e4 mov -0x1c(%ebp),%ecx 10c0dd: 85 c9 test %ecx,%ecx 10c0df: 74 0f je 10c0f0 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10c0e1: b8 04 00 00 00 mov $0x4,%eax } 10c0e6: 8d 65 f4 lea -0xc(%ebp),%esp 10c0e9: 5b pop %ebx 10c0ea: 5e pop %esi 10c0eb: 5f pop %edi 10c0ec: c9 leave 10c0ed: c3 ret 10c0ee: 66 90 xchg %ax,%ax the_timer = _Timer_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 10c0f0: 8d 50 10 lea 0x10(%eax),%edx 10c0f3: 83 ec 0c sub $0xc,%esp 10c0f6: 52 push %edx 10c0f7: 89 55 d4 mov %edx,-0x2c(%ebp) 10c0fa: e8 31 2d 00 00 call 10ee30 <_Watchdog_Remove> _ISR_Disable( level ); 10c0ff: 9c pushf 10c100: fa cli 10c101: 58 pop %eax /* * Check to see if the watchdog has just been inserted by a * higher priority interrupt. If so, abandon this insert. */ if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) { 10c102: 83 c4 10 add $0x10,%esp 10c105: 8b 57 18 mov 0x18(%edi),%edx 10c108: 85 d2 test %edx,%edx 10c10a: 8b 55 d4 mov -0x2c(%ebp),%edx 10c10d: 75 55 jne 10c164 /* * OK. Now we now the timer was not rescheduled by an interrupt * so we can atomically initialize it as in use. */ the_timer->the_class = TIMER_INTERVAL; 10c10f: c7 47 38 00 00 00 00 movl $0x0,0x38(%edi) Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 10c116: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi) the_watchdog->routine = routine; 10c11d: 89 77 2c mov %esi,0x2c(%edi) the_watchdog->id = id; 10c120: 8b 4d 08 mov 0x8(%ebp),%ecx 10c123: 89 4f 30 mov %ecx,0x30(%edi) the_watchdog->user_data = user_data; 10c126: 8b 4d 14 mov 0x14(%ebp),%ecx 10c129: 89 4f 34 mov %ecx,0x34(%edi) _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); _ISR_Enable( level ); 10c12c: 50 push %eax 10c12d: 9d popf Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10c12e: 89 5f 1c mov %ebx,0x1c(%edi) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10c131: 83 ec 08 sub $0x8,%esp 10c134: 52 push %edx 10c135: 68 e0 98 12 00 push $0x1298e0 10c13a: e8 b1 2b 00 00 call 10ecf0 <_Watchdog_Insert> _Watchdog_Insert_ticks( &the_timer->Ticker, ticks ); _Thread_Enable_dispatch(); 10c13f: e8 3c 1e 00 00 call 10df80 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10c144: 83 c4 10 add $0x10,%esp 10c147: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10c149: 8d 65 f4 lea -0xc(%ebp),%esp 10c14c: 5b pop %ebx 10c14d: 5e pop %esi 10c14e: 5f pop %edi 10c14f: c9 leave 10c150: c3 ret 10c151: 8d 76 00 lea 0x0(%esi),%esi Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( ticks == 0 ) return RTEMS_INVALID_NUMBER; 10c154: b8 0a 00 00 00 mov $0xa,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10c159: 8d 65 f4 lea -0xc(%ebp),%esp 10c15c: 5b pop %ebx 10c15d: 5e pop %esi 10c15e: 5f pop %edi 10c15f: c9 leave 10c160: c3 ret 10c161: 8d 76 00 lea 0x0(%esi),%esi * Check to see if the watchdog has just been inserted by a * higher priority interrupt. If so, abandon this insert. */ if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) { _ISR_Enable( level ); 10c164: 50 push %eax 10c165: 9d popf _Thread_Enable_dispatch(); 10c166: e8 15 1e 00 00 call 10df80 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10c16b: 31 c0 xor %eax,%eax 10c16d: e9 74 ff ff ff jmp 10c0e6 10c172: 66 90 xchg %ax,%ax if ( ticks == 0 ) return RTEMS_INVALID_NUMBER; if ( !routine ) return RTEMS_INVALID_ADDRESS; 10c174: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10c179: 8d 65 f4 lea -0xc(%ebp),%esp 10c17c: 5b pop %ebx 10c17d: 5e pop %esi 10c17e: 5f pop %edi 10c17f: c9 leave 10c180: c3 ret =============================================================================== 00118918 : rtems_id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 118918: 55 push %ebp 118919: 89 e5 mov %esp,%ebp 11891b: 57 push %edi 11891c: 56 push %esi 11891d: 53 push %ebx 11891e: 83 ec 2c sub $0x2c,%esp 118921: 8b 75 08 mov 0x8(%ebp),%esi 118924: 8b 7d 0c mov 0xc(%ebp),%edi 118927: 8b 5d 10 mov 0x10(%ebp),%ebx Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; if ( !_TOD_Is_set ) 11892a: 80 3d 44 2a 14 00 00 cmpb $0x0,0x142a44 118931: 75 0d jne 118940 return RTEMS_NOT_DEFINED; 118933: b8 0b 00 00 00 mov $0xb,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 118938: 8d 65 f4 lea -0xc(%ebp),%esp 11893b: 5b pop %ebx 11893c: 5e pop %esi 11893d: 5f pop %edi 11893e: c9 leave 11893f: c3 ret rtems_interval seconds; if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; if ( !_TOD_Validate( wall_time ) ) 118940: 83 ec 0c sub $0xc,%esp 118943: 57 push %edi 118944: e8 93 d4 ff ff call 115ddc <_TOD_Validate> 118949: 83 c4 10 add $0x10,%esp 11894c: 84 c0 test %al,%al 11894e: 74 1e je 11896e return RTEMS_INVALID_CLOCK; if ( !routine ) 118950: 85 db test %ebx,%ebx 118952: 0f 84 a4 00 00 00 je 1189fc return RTEMS_INVALID_ADDRESS; seconds = _TOD_To_seconds( wall_time ); 118958: 83 ec 0c sub $0xc,%esp 11895b: 57 push %edi 11895c: e8 ef d3 ff ff call 115d50 <_TOD_To_seconds> 118961: 89 c7 mov %eax,%edi if ( seconds <= _TOD_Seconds_since_epoch() ) 118963: 83 c4 10 add $0x10,%esp 118966: 3b 05 c8 2a 14 00 cmp 0x142ac8,%eax 11896c: 77 0e ja 11897c return RTEMS_INVALID_CLOCK; 11896e: b8 14 00 00 00 mov $0x14,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 118973: 8d 65 f4 lea -0xc(%ebp),%esp 118976: 5b pop %ebx 118977: 5e pop %esi 118978: 5f pop %edi 118979: c9 leave 11897a: c3 ret 11897b: 90 nop 11897c: 50 push %eax seconds = _TOD_To_seconds( wall_time ); if ( seconds <= _TOD_Seconds_since_epoch() ) return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); 11897d: 8d 45 e4 lea -0x1c(%ebp),%eax 118980: 50 push %eax 118981: 56 push %esi 118982: 68 60 34 14 00 push $0x143460 118987: e8 50 29 00 00 call 11b2dc <_Objects_Get> switch ( location ) { 11898c: 83 c4 10 add $0x10,%esp 11898f: 8b 4d e4 mov -0x1c(%ebp),%ecx 118992: 85 c9 test %ecx,%ecx 118994: 75 5a jne 1189f0 case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 118996: 8d 48 10 lea 0x10(%eax),%ecx 118999: 83 ec 0c sub $0xc,%esp 11899c: 51 push %ecx 11899d: 89 45 d0 mov %eax,-0x30(%ebp) 1189a0: 89 4d d4 mov %ecx,-0x2c(%ebp) 1189a3: e8 e8 45 00 00 call 11cf90 <_Watchdog_Remove> the_timer->the_class = TIMER_TIME_OF_DAY; 1189a8: 8b 55 d0 mov -0x30(%ebp),%edx 1189ab: c7 42 38 02 00 00 00 movl $0x2,0x38(%edx) Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 1189b2: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx) the_watchdog->routine = routine; 1189b9: 89 5a 2c mov %ebx,0x2c(%edx) the_watchdog->id = id; 1189bc: 89 72 30 mov %esi,0x30(%edx) the_watchdog->user_data = user_data; 1189bf: 8b 45 14 mov 0x14(%ebp),%eax 1189c2: 89 42 34 mov %eax,0x34(%edx) _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); _Watchdog_Insert_seconds( 1189c5: 2b 3d c8 2a 14 00 sub 0x142ac8,%edi 1189cb: 89 7a 1c mov %edi,0x1c(%edx) ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 1189ce: 58 pop %eax 1189cf: 5a pop %edx 1189d0: 8b 4d d4 mov -0x2c(%ebp),%ecx 1189d3: 51 push %ecx 1189d4: 68 f4 2a 14 00 push $0x142af4 1189d9: e8 72 44 00 00 call 11ce50 <_Watchdog_Insert> &the_timer->Ticker, seconds - _TOD_Seconds_since_epoch() ); _Thread_Enable_dispatch(); 1189de: e8 71 34 00 00 call 11be54 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 1189e3: 83 c4 10 add $0x10,%esp 1189e6: 31 c0 xor %eax,%eax 1189e8: e9 4b ff ff ff jmp 118938 1189ed: 8d 76 00 lea 0x0(%esi),%esi #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 1189f0: b8 04 00 00 00 mov $0x4,%eax 1189f5: e9 3e ff ff ff jmp 118938 1189fa: 66 90 xchg %ax,%ax if ( !_TOD_Validate( wall_time ) ) return RTEMS_INVALID_CLOCK; if ( !routine ) return RTEMS_INVALID_ADDRESS; 1189fc: b8 09 00 00 00 mov $0x9,%eax 118a01: e9 32 ff ff ff jmp 118938 =============================================================================== 001190b0 : rtems_status_code rtems_timer_initiate_server( uint32_t priority, uint32_t stack_size, rtems_attribute attribute_set ) { 1190b0: 55 push %ebp 1190b1: 89 e5 mov %esp,%ebp 1190b3: 56 push %esi 1190b4: 53 push %ebx 1190b5: 83 ec 10 sub $0x10,%esp 1190b8: 8b 45 08 mov 0x8(%ebp),%eax 1190bb: 85 c0 test %eax,%eax 1190bd: 74 41 je 119100 ( the_priority <= RTEMS_MAXIMUM_PRIORITY ) ); 1190bf: 0f b6 15 d4 a2 13 00 movzbl 0x13a2d4,%edx */ RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid ( rtems_task_priority the_priority ) { return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) && 1190c6: 39 d0 cmp %edx,%eax 1190c8: 76 42 jbe 11910c * structured so we check it is invalid before looking for * a specific invalid value as the default. */ _priority = priority; if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) { if ( priority != RTEMS_TIMER_SERVER_DEFAULT_PRIORITY ) 1190ca: 40 inc %eax 1190cb: 75 33 jne 119100 return RTEMS_INVALID_PRIORITY; _priority = 0; 1190cd: 31 f6 xor %esi,%esi 1190cf: 8b 15 30 2a 14 00 mov 0x142a30,%edx 1190d5: 42 inc %edx 1190d6: 89 15 30 2a 14 00 mov %edx,0x142a30 /* * Just to make sure this is only called once. */ _Thread_Disable_dispatch(); tmpInitialized = initialized; 1190dc: 8a 1d 60 e3 13 00 mov 0x13e360,%bl initialized = true; 1190e2: c6 05 60 e3 13 00 01 movb $0x1,0x13e360 _Thread_Enable_dispatch(); 1190e9: e8 66 2d 00 00 call 11be54 <_Thread_Enable_dispatch> if ( tmpInitialized ) 1190ee: 84 db test %bl,%bl 1190f0: 74 1e je 119110 return RTEMS_INCORRECT_STATE; 1190f2: b8 0e 00 00 00 mov $0xe,%eax initialized = false; } #endif return status; } 1190f7: 8d 65 f8 lea -0x8(%ebp),%esp 1190fa: 5b pop %ebx 1190fb: 5e pop %esi 1190fc: c9 leave 1190fd: c3 ret 1190fe: 66 90 xchg %ax,%ax * a specific invalid value as the default. */ _priority = priority; if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) { if ( priority != RTEMS_TIMER_SERVER_DEFAULT_PRIORITY ) return RTEMS_INVALID_PRIORITY; 119100: b8 13 00 00 00 mov $0x13,%eax initialized = false; } #endif return status; } 119105: 8d 65 f8 lea -0x8(%ebp),%esp 119108: 5b pop %ebx 119109: 5e pop %esi 11910a: c9 leave 11910b: c3 ret 11910c: 89 c6 mov %eax,%esi 11910e: eb bf jmp 1190cf * other library rules. For example, if using a TSR written in Ada the * Server should run at the same priority as the priority Ada task. * Otherwise, the priority ceiling for the mutex used to protect the * GNAT run-time is violated. */ status = rtems_task_create( 119110: 83 ec 08 sub $0x8,%esp 119113: 8d 45 f4 lea -0xc(%ebp),%eax 119116: 50 push %eax 119117: 8b 45 10 mov 0x10(%ebp),%eax 11911a: 80 cc 80 or $0x80,%ah 11911d: 50 push %eax 11911e: 68 00 01 00 00 push $0x100 119123: ff 75 0c pushl 0xc(%ebp) 119126: 56 push %esi 119127: 68 45 4d 49 54 push $0x54494d45 11912c: e8 c7 ec ff ff call 117df8 /* user may want floating point but we need */ /* system task specified for 0 priority */ attribute_set | RTEMS_SYSTEM_TASK, &id /* get the id back */ ); if (status) { 119131: 83 c4 20 add $0x20,%esp 119134: 85 c0 test %eax,%eax 119136: 74 10 je 119148 initialized = false; 119138: c6 05 60 e3 13 00 00 movb $0x0,0x13e360 initialized = false; } #endif return status; } 11913f: 8d 65 f8 lea -0x8(%ebp),%esp 119142: 5b pop %ebx 119143: 5e pop %esi 119144: c9 leave 119145: c3 ret 119146: 66 90 xchg %ax,%ax * We work with the TCB pointer, not the ID, so we need to convert * to a TCB pointer from here out. */ ts->thread = (Thread_Control *)_Objects_Get_local_object( &_RTEMS_tasks_Information, _Objects_Get_index(id) 119148: 8b 45 f4 mov -0xc(%ebp),%eax */ #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return NULL; #endif return information->local_table[ index ]; 11914b: 0f b7 c8 movzwl %ax,%ecx 11914e: 8b 15 dc 29 14 00 mov 0x1429dc,%edx /* * We work with the TCB pointer, not the ID, so we need to convert * to a TCB pointer from here out. */ ts->thread = (Thread_Control *)_Objects_Get_local_object( 119154: 8b 14 8a mov (%edx,%ecx,4),%edx 119157: 89 15 e0 e2 13 00 mov %edx,0x13e2e0 ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 11915d: c7 05 10 e3 13 00 14 movl $0x13e314,0x13e310 119164: e3 13 00 head->previous = NULL; 119167: c7 05 14 e3 13 00 00 movl $0x0,0x13e314 11916e: 00 00 00 tail->previous = head; 119171: c7 05 18 e3 13 00 10 movl $0x13e310,0x13e318 119178: e3 13 00 ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 11917b: c7 05 48 e3 13 00 4c movl $0x13e34c,0x13e348 119182: e3 13 00 head->previous = NULL; 119185: c7 05 4c e3 13 00 00 movl $0x0,0x13e34c 11918c: 00 00 00 tail->previous = head; 11918f: c7 05 50 e3 13 00 48 movl $0x13e348,0x13e350 119196: e3 13 00 Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 119199: c7 05 f0 e2 13 00 00 movl $0x0,0x13e2f0 1191a0: 00 00 00 the_watchdog->routine = routine; 1191a3: c7 05 04 e3 13 00 a0 movl $0x11bca0,0x13e304 1191aa: bc 11 00 the_watchdog->id = id; 1191ad: a3 08 e3 13 00 mov %eax,0x13e308 the_watchdog->user_data = user_data; 1191b2: c7 05 0c e3 13 00 00 movl $0x0,0x13e30c 1191b9: 00 00 00 Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 1191bc: c7 05 28 e3 13 00 00 movl $0x0,0x13e328 1191c3: 00 00 00 the_watchdog->routine = routine; 1191c6: c7 05 3c e3 13 00 a0 movl $0x11bca0,0x13e33c 1191cd: bc 11 00 the_watchdog->id = id; 1191d0: a3 40 e3 13 00 mov %eax,0x13e340 the_watchdog->user_data = user_data; 1191d5: c7 05 44 e3 13 00 00 movl $0x0,0x13e344 1191dc: 00 00 00 /* * Initialize the pointer to the timer schedule method so applications that * do not use the Timer Server do not have to pull it in. */ ts->schedule_operation = _Timer_server_Schedule_operation_method; 1191df: c7 05 e4 e2 13 00 80 movl $0x118f80,0x13e2e4 1191e6: 8f 11 00 ts->Interval_watchdogs.last_snapshot = _Watchdog_Ticks_since_boot; 1191e9: 8b 15 64 2b 14 00 mov 0x142b64,%edx 1191ef: 89 15 1c e3 13 00 mov %edx,0x13e31c ts->TOD_watchdogs.last_snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); 1191f5: 8b 15 c8 2a 14 00 mov 0x142ac8,%edx 1191fb: 89 15 54 e3 13 00 mov %edx,0x13e354 ts->insert_chain = NULL; 119201: c7 05 58 e3 13 00 00 movl $0x0,0x13e358 119208: 00 00 00 ts->active = false; 11920b: c6 05 5c e3 13 00 00 movb $0x0,0x13e35c /* * The default timer server is now available. */ _Timer_server = ts; 119212: c7 05 a0 34 14 00 e0 movl $0x13e2e0,0x1434a0 119219: e2 13 00 /* * Start the timer server */ status = rtems_task_start( 11921c: 53 push %ebx 11921d: 68 e0 e2 13 00 push $0x13e2e0 119222: 68 b8 8d 11 00 push $0x118db8 119227: 50 push %eax 119228: e8 8b f2 ff ff call 1184b8 if (status) { initialized = false; } #endif return status; 11922d: 83 c4 10 add $0x10,%esp 119230: e9 d0 fe ff ff jmp 119105 =============================================================================== 00118a90 : */ rtems_status_code rtems_timer_reset( rtems_id id ) { 118a90: 55 push %ebp 118a91: 89 e5 mov %esp,%ebp 118a93: 56 push %esi 118a94: 53 push %ebx 118a95: 83 ec 24 sub $0x24,%esp Timer_Control *the_timer; Objects_Locations location; rtems_status_code status = RTEMS_SUCCESSFUL; the_timer = _Timer_Get( id, &location ); 118a98: 8d 45 f4 lea -0xc(%ebp),%eax 118a9b: 50 push %eax 118a9c: ff 75 08 pushl 0x8(%ebp) 118a9f: 68 60 34 14 00 push $0x143460 118aa4: e8 33 28 00 00 call 11b2dc <_Objects_Get> 118aa9: 89 c3 mov %eax,%ebx switch ( location ) { 118aab: 83 c4 10 add $0x10,%esp 118aae: 8b 45 f4 mov -0xc(%ebp),%eax 118ab1: 85 c0 test %eax,%eax 118ab3: 74 0f je 118ac4 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 118ab5: b8 04 00 00 00 mov $0x4,%eax } 118aba: 8d 65 f8 lea -0x8(%ebp),%esp 118abd: 5b pop %ebx 118abe: 5e pop %esi 118abf: c9 leave 118ac0: c3 ret 118ac1: 8d 76 00 lea 0x0(%esi),%esi the_timer = _Timer_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( the_timer->the_class == TIMER_INTERVAL ) { 118ac4: 8b 43 38 mov 0x38(%ebx),%eax 118ac7: 85 c0 test %eax,%eax 118ac9: 74 1d je 118ae8 _Watchdog_Remove( &the_timer->Ticker ); _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker ); } else if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) { 118acb: 48 dec %eax 118acc: 74 3a je 118b08 /* * Must be dormant or time of day timer (e.g. TIMER_DORMANT, * TIMER_TIME_OF_DAY, or TIMER_TIME_OF_DAY_ON_TASK). We * can only reset active interval timers. */ status = RTEMS_NOT_DEFINED; 118ace: b8 0b 00 00 00 mov $0xb,%eax } _Thread_Enable_dispatch(); 118ad3: 89 45 e4 mov %eax,-0x1c(%ebp) 118ad6: e8 79 33 00 00 call 11be54 <_Thread_Enable_dispatch> return status; 118adb: 8b 45 e4 mov -0x1c(%ebp),%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 118ade: 8d 65 f8 lea -0x8(%ebp),%esp 118ae1: 5b pop %ebx 118ae2: 5e pop %esi 118ae3: c9 leave 118ae4: c3 ret 118ae5: 8d 76 00 lea 0x0(%esi),%esi the_timer = _Timer_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( the_timer->the_class == TIMER_INTERVAL ) { _Watchdog_Remove( &the_timer->Ticker ); 118ae8: 83 c3 10 add $0x10,%ebx 118aeb: 83 ec 0c sub $0xc,%esp 118aee: 53 push %ebx 118aef: e8 9c 44 00 00 call 11cf90 <_Watchdog_Remove> _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker ); 118af4: 59 pop %ecx 118af5: 5e pop %esi 118af6: 53 push %ebx 118af7: 68 00 2b 14 00 push $0x142b00 118afc: e8 4f 43 00 00 call 11ce50 <_Watchdog_Insert> 118b01: 83 c4 10 add $0x10,%esp rtems_id id ) { Timer_Control *the_timer; Objects_Locations location; rtems_status_code status = RTEMS_SUCCESSFUL; 118b04: 31 c0 xor %eax,%eax 118b06: eb cb jmp 118ad3 case OBJECTS_LOCAL: if ( the_timer->the_class == TIMER_INTERVAL ) { _Watchdog_Remove( &the_timer->Ticker ); _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker ); } else if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) { Timer_server_Control *timer_server = _Timer_server; 118b08: 8b 35 a0 34 14 00 mov 0x1434a0,%esi if ( !timer_server ) { _Thread_Enable_dispatch(); return RTEMS_INCORRECT_STATE; } #endif _Watchdog_Remove( &the_timer->Ticker ); 118b0e: 83 ec 0c sub $0xc,%esp 118b11: 8d 43 10 lea 0x10(%ebx),%eax 118b14: 50 push %eax 118b15: e8 76 44 00 00 call 11cf90 <_Watchdog_Remove> (*timer_server->schedule_operation)( timer_server, the_timer ); 118b1a: 58 pop %eax 118b1b: 5a pop %edx 118b1c: 53 push %ebx 118b1d: 56 push %esi 118b1e: ff 56 04 call *0x4(%esi) 118b21: 83 c4 10 add $0x10,%esp rtems_id id ) { Timer_Control *the_timer; Objects_Locations location; rtems_status_code status = RTEMS_SUCCESSFUL; 118b24: 31 c0 xor %eax,%eax 118b26: eb ab jmp 118ad3 =============================================================================== 00118b28 : rtems_id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 118b28: 55 push %ebp 118b29: 89 e5 mov %esp,%ebp 118b2b: 57 push %edi 118b2c: 56 push %esi 118b2d: 53 push %ebx 118b2e: 83 ec 2c sub $0x2c,%esp 118b31: 8b 7d 0c mov 0xc(%ebp),%edi 118b34: 8b 75 10 mov 0x10(%ebp),%esi Timer_Control *the_timer; Objects_Locations location; ISR_Level level; Timer_server_Control *timer_server = _Timer_server; 118b37: 8b 1d a0 34 14 00 mov 0x1434a0,%ebx if ( !timer_server ) 118b3d: 85 db test %ebx,%ebx 118b3f: 0f 84 9f 00 00 00 je 118be4 return RTEMS_INCORRECT_STATE; if ( !routine ) 118b45: 85 f6 test %esi,%esi 118b47: 0f 84 a3 00 00 00 je 118bf0 return RTEMS_INVALID_ADDRESS; if ( ticks == 0 ) 118b4d: 85 ff test %edi,%edi 118b4f: 75 0f jne 118b60 return RTEMS_INVALID_NUMBER; 118b51: b8 0a 00 00 00 mov $0xa,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 118b56: 8d 65 f4 lea -0xc(%ebp),%esp 118b59: 5b pop %ebx 118b5a: 5e pop %esi 118b5b: 5f pop %edi 118b5c: c9 leave 118b5d: c3 ret 118b5e: 66 90 xchg %ax,%ax 118b60: 52 push %edx return RTEMS_INVALID_ADDRESS; if ( ticks == 0 ) return RTEMS_INVALID_NUMBER; the_timer = _Timer_Get( id, &location ); 118b61: 8d 45 e4 lea -0x1c(%ebp),%eax 118b64: 50 push %eax 118b65: ff 75 08 pushl 0x8(%ebp) 118b68: 68 60 34 14 00 push $0x143460 118b6d: e8 6a 27 00 00 call 11b2dc <_Objects_Get> 118b72: 89 c2 mov %eax,%edx switch ( location ) { 118b74: 83 c4 10 add $0x10,%esp 118b77: 8b 45 e4 mov -0x1c(%ebp),%eax 118b7a: 85 c0 test %eax,%eax 118b7c: 75 56 jne 118bd4 case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 118b7e: 83 ec 0c sub $0xc,%esp 118b81: 8d 42 10 lea 0x10(%edx),%eax 118b84: 50 push %eax 118b85: 89 55 d4 mov %edx,-0x2c(%ebp) 118b88: e8 03 44 00 00 call 11cf90 <_Watchdog_Remove> _ISR_Disable( level ); 118b8d: 9c pushf 118b8e: fa cli 118b8f: 58 pop %eax /* * Check to see if the watchdog has just been inserted by a * higher priority interrupt. If so, abandon this insert. */ if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) { 118b90: 83 c4 10 add $0x10,%esp 118b93: 8b 55 d4 mov -0x2c(%ebp),%edx 118b96: 8b 4a 18 mov 0x18(%edx),%ecx 118b99: 85 c9 test %ecx,%ecx 118b9b: 75 5f jne 118bfc /* * OK. Now we now the timer was not rescheduled by an interrupt * so we can atomically initialize it as in use. */ the_timer->the_class = TIMER_INTERVAL_ON_TASK; 118b9d: c7 42 38 01 00 00 00 movl $0x1,0x38(%edx) Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 118ba4: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx) the_watchdog->routine = routine; 118bab: 89 72 2c mov %esi,0x2c(%edx) the_watchdog->id = id; 118bae: 8b 4d 08 mov 0x8(%ebp),%ecx 118bb1: 89 4a 30 mov %ecx,0x30(%edx) the_watchdog->user_data = user_data; 118bb4: 8b 4d 14 mov 0x14(%ebp),%ecx 118bb7: 89 4a 34 mov %ecx,0x34(%edx) _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); the_timer->Ticker.initial = ticks; 118bba: 89 7a 1c mov %edi,0x1c(%edx) _ISR_Enable( level ); 118bbd: 50 push %eax 118bbe: 9d popf (*timer_server->schedule_operation)( timer_server, the_timer ); 118bbf: 83 ec 08 sub $0x8,%esp 118bc2: 52 push %edx 118bc3: 53 push %ebx 118bc4: ff 53 04 call *0x4(%ebx) _Thread_Enable_dispatch(); 118bc7: e8 88 32 00 00 call 11be54 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 118bcc: 83 c4 10 add $0x10,%esp 118bcf: 31 c0 xor %eax,%eax 118bd1: eb 83 jmp 118b56 118bd3: 90 nop #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 118bd4: b8 04 00 00 00 mov $0x4,%eax } 118bd9: 8d 65 f4 lea -0xc(%ebp),%esp 118bdc: 5b pop %ebx 118bdd: 5e pop %esi 118bde: 5f pop %edi 118bdf: c9 leave 118be0: c3 ret 118be1: 8d 76 00 lea 0x0(%esi),%esi Objects_Locations location; ISR_Level level; Timer_server_Control *timer_server = _Timer_server; if ( !timer_server ) return RTEMS_INCORRECT_STATE; 118be4: b8 0e 00 00 00 mov $0xe,%eax 118be9: e9 68 ff ff ff jmp 118b56 118bee: 66 90 xchg %ax,%ax if ( !routine ) return RTEMS_INVALID_ADDRESS; 118bf0: b8 09 00 00 00 mov $0x9,%eax 118bf5: e9 5c ff ff ff jmp 118b56 118bfa: 66 90 xchg %ax,%ax * Check to see if the watchdog has just been inserted by a * higher priority interrupt. If so, abandon this insert. */ if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) { _ISR_Enable( level ); 118bfc: 50 push %eax 118bfd: 9d popf _Thread_Enable_dispatch(); 118bfe: e8 51 32 00 00 call 11be54 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 118c03: 31 c0 xor %eax,%eax 118c05: e9 4c ff ff ff jmp 118b56 =============================================================================== 00118c0c : rtems_id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 118c0c: 55 push %ebp 118c0d: 89 e5 mov %esp,%ebp 118c0f: 57 push %edi 118c10: 56 push %esi 118c11: 53 push %ebx 118c12: 83 ec 2c sub $0x2c,%esp 118c15: 8b 7d 0c mov 0xc(%ebp),%edi 118c18: 8b 75 10 mov 0x10(%ebp),%esi Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server; 118c1b: 8b 1d a0 34 14 00 mov 0x1434a0,%ebx if ( !timer_server ) 118c21: 85 db test %ebx,%ebx 118c23: 0f 84 d7 00 00 00 je 118d00 return RTEMS_INCORRECT_STATE; if ( !_TOD_Is_set ) 118c29: 80 3d 44 2a 14 00 00 cmpb $0x0,0x142a44 118c30: 0f 84 aa 00 00 00 je 118ce0 <== NEVER TAKEN return RTEMS_NOT_DEFINED; if ( !routine ) 118c36: 85 f6 test %esi,%esi 118c38: 0f 84 b2 00 00 00 je 118cf0 return RTEMS_INVALID_ADDRESS; if ( !_TOD_Validate( wall_time ) ) 118c3e: 83 ec 0c sub $0xc,%esp 118c41: 57 push %edi 118c42: e8 95 d1 ff ff call 115ddc <_TOD_Validate> 118c47: 83 c4 10 add $0x10,%esp 118c4a: 84 c0 test %al,%al 118c4c: 75 0e jne 118c5c return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( wall_time ); if ( seconds <= _TOD_Seconds_since_epoch() ) return RTEMS_INVALID_CLOCK; 118c4e: b8 14 00 00 00 mov $0x14,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 118c53: 8d 65 f4 lea -0xc(%ebp),%esp 118c56: 5b pop %ebx 118c57: 5e pop %esi 118c58: 5f pop %edi 118c59: c9 leave 118c5a: c3 ret 118c5b: 90 nop return RTEMS_INVALID_ADDRESS; if ( !_TOD_Validate( wall_time ) ) return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( wall_time ); 118c5c: 83 ec 0c sub $0xc,%esp 118c5f: 57 push %edi 118c60: e8 eb d0 ff ff call 115d50 <_TOD_To_seconds> 118c65: 89 c7 mov %eax,%edi if ( seconds <= _TOD_Seconds_since_epoch() ) 118c67: 83 c4 10 add $0x10,%esp 118c6a: 3b 05 c8 2a 14 00 cmp 0x142ac8,%eax 118c70: 76 dc jbe 118c4e 118c72: 52 push %edx return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); 118c73: 8d 45 e4 lea -0x1c(%ebp),%eax 118c76: 50 push %eax 118c77: ff 75 08 pushl 0x8(%ebp) 118c7a: 68 60 34 14 00 push $0x143460 118c7f: e8 58 26 00 00 call 11b2dc <_Objects_Get> 118c84: 89 c2 mov %eax,%edx switch ( location ) { 118c86: 83 c4 10 add $0x10,%esp 118c89: 8b 45 e4 mov -0x1c(%ebp),%eax 118c8c: 85 c0 test %eax,%eax 118c8e: 75 7c jne 118d0c case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 118c90: 83 ec 0c sub $0xc,%esp 118c93: 8d 42 10 lea 0x10(%edx),%eax 118c96: 50 push %eax 118c97: 89 55 d4 mov %edx,-0x2c(%ebp) 118c9a: e8 f1 42 00 00 call 11cf90 <_Watchdog_Remove> the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK; 118c9f: 8b 55 d4 mov -0x2c(%ebp),%edx 118ca2: c7 42 38 03 00 00 00 movl $0x3,0x38(%edx) Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 118ca9: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx) the_watchdog->routine = routine; 118cb0: 89 72 2c mov %esi,0x2c(%edx) the_watchdog->id = id; 118cb3: 8b 45 08 mov 0x8(%ebp),%eax 118cb6: 89 42 30 mov %eax,0x30(%edx) the_watchdog->user_data = user_data; 118cb9: 8b 45 14 mov 0x14(%ebp),%eax 118cbc: 89 42 34 mov %eax,0x34(%edx) _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch(); 118cbf: 2b 3d c8 2a 14 00 sub 0x142ac8,%edi 118cc5: 89 7a 1c mov %edi,0x1c(%edx) (*timer_server->schedule_operation)( timer_server, the_timer ); 118cc8: 58 pop %eax 118cc9: 59 pop %ecx 118cca: 52 push %edx 118ccb: 53 push %ebx 118ccc: ff 53 04 call *0x4(%ebx) _Thread_Enable_dispatch(); 118ccf: e8 80 31 00 00 call 11be54 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 118cd4: 83 c4 10 add $0x10,%esp 118cd7: 31 c0 xor %eax,%eax 118cd9: e9 75 ff ff ff jmp 118c53 118cde: 66 90 xchg %ax,%ax if ( !timer_server ) return RTEMS_INCORRECT_STATE; if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; 118ce0: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 118ce5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 118ce8: 5b pop %ebx <== NOT EXECUTED 118ce9: 5e pop %esi <== NOT EXECUTED 118cea: 5f pop %edi <== NOT EXECUTED 118ceb: c9 leave <== NOT EXECUTED 118cec: c3 ret <== NOT EXECUTED 118ced: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; if ( !routine ) return RTEMS_INVALID_ADDRESS; 118cf0: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 118cf5: 8d 65 f4 lea -0xc(%ebp),%esp 118cf8: 5b pop %ebx 118cf9: 5e pop %esi 118cfa: 5f pop %edi 118cfb: c9 leave 118cfc: c3 ret 118cfd: 8d 76 00 lea 0x0(%esi),%esi Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server; if ( !timer_server ) return RTEMS_INCORRECT_STATE; 118d00: b8 0e 00 00 00 mov $0xe,%eax 118d05: e9 49 ff ff ff jmp 118c53 118d0a: 66 90 xchg %ax,%ax #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 118d0c: b8 04 00 00 00 mov $0x4,%eax 118d11: e9 3d ff ff ff jmp 118c53 =============================================================================== 0010c700 : static int rtems_verror( rtems_error_code_t error_flag, const char *printf_format, va_list arglist ) { 10c700: 55 push %ebp 10c701: 89 e5 mov %esp,%ebp 10c703: 57 push %edi 10c704: 56 push %esi 10c705: 53 push %ebx 10c706: 83 ec 1c sub $0x1c,%esp 10c709: 89 c3 mov %eax,%ebx 10c70b: 89 d6 mov %edx,%esi 10c70d: 89 cf mov %ecx,%edi int local_errno = 0; int chars_written = 0; rtems_status_code status; if (error_flag & RTEMS_ERROR_PANIC) { 10c70f: a9 00 00 00 20 test $0x20000000,%eax 10c714: 74 2b je 10c741 if (rtems_panic_in_progress++) 10c716: 8b 15 a0 e9 12 00 mov 0x12e9a0,%edx 10c71c: 8d 42 01 lea 0x1(%edx),%eax 10c71f: a3 a0 e9 12 00 mov %eax,0x12e9a0 10c724: 85 d2 test %edx,%edx 10c726: 74 10 je 10c738 <== ALWAYS TAKEN rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10c728: a1 10 eb 12 00 mov 0x12eb10,%eax <== NOT EXECUTED 10c72d: 40 inc %eax <== NOT EXECUTED 10c72e: a3 10 eb 12 00 mov %eax,0x12eb10 <== NOT EXECUTED RTEMS_COMPILER_MEMORY_BARRIER(); 10c733: a1 a0 e9 12 00 mov 0x12e9a0,%eax <== NOT EXECUTED _Thread_Disable_dispatch(); /* disable task switches */ /* don't aggravate things */ if (rtems_panic_in_progress > 2) 10c738: 83 f8 02 cmp $0x2,%eax 10c73b: 0f 8f af 00 00 00 jg 10c7f0 <== NEVER TAKEN return 0; } (void) fflush(stdout); /* in case stdout/stderr same */ 10c741: 83 ec 0c sub $0xc,%esp 10c744: a1 20 c7 12 00 mov 0x12c720,%eax 10c749: ff 70 08 pushl 0x8(%eax) 10c74c: e8 7f c0 00 00 call 1187d0 status = error_flag & ~RTEMS_ERROR_MASK; 10c751: 89 d8 mov %ebx,%eax 10c753: 25 ff ff ff 8f and $0x8fffffff,%eax 10c758: 89 45 e4 mov %eax,-0x1c(%ebp) if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */ 10c75b: 83 c4 10 add $0x10,%esp 10c75e: 81 e3 00 00 00 40 and $0x40000000,%ebx 10c764: 0f 85 be 00 00 00 jne 10c828 <== NEVER TAKEN rtems_error_code_t error_flag, const char *printf_format, va_list arglist ) { int local_errno = 0; 10c76a: 31 db xor %ebx,%ebx #if defined(RTEMS_MULTIPROCESSING) if (_System_state_Is_multiprocessing) fprintf(stderr, "[%" PRIu32 "] ", _Configuration_MP_table->node); #endif chars_written += vfprintf(stderr, printf_format, arglist); 10c76c: 50 push %eax 10c76d: 57 push %edi 10c76e: 56 push %esi 10c76f: a1 20 c7 12 00 mov 0x12c720,%eax 10c774: ff 70 0c pushl 0xc(%eax) 10c777: e8 18 25 01 00 call 11ec94 10c77c: 89 c6 mov %eax,%esi if (status) 10c77e: 83 c4 10 add $0x10,%esp 10c781: 8b 4d e4 mov -0x1c(%ebp),%ecx 10c784: 85 c9 test %ecx,%ecx 10c786: 75 74 jne 10c7fc <== NEVER TAKEN chars_written += fprintf(stderr, " (status: %s)", rtems_status_text(status)); if (local_errno) { 10c788: 83 fb 00 cmp $0x0,%ebx 10c78b: 74 30 je 10c7bd if ((local_errno > 0) && *strerror(local_errno)) 10c78d: 7e 15 jle 10c7a4 10c78f: 83 ec 0c sub $0xc,%esp 10c792: 53 push %ebx 10c793: e8 84 cc 00 00 call 11941c 10c798: 83 c4 10 add $0x10,%esp 10c79b: 80 38 00 cmpb $0x0,(%eax) 10c79e: 0f 85 90 00 00 00 jne 10c834 <== ALWAYS TAKEN chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno)); else chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno); 10c7a4: 52 push %edx 10c7a5: 53 push %ebx 10c7a6: 68 69 72 12 00 push $0x127269 10c7ab: a1 20 c7 12 00 mov 0x12c720,%eax 10c7b0: ff 70 0c pushl 0xc(%eax) 10c7b3: e8 0c c4 00 00 call 118bc4 10c7b8: 01 c6 add %eax,%esi 10c7ba: 83 c4 10 add $0x10,%esp } chars_written += fprintf(stderr, "\n"); 10c7bd: 83 ec 08 sub $0x8,%esp 10c7c0: 68 22 65 12 00 push $0x126522 10c7c5: a1 20 c7 12 00 mov 0x12c720,%eax 10c7ca: ff 70 0c pushl 0xc(%eax) 10c7cd: e8 f2 c3 00 00 call 118bc4 10c7d2: 8d 34 30 lea (%eax,%esi,1),%esi (void) fflush(stderr); 10c7d5: 58 pop %eax 10c7d6: a1 20 c7 12 00 mov 0x12c720,%eax 10c7db: ff 70 0c pushl 0xc(%eax) 10c7de: e8 ed bf 00 00 call 1187d0 return chars_written; 10c7e3: 83 c4 10 add $0x10,%esp } 10c7e6: 89 f0 mov %esi,%eax 10c7e8: 8d 65 f4 lea -0xc(%ebp),%esp 10c7eb: 5b pop %ebx 10c7ec: 5e pop %esi 10c7ed: 5f pop %edi 10c7ee: c9 leave 10c7ef: c3 ret if (rtems_panic_in_progress++) _Thread_Disable_dispatch(); /* disable task switches */ /* don't aggravate things */ if (rtems_panic_in_progress > 2) return 0; 10c7f0: 31 f6 xor %esi,%esi chars_written += fprintf(stderr, "\n"); (void) fflush(stderr); return chars_written; } 10c7f2: 89 f0 mov %esi,%eax <== NOT EXECUTED 10c7f4: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c7f7: 5b pop %ebx <== NOT EXECUTED 10c7f8: 5e pop %esi <== NOT EXECUTED 10c7f9: 5f pop %edi <== NOT EXECUTED 10c7fa: c9 leave <== NOT EXECUTED 10c7fb: c3 ret <== NOT EXECUTED chars_written += vfprintf(stderr, printf_format, arglist); if (status) chars_written += fprintf(stderr, " (status: %s)", rtems_status_text(status)); 10c7fc: 83 ec 0c sub $0xc,%esp 10c7ff: ff 75 e4 pushl -0x1c(%ebp) 10c802: e8 e1 fe ff ff call 10c6e8 10c807: 83 c4 0c add $0xc,%esp 10c80a: 50 push %eax 10c80b: 68 4e 72 12 00 push $0x12724e 10c810: a1 20 c7 12 00 mov 0x12c720,%eax 10c815: ff 70 0c pushl 0xc(%eax) 10c818: e8 a7 c3 00 00 call 118bc4 #endif chars_written += vfprintf(stderr, printf_format, arglist); if (status) chars_written += 10c81d: 01 c6 add %eax,%esi 10c81f: 83 c4 10 add $0x10,%esp 10c822: e9 61 ff ff ff jmp 10c788 10c827: 90 nop (void) fflush(stdout); /* in case stdout/stderr same */ status = error_flag & ~RTEMS_ERROR_MASK; if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */ local_errno = errno; 10c828: e8 0b bc 00 00 call 118438 <__errno> 10c82d: 8b 18 mov (%eax),%ebx 10c82f: e9 38 ff ff ff jmp 10c76c chars_written += fprintf(stderr, " (status: %s)", rtems_status_text(status)); if (local_errno) { if ((local_errno > 0) && *strerror(local_errno)) chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno)); 10c834: 83 ec 0c sub $0xc,%esp 10c837: 53 push %ebx 10c838: e8 df cb 00 00 call 11941c 10c83d: 83 c4 0c add $0xc,%esp 10c840: 50 push %eax 10c841: 68 5c 72 12 00 push $0x12725c 10c846: e9 60 ff ff ff jmp 10c7ab =============================================================================== 001086b4 : /* * Extract an integer value from the database */ static int scanInt(FILE *fp, int *val) { 1086b4: 55 push %ebp 1086b5: 89 e5 mov %esp,%ebp 1086b7: 57 push %edi 1086b8: 56 push %esi 1086b9: 53 push %ebx 1086ba: 83 ec 1c sub $0x1c,%esp 1086bd: 89 c6 mov %eax,%esi 1086bf: 89 55 e0 mov %edx,-0x20(%ebp) int c; unsigned int i = 0; unsigned int limit = INT_MAX; int sign = 0; 1086c2: 31 ff xor %edi,%edi static int scanInt(FILE *fp, int *val) { int c; unsigned int i = 0; unsigned int limit = INT_MAX; 1086c4: c7 45 e4 ff ff ff 7f movl $0x7fffffff,-0x1c(%ebp) */ static int scanInt(FILE *fp, int *val) { int c; unsigned int i = 0; 1086cb: 31 db xor %ebx,%ebx unsigned int limit = INT_MAX; int sign = 0; int d; for (;;) { c = getc(fp); 1086cd: 8b 46 04 mov 0x4(%esi),%eax 1086d0: 48 dec %eax 1086d1: 89 46 04 mov %eax,0x4(%esi) 1086d4: 85 c0 test %eax,%eax 1086d6: 78 52 js 10872a <== NEVER TAKEN 1086d8: 8b 06 mov (%esi),%eax 1086da: 0f b6 08 movzbl (%eax),%ecx 1086dd: 40 inc %eax 1086de: 89 06 mov %eax,(%esi) if (c == ':') 1086e0: 83 f9 3a cmp $0x3a,%ecx 1086e3: 74 5f je 108744 break; if (sign == 0) { 1086e5: 85 ff test %edi,%edi 1086e7: 75 0e jne 1086f7 if (c == '-') { 1086e9: 83 f9 2d cmp $0x2d,%ecx 1086ec: 0f 84 8a 00 00 00 je 10877c sign = -1; limit++; continue; } sign = 1; 1086f2: bf 01 00 00 00 mov $0x1,%edi } if (!isdigit(c)) 1086f7: a1 94 74 12 00 mov 0x127494,%eax 1086fc: f6 44 08 01 04 testb $0x4,0x1(%eax,%ecx,1) 108701: 74 6d je 108770 return 0; d = c - '0'; if ((i > (limit / 10)) 108703: b8 cd cc cc cc mov $0xcccccccd,%eax 108708: f7 65 e4 mull -0x1c(%ebp) 10870b: c1 ea 03 shr $0x3,%edx 10870e: 39 d3 cmp %edx,%ebx 108710: 77 5e ja 108770 } sign = 1; } if (!isdigit(c)) return 0; d = c - '0'; 108712: 83 e9 30 sub $0x30,%ecx if ((i > (limit / 10)) || ((i == (limit / 10)) && (d > (limit % 10)))) 108715: 39 d3 cmp %edx,%ebx 108717: 74 47 je 108760 return 0; i = i * 10 + d; 108719: 8d 04 9b lea (%ebx,%ebx,4),%eax 10871c: 8d 1c 41 lea (%ecx,%eax,2),%ebx unsigned int limit = INT_MAX; int sign = 0; int d; for (;;) { c = getc(fp); 10871f: 8b 46 04 mov 0x4(%esi),%eax 108722: 48 dec %eax 108723: 89 46 04 mov %eax,0x4(%esi) 108726: 85 c0 test %eax,%eax 108728: 79 ae jns 1086d8 <== ALWAYS TAKEN 10872a: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10872d: 56 push %esi <== NOT EXECUTED 10872e: ff 35 a0 74 12 00 pushl 0x1274a0 <== NOT EXECUTED 108734: e8 73 cd 00 00 call 1154ac <__srget_r> <== NOT EXECUTED 108739: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10873b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if (c == ':') 10873e: 83 f9 3a cmp $0x3a,%ecx <== NOT EXECUTED 108741: 75 a2 jne 1086e5 <== NOT EXECUTED 108743: 90 nop <== NOT EXECUTED if ((i > (limit / 10)) || ((i == (limit / 10)) && (d > (limit % 10)))) return 0; i = i * 10 + d; } if (sign == 0) 108744: 85 ff test %edi,%edi 108746: 74 28 je 108770 <== NEVER TAKEN return 0; *val = i * sign; 108748: 0f af df imul %edi,%ebx 10874b: 8b 45 e0 mov -0x20(%ebp),%eax 10874e: 89 18 mov %ebx,(%eax) return 1; 108750: b8 01 00 00 00 mov $0x1,%eax } 108755: 8d 65 f4 lea -0xc(%ebp),%esp 108758: 5b pop %ebx 108759: 5e pop %esi 10875a: 5f pop %edi 10875b: c9 leave 10875c: c3 ret 10875d: 8d 76 00 lea 0x0(%esi),%esi } if (!isdigit(c)) return 0; d = c - '0'; if ((i > (limit / 10)) || ((i == (limit / 10)) && (d > (limit % 10)))) 108760: 8d 04 9b lea (%ebx,%ebx,4),%eax 108763: d1 e0 shl %eax 108765: 8b 55 e4 mov -0x1c(%ebp),%edx 108768: 29 c2 sub %eax,%edx 10876a: 39 d1 cmp %edx,%ecx 10876c: 76 ab jbe 108719 <== NEVER TAKEN 10876e: 66 90 xchg %ax,%ax return 0; i = i * 10 + d; } if (sign == 0) return 0; 108770: 31 c0 xor %eax,%eax *val = i * sign; return 1; } 108772: 8d 65 f4 lea -0xc(%ebp),%esp 108775: 5b pop %ebx 108776: 5e pop %esi 108777: 5f pop %edi 108778: c9 leave 108779: c3 ret 10877a: 66 90 xchg %ax,%ax if (c == ':') break; if (sign == 0) { if (c == '-') { sign = -1; limit++; 10877c: ff 45 e4 incl -0x1c(%ebp) c = getc(fp); if (c == ':') break; if (sign == 0) { if (c == '-') { sign = -1; 10877f: bf ff ff ff ff mov $0xffffffff,%edi limit++; continue; 108784: e9 44 ff ff ff jmp 1086cd =============================================================================== 0010878c : /* * Extract a string value from the database */ static int scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag) { 10878c: 55 push %ebp 10878d: 89 e5 mov %esp,%ebp 10878f: 57 push %edi 108790: 56 push %esi 108791: 53 push %ebx 108792: 83 ec 0c sub $0xc,%esp 108795: 89 c3 mov %eax,%ebx 108797: 89 ce mov %ecx,%esi 108799: 8b 7d 08 mov 0x8(%ebp),%edi int c; *name = *bufp; 10879c: 8b 01 mov (%ecx),%eax 10879e: 89 02 mov %eax,(%edx) 1087a0: eb 26 jmp 1087c8 1087a2: 66 90 xchg %ax,%ax for (;;) { c = getc(fp); 1087a4: 8b 13 mov (%ebx),%edx 1087a6: 0f b6 02 movzbl (%edx),%eax 1087a9: 42 inc %edx 1087aa: 89 13 mov %edx,(%ebx) if (c == ':') { 1087ac: 83 f8 3a cmp $0x3a,%eax 1087af: 74 3b je 1087ec if (nlFlag) return 0; break; } if (c == '\n') { 1087b1: 83 f8 0a cmp $0xa,%eax 1087b4: 74 56 je 10880c if (!nlFlag) return 0; break; } if (c == EOF) 1087b6: 83 f8 ff cmp $0xffffffff,%eax 1087b9: 74 59 je 108814 return 0; if (*nleft < 2) 1087bb: 83 3f 01 cmpl $0x1,(%edi) 1087be: 76 54 jbe 108814 return 0; **bufp = c; 1087c0: 8b 16 mov (%esi),%edx 1087c2: 88 02 mov %al,(%edx) ++(*bufp); 1087c4: ff 06 incl (%esi) --(*nleft); 1087c6: ff 0f decl (%edi) { int c; *name = *bufp; for (;;) { c = getc(fp); 1087c8: 8b 43 04 mov 0x4(%ebx),%eax 1087cb: 48 dec %eax 1087cc: 89 43 04 mov %eax,0x4(%ebx) 1087cf: 85 c0 test %eax,%eax 1087d1: 79 d1 jns 1087a4 1087d3: 83 ec 08 sub $0x8,%esp 1087d6: 53 push %ebx 1087d7: ff 35 a0 74 12 00 pushl 0x1274a0 1087dd: e8 ca cc 00 00 call 1154ac <__srget_r> 1087e2: 83 c4 10 add $0x10,%esp if (c == ':') { 1087e5: 83 f8 3a cmp $0x3a,%eax 1087e8: 75 c7 jne 1087b1 <== ALWAYS TAKEN 1087ea: 66 90 xchg %ax,%ax if (nlFlag) 1087ec: 8b 55 0c mov 0xc(%ebp),%edx 1087ef: 85 d2 test %edx,%edx 1087f1: 75 21 jne 108814 return 0; **bufp = c; ++(*bufp); --(*nleft); } **bufp = '\0'; 1087f3: 8b 06 mov (%esi),%eax 1087f5: c6 00 00 movb $0x0,(%eax) ++(*bufp); 1087f8: ff 06 incl (%esi) --(*nleft); 1087fa: ff 0f decl (%edi) return 1; 1087fc: b8 01 00 00 00 mov $0x1,%eax } 108801: 8d 65 f4 lea -0xc(%ebp),%esp 108804: 5b pop %ebx 108805: 5e pop %esi 108806: 5f pop %edi 108807: c9 leave 108808: c3 ret 108809: 8d 76 00 lea 0x0(%esi),%esi if (nlFlag) return 0; break; } if (c == '\n') { if (!nlFlag) 10880c: 8b 45 0c mov 0xc(%ebp),%eax 10880f: 85 c0 test %eax,%eax 108811: 75 e0 jne 1087f3 108813: 90 nop break; } if (c == EOF) return 0; if (*nleft < 2) return 0; 108814: 31 c0 xor %eax,%eax } **bufp = '\0'; ++(*bufp); --(*nleft); return 1; } 108816: 8d 65 f4 lea -0xc(%ebp),%esp 108819: 5b pop %ebx 10881a: 5e pop %esi 10881b: 5f pop %edi 10881c: c9 leave 10881d: c3 ret =============================================================================== 00108820 : FILE *fp, struct group *grp, char *buffer, size_t bufsize ) { 108820: 55 push %ebp 108821: 89 e5 mov %esp,%ebp 108823: 57 push %edi 108824: 56 push %esi 108825: 53 push %ebx 108826: 83 ec 34 sub $0x34,%esp 108829: 89 c6 mov %eax,%esi 10882b: 89 d3 mov %edx,%ebx 10882d: 89 4d d4 mov %ecx,-0x2c(%ebp) int grgid; char *grmem, *cp; int memcount; if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0) 108830: 8d 7d d4 lea -0x2c(%ebp),%edi 108833: 6a 00 push $0x0 108835: 8d 45 08 lea 0x8(%ebp),%eax 108838: 50 push %eax 108839: 89 f9 mov %edi,%ecx 10883b: 89 f0 mov %esi,%eax 10883d: e8 4a ff ff ff call 10878c 108842: 83 c4 10 add $0x10,%esp 108845: 85 c0 test %eax,%eax 108847: 75 0b jne 108854 /* * Hack to produce (hopefully) a suitably-aligned array of pointers */ if (bufsize < (((memcount+1)*sizeof(char *)) + 15)) return 0; 108849: 31 c0 xor %eax,%eax grp->gr_mem[memcount++] = cp + 1; } } grp->gr_mem[memcount] = NULL; return 1; } 10884b: 8d 65 f4 lea -0xc(%ebp),%esp 10884e: 5b pop %ebx 10884f: 5e pop %esi 108850: 5f pop %edi 108851: c9 leave 108852: c3 ret 108853: 90 nop int grgid; char *grmem, *cp; int memcount; if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0) || !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0) 108854: 83 ec 08 sub $0x8,%esp 108857: 8d 53 04 lea 0x4(%ebx),%edx 10885a: 6a 00 push $0x0 10885c: 8d 45 08 lea 0x8(%ebp),%eax 10885f: 50 push %eax 108860: 89 f9 mov %edi,%ecx 108862: 89 f0 mov %esi,%eax 108864: e8 23 ff ff ff call 10878c 108869: 83 c4 10 add $0x10,%esp 10886c: 85 c0 test %eax,%eax 10886e: 74 d9 je 108849 <== NEVER TAKEN || !scanInt(fp, &grgid) 108870: 8d 55 e4 lea -0x1c(%ebp),%edx 108873: 89 f0 mov %esi,%eax 108875: e8 3a fe ff ff call 1086b4 10887a: 85 c0 test %eax,%eax 10887c: 74 cb je 108849 <== NEVER TAKEN || !scanString(fp, &grmem, &buffer, &bufsize, 1)) 10887e: 83 ec 08 sub $0x8,%esp 108881: 8d 55 e0 lea -0x20(%ebp),%edx 108884: 6a 01 push $0x1 108886: 8d 45 08 lea 0x8(%ebp),%eax 108889: 50 push %eax 10888a: 89 f9 mov %edi,%ecx 10888c: 89 f0 mov %esi,%eax 10888e: e8 f9 fe ff ff call 10878c 108893: 83 c4 10 add $0x10,%esp 108896: 85 c0 test %eax,%eax 108898: 74 af je 108849 <== NEVER TAKEN return 0; grp->gr_gid = grgid; 10889a: 8b 45 e4 mov -0x1c(%ebp),%eax 10889d: 66 89 43 08 mov %ax,0x8(%ebx) /* * Determine number of members */ for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 1088a1: 8b 7d e0 mov -0x20(%ebp),%edi 1088a4: 8a 07 mov (%edi),%al 1088a6: 84 c0 test %al,%al 1088a8: 74 7d je 108927 <== NEVER TAKEN 1088aa: 89 fa mov %edi,%edx 1088ac: b9 01 00 00 00 mov $0x1,%ecx 1088b1: eb 08 jmp 1088bb 1088b3: 90 nop 1088b4: 42 inc %edx 1088b5: 8a 02 mov (%edx),%al 1088b7: 84 c0 test %al,%al 1088b9: 74 09 je 1088c4 if(*cp == ',') 1088bb: 3c 2c cmp $0x2c,%al 1088bd: 75 f5 jne 1088b4 memcount++; 1088bf: 41 inc %ecx 1088c0: eb f2 jmp 1088b4 1088c2: 66 90 xchg %ax,%ax grp->gr_gid = grgid; /* * Determine number of members */ for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 1088c4: 8d 04 8d 13 00 00 00 lea 0x13(,%ecx,4),%eax } /* * Hack to produce (hopefully) a suitably-aligned array of pointers */ if (bufsize < (((memcount+1)*sizeof(char *)) + 15)) 1088cb: 39 45 08 cmp %eax,0x8(%ebp) 1088ce: 0f 82 75 ff ff ff jb 108849 <== NEVER TAKEN return 0; grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15); 1088d4: 8b 75 d4 mov -0x2c(%ebp),%esi 1088d7: 83 c6 0f add $0xf,%esi 1088da: 83 e6 f0 and $0xfffffff0,%esi 1088dd: 89 73 0c mov %esi,0xc(%ebx) /* * Fill in pointer array */ grp->gr_mem[0] = grmem; 1088e0: 89 3e mov %edi,(%esi) for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 1088e2: 8b 45 e0 mov -0x20(%ebp),%eax 1088e5: 8a 10 mov (%eax),%dl 1088e7: 84 d2 test %dl,%dl 1088e9: 74 43 je 10892e <== NEVER TAKEN } /* * Extract a single group record from the database */ static int scangr( 1088eb: 40 inc %eax /* * Fill in pointer array */ grp->gr_mem[0] = grmem; for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 1088ec: b9 01 00 00 00 mov $0x1,%ecx 1088f1: eb 08 jmp 1088fb 1088f3: 90 nop 1088f4: 8a 10 mov (%eax),%dl 1088f6: 40 inc %eax 1088f7: 84 d2 test %dl,%dl 1088f9: 74 15 je 108910 if(*cp == ',') { 1088fb: 80 fa 2c cmp $0x2c,%dl 1088fe: 75 f4 jne 1088f4 *cp = '\0'; 108900: c6 40 ff 00 movb $0x0,-0x1(%eax) grp->gr_mem[memcount++] = cp + 1; 108904: 8b 53 0c mov 0xc(%ebx),%edx 108907: 89 04 8a mov %eax,(%edx,%ecx,4) 10890a: 41 inc %ecx 10890b: eb e7 jmp 1088f4 10890d: 8d 76 00 lea 0x0(%esi),%esi /* * Fill in pointer array */ grp->gr_mem[0] = grmem; for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 108910: 8b 73 0c mov 0xc(%ebx),%esi 108913: c1 e1 02 shl $0x2,%ecx if(*cp == ',') { *cp = '\0'; grp->gr_mem[memcount++] = cp + 1; } } grp->gr_mem[memcount] = NULL; 108916: c7 04 0e 00 00 00 00 movl $0x0,(%esi,%ecx,1) return 1; 10891d: b8 01 00 00 00 mov $0x1,%eax 108922: e9 24 ff ff ff jmp 10884b grp->gr_gid = grgid; /* * Determine number of members */ for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 108927: b8 17 00 00 00 mov $0x17,%eax <== NOT EXECUTED 10892c: eb 9d jmp 1088cb <== NOT EXECUTED /* * Fill in pointer array */ grp->gr_mem[0] = grmem; for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 10892e: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 108933: eb e1 jmp 108916 <== NOT EXECUTED =============================================================================== 00108938 : FILE *fp, struct passwd *pwd, char *buffer, size_t bufsize ) { 108938: 55 push %ebp 108939: 89 e5 mov %esp,%ebp 10893b: 57 push %edi 10893c: 56 push %esi 10893d: 53 push %ebx 10893e: 83 ec 34 sub $0x34,%esp 108941: 89 c6 mov %eax,%esi 108943: 89 d3 mov %edx,%ebx 108945: 89 4d d4 mov %ecx,-0x2c(%ebp) int pwuid, pwgid; if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0) 108948: 8d 7d d4 lea -0x2c(%ebp),%edi 10894b: 6a 00 push $0x0 10894d: 8d 45 08 lea 0x8(%ebp),%eax 108950: 50 push %eax 108951: 89 f9 mov %edi,%ecx 108953: 89 f0 mov %esi,%eax 108955: e8 32 fe ff ff call 10878c 10895a: 83 c4 10 add $0x10,%esp 10895d: 85 c0 test %eax,%eax 10895f: 75 0b jne 10896c || !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; 108961: 31 c0 xor %eax,%eax pwd->pw_uid = pwuid; pwd->pw_gid = pwgid; return 1; } 108963: 8d 65 f4 lea -0xc(%ebp),%esp 108966: 5b pop %ebx 108967: 5e pop %esi 108968: 5f pop %edi 108969: c9 leave 10896a: c3 ret 10896b: 90 nop ) { int pwuid, pwgid; if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0) || !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0) 10896c: 83 ec 08 sub $0x8,%esp 10896f: 8d 53 04 lea 0x4(%ebx),%edx 108972: 6a 00 push $0x0 108974: 8d 45 08 lea 0x8(%ebp),%eax 108977: 50 push %eax 108978: 89 f9 mov %edi,%ecx 10897a: 89 f0 mov %esi,%eax 10897c: e8 0b fe ff ff call 10878c 108981: 83 c4 10 add $0x10,%esp 108984: 85 c0 test %eax,%eax 108986: 74 d9 je 108961 <== NEVER TAKEN || !scanInt(fp, &pwuid) 108988: 8d 55 e4 lea -0x1c(%ebp),%edx 10898b: 89 f0 mov %esi,%eax 10898d: e8 22 fd ff ff call 1086b4 108992: 85 c0 test %eax,%eax 108994: 74 cb je 108961 || !scanInt(fp, &pwgid) 108996: 8d 55 e0 lea -0x20(%ebp),%edx 108999: 89 f0 mov %esi,%eax 10899b: e8 14 fd ff ff call 1086b4 1089a0: 85 c0 test %eax,%eax 1089a2: 74 bd je 108961 || !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0) 1089a4: 83 ec 08 sub $0x8,%esp 1089a7: 8d 53 0c lea 0xc(%ebx),%edx 1089aa: 6a 00 push $0x0 1089ac: 8d 45 08 lea 0x8(%ebp),%eax 1089af: 50 push %eax 1089b0: 89 f9 mov %edi,%ecx 1089b2: 89 f0 mov %esi,%eax 1089b4: e8 d3 fd ff ff call 10878c 1089b9: 83 c4 10 add $0x10,%esp 1089bc: 85 c0 test %eax,%eax 1089be: 74 a1 je 108961 <== NEVER TAKEN || !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0) 1089c0: 83 ec 08 sub $0x8,%esp 1089c3: 8d 53 10 lea 0x10(%ebx),%edx 1089c6: 6a 00 push $0x0 1089c8: 8d 45 08 lea 0x8(%ebp),%eax 1089cb: 50 push %eax 1089cc: 89 f9 mov %edi,%ecx 1089ce: 89 f0 mov %esi,%eax 1089d0: e8 b7 fd ff ff call 10878c 1089d5: 83 c4 10 add $0x10,%esp 1089d8: 85 c0 test %eax,%eax 1089da: 74 85 je 108961 <== NEVER TAKEN || !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0) 1089dc: 83 ec 08 sub $0x8,%esp 1089df: 8d 53 14 lea 0x14(%ebx),%edx 1089e2: 6a 00 push $0x0 1089e4: 8d 45 08 lea 0x8(%ebp),%eax 1089e7: 50 push %eax 1089e8: 89 f9 mov %edi,%ecx 1089ea: 89 f0 mov %esi,%eax 1089ec: e8 9b fd ff ff call 10878c 1089f1: 83 c4 10 add $0x10,%esp 1089f4: 85 c0 test %eax,%eax 1089f6: 0f 84 65 ff ff ff je 108961 <== NEVER TAKEN || !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1)) 1089fc: 83 ec 08 sub $0x8,%esp 1089ff: 8d 53 18 lea 0x18(%ebx),%edx 108a02: 6a 01 push $0x1 108a04: 8d 45 08 lea 0x8(%ebp),%eax 108a07: 50 push %eax 108a08: 89 f9 mov %edi,%ecx 108a0a: 89 f0 mov %esi,%eax 108a0c: e8 7b fd ff ff call 10878c 108a11: 83 c4 10 add $0x10,%esp 108a14: 85 c0 test %eax,%eax 108a16: 0f 84 45 ff ff ff je 108961 return 0; pwd->pw_uid = pwuid; 108a1c: 8b 45 e4 mov -0x1c(%ebp),%eax 108a1f: 66 89 43 08 mov %ax,0x8(%ebx) pwd->pw_gid = pwgid; 108a23: 8b 45 e0 mov -0x20(%ebp),%eax 108a26: 66 89 43 0a mov %ax,0xa(%ebx) return 1; 108a2a: b8 01 00 00 00 mov $0x1,%eax 108a2f: e9 2f ff ff ff jmp 108963 =============================================================================== 0010be34 : #include int sched_get_priority_max( int policy ) { 10be34: 55 push %ebp 10be35: 89 e5 mov %esp,%ebp 10be37: 83 ec 08 sub $0x8,%esp 10be3a: 8b 45 08 mov 0x8(%ebp),%eax switch ( policy ) { 10be3d: 85 c0 test %eax,%eax 10be3f: 78 0a js 10be4b 10be41: 83 f8 02 cmp $0x2,%eax 10be44: 7e 1a jle 10be60 10be46: 83 f8 04 cmp $0x4,%eax 10be49: 74 15 je 10be60 <== ALWAYS TAKEN case SCHED_RR: case SCHED_SPORADIC: break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 10be4b: e8 20 81 00 00 call 113f70 <__errno> 10be50: c7 00 16 00 00 00 movl $0x16,(%eax) 10be56: b8 ff ff ff ff mov $0xffffffff,%eax } return POSIX_SCHEDULER_MAXIMUM_PRIORITY; } 10be5b: c9 leave 10be5c: c3 ret 10be5d: 8d 76 00 lea 0x0(%esi),%esi default: rtems_set_errno_and_return_minus_one( EINVAL ); } return POSIX_SCHEDULER_MAXIMUM_PRIORITY; 10be60: 0f b6 05 9c 4d 12 00 movzbl 0x124d9c,%eax 10be67: 48 dec %eax } 10be68: c9 leave 10be69: c3 ret =============================================================================== 0010be6c : #include int sched_get_priority_min( int policy ) { 10be6c: 55 push %ebp 10be6d: 89 e5 mov %esp,%ebp 10be6f: 83 ec 08 sub $0x8,%esp 10be72: 8b 45 08 mov 0x8(%ebp),%eax switch ( policy ) { 10be75: 85 c0 test %eax,%eax 10be77: 78 0a js 10be83 10be79: 83 f8 02 cmp $0x2,%eax 10be7c: 7e 1a jle 10be98 <== ALWAYS TAKEN 10be7e: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 10be81: 74 15 je 10be98 <== NOT EXECUTED case SCHED_RR: case SCHED_SPORADIC: break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 10be83: e8 e8 80 00 00 call 113f70 <__errno> 10be88: c7 00 16 00 00 00 movl $0x16,(%eax) 10be8e: b8 ff ff ff ff mov $0xffffffff,%eax } return POSIX_SCHEDULER_MINIMUM_PRIORITY; } 10be93: c9 leave 10be94: c3 ret 10be95: 8d 76 00 lea 0x0(%esi),%esi default: rtems_set_errno_and_return_minus_one( EINVAL ); } return POSIX_SCHEDULER_MINIMUM_PRIORITY; 10be98: b8 01 00 00 00 mov $0x1,%eax } 10be9d: c9 leave 10be9e: c3 ret =============================================================================== 0010bea0 : int sched_rr_get_interval( pid_t pid, struct timespec *interval ) { 10bea0: 55 push %ebp 10bea1: 89 e5 mov %esp,%ebp 10bea3: 56 push %esi 10bea4: 53 push %ebx 10bea5: 8b 75 08 mov 0x8(%ebp),%esi 10bea8: 8b 5d 0c mov 0xc(%ebp),%ebx /* * Only supported for the "calling process" (i.e. this node). */ if ( pid && pid != getpid() ) 10beab: 85 f6 test %esi,%esi 10bead: 75 21 jne 10bed0 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( ESRCH ); if ( !interval ) 10beaf: 85 db test %ebx,%ebx 10beb1: 74 38 je 10beeb rtems_set_errno_and_return_minus_one( EINVAL ); _Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval ); 10beb3: 83 ec 08 sub $0x8,%esp 10beb6: 53 push %ebx 10beb7: ff 35 60 90 12 00 pushl 0x129060 10bebd: e8 b2 35 00 00 call 10f474 <_Timespec_From_ticks> return 0; 10bec2: 83 c4 10 add $0x10,%esp 10bec5: 31 c0 xor %eax,%eax } 10bec7: 8d 65 f8 lea -0x8(%ebp),%esp 10beca: 5b pop %ebx 10becb: 5e pop %esi 10becc: c9 leave 10becd: c3 ret 10bece: 66 90 xchg %ax,%ax { /* * Only supported for the "calling process" (i.e. this node). */ if ( pid && pid != getpid() ) 10bed0: e8 fb c8 ff ff call 1087d0 10bed5: 39 f0 cmp %esi,%eax 10bed7: 74 d6 je 10beaf rtems_set_errno_and_return_minus_one( ESRCH ); 10bed9: e8 92 80 00 00 call 113f70 <__errno> 10bede: c7 00 03 00 00 00 movl $0x3,(%eax) 10bee4: b8 ff ff ff ff mov $0xffffffff,%eax 10bee9: eb dc jmp 10bec7 if ( !interval ) rtems_set_errno_and_return_minus_one( EINVAL ); 10beeb: e8 80 80 00 00 call 113f70 <__errno> 10bef0: c7 00 16 00 00 00 movl $0x16,(%eax) 10bef6: b8 ff ff ff ff mov $0xffffffff,%eax 10befb: eb ca jmp 10bec7 =============================================================================== 0010e604 : */ int sem_close( sem_t *sem ) { 10e604: 55 push %ebp 10e605: 89 e5 mov %esp,%ebp 10e607: 83 ec 1c sub $0x1c,%esp register POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); 10e60a: 8d 45 f4 lea -0xc(%ebp),%eax sem_t *id, Objects_Locations *location ) { return (POSIX_Semaphore_Control *) _Objects_Get( &_POSIX_Semaphore_Information, (Objects_Id)*id, location ); 10e60d: 50 push %eax 10e60e: 8b 45 08 mov 0x8(%ebp),%eax 10e611: ff 30 pushl (%eax) 10e613: 68 20 de 12 00 push $0x12de20 10e618: e8 bf 21 00 00 call 1107dc <_Objects_Get> switch ( location ) { 10e61d: 83 c4 10 add $0x10,%esp 10e620: 8b 55 f4 mov -0xc(%ebp),%edx 10e623: 85 d2 test %edx,%edx 10e625: 74 15 je 10e63c #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10e627: e8 7c 8f 00 00 call 1175a8 <__errno> 10e62c: c7 00 16 00 00 00 movl $0x16,(%eax) 10e632: b8 ff ff ff ff mov $0xffffffff,%eax } 10e637: c9 leave 10e638: c3 ret 10e639: 8d 76 00 lea 0x0(%esi),%esi the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { case OBJECTS_LOCAL: the_semaphore->open_count -= 1; 10e63c: ff 48 18 decl 0x18(%eax) _POSIX_Semaphore_Delete( the_semaphore ); 10e63f: 83 ec 0c sub $0xc,%esp 10e642: 50 push %eax 10e643: e8 3c 64 00 00 call 114a84 <_POSIX_Semaphore_Delete> _Thread_Enable_dispatch(); 10e648: e8 87 2d 00 00 call 1113d4 <_Thread_Enable_dispatch> return 0; 10e64d: 83 c4 10 add $0x10,%esp 10e650: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 10e652: c9 leave 10e653: c3 ret =============================================================================== 0010e654 : */ int sem_destroy( sem_t *sem ) { 10e654: 55 push %ebp 10e655: 89 e5 mov %esp,%ebp 10e657: 83 ec 1c sub $0x1c,%esp register POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); 10e65a: 8d 45 f4 lea -0xc(%ebp),%eax 10e65d: 50 push %eax 10e65e: 8b 45 08 mov 0x8(%ebp),%eax 10e661: ff 30 pushl (%eax) 10e663: 68 20 de 12 00 push $0x12de20 10e668: e8 6f 21 00 00 call 1107dc <_Objects_Get> switch ( location ) { 10e66d: 83 c4 10 add $0x10,%esp 10e670: 8b 55 f4 mov -0xc(%ebp),%edx 10e673: 85 d2 test %edx,%edx 10e675: 74 15 je 10e68c #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10e677: e8 2c 8f 00 00 call 1175a8 <__errno> 10e67c: c7 00 16 00 00 00 movl $0x16,(%eax) 10e682: b8 ff ff ff ff mov $0xffffffff,%eax } 10e687: c9 leave 10e688: c3 ret 10e689: 8d 76 00 lea 0x0(%esi),%esi case OBJECTS_LOCAL: /* * Undefined operation on a named semaphore. */ if ( the_semaphore->named == true ) { 10e68c: 80 78 14 00 cmpb $0x0,0x14(%eax) 10e690: 75 16 jne 10e6a8 _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EINVAL ); } _POSIX_Semaphore_Delete( the_semaphore ); 10e692: 83 ec 0c sub $0xc,%esp 10e695: 50 push %eax 10e696: e8 e9 63 00 00 call 114a84 <_POSIX_Semaphore_Delete> _Thread_Enable_dispatch(); 10e69b: e8 34 2d 00 00 call 1113d4 <_Thread_Enable_dispatch> return 0; 10e6a0: 83 c4 10 add $0x10,%esp 10e6a3: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 10e6a5: c9 leave 10e6a6: c3 ret 10e6a7: 90 nop /* * Undefined operation on a named semaphore. */ if ( the_semaphore->named == true ) { _Thread_Enable_dispatch(); 10e6a8: e8 27 2d 00 00 call 1113d4 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EINVAL ); 10e6ad: e8 f6 8e 00 00 call 1175a8 <__errno> 10e6b2: c7 00 16 00 00 00 movl $0x16,(%eax) 10e6b8: b8 ff ff ff ff mov $0xffffffff,%eax case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 10e6bd: c9 leave 10e6be: c3 ret =============================================================================== 0010e6c0 : int sem_getvalue( sem_t *sem, int *sval ) { 10e6c0: 55 push %ebp 10e6c1: 89 e5 mov %esp,%ebp 10e6c3: 83 ec 1c sub $0x1c,%esp register POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); 10e6c6: 8d 45 f4 lea -0xc(%ebp),%eax 10e6c9: 50 push %eax 10e6ca: 8b 45 08 mov 0x8(%ebp),%eax 10e6cd: ff 30 pushl (%eax) 10e6cf: 68 20 de 12 00 push $0x12de20 10e6d4: e8 03 21 00 00 call 1107dc <_Objects_Get> switch ( location ) { 10e6d9: 83 c4 10 add $0x10,%esp 10e6dc: 8b 55 f4 mov -0xc(%ebp),%edx 10e6df: 85 d2 test %edx,%edx 10e6e1: 74 15 je 10e6f8 #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10e6e3: e8 c0 8e 00 00 call 1175a8 <__errno> 10e6e8: c7 00 16 00 00 00 movl $0x16,(%eax) 10e6ee: b8 ff ff ff ff mov $0xffffffff,%eax } 10e6f3: c9 leave 10e6f4: c3 ret 10e6f5: 8d 76 00 lea 0x0(%esi),%esi the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { case OBJECTS_LOCAL: *sval = _CORE_semaphore_Get_count( &the_semaphore->Semaphore ); 10e6f8: 8b 50 64 mov 0x64(%eax),%edx 10e6fb: 8b 45 0c mov 0xc(%ebp),%eax 10e6fe: 89 10 mov %edx,(%eax) _Thread_Enable_dispatch(); 10e700: e8 cf 2c 00 00 call 1113d4 <_Thread_Enable_dispatch> return 0; 10e705: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 10e707: c9 leave 10e708: c3 ret =============================================================================== 0010e754 : int oflag, ... /* mode_t mode, */ /* unsigned int value */ ) { 10e754: 55 push %ebp 10e755: 89 e5 mov %esp,%ebp 10e757: 57 push %edi 10e758: 56 push %esi 10e759: 53 push %ebx 10e75a: 83 ec 2c sub $0x2c,%esp 10e75d: 8b 75 08 mov 0x8(%ebp),%esi rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10e760: a1 10 db 12 00 mov 0x12db10,%eax 10e765: 40 inc %eax 10e766: a3 10 db 12 00 mov %eax,0x12db10 POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { 10e76b: 8b 7d 0c mov 0xc(%ebp),%edi 10e76e: 81 e7 00 02 00 00 and $0x200,%edi 10e774: 0f 85 86 00 00 00 jne 10e800 /* unsigned int value */ ) { va_list arg; mode_t mode; unsigned int value = 0; 10e77a: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) mode = (mode_t) va_arg( arg, unsigned int ); value = va_arg( arg, unsigned int ); va_end(arg); } status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id ); 10e781: 83 ec 08 sub $0x8,%esp 10e784: 8d 45 e4 lea -0x1c(%ebp),%eax 10e787: 50 push %eax 10e788: 56 push %esi 10e789: e8 46 63 00 00 call 114ad4 <_POSIX_Semaphore_Name_to_id> 10e78e: 89 c3 mov %eax,%ebx * and we can just return a pointer to the id. Otherwise we may * need to check to see if this is a "semaphore does not exist" * or some other miscellaneous error on the name. */ if ( status ) { 10e790: 83 c4 10 add $0x10,%esp 10e793: 85 c0 test %eax,%eax 10e795: 74 25 je 10e7bc /* * Unless provided a valid name that did not already exist * and we are willing to create then it is an error. */ if ( !( status == ENOENT && (oflag & O_CREAT) ) ) { 10e797: 83 f8 02 cmp $0x2,%eax 10e79a: 75 04 jne 10e7a0 <== NEVER TAKEN 10e79c: 85 ff test %edi,%edi 10e79e: 75 6c jne 10e80c _Thread_Enable_dispatch(); 10e7a0: e8 2f 2c 00 00 call 1113d4 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one_cast( status, sem_t * ); 10e7a5: e8 fe 8d 00 00 call 1175a8 <__errno> 10e7aa: 89 18 mov %ebx,(%eax) 10e7ac: b8 ff ff ff ff mov $0xffffffff,%eax id = &the_semaphore->Semaphore_id; #else id = (sem_t *)&the_semaphore->Object.id; #endif return id; } 10e7b1: 8d 65 f4 lea -0xc(%ebp),%esp 10e7b4: 5b pop %ebx 10e7b5: 5e pop %esi 10e7b6: 5f pop %edi 10e7b7: c9 leave 10e7b8: c3 ret 10e7b9: 8d 76 00 lea 0x0(%esi),%esi /* * Check for existence with creation. */ if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { 10e7bc: 8b 45 0c mov 0xc(%ebp),%eax 10e7bf: 25 00 0a 00 00 and $0xa00,%eax 10e7c4: 3d 00 0a 00 00 cmp $0xa00,%eax 10e7c9: 74 65 je 10e830 10e7cb: 50 push %eax _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * ); } the_semaphore = _POSIX_Semaphore_Get( &the_semaphore_id, &location ); 10e7cc: 8d 45 dc lea -0x24(%ebp),%eax 10e7cf: 50 push %eax 10e7d0: ff 75 e4 pushl -0x1c(%ebp) 10e7d3: 68 20 de 12 00 push $0x12de20 10e7d8: e8 ff 1f 00 00 call 1107dc <_Objects_Get> 10e7dd: 89 45 e0 mov %eax,-0x20(%ebp) the_semaphore->open_count += 1; 10e7e0: ff 40 18 incl 0x18(%eax) _Thread_Enable_dispatch(); 10e7e3: e8 ec 2b 00 00 call 1113d4 <_Thread_Enable_dispatch> _Thread_Enable_dispatch(); 10e7e8: e8 e7 2b 00 00 call 1113d4 <_Thread_Enable_dispatch> goto return_id; 10e7ed: 83 c4 10 add $0x10,%esp return_id: #if defined(RTEMS_USE_16_BIT_OBJECT) the_semaphore->Semaphore_id = the_semaphore->Object.id; id = &the_semaphore->Semaphore_id; #else id = (sem_t *)&the_semaphore->Object.id; 10e7f0: 8b 45 e0 mov -0x20(%ebp),%eax 10e7f3: 83 c0 08 add $0x8,%eax #endif return id; } 10e7f6: 8d 65 f4 lea -0xc(%ebp),%esp 10e7f9: 5b pop %ebx 10e7fa: 5e pop %esi 10e7fb: 5f pop %edi 10e7fc: c9 leave 10e7fd: c3 ret 10e7fe: 66 90 xchg %ax,%ax _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { va_start(arg, oflag); mode = (mode_t) va_arg( arg, unsigned int ); value = va_arg( arg, unsigned int ); 10e800: 8b 45 14 mov 0x14(%ebp),%eax 10e803: 89 45 d4 mov %eax,-0x2c(%ebp) 10e806: e9 76 ff ff ff jmp 10e781 10e80b: 90 nop /* * At this point, the semaphore does not exist and everything has been * checked. We should go ahead and create a semaphore. */ status =_POSIX_Semaphore_Create_support( 10e80c: 8d 45 e0 lea -0x20(%ebp),%eax 10e80f: 50 push %eax 10e810: ff 75 d4 pushl -0x2c(%ebp) 10e813: 6a 00 push $0x0 10e815: 56 push %esi 10e816: e8 5d 61 00 00 call 114978 <_POSIX_Semaphore_Create_support> 10e81b: 89 c3 mov %eax,%ebx /* * errno was set by Create_support, so don't set it again. */ _Thread_Enable_dispatch(); 10e81d: e8 b2 2b 00 00 call 1113d4 <_Thread_Enable_dispatch> if ( status == -1 ) 10e822: 83 c4 10 add $0x10,%esp 10e825: 43 inc %ebx 10e826: 75 c8 jne 10e7f0 return SEM_FAILED; 10e828: b8 ff ff ff ff mov $0xffffffff,%eax 10e82d: eb c7 jmp 10e7f6 10e82f: 90 nop /* * Check for existence with creation. */ if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { _Thread_Enable_dispatch(); 10e830: e8 9f 2b 00 00 call 1113d4 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * ); 10e835: e8 6e 8d 00 00 call 1175a8 <__errno> 10e83a: c7 00 11 00 00 00 movl $0x11,(%eax) 10e840: b8 ff ff ff ff mov $0xffffffff,%eax 10e845: eb af jmp 10e7f6 =============================================================================== 0010e848 : */ int sem_post( sem_t *sem ) { 10e848: 55 push %ebp 10e849: 89 e5 mov %esp,%ebp 10e84b: 83 ec 1c sub $0x1c,%esp register POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); 10e84e: 8d 45 f4 lea -0xc(%ebp),%eax 10e851: 50 push %eax 10e852: 8b 45 08 mov 0x8(%ebp),%eax 10e855: ff 30 pushl (%eax) 10e857: 68 20 de 12 00 push $0x12de20 10e85c: e8 7b 1f 00 00 call 1107dc <_Objects_Get> switch ( location ) { 10e861: 83 c4 10 add $0x10,%esp 10e864: 8b 4d f4 mov -0xc(%ebp),%ecx 10e867: 85 c9 test %ecx,%ecx 10e869: 74 15 je 10e880 #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10e86b: e8 38 8d 00 00 call 1175a8 <__errno> 10e870: c7 00 16 00 00 00 movl $0x16,(%eax) 10e876: b8 ff ff ff ff mov $0xffffffff,%eax } 10e87b: c9 leave 10e87c: c3 ret 10e87d: 8d 76 00 lea 0x0(%esi),%esi the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { case OBJECTS_LOCAL: _CORE_semaphore_Surrender( 10e880: 52 push %edx 10e881: 6a 00 push $0x0 10e883: ff 70 08 pushl 0x8(%eax) 10e886: 83 c0 1c add $0x1c,%eax 10e889: 50 push %eax 10e88a: e8 61 15 00 00 call 10fdf0 <_CORE_semaphore_Surrender> NULL /* XXX need to define a routine to handle this case */ #else NULL #endif ); _Thread_Enable_dispatch(); 10e88f: e8 40 2b 00 00 call 1113d4 <_Thread_Enable_dispatch> return 0; 10e894: 83 c4 10 add $0x10,%esp 10e897: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 10e899: c9 leave 10e89a: c3 ret =============================================================================== 0010e89c : int sem_timedwait( sem_t *sem, const struct timespec *abstime ) { 10e89c: 55 push %ebp 10e89d: 89 e5 mov %esp,%ebp 10e89f: 53 push %ebx 10e8a0: 83 ec 1c sub $0x1c,%esp 10e8a3: 8b 5d 08 mov 0x8(%ebp),%ebx * * If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID, * POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW, * then we should not wait. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); 10e8a6: 8d 45 f4 lea -0xc(%ebp),%eax 10e8a9: 50 push %eax 10e8aa: ff 75 0c pushl 0xc(%ebp) 10e8ad: e8 56 55 00 00 call 113e08 <_POSIX_Absolute_timeout_to_ticks> if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE ) 10e8b2: 83 c4 10 add $0x10,%esp 10e8b5: 83 f8 03 cmp $0x3,%eax 10e8b8: 74 16 je 10e8d0 <== ALWAYS TAKEN do_wait = false; lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks ); 10e8ba: 50 push %eax <== NOT EXECUTED 10e8bb: ff 75 f4 pushl -0xc(%ebp) <== NOT EXECUTED 10e8be: 6a 00 push $0x0 <== NOT EXECUTED 10e8c0: 53 push %ebx <== NOT EXECUTED 10e8c1: e8 7a 62 00 00 call 114b40 <_POSIX_Semaphore_Wait_support><== NOT EXECUTED 10e8c6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED lock_status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) rtems_set_errno_and_return_minus_one( ETIMEDOUT ); } return lock_status; } 10e8c9: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10e8cc: c9 leave <== NOT EXECUTED 10e8cd: c3 ret <== NOT EXECUTED 10e8ce: 66 90 xchg %ax,%ax <== NOT EXECUTED */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE ) do_wait = false; lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks ); 10e8d0: 52 push %edx 10e8d1: ff 75 f4 pushl -0xc(%ebp) 10e8d4: 6a 01 push $0x1 10e8d6: 53 push %ebx 10e8d7: e8 64 62 00 00 call 114b40 <_POSIX_Semaphore_Wait_support> 10e8dc: 83 c4 10 add $0x10,%esp lock_status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) rtems_set_errno_and_return_minus_one( ETIMEDOUT ); } return lock_status; } 10e8df: 8b 5d fc mov -0x4(%ebp),%ebx 10e8e2: c9 leave 10e8e3: c3 ret =============================================================================== 0010b2f4 : int setitimer( int which, const struct itimerval *value, struct itimerval *ovalue ) { 10b2f4: 55 push %ebp 10b2f5: 89 e5 mov %esp,%ebp 10b2f7: 83 ec 08 sub $0x8,%esp if ( !value ) 10b2fa: 8b 55 0c mov 0xc(%ebp),%edx 10b2fd: 85 d2 test %edx,%edx 10b2ff: 74 33 je 10b334 rtems_set_errno_and_return_minus_one( EFAULT ); if ( !ovalue ) 10b301: 8b 45 10 mov 0x10(%ebp),%eax 10b304: 85 c0 test %eax,%eax 10b306: 74 2c je 10b334 rtems_set_errno_and_return_minus_one( EFAULT ); switch ( which ) { 10b308: 83 7d 08 02 cmpl $0x2,0x8(%ebp) 10b30c: 76 12 jbe 10b320 case ITIMER_PROF: rtems_set_errno_and_return_minus_one( ENOSYS ); default: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10b30e: e8 6d 86 00 00 call 113980 <__errno> 10b313: c7 00 16 00 00 00 movl $0x16,(%eax) } 10b319: b8 ff ff ff ff mov $0xffffffff,%eax 10b31e: c9 leave 10b31f: c3 ret switch ( which ) { case ITIMER_REAL: case ITIMER_VIRTUAL: case ITIMER_PROF: rtems_set_errno_and_return_minus_one( ENOSYS ); 10b320: e8 5b 86 00 00 call 113980 <__errno> 10b325: c7 00 58 00 00 00 movl $0x58,(%eax) default: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 10b32b: b8 ff ff ff ff mov $0xffffffff,%eax 10b330: c9 leave 10b331: c3 ret 10b332: 66 90 xchg %ax,%ax { if ( !value ) rtems_set_errno_and_return_minus_one( EFAULT ); if ( !ovalue ) rtems_set_errno_and_return_minus_one( EFAULT ); 10b334: e8 47 86 00 00 call 113980 <__errno> 10b339: c7 00 0e 00 00 00 movl $0xe,(%eax) 10b33f: eb d8 jmp 10b319 =============================================================================== 0010bd48 : int sigaction( int sig, const struct sigaction *act, struct sigaction *oact ) { 10bd48: 55 push %ebp 10bd49: 89 e5 mov %esp,%ebp 10bd4b: 57 push %edi 10bd4c: 56 push %esi 10bd4d: 53 push %ebx 10bd4e: 83 ec 1c sub $0x1c,%esp 10bd51: 8b 5d 08 mov 0x8(%ebp),%ebx 10bd54: 8b 45 0c mov 0xc(%ebp),%eax 10bd57: 8b 55 10 mov 0x10(%ebp),%edx ISR_Level level; if ( oact ) 10bd5a: 85 d2 test %edx,%edx 10bd5c: 74 13 je 10bd71 *oact = _POSIX_signals_Vectors[ sig ]; 10bd5e: 8d 0c 5b lea (%ebx,%ebx,2),%ecx 10bd61: 8d 34 8d c0 a3 12 00 lea 0x12a3c0(,%ecx,4),%esi 10bd68: b9 03 00 00 00 mov $0x3,%ecx 10bd6d: 89 d7 mov %edx,%edi 10bd6f: f3 a5 rep movsl %ds:(%esi),%es:(%edi) if ( !sig ) 10bd71: 85 db test %ebx,%ebx 10bd73: 74 77 je 10bdec static inline bool is_valid_signo( int signo ) { return ((signo) >= 1 && (signo) <= 32 ); 10bd75: 8d 53 ff lea -0x1(%ebx),%edx rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 10bd78: 83 fa 1f cmp $0x1f,%edx 10bd7b: 77 6f ja 10bdec * * NOTE: Solaris documentation claims to "silently enforce" this which * contradicts the POSIX specification. */ if ( sig == SIGKILL ) 10bd7d: 83 fb 09 cmp $0x9,%ebx 10bd80: 74 6a je 10bdec /* * Evaluate the new action structure and set the global signal vector * appropriately. */ if ( act ) { 10bd82: 85 c0 test %eax,%eax 10bd84: 74 62 je 10bde8 <== NEVER TAKEN /* * Unless the user is installing the default signal actions, then * we can just copy the provided sigaction structure into the vectors. */ _ISR_Disable( level ); 10bd86: 9c pushf 10bd87: fa cli 10bd88: 8f 45 e4 popl -0x1c(%ebp) if ( act->sa_handler == SIG_DFL ) { 10bd8b: 8b 50 08 mov 0x8(%eax),%edx 10bd8e: 85 d2 test %edx,%edx 10bd90: 74 36 je 10bdc8 _POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ]; } else { _POSIX_signals_Clear_process_signals( sig ); 10bd92: 83 ec 0c sub $0xc,%esp 10bd95: 53 push %ebx 10bd96: 89 45 e0 mov %eax,-0x20(%ebp) 10bd99: e8 be 57 00 00 call 11155c <_POSIX_signals_Clear_process_signals> _POSIX_signals_Vectors[ sig ] = *act; 10bd9e: 8d 14 5b lea (%ebx,%ebx,2),%edx 10bda1: 8d 14 95 c0 a3 12 00 lea 0x12a3c0(,%edx,4),%edx 10bda8: b9 03 00 00 00 mov $0x3,%ecx 10bdad: 8b 45 e0 mov -0x20(%ebp),%eax 10bdb0: 89 d7 mov %edx,%edi 10bdb2: 89 c6 mov %eax,%esi 10bdb4: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 10bdb6: 83 c4 10 add $0x10,%esp } _ISR_Enable( level ); 10bdb9: ff 75 e4 pushl -0x1c(%ebp) 10bdbc: 9d popf * now (signals not posted when SIG_IGN). * + If we are now ignoring a signal that was previously pending, * we clear the pending signal indicator. */ return 0; 10bdbd: 31 c0 xor %eax,%eax } 10bdbf: 8d 65 f4 lea -0xc(%ebp),%esp 10bdc2: 5b pop %ebx 10bdc3: 5e pop %esi 10bdc4: 5f pop %edi 10bdc5: c9 leave 10bdc6: c3 ret 10bdc7: 90 nop * we can just copy the provided sigaction structure into the vectors. */ _ISR_Disable( level ); if ( act->sa_handler == SIG_DFL ) { _POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ]; 10bdc8: 8d 34 5b lea (%ebx,%ebx,2),%esi 10bdcb: c1 e6 02 shl $0x2,%esi 10bdce: 8d 86 c0 a3 12 00 lea 0x12a3c0(%esi),%eax 10bdd4: 81 c6 40 38 12 00 add $0x123840,%esi 10bdda: b9 03 00 00 00 mov $0x3,%ecx 10bddf: 89 c7 mov %eax,%edi 10bde1: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 10bde3: eb d4 jmp 10bdb9 10bde5: 8d 76 00 lea 0x0(%esi),%esi * now (signals not posted when SIG_IGN). * + If we are now ignoring a signal that was previously pending, * we clear the pending signal indicator. */ return 0; 10bde8: 31 c0 xor %eax,%eax 10bdea: eb d3 jmp 10bdbf <== NOT EXECUTED * NOTE: Solaris documentation claims to "silently enforce" this which * contradicts the POSIX specification. */ if ( sig == SIGKILL ) rtems_set_errno_and_return_minus_one( EINVAL ); 10bdec: e8 7b 84 00 00 call 11426c <__errno> 10bdf1: c7 00 16 00 00 00 movl $0x16,(%eax) 10bdf7: b8 ff ff ff ff mov $0xffffffff,%eax 10bdfc: eb c1 jmp 10bdbf =============================================================================== 0010c120 : int sigtimedwait( const sigset_t *set, siginfo_t *info, const struct timespec *timeout ) { 10c120: 55 push %ebp 10c121: 89 e5 mov %esp,%ebp 10c123: 57 push %edi 10c124: 56 push %esi 10c125: 53 push %ebx 10c126: 83 ec 2c sub $0x2c,%esp 10c129: 8b 5d 08 mov 0x8(%ebp),%ebx 10c12c: 8b 7d 0c mov 0xc(%ebp),%edi 10c12f: 8b 75 10 mov 0x10(%ebp),%esi ISR_Level level; /* * Error check parameters before disabling interrupts. */ if ( !set ) 10c132: 85 db test %ebx,%ebx 10c134: 0f 84 9e 01 00 00 je 10c2d8 /* NOTE: This is very specifically a RELATIVE not ABSOLUTE time * in the Open Group specification. */ interval = 0; if ( timeout ) { 10c13a: 85 f6 test %esi,%esi 10c13c: 0f 84 3e 01 00 00 je 10c280 if ( !_Timespec_Is_valid( timeout ) ) 10c142: 83 ec 0c sub $0xc,%esp 10c145: 56 push %esi 10c146: e8 41 36 00 00 call 10f78c <_Timespec_Is_valid> 10c14b: 83 c4 10 add $0x10,%esp 10c14e: 84 c0 test %al,%al 10c150: 0f 84 82 01 00 00 je 10c2d8 rtems_set_errno_and_return_minus_one( EINVAL ); interval = _Timespec_To_ticks( timeout ); 10c156: 83 ec 0c sub $0xc,%esp 10c159: 56 push %esi 10c15a: e8 95 36 00 00 call 10f7f4 <_Timespec_To_ticks> if ( !interval ) 10c15f: 83 c4 10 add $0x10,%esp 10c162: 85 c0 test %eax,%eax 10c164: 0f 84 6e 01 00 00 je 10c2d8 <== NEVER TAKEN /* * Initialize local variables. */ the_info = ( info ) ? info : &signal_information; 10c16a: 85 ff test %edi,%edi 10c16c: 0f 84 18 01 00 00 je 10c28a <== NEVER TAKEN the_thread = _Thread_Executing; 10c172: 8b 0d 98 9b 12 00 mov 0x129b98,%ecx api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10c178: 8b 91 ec 00 00 00 mov 0xec(%ecx),%edx * What if they are already pending? */ /* API signals pending? */ _ISR_Disable( level ); 10c17e: 9c pushf 10c17f: fa cli 10c180: 8f 45 d0 popl -0x30(%ebp) if ( *set & api->signals_pending ) { 10c183: 8b 33 mov (%ebx),%esi 10c185: 89 75 d4 mov %esi,-0x2c(%ebp) 10c188: 8b b2 d4 00 00 00 mov 0xd4(%edx),%esi 10c18e: 85 75 d4 test %esi,-0x2c(%ebp) 10c191: 0f 85 fd 00 00 00 jne 10c294 return the_info->si_signo; } /* Process pending signals? */ if ( *set & _POSIX_signals_Pending ) { 10c197: 8b 35 08 9e 12 00 mov 0x129e08,%esi 10c19d: 85 75 d4 test %esi,-0x2c(%ebp) 10c1a0: 0f 85 96 00 00 00 jne 10c23c the_info->si_code = SI_USER; the_info->si_value.sival_int = 0; return signo; } the_info->si_signo = -1; 10c1a6: c7 07 ff ff ff ff movl $0xffffffff,(%edi) 10c1ac: 8b 35 f0 95 12 00 mov 0x1295f0,%esi 10c1b2: 46 inc %esi 10c1b3: 89 35 f0 95 12 00 mov %esi,0x1295f0 _Thread_Disable_dispatch(); the_thread->Wait.queue = &_POSIX_signals_Wait_queue; 10c1b9: c7 41 44 a0 9d 12 00 movl $0x129da0,0x44(%ecx) the_thread->Wait.return_code = EINTR; 10c1c0: c7 41 34 04 00 00 00 movl $0x4,0x34(%ecx) the_thread->Wait.option = *set; 10c1c7: 8b 33 mov (%ebx),%esi 10c1c9: 89 71 30 mov %esi,0x30(%ecx) the_thread->Wait.return_argument = the_info; 10c1cc: 89 79 28 mov %edi,0x28(%ecx) RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 10c1cf: c7 05 d0 9d 12 00 01 movl $0x1,0x129dd0 10c1d6: 00 00 00 _Thread_queue_Enter_critical_section( &_POSIX_signals_Wait_queue ); _ISR_Enable( level ); 10c1d9: ff 75 d0 pushl -0x30(%ebp) 10c1dc: 9d popf _Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval ); 10c1dd: 51 push %ecx 10c1de: 68 cc f4 10 00 push $0x10f4cc 10c1e3: 50 push %eax 10c1e4: 68 a0 9d 12 00 push $0x129da0 10c1e9: 89 55 cc mov %edx,-0x34(%ebp) 10c1ec: e8 af 2f 00 00 call 10f1a0 <_Thread_queue_Enqueue_with_handler> _Thread_Enable_dispatch(); 10c1f1: e8 06 2b 00 00 call 10ecfc <_Thread_Enable_dispatch> /* * When the thread is set free by a signal, it is need to eliminate * the signal. */ _POSIX_signals_Clear_signals( api, the_info->si_signo, the_info, false, false ); 10c1f6: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10c1fd: 6a 00 push $0x0 10c1ff: 57 push %edi 10c200: ff 37 pushl (%edi) 10c202: 8b 55 cc mov -0x34(%ebp),%edx 10c205: 52 push %edx 10c206: e8 4d 5a 00 00 call 111c58 <_POSIX_signals_Clear_signals> /* Set errno only if return code is not EINTR or * if EINTR was caused by a signal being caught, which * was not in our set. */ if ( (_Thread_Executing->Wait.return_code != EINTR) 10c20b: 83 c4 20 add $0x20,%esp 10c20e: a1 98 9b 12 00 mov 0x129b98,%eax 10c213: 83 78 34 04 cmpl $0x4,0x34(%eax) 10c217: 0f 85 d3 00 00 00 jne 10c2f0 || !(*set & signo_to_mask( the_info->si_signo )) ) { 10c21d: 8b 37 mov (%edi),%esi 10c21f: 8d 4e ff lea -0x1(%esi),%ecx 10c222: b8 01 00 00 00 mov $0x1,%eax 10c227: d3 e0 shl %cl,%eax 10c229: 85 03 test %eax,(%ebx) 10c22b: 0f 84 bf 00 00 00 je 10c2f0 errno = _Thread_Executing->Wait.return_code; return -1; } return the_info->si_signo; } 10c231: 89 f0 mov %esi,%eax 10c233: 8d 65 f4 lea -0xc(%ebp),%esp 10c236: 5b pop %ebx 10c237: 5e pop %esi 10c238: 5f pop %edi 10c239: c9 leave 10c23a: c3 ret 10c23b: 90 nop } /* Process pending signals? */ if ( *set & _POSIX_signals_Pending ) { signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending ); 10c23c: 83 ec 0c sub $0xc,%esp 10c23f: 56 push %esi 10c240: 89 55 cc mov %edx,-0x34(%ebp) 10c243: e8 94 fe ff ff call 10c0dc <_POSIX_signals_Get_lowest> 10c248: 89 c6 mov %eax,%esi _POSIX_signals_Clear_signals( api, signo, the_info, true, false ); 10c24a: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10c251: 6a 01 push $0x1 10c253: 57 push %edi 10c254: 50 push %eax 10c255: 8b 55 cc mov -0x34(%ebp),%edx 10c258: 52 push %edx 10c259: e8 fa 59 00 00 call 111c58 <_POSIX_signals_Clear_signals> _ISR_Enable( level ); 10c25e: ff 75 d0 pushl -0x30(%ebp) 10c261: 9d popf the_info->si_signo = signo; 10c262: 89 37 mov %esi,(%edi) the_info->si_code = SI_USER; 10c264: c7 47 04 01 00 00 00 movl $0x1,0x4(%edi) the_info->si_value.sival_int = 0; 10c26b: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi) return signo; 10c272: 83 c4 20 add $0x20,%esp errno = _Thread_Executing->Wait.return_code; return -1; } return the_info->si_signo; } 10c275: 89 f0 mov %esi,%eax 10c277: 8d 65 f4 lea -0xc(%ebp),%esp 10c27a: 5b pop %ebx 10c27b: 5e pop %esi 10c27c: 5f pop %edi 10c27d: c9 leave 10c27e: c3 ret 10c27f: 90 nop /* NOTE: This is very specifically a RELATIVE not ABSOLUTE time * in the Open Group specification. */ interval = 0; 10c280: 31 c0 xor %eax,%eax /* * Initialize local variables. */ the_info = ( info ) ? info : &signal_information; 10c282: 85 ff test %edi,%edi 10c284: 0f 85 e8 fe ff ff jne 10c172 10c28a: 8d 7d dc lea -0x24(%ebp),%edi 10c28d: e9 e0 fe ff ff jmp 10c172 10c292: 66 90 xchg %ax,%ax /* API signals pending? */ _ISR_Disable( level ); if ( *set & api->signals_pending ) { /* XXX real info later */ the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending ); 10c294: 83 ec 0c sub $0xc,%esp 10c297: 56 push %esi 10c298: 89 55 cc mov %edx,-0x34(%ebp) 10c29b: e8 3c fe ff ff call 10c0dc <_POSIX_signals_Get_lowest> 10c2a0: 89 07 mov %eax,(%edi) _POSIX_signals_Clear_signals( 10c2a2: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10c2a9: 6a 00 push $0x0 10c2ab: 57 push %edi 10c2ac: 50 push %eax 10c2ad: 8b 55 cc mov -0x34(%ebp),%edx 10c2b0: 52 push %edx 10c2b1: e8 a2 59 00 00 call 111c58 <_POSIX_signals_Clear_signals> the_info->si_signo, the_info, false, false ); _ISR_Enable( level ); 10c2b6: ff 75 d0 pushl -0x30(%ebp) 10c2b9: 9d popf the_info->si_code = SI_USER; 10c2ba: c7 47 04 01 00 00 00 movl $0x1,0x4(%edi) the_info->si_value.sival_int = 0; 10c2c1: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi) return the_info->si_signo; 10c2c8: 8b 37 mov (%edi),%esi 10c2ca: 83 c4 20 add $0x20,%esp errno = _Thread_Executing->Wait.return_code; return -1; } return the_info->si_signo; } 10c2cd: 89 f0 mov %esi,%eax 10c2cf: 8d 65 f4 lea -0xc(%ebp),%esp 10c2d2: 5b pop %ebx 10c2d3: 5e pop %esi 10c2d4: 5f pop %edi 10c2d5: c9 leave 10c2d6: c3 ret 10c2d7: 90 nop rtems_set_errno_and_return_minus_one( EINVAL ); interval = _Timespec_To_ticks( timeout ); if ( !interval ) rtems_set_errno_and_return_minus_one( EINVAL ); 10c2d8: e8 e3 85 00 00 call 1148c0 <__errno> 10c2dd: c7 00 16 00 00 00 movl $0x16,(%eax) 10c2e3: be ff ff ff ff mov $0xffffffff,%esi 10c2e8: e9 44 ff ff ff jmp 10c231 10c2ed: 8d 76 00 lea 0x0(%esi),%esi * was not in our set. */ if ( (_Thread_Executing->Wait.return_code != EINTR) || !(*set & signo_to_mask( the_info->si_signo )) ) { errno = _Thread_Executing->Wait.return_code; 10c2f0: e8 cb 85 00 00 call 1148c0 <__errno> 10c2f5: 8b 15 98 9b 12 00 mov 0x129b98,%edx 10c2fb: 8b 52 34 mov 0x34(%edx),%edx 10c2fe: 89 10 mov %edx,(%eax) return -1; 10c300: be ff ff ff ff mov $0xffffffff,%esi 10c305: e9 27 ff ff ff jmp 10c231 =============================================================================== 0010df98 : int sigwait( const sigset_t *set, int *sig ) { 10df98: 55 push %ebp 10df99: 89 e5 mov %esp,%ebp 10df9b: 53 push %ebx 10df9c: 83 ec 08 sub $0x8,%esp 10df9f: 8b 5d 0c mov 0xc(%ebp),%ebx int status; status = sigtimedwait( set, NULL, NULL ); 10dfa2: 6a 00 push $0x0 10dfa4: 6a 00 push $0x0 10dfa6: ff 75 08 pushl 0x8(%ebp) 10dfa9: e8 e6 fd ff ff call 10dd94 if ( status != -1 ) { 10dfae: 83 c4 10 add $0x10,%esp 10dfb1: 83 f8 ff cmp $0xffffffff,%eax 10dfb4: 74 0e je 10dfc4 if ( sig ) 10dfb6: 85 db test %ebx,%ebx 10dfb8: 74 16 je 10dfd0 <== NEVER TAKEN *sig = status; 10dfba: 89 03 mov %eax,(%ebx) return 0; 10dfbc: 31 c0 xor %eax,%eax } return errno; } 10dfbe: 8b 5d fc mov -0x4(%ebp),%ebx 10dfc1: c9 leave 10dfc2: c3 ret 10dfc3: 90 nop if ( sig ) *sig = status; return 0; } return errno; 10dfc4: e8 a7 80 00 00 call 116070 <__errno> 10dfc9: 8b 00 mov (%eax),%eax } 10dfcb: 8b 5d fc mov -0x4(%ebp),%ebx 10dfce: c9 leave 10dfcf: c3 ret status = sigtimedwait( set, NULL, NULL ); if ( status != -1 ) { if ( sig ) *sig = status; return 0; 10dfd0: 31 c0 xor %eax,%eax } return errno; } 10dfd2: 8b 5d fc mov -0x4(%ebp),%ebx 10dfd5: c9 leave 10dfd6: c3 ret <== NOT EXECUTED =============================================================================== 0010a0b8 : /* * Process input character, with semaphore. */ static int siproc (unsigned char c, struct rtems_termios_tty *tty) { 10a0b8: 55 push %ebp 10a0b9: 89 e5 mov %esp,%ebp 10a0bb: 56 push %esi 10a0bc: 53 push %ebx 10a0bd: 89 d3 mov %edx,%ebx 10a0bf: 89 c6 mov %eax,%esi int i; /* * Obtain output semaphore if character will be echoed */ if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) { 10a0c1: f7 42 3c 78 0e 00 00 testl $0xe78,0x3c(%edx) 10a0c8: 75 12 jne 10a0dc <== ALWAYS TAKEN rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); i = iproc (c, tty); rtems_semaphore_release (tty->osem); } else { i = iproc (c, tty); 10a0ca: 0f b6 c0 movzbl %al,%eax 10a0cd: 89 da mov %ebx,%edx } return i; } 10a0cf: 8d 65 f8 lea -0x8(%ebp),%esp 10a0d2: 5b pop %ebx <== NOT EXECUTED 10a0d3: 5e pop %esi <== NOT EXECUTED 10a0d4: c9 leave <== NOT EXECUTED rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); i = iproc (c, tty); rtems_semaphore_release (tty->osem); } else { i = iproc (c, tty); 10a0d5: e9 92 fe ff ff jmp 109f6c <== NOT EXECUTED 10a0da: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * Obtain output semaphore if character will be echoed */ if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) { rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 10a0dc: 52 push %edx 10a0dd: 6a 00 push $0x0 10a0df: 6a 00 push $0x0 10a0e1: ff 73 18 pushl 0x18(%ebx) 10a0e4: e8 c7 15 00 00 call 10b6b0 i = iproc (c, tty); 10a0e9: 89 f2 mov %esi,%edx 10a0eb: 0f b6 c2 movzbl %dl,%eax 10a0ee: 89 da mov %ebx,%edx 10a0f0: e8 77 fe ff ff call 109f6c 10a0f5: 89 c6 mov %eax,%esi rtems_semaphore_release (tty->osem); 10a0f7: 58 pop %eax 10a0f8: ff 73 18 pushl 0x18(%ebx) 10a0fb: e8 ac 16 00 00 call 10b7ac 10a100: 83 c4 10 add $0x10,%esp } else { i = iproc (c, tty); } return i; } 10a103: 89 f0 mov %esi,%eax 10a105: 8d 65 f8 lea -0x8(%ebp),%esp 10a108: 5b pop %ebx 10a109: 5e pop %esi 10a10a: c9 leave 10a10b: c3 ret =============================================================================== 00108ecc : int _STAT_NAME( const char *path, struct stat *buf ) { 108ecc: 55 push %ebp 108ecd: 89 e5 mov %esp,%ebp 108ecf: 57 push %edi 108ed0: 56 push %esi 108ed1: 53 push %ebx 108ed2: 83 ec 3c sub $0x3c,%esp 108ed5: 8b 55 08 mov 0x8(%ebp),%edx 108ed8: 8b 75 0c mov 0xc(%ebp),%esi /* * Check to see if we were passed a valid pointer. */ if ( !buf ) 108edb: 85 f6 test %esi,%esi 108edd: 74 65 je 108f44 rtems_set_errno_and_return_minus_one( EFAULT ); status = rtems_filesystem_evaluate_path( path, strlen( path ), 108edf: b9 ff ff ff ff mov $0xffffffff,%ecx 108ee4: 89 d7 mov %edx,%edi 108ee6: 31 c0 xor %eax,%eax 108ee8: f2 ae repnz scas %es:(%edi),%al 108eea: f7 d1 not %ecx 108eec: 49 dec %ecx 108eed: 83 ec 0c sub $0xc,%esp 108ef0: 6a 01 push $0x1 108ef2: 8d 5d d4 lea -0x2c(%ebp),%ebx 108ef5: 53 push %ebx 108ef6: 6a 00 push $0x0 108ef8: 51 push %ecx 108ef9: 52 push %edx 108efa: e8 45 f1 ff ff call 108044 0, &loc, _STAT_FOLLOW_LINKS ); if ( status != 0 ) 108eff: 83 c4 20 add $0x20,%esp 108f02: 85 c0 test %eax,%eax 108f04: 74 0e je 108f14 return -1; 108f06: b8 ff ff ff ff mov $0xffffffff,%eax status = (*loc.handlers->fstat_h)( &loc, buf ); rtems_filesystem_freenode( &loc ); return status; } 108f0b: 8d 65 f4 lea -0xc(%ebp),%esp 108f0e: 5b pop %ebx 108f0f: 5e pop %esi 108f10: 5f pop %edi 108f11: c9 leave 108f12: c3 ret 108f13: 90 nop /* * Zero out the stat structure so the various support * versions of stat don't have to. */ memset( buf, 0, sizeof(struct stat) ); 108f14: b9 48 00 00 00 mov $0x48,%ecx 108f19: 89 f7 mov %esi,%edi 108f1b: f3 aa rep stos %al,%es:(%edi) status = (*loc.handlers->fstat_h)( &loc, buf ); 108f1d: 83 ec 08 sub $0x8,%esp 108f20: 56 push %esi 108f21: 53 push %ebx 108f22: 8b 45 dc mov -0x24(%ebp),%eax 108f25: ff 50 18 call *0x18(%eax) rtems_filesystem_freenode( &loc ); 108f28: 89 1c 24 mov %ebx,(%esp) 108f2b: 89 45 c4 mov %eax,-0x3c(%ebp) 108f2e: e8 e9 f1 ff ff call 10811c return status; 108f33: 83 c4 10 add $0x10,%esp 108f36: 8b 45 c4 mov -0x3c(%ebp),%eax } 108f39: 8d 65 f4 lea -0xc(%ebp),%esp 108f3c: 5b pop %ebx 108f3d: 5e pop %esi 108f3e: 5f pop %edi 108f3f: c9 leave 108f40: c3 ret 108f41: 8d 76 00 lea 0x0(%esi),%esi /* * Check to see if we were passed a valid pointer. */ if ( !buf ) rtems_set_errno_and_return_minus_one( EFAULT ); 108f44: e8 5b 87 00 00 call 1116a4 <__errno> 108f49: c7 00 0e 00 00 00 movl $0xe,(%eax) 108f4f: b8 ff ff ff ff mov $0xffffffff,%eax status = (*loc.handlers->fstat_h)( &loc, buf ); rtems_filesystem_freenode( &loc ); return status; } 108f54: 8d 65 f4 lea -0xc(%ebp),%esp 108f57: 5b pop %ebx 108f58: 5e pop %esi 108f59: 5f pop %edi 108f5a: c9 leave 108f5b: c3 ret =============================================================================== 0010b33c : #include int statvfs (const char *path, struct statvfs *sb) { 10b33c: 55 push %ebp 10b33d: 89 e5 mov %esp,%ebp 10b33f: 57 push %edi 10b340: 56 push %esi 10b341: 53 push %ebx 10b342: 83 ec 48 sub $0x48,%esp 10b345: 8b 55 08 mov 0x8(%ebp),%edx * The root node of the mounted filesytem. * The node for the directory that the fileystem is mounted on. * The mount entry that is being refered to. */ if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) ) 10b348: 31 f6 xor %esi,%esi 10b34a: b9 ff ff ff ff mov $0xffffffff,%ecx 10b34f: 89 d7 mov %edx,%edi 10b351: 89 f0 mov %esi,%eax 10b353: f2 ae repnz scas %es:(%edi),%al 10b355: f7 d1 not %ecx 10b357: 49 dec %ecx 10b358: 6a 01 push $0x1 10b35a: 8d 5d d4 lea -0x2c(%ebp),%ebx 10b35d: 53 push %ebx 10b35e: 6a 00 push $0x0 10b360: 51 push %ecx 10b361: 52 push %edx 10b362: e8 ad eb ff ff call 109f14 10b367: 83 c4 20 add $0x20,%esp 10b36a: 85 c0 test %eax,%eax 10b36c: 74 0e je 10b37c <== ALWAYS TAKEN return -1; 10b36e: b8 ff ff ff ff mov $0xffffffff,%eax result = ( fs_mount_root->ops->statvfs_h )( fs_mount_root, sb ); rtems_filesystem_freenode( &loc ); return result; } 10b373: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b376: 5b pop %ebx <== NOT EXECUTED 10b377: 5e pop %esi <== NOT EXECUTED 10b378: 5f pop %edi <== NOT EXECUTED 10b379: c9 leave <== NOT EXECUTED 10b37a: c3 ret <== NOT EXECUTED 10b37b: 90 nop <== NOT EXECUTED */ if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) ) return -1; mt_entry = loc.mt_entry; 10b37c: 8b 55 e4 mov -0x1c(%ebp),%edx fs_mount_root = &mt_entry->mt_fs_root; memset (sb, 0, sizeof (struct statvfs)); 10b37f: b9 38 00 00 00 mov $0x38,%ecx 10b384: 8b 7d 0c mov 0xc(%ebp),%edi 10b387: 89 f0 mov %esi,%eax 10b389: f3 aa rep stos %al,%es:(%edi) result = ( fs_mount_root->ops->statvfs_h )( fs_mount_root, sb ); 10b38b: 83 ec 08 sub $0x8,%esp 10b38e: 8b 42 28 mov 0x28(%edx),%eax 10b391: ff 75 0c pushl 0xc(%ebp) if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) ) return -1; mt_entry = loc.mt_entry; fs_mount_root = &mt_entry->mt_fs_root; 10b394: 83 c2 1c add $0x1c,%edx memset (sb, 0, sizeof (struct statvfs)); result = ( fs_mount_root->ops->statvfs_h )( fs_mount_root, sb ); 10b397: 52 push %edx 10b398: ff 50 44 call *0x44(%eax) rtems_filesystem_freenode( &loc ); 10b39b: 89 1c 24 mov %ebx,(%esp) 10b39e: 89 45 c4 mov %eax,-0x3c(%ebp) 10b3a1: e8 46 ec ff ff call 109fec return result; 10b3a6: 83 c4 10 add $0x10,%esp 10b3a9: 8b 45 c4 mov -0x3c(%ebp),%eax } 10b3ac: 8d 65 f4 lea -0xc(%ebp),%esp 10b3af: 5b pop %ebx 10b3b0: 5e pop %esi 10b3b1: 5f pop %edi 10b3b2: c9 leave 10b3b3: c3 ret =============================================================================== 0010acf4 : int symlink( const char *actualpath, const char *sympath ) { 10acf4: 55 push %ebp 10acf5: 89 e5 mov %esp,%ebp 10acf7: 56 push %esi 10acf8: 53 push %ebx 10acf9: 83 ec 34 sub $0x34,%esp 10acfc: 8b 75 0c mov 0xc(%ebp),%esi rtems_filesystem_location_info_t loc; int i; const char *name_start; int result; rtems_filesystem_get_start_loc( sympath, &i, &loc ); 10acff: 8d 5d dc lea -0x24(%ebp),%ebx 10ad02: 53 push %ebx 10ad03: 8d 45 f4 lea -0xc(%ebp),%eax 10ad06: 50 push %eax 10ad07: 56 push %esi 10ad08: e8 0f ff ff ff call 10ac1c result = (*loc.ops->evalformake_h)( &sympath[i], &loc, &name_start ); 10ad0d: 83 c4 0c add $0xc,%esp 10ad10: 8d 45 f0 lea -0x10(%ebp),%eax 10ad13: 50 push %eax 10ad14: 53 push %ebx 10ad15: 03 75 f4 add -0xc(%ebp),%esi 10ad18: 56 push %esi 10ad19: 8b 45 e8 mov -0x18(%ebp),%eax 10ad1c: ff 50 04 call *0x4(%eax) if ( result != 0 ) 10ad1f: 83 c4 10 add $0x10,%esp 10ad22: 85 c0 test %eax,%eax 10ad24: 74 0e je 10ad34 return -1; 10ad26: b8 ff ff ff ff mov $0xffffffff,%eax result = (*loc.ops->symlink_h)( &loc, actualpath, name_start); rtems_filesystem_freenode( &loc ); return result; } 10ad2b: 8d 65 f8 lea -0x8(%ebp),%esp 10ad2e: 5b pop %ebx 10ad2f: 5e pop %esi 10ad30: c9 leave 10ad31: c3 ret 10ad32: 66 90 xchg %ax,%ax result = (*loc.ops->evalformake_h)( &sympath[i], &loc, &name_start ); if ( result != 0 ) return -1; result = (*loc.ops->symlink_h)( &loc, actualpath, name_start); 10ad34: 50 push %eax 10ad35: ff 75 f0 pushl -0x10(%ebp) 10ad38: ff 75 08 pushl 0x8(%ebp) 10ad3b: 53 push %ebx 10ad3c: 8b 45 e8 mov -0x18(%ebp),%eax 10ad3f: ff 50 38 call *0x38(%eax) rtems_filesystem_freenode( &loc ); 10ad42: 89 1c 24 mov %ebx,(%esp) 10ad45: 89 45 d4 mov %eax,-0x2c(%ebp) 10ad48: e8 6f ec ff ff call 1099bc return result; 10ad4d: 83 c4 10 add $0x10,%esp 10ad50: 8b 45 d4 mov -0x2c(%ebp),%eax } 10ad53: 8d 65 f8 lea -0x8(%ebp),%esp 10ad56: 5b pop %ebx 10ad57: 5e pop %esi 10ad58: c9 leave 10ad59: c3 ret =============================================================================== 0010a1c8 : fdatasync(fn); } /* iterate over all FILE *'s for this thread */ static void sync_per_thread(Thread_Control *t) { 10a1c8: 55 push %ebp 10a1c9: 89 e5 mov %esp,%ebp 10a1cb: 53 push %ebx 10a1cc: 83 ec 04 sub $0x4,%esp 10a1cf: 8b 45 08 mov 0x8(%ebp),%eax /* * The sync_wrapper() function will operate on the current thread's * reent structure so we will temporarily use that. */ this_reent = t->libc_reent; 10a1d2: 8b 90 e4 00 00 00 mov 0xe4(%eax),%edx if ( this_reent ) { 10a1d8: 85 d2 test %edx,%edx 10a1da: 74 33 je 10a20f <== NEVER TAKEN current_reent = _Thread_Executing->libc_reent; 10a1dc: 8b 0d 78 9f 12 00 mov 0x129f78,%ecx 10a1e2: 8b 99 e4 00 00 00 mov 0xe4(%ecx),%ebx _Thread_Executing->libc_reent = this_reent; 10a1e8: 89 91 e4 00 00 00 mov %edx,0xe4(%ecx) _fwalk (t->libc_reent, sync_wrapper); 10a1ee: 83 ec 08 sub $0x8,%esp 10a1f1: 68 14 a2 10 00 push $0x10a214 10a1f6: ff b0 e4 00 00 00 pushl 0xe4(%eax) 10a1fc: e8 f7 b0 00 00 call 1152f8 <_fwalk> _Thread_Executing->libc_reent = current_reent; 10a201: a1 78 9f 12 00 mov 0x129f78,%eax 10a206: 89 98 e4 00 00 00 mov %ebx,0xe4(%eax) 10a20c: 83 c4 10 add $0x10,%esp } } 10a20f: 8b 5d fc mov -0x4(%ebp),%ebx 10a212: c9 leave 10a213: c3 ret =============================================================================== 0010a874 : int tcsetattr( int fd, int opt, struct termios *tp ) { 10a874: 55 push %ebp 10a875: 89 e5 mov %esp,%ebp 10a877: 56 push %esi 10a878: 53 push %ebx 10a879: 8b 5d 08 mov 0x8(%ebp),%ebx 10a87c: 8b 45 0c mov 0xc(%ebp),%eax 10a87f: 8b 75 10 mov 0x10(%ebp),%esi switch (opt) { 10a882: 85 c0 test %eax,%eax 10a884: 74 2c je 10a8b2 10a886: 48 dec %eax 10a887: 74 17 je 10a8a0 default: rtems_set_errno_and_return_minus_one( ENOTSUP ); 10a889: e8 5a a5 00 00 call 114de8 <__errno> 10a88e: c7 00 86 00 00 00 movl $0x86,(%eax) * Fall through to.... */ case TCSANOW: return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp ); } } 10a894: b8 ff ff ff ff mov $0xffffffff,%eax 10a899: 8d 65 f8 lea -0x8(%ebp),%esp 10a89c: 5b pop %ebx 10a89d: 5e pop %esi 10a89e: c9 leave 10a89f: c3 ret switch (opt) { default: rtems_set_errno_and_return_minus_one( ENOTSUP ); case TCSADRAIN: if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0) 10a8a0: 50 push %eax 10a8a1: 6a 00 push $0x0 10a8a3: 6a 03 push $0x3 10a8a5: 53 push %ebx 10a8a6: e8 09 72 00 00 call 111ab4 10a8ab: 83 c4 10 add $0x10,%esp 10a8ae: 85 c0 test %eax,%eax 10a8b0: 78 e2 js 10a894 <== NEVER TAKEN return -1; /* * Fall through to.... */ case TCSANOW: return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp ); 10a8b2: 89 75 10 mov %esi,0x10(%ebp) 10a8b5: c7 45 0c 02 00 00 00 movl $0x2,0xc(%ebp) 10a8bc: 89 5d 08 mov %ebx,0x8(%ebp) } } 10a8bf: 8d 65 f8 lea -0x8(%ebp),%esp 10a8c2: 5b pop %ebx 10a8c3: 5e pop %esi 10a8c4: c9 leave return -1; /* * Fall through to.... */ case TCSANOW: return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp ); 10a8c5: e9 ea 71 00 00 jmp 111ab4 =============================================================================== 0010b500 : int timer_create( clockid_t clock_id, struct sigevent *evp, timer_t *timerid ) { 10b500: 55 push %ebp 10b501: 89 e5 mov %esp,%ebp 10b503: 56 push %esi 10b504: 53 push %ebx 10b505: 8b 5d 0c mov 0xc(%ebp),%ebx 10b508: 8b 75 10 mov 0x10(%ebp),%esi POSIX_Timer_Control *ptimer; if ( clock_id != CLOCK_REALTIME ) 10b50b: 83 7d 08 01 cmpl $0x1,0x8(%ebp) 10b50f: 0f 85 db 00 00 00 jne 10b5f0 rtems_set_errno_and_return_minus_one( EINVAL ); if ( !timerid ) 10b515: 85 f6 test %esi,%esi 10b517: 0f 84 d3 00 00 00 je 10b5f0 /* * The data of the structure evp are checked in order to verify if they * are coherent. */ if (evp != NULL) { 10b51d: 85 db test %ebx,%ebx 10b51f: 74 21 je 10b542 /* The structure has data */ if ( ( evp->sigev_notify != SIGEV_NONE ) && 10b521: 8b 03 mov (%ebx),%eax 10b523: 48 dec %eax 10b524: 83 f8 01 cmp $0x1,%eax 10b527: 0f 87 c3 00 00 00 ja 10b5f0 <== NEVER TAKEN ( evp->sigev_notify != SIGEV_SIGNAL ) ) { /* The value of the field sigev_notify is not valid */ rtems_set_errno_and_return_minus_one( EINVAL ); } if ( !evp->sigev_signo ) 10b52d: 8b 43 04 mov 0x4(%ebx),%eax 10b530: 85 c0 test %eax,%eax 10b532: 0f 84 b8 00 00 00 je 10b5f0 <== NEVER TAKEN static inline bool is_valid_signo( int signo ) { return ((signo) >= 1 && (signo) <= 32 ); 10b538: 48 dec %eax rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(evp->sigev_signo) ) 10b539: 83 f8 1f cmp $0x1f,%eax 10b53c: 0f 87 ae 00 00 00 ja 10b5f0 <== NEVER TAKEN rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10b542: a1 d0 a0 12 00 mov 0x12a0d0,%eax 10b547: 40 inc %eax 10b548: a3 d0 a0 12 00 mov %eax,0x12a0d0 * the inactive chain of free timer control blocks. */ RTEMS_INLINE_ROUTINE POSIX_Timer_Control *_POSIX_Timer_Allocate( void ) { return (POSIX_Timer_Control *) _Objects_Allocate( &_POSIX_Timer_Information ); 10b54d: 83 ec 0c sub $0xc,%esp 10b550: 68 20 a4 12 00 push $0x12a420 10b555: e8 9a 1e 00 00 call 10d3f4 <_Objects_Allocate> /* * Allocate a timer */ ptimer = _POSIX_Timer_Allocate(); if ( !ptimer ) { 10b55a: 83 c4 10 add $0x10,%esp 10b55d: 85 c0 test %eax,%eax 10b55f: 0f 84 a2 00 00 00 je 10b607 rtems_set_errno_and_return_minus_one( EAGAIN ); } /* The data of the created timer are stored to use them later */ ptimer->state = POSIX_TIMER_STATE_CREATE_NEW; 10b565: c6 40 3c 02 movb $0x2,0x3c(%eax) ptimer->thread_id = _Thread_Executing->Object.id; 10b569: 8b 15 78 a6 12 00 mov 0x12a678,%edx 10b56f: 8b 52 08 mov 0x8(%edx),%edx 10b572: 89 50 38 mov %edx,0x38(%eax) if ( evp != NULL ) { 10b575: 85 db test %ebx,%ebx 10b577: 74 11 je 10b58a ptimer->inf.sigev_notify = evp->sigev_notify; 10b579: 8b 13 mov (%ebx),%edx 10b57b: 89 50 40 mov %edx,0x40(%eax) ptimer->inf.sigev_signo = evp->sigev_signo; 10b57e: 8b 53 04 mov 0x4(%ebx),%edx 10b581: 89 50 44 mov %edx,0x44(%eax) ptimer->inf.sigev_value = evp->sigev_value; 10b584: 8b 53 08 mov 0x8(%ebx),%edx 10b587: 89 50 48 mov %edx,0x48(%eax) } ptimer->overrun = 0; 10b58a: c7 40 68 00 00 00 00 movl $0x0,0x68(%eax) ptimer->timer_data.it_value.tv_sec = 0; 10b591: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax) ptimer->timer_data.it_value.tv_nsec = 0; 10b598: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax) ptimer->timer_data.it_interval.tv_sec = 0; 10b59f: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) ptimer->timer_data.it_interval.tv_nsec = 0; 10b5a6: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax) Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 10b5ad: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) the_watchdog->routine = routine; 10b5b4: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax) the_watchdog->id = id; 10b5bb: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax) the_watchdog->user_data = user_data; 10b5c2: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax) uint32_t name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10b5c9: 8b 50 08 mov 0x8(%eax),%edx Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 10b5cc: 0f b7 da movzwl %dx,%ebx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10b5cf: 8b 0d 3c a4 12 00 mov 0x12a43c,%ecx 10b5d5: 89 04 99 mov %eax,(%ecx,%ebx,4) _Objects_Get_index( the_object->id ), the_object ); /* ASSERT: information->is_string == false */ the_object->name.name_u32 = name; 10b5d8: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) _Watchdog_Initialize( &ptimer->Timer, NULL, 0, NULL ); _Objects_Open_u32(&_POSIX_Timer_Information, &ptimer->Object, 0); *timerid = ptimer->Object.id; 10b5df: 89 16 mov %edx,(%esi) _Thread_Enable_dispatch(); 10b5e1: e8 3a 2e 00 00 call 10e420 <_Thread_Enable_dispatch> return 0; 10b5e6: 31 c0 xor %eax,%eax } 10b5e8: 8d 65 f8 lea -0x8(%ebp),%esp 10b5eb: 5b pop %ebx 10b5ec: 5e pop %esi 10b5ed: c9 leave 10b5ee: c3 ret 10b5ef: 90 nop if ( !evp->sigev_signo ) rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(evp->sigev_signo) ) rtems_set_errno_and_return_minus_one( EINVAL ); 10b5f0: e8 2f 8a 00 00 call 114024 <__errno> 10b5f5: c7 00 16 00 00 00 movl $0x16,(%eax) 10b5fb: b8 ff ff ff ff mov $0xffffffff,%eax _Objects_Open_u32(&_POSIX_Timer_Information, &ptimer->Object, 0); *timerid = ptimer->Object.id; _Thread_Enable_dispatch(); return 0; } 10b600: 8d 65 f8 lea -0x8(%ebp),%esp 10b603: 5b pop %ebx 10b604: 5e pop %esi 10b605: c9 leave 10b606: c3 ret /* * Allocate a timer */ ptimer = _POSIX_Timer_Allocate(); if ( !ptimer ) { _Thread_Enable_dispatch(); 10b607: e8 14 2e 00 00 call 10e420 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EAGAIN ); 10b60c: e8 13 8a 00 00 call 114024 <__errno> 10b611: c7 00 0b 00 00 00 movl $0xb,(%eax) 10b617: b8 ff ff ff ff mov $0xffffffff,%eax 10b61c: eb ca jmp 10b5e8 =============================================================================== 0010ba44 : int timer_delete( timer_t timerid ) { 10ba44: 55 push %ebp 10ba45: 89 e5 mov %esp,%ebp 10ba47: 53 push %ebx 10ba48: 83 ec 18 sub $0x18,%esp * because rtems_timer_delete stops the timer before deleting it. */ POSIX_Timer_Control *ptimer; Objects_Locations location; ptimer = _POSIX_Timer_Get( timerid, &location ); 10ba4b: 8d 45 f4 lea -0xc(%ebp),%eax timer_t id, Objects_Locations *location ) { return (POSIX_Timer_Control *) _Objects_Get( &_POSIX_Timer_Information, (Objects_Id) id, location ); 10ba4e: 50 push %eax 10ba4f: ff 75 08 pushl 0x8(%ebp) 10ba52: 68 00 a3 12 00 push $0x12a300 10ba57: e8 9c 21 00 00 call 10dbf8 <_Objects_Get> 10ba5c: 89 c3 mov %eax,%ebx switch ( location ) { 10ba5e: 83 c4 10 add $0x10,%esp 10ba61: 8b 4d f4 mov -0xc(%ebp),%ecx 10ba64: 85 c9 test %ecx,%ecx 10ba66: 74 18 je 10ba80 #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10ba68: e8 b7 8c 00 00 call 114724 <__errno> 10ba6d: c7 00 16 00 00 00 movl $0x16,(%eax) 10ba73: b8 ff ff ff ff mov $0xffffffff,%eax } 10ba78: 8b 5d fc mov -0x4(%ebp),%ebx 10ba7b: c9 leave 10ba7c: c3 ret 10ba7d: 8d 76 00 lea 0x0(%esi),%esi ptimer = _POSIX_Timer_Get( timerid, &location ); switch ( location ) { case OBJECTS_LOCAL: _Objects_Close( &_POSIX_Timer_Information, &ptimer->Object ); 10ba80: 83 ec 08 sub $0x8,%esp 10ba83: 50 push %eax 10ba84: 68 00 a3 12 00 push $0x12a300 10ba89: e8 32 1d 00 00 call 10d7c0 <_Objects_Close> ptimer->state = POSIX_TIMER_STATE_FREE; 10ba8e: c6 43 3c 01 movb $0x1,0x3c(%ebx) (void) _Watchdog_Remove( &ptimer->Timer ); 10ba92: 8d 43 10 lea 0x10(%ebx),%eax 10ba95: 89 04 24 mov %eax,(%esp) 10ba98: e8 6b 3c 00 00 call 10f708 <_Watchdog_Remove> RTEMS_INLINE_ROUTINE void _POSIX_Timer_Free ( POSIX_Timer_Control *the_timer ) { _Objects_Free( &_POSIX_Timer_Information, &the_timer->Object ); 10ba9d: 58 pop %eax 10ba9e: 5a pop %edx 10ba9f: 53 push %ebx 10baa0: 68 00 a3 12 00 push $0x12a300 10baa5: e8 0e 20 00 00 call 10dab8 <_Objects_Free> _POSIX_Timer_Free( ptimer ); _Thread_Enable_dispatch(); 10baaa: e8 c1 2c 00 00 call 10e770 <_Thread_Enable_dispatch> return 0; 10baaf: 83 c4 10 add $0x10,%esp 10bab2: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 10bab4: 8b 5d fc mov -0x4(%ebp),%ebx 10bab7: c9 leave 10bab8: c3 ret =============================================================================== 0010c900 : * its execution, _POSIX_Timer_TSR will have to set this counter to 0. */ int timer_getoverrun( timer_t timerid ) { 10c900: 55 push %ebp 10c901: 89 e5 mov %esp,%ebp 10c903: 53 push %ebx 10c904: 83 ec 18 sub $0x18,%esp int overrun; POSIX_Timer_Control *ptimer; Objects_Locations location; ptimer = _POSIX_Timer_Get( timerid, &location ); 10c907: 8d 45 f4 lea -0xc(%ebp),%eax timer_t id, Objects_Locations *location ) { return (POSIX_Timer_Control *) _Objects_Get( &_POSIX_Timer_Information, (Objects_Id) id, location ); 10c90a: 50 push %eax 10c90b: ff 75 08 pushl 0x8(%ebp) 10c90e: 68 e0 b9 12 00 push $0x12b9e0 10c913: e8 24 21 00 00 call 10ea3c <_Objects_Get> switch ( location ) { 10c918: 83 c4 10 add $0x10,%esp 10c91b: 8b 55 f4 mov -0xc(%ebp),%edx 10c91e: 85 d2 test %edx,%edx 10c920: 74 1a je 10c93c #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10c922: e8 7d 88 00 00 call 1151a4 <__errno> 10c927: c7 00 16 00 00 00 movl $0x16,(%eax) 10c92d: bb ff ff ff ff mov $0xffffffff,%ebx } 10c932: 89 d8 mov %ebx,%eax 10c934: 8b 5d fc mov -0x4(%ebp),%ebx 10c937: c9 leave 10c938: c3 ret 10c939: 8d 76 00 lea 0x0(%esi),%esi ptimer = _POSIX_Timer_Get( timerid, &location ); switch ( location ) { case OBJECTS_LOCAL: overrun = ptimer->overrun; 10c93c: 8b 58 68 mov 0x68(%eax),%ebx ptimer->overrun = 0; 10c93f: c7 40 68 00 00 00 00 movl $0x0,0x68(%eax) _Thread_Enable_dispatch(); 10c946: e8 69 2c 00 00 call 10f5b4 <_Thread_Enable_dispatch> case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 10c94b: 89 d8 mov %ebx,%eax 10c94d: 8b 5d fc mov -0x4(%ebp),%ebx 10c950: c9 leave 10c951: c3 ret =============================================================================== 0010c954 : int timer_gettime( timer_t timerid, struct itimerspec *value ) { 10c954: 55 push %ebp 10c955: 89 e5 mov %esp,%ebp 10c957: 56 push %esi 10c958: 53 push %ebx 10c959: 83 ec 10 sub $0x10,%esp 10c95c: 8b 5d 0c mov 0xc(%ebp),%ebx POSIX_Timer_Control *ptimer; Objects_Locations location; struct timespec current_time; Watchdog_Interval left; if ( !value ) 10c95f: 85 db test %ebx,%ebx 10c961: 74 65 je 10c9c8 rtems_set_errno_and_return_minus_one( EINVAL ); /* Reads the current time */ _TOD_Get( ¤t_time ); 10c963: 83 ec 0c sub $0xc,%esp 10c966: 8d 45 ec lea -0x14(%ebp),%eax 10c969: 50 push %eax 10c96a: e8 fd 16 00 00 call 10e06c <_TOD_Get> 10c96f: 83 c4 0c add $0xc,%esp ptimer = _POSIX_Timer_Get( timerid, &location ); 10c972: 8d 45 f4 lea -0xc(%ebp),%eax 10c975: 50 push %eax 10c976: ff 75 08 pushl 0x8(%ebp) 10c979: 68 e0 b9 12 00 push $0x12b9e0 10c97e: e8 b9 20 00 00 call 10ea3c <_Objects_Get> 10c983: 89 c6 mov %eax,%esi switch ( location ) { 10c985: 83 c4 10 add $0x10,%esp 10c988: 8b 45 f4 mov -0xc(%ebp),%eax 10c98b: 85 c0 test %eax,%eax 10c98d: 75 39 jne 10c9c8 case OBJECTS_LOCAL: /* Calculates the time left before the timer finishes */ left = (ptimer->Timer.start_time + ptimer->Timer.initial) - /* expire */ 10c98f: a1 c4 b7 12 00 mov 0x12b7c4,%eax _Watchdog_Ticks_since_boot; /* now */ _Timespec_From_ticks( left, &value->it_value ); 10c994: 83 ec 08 sub $0x8,%esp 10c997: 8d 53 08 lea 0x8(%ebx),%edx 10c99a: 52 push %edx case OBJECTS_LOCAL: /* Calculates the time left before the timer finishes */ left = (ptimer->Timer.start_time + ptimer->Timer.initial) - /* expire */ 10c99b: 8b 56 1c mov 0x1c(%esi),%edx 10c99e: 03 56 24 add 0x24(%esi),%edx case OBJECTS_LOCAL: /* Calculates the time left before the timer finishes */ left = 10c9a1: 29 c2 sub %eax,%edx (ptimer->Timer.start_time + ptimer->Timer.initial) - /* expire */ _Watchdog_Ticks_since_boot; /* now */ _Timespec_From_ticks( left, &value->it_value ); 10c9a3: 52 push %edx 10c9a4: e8 9b 36 00 00 call 110044 <_Timespec_From_ticks> value->it_interval = ptimer->timer_data.it_interval; 10c9a9: 8b 46 54 mov 0x54(%esi),%eax 10c9ac: 8b 56 58 mov 0x58(%esi),%edx 10c9af: 89 03 mov %eax,(%ebx) 10c9b1: 89 53 04 mov %edx,0x4(%ebx) _Thread_Enable_dispatch(); 10c9b4: e8 fb 2b 00 00 call 10f5b4 <_Thread_Enable_dispatch> return 0; 10c9b9: 83 c4 10 add $0x10,%esp 10c9bc: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 10c9be: 8d 65 f8 lea -0x8(%ebp),%esp 10c9c1: 5b pop %ebx 10c9c2: 5e pop %esi 10c9c3: c9 leave 10c9c4: c3 ret 10c9c5: 8d 76 00 lea 0x0(%esi),%esi #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10c9c8: e8 d7 87 00 00 call 1151a4 <__errno> 10c9cd: c7 00 16 00 00 00 movl $0x16,(%eax) 10c9d3: b8 ff ff ff ff mov $0xffffffff,%eax 10c9d8: eb e4 jmp 10c9be =============================================================================== 0010b620 : timer_t timerid, int flags, const struct itimerspec *value, struct itimerspec *ovalue ) { 10b620: 55 push %ebp 10b621: 89 e5 mov %esp,%ebp 10b623: 57 push %edi 10b624: 56 push %esi 10b625: 53 push %ebx 10b626: 83 ec 3c sub $0x3c,%esp 10b629: 8b 5d 10 mov 0x10(%ebp),%ebx Objects_Locations location; bool activated; uint32_t initial_period; struct itimerspec normalize; if ( !value ) 10b62c: 85 db test %ebx,%ebx 10b62e: 0f 84 50 01 00 00 je 10b784 <== NEVER TAKEN /* * First, it verifies if the structure "value" is correct * if the number of nanoseconds is not correct return EINVAL */ if ( !_Timespec_Is_valid( &(value->it_value) ) ) { 10b634: 83 ec 0c sub $0xc,%esp 10b637: 8d 43 08 lea 0x8(%ebx),%eax 10b63a: 50 push %eax 10b63b: e8 94 38 00 00 call 10eed4 <_Timespec_Is_valid> 10b640: 83 c4 10 add $0x10,%esp 10b643: 84 c0 test %al,%al 10b645: 0f 84 39 01 00 00 je 10b784 rtems_set_errno_and_return_minus_one( EINVAL ); } if ( !_Timespec_Is_valid( &(value->it_interval) ) ) { 10b64b: 83 ec 0c sub $0xc,%esp 10b64e: 53 push %ebx 10b64f: e8 80 38 00 00 call 10eed4 <_Timespec_Is_valid> 10b654: 83 c4 10 add $0x10,%esp 10b657: 84 c0 test %al,%al 10b659: 0f 84 25 01 00 00 je 10b784 <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); } if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) { 10b65f: 83 7d 0c 04 cmpl $0x4,0xc(%ebp) 10b663: 0f 84 db 00 00 00 je 10b744 10b669: 8b 45 0c mov 0xc(%ebp),%eax 10b66c: 85 c0 test %eax,%eax 10b66e: 0f 85 10 01 00 00 jne 10b784 rtems_set_errno_and_return_minus_one( EINVAL ); } normalize = *value; 10b674: 8d 45 cc lea -0x34(%ebp),%eax 10b677: 89 45 c4 mov %eax,-0x3c(%ebp) 10b67a: b9 04 00 00 00 mov $0x4,%ecx 10b67f: 89 c7 mov %eax,%edi 10b681: 89 de mov %ebx,%esi 10b683: f3 a5 rep movsl %ds:(%esi),%es:(%edi) timer_t id, Objects_Locations *location ) { return (POSIX_Timer_Control *) _Objects_Get( &_POSIX_Timer_Information, (Objects_Id) id, location ); 10b685: 50 push %eax /* If the function reaches this point, then it will be necessary to do * something with the structure of times of the timer: to stop, start * or start it again */ ptimer = _POSIX_Timer_Get( timerid, &location ); 10b686: 8d 45 e4 lea -0x1c(%ebp),%eax 10b689: 50 push %eax 10b68a: ff 75 08 pushl 0x8(%ebp) 10b68d: 68 20 a4 12 00 push $0x12a420 10b692: e8 11 22 00 00 call 10d8a8 <_Objects_Get> 10b697: 89 c2 mov %eax,%edx switch ( location ) { 10b699: 83 c4 10 add $0x10,%esp 10b69c: 8b 7d e4 mov -0x1c(%ebp),%edi 10b69f: 85 ff test %edi,%edi 10b6a1: 0f 85 dd 00 00 00 jne 10b784 case OBJECTS_LOCAL: /* First, it verifies if the timer must be stopped */ if ( normalize.it_value.tv_sec == 0 && normalize.it_value.tv_nsec == 0 ) { 10b6a7: 8b 75 d4 mov -0x2c(%ebp),%esi 10b6aa: 85 f6 test %esi,%esi 10b6ac: 75 0b jne 10b6b9 10b6ae: 8b 4d d8 mov -0x28(%ebp),%ecx 10b6b1: 85 c9 test %ecx,%ecx 10b6b3: 0f 84 df 00 00 00 je 10b798 _Thread_Enable_dispatch(); return 0; } /* Convert from seconds and nanoseconds to ticks */ ptimer->ticks = _Timespec_To_ticks( &value->it_interval ); 10b6b9: 83 ec 0c sub $0xc,%esp 10b6bc: 53 push %ebx 10b6bd: 89 55 c0 mov %edx,-0x40(%ebp) 10b6c0: e8 77 38 00 00 call 10ef3c <_Timespec_To_ticks> 10b6c5: 8b 55 c0 mov -0x40(%ebp),%edx 10b6c8: 89 42 64 mov %eax,0x64(%edx) initial_period = _Timespec_To_ticks( &normalize.it_value ); 10b6cb: 8d 45 d4 lea -0x2c(%ebp),%eax 10b6ce: 89 04 24 mov %eax,(%esp) 10b6d1: e8 66 38 00 00 call 10ef3c <_Timespec_To_ticks> activated = _POSIX_Timer_Insert_helper( 10b6d6: 8b 55 c0 mov -0x40(%ebp),%edx 10b6d9: 89 14 24 mov %edx,(%esp) 10b6dc: 68 04 b8 10 00 push $0x10b804 10b6e1: ff 72 08 pushl 0x8(%edx) 10b6e4: 50 push %eax 10b6e5: 8d 42 10 lea 0x10(%edx),%eax 10b6e8: 50 push %eax 10b6e9: e8 6e 61 00 00 call 11185c <_POSIX_Timer_Insert_helper> initial_period, ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) { 10b6ee: 83 c4 20 add $0x20,%esp 10b6f1: 84 c0 test %al,%al 10b6f3: 8b 55 c0 mov -0x40(%ebp),%edx 10b6f6: 0f 84 e8 00 00 00 je 10b7e4 /* * The timer has been started and is running. So we return the * old ones in "ovalue" */ if ( ovalue ) 10b6fc: 8b 45 14 mov 0x14(%ebp),%eax 10b6ff: 85 c0 test %eax,%eax 10b701: 0f 84 ed 00 00 00 je 10b7f4 *ovalue = ptimer->timer_data; 10b707: 8d 42 54 lea 0x54(%edx),%eax 10b70a: b9 04 00 00 00 mov $0x4,%ecx 10b70f: 8b 7d 14 mov 0x14(%ebp),%edi 10b712: 89 c6 mov %eax,%esi 10b714: f3 a5 rep movsl %ds:(%esi),%es:(%edi) ptimer->timer_data = normalize; 10b716: b9 04 00 00 00 mov $0x4,%ecx 10b71b: 89 c7 mov %eax,%edi 10b71d: 8b 75 c4 mov -0x3c(%ebp),%esi 10b720: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* Indicate that the time is running */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; 10b722: c6 42 3c 03 movb $0x3,0x3c(%edx) _TOD_Get( &ptimer->time ); 10b726: 83 ec 0c sub $0xc,%esp 10b729: 83 c2 6c add $0x6c,%edx 10b72c: 52 push %edx 10b72d: e8 ca 17 00 00 call 10cefc <_TOD_Get> _Thread_Enable_dispatch(); 10b732: e8 e9 2c 00 00 call 10e420 <_Thread_Enable_dispatch> return 0; 10b737: 83 c4 10 add $0x10,%esp 10b73a: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 10b73c: 8d 65 f4 lea -0xc(%ebp),%esp 10b73f: 5b pop %ebx 10b740: 5e pop %esi 10b741: 5f pop %edi 10b742: c9 leave 10b743: c3 ret if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) { rtems_set_errno_and_return_minus_one( EINVAL ); } normalize = *value; 10b744: 8d 45 cc lea -0x34(%ebp),%eax 10b747: 89 45 c4 mov %eax,-0x3c(%ebp) 10b74a: 89 c7 mov %eax,%edi 10b74c: 89 de mov %ebx,%esi 10b74e: 8b 4d 0c mov 0xc(%ebp),%ecx 10b751: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* Convert absolute to relative time */ if (flags == TIMER_ABSTIME) { struct timespec now; _TOD_Get( &now ); 10b753: 83 ec 0c sub $0xc,%esp 10b756: 8d 75 dc lea -0x24(%ebp),%esi 10b759: 56 push %esi 10b75a: e8 9d 17 00 00 call 10cefc <_TOD_Get> /* Check for seconds in the past */ if ( _Timespec_Greater_than( &now, &normalize.it_value ) ) 10b75f: 59 pop %ecx 10b760: 5f pop %edi 10b761: 8d 7d d4 lea -0x2c(%ebp),%edi 10b764: 57 push %edi 10b765: 56 push %esi 10b766: e8 45 37 00 00 call 10eeb0 <_Timespec_Greater_than> 10b76b: 83 c4 10 add $0x10,%esp 10b76e: 84 c0 test %al,%al 10b770: 75 12 jne 10b784 rtems_set_errno_and_return_minus_one( EINVAL ); _Timespec_Subtract( &now, &normalize.it_value, &normalize.it_value ); 10b772: 52 push %edx 10b773: 57 push %edi 10b774: 57 push %edi 10b775: 56 push %esi 10b776: e8 81 37 00 00 call 10eefc <_Timespec_Subtract> 10b77b: 83 c4 10 add $0x10,%esp 10b77e: e9 02 ff ff ff jmp 10b685 10b783: 90 nop #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10b784: e8 9b 88 00 00 call 114024 <__errno> 10b789: c7 00 16 00 00 00 movl $0x16,(%eax) 10b78f: b8 ff ff ff ff mov $0xffffffff,%eax 10b794: eb a6 jmp 10b73c 10b796: 66 90 xchg %ax,%ax case OBJECTS_LOCAL: /* First, it verifies if the timer must be stopped */ if ( normalize.it_value.tv_sec == 0 && normalize.it_value.tv_nsec == 0 ) { /* Stop the timer */ (void) _Watchdog_Remove( &ptimer->Timer ); 10b798: 83 ec 0c sub $0xc,%esp 10b79b: 8d 40 10 lea 0x10(%eax),%eax 10b79e: 50 push %eax 10b79f: 89 55 c0 mov %edx,-0x40(%ebp) 10b7a2: e8 c9 3b 00 00 call 10f370 <_Watchdog_Remove> /* The old data of the timer are returned */ if ( ovalue ) 10b7a7: 83 c4 10 add $0x10,%esp 10b7aa: 8b 55 14 mov 0x14(%ebp),%edx 10b7ad: 85 d2 test %edx,%edx 10b7af: 8b 55 c0 mov -0x40(%ebp),%edx 10b7b2: 74 48 je 10b7fc *ovalue = ptimer->timer_data; 10b7b4: 8d 42 54 lea 0x54(%edx),%eax 10b7b7: b9 04 00 00 00 mov $0x4,%ecx 10b7bc: 8b 7d 14 mov 0x14(%ebp),%edi 10b7bf: 89 c6 mov %eax,%esi 10b7c1: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* The new data are set */ ptimer->timer_data = normalize; 10b7c3: b9 04 00 00 00 mov $0x4,%ecx 10b7c8: 89 c7 mov %eax,%edi 10b7ca: 8b 75 c4 mov -0x3c(%ebp),%esi 10b7cd: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* Indicates that the timer is created and stopped */ ptimer->state = POSIX_TIMER_STATE_CREATE_STOP; 10b7cf: c6 42 3c 04 movb $0x4,0x3c(%edx) /* Returns with success */ _Thread_Enable_dispatch(); 10b7d3: e8 48 2c 00 00 call 10e420 <_Thread_Enable_dispatch> return 0; 10b7d8: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 10b7da: 8d 65 f4 lea -0xc(%ebp),%esp 10b7dd: 5b pop %ebx 10b7de: 5e pop %esi 10b7df: 5f pop %edi 10b7e0: c9 leave 10b7e1: c3 ret 10b7e2: 66 90 xchg %ax,%ax ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) { _Thread_Enable_dispatch(); 10b7e4: e8 37 2c 00 00 call 10e420 <_Thread_Enable_dispatch> return 0; 10b7e9: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 10b7eb: 8d 65 f4 lea -0xc(%ebp),%esp 10b7ee: 5b pop %ebx 10b7ef: 5e pop %esi 10b7f0: 5f pop %edi 10b7f1: c9 leave 10b7f2: c3 ret 10b7f3: 90 nop 10b7f4: 8d 42 54 lea 0x54(%edx),%eax 10b7f7: e9 1a ff ff ff jmp 10b716 10b7fc: 8d 42 54 lea 0x54(%edx),%eax 10b7ff: eb c2 jmp 10b7c3 =============================================================================== 0010b410 : useconds_t ualarm( useconds_t useconds, useconds_t interval ) { 10b410: 55 push %ebp 10b411: 89 e5 mov %esp,%ebp 10b413: 56 push %esi 10b414: 53 push %ebx 10b415: 83 ec 10 sub $0x10,%esp 10b418: 8b 5d 08 mov 0x8(%ebp),%ebx /* * Initialize the timer used to implement alarm(). */ if ( !the_timer->routine ) { 10b41b: 8b 0d 5c a6 12 00 mov 0x12a65c,%ecx 10b421: 85 c9 test %ecx,%ecx 10b423: 0f 84 8f 00 00 00 je 10b4b8 _Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL ); } else { Watchdog_States state; state = _Watchdog_Remove( the_timer ); 10b429: 83 ec 0c sub $0xc,%esp 10b42c: 68 40 a6 12 00 push $0x12a640 10b431: e8 9a 3a 00 00 call 10eed0 <_Watchdog_Remove> if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) { 10b436: 83 e8 02 sub $0x2,%eax 10b439: 83 c4 10 add $0x10,%esp 10b43c: 83 f8 01 cmp $0x1,%eax 10b43f: 0f 86 a3 00 00 00 jbe 10b4e8 <== ALWAYS TAKEN useconds_t ualarm( useconds_t useconds, useconds_t interval ) { useconds_t remaining = 0; 10b445: 31 f6 xor %esi,%esi /* * If useconds is non-zero, then the caller wants to schedule * the alarm repeatedly at that interval. If the interval is * less than a single clock tick, then fudge it to a clock tick. */ if ( useconds ) { 10b447: 85 db test %ebx,%ebx 10b449: 74 62 je 10b4ad Watchdog_Interval ticks; tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND; 10b44b: ba 83 de 1b 43 mov $0x431bde83,%edx 10b450: 89 d8 mov %ebx,%eax 10b452: f7 e2 mul %edx 10b454: c1 ea 12 shr $0x12,%edx 10b457: 89 55 f0 mov %edx,-0x10(%ebp) tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000; 10b45a: 8d 04 92 lea (%edx,%edx,4),%eax 10b45d: 8d 04 80 lea (%eax,%eax,4),%eax 10b460: 8d 04 80 lea (%eax,%eax,4),%eax 10b463: 8d 04 80 lea (%eax,%eax,4),%eax 10b466: 8d 04 80 lea (%eax,%eax,4),%eax 10b469: 8d 04 80 lea (%eax,%eax,4),%eax 10b46c: c1 e0 06 shl $0x6,%eax 10b46f: 29 c3 sub %eax,%ebx 10b471: 8d 04 9b lea (%ebx,%ebx,4),%eax 10b474: 8d 04 80 lea (%eax,%eax,4),%eax 10b477: 8d 04 80 lea (%eax,%eax,4),%eax 10b47a: c1 e0 03 shl $0x3,%eax 10b47d: 89 45 f4 mov %eax,-0xc(%ebp) ticks = _Timespec_To_ticks( &tp ); 10b480: 83 ec 0c sub $0xc,%esp 10b483: 8d 5d f0 lea -0x10(%ebp),%ebx 10b486: 53 push %ebx 10b487: e8 98 35 00 00 call 10ea24 <_Timespec_To_ticks> if ( ticks == 0 ) ticks = 1; _Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) ); 10b48c: 89 1c 24 mov %ebx,(%esp) 10b48f: e8 90 35 00 00 call 10ea24 <_Timespec_To_ticks> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10b494: a3 4c a6 12 00 mov %eax,0x12a64c _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10b499: 58 pop %eax 10b49a: 5a pop %edx 10b49b: 68 40 a6 12 00 push $0x12a640 10b4a0: 68 60 9d 12 00 push $0x129d60 10b4a5: e8 e6 38 00 00 call 10ed90 <_Watchdog_Insert> 10b4aa: 83 c4 10 add $0x10,%esp } return remaining; } 10b4ad: 89 f0 mov %esi,%eax 10b4af: 8d 65 f8 lea -0x8(%ebp),%esp 10b4b2: 5b pop %ebx 10b4b3: 5e pop %esi 10b4b4: c9 leave 10b4b5: c3 ret 10b4b6: 66 90 xchg %ax,%ax Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 10b4b8: c7 05 48 a6 12 00 00 movl $0x0,0x12a648 10b4bf: 00 00 00 the_watchdog->routine = routine; 10b4c2: c7 05 5c a6 12 00 d4 movl $0x10b3d4,0x12a65c 10b4c9: b3 10 00 the_watchdog->id = id; 10b4cc: c7 05 60 a6 12 00 00 movl $0x0,0x12a660 10b4d3: 00 00 00 the_watchdog->user_data = user_data; 10b4d6: c7 05 64 a6 12 00 00 movl $0x0,0x12a664 10b4dd: 00 00 00 useconds_t ualarm( useconds_t useconds, useconds_t interval ) { useconds_t remaining = 0; 10b4e0: 31 f6 xor %esi,%esi 10b4e2: e9 60 ff ff ff jmp 10b447 10b4e7: 90 nop * boot. Since alarm() is dealing in seconds, we must account for * this. */ ticks = the_timer->initial; ticks -= (the_timer->stop_time - the_timer->start_time); 10b4e8: a1 54 a6 12 00 mov 0x12a654,%eax 10b4ed: 03 05 4c a6 12 00 add 0x12a64c,%eax /* remaining is now in ticks */ _Timespec_From_ticks( ticks, &tp ); 10b4f3: 83 ec 08 sub $0x8,%esp 10b4f6: 8d 55 f0 lea -0x10(%ebp),%edx 10b4f9: 52 push %edx * boot. Since alarm() is dealing in seconds, we must account for * this. */ ticks = the_timer->initial; ticks -= (the_timer->stop_time - the_timer->start_time); 10b4fa: 2b 05 58 a6 12 00 sub 0x12a658,%eax /* remaining is now in ticks */ _Timespec_From_ticks( ticks, &tp ); 10b500: 50 push %eax 10b501: e8 96 34 00 00 call 10e99c <_Timespec_From_ticks> remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND; 10b506: 8b 45 f0 mov -0x10(%ebp),%eax 10b509: 8d 04 80 lea (%eax,%eax,4),%eax 10b50c: 8d 04 80 lea (%eax,%eax,4),%eax 10b50f: 8d 04 80 lea (%eax,%eax,4),%eax 10b512: 8d 04 80 lea (%eax,%eax,4),%eax 10b515: 8d 04 80 lea (%eax,%eax,4),%eax 10b518: 8d 0c 80 lea (%eax,%eax,4),%ecx 10b51b: c1 e1 06 shl $0x6,%ecx remaining += tp.tv_nsec / 1000; 10b51e: 8b 75 f4 mov -0xc(%ebp),%esi 10b521: b8 d3 4d 62 10 mov $0x10624dd3,%eax 10b526: f7 ee imul %esi 10b528: 89 d0 mov %edx,%eax 10b52a: c1 f8 06 sar $0x6,%eax 10b52d: c1 fe 1f sar $0x1f,%esi 10b530: 29 f0 sub %esi,%eax 10b532: 8d 34 08 lea (%eax,%ecx,1),%esi 10b535: 83 c4 10 add $0x10,%esp 10b538: e9 0a ff ff ff jmp 10b447 =============================================================================== 0010bb84 : #include int unlink( const char *path ) { 10bb84: 55 push %ebp 10bb85: 89 e5 mov %esp,%ebp 10bb87: 57 push %edi 10bb88: 56 push %esi 10bb89: 53 push %ebx 10bb8a: 83 ec 58 sub $0x58,%esp 10bb8d: 8b 5d 08 mov 0x8(%ebp),%ebx /* * Get the node to be unlinked. Find the parent path first. */ parentpathlen = rtems_filesystem_dirname ( path ); 10bb90: 53 push %ebx 10bb91: e8 3e d3 ff ff call 108ed4 if ( parentpathlen == 0 ) 10bb96: 83 c4 10 add $0x10,%esp 10bb99: 85 c0 test %eax,%eax 10bb9b: 0f 85 d3 00 00 00 jne 10bc74 rtems_filesystem_get_start_loc( path, &i, &parentloc ); 10bba1: 50 push %eax 10bba2: 8d 45 d0 lea -0x30(%ebp),%eax 10bba5: 89 45 b4 mov %eax,-0x4c(%ebp) 10bba8: 50 push %eax 10bba9: 8d 45 e4 lea -0x1c(%ebp),%eax 10bbac: 50 push %eax 10bbad: 53 push %ebx 10bbae: e8 b9 e2 ff ff call 109e6c 10bbb3: 83 c4 10 add $0x10,%esp 10bbb6: 31 d2 xor %edx,%edx const char *name; rtems_filesystem_location_info_t parentloc; rtems_filesystem_location_info_t loc; int i; int result; bool free_parentloc = false; 10bbb8: c6 45 b3 00 movb $0x0,-0x4d(%ebp) /* * Start from the parent to find the node that should be under it. */ loc = parentloc; 10bbbc: 8d 7d bc lea -0x44(%ebp),%edi 10bbbf: b9 05 00 00 00 mov $0x5,%ecx 10bbc4: 8b 75 b4 mov -0x4c(%ebp),%esi 10bbc7: f3 a5 rep movsl %ds:(%esi),%es:(%edi) name = path + parentpathlen; 10bbc9: 01 d3 add %edx,%ebx name += rtems_filesystem_prefix_separators( name, strlen( name ) ); 10bbcb: be ff ff ff ff mov $0xffffffff,%esi 10bbd0: 89 f1 mov %esi,%ecx 10bbd2: 89 df mov %ebx,%edi 10bbd4: 31 c0 xor %eax,%eax 10bbd6: f2 ae repnz scas %es:(%edi),%al 10bbd8: f7 d1 not %ecx 10bbda: 49 dec %ecx 10bbdb: 83 ec 08 sub $0x8,%esp 10bbde: 51 push %ecx 10bbdf: 53 push %ebx 10bbe0: e8 33 d3 ff ff call 108f18 10bbe5: 01 c3 add %eax,%ebx result = rtems_filesystem_evaluate_relative_path( name , strlen( name ), 10bbe7: 89 f1 mov %esi,%ecx 10bbe9: 89 df mov %ebx,%edi 10bbeb: 31 c0 xor %eax,%eax 10bbed: f2 ae repnz scas %es:(%edi),%al 10bbef: f7 d1 not %ecx 10bbf1: 49 dec %ecx 10bbf2: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10bbf9: 8d 75 bc lea -0x44(%ebp),%esi 10bbfc: 56 push %esi 10bbfd: 6a 00 push $0x0 10bbff: 51 push %ecx 10bc00: 53 push %ebx 10bc01: e8 22 d2 ff ff call 108e28 0, &loc, false ); if ( result != 0 ) { 10bc06: 83 c4 20 add $0x20,%esp 10bc09: 85 c0 test %eax,%eax 10bc0b: 75 53 jne 10bc60 if ( free_parentloc ) rtems_filesystem_freenode( &parentloc ); return -1; } if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) { 10bc0d: 83 ec 0c sub $0xc,%esp 10bc10: 56 push %esi 10bc11: 8b 45 c8 mov -0x38(%ebp),%eax 10bc14: ff 50 10 call *0x10(%eax) 10bc17: 83 c4 10 add $0x10,%esp 10bc1a: 48 dec %eax 10bc1b: 0f 84 83 00 00 00 je 10bca4 if ( free_parentloc ) rtems_filesystem_freenode( &parentloc ); rtems_set_errno_and_return_minus_one( EISDIR ); } result = (*loc.ops->unlink_h)( &parentloc, &loc ); 10bc21: 83 ec 08 sub $0x8,%esp 10bc24: 56 push %esi 10bc25: ff 75 b4 pushl -0x4c(%ebp) 10bc28: 8b 45 c8 mov -0x38(%ebp),%eax 10bc2b: ff 50 0c call *0xc(%eax) rtems_filesystem_freenode( &loc ); 10bc2e: 89 34 24 mov %esi,(%esp) 10bc31: 89 45 ac mov %eax,-0x54(%ebp) 10bc34: e8 2f d3 ff ff call 108f68 if ( free_parentloc ) 10bc39: 83 c4 10 add $0x10,%esp 10bc3c: 80 7d b3 00 cmpb $0x0,-0x4d(%ebp) 10bc40: 8b 45 ac mov -0x54(%ebp),%eax 10bc43: 74 11 je 10bc56 rtems_filesystem_freenode( &parentloc ); 10bc45: 83 ec 0c sub $0xc,%esp 10bc48: ff 75 b4 pushl -0x4c(%ebp) 10bc4b: e8 18 d3 ff ff call 108f68 10bc50: 83 c4 10 add $0x10,%esp 10bc53: 8b 45 ac mov -0x54(%ebp),%eax return result; } 10bc56: 8d 65 f4 lea -0xc(%ebp),%esp 10bc59: 5b pop %ebx 10bc5a: 5e pop %esi 10bc5b: 5f pop %edi 10bc5c: c9 leave 10bc5d: c3 ret 10bc5e: 66 90 xchg %ax,%ax name += rtems_filesystem_prefix_separators( name, strlen( name ) ); result = rtems_filesystem_evaluate_relative_path( name , strlen( name ), 0, &loc, false ); if ( result != 0 ) { if ( free_parentloc ) 10bc60: 80 7d b3 00 cmpb $0x0,-0x4d(%ebp) 10bc64: 75 70 jne 10bcd6 <== ALWAYS TAKEN rtems_filesystem_freenode( &parentloc ); return -1; 10bc66: b8 ff ff ff ff mov $0xffffffff,%eax rtems_filesystem_freenode( &loc ); if ( free_parentloc ) rtems_filesystem_freenode( &parentloc ); return result; } 10bc6b: 8d 65 f4 lea -0xc(%ebp),%esp 10bc6e: 5b pop %ebx <== NOT EXECUTED 10bc6f: 5e pop %esi <== NOT EXECUTED 10bc70: 5f pop %edi <== NOT EXECUTED 10bc71: c9 leave <== NOT EXECUTED 10bc72: c3 ret <== NOT EXECUTED 10bc73: 90 nop <== NOT EXECUTED parentpathlen = rtems_filesystem_dirname ( path ); if ( parentpathlen == 0 ) rtems_filesystem_get_start_loc( path, &i, &parentloc ); else { result = rtems_filesystem_evaluate_path( path, parentpathlen, 10bc74: 89 c2 mov %eax,%edx 10bc76: 83 ec 0c sub $0xc,%esp 10bc79: 6a 00 push $0x0 10bc7b: 8d 45 d0 lea -0x30(%ebp),%eax 10bc7e: 89 45 b4 mov %eax,-0x4c(%ebp) 10bc81: 50 push %eax 10bc82: 6a 02 push $0x2 10bc84: 52 push %edx 10bc85: 53 push %ebx 10bc86: 89 55 ac mov %edx,-0x54(%ebp) 10bc89: e8 02 d2 ff ff call 108e90 RTEMS_LIBIO_PERMS_WRITE, &parentloc, false ); if ( result != 0 ) 10bc8e: 83 c4 20 add $0x20,%esp 10bc91: 85 c0 test %eax,%eax 10bc93: 8b 55 ac mov -0x54(%ebp),%edx 10bc96: 75 ce jne 10bc66 <== NEVER TAKEN return -1; free_parentloc = true; 10bc98: c6 45 b3 01 movb $0x1,-0x4d(%ebp) 10bc9c: e9 1b ff ff ff jmp 10bbbc 10bca1: 8d 76 00 lea 0x0(%esi),%esi rtems_filesystem_freenode( &parentloc ); return -1; } if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) { rtems_filesystem_freenode( &loc ); 10bca4: 83 ec 0c sub $0xc,%esp 10bca7: 56 push %esi 10bca8: e8 bb d2 ff ff call 108f68 if ( free_parentloc ) 10bcad: 83 c4 10 add $0x10,%esp 10bcb0: 80 7d b3 00 cmpb $0x0,-0x4d(%ebp) 10bcb4: 74 0e je 10bcc4 rtems_filesystem_freenode( &parentloc ); 10bcb6: 83 ec 0c sub $0xc,%esp 10bcb9: ff 75 b4 pushl -0x4c(%ebp) 10bcbc: e8 a7 d2 ff ff call 108f68 10bcc1: 83 c4 10 add $0x10,%esp rtems_set_errno_and_return_minus_one( EISDIR ); 10bcc4: e8 6b b3 00 00 call 117034 <__errno> 10bcc9: c7 00 15 00 00 00 movl $0x15,(%eax) 10bccf: b8 ff ff ff ff mov $0xffffffff,%eax 10bcd4: eb 80 jmp 10bc56 result = rtems_filesystem_evaluate_relative_path( name , strlen( name ), 0, &loc, false ); if ( result != 0 ) { if ( free_parentloc ) rtems_filesystem_freenode( &parentloc ); 10bcd6: 83 ec 0c sub $0xc,%esp 10bcd9: ff 75 b4 pushl -0x4c(%ebp) 10bcdc: e8 87 d2 ff ff call 108f68 10bce1: 83 c4 10 add $0x10,%esp return -1; 10bce4: b8 ff ff ff ff mov $0xffffffff,%eax 10bce9: e9 68 ff ff ff jmp 10bc56 =============================================================================== 0010bd64 : */ int unmount( const char *path ) { 10bd64: 55 push %ebp 10bd65: 89 e5 mov %esp,%ebp 10bd67: 57 push %edi 10bd68: 56 push %esi 10bd69: 53 push %ebx 10bd6a: 83 ec 38 sub $0x38,%esp 10bd6d: 8b 55 08 mov 0x8(%ebp),%edx * The root node of the mounted filesytem. * The node for the directory that the fileystem is mounted on. * The mount entry that is being refered to. */ if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) ) 10bd70: 31 c0 xor %eax,%eax 10bd72: b9 ff ff ff ff mov $0xffffffff,%ecx 10bd77: 89 d7 mov %edx,%edi 10bd79: f2 ae repnz scas %es:(%edi),%al 10bd7b: f7 d1 not %ecx 10bd7d: 49 dec %ecx 10bd7e: 6a 01 push $0x1 10bd80: 8d 75 d4 lea -0x2c(%ebp),%esi 10bd83: 56 push %esi 10bd84: 6a 00 push $0x0 10bd86: 51 push %ecx 10bd87: 52 push %edx 10bd88: e8 77 cf ff ff call 108d04 10bd8d: 83 c4 20 add $0x20,%esp 10bd90: 85 c0 test %eax,%eax 10bd92: 75 68 jne 10bdfc return -1; mt_entry = loc.mt_entry; 10bd94: 8b 5d e4 mov -0x1c(%ebp),%ebx /* * Verify this is the root node for the file system to be unmounted. */ if ( fs_root_loc->node_access != loc.node_access ){ 10bd97: 8b 45 d4 mov -0x2c(%ebp),%eax 10bd9a: 39 43 1c cmp %eax,0x1c(%ebx) 10bd9d: 0f 85 c5 00 00 00 jne 10be68 /* * Free the loc node and just use the nodes from the mt_entry . */ rtems_filesystem_freenode( &loc ); 10bda3: 83 ec 0c sub $0xc,%esp 10bda6: 56 push %esi 10bda7: e8 30 d0 ff ff call 108ddc * that made the current node thread based instead * of system based? I thought it was but it doesn't * look like it in this version. */ if ( rtems_filesystem_current.mt_entry == mt_entry ) 10bdac: 83 c4 10 add $0x10,%esp 10bdaf: a1 50 85 12 00 mov 0x128550,%eax 10bdb4: 39 58 14 cmp %ebx,0x14(%eax) 10bdb7: 0f 84 cf 00 00 00 je 10be8c /* * Verify there are no file systems below the path specified */ if ( rtems_filesystem_mount_iterate( is_fs_below_mount_point, 10bdbd: 83 ec 08 sub $0x8,%esp 10bdc0: ff 73 2c pushl 0x2c(%ebx) 10bdc3: 68 50 bd 10 00 push $0x10bd50 10bdc8: e8 ab d7 ff ff call 109578 10bdcd: 83 c4 10 add $0x10,%esp 10bdd0: 84 c0 test %al,%al 10bdd2: 0f 85 b4 00 00 00 jne 10be8c * Run the file descriptor table to determine if there are any file * descriptors that are currently active and reference nodes in the * file system that we are trying to unmount */ if ( rtems_libio_is_open_files_in_fs( mt_entry ) == 1 ) 10bdd8: 83 ec 0c sub $0xc,%esp 10bddb: 53 push %ebx 10bddc: e8 2b d3 ff ff call 10910c 10bde1: 83 c4 10 add $0x10,%esp 10bde4: 48 dec %eax 10bde5: 0f 84 a1 00 00 00 je 10be8c * Allow the file system being unmounted on to do its cleanup. * If it fails it will set the errno to the approprate value * and the fileystem will not be modified. */ if (( fs_mount_loc->ops->unmount_h )( mt_entry ) != 0 ) 10bdeb: 83 ec 0c sub $0xc,%esp 10bdee: 8b 43 14 mov 0x14(%ebx),%eax 10bdf1: 53 push %ebx 10bdf2: ff 50 28 call *0x28(%eax) 10bdf5: 83 c4 10 add $0x10,%esp 10bdf8: 85 c0 test %eax,%eax 10bdfa: 74 10 je 10be0c <== ALWAYS TAKEN */ if ((fs_root_loc->ops->fsunmount_me_h )( mt_entry ) != 0){ if (( fs_mount_loc->ops->mount_h )( mt_entry ) != 0 ) rtems_fatal_error_occurred( 0 ); return -1; 10bdfc: b8 ff ff ff ff mov $0xffffffff,%eax rtems_filesystem_freenode( fs_mount_loc ); free( mt_entry ); return 0; } 10be01: 8d 65 f4 lea -0xc(%ebp),%esp 10be04: 5b pop %ebx 10be05: 5e pop %esi 10be06: 5f pop %edi 10be07: c9 leave 10be08: c3 ret 10be09: 8d 76 00 lea 0x0(%esi),%esi * NOTE: Fatal error is called in a case which should never happen * This was response was questionable but the best we could * come up with. */ if ((fs_root_loc->ops->fsunmount_me_h )( mt_entry ) != 0){ 10be0c: 83 ec 0c sub $0xc,%esp 10be0f: 8b 43 28 mov 0x28(%ebx),%eax 10be12: 53 push %ebx 10be13: ff 50 2c call *0x2c(%eax) 10be16: 83 c4 10 add $0x10,%esp 10be19: 85 c0 test %eax,%eax 10be1b: 0f 85 83 00 00 00 jne 10bea4 <== NEVER TAKEN rtems_status_code rtems_libio_set_private_env(void); rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ; static inline void rtems_libio_lock( void ) { rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); 10be21: 52 push %edx 10be22: 6a 00 push $0x0 10be24: 6a 00 push $0x0 10be26: ff 35 88 a8 12 00 pushl 0x12a888 10be2c: e8 77 0b 00 00 call 10c9a8 */ RTEMS_INLINE_ROUTINE void rtems_chain_extract( rtems_chain_node *the_node ) { _Chain_Extract( the_node ); 10be31: 89 1c 24 mov %ebx,(%esp) 10be34: e8 73 14 00 00 call 10d2ac <_Chain_Extract> } static inline void rtems_libio_unlock( void ) { rtems_semaphore_release( rtems_libio_semaphore ); 10be39: 58 pop %eax 10be3a: ff 35 88 a8 12 00 pushl 0x12a888 10be40: e8 5f 0c 00 00 call 10caa4 if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) ) return -1; mt_entry = loc.mt_entry; fs_mount_loc = &mt_entry->mt_point_node; 10be45: 8d 43 08 lea 0x8(%ebx),%eax /* * Free the memory node that was allocated in mount * Free the memory associated with the extracted mount table entry. */ rtems_filesystem_freenode( fs_mount_loc ); 10be48: 89 04 24 mov %eax,(%esp) 10be4b: e8 8c cf ff ff call 108ddc free( mt_entry ); 10be50: 89 1c 24 mov %ebx,(%esp) 10be53: e8 98 cf ff ff call 108df0 return 0; 10be58: 83 c4 10 add $0x10,%esp 10be5b: 31 c0 xor %eax,%eax } 10be5d: 8d 65 f4 lea -0xc(%ebp),%esp 10be60: 5b pop %ebx 10be61: 5e pop %esi 10be62: 5f pop %edi 10be63: c9 leave 10be64: c3 ret 10be65: 8d 76 00 lea 0x0(%esi),%esi /* * Verify this is the root node for the file system to be unmounted. */ if ( fs_root_loc->node_access != loc.node_access ){ rtems_filesystem_freenode( &loc ); 10be68: 83 ec 0c sub $0xc,%esp 10be6b: 56 push %esi 10be6c: e8 6b cf ff ff call 108ddc rtems_set_errno_and_return_minus_one( EACCES ); 10be71: e8 4a 84 00 00 call 1142c0 <__errno> 10be76: c7 00 0d 00 00 00 movl $0xd,(%eax) 10be7c: 83 c4 10 add $0x10,%esp 10be7f: b8 ff ff ff ff mov $0xffffffff,%eax rtems_filesystem_freenode( fs_mount_loc ); free( mt_entry ); return 0; } 10be84: 8d 65 f4 lea -0xc(%ebp),%esp 10be87: 5b pop %ebx 10be88: 5e pop %esi 10be89: 5f pop %edi 10be8a: c9 leave 10be8b: c3 ret * descriptors that are currently active and reference nodes in the * file system that we are trying to unmount */ if ( rtems_libio_is_open_files_in_fs( mt_entry ) == 1 ) rtems_set_errno_and_return_minus_one( EBUSY ); 10be8c: e8 2f 84 00 00 call 1142c0 <__errno> 10be91: c7 00 10 00 00 00 movl $0x10,(%eax) 10be97: b8 ff ff ff ff mov $0xffffffff,%eax rtems_filesystem_freenode( fs_mount_loc ); free( mt_entry ); return 0; } 10be9c: 8d 65 f4 lea -0xc(%ebp),%esp 10be9f: 5b pop %ebx 10bea0: 5e pop %esi 10bea1: 5f pop %edi 10bea2: c9 leave 10bea3: c3 ret * This was response was questionable but the best we could * come up with. */ if ((fs_root_loc->ops->fsunmount_me_h )( mt_entry ) != 0){ if (( fs_mount_loc->ops->mount_h )( mt_entry ) != 0 ) 10bea4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bea7: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 10beaa: 53 push %ebx <== NOT EXECUTED 10beab: ff 50 20 call *0x20(%eax) <== NOT EXECUTED 10beae: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10beb1: 85 c0 test %eax,%eax <== NOT EXECUTED 10beb3: 0f 84 43 ff ff ff je 10bdfc <== NOT EXECUTED rtems_fatal_error_occurred( 0 ); 10beb9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bebc: 6a 00 push $0x0 <== NOT EXECUTED 10bebe: e8 e1 10 00 00 call 10cfa4 <== NOT EXECUTED =============================================================================== 0010bf0c : int utime( const char *path, const struct utimbuf *times ) { 10bf0c: 55 push %ebp 10bf0d: 89 e5 mov %esp,%ebp 10bf0f: 57 push %edi 10bf10: 56 push %esi 10bf11: 53 push %ebx 10bf12: 83 ec 48 sub $0x48,%esp 10bf15: 8b 55 08 mov 0x8(%ebp),%edx 10bf18: 8b 5d 0c mov 0xc(%ebp),%ebx rtems_filesystem_location_info_t temp_loc; int result; struct utimbuf now; if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x00, &temp_loc, true ) ) 10bf1b: 31 c0 xor %eax,%eax 10bf1d: b9 ff ff ff ff mov $0xffffffff,%ecx 10bf22: 89 d7 mov %edx,%edi 10bf24: f2 ae repnz scas %es:(%edi),%al 10bf26: f7 d1 not %ecx 10bf28: 49 dec %ecx 10bf29: 6a 01 push $0x1 10bf2b: 8d 75 d4 lea -0x2c(%ebp),%esi 10bf2e: 56 push %esi 10bf2f: 6a 00 push $0x0 10bf31: 51 push %ecx 10bf32: 52 push %edx 10bf33: e8 d0 ca ff ff call 108a08 10bf38: 83 c4 20 add $0x20,%esp 10bf3b: 85 c0 test %eax,%eax 10bf3d: 75 2d jne 10bf6c return -1; if ( times == NULL ) { 10bf3f: 85 db test %ebx,%ebx 10bf41: 74 39 je 10bf7c 10bf43: 8b 53 04 mov 0x4(%ebx),%edx 10bf46: 8b 03 mov (%ebx),%eax now.actime = now.modtime = time( NULL ); times = &now; } result = (*temp_loc.ops->utime_h)( &temp_loc, times->actime, times->modtime ); 10bf48: 51 push %ecx 10bf49: 52 push %edx 10bf4a: 50 push %eax 10bf4b: 56 push %esi 10bf4c: 8b 45 e0 mov -0x20(%ebp),%eax 10bf4f: ff 50 30 call *0x30(%eax) rtems_filesystem_freenode( &temp_loc ); 10bf52: 89 34 24 mov %esi,(%esp) 10bf55: 89 45 c4 mov %eax,-0x3c(%ebp) 10bf58: e8 9b ce ff ff call 108df8 return result; 10bf5d: 83 c4 10 add $0x10,%esp 10bf60: 8b 45 c4 mov -0x3c(%ebp),%eax } 10bf63: 8d 65 f4 lea -0xc(%ebp),%esp 10bf66: 5b pop %ebx 10bf67: 5e pop %esi 10bf68: 5f pop %edi 10bf69: c9 leave 10bf6a: c3 ret 10bf6b: 90 nop rtems_filesystem_location_info_t temp_loc; int result; struct utimbuf now; if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x00, &temp_loc, true ) ) return -1; 10bf6c: b8 ff ff ff ff mov $0xffffffff,%eax result = (*temp_loc.ops->utime_h)( &temp_loc, times->actime, times->modtime ); rtems_filesystem_freenode( &temp_loc ); return result; } 10bf71: 8d 65 f4 lea -0xc(%ebp),%esp 10bf74: 5b pop %ebx 10bf75: 5e pop %esi 10bf76: 5f pop %edi 10bf77: c9 leave 10bf78: c3 ret 10bf79: 8d 76 00 lea 0x0(%esi),%esi if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x00, &temp_loc, true ) ) return -1; if ( times == NULL ) { now.actime = now.modtime = time( NULL ); 10bf7c: 83 ec 0c sub $0xc,%esp 10bf7f: 6a 00 push $0x0 10bf81: e8 c2 cc 00 00 call 118c48