=============================================================================== 0010f0b8 : #define MAXSYMLINK 5 int IMFS_Set_handlers( rtems_filesystem_location_info_t *loc ) { 10f0b8: 55 push %ebp 10f0b9: 89 e5 mov %esp,%ebp 10f0bb: 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; 10f0be: 8b 50 10 mov 0x10(%eax),%edx 10f0c1: 8b 4a 34 mov 0x34(%edx),%ecx switch( node->type ) { 10f0c4: 8b 10 mov (%eax),%edx 10f0c6: 83 7a 4c 07 cmpl $0x7,0x4c(%edx) 10f0ca: 77 12 ja 10f0de <== NEVER TAKEN 10f0cc: 8b 52 4c mov 0x4c(%edx),%edx 10f0cf: ff 24 95 d0 0f 12 00 jmp *0x120fd0(,%edx,4) 10f0d6: 66 90 xchg %ax,%ax case IMFS_DIRECTORY: loc->handlers = fs_info->directory_handlers; 10f0d8: 8b 51 0c mov 0xc(%ecx),%edx 10f0db: 89 50 08 mov %edx,0x8(%eax) loc->handlers = fs_info->fifo_handlers; break; } return 0; } 10f0de: 31 c0 xor %eax,%eax 10f0e0: c9 leave 10f0e1: c3 ret 10f0e2: 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; 10f0e4: 8b 51 08 mov 0x8(%ecx),%edx 10f0e7: 89 50 08 mov %edx,0x8(%eax) loc->handlers = fs_info->fifo_handlers; break; } return 0; } 10f0ea: 31 c0 xor %eax,%eax 10f0ec: c9 leave 10f0ed: c3 ret 10f0ee: 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; 10f0f0: c7 40 08 80 10 12 00 movl $0x121080,0x8(%eax) loc->handlers = fs_info->fifo_handlers; break; } return 0; } 10f0f7: 31 c0 xor %eax,%eax 10f0f9: c9 leave 10f0fa: c3 ret 10f0fb: 90 nop break; case IMFS_MEMORY_FILE: loc->handlers = fs_info->memfile_handlers; break; case IMFS_FIFO: loc->handlers = fs_info->fifo_handlers; 10f0fc: 8b 51 10 mov 0x10(%ecx),%edx 10f0ff: 89 50 08 mov %edx,0x8(%eax) break; } return 0; } 10f102: 31 c0 xor %eax,%eax 10f104: c9 leave 10f105: c3 ret 10f106: 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; 10f108: c7 40 08 00 10 12 00 movl $0x121000,0x8(%eax) loc->handlers = fs_info->fifo_handlers; break; } return 0; } 10f10f: 31 c0 xor %eax,%eax 10f111: c9 leave 10f112: c3 ret =============================================================================== 0010fa30 : void IMFS_check_node_remove( IMFS_jnode_t *jnode ) { 10fa30: 55 push %ebp 10fa31: 89 e5 mov %esp,%ebp 10fa33: 53 push %ebx 10fa34: 83 ec 10 sub $0x10,%esp 10fa37: 8b 5d 08 mov 0x8(%ebp),%ebx if ( !rtems_libio_is_file_open( jnode ) && jnode->st_nlink < 1 ) { 10fa3a: 53 push %ebx 10fa3b: e8 f8 04 00 00 call 10ff38 10fa40: 83 c4 10 add $0x10,%esp 10fa43: 85 c0 test %eax,%eax 10fa45: 75 2d jne 10fa74 10fa47: 66 83 7b 34 00 cmpw $0x0,0x34(%ebx) 10fa4c: 75 26 jne 10fa74 if ( rtems_filesystem_current.node_access == jnode ) 10fa4e: a1 b0 51 12 00 mov 0x1251b0,%eax 10fa53: 39 58 04 cmp %ebx,0x4(%eax) 10fa56: 74 58 je 10fab0 rtems_filesystem_current.node_access = NULL; switch ( jnode->type ) { 10fa58: 8b 43 4c mov 0x4c(%ebx),%eax 10fa5b: 83 f8 04 cmp $0x4,%eax 10fa5e: 74 34 je 10fa94 10fa60: 83 f8 05 cmp $0x5,%eax 10fa63: 74 17 je 10fa7c break; default: break; } free( jnode ); 10fa65: 89 5d 08 mov %ebx,0x8(%ebp) } } 10fa68: 8b 5d fc mov -0x4(%ebp),%ebx 10fa6b: c9 leave break; default: break; } free( jnode ); 10fa6c: e9 43 86 ff ff jmp 1080b4 10fa71: 8d 76 00 lea 0x0(%esi),%esi } } 10fa74: 8b 5d fc mov -0x4(%ebp),%ebx 10fa77: c9 leave 10fa78: c3 ret 10fa79: 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 ); 10fa7c: 83 ec 0c sub $0xc,%esp 10fa7f: 53 push %ebx 10fa80: e8 9f 24 00 00 call 111f24 break; 10fa85: 83 c4 10 add $0x10,%esp break; default: break; } free( jnode ); 10fa88: 89 5d 08 mov %ebx,0x8(%ebp) } } 10fa8b: 8b 5d fc mov -0x4(%ebp),%ebx 10fa8e: c9 leave break; default: break; } free( jnode ); 10fa8f: e9 20 86 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 ); 10fa94: 83 ec 0c sub $0xc,%esp 10fa97: ff 73 50 pushl 0x50(%ebx) 10fa9a: e8 15 86 ff ff call 1080b4 break; 10fa9f: 83 c4 10 add $0x10,%esp default: break; } free( jnode ); 10faa2: 89 5d 08 mov %ebx,0x8(%ebp) } } 10faa5: 8b 5d fc mov -0x4(%ebp),%ebx 10faa8: c9 leave break; default: break; } free( jnode ); 10faa9: e9 06 86 ff ff jmp 1080b4 10faae: 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; 10fab0: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) 10fab7: eb 9f jmp 10fa58 =============================================================================== 0010ee78 : int IMFS_chown( rtems_filesystem_location_info_t *pathloc, /* IN */ uid_t owner, /* IN */ gid_t group /* IN */ ) { 10ee78: 55 push %ebp 10ee79: 89 e5 mov %esp,%ebp 10ee7b: 57 push %edi 10ee7c: 56 push %esi 10ee7d: 53 push %ebx 10ee7e: 83 ec 1c sub $0x1c,%esp 10ee81: 8b 7d 0c mov 0xc(%ebp),%edi 10ee84: 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; 10ee87: 8b 45 08 mov 0x8(%ebp),%eax 10ee8a: 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(); 10ee8c: e8 bb 0e 00 00 call 10fd4c if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) ) 10ee91: 66 39 43 3c cmp %ax,0x3c(%ebx) 10ee95: 74 05 je 10ee9c 10ee97: 66 85 c0 test %ax,%ax 10ee9a: 75 2c jne 10eec8 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EPERM ); #endif jnode->st_uid = owner; 10ee9c: 66 89 7b 3c mov %di,0x3c(%ebx) jnode->st_gid = group; 10eea0: 66 89 73 3e mov %si,0x3e(%ebx) IMFS_update_ctime( jnode ); 10eea4: 83 ec 08 sub $0x8,%esp 10eea7: 6a 00 push $0x0 10eea9: 8d 45 e0 lea -0x20(%ebp),%eax 10eeac: 50 push %eax 10eead: e8 7e 92 ff ff call 108130 10eeb2: 8b 45 e0 mov -0x20(%ebp),%eax 10eeb5: 89 43 48 mov %eax,0x48(%ebx) return 0; 10eeb8: 83 c4 10 add $0x10,%esp 10eebb: 31 c0 xor %eax,%eax } 10eebd: 8d 65 f4 lea -0xc(%ebp),%esp 10eec0: 5b pop %ebx 10eec1: 5e pop %esi 10eec2: 5f pop %edi 10eec3: c9 leave 10eec4: c3 ret 10eec5: 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 ); 10eec8: e8 47 44 00 00 call 113314 <__errno> 10eecd: c7 00 01 00 00 00 movl $0x1,(%eax) 10eed3: b8 ff ff ff ff mov $0xffffffff,%eax 10eed8: eb e3 jmp 10eebd =============================================================================== 0010ef4c : IMFS_jnode_types_t type, const char *name, mode_t mode, const IMFS_types_union *info ) { 10ef4c: 55 push %ebp 10ef4d: 89 e5 mov %esp,%ebp 10ef4f: 57 push %edi 10ef50: 56 push %esi 10ef51: 53 push %ebx 10ef52: 83 ec 1c sub $0x1c,%esp 10ef55: 8b 45 08 mov 0x8(%ebp),%eax 10ef58: 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 ) 10ef5b: 85 c0 test %eax,%eax 10ef5d: 0f 84 ba 00 00 00 je 10f01d <== NEVER TAKEN return NULL; parent = parent_loc->node_access; 10ef63: 8b 38 mov (%eax),%edi fs_info = parent_loc->mt_entry->fs_info; 10ef65: 8b 40 10 mov 0x10(%eax),%eax 10ef68: 8b 70 34 mov 0x34(%eax),%esi /* * Reject creation of FIFOs if support is disabled. */ if ( type == IMFS_FIFO && 10ef6b: 83 fb 07 cmp $0x7,%ebx 10ef6e: 0f 84 9c 00 00 00 je 10f010 return NULL; /* * Allocate filesystem node and fill in basic information */ node = IMFS_allocate_node( type, name, mode & ~rtems_filesystem_umask ); 10ef74: 50 push %eax 10ef75: a1 b0 51 12 00 mov 0x1251b0,%eax 10ef7a: 8b 40 2c mov 0x2c(%eax),%eax 10ef7d: f7 d0 not %eax 10ef7f: 23 45 14 and 0x14(%ebp),%eax 10ef82: 50 push %eax 10ef83: ff 75 10 pushl 0x10(%ebp) 10ef86: 53 push %ebx 10ef87: e8 50 ff ff ff call 10eedc if ( !node ) 10ef8c: 83 c4 10 add $0x10,%esp 10ef8f: 85 c0 test %eax,%eax 10ef91: 74 73 je 10f006 return NULL; /* * Set the type specific information */ if ( type == IMFS_DIRECTORY ) { 10ef93: 83 fb 01 cmp $0x1,%ebx 10ef96: 74 38 je 10efd0 rtems_chain_initialize_empty(&node->info.directory.Entries); } else if ( type == IMFS_HARD_LINK ) { 10ef98: 83 fb 03 cmp $0x3,%ebx 10ef9b: 0f 84 97 00 00 00 je 10f038 node->info.hard_link.link_node = info->hard_link.link_node; } else if ( type == IMFS_SYM_LINK ) { 10efa1: 83 fb 04 cmp $0x4,%ebx 10efa4: 0f 84 8e 00 00 00 je 10f038 node->info.sym_link.name = info->sym_link.name; } else if ( type == IMFS_DEVICE ) { 10efaa: 83 fb 02 cmp $0x2,%ebx 10efad: 74 79 je 10f028 node->info.device.major = info->device.major; node->info.device.minor = info->device.minor; } else if ( type == IMFS_LINEAR_FILE ) { 10efaf: 83 fb 06 cmp $0x6,%ebx 10efb2: 0f 84 8c 00 00 00 je 10f044 node->info.linearfile.size = 0; node->info.linearfile.direct = 0; } else if ( type == IMFS_MEMORY_FILE ) { 10efb8: 83 fb 05 cmp $0x5,%ebx 10efbb: 0f 84 9b 00 00 00 je 10f05c 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 ) { 10efc1: 83 fb 07 cmp $0x7,%ebx 10efc4: 75 1d jne 10efe3 <== NEVER TAKEN node->info.fifo.pipe = NULL; 10efc6: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) 10efcd: eb 14 jmp 10efe3 10efcf: 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 ); 10efd0: 8d 50 54 lea 0x54(%eax),%edx 10efd3: 89 50 50 mov %edx,0x50(%eax) head->next = tail; head->previous = NULL; 10efd6: 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 ); 10efdd: 8d 50 50 lea 0x50(%eax),%edx 10efe0: 89 50 58 mov %edx,0x58(%eax) } /* * This node MUST have a parent, so put it in that directory list. */ node->Parent = parent; 10efe3: 89 78 08 mov %edi,0x8(%eax) node->st_ino = ++fs_info->ino_count; 10efe6: 8b 56 04 mov 0x4(%esi),%edx 10efe9: 42 inc %edx 10efea: 89 56 04 mov %edx,0x4(%esi) 10efed: 89 50 38 mov %edx,0x38(%eax) 10eff0: 83 ec 08 sub $0x8,%esp 10eff3: 50 push %eax rtems_chain_append( &parent->info.directory.Entries, &node->Node ); 10eff4: 83 c7 50 add $0x50,%edi 10eff7: 57 push %edi 10eff8: 89 45 e4 mov %eax,-0x1c(%ebp) 10effb: e8 dc cf ff ff call 10bfdc <_Chain_Append> return node; 10f000: 83 c4 10 add $0x10,%esp 10f003: 8b 45 e4 mov -0x1c(%ebp),%eax } 10f006: 8d 65 f4 lea -0xc(%ebp),%esp 10f009: 5b pop %ebx 10f00a: 5e pop %esi 10f00b: 5f pop %edi 10f00c: c9 leave 10f00d: c3 ret 10f00e: 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 && 10f010: 81 7e 10 60 0f 12 00 cmpl $0x120f60,0x10(%esi) 10f017: 0f 85 57 ff ff ff jne 10ef74 fs_info->fifo_handlers == &rtems_filesystem_handlers_default ) return NULL; 10f01d: 31 c0 xor %eax,%eax node->st_ino = ++fs_info->ino_count; rtems_chain_append( &parent->info.directory.Entries, &node->Node ); return node; } 10f01f: 8d 65 f4 lea -0xc(%ebp),%esp 10f022: 5b pop %ebx 10f023: 5e pop %esi 10f024: 5f pop %edi 10f025: c9 leave 10f026: c3 ret 10f027: 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; 10f028: 8b 4d 18 mov 0x18(%ebp),%ecx 10f02b: 8b 11 mov (%ecx),%edx 10f02d: 89 50 50 mov %edx,0x50(%eax) node->info.device.minor = info->device.minor; 10f030: 8b 51 04 mov 0x4(%ecx),%edx 10f033: 89 50 54 mov %edx,0x54(%eax) 10f036: eb ab jmp 10efe3 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; 10f038: 8b 4d 18 mov 0x18(%ebp),%ecx 10f03b: 8b 11 mov (%ecx),%edx 10f03d: 89 50 50 mov %edx,0x50(%eax) 10f040: eb a1 jmp 10efe3 10f042: 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; 10f044: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) 10f04b: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) node->info.linearfile.direct = 0; 10f052: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax) 10f059: eb 88 jmp 10efe3 10f05b: 90 nop } else if ( type == IMFS_MEMORY_FILE ) { node->info.file.size = 0; 10f05c: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) 10f063: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) node->info.file.indirect = 0; 10f06a: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax) node->info.file.doubly_indirect = 0; 10f071: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax) node->info.file.triply_indirect = 0; 10f078: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax) 10f07f: e9 5f ff ff ff jmp 10efe3 =============================================================================== 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 60 b2 12 00 mov 0x12b260,%eax 10a519: ff 70 08 pushl 0x8(%eax) 10a51c: 6a 04 push $0x4 10a51e: 6a 01 push $0x1 10a520: 68 92 69 12 00 push $0x126992 10a525: e8 3a e1 00 00 call 118664 !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 =============================================================================== 0010f1c4 : const char *pathname, /* IN */ size_t pathnamelen, /* IN */ int flags, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN/OUT */ ) { 10f1c4: 55 push %ebp 10f1c5: 89 e5 mov %esp,%ebp 10f1c7: 57 push %edi 10f1c8: 56 push %esi 10f1c9: 53 push %ebx 10f1ca: 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 ) ) { 10f1cd: f7 45 10 f8 ff ff ff testl $0xfffffff8,0x10(%ebp) 10f1d4: 0f 85 ee 01 00 00 jne 10f3c8 <== NEVER TAKEN /* * This was filled in by the caller and is valid in the * mount table. */ node = pathloc->node_access; 10f1da: 8b 45 14 mov 0x14(%ebp),%eax 10f1dd: 8b 38 mov (%eax),%edi size_t pathnamelen, /* IN */ int flags, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN/OUT */ ) { int i = 0; 10f1df: c7 45 a4 00 00 00 00 movl $0x0,-0x5c(%ebp) 10f1e6: 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 ); 10f1e9: 8d 55 e4 lea -0x1c(%ebp),%edx 10f1ec: 52 push %edx 10f1ed: 56 push %esi 10f1ee: ff 75 0c pushl 0xc(%ebp) 10f1f1: 8b 45 08 mov 0x8(%ebp),%eax 10f1f4: 03 45 a4 add -0x5c(%ebp),%eax 10f1f7: 50 push %eax 10f1f8: e8 17 07 00 00 call 10f914 10f1fd: 89 c3 mov %eax,%ebx pathnamelen -= len; 10f1ff: 8b 55 e4 mov -0x1c(%ebp),%edx i += len; if ( !pathloc->node_access ) 10f202: 8b 4d 14 mov 0x14(%ebp),%ecx 10f205: 8b 01 mov (%ecx),%eax 10f207: 83 c4 10 add $0x10,%esp 10f20a: 85 c0 test %eax,%eax 10f20c: 0f 84 e6 00 00 00 je 10f2f8 <== NEVER TAKEN */ while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) { type = IMFS_get_token( &pathname[i], pathnamelen, token, &len ); pathnamelen -= len; 10f212: 29 55 0c sub %edx,0xc(%ebp) i += len; 10f215: 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 ) 10f218: 85 db test %ebx,%ebx 10f21a: 75 44 jne 10f260 * 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 ) { 10f21c: 83 78 4c 01 cmpl $0x1,0x4c(%eax) 10f220: 0f 84 26 01 00 00 je 10f34c flags, pathloc ); } else { result = IMFS_Set_handlers( pathloc ); } } else { result = IMFS_Set_handlers( pathloc ); 10f226: 83 ec 0c sub $0xc,%esp 10f229: ff 75 14 pushl 0x14(%ebp) 10f22c: e8 87 fe ff ff call 10f0b8 10f231: 89 c3 mov %eax,%ebx 10f233: 5a pop %edx 10f234: 59 pop %ecx /* * Verify we have the correct permissions for this node. */ if ( !IMFS_evaluate_permission( pathloc, flags ) ) 10f235: ff 75 10 pushl 0x10(%ebp) 10f238: ff 75 14 pushl 0x14(%ebp) 10f23b: e8 d4 fe ff ff call 10f114 10f240: 83 c4 10 add $0x10,%esp 10f243: 85 c0 test %eax,%eax 10f245: 0f 85 d1 00 00 00 jne 10f31c rtems_set_errno_and_return_minus_one( EACCES ); 10f24b: e8 c4 40 00 00 call 113314 <__errno> 10f250: c7 00 0d 00 00 00 movl $0xd,(%eax) 10f256: bb ff ff ff ff mov $0xffffffff,%ebx 10f25b: e9 bc 00 00 00 jmp 10f31c /* * I cannot move out of this directory without execute permission. */ if ( type != IMFS_NO_MORE_PATH ) if ( node->type == IMFS_DIRECTORY ) 10f260: 83 7f 4c 01 cmpl $0x1,0x4c(%edi) 10f264: 0f 84 be 00 00 00 je 10f328 if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) ) rtems_set_errno_and_return_minus_one( EACCES ); node = pathloc->node_access; 10f26a: 89 c7 mov %eax,%edi switch( type ) { 10f26c: 83 fb 03 cmp $0x3,%ebx 10f26f: 74 1b je 10f28c 10f271: 83 fb 04 cmp $0x4,%ebx 10f274: 0f 84 92 00 00 00 je 10f30c 10f27a: 83 fb 02 cmp $0x2,%ebx 10f27d: 74 51 je 10f2d0 /* * Evaluate all tokens until we are done or an error occurs. */ while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) { 10f27f: 83 fb 04 cmp $0x4,%ebx 10f282: 0f 85 61 ff ff ff jne 10f1e9 <== ALWAYS TAKEN 10f288: eb 92 jmp 10f21c <== NOT EXECUTED 10f28a: 66 90 xchg %ax,%ax <== NOT EXECUTED case IMFS_NAME: /* * If we are at a link follow it. */ if ( node->type == IMFS_HARD_LINK ) { 10f28c: 8b 40 4c mov 0x4c(%eax),%eax 10f28f: 83 f8 03 cmp $0x3,%eax 10f292: 0f 84 08 01 00 00 je 10f3a0 * It would be a design error if we evaluated the link and * was broken. */ IMFS_assert( node ); } else if ( node->type == IMFS_SYM_LINK ) { 10f298: 83 f8 04 cmp $0x4,%eax 10f29b: 0f 84 51 01 00 00 je 10f3f2 } /* * Only a directory can be decended into. */ if ( node->type != IMFS_DIRECTORY ) 10f2a1: 48 dec %eax 10f2a2: 0f 85 35 01 00 00 jne 10f3dd /* * 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 ) { 10f2a8: 8b 47 5c mov 0x5c(%edi),%eax 10f2ab: 85 c0 test %eax,%eax 10f2ad: 0f 85 a4 00 00 00 jne 10f357 } /* * Otherwise find the token name in the present location. */ node = IMFS_find_match_in_dir( node, token ); 10f2b3: 83 ec 08 sub $0x8,%esp 10f2b6: 56 push %esi 10f2b7: 57 push %edi 10f2b8: e8 eb 05 00 00 call 10f8a8 10f2bd: 89 c7 mov %eax,%edi if ( !node ) 10f2bf: 83 c4 10 add $0x10,%esp 10f2c2: 85 c0 test %eax,%eax 10f2c4: 74 32 je 10f2f8 /* * Set the node access to the point we have found. */ pathloc->node_access = node; 10f2c6: 8b 45 14 mov 0x14(%ebp),%eax 10f2c9: 89 38 mov %edi,(%eax) 10f2cb: e9 19 ff ff ff jmp 10f1e9 case IMFS_UP_DIR: /* * Am I at the root of all filesystems? (chroot'ed?) */ if ( pathloc->node_access == rtems_filesystem_root.node_access ) 10f2d0: 8b 15 b0 51 12 00 mov 0x1251b0,%edx 10f2d6: 39 42 18 cmp %eax,0x18(%edx) 10f2d9: 0f 84 0a ff ff ff je 10f1e9 /* * Am I at the root of this mounted filesystem? */ if (pathloc->node_access == pathloc->mt_entry->mt_fs_root.node_access) { 10f2df: 8b 4d 14 mov 0x14(%ebp),%ecx 10f2e2: 8b 51 10 mov 0x10(%ecx),%edx /* * Am I at the root of this mounted filesystem? */ if (pathloc->node_access == 10f2e5: 39 42 1c cmp %eax,0x1c(%edx) 10f2e8: 0f 84 d2 00 00 00 je 10f3c0 pathnamelen+len, flags,pathloc); } } else { if ( !node->Parent ) 10f2ee: 8b 78 08 mov 0x8(%eax),%edi 10f2f1: 85 ff test %edi,%edi 10f2f3: 75 d1 jne 10f2c6 10f2f5: 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 ); 10f2f8: e8 17 40 00 00 call 113314 <__errno> 10f2fd: c7 00 02 00 00 00 movl $0x2,(%eax) 10f303: bb ff ff ff ff mov $0xffffffff,%ebx 10f308: eb 12 jmp 10f31c 10f30a: 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 ); 10f30c: e8 03 40 00 00 call 113314 <__errno> 10f311: c7 00 5b 00 00 00 movl $0x5b,(%eax) 10f317: bb ff ff ff ff mov $0xffffffff,%ebx if ( !IMFS_evaluate_permission( pathloc, flags ) ) rtems_set_errno_and_return_minus_one( EACCES ); return result; } 10f31c: 89 d8 mov %ebx,%eax 10f31e: 8d 65 f4 lea -0xc(%ebp),%esp 10f321: 5b pop %ebx 10f322: 5e pop %esi 10f323: 5f pop %edi 10f324: c9 leave 10f325: c3 ret 10f326: 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 ) ) 10f328: 83 ec 08 sub $0x8,%esp 10f32b: 6a 01 push $0x1 10f32d: ff 75 14 pushl 0x14(%ebp) 10f330: e8 df fd ff ff call 10f114 10f335: 83 c4 10 add $0x10,%esp 10f338: 85 c0 test %eax,%eax 10f33a: 0f 84 0b ff ff ff je 10f24b 10f340: 8b 55 14 mov 0x14(%ebp),%edx 10f343: 8b 02 mov (%edx),%eax 10f345: e9 20 ff ff ff jmp 10f26a 10f34a: 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 ) { 10f34c: 8b 40 5c mov 0x5c(%eax),%eax 10f34f: 85 c0 test %eax,%eax 10f351: 0f 84 cf fe ff ff je 10f226 newloc = node->info.directory.mt_fs->mt_fs_root; 10f357: 8d 7d d0 lea -0x30(%ebp),%edi 10f35a: 8d 70 1c lea 0x1c(%eax),%esi 10f35d: b9 05 00 00 00 mov $0x5,%ecx 10f362: f3 a5 rep movsl %ds:(%esi),%es:(%edi) *pathloc = newloc; 10f364: 8d 75 d0 lea -0x30(%ebp),%esi 10f367: b1 05 mov $0x5,%cl 10f369: 8b 7d 14 mov 0x14(%ebp),%edi 10f36c: f3 a5 rep movsl %ds:(%esi),%es:(%edi) return (*pathloc->ops->evalpath_h)( &pathname[i-len], 10f36e: 8b 55 e4 mov -0x1c(%ebp),%edx 10f371: 8b 4d 14 mov 0x14(%ebp),%ecx 10f374: 8b 41 0c mov 0xc(%ecx),%eax 10f377: 51 push %ecx 10f378: ff 75 10 pushl 0x10(%ebp) 10f37b: 8b 4d 0c mov 0xc(%ebp),%ecx 10f37e: 01 d1 add %edx,%ecx 10f380: 51 push %ecx 10f381: 8b 4d a4 mov -0x5c(%ebp),%ecx 10f384: 29 d1 sub %edx,%ecx 10f386: 8b 55 08 mov 0x8(%ebp),%edx 10f389: 01 ca add %ecx,%edx 10f38b: 52 push %edx 10f38c: ff 10 call *(%eax) 10f38e: 89 c3 mov %eax,%ebx 10f390: 83 c4 10 add $0x10,%esp if ( !IMFS_evaluate_permission( pathloc, flags ) ) rtems_set_errno_and_return_minus_one( EACCES ); return result; } 10f393: 89 d8 mov %ebx,%eax 10f395: 8d 65 f4 lea -0xc(%ebp),%esp 10f398: 5b pop %ebx 10f399: 5e pop %esi 10f39a: 5f pop %edi 10f39b: c9 leave 10f39c: c3 ret 10f39d: 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 ); 10f3a0: 83 ec 08 sub $0x8,%esp 10f3a3: 6a 00 push $0x0 10f3a5: ff 75 14 pushl 0x14(%ebp) 10f3a8: e8 d3 fd ff ff call 10f180 node = pathloc->node_access; 10f3ad: 8b 55 14 mov 0x14(%ebp),%edx 10f3b0: 8b 3a mov (%edx),%edi 10f3b2: 8b 47 4c mov 0x4c(%edi),%eax 10f3b5: 83 c4 10 add $0x10,%esp 10f3b8: e9 e4 fe ff ff jmp 10f2a1 10f3bd: 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; 10f3c0: 8d 7d d0 lea -0x30(%ebp),%edi 10f3c3: 8d 72 08 lea 0x8(%edx),%esi 10f3c6: eb 95 jmp 10f35d 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 ); 10f3c8: e8 47 3f 00 00 call 113314 <__errno> <== NOT EXECUTED 10f3cd: c7 00 05 00 00 00 movl $0x5,(%eax) <== NOT EXECUTED 10f3d3: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED 10f3d8: e9 3f ff ff ff jmp 10f31c <== NOT EXECUTED /* * Only a directory can be decended into. */ if ( node->type != IMFS_DIRECTORY ) rtems_set_errno_and_return_minus_one( ENOTDIR ); 10f3dd: e8 32 3f 00 00 call 113314 <__errno> 10f3e2: c7 00 14 00 00 00 movl $0x14,(%eax) 10f3e8: bb ff ff ff ff mov $0xffffffff,%ebx 10f3ed: e9 2a ff ff ff jmp 10f31c * was broken. */ IMFS_assert( node ); } else if ( node->type == IMFS_SYM_LINK ) { result = IMFS_evaluate_sym_link( pathloc, 0 ); 10f3f2: 83 ec 08 sub $0x8,%esp 10f3f5: 6a 00 push $0x0 10f3f7: ff 75 14 pushl 0x14(%ebp) 10f3fa: e8 1d 00 00 00 call 10f41c 10f3ff: 89 c3 mov %eax,%ebx /* * In contrast to a hard link, it is possible to have a broken * symbolic link. */ node = pathloc->node_access; 10f401: 8b 4d 14 mov 0x14(%ebp),%ecx 10f404: 8b 39 mov (%ecx),%edi if ( result == -1 ) 10f406: 83 c4 10 add $0x10,%esp 10f409: 83 f8 ff cmp $0xffffffff,%eax 10f40c: 0f 84 0a ff ff ff je 10f31c <== NEVER TAKEN /* * In contrast to a hard link, it is possible to have a broken * symbolic link. */ node = pathloc->node_access; 10f412: 8b 47 4c mov 0x4c(%edi),%eax 10f415: e9 87 fe ff ff jmp 10f2a1 =============================================================================== 0010f544 : int IMFS_evaluate_for_make( const char *path, /* IN */ rtems_filesystem_location_info_t *pathloc, /* IN/OUT */ const char **name /* OUT */ ) { 10f544: 55 push %ebp 10f545: 89 e5 mov %esp,%ebp 10f547: 57 push %edi 10f548: 56 push %esi 10f549: 53 push %ebx 10f54a: 83 ec 5c sub $0x5c,%esp /* * This was filled in by the caller and is valid in the * mount table. */ node = pathloc->node_access; 10f54d: 8b 45 0c mov 0xc(%ebp),%eax 10f550: 8b 18 mov (%eax),%ebx /* * Get the path length. */ pathlen = strlen( path ); 10f552: 31 c0 xor %eax,%eax 10f554: b9 ff ff ff ff mov $0xffffffff,%ecx 10f559: 8b 7d 08 mov 0x8(%ebp),%edi 10f55c: f2 ae repnz scas %es:(%edi),%al 10f55e: f7 d1 not %ecx 10f560: 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; 10f563: 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 ); 10f56a: 8d 55 e4 lea -0x1c(%ebp),%edx 10f56d: 52 push %edx 10f56e: 8d 4d af lea -0x51(%ebp),%ecx 10f571: 51 push %ecx 10f572: 56 push %esi 10f573: 8b 45 08 mov 0x8(%ebp),%eax 10f576: 03 45 a4 add -0x5c(%ebp),%eax 10f579: 50 push %eax 10f57a: e8 95 03 00 00 call 10f914 10f57f: 89 c7 mov %eax,%edi pathlen -= len; 10f581: 8b 55 e4 mov -0x1c(%ebp),%edx 10f584: 29 d6 sub %edx,%esi i += len; if ( !pathloc->node_access ) 10f586: 8b 4d 0c mov 0xc(%ebp),%ecx 10f589: 8b 01 mov (%ecx),%eax 10f58b: 83 c4 10 add $0x10,%esp 10f58e: 85 c0 test %eax,%eax 10f590: 0f 84 55 01 00 00 je 10f6eb <== NEVER TAKEN /* * I cannot move out of this directory without execute permission. */ if ( type != IMFS_NO_MORE_PATH ) 10f596: 85 ff test %edi,%edi 10f598: 75 1a jne 10f5b4 pathloc->node_access = node; break; case IMFS_NO_MORE_PATH: rtems_set_errno_and_return_minus_one( EEXIST ); 10f59a: e8 75 3d 00 00 call 113314 <__errno> 10f59f: c7 00 11 00 00 00 movl $0x11,(%eax) 10f5a5: 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; } 10f5aa: 89 d8 mov %ebx,%eax 10f5ac: 8d 65 f4 lea -0xc(%ebp),%esp 10f5af: 5b pop %ebx 10f5b0: 5e pop %esi 10f5b1: 5f pop %edi 10f5b2: c9 leave 10f5b3: c3 ret /* * I cannot move out of this directory without execute permission. */ if ( type != IMFS_NO_MORE_PATH ) if ( node->type == IMFS_DIRECTORY ) 10f5b4: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx) 10f5b8: 0f 84 c6 00 00 00 je 10f684 while( !done ) { type = IMFS_get_token( &path[i], pathlen, token, &len ); pathlen -= len; i += len; 10f5be: 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; 10f5c1: 89 c3 mov %eax,%ebx switch( type ) { 10f5c3: 83 ff 02 cmp $0x2,%edi 10f5c6: 0f 84 88 00 00 00 je 10f654 10f5cc: 76 26 jbe 10f5f4 10f5ce: 83 ff 03 cmp $0x3,%edi 10f5d1: 74 2d je 10f600 10f5d3: 83 ff 04 cmp $0x4,%edi 10f5d6: 75 92 jne 10f56a <== 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 ); 10f5d8: e8 37 3d 00 00 call 113314 <__errno> 10f5dd: c7 00 5b 00 00 00 movl $0x5b,(%eax) 10f5e3: 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; } 10f5e8: 89 d8 mov %ebx,%eax 10f5ea: 8d 65 f4 lea -0xc(%ebp),%esp 10f5ed: 5b pop %ebx 10f5ee: 5e pop %esi 10f5ef: 5f pop %edi 10f5f0: c9 leave 10f5f1: c3 ret 10f5f2: 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 ) { 10f5f4: 85 ff test %edi,%edi 10f5f6: 74 a2 je 10f59a <== NEVER TAKEN 10f5f8: e9 6d ff ff ff jmp 10f56a 10f5fd: 8d 76 00 lea 0x0(%esi),%esi pathloc->node_access = node; break; case IMFS_NAME: if ( node->type == IMFS_HARD_LINK ) { 10f600: 8b 40 4c mov 0x4c(%eax),%eax 10f603: 83 f8 03 cmp $0x3,%eax 10f606: 0f 84 b4 01 00 00 je 10f7c0 result = IMFS_evaluate_link( pathloc, 0 ); if ( result == -1 ) return -1; } else if ( node->type == IMFS_SYM_LINK ) { 10f60c: 83 f8 04 cmp $0x4,%eax 10f60f: 0f 84 ca 01 00 00 je 10f7df if ( result == -1 ) return -1; } node = pathloc->node_access; if ( !node ) 10f615: 85 db test %ebx,%ebx 10f617: 0f 84 67 01 00 00 je 10f784 <== NEVER TAKEN /* * Only a directory can be decended into. */ if ( node->type != IMFS_DIRECTORY ) 10f61d: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx) 10f621: 0f 85 5d 01 00 00 jne 10f784 /* * 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 ) { 10f627: 8b 43 5c mov 0x5c(%ebx),%eax 10f62a: 85 c0 test %eax,%eax 10f62c: 0f 85 67 01 00 00 jne 10f799 /* * Otherwise find the token name in the present location. */ node = IMFS_find_match_in_dir( node, token ); 10f632: 83 ec 08 sub $0x8,%esp 10f635: 8d 45 af lea -0x51(%ebp),%eax 10f638: 50 push %eax 10f639: 53 push %ebx 10f63a: e8 69 02 00 00 call 10f8a8 10f63f: 89 c3 mov %eax,%ebx /* * If there is no node we have found the name of the node we * wish to create. */ if ( ! node ) 10f641: 83 c4 10 add $0x10,%esp 10f644: 85 c0 test %eax,%eax 10f646: 74 64 je 10f6ac done = true; else pathloc->node_access = node; 10f648: 8b 55 0c mov 0xc(%ebp),%edx 10f64b: 89 02 mov %eax,(%edx) 10f64d: e9 18 ff ff ff jmp 10f56a 10f652: 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 ) 10f654: 8b 15 b0 51 12 00 mov 0x1251b0,%edx 10f65a: 3b 42 18 cmp 0x18(%edx),%eax 10f65d: 0f 84 07 ff ff ff je 10f56a /* * Am I at the root of this mounted filesystem? */ if (pathloc->node_access == pathloc->mt_entry->mt_fs_root.node_access){ 10f663: 8b 4d 0c mov 0xc(%ebp),%ecx 10f666: 8b 51 10 mov 0x10(%ecx),%edx 10f669: 3b 42 1c cmp 0x1c(%edx),%eax 10f66c: 0f 84 8e 00 00 00 je 10f700 *pathloc = newloc; return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name ); } } else { if ( !node->Parent ) 10f672: 8b 58 08 mov 0x8(%eax),%ebx 10f675: 85 db test %ebx,%ebx 10f677: 74 72 je 10f6eb rtems_set_errno_and_return_minus_one( ENOENT ); node = node->Parent; } pathloc->node_access = node; 10f679: 8b 4d 0c mov 0xc(%ebp),%ecx 10f67c: 89 19 mov %ebx,(%ecx) break; 10f67e: e9 e7 fe ff ff jmp 10f56a 10f683: 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 ) ) 10f684: 83 ec 08 sub $0x8,%esp 10f687: 6a 01 push $0x1 10f689: ff 75 0c pushl 0xc(%ebp) 10f68c: 89 55 a0 mov %edx,-0x60(%ebp) 10f68f: e8 80 fa ff ff call 10f114 10f694: 83 c4 10 add $0x10,%esp 10f697: 85 c0 test %eax,%eax 10f699: 8b 55 a0 mov -0x60(%ebp),%edx 10f69c: 0f 84 cd 00 00 00 je 10f76f 10f6a2: 8b 4d 0c mov 0xc(%ebp),%ecx 10f6a5: 8b 01 mov (%ecx),%eax 10f6a7: e9 12 ff ff ff jmp 10f5be case IMFS_CURRENT_DIR: break; } } *name = &path[ i - len ]; 10f6ac: 8b 45 a4 mov -0x5c(%ebp),%eax 10f6af: 2b 45 e4 sub -0x1c(%ebp),%eax 10f6b2: 03 45 08 add 0x8(%ebp),%eax 10f6b5: 8b 4d 10 mov 0x10(%ebp),%ecx 10f6b8: 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++) { 10f6ba: 8b 4d 08 mov 0x8(%ebp),%ecx 10f6bd: 8b 55 a4 mov -0x5c(%ebp),%edx 10f6c0: 8a 04 11 mov (%ecx,%edx,1),%al 10f6c3: 84 c0 test %al,%al 10f6c5: 74 75 je 10f73c 10f6c7: 89 d3 mov %edx,%ebx 10f6c9: 89 ce mov %ecx,%esi 10f6cb: eb 0b jmp 10f6d8 10f6cd: 8d 76 00 lea 0x0(%esi),%esi 10f6d0: 43 inc %ebx 10f6d1: 8a 04 1e mov (%esi,%ebx,1),%al 10f6d4: 84 c0 test %al,%al 10f6d6: 74 64 je 10f73c if ( !IMFS_is_separator( path[ i ] ) ) 10f6d8: 83 ec 0c sub $0xc,%esp 10f6db: 0f be c0 movsbl %al,%eax 10f6de: 50 push %eax 10f6df: e8 34 98 ff ff call 108f18 10f6e4: 83 c4 10 add $0x10,%esp 10f6e7: 85 c0 test %eax,%eax 10f6e9: 75 e5 jne 10f6d0 rtems_set_errno_and_return_minus_one( ENOENT ); 10f6eb: e8 24 3c 00 00 call 113314 <__errno> 10f6f0: c7 00 02 00 00 00 movl $0x2,(%eax) 10f6f6: bb ff ff ff ff mov $0xffffffff,%ebx 10f6fb: e9 aa fe ff ff jmp 10f5aa if ( pathloc->node_access == rtems_filesystem_root.node_access ) { break; } else { newloc = pathloc->mt_entry->mt_point_node; 10f700: 8d 7d d0 lea -0x30(%ebp),%edi 10f703: 8d 72 08 lea 0x8(%edx),%esi 10f706: b9 05 00 00 00 mov $0x5,%ecx 10f70b: f3 a5 rep movsl %ds:(%esi),%es:(%edi) *pathloc = newloc; 10f70d: 8d 75 d0 lea -0x30(%ebp),%esi 10f710: b1 05 mov $0x5,%cl 10f712: 8b 7d 0c mov 0xc(%ebp),%edi 10f715: f3 a5 rep movsl %ds:(%esi),%es:(%edi) return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name ); 10f717: 53 push %ebx 10f718: 8b 55 0c mov 0xc(%ebp),%edx 10f71b: 8b 42 0c mov 0xc(%edx),%eax 10f71e: ff 75 10 pushl 0x10(%ebp) 10f721: 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 ); 10f722: 8b 55 a4 mov -0x5c(%ebp),%edx 10f725: 2b 55 e4 sub -0x1c(%ebp),%edx 10f728: 03 55 08 add 0x8(%ebp),%edx 10f72b: 52 push %edx 10f72c: ff 50 04 call *0x4(%eax) 10f72f: 89 c3 mov %eax,%ebx 10f731: 83 c4 10 add $0x10,%esp 10f734: e9 71 fe ff ff jmp 10f5aa 10f739: 8d 76 00 lea 0x0(%esi),%esi /* * Verify we can execute and write to this directory. */ result = IMFS_Set_handlers( pathloc ); 10f73c: 83 ec 0c sub $0xc,%esp 10f73f: ff 75 0c pushl 0xc(%ebp) 10f742: e8 71 f9 ff ff call 10f0b8 10f747: 89 c3 mov %eax,%ebx /* * The returned node must be a directory */ node = pathloc->node_access; if ( node->type != IMFS_DIRECTORY ) 10f749: 8b 55 0c mov 0xc(%ebp),%edx 10f74c: 8b 02 mov (%edx),%eax 10f74e: 83 c4 10 add $0x10,%esp 10f751: 83 78 4c 01 cmpl $0x1,0x4c(%eax) 10f755: 75 2d jne 10f784 <== NEVER TAKEN /* * We must have Write and execute permission on the returned node. */ if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) ) 10f757: 83 ec 08 sub $0x8,%esp 10f75a: 6a 03 push $0x3 10f75c: ff 75 0c pushl 0xc(%ebp) 10f75f: e8 b0 f9 ff ff call 10f114 10f764: 83 c4 10 add $0x10,%esp 10f767: 85 c0 test %eax,%eax 10f769: 0f 85 3b fe ff ff jne 10f5aa rtems_set_errno_and_return_minus_one( EACCES ); 10f76f: e8 a0 3b 00 00 call 113314 <__errno> 10f774: c7 00 0d 00 00 00 movl $0xd,(%eax) 10f77a: bb ff ff ff ff mov $0xffffffff,%ebx 10f77f: e9 26 fe ff ff jmp 10f5aa /* * The returned node must be a directory */ node = pathloc->node_access; if ( node->type != IMFS_DIRECTORY ) rtems_set_errno_and_return_minus_one( ENOTDIR ); 10f784: e8 8b 3b 00 00 call 113314 <__errno> 10f789: c7 00 14 00 00 00 movl $0x14,(%eax) 10f78f: bb ff ff ff ff mov $0xffffffff,%ebx 10f794: e9 11 fe ff ff jmp 10f5aa * 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; 10f799: 8d 7d d0 lea -0x30(%ebp),%edi 10f79c: 8d 70 1c lea 0x1c(%eax),%esi 10f79f: b9 05 00 00 00 mov $0x5,%ecx 10f7a4: f3 a5 rep movsl %ds:(%esi),%es:(%edi) *pathloc = newloc; 10f7a6: 8d 75 d0 lea -0x30(%ebp),%esi 10f7a9: b1 05 mov $0x5,%cl 10f7ab: 8b 7d 0c mov 0xc(%ebp),%edi 10f7ae: f3 a5 rep movsl %ds:(%esi),%es:(%edi) return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name ); 10f7b0: 51 push %ecx 10f7b1: 8b 4d 0c mov 0xc(%ebp),%ecx 10f7b4: 8b 41 0c mov 0xc(%ecx),%eax 10f7b7: ff 75 10 pushl 0x10(%ebp) 10f7ba: 51 push %ecx 10f7bb: e9 62 ff ff ff jmp 10f722 case IMFS_NAME: if ( node->type == IMFS_HARD_LINK ) { result = IMFS_evaluate_link( pathloc, 0 ); 10f7c0: 83 ec 08 sub $0x8,%esp 10f7c3: 6a 00 push $0x0 10f7c5: ff 75 0c pushl 0xc(%ebp) 10f7c8: e8 cb fc ff ff call 10f498 if ( result == -1 ) 10f7cd: 83 c4 10 add $0x10,%esp 10f7d0: 83 f8 ff cmp $0xffffffff,%eax 10f7d3: 74 29 je 10f7fe <== NEVER TAKEN 10f7d5: 8b 45 0c mov 0xc(%ebp),%eax 10f7d8: 8b 18 mov (%eax),%ebx 10f7da: e9 36 fe ff ff jmp 10f615 return -1; } else if ( node->type == IMFS_SYM_LINK ) { result = IMFS_evaluate_link( pathloc, 0 ); 10f7df: 83 ec 08 sub $0x8,%esp 10f7e2: 6a 00 push $0x0 10f7e4: ff 75 0c pushl 0xc(%ebp) 10f7e7: e8 ac fc ff ff call 10f498 if ( result == -1 ) 10f7ec: 83 c4 10 add $0x10,%esp 10f7ef: 83 f8 ff cmp $0xffffffff,%eax 10f7f2: 74 0a je 10f7fe <== NEVER TAKEN 10f7f4: 8b 55 0c mov 0xc(%ebp),%edx 10f7f7: 8b 1a mov (%edx),%ebx 10f7f9: e9 17 fe ff ff jmp 10f615 10f7fe: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10f800: e9 a5 fd ff ff jmp 10f5aa <== NOT EXECUTED =============================================================================== 0010f498 : */ int IMFS_evaluate_link( rtems_filesystem_location_info_t *node, /* IN/OUT */ int flags /* IN */ ) { 10f498: 55 push %ebp 10f499: 89 e5 mov %esp,%ebp 10f49b: 57 push %edi 10f49c: 56 push %esi 10f49d: 53 push %ebx 10f49e: 83 ec 0c sub $0xc,%esp 10f4a1: 8b 75 08 mov 0x8(%ebp),%esi 10f4a4: 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 ); 10f4a7: 8b 15 b0 51 12 00 mov 0x1251b0,%edx 10f4ad: eb 0e jmp 10f4bd 10f4af: 90 nop */ if ( jnode->type == IMFS_HARD_LINK ) result = IMFS_evaluate_hard_link( node, flags ); else if (jnode->type == IMFS_SYM_LINK ) 10f4b0: 83 f8 04 cmp $0x4,%eax 10f4b3: 74 53 je 10f508 result = IMFS_evaluate_sym_link( node, flags ); } while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) || 10f4b5: 83 e8 03 sub $0x3,%eax 10f4b8: 83 f8 01 cmp $0x1,%eax 10f4bb: 77 3a ja 10f4f7 <== ALWAYS TAKEN { IMFS_jnode_t *jnode; int result = 0; do { jnode = node->node_access; 10f4bd: 8b 1e mov (%esi),%ebx /* * Increment and check the link counter. */ rtems_filesystem_link_counts ++; 10f4bf: 8b 42 30 mov 0x30(%edx),%eax 10f4c2: 40 inc %eax 10f4c3: 66 89 42 30 mov %ax,0x30(%edx) if ( rtems_filesystem_link_counts > MAXSYMLINK ) { 10f4c7: 66 83 f8 05 cmp $0x5,%ax 10f4cb: 77 57 ja 10f524 <== NEVER TAKEN /* * Follow the Link node. */ if ( jnode->type == IMFS_HARD_LINK ) 10f4cd: 8b 43 4c mov 0x4c(%ebx),%eax 10f4d0: 83 f8 03 cmp $0x3,%eax 10f4d3: 75 db jne 10f4b0 result = IMFS_evaluate_hard_link( node, flags ); 10f4d5: 83 ec 08 sub $0x8,%esp 10f4d8: 57 push %edi 10f4d9: 56 push %esi 10f4da: e8 a1 fc ff ff call 10f180 10f4df: 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 ) ) ); 10f4e2: 85 c0 test %eax,%eax 10f4e4: 75 33 jne 10f519 10f4e6: 8b 43 4c mov 0x4c(%ebx),%eax 10f4e9: 8b 15 b0 51 12 00 mov 0x1251b0,%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 ) || 10f4ef: 83 e8 03 sub $0x3,%eax 10f4f2: 83 f8 01 cmp $0x1,%eax 10f4f5: 76 c6 jbe 10f4bd <== ALWAYS TAKEN 10f4f7: 31 c0 xor %eax,%eax /* * Clear link counter. */ rtems_filesystem_link_counts = 0; 10f4f9: 66 c7 42 30 00 00 movw $0x0,0x30(%edx) return result; } 10f4ff: 8d 65 f4 lea -0xc(%ebp),%esp 10f502: 5b pop %ebx 10f503: 5e pop %esi 10f504: 5f pop %edi 10f505: c9 leave 10f506: c3 ret 10f507: 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 ); 10f508: 83 ec 08 sub $0x8,%esp 10f50b: 57 push %edi 10f50c: 56 push %esi 10f50d: e8 0a ff ff ff call 10f41c 10f512: 83 c4 10 add $0x10,%esp } while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) || ( jnode->type == IMFS_HARD_LINK ) ) ); 10f515: 85 c0 test %eax,%eax 10f517: 74 cd je 10f4e6 10f519: 8b 15 b0 51 12 00 mov 0x1251b0,%edx 10f51f: eb d8 jmp 10f4f9 10f521: 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; 10f524: 66 c7 42 30 00 00 movw $0x0,0x30(%edx) rtems_set_errno_and_return_minus_one( ELOOP ); 10f52a: e8 e5 3d 00 00 call 113314 <__errno> 10f52f: c7 00 5c 00 00 00 movl $0x5c,(%eax) 10f535: b8 ff ff ff ff mov $0xffffffff,%eax */ rtems_filesystem_link_counts = 0; return result; } 10f53a: 8d 65 f4 lea -0xc(%ebp),%esp 10f53d: 5b pop %ebx 10f53e: 5e pop %esi 10f53f: 5f pop %edi 10f540: c9 leave 10f541: c3 ret =============================================================================== 0010f114 : */ int IMFS_evaluate_permission( rtems_filesystem_location_info_t *node, int flags ) { 10f114: 55 push %ebp 10f115: 89 e5 mov %esp,%ebp 10f117: 57 push %edi 10f118: 56 push %esi 10f119: 53 push %ebx 10f11a: 83 ec 0c sub $0xc,%esp 10f11d: 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 ) ) 10f120: f7 c6 f8 ff ff ff test $0xfffffff8,%esi 10f126: 75 44 jne 10f16c <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EPERM ); jnode = node->node_access; 10f128: 8b 45 08 mov 0x8(%ebp),%eax 10f12b: 8b 18 mov (%eax),%ebx #if defined(RTEMS_POSIX_API) st_uid = geteuid(); 10f12d: e8 1a 0c 00 00 call 10fd4c 10f132: 89 c7 mov %eax,%edi st_gid = getegid(); 10f134: e8 03 0c 00 00 call 10fd3c * Check if I am owner or a group member or someone else. */ flags_to_test = flags; if ( st_uid == jnode->st_uid ) 10f139: 66 39 7b 3c cmp %di,0x3c(%ebx) 10f13d: 74 1d je 10f15c flags_to_test <<= 6; else if ( st_gid == jnode->st_gid ) 10f13f: 66 39 43 3e cmp %ax,0x3e(%ebx) 10f143: 74 1f je 10f164 <== 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 ) 10f145: 8b 43 30 mov 0x30(%ebx),%eax 10f148: 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 ); 10f14a: 39 c6 cmp %eax,%esi 10f14c: 0f 94 c0 sete %al 10f14f: 0f b6 c0 movzbl %al,%eax */ if ( ( flags_to_test & jnode->st_mode) == flags_to_test ) return 1; return 0; } 10f152: 83 c4 0c add $0xc,%esp 10f155: 5b pop %ebx 10f156: 5e pop %esi 10f157: 5f pop %edi 10f158: c9 leave 10f159: c3 ret 10f15a: 66 90 xchg %ax,%ax */ flags_to_test = flags; if ( st_uid == jnode->st_uid ) flags_to_test <<= 6; 10f15c: c1 e6 06 shl $0x6,%esi 10f15f: eb e4 jmp 10f145 10f161: 8d 76 00 lea 0x0(%esi),%esi else if ( st_gid == jnode->st_gid ) flags_to_test <<= 3; 10f164: c1 e6 03 shl $0x3,%esi 10f167: eb dc jmp 10f145 10f169: 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 ); 10f16c: e8 a3 41 00 00 call 113314 <__errno> <== NOT EXECUTED 10f171: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED 10f177: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10f17c: eb d4 jmp 10f152 <== NOT EXECUTED =============================================================================== 0010f41c : int IMFS_evaluate_sym_link( rtems_filesystem_location_info_t *node, /* IN/OUT */ int flags /* IN */ ) { 10f41c: 55 push %ebp 10f41d: 89 e5 mov %esp,%ebp 10f41f: 57 push %edi 10f420: 56 push %esi 10f421: 53 push %ebx 10f422: 83 ec 20 sub $0x20,%esp 10f425: 8b 5d 08 mov 0x8(%ebp),%ebx 10f428: 8b 75 0c mov 0xc(%ebp),%esi IMFS_jnode_t *jnode = node->node_access; 10f42b: 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; 10f42d: 8b 47 08 mov 0x8(%edi),%eax 10f430: 89 03 mov %eax,(%ebx) rtems_filesystem_get_sym_start_loc( 10f432: 53 push %ebx 10f433: 8d 45 e4 lea -0x1c(%ebp),%eax 10f436: 50 push %eax 10f437: ff 77 50 pushl 0x50(%edi) 10f43a: e8 f9 0d 00 00 call 110238 ); /* * Use eval path to evaluate the path of the symbolic link. */ result = IMFS_eval_path( 10f43f: 8b 57 50 mov 0x50(%edi),%edx 10f442: 03 55 e4 add -0x1c(%ebp),%edx 10f445: 31 c0 xor %eax,%eax 10f447: b9 ff ff ff ff mov $0xffffffff,%ecx 10f44c: 89 d7 mov %edx,%edi 10f44e: f2 ae repnz scas %es:(%edi),%al 10f450: f7 d1 not %ecx 10f452: 49 dec %ecx 10f453: 53 push %ebx 10f454: 56 push %esi 10f455: 51 push %ecx 10f456: 52 push %edx 10f457: e8 68 fd ff ff call 10f1c4 10f45c: 89 c7 mov %eax,%edi strlen( &jnode->info.sym_link.name[i] ), flags, node ); IMFS_Set_handlers( node ); 10f45e: 83 c4 14 add $0x14,%esp 10f461: 53 push %ebx 10f462: e8 51 fc ff ff call 10f0b8 /* * Verify we have the correct permissions for this node. */ if ( !IMFS_evaluate_permission( node, flags ) ) 10f467: 58 pop %eax 10f468: 5a pop %edx 10f469: 56 push %esi 10f46a: 53 push %ebx 10f46b: e8 a4 fc ff ff call 10f114 10f470: 83 c4 10 add $0x10,%esp 10f473: 85 c0 test %eax,%eax 10f475: 74 0d je 10f484 rtems_set_errno_and_return_minus_one( EACCES ); return result; } 10f477: 89 f8 mov %edi,%eax 10f479: 8d 65 f4 lea -0xc(%ebp),%esp 10f47c: 5b pop %ebx 10f47d: 5e pop %esi 10f47e: 5f pop %edi 10f47f: c9 leave 10f480: c3 ret 10f481: 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 ); 10f484: e8 8b 3e 00 00 call 113314 <__errno> 10f489: c7 00 0d 00 00 00 movl $0xd,(%eax) 10f48f: bf ff ff ff ff mov $0xffffffff,%edi 10f494: eb e1 jmp 10f477 =============================================================================== 00112a94 : int IMFS_fchmod( rtems_filesystem_location_info_t *loc, mode_t mode ) { 112a94: 55 push %ebp 112a95: 89 e5 mov %esp,%ebp 112a97: 53 push %ebx 112a98: 83 ec 14 sub $0x14,%esp IMFS_jnode_t *jnode; #if defined(RTEMS_POSIX_API) uid_t st_uid; #endif jnode = loc->node_access; 112a9b: 8b 45 08 mov 0x8(%ebp),%eax 112a9e: 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(); 112aa0: e8 a7 d2 ff ff call 10fd4c if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) ) 112aa5: 66 39 43 3c cmp %ax,0x3c(%ebx) 112aa9: 74 05 je 112ab0 112aab: 66 85 c0 test %ax,%ax 112aae: 75 34 jne 112ae4 <== 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); 112ab0: 8b 45 0c mov 0xc(%ebp),%eax 112ab3: 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); 112ab8: 8b 53 30 mov 0x30(%ebx),%edx 112abb: 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); 112ac1: 09 d0 or %edx,%eax 112ac3: 89 43 30 mov %eax,0x30(%ebx) IMFS_update_ctime( jnode ); 112ac6: 83 ec 08 sub $0x8,%esp 112ac9: 6a 00 push $0x0 112acb: 8d 45 f0 lea -0x10(%ebp),%eax 112ace: 50 push %eax 112acf: e8 5c 56 ff ff call 108130 112ad4: 8b 45 f0 mov -0x10(%ebp),%eax 112ad7: 89 43 48 mov %eax,0x48(%ebx) return 0; 112ada: 83 c4 10 add $0x10,%esp 112add: 31 c0 xor %eax,%eax } 112adf: 8b 5d fc mov -0x4(%ebp),%ebx 112ae2: c9 leave 112ae3: 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 ); 112ae4: e8 2b 08 00 00 call 113314 <__errno> 112ae9: c7 00 01 00 00 00 movl $0x1,(%eax) 112aef: b8 ff ff ff ff mov $0xffffffff,%eax 112af4: eb e9 jmp 112adf =============================================================================== 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 f6 97 00 00 call 1122a0 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 26 ca 00 00 call 11550c <__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 a1 98 00 00 call 112300 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 99 ca 00 00 call 11550c <__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 8b 95 00 00 call 1120a0 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 <== NOT EXECUTED 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 b8 c9 00 00 call 11550c <__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 =============================================================================== 0010f8a8 : IMFS_jnode_t *IMFS_find_match_in_dir( IMFS_jnode_t *directory, char *name ) { 10f8a8: 55 push %ebp 10f8a9: 89 e5 mov %esp,%ebp 10f8ab: 57 push %edi 10f8ac: 56 push %esi 10f8ad: 53 push %ebx 10f8ae: 83 ec 0c sub $0xc,%esp 10f8b1: 8b 45 08 mov 0x8(%ebp),%eax 10f8b4: 8b 5d 0c mov 0xc(%ebp),%ebx /* * Check for "." and ".." */ if ( !strcmp( name, dotname ) ) 10f8b7: bf f0 0f 12 00 mov $0x120ff0,%edi 10f8bc: b9 02 00 00 00 mov $0x2,%ecx 10f8c1: 89 de mov %ebx,%esi 10f8c3: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) 10f8c5: 74 13 je 10f8da <== NEVER TAKEN return directory; if ( !strcmp( name, dotdotname ) ) 10f8c7: bf f2 0f 12 00 mov $0x120ff2,%edi 10f8cc: b9 03 00 00 00 mov $0x3,%ecx 10f8d1: 89 de mov %ebx,%esi 10f8d3: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) 10f8d5: 75 0d jne 10f8e4 <== ALWAYS TAKEN return directory->Parent; 10f8d7: 8b 40 08 mov 0x8(%eax),%eax if ( !strcmp( name, the_jnode->name ) ) return the_jnode; } return 0; } 10f8da: 8d 65 f4 lea -0xc(%ebp),%esp 10f8dd: 5b pop %ebx 10f8de: 5e pop %esi 10f8df: 5f pop %edi 10f8e0: c9 leave 10f8e1: c3 ret 10f8e2: 66 90 xchg %ax,%ax 10f8e4: 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)); 10f8e7: 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 ); 10f8ea: 39 fe cmp %edi,%esi 10f8ec: 75 08 jne 10f8f6 10f8ee: eb 20 jmp 10f910 !rtems_chain_is_tail( the_chain, the_node ); the_node = the_node->next ) { 10f8f0: 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 ); 10f8f2: 39 fe cmp %edi,%esi 10f8f4: 74 1a je 10f910 !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 ) ) 10f8f6: 8d 46 0c lea 0xc(%esi),%eax 10f8f9: 83 ec 08 sub $0x8,%esp 10f8fc: 50 push %eax 10f8fd: 53 push %ebx 10f8fe: e8 89 46 00 00 call 113f8c 10f903: 83 c4 10 add $0x10,%esp 10f906: 85 c0 test %eax,%eax 10f908: 75 e6 jne 10f8f0 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; 10f90a: 89 f0 mov %esi,%eax 10f90c: eb cc jmp 10f8da 10f90e: 66 90 xchg %ax,%ax if ( !strcmp( name, the_jnode->name ) ) return the_jnode; } return 0; 10f910: 31 c0 xor %eax,%eax 10f912: eb c6 jmp 10f8da =============================================================================== 0010f808 : ((IMFS_jnode_t *)( rtems_chain_head( jnode_get_control( jnode ) )->next)) int IMFS_fsunmount( rtems_filesystem_mount_table_entry_t *temp_mt_entry ) { 10f808: 55 push %ebp 10f809: 89 e5 mov %esp,%ebp 10f80b: 57 push %edi 10f80c: 56 push %esi 10f80d: 53 push %ebx 10f80e: 83 ec 3c sub $0x3c,%esp 10f811: 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; 10f814: 8b 58 1c mov 0x1c(%eax),%ebx loc = temp_mt_entry->mt_fs_root; 10f817: 8d 55 d4 lea -0x2c(%ebp),%edx 10f81a: 89 55 c4 mov %edx,-0x3c(%ebp) 10f81d: 8d 70 1c lea 0x1c(%eax),%esi 10f820: b9 05 00 00 00 mov $0x5,%ecx 10f825: 89 d7 mov %edx,%edi 10f827: 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; 10f829: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax) do { next = jnode->Parent; 10f830: 8b 73 08 mov 0x8(%ebx),%esi loc.node_access = (void *)jnode; 10f833: 89 5d d4 mov %ebx,-0x2c(%ebp) IMFS_Set_handlers( &loc ); 10f836: 83 ec 0c sub $0xc,%esp 10f839: 8d 45 d4 lea -0x2c(%ebp),%eax 10f83c: 50 push %eax 10f83d: e8 76 f8 ff ff call 10f0b8 if ( jnode->type != IMFS_DIRECTORY ) { 10f842: 83 c4 10 add $0x10,%esp 10f845: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx) 10f849: 75 31 jne 10f87c RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 10f84b: 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 ) ) { 10f84e: 39 43 50 cmp %eax,0x50(%ebx) 10f851: 74 42 je 10f895 result = IMFS_unlink( NULL, &loc ); if (result != 0) return -1; jnode = next; } if ( jnode != NULL ) { 10f853: 85 db test %ebx,%ebx 10f855: 74 19 je 10f870 if ( jnode->type == IMFS_DIRECTORY ) { 10f857: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx) 10f85b: 75 d3 jne 10f830 <== NEVER TAKEN } } } while (jnode != NULL); return 0; } 10f85d: 8b 43 50 mov 0x50(%ebx),%eax 10f860: 8d 53 54 lea 0x54(%ebx),%edx return -1; jnode = next; } if ( jnode != NULL ) { if ( jnode->type == IMFS_DIRECTORY ) { if ( jnode_has_children( jnode ) ) 10f863: 39 d0 cmp %edx,%eax 10f865: 74 c9 je 10f830 jnode = jnode_get_first_child( jnode ); 10f867: 89 c3 mov %eax,%ebx } } } while (jnode != NULL); 10f869: 85 c0 test %eax,%eax 10f86b: 75 c3 jne 10f830 <== ALWAYS TAKEN 10f86d: 8d 76 00 lea 0x0(%esi),%esi return 0; 10f870: 31 c0 xor %eax,%eax } 10f872: 8d 65 f4 lea -0xc(%ebp),%esp 10f875: 5b pop %ebx 10f876: 5e pop %esi 10f877: 5f pop %edi 10f878: c9 leave 10f879: c3 ret 10f87a: 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 ); 10f87c: 83 ec 08 sub $0x8,%esp 10f87f: 8d 55 d4 lea -0x2c(%ebp),%edx 10f882: 52 push %edx if (result != 0) return -1; jnode = next; } else if ( jnode_has_no_children( jnode ) ) { result = IMFS_unlink( NULL, &loc ); 10f883: 6a 00 push $0x0 10f885: e8 72 83 ff ff call 107bfc if (result != 0) 10f88a: 83 c4 10 add $0x10,%esp 10f88d: 85 c0 test %eax,%eax 10f88f: 75 0d jne 10f89e <== NEVER TAKEN return -1; jnode = next; 10f891: 89 f3 mov %esi,%ebx 10f893: eb be jmp 10f853 result = IMFS_unlink( NULL, &loc ); if (result != 0) return -1; jnode = next; } else if ( jnode_has_no_children( jnode ) ) { result = IMFS_unlink( NULL, &loc ); 10f895: 83 ec 08 sub $0x8,%esp 10f898: 8d 45 d4 lea -0x2c(%ebp),%eax 10f89b: 50 push %eax 10f89c: eb e5 jmp 10f883 if (result != 0) return -1; 10f89e: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10f8a3: eb cd jmp 10f872 <== NOT EXECUTED =============================================================================== 0010f914 : const char *path, int pathlen, char *token, int *token_len ) { 10f914: 55 push %ebp 10f915: 89 e5 mov %esp,%ebp 10f917: 57 push %edi 10f918: 56 push %esi 10f919: 53 push %ebx 10f91a: 83 ec 1c sub $0x1c,%esp 10f91d: 8b 7d 08 mov 0x8(%ebp),%edi 10f920: 8b 5d 10 mov 0x10(%ebp),%ebx register char c; /* * Copy a name into token. (Remember NULL is a token.) */ c = path[i]; 10f923: 8a 17 mov (%edi),%dl int pathlen, char *token, int *token_len ) { register int i = 0; 10f925: 31 f6 xor %esi,%esi 10f927: 89 7d e4 mov %edi,-0x1c(%ebp) 10f92a: 89 df mov %ebx,%edi 10f92c: 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) ) { 10f92e: eb 07 jmp 10f937 return IMFS_INVALID_TOKEN; if ( !IMFS_is_valid_name_char(c) ) type = IMFS_INVALID_TOKEN; c = path [++i]; 10f930: 46 inc %esi 10f931: 8b 45 e4 mov -0x1c(%ebp),%eax 10f934: 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) ) { 10f937: 83 ec 0c sub $0xc,%esp 10f93a: 0f be c3 movsbl %bl,%eax 10f93d: 50 push %eax 10f93e: e8 d5 95 ff ff call 108f18 10f943: 83 c4 10 add $0x10,%esp 10f946: 85 c0 test %eax,%eax 10f948: 75 1a jne 10f964 10f94a: 3b 75 0c cmp 0xc(%ebp),%esi 10f94d: 7d 15 jge 10f964 token[i] = c; 10f94f: 88 1c 37 mov %bl,(%edi,%esi,1) if ( i == IMFS_NAME_MAX ) 10f952: 83 fe 20 cmp $0x20,%esi 10f955: 75 d9 jne 10f930 return IMFS_INVALID_TOKEN; 10f957: b8 04 00 00 00 mov $0x4,%eax else if ( strcmp( token, "." ) == 0 ) type = IMFS_CURRENT_DIR; } return type; } 10f95c: 8d 65 f4 lea -0xc(%ebp),%esp 10f95f: 5b pop %ebx 10f960: 5e pop %esi 10f961: 5f pop %edi 10f962: c9 leave 10f963: c3 ret 10f964: 88 da mov %bl,%dl 10f966: 89 fb mov %edi,%ebx /* * Copy a seperator into token. */ if ( i == 0 ) { 10f968: 85 f6 test %esi,%esi 10f96a: 75 25 jne 10f991 token[i] = c; 10f96c: 88 17 mov %dl,(%edi) if ( (token[i] != '\0') && pathlen ) { 10f96e: 84 d2 test %dl,%dl 10f970: 74 16 je 10f988 10f972: 8b 45 0c mov 0xc(%ebp),%eax 10f975: 85 c0 test %eax,%eax 10f977: 74 0f je 10f988 i++; type = IMFS_CURRENT_DIR; 10f979: b8 01 00 00 00 mov $0x1,%eax if ( i == 0 ) { token[i] = c; if ( (token[i] != '\0') && pathlen ) { i++; 10f97e: be 01 00 00 00 mov $0x1,%esi 10f983: eb 05 jmp 10f98a 10f985: 8d 76 00 lea 0x0(%esi),%esi type = IMFS_CURRENT_DIR; } else { type = IMFS_NO_MORE_PATH; 10f988: 31 c0 xor %eax,%eax /* * Set token_len to the number of characters copied. */ *token_len = i; 10f98a: 8b 55 14 mov 0x14(%ebp),%edx 10f98d: 89 32 mov %esi,(%edx) 10f98f: eb cb jmp 10f95c i++; type = IMFS_CURRENT_DIR; } else { type = IMFS_NO_MORE_PATH; } } else if (token[ i-1 ] != '\0') { 10f991: 80 7c 37 ff 00 cmpb $0x0,-0x1(%edi,%esi,1) 10f996: 74 04 je 10f99c <== NEVER TAKEN token[i] = '\0'; 10f998: c6 04 37 00 movb $0x0,(%edi,%esi,1) /* * Set token_len to the number of characters copied. */ *token_len = i; 10f99c: 8b 45 14 mov 0x14(%ebp),%eax 10f99f: 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 ) 10f9a1: bf f5 0f 12 00 mov $0x120ff5,%edi 10f9a6: b9 03 00 00 00 mov $0x3,%ecx 10f9ab: 89 de mov %ebx,%esi 10f9ad: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) 10f9af: 75 0f jne 10f9c0 type = IMFS_UP_DIR; 10f9b1: b8 02 00 00 00 mov $0x2,%eax else if ( strcmp( token, "." ) == 0 ) type = IMFS_CURRENT_DIR; } return type; } 10f9b6: 8d 65 f4 lea -0xc(%ebp),%esp 10f9b9: 5b pop %ebx 10f9ba: 5e pop %esi 10f9bb: 5f pop %edi 10f9bc: c9 leave 10f9bd: c3 ret 10f9be: 66 90 xchg %ax,%ax */ if ( type == IMFS_NAME ) { if ( strcmp( token, "..") == 0 ) type = IMFS_UP_DIR; else if ( strcmp( token, "." ) == 0 ) 10f9c0: bf f6 0f 12 00 mov $0x120ff6,%edi 10f9c5: b9 02 00 00 00 mov $0x2,%ecx 10f9ca: 89 de mov %ebx,%esi 10f9cc: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) 10f9ce: 0f 97 c0 seta %al 10f9d1: 0f 92 c2 setb %dl 10f9d4: 28 d0 sub %dl,%al 10f9d6: 0f be c0 movsbl %al,%eax 10f9d9: 83 f8 01 cmp $0x1,%eax 10f9dc: 19 c0 sbb %eax,%eax 10f9de: 83 e0 fe and $0xfffffffe,%eax 10f9e1: 83 c0 03 add $0x3,%eax type = IMFS_CURRENT_DIR; } return type; } 10f9e4: 8d 65 f4 lea -0xc(%ebp),%esp 10f9e7: 5b pop %ebx 10f9e8: 5e pop %esi 10f9e9: 5f pop %edi 10f9ea: c9 leave 10f9eb: 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 b0 31 12 00 mov 0x1231b0,%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 c0 70 12 00 mov %ecx,0x1270c0 /* * 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 ff 77 00 00 call 10f084 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 0f 12 00 mov $0x120fa0,%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 c4 70 12 00 mov 0x1270c4,%ecx 1078c7: 89 08 mov %ecx,(%eax) 1078c9: 41 inc %ecx 1078ca: 89 0d c4 70 12 00 mov %ecx,0x1270c4 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 0c ba 00 00 call 113314 <__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 c5 7f 00 00 call 10f914 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 e7 75 00 00 call 10ef4c 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 77 b9 00 00 call 113314 <__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 65 b9 00 00 call 113314 <__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 =============================================================================== 00111e6c : */ MEMFILE_STATIC int IMFS_memfile_addblock( IMFS_jnode_t *the_jnode, unsigned int block ) { 111e6c: 55 push %ebp 111e6d: 89 e5 mov %esp,%ebp 111e6f: 53 push %ebx 111e70: 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 ); 111e73: 6a 01 push $0x1 111e75: ff 75 0c pushl 0xc(%ebp) 111e78: ff 75 08 pushl 0x8(%ebp) 111e7b: e8 28 fc ff ff call 111aa8 111e80: 89 c3 mov %eax,%ebx if ( *block_entry_ptr ) 111e82: 83 c4 10 add $0x10,%esp 111e85: 8b 00 mov (%eax),%eax 111e87: 85 c0 test %eax,%eax 111e89: 74 09 je 111e94 return 0; 111e8b: 31 c0 xor %eax,%eax if ( !memory ) return 1; *block_entry_ptr = memory; return 0; } 111e8d: 8b 5d fc mov -0x4(%ebp),%ebx 111e90: c9 leave 111e91: c3 ret 111e92: 66 90 xchg %ax,%ax return 0; /* * There is no memory for this block number so allocate it. */ memory = memfile_alloc_block(); 111e94: e8 eb fb ff ff call 111a84 if ( !memory ) 111e99: 85 c0 test %eax,%eax 111e9b: 74 07 je 111ea4 return 1; *block_entry_ptr = memory; 111e9d: 89 03 mov %eax,(%ebx) return 0; 111e9f: 31 c0 xor %eax,%eax 111ea1: eb ea jmp 111e8d 111ea3: 90 nop /* * There is no memory for this block number so allocate it. */ memory = memfile_alloc_block(); if ( !memory ) return 1; 111ea4: b8 01 00 00 00 mov $0x1,%eax 111ea9: eb e2 jmp 111e8d =============================================================================== 001120ac : */ MEMFILE_STATIC int IMFS_memfile_extend( IMFS_jnode_t *the_jnode, off_t new_length ) { 1120ac: 55 push %ebp 1120ad: 89 e5 mov %esp,%ebp 1120af: 57 push %edi 1120b0: 56 push %esi 1120b1: 53 push %ebx 1120b2: 83 ec 2c sub $0x2c,%esp 1120b5: 8b 5d 08 mov 0x8(%ebp),%ebx 1120b8: 8b 45 0c mov 0xc(%ebp),%eax 1120bb: 8b 55 10 mov 0x10(%ebp),%edx 1120be: 89 45 d8 mov %eax,-0x28(%ebp) 1120c1: 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 ) 1120c4: a1 c0 70 12 00 mov 0x1270c0,%eax 1120c9: 89 c1 mov %eax,%ecx 1120cb: c1 e9 02 shr $0x2,%ecx 1120ce: 8d 51 01 lea 0x1(%ecx),%edx 1120d1: 0f af d1 imul %ecx,%edx 1120d4: 42 inc %edx 1120d5: 0f af d1 imul %ecx,%edx 1120d8: 4a dec %edx 1120d9: 0f af d0 imul %eax,%edx 1120dc: 31 c9 xor %ecx,%ecx 1120de: 3b 4d dc cmp -0x24(%ebp),%ecx 1120e1: 7f 1a jg 1120fd <== NEVER TAKEN 1120e3: 7d 13 jge 1120f8 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); 1120e5: e8 2a 12 00 00 call 113314 <__errno> 1120ea: c7 00 16 00 00 00 movl $0x16,(%eax) 1120f0: b8 ff ff ff ff mov $0xffffffff,%eax 1120f5: eb 19 jmp 112110 1120f7: 90 nop IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE ); /* * Verify new file size is supported */ if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE ) 1120f8: 3b 55 d8 cmp -0x28(%ebp),%edx 1120fb: 76 e8 jbe 1120e5 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 ) 1120fd: 8b 53 50 mov 0x50(%ebx),%edx 112100: 8b 4b 54 mov 0x54(%ebx),%ecx 112103: 89 55 e0 mov %edx,-0x20(%ebp) 112106: 89 4d e4 mov %ecx,-0x1c(%ebp) 112109: 39 4d dc cmp %ecx,-0x24(%ebp) 11210c: 7d 0a jge 112118 <== ALWAYS TAKEN return 0; 11210e: 31 c0 xor %eax,%eax /* * Set the new length of the file. */ the_jnode->info.file.size = new_length; return 0; } 112110: 8d 65 f4 lea -0xc(%ebp),%esp 112113: 5b pop %ebx 112114: 5e pop %esi 112115: 5f pop %edi 112116: c9 leave 112117: 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 ) 112118: 7f 05 jg 11211f <== NEVER TAKEN 11211a: 39 55 d8 cmp %edx,-0x28(%ebp) 11211d: 76 ef jbe 11210e return 0; /* * Calculate the number of range of blocks to allocate */ new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK; 11211f: 89 45 d0 mov %eax,-0x30(%ebp) 112122: 89 c1 mov %eax,%ecx 112124: c1 f9 1f sar $0x1f,%ecx 112127: 89 4d d4 mov %ecx,-0x2c(%ebp) 11212a: ff 75 d4 pushl -0x2c(%ebp) 11212d: ff 75 d0 pushl -0x30(%ebp) 112130: ff 75 dc pushl -0x24(%ebp) 112133: ff 75 d8 pushl -0x28(%ebp) 112136: e8 29 c1 00 00 call 11e264 <__divdi3> 11213b: 83 c4 10 add $0x10,%esp 11213e: 89 c6 mov %eax,%esi old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK; 112140: ff 75 d4 pushl -0x2c(%ebp) 112143: ff 75 d0 pushl -0x30(%ebp) 112146: ff 75 e4 pushl -0x1c(%ebp) 112149: ff 75 e0 pushl -0x20(%ebp) 11214c: e8 13 c1 00 00 call 11e264 <__divdi3> 112151: 83 c4 10 add $0x10,%esp 112154: 89 45 e0 mov %eax,-0x20(%ebp) /* * Now allocate each of those blocks. */ for ( block=old_blocks ; block<=new_blocks ; block++ ) { 112157: 39 c6 cmp %eax,%esi 112159: 72 51 jb 1121ac <== NEVER TAKEN 11215b: 89 c7 mov %eax,%edi 11215d: eb 06 jmp 112165 11215f: 90 nop 112160: 47 inc %edi 112161: 39 fe cmp %edi,%esi 112163: 72 47 jb 1121ac if ( IMFS_memfile_addblock( the_jnode, block ) ) { 112165: 83 ec 08 sub $0x8,%esp 112168: 57 push %edi 112169: 53 push %ebx 11216a: e8 fd fc ff ff call 111e6c 11216f: 83 c4 10 add $0x10,%esp 112172: 85 c0 test %eax,%eax 112174: 74 ea je 112160 for ( ; block>=old_blocks ; block-- ) { 112176: 39 7d e0 cmp %edi,-0x20(%ebp) 112179: 77 17 ja 112192 <== NEVER TAKEN 11217b: 8b 75 e0 mov -0x20(%ebp),%esi 11217e: 66 90 xchg %ax,%ax IMFS_memfile_remove_block( the_jnode, block ); 112180: 83 ec 08 sub $0x8,%esp 112183: 57 push %edi 112184: 53 push %ebx 112185: e8 f6 fe ff ff call 112080 /* * 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-- ) { 11218a: 4f dec %edi 11218b: 83 c4 10 add $0x10,%esp 11218e: 39 fe cmp %edi,%esi 112190: 76 ee jbe 112180 IMFS_memfile_remove_block( the_jnode, block ); } rtems_set_errno_and_return_minus_one( ENOSPC ); 112192: e8 7d 11 00 00 call 113314 <__errno> 112197: c7 00 1c 00 00 00 movl $0x1c,(%eax) 11219d: b8 ff ff ff ff mov $0xffffffff,%eax /* * Set the new length of the file. */ the_jnode->info.file.size = new_length; return 0; } 1121a2: 8d 65 f4 lea -0xc(%ebp),%esp 1121a5: 5b pop %ebx 1121a6: 5e pop %esi 1121a7: 5f pop %edi 1121a8: c9 leave 1121a9: c3 ret 1121aa: 66 90 xchg %ax,%ax } /* * Set the new length of the file. */ the_jnode->info.file.size = new_length; 1121ac: 8b 45 d8 mov -0x28(%ebp),%eax 1121af: 8b 55 dc mov -0x24(%ebp),%edx 1121b2: 89 43 50 mov %eax,0x50(%ebx) 1121b5: 89 53 54 mov %edx,0x54(%ebx) return 0; 1121b8: 31 c0 xor %eax,%eax } 1121ba: 8d 65 f4 lea -0xc(%ebp),%esp 1121bd: 5b pop %ebx 1121be: 5e pop %esi 1121bf: 5f pop %edi 1121c0: c9 leave 1121c1: c3 ret =============================================================================== 00111aa8 : #endif IMFS_jnode_t *the_jnode, unsigned int block, int malloc_it ) { 111aa8: 55 push %ebp 111aa9: 89 e5 mov %esp,%ebp 111aab: 57 push %edi 111aac: 56 push %esi 111aad: 53 push %ebx 111aae: 83 ec 1c sub $0x1c,%esp 111ab1: 8b 5d 08 mov 0x8(%ebp),%ebx 111ab4: 8b 75 0c mov 0xc(%ebp),%esi 111ab7: 8b 7d 10 mov 0x10(%ebp),%edi my_block = block; /* * Is the block number in the simple indirect portion? */ if ( my_block <= LAST_INDIRECT ) { 111aba: 8b 0d c0 70 12 00 mov 0x1270c0,%ecx 111ac0: c1 e9 02 shr $0x2,%ecx 111ac3: 8d 41 ff lea -0x1(%ecx),%eax 111ac6: 39 c6 cmp %eax,%esi 111ac8: 77 1a ja 111ae4 p = info->indirect; 111aca: 8b 43 58 mov 0x58(%ebx),%eax if ( malloc_it ) { 111acd: 85 ff test %edi,%edi 111acf: 74 53 je 111b24 if ( !p ) { 111ad1: 85 c0 test %eax,%eax 111ad3: 0f 84 b6 00 00 00 je 111b8f } if ( !p ) return 0; return &info->indirect[ my_block ]; 111ad9: 8d 04 b0 lea (%eax,%esi,4),%eax /* * This means the requested block number is out of range. */ return 0; } 111adc: 83 c4 1c add $0x1c,%esp 111adf: 5b pop %ebx 111ae0: 5e pop %esi 111ae1: 5f pop %edi 111ae2: c9 leave 111ae3: c3 ret /* * Is the block number in the doubly indirect portion? */ if ( my_block <= LAST_DOUBLY_INDIRECT ) { 111ae4: 8d 41 01 lea 0x1(%ecx),%eax 111ae7: 0f af c1 imul %ecx,%eax 111aea: 8d 50 ff lea -0x1(%eax),%edx 111aed: 39 d6 cmp %edx,%esi 111aef: 77 3b ja 111b2c my_block -= FIRST_DOUBLY_INDIRECT; 111af1: 29 ce sub %ecx,%esi singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS; 111af3: 89 f0 mov %esi,%eax 111af5: 31 d2 xor %edx,%edx 111af7: f7 f1 div %ecx 111af9: 89 c6 mov %eax,%esi doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS; p = info->doubly_indirect; 111afb: 8b 43 5c mov 0x5c(%ebx),%eax if ( malloc_it ) { 111afe: 85 ff test %edi,%edi 111b00: 74 7e je 111b80 if ( !p ) { 111b02: 85 c0 test %eax,%eax 111b04: 0f 84 96 00 00 00 je 111ba0 if ( !p ) return 0; info->doubly_indirect = p; } p1 = (block_p *)p[ doubly ]; 111b0a: 8d 1c b0 lea (%eax,%esi,4),%ebx 111b0d: 8b 03 mov (%ebx),%eax if ( !p1 ) { 111b0f: 85 c0 test %eax,%eax 111b11: 0f 84 a4 00 00 00 je 111bbb p = (block_p *)p[ doubly ]; if ( !p ) return 0; return (block_p *)&p[ singly ]; 111b17: 8d 04 90 lea (%eax,%edx,4),%eax /* * This means the requested block number is out of range. */ return 0; } 111b1a: 83 c4 1c add $0x1c,%esp 111b1d: 5b pop %ebx 111b1e: 5e pop %esi 111b1f: 5f pop %edi 111b20: c9 leave 111b21: c3 ret 111b22: 66 90 xchg %ax,%ax info->indirect = p; } return &info->indirect[ my_block ]; } if ( !p ) 111b24: 85 c0 test %eax,%eax 111b26: 75 b1 jne 111ad9 <== ALWAYS TAKEN if ( !p ) return 0; p1 = (block_p *) p[ triply ]; if ( !p1 ) return 0; 111b28: 31 c0 xor %eax,%eax 111b2a: eb ee jmp 111b1a <== NOT EXECUTED } /* * Is the block number in the triply indirect portion? */ if ( my_block <= LAST_TRIPLY_INDIRECT ) { 111b2c: 8d 50 01 lea 0x1(%eax),%edx 111b2f: 0f af d1 imul %ecx,%edx 111b32: 4a dec %edx 111b33: 39 d6 cmp %edx,%esi 111b35: 77 f1 ja 111b28 <== NEVER TAKEN my_block -= FIRST_TRIPLY_INDIRECT; 111b37: 29 c6 sub %eax,%esi 111b39: 89 f0 mov %esi,%eax singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS; 111b3b: 31 d2 xor %edx,%edx 111b3d: f7 f1 div %ecx 111b3f: 89 55 e4 mov %edx,-0x1c(%ebp) doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS; triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS; 111b42: 31 d2 xor %edx,%edx 111b44: f7 f1 div %ecx 111b46: 89 c6 mov %eax,%esi doubly %= IMFS_MEMFILE_BLOCK_SLOTS; p = info->triply_indirect; 111b48: 8b 4b 60 mov 0x60(%ebx),%ecx if ( malloc_it ) { 111b4b: 85 ff test %edi,%edi 111b4d: 0f 84 82 00 00 00 je 111bd5 if ( !p ) { 111b53: 85 c9 test %ecx,%ecx 111b55: 0f 84 9b 00 00 00 je 111bf6 if ( !p ) return 0; info->triply_indirect = p; } p1 = (block_p *) p[ triply ]; 111b5b: 8d 1c b1 lea (%ecx,%esi,4),%ebx 111b5e: 8b 0b mov (%ebx),%ecx if ( !p1 ) { 111b60: 85 c9 test %ecx,%ecx 111b62: 0f 84 c5 00 00 00 je 111c2d if ( !p1 ) return 0; p[ triply ] = (block_p) p1; } p2 = (block_p *)p1[ doubly ]; 111b68: 8d 1c 91 lea (%ecx,%edx,4),%ebx 111b6b: 8b 13 mov (%ebx),%edx if ( !p2 ) { 111b6d: 85 d2 test %edx,%edx 111b6f: 0f 84 a0 00 00 00 je 111c15 p2 = (block_p *)p1[ doubly ]; if ( !p2 ) return 0; return (block_p *)&p2[ singly ]; 111b75: 8b 4d e4 mov -0x1c(%ebp),%ecx 111b78: 8d 04 8a lea (%edx,%ecx,4),%eax 111b7b: eb 9d jmp 111b1a 111b7d: 8d 76 00 lea 0x0(%esi),%esi } return (block_p *)&p1[ singly ]; } if ( !p ) 111b80: 85 c0 test %eax,%eax 111b82: 74 a4 je 111b28 <== NEVER TAKEN return 0; p = (block_p *)p[ doubly ]; 111b84: 8b 04 b0 mov (%eax,%esi,4),%eax if ( !p ) 111b87: 85 c0 test %eax,%eax 111b89: 75 8c jne 111b17 <== ALWAYS TAKEN if ( !p ) return 0; p1 = (block_p *) p[ triply ]; if ( !p1 ) return 0; 111b8b: 31 c0 xor %eax,%eax 111b8d: eb 8b jmp 111b1a <== NOT EXECUTED p = info->indirect; if ( malloc_it ) { if ( !p ) { p = memfile_alloc_block(); 111b8f: e8 f0 fe ff ff call 111a84 if ( !p ) 111b94: 85 c0 test %eax,%eax 111b96: 74 90 je 111b28 <== NEVER TAKEN return 0; info->indirect = p; 111b98: 89 43 58 mov %eax,0x58(%ebx) 111b9b: e9 39 ff ff ff jmp 111ad9 p = info->doubly_indirect; if ( malloc_it ) { if ( !p ) { p = memfile_alloc_block(); 111ba0: 89 55 e0 mov %edx,-0x20(%ebp) 111ba3: e8 dc fe ff ff call 111a84 if ( !p ) 111ba8: 85 c0 test %eax,%eax 111baa: 8b 55 e0 mov -0x20(%ebp),%edx 111bad: 0f 84 75 ff ff ff je 111b28 <== NEVER TAKEN return 0; info->doubly_indirect = p; 111bb3: 89 43 5c mov %eax,0x5c(%ebx) 111bb6: e9 4f ff ff ff jmp 111b0a } p1 = (block_p *)p[ doubly ]; if ( !p1 ) { p1 = memfile_alloc_block(); 111bbb: 89 55 e0 mov %edx,-0x20(%ebp) 111bbe: e8 c1 fe ff ff call 111a84 if ( !p1 ) 111bc3: 85 c0 test %eax,%eax 111bc5: 8b 55 e0 mov -0x20(%ebp),%edx 111bc8: 0f 84 5a ff ff ff je 111b28 <== NEVER TAKEN return 0; p[ doubly ] = (block_p) p1; 111bce: 89 03 mov %eax,(%ebx) 111bd0: e9 42 ff ff ff jmp 111b17 p1[ doubly ] = (block_p) p2; } return (block_p *)&p2[ singly ]; } if ( !p ) 111bd5: 85 c9 test %ecx,%ecx 111bd7: 0f 84 4b ff ff ff je 111b28 <== NEVER TAKEN return 0; p1 = (block_p *) p[ triply ]; 111bdd: 8b 04 81 mov (%ecx,%eax,4),%eax if ( !p1 ) 111be0: 85 c0 test %eax,%eax 111be2: 0f 84 40 ff ff ff je 111b28 <== NEVER TAKEN return 0; p2 = (block_p *)p1[ doubly ]; 111be8: 8b 14 90 mov (%eax,%edx,4),%edx if ( !p2 ) return 0; 111beb: 31 c0 xor %eax,%eax p1 = (block_p *) p[ triply ]; if ( !p1 ) return 0; p2 = (block_p *)p1[ doubly ]; if ( !p2 ) 111bed: 85 d2 test %edx,%edx 111bef: 75 84 jne 111b75 <== ALWAYS TAKEN 111bf1: e9 24 ff ff ff jmp 111b1a <== NOT EXECUTED p = info->triply_indirect; if ( malloc_it ) { if ( !p ) { p = memfile_alloc_block(); 111bf6: 89 55 e0 mov %edx,-0x20(%ebp) 111bf9: e8 86 fe ff ff call 111a84 111bfe: 89 c1 mov %eax,%ecx if ( !p ) return 0; 111c00: 31 c0 xor %eax,%eax p = info->triply_indirect; if ( malloc_it ) { if ( !p ) { p = memfile_alloc_block(); if ( !p ) 111c02: 85 c9 test %ecx,%ecx 111c04: 8b 55 e0 mov -0x20(%ebp),%edx 111c07: 0f 84 0d ff ff ff je 111b1a <== NEVER TAKEN return 0; info->triply_indirect = p; 111c0d: 89 4b 60 mov %ecx,0x60(%ebx) 111c10: e9 46 ff ff ff jmp 111b5b p[ triply ] = (block_p) p1; } p2 = (block_p *)p1[ doubly ]; if ( !p2 ) { p2 = memfile_alloc_block(); 111c15: e8 6a fe ff ff call 111a84 111c1a: 89 c2 mov %eax,%edx if ( !p2 ) return 0; 111c1c: 31 c0 xor %eax,%eax } p2 = (block_p *)p1[ doubly ]; if ( !p2 ) { p2 = memfile_alloc_block(); if ( !p2 ) 111c1e: 85 d2 test %edx,%edx 111c20: 0f 84 f4 fe ff ff je 111b1a <== NEVER TAKEN return 0; p1[ doubly ] = (block_p) p2; 111c26: 89 13 mov %edx,(%ebx) 111c28: e9 48 ff ff ff jmp 111b75 info->triply_indirect = p; } p1 = (block_p *) p[ triply ]; if ( !p1 ) { p1 = memfile_alloc_block(); 111c2d: 89 55 e0 mov %edx,-0x20(%ebp) 111c30: e8 4f fe ff ff call 111a84 111c35: 89 c1 mov %eax,%ecx if ( !p1 ) return 0; 111c37: 31 c0 xor %eax,%eax } p1 = (block_p *) p[ triply ]; if ( !p1 ) { p1 = memfile_alloc_block(); if ( !p1 ) 111c39: 85 c9 test %ecx,%ecx 111c3b: 8b 55 e0 mov -0x20(%ebp),%edx 111c3e: 0f 84 d6 fe ff ff je 111b1a <== NEVER TAKEN return 0; p[ triply ] = (block_p) p1; 111c44: 89 0b mov %ecx,(%ebx) 111c46: e9 1d ff ff ff jmp 111b68 =============================================================================== 00111c4c : IMFS_jnode_t *the_jnode, off_t start, unsigned char *destination, unsigned int length ) { 111c4c: 55 push %ebp 111c4d: 89 e5 mov %esp,%ebp 111c4f: 57 push %edi 111c50: 56 push %esi 111c51: 53 push %ebx 111c52: 83 ec 3c sub $0x3c,%esp 111c55: 8b 75 0c mov 0xc(%ebp),%esi 111c58: 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) { 111c5b: 8b 45 08 mov 0x8(%ebp),%eax 111c5e: 83 78 4c 06 cmpl $0x6,0x4c(%eax) 111c62: 0f 84 60 01 00 00 je 111dc8 /* * 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; 111c68: 89 f0 mov %esi,%eax if ( last_byte > the_jnode->info.file.size ) 111c6a: 8b 55 08 mov 0x8(%ebp),%edx 111c6d: 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; 111c70: 8b 5d 18 mov 0x18(%ebp),%ebx 111c73: 01 f3 add %esi,%ebx 111c75: 89 5d d0 mov %ebx,-0x30(%ebp) if ( last_byte > the_jnode->info.file.size ) 111c78: 31 d2 xor %edx,%edx 111c7a: 8b 5d 08 mov 0x8(%ebp),%ebx 111c7d: 3b 53 54 cmp 0x54(%ebx),%edx 111c80: 0f 8d d2 00 00 00 jge 111d58 <== ALWAYS TAKEN /* * Linear files (as created from a tar file are easier to handle * than block files). */ my_length = length; 111c86: 8b 45 18 mov 0x18(%ebp),%eax 111c89: 89 45 cc mov %eax,-0x34(%ebp) */ /* * Phase 1: possibly the last part of one block */ start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK; 111c8c: 8b 15 c0 70 12 00 mov 0x1270c0,%edx 111c92: 89 55 d0 mov %edx,-0x30(%ebp) 111c95: 89 d0 mov %edx,%eax 111c97: 99 cltd 111c98: 89 d3 mov %edx,%ebx 111c9a: 52 push %edx 111c9b: 50 push %eax 111c9c: 57 push %edi 111c9d: 56 push %esi 111c9e: 89 45 c0 mov %eax,-0x40(%ebp) 111ca1: e8 0a c7 00 00 call 11e3b0 <__moddi3> 111ca6: 83 c4 10 add $0x10,%esp 111ca9: 89 45 c8 mov %eax,-0x38(%ebp) block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; 111cac: 8b 4d c0 mov -0x40(%ebp),%ecx 111caf: 53 push %ebx 111cb0: 51 push %ecx 111cb1: 57 push %edi 111cb2: 56 push %esi 111cb3: e8 ac c5 00 00 call 11e264 <__divdi3> 111cb8: 83 c4 10 add $0x10,%esp 111cbb: 89 c3 mov %eax,%ebx if ( start_offset ) { 111cbd: 8b 7d c8 mov -0x38(%ebp),%edi 111cc0: 85 ff test %edi,%edi 111cc2: 0f 84 a0 00 00 00 je 111d68 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 ); 111cc8: 56 push %esi 111cc9: 6a 00 push $0x0 111ccb: 50 push %eax 111ccc: ff 75 08 pushl 0x8(%ebp) 111ccf: e8 d4 fd ff ff call 111aa8 if ( !block_ptr ) 111cd4: 83 c4 10 add $0x10,%esp 111cd7: 85 c0 test %eax,%eax 111cd9: 0f 84 65 01 00 00 je 111e44 <== 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; 111cdf: 8b 4d d0 mov -0x30(%ebp),%ecx 111ce2: 2b 4d c8 sub -0x38(%ebp),%ecx 111ce5: 8b 55 cc mov -0x34(%ebp),%edx 111ce8: 39 ca cmp %ecx,%edx 111cea: 0f 87 3c 01 00 00 ja 111e2c 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 ); 111cf0: 8b 75 c8 mov -0x38(%ebp),%esi 111cf3: 03 30 add (%eax),%esi dest += to_copy; 111cf5: 8b 7d 14 mov 0x14(%ebp),%edi 111cf8: 89 d1 mov %edx,%ecx 111cfa: f3 a4 rep movsb %ds:(%esi),%es:(%edi) 111cfc: 89 7d c8 mov %edi,-0x38(%ebp) block++; 111cff: 43 inc %ebx my_length -= to_copy; 111d00: 29 55 cc sub %edx,-0x34(%ebp) 111d03: a1 c0 70 12 00 mov 0x1270c0,%eax 111d08: 89 45 d0 mov %eax,-0x30(%ebp) copied += to_copy; 111d0b: 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 ) { 111d0e: 8b 4d d0 mov -0x30(%ebp),%ecx 111d11: 39 4d cc cmp %ecx,-0x34(%ebp) 111d14: 73 24 jae 111d3a 111d16: eb 60 jmp 111d78 block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); if ( !block_ptr ) return copied; memcpy( dest, &(*block_ptr)[ 0 ], to_copy ); 111d18: 8b 30 mov (%eax),%esi 111d1a: 8b 7d c8 mov -0x38(%ebp),%edi 111d1d: 8b 4d d0 mov -0x30(%ebp),%ecx 111d20: f3 a4 rep movsb %ds:(%esi),%es:(%edi) dest += to_copy; 111d22: 89 7d c8 mov %edi,-0x38(%ebp) block++; 111d25: 43 inc %ebx my_length -= to_copy; 111d26: 8b 7d d0 mov -0x30(%ebp),%edi 111d29: 29 7d cc sub %edi,-0x34(%ebp) copied += to_copy; 111d2c: 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 ) { 111d2f: 8b 45 cc mov -0x34(%ebp),%eax 111d32: 39 05 c0 70 12 00 cmp %eax,0x1270c0 111d38: 77 3e ja 111d78 block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 111d3a: 51 push %ecx 111d3b: 6a 00 push $0x0 111d3d: 53 push %ebx 111d3e: ff 75 08 pushl 0x8(%ebp) 111d41: e8 62 fd ff ff call 111aa8 if ( !block_ptr ) 111d46: 83 c4 10 add $0x10,%esp 111d49: 85 c0 test %eax,%eax 111d4b: 75 cb jne 111d18 <== 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; 111d4d: 8b 45 c4 mov -0x3c(%ebp),%eax <== NOT EXECUTED } IMFS_update_atime( the_jnode ); return copied; } 111d50: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 111d53: 5b pop %ebx <== NOT EXECUTED 111d54: 5e pop %esi <== NOT EXECUTED 111d55: 5f pop %edi <== NOT EXECUTED 111d56: c9 leave <== NOT EXECUTED 111d57: 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 ) 111d58: 0f 8e be 00 00 00 jle 111e1c <== ALWAYS TAKEN my_length = the_jnode->info.file.size - start; 111d5e: 29 c1 sub %eax,%ecx 111d60: 89 4d cc mov %ecx,-0x34(%ebp) 111d63: e9 24 ff ff ff jmp 111c8c unsigned int last_byte; unsigned int copied; unsigned int start_offset; unsigned char *dest; dest = destination; 111d68: 8b 55 14 mov 0x14(%ebp),%edx 111d6b: 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; 111d6e: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp) 111d75: eb 97 jmp 111d0e 111d77: 90 nop /* * Phase 3: possibly the first part of one block */ IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK ); if ( my_length ) { 111d78: 8b 55 cc mov -0x34(%ebp),%edx 111d7b: 85 d2 test %edx,%edx 111d7d: 74 23 je 111da2 block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 111d7f: 50 push %eax 111d80: 6a 00 push $0x0 111d82: 53 push %ebx 111d83: ff 75 08 pushl 0x8(%ebp) 111d86: e8 1d fd ff ff call 111aa8 if ( !block_ptr ) 111d8b: 83 c4 10 add $0x10,%esp 111d8e: 85 c0 test %eax,%eax 111d90: 74 bb je 111d4d <== NEVER TAKEN return copied; memcpy( dest, &(*block_ptr)[ 0 ], my_length ); 111d92: 8b 30 mov (%eax),%esi 111d94: 8b 7d c8 mov -0x38(%ebp),%edi 111d97: 8b 4d cc mov -0x34(%ebp),%ecx 111d9a: f3 a4 rep movsb %ds:(%esi),%es:(%edi) copied += my_length; 111d9c: 8b 55 cc mov -0x34(%ebp),%edx 111d9f: 01 55 c4 add %edx,-0x3c(%ebp) } IMFS_update_atime( the_jnode ); 111da2: 83 ec 08 sub $0x8,%esp 111da5: 6a 00 push $0x0 111da7: 8d 45 e0 lea -0x20(%ebp),%eax 111daa: 50 push %eax 111dab: e8 80 63 ff ff call 108130 111db0: 8b 45 e0 mov -0x20(%ebp),%eax 111db3: 8b 4d 08 mov 0x8(%ebp),%ecx 111db6: 89 41 40 mov %eax,0x40(%ecx) return copied; 111db9: 8b 45 c4 mov -0x3c(%ebp),%eax 111dbc: 83 c4 10 add $0x10,%esp } 111dbf: 8d 65 f4 lea -0xc(%ebp),%esp 111dc2: 5b pop %ebx 111dc3: 5e pop %esi 111dc4: 5f pop %edi 111dc5: c9 leave 111dc6: c3 ret 111dc7: 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; 111dc8: 8b 50 58 mov 0x58(%eax),%edx 111dcb: 89 55 cc mov %edx,-0x34(%ebp) if (my_length > (the_jnode->info.linearfile.size - start)) 111dce: 89 c1 mov %eax,%ecx 111dd0: 8b 40 50 mov 0x50(%eax),%eax 111dd3: 8b 51 54 mov 0x54(%ecx),%edx 111dd6: 89 c1 mov %eax,%ecx 111dd8: 89 d3 mov %edx,%ebx 111dda: 29 f1 sub %esi,%ecx 111ddc: 19 fb sbb %edi,%ebx 111dde: 89 4d d0 mov %ecx,-0x30(%ebp) 111de1: 89 5d d4 mov %ebx,-0x2c(%ebp) 111de4: 31 c9 xor %ecx,%ecx 111de6: 39 d9 cmp %ebx,%ecx 111de8: 7d 4a jge 111e34 <== ALWAYS TAKEN /* * Linear files (as created from a tar file are easier to handle * than block files). */ my_length = length; 111dea: 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); 111ded: 03 75 cc add -0x34(%ebp),%esi 111df0: 8b 7d 14 mov 0x14(%ebp),%edi 111df3: 89 d9 mov %ebx,%ecx 111df5: f3 a4 rep movsb %ds:(%esi),%es:(%edi) IMFS_update_atime( the_jnode ); 111df7: 83 ec 08 sub $0x8,%esp 111dfa: 6a 00 push $0x0 111dfc: 8d 45 e0 lea -0x20(%ebp),%eax 111dff: 50 push %eax 111e00: e8 2b 63 ff ff call 108130 111e05: 8b 45 e0 mov -0x20(%ebp),%eax 111e08: 8b 7d 08 mov 0x8(%ebp),%edi 111e0b: 89 47 40 mov %eax,0x40(%edi) return my_length; 111e0e: 89 d8 mov %ebx,%eax 111e10: 83 c4 10 add $0x10,%esp } IMFS_update_atime( the_jnode ); return copied; } 111e13: 8d 65 f4 lea -0xc(%ebp),%esp 111e16: 5b pop %ebx 111e17: 5e pop %esi 111e18: 5f pop %edi 111e19: c9 leave 111e1a: c3 ret 111e1b: 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 ) 111e1c: 39 4d d0 cmp %ecx,-0x30(%ebp) 111e1f: 0f 86 61 fe ff ff jbe 111c86 111e25: e9 34 ff ff ff jmp 111d5e 111e2a: 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; 111e2c: 89 ca mov %ecx,%edx 111e2e: e9 bd fe ff ff jmp 111cf0 111e33: 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)) 111e34: 7f 08 jg 111e3e <== NEVER TAKEN 111e36: 8b 5d d0 mov -0x30(%ebp),%ebx 111e39: 39 5d 18 cmp %ebx,0x18(%ebp) 111e3c: 76 ac jbe 111dea <== NEVER TAKEN my_length = the_jnode->info.linearfile.size - start; 111e3e: 89 c3 mov %eax,%ebx 111e40: 29 f3 sub %esi,%ebx 111e42: eb a9 jmp 111ded 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; 111e44: 31 c0 xor %eax,%eax 111e46: e9 05 ff ff ff jmp 111d50 <== NOT EXECUTED =============================================================================== 00111f24 : * is better to stick to simple, easy to understand algorithms. */ int IMFS_memfile_remove( IMFS_jnode_t *the_jnode ) { 111f24: 55 push %ebp 111f25: 89 e5 mov %esp,%ebp 111f27: 57 push %edi 111f28: 56 push %esi 111f29: 53 push %ebx 111f2a: 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; 111f2d: 8b 3d c0 70 12 00 mov 0x1270c0,%edi 111f33: c1 ef 02 shr $0x2,%edi * + doubly indirect * + triply indirect */ info = &the_jnode->info.file; if ( info->indirect ) { 111f36: 8b 45 08 mov 0x8(%ebp),%eax 111f39: 8b 50 58 mov 0x58(%eax),%edx 111f3c: 85 d2 test %edx,%edx 111f3e: 74 10 je 111f50 memfile_free_blocks_in_table( &info->indirect, to_free ); 111f40: 83 ec 08 sub $0x8,%esp 111f43: 57 push %edi 111f44: 83 c0 58 add $0x58,%eax 111f47: 50 push %eax 111f48: e8 7b ff ff ff call 111ec8 111f4d: 83 c4 10 add $0x10,%esp } if ( info->doubly_indirect ) { 111f50: 8b 4d 08 mov 0x8(%ebp),%ecx 111f53: 8b 51 5c mov 0x5c(%ecx),%edx 111f56: 85 d2 test %edx,%edx 111f58: 74 55 je 111faf for ( i=0 ; i<== NEVER TAKEN 111f66: 31 c9 xor %ecx,%ecx 111f68: 31 db xor %ebx,%ebx 111f6a: 8b 75 08 mov 0x8(%ebp),%esi 111f6d: eb 04 jmp 111f73 111f6f: 90 nop 111f70: 8b 56 5c mov 0x5c(%esi),%edx if ( info->doubly_indirect[i] ) { 111f73: c1 e1 02 shl $0x2,%ecx 111f76: 83 3c 0a 00 cmpl $0x0,(%edx,%ecx,1) 111f7a: 74 14 je 111f90 <== NEVER TAKEN memfile_free_blocks_in_table( 111f7c: 83 ec 08 sub $0x8,%esp 111f7f: 57 push %edi 111f80: 01 ca add %ecx,%edx 111f82: 52 push %edx 111f83: e8 40 ff ff ff call 111ec8 111f88: 83 c4 10 add $0x10,%esp 111f8b: a1 c0 70 12 00 mov 0x1270c0,%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 ); 111f9c: 83 ec 08 sub $0x8,%esp 111f9f: 57 push %edi 111fa0: 8b 45 08 mov 0x8(%ebp),%eax 111fa3: 83 c0 5c add $0x5c,%eax 111fa6: 50 push %eax 111fa7: e8 1c ff ff ff call 111ec8 111fac: 83 c4 10 add $0x10,%esp } if ( info->triply_indirect ) { 111faf: 8b 45 08 mov 0x8(%ebp),%eax 111fb2: 8b 50 60 mov 0x60(%eax),%edx 111fb5: 85 d2 test %edx,%edx 111fb7: 0f 84 b6 00 00 00 je 112073 for ( i=0 ; i<== NEVER TAKEN p = (block_p *) info->triply_indirect[i]; 111fcd: 8b 32 mov (%edx),%esi if ( !p ) /* ensure we have a valid pointer */ 111fcf: 85 f6 test %esi,%esi 111fd1: 0f 84 89 00 00 00 je 112060 <== NEVER TAKEN } if ( info->triply_indirect ) { for ( i=0 ; itriply_indirect[i]; 111fd7: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) if ( !p ) /* ensure we have a valid pointer */ 111fde: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) 111fe5: 8d 76 00 lea 0x0(%esi),%esi break; for ( j=0 ; j<== NEVER TAKEN 111fef: 31 d2 xor %edx,%edx 111ff1: 31 db xor %ebx,%ebx 111ff3: 90 nop if ( p[j] ) { 111ff4: c1 e2 02 shl $0x2,%edx 111ff7: 8b 0c 16 mov (%esi,%edx,1),%ecx 111ffa: 85 c9 test %ecx,%ecx 111ffc: 74 15 je 112013 <== NEVER TAKEN memfile_free_blocks_in_table( (block_p **)&p[j], to_free); 111ffe: 83 ec 08 sub $0x8,%esp 112001: 57 push %edi 112002: 8d 14 16 lea (%esi,%edx,1),%edx 112005: 52 push %edx 112006: e8 bd fe ff ff call 111ec8 11200b: 83 c4 10 add $0x10,%esp 11200e: a1 c0 70 12 00 mov 0x1270c0,%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( 11201f: 83 ec 08 sub $0x8,%esp 112022: 57 push %edi 112023: 8b 45 e0 mov -0x20(%ebp),%eax 112026: 8b 4d 08 mov 0x8(%ebp),%ecx 112029: 03 41 60 add 0x60(%ecx),%eax 11202c: 50 push %eax 11202d: e8 96 fe ff ff call 111ec8 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 */ 112047: 8b 55 e4 mov -0x1c(%ebp),%edx 11204a: c1 e2 02 shl $0x2,%edx 11204d: 89 55 e0 mov %edx,-0x20(%ebp) } if ( info->triply_indirect ) { for ( i=0 ; itriply_indirect[i]; 112050: 8b 4d 08 mov 0x8(%ebp),%ecx 112053: 8b 51 60 mov 0x60(%ecx),%edx 112056: 8b 4d e0 mov -0x20(%ebp),%ecx 112059: 8b 34 0a mov (%edx,%ecx,1),%esi if ( !p ) /* ensure we have a valid pointer */ 11205c: 85 f6 test %esi,%esi 11205e: 75 88 jne 111fe8 <== ALWAYS TAKEN } } memfile_free_blocks_in_table( (block_p **)&info->triply_indirect[i], to_free ); } memfile_free_blocks_in_table( 112060: 83 ec 08 sub $0x8,%esp 112063: 57 push %edi (block_p **)&info->triply_indirect, to_free ); 112064: 8b 45 08 mov 0x8(%ebp),%eax 112067: 83 c0 60 add $0x60,%eax } } memfile_free_blocks_in_table( (block_p **)&info->triply_indirect[i], to_free ); } memfile_free_blocks_in_table( 11206a: 50 push %eax 11206b: e8 58 fe ff ff call 111ec8 112070: 83 c4 10 add $0x10,%esp (block_p **)&info->triply_indirect, to_free ); } return 0; } 112073: 31 c0 xor %eax,%eax 112075: 8d 65 f4 lea -0xc(%ebp),%esp 112078: 5b pop %ebx 112079: 5e pop %esi 11207a: 5f pop %edi 11207b: c9 leave 11207c: c3 ret =============================================================================== 001121c4 : IMFS_jnode_t *the_jnode, off_t start, const unsigned char *source, unsigned int length ) { 1121c4: 55 push %ebp 1121c5: 89 e5 mov %esp,%ebp 1121c7: 57 push %edi 1121c8: 56 push %esi 1121c9: 53 push %ebx 1121ca: 83 ec 3c sub $0x3c,%esp 1121cd: 8b 5d 0c mov 0xc(%ebp),%ebx 1121d0: 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; 1121d3: 8b 4d 18 mov 0x18(%ebp),%ecx 1121d6: 01 d9 add %ebx,%ecx if ( last_byte > the_jnode->info.file.size ) { 1121d8: 89 c8 mov %ecx,%eax 1121da: 31 d2 xor %edx,%edx 1121dc: 8b 7d 08 mov 0x8(%ebp),%edi 1121df: 3b 57 54 cmp 0x54(%edi),%edx 1121e2: 7c 1c jl 112200 <== NEVER TAKEN 1121e4: 0f 8e f2 00 00 00 jle 1122dc <== ALWAYS TAKEN status = IMFS_memfile_extend( the_jnode, last_byte ); 1121ea: 51 push %ecx 1121eb: 52 push %edx 1121ec: 50 push %eax 1121ed: ff 75 08 pushl 0x8(%ebp) 1121f0: e8 b7 fe ff ff call 1120ac if ( status ) 1121f5: 83 c4 10 add $0x10,%esp 1121f8: 85 c0 test %eax,%eax 1121fa: 0f 85 52 01 00 00 jne 112352 */ /* * Phase 1: possibly the last part of one block */ start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK; 112200: a1 c0 70 12 00 mov 0x1270c0,%eax 112205: 89 45 d4 mov %eax,-0x2c(%ebp) 112208: 99 cltd 112209: 89 45 c8 mov %eax,-0x38(%ebp) 11220c: 89 55 cc mov %edx,-0x34(%ebp) 11220f: 52 push %edx 112210: 50 push %eax 112211: 56 push %esi 112212: 53 push %ebx 112213: e8 98 c1 00 00 call 11e3b0 <__moddi3> 112218: 83 c4 10 add $0x10,%esp 11221b: 89 c7 mov %eax,%edi block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; 11221d: ff 75 cc pushl -0x34(%ebp) 112220: ff 75 c8 pushl -0x38(%ebp) 112223: 56 push %esi 112224: 53 push %ebx 112225: e8 3a c0 00 00 call 11e264 <__divdi3> 11222a: 83 c4 10 add $0x10,%esp 11222d: 89 c3 mov %eax,%ebx if ( start_offset ) { 11222f: 85 ff test %edi,%edi 112231: 75 5d jne 112290 unsigned int last_byte; unsigned int start_offset; int copied; const unsigned char *src; src = source; 112233: 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 ) { 112236: 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; 112239: 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 ) { 112240: 3b 55 d4 cmp -0x2c(%ebp),%edx 112243: 73 26 jae 11226b 112245: e9 a2 00 00 00 jmp 1122ec 11224a: 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 ); 11224c: 8b 00 mov (%eax),%eax src += to_copy; 11224e: 89 c7 mov %eax,%edi 112250: 8b 4d d4 mov -0x2c(%ebp),%ecx 112253: f3 a4 rep movsb %ds:(%esi),%es:(%edi) block++; 112255: 43 inc %ebx my_length -= to_copy; 112256: 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( 112259: 8b 45 d4 mov -0x2c(%ebp),%eax 11225c: 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 ) { 11225f: 39 15 c0 70 12 00 cmp %edx,0x1270c0 112265: 0f 87 81 00 00 00 ja 1122ec block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 11226b: 57 push %edi 11226c: 6a 00 push $0x0 11226e: 53 push %ebx 11226f: ff 75 08 pushl 0x8(%ebp) 112272: 89 55 c4 mov %edx,-0x3c(%ebp) 112275: e8 2e f8 ff ff call 111aa8 if ( !block_ptr ) 11227a: 83 c4 10 add $0x10,%esp 11227d: 85 c0 test %eax,%eax 11227f: 8b 55 c4 mov -0x3c(%ebp),%edx 112282: 75 c8 jne 11224c <== 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 ) 112284: 8b 45 c8 mov -0x38(%ebp),%eax <== NOT EXECUTED } IMFS_mtime_ctime_update( the_jnode ); return copied; } 112287: 8d 65 f4 lea -0xc(%ebp),%esp 11228a: 5b pop %ebx 11228b: 5e pop %esi 11228c: 5f pop %edi 11228d: c9 leave 11228e: c3 ret 11228f: 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 ); 112290: 50 push %eax 112291: 6a 00 push $0x0 112293: 53 push %ebx 112294: ff 75 08 pushl 0x8(%ebp) 112297: e8 0c f8 ff ff call 111aa8 if ( !block_ptr ) 11229c: 83 c4 10 add $0x10,%esp 11229f: 85 c0 test %eax,%eax 1122a1: 0f 84 a1 00 00 00 je 112348 <== 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; 1122a7: 8b 55 d4 mov -0x2c(%ebp),%edx 1122aa: 29 fa sub %edi,%edx 1122ac: 89 55 c8 mov %edx,-0x38(%ebp) 1122af: 8b 55 18 mov 0x18(%ebp),%edx 1122b2: 39 55 c8 cmp %edx,-0x38(%ebp) 1122b5: 0f 87 85 00 00 00 ja 112340 block, to_copy, src ); #endif memcpy( &(*block_ptr)[ start_offset ], src, to_copy ); 1122bb: 03 38 add (%eax),%edi src += to_copy; 1122bd: 8b 75 14 mov 0x14(%ebp),%esi 1122c0: 8b 4d c8 mov -0x38(%ebp),%ecx 1122c3: f3 a4 rep movsb %ds:(%esi),%es:(%edi) block++; 1122c5: 43 inc %ebx my_length -= to_copy; 1122c6: 8b 55 18 mov 0x18(%ebp),%edx 1122c9: 2b 55 c8 sub -0x38(%ebp),%edx copied += to_copy; 1122cc: 8b 3d c0 70 12 00 mov 0x1270c0,%edi 1122d2: 89 7d d4 mov %edi,-0x2c(%ebp) 1122d5: e9 66 ff ff ff jmp 112240 1122da: 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 ) { 1122dc: 3b 4f 50 cmp 0x50(%edi),%ecx 1122df: 0f 86 1b ff ff ff jbe 112200 <== NEVER TAKEN 1122e5: e9 00 ff ff ff jmp 1121ea 1122ea: 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 ) { 1122ec: 85 d2 test %edx,%edx 1122ee: 74 28 je 112318 block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 1122f0: 51 push %ecx 1122f1: 6a 00 push $0x0 1122f3: 53 push %ebx 1122f4: ff 75 08 pushl 0x8(%ebp) 1122f7: 89 55 c4 mov %edx,-0x3c(%ebp) 1122fa: e8 a9 f7 ff ff call 111aa8 if ( !block_ptr ) 1122ff: 83 c4 10 add $0x10,%esp 112302: 85 c0 test %eax,%eax 112304: 8b 55 c4 mov -0x3c(%ebp),%edx 112307: 0f 84 77 ff ff ff je 112284 <== 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 ); 11230d: 8b 00 mov (%eax),%eax 11230f: 89 c7 mov %eax,%edi 112311: 89 d1 mov %edx,%ecx 112313: f3 a4 rep movsb %ds:(%esi),%es:(%edi) my_length = 0; copied += to_copy; 112315: 01 55 c8 add %edx,-0x38(%ebp) } IMFS_mtime_ctime_update( the_jnode ); 112318: 83 ec 08 sub $0x8,%esp 11231b: 6a 00 push $0x0 11231d: 8d 45 e0 lea -0x20(%ebp),%eax 112320: 50 push %eax 112321: e8 0a 5e ff ff call 108130 112326: 8b 45 e0 mov -0x20(%ebp),%eax 112329: 8b 55 08 mov 0x8(%ebp),%edx 11232c: 89 42 44 mov %eax,0x44(%edx) 11232f: 89 42 48 mov %eax,0x48(%edx) return copied; 112332: 83 c4 10 add $0x10,%esp 112335: 8b 45 c8 mov -0x38(%ebp),%eax } 112338: 8d 65 f4 lea -0xc(%ebp),%esp 11233b: 5b pop %ebx 11233c: 5e pop %esi 11233d: 5f pop %edi 11233e: c9 leave 11233f: 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; 112340: 89 55 c8 mov %edx,-0x38(%ebp) 112343: e9 73 ff ff ff jmp 1122bb 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; 112348: 31 c0 xor %eax,%eax } IMFS_mtime_ctime_update( the_jnode ); return copied; } 11234a: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11234d: 5b pop %ebx <== NOT EXECUTED 11234e: 5e pop %esi <== NOT EXECUTED 11234f: 5f pop %edi <== NOT EXECUTED 112350: c9 leave <== NOT EXECUTED 112351: 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 ); 112352: e8 bd 0f 00 00 call 113314 <__errno> 112357: c7 00 1c 00 00 00 movl $0x1c,(%eax) 11235d: 83 c8 ff or $0xffffffff,%eax 112360: e9 22 ff ff ff jmp 112287 =============================================================================== 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 23 7f 00 00 call 10f914 /* * 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 08 75 00 00 call 10ef4c 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 a0 b8 00 00 call 113314 <__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 6f b8 00 00 call 113314 <__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 60 b2 12 00 mov 0x12b260,%eax 10a3bf: ff 70 08 pushl 0x8(%eax) 10a3c2: 8d 43 0c lea 0xc(%ebx),%eax 10a3c5: 50 push %eax 10a3c6: e8 75 d6 00 00 call 117a40 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 69 12 00 push $0x126984 <== NOT EXECUTED 10a3dd: a1 60 b2 12 00 mov 0x12b260,%eax <== NOT EXECUTED 10a3e2: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 10a3e5: e8 4a d5 00 00 call 117934 <== 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 69 12 00 jmp *0x12699c(,%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 60 b2 12 00 mov 0x12b260,%eax 10a401: ff 70 08 pushl 0x8(%eax) 10a404: 6a 13 push $0x13 10a406: 6a 01 push $0x1 10a408: 68 5d 69 12 00 push $0x12695d 10a40d: e8 52 e2 00 00 call 118664 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 60 b2 12 00 mov 0x12b260,%eax 10a421: ff 70 08 pushl 0x8(%eax) 10a424: 6a 12 push $0x12 10a426: 6a 01 push $0x1 10a428: 68 71 69 12 00 push $0x126971 10a42d: e8 32 e2 00 00 call 118664 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 69 12 00 push $0x126951 10a445: a1 60 b2 12 00 mov 0x12b260,%eax 10a44a: ff 70 08 pushl 0x8(%eax) 10a44d: e8 e2 d4 00 00 call 117934 (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 6c 12 00 movl $0x126c89,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 f3 ed 00 00 jmp 119258 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 69 12 00 push $0x126942 10a473: a1 60 b2 12 00 mov 0x12b260,%eax 10a478: ff 70 08 pushl 0x8(%eax) 10a47b: e8 b4 d4 00 00 call 117934 (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 6c 12 00 movl $0x126c89,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 c5 ed 00 00 jmp 119258 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 60 b2 12 00 mov 0x12b260,%eax 10a49c: ff 70 08 pushl 0x8(%eax) 10a49f: 6a 2f push $0x2f 10a4a1: e8 ee d4 00 00 call 117994 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 6c 12 00 movl $0x126c89,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 9f ed 00 00 jmp 119258 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 69 12 00 push $0x12692f 10a4c7: a1 60 b2 12 00 mov 0x12b260,%eax 10a4cc: ff 70 08 pushl 0x8(%eax) 10a4cf: e8 60 d4 00 00 call 117934 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 6c 12 00 movl $0x126c89,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 71 ed 00 00 jmp 119258 =============================================================================== 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 ea c5 00 00 call 11410c 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 cb 44 00 00 call 10c000 <_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 8f 44 00 00 call 10bfdc <_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 =============================================================================== 0010fae0 : int IMFS_stat( rtems_filesystem_location_info_t *loc, struct stat *buf ) { 10fae0: 55 push %ebp 10fae1: 89 e5 mov %esp,%ebp 10fae3: 56 push %esi 10fae4: 53 push %ebx 10fae5: 8b 4d 08 mov 0x8(%ebp),%ecx 10fae8: 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; 10faeb: 8b 11 mov (%ecx),%edx switch ( the_jnode->type ) { 10faed: 83 7a 4c 07 cmpl $0x7,0x4c(%edx) 10faf1: 76 15 jbe 10fb08 <== ALWAYS TAKEN case IMFS_FIFO: buf->st_size = 0; break; default: rtems_set_errno_and_return_minus_one( ENOTSUP ); 10faf3: e8 1c 38 00 00 call 113314 <__errno> 10faf8: c7 00 86 00 00 00 movl $0x86,(%eax) 10fafe: 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; } 10fb03: 5b pop %ebx 10fb04: 5e pop %esi 10fb05: c9 leave 10fb06: c3 ret 10fb07: 90 nop IMFS_device_t *io; the_jnode = loc->node_access; switch ( the_jnode->type ) { 10fb08: 8b 5a 4c mov 0x4c(%edx),%ebx 10fb0b: ff 24 9d f8 10 12 00 jmp *0x1210f8(,%ebx,4) 10fb12: 66 90 xchg %ax,%ax case IMFS_SYM_LINK: buf->st_size = 0; break; case IMFS_FIFO: buf->st_size = 0; 10fb14: c7 40 20 00 00 00 00 movl $0x0,0x20(%eax) 10fb1b: 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; 10fb22: 8b 49 10 mov 0x10(%ecx),%ecx buf->st_dev = rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance ); 10fb25: 8b 49 34 mov 0x34(%ecx),%ecx 10fb28: 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 = 10fb2a: c7 00 fe ff 00 00 movl $0xfffe,(%eax) 10fb30: 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; 10fb33: 8b 4a 30 mov 0x30(%edx),%ecx 10fb36: 89 48 0c mov %ecx,0xc(%eax) buf->st_nlink = the_jnode->st_nlink; 10fb39: 8b 4a 34 mov 0x34(%edx),%ecx 10fb3c: 66 89 48 10 mov %cx,0x10(%eax) buf->st_ino = the_jnode->st_ino; 10fb40: 8b 4a 38 mov 0x38(%edx),%ecx 10fb43: 89 48 08 mov %ecx,0x8(%eax) buf->st_uid = the_jnode->st_uid; 10fb46: 8b 4a 3c mov 0x3c(%edx),%ecx 10fb49: 66 89 48 12 mov %cx,0x12(%eax) buf->st_gid = the_jnode->st_gid; 10fb4d: 66 8b 4a 3e mov 0x3e(%edx),%cx 10fb51: 66 89 48 14 mov %cx,0x14(%eax) buf->st_atime = the_jnode->stat_atime; 10fb55: 8b 4a 40 mov 0x40(%edx),%ecx 10fb58: 89 48 28 mov %ecx,0x28(%eax) buf->st_mtime = the_jnode->stat_mtime; 10fb5b: 8b 4a 44 mov 0x44(%edx),%ecx 10fb5e: 89 48 30 mov %ecx,0x30(%eax) buf->st_ctime = the_jnode->stat_ctime; 10fb61: 8b 52 48 mov 0x48(%edx),%edx 10fb64: 89 50 38 mov %edx,0x38(%eax) return 0; 10fb67: 31 c0 xor %eax,%eax } 10fb69: 5b pop %ebx 10fb6a: 5e pop %esi 10fb6b: c9 leave 10fb6c: c3 ret 10fb6d: 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 ); 10fb70: 8b 5a 54 mov 0x54(%edx),%ebx rtems_device_minor_number _minor ) { union __rtems_dev_t temp; temp.__overlay.major = _major; 10fb73: 8b 72 50 mov 0x50(%edx),%esi 10fb76: 89 70 18 mov %esi,0x18(%eax) 10fb79: 89 58 1c mov %ebx,0x1c(%eax) break; 10fb7c: eb a4 jmp 10fb22 10fb7e: 66 90 xchg %ax,%ax case IMFS_LINEAR_FILE: case IMFS_MEMORY_FILE: buf->st_size = the_jnode->info.file.size; 10fb80: 8b 5a 50 mov 0x50(%edx),%ebx 10fb83: 8b 72 54 mov 0x54(%edx),%esi 10fb86: 89 58 20 mov %ebx,0x20(%eax) 10fb89: 89 70 24 mov %esi,0x24(%eax) break; 10fb8c: eb 94 jmp 10fb22 =============================================================================== 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 6b 74 00 00 call 10f0b8 /* * 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 67 b6 00 00 call 113314 <__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 2b b6 00 00 call 113314 <__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 19 b6 00 00 call 113314 <__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 c8 57 12 00 mov 0x1257c8,%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 cc 57 12 00 mov 0x1257cc,%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 c4 57 12 00 00 cmpb $0x0,0x1257c4 10831c: 75 1f jne 10833d !rtems_unified_work_area && rtems_configuration_get_do_zero_of_workspace() 10831e: 80 3d ac 32 12 00 00 cmpb $0x0,0x1232ac 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 b8 31 12 00 pushl 0x1231b8 108331: e8 ba 43 00 00 call 10c6f0 <_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 20 74 12 00 mov 0x127420,%ebx 108343: 83 ec 0c sub $0xc,%esp 108346: ff 35 b8 31 12 00 pushl 0x1231b8 10834c: e8 23 4e 00 00 call 10d174 <_Protected_heap_Get_size> 108351: 8d 1c 18 lea (%eax,%ebx,1),%ebx 108354: 89 1d 20 74 12 00 mov %ebx,0x127420 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 c4 57 12 00 00 cmpb $0x0,0x1257c4 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 7b 39 00 00 call 10bd00 =============================================================================== 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 44 9d 12 00 mov 0x129d44,%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 db 5e 00 00 call 10dd58 <== NOT EXECUTED 107e7d: 50 push %eax <== NOT EXECUTED 107e7e: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 107e81: 68 13 35 12 00 push $0x123513 <== NOT EXECUTED 107e86: ff 35 40 9d 12 00 pushl 0x129d40 <== 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 2e 35 12 00 push $0x12352e <== NOT EXECUTED 107ea9: ff 35 40 9d 12 00 pushl 0x129d40 <== NOT EXECUTED 107eaf: ff 15 44 9d 12 00 call *0x129d44 <== 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 48 9d 12 00 mov 0x129d48,%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 59 35 12 00 push $0x123559 <== NOT EXECUTED 107ecb: ff 35 40 9d 12 00 pushl 0x129d40 <== NOT EXECUTED 107ed1: ff 15 44 9d 12 00 call *0x129d44 <== 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 20 35 12 00 push $0x123520 <== NOT EXECUTED 107f06: ff 35 40 9d 12 00 pushl 0x129d40 <== NOT EXECUTED 107f0c: ff 15 44 9d 12 00 call *0x129d44 <== 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 4c 35 12 00 push $0x12354c <== NOT EXECUTED 107f24: ff 35 40 9d 12 00 pushl 0x129d40 <== NOT EXECUTED 107f2a: ff 15 44 9d 12 00 call *0x129d44 <== 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 b4 a0 12 00 mov 0x12a0b4,%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 b0 a0 12 00 mov $0x12a0b0,%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 48 9d 12 00 mov 0x129d48,%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 a0 a0 12 00 0d movl $0xfeedf00d,0x12a0a0 107f71: f0 ed fe 107f74: c7 05 a4 a0 12 00 06 movl $0xbad0d06,0x12a0a4 107f7b: 0d ad 0b 107f7e: c7 05 a8 a0 12 00 0d movl $0xdeadf00d,0x12a0a8 107f85: f0 ad de 107f88: c7 05 ac a0 12 00 06 movl $0x600d0d06,0x12a0ac 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 8c a8 12 00 mov 0x12a88c,%edx 107f98: 85 d2 test %edx,%edx 107f9a: 74 1e je 107fba <== NEVER TAKEN 107f9c: 8b 0d 90 a8 12 00 mov 0x12a890,%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 b4 a0 12 00 mov %edx,0x12a0b4 Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high - 107fac: 29 d1 sub %edx,%ecx 107fae: 89 0d b0 a0 12 00 mov %ecx,0x12a0b0 (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 48 9d 12 00 01 movl $0x1,0x129d48 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 5f 35 12 00 push $0x12355f <== 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 6f 35 12 00 push $0x12356f <== 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 8c 35 12 00 push $0x12358c <== 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 9e 35 12 00 push $0x12359e <== 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 e3 5c 00 00 call 10dd58 <== NOT EXECUTED 108075: 5a pop %edx <== NOT EXECUTED 108076: 59 pop %ecx <== NOT EXECUTED 108077: 50 push %eax <== NOT EXECUTED 108078: 68 b2 35 12 00 push $0x1235b2 <== 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 e0 35 12 00 push $0x1235e0 <== 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 bf 64 00 00 call 10e574 <== 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 14 36 12 00 push $0x123614 <== 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 =============================================================================== 0010bea8 <_API_extensions_Run_postdriver>: * * _API_extensions_Run_postdriver */ void _API_extensions_Run_postdriver( void ) { 10bea8: 55 push %ebp 10bea9: 89 e5 mov %esp,%ebp 10beab: 53 push %ebx 10beac: 83 ec 04 sub $0x4,%esp the_extension = (API_extensions_Control *) the_node; (*the_extension->postswitch_hook)( _Thread_Executing ); } } 10beaf: 8b 1d d8 77 12 00 mov 0x1277d8,%ebx void _API_extensions_Run_postdriver( void ) { Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _Chain_First( &_API_extensions_List ); 10beb5: 81 fb dc 77 12 00 cmp $0x1277dc,%ebx 10bebb: 74 10 je 10becd <_API_extensions_Run_postdriver+0x25><== NEVER TAKEN 10bebd: 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)(); 10bec0: 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 ) { 10bec3: 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 ); 10bec5: 81 fb dc 77 12 00 cmp $0x1277dc,%ebx 10becb: 75 f3 jne 10bec0 <_API_extensions_Run_postdriver+0x18> #if defined(FUNCTIONALITY_NOT_CURRENTLY_USED_BY_ANY_API) if ( the_extension->postdriver_hook ) #endif (*the_extension->postdriver_hook)(); } } 10becd: 58 pop %eax 10bece: 5b pop %ebx 10becf: c9 leave 10bed0: c3 ret =============================================================================== 0010bed4 <_API_extensions_Run_postswitch>: * * _API_extensions_Run_postswitch */ void _API_extensions_Run_postswitch( void ) { 10bed4: 55 push %ebp 10bed5: 89 e5 mov %esp,%ebp 10bed7: 53 push %ebx 10bed8: 83 ec 04 sub $0x4,%esp the_extension = (API_extensions_Control *) the_node; (*the_extension->postswitch_hook)( _Thread_Executing ); } } 10bedb: 8b 1d d8 77 12 00 mov 0x1277d8,%ebx void _API_extensions_Run_postswitch( void ) { Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _Chain_First( &_API_extensions_List ); 10bee1: 81 fb dc 77 12 00 cmp $0x1277dc,%ebx 10bee7: 74 1c je 10bf05 <_API_extensions_Run_postswitch+0x31><== NEVER TAKEN 10bee9: 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 ); 10beec: 83 ec 0c sub $0xc,%esp 10beef: ff 35 58 7b 12 00 pushl 0x127b58 10bef5: 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 ) { 10bef8: 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 ); 10befa: 83 c4 10 add $0x10,%esp 10befd: 81 fb dc 77 12 00 cmp $0x1277dc,%ebx 10bf03: 75 e7 jne 10beec <_API_extensions_Run_postswitch+0x18> the_extension = (API_extensions_Control *) the_node; (*the_extension->postswitch_hook)( _Thread_Executing ); } } 10bf05: 8b 5d fc mov -0x4(%ebp),%ebx 10bf08: c9 leave 10bf09: c3 ret =============================================================================== 0010e3e4 <_CORE_RWLock_Obtain_for_reading>: Objects_Id id, bool wait, Watchdog_Interval timeout, CORE_RWLock_API_mp_support_callout api_rwlock_mp_support ) { 10e3e4: 55 push %ebp 10e3e5: 89 e5 mov %esp,%ebp 10e3e7: 57 push %edi 10e3e8: 56 push %esi 10e3e9: 53 push %ebx 10e3ea: 83 ec 1c sub $0x1c,%esp 10e3ed: 8b 5d 08 mov 0x8(%ebp),%ebx 10e3f0: 8b 7d 0c mov 0xc(%ebp),%edi 10e3f3: 8b 4d 14 mov 0x14(%ebp),%ecx 10e3f6: 8a 55 10 mov 0x10(%ebp),%dl ISR_Level level; Thread_Control *executing = _Thread_Executing; 10e3f9: 8b 35 d8 b4 12 00 mov 0x12b4d8,%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 ); 10e3ff: 9c pushf 10e400: fa cli 10e401: 8f 45 e4 popl -0x1c(%ebp) switch ( the_rwlock->current_state ) { 10e404: 8b 43 44 mov 0x44(%ebx),%eax 10e407: 85 c0 test %eax,%eax 10e409: 75 1d jne 10e428 <_CORE_RWLock_Obtain_for_reading+0x44> case CORE_RWLOCK_UNLOCKED: the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING; 10e40b: c7 43 44 01 00 00 00 movl $0x1,0x44(%ebx) the_rwlock->number_of_readers += 1; 10e412: ff 43 48 incl 0x48(%ebx) _ISR_Enable( level ); 10e415: ff 75 e4 pushl -0x1c(%ebp) 10e418: 9d popf executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 10e419: 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 */ } 10e420: 8d 65 f4 lea -0xc(%ebp),%esp 10e423: 5b pop %ebx 10e424: 5e pop %esi 10e425: 5f pop %edi 10e426: c9 leave 10e427: 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 ) { 10e428: 48 dec %eax 10e429: 74 51 je 10e47c <_CORE_RWLock_Obtain_for_reading+0x98> /* * If the thread is not willing to wait, then return immediately. */ if ( !wait ) { 10e42b: 84 d2 test %dl,%dl 10e42d: 75 15 jne 10e444 <_CORE_RWLock_Obtain_for_reading+0x60> _ISR_Enable( level ); 10e42f: ff 75 e4 pushl -0x1c(%ebp) 10e432: 9d popf executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; 10e433: 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 */ } 10e43a: 8d 65 f4 lea -0xc(%ebp),%esp 10e43d: 5b pop %ebx 10e43e: 5e pop %esi 10e43f: 5f pop %edi 10e440: c9 leave 10e441: c3 ret 10e442: 66 90 xchg %ax,%ax 10e444: 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; 10e44b: 89 5e 44 mov %ebx,0x44(%esi) executing->Wait.id = id; 10e44e: 89 7e 20 mov %edi,0x20(%esi) executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_READ; 10e451: c7 46 30 00 00 00 00 movl $0x0,0x30(%esi) executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 10e458: c7 46 34 00 00 00 00 movl $0x0,0x34(%esi) _ISR_Enable( level ); 10e45f: ff 75 e4 pushl -0x1c(%ebp) 10e462: 9d popf _Thread_queue_Enqueue_with_handler( 10e463: c7 45 10 e8 e5 10 00 movl $0x10e5e8,0x10(%ebp) 10e46a: 89 4d 0c mov %ecx,0xc(%ebp) 10e46d: 89 5d 08 mov %ebx,0x8(%ebp) timeout, _CORE_RWLock_Timeout ); /* return to API level so it can dispatch and we block */ } 10e470: 8d 65 f4 lea -0xc(%ebp),%esp 10e473: 5b pop %ebx 10e474: 5e pop %esi 10e475: 5f pop %edi 10e476: 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( 10e477: e9 94 1b 00 00 jmp 110010 <_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 ); 10e47c: 83 ec 0c sub $0xc,%esp 10e47f: 53 push %ebx 10e480: 88 55 e0 mov %dl,-0x20(%ebp) 10e483: 89 4d dc mov %ecx,-0x24(%ebp) 10e486: e8 ad 1e 00 00 call 110338 <_Thread_queue_First> if ( !waiter ) { 10e48b: 83 c4 10 add $0x10,%esp 10e48e: 85 c0 test %eax,%eax 10e490: 8a 55 e0 mov -0x20(%ebp),%dl 10e493: 8b 4d dc mov -0x24(%ebp),%ecx 10e496: 75 93 jne 10e42b <_CORE_RWLock_Obtain_for_reading+0x47> the_rwlock->number_of_readers += 1; 10e498: ff 43 48 incl 0x48(%ebx) _ISR_Enable( level ); 10e49b: ff 75 e4 pushl -0x1c(%ebp) 10e49e: 9d popf executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 10e49f: c7 46 34 00 00 00 00 movl $0x0,0x34(%esi) return; 10e4a6: e9 75 ff ff ff jmp 10e420 <_CORE_RWLock_Obtain_for_reading+0x3c> =============================================================================== 0010e4ac <_CORE_RWLock_Obtain_for_writing>: Objects_Id id, bool wait, Watchdog_Interval timeout, CORE_RWLock_API_mp_support_callout api_rwlock_mp_support ) { 10e4ac: 55 push %ebp 10e4ad: 89 e5 mov %esp,%ebp 10e4af: 57 push %edi 10e4b0: 56 push %esi 10e4b1: 53 push %ebx 10e4b2: 83 ec 0c sub $0xc,%esp 10e4b5: 8b 45 08 mov 0x8(%ebp),%eax 10e4b8: 8b 7d 0c mov 0xc(%ebp),%edi 10e4bb: 8b 75 14 mov 0x14(%ebp),%esi 10e4be: 8a 5d 10 mov 0x10(%ebp),%bl ISR_Level level; Thread_Control *executing = _Thread_Executing; 10e4c1: 8b 15 d8 b4 12 00 mov 0x12b4d8,%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 ); 10e4c7: 9c pushf 10e4c8: fa cli 10e4c9: 59 pop %ecx switch ( the_rwlock->current_state ) { 10e4ca: 83 78 44 00 cmpl $0x0,0x44(%eax) 10e4ce: 75 18 jne 10e4e8 <_CORE_RWLock_Obtain_for_writing+0x3c> case CORE_RWLOCK_UNLOCKED: the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING; 10e4d0: c7 40 44 02 00 00 00 movl $0x2,0x44(%eax) _ISR_Enable( level ); 10e4d7: 51 push %ecx 10e4d8: 9d popf executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 10e4d9: 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 */ } 10e4e0: 83 c4 0c add $0xc,%esp 10e4e3: 5b pop %ebx 10e4e4: 5e pop %esi 10e4e5: 5f pop %edi 10e4e6: c9 leave 10e4e7: c3 ret /* * If the thread is not willing to wait, then return immediately. */ if ( !wait ) { 10e4e8: 84 db test %bl,%bl 10e4ea: 75 14 jne 10e500 <_CORE_RWLock_Obtain_for_writing+0x54> _ISR_Enable( level ); 10e4ec: 51 push %ecx 10e4ed: 9d popf executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; 10e4ee: 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 */ } 10e4f5: 83 c4 0c add $0xc,%esp 10e4f8: 5b pop %ebx 10e4f9: 5e pop %esi 10e4fa: 5f pop %edi 10e4fb: c9 leave 10e4fc: c3 ret 10e4fd: 8d 76 00 lea 0x0(%esi),%esi 10e500: 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; 10e507: 89 42 44 mov %eax,0x44(%edx) executing->Wait.id = id; 10e50a: 89 7a 20 mov %edi,0x20(%edx) executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_WRITE; 10e50d: c7 42 30 01 00 00 00 movl $0x1,0x30(%edx) executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 10e514: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx) _ISR_Enable( level ); 10e51b: 51 push %ecx 10e51c: 9d popf _Thread_queue_Enqueue_with_handler( 10e51d: c7 45 10 e8 e5 10 00 movl $0x10e5e8,0x10(%ebp) 10e524: 89 75 0c mov %esi,0xc(%ebp) 10e527: 89 45 08 mov %eax,0x8(%ebp) _CORE_RWLock_Timeout ); /* return to API level so it can dispatch and we block */ } 10e52a: 83 c4 0c add $0xc,%esp 10e52d: 5b pop %ebx 10e52e: 5e pop %esi 10e52f: 5f pop %edi 10e530: 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( 10e531: e9 da 1a 00 00 jmp 110010 <_Thread_queue_Enqueue_with_handler> =============================================================================== 0010e538 <_CORE_RWLock_Release>: */ CORE_RWLock_Status _CORE_RWLock_Release( CORE_RWLock_Control *the_rwlock ) { 10e538: 55 push %ebp 10e539: 89 e5 mov %esp,%ebp 10e53b: 53 push %ebx 10e53c: 83 ec 04 sub $0x4,%esp 10e53f: 8b 5d 08 mov 0x8(%ebp),%ebx ISR_Level level; Thread_Control *executing = _Thread_Executing; 10e542: 8b 0d d8 b4 12 00 mov 0x12b4d8,%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 ); 10e548: 9c pushf 10e549: fa cli 10e54a: 5a pop %edx if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){ 10e54b: 8b 43 44 mov 0x44(%ebx),%eax 10e54e: 85 c0 test %eax,%eax 10e550: 74 7a je 10e5cc <_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 ) { 10e552: 48 dec %eax 10e553: 74 63 je 10e5b8 <_CORE_RWLock_Release+0x80> return CORE_RWLOCK_SUCCESSFUL; } } /* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */ executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 10e555: 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; 10e55c: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) _ISR_Enable( level ); 10e563: 52 push %edx 10e564: 9d popf next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue ); 10e565: 83 ec 0c sub $0xc,%esp 10e568: 53 push %ebx 10e569: e8 7a 19 00 00 call 10fee8 <_Thread_queue_Dequeue> if ( next ) { 10e56e: 83 c4 10 add $0x10,%esp 10e571: 85 c0 test %eax,%eax 10e573: 74 39 je 10e5ae <_CORE_RWLock_Release+0x76> if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) { 10e575: 83 78 30 01 cmpl $0x1,0x30(%eax) 10e579: 74 61 je 10e5dc <_CORE_RWLock_Release+0xa4> } /* * Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING */ the_rwlock->number_of_readers += 1; 10e57b: ff 43 48 incl 0x48(%ebx) the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING; 10e57e: c7 43 44 01 00 00 00 movl $0x1,0x44(%ebx) 10e585: eb 17 jmp 10e59e <_CORE_RWLock_Release+0x66> 10e587: 90 nop /* * Now see if more readers can be let go. */ while ( 1 ) { next = _Thread_queue_First( &the_rwlock->Wait_queue ); if ( !next || 10e588: 83 78 30 01 cmpl $0x1,0x30(%eax) 10e58c: 74 20 je 10e5ae <_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; 10e58e: ff 43 48 incl 0x48(%ebx) _Thread_queue_Extract( &the_rwlock->Wait_queue, next ); 10e591: 83 ec 08 sub $0x8,%esp 10e594: 50 push %eax 10e595: 53 push %ebx 10e596: e8 85 1c 00 00 call 110220 <_Thread_queue_Extract> } 10e59b: 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 ); 10e59e: 83 ec 0c sub $0xc,%esp 10e5a1: 53 push %ebx 10e5a2: e8 91 1d 00 00 call 110338 <_Thread_queue_First> if ( !next || 10e5a7: 83 c4 10 add $0x10,%esp 10e5aa: 85 c0 test %eax,%eax 10e5ac: 75 da jne 10e588 <_CORE_RWLock_Release+0x50> } /* indentation is to match _ISR_Disable at top */ return CORE_RWLOCK_SUCCESSFUL; } 10e5ae: 31 c0 xor %eax,%eax 10e5b0: 8b 5d fc mov -0x4(%ebp),%ebx 10e5b3: c9 leave 10e5b4: c3 ret 10e5b5: 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; 10e5b8: 8b 43 48 mov 0x48(%ebx),%eax 10e5bb: 48 dec %eax 10e5bc: 89 43 48 mov %eax,0x48(%ebx) if ( the_rwlock->number_of_readers != 0 ) { 10e5bf: 85 c0 test %eax,%eax 10e5c1: 74 92 je 10e555 <_CORE_RWLock_Release+0x1d> /* must be unlocked again */ _ISR_Enable( level ); 10e5c3: 52 push %edx 10e5c4: 9d popf } /* indentation is to match _ISR_Disable at top */ return CORE_RWLOCK_SUCCESSFUL; } 10e5c5: 31 c0 xor %eax,%eax 10e5c7: 8b 5d fc mov -0x4(%ebp),%ebx 10e5ca: c9 leave 10e5cb: c3 ret * If any thread is waiting, then we wait. */ _ISR_Disable( level ); if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){ _ISR_Enable( level ); 10e5cc: 52 push %edx 10e5cd: 9d popf executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; 10e5ce: c7 41 34 02 00 00 00 movl $0x2,0x34(%ecx) } /* indentation is to match _ISR_Disable at top */ return CORE_RWLOCK_SUCCESSFUL; } 10e5d5: 31 c0 xor %eax,%eax 10e5d7: 8b 5d fc mov -0x4(%ebp),%ebx 10e5da: c9 leave 10e5db: 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; 10e5dc: c7 43 44 02 00 00 00 movl $0x2,0x44(%ebx) return CORE_RWLOCK_SUCCESSFUL; 10e5e3: eb c9 jmp 10e5ae <_CORE_RWLock_Release+0x76> =============================================================================== 0010e5e8 <_CORE_RWLock_Timeout>: void _CORE_RWLock_Timeout( Objects_Id id, void *ignored ) { 10e5e8: 55 push %ebp 10e5e9: 89 e5 mov %esp,%ebp 10e5eb: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10e5ee: 8d 45 f4 lea -0xc(%ebp),%eax 10e5f1: 50 push %eax 10e5f2: ff 75 08 pushl 0x8(%ebp) 10e5f5: e8 5e 15 00 00 call 10fb58 <_Thread_Get> switch ( location ) { 10e5fa: 83 c4 10 add $0x10,%esp 10e5fd: 8b 55 f4 mov -0xc(%ebp),%edx 10e600: 85 d2 test %edx,%edx 10e602: 75 17 jne 10e61b <_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 ); 10e604: 83 ec 0c sub $0xc,%esp 10e607: 50 push %eax 10e608: e8 0b 1e 00 00 call 110418 <_Thread_queue_Process_timeout> */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 10e60d: a1 f0 ae 12 00 mov 0x12aef0,%eax 10e612: 48 dec %eax 10e613: a3 f0 ae 12 00 mov %eax,0x12aef0 10e618: 83 c4 10 add $0x10,%esp _Thread_Unnest_dispatch(); break; } } 10e61b: c9 leave 10e61c: c3 ret =============================================================================== 001198e0 <_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 ) { 1198e0: 55 push %ebp 1198e1: 89 e5 mov %esp,%ebp 1198e3: 57 push %edi 1198e4: 56 push %esi 1198e5: 53 push %ebx 1198e6: 83 ec 1c sub $0x1c,%esp 1198e9: 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 ) { 1198ec: 8b 45 10 mov 0x10(%ebp),%eax 1198ef: 39 43 4c cmp %eax,0x4c(%ebx) 1198f2: 72 60 jb 119954 <_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 ) { 1198f4: 8b 43 48 mov 0x48(%ebx),%eax 1198f7: 85 c0 test %eax,%eax 1198f9: 75 45 jne 119940 <_CORE_message_queue_Broadcast+0x60> 1198fb: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) 119902: eb 18 jmp 11991c <_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; 119904: ff 45 e4 incl -0x1c(%ebp) const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 119907: 8b 42 2c mov 0x2c(%edx),%eax 11990a: 89 c7 mov %eax,%edi 11990c: 8b 75 0c mov 0xc(%ebp),%esi 11990f: 8b 4d 10 mov 0x10(%ebp),%ecx 119912: f3 a4 rep movsb %ds:(%esi),%es:(%edi) buffer, waitp->return_argument_second.mutable_object, size ); *(size_t *) the_thread->Wait.return_argument = size; 119914: 8b 42 28 mov 0x28(%edx),%eax 119917: 8b 55 10 mov 0x10(%ebp),%edx 11991a: 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 = 11991c: 83 ec 0c sub $0xc,%esp 11991f: 53 push %ebx 119920: e8 27 28 00 00 call 11c14c <_Thread_queue_Dequeue> 119925: 89 c2 mov %eax,%edx 119927: 83 c4 10 add $0x10,%esp 11992a: 85 c0 test %eax,%eax 11992c: 75 d6 jne 119904 <_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; 11992e: 8b 55 e4 mov -0x1c(%ebp),%edx 119931: 8b 45 1c mov 0x1c(%ebp),%eax 119934: 89 10 mov %edx,(%eax) return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 119936: 31 c0 xor %eax,%eax } 119938: 8d 65 f4 lea -0xc(%ebp),%esp 11993b: 5b pop %ebx 11993c: 5e pop %esi 11993d: 5f pop %edi 11993e: c9 leave 11993f: 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; 119940: 8b 55 1c mov 0x1c(%ebp),%edx 119943: c7 02 00 00 00 00 movl $0x0,(%edx) return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 119949: 31 c0 xor %eax,%eax #endif } *count = number_broadcasted; return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; } 11994b: 8d 65 f4 lea -0xc(%ebp),%esp 11994e: 5b pop %ebx 11994f: 5e pop %esi 119950: 5f pop %edi 119951: c9 leave 119952: c3 ret 119953: 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; 119954: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED #endif } *count = number_broadcasted; return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; } 119959: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11995c: 5b pop %ebx <== NOT EXECUTED 11995d: 5e pop %esi <== NOT EXECUTED 11995e: 5f pop %edi <== NOT EXECUTED 11995f: c9 leave <== NOT EXECUTED 119960: c3 ret <== NOT EXECUTED =============================================================================== 00114a20 <_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 ) { 114a20: 55 push %ebp 114a21: 89 e5 mov %esp,%ebp 114a23: 57 push %edi 114a24: 56 push %esi 114a25: 53 push %ebx 114a26: 83 ec 0c sub $0xc,%esp 114a29: 8b 5d 08 mov 0x8(%ebp),%ebx 114a2c: 8b 75 10 mov 0x10(%ebp),%esi 114a2f: 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; 114a32: 89 73 44 mov %esi,0x44(%ebx) the_message_queue->number_of_pending_messages = 0; 114a35: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx) the_message_queue->maximum_message_size = maximum_message_size; 114a3c: 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; 114a3f: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) the_message_queue->notify_argument = the_argument; 114a46: 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)) { 114a4d: a8 03 test $0x3,%al 114a4f: 74 17 je 114a68 <_CORE_message_queue_Initialize+0x48> allocated_message_size += sizeof(uint32_t); 114a51: 8d 50 04 lea 0x4(%eax),%edx allocated_message_size &= ~(sizeof(uint32_t) - 1); 114a54: 83 e2 fc and $0xfffffffc,%edx } if (allocated_message_size < maximum_message_size) 114a57: 39 d0 cmp %edx,%eax 114a59: 76 0f jbe 114a6a <_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; 114a5b: 31 c0 xor %eax,%eax STATES_WAITING_FOR_MESSAGE, CORE_MESSAGE_QUEUE_STATUS_TIMEOUT ); return true; } 114a5d: 8d 65 f4 lea -0xc(%ebp),%esp 114a60: 5b pop %ebx 114a61: 5e pop %esi 114a62: 5f pop %edi 114a63: c9 leave 114a64: c3 ret 114a65: 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)) { 114a68: 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)); 114a6a: 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 * 114a6d: 89 f8 mov %edi,%eax 114a6f: 0f af c6 imul %esi,%eax (allocated_message_size + sizeof(CORE_message_queue_Buffer_control)); if (message_buffering_required < allocated_message_size) 114a72: 39 d0 cmp %edx,%eax 114a74: 72 e5 jb 114a5b <_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 ); 114a76: 83 ec 0c sub $0xc,%esp 114a79: 50 push %eax 114a7a: e8 21 2b 00 00 call 1175a0 <_Workspace_Allocate> return false; /* * Attempt to allocate the message memory */ the_message_queue->message_buffers = (CORE_message_queue_Buffer *) 114a7f: 89 43 5c mov %eax,0x5c(%ebx) _Workspace_Allocate( message_buffering_required ); if (the_message_queue->message_buffers == 0) 114a82: 83 c4 10 add $0x10,%esp 114a85: 85 c0 test %eax,%eax 114a87: 74 d2 je 114a5b <_CORE_message_queue_Initialize+0x3b> /* * Initialize the pool of inactive messages, pending messages, * and set of waiting threads. */ _Chain_Initialize ( 114a89: 57 push %edi 114a8a: 56 push %esi 114a8b: 50 push %eax 114a8c: 8d 43 68 lea 0x68(%ebx),%eax 114a8f: 50 push %eax 114a90: e8 13 52 00 00 call 119ca8 <_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 ); 114a95: 8d 43 54 lea 0x54(%ebx),%eax 114a98: 89 43 50 mov %eax,0x50(%ebx) head->next = tail; head->previous = NULL; 114a9b: 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 ); 114aa2: 8d 43 50 lea 0x50(%ebx),%eax 114aa5: 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( 114aa8: 6a 06 push $0x6 114aaa: 68 80 00 00 00 push $0x80 114aaf: 8b 45 0c mov 0xc(%ebp),%eax 114ab2: 83 38 01 cmpl $0x1,(%eax) 114ab5: 0f 94 c0 sete %al 114ab8: 0f b6 c0 movzbl %al,%eax 114abb: 50 push %eax 114abc: 53 push %ebx 114abd: e8 b6 21 00 00 call 116c78 <_Thread_queue_Initialize> THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO, STATES_WAITING_FOR_MESSAGE, CORE_MESSAGE_QUEUE_STATUS_TIMEOUT ); return true; 114ac2: 83 c4 20 add $0x20,%esp 114ac5: b0 01 mov $0x1,%al } 114ac7: 8d 65 f4 lea -0xc(%ebp),%esp 114aca: 5b pop %ebx 114acb: 5e pop %esi 114acc: 5f pop %edi 114acd: c9 leave 114ace: c3 ret =============================================================================== 001110b0 <_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 ) { 1110b0: 55 push %ebp 1110b1: 89 e5 mov %esp,%ebp 1110b3: 56 push %esi 1110b4: 53 push %ebx 1110b5: 83 ec 10 sub $0x10,%esp 1110b8: 8b 45 08 mov 0x8(%ebp),%eax 1110bb: 8b 55 0c mov 0xc(%ebp),%edx 1110be: 8b 4d 10 mov 0x10(%ebp),%ecx 1110c1: 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 ) { 1110c4: 81 f9 ff ff ff 7f cmp $0x7fffffff,%ecx 1110ca: 74 70 je 11113c <_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 ) { 1110cc: 81 f9 00 00 00 80 cmp $0x80000000,%ecx 1110d2: 0f 84 88 00 00 00 je 111160 <_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 } 1110d8: 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)); 1110db: 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 ) ) { 1110de: 39 de cmp %ebx,%esi 1110e0: 74 05 je 1110e7 <_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 ) { 1110e2: 3b 4b 08 cmp 0x8(%ebx),%ecx 1110e5: 7d 45 jge 11112c <_CORE_message_queue_Insert_message+0x7c> the_node = the_node->next; continue; } break; } _ISR_Disable( level ); 1110e7: 9c pushf 1110e8: fa cli 1110e9: 5e pop %esi SET_NOTIFY(); 1110ea: 8b 48 48 mov 0x48(%eax),%ecx * * INTERRUPT LATENCY: * insert */ void _CORE_message_queue_Insert_message( 1110ed: 85 c9 test %ecx,%ecx 1110ef: 0f 94 45 f7 sete -0x9(%ebp) } break; } _ISR_Disable( level ); SET_NOTIFY(); the_message_queue->number_of_pending_messages++; 1110f3: 41 inc %ecx 1110f4: 89 48 48 mov %ecx,0x48(%eax) _Chain_Insert_unprotected( the_node->previous, &the_message->Node ); 1110f7: 8b 4b 04 mov 0x4(%ebx),%ecx Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 1110fa: 89 4a 04 mov %ecx,0x4(%edx) before_node = after_node->next; 1110fd: 8b 19 mov (%ecx),%ebx after_node->next = the_node; 1110ff: 89 11 mov %edx,(%ecx) the_node->next = before_node; 111101: 89 1a mov %ebx,(%edx) before_node->previous = the_node; 111103: 89 53 04 mov %edx,0x4(%ebx) _ISR_Enable( level ); 111106: 56 push %esi 111107: 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 ) 111108: 80 7d f7 00 cmpb $0x0,-0x9(%ebp) 11110c: 74 16 je 111124 <_CORE_message_queue_Insert_message+0x74> 11110e: 8b 50 60 mov 0x60(%eax),%edx 111111: 85 d2 test %edx,%edx 111113: 74 0f je 111124 <_CORE_message_queue_Insert_message+0x74> (*the_message_queue->notify_handler)(the_message_queue->notify_argument); 111115: 8b 40 64 mov 0x64(%eax),%eax 111118: 89 45 08 mov %eax,0x8(%ebp) #endif } 11111b: 83 c4 10 add $0x10,%esp 11111e: 5b pop %ebx 11111f: 5e pop %esi 111120: 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); 111121: ff e2 jmp *%edx 111123: 90 nop #endif } 111124: 83 c4 10 add $0x10,%esp 111127: 5b pop %ebx 111128: 5e pop %esi 111129: c9 leave 11112a: c3 ret 11112b: 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; 11112c: 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 ) ) { 11112e: 39 de cmp %ebx,%esi 111130: 74 b5 je 1110e7 <_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 ) { 111132: 3b 4b 08 cmp 0x8(%ebx),%ecx 111135: 7c b0 jl 1110e7 <_CORE_message_queue_Insert_message+0x37> 111137: eb f3 jmp 11112c <_CORE_message_queue_Insert_message+0x7c> 111139: 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 ); 11113c: 9c pushf 11113d: fa cli 11113e: 5b pop %ebx SET_NOTIFY(); 11113f: 8b 48 48 mov 0x48(%eax),%ecx * * INTERRUPT LATENCY: * insert */ void _CORE_message_queue_Insert_message( 111142: 85 c9 test %ecx,%ecx 111144: 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++; 111148: 41 inc %ecx 111149: 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; 11114c: 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 ); 11114f: 8d 70 54 lea 0x54(%eax),%esi 111152: 89 32 mov %esi,(%edx) Chain_Node *old_last = tail->previous; the_node->next = tail; tail->previous = the_node; 111154: 89 50 58 mov %edx,0x58(%eax) old_last->next = the_node; 111157: 89 11 mov %edx,(%ecx) the_node->previous = old_last; 111159: 89 4a 04 mov %ecx,0x4(%edx) _CORE_message_queue_Append_unprotected(the_message_queue, the_message); _ISR_Enable( level ); 11115c: 53 push %ebx 11115d: 9d popf 11115e: eb a8 jmp 111108 <_CORE_message_queue_Insert_message+0x58> } else if ( submit_type == CORE_MESSAGE_QUEUE_URGENT_REQUEST ) { _ISR_Disable( level ); 111160: 9c pushf 111161: fa cli 111162: 5b pop %ebx SET_NOTIFY(); 111163: 8b 48 48 mov 0x48(%eax),%ecx * * INTERRUPT LATENCY: * insert */ void _CORE_message_queue_Insert_message( 111166: 85 c9 test %ecx,%ecx 111168: 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++; 11116c: 41 inc %ecx 11116d: 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); 111170: 8d 48 50 lea 0x50(%eax),%ecx 111173: 89 4a 04 mov %ecx,0x4(%edx) ) { Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; 111176: 8b 48 50 mov 0x50(%eax),%ecx after_node->next = the_node; 111179: 89 50 50 mov %edx,0x50(%eax) the_node->next = before_node; 11117c: 89 0a mov %ecx,(%edx) before_node->previous = the_node; 11117e: 89 51 04 mov %edx,0x4(%ecx) _CORE_message_queue_Prepend_unprotected(the_message_queue, the_message); _ISR_Enable( level ); 111181: 53 push %ebx 111182: 9d popf 111183: eb 83 jmp 111108 <_CORE_message_queue_Insert_message+0x58> =============================================================================== 00114ad0 <_CORE_message_queue_Seize>: void *buffer, size_t *size_p, bool wait, Watchdog_Interval timeout ) { 114ad0: 55 push %ebp 114ad1: 89 e5 mov %esp,%ebp 114ad3: 57 push %edi 114ad4: 56 push %esi 114ad5: 53 push %ebx 114ad6: 83 ec 2c sub $0x2c,%esp 114ad9: 8b 55 08 mov 0x8(%ebp),%edx 114adc: 8b 45 0c mov 0xc(%ebp),%eax 114adf: 89 45 dc mov %eax,-0x24(%ebp) 114ae2: 8b 4d 10 mov 0x10(%ebp),%ecx 114ae5: 89 4d e0 mov %ecx,-0x20(%ebp) 114ae8: 8b 45 14 mov 0x14(%ebp),%eax 114aeb: 8b 5d 1c mov 0x1c(%ebp),%ebx 114aee: 89 5d d8 mov %ebx,-0x28(%ebp) 114af1: 0f b6 7d 18 movzbl 0x18(%ebp),%edi ISR_Level level; CORE_message_queue_Buffer_control *the_message; Thread_Control *executing; executing = _Thread_Executing; 114af5: 8b 0d d8 11 13 00 mov 0x1311d8,%ecx executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 114afb: c7 41 34 00 00 00 00 movl $0x0,0x34(%ecx) _ISR_Disable( level ); 114b02: 9c pushf 114b03: fa cli 114b04: 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 ); } 114b07: 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 ); 114b0a: 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)) 114b0d: 39 f3 cmp %esi,%ebx 114b0f: 74 7b je 114b8c <_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; 114b11: 8b 0b mov (%ebx),%ecx head->next = new_first; 114b13: 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 ); 114b16: 8d 72 50 lea 0x50(%edx),%esi 114b19: 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; 114b1c: ff 4a 48 decl 0x48(%edx) _ISR_Enable( level ); 114b1f: ff 75 e4 pushl -0x1c(%ebp) 114b22: 9d popf *size_p = the_message->Contents.size; 114b23: 8b 4b 0c mov 0xc(%ebx),%ecx 114b26: 89 08 mov %ecx,(%eax) _Thread_Executing->Wait.count = 114b28: 8b 73 08 mov 0x8(%ebx),%esi 114b2b: 8b 0d d8 11 13 00 mov 0x1311d8,%ecx 114b31: 89 71 24 mov %esi,0x24(%ecx) _CORE_message_queue_Get_message_priority( the_message ); _CORE_message_queue_Copy_buffer( the_message->Contents.buffer, 114b34: 8d 4b 10 lea 0x10(%ebx),%ecx 114b37: 89 4d e4 mov %ecx,-0x1c(%ebp) const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 114b3a: 8b 08 mov (%eax),%ecx 114b3c: 8b 7d e0 mov -0x20(%ebp),%edi 114b3f: 8b 75 e4 mov -0x1c(%ebp),%esi 114b42: 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 ); 114b44: 83 ec 0c sub $0xc,%esp 114b47: 52 push %edx 114b48: 89 55 d4 mov %edx,-0x2c(%ebp) 114b4b: e8 98 1d 00 00 call 1168e8 <_Thread_queue_Dequeue> if ( !the_thread ) { 114b50: 83 c4 10 add $0x10,%esp 114b53: 85 c0 test %eax,%eax 114b55: 8b 55 d4 mov -0x2c(%ebp),%edx 114b58: 0f 84 86 00 00 00 je 114be4 <_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; 114b5e: 8b 48 24 mov 0x24(%eax),%ecx 114b61: 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; 114b64: 8b 48 30 mov 0x30(%eax),%ecx 114b67: 89 4b 0c mov %ecx,0xc(%ebx) const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 114b6a: 8b 70 2c mov 0x2c(%eax),%esi 114b6d: 8b 7d e4 mov -0x1c(%ebp),%edi 114b70: 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( 114b72: 8b 43 08 mov 0x8(%ebx),%eax 114b75: 89 45 10 mov %eax,0x10(%ebp) 114b78: 89 5d 0c mov %ebx,0xc(%ebp) 114b7b: 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 ); } 114b7e: 8d 65 f4 lea -0xc(%ebp),%esp 114b81: 5b pop %ebx 114b82: 5e pop %esi 114b83: 5f pop %edi 114b84: c9 leave the_thread->Wait.return_argument_second.immutable_object, the_message->Contents.buffer, the_message->Contents.size ); _CORE_message_queue_Insert_message( 114b85: e9 7a 51 00 00 jmp 119d04 <_CORE_message_queue_Insert_message> 114b8a: 66 90 xchg %ax,%ax return; } #endif } if ( !wait ) { 114b8c: 89 fb mov %edi,%ebx 114b8e: 84 db test %bl,%bl 114b90: 75 16 jne 114ba8 <_CORE_message_queue_Seize+0xd8> _ISR_Enable( level ); 114b92: ff 75 e4 pushl -0x1c(%ebp) 114b95: 9d popf executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT; 114b96: 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 ); } 114b9d: 8d 65 f4 lea -0xc(%ebp),%esp 114ba0: 5b pop %ebx 114ba1: 5e pop %esi 114ba2: 5f pop %edi 114ba3: c9 leave 114ba4: c3 ret 114ba5: 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; 114ba8: 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; 114baf: 89 51 44 mov %edx,0x44(%ecx) executing->Wait.id = id; 114bb2: 8b 5d dc mov -0x24(%ebp),%ebx 114bb5: 89 59 20 mov %ebx,0x20(%ecx) executing->Wait.return_argument_second.mutable_object = buffer; 114bb8: 8b 5d e0 mov -0x20(%ebp),%ebx 114bbb: 89 59 2c mov %ebx,0x2c(%ecx) executing->Wait.return_argument = size_p; 114bbe: 89 41 28 mov %eax,0x28(%ecx) /* Wait.count will be filled in with the message priority */ _ISR_Enable( level ); 114bc1: ff 75 e4 pushl -0x1c(%ebp) 114bc4: 9d popf _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 114bc5: c7 45 10 3c 6d 11 00 movl $0x116d3c,0x10(%ebp) 114bcc: 8b 45 d8 mov -0x28(%ebp),%eax 114bcf: 89 45 0c mov %eax,0xc(%ebp) 114bd2: 89 55 08 mov %edx,0x8(%ebp) } 114bd5: 8d 65 f4 lea -0xc(%ebp),%esp 114bd8: 5b pop %ebx 114bd9: 5e pop %esi 114bda: 5f pop %edi 114bdb: 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 ); 114bdc: e9 2f 1e 00 00 jmp 116a10 <_Thread_queue_Enqueue_with_handler> 114be1: 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 ); 114be4: 89 5d 0c mov %ebx,0xc(%ebp) 114be7: 83 c2 68 add $0x68,%edx 114bea: 89 55 08 mov %edx,0x8(%ebp) } 114bed: 8d 65 f4 lea -0xc(%ebp),%esp 114bf0: 5b pop %ebx 114bf1: 5e pop %esi 114bf2: 5f pop %edi 114bf3: c9 leave 114bf4: e9 a7 fd ff ff jmp 1149a0 <_Chain_Append> =============================================================================== 0010c03c <_CORE_message_queue_Submit>: #endif CORE_message_queue_Submit_types submit_type, bool wait, Watchdog_Interval timeout ) { 10c03c: 55 push %ebp 10c03d: 89 e5 mov %esp,%ebp 10c03f: 57 push %edi 10c040: 56 push %esi 10c041: 53 push %ebx 10c042: 83 ec 1c sub $0x1c,%esp 10c045: 8b 5d 08 mov 0x8(%ebp),%ebx 10c048: 8b 75 0c mov 0xc(%ebp),%esi 10c04b: 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 ) { 10c04e: 8b 45 10 mov 0x10(%ebp),%eax 10c051: 39 43 4c cmp %eax,0x4c(%ebx) 10c054: 72 32 jb 10c088 <_CORE_message_queue_Submit+0x4c> } /* * Is there a thread currently waiting on this message queue? */ if ( the_message_queue->number_of_pending_messages == 0 ) { 10c056: 8b 43 48 mov 0x48(%ebx),%eax 10c059: 85 c0 test %eax,%eax 10c05b: 74 3b je 10c098 <_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 < 10c05d: 39 43 44 cmp %eax,0x44(%ebx) 10c060: 0f 87 ba 00 00 00 ja 10c120 <_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 ) { 10c066: 84 c9 test %cl,%cl 10c068: 0f 84 ee 00 00 00 je 10c15c <_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() ) { 10c06e: 8b 15 54 7b 12 00 mov 0x127b54,%edx 10c074: 85 d2 test %edx,%edx 10c076: 74 60 je 10c0d8 <_CORE_message_queue_Submit+0x9c> return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED; 10c078: 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 } 10c07d: 8d 65 f4 lea -0xc(%ebp),%esp 10c080: 5b pop %ebx 10c081: 5e pop %esi 10c082: 5f pop %edi 10c083: c9 leave 10c084: c3 ret 10c085: 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; 10c088: 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 } 10c08d: 8d 65 f4 lea -0xc(%ebp),%esp 10c090: 5b pop %ebx 10c091: 5e pop %esi 10c092: 5f pop %edi 10c093: c9 leave 10c094: c3 ret 10c095: 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 ); 10c098: 83 ec 0c sub $0xc,%esp 10c09b: 53 push %ebx 10c09c: 88 4d e4 mov %cl,-0x1c(%ebp) 10c09f: e8 04 1c 00 00 call 10dca8 <_Thread_queue_Dequeue> 10c0a4: 89 c2 mov %eax,%edx if ( the_thread ) { 10c0a6: 83 c4 10 add $0x10,%esp 10c0a9: 85 c0 test %eax,%eax 10c0ab: 8a 4d e4 mov -0x1c(%ebp),%cl 10c0ae: 0f 84 b8 00 00 00 je 10c16c <_CORE_message_queue_Submit+0x130> const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 10c0b4: 8b 40 2c mov 0x2c(%eax),%eax 10c0b7: 89 c7 mov %eax,%edi 10c0b9: 8b 4d 10 mov 0x10(%ebp),%ecx 10c0bc: 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; 10c0be: 8b 42 28 mov 0x28(%edx),%eax 10c0c1: 8b 4d 10 mov 0x10(%ebp),%ecx 10c0c4: 89 08 mov %ecx,(%eax) the_thread->Wait.count = (uint32_t) submit_type; 10c0c6: 8b 45 1c mov 0x1c(%ebp),%eax 10c0c9: 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; 10c0cc: 31 c0 xor %eax,%eax _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); } return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT; #endif } 10c0ce: 8d 65 f4 lea -0xc(%ebp),%esp 10c0d1: 5b pop %ebx 10c0d2: 5e pop %esi 10c0d3: 5f pop %edi 10c0d4: c9 leave 10c0d5: c3 ret 10c0d6: 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; 10c0d8: a1 58 7b 12 00 mov 0x127b58,%eax ISR_Level level; _ISR_Disable( level ); 10c0dd: 9c pushf 10c0de: fa cli 10c0df: 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; 10c0e0: 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; 10c0e7: 89 58 44 mov %ebx,0x44(%eax) executing->Wait.id = id; 10c0ea: 8b 55 14 mov 0x14(%ebp),%edx 10c0ed: 89 50 20 mov %edx,0x20(%eax) executing->Wait.return_argument_second.immutable_object = buffer; 10c0f0: 89 70 2c mov %esi,0x2c(%eax) executing->Wait.option = (uint32_t) size; 10c0f3: 8b 55 10 mov 0x10(%ebp),%edx 10c0f6: 89 50 30 mov %edx,0x30(%eax) executing->Wait.count = submit_type; 10c0f9: 8b 55 1c mov 0x1c(%ebp),%edx 10c0fc: 89 50 24 mov %edx,0x24(%eax) _ISR_Enable( level ); 10c0ff: 51 push %ecx 10c100: 9d popf _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 10c101: 50 push %eax 10c102: 68 fc e0 10 00 push $0x10e0fc 10c107: ff 75 24 pushl 0x24(%ebp) 10c10a: 53 push %ebx 10c10b: e8 c0 1c 00 00 call 10ddd0 <_Thread_queue_Enqueue_with_handler> } return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT; 10c110: 83 c4 10 add $0x10,%esp 10c113: b8 07 00 00 00 mov $0x7,%eax #endif } 10c118: 8d 65 f4 lea -0xc(%ebp),%esp 10c11b: 5b pop %ebx 10c11c: 5e pop %esi 10c11d: 5f pop %edi 10c11e: c9 leave 10c11f: 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 ); 10c120: 83 ec 0c sub $0xc,%esp 10c123: 8d 43 68 lea 0x68(%ebx),%eax 10c126: 50 push %eax 10c127: e8 ec fe ff ff call 10c018 <_Chain_Get> 10c12c: 89 c2 mov %eax,%edx return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED; #endif _CORE_message_queue_Copy_buffer( buffer, the_message->Contents.buffer, 10c12e: 8d 40 10 lea 0x10(%eax),%eax const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 10c131: 89 c7 mov %eax,%edi 10c133: 8b 4d 10 mov 0x10(%ebp),%ecx 10c136: f3 a4 rep movsb %ds:(%esi),%es:(%edi) size ); the_message->Contents.size = size; 10c138: 8b 4d 10 mov 0x10(%ebp),%ecx 10c13b: 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; 10c13e: 8b 45 1c mov 0x1c(%ebp),%eax 10c141: 89 42 08 mov %eax,0x8(%edx) _CORE_message_queue_Set_message_priority( the_message, submit_type ); _CORE_message_queue_Insert_message( 10c144: 83 c4 0c add $0xc,%esp 10c147: 50 push %eax 10c148: 52 push %edx 10c149: 53 push %ebx 10c14a: e8 61 4f 00 00 call 1110b0 <_CORE_message_queue_Insert_message> the_message_queue, the_message, submit_type ); return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 10c14f: 83 c4 10 add $0x10,%esp 10c152: 31 c0 xor %eax,%eax 10c154: e9 34 ff ff ff jmp 10c08d <_CORE_message_queue_Submit+0x51> 10c159: 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; 10c15c: 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 } 10c161: 8d 65 f4 lea -0xc(%ebp),%esp 10c164: 5b pop %ebx 10c165: 5e pop %esi 10c166: 5f pop %edi 10c167: c9 leave 10c168: c3 ret 10c169: 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 ) { 10c16c: 8b 43 48 mov 0x48(%ebx),%eax 10c16f: e9 e9 fe ff ff jmp 10c05d <_CORE_message_queue_Submit+0x21> =============================================================================== 0010c180 <_CORE_mutex_Initialize>: CORE_mutex_Status _CORE_mutex_Initialize( CORE_mutex_Control *the_mutex, CORE_mutex_Attributes *the_mutex_attributes, uint32_t initial_lock ) { 10c180: 55 push %ebp 10c181: 89 e5 mov %esp,%ebp 10c183: 57 push %edi 10c184: 56 push %esi 10c185: 53 push %ebx 10c186: 83 ec 0c sub $0xc,%esp 10c189: 8b 45 08 mov 0x8(%ebp),%eax 10c18c: 8b 5d 0c mov 0xc(%ebp),%ebx 10c18f: 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; 10c192: 8d 78 40 lea 0x40(%eax),%edi 10c195: b9 04 00 00 00 mov $0x4,%ecx 10c19a: 89 de mov %ebx,%esi 10c19c: f3 a5 rep movsl %ds:(%esi),%es:(%edi) the_mutex->lock = initial_lock; 10c19e: 89 50 50 mov %edx,0x50(%eax) the_mutex->blocked_count = 0; 10c1a1: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax) if ( initial_lock == CORE_MUTEX_LOCKED ) { 10c1a8: 85 d2 test %edx,%edx 10c1aa: 75 30 jne 10c1dc <_CORE_mutex_Initialize+0x5c> the_mutex->nest_count = 1; 10c1ac: c7 40 54 01 00 00 00 movl $0x1,0x54(%eax) the_mutex->holder = _Thread_Executing; 10c1b3: 8b 15 58 7b 12 00 mov 0x127b58,%edx 10c1b9: 89 50 5c mov %edx,0x5c(%eax) the_mutex->holder_id = _Thread_Executing->Object.id; 10c1bc: 8b 4a 08 mov 0x8(%edx),%ecx 10c1bf: 89 48 60 mov %ecx,0x60(%eax) STATES_WAITING_FOR_MUTEX, CORE_MUTEX_TIMEOUT ); return CORE_MUTEX_STATUS_SUCCESSFUL; } 10c1c2: 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 ) || 10c1c5: 83 f9 02 cmp $0x2,%ecx 10c1c8: 74 05 je 10c1cf <_CORE_mutex_Initialize+0x4f> 10c1ca: 83 f9 03 cmp $0x3,%ecx 10c1cd: 75 22 jne 10c1f1 <_CORE_mutex_Initialize+0x71> _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { if ( _Thread_Executing->current_priority < 10c1cf: 8b 48 4c mov 0x4c(%eax),%ecx 10c1d2: 39 4a 14 cmp %ecx,0x14(%edx) 10c1d5: 72 41 jb 10c218 <_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++; 10c1d7: ff 42 1c incl 0x1c(%edx) 10c1da: eb 15 jmp 10c1f1 <_CORE_mutex_Initialize+0x71> } } else { the_mutex->nest_count = 0; 10c1dc: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) the_mutex->holder = NULL; 10c1e3: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax) the_mutex->holder_id = 0; 10c1ea: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax) } _Thread_queue_Initialize( 10c1f1: 6a 05 push $0x5 10c1f3: 68 00 04 00 00 push $0x400 10c1f8: 31 d2 xor %edx,%edx 10c1fa: 83 7b 08 00 cmpl $0x0,0x8(%ebx) 10c1fe: 0f 95 c2 setne %dl 10c201: 52 push %edx 10c202: 50 push %eax 10c203: e8 30 1e 00 00 call 10e038 <_Thread_queue_Initialize> THREAD_QUEUE_DISCIPLINE_FIFO : THREAD_QUEUE_DISCIPLINE_PRIORITY, STATES_WAITING_FOR_MUTEX, CORE_MUTEX_TIMEOUT ); return CORE_MUTEX_STATUS_SUCCESSFUL; 10c208: 83 c4 10 add $0x10,%esp 10c20b: 31 c0 xor %eax,%eax } 10c20d: 8d 65 f4 lea -0xc(%ebp),%esp 10c210: 5b pop %ebx 10c211: 5e pop %esi 10c212: 5f pop %edi 10c213: c9 leave 10c214: c3 ret 10c215: 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; 10c218: b8 06 00 00 00 mov $0x6,%eax STATES_WAITING_FOR_MUTEX, CORE_MUTEX_TIMEOUT ); return CORE_MUTEX_STATUS_SUCCESSFUL; } 10c21d: 8d 65 f4 lea -0xc(%ebp),%esp 10c220: 5b pop %ebx 10c221: 5e pop %esi 10c222: 5f pop %edi 10c223: c9 leave 10c224: c3 ret =============================================================================== 0010c278 <_CORE_mutex_Seize>: Objects_Id _id, bool _wait, Watchdog_Interval _timeout, ISR_Level _level ) { 10c278: 55 push %ebp 10c279: 89 e5 mov %esp,%ebp 10c27b: 53 push %ebx 10c27c: 83 ec 14 sub $0x14,%esp 10c27f: 8b 5d 08 mov 0x8(%ebp),%ebx 10c282: 8a 55 10 mov 0x10(%ebp),%dl _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 10c285: a1 70 75 12 00 mov 0x127570,%eax 10c28a: 85 c0 test %eax,%eax 10c28c: 74 04 je 10c292 <_CORE_mutex_Seize+0x1a> 10c28e: 84 d2 test %dl,%dl 10c290: 75 36 jne 10c2c8 <_CORE_mutex_Seize+0x50><== ALWAYS TAKEN 10c292: 83 ec 08 sub $0x8,%esp 10c295: 8d 45 18 lea 0x18(%ebp),%eax 10c298: 50 push %eax 10c299: 53 push %ebx 10c29a: 88 55 f4 mov %dl,-0xc(%ebp) 10c29d: e8 e6 4e 00 00 call 111188 <_CORE_mutex_Seize_interrupt_trylock> 10c2a2: 83 c4 10 add $0x10,%esp 10c2a5: 85 c0 test %eax,%eax 10c2a7: 8a 55 f4 mov -0xc(%ebp),%dl 10c2aa: 74 14 je 10c2c0 <_CORE_mutex_Seize+0x48> 10c2ac: 84 d2 test %dl,%dl 10c2ae: 75 30 jne 10c2e0 <_CORE_mutex_Seize+0x68> 10c2b0: ff 75 18 pushl 0x18(%ebp) 10c2b3: 9d popf 10c2b4: a1 58 7b 12 00 mov 0x127b58,%eax 10c2b9: c7 40 34 01 00 00 00 movl $0x1,0x34(%eax) } 10c2c0: 8b 5d fc mov -0x4(%ebp),%ebx 10c2c3: c9 leave 10c2c4: c3 ret 10c2c5: 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 ); 10c2c8: 83 3d 40 77 12 00 01 cmpl $0x1,0x127740 10c2cf: 76 c1 jbe 10c292 <_CORE_mutex_Seize+0x1a> 10c2d1: 53 push %ebx 10c2d2: 6a 12 push $0x12 10c2d4: 6a 00 push $0x0 10c2d6: 6a 00 push $0x0 10c2d8: e8 1b 06 00 00 call 10c8f8 <_Internal_error_Occurred> 10c2dd: 8d 76 00 lea 0x0(%esi),%esi 10c2e0: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx) 10c2e7: a1 58 7b 12 00 mov 0x127b58,%eax 10c2ec: 89 58 44 mov %ebx,0x44(%eax) 10c2ef: 8b 55 0c mov 0xc(%ebp),%edx 10c2f2: 89 50 20 mov %edx,0x20(%eax) 10c2f5: a1 70 75 12 00 mov 0x127570,%eax 10c2fa: 40 inc %eax 10c2fb: a3 70 75 12 00 mov %eax,0x127570 10c300: ff 75 18 pushl 0x18(%ebp) 10c303: 9d popf 10c304: 83 ec 08 sub $0x8,%esp 10c307: ff 75 14 pushl 0x14(%ebp) 10c30a: 53 push %ebx 10c30b: e8 18 ff ff ff call 10c228 <_CORE_mutex_Seize_interrupt_blocking> 10c310: 83 c4 10 add $0x10,%esp } 10c313: 8b 5d fc mov -0x4(%ebp),%ebx 10c316: c9 leave 10c317: c3 ret =============================================================================== 00111188 <_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 ) { 111188: 55 push %ebp 111189: 89 e5 mov %esp,%ebp 11118b: 56 push %esi 11118c: 53 push %ebx 11118d: 8b 45 08 mov 0x8(%ebp),%eax 111190: 8b 4d 0c mov 0xc(%ebp),%ecx { Thread_Control *executing; /* disabled when you get here */ executing = _Thread_Executing; 111193: 8b 15 58 7b 12 00 mov 0x127b58,%edx executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 111199: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx) if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 1111a0: 8b 58 50 mov 0x50(%eax),%ebx 1111a3: 85 db test %ebx,%ebx 1111a5: 74 31 je 1111d8 <_CORE_mutex_Seize_interrupt_trylock+0x50> the_mutex->lock = CORE_MUTEX_LOCKED; 1111a7: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) the_mutex->holder = executing; 1111ae: 89 50 5c mov %edx,0x5c(%eax) the_mutex->holder_id = executing->Object.id; 1111b1: 8b 5a 08 mov 0x8(%edx),%ebx 1111b4: 89 58 60 mov %ebx,0x60(%eax) the_mutex->nest_count = 1; 1111b7: c7 40 54 01 00 00 00 movl $0x1,0x54(%eax) return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p ); } 1111be: 8b 58 48 mov 0x48(%eax),%ebx if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 1111c1: 83 fb 02 cmp $0x2,%ebx 1111c4: 74 26 je 1111ec <_CORE_mutex_Seize_interrupt_trylock+0x64> 1111c6: 83 fb 03 cmp $0x3,%ebx 1111c9: 74 3d je 111208 <_CORE_mutex_Seize_interrupt_trylock+0x80> executing->resource_count++; } if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { _ISR_Enable( *level_p ); 1111cb: ff 31 pushl (%ecx) 1111cd: 9d popf return 0; 1111ce: 31 c0 xor %eax,%eax 1111d0: 8d 65 f8 lea -0x8(%ebp),%esp 1111d3: 5b pop %ebx 1111d4: 5e pop %esi 1111d5: c9 leave 1111d6: c3 ret 1111d7: 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 ) ) { 1111d8: 3b 50 5c cmp 0x5c(%eax),%edx 1111db: 74 17 je 1111f4 <_CORE_mutex_Seize_interrupt_trylock+0x6c> /* * The mutex is not available and the caller must deal with the possibility * of blocking. */ return 1; 1111dd: b8 01 00 00 00 mov $0x1,%eax 1111e2: 8d 65 f8 lea -0x8(%ebp),%esp 1111e5: 5b pop %ebx 1111e6: 5e pop %esi 1111e7: c9 leave 1111e8: c3 ret 1111e9: 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++; 1111ec: ff 42 1c incl 0x1c(%edx) 1111ef: eb da jmp 1111cb <_CORE_mutex_Seize_interrupt_trylock+0x43> 1111f1: 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 ) { 1111f4: 8b 58 40 mov 0x40(%eax),%ebx 1111f7: 85 db test %ebx,%ebx 1111f9: 75 45 jne 111240 <_CORE_mutex_Seize_interrupt_trylock+0xb8> case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 1111fb: ff 40 54 incl 0x54(%eax) _ISR_Enable( *level_p ); 1111fe: ff 31 pushl (%ecx) 111200: 9d popf return 0; 111201: 31 c0 xor %eax,%eax 111203: eb dd jmp 1111e2 <_CORE_mutex_Seize_interrupt_trylock+0x5a> 111205: 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++; 111208: 8b 5a 1c mov 0x1c(%edx),%ebx 11120b: 8d 73 01 lea 0x1(%ebx),%esi 11120e: 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 ) { 111211: 8b 72 14 mov 0x14(%edx),%esi 111214: 39 70 4c cmp %esi,0x4c(%eax) 111217: 74 6b je 111284 <_CORE_mutex_Seize_interrupt_trylock+0xfc> _ISR_Enable( *level_p ); return 0; } if ( current > ceiling ) { 111219: 72 39 jb 111254 <_CORE_mutex_Seize_interrupt_trylock+0xcc> ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 11121b: c7 42 34 06 00 00 00 movl $0x6,0x34(%edx) the_mutex->lock = CORE_MUTEX_UNLOCKED; 111222: c7 40 50 01 00 00 00 movl $0x1,0x50(%eax) the_mutex->nest_count = 0; /* undo locking above */ 111229: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) executing->resource_count--; /* undo locking above */ 111230: 89 5a 1c mov %ebx,0x1c(%edx) _ISR_Enable( *level_p ); 111233: ff 31 pushl (%ecx) 111235: 9d popf return 0; 111236: 31 c0 xor %eax,%eax 111238: 8d 65 f8 lea -0x8(%ebp),%esp 11123b: 5b pop %ebx 11123c: 5e pop %esi 11123d: c9 leave 11123e: c3 ret 11123f: 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 ) { 111240: 4b dec %ebx 111241: 75 9a jne 1111dd <_CORE_mutex_Seize_interrupt_trylock+0x55> case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; _ISR_Enable( *level_p ); return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 111243: c7 42 34 02 00 00 00 movl $0x2,0x34(%edx) _ISR_Enable( *level_p ); 11124a: ff 31 pushl (%ecx) 11124c: 9d popf return 0; 11124d: 31 c0 xor %eax,%eax 11124f: eb 91 jmp 1111e2 <_CORE_mutex_Seize_interrupt_trylock+0x5a> 111251: 8d 76 00 lea 0x0(%esi),%esi rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 111254: 8b 15 70 75 12 00 mov 0x127570,%edx 11125a: 42 inc %edx 11125b: 89 15 70 75 12 00 mov %edx,0x127570 return 0; } if ( current > ceiling ) { _Thread_Disable_dispatch(); _ISR_Enable( *level_p ); 111261: ff 31 pushl (%ecx) 111263: 9d popf _Thread_Change_priority( 111264: 52 push %edx 111265: 6a 00 push $0x0 111267: ff 70 4c pushl 0x4c(%eax) 11126a: ff 70 5c pushl 0x5c(%eax) 11126d: e8 ce c1 ff ff call 10d440 <_Thread_Change_priority> the_mutex->holder, the_mutex->Attributes.priority_ceiling, false ); _Thread_Enable_dispatch(); 111272: e8 7d c6 ff ff call 10d8f4 <_Thread_Enable_dispatch> 111277: 83 c4 10 add $0x10,%esp return 0; 11127a: 31 c0 xor %eax,%eax 11127c: e9 61 ff ff ff jmp 1111e2 <_CORE_mutex_Seize_interrupt_trylock+0x5a> 111281: 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 ); 111284: ff 31 pushl (%ecx) 111286: 9d popf return 0; 111287: 31 c0 xor %eax,%eax 111289: e9 54 ff ff ff jmp 1111e2 <_CORE_mutex_Seize_interrupt_trylock+0x5a> =============================================================================== 0010c318 <_CORE_mutex_Surrender>: #else Objects_Id id __attribute__((unused)), CORE_mutex_API_mp_support_callout api_mutex_mp_support __attribute__((unused)) #endif ) { 10c318: 55 push %ebp 10c319: 89 e5 mov %esp,%ebp 10c31b: 53 push %ebx 10c31c: 83 ec 04 sub $0x4,%esp 10c31f: 8b 5d 08 mov 0x8(%ebp),%ebx Thread_Control *the_thread; Thread_Control *holder; holder = the_mutex->holder; 10c322: 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 ) { 10c325: 80 7b 44 00 cmpb $0x0,0x44(%ebx) 10c329: 74 15 je 10c340 <_CORE_mutex_Surrender+0x28> if ( !_Thread_Is_executing( holder ) ) 10c32b: 3b 05 58 7b 12 00 cmp 0x127b58,%eax 10c331: 74 0d je 10c340 <_CORE_mutex_Surrender+0x28> return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE; 10c333: b8 03 00 00 00 mov $0x3,%eax } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; return CORE_MUTEX_STATUS_SUCCESSFUL; } 10c338: 8b 5d fc mov -0x4(%ebp),%ebx 10c33b: c9 leave 10c33c: c3 ret 10c33d: 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 ) 10c340: 8b 53 54 mov 0x54(%ebx),%edx 10c343: 85 d2 test %edx,%edx 10c345: 74 51 je 10c398 <_CORE_mutex_Surrender+0x80> return CORE_MUTEX_STATUS_SUCCESSFUL; the_mutex->nest_count--; 10c347: 4a dec %edx 10c348: 89 53 54 mov %edx,0x54(%ebx) if ( the_mutex->nest_count != 0 ) { 10c34b: 85 d2 test %edx,%edx 10c34d: 75 49 jne 10c398 <_CORE_mutex_Surrender+0x80> } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; return CORE_MUTEX_STATUS_SUCCESSFUL; } 10c34f: 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 ) || 10c352: 83 fa 02 cmp $0x2,%edx 10c355: 74 69 je 10c3c0 <_CORE_mutex_Surrender+0xa8> 10c357: 83 fa 03 cmp $0x3,%edx 10c35a: 74 64 je 10c3c0 <_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; 10c35c: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) the_mutex->holder_id = 0; 10c363: 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 ) ) ) { 10c36a: 83 ec 0c sub $0xc,%esp 10c36d: 53 push %ebx 10c36e: e8 35 19 00 00 call 10dca8 <_Thread_queue_Dequeue> 10c373: 83 c4 10 add $0x10,%esp 10c376: 85 c0 test %eax,%eax 10c378: 74 7a je 10c3f4 <_CORE_mutex_Surrender+0xdc> } else #endif { the_mutex->holder = the_thread; 10c37a: 89 43 5c mov %eax,0x5c(%ebx) the_mutex->holder_id = the_thread->Object.id; 10c37d: 8b 50 08 mov 0x8(%eax),%edx 10c380: 89 53 60 mov %edx,0x60(%ebx) the_mutex->nest_count = 1; 10c383: c7 43 54 01 00 00 00 movl $0x1,0x54(%ebx) switch ( the_mutex->Attributes.discipline ) { 10c38a: 8b 53 48 mov 0x48(%ebx),%edx 10c38d: 83 fa 02 cmp $0x2,%edx 10c390: 74 56 je 10c3e8 <_CORE_mutex_Surrender+0xd0> 10c392: 83 fa 03 cmp $0x3,%edx 10c395: 74 09 je 10c3a0 <_CORE_mutex_Surrender+0x88> 10c397: 90 nop } } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; return CORE_MUTEX_STATUS_SUCCESSFUL; 10c398: 31 c0 xor %eax,%eax } 10c39a: 8b 5d fc mov -0x4(%ebp),%ebx 10c39d: c9 leave 10c39e: c3 ret 10c39f: 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++; 10c3a0: ff 40 1c incl 0x1c(%eax) if (the_mutex->Attributes.priority_ceiling < 10c3a3: 8b 53 4c mov 0x4c(%ebx),%edx 10c3a6: 3b 50 14 cmp 0x14(%eax),%edx 10c3a9: 73 ed jae 10c398 <_CORE_mutex_Surrender+0x80> the_thread->current_priority){ _Thread_Change_priority( 10c3ab: 51 push %ecx 10c3ac: 6a 00 push $0x0 10c3ae: 52 push %edx 10c3af: 50 push %eax 10c3b0: e8 8b 10 00 00 call 10d440 <_Thread_Change_priority> 10c3b5: 83 c4 10 add $0x10,%esp } } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; return CORE_MUTEX_STATUS_SUCCESSFUL; 10c3b8: 31 c0 xor %eax,%eax 10c3ba: e9 79 ff ff ff jmp 10c338 <_CORE_mutex_Surrender+0x20> 10c3bf: 90 nop _CORE_mutex_Pop_priority( the_mutex, holder ); if ( pop_status != CORE_MUTEX_STATUS_SUCCESSFUL ) return pop_status; holder->resource_count--; 10c3c0: 8b 50 1c mov 0x1c(%eax),%edx 10c3c3: 4a dec %edx 10c3c4: 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 && 10c3c7: 85 d2 test %edx,%edx 10c3c9: 75 91 jne 10c35c <_CORE_mutex_Surrender+0x44> holder->real_priority != holder->current_priority ) { 10c3cb: 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 && 10c3ce: 3b 50 14 cmp 0x14(%eax),%edx 10c3d1: 74 89 je 10c35c <_CORE_mutex_Surrender+0x44> holder->real_priority != holder->current_priority ) { _Thread_Change_priority( holder, holder->real_priority, true ); 10c3d3: 51 push %ecx 10c3d4: 6a 01 push $0x1 10c3d6: 52 push %edx 10c3d7: 50 push %eax 10c3d8: e8 63 10 00 00 call 10d440 <_Thread_Change_priority> 10c3dd: 83 c4 10 add $0x10,%esp 10c3e0: e9 77 ff ff ff jmp 10c35c <_CORE_mutex_Surrender+0x44> 10c3e5: 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++; 10c3e8: ff 40 1c incl 0x1c(%eax) } } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; return CORE_MUTEX_STATUS_SUCCESSFUL; 10c3eb: 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; 10c3ed: e9 46 ff ff ff jmp 10c338 <_CORE_mutex_Surrender+0x20> 10c3f2: 66 90 xchg %ax,%ax } break; } } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; 10c3f4: c7 43 50 01 00 00 00 movl $0x1,0x50(%ebx) return CORE_MUTEX_STATUS_SUCCESSFUL; 10c3fb: 31 c0 xor %eax,%eax 10c3fd: e9 36 ff ff ff jmp 10c338 <_CORE_mutex_Surrender+0x20> =============================================================================== 00115298 <_CORE_semaphore_Seize>: CORE_semaphore_Control *the_semaphore, Objects_Id id, bool wait, Watchdog_Interval timeout ) { 115298: 55 push %ebp 115299: 89 e5 mov %esp,%ebp 11529b: 57 push %edi 11529c: 56 push %esi 11529d: 53 push %ebx 11529e: 83 ec 1c sub $0x1c,%esp 1152a1: 8b 45 08 mov 0x8(%ebp),%eax 1152a4: 8b 7d 0c mov 0xc(%ebp),%edi 1152a7: 8b 75 14 mov 0x14(%ebp),%esi 1152aa: 8a 5d 10 mov 0x10(%ebp),%bl Thread_Control *executing; ISR_Level level; executing = _Thread_Executing; 1152ad: 8b 15 d8 d8 12 00 mov 0x12d8d8,%edx executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 1152b3: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx) _ISR_Disable( level ); 1152ba: 9c pushf 1152bb: fa cli 1152bc: 8f 45 e4 popl -0x1c(%ebp) if ( the_semaphore->count != 0 ) { 1152bf: 8b 48 48 mov 0x48(%eax),%ecx 1152c2: 85 c9 test %ecx,%ecx 1152c4: 75 46 jne 11530c <_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 ) { 1152c6: 84 db test %bl,%bl 1152c8: 75 16 jne 1152e0 <_CORE_semaphore_Seize+0x48> _ISR_Enable( level ); 1152ca: ff 75 e4 pushl -0x1c(%ebp) 1152cd: 9d popf executing->Wait.return_code = CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT; 1152ce: 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 ); } 1152d5: 83 c4 1c add $0x1c,%esp 1152d8: 5b pop %ebx 1152d9: 5e pop %esi 1152da: 5f pop %edi 1152db: c9 leave 1152dc: c3 ret 1152dd: 8d 76 00 lea 0x0(%esi),%esi 1152e0: 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; 1152e7: 89 42 44 mov %eax,0x44(%edx) executing->Wait.id = id; 1152ea: 89 7a 20 mov %edi,0x20(%edx) _ISR_Enable( level ); 1152ed: ff 75 e4 pushl -0x1c(%ebp) 1152f0: 9d popf _Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout ); 1152f1: c7 45 10 20 1b 11 00 movl $0x111b20,0x10(%ebp) 1152f8: 89 75 0c mov %esi,0xc(%ebp) 1152fb: 89 45 08 mov %eax,0x8(%ebp) } 1152fe: 83 c4 1c add $0x1c,%esp 115301: 5b pop %ebx 115302: 5e pop %esi 115303: 5f pop %edi 115304: 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 ); 115305: e9 ea c4 ff ff jmp 1117f4 <_Thread_queue_Enqueue_with_handler> 11530a: 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; 11530c: 49 dec %ecx 11530d: 89 48 48 mov %ecx,0x48(%eax) _ISR_Enable( level ); 115310: ff 75 e4 pushl -0x1c(%ebp) 115313: 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 ); } 115314: 83 c4 1c add $0x1c,%esp 115317: 5b pop %ebx 115318: 5e pop %esi 115319: 5f pop %edi 11531a: c9 leave 11531b: c3 ret =============================================================================== 0010c450 <_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 ) { 10c450: 55 push %ebp 10c451: 89 e5 mov %esp,%ebp 10c453: 53 push %ebx 10c454: 83 ec 10 sub $0x10,%esp 10c457: 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)) ) { 10c45a: 53 push %ebx 10c45b: e8 48 18 00 00 call 10dca8 <_Thread_queue_Dequeue> 10c460: 83 c4 10 add $0x10,%esp 10c463: 85 c0 test %eax,%eax 10c465: 74 09 je 10c470 <_CORE_semaphore_Surrender+0x20> { Thread_Control *the_thread; ISR_Level level; CORE_semaphore_Status status; status = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 10c467: 31 c0 xor %eax,%eax status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED; _ISR_Enable( level ); } return status; } 10c469: 8b 5d fc mov -0x4(%ebp),%ebx 10c46c: c9 leave 10c46d: c3 ret 10c46e: 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 ); 10c470: 9c pushf 10c471: fa cli 10c472: 5a pop %edx if ( the_semaphore->count < the_semaphore->Attributes.maximum_count ) 10c473: 8b 43 48 mov 0x48(%ebx),%eax 10c476: 3b 43 40 cmp 0x40(%ebx),%eax 10c479: 72 0d jb 10c488 <_CORE_semaphore_Surrender+0x38><== ALWAYS TAKEN the_semaphore->count += 1; else status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED; 10c47b: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED _ISR_Enable( level ); 10c480: 52 push %edx 10c481: 9d popf } return status; } 10c482: 8b 5d fc mov -0x4(%ebp),%ebx 10c485: c9 leave 10c486: c3 ret 10c487: 90 nop #endif } else { _ISR_Disable( level ); if ( the_semaphore->count < the_semaphore->Attributes.maximum_count ) the_semaphore->count += 1; 10c488: 40 inc %eax 10c489: 89 43 48 mov %eax,0x48(%ebx) { Thread_Control *the_thread; ISR_Level level; CORE_semaphore_Status status; status = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 10c48c: 31 c0 xor %eax,%eax 10c48e: eb f0 jmp 10c480 <_CORE_semaphore_Surrender+0x30> =============================================================================== 0010c6b0 <_Chain_Get_with_empty_check>: bool _Chain_Get_with_empty_check( Chain_Control *chain, Chain_Node **node ) { 10c6b0: 55 push %ebp 10c6b1: 89 e5 mov %esp,%ebp 10c6b3: 57 push %edi 10c6b4: 56 push %esi 10c6b5: 53 push %ebx 10c6b6: 8b 45 08 mov 0x8(%ebp),%eax 10c6b9: 8b 7d 0c mov 0xc(%ebp),%edi ISR_Level level; bool is_empty_now; _ISR_Disable( level ); 10c6bc: 9c pushf 10c6bd: fa cli 10c6be: 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 ); 10c6bf: 8d 58 04 lea 0x4(%eax),%ebx Chain_Node *old_first = head->next; 10c6c2: 8b 10 mov (%eax),%edx if ( old_first != tail ) { 10c6c4: 39 d3 cmp %edx,%ebx 10c6c6: 74 18 je 10c6e0 <_Chain_Get_with_empty_check+0x30> Chain_Node *new_first = old_first->next; 10c6c8: 8b 0a mov (%edx),%ecx head->next = new_first; 10c6ca: 89 08 mov %ecx,(%eax) new_first->previous = head; 10c6cc: 89 41 04 mov %eax,0x4(%ecx) *the_node = old_first; 10c6cf: 89 17 mov %edx,(%edi) is_empty_now = new_first == tail; 10c6d1: 39 cb cmp %ecx,%ebx 10c6d3: 0f 94 c0 sete %al is_empty_now = _Chain_Get_with_empty_check_unprotected( chain, node ); _ISR_Enable( level ); 10c6d6: 56 push %esi 10c6d7: 9d popf return is_empty_now; } 10c6d8: 5b pop %ebx 10c6d9: 5e pop %esi 10c6da: 5f pop %edi 10c6db: c9 leave 10c6dc: c3 ret 10c6dd: 8d 76 00 lea 0x0(%esi),%esi } else *the_node = NULL; 10c6e0: 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; 10c6e6: b0 01 mov $0x1,%al 10c6e8: eb ec jmp 10c6d6 <_Chain_Get_with_empty_check+0x26> =============================================================================== 00111054 <_Chain_Initialize>: Chain_Control *the_chain, void *starting_address, size_t number_nodes, size_t node_size ) { 111054: 55 push %ebp 111055: 89 e5 mov %esp,%ebp 111057: 57 push %edi 111058: 56 push %esi 111059: 53 push %ebx 11105a: 83 ec 08 sub $0x8,%esp 11105d: 8b 7d 08 mov 0x8(%ebp),%edi 111060: 8b 4d 10 mov 0x10(%ebp),%ecx 111063: 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 ); 111066: 8d 47 04 lea 0x4(%edi),%eax 111069: 89 45 f0 mov %eax,-0x10(%ebp) Chain_Node *current = head; Chain_Node *next = starting_address; head->previous = NULL; 11106c: c7 47 04 00 00 00 00 movl $0x0,0x4(%edi) while ( count-- ) { 111073: 85 c9 test %ecx,%ecx 111075: 74 35 je 1110ac <_Chain_Initialize+0x58><== NEVER TAKEN 111077: 49 dec %ecx 111078: 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; 11107b: 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; 11107e: 89 fa mov %edi,%edx 111080: eb 07 jmp 111089 <_Chain_Initialize+0x35> 111082: 66 90 xchg %ax,%ax Chain_Node *next = starting_address; head->previous = NULL; while ( count-- ) { 111084: 89 c2 mov %eax,%edx current->next = next; next->previous = current; current = next; next = (Chain_Node *) 111086: 89 d8 mov %ebx,%eax 111088: 49 dec %ecx Chain_Node *next = starting_address; head->previous = NULL; while ( count-- ) { current->next = next; 111089: 89 02 mov %eax,(%edx) next->previous = current; 11108b: 89 50 04 mov %edx,0x4(%eax) * node_size - size of node in bytes * * Output parameters: NONE */ void _Chain_Initialize( 11108e: 8d 1c 30 lea (%eax,%esi,1),%ebx Chain_Node *current = head; Chain_Node *next = starting_address; head->previous = NULL; while ( count-- ) { 111091: 85 c9 test %ecx,%ecx 111093: 75 ef jne 111084 <_Chain_Initialize+0x30> * node_size - size of node in bytes * * Output parameters: NONE */ void _Chain_Initialize( 111095: 0f af 75 ec imul -0x14(%ebp),%esi 111099: 03 75 0c add 0xc(%ebp),%esi current = next; next = (Chain_Node *) _Addresses_Add_offset( (void *) next, node_size ); } current->next = tail; 11109c: 8b 45 f0 mov -0x10(%ebp),%eax 11109f: 89 06 mov %eax,(%esi) tail->previous = current; 1110a1: 89 77 08 mov %esi,0x8(%edi) } 1110a4: 83 c4 08 add $0x8,%esp 1110a7: 5b pop %ebx 1110a8: 5e pop %esi 1110a9: 5f pop %edi 1110aa: c9 leave 1110ab: 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; 1110ac: 89 fe mov %edi,%esi <== NOT EXECUTED 1110ae: eb ec jmp 11109c <_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 58 7b 12 00 mov 0x127b58,%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 88 7f 12 00 01 movl $0x1,0x127f88 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 6a 30 00 00 call 10e158 <_Thread_Set_state> _ISR_Disable( level ); 10b0ee: 9c pushf 10b0ef: fa cli 10b0f0: 5a pop %edx sync_state = _Event_Sync_state; 10b0f1: a1 88 7f 12 00 mov 0x127f88,%eax _Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10b0f6: c7 05 88 7f 12 00 00 movl $0x0,0x127f88 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 d7 22 00 00 jmp 10d3f4 <_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 7c 76 12 00 push $0x12767c 10b18d: e8 66 35 00 00 call 10e6f8 <_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 54 7b 12 00 mov 0x127b54,%esi 10b21e: 85 f6 test %esi,%esi 10b220: 74 0c je 10b22e <_Event_Surrender+0x3e> 10b222: 3b 1d 58 7b 12 00 cmp 0x127b58,%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 01 23 00 00 call 10d574 <_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 89 35 00 00 call 10e838 <_Watchdog_Remove> 10b2af: 58 pop %eax 10b2b0: 5a pop %edx 10b2b1: 68 f8 ff 03 10 push $0x1003fff8 10b2b6: 53 push %ebx 10b2b7: e8 b8 22 00 00 call 10d574 <_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 88 7f 12 00 mov 0x127f88,%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 88 7f 12 00 mov 0x127f88,%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 88 7f 12 00 03 movl $0x3,0x127f88 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 f2 25 00 00 call 10d918 <_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 58 7b 12 00 cmp 0x127b58,%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 1b 22 00 00 call 10d574 <_Thread_Clear_state> */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 10b359: a1 70 75 12 00 mov 0x127570,%eax 10b35e: 48 dec %eax 10b35f: a3 70 75 12 00 mov %eax,0x127570 _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 88 7f 12 00 mov 0x127f88,%ecx 10b372: 49 dec %ecx 10b373: 75 cd jne 10b342 <_Event_Timeout+0x2e> _Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; 10b375: c7 05 88 7f 12 00 02 movl $0x2,0x127f88 10b37c: 00 00 00 10b37f: eb c1 jmp 10b342 <_Event_Timeout+0x2e> =============================================================================== 001112e4 <_Heap_Allocate_aligned_with_boundary>: Heap_Control *heap, uintptr_t alloc_size, uintptr_t alignment, uintptr_t boundary ) { 1112e4: 55 push %ebp 1112e5: 89 e5 mov %esp,%ebp 1112e7: 57 push %edi 1112e8: 56 push %esi 1112e9: 53 push %ebx 1112ea: 83 ec 2c sub $0x2c,%esp 1112ed: 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 1112f0: 8d 47 04 lea 0x4(%edi),%eax 1112f3: 89 45 dc mov %eax,-0x24(%ebp) - HEAP_ALLOC_BONUS; uintptr_t const page_size = heap->page_size; 1112f6: 8b 55 08 mov 0x8(%ebp),%edx 1112f9: 8b 52 10 mov 0x10(%edx),%edx 1112fc: 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 ) { 1112ff: 39 c7 cmp %eax,%edi 111301: 0f 87 69 01 00 00 ja 111470 <_Heap_Allocate_aligned_with_boundary+0x18c> /* Integer overflow occured */ return NULL; } if ( boundary != 0 ) { 111307: 8b 5d 14 mov 0x14(%ebp),%ebx 11130a: 85 db test %ebx,%ebx 11130c: 0f 85 56 01 00 00 jne 111468 <_Heap_Allocate_aligned_with_boundary+0x184> if ( stats->max_search < search_count ) { stats->max_search = search_count; } return (void *) alloc_begin; } 111312: 8b 45 08 mov 0x8(%ebp),%eax 111315: 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 ) { 111318: 39 c8 cmp %ecx,%eax 11131a: 0f 84 50 01 00 00 je 111470 <_Heap_Allocate_aligned_with_boundary+0x18c> 111320: 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 111327: 8b 55 cc mov -0x34(%ebp),%edx 11132a: 83 c2 07 add $0x7,%edx 11132d: 89 55 c8 mov %edx,-0x38(%ebp) + HEAP_BLOCK_HEADER_SIZE + page_size - 1; uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS; 111330: c7 45 d0 04 00 00 00 movl $0x4,-0x30(%ebp) 111337: 29 7d d0 sub %edi,-0x30(%ebp) 11133a: eb 1e jmp 11135a <_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; 11133c: 8d 59 08 lea 0x8(%ecx),%ebx } /* Statistics */ ++search_count; if ( alloc_begin != 0 ) { 11133f: 85 db test %ebx,%ebx 111341: 0f 85 f1 00 00 00 jne 111438 <_Heap_Allocate_aligned_with_boundary+0x154><== ALWAYS TAKEN break; } block = block->next; 111347: 8b 49 08 mov 0x8(%ecx),%ecx 11134a: 8b 45 e4 mov -0x1c(%ebp),%eax 11134d: 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 ) { 11134e: 39 4d 08 cmp %ecx,0x8(%ebp) 111351: 0f 84 25 01 00 00 je 11147c <_Heap_Allocate_aligned_with_boundary+0x198> 111357: 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 ) { 11135a: 8b 59 04 mov 0x4(%ecx),%ebx 11135d: 39 5d dc cmp %ebx,-0x24(%ebp) 111360: 73 e5 jae 111347 <_Heap_Allocate_aligned_with_boundary+0x63> if ( alignment == 0 ) { 111362: 8b 55 10 mov 0x10(%ebp),%edx 111365: 85 d2 test %edx,%edx 111367: 74 d3 je 11133c <_Heap_Allocate_aligned_with_boundary+0x58> if ( stats->max_search < search_count ) { stats->max_search = search_count; } return (void *) alloc_begin; } 111369: 8b 45 08 mov 0x8(%ebp),%eax 11136c: 8b 40 14 mov 0x14(%eax),%eax 11136f: 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; 111372: 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; 111375: 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; 111378: 8d 51 08 lea 0x8(%ecx),%edx 11137b: 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; 11137e: 8b 75 c8 mov -0x38(%ebp),%esi 111381: 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 111383: 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; 111385: 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); 111388: 89 d8 mov %ebx,%eax 11138a: 31 d2 xor %edx,%edx 11138c: f7 75 10 divl 0x10(%ebp) 11138f: 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 ) { 111391: 39 de cmp %ebx,%esi 111393: 73 0b jae 1113a0 <_Heap_Allocate_aligned_with_boundary+0xbc> 111395: 89 f0 mov %esi,%eax 111397: 31 d2 xor %edx,%edx 111399: f7 75 10 divl 0x10(%ebp) 11139c: 89 f3 mov %esi,%ebx 11139e: 29 d3 sub %edx,%ebx } alloc_end = alloc_begin + alloc_size; /* Ensure boundary constaint */ if ( boundary != 0 ) { 1113a0: 8b 45 14 mov 0x14(%ebp),%eax 1113a3: 85 c0 test %eax,%eax 1113a5: 74 5b je 111402 <_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; 1113a7: 8d 34 3b lea (%ebx,%edi,1),%esi 1113aa: 89 f0 mov %esi,%eax 1113ac: 31 d2 xor %edx,%edx 1113ae: f7 75 14 divl 0x14(%ebp) 1113b1: 89 f0 mov %esi,%eax 1113b3: 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 ) { 1113b5: 39 c3 cmp %eax,%ebx 1113b7: 73 49 jae 111402 <_Heap_Allocate_aligned_with_boundary+0x11e> 1113b9: 39 c6 cmp %eax,%esi 1113bb: 76 45 jbe 111402 <_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; 1113bd: 8b 55 d4 mov -0x2c(%ebp),%edx 1113c0: 01 fa add %edi,%edx 1113c2: 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 ) { 1113c5: 39 c2 cmp %eax,%edx 1113c7: 0f 87 7a ff ff ff ja 111347 <_Heap_Allocate_aligned_with_boundary+0x63> 1113cd: 89 ce mov %ecx,%esi 1113cf: eb 10 jmp 1113e1 <_Heap_Allocate_aligned_with_boundary+0xfd> 1113d1: 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 ) { 1113d4: 39 c1 cmp %eax,%ecx 1113d6: 76 28 jbe 111400 <_Heap_Allocate_aligned_with_boundary+0x11c> if ( boundary_line < boundary_floor ) { 1113d8: 39 45 e0 cmp %eax,-0x20(%ebp) 1113db: 0f 87 9f 00 00 00 ja 111480 <_Heap_Allocate_aligned_with_boundary+0x19c><== NEVER TAKEN return 0; } alloc_begin = boundary_line - alloc_size; 1113e1: 89 c3 mov %eax,%ebx 1113e3: 29 fb sub %edi,%ebx 1113e5: 89 d8 mov %ebx,%eax 1113e7: 31 d2 xor %edx,%edx 1113e9: f7 75 10 divl 0x10(%ebp) 1113ec: 29 d3 sub %edx,%ebx alloc_begin = _Heap_Align_down( alloc_begin, alignment ); alloc_end = alloc_begin + alloc_size; 1113ee: 8d 0c 3b lea (%ebx,%edi,1),%ecx 1113f1: 89 c8 mov %ecx,%eax 1113f3: 31 d2 xor %edx,%edx 1113f5: f7 75 14 divl 0x14(%ebp) 1113f8: 89 c8 mov %ecx,%eax 1113fa: 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 ) { 1113fc: 39 c3 cmp %eax,%ebx 1113fe: 72 d4 jb 1113d4 <_Heap_Allocate_aligned_with_boundary+0xf0> 111400: 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 ) { 111402: 39 5d d4 cmp %ebx,-0x2c(%ebp) 111405: 0f 87 3c ff ff ff ja 111347 <_Heap_Allocate_aligned_with_boundary+0x63> 11140b: be f8 ff ff ff mov $0xfffffff8,%esi 111410: 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); 111412: 01 de add %ebx,%esi RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 111414: 89 d8 mov %ebx,%eax 111416: 31 d2 xor %edx,%edx 111418: 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; 11141b: 29 d6 sub %edx,%esi if ( free_size >= min_block_size || free_size == 0 ) { 11141d: 39 75 d8 cmp %esi,-0x28(%ebp) 111420: 0f 86 19 ff ff ff jbe 11133f <_Heap_Allocate_aligned_with_boundary+0x5b> 111426: 85 f6 test %esi,%esi 111428: 0f 85 19 ff ff ff jne 111347 <_Heap_Allocate_aligned_with_boundary+0x63> } /* Statistics */ ++search_count; if ( alloc_begin != 0 ) { 11142e: 85 db test %ebx,%ebx 111430: 0f 84 11 ff ff ff je 111347 <_Heap_Allocate_aligned_with_boundary+0x63><== NEVER TAKEN 111436: 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; 111438: 8b 45 08 mov 0x8(%ebp),%eax 11143b: ff 40 48 incl 0x48(%eax) stats->searches += search_count; 11143e: 8b 55 e4 mov -0x1c(%ebp),%edx 111441: 01 50 4c add %edx,0x4c(%eax) block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size ); 111444: 57 push %edi 111445: 53 push %ebx 111446: 51 push %ecx 111447: 50 push %eax 111448: e8 b7 b3 ff ff call 10c804 <_Heap_Block_allocate> 11144d: 89 d8 mov %ebx,%eax 11144f: 83 c4 10 add $0x10,%esp boundary ); } /* Statistics */ if ( stats->max_search < search_count ) { 111452: 8b 55 e4 mov -0x1c(%ebp),%edx 111455: 8b 4d 08 mov 0x8(%ebp),%ecx 111458: 39 51 44 cmp %edx,0x44(%ecx) 11145b: 73 15 jae 111472 <_Heap_Allocate_aligned_with_boundary+0x18e> stats->max_search = search_count; 11145d: 89 51 44 mov %edx,0x44(%ecx) } return (void *) alloc_begin; } 111460: 8d 65 f4 lea -0xc(%ebp),%esp 111463: 5b pop %ebx 111464: 5e pop %esi 111465: 5f pop %edi 111466: c9 leave 111467: c3 ret /* Integer overflow occured */ return NULL; } if ( boundary != 0 ) { if ( boundary < alloc_size ) { 111468: 3b 7d 14 cmp 0x14(%ebp),%edi 11146b: 76 1a jbe 111487 <_Heap_Allocate_aligned_with_boundary+0x1a3> 11146d: 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 ) { 111470: 31 c0 xor %eax,%eax if ( stats->max_search < search_count ) { stats->max_search = search_count; } return (void *) alloc_begin; } 111472: 8d 65 f4 lea -0xc(%ebp),%esp 111475: 5b pop %ebx 111476: 5e pop %esi 111477: 5f pop %edi 111478: c9 leave 111479: c3 ret 11147a: 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 ) { 11147c: 31 c0 xor %eax,%eax 11147e: eb d2 jmp 111452 <_Heap_Allocate_aligned_with_boundary+0x16e> 111480: 89 f1 mov %esi,%ecx <== NOT EXECUTED 111482: e9 c0 fe ff ff jmp 111347 <_Heap_Allocate_aligned_with_boundary+0x63><== NOT EXECUTED if ( boundary != 0 ) { if ( boundary < alloc_size ) { return NULL; } if ( alignment == 0 ) { 111487: 8b 4d 10 mov 0x10(%ebp),%ecx 11148a: 85 c9 test %ecx,%ecx 11148c: 0f 85 80 fe ff ff jne 111312 <_Heap_Allocate_aligned_with_boundary+0x2e> alignment = page_size; 111492: 89 55 10 mov %edx,0x10(%ebp) 111495: e9 78 fe ff ff jmp 111312 <_Heap_Allocate_aligned_with_boundary+0x2e> =============================================================================== 00111888 <_Heap_Extend>: Heap_Control *heap, void *extend_area_begin_ptr, uintptr_t extend_area_size, uintptr_t *extended_size_ptr ) { 111888: 55 push %ebp 111889: 89 e5 mov %esp,%ebp 11188b: 57 push %edi 11188c: 56 push %esi 11188d: 53 push %ebx 11188e: 83 ec 4c sub $0x4c,%esp 111891: 8b 5d 08 mov 0x8(%ebp),%ebx 111894: 8b 4d 10 mov 0x10(%ebp),%ecx Heap_Statistics *const stats = &heap->stats; Heap_Block *const first_block = heap->first_block; 111897: 8b 43 20 mov 0x20(%ebx),%eax 11189a: 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; 11189d: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) Heap_Block *extend_last_block = NULL; 1118a4: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) uintptr_t const page_size = heap->page_size; 1118ab: 8b 53 10 mov 0x10(%ebx),%edx 1118ae: 89 55 d4 mov %edx,-0x2c(%ebp) uintptr_t const min_block_size = heap->min_block_size; 1118b1: 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; 1118b4: 8b 73 30 mov 0x30(%ebx),%esi 1118b7: 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 ) { 1118ba: 8b 55 0c mov 0xc(%ebp),%edx 1118bd: 01 ca add %ecx,%edx 1118bf: 89 55 cc mov %edx,-0x34(%ebp) 1118c2: 73 0c jae 1118d0 <_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; 1118c4: 31 c0 xor %eax,%eax if ( extended_size_ptr != NULL ) *extended_size_ptr = extended_size; return true; } 1118c6: 8d 65 f4 lea -0xc(%ebp),%esp 1118c9: 5b pop %ebx 1118ca: 5e pop %esi 1118cb: 5f pop %edi 1118cc: c9 leave 1118cd: c3 ret 1118ce: 66 90 xchg %ax,%ax if ( extend_area_end < extend_area_begin ) { return false; } extend_area_ok = _Heap_Get_first_and_last_block( 1118d0: 83 ec 08 sub $0x8,%esp 1118d3: 8d 55 e0 lea -0x20(%ebp),%edx 1118d6: 52 push %edx 1118d7: 8d 55 e4 lea -0x1c(%ebp),%edx 1118da: 52 push %edx 1118db: 50 push %eax 1118dc: ff 75 d4 pushl -0x2c(%ebp) 1118df: 51 push %ecx 1118e0: ff 75 0c pushl 0xc(%ebp) 1118e3: e8 38 b1 ff ff call 10ca20 <_Heap_Get_first_and_last_block> page_size, min_block_size, &extend_first_block, &extend_last_block ); if (!extend_area_ok ) { 1118e8: 83 c4 20 add $0x20,%esp 1118eb: 84 c0 test %al,%al 1118ed: 74 d5 je 1118c4 <_Heap_Extend+0x3c> 1118ef: 8b 7d d0 mov -0x30(%ebp),%edi 1118f2: c7 45 bc 00 00 00 00 movl $0x0,-0x44(%ebp) 1118f9: c7 45 b8 00 00 00 00 movl $0x0,-0x48(%ebp) 111900: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp) 111907: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp) 11190e: 8b 75 cc mov -0x34(%ebp),%esi 111911: 89 5d b4 mov %ebx,-0x4c(%ebp) 111914: eb 30 jmp 111946 <_Heap_Extend+0xbe> 111916: 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 ) { 111918: 39 ce cmp %ecx,%esi 11191a: 73 03 jae 11191f <_Heap_Extend+0x97> 11191c: 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); 11191f: 8d 59 f8 lea -0x8(%ecx),%ebx 111922: 89 c8 mov %ecx,%eax 111924: 31 d2 xor %edx,%edx 111926: 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); 111929: 29 d3 sub %edx,%ebx link_below_block = start_block; } if ( sub_area_end == extend_area_begin ) { 11192b: 3b 4d 0c cmp 0xc(%ebp),%ecx 11192e: 74 3c je 11196c <_Heap_Extend+0xe4> start_block->prev_size = extend_area_end; merge_above_block = end_block; } else if ( sub_area_end < extend_area_begin ) { 111930: 39 4d 0c cmp %ecx,0xc(%ebp) 111933: 76 03 jbe 111938 <_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 ) 111935: 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; 111938: 8b 7b 04 mov 0x4(%ebx),%edi 11193b: 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); 11193e: 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 ); 111941: 39 7d d0 cmp %edi,-0x30(%ebp) 111944: 74 39 je 11197f <_Heap_Extend+0xf7> return false; } do { uintptr_t const sub_area_begin = (start_block != first_block) ? (uintptr_t) start_block : heap->area_begin; 111946: 3b 7d d0 cmp -0x30(%ebp),%edi 111949: 0f 84 39 01 00 00 je 111a88 <_Heap_Extend+0x200> 11194f: 89 f8 mov %edi,%eax uintptr_t const sub_area_end = start_block->prev_size; 111951: 8b 0f mov (%edi),%ecx Heap_Block *const end_block = _Heap_Block_of_alloc_area( sub_area_end, page_size ); if ( 111953: 39 4d 0c cmp %ecx,0xc(%ebp) 111956: 73 08 jae 111960 <_Heap_Extend+0xd8> sub_area_end > extend_area_begin && extend_area_end > sub_area_begin 111958: 39 f0 cmp %esi,%eax 11195a: 0f 82 64 ff ff ff jb 1118c4 <_Heap_Extend+0x3c> ) { return false; } if ( extend_area_end == sub_area_begin ) { 111960: 39 f0 cmp %esi,%eax 111962: 75 b4 jne 111918 <_Heap_Extend+0x90> 111964: 89 7d c4 mov %edi,-0x3c(%ebp) 111967: eb b6 jmp 11191f <_Heap_Extend+0x97> 111969: 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; 11196c: 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 ) 11196e: 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; 111971: 8b 7b 04 mov 0x4(%ebx),%edi 111974: 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); 111977: 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 ); 11197a: 39 7d d0 cmp %edi,-0x30(%ebp) 11197d: 75 c7 jne 111946 <_Heap_Extend+0xbe> <== NEVER TAKEN 11197f: 8b 5d b4 mov -0x4c(%ebp),%ebx if ( extend_area_begin < heap->area_begin ) { 111982: 8b 75 0c mov 0xc(%ebp),%esi 111985: 3b 73 18 cmp 0x18(%ebx),%esi 111988: 0f 82 06 01 00 00 jb 111a94 <_Heap_Extend+0x20c> heap->area_begin = extend_area_begin; } else if ( heap->area_end < extend_area_end ) { 11198e: 8b 45 cc mov -0x34(%ebp),%eax 111991: 3b 43 1c cmp 0x1c(%ebx),%eax 111994: 76 03 jbe 111999 <_Heap_Extend+0x111> heap->area_end = extend_area_end; 111996: 89 43 1c mov %eax,0x1c(%ebx) } extend_first_block_size = (uintptr_t) extend_last_block - (uintptr_t) extend_first_block; 111999: 8b 55 e0 mov -0x20(%ebp),%edx 11199c: 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 = 11199f: 89 d1 mov %edx,%ecx 1119a1: 29 c1 sub %eax,%ecx (uintptr_t) extend_last_block - (uintptr_t) extend_first_block; extend_first_block->prev_size = extend_area_end; 1119a3: 8b 75 cc mov -0x34(%ebp),%esi 1119a6: 89 30 mov %esi,(%eax) extend_first_block->size_and_flag = extend_first_block_size | HEAP_PREV_BLOCK_USED; 1119a8: 89 ce mov %ecx,%esi 1119aa: 83 ce 01 or $0x1,%esi 1119ad: 89 70 04 mov %esi,0x4(%eax) _Heap_Protection_block_initialize( heap, extend_first_block ); extend_last_block->prev_size = extend_first_block_size; 1119b0: 89 0a mov %ecx,(%edx) extend_last_block->size_and_flag = 0; 1119b2: 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 ) { 1119b9: 39 43 20 cmp %eax,0x20(%ebx) 1119bc: 0f 86 da 00 00 00 jbe 111a9c <_Heap_Extend+0x214> heap->first_block = extend_first_block; 1119c2: 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 ) { 1119c5: 8b 75 c4 mov -0x3c(%ebp),%esi 1119c8: 85 f6 test %esi,%esi 1119ca: 0f 84 10 01 00 00 je 111ae0 <_Heap_Extend+0x258> Heap_Control *heap, uintptr_t extend_area_begin, Heap_Block *first_block ) { uintptr_t const page_size = heap->page_size; 1119d0: 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 ); 1119d3: 8b 4d 0c mov 0xc(%ebp),%ecx 1119d6: 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; 1119d9: 89 c8 mov %ecx,%eax 1119db: 31 d2 xor %edx,%edx 1119dd: f7 f6 div %esi if ( remainder != 0 ) { 1119df: 85 d2 test %edx,%edx 1119e1: 0f 84 c9 00 00 00 je 111ab0 <_Heap_Extend+0x228> <== ALWAYS TAKEN return value - remainder + alignment; 1119e7: 8d 04 31 lea (%ecx,%esi,1),%eax <== NOT EXECUTED 1119ea: 29 d0 sub %edx,%eax <== NOT EXECUTED uintptr_t const new_first_block_begin = 1119ec: 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; 1119ef: 8b 75 c4 mov -0x3c(%ebp),%esi 1119f2: 8b 0e mov (%esi),%ecx 1119f4: 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 = 1119f7: 89 f0 mov %esi,%eax 1119f9: 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; 1119fb: 83 c8 01 or $0x1,%eax 1119fe: 89 42 04 mov %eax,0x4(%edx) _Heap_Free_block( heap, new_first_block ); 111a01: 89 d8 mov %ebx,%eax 111a03: e8 64 fe ff ff call 11186c <_Heap_Free_block> link_below_block, extend_last_block ); } if ( merge_above_block != NULL ) { 111a08: 8b 45 c8 mov -0x38(%ebp),%eax 111a0b: 85 c0 test %eax,%eax 111a0d: 0f 84 a5 00 00 00 je 111ab8 <_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, 111a13: 8b 4d cc mov -0x34(%ebp),%ecx 111a16: 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( 111a19: 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); 111a1c: 89 c8 mov %ecx,%eax 111a1e: 31 d2 xor %edx,%edx 111a20: f7 73 10 divl 0x10(%ebx) 111a23: 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) 111a25: 8b 55 c8 mov -0x38(%ebp),%edx 111a28: 8b 42 04 mov 0x4(%edx),%eax 111a2b: 29 c8 sub %ecx,%eax | HEAP_PREV_BLOCK_USED; 111a2d: 83 c8 01 or $0x1,%eax 111a30: 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; 111a34: 8b 42 04 mov 0x4(%edx),%eax 111a37: 83 e0 01 and $0x1,%eax block->size_and_flag = size | flag; 111a3a: 09 c8 or %ecx,%eax 111a3c: 89 42 04 mov %eax,0x4(%edx) _Heap_Block_set_size( last_block, last_block_new_size ); _Heap_Free_block( heap, last_block ); 111a3f: 89 d8 mov %ebx,%eax 111a41: e8 26 fe ff ff call 11186c <_Heap_Free_block> extend_first_block, extend_last_block ); } if ( merge_below_block == NULL && merge_above_block == NULL ) { 111a46: 8b 75 c4 mov -0x3c(%ebp),%esi 111a49: 85 f6 test %esi,%esi 111a4b: 0f 84 ab 00 00 00 je 111afc <_Heap_Extend+0x274> if ( extended_size_ptr != NULL ) *extended_size_ptr = extended_size; return true; } 111a51: 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( 111a54: 8b 43 20 mov 0x20(%ebx),%eax 111a57: 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; 111a59: 8b 4a 04 mov 0x4(%edx),%ecx 111a5c: 83 e1 01 and $0x1,%ecx block->size_and_flag = size | flag; 111a5f: 09 c8 or %ecx,%eax 111a61: 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; 111a64: 8b 43 30 mov 0x30(%ebx),%eax 111a67: 2b 45 c0 sub -0x40(%ebp),%eax /* Statistics */ stats->size += extended_size; 111a6a: 01 43 2c add %eax,0x2c(%ebx) if ( extended_size_ptr != NULL ) 111a6d: 8b 55 14 mov 0x14(%ebp),%edx 111a70: 85 d2 test %edx,%edx 111a72: 0f 84 a0 00 00 00 je 111b18 <_Heap_Extend+0x290> <== NEVER TAKEN *extended_size_ptr = extended_size; 111a78: 8b 55 14 mov 0x14(%ebp),%edx 111a7b: 89 02 mov %eax,(%edx) return true; 111a7d: b0 01 mov $0x1,%al } 111a7f: 8d 65 f4 lea -0xc(%ebp),%esp 111a82: 5b pop %ebx 111a83: 5e pop %esi 111a84: 5f pop %edi 111a85: c9 leave 111a86: c3 ret 111a87: 90 nop return false; } do { uintptr_t const sub_area_begin = (start_block != first_block) ? (uintptr_t) start_block : heap->area_begin; 111a88: 8b 55 b4 mov -0x4c(%ebp),%edx 111a8b: 8b 42 18 mov 0x18(%edx),%eax 111a8e: e9 be fe ff ff jmp 111951 <_Heap_Extend+0xc9> 111a93: 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; 111a94: 89 73 18 mov %esi,0x18(%ebx) 111a97: e9 fd fe ff ff jmp 111999 <_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 ) { 111a9c: 39 53 24 cmp %edx,0x24(%ebx) 111a9f: 0f 83 20 ff ff ff jae 1119c5 <_Heap_Extend+0x13d> heap->last_block = extend_last_block; 111aa5: 89 53 24 mov %edx,0x24(%ebx) 111aa8: e9 18 ff ff ff jmp 1119c5 <_Heap_Extend+0x13d> 111aad: 8d 76 00 lea 0x0(%esi),%esi uintptr_t remainder = value % alignment; if ( remainder != 0 ) { return value - remainder + alignment; } else { return value; 111ab0: 89 c8 mov %ecx,%eax 111ab2: e9 35 ff ff ff jmp 1119ec <_Heap_Extend+0x164> 111ab7: 90 nop ); } if ( merge_above_block != NULL ) { _Heap_Merge_above( heap, merge_above_block, extend_area_end ); } else if ( link_above_block != NULL ) { 111ab8: 8b 7d bc mov -0x44(%ebp),%edi 111abb: 85 ff test %edi,%edi 111abd: 74 87 je 111a46 <_Heap_Extend+0x1be> _Heap_Link_above( 111abf: 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 ); 111ac2: 8b 45 e4 mov -0x1c(%ebp),%eax 111ac5: 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; 111ac8: 8b 75 bc mov -0x44(%ebp),%esi 111acb: 8b 56 04 mov 0x4(%esi),%edx 111ace: 83 e2 01 and $0x1,%edx block->size_and_flag = size | flag; 111ad1: 09 d0 or %edx,%eax 111ad3: 89 46 04 mov %eax,0x4(%esi) last_block->size_and_flag |= HEAP_PREV_BLOCK_USED; 111ad6: 83 49 04 01 orl $0x1,0x4(%ecx) 111ada: e9 67 ff ff ff jmp 111a46 <_Heap_Extend+0x1be> 111adf: 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 ) { 111ae0: 8b 4d b8 mov -0x48(%ebp),%ecx 111ae3: 85 c9 test %ecx,%ecx 111ae5: 0f 84 1d ff ff ff je 111a08 <_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; 111aeb: 8b 45 b8 mov -0x48(%ebp),%eax 111aee: 29 d0 sub %edx,%eax 111af0: 83 c8 01 or $0x1,%eax 111af3: 89 42 04 mov %eax,0x4(%edx) 111af6: e9 0d ff ff ff jmp 111a08 <_Heap_Extend+0x180> 111afb: 90 nop extend_first_block, extend_last_block ); } if ( merge_below_block == NULL && merge_above_block == NULL ) { 111afc: 8b 4d c8 mov -0x38(%ebp),%ecx 111aff: 85 c9 test %ecx,%ecx 111b01: 0f 85 4a ff ff ff jne 111a51 <_Heap_Extend+0x1c9> _Heap_Free_block( heap, extend_first_block ); 111b07: 8b 55 e4 mov -0x1c(%ebp),%edx 111b0a: 89 d8 mov %ebx,%eax 111b0c: e8 5b fd ff ff call 11186c <_Heap_Free_block> 111b11: e9 3b ff ff ff jmp 111a51 <_Heap_Extend+0x1c9> 111b16: 66 90 xchg %ax,%ax stats->size += extended_size; if ( extended_size_ptr != NULL ) *extended_size_ptr = extended_size; return true; 111b18: b0 01 mov $0x1,%al <== NOT EXECUTED 111b1a: e9 a7 fd ff ff jmp 1118c6 <_Heap_Extend+0x3e> <== NOT EXECUTED =============================================================================== 0011149c <_Heap_Free>: return do_free; } #endif bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr ) { 11149c: 55 push %ebp 11149d: 89 e5 mov %esp,%ebp 11149f: 57 push %edi 1114a0: 56 push %esi 1114a1: 53 push %ebx 1114a2: 83 ec 10 sub $0x10,%esp 1114a5: 8b 5d 08 mov 0x8(%ebp),%ebx 1114a8: 8b 45 0c mov 0xc(%ebp),%eax 1114ab: 8d 48 f8 lea -0x8(%eax),%ecx 1114ae: 31 d2 xor %edx,%edx 1114b0: 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); 1114b3: 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 1114b5: 8b 43 20 mov 0x20(%ebx),%eax && (uintptr_t) block <= (uintptr_t) heap->last_block; 1114b8: 39 c1 cmp %eax,%ecx 1114ba: 72 07 jb 1114c3 <_Heap_Free+0x27> 1114bc: 8b 73 24 mov 0x24(%ebx),%esi 1114bf: 39 f1 cmp %esi,%ecx 1114c1: 76 0d jbe 1114d0 <_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 ); 1114c3: 31 c0 xor %eax,%eax --stats->used_blocks; ++stats->frees; stats->free_size += block_size; return( true ); } 1114c5: 83 c4 10 add $0x10,%esp 1114c8: 5b pop %ebx 1114c9: 5e pop %esi 1114ca: 5f pop %edi 1114cb: c9 leave 1114cc: c3 ret 1114cd: 8d 76 00 lea 0x0(%esi),%esi 1114d0: 8b 51 04 mov 0x4(%ecx),%edx 1114d3: 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; 1114d6: 83 e2 fe and $0xfffffffe,%edx 1114d9: 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); 1114dc: 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; 1114df: 39 d0 cmp %edx,%eax 1114e1: 77 e0 ja 1114c3 <_Heap_Free+0x27> <== NEVER TAKEN 1114e3: 39 d6 cmp %edx,%esi 1114e5: 72 dc jb 1114c3 <_Heap_Free+0x27> <== NEVER TAKEN 1114e7: 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 ) ) { 1114ea: f7 c7 01 00 00 00 test $0x1,%edi 1114f0: 74 d1 je 1114c3 <_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; 1114f2: 83 e7 fe and $0xfffffffe,%edi 1114f5: 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 )); 1114f8: 39 d6 cmp %edx,%esi 1114fa: 0f 84 c8 00 00 00 je 1115c8 <_Heap_Free+0x12c> return do_free; } #endif bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr ) 111500: f6 44 3a 04 01 testb $0x1,0x4(%edx,%edi,1) 111505: 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 ) ) { 111509: f6 45 f0 01 testb $0x1,-0x10(%ebp) 11150d: 75 45 jne 111554 <_Heap_Free+0xb8> uintptr_t const prev_size = block->prev_size; 11150f: 8b 39 mov (%ecx),%edi 111511: 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); 111514: 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; 111516: 39 c8 cmp %ecx,%eax 111518: 77 a9 ja 1114c3 <_Heap_Free+0x27> <== NEVER TAKEN 11151a: 39 ce cmp %ecx,%esi 11151c: 72 a5 jb 1114c3 <_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) ) { 11151e: f6 41 04 01 testb $0x1,0x4(%ecx) 111522: 74 9f je 1114c3 <_Heap_Free+0x27> <== NEVER TAKEN _HAssert( false ); return( false ); } if ( next_is_free ) { /* coalesce both */ 111524: 80 7d eb 00 cmpb $0x0,-0x15(%ebp) 111528: 0f 84 a6 00 00 00 je 1115d4 <_Heap_Free+0x138> uintptr_t const size = block_size + prev_size + next_block_size; 11152e: 8b 7d e4 mov -0x1c(%ebp),%edi 111531: 03 7d ec add -0x14(%ebp),%edi 111534: 03 7d f0 add -0x10(%ebp),%edi --stats->used_blocks; ++stats->frees; stats->free_size += block_size; return( true ); } 111537: 8b 42 08 mov 0x8(%edx),%eax 11153a: 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; 11153d: 89 42 08 mov %eax,0x8(%edx) next->prev = prev; 111540: 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; 111543: ff 4b 38 decl 0x38(%ebx) prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED; 111546: 89 f8 mov %edi,%eax 111548: 83 c8 01 or $0x1,%eax 11154b: 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; 11154e: 89 3c 39 mov %edi,(%ecx,%edi,1) 111551: eb 2a jmp 11157d <_Heap_Free+0xe1> 111553: 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 */ 111554: 80 7d eb 00 cmpb $0x0,-0x15(%ebp) 111558: 74 3a je 111594 <_Heap_Free+0xf8> uintptr_t const size = block_size + next_block_size; 11155a: 8b 7d e4 mov -0x1c(%ebp),%edi 11155d: 03 7d ec add -0x14(%ebp),%edi --stats->used_blocks; ++stats->frees; stats->free_size += block_size; return( true ); } 111560: 8b 42 08 mov 0x8(%edx),%eax 111563: 8b 52 0c mov 0xc(%edx),%edx ) { Heap_Block *next = old_block->next; Heap_Block *prev = old_block->prev; new_block->next = next; 111566: 89 41 08 mov %eax,0x8(%ecx) new_block->prev = prev; 111569: 89 51 0c mov %edx,0xc(%ecx) next->prev = new_block; 11156c: 89 48 0c mov %ecx,0xc(%eax) prev->next = new_block; 11156f: 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; 111572: 89 f8 mov %edi,%eax 111574: 83 c8 01 or $0x1,%eax 111577: 89 41 04 mov %eax,0x4(%ecx) next_block = _Heap_Block_at( block, size ); next_block->prev_size = size; 11157a: 89 3c 39 mov %edi,(%ecx,%edi,1) stats->max_free_blocks = stats->free_blocks; } } /* Statistics */ --stats->used_blocks; 11157d: ff 4b 40 decl 0x40(%ebx) ++stats->frees; 111580: ff 43 50 incl 0x50(%ebx) stats->free_size += block_size; 111583: 8b 55 ec mov -0x14(%ebp),%edx 111586: 01 53 30 add %edx,0x30(%ebx) return( true ); 111589: b0 01 mov $0x1,%al } 11158b: 83 c4 10 add $0x10,%esp 11158e: 5b pop %ebx 11158f: 5e pop %esi 111590: 5f pop %edi 111591: c9 leave 111592: c3 ret 111593: 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; 111594: 8b 43 08 mov 0x8(%ebx),%eax new_block->next = next; 111597: 89 41 08 mov %eax,0x8(%ecx) new_block->prev = block_before; 11159a: 89 59 0c mov %ebx,0xc(%ecx) block_before->next = new_block; 11159d: 89 4b 08 mov %ecx,0x8(%ebx) next->prev = new_block; 1115a0: 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; 1115a3: 8b 45 ec mov -0x14(%ebp),%eax 1115a6: 83 c8 01 or $0x1,%eax 1115a9: 89 41 04 mov %eax,0x4(%ecx) next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 1115ac: 83 62 04 fe andl $0xfffffffe,0x4(%edx) next_block->prev_size = block_size; 1115b0: 8b 45 ec mov -0x14(%ebp),%eax 1115b3: 89 02 mov %eax,(%edx) /* Statistics */ ++stats->free_blocks; 1115b5: 8b 43 38 mov 0x38(%ebx),%eax 1115b8: 40 inc %eax 1115b9: 89 43 38 mov %eax,0x38(%ebx) if ( stats->max_free_blocks < stats->free_blocks ) { 1115bc: 3b 43 3c cmp 0x3c(%ebx),%eax 1115bf: 76 bc jbe 11157d <_Heap_Free+0xe1> stats->max_free_blocks = stats->free_blocks; 1115c1: 89 43 3c mov %eax,0x3c(%ebx) 1115c4: eb b7 jmp 11157d <_Heap_Free+0xe1> 1115c6: 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 )); 1115c8: c6 45 eb 00 movb $0x0,-0x15(%ebp) 1115cc: e9 38 ff ff ff jmp 111509 <_Heap_Free+0x6d> 1115d1: 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; 1115d4: 8b 45 ec mov -0x14(%ebp),%eax 1115d7: 03 45 f0 add -0x10(%ebp),%eax prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED; 1115da: 89 c6 mov %eax,%esi 1115dc: 83 ce 01 or $0x1,%esi 1115df: 89 71 04 mov %esi,0x4(%ecx) next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 1115e2: 83 62 04 fe andl $0xfffffffe,0x4(%edx) next_block->prev_size = size; 1115e6: 89 02 mov %eax,(%edx) 1115e8: eb 93 jmp 11157d <_Heap_Free+0xe1> =============================================================================== 0010c694 <_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 ) { 10c694: 55 push %ebp 10c695: 89 e5 mov %esp,%ebp 10c697: 57 push %edi 10c698: 56 push %esi 10c699: 53 push %ebx 10c69a: 8b 4d 08 mov 0x8(%ebp),%ecx 10c69d: 8b 7d 0c mov 0xc(%ebp),%edi uintptr_t const heap_area_end = heap_area_begin + heap_area_size; 10c6a0: 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 ); 10c6a3: 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; 10c6a6: 89 d8 mov %ebx,%eax 10c6a8: 31 d2 xor %edx,%edx 10c6aa: f7 75 10 divl 0x10(%ebp) if ( remainder != 0 ) { 10c6ad: 85 d2 test %edx,%edx 10c6af: 74 05 je 10c6b6 <_Heap_Get_first_and_last_block+0x22> return value - remainder + alignment; 10c6b1: 03 5d 10 add 0x10(%ebp),%ebx 10c6b4: 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 ( 10c6b6: 39 f1 cmp %esi,%ecx 10c6b8: 77 2e ja 10c6e8 <_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); 10c6ba: 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 = 10c6bd: 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 10c6bf: 39 df cmp %ebx,%edi 10c6c1: 76 25 jbe 10c6e8 <_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 ); 10c6c3: 29 df sub %ebx,%edi RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 10c6c5: 89 f8 mov %edi,%eax 10c6c7: 31 d2 xor %edx,%edx 10c6c9: f7 75 10 divl 0x10(%ebp) 10c6cc: 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 10c6ce: 39 7d 14 cmp %edi,0x14(%ebp) 10c6d1: 77 15 ja 10c6e8 <_Heap_Get_first_and_last_block+0x54> ) { /* Invalid area or area too small */ return false; } *first_block_ptr = first_block; 10c6d3: 8b 45 18 mov 0x18(%ebp),%eax 10c6d6: 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); 10c6d8: 01 f7 add %esi,%edi 10c6da: 8b 45 1c mov 0x1c(%ebp),%eax 10c6dd: 89 38 mov %edi,(%eax) *last_block_ptr = last_block; return true; 10c6df: b0 01 mov $0x1,%al } 10c6e1: 5b pop %ebx 10c6e2: 5e pop %esi 10c6e3: 5f pop %edi 10c6e4: c9 leave 10c6e5: c3 ret 10c6e6: 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; 10c6e8: 31 c0 xor %eax,%eax *first_block_ptr = first_block; *last_block_ptr = last_block; return true; } 10c6ea: 5b pop %ebx 10c6eb: 5e pop %esi 10c6ec: 5f pop %edi 10c6ed: c9 leave 10c6ee: c3 ret =============================================================================== 001151b0 <_Heap_Get_free_information>: void _Heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ) { 1151b0: 55 push %ebp 1151b1: 89 e5 mov %esp,%ebp 1151b3: 57 push %edi 1151b4: 56 push %esi 1151b5: 53 push %ebx 1151b6: 8b 7d 0c mov 0xc(%ebp),%edi Heap_Block *the_block; Heap_Block *const tail = _Heap_Free_list_tail(the_heap); info->number = 0; 1151b9: c7 07 00 00 00 00 movl $0x0,(%edi) info->largest = 0; 1151bf: c7 47 04 00 00 00 00 movl $0x0,0x4(%edi) info->total = 0; 1151c6: 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; } } 1151cd: 8b 45 08 mov 0x8(%ebp),%eax 1151d0: 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); 1151d3: 39 d0 cmp %edx,%eax 1151d5: 74 31 je 115208 <_Heap_Get_free_information+0x58> 1151d7: b9 01 00 00 00 mov $0x1,%ecx 1151dc: 31 f6 xor %esi,%esi 1151de: 31 db xor %ebx,%ebx 1151e0: eb 07 jmp 1151e9 <_Heap_Get_free_information+0x39> 1151e2: 66 90 xchg %ax,%ax 1151e4: 8b 77 04 mov 0x4(%edi),%esi 1151e7: 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; 1151e9: 8b 42 04 mov 0x4(%edx),%eax 1151ec: 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; 1151ef: 01 c3 add %eax,%ebx if ( info->largest < the_size ) 1151f1: 39 f0 cmp %esi,%eax 1151f3: 76 03 jbe 1151f8 <_Heap_Get_free_information+0x48> info->largest = the_size; 1151f5: 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) 1151f8: 8b 52 08 mov 0x8(%edx),%edx 1151fb: 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); 1151fe: 39 55 08 cmp %edx,0x8(%ebp) 115201: 75 e1 jne 1151e4 <_Heap_Get_free_information+0x34> 115203: 89 0f mov %ecx,(%edi) 115205: 89 5f 08 mov %ebx,0x8(%edi) info->number++; info->total += the_size; if ( info->largest < the_size ) info->largest = the_size; } } 115208: 5b pop %ebx 115209: 5e pop %esi 11520a: 5f pop %edi 11520b: c9 leave 11520c: c3 ret =============================================================================== 00112014 <_Heap_Get_information>: void _Heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ) { 112014: 55 push %ebp 112015: 89 e5 mov %esp,%ebp 112017: 57 push %edi 112018: 56 push %esi 112019: 53 push %ebx 11201a: 83 ec 04 sub $0x4,%esp 11201d: 8b 45 08 mov 0x8(%ebp),%eax 112020: 8b 5d 0c mov 0xc(%ebp),%ebx Heap_Block *the_block = the_heap->first_block; 112023: 8b 50 20 mov 0x20(%eax),%edx Heap_Block *const end = the_heap->last_block; 112026: 8b 40 24 mov 0x24(%eax),%eax 112029: 89 45 f0 mov %eax,-0x10(%ebp) memset(the_info, 0, sizeof(*the_info)); 11202c: b9 18 00 00 00 mov $0x18,%ecx 112031: 31 c0 xor %eax,%eax 112033: 89 df mov %ebx,%edi 112035: f3 aa rep stos %al,%es:(%edi) while ( the_block != end ) { 112037: 3b 55 f0 cmp -0x10(%ebp),%edx 11203a: 74 38 je 112074 <_Heap_Get_information+0x60><== NEVER TAKEN 11203c: 8b 7a 04 mov 0x4(%edx),%edi 11203f: eb 18 jmp 112059 <_Heap_Get_information+0x45> 112041: 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; 112044: 8d 43 0c lea 0xc(%ebx),%eax else info = &the_info->Free; info->number++; 112047: ff 00 incl (%eax) info->total += the_size; 112049: 01 48 08 add %ecx,0x8(%eax) if ( info->largest < the_size ) 11204c: 39 48 04 cmp %ecx,0x4(%eax) 11204f: 73 03 jae 112054 <_Heap_Get_information+0x40> info->largest = the_size; 112051: 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 ) { 112054: 39 75 f0 cmp %esi,-0x10(%ebp) 112057: 74 1b je 112074 <_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; 112059: 89 f9 mov %edi,%ecx 11205b: 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); 11205e: 8d 34 0a lea (%edx,%ecx,1),%esi 112061: 89 f2 mov %esi,%edx if ( info->largest < the_size ) info->largest = the_size; the_block = next_block; } } 112063: 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) ) 112066: f7 c7 01 00 00 00 test $0x1,%edi 11206c: 75 d6 jne 112044 <_Heap_Get_information+0x30> info = &the_info->Used; else info = &the_info->Free; 11206e: 89 d8 mov %ebx,%eax 112070: eb d5 jmp 112047 <_Heap_Get_information+0x33> 112072: 66 90 xchg %ax,%ax if ( info->largest < the_size ) info->largest = the_size; the_block = next_block; } } 112074: 58 pop %eax 112075: 5b pop %ebx 112076: 5e pop %esi 112077: 5f pop %edi 112078: c9 leave 112079: c3 ret =============================================================================== 0011ed1c <_Heap_Resize_block>: void *alloc_begin_ptr, uintptr_t new_alloc_size, uintptr_t *old_size, uintptr_t *new_size ) { 11ed1c: 55 push %ebp 11ed1d: 89 e5 mov %esp,%ebp 11ed1f: 57 push %edi 11ed20: 56 push %esi 11ed21: 53 push %ebx 11ed22: 83 ec 2c sub $0x2c,%esp 11ed25: 8b 5d 08 mov 0x8(%ebp),%ebx 11ed28: 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); 11ed2b: 8d 4e f8 lea -0x8(%esi),%ecx 11ed2e: 89 f0 mov %esi,%eax 11ed30: 31 d2 xor %edx,%edx 11ed32: 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); 11ed35: 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; 11ed37: 8b 45 14 mov 0x14(%ebp),%eax 11ed3a: c7 00 00 00 00 00 movl $0x0,(%eax) *new_size = 0; 11ed40: 8b 55 18 mov 0x18(%ebp),%edx 11ed43: 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; 11ed49: 39 4b 20 cmp %ecx,0x20(%ebx) 11ed4c: 77 05 ja 11ed53 <_Heap_Resize_block+0x37> 11ed4e: 39 4b 24 cmp %ecx,0x24(%ebx) 11ed51: 73 0d jae 11ed60 <_Heap_Resize_block+0x44> new_alloc_size, old_size, new_size ); } else { return HEAP_RESIZE_FATAL_ERROR; 11ed53: b8 02 00 00 00 mov $0x2,%eax } } 11ed58: 8d 65 f4 lea -0xc(%ebp),%esp 11ed5b: 5b pop %ebx 11ed5c: 5e pop %esi 11ed5d: 5f pop %edi 11ed5e: c9 leave 11ed5f: 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; 11ed60: 8b 41 04 mov 0x4(%ecx),%eax 11ed63: 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; 11ed66: 8d 3c 01 lea (%ecx,%eax,1),%edi 11ed69: 89 7d d4 mov %edi,-0x2c(%ebp) uintptr_t alloc_size = block_end - alloc_begin + HEAP_ALLOC_BONUS; 11ed6c: 89 fa mov %edi,%edx 11ed6e: 29 f2 sub %esi,%edx 11ed70: 83 c2 04 add $0x4,%edx 11ed73: 89 55 e0 mov %edx,-0x20(%ebp) 11ed76: 8b 57 04 mov 0x4(%edi),%edx 11ed79: 83 e2 fe and $0xfffffffe,%edx 11ed7c: 89 55 d0 mov %edx,-0x30(%ebp) RTEMS_INLINE_ROUTINE bool _Heap_Is_free( const Heap_Block *block ) { return !_Heap_Is_used( block ); 11ed7f: f6 44 17 04 01 testb $0x1,0x4(%edi,%edx,1) 11ed84: 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; 11ed88: 8b 55 e0 mov -0x20(%ebp),%edx 11ed8b: 8b 7d 14 mov 0x14(%ebp),%edi 11ed8e: 89 17 mov %edx,(%edi) if ( next_block_is_free ) { 11ed90: 80 7d df 00 cmpb $0x0,-0x21(%ebp) 11ed94: 75 6e jne 11ee04 <_Heap_Resize_block+0xe8> block_size += next_block_size; alloc_size += next_block_size; } if ( new_alloc_size > alloc_size ) { 11ed96: 8b 55 e0 mov -0x20(%ebp),%edx 11ed99: 39 55 10 cmp %edx,0x10(%ebp) 11ed9c: 77 79 ja 11ee17 <_Heap_Resize_block+0xfb> return HEAP_RESIZE_UNSATISFIED; } if ( next_block_is_free ) { 11ed9e: 80 7d df 00 cmpb $0x0,-0x21(%ebp) 11eda2: 74 31 je 11edd5 <_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; 11eda4: 8b 79 04 mov 0x4(%ecx),%edi 11eda7: 83 e7 01 and $0x1,%edi block->size_and_flag = size | flag; 11edaa: 09 c7 or %eax,%edi 11edac: 89 79 04 mov %edi,0x4(%ecx) new_size ); } else { return HEAP_RESIZE_FATAL_ERROR; } } 11edaf: 8b 7d d4 mov -0x2c(%ebp),%edi 11edb2: 8b 7f 08 mov 0x8(%edi),%edi 11edb5: 89 7d e4 mov %edi,-0x1c(%ebp) 11edb8: 8b 55 d4 mov -0x2c(%ebp),%edx 11edbb: 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; 11edbe: 8b 55 e4 mov -0x1c(%ebp),%edx 11edc1: 89 57 08 mov %edx,0x8(%edi) next->prev = prev; 11edc4: 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; 11edc7: 83 4c 01 04 01 orl $0x1,0x4(%ecx,%eax,1) /* Statistics */ --stats->free_blocks; 11edcc: ff 4b 38 decl 0x38(%ebx) stats->free_size -= next_block_size; 11edcf: 8b 7d d0 mov -0x30(%ebp),%edi 11edd2: 29 7b 30 sub %edi,0x30(%ebx) } block = _Heap_Block_allocate( heap, block, alloc_begin, new_alloc_size ); 11edd5: ff 75 10 pushl 0x10(%ebp) 11edd8: 56 push %esi 11edd9: 51 push %ecx 11edda: 53 push %ebx 11eddb: e8 24 da fe ff call 10c804 <_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; 11ede0: 8b 50 04 mov 0x4(%eax),%edx 11ede3: 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; 11ede6: 29 f0 sub %esi,%eax 11ede8: 8d 44 10 04 lea 0x4(%eax,%edx,1),%eax 11edec: 8b 55 18 mov 0x18(%ebp),%edx 11edef: 89 02 mov %eax,(%edx) /* Statistics */ ++stats->resizes; 11edf1: ff 43 54 incl 0x54(%ebx) 11edf4: 83 c4 10 add $0x10,%esp return HEAP_RESIZE_SUCCESSFUL; 11edf7: 31 c0 xor %eax,%eax new_size ); } else { return HEAP_RESIZE_FATAL_ERROR; } } 11edf9: 8d 65 f4 lea -0xc(%ebp),%esp 11edfc: 5b pop %ebx 11edfd: 5e pop %esi 11edfe: 5f pop %edi 11edff: c9 leave 11ee00: c3 ret 11ee01: 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; 11ee04: 03 45 d0 add -0x30(%ebp),%eax alloc_size += next_block_size; 11ee07: 8b 7d d0 mov -0x30(%ebp),%edi 11ee0a: 01 fa add %edi,%edx 11ee0c: 89 55 e0 mov %edx,-0x20(%ebp) } if ( new_alloc_size > alloc_size ) { 11ee0f: 8b 55 e0 mov -0x20(%ebp),%edx 11ee12: 39 55 10 cmp %edx,0x10(%ebp) 11ee15: 76 87 jbe 11ed9e <_Heap_Resize_block+0x82> return HEAP_RESIZE_UNSATISFIED; 11ee17: b8 01 00 00 00 mov $0x1,%eax new_size ); } else { return HEAP_RESIZE_FATAL_ERROR; } } 11ee1c: 8d 65 f4 lea -0xc(%ebp),%esp 11ee1f: 5b pop %ebx 11ee20: 5e pop %esi 11ee21: 5f pop %edi 11ee22: c9 leave 11ee23: c3 ret =============================================================================== 0011ee24 <_Heap_Size_of_alloc_area>: bool _Heap_Size_of_alloc_area( Heap_Control *heap, void *alloc_begin_ptr, uintptr_t *alloc_size ) { 11ee24: 55 push %ebp 11ee25: 89 e5 mov %esp,%ebp 11ee27: 56 push %esi 11ee28: 53 push %ebx 11ee29: 8b 5d 08 mov 0x8(%ebp),%ebx 11ee2c: 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); 11ee2f: 8d 4e f8 lea -0x8(%esi),%ecx 11ee32: 89 f0 mov %esi,%eax 11ee34: 31 d2 xor %edx,%edx 11ee36: 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); 11ee39: 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 11ee3b: 8b 43 20 mov 0x20(%ebx),%eax && (uintptr_t) block <= (uintptr_t) heap->last_block; 11ee3e: 39 c1 cmp %eax,%ecx 11ee40: 72 07 jb 11ee49 <_Heap_Size_of_alloc_area+0x25> 11ee42: 8b 53 24 mov 0x24(%ebx),%edx 11ee45: 39 d1 cmp %edx,%ecx 11ee47: 76 07 jbe 11ee50 <_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; 11ee49: 31 c0 xor %eax,%eax } *alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin; return true; } 11ee4b: 5b pop %ebx 11ee4c: 5e pop %esi 11ee4d: c9 leave 11ee4e: c3 ret 11ee4f: 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; 11ee50: 8b 59 04 mov 0x4(%ecx),%ebx 11ee53: 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); 11ee56: 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; 11ee58: 39 c8 cmp %ecx,%eax 11ee5a: 77 ed ja 11ee49 <_Heap_Size_of_alloc_area+0x25><== NEVER TAKEN 11ee5c: 39 ca cmp %ecx,%edx 11ee5e: 72 e9 jb 11ee49 <_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 ) 11ee60: f6 41 04 01 testb $0x1,0x4(%ecx) 11ee64: 74 e3 je 11ee49 <_Heap_Size_of_alloc_area+0x25><== NEVER TAKEN ) { return false; } *alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin; 11ee66: 29 f1 sub %esi,%ecx 11ee68: 8d 51 04 lea 0x4(%ecx),%edx 11ee6b: 8b 45 10 mov 0x10(%ebp),%eax 11ee6e: 89 10 mov %edx,(%eax) return true; 11ee70: b0 01 mov $0x1,%al } 11ee72: 5b pop %ebx 11ee73: 5e pop %esi 11ee74: c9 leave 11ee75: c3 ret =============================================================================== 0010d338 <_Heap_Walk>: bool _Heap_Walk( Heap_Control *heap, int source, bool dump ) { 10d338: 55 push %ebp 10d339: 89 e5 mov %esp,%ebp 10d33b: 57 push %edi 10d33c: 56 push %esi 10d33d: 53 push %ebx 10d33e: 83 ec 4c sub $0x4c,%esp 10d341: 8b 5d 08 mov 0x8(%ebp),%ebx uintptr_t const page_size = heap->page_size; 10d344: 8b 43 10 mov 0x10(%ebx),%eax 10d347: 89 45 e0 mov %eax,-0x20(%ebp) uintptr_t const min_block_size = heap->min_block_size; 10d34a: 8b 53 14 mov 0x14(%ebx),%edx 10d34d: 89 55 d0 mov %edx,-0x30(%ebp) Heap_Block *const first_block = heap->first_block; 10d350: 8b 43 20 mov 0x20(%ebx),%eax 10d353: 89 45 dc mov %eax,-0x24(%ebp) Heap_Block *const last_block = heap->last_block; 10d356: 8b 53 24 mov 0x24(%ebx),%edx 10d359: 89 55 cc mov %edx,-0x34(%ebp) Heap_Block *block = first_block; Heap_Walk_printer printer = dump ? _Heap_Walk_print : _Heap_Walk_print_nothing; 10d35c: 80 7d 10 00 cmpb $0x0,0x10(%ebp) 10d360: 74 1a je 10d37c <_Heap_Walk+0x44> 10d362: c7 45 d8 f0 d2 10 00 movl $0x10d2f0,-0x28(%ebp) if ( !_System_state_Is_up( _System_state_Get() ) ) { 10d369: 83 3d 40 9c 12 00 03 cmpl $0x3,0x129c40 10d370: 74 1a je 10d38c <_Heap_Walk+0x54> <== ALWAYS TAKEN } block = next_block; } while ( block != first_block ); return true; 10d372: b0 01 mov $0x1,%al } 10d374: 8d 65 f4 lea -0xc(%ebp),%esp 10d377: 5b pop %ebx 10d378: 5e pop %esi 10d379: 5f pop %edi 10d37a: c9 leave 10d37b: 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; 10d37c: c7 45 d8 e8 d2 10 00 movl $0x10d2e8,-0x28(%ebp) if ( !_System_state_Is_up( _System_state_Get() ) ) { 10d383: 83 3d 40 9c 12 00 03 cmpl $0x3,0x129c40 10d38a: 75 e6 jne 10d372 <_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)( 10d38c: 52 push %edx 10d38d: ff 73 0c pushl 0xc(%ebx) 10d390: ff 73 08 pushl 0x8(%ebx) 10d393: ff 75 cc pushl -0x34(%ebp) 10d396: ff 75 dc pushl -0x24(%ebp) 10d399: ff 73 1c pushl 0x1c(%ebx) 10d39c: ff 73 18 pushl 0x18(%ebx) 10d39f: ff 75 d0 pushl -0x30(%ebp) 10d3a2: ff 75 e0 pushl -0x20(%ebp) 10d3a5: 68 94 1d 12 00 push $0x121d94 10d3aa: 6a 00 push $0x0 10d3ac: ff 75 0c pushl 0xc(%ebp) 10d3af: 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 ) { 10d3b2: 83 c4 30 add $0x30,%esp 10d3b5: 8b 45 e0 mov -0x20(%ebp),%eax 10d3b8: 85 c0 test %eax,%eax 10d3ba: 74 70 je 10d42c <_Heap_Walk+0xf4> (*printer)( source, true, "page size is zero\n" ); return false; } if ( !_Addresses_Is_aligned( (void *) page_size ) ) { 10d3bc: f6 45 e0 03 testb $0x3,-0x20(%ebp) 10d3c0: 75 72 jne 10d434 <_Heap_Walk+0xfc> RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10d3c2: 8b 45 d0 mov -0x30(%ebp),%eax 10d3c5: 31 d2 xor %edx,%edx 10d3c7: f7 75 e0 divl -0x20(%ebp) ); return false; } if ( !_Heap_Is_aligned( min_block_size, page_size ) ) { 10d3ca: 85 d2 test %edx,%edx 10d3cc: 75 72 jne 10d440 <_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; 10d3ce: 8b 45 dc mov -0x24(%ebp),%eax 10d3d1: 83 c0 08 add $0x8,%eax RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10d3d4: 31 d2 xor %edx,%edx 10d3d6: f7 75 e0 divl -0x20(%ebp) ); return false; } if ( 10d3d9: 85 d2 test %edx,%edx 10d3db: 75 6f jne 10d44c <_Heap_Walk+0x114> block = next_block; } while ( block != first_block ); return true; } 10d3dd: 8b 45 dc mov -0x24(%ebp),%eax 10d3e0: 8b 40 04 mov 0x4(%eax),%eax 10d3e3: 89 45 e4 mov %eax,-0x1c(%ebp) ); return false; } if ( !_Heap_Is_prev_used( first_block ) ) { 10d3e6: a8 01 test $0x1,%al 10d3e8: 0f 84 ce 02 00 00 je 10d6bc <_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; 10d3ee: 8b 55 cc mov -0x34(%ebp),%edx 10d3f1: 8b 42 04 mov 0x4(%edx),%eax 10d3f4: 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); 10d3f7: 01 d0 add %edx,%eax ); return false; } if ( _Heap_Is_free( last_block ) ) { 10d3f9: f6 40 04 01 testb $0x1,0x4(%eax) 10d3fd: 74 25 je 10d424 <_Heap_Walk+0xec> ); return false; } if ( 10d3ff: 39 45 dc cmp %eax,-0x24(%ebp) 10d402: 74 54 je 10d458 <_Heap_Walk+0x120> <== ALWAYS TAKEN _Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block ) { (*printer)( 10d404: 51 push %ecx <== NOT EXECUTED 10d405: 68 b0 1e 12 00 push $0x121eb0 <== NOT EXECUTED 10d40a: 66 90 xchg %ax,%ax <== NOT EXECUTED return false; } if ( !_Heap_Walk_is_in_free_list( heap, block ) ) { (*printer)( 10d40c: 6a 01 push $0x1 10d40e: ff 75 0c pushl 0xc(%ebp) 10d411: ff 55 d8 call *-0x28(%ebp) 10d414: 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; 10d417: 31 c0 xor %eax,%eax block = next_block; } while ( block != first_block ); return true; } 10d419: 8d 65 f4 lea -0xc(%ebp),%esp 10d41c: 5b pop %ebx 10d41d: 5e pop %esi 10d41e: 5f pop %edi 10d41f: c9 leave 10d420: c3 ret 10d421: 8d 76 00 lea 0x0(%esi),%esi return false; } if ( _Heap_Is_free( last_block ) ) { (*printer)( 10d424: 53 push %ebx 10d425: 68 4a 1d 12 00 push $0x121d4a 10d42a: eb e0 jmp 10d40c <_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" ); 10d42c: 57 push %edi 10d42d: 68 19 1d 12 00 push $0x121d19 10d432: eb d8 jmp 10d40c <_Heap_Walk+0xd4> return false; } if ( !_Addresses_Is_aligned( (void *) page_size ) ) { (*printer)( 10d434: ff 75 e0 pushl -0x20(%ebp) 10d437: 68 2c 1d 12 00 push $0x121d2c 10d43c: eb ce jmp 10d40c <_Heap_Walk+0xd4> 10d43e: 66 90 xchg %ax,%ax return false; } if ( !_Heap_Is_aligned( min_block_size, page_size ) ) { (*printer)( 10d440: ff 75 d0 pushl -0x30(%ebp) 10d443: 68 28 1e 12 00 push $0x121e28 10d448: eb c2 jmp 10d40c <_Heap_Walk+0xd4> 10d44a: 66 90 xchg %ax,%ax } if ( !_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size ) ) { (*printer)( 10d44c: ff 75 dc pushl -0x24(%ebp) 10d44f: 68 4c 1e 12 00 push $0x121e4c 10d454: eb b6 jmp 10d40c <_Heap_Walk+0xd4> 10d456: 66 90 xchg %ax,%ax int source, Heap_Walk_printer printer, Heap_Control *heap ) { uintptr_t const page_size = heap->page_size; 10d458: 8b 43 10 mov 0x10(%ebx),%eax 10d45b: 89 45 c8 mov %eax,-0x38(%ebp) block = next_block; } while ( block != first_block ); return true; } 10d45e: 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 ) { 10d461: 39 f3 cmp %esi,%ebx 10d463: 74 65 je 10d4ca <_Heap_Walk+0x192> block = next_block; } while ( block != first_block ); return true; } 10d465: 8b 43 20 mov 0x20(%ebx),%eax 10d468: 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; 10d46b: 39 f0 cmp %esi,%eax 10d46d: 0f 87 55 02 00 00 ja 10d6c8 <_Heap_Walk+0x390> <== NEVER TAKEN 10d473: 8b 7b 24 mov 0x24(%ebx),%edi 10d476: 39 f7 cmp %esi,%edi 10d478: 0f 82 4a 02 00 00 jb 10d6c8 <_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; 10d47e: 8d 46 08 lea 0x8(%esi),%eax RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10d481: 31 d2 xor %edx,%edx 10d483: f7 75 c8 divl -0x38(%ebp) ); return false; } if ( 10d486: 85 d2 test %edx,%edx 10d488: 0f 85 71 02 00 00 jne 10d6ff <_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; 10d48e: 8b 46 04 mov 0x4(%esi),%eax 10d491: 83 e0 fe and $0xfffffffe,%eax ); return false; } if ( _Heap_Is_used( free_block ) ) { 10d494: f6 44 06 04 01 testb $0x1,0x4(%esi,%eax,1) 10d499: 0f 85 6d 02 00 00 jne 10d70c <_Heap_Walk+0x3d4> <== NEVER TAKEN 10d49f: 89 da mov %ebx,%edx 10d4a1: 8d 76 00 lea 0x0(%esi),%esi ); return false; } if ( free_block->prev != prev_block ) { 10d4a4: 8b 46 0c mov 0xc(%esi),%eax 10d4a7: 39 d0 cmp %edx,%eax 10d4a9: 0f 85 6a 02 00 00 jne 10d719 <_Heap_Walk+0x3e1> return false; } prev_block = free_block; free_block = free_block->next; 10d4af: 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 ) { 10d4b2: 39 cb cmp %ecx,%ebx 10d4b4: 74 1a je 10d4d0 <_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; 10d4b6: 39 4d d4 cmp %ecx,-0x2c(%ebp) 10d4b9: 0f 86 7d 01 00 00 jbe 10d63c <_Heap_Walk+0x304> if ( !_Heap_Is_block_in_heap( heap, free_block ) ) { (*printer)( 10d4bf: 51 push %ecx 10d4c0: 68 e0 1e 12 00 push $0x121ee0 10d4c5: e9 42 ff ff ff jmp 10d40c <_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 ) { 10d4ca: 8b 53 20 mov 0x20(%ebx),%edx 10d4cd: 89 55 d4 mov %edx,-0x2c(%ebp) ); return false; } if ( _Heap_Is_used( free_block ) ) { 10d4d0: 8b 7d dc mov -0x24(%ebp),%edi 10d4d3: 8b 45 d4 mov -0x2c(%ebp),%eax 10d4d6: 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; 10d4d8: 8b 4d e4 mov -0x1c(%ebp),%ecx 10d4db: 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); 10d4de: 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; 10d4e1: 39 f0 cmp %esi,%eax 10d4e3: 76 23 jbe 10d508 <_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)( 10d4e5: 83 ec 0c sub $0xc,%esp 10d4e8: 56 push %esi 10d4e9: 57 push %edi 10d4ea: 68 64 1f 12 00 push $0x121f64 10d4ef: 90 nop 10d4f0: 6a 01 push $0x1 10d4f2: ff 75 0c pushl 0xc(%ebp) 10d4f5: ff 55 d8 call *-0x28(%ebp) "block 0x%08x: next block 0x%08x not in heap\n", block, next_block ); return false; 10d4f8: 83 c4 20 add $0x20,%esp 10d4fb: 31 c0 xor %eax,%eax block = next_block; } while ( block != first_block ); return true; } 10d4fd: 8d 65 f4 lea -0xc(%ebp),%esp 10d500: 5b pop %ebx 10d501: 5e pop %esi 10d502: 5f pop %edi 10d503: c9 leave 10d504: c3 ret 10d505: 8d 76 00 lea 0x0(%esi),%esi 10d508: 39 73 24 cmp %esi,0x24(%ebx) 10d50b: 72 d8 jb 10d4e5 <_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; 10d50d: 3b 7d cc cmp -0x34(%ebp),%edi 10d510: 0f 95 45 d4 setne -0x2c(%ebp) RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10d514: 89 c8 mov %ecx,%eax 10d516: 31 d2 xor %edx,%edx 10d518: f7 75 e0 divl -0x20(%ebp) ); return false; } if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) { 10d51b: 85 d2 test %edx,%edx 10d51d: 74 0a je 10d529 <_Heap_Walk+0x1f1> 10d51f: 80 7d d4 00 cmpb $0x0,-0x2c(%ebp) 10d523: 0f 85 a6 01 00 00 jne 10d6cf <_Heap_Walk+0x397> ); return false; } if ( block_size < min_block_size && is_not_last_block ) { 10d529: 39 4d d0 cmp %ecx,-0x30(%ebp) 10d52c: 76 0a jbe 10d538 <_Heap_Walk+0x200> 10d52e: 80 7d d4 00 cmpb $0x0,-0x2c(%ebp) 10d532: 0f 85 a6 01 00 00 jne 10d6de <_Heap_Walk+0x3a6> <== ALWAYS TAKEN ); return false; } if ( next_block_begin <= block_begin && is_not_last_block ) { 10d538: 39 f7 cmp %esi,%edi 10d53a: 72 0a jb 10d546 <_Heap_Walk+0x20e> 10d53c: 80 7d d4 00 cmpb $0x0,-0x2c(%ebp) 10d540: 0f 85 aa 01 00 00 jne 10d6f0 <_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; 10d546: 8b 55 e4 mov -0x1c(%ebp),%edx 10d549: 83 e2 01 and $0x1,%edx ); return false; } if ( !_Heap_Is_prev_used( next_block ) ) { 10d54c: f6 46 04 01 testb $0x1,0x4(%esi) 10d550: 74 4e je 10d5a0 <_Heap_Walk+0x268> if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) { return false; } } else if (prev_used) { 10d552: 85 d2 test %edx,%edx 10d554: 74 2e je 10d584 <_Heap_Walk+0x24c> (*printer)( 10d556: 83 ec 0c sub $0xc,%esp 10d559: 51 push %ecx 10d55a: 57 push %edi 10d55b: 68 7b 1d 12 00 push $0x121d7b 10d560: 6a 00 push $0x0 10d562: ff 75 0c pushl 0xc(%ebp) 10d565: ff 55 d8 call *-0x28(%ebp) 10d568: 83 c4 20 add $0x20,%esp block->prev_size ); } block = next_block; } while ( block != first_block ); 10d56b: 39 75 dc cmp %esi,-0x24(%ebp) 10d56e: 0f 84 fe fd ff ff je 10d372 <_Heap_Walk+0x3a> 10d574: 8b 56 04 mov 0x4(%esi),%edx 10d577: 89 55 e4 mov %edx,-0x1c(%ebp) 10d57a: 8b 43 20 mov 0x20(%ebx),%eax 10d57d: 89 f7 mov %esi,%edi 10d57f: e9 54 ff ff ff jmp 10d4d8 <_Heap_Walk+0x1a0> "block 0x%08x: size %u\n", block, block_size ); } else { (*printer)( 10d584: 83 ec 08 sub $0x8,%esp 10d587: ff 37 pushl (%edi) 10d589: 51 push %ecx 10d58a: 57 push %edi 10d58b: 68 c8 20 12 00 push $0x1220c8 10d590: 6a 00 push $0x0 10d592: ff 75 0c pushl 0xc(%ebp) 10d595: ff 55 d8 call *-0x28(%ebp) 10d598: 83 c4 20 add $0x20,%esp 10d59b: eb ce jmp 10d56b <_Heap_Walk+0x233> 10d59d: 8d 76 00 lea 0x0(%esi),%esi block = next_block; } while ( block != first_block ); return true; } 10d5a0: 8b 43 08 mov 0x8(%ebx),%eax 10d5a3: 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 ? 10d5a6: 8b 47 08 mov 0x8(%edi),%eax 10d5a9: 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)( 10d5ac: 39 43 0c cmp %eax,0xc(%ebx) 10d5af: 0f 84 cb 00 00 00 je 10d680 <_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)" : "") 10d5b5: 39 c3 cmp %eax,%ebx 10d5b7: 0f 84 db 00 00 00 je 10d698 <_Heap_Walk+0x360> 10d5bd: c7 45 c8 09 1c 12 00 movl $0x121c09,-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 ? 10d5c4: 8b 47 0c mov 0xc(%edi),%eax 10d5c7: 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)( 10d5ca: 39 45 b4 cmp %eax,-0x4c(%ebp) 10d5cd: 0f 84 b9 00 00 00 je 10d68c <_Heap_Walk+0x354> block, block_size, block->prev, block->prev == first_free_block ? " (= first free)" : (block->prev == free_list_head ? " (= head)" : ""), 10d5d3: 39 c3 cmp %eax,%ebx 10d5d5: 0f 84 c9 00 00 00 je 10d6a4 <_Heap_Walk+0x36c> 10d5db: b8 09 1c 12 00 mov $0x121c09,%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)( 10d5e0: 83 ec 0c sub $0xc,%esp 10d5e3: ff 75 c8 pushl -0x38(%ebp) 10d5e6: ff 75 e4 pushl -0x1c(%ebp) 10d5e9: 50 push %eax 10d5ea: ff 75 d4 pushl -0x2c(%ebp) 10d5ed: 51 push %ecx 10d5ee: 57 push %edi 10d5ef: 68 24 20 12 00 push $0x122024 10d5f4: 6a 00 push $0x0 10d5f6: ff 75 0c pushl 0xc(%ebp) 10d5f9: 89 55 c4 mov %edx,-0x3c(%ebp) 10d5fc: 89 4d c0 mov %ecx,-0x40(%ebp) 10d5ff: 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 ) { 10d602: 8b 06 mov (%esi),%eax 10d604: 83 c4 30 add $0x30,%esp 10d607: 8b 4d c0 mov -0x40(%ebp),%ecx 10d60a: 39 c1 cmp %eax,%ecx 10d60c: 8b 55 c4 mov -0x3c(%ebp),%edx 10d60f: 75 5f jne 10d670 <_Heap_Walk+0x338> ); return false; } if ( !prev_used ) { 10d611: 85 d2 test %edx,%edx 10d613: 0f 84 97 00 00 00 je 10d6b0 <_Heap_Walk+0x378> block = next_block; } while ( block != first_block ); return true; } 10d619: 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 ) { 10d61c: 39 c3 cmp %eax,%ebx 10d61e: 74 0f je 10d62f <_Heap_Walk+0x2f7> <== NEVER TAKEN if ( free_block == block ) { 10d620: 39 c7 cmp %eax,%edi 10d622: 0f 84 43 ff ff ff je 10d56b <_Heap_Walk+0x233> return true; } free_block = free_block->next; 10d628: 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 ) { 10d62b: 39 c3 cmp %eax,%ebx 10d62d: 75 f1 jne 10d620 <_Heap_Walk+0x2e8> return false; } if ( !_Heap_Walk_is_in_free_list( heap, block ) ) { (*printer)( 10d62f: 57 push %edi 10d630: 68 f0 20 12 00 push $0x1220f0 10d635: e9 d2 fd ff ff jmp 10d40c <_Heap_Walk+0xd4> 10d63a: 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; 10d63c: 39 f9 cmp %edi,%ecx 10d63e: 0f 87 7b fe ff ff ja 10d4bf <_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; 10d644: 8d 41 08 lea 0x8(%ecx),%eax RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10d647: 31 d2 xor %edx,%edx 10d649: f7 75 c8 divl -0x38(%ebp) ); return false; } if ( 10d64c: 85 d2 test %edx,%edx 10d64e: 0f 85 ad 00 00 00 jne 10d701 <_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; 10d654: 8b 41 04 mov 0x4(%ecx),%eax 10d657: 83 e0 fe and $0xfffffffe,%eax ); return false; } if ( _Heap_Is_used( free_block ) ) { 10d65a: f6 44 01 04 01 testb $0x1,0x4(%ecx,%eax,1) 10d65f: 0f 85 a9 00 00 00 jne 10d70e <_Heap_Walk+0x3d6> 10d665: 89 f2 mov %esi,%edx 10d667: 89 ce mov %ecx,%esi 10d669: e9 36 fe ff ff jmp 10d4a4 <_Heap_Walk+0x16c> 10d66e: 66 90 xchg %ax,%ax " (= last free)" : (block->next == free_list_tail ? " (= tail)" : "") ); if ( block_size != next_block->prev_size ) { (*printer)( 10d670: 52 push %edx 10d671: 56 push %esi 10d672: 50 push %eax 10d673: 51 push %ecx 10d674: 57 push %edi 10d675: 68 5c 20 12 00 push $0x12205c 10d67a: e9 71 fe ff ff jmp 10d4f0 <_Heap_Walk+0x1b8> 10d67f: 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)( 10d680: c7 45 c8 e6 1c 12 00 movl $0x121ce6,-0x38(%ebp) 10d687: e9 38 ff ff ff jmp 10d5c4 <_Heap_Walk+0x28c> 10d68c: b8 ff 1c 12 00 mov $0x121cff,%eax 10d691: e9 4a ff ff ff jmp 10d5e0 <_Heap_Walk+0x2a8> 10d696: 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)" : "") 10d698: c7 45 c8 f5 1c 12 00 movl $0x121cf5,-0x38(%ebp) 10d69f: e9 20 ff ff ff jmp 10d5c4 <_Heap_Walk+0x28c> block, block_size, block->prev, block->prev == first_free_block ? " (= first free)" : (block->prev == free_list_head ? " (= head)" : ""), 10d6a4: b8 0f 1d 12 00 mov $0x121d0f,%eax 10d6a9: e9 32 ff ff ff jmp 10d5e0 <_Heap_Walk+0x2a8> 10d6ae: 66 90 xchg %ax,%ax return false; } if ( !prev_used ) { (*printer)( 10d6b0: 57 push %edi 10d6b1: 68 98 20 12 00 push $0x122098 10d6b6: e9 51 fd ff ff jmp 10d40c <_Heap_Walk+0xd4> 10d6bb: 90 nop return false; } if ( !_Heap_Is_prev_used( first_block ) ) { (*printer)( 10d6bc: 56 push %esi 10d6bd: 68 80 1e 12 00 push $0x121e80 10d6c2: e9 45 fd ff ff jmp 10d40c <_Heap_Walk+0xd4> 10d6c7: 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; 10d6c8: 89 f1 mov %esi,%ecx <== NOT EXECUTED 10d6ca: e9 f0 fd ff ff jmp 10d4bf <_Heap_Walk+0x187> <== NOT EXECUTED return false; } if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) { (*printer)( 10d6cf: 83 ec 0c sub $0xc,%esp 10d6d2: 51 push %ecx 10d6d3: 57 push %edi 10d6d4: 68 94 1f 12 00 push $0x121f94 10d6d9: e9 12 fe ff ff jmp 10d4f0 <_Heap_Walk+0x1b8> return false; } if ( block_size < min_block_size && is_not_last_block ) { (*printer)( 10d6de: 83 ec 08 sub $0x8,%esp 10d6e1: ff 75 d0 pushl -0x30(%ebp) 10d6e4: 51 push %ecx 10d6e5: 57 push %edi 10d6e6: 68 c4 1f 12 00 push $0x121fc4 10d6eb: e9 00 fe ff ff jmp 10d4f0 <_Heap_Walk+0x1b8> return false; } if ( next_block_begin <= block_begin && is_not_last_block ) { (*printer)( 10d6f0: 83 ec 0c sub $0xc,%esp 10d6f3: 56 push %esi 10d6f4: 57 push %edi 10d6f5: 68 f0 1f 12 00 push $0x121ff0 10d6fa: e9 f1 fd ff ff jmp 10d4f0 <_Heap_Walk+0x1b8> ); return false; } if ( 10d6ff: 89 f1 mov %esi,%ecx <== NOT EXECUTED !_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size ) ) { (*printer)( 10d701: 51 push %ecx 10d702: 68 00 1f 12 00 push $0x121f00 10d707: e9 00 fd ff ff jmp 10d40c <_Heap_Walk+0xd4> ); return false; } if ( _Heap_Is_used( free_block ) ) { 10d70c: 89 f1 mov %esi,%ecx <== NOT EXECUTED (*printer)( 10d70e: 51 push %ecx 10d70f: 68 5f 1d 12 00 push $0x121d5f 10d714: e9 f3 fc ff ff jmp 10d40c <_Heap_Walk+0xd4> return false; } if ( free_block->prev != prev_block ) { (*printer)( 10d719: 83 ec 0c sub $0xc,%esp 10d71c: 50 push %eax 10d71d: 56 push %esi 10d71e: 68 30 1f 12 00 push $0x121f30 10d723: e9 c8 fd ff ff jmp 10d4f0 <_Heap_Walk+0x1b8> =============================================================================== 0010bdac <_IO_Initialize_all_drivers>: * * Output Parameters: NONE */ void _IO_Initialize_all_drivers( void ) { 10bdac: 55 push %ebp 10bdad: 89 e5 mov %esp,%ebp 10bdaf: 53 push %ebx 10bdb0: 83 ec 04 sub $0x4,%esp rtems_device_major_number major; for ( major=0 ; major < _IO_Number_of_drivers ; major ++ ) 10bdb3: 8b 0d 20 80 12 00 mov 0x128020,%ecx 10bdb9: 85 c9 test %ecx,%ecx 10bdbb: 74 1a je 10bdd7 <_IO_Initialize_all_drivers+0x2b><== NEVER TAKEN 10bdbd: 31 db xor %ebx,%ebx 10bdbf: 90 nop (void) rtems_io_initialize( major, 0, NULL ); 10bdc0: 52 push %edx 10bdc1: 6a 00 push $0x0 10bdc3: 6a 00 push $0x0 10bdc5: 53 push %ebx 10bdc6: e8 49 52 00 00 call 111014 void _IO_Initialize_all_drivers( void ) { rtems_device_major_number major; for ( major=0 ; major < _IO_Number_of_drivers ; major ++ ) 10bdcb: 43 inc %ebx 10bdcc: 83 c4 10 add $0x10,%esp 10bdcf: 39 1d 20 80 12 00 cmp %ebx,0x128020 10bdd5: 77 e9 ja 10bdc0 <_IO_Initialize_all_drivers+0x14> (void) rtems_io_initialize( major, 0, NULL ); } 10bdd7: 8b 5d fc mov -0x4(%ebp),%ebx 10bdda: c9 leave 10bddb: c3 ret =============================================================================== 0010bd14 <_IO_Manager_initialization>: * workspace. * */ void _IO_Manager_initialization(void) { 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 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; 10bd1d: 8b 1d b8 32 12 00 mov 0x1232b8,%ebx drivers_in_table = Configuration.number_of_device_drivers; 10bd23: a1 b4 32 12 00 mov 0x1232b4,%eax 10bd28: 89 45 e4 mov %eax,-0x1c(%ebp) number_of_drivers = Configuration.maximum_drivers; 10bd2b: 8b 35 b0 32 12 00 mov 0x1232b0,%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 ) 10bd31: 39 f0 cmp %esi,%eax 10bd33: 73 5f jae 10bd94 <_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( 10bd35: 8d 0c 76 lea (%esi,%esi,2),%ecx 10bd38: c1 e1 03 shl $0x3,%ecx 10bd3b: 83 ec 0c sub $0xc,%esp 10bd3e: 51 push %ecx 10bd3f: 89 4d dc mov %ecx,-0x24(%ebp) 10bd42: e8 4d 2c 00 00 call 10e994 <_Workspace_Allocate_or_fatal_error> 10bd47: 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 *) 10bd49: a3 24 80 12 00 mov %eax,0x128024 _Workspace_Allocate_or_fatal_error( sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); _IO_Number_of_drivers = number_of_drivers; 10bd4e: 89 35 20 80 12 00 mov %esi,0x128020 memset( 10bd54: 31 c0 xor %eax,%eax 10bd56: 8b 4d dc mov -0x24(%ebp),%ecx 10bd59: 89 d7 mov %edx,%edi 10bd5b: 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++ ) 10bd5d: 83 c4 10 add $0x10,%esp 10bd60: 8b 45 e4 mov -0x1c(%ebp),%eax 10bd63: 85 c0 test %eax,%eax 10bd65: 74 25 je 10bd8c <_IO_Manager_initialization+0x78><== NEVER TAKEN 10bd67: a1 24 80 12 00 mov 0x128024,%eax 10bd6c: 89 45 e0 mov %eax,-0x20(%ebp) 10bd6f: 31 c0 xor %eax,%eax 10bd71: 31 d2 xor %edx,%edx 10bd73: 90 nop _IO_Driver_address_table[index] = driver_table[index]; 10bd74: 8b 7d e0 mov -0x20(%ebp),%edi 10bd77: 01 c7 add %eax,%edi 10bd79: 8d 34 03 lea (%ebx,%eax,1),%esi 10bd7c: b9 06 00 00 00 mov $0x6,%ecx 10bd81: 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++ ) 10bd83: 42 inc %edx 10bd84: 83 c0 18 add $0x18,%eax 10bd87: 39 55 e4 cmp %edx,-0x1c(%ebp) 10bd8a: 77 e8 ja 10bd74 <_IO_Manager_initialization+0x60> _IO_Driver_address_table[index] = driver_table[index]; } 10bd8c: 8d 65 f4 lea -0xc(%ebp),%esp 10bd8f: 5b pop %ebx 10bd90: 5e pop %esi 10bd91: 5f pop %edi 10bd92: c9 leave 10bd93: 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; 10bd94: 89 1d 24 80 12 00 mov %ebx,0x128024 _IO_Number_of_drivers = number_of_drivers; 10bd9a: 8b 45 e4 mov -0x1c(%ebp),%eax 10bd9d: a3 20 80 12 00 mov %eax,0x128020 sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) _IO_Driver_address_table[index] = driver_table[index]; } 10bda2: 8d 65 f4 lea -0xc(%ebp),%esp 10bda5: 5b pop %ebx 10bda6: 5e pop %esi 10bda7: 5f pop %edi 10bda8: c9 leave 10bda9: c3 ret =============================================================================== 0010c8f8 <_Internal_error_Occurred>: void _Internal_error_Occurred( Internal_errors_Source the_source, bool is_internal, Internal_errors_t the_error ) { 10c8f8: 55 push %ebp 10c8f9: 89 e5 mov %esp,%ebp 10c8fb: 53 push %ebx 10c8fc: 83 ec 08 sub $0x8,%esp 10c8ff: 8b 45 08 mov 0x8(%ebp),%eax 10c902: 8b 55 0c mov 0xc(%ebp),%edx 10c905: 8b 5d 10 mov 0x10(%ebp),%ebx _Internal_errors_What_happened.the_source = the_source; 10c908: a3 50 76 12 00 mov %eax,0x127650 _Internal_errors_What_happened.is_internal = is_internal; 10c90d: 88 15 54 76 12 00 mov %dl,0x127654 _Internal_errors_What_happened.the_error = the_error; 10c913: 89 1d 58 76 12 00 mov %ebx,0x127658 _User_extensions_Fatal( the_source, is_internal, the_error ); 10c919: 53 push %ebx 10c91a: 0f b6 d2 movzbl %dl,%edx 10c91d: 52 push %edx 10c91e: 50 push %eax 10c91f: e8 70 1c 00 00 call 10e594 <_User_extensions_Fatal> RTEMS_INLINE_ROUTINE void _System_state_Set ( System_state_Codes state ) { _System_state_Current = state; 10c924: c7 05 40 77 12 00 05 movl $0x5,0x127740 <== NOT EXECUTED 10c92b: 00 00 00 _System_state_Set( SYSTEM_STATE_FAILED ); _CPU_Fatal_halt( the_error ); 10c92e: fa cli <== NOT EXECUTED 10c92f: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10c931: f4 hlt <== NOT EXECUTED 10c932: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c935: eb fe jmp 10c935 <_Internal_error_Occurred+0x3d><== NOT EXECUTED =============================================================================== 001115ec <_Objects_API_maximum_class>: #include unsigned int _Objects_API_maximum_class( uint32_t api ) { 1115ec: 55 push %ebp 1115ed: 89 e5 mov %esp,%ebp 1115ef: 8b 45 08 mov 0x8(%ebp),%eax 1115f2: 48 dec %eax 1115f3: 83 f8 02 cmp $0x2,%eax 1115f6: 77 0c ja 111604 <_Objects_API_maximum_class+0x18> 1115f8: 8b 04 85 a0 13 12 00 mov 0x1213a0(,%eax,4),%eax case OBJECTS_NO_API: default: break; } return 0; } 1115ff: c9 leave 111600: c3 ret 111601: 8d 76 00 lea 0x0(%esi),%esi #include unsigned int _Objects_API_maximum_class( uint32_t api ) { 111604: 31 c0 xor %eax,%eax case OBJECTS_NO_API: default: break; } return 0; } 111606: c9 leave 111607: c3 ret =============================================================================== 0010c988 <_Objects_Allocate>: */ Objects_Control *_Objects_Allocate( Objects_Information *information ) { 10c988: 55 push %ebp 10c989: 89 e5 mov %esp,%ebp 10c98b: 56 push %esi 10c98c: 53 push %ebx 10c98d: 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 ) 10c990: 8b 43 18 mov 0x18(%ebx),%eax 10c993: 85 c0 test %eax,%eax 10c995: 75 0d jne 10c9a4 <_Objects_Allocate+0x1c><== ALWAYS TAKEN return NULL; 10c997: 31 c9 xor %ecx,%ecx ); } #endif return the_object; } 10c999: 89 c8 mov %ecx,%eax 10c99b: 8d 65 f8 lea -0x8(%ebp),%esp 10c99e: 5b pop %ebx 10c99f: 5e pop %esi 10c9a0: c9 leave 10c9a1: c3 ret 10c9a2: 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 ); 10c9a4: 8d 73 20 lea 0x20(%ebx),%esi 10c9a7: 83 ec 0c sub $0xc,%esp 10c9aa: 56 push %esi 10c9ab: e8 68 f6 ff ff call 10c018 <_Chain_Get> 10c9b0: 89 c1 mov %eax,%ecx if ( information->auto_extend ) { 10c9b2: 83 c4 10 add $0x10,%esp 10c9b5: 80 7b 12 00 cmpb $0x0,0x12(%ebx) 10c9b9: 74 de je 10c999 <_Objects_Allocate+0x11> /* * If the list is empty then we are out of objects and need to * extend information base. */ if ( !the_object ) { 10c9bb: 85 c0 test %eax,%eax 10c9bd: 74 29 je 10c9e8 <_Objects_Allocate+0x60> } if ( the_object ) { uint32_t block; block = (uint32_t) _Objects_Get_index( the_object->id ) - 10c9bf: 0f b7 41 08 movzwl 0x8(%ecx),%eax 10c9c3: 0f b7 53 08 movzwl 0x8(%ebx),%edx 10c9c7: 29 d0 sub %edx,%eax _Objects_Get_index( information->minimum_id ); block /= information->allocation_size; 10c9c9: 0f b7 73 14 movzwl 0x14(%ebx),%esi 10c9cd: 31 d2 xor %edx,%edx 10c9cf: f7 f6 div %esi information->inactive_per_block[ block ]--; 10c9d1: c1 e0 02 shl $0x2,%eax 10c9d4: 03 43 30 add 0x30(%ebx),%eax 10c9d7: ff 08 decl (%eax) information->inactive--; 10c9d9: 66 ff 4b 2c decw 0x2c(%ebx) ); } #endif return the_object; } 10c9dd: 89 c8 mov %ecx,%eax 10c9df: 8d 65 f8 lea -0x8(%ebp),%esp 10c9e2: 5b pop %ebx 10c9e3: 5e pop %esi 10c9e4: c9 leave 10c9e5: c3 ret 10c9e6: 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 ); 10c9e8: 83 ec 0c sub $0xc,%esp 10c9eb: 53 push %ebx 10c9ec: e8 3b 00 00 00 call 10ca2c <_Objects_Extend_information> the_object = (Objects_Control *) _Chain_Get( &information->Inactive ); 10c9f1: 89 34 24 mov %esi,(%esp) 10c9f4: e8 1f f6 ff ff call 10c018 <_Chain_Get> 10c9f9: 89 c1 mov %eax,%ecx } if ( the_object ) { 10c9fb: 83 c4 10 add $0x10,%esp 10c9fe: 85 c0 test %eax,%eax 10ca00: 74 97 je 10c999 <_Objects_Allocate+0x11> 10ca02: eb bb jmp 10c9bf <_Objects_Allocate+0x37> =============================================================================== 0010ca2c <_Objects_Extend_information>: */ void _Objects_Extend_information( Objects_Information *information ) { 10ca2c: 55 push %ebp 10ca2d: 89 e5 mov %esp,%ebp 10ca2f: 57 push %edi 10ca30: 56 push %esi 10ca31: 53 push %ebx 10ca32: 83 ec 4c sub $0x4c,%esp 10ca35: 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 ); 10ca38: 0f b7 43 08 movzwl 0x8(%ebx),%eax 10ca3c: 89 45 cc mov %eax,-0x34(%ebp) index_base = minimum_index; block = 0; /* if ( information->maximum < minimum_index ) */ if ( information->object_blocks == NULL ) 10ca3f: 8b 4b 34 mov 0x34(%ebx),%ecx 10ca42: 85 c9 test %ecx,%ecx 10ca44: 0f 84 66 02 00 00 je 10ccb0 <_Objects_Extend_information+0x284> block_count = 0; else { block_count = information->maximum / information->allocation_size; 10ca4a: 8b 73 10 mov 0x10(%ebx),%esi 10ca4d: 66 89 75 d0 mov %si,-0x30(%ebp) 10ca51: 8b 7b 14 mov 0x14(%ebx),%edi 10ca54: 89 f0 mov %esi,%eax 10ca56: 31 d2 xor %edx,%edx 10ca58: 66 f7 f7 div %di 10ca5b: 0f b7 f0 movzwl %ax,%esi for ( ; block < block_count; block++ ) { 10ca5e: 85 f6 test %esi,%esi 10ca60: 0f 84 63 02 00 00 je 10ccc9 <_Objects_Extend_information+0x29d><== NEVER TAKEN if ( information->object_blocks[ block ] == NULL ) { 10ca66: 8b 01 mov (%ecx),%eax 10ca68: 85 c0 test %eax,%eax 10ca6a: 0f 84 6b 02 00 00 je 10ccdb <_Objects_Extend_information+0x2af><== NEVER TAKEN 10ca70: 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 ); 10ca73: 8b 55 cc mov -0x34(%ebp),%edx 10ca76: 89 55 d4 mov %edx,-0x2c(%ebp) index_base = minimum_index; block = 0; 10ca79: 31 d2 xor %edx,%edx 10ca7b: 8b 45 d4 mov -0x2c(%ebp),%eax 10ca7e: eb 0a jmp 10ca8a <_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 ) { 10ca80: 83 3c 91 00 cmpl $0x0,(%ecx,%edx,4) 10ca84: 0f 84 c6 01 00 00 je 10cc50 <_Objects_Extend_information+0x224> do_extend = false; break; } else index_base += information->allocation_size; 10ca8a: 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++ ) { 10ca8c: 42 inc %edx 10ca8d: 39 d6 cmp %edx,%esi 10ca8f: 77 ef ja 10ca80 <_Objects_Extend_information+0x54> 10ca91: 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; 10ca94: b1 01 mov $0x1,%cl } else index_base += information->allocation_size; } } maximum = (uint32_t) information->maximum + information->allocation_size; 10ca96: 0f b7 45 d0 movzwl -0x30(%ebp),%eax 10ca9a: 01 f8 add %edi,%eax 10ca9c: 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 ) { 10ca9f: 3d ff ff 00 00 cmp $0xffff,%eax 10caa4: 0f 87 9e 01 00 00 ja 10cc48 <_Objects_Extend_information+0x21c><== 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; 10caaa: 0f af 7b 18 imul 0x18(%ebx),%edi if ( information->auto_extend ) { 10caae: 80 7b 12 00 cmpb $0x0,0x12(%ebx) 10cab2: 0f 84 a4 01 00 00 je 10cc5c <_Objects_Extend_information+0x230> new_object_block = _Workspace_Allocate( block_size ); 10cab8: 83 ec 0c sub $0xc,%esp 10cabb: 57 push %edi 10cabc: 89 55 b8 mov %edx,-0x48(%ebp) 10cabf: 88 4d b4 mov %cl,-0x4c(%ebp) 10cac2: e8 99 1e 00 00 call 10e960 <_Workspace_Allocate> 10cac7: 89 45 c8 mov %eax,-0x38(%ebp) if ( !new_object_block ) 10caca: 83 c4 10 add $0x10,%esp 10cacd: 85 c0 test %eax,%eax 10cacf: 8b 55 b8 mov -0x48(%ebp),%edx 10cad2: 8a 4d b4 mov -0x4c(%ebp),%cl 10cad5: 0f 84 6d 01 00 00 je 10cc48 <_Objects_Extend_information+0x21c> } /* * Do we need to grow the tables? */ if ( do_extend ) { 10cadb: 84 c9 test %cl,%cl 10cadd: 0f 84 ea 00 00 00 je 10cbcd <_Objects_Extend_information+0x1a1> */ /* * Up the block count and maximum */ block_count++; 10cae3: 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 ); 10cae6: 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 *)) + 10cae9: 8d 04 7f lea (%edi,%edi,2),%eax ((maximum + minimum_index) * sizeof(Objects_Control *)); 10caec: 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 *)) + 10caef: 03 45 cc add -0x34(%ebp),%eax block_count++; /* * Allocate the tables and break it up. */ block_size = block_count * 10caf2: 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 ); 10caf5: 50 push %eax 10caf6: 89 55 b8 mov %edx,-0x48(%ebp) 10caf9: e8 62 1e 00 00 call 10e960 <_Workspace_Allocate> 10cafe: 89 45 c4 mov %eax,-0x3c(%ebp) if ( !object_blocks ) { 10cb01: 83 c4 10 add $0x10,%esp 10cb04: 85 c0 test %eax,%eax 10cb06: 8b 55 b8 mov -0x48(%ebp),%edx 10cb09: 0f 84 de 01 00 00 je 10cced <_Objects_Extend_information+0x2c1> 10cb0f: 8b 45 c4 mov -0x3c(%ebp),%eax 10cb12: 8d 04 b8 lea (%eax,%edi,4),%eax 10cb15: 89 45 bc mov %eax,-0x44(%ebp) 10cb18: 8b 4d c4 mov -0x3c(%ebp),%ecx 10cb1b: 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 ) { 10cb1e: 0f b7 4b 10 movzwl 0x10(%ebx),%ecx 10cb22: 39 4d cc cmp %ecx,-0x34(%ebp) 10cb25: 0f 82 51 01 00 00 jb 10cc7c <_Objects_Extend_information+0x250> } else { /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { 10cb2b: 8b 4d cc mov -0x34(%ebp),%ecx 10cb2e: 85 c9 test %ecx,%ecx 10cb30: 74 12 je 10cb44 <_Objects_Extend_information+0x118><== NEVER TAKEN 10cb32: 31 c9 xor %ecx,%ecx 10cb34: 8b 7d cc mov -0x34(%ebp),%edi 10cb37: 90 nop local_table[ index ] = NULL; 10cb38: 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++ ) { 10cb3f: 41 inc %ecx 10cb40: 39 cf cmp %ecx,%edi 10cb42: 77 f4 ja 10cb38 <_Objects_Extend_information+0x10c><== NEVER TAKEN 10cb44: c1 e6 02 shl $0x2,%esi 10cb47: 89 75 c0 mov %esi,-0x40(%ebp) } /* * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; 10cb4a: 8b 4d c4 mov -0x3c(%ebp),%ecx 10cb4d: 8b 75 c0 mov -0x40(%ebp),%esi 10cb50: c7 04 31 00 00 00 00 movl $0x0,(%ecx,%esi,1) inactive_per_block[block_count] = 0; 10cb57: 8b 4d bc mov -0x44(%ebp),%ecx 10cb5a: c7 04 31 00 00 00 00 movl $0x0,(%ecx,%esi,1) for ( index=index_base ; index < ( information->allocation_size + index_base ); 10cb61: 0f b7 73 14 movzwl 0x14(%ebx),%esi 10cb65: 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 ; 10cb68: 39 75 d4 cmp %esi,-0x2c(%ebp) 10cb6b: 73 0f jae 10cb7c <_Objects_Extend_information+0x150><== NEVER TAKEN 10cb6d: 8b 4d d4 mov -0x2c(%ebp),%ecx index < ( information->allocation_size + index_base ); index++ ) { local_table[ index ] = NULL; 10cb70: 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++ ) { 10cb77: 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 ; 10cb78: 39 f1 cmp %esi,%ecx 10cb7a: 72 f4 jb 10cb70 <_Objects_Extend_information+0x144> index < ( information->allocation_size + index_base ); index++ ) { local_table[ index ] = NULL; } _ISR_Disable( level ); 10cb7c: 9c pushf 10cb7d: fa cli 10cb7e: 5f pop %edi old_tables = information->object_blocks; 10cb7f: 8b 4b 34 mov 0x34(%ebx),%ecx information->object_blocks = object_blocks; 10cb82: 8b 75 c4 mov -0x3c(%ebp),%esi 10cb85: 89 73 34 mov %esi,0x34(%ebx) information->inactive_per_block = inactive_per_block; 10cb88: 8b 75 bc mov -0x44(%ebp),%esi 10cb8b: 89 73 30 mov %esi,0x30(%ebx) information->local_table = local_table; 10cb8e: 89 43 1c mov %eax,0x1c(%ebx) information->maximum = (Objects_Maximum) maximum; 10cb91: 8b 45 d0 mov -0x30(%ebp),%eax 10cb94: 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) | 10cb98: 8b 33 mov (%ebx),%esi 10cb9a: c1 e6 18 shl $0x18,%esi 10cb9d: 81 ce 00 00 01 00 or $0x10000,%esi information->maximum_id = _Objects_Build_id( 10cba3: 0f b7 43 04 movzwl 0x4(%ebx),%eax (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) | 10cba7: c1 e0 1b shl $0x1b,%eax 10cbaa: 09 c6 or %eax,%esi 10cbac: 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) | 10cbb0: 09 c6 or %eax,%esi 10cbb2: 89 73 0c mov %esi,0xc(%ebx) information->the_class, _Objects_Local_node, information->maximum ); _ISR_Enable( level ); 10cbb5: 57 push %edi 10cbb6: 9d popf if ( old_tables ) 10cbb7: 85 c9 test %ecx,%ecx 10cbb9: 74 12 je 10cbcd <_Objects_Extend_information+0x1a1> _Workspace_Free( old_tables ); 10cbbb: 83 ec 0c sub $0xc,%esp 10cbbe: 51 push %ecx 10cbbf: 89 55 b8 mov %edx,-0x48(%ebp) 10cbc2: e8 b5 1d 00 00 call 10e97c <_Workspace_Free> 10cbc7: 83 c4 10 add $0x10,%esp 10cbca: 8b 55 b8 mov -0x48(%ebp),%edx } /* * Assign the new object block to the object block table. */ information->object_blocks[ block ] = new_object_block; 10cbcd: c1 e2 02 shl $0x2,%edx 10cbd0: 89 55 d0 mov %edx,-0x30(%ebp) 10cbd3: 8b 43 34 mov 0x34(%ebx),%eax 10cbd6: 8b 4d c8 mov -0x38(%ebp),%ecx 10cbd9: 89 0c 10 mov %ecx,(%eax,%edx,1) /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 10cbdc: ff 73 18 pushl 0x18(%ebx) 10cbdf: 0f b7 43 14 movzwl 0x14(%ebx),%eax 10cbe3: 50 push %eax 10cbe4: 51 push %ecx 10cbe5: 8d 7d dc lea -0x24(%ebp),%edi 10cbe8: 57 push %edi 10cbe9: e8 66 44 00 00 call 111054 <_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 ) { 10cbee: 83 c4 10 add $0x10,%esp 10cbf1: 8b 75 d4 mov -0x2c(%ebp),%esi information->the_class, _Objects_Local_node, index ); _Chain_Append( &information->Inactive, &the_object->Node ); 10cbf4: 8d 43 20 lea 0x20(%ebx),%eax 10cbf7: 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 ) { 10cbfa: eb 29 jmp 10cc25 <_Objects_Extend_information+0x1f9> 10cbfc: 8b 13 mov (%ebx),%edx 10cbfe: c1 e2 18 shl $0x18,%edx 10cc01: 81 ca 00 00 01 00 or $0x10000,%edx the_object->id = _Objects_Build_id( 10cc07: 0f b7 4b 04 movzwl 0x4(%ebx),%ecx (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) | 10cc0b: c1 e1 1b shl $0x1b,%ecx 10cc0e: 09 ca or %ecx,%edx uint32_t the_class, uint32_t node, uint32_t index ) { return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) | 10cc10: 09 f2 or %esi,%edx 10cc12: 89 50 08 mov %edx,0x8(%eax) information->the_class, _Objects_Local_node, index ); _Chain_Append( &information->Inactive, &the_object->Node ); 10cc15: 83 ec 08 sub $0x8,%esp 10cc18: 50 push %eax 10cc19: ff 75 d4 pushl -0x2c(%ebp) 10cc1c: e8 bb f3 ff ff call 10bfdc <_Chain_Append> index++; 10cc21: 46 inc %esi 10cc22: 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 ) { 10cc25: 83 ec 0c sub $0xc,%esp 10cc28: 57 push %edi 10cc29: e8 ea f3 ff ff call 10c018 <_Chain_Get> 10cc2e: 83 c4 10 add $0x10,%esp 10cc31: 85 c0 test %eax,%eax 10cc33: 75 c7 jne 10cbfc <_Objects_Extend_information+0x1d0> _Chain_Append( &information->Inactive, &the_object->Node ); index++; } information->inactive_per_block[ block ] = information->allocation_size; 10cc35: 8b 43 14 mov 0x14(%ebx),%eax 10cc38: 8b 53 30 mov 0x30(%ebx),%edx 10cc3b: 0f b7 c8 movzwl %ax,%ecx 10cc3e: 8b 75 d0 mov -0x30(%ebp),%esi 10cc41: 89 0c 32 mov %ecx,(%edx,%esi,1) information->inactive = (Objects_Maximum)(information->inactive + information->allocation_size); 10cc44: 66 01 43 2c add %ax,0x2c(%ebx) } 10cc48: 8d 65 f4 lea -0xc(%ebp),%esp 10cc4b: 5b pop %ebx 10cc4c: 5e pop %esi 10cc4d: 5f pop %edi 10cc4e: c9 leave 10cc4f: c3 ret 10cc50: 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; 10cc53: 31 c9 xor %ecx,%ecx 10cc55: e9 3c fe ff ff jmp 10ca96 <_Objects_Extend_information+0x6a> 10cc5a: 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 ); 10cc5c: 83 ec 0c sub $0xc,%esp 10cc5f: 57 push %edi 10cc60: 89 55 b8 mov %edx,-0x48(%ebp) 10cc63: 88 4d b4 mov %cl,-0x4c(%ebp) 10cc66: e8 29 1d 00 00 call 10e994 <_Workspace_Allocate_or_fatal_error> 10cc6b: 89 45 c8 mov %eax,-0x38(%ebp) 10cc6e: 83 c4 10 add $0x10,%esp 10cc71: 8a 4d b4 mov -0x4c(%ebp),%cl 10cc74: 8b 55 b8 mov -0x48(%ebp),%edx 10cc77: e9 5f fe ff ff jmp 10cadb <_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, 10cc7c: c1 e6 02 shl $0x2,%esi 10cc7f: 89 75 c0 mov %esi,-0x40(%ebp) 10cc82: 8b 73 34 mov 0x34(%ebx),%esi 10cc85: 8b 7d c4 mov -0x3c(%ebp),%edi 10cc88: 8b 4d c0 mov -0x40(%ebp),%ecx 10cc8b: f3 a4 rep movsb %ds:(%esi),%es:(%edi) information->object_blocks, block_count * sizeof(void*) ); memcpy( inactive_per_block, 10cc8d: 8b 73 30 mov 0x30(%ebx),%esi 10cc90: 8b 7d bc mov -0x44(%ebp),%edi 10cc93: 8b 4d c0 mov -0x40(%ebp),%ecx 10cc96: 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 *) ); 10cc98: 0f b7 4b 10 movzwl 0x10(%ebx),%ecx 10cc9c: 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, 10cc9f: c1 e1 02 shl $0x2,%ecx 10cca2: 8b 73 1c mov 0x1c(%ebx),%esi 10cca5: 89 c7 mov %eax,%edi 10cca7: f3 a4 rep movsb %ds:(%esi),%es:(%edi) 10cca9: e9 9c fe ff ff jmp 10cb4a <_Objects_Extend_information+0x11e> 10ccae: 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 ) 10ccb0: 8b 53 10 mov 0x10(%ebx),%edx 10ccb3: 66 89 55 d0 mov %dx,-0x30(%ebp) 10ccb7: 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 ); 10ccbb: 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; 10ccbe: b1 01 mov $0x1,%cl minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0; 10ccc0: 31 d2 xor %edx,%edx /* if ( information->maximum < minimum_index ) */ if ( information->object_blocks == NULL ) block_count = 0; 10ccc2: 31 f6 xor %esi,%esi 10ccc4: e9 cd fd ff ff jmp 10ca96 <_Objects_Extend_information+0x6a> else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { 10ccc9: 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 ); 10cccc: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED 10cccf: 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; 10ccd2: b1 01 mov $0x1,%cl <== NOT EXECUTED minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0; 10ccd4: 31 d2 xor %edx,%edx <== NOT EXECUTED 10ccd6: e9 bb fd ff ff jmp 10ca96 <_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 ) { 10ccdb: 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 ); 10ccde: 8b 4d cc mov -0x34(%ebp),%ecx <== NOT EXECUTED 10cce1: 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; 10cce4: 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; 10cce6: 31 d2 xor %edx,%edx <== NOT EXECUTED 10cce8: e9 a9 fd ff ff jmp 10ca96 <_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 ); 10cced: 83 ec 0c sub $0xc,%esp 10ccf0: ff 75 c8 pushl -0x38(%ebp) 10ccf3: e8 84 1c 00 00 call 10e97c <_Workspace_Free> return; 10ccf8: 83 c4 10 add $0x10,%esp 10ccfb: e9 48 ff ff ff jmp 10cc48 <_Objects_Extend_information+0x21c> =============================================================================== 0010cd90 <_Objects_Get_information>: Objects_Information *_Objects_Get_information( Objects_APIs the_api, uint16_t the_class ) { 10cd90: 55 push %ebp 10cd91: 89 e5 mov %esp,%ebp 10cd93: 56 push %esi 10cd94: 53 push %ebx 10cd95: 8b 75 08 mov 0x8(%ebp),%esi 10cd98: 8b 5d 0c mov 0xc(%ebp),%ebx Objects_Information *info; int the_class_api_maximum; if ( !the_class ) 10cd9b: 66 85 db test %bx,%bx 10cd9e: 75 0c jne 10cdac <_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; 10cda0: 31 c0 xor %eax,%eax if ( info->maximum == 0 ) return NULL; #endif return info; } 10cda2: 8d 65 f8 lea -0x8(%ebp),%esp 10cda5: 5b pop %ebx 10cda6: 5e pop %esi 10cda7: c9 leave 10cda8: c3 ret 10cda9: 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 ); 10cdac: 83 ec 0c sub $0xc,%esp 10cdaf: 56 push %esi 10cdb0: e8 37 48 00 00 call 1115ec <_Objects_API_maximum_class> if ( the_class_api_maximum == 0 ) 10cdb5: 83 c4 10 add $0x10,%esp 10cdb8: 85 c0 test %eax,%eax 10cdba: 74 e4 je 10cda0 <_Objects_Get_information+0x10> return NULL; if ( the_class > (uint32_t) the_class_api_maximum ) 10cdbc: 0f b7 db movzwl %bx,%ebx 10cdbf: 39 d8 cmp %ebx,%eax 10cdc1: 72 dd jb 10cda0 <_Objects_Get_information+0x10> return NULL; if ( !_Objects_Information_table[ the_api ] ) 10cdc3: 8b 14 b5 48 75 12 00 mov 0x127548(,%esi,4),%edx return NULL; 10cdca: 31 c0 xor %eax,%eax return NULL; if ( the_class > (uint32_t) the_class_api_maximum ) return NULL; if ( !_Objects_Information_table[ the_api ] ) 10cdcc: 85 d2 test %edx,%edx 10cdce: 74 d2 je 10cda2 <_Objects_Get_information+0x12><== NEVER TAKEN return NULL; info = _Objects_Information_table[ the_api ][ the_class ]; 10cdd0: 8b 04 9a mov (%edx,%ebx,4),%eax if ( !info ) 10cdd3: 85 c0 test %eax,%eax 10cdd5: 74 cb je 10cda2 <_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; 10cdd7: 31 d2 xor %edx,%edx 10cdd9: 66 83 78 10 00 cmpw $0x0,0x10(%eax) 10cdde: 0f 95 c2 setne %dl 10cde1: f7 da neg %edx 10cde3: 21 d0 and %edx,%eax 10cde5: eb bb jmp 10cda2 <_Objects_Get_information+0x12> =============================================================================== 0010cde8 <_Objects_Get_isr_disable>: Objects_Information *information, Objects_Id id, Objects_Locations *location, ISR_Level *level_p ) { 10cde8: 55 push %ebp 10cde9: 89 e5 mov %esp,%ebp 10cdeb: 56 push %esi 10cdec: 53 push %ebx 10cded: 8b 55 08 mov 0x8(%ebp),%edx 10cdf0: 8b 5d 10 mov 0x10(%ebp),%ebx Objects_Control *the_object; uint32_t index; ISR_Level level; index = id - information->minimum_id + 1; 10cdf3: b8 01 00 00 00 mov $0x1,%eax 10cdf8: 2b 42 08 sub 0x8(%edx),%eax 10cdfb: 03 45 0c add 0xc(%ebp),%eax _ISR_Disable( level ); 10cdfe: 9c pushf 10cdff: fa cli 10ce00: 5e pop %esi if ( information->maximum >= index ) { 10ce01: 0f b7 4a 10 movzwl 0x10(%edx),%ecx 10ce05: 39 c8 cmp %ecx,%eax 10ce07: 77 1b ja 10ce24 <_Objects_Get_isr_disable+0x3c> if ( (the_object = information->local_table[ index ]) != NULL ) { 10ce09: 8b 52 1c mov 0x1c(%edx),%edx 10ce0c: 8b 04 82 mov (%edx,%eax,4),%eax 10ce0f: 85 c0 test %eax,%eax 10ce11: 74 21 je 10ce34 <_Objects_Get_isr_disable+0x4c> *location = OBJECTS_LOCAL; 10ce13: c7 03 00 00 00 00 movl $0x0,(%ebx) *level_p = level; 10ce19: 8b 55 14 mov 0x14(%ebp),%edx 10ce1c: 89 32 mov %esi,(%edx) _Objects_MP_Is_remote( information, id, location, &the_object ); return the_object; #else return NULL; #endif } 10ce1e: 5b pop %ebx 10ce1f: 5e pop %esi 10ce20: c9 leave 10ce21: c3 ret 10ce22: 66 90 xchg %ax,%ax } _ISR_Enable( level ); *location = OBJECTS_ERROR; return NULL; } _ISR_Enable( level ); 10ce24: 56 push %esi 10ce25: 9d popf *location = OBJECTS_ERROR; 10ce26: 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; 10ce2c: 31 c0 xor %eax,%eax #endif } 10ce2e: 5b pop %ebx 10ce2f: 5e pop %esi 10ce30: c9 leave 10ce31: c3 ret 10ce32: 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 ); 10ce34: 56 push %esi 10ce35: 9d popf *location = OBJECTS_ERROR; 10ce36: c7 03 01 00 00 00 movl $0x1,(%ebx) return NULL; 10ce3c: eb e0 jmp 10ce1e <_Objects_Get_isr_disable+0x36> =============================================================================== 0010e4d8 <_Objects_Get_name_as_string>: char *_Objects_Get_name_as_string( Objects_Id id, size_t length, char *name ) { 10e4d8: 55 push %ebp 10e4d9: 89 e5 mov %esp,%ebp 10e4db: 57 push %edi 10e4dc: 56 push %esi 10e4dd: 53 push %ebx 10e4de: 83 ec 2c sub $0x2c,%esp 10e4e1: 8b 55 08 mov 0x8(%ebp),%edx 10e4e4: 8b 75 0c mov 0xc(%ebp),%esi 10e4e7: 8b 5d 10 mov 0x10(%ebp),%ebx char lname[5]; Objects_Control *the_object; Objects_Locations location; Objects_Id tmpId; if ( length == 0 ) 10e4ea: 85 f6 test %esi,%esi 10e4ec: 75 0e jne 10e4fc <_Objects_Get_name_as_string+0x24> #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* not supported */ #endif case OBJECTS_ERROR: return NULL; 10e4ee: 31 db xor %ebx,%ebx _Thread_Enable_dispatch(); return name; } return NULL; /* unreachable path */ } 10e4f0: 89 d8 mov %ebx,%eax 10e4f2: 8d 65 f4 lea -0xc(%ebp),%esp 10e4f5: 5b pop %ebx 10e4f6: 5e pop %esi 10e4f7: 5f pop %edi 10e4f8: c9 leave 10e4f9: c3 ret 10e4fa: 66 90 xchg %ax,%ax Objects_Id tmpId; if ( length == 0 ) return NULL; if ( name == NULL ) 10e4fc: 85 db test %ebx,%ebx 10e4fe: 74 f0 je 10e4f0 <_Objects_Get_name_as_string+0x18> return NULL; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10e500: 85 d2 test %edx,%edx 10e502: 75 08 jne 10e50c <_Objects_Get_name_as_string+0x34> 10e504: a1 98 29 13 00 mov 0x132998,%eax 10e509: 8b 50 08 mov 0x8(%eax),%edx information = _Objects_Get_information_id( tmpId ); 10e50c: 83 ec 0c sub $0xc,%esp 10e50f: 52 push %edx 10e510: 89 55 cc mov %edx,-0x34(%ebp) 10e513: e8 f0 fe ff ff call 10e408 <_Objects_Get_information_id> 10e518: 89 c7 mov %eax,%edi if ( !information ) 10e51a: 83 c4 10 add $0x10,%esp 10e51d: 85 c0 test %eax,%eax 10e51f: 8b 55 cc mov -0x34(%ebp),%edx 10e522: 74 ca je 10e4ee <_Objects_Get_name_as_string+0x16> return NULL; the_object = _Objects_Get( information, tmpId, &location ); 10e524: 51 push %ecx 10e525: 8d 45 e4 lea -0x1c(%ebp),%eax 10e528: 50 push %eax 10e529: 52 push %edx 10e52a: 57 push %edi 10e52b: e8 90 00 00 00 call 10e5c0 <_Objects_Get> switch ( location ) { 10e530: 83 c4 10 add $0x10,%esp 10e533: 8b 55 e4 mov -0x1c(%ebp),%edx 10e536: 85 d2 test %edx,%edx 10e538: 75 b4 jne 10e4ee <_Objects_Get_name_as_string+0x16> return NULL; case OBJECTS_LOCAL: #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) if ( information->is_string ) { 10e53a: 80 7f 38 00 cmpb $0x0,0x38(%edi) 10e53e: 74 54 je 10e594 <_Objects_Get_name_as_string+0xbc> s = the_object->name.name_p; 10e540: 8b 78 0c mov 0xc(%eax),%edi lname[ 4 ] = '\0'; s = lname; } d = name; if ( s ) { 10e543: 85 ff test %edi,%edi 10e545: 74 74 je 10e5bb <_Objects_Get_name_as_string+0xe3> for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 10e547: 4e dec %esi 10e548: 89 75 d4 mov %esi,-0x2c(%ebp) 10e54b: 74 6e je 10e5bb <_Objects_Get_name_as_string+0xe3><== NEVER TAKEN 10e54d: 8a 17 mov (%edi),%dl 10e54f: 84 d2 test %dl,%dl 10e551: 74 68 je 10e5bb <_Objects_Get_name_as_string+0xe3> 10e553: 89 d9 mov %ebx,%ecx 10e555: 31 c0 xor %eax,%eax 10e557: 89 5d d0 mov %ebx,-0x30(%ebp) 10e55a: eb 07 jmp 10e563 <_Objects_Get_name_as_string+0x8b> 10e55c: 8a 14 07 mov (%edi,%eax,1),%dl 10e55f: 84 d2 test %dl,%dl 10e561: 74 21 je 10e584 <_Objects_Get_name_as_string+0xac> *d = (isprint((unsigned char)*s)) ? *s : '*'; 10e563: 0f b6 da movzbl %dl,%ebx 10e566: 8b 35 a8 82 12 00 mov 0x1282a8,%esi 10e56c: 0f be 5c 1e 01 movsbl 0x1(%esi,%ebx,1),%ebx 10e571: 81 e3 97 00 00 00 and $0x97,%ebx 10e577: 75 02 jne 10e57b <_Objects_Get_name_as_string+0xa3> 10e579: b2 2a mov $0x2a,%dl 10e57b: 88 11 mov %dl,(%ecx) s = lname; } d = name; if ( s ) { for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 10e57d: 40 inc %eax 10e57e: 41 inc %ecx 10e57f: 3b 45 d4 cmp -0x2c(%ebp),%eax 10e582: 72 d8 jb 10e55c <_Objects_Get_name_as_string+0x84> 10e584: 8b 5d d0 mov -0x30(%ebp),%ebx *d = (isprint((unsigned char)*s)) ? *s : '*'; } } *d = '\0'; 10e587: c6 01 00 movb $0x0,(%ecx) _Thread_Enable_dispatch(); 10e58a: e8 e5 0a 00 00 call 10f074 <_Thread_Enable_dispatch> return name; 10e58f: e9 5c ff ff ff jmp 10e4f0 <_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; 10e594: 8b 40 0c mov 0xc(%eax),%eax lname[ 0 ] = (u32_name >> 24) & 0xff; 10e597: 89 c2 mov %eax,%edx 10e599: c1 ea 18 shr $0x18,%edx 10e59c: 88 55 df mov %dl,-0x21(%ebp) lname[ 1 ] = (u32_name >> 16) & 0xff; 10e59f: 89 c2 mov %eax,%edx 10e5a1: c1 ea 10 shr $0x10,%edx 10e5a4: 88 55 e0 mov %dl,-0x20(%ebp) lname[ 2 ] = (u32_name >> 8) & 0xff; 10e5a7: 89 c2 mov %eax,%edx 10e5a9: c1 ea 08 shr $0x8,%edx 10e5ac: 88 55 e1 mov %dl,-0x1f(%ebp) lname[ 3 ] = (u32_name >> 0) & 0xff; 10e5af: 88 45 e2 mov %al,-0x1e(%ebp) lname[ 4 ] = '\0'; 10e5b2: c6 45 e3 00 movb $0x0,-0x1d(%ebp) s = lname; 10e5b6: 8d 7d df lea -0x21(%ebp),%edi 10e5b9: eb 8c jmp 10e547 <_Objects_Get_name_as_string+0x6f> } d = name; if ( s ) { for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 10e5bb: 89 d9 mov %ebx,%ecx 10e5bd: eb c8 jmp 10e587 <_Objects_Get_name_as_string+0xaf> =============================================================================== 0010cf98 <_Objects_Get_next>: Objects_Information *information, Objects_Id id, Objects_Locations *location_p, Objects_Id *next_id_p ) { 10cf98: 55 push %ebp 10cf99: 89 e5 mov %esp,%ebp 10cf9b: 57 push %edi 10cf9c: 56 push %esi 10cf9d: 53 push %ebx 10cf9e: 83 ec 0c sub $0xc,%esp 10cfa1: 8b 5d 08 mov 0x8(%ebp),%ebx 10cfa4: 8b 75 0c mov 0xc(%ebp),%esi 10cfa7: 8b 7d 10 mov 0x10(%ebp),%edi Objects_Control *object; Objects_Id next_id; if ( !information ) 10cfaa: 85 db test %ebx,%ebx 10cfac: 75 0a jne 10cfb8 <_Objects_Get_next+0x20> if ( !location_p ) return NULL; if ( !next_id_p ) return NULL; 10cfae: 31 c0 xor %eax,%eax return object; final: *next_id_p = OBJECTS_ID_FINAL; return 0; } 10cfb0: 8d 65 f4 lea -0xc(%ebp),%esp 10cfb3: 5b pop %ebx 10cfb4: 5e pop %esi 10cfb5: 5f pop %edi 10cfb6: c9 leave 10cfb7: c3 ret Objects_Id next_id; if ( !information ) return NULL; if ( !location_p ) 10cfb8: 85 ff test %edi,%edi 10cfba: 74 f2 je 10cfae <_Objects_Get_next+0x16> return NULL; if ( !next_id_p ) 10cfbc: 8b 45 14 mov 0x14(%ebp),%eax 10cfbf: 85 c0 test %eax,%eax 10cfc1: 74 eb je 10cfae <_Objects_Get_next+0x16> return NULL; if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX) 10cfc3: 66 85 f6 test %si,%si 10cfc6: 75 04 jne 10cfcc <_Objects_Get_next+0x34> next_id = information->minimum_id; 10cfc8: 8b 73 08 mov 0x8(%ebx),%esi 10cfcb: 90 nop else next_id = id; do { /* walked off end of list? */ if (_Objects_Get_index(next_id) > information->maximum) 10cfcc: 66 39 73 10 cmp %si,0x10(%ebx) 10cfd0: 72 22 jb 10cff4 <_Objects_Get_next+0x5c> *location_p = OBJECTS_ERROR; goto final; } /* try to grab one */ object = _Objects_Get(information, next_id, location_p); 10cfd2: 51 push %ecx 10cfd3: 57 push %edi 10cfd4: 56 push %esi 10cfd5: 53 push %ebx 10cfd6: e8 2d 00 00 00 call 10d008 <_Objects_Get> next_id++; 10cfdb: 46 inc %esi } while (*location_p != OBJECTS_LOCAL); 10cfdc: 83 c4 10 add $0x10,%esp 10cfdf: 8b 17 mov (%edi),%edx 10cfe1: 85 d2 test %edx,%edx 10cfe3: 75 e7 jne 10cfcc <_Objects_Get_next+0x34> *next_id_p = next_id; 10cfe5: 8b 55 14 mov 0x14(%ebp),%edx 10cfe8: 89 32 mov %esi,(%edx) return object; final: *next_id_p = OBJECTS_ID_FINAL; return 0; } 10cfea: 8d 65 f4 lea -0xc(%ebp),%esp 10cfed: 5b pop %ebx 10cfee: 5e pop %esi 10cfef: 5f pop %edi 10cff0: c9 leave 10cff1: c3 ret 10cff2: 66 90 xchg %ax,%ax do { /* walked off end of list? */ if (_Objects_Get_index(next_id) > information->maximum) { *location_p = OBJECTS_ERROR; 10cff4: c7 07 01 00 00 00 movl $0x1,(%edi) *next_id_p = next_id; return object; final: *next_id_p = OBJECTS_ID_FINAL; 10cffa: 8b 45 14 mov 0x14(%ebp),%eax 10cffd: c7 00 ff ff ff ff movl $0xffffffff,(%eax) return 0; 10d003: 31 c0 xor %eax,%eax 10d005: eb a9 jmp 10cfb0 <_Objects_Get_next+0x18> =============================================================================== 0011b2a8 <_Objects_Get_no_protection>: Objects_Control *_Objects_Get_no_protection( Objects_Information *information, Objects_Id id, Objects_Locations *location ) { 11b2a8: 55 push %ebp 11b2a9: 89 e5 mov %esp,%ebp 11b2ab: 53 push %ebx 11b2ac: 8b 55 08 mov 0x8(%ebp),%edx 11b2af: 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; 11b2b2: b8 01 00 00 00 mov $0x1,%eax 11b2b7: 2b 42 08 sub 0x8(%edx),%eax 11b2ba: 03 45 0c add 0xc(%ebp),%eax if ( information->maximum >= index ) { 11b2bd: 0f b7 4a 10 movzwl 0x10(%edx),%ecx 11b2c1: 39 c8 cmp %ecx,%eax 11b2c3: 77 13 ja 11b2d8 <_Objects_Get_no_protection+0x30> if ( (the_object = information->local_table[ index ]) != NULL ) { 11b2c5: 8b 52 1c mov 0x1c(%edx),%edx 11b2c8: 8b 04 82 mov (%edx,%eax,4),%eax 11b2cb: 85 c0 test %eax,%eax 11b2cd: 74 09 je 11b2d8 <_Objects_Get_no_protection+0x30><== NEVER TAKEN *location = OBJECTS_LOCAL; 11b2cf: 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; } 11b2d5: 5b pop %ebx 11b2d6: c9 leave 11b2d7: 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; 11b2d8: c7 03 01 00 00 00 movl $0x1,(%ebx) return NULL; 11b2de: 31 c0 xor %eax,%eax } 11b2e0: 5b pop %ebx 11b2e1: c9 leave 11b2e2: c3 ret =============================================================================== 0010e0ec <_Objects_Id_to_name>: */ Objects_Name_or_id_lookup_errors _Objects_Id_to_name ( Objects_Id id, Objects_Name *name ) { 10e0ec: 55 push %ebp 10e0ed: 89 e5 mov %esp,%ebp 10e0ef: 83 ec 18 sub $0x18,%esp 10e0f2: 8b 55 08 mov 0x8(%ebp),%edx /* * Caller is trusted for name != NULL. */ tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10e0f5: 85 d2 test %edx,%edx 10e0f7: 75 08 jne 10e101 <_Objects_Id_to_name+0x15> 10e0f9: a1 78 a7 12 00 mov 0x12a778,%eax 10e0fe: 8b 50 08 mov 0x8(%eax),%edx 10e101: 89 d0 mov %edx,%eax 10e103: c1 e8 18 shr $0x18,%eax 10e106: 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 ) 10e109: 8d 48 ff lea -0x1(%eax),%ecx 10e10c: 83 f9 02 cmp $0x2,%ecx 10e10f: 77 1d ja 10e12e <_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 ] ) 10e111: 8b 04 85 68 a1 12 00 mov 0x12a168(,%eax,4),%eax 10e118: 85 c0 test %eax,%eax 10e11a: 74 12 je 10e12e <_Objects_Id_to_name+0x42> */ RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class( Objects_Id id ) { return (uint32_t) 10e11c: 89 d1 mov %edx,%ecx 10e11e: c1 e9 1b shr $0x1b,%ecx return OBJECTS_INVALID_ID; the_class = _Objects_Get_class( tmpId ); information = _Objects_Information_table[ the_api ][ the_class ]; 10e121: 8b 04 88 mov (%eax,%ecx,4),%eax if ( !information ) 10e124: 85 c0 test %eax,%eax 10e126: 74 06 je 10e12e <_Objects_Id_to_name+0x42><== NEVER TAKEN return OBJECTS_INVALID_ID; #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) if ( information->is_string ) 10e128: 80 78 38 00 cmpb $0x0,0x38(%eax) 10e12c: 74 0a je 10e138 <_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; 10e12e: 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; } 10e133: c9 leave 10e134: c3 ret 10e135: 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 ); 10e138: 51 push %ecx 10e139: 8d 4d f4 lea -0xc(%ebp),%ecx 10e13c: 51 push %ecx 10e13d: 52 push %edx 10e13e: 50 push %eax 10e13f: e8 40 ff ff ff call 10e084 <_Objects_Get> if ( !the_object ) 10e144: 83 c4 10 add $0x10,%esp 10e147: 85 c0 test %eax,%eax 10e149: 74 e3 je 10e12e <_Objects_Id_to_name+0x42> return OBJECTS_INVALID_ID; *name = the_object->name; 10e14b: 8b 50 0c mov 0xc(%eax),%edx 10e14e: 8b 45 0c mov 0xc(%ebp),%eax 10e151: 89 10 mov %edx,(%eax) _Thread_Enable_dispatch(); 10e153: e8 50 0a 00 00 call 10eba8 <_Thread_Enable_dispatch> return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; 10e158: 31 c0 xor %eax,%eax } 10e15a: c9 leave 10e15b: c3 ret =============================================================================== 0010cea8 <_Objects_Initialize_information>: , bool supports_global, Objects_Thread_queue_Extract_callout extract #endif ) { 10cea8: 55 push %ebp 10cea9: 89 e5 mov %esp,%ebp 10ceab: 57 push %edi 10ceac: 56 push %esi 10cead: 53 push %ebx 10ceae: 83 ec 0c sub $0xc,%esp 10ceb1: 8b 45 08 mov 0x8(%ebp),%eax 10ceb4: 8b 55 0c mov 0xc(%ebp),%edx 10ceb7: 8b 5d 10 mov 0x10(%ebp),%ebx 10ceba: 8b 75 20 mov 0x20(%ebp),%esi 10cebd: 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; 10cec1: 89 10 mov %edx,(%eax) information->the_class = the_class; 10cec3: 66 89 58 04 mov %bx,0x4(%eax) information->size = size; 10cec7: 89 78 18 mov %edi,0x18(%eax) information->local_table = 0; 10ceca: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax) information->inactive_per_block = 0; 10ced1: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax) information->object_blocks = 0; 10ced8: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax) information->inactive = 0; 10cedf: 66 c7 40 2c 00 00 movw $0x0,0x2c(%eax) #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) information->is_string = is_string; 10cee5: 8b 7d 1c mov 0x1c(%ebp),%edi 10cee8: 89 f9 mov %edi,%ecx 10ceea: 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; 10ceed: 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; 10cef3: 0f b7 db movzwl %bx,%ebx 10cef6: 8b 3c 95 48 75 12 00 mov 0x127548(,%edx,4),%edi 10cefd: 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; 10cf00: 8b 7d 14 mov 0x14(%ebp),%edi 10cf03: 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 = 10cf06: 89 f9 mov %edi,%ecx 10cf08: 88 48 12 mov %cl,0x12(%eax) (maximum & OBJECTS_UNLIMITED_OBJECTS) ? true : false; maximum_per_allocation = maximum & ~OBJECTS_UNLIMITED_OBJECTS; 10cf0b: 8b 4d 14 mov 0x14(%ebp),%ecx 10cf0e: 81 e1 ff ff ff 7f and $0x7fffffff,%ecx /* * Unlimited and maximum of zero is illogical. */ if ( information->auto_extend && maximum_per_allocation == 0) { 10cf14: 85 ff test %edi,%edi 10cf16: 74 04 je 10cf1c <_Objects_Initialize_information+0x74> 10cf18: 85 c9 test %ecx,%ecx 10cf1a: 74 67 je 10cf83 <_Objects_Initialize_information+0xdb><== NEVER TAKEN } /* * The allocation unit is the maximum value */ information->allocation_size = maximum_per_allocation; 10cf1c: 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; 10cf20: c7 40 1c e4 71 12 00 movl $0x1271e4,0x1c(%eax) uint32_t the_class, uint32_t node, uint32_t index ) { return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) | 10cf27: c1 e2 18 shl $0x18,%edx 10cf2a: 81 ca 00 00 01 00 or $0x10000,%edx (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) | 10cf30: c1 e3 1b shl $0x1b,%ebx 10cf33: 09 da or %ebx,%edx /* * Calculate minimum and maximum Id's */ minimum_index = (maximum_per_allocation == 0) ? 0 : 1; 10cf35: 31 db xor %ebx,%ebx 10cf37: 85 c9 test %ecx,%ecx 10cf39: 0f 95 c3 setne %bl uint32_t the_class, uint32_t node, uint32_t index ) { return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) | 10cf3c: 09 da or %ebx,%edx 10cf3e: 89 50 08 mov %edx,0x8(%eax) /* * Calculate the maximum name length */ name_length = maximum_name_length; if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) ) 10cf41: f7 c6 03 00 00 00 test $0x3,%esi 10cf47: 75 23 jne 10cf6c <_Objects_Initialize_information+0xc4> name_length = (name_length + OBJECTS_NAME_ALIGNMENT) & ~(OBJECTS_NAME_ALIGNMENT-1); information->name_length = name_length; 10cf49: 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 ); 10cf4d: 8d 50 24 lea 0x24(%eax),%edx 10cf50: 89 50 20 mov %edx,0x20(%eax) head->next = tail; head->previous = NULL; 10cf53: 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 ); 10cf5a: 8d 50 20 lea 0x20(%eax),%edx 10cf5d: 89 50 28 mov %edx,0x28(%eax) _Chain_Initialize_empty( &information->Inactive ); /* * Initialize objects .. if there are any */ if ( maximum_per_allocation ) { 10cf60: 85 c9 test %ecx,%ecx 10cf62: 75 10 jne 10cf74 <_Objects_Initialize_information+0xcc> _Chain_Initialize_empty( &information->global_table[ index ] ); } else information->global_table = NULL; #endif } 10cf64: 8d 65 f4 lea -0xc(%ebp),%esp 10cf67: 5b pop %ebx 10cf68: 5e pop %esi 10cf69: 5f pop %edi 10cf6a: c9 leave 10cf6b: c3 ret * Calculate the maximum name length */ name_length = maximum_name_length; if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) ) name_length = (name_length + OBJECTS_NAME_ALIGNMENT) & 10cf6c: 83 c6 04 add $0x4,%esi 10cf6f: 83 e6 fc and $0xfffffffc,%esi 10cf72: eb d5 jmp 10cf49 <_Objects_Initialize_information+0xa1> /* * 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 ); 10cf74: 89 45 08 mov %eax,0x8(%ebp) _Chain_Initialize_empty( &information->global_table[ index ] ); } else information->global_table = NULL; #endif } 10cf77: 8d 65 f4 lea -0xc(%ebp),%esp 10cf7a: 5b pop %ebx 10cf7b: 5e pop %esi 10cf7c: 5f pop %edi 10cf7d: 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 ); 10cf7e: e9 a9 fa ff ff jmp 10ca2c <_Objects_Extend_information> /* * Unlimited and maximum of zero is illogical. */ if ( information->auto_extend && maximum_per_allocation == 0) { _Internal_error_Occurred( 10cf83: 50 push %eax 10cf84: 6a 13 push $0x13 10cf86: 6a 01 push $0x1 10cf88: 6a 00 push $0x0 10cf8a: e8 69 f9 ff ff call 10c8f8 <_Internal_error_Occurred> =============================================================================== 00117964 <_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 ) { 117964: 55 push %ebp 117965: 89 e5 mov %esp,%ebp 117967: 57 push %edi 117968: 56 push %esi 117969: 53 push %ebx 11796a: 83 ec 1c sub $0x1c,%esp 11796d: 8b 7d 08 mov 0x8(%ebp),%edi Objects_Control *the_object; uint32_t index; /* ASSERT: information->is_string == true */ if ( !id ) 117970: 8b 5d 10 mov 0x10(%ebp),%ebx 117973: 85 db test %ebx,%ebx 117975: 74 75 je 1179ec <_Objects_Name_to_id_string+0x88> return OBJECTS_INVALID_ADDRESS; if ( !name ) 117977: 8b 4d 0c mov 0xc(%ebp),%ecx 11797a: 85 c9 test %ecx,%ecx 11797c: 74 4b je 1179c9 <_Objects_Name_to_id_string+0x65> return OBJECTS_INVALID_NAME; if ( information->maximum != 0 ) { 11797e: 8b 47 10 mov 0x10(%edi),%eax 117981: 66 85 c0 test %ax,%ax 117984: 74 43 je 1179c9 <_Objects_Name_to_id_string+0x65> for ( index = 1; index <= information->maximum; index++ ) { 117986: 0f b7 c0 movzwl %ax,%eax 117989: 89 45 e4 mov %eax,-0x1c(%ebp) 11798c: 8b 47 1c mov 0x1c(%edi),%eax 11798f: bb 01 00 00 00 mov $0x1,%ebx 117994: 89 7d e0 mov %edi,-0x20(%ebp) 117997: 89 c7 mov %eax,%edi 117999: 8d 76 00 lea 0x0(%esi),%esi the_object = information->local_table[ index ]; 11799c: 8b 34 9f mov (%edi,%ebx,4),%esi if ( !the_object ) 11799f: 85 f6 test %esi,%esi 1179a1: 74 20 je 1179c3 <_Objects_Name_to_id_string+0x5f> continue; if ( !the_object->name.name_p ) 1179a3: 8b 46 0c mov 0xc(%esi),%eax 1179a6: 85 c0 test %eax,%eax 1179a8: 74 19 je 1179c3 <_Objects_Name_to_id_string+0x5f> continue; if (!strncmp( name, the_object->name.name_p, information->name_length)) { 1179aa: 52 push %edx 1179ab: 8b 4d e0 mov -0x20(%ebp),%ecx 1179ae: 0f b7 51 3a movzwl 0x3a(%ecx),%edx 1179b2: 52 push %edx 1179b3: 50 push %eax 1179b4: ff 75 0c pushl 0xc(%ebp) 1179b7: e8 70 35 00 00 call 11af2c 1179bc: 83 c4 10 add $0x10,%esp 1179bf: 85 c0 test %eax,%eax 1179c1: 74 15 je 1179d8 <_Objects_Name_to_id_string+0x74> if ( !name ) return OBJECTS_INVALID_NAME; if ( information->maximum != 0 ) { for ( index = 1; index <= information->maximum; index++ ) { 1179c3: 43 inc %ebx 1179c4: 3b 5d e4 cmp -0x1c(%ebp),%ebx 1179c7: 76 d3 jbe 11799c <_Objects_Name_to_id_string+0x38> return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; } } } return OBJECTS_INVALID_NAME; 1179c9: b8 01 00 00 00 mov $0x1,%eax } 1179ce: 8d 65 f4 lea -0xc(%ebp),%esp 1179d1: 5b pop %ebx 1179d2: 5e pop %esi 1179d3: 5f pop %edi 1179d4: c9 leave 1179d5: c3 ret 1179d6: 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; 1179d8: 8b 46 08 mov 0x8(%esi),%eax 1179db: 8b 55 10 mov 0x10(%ebp),%edx 1179de: 89 02 mov %eax,(%edx) return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; 1179e0: 31 c0 xor %eax,%eax } } } return OBJECTS_INVALID_NAME; } 1179e2: 8d 65 f4 lea -0xc(%ebp),%esp 1179e5: 5b pop %ebx 1179e6: 5e pop %esi 1179e7: 5f pop %edi 1179e8: c9 leave 1179e9: c3 ret 1179ea: 66 90 xchg %ax,%ax uint32_t index; /* ASSERT: information->is_string == true */ if ( !id ) return OBJECTS_INVALID_ADDRESS; 1179ec: b8 02 00 00 00 mov $0x2,%eax } } } return OBJECTS_INVALID_NAME; } 1179f1: 8d 65 f4 lea -0xc(%ebp),%esp 1179f4: 5b pop %ebx 1179f5: 5e pop %esi 1179f6: 5f pop %edi 1179f7: c9 leave 1179f8: c3 ret =============================================================================== 0010cfc4 <_Objects_Name_to_id_u32>: Objects_Information *information, uint32_t name, uint32_t node, Objects_Id *id ) { 10cfc4: 55 push %ebp 10cfc5: 89 e5 mov %esp,%ebp 10cfc7: 57 push %edi 10cfc8: 56 push %esi 10cfc9: 53 push %ebx 10cfca: 8b 45 08 mov 0x8(%ebp),%eax 10cfcd: 8b 4d 0c mov 0xc(%ebp),%ecx 10cfd0: 8b 55 10 mov 0x10(%ebp),%edx 10cfd3: 8b 7d 14 mov 0x14(%ebp),%edi Objects_Name name_for_mp; #endif /* ASSERT: information->is_string == false */ if ( !id ) 10cfd6: 85 ff test %edi,%edi 10cfd8: 74 56 je 10d030 <_Objects_Name_to_id_u32+0x6c> return OBJECTS_INVALID_ADDRESS; if ( name == 0 ) 10cfda: 85 c9 test %ecx,%ecx 10cfdc: 74 08 je 10cfe6 <_Objects_Name_to_id_u32+0x22> return OBJECTS_INVALID_NAME; search_local_node = false; if ( information->maximum != 0 && 10cfde: 8b 70 10 mov 0x10(%eax),%esi 10cfe1: 66 85 f6 test %si,%si 10cfe4: 75 0a jne 10cff0 <_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; 10cfe6: b8 01 00 00 00 mov $0x1,%eax #endif } 10cfeb: 5b pop %ebx 10cfec: 5e pop %esi 10cfed: 5f pop %edi 10cfee: c9 leave 10cfef: c3 ret if ( name == 0 ) return OBJECTS_INVALID_NAME; search_local_node = false; if ( information->maximum != 0 && 10cff0: 85 d2 test %edx,%edx 10cff2: 75 20 jne 10d014 <_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++ ) { 10cff4: 0f b7 f6 movzwl %si,%esi 10cff7: 8b 58 1c mov 0x1c(%eax),%ebx 10cffa: b8 01 00 00 00 mov $0x1,%eax 10cfff: 90 nop the_object = information->local_table[ index ]; 10d000: 8b 14 83 mov (%ebx,%eax,4),%edx if ( !the_object ) 10d003: 85 d2 test %edx,%edx 10d005: 74 05 je 10d00c <_Objects_Name_to_id_u32+0x48> continue; if ( name == the_object->name.name_u32 ) { 10d007: 39 4a 0c cmp %ecx,0xc(%edx) 10d00a: 74 18 je 10d024 <_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++ ) { 10d00c: 40 inc %eax 10d00d: 39 c6 cmp %eax,%esi 10d00f: 73 ef jae 10d000 <_Objects_Name_to_id_u32+0x3c> 10d011: eb d3 jmp 10cfe6 <_Objects_Name_to_id_u32+0x22> 10d013: 90 nop return OBJECTS_INVALID_NAME; search_local_node = false; if ( information->maximum != 0 && (node == OBJECTS_SEARCH_ALL_NODES || 10d014: 81 fa ff ff ff 7f cmp $0x7fffffff,%edx 10d01a: 74 d8 je 10cff4 <_Objects_Name_to_id_u32+0x30> node == OBJECTS_SEARCH_LOCAL_NODE || 10d01c: 4a dec %edx 10d01d: 75 c7 jne 10cfe6 <_Objects_Name_to_id_u32+0x22> 10d01f: eb d3 jmp 10cff4 <_Objects_Name_to_id_u32+0x30> 10d021: 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; 10d024: 8b 42 08 mov 0x8(%edx),%eax 10d027: 89 07 mov %eax,(%edi) return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; 10d029: 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 } 10d02b: 5b pop %ebx 10d02c: 5e pop %esi 10d02d: 5f pop %edi 10d02e: c9 leave 10d02f: c3 ret #endif /* ASSERT: information->is_string == false */ if ( !id ) return OBJECTS_INVALID_ADDRESS; 10d030: 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 } 10d035: 5b pop %ebx 10d036: 5e pop %esi 10d037: 5f pop %edi 10d038: c9 leave 10d039: c3 ret =============================================================================== 0010d6ac <_Objects_Set_name>: bool _Objects_Set_name( Objects_Information *information, Objects_Control *the_object, const char *name ) { 10d6ac: 55 push %ebp 10d6ad: 89 e5 mov %esp,%ebp 10d6af: 57 push %edi 10d6b0: 56 push %esi 10d6b1: 53 push %ebx 10d6b2: 83 ec 14 sub $0x14,%esp 10d6b5: 8b 7d 08 mov 0x8(%ebp),%edi 10d6b8: 8b 5d 10 mov 0x10(%ebp),%ebx size_t length; const char *s; s = name; length = strnlen( name, information->name_length ); 10d6bb: 0f b7 47 3a movzwl 0x3a(%edi),%eax 10d6bf: 50 push %eax 10d6c0: 53 push %ebx 10d6c1: e8 22 7a 00 00 call 1150e8 10d6c6: 89 c6 mov %eax,%esi #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) if ( information->is_string ) { 10d6c8: 83 c4 10 add $0x10,%esp 10d6cb: 80 7f 38 00 cmpb $0x0,0x38(%edi) 10d6cf: 75 57 jne 10d728 <_Objects_Set_name+0x7c> d[length] = '\0'; the_object->name.name_p = d; } else #endif { the_object->name.name_u32 = _Objects_Build_name( 10d6d1: 0f be 13 movsbl (%ebx),%edx 10d6d4: c1 e2 18 shl $0x18,%edx 10d6d7: 83 f8 01 cmp $0x1,%eax 10d6da: 76 38 jbe 10d714 <_Objects_Set_name+0x68> 10d6dc: 0f be 43 01 movsbl 0x1(%ebx),%eax 10d6e0: c1 e0 10 shl $0x10,%eax 10d6e3: 09 d0 or %edx,%eax 10d6e5: 83 fe 02 cmp $0x2,%esi 10d6e8: 74 31 je 10d71b <_Objects_Set_name+0x6f> 10d6ea: 0f be 53 02 movsbl 0x2(%ebx),%edx 10d6ee: c1 e2 08 shl $0x8,%edx 10d6f1: 09 c2 or %eax,%edx 10d6f3: 83 fe 03 cmp $0x3,%esi 10d6f6: 0f 84 88 00 00 00 je 10d784 <_Objects_Set_name+0xd8> 10d6fc: 0f be 43 03 movsbl 0x3(%ebx),%eax 10d700: 09 c2 or %eax,%edx 10d702: 8b 45 0c mov 0xc(%ebp),%eax 10d705: 89 50 0c mov %edx,0xc(%eax) ((3 < length) ? s[ 3 ] : ' ') ); } return true; 10d708: b0 01 mov $0x1,%al } 10d70a: 8d 65 f4 lea -0xc(%ebp),%esp 10d70d: 5b pop %ebx 10d70e: 5e pop %esi 10d70f: 5f pop %edi 10d710: c9 leave 10d711: c3 ret 10d712: 66 90 xchg %ax,%ax d[length] = '\0'; the_object->name.name_p = d; } else #endif { the_object->name.name_u32 = _Objects_Build_name( 10d714: 89 d0 mov %edx,%eax 10d716: 0d 00 00 20 00 or $0x200000,%eax 10d71b: 89 c2 mov %eax,%edx 10d71d: 80 ce 20 or $0x20,%dh 10d720: b8 20 00 00 00 mov $0x20,%eax 10d725: eb d9 jmp 10d700 <_Objects_Set_name+0x54> 10d727: 90 nop #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) if ( information->is_string ) { char *d; d = _Workspace_Allocate( length + 1 ); 10d728: 83 ec 0c sub $0xc,%esp 10d72b: 8d 40 01 lea 0x1(%eax),%eax 10d72e: 50 push %eax 10d72f: e8 80 19 00 00 call 10f0b4 <_Workspace_Allocate> 10d734: 89 c7 mov %eax,%edi if ( !d ) 10d736: 83 c4 10 add $0x10,%esp 10d739: 85 c0 test %eax,%eax 10d73b: 74 43 je 10d780 <_Objects_Set_name+0xd4> return false; if ( the_object->name.name_p ) { 10d73d: 8b 55 0c mov 0xc(%ebp),%edx 10d740: 8b 42 0c mov 0xc(%edx),%eax 10d743: 85 c0 test %eax,%eax 10d745: 74 16 je 10d75d <_Objects_Set_name+0xb1> _Workspace_Free( (void *)the_object->name.name_p ); 10d747: 83 ec 0c sub $0xc,%esp 10d74a: 50 push %eax 10d74b: e8 80 19 00 00 call 10f0d0 <_Workspace_Free> the_object->name.name_p = NULL; 10d750: 8b 45 0c mov 0xc(%ebp),%eax 10d753: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) 10d75a: 83 c4 10 add $0x10,%esp } strncpy( d, name, length ); 10d75d: 50 push %eax 10d75e: 56 push %esi 10d75f: 53 push %ebx 10d760: 57 push %edi 10d761: e8 06 79 00 00 call 11506c d[length] = '\0'; 10d766: c6 04 37 00 movb $0x0,(%edi,%esi,1) the_object->name.name_p = d; 10d76a: 8b 55 0c mov 0xc(%ebp),%edx 10d76d: 89 7a 0c mov %edi,0xc(%edx) 10d770: 83 c4 10 add $0x10,%esp ((3 < length) ? s[ 3 ] : ' ') ); } return true; 10d773: b0 01 mov $0x1,%al } 10d775: 8d 65 f4 lea -0xc(%ebp),%esp 10d778: 5b pop %ebx 10d779: 5e pop %esi 10d77a: 5f pop %edi 10d77b: c9 leave 10d77c: c3 ret 10d77d: 8d 76 00 lea 0x0(%esi),%esi if ( information->is_string ) { char *d; d = _Workspace_Allocate( length + 1 ); if ( !d ) return false; 10d780: 31 c0 xor %eax,%eax 10d782: eb 86 jmp 10d70a <_Objects_Set_name+0x5e> d[length] = '\0'; the_object->name.name_p = d; } else #endif { the_object->name.name_u32 = _Objects_Build_name( 10d784: b8 20 00 00 00 mov $0x20,%eax 10d789: e9 72 ff ff ff jmp 10d700 <_Objects_Set_name+0x54> =============================================================================== 0010d03c <_Objects_Shrink_information>: */ void _Objects_Shrink_information( Objects_Information *information ) { 10d03c: 55 push %ebp 10d03d: 89 e5 mov %esp,%ebp 10d03f: 57 push %edi 10d040: 56 push %esi 10d041: 53 push %ebx 10d042: 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 ); 10d045: 8b 45 08 mov 0x8(%ebp),%eax 10d048: 0f b7 58 08 movzwl 0x8(%eax),%ebx block_count = (information->maximum - index_base) / 10d04c: 0f b7 48 14 movzwl 0x14(%eax),%ecx 10d050: 0f b7 40 10 movzwl 0x10(%eax),%eax 10d054: 29 d8 sub %ebx,%eax 10d056: 31 d2 xor %edx,%edx 10d058: f7 f1 div %ecx information->allocation_size; for ( block = 0; block < block_count; block++ ) { 10d05a: 85 c0 test %eax,%eax 10d05c: 74 21 je 10d07f <_Objects_Shrink_information+0x43><== NEVER TAKEN if ( information->inactive_per_block[ block ] == 10d05e: 8b 55 08 mov 0x8(%ebp),%edx 10d061: 8b 7a 30 mov 0x30(%edx),%edi 10d064: 3b 0f cmp (%edi),%ecx 10d066: 74 1f je 10d087 <_Objects_Shrink_information+0x4b><== NEVER TAKEN 10d068: 31 d2 xor %edx,%edx 10d06a: eb 0e jmp 10d07a <_Objects_Shrink_information+0x3e> information->inactive -= information->allocation_size; return; } index_base += information->allocation_size; 10d06c: 01 cb add %ecx,%ebx 10d06e: 8d 34 95 00 00 00 00 lea 0x0(,%edx,4),%esi 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 ] == 10d075: 3b 0c 97 cmp (%edi,%edx,4),%ecx 10d078: 74 12 je 10d08c <_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++ ) { 10d07a: 42 inc %edx 10d07b: 39 d0 cmp %edx,%eax 10d07d: 77 ed ja 10d06c <_Objects_Shrink_information+0x30> return; } index_base += information->allocation_size; } } 10d07f: 8d 65 f4 lea -0xc(%ebp),%esp 10d082: 5b pop %ebx 10d083: 5e pop %esi 10d084: 5f pop %edi 10d085: c9 leave 10d086: 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 ] == 10d087: 31 f6 xor %esi,%esi 10d089: 8d 76 00 lea 0x0(%esi),%esi information->allocation_size ) { /* * Assume the Inactive chain is never empty at this point */ the_object = (Objects_Control *) _Chain_First( &information->Inactive ); 10d08c: 8b 55 08 mov 0x8(%ebp),%edx 10d08f: 8b 42 20 mov 0x20(%edx),%eax 10d092: 89 75 e4 mov %esi,-0x1c(%ebp) 10d095: eb 07 jmp 10d09e <_Objects_Shrink_information+0x62> 10d097: 90 nop if ((index >= index_base) && (index < (index_base + information->allocation_size))) { _Chain_Extract( &extract_me->Node ); } } while ( the_object ); 10d098: 85 ff test %edi,%edi 10d09a: 74 2c je 10d0c8 <_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; 10d09c: 89 f8 mov %edi,%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 ); 10d09e: 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; 10d0a2: 8b 38 mov (%eax),%edi if ((index >= index_base) && 10d0a4: 39 da cmp %ebx,%edx 10d0a6: 72 f0 jb 10d098 <_Objects_Shrink_information+0x5c> (index < (index_base + information->allocation_size))) { 10d0a8: 8b 75 08 mov 0x8(%ebp),%esi 10d0ab: 0f b7 4e 14 movzwl 0x14(%esi),%ecx 10d0af: 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) && 10d0b2: 39 ca cmp %ecx,%edx 10d0b4: 73 e2 jae 10d098 <_Objects_Shrink_information+0x5c> (index < (index_base + information->allocation_size))) { _Chain_Extract( &extract_me->Node ); 10d0b6: 83 ec 0c sub $0xc,%esp 10d0b9: 50 push %eax 10d0ba: e8 41 ef ff ff call 10c000 <_Chain_Extract> 10d0bf: 83 c4 10 add $0x10,%esp } } while ( the_object ); 10d0c2: 85 ff test %edi,%edi 10d0c4: 75 d6 jne 10d09c <_Objects_Shrink_information+0x60> 10d0c6: 66 90 xchg %ax,%ax 10d0c8: 8b 75 e4 mov -0x1c(%ebp),%esi /* * Free the memory and reset the structures in the object' information */ _Workspace_Free( information->object_blocks[ block ] ); 10d0cb: 83 ec 0c sub $0xc,%esp 10d0ce: 8b 55 08 mov 0x8(%ebp),%edx 10d0d1: 8b 42 34 mov 0x34(%edx),%eax 10d0d4: ff 34 30 pushl (%eax,%esi,1) 10d0d7: e8 a0 18 00 00 call 10e97c <_Workspace_Free> information->object_blocks[ block ] = NULL; 10d0dc: 8b 55 08 mov 0x8(%ebp),%edx 10d0df: 8b 42 34 mov 0x34(%edx),%eax 10d0e2: c7 04 30 00 00 00 00 movl $0x0,(%eax,%esi,1) information->inactive_per_block[ block ] = 0; 10d0e9: 8b 42 30 mov 0x30(%edx),%eax 10d0ec: c7 04 30 00 00 00 00 movl $0x0,(%eax,%esi,1) information->inactive -= information->allocation_size; 10d0f3: 8b 42 14 mov 0x14(%edx),%eax 10d0f6: 66 29 42 2c sub %ax,0x2c(%edx) return; 10d0fa: 83 c4 10 add $0x10,%esp } index_base += information->allocation_size; } } 10d0fd: 8d 65 f4 lea -0xc(%ebp),%esp 10d100: 5b pop %ebx 10d101: 5e pop %esi 10d102: 5f pop %edi 10d103: c9 leave 10d104: 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 99 3d 00 00 call 1112d8 <_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 88 1d 00 00 call 10f2e4 <_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 9b 3d 00 00 call 111300 <_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 99 3d 00 00 call 111324 <_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 ce 3d 00 00 call 111364 <_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 c0 a1 12 00 push $0x12a1c0 10c0ea: e8 7d 2b 00 00 call 10ec6c <_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 9f 38 00 00 call 10fad4 <_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 d3 34 00 00 call 10f720 <_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 d0 9c 12 00 mov 0x129cd0,%eax 10c2db: 48 dec %eax 10c2dc: a3 d0 9c 12 00 mov %eax,0x129cd0 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 08 34 00 00 call 10f720 <_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 b8 a2 12 00 mov 0x12a2b8,%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 78 ff 10 00 push $0x10ff78 10c363: ff 75 10 pushl 0x10(%ebp) 10c366: 56 push %esi 10c367: e8 90 38 00 00 call 10fbfc <_Thread_queue_Enqueue_with_handler> _Thread_Enable_dispatch(); 10c36c: e8 af 33 00 00 call 10f720 <_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 b8 a2 12 00 mov 0x12a2b8,%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 93 33 00 00 call 10f720 <_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 =============================================================================== 00116378 <_POSIX_Message_queue_Create_support>: const char *name_arg, int pshared, struct mq_attr *attr_ptr, POSIX_Message_queue_Control **message_queue ) { 116378: 55 push %ebp 116379: 89 e5 mov %esp,%ebp 11637b: 57 push %edi 11637c: 56 push %esi 11637d: 53 push %ebx 11637e: 83 ec 24 sub $0x24,%esp 116381: 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 ); 116384: 68 ff 00 00 00 push $0xff 116389: ff 75 08 pushl 0x8(%ebp) 11638c: e8 a7 4c 00 00 call 11b038 116391: 89 c6 mov %eax,%esi 116393: a1 b0 fa 12 00 mov 0x12fab0,%eax 116398: 40 inc %eax 116399: a3 b0 fa 12 00 mov %eax,0x12fab0 * 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 ) { 11639e: 83 c4 10 add $0x10,%esp 1163a1: 85 db test %ebx,%ebx 1163a3: 0f 84 b7 00 00 00 je 116460 <_POSIX_Message_queue_Create_support+0xe8> attr.mq_maxmsg = 10; attr.mq_msgsize = 16; } else { if ( attr_ptr->mq_maxmsg <= 0 ){ 1163a9: 8b 7b 04 mov 0x4(%ebx),%edi 1163ac: 85 ff test %edi,%edi 1163ae: 0f 8e f0 00 00 00 jle 1164a4 <_POSIX_Message_queue_Create_support+0x12c> _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EINVAL ); } if ( attr_ptr->mq_msgsize <= 0 ){ 1163b4: 8b 5b 08 mov 0x8(%ebx),%ebx 1163b7: 89 5d e4 mov %ebx,-0x1c(%ebp) 1163ba: 85 db test %ebx,%ebx 1163bc: 0f 8e e2 00 00 00 jle 1164a4 <_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 ); 1163c2: 83 ec 0c sub $0xc,%esp 1163c5: 68 80 fe 12 00 push $0x12fe80 1163ca: e8 d9 c3 ff ff call 1127a8 <_Objects_Allocate> 1163cf: 89 c3 mov %eax,%ebx attr = *attr_ptr; } the_mq = _POSIX_Message_queue_Allocate(); if ( !the_mq ) { 1163d1: 83 c4 10 add $0x10,%esp 1163d4: 85 c0 test %eax,%eax 1163d6: 0f 84 0a 01 00 00 je 1164e6 <_POSIX_Message_queue_Create_support+0x16e> _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENFILE ); } the_mq->process_shared = pshared; 1163dc: 8b 45 0c mov 0xc(%ebp),%eax 1163df: 89 43 10 mov %eax,0x10(%ebx) the_mq->named = true; 1163e2: c6 43 14 01 movb $0x1,0x14(%ebx) the_mq->open_count = 1; 1163e6: c7 43 18 01 00 00 00 movl $0x1,0x18(%ebx) the_mq->linked = true; 1163ed: 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); 1163f1: 8d 56 01 lea 0x1(%esi),%edx 1163f4: 83 ec 0c sub $0xc,%esp 1163f7: 52 push %edx 1163f8: 89 55 e0 mov %edx,-0x20(%ebp) 1163fb: e8 dc e4 ff ff call 1148dc <_Workspace_Allocate> 116400: 89 c6 mov %eax,%esi if (!name) { 116402: 83 c4 10 add $0x10,%esp 116405: 85 c0 test %eax,%eax 116407: 8b 55 e0 mov -0x20(%ebp),%edx 11640a: 0f 84 ab 00 00 00 je 1164bb <_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 ); 116410: 50 push %eax 116411: 52 push %edx 116412: ff 75 08 pushl 0x8(%ebp) 116415: 56 push %esi 116416: e8 a1 4b 00 00 call 11afbc * * 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; 11641b: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) if ( !_CORE_message_queue_Initialize( 116422: ff 75 e4 pushl -0x1c(%ebp) 116425: 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; 116426: 8d 43 5c lea 0x5c(%ebx),%eax the_mq_attr->discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO; if ( !_CORE_message_queue_Initialize( 116429: 50 push %eax 11642a: 8d 43 1c lea 0x1c(%ebx),%eax 11642d: 50 push %eax 11642e: e8 25 0f 00 00 call 117358 <_CORE_message_queue_Initialize> 116433: 83 c4 20 add $0x20,%esp 116436: 84 c0 test %al,%al 116438: 74 3a je 116474 <_POSIX_Message_queue_Create_support+0xfc> Objects_Information *information, Objects_Control *the_object, const char *name ) { _Objects_Set_local_object( 11643a: 0f b7 53 08 movzwl 0x8(%ebx),%edx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 11643e: a1 9c fe 12 00 mov 0x12fe9c,%eax 116443: 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; 116446: 89 73 0c mov %esi,0xc(%ebx) &_POSIX_Message_queue_Information, &the_mq->Object, name ); *message_queue = the_mq; 116449: 8b 45 14 mov 0x14(%ebp),%eax 11644c: 89 18 mov %ebx,(%eax) _Thread_Enable_dispatch(); 11644e: e8 41 d3 ff ff call 113794 <_Thread_Enable_dispatch> return 0; 116453: 31 c0 xor %eax,%eax } 116455: 8d 65 f4 lea -0xc(%ebp),%esp 116458: 5b pop %ebx 116459: 5e pop %esi 11645a: 5f pop %edi 11645b: c9 leave 11645c: c3 ret 11645d: 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; 116460: 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; 116467: bf 0a 00 00 00 mov $0xa,%edi 11646c: e9 51 ff ff ff jmp 1163c2 <_POSIX_Message_queue_Create_support+0x4a> 116471: 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 ); 116474: 83 ec 08 sub $0x8,%esp 116477: 53 push %ebx 116478: 68 80 fe 12 00 push $0x12fe80 11647d: e8 9e c6 ff ff call 112b20 <_Objects_Free> attr.mq_maxmsg, attr.mq_msgsize ) ) { _POSIX_Message_queue_Free( the_mq ); _Workspace_Free(name); 116482: 89 34 24 mov %esi,(%esp) 116485: e8 6e e4 ff ff call 1148f8 <_Workspace_Free> _Thread_Enable_dispatch(); 11648a: e8 05 d3 ff ff call 113794 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( ENOSPC ); 11648f: e8 24 34 00 00 call 1198b8 <__errno> 116494: c7 00 1c 00 00 00 movl $0x1c,(%eax) 11649a: 83 c4 10 add $0x10,%esp 11649d: b8 ff ff ff ff mov $0xffffffff,%eax 1164a2: eb b1 jmp 116455 <_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(); 1164a4: e8 eb d2 ff ff call 113794 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EINVAL ); 1164a9: e8 0a 34 00 00 call 1198b8 <__errno> 1164ae: c7 00 16 00 00 00 movl $0x16,(%eax) 1164b4: b8 ff ff ff ff mov $0xffffffff,%eax 1164b9: eb 9a jmp 116455 <_POSIX_Message_queue_Create_support+0xdd> 1164bb: 83 ec 08 sub $0x8,%esp 1164be: 53 push %ebx 1164bf: 68 80 fe 12 00 push $0x12fe80 1164c4: e8 57 c6 ff ff call 112b20 <_Objects_Free> * dynamically constructed. */ name = _Workspace_Allocate(n+1); if (!name) { _POSIX_Message_queue_Free( the_mq ); _Thread_Enable_dispatch(); 1164c9: e8 c6 d2 ff ff call 113794 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( ENOMEM ); 1164ce: e8 e5 33 00 00 call 1198b8 <__errno> 1164d3: c7 00 0c 00 00 00 movl $0xc,(%eax) 1164d9: 83 c4 10 add $0x10,%esp 1164dc: b8 ff ff ff ff mov $0xffffffff,%eax 1164e1: e9 6f ff ff ff jmp 116455 <_POSIX_Message_queue_Create_support+0xdd> attr = *attr_ptr; } the_mq = _POSIX_Message_queue_Allocate(); if ( !the_mq ) { _Thread_Enable_dispatch(); 1164e6: e8 a9 d2 ff ff call 113794 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( ENFILE ); 1164eb: e8 c8 33 00 00 call 1198b8 <__errno> 1164f0: c7 00 17 00 00 00 movl $0x17,(%eax) 1164f6: b8 ff ff ff ff mov $0xffffffff,%eax 1164fb: e9 55 ff ff ff jmp 116455 <_POSIX_Message_queue_Create_support+0xdd> =============================================================================== 00116500 <_POSIX_Message_queue_Name_to_id>: */ int _POSIX_Message_queue_Name_to_id( const char *name, Objects_Id *id ) { 116500: 55 push %ebp 116501: 89 e5 mov %esp,%ebp 116503: 53 push %ebx 116504: 83 ec 14 sub $0x14,%esp 116507: 8b 5d 08 mov 0x8(%ebp),%ebx Objects_Name_or_id_lookup_errors status; Objects_Id the_id; if ( !name ) 11650a: 85 db test %ebx,%ebx 11650c: 74 05 je 116513 <_POSIX_Message_queue_Name_to_id+0x13> return EINVAL; if ( !name[0] ) 11650e: 80 3b 00 cmpb $0x0,(%ebx) 116511: 75 0d jne 116520 <_POSIX_Message_queue_Name_to_id+0x20> return EINVAL; 116513: b8 16 00 00 00 mov $0x16,%eax if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL ) return 0; return ENOENT; } 116518: 8b 5d fc mov -0x4(%ebp),%ebx 11651b: c9 leave 11651c: c3 ret 11651d: 8d 76 00 lea 0x0(%esi),%esi return EINVAL; if ( !name[0] ) return EINVAL; if ( strnlen( name, NAME_MAX ) >= NAME_MAX ) 116520: 83 ec 08 sub $0x8,%esp 116523: 68 ff 00 00 00 push $0xff 116528: 53 push %ebx 116529: e8 0a 4b 00 00 call 11b038 11652e: 83 c4 10 add $0x10,%esp 116531: 3d fe 00 00 00 cmp $0xfe,%eax 116536: 76 0c jbe 116544 <_POSIX_Message_queue_Name_to_id+0x44> return ENAMETOOLONG; 116538: b8 5b 00 00 00 mov $0x5b,%eax if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL ) return 0; return ENOENT; } 11653d: 8b 5d fc mov -0x4(%ebp),%ebx 116540: c9 leave 116541: c3 ret 116542: 66 90 xchg %ax,%ax return EINVAL; if ( strnlen( name, NAME_MAX ) >= NAME_MAX ) return ENAMETOOLONG; status = _Objects_Name_to_id_string( 116544: 50 push %eax 116545: 8d 45 f4 lea -0xc(%ebp),%eax 116548: 50 push %eax 116549: 53 push %ebx 11654a: 68 80 fe 12 00 push $0x12fe80 11654f: e8 10 14 00 00 call 117964 <_Objects_Name_to_id_string> &_POSIX_Message_queue_Information, name, &the_id ); *id = the_id; 116554: 8b 4d f4 mov -0xc(%ebp),%ecx 116557: 8b 55 0c mov 0xc(%ebp),%edx 11655a: 89 0a mov %ecx,(%edx) if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL ) 11655c: 83 c4 10 add $0x10,%esp return 0; 11655f: 83 f8 01 cmp $0x1,%eax 116562: 19 c0 sbb %eax,%eax 116564: f7 d0 not %eax 116566: 83 e0 02 and $0x2,%eax return ENOENT; } 116569: 8b 5d fc mov -0x4(%ebp),%ebx 11656c: c9 leave 11656d: 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 00 13 00 push $0x130020 10fd02: e8 59 2f 00 00 call 112c60 <_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 a2 9b 00 00 call 1198b8 <__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 a3 1f 00 00 call 111d0c <_CORE_message_queue_Seize> &length_out, do_wait, timeout ); _Thread_Enable_dispatch(); 10fd69: 83 c4 20 add $0x20,%esp 10fd6c: e8 23 3a 00 00 call 113794 <_Thread_Enable_dispatch> *msg_prio = _POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count); 10fd71: 8b 15 98 00 13 00 mov 0x130098,%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 eb 39 00 00 call 113794 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EMSGSIZE ); 10fda9: e8 0a 9b 00 00 call 1198b8 <__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 f3 9a 00 00 call 1198b8 <__errno> 10fdc5: 89 c3 mov %eax,%ebx 10fdc7: 83 ec 0c sub $0xc,%esp 10fdca: a1 98 00 13 00 mov 0x130098,%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 a9 39 00 00 call 113794 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EBADF ); 10fdeb: e8 c8 9a 00 00 call 1198b8 <__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 00 13 00 push $0x130020 10fe45: 88 55 e4 mov %dl,-0x1c(%ebp) 10fe48: e8 13 2e 00 00 call 112c60 <_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 b4 1f 00 00 call 111e38 <_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 06 39 00 00 call 113794 <_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 00 13 00 mov 0x130098,%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 fb 99 00 00 call 1198b8 <__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 e7 99 00 00 call 1198b8 <__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 af 38 00 00 call 113794 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EBADF ); 10fee5: e8 ce 99 00 00 call 1198b8 <__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 bb 99 00 00 call 1198b8 <__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 a0 b9 12 00 push $0x12b9a0 10d112: e8 e9 2b 00 00 call 10fd00 <_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 a0 b9 12 00 push $0x12b9a0 10d168: e8 3b 2b 00 00 call 10fca8 <_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 47 1d 00 00 call 10f0cc <_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 78 bb 12 00 mov 0x12bb78,%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 =============================================================================== 00114958 <_POSIX_Semaphore_Create_support>: const char *name, int pshared, unsigned int value, POSIX_Semaphore_Control **the_sem ) { 114958: 55 push %ebp 114959: 89 e5 mov %esp,%ebp 11495b: 56 push %esi 11495c: 53 push %ebx 11495d: 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) 114960: 8b 55 0c mov 0xc(%ebp),%edx 114963: 85 d2 test %edx,%edx 114965: 0f 85 b9 00 00 00 jne 114a24 <_POSIX_Semaphore_Create_support+0xcc> rtems_set_errno_and_return_minus_one( ENOSYS ); if ( name ) { 11496b: 85 db test %ebx,%ebx 11496d: 74 1c je 11498b <_POSIX_Semaphore_Create_support+0x33> if ( strnlen( name, NAME_MAX ) >= NAME_MAX ) 11496f: 83 ec 08 sub $0x8,%esp 114972: 68 ff 00 00 00 push $0xff 114977: 53 push %ebx 114978: e8 0b 3e 00 00 call 118788 11497d: 83 c4 10 add $0x10,%esp 114980: 3d fe 00 00 00 cmp $0xfe,%eax 114985: 0f 87 ad 00 00 00 ja 114a38 <_POSIX_Semaphore_Create_support+0xe0> 11498b: a1 f0 d2 12 00 mov 0x12d2f0,%eax 114990: 40 inc %eax 114991: a3 f0 d2 12 00 mov %eax,0x12d2f0 */ RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Allocate( void ) { return (POSIX_Semaphore_Control *) _Objects_Allocate( &_POSIX_Semaphore_Information ); 114996: 83 ec 0c sub $0xc,%esp 114999: 68 40 d6 12 00 push $0x12d640 11499e: e8 89 b9 ff ff call 11032c <_Objects_Allocate> 1149a3: 89 c6 mov %eax,%esi _Thread_Disable_dispatch(); the_semaphore = _POSIX_Semaphore_Allocate(); if ( !the_semaphore ) { 1149a5: 83 c4 10 add $0x10,%esp 1149a8: 85 c0 test %eax,%eax 1149aa: 0f 84 9a 00 00 00 je 114a4a <_POSIX_Semaphore_Create_support+0xf2> _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENOSPC ); } the_semaphore->process_shared = pshared; 1149b0: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax) if ( name ) { 1149b7: 85 db test %ebx,%ebx 1149b9: 74 55 je 114a10 <_POSIX_Semaphore_Create_support+0xb8> the_semaphore->named = true; 1149bb: c6 40 14 01 movb $0x1,0x14(%eax) the_semaphore->open_count = 1; 1149bf: c7 40 18 01 00 00 00 movl $0x1,0x18(%eax) the_semaphore->linked = true; 1149c6: 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; 1149ca: c7 46 60 00 00 00 00 movl $0x0,0x60(%esi) /* * This effectively disables limit checking. */ the_sem_attr->maximum_count = 0xFFFFFFFF; 1149d1: c7 46 5c ff ff ff ff movl $0xffffffff,0x5c(%esi) _CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value ); 1149d8: 50 push %eax 1149d9: 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; 1149dc: 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 ); 1149df: 50 push %eax 1149e0: 8d 46 1c lea 0x1c(%esi),%eax 1149e3: 50 push %eax 1149e4: e8 cb b3 ff ff call 10fdb4 <_CORE_semaphore_Initialize> Objects_Information *information, Objects_Control *the_object, const char *name ) { _Objects_Set_local_object( 1149e9: 0f b7 56 08 movzwl 0x8(%esi),%edx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 1149ed: a1 5c d6 12 00 mov 0x12d65c,%eax 1149f2: 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; 1149f5: 89 5e 0c mov %ebx,0xc(%esi) &_POSIX_Semaphore_Information, &the_semaphore->Object, name_p ); *the_sem = the_semaphore; 1149f8: 8b 45 14 mov 0x14(%ebp),%eax 1149fb: 89 30 mov %esi,(%eax) _Thread_Enable_dispatch(); 1149fd: e8 16 c9 ff ff call 111318 <_Thread_Enable_dispatch> return 0; 114a02: 83 c4 10 add $0x10,%esp 114a05: 31 c0 xor %eax,%eax } 114a07: 8d 65 f8 lea -0x8(%ebp),%esp 114a0a: 5b pop %ebx 114a0b: 5e pop %esi 114a0c: c9 leave 114a0d: c3 ret 114a0e: 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; 114a10: c6 40 14 00 movb $0x0,0x14(%eax) the_semaphore->open_count = 0; 114a14: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) the_semaphore->linked = false; 114a1b: c6 40 15 00 movb $0x0,0x15(%eax) 114a1f: eb a9 jmp 1149ca <_POSIX_Semaphore_Create_support+0x72> 114a21: 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 ); 114a24: e8 33 2c 00 00 call 11765c <__errno> 114a29: c7 00 58 00 00 00 movl $0x58,(%eax) 114a2f: b8 ff ff ff ff mov $0xffffffff,%eax 114a34: eb d1 jmp 114a07 <_POSIX_Semaphore_Create_support+0xaf> 114a36: 66 90 xchg %ax,%ax if ( name ) { if ( strnlen( name, NAME_MAX ) >= NAME_MAX ) rtems_set_errno_and_return_minus_one( ENAMETOOLONG ); 114a38: e8 1f 2c 00 00 call 11765c <__errno> 114a3d: c7 00 5b 00 00 00 movl $0x5b,(%eax) 114a43: b8 ff ff ff ff mov $0xffffffff,%eax 114a48: eb bd jmp 114a07 <_POSIX_Semaphore_Create_support+0xaf> _Thread_Disable_dispatch(); the_semaphore = _POSIX_Semaphore_Allocate(); if ( !the_semaphore ) { _Thread_Enable_dispatch(); 114a4a: e8 c9 c8 ff ff call 111318 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( ENOSPC ); 114a4f: e8 08 2c 00 00 call 11765c <__errno> 114a54: c7 00 1c 00 00 00 movl $0x1c,(%eax) 114a5a: b8 ff ff ff ff mov $0xffffffff,%eax 114a5f: eb a6 jmp 114a07 <_POSIX_Semaphore_Create_support+0xaf> =============================================================================== 00114ab4 <_POSIX_Semaphore_Name_to_id>: int _POSIX_Semaphore_Name_to_id( const char *name, sem_t *id ) { 114ab4: 55 push %ebp 114ab5: 89 e5 mov %esp,%ebp 114ab7: 83 ec 18 sub $0x18,%esp 114aba: 8b 45 08 mov 0x8(%ebp),%eax Objects_Name_or_id_lookup_errors status; Objects_Id the_id; if ( !name ) 114abd: 85 c0 test %eax,%eax 114abf: 74 05 je 114ac6 <_POSIX_Semaphore_Name_to_id+0x12> return EINVAL; if ( !name[0] ) 114ac1: 80 38 00 cmpb $0x0,(%eax) 114ac4: 75 0a jne 114ad0 <_POSIX_Semaphore_Name_to_id+0x1c> return EINVAL; 114ac6: b8 16 00 00 00 mov $0x16,%eax if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL ) return 0; return ENOENT; } 114acb: c9 leave 114acc: c3 ret 114acd: 8d 76 00 lea 0x0(%esi),%esi return EINVAL; if ( !name[0] ) return EINVAL; status = _Objects_Name_to_id_string( 114ad0: 52 push %edx 114ad1: 8d 55 f4 lea -0xc(%ebp),%edx 114ad4: 52 push %edx 114ad5: 50 push %eax 114ad6: 68 40 d6 12 00 push $0x12d640 114adb: e8 7c 0c 00 00 call 11575c <_Objects_Name_to_id_string> &_POSIX_Semaphore_Information, name, &the_id ); *id = the_id; 114ae0: 8b 4d f4 mov -0xc(%ebp),%ecx 114ae3: 8b 55 0c mov 0xc(%ebp),%edx 114ae6: 89 0a mov %ecx,(%edx) if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL ) 114ae8: 83 c4 10 add $0x10,%esp return 0; 114aeb: 83 f8 01 cmp $0x1,%eax 114aee: 19 c0 sbb %eax,%eax 114af0: f7 d0 not %eax 114af2: 83 e0 02 and $0x2,%eax return ENOENT; } 114af5: c9 leave 114af6: c3 ret =============================================================================== 00114b20 <_POSIX_Semaphore_Wait_support>: int _POSIX_Semaphore_Wait_support( sem_t *sem, bool blocking, Watchdog_Interval timeout ) { 114b20: 55 push %ebp 114b21: 89 e5 mov %esp,%ebp 114b23: 53 push %ebx 114b24: 83 ec 18 sub $0x18,%esp 114b27: 8a 5d 0c mov 0xc(%ebp),%bl POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); 114b2a: 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 ); 114b2d: 50 push %eax 114b2e: 8b 45 08 mov 0x8(%ebp),%eax 114b31: ff 30 pushl (%eax) 114b33: 68 40 d6 12 00 push $0x12d640 114b38: e8 a7 bc ff ff call 1107e4 <_Objects_Get> switch ( location ) { 114b3d: 83 c4 10 add $0x10,%esp 114b40: 8b 55 f4 mov -0xc(%ebp),%edx 114b43: 85 d2 test %edx,%edx 114b45: 74 15 je 114b5c <_POSIX_Semaphore_Wait_support+0x3c> #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 114b47: e8 10 2b 00 00 call 11765c <__errno> 114b4c: c7 00 16 00 00 00 movl $0x16,(%eax) 114b52: b8 ff ff ff ff mov $0xffffffff,%eax } 114b57: 8b 5d fc mov -0x4(%ebp),%ebx 114b5a: c9 leave 114b5b: c3 ret the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { case OBJECTS_LOCAL: _CORE_semaphore_Seize( 114b5c: ff 75 10 pushl 0x10(%ebp) 114b5f: 0f b6 db movzbl %bl,%ebx 114b62: 53 push %ebx 114b63: ff 70 08 pushl 0x8(%eax) 114b66: 83 c0 1c add $0x1c,%eax 114b69: 50 push %eax 114b6a: e8 29 07 00 00 call 115298 <_CORE_semaphore_Seize> &the_semaphore->Semaphore, the_semaphore->Object.id, blocking, timeout ); _Thread_Enable_dispatch(); 114b6f: e8 a4 c7 ff ff call 111318 <_Thread_Enable_dispatch> if ( !_Thread_Executing->Wait.return_code ) 114b74: 83 c4 10 add $0x10,%esp 114b77: a1 d8 d8 12 00 mov 0x12d8d8,%eax 114b7c: 8b 40 34 mov 0x34(%eax),%eax 114b7f: 85 c0 test %eax,%eax 114b81: 75 09 jne 114b8c <_POSIX_Semaphore_Wait_support+0x6c> return 0; 114b83: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 114b85: 8b 5d fc mov -0x4(%ebp),%ebx 114b88: c9 leave 114b89: c3 ret 114b8a: 66 90 xchg %ax,%ax _Thread_Enable_dispatch(); if ( !_Thread_Executing->Wait.return_code ) return 0; rtems_set_errno_and_return_minus_one( 114b8c: e8 cb 2a 00 00 call 11765c <__errno> 114b91: 89 c3 mov %eax,%ebx 114b93: 83 ec 0c sub $0xc,%esp 114b96: a1 d8 d8 12 00 mov 0x12d8d8,%eax 114b9b: ff 70 34 pushl 0x34(%eax) 114b9e: e8 29 26 00 00 call 1171cc <_POSIX_Semaphore_Translate_core_semaphore_return_code> 114ba3: 89 03 mov %eax,(%ebx) 114ba5: 83 c4 10 add $0x10,%esp 114ba8: b8 ff ff ff ff mov $0xffffffff,%eax 114bad: eb a8 jmp 114b57 <_POSIX_Semaphore_Wait_support+0x37> =============================================================================== 001106dc <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch>: #include void _POSIX_Thread_Evaluate_cancellation_and_enable_dispatch( Thread_Control *the_thread ) { 1106dc: 55 push %ebp 1106dd: 89 e5 mov %esp,%ebp 1106df: 83 ec 08 sub $0x8,%esp 1106e2: 8b 55 08 mov 0x8(%ebp),%edx POSIX_API_Control *thread_support; thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ]; 1106e5: 8b 82 ec 00 00 00 mov 0xec(%edx),%eax if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 1106eb: 8b 88 d8 00 00 00 mov 0xd8(%eax),%ecx 1106f1: 85 c9 test %ecx,%ecx 1106f3: 75 09 jne 1106fe <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x22><== NEVER TAKEN 1106f5: 83 b8 dc 00 00 00 01 cmpl $0x1,0xdc(%eax) 1106fc: 74 06 je 110704 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x28> _Thread_Unnest_dispatch(); _POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED ); } else _Thread_Enable_dispatch(); } 1106fe: 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(); 1106ff: e9 38 d6 ff ff jmp 10dd3c <_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 && 110704: 8b 80 e0 00 00 00 mov 0xe0(%eax),%eax 11070a: 85 c0 test %eax,%eax 11070c: 74 f0 je 1106fe <_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; 11070e: a1 70 88 12 00 mov 0x128870,%eax 110713: 48 dec %eax 110714: a3 70 88 12 00 mov %eax,0x128870 thread_support->cancelation_requested ) { _Thread_Unnest_dispatch(); _POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED ); 110719: 83 ec 08 sub $0x8,%esp 11071c: 6a ff push $0xffffffff 11071e: 52 push %edx 11071f: e8 c0 08 00 00 call 110fe4 <_POSIX_Thread_Exit> 110724: 83 c4 10 add $0x10,%esp } else _Thread_Enable_dispatch(); } 110727: c9 leave 110728: c3 ret =============================================================================== 00111a4c <_POSIX_Thread_Translate_sched_param>: int policy, struct sched_param *param, Thread_CPU_budget_algorithms *budget_algorithm, Thread_CPU_budget_algorithm_callout *budget_callout ) { 111a4c: 55 push %ebp 111a4d: 89 e5 mov %esp,%ebp 111a4f: 57 push %edi 111a50: 56 push %esi 111a51: 53 push %ebx 111a52: 83 ec 18 sub $0x18,%esp 111a55: 8b 5d 08 mov 0x8(%ebp),%ebx 111a58: 8b 75 0c mov 0xc(%ebp),%esi 111a5b: 8b 7d 10 mov 0x10(%ebp),%edi if ( !_POSIX_Priority_Is_valid( param->sched_priority ) ) 111a5e: ff 36 pushl (%esi) 111a60: e8 cb ff ff ff call 111a30 <_POSIX_Priority_Is_valid> 111a65: 83 c4 10 add $0x10,%esp 111a68: 84 c0 test %al,%al 111a6a: 74 2a je 111a96 <_POSIX_Thread_Translate_sched_param+0x4a><== NEVER TAKEN return EINVAL; *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; 111a6c: c7 07 00 00 00 00 movl $0x0,(%edi) *budget_callout = NULL; 111a72: 8b 45 14 mov 0x14(%ebp),%eax 111a75: c7 00 00 00 00 00 movl $0x0,(%eax) if ( policy == SCHED_OTHER ) { 111a7b: 85 db test %ebx,%ebx 111a7d: 74 25 je 111aa4 <_POSIX_Thread_Translate_sched_param+0x58> *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; return 0; } if ( policy == SCHED_FIFO ) { 111a7f: 83 fb 01 cmp $0x1,%ebx 111a82: 0f 84 90 00 00 00 je 111b18 <_POSIX_Thread_Translate_sched_param+0xcc> *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; return 0; } if ( policy == SCHED_RR ) { 111a88: 83 fb 02 cmp $0x2,%ebx 111a8b: 0f 84 8f 00 00 00 je 111b20 <_POSIX_Thread_Translate_sched_param+0xd4> *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE; return 0; } if ( policy == SCHED_SPORADIC ) { 111a91: 83 fb 04 cmp $0x4,%ebx 111a94: 74 1e je 111ab4 <_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; 111a96: b8 16 00 00 00 mov $0x16,%eax *budget_callout = _POSIX_Threads_Sporadic_budget_callout; return 0; } return EINVAL; } 111a9b: 8d 65 f4 lea -0xc(%ebp),%esp 111a9e: 5b pop %ebx 111a9f: 5e pop %esi 111aa0: 5f pop %edi 111aa1: c9 leave 111aa2: c3 ret 111aa3: 90 nop *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; *budget_callout = NULL; if ( policy == SCHED_OTHER ) { *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; 111aa4: c7 07 01 00 00 00 movl $0x1,(%edi) return 0; 111aaa: 31 c0 xor %eax,%eax *budget_callout = _POSIX_Threads_Sporadic_budget_callout; return 0; } return EINVAL; } 111aac: 8d 65 f4 lea -0xc(%ebp),%esp 111aaf: 5b pop %ebx 111ab0: 5e pop %esi 111ab1: 5f pop %edi 111ab2: c9 leave 111ab3: 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) && 111ab4: 8b 5e 08 mov 0x8(%esi),%ebx 111ab7: 85 db test %ebx,%ebx 111ab9: 75 07 jne 111ac2 <_POSIX_Thread_Translate_sched_param+0x76> 111abb: 8b 4e 0c mov 0xc(%esi),%ecx 111abe: 85 c9 test %ecx,%ecx 111ac0: 74 d4 je 111a96 <_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) && 111ac2: 8b 56 10 mov 0x10(%esi),%edx 111ac5: 85 d2 test %edx,%edx 111ac7: 75 07 jne 111ad0 <_POSIX_Thread_Translate_sched_param+0x84> 111ac9: 8b 46 14 mov 0x14(%esi),%eax 111acc: 85 c0 test %eax,%eax 111ace: 74 c6 je 111a96 <_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 ) < 111ad0: 83 ec 0c sub $0xc,%esp 111ad3: 8d 46 08 lea 0x8(%esi),%eax 111ad6: 50 push %eax 111ad7: e8 00 da ff ff call 10f4dc <_Timespec_To_ticks> 111adc: 89 c3 mov %eax,%ebx _Timespec_To_ticks( ¶m->sched_ss_init_budget ) ) 111ade: 8d 46 10 lea 0x10(%esi),%eax 111ae1: 89 04 24 mov %eax,(%esp) 111ae4: e8 f3 d9 ff ff call 10f4dc <_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 ) < 111ae9: 83 c4 10 add $0x10,%esp 111aec: 39 c3 cmp %eax,%ebx 111aee: 72 a6 jb 111a96 <_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 ) ) 111af0: 83 ec 0c sub $0xc,%esp 111af3: ff 76 04 pushl 0x4(%esi) 111af6: e8 35 ff ff ff call 111a30 <_POSIX_Priority_Is_valid> 111afb: 83 c4 10 add $0x10,%esp 111afe: 84 c0 test %al,%al 111b00: 74 94 je 111a96 <_POSIX_Thread_Translate_sched_param+0x4a> return EINVAL; *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT; 111b02: c7 07 03 00 00 00 movl $0x3,(%edi) *budget_callout = _POSIX_Threads_Sporadic_budget_callout; 111b08: 8b 45 14 mov 0x14(%ebp),%eax 111b0b: c7 00 14 bd 10 00 movl $0x10bd14,(%eax) return 0; 111b11: 31 c0 xor %eax,%eax 111b13: eb 86 jmp 111a9b <_POSIX_Thread_Translate_sched_param+0x4f> 111b15: 8d 76 00 lea 0x0(%esi),%esi return 0; } if ( policy == SCHED_FIFO ) { *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; return 0; 111b18: 31 c0 xor %eax,%eax 111b1a: e9 7c ff ff ff jmp 111a9b <_POSIX_Thread_Translate_sched_param+0x4f> 111b1f: 90 nop } if ( policy == SCHED_RR ) { *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE; 111b20: c7 07 02 00 00 00 movl $0x2,(%edi) return 0; 111b26: 31 c0 xor %eax,%eax 111b28: e9 6e ff ff ff jmp 111a9b <_POSIX_Thread_Translate_sched_param+0x4f> =============================================================================== 001108e8 <_POSIX_Threads_Create_extension>: bool _POSIX_Threads_Create_extension( Thread_Control *executing __attribute__((unused)), Thread_Control *created ) { 1108e8: 55 push %ebp 1108e9: 89 e5 mov %esp,%ebp 1108eb: 57 push %edi 1108ec: 56 push %esi 1108ed: 53 push %ebx 1108ee: 83 ec 28 sub $0x28,%esp 1108f1: 8b 55 0c mov 0xc(%ebp),%edx POSIX_API_Control *api; POSIX_API_Control *executing_api; api = _Workspace_Allocate( sizeof( POSIX_API_Control ) ); 1108f4: 68 f0 00 00 00 push $0xf0 1108f9: 89 55 e4 mov %edx,-0x1c(%ebp) 1108fc: e8 5f e0 ff ff call 10e960 <_Workspace_Allocate> 110901: 89 c3 mov %eax,%ebx if ( !api ) 110903: 83 c4 10 add $0x10,%esp 110906: 85 c0 test %eax,%eax 110908: 8b 55 e4 mov -0x1c(%ebp),%edx 11090b: 0f 84 2f 01 00 00 je 110a40 <_POSIX_Threads_Create_extension+0x158><== NEVER TAKEN return false; created->API_Extensions[ THREAD_API_POSIX ] = api; 110911: 89 82 ec 00 00 00 mov %eax,0xec(%edx) /* XXX check all fields are touched */ api->Attributes = _POSIX_Threads_Default_attributes; 110917: b9 40 00 00 00 mov $0x40,%ecx 11091c: 31 c0 xor %eax,%eax 11091e: 89 df mov %ebx,%edi 110920: f3 aa rep stos %al,%es:(%edi) 110922: c7 03 01 00 00 00 movl $0x1,(%ebx) 110928: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx) 11092f: c7 43 14 01 00 00 00 movl $0x1,0x14(%ebx) 110936: c7 43 18 02 00 00 00 movl $0x2,0x18(%ebx) 11093d: c7 43 38 01 00 00 00 movl $0x1,0x38(%ebx) 110944: c7 43 3c 01 00 00 00 movl $0x1,0x3c(%ebx) api->detachstate = _POSIX_Threads_Default_attributes.detachstate; 11094b: c7 43 40 01 00 00 00 movl $0x1,0x40(%ebx) api->schedpolicy = _POSIX_Threads_Default_attributes.schedpolicy; 110952: c7 83 84 00 00 00 01 movl $0x1,0x84(%ebx) 110959: 00 00 00 api->schedparam = _POSIX_Threads_Default_attributes.schedparam; 11095c: be 78 13 12 00 mov $0x121378,%esi 110961: 8d bb 88 00 00 00 lea 0x88(%ebx),%edi 110967: b1 07 mov $0x7,%cl 110969: 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); 11096b: 0f b6 05 74 32 12 00 movzbl 0x123274,%eax 110972: 2b 42 14 sub 0x14(%edx),%eax 110975: 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; 11097b: c7 83 e0 00 00 00 00 movl $0x0,0xe0(%ebx) 110982: 00 00 00 api->cancelability_state = PTHREAD_CANCEL_ENABLE; 110985: c7 83 d8 00 00 00 00 movl $0x0,0xd8(%ebx) 11098c: 00 00 00 api->cancelability_type = PTHREAD_CANCEL_DEFERRED; 11098f: c7 83 dc 00 00 00 00 movl $0x0,0xdc(%ebx) 110996: 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 ); 110999: 8d 83 e8 00 00 00 lea 0xe8(%ebx),%eax 11099f: 89 83 e4 00 00 00 mov %eax,0xe4(%ebx) head->next = tail; head->previous = NULL; 1109a5: c7 83 e8 00 00 00 00 movl $0x0,0xe8(%ebx) 1109ac: 00 00 00 */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); 1109af: 8d 83 e4 00 00 00 lea 0xe4(%ebx),%eax 1109b5: 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; 1109bb: c7 83 d4 00 00 00 00 movl $0x0,0xd4(%ebx) 1109c2: 00 00 00 1109c5: 0f b6 42 0b movzbl 0xb(%edx),%eax 1109c9: 83 e0 07 and $0x7,%eax if ( _Objects_Get_API( created->Object.id ) == OBJECTS_POSIX_API 1109cc: 83 f8 03 cmp $0x3,%eax 1109cf: 74 53 je 110a24 <_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; 1109d1: c7 83 d0 00 00 00 ff movl $0xffffffff,0xd0(%ebx) 1109d8: ff ff ff } _Thread_queue_Initialize( 1109db: 6a 00 push $0x0 1109dd: 68 00 10 00 00 push $0x1000 1109e2: 6a 00 push $0x0 1109e4: 8d 43 44 lea 0x44(%ebx),%eax 1109e7: 50 push %eax 1109e8: 89 55 e4 mov %edx,-0x1c(%ebp) 1109eb: e8 48 d6 ff ff call 10e038 <_Thread_queue_Initialize> THREAD_QUEUE_DISCIPLINE_FIFO, STATES_WAITING_FOR_JOIN_AT_EXIT, 0 ); _Watchdog_Initialize( 1109f0: 8b 55 e4 mov -0x1c(%ebp),%edx 1109f3: 8b 42 08 mov 0x8(%edx),%eax Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 1109f6: c7 83 b0 00 00 00 00 movl $0x0,0xb0(%ebx) 1109fd: 00 00 00 the_watchdog->routine = routine; 110a00: c7 83 c4 00 00 00 4c movl $0x110a4c,0xc4(%ebx) 110a07: 0a 11 00 the_watchdog->id = id; 110a0a: 89 83 c8 00 00 00 mov %eax,0xc8(%ebx) the_watchdog->user_data = user_data; 110a10: 89 93 cc 00 00 00 mov %edx,0xcc(%ebx) _POSIX_Threads_Sporadic_budget_TSR, created->Object.id, created ); return true; 110a16: 83 c4 10 add $0x10,%esp 110a19: b0 01 mov $0x1,%al } 110a1b: 8d 65 f4 lea -0xc(%ebp),%esp 110a1e: 5b pop %ebx 110a1f: 5e pop %esi 110a20: 5f pop %edi 110a21: c9 leave 110a22: c3 ret 110a23: 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 ]; 110a24: a1 58 7b 12 00 mov 0x127b58,%eax api->signals_blocked = executing_api->signals_blocked; 110a29: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax 110a2f: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax 110a35: 89 83 d0 00 00 00 mov %eax,0xd0(%ebx) 110a3b: eb 9e jmp 1109db <_POSIX_Threads_Create_extension+0xf3> 110a3d: 8d 76 00 lea 0x0(%esi),%esi POSIX_API_Control *executing_api; api = _Workspace_Allocate( sizeof( POSIX_API_Control ) ); if ( !api ) return false; 110a40: 31 c0 xor %eax,%eax created->Object.id, created ); return true; } 110a42: 8d 65 f4 lea -0xc(%ebp),%esp 110a45: 5b pop %ebx 110a46: 5e pop %esi 110a47: 5f pop %edi 110a48: c9 leave 110a49: c3 ret =============================================================================== 00110860 <_POSIX_Threads_Delete_extension>: */ void _POSIX_Threads_Delete_extension( Thread_Control *executing __attribute__((unused)), Thread_Control *deleted ) { 110860: 55 push %ebp 110861: 89 e5 mov %esp,%ebp 110863: 57 push %edi 110864: 56 push %esi 110865: 53 push %ebx 110866: 83 ec 28 sub $0x28,%esp 110869: 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 ]; 11086c: 8b 87 ec 00 00 00 mov 0xec(%edi),%eax 110872: 89 45 e4 mov %eax,-0x1c(%ebp) /* * Run the POSIX cancellation handlers */ _POSIX_Threads_cancel_run( deleted ); 110875: 57 push %edi 110876: e8 d1 22 00 00 call 112b4c <_POSIX_Threads_cancel_run> /* * Run all the key destructors */ _POSIX_Keys_Run_destructors( deleted ); 11087b: 89 3c 24 mov %edi,(%esp) 11087e: e8 31 23 00 00 call 112bb4 <_POSIX_Keys_Run_destructors> /* * Wakeup all the tasks which joined with this one */ value_ptr = (void **) deleted->Wait.return_argument; 110883: 8b 77 28 mov 0x28(%edi),%esi while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) ) 110886: 83 c4 10 add $0x10,%esp 110889: 8b 45 e4 mov -0x1c(%ebp),%eax 11088c: 8d 58 44 lea 0x44(%eax),%ebx 11088f: eb 08 jmp 110899 <_POSIX_Threads_Delete_extension+0x39> 110891: 8d 76 00 lea 0x0(%esi),%esi *(void **)the_thread->Wait.return_argument = value_ptr; 110894: 8b 40 28 mov 0x28(%eax),%eax 110897: 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 )) ) 110899: 83 ec 0c sub $0xc,%esp 11089c: 53 push %ebx 11089d: e8 06 d4 ff ff call 10dca8 <_Thread_queue_Dequeue> 1108a2: 83 c4 10 add $0x10,%esp 1108a5: 85 c0 test %eax,%eax 1108a7: 75 eb jne 110894 <_POSIX_Threads_Delete_extension+0x34> *(void **)the_thread->Wait.return_argument = value_ptr; if ( api->schedpolicy == SCHED_SPORADIC ) 1108a9: 8b 45 e4 mov -0x1c(%ebp),%eax 1108ac: 83 b8 84 00 00 00 04 cmpl $0x4,0x84(%eax) 1108b3: 74 1f je 1108d4 <_POSIX_Threads_Delete_extension+0x74> (void) _Watchdog_Remove( &api->Sporadic_timer ); deleted->API_Extensions[ THREAD_API_POSIX ] = NULL; 1108b5: c7 87 ec 00 00 00 00 movl $0x0,0xec(%edi) 1108bc: 00 00 00 (void) _Workspace_Free( api ); 1108bf: 8b 45 e4 mov -0x1c(%ebp),%eax 1108c2: 89 45 08 mov %eax,0x8(%ebp) } 1108c5: 8d 65 f4 lea -0xc(%ebp),%esp 1108c8: 5b pop %ebx 1108c9: 5e pop %esi 1108ca: 5f pop %edi 1108cb: c9 leave if ( api->schedpolicy == SCHED_SPORADIC ) (void) _Watchdog_Remove( &api->Sporadic_timer ); deleted->API_Extensions[ THREAD_API_POSIX ] = NULL; (void) _Workspace_Free( api ); 1108cc: e9 ab e0 ff ff jmp 10e97c <_Workspace_Free> 1108d1: 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 ); 1108d4: 83 ec 0c sub $0xc,%esp 1108d7: 05 a8 00 00 00 add $0xa8,%eax 1108dc: 50 push %eax 1108dd: e8 56 df ff ff call 10e838 <_Watchdog_Remove> 1108e2: 83 c4 10 add $0x10,%esp 1108e5: eb ce jmp 1108b5 <_POSIX_Threads_Delete_extension+0x55> =============================================================================== 00110824 <_POSIX_Threads_Initialize_user_threads>: * * This routine creates and starts all configured user * initialzation threads. */ void _POSIX_Threads_Initialize_user_threads( void ) { 110824: 55 push %ebp 110825: 89 e5 mov %esp,%ebp 110827: 83 ec 08 sub $0x8,%esp if ( _POSIX_Threads_Initialize_user_threads_p ) 11082a: a1 18 58 12 00 mov 0x125818,%eax 11082f: 85 c0 test %eax,%eax 110831: 74 05 je 110838 <_POSIX_Threads_Initialize_user_threads+0x14> (*_POSIX_Threads_Initialize_user_threads_p)(); } 110833: c9 leave * initialzation threads. */ void _POSIX_Threads_Initialize_user_threads( void ) { if ( _POSIX_Threads_Initialize_user_threads_p ) (*_POSIX_Threads_Initialize_user_threads_p)(); 110834: ff e0 jmp *%eax 110836: 66 90 xchg %ax,%ax } 110838: c9 leave 110839: 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 74 45 12 00 mov 0x124574,%edi maximum = Configuration_POSIX_API.number_of_initialization_threads; 10ba03: a1 70 45 12 00 mov 0x124570,%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 0f 61 00 00 call 111b30 (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 31 61 00 00 call 111b5c (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 59 61 00 00 call 111b90 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 ce 1e 00 00 call 10d934 <_Internal_error_Occurred> =============================================================================== 00110a4c <_POSIX_Threads_Sporadic_budget_TSR>: */ void _POSIX_Threads_Sporadic_budget_TSR( Objects_Id id __attribute__((unused)), void *argument ) { 110a4c: 55 push %ebp 110a4d: 89 e5 mov %esp,%ebp 110a4f: 56 push %esi 110a50: 53 push %ebx 110a51: 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 ]; 110a54: 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 ); 110a5a: 83 ec 0c sub $0xc,%esp 110a5d: 8d 83 98 00 00 00 lea 0x98(%ebx),%eax 110a63: 50 push %eax 110a64: e8 53 0f 00 00 call 1119bc <_Timespec_To_ticks> the_thread->cpu_time_budget = ticks; 110a69: 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); 110a6c: 0f b6 05 74 32 12 00 movzbl 0x123274,%eax 110a73: 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; 110a79: 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 ) { 110a7c: 83 c4 10 add $0x10,%esp 110a7f: 8b 4e 1c mov 0x1c(%esi),%ecx 110a82: 85 c9 test %ecx,%ecx 110a84: 75 05 jne 110a8b <_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 ) { 110a86: 39 46 14 cmp %eax,0x14(%esi) 110a89: 77 35 ja 110ac0 <_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 ); 110a8b: 83 ec 0c sub $0xc,%esp 110a8e: 8d 83 90 00 00 00 lea 0x90(%ebx),%eax 110a94: 50 push %eax 110a95: e8 22 0f 00 00 call 1119bc <_Timespec_To_ticks> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 110a9a: 89 83 b4 00 00 00 mov %eax,0xb4(%ebx) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 110aa0: 83 c4 10 add $0x10,%esp _Watchdog_Insert_ticks( &api->Sporadic_timer, ticks ); 110aa3: 81 c3 a8 00 00 00 add $0xa8,%ebx 110aa9: 89 5d 0c mov %ebx,0xc(%ebp) 110aac: c7 45 08 7c 76 12 00 movl $0x12767c,0x8(%ebp) } 110ab3: 8d 65 f8 lea -0x8(%ebp),%esp 110ab6: 5b pop %ebx 110ab7: 5e pop %esi 110ab8: c9 leave 110ab9: e9 3a dc ff ff jmp 10e6f8 <_Watchdog_Insert> 110abe: 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 ); 110ac0: 52 push %edx 110ac1: 6a 01 push $0x1 110ac3: 50 push %eax 110ac4: 56 push %esi 110ac5: e8 76 c9 ff ff call 10d440 <_Thread_Change_priority> 110aca: 83 c4 10 add $0x10,%esp 110acd: eb bc jmp 110a8b <_POSIX_Threads_Sporadic_budget_TSR+0x3f> =============================================================================== 00110ad0 <_POSIX_Threads_Sporadic_budget_callout>: * _POSIX_Threads_Sporadic_budget_callout */ void _POSIX_Threads_Sporadic_budget_callout( Thread_Control *the_thread ) { 110ad0: 55 push %ebp 110ad1: 89 e5 mov %esp,%ebp 110ad3: 83 ec 08 sub $0x8,%esp 110ad6: 8b 45 08 mov 0x8(%ebp),%eax POSIX_API_Control *api; uint32_t new_priority; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 110ad9: 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 */ 110adf: c7 40 78 ff ff ff ff movl $0xffffffff,0x78(%eax) 110ae6: 0f b6 15 74 32 12 00 movzbl 0x123274,%edx 110aed: 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; 110af3: 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 ) { 110af6: 8b 48 1c mov 0x1c(%eax),%ecx 110af9: 85 c9 test %ecx,%ecx 110afb: 75 05 jne 110b02 <_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 ) { 110afd: 39 50 14 cmp %edx,0x14(%eax) 110b00: 72 02 jb 110b04 <_POSIX_Threads_Sporadic_budget_callout+0x34><== ALWAYS TAKEN #if 0 printk( "lower priority\n" ); #endif } } } 110b02: c9 leave <== NOT EXECUTED 110b03: 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 ); 110b04: 51 push %ecx 110b05: 6a 01 push $0x1 110b07: 52 push %edx 110b08: 50 push %eax 110b09: e8 32 c9 ff ff call 10d440 <_Thread_Change_priority> 110b0e: 83 c4 10 add $0x10,%esp #if 0 printk( "lower priority\n" ); #endif } } } 110b11: c9 leave 110b12: c3 ret =============================================================================== 00112b4c <_POSIX_Threads_cancel_run>: #include void _POSIX_Threads_cancel_run( Thread_Control *the_thread ) { 112b4c: 55 push %ebp 112b4d: 89 e5 mov %esp,%ebp 112b4f: 57 push %edi 112b50: 56 push %esi 112b51: 53 push %ebx 112b52: 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 ]; 112b55: 8b 45 08 mov 0x8(%ebp),%eax 112b58: 8b 98 ec 00 00 00 mov 0xec(%eax),%ebx handler_stack = &thread_support->Cancellation_Handlers; thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE; 112b5e: c7 83 d8 00 00 00 01 movl $0x1,0xd8(%ebx) 112b65: 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 ); 112b68: 8d b3 e8 00 00 00 lea 0xe8(%ebx),%esi while ( !_Chain_Is_empty( handler_stack ) ) { 112b6e: 39 b3 e4 00 00 00 cmp %esi,0xe4(%ebx) 112b74: 74 33 je 112ba9 <_POSIX_Threads_cancel_run+0x5d> 112b76: 66 90 xchg %ax,%ax _ISR_Disable( level ); 112b78: 9c pushf 112b79: fa cli 112b7a: 59 pop %ecx handler = (POSIX_Cancel_Handler_control *) 112b7b: 8b bb ec 00 00 00 mov 0xec(%ebx),%edi ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 112b81: 8b 17 mov (%edi),%edx previous = the_node->previous; 112b83: 8b 47 04 mov 0x4(%edi),%eax next->previous = previous; 112b86: 89 42 04 mov %eax,0x4(%edx) previous->next = next; 112b89: 89 10 mov %edx,(%eax) _Chain_Tail( handler_stack )->previous; _Chain_Extract_unprotected( &handler->Node ); _ISR_Enable( level ); 112b8b: 51 push %ecx 112b8c: 9d popf (*handler->routine)( handler->arg ); 112b8d: 83 ec 0c sub $0xc,%esp 112b90: ff 77 0c pushl 0xc(%edi) 112b93: ff 57 08 call *0x8(%edi) _Workspace_Free( handler ); 112b96: 89 3c 24 mov %edi,(%esp) 112b99: e8 de bd ff ff call 10e97c <_Workspace_Free> handler_stack = &thread_support->Cancellation_Handlers; thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE; while ( !_Chain_Is_empty( handler_stack ) ) { 112b9e: 83 c4 10 add $0x10,%esp 112ba1: 39 b3 e4 00 00 00 cmp %esi,0xe4(%ebx) 112ba7: 75 cf jne 112b78 <_POSIX_Threads_cancel_run+0x2c><== NEVER TAKEN (*handler->routine)( handler->arg ); _Workspace_Free( handler ); } } 112ba9: 8d 65 f4 lea -0xc(%ebp),%esp 112bac: 5b pop %ebx 112bad: 5e pop %esi 112bae: 5f pop %edi 112baf: c9 leave 112bb0: c3 ret =============================================================================== 0011182c <_POSIX_Timer_Insert_helper>: Watchdog_Interval ticks, Objects_Id id, Watchdog_Service_routine_entry TSR, void *arg ) { 11182c: 55 push %ebp 11182d: 89 e5 mov %esp,%ebp 11182f: 56 push %esi 111830: 53 push %ebx 111831: 8b 5d 08 mov 0x8(%ebp),%ebx ISR_Level level; (void) _Watchdog_Remove( timer ); 111834: 83 ec 0c sub $0xc,%esp 111837: 53 push %ebx 111838: e8 0b db ff ff call 10f348 <_Watchdog_Remove> _ISR_Disable( level ); 11183d: 9c pushf 11183e: fa cli 11183f: 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 ) { 111840: 83 c4 10 add $0x10,%esp 111843: 8b 43 08 mov 0x8(%ebx),%eax 111846: 85 c0 test %eax,%eax 111848: 74 0e je 111858 <_POSIX_Timer_Insert_helper+0x2c> _ISR_Enable( level ); 11184a: 56 push %esi 11184b: 9d popf return false; 11184c: 31 c0 xor %eax,%eax */ _Watchdog_Initialize( timer, TSR, id, arg ); _Watchdog_Insert_ticks( timer, ticks ); _ISR_Enable( level ); return true; } 11184e: 8d 65 f8 lea -0x8(%ebp),%esp 111851: 5b pop %ebx 111852: 5e pop %esi 111853: c9 leave 111854: c3 ret 111855: 8d 76 00 lea 0x0(%esi),%esi Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 111858: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) the_watchdog->routine = routine; 11185f: 8b 45 14 mov 0x14(%ebp),%eax 111862: 89 43 1c mov %eax,0x1c(%ebx) the_watchdog->id = id; 111865: 8b 45 10 mov 0x10(%ebp),%eax 111868: 89 43 20 mov %eax,0x20(%ebx) the_watchdog->user_data = user_data; 11186b: 8b 45 18 mov 0x18(%ebp),%eax 11186e: 89 43 24 mov %eax,0x24(%ebx) Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 111871: 8b 45 0c mov 0xc(%ebp),%eax 111874: 89 43 0c mov %eax,0xc(%ebx) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 111877: 83 ec 08 sub $0x8,%esp 11187a: 53 push %ebx 11187b: 68 9c 99 12 00 push $0x12999c 111880: e8 83 d9 ff ff call 10f208 <_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 ); 111885: 56 push %esi 111886: 9d popf return true; 111887: 83 c4 10 add $0x10,%esp 11188a: b0 01 mov $0x1,%al } 11188c: 8d 65 f8 lea -0x8(%ebp),%esp 11188f: 5b pop %ebx 111890: 5e pop %esi 111891: c9 leave 111892: 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 8b 5b 00 00 call 1113bc } /* 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 d4 5f 00 00 call 11182c <_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 95 16 00 00 call 10cf00 <_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> =============================================================================== 00112c38 <_POSIX_signals_Check_signal>: bool _POSIX_signals_Check_signal( POSIX_API_Control *api, int signo, bool is_global ) { 112c38: 55 push %ebp 112c39: 89 e5 mov %esp,%ebp 112c3b: 57 push %edi 112c3c: 56 push %esi 112c3d: 53 push %ebx 112c3e: 83 ec 78 sub $0x78,%esp 112c41: 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, 112c44: 6a 01 push $0x1 112c46: 0f b6 45 10 movzbl 0x10(%ebp),%eax 112c4a: 50 push %eax 112c4b: 8d 55 dc lea -0x24(%ebp),%edx 112c4e: 52 push %edx 112c4f: 53 push %ebx 112c50: ff 75 08 pushl 0x8(%ebp) 112c53: 89 55 9c mov %edx,-0x64(%ebp) 112c56: e8 b5 00 00 00 call 112d10 <_POSIX_signals_Clear_signals> 112c5b: 83 c4 20 add $0x20,%esp 112c5e: 84 c0 test %al,%al 112c60: 8b 55 9c mov -0x64(%ebp),%edx 112c63: 0f 84 9b 00 00 00 je 112d04 <_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 ) 112c69: 8d 04 5b lea (%ebx,%ebx,2),%eax 112c6c: c1 e0 02 shl $0x2,%eax 112c6f: 8b 88 c8 7b 12 00 mov 0x127bc8(%eax),%ecx 112c75: 89 4d a4 mov %ecx,-0x5c(%ebp) 112c78: 49 dec %ecx 112c79: 0f 84 85 00 00 00 je 112d04 <_POSIX_signals_Check_signal+0xcc><== NEVER TAKEN return false; /* * Block the signals requested in sa_mask */ saved_signals_blocked = api->signals_blocked; 112c7f: 8b 75 08 mov 0x8(%ebp),%esi 112c82: 8b b6 d0 00 00 00 mov 0xd0(%esi),%esi 112c88: 89 75 a0 mov %esi,-0x60(%ebp) api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask; 112c8b: 8b 88 c4 7b 12 00 mov 0x127bc4(%eax),%ecx 112c91: 09 f1 or %esi,%ecx 112c93: 8b 75 08 mov 0x8(%ebp),%esi 112c96: 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, 112c9c: 8d 75 b4 lea -0x4c(%ebp),%esi 112c9f: 89 75 94 mov %esi,-0x6c(%ebp) 112ca2: 8b 35 58 7b 12 00 mov 0x127b58,%esi 112ca8: 83 c6 20 add $0x20,%esi 112cab: b9 0a 00 00 00 mov $0xa,%ecx 112cb0: 8b 7d 94 mov -0x6c(%ebp),%edi 112cb3: 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 ) { 112cb5: 83 b8 c0 7b 12 00 02 cmpl $0x2,0x127bc0(%eax) 112cbc: 74 36 je 112cf4 <_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 ); 112cbe: 83 ec 0c sub $0xc,%esp 112cc1: 53 push %ebx 112cc2: ff 55 a4 call *-0x5c(%ebp) break; 112cc5: 83 c4 10 add $0x10,%esp } /* * Restore the blocking information */ memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information, 112cc8: 8b 3d 58 7b 12 00 mov 0x127b58,%edi 112cce: 83 c7 20 add $0x20,%edi 112cd1: b9 0a 00 00 00 mov $0xa,%ecx 112cd6: 8b 75 94 mov -0x6c(%ebp),%esi 112cd9: 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; 112cdb: 8b 55 a0 mov -0x60(%ebp),%edx 112cde: 8b 45 08 mov 0x8(%ebp),%eax 112ce1: 89 90 d0 00 00 00 mov %edx,0xd0(%eax) return true; 112ce7: b0 01 mov $0x1,%al } 112ce9: 8d 65 f4 lea -0xc(%ebp),%esp 112cec: 5b pop %ebx 112ced: 5e pop %esi 112cee: 5f pop %edi 112cef: c9 leave 112cf0: c3 ret 112cf1: 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)( 112cf4: 50 push %eax 112cf5: 6a 00 push $0x0 112cf7: 52 push %edx 112cf8: 53 push %ebx 112cf9: ff 55 a4 call *-0x5c(%ebp) signo, &siginfo_struct, NULL /* context is undefined per 1003.1b-1993, p. 66 */ ); break; 112cfc: 83 c4 10 add $0x10,%esp 112cff: eb c7 jmp 112cc8 <_POSIX_signals_Check_signal+0x90> 112d01: 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; 112d04: 31 c0 xor %eax,%eax * Restore the previous set of blocked signals */ api->signals_blocked = saved_signals_blocked; return true; } 112d06: 8d 65 f4 lea -0xc(%ebp),%esp 112d09: 5b pop %ebx 112d0a: 5e pop %esi 112d0b: 5f pop %edi 112d0c: c9 leave 112d0d: c3 ret =============================================================================== 001132c0 <_POSIX_signals_Clear_process_signals>: */ void _POSIX_signals_Clear_process_signals( int signo ) { 1132c0: 55 push %ebp 1132c1: 89 e5 mov %esp,%ebp 1132c3: 53 push %ebx 1132c4: 8b 4d 08 mov 0x8(%ebp),%ecx clear_signal = true; mask = signo_to_mask( signo ); ISR_Level level; _ISR_Disable( level ); 1132c7: 9c pushf 1132c8: fa cli 1132c9: 5a pop %edx if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) { 1132ca: 8d 04 49 lea (%ecx,%ecx,2),%eax 1132cd: c1 e0 02 shl $0x2,%eax 1132d0: 83 b8 c0 7b 12 00 02 cmpl $0x2,0x127bc0(%eax) 1132d7: 74 13 je 1132ec <_POSIX_signals_Clear_process_signals+0x2c> 1132d9: 49 dec %ecx 1132da: 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; 1132df: d3 c0 rol %cl,%eax 1132e1: 21 05 c8 7d 12 00 and %eax,0x127dc8 } _ISR_Enable( level ); 1132e7: 52 push %edx 1132e8: 9d popf } 1132e9: 5b pop %ebx 1132ea: c9 leave 1132eb: 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 ); 1132ec: 8d 98 e4 7d 12 00 lea 0x127de4(%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 ] ) ) 1132f2: 39 98 e0 7d 12 00 cmp %ebx,0x127de0(%eax) 1132f8: 75 ed jne 1132e7 <_POSIX_signals_Clear_process_signals+0x27><== NEVER TAKEN 1132fa: eb dd jmp 1132d9 <_POSIX_signals_Clear_process_signals+0x19> =============================================================================== 00112d10 <_POSIX_signals_Clear_signals>: int signo, siginfo_t *info, bool is_global, bool check_blocked ) { 112d10: 55 push %ebp 112d11: 89 e5 mov %esp,%ebp 112d13: 57 push %edi 112d14: 56 push %esi 112d15: 53 push %ebx 112d16: 83 ec 1c sub $0x1c,%esp 112d19: 8b 5d 0c mov 0xc(%ebp),%ebx 112d1c: 0f b6 7d 14 movzbl 0x14(%ebp),%edi static inline sigset_t signo_to_mask( uint32_t sig ) { return 1u << (sig - 1); 112d20: 8d 4b ff lea -0x1(%ebx),%ecx 112d23: b8 01 00 00 00 mov $0x1,%eax 112d28: 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 ) 112d2a: 80 7d 18 00 cmpb $0x0,0x18(%ebp) 112d2e: 74 40 je 112d70 <_POSIX_signals_Clear_signals+0x60> signals_blocked = ~api->signals_blocked; 112d30: 8b 55 08 mov 0x8(%ebp),%edx 112d33: 8b 8a d0 00 00 00 mov 0xd0(%edx),%ecx 112d39: 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 ); 112d3b: 9c pushf 112d3c: fa cli 112d3d: 8f 45 e4 popl -0x1c(%ebp) if ( is_global ) { 112d40: 89 fa mov %edi,%edx 112d42: 84 d2 test %dl,%dl 112d44: 74 32 je 112d78 <_POSIX_signals_Clear_signals+0x68> if ( mask & (_POSIX_signals_Pending & signals_blocked) ) { 112d46: 23 05 c8 7d 12 00 and 0x127dc8,%eax 112d4c: 85 c8 test %ecx,%eax 112d4e: 74 54 je 112da4 <_POSIX_signals_Clear_signals+0x94> if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) { 112d50: 8d 14 5b lea (%ebx,%ebx,2),%edx 112d53: c1 e2 02 shl $0x2,%edx 112d56: 83 ba c0 7b 12 00 02 cmpl $0x2,0x127bc0(%edx) 112d5d: 74 49 je 112da8 <_POSIX_signals_Clear_signals+0x98> &psiginfo->Node ); } else do_callout = false; } _POSIX_signals_Clear_process_signals( signo ); 112d5f: 83 ec 0c sub $0xc,%esp 112d62: 53 push %ebx 112d63: e8 58 05 00 00 call 1132c0 <_POSIX_signals_Clear_process_signals> 112d68: 83 c4 10 add $0x10,%esp do_callout = true; 112d6b: b0 01 mov $0x1,%al 112d6d: eb 26 jmp 112d95 <_POSIX_signals_Clear_signals+0x85> 112d6f: 90 nop */ if ( check_blocked ) signals_blocked = ~api->signals_blocked; else signals_blocked = SIGNAL_ALL_MASK; 112d70: b9 ff ff ff ff mov $0xffffffff,%ecx 112d75: eb c4 jmp 112d3b <_POSIX_signals_Clear_signals+0x2b> 112d77: 90 nop } _POSIX_signals_Clear_process_signals( signo ); do_callout = true; } } else { if ( mask & (api->signals_pending & signals_blocked) ) { 112d78: 8b 55 08 mov 0x8(%ebp),%edx 112d7b: 8b 9a d4 00 00 00 mov 0xd4(%edx),%ebx 112d81: 89 c6 mov %eax,%esi 112d83: 21 de and %ebx,%esi 112d85: 85 ce test %ecx,%esi 112d87: 74 1b je 112da4 <_POSIX_signals_Clear_signals+0x94> api->signals_pending &= ~mask; 112d89: f7 d0 not %eax 112d8b: 21 d8 and %ebx,%eax 112d8d: 89 82 d4 00 00 00 mov %eax,0xd4(%edx) do_callout = true; 112d93: b0 01 mov $0x1,%al } } _ISR_Enable( level ); 112d95: ff 75 e4 pushl -0x1c(%ebp) 112d98: 9d popf return do_callout; } 112d99: 8d 65 f4 lea -0xc(%ebp),%esp 112d9c: 5b pop %ebx 112d9d: 5e pop %esi 112d9e: 5f pop %edi 112d9f: c9 leave 112da0: c3 ret 112da1: 8d 76 00 lea 0x0(%esi),%esi bool do_callout; POSIX_signals_Siginfo_node *psiginfo; mask = signo_to_mask( signo ); do_callout = false; 112da4: 31 c0 xor %eax,%eax 112da6: eb ed jmp 112d95 <_POSIX_signals_Clear_signals+0x85> do_callout = true; } } _ISR_Enable( level ); return do_callout; } 112da8: 8d 8a e0 7d 12 00 lea 0x127de0(%edx),%ecx 112dae: 8b 82 e0 7d 12 00 mov 0x127de0(%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 ); 112db4: 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)) 112db7: 39 f0 cmp %esi,%eax 112db9: 74 45 je 112e00 <_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; 112dbb: 8b 30 mov (%eax),%esi head->next = new_first; 112dbd: 89 b2 e0 7d 12 00 mov %esi,0x127de0(%edx) */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_first_unprotected( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); 112dc3: 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 ); 112dc6: 83 ec 0c sub $0xc,%esp 112dc9: 53 push %ebx 112dca: 89 45 e0 mov %eax,-0x20(%ebp) 112dcd: e8 ee 04 00 00 call 1132c0 <_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; 112dd2: 8b 45 e0 mov -0x20(%ebp),%eax 112dd5: 8d 70 08 lea 0x8(%eax),%esi 112dd8: b9 03 00 00 00 mov $0x3,%ecx 112ddd: 8b 7d 10 mov 0x10(%ebp),%edi 112de0: 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; 112de2: 8b 15 48 7d 12 00 mov 0x127d48,%edx the_node->next = tail; 112de8: c7 00 44 7d 12 00 movl $0x127d44,(%eax) tail->previous = the_node; 112dee: a3 48 7d 12 00 mov %eax,0x127d48 old_last->next = the_node; 112df3: 89 02 mov %eax,(%edx) the_node->previous = old_last; 112df5: 89 50 04 mov %edx,0x4(%eax) 112df8: 83 c4 10 add $0x10,%esp 112dfb: e9 5f ff ff ff jmp 112d5f <_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 ); 112e00: 83 ec 0c sub $0xc,%esp 112e03: 53 push %ebx 112e04: e8 b7 04 00 00 call 1132c0 <_POSIX_signals_Clear_process_signals> 112e09: 83 c4 10 add $0x10,%esp 112e0c: e9 4e ff ff ff jmp 112d5f <_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 =============================================================================== 00124468 <_POSIX_signals_Unblock_thread>: bool _POSIX_signals_Unblock_thread( Thread_Control *the_thread, int signo, siginfo_t *info ) { 124468: 55 push %ebp 124469: 89 e5 mov %esp,%ebp 12446b: 57 push %edi 12446c: 56 push %esi 12446d: 53 push %ebx 12446e: 83 ec 0c sub $0xc,%esp 124471: 8b 5d 08 mov 0x8(%ebp),%ebx 124474: 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 ]; 124477: 8b b3 ec 00 00 00 mov 0xec(%ebx),%esi 12447d: 8d 4a ff lea -0x1(%edx),%ecx 124480: b8 01 00 00 00 mov $0x1,%eax 124485: d3 e0 shl %cl,%eax /* * Is the thread is specifically waiting for a signal? */ if ( _States_Is_interruptible_signal( the_thread->current_state ) ) { 124487: 8b 4b 10 mov 0x10(%ebx),%ecx 12448a: 89 cf mov %ecx,%edi 12448c: 81 e7 00 80 00 10 and $0x10008000,%edi 124492: 81 ff 00 80 00 10 cmp $0x10008000,%edi 124498: 74 72 je 12450c <_POSIX_signals_Unblock_thread+0xa4> } /* * Thread is not waiting due to a sigwait. */ if ( ~api->signals_blocked & mask ) { 12449a: 8b 96 d0 00 00 00 mov 0xd0(%esi),%edx 1244a0: f7 d2 not %edx 1244a2: 85 d0 test %edx,%eax 1244a4: 74 5a je 124500 <_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 ) ) { 1244a6: f7 c1 00 00 00 10 test $0x10000000,%ecx 1244ac: 74 3a je 1244e8 <_POSIX_signals_Unblock_thread+0x80> the_thread->Wait.return_code = EINTR; 1244ae: 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) ) 1244b5: f7 c1 e0 be 03 00 test $0x3bee0,%ecx 1244bb: 0f 85 93 00 00 00 jne 124554 <_POSIX_signals_Unblock_thread+0xec> _Thread_queue_Extract_with_proxy( the_thread ); else if ( _States_Is_delaying(the_thread->current_state) ) { 1244c1: 83 e1 08 and $0x8,%ecx 1244c4: 74 3a je 124500 <_POSIX_signals_Unblock_thread+0x98><== NEVER TAKEN (void) _Watchdog_Remove( &the_thread->Timer ); 1244c6: 83 ec 0c sub $0xc,%esp 1244c9: 8d 43 48 lea 0x48(%ebx),%eax 1244cc: 50 push %eax 1244cd: e8 8e f4 fe ff call 113960 <_Watchdog_Remove> RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 1244d2: 5a pop %edx 1244d3: 59 pop %ecx 1244d4: 68 f8 ff 03 10 push $0x1003fff8 1244d9: 53 push %ebx 1244da: e8 bd e1 fe ff call 11269c <_Thread_Clear_state> 1244df: 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; 1244e2: 31 c0 xor %eax,%eax 1244e4: eb 1c jmp 124502 <_POSIX_signals_Unblock_thread+0x9a> 1244e6: 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 ) { 1244e8: 85 c9 test %ecx,%ecx 1244ea: 75 14 jne 124500 <_POSIX_signals_Unblock_thread+0x98><== NEVER TAKEN if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 1244ec: a1 b4 e8 12 00 mov 0x12e8b4,%eax 1244f1: 85 c0 test %eax,%eax 1244f3: 74 0b je 124500 <_POSIX_signals_Unblock_thread+0x98> 1244f5: 3b 1d b8 e8 12 00 cmp 0x12e8b8,%ebx 1244fb: 74 7b je 124578 <_POSIX_signals_Unblock_thread+0x110><== ALWAYS TAKEN 1244fd: 8d 76 00 lea 0x0(%esi),%esi _Thread_Dispatch_necessary = true; } } return false; 124500: 31 c0 xor %eax,%eax } 124502: 8d 65 f4 lea -0xc(%ebp),%esp 124505: 5b pop %ebx 124506: 5e pop %esi 124507: 5f pop %edi 124508: c9 leave 124509: c3 ret 12450a: 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) ) { 12450c: 85 43 30 test %eax,0x30(%ebx) 12450f: 74 33 je 124544 <_POSIX_signals_Unblock_thread+0xdc> the_thread->Wait.return_code = EINTR; 124511: c7 43 34 04 00 00 00 movl $0x4,0x34(%ebx) the_info = (siginfo_t *) the_thread->Wait.return_argument; 124518: 8b 43 28 mov 0x28(%ebx),%eax if ( !info ) { 12451b: 8b 75 10 mov 0x10(%ebp),%esi 12451e: 85 f6 test %esi,%esi 124520: 74 42 je 124564 <_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; 124522: b9 03 00 00 00 mov $0x3,%ecx 124527: 89 c7 mov %eax,%edi 124529: 8b 75 10 mov 0x10(%ebp),%esi 12452c: f3 a5 rep movsl %ds:(%esi),%es:(%edi) } _Thread_queue_Extract_with_proxy( the_thread ); 12452e: 83 ec 0c sub $0xc,%esp 124531: 53 push %ebx 124532: e8 d1 eb fe ff call 113108 <_Thread_queue_Extract_with_proxy> return true; 124537: 83 c4 10 add $0x10,%esp 12453a: b0 01 mov $0x1,%al if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) _Thread_Dispatch_necessary = true; } } return false; } 12453c: 8d 65 f4 lea -0xc(%ebp),%esp 12453f: 5b pop %ebx 124540: 5e pop %esi 124541: 5f pop %edi 124542: c9 leave 124543: 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) ) { 124544: 8b 8e d0 00 00 00 mov 0xd0(%esi),%ecx 12454a: f7 d1 not %ecx 12454c: 85 c8 test %ecx,%eax 12454e: 75 c1 jne 124511 <_POSIX_signals_Unblock_thread+0xa9> 124550: eb ae jmp 124500 <_POSIX_signals_Unblock_thread+0x98> 124552: 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 ); 124554: 83 ec 0c sub $0xc,%esp 124557: 53 push %ebx 124558: e8 ab eb fe ff call 113108 <_Thread_queue_Extract_with_proxy> 12455d: 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; 124560: 31 c0 xor %eax,%eax 124562: eb 9e jmp 124502 <_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; 124564: 89 10 mov %edx,(%eax) the_info->si_code = SI_USER; 124566: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax) the_info->si_value.sival_int = 0; 12456d: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax) 124574: eb b8 jmp 12452e <_POSIX_signals_Unblock_thread+0xc6> 124576: 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; 124578: c6 05 c4 e8 12 00 01 movb $0x1,0x12e8c4 } } return false; 12457f: 31 c0 xor %eax,%eax 124581: e9 7c ff ff ff jmp 124502 <_POSIX_signals_Unblock_thread+0x9a> =============================================================================== 0010d864 <_Protected_heap_Get_information>: bool _Protected_heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ) { 10d864: 55 push %ebp 10d865: 89 e5 mov %esp,%ebp 10d867: 56 push %esi 10d868: 53 push %ebx 10d869: 8b 5d 08 mov 0x8(%ebp),%ebx 10d86c: 8b 75 0c mov 0xc(%ebp),%esi if ( !the_heap ) 10d86f: 85 db test %ebx,%ebx 10d871: 74 35 je 10d8a8 <_Protected_heap_Get_information+0x44> return false; if ( !the_info ) 10d873: 85 f6 test %esi,%esi 10d875: 74 31 je 10d8a8 <_Protected_heap_Get_information+0x44> return false; _RTEMS_Lock_allocator(); 10d877: 83 ec 0c sub $0xc,%esp 10d87a: ff 35 3c 80 12 00 pushl 0x12803c 10d880: e8 cf ed ff ff call 10c654 <_API_Mutex_Lock> _Heap_Get_information( the_heap, the_info ); 10d885: 5a pop %edx 10d886: 59 pop %ecx 10d887: 56 push %esi 10d888: 53 push %ebx 10d889: e8 86 47 00 00 call 112014 <_Heap_Get_information> _RTEMS_Unlock_allocator(); 10d88e: 58 pop %eax 10d88f: ff 35 3c 80 12 00 pushl 0x12803c 10d895: e8 02 ee ff ff call 10c69c <_API_Mutex_Unlock> return true; 10d89a: 83 c4 10 add $0x10,%esp 10d89d: b0 01 mov $0x1,%al } 10d89f: 8d 65 f8 lea -0x8(%ebp),%esp 10d8a2: 5b pop %ebx 10d8a3: 5e pop %esi 10d8a4: c9 leave 10d8a5: c3 ret 10d8a6: 66 90 xchg %ax,%ax { if ( !the_heap ) return false; if ( !the_info ) return false; 10d8a8: 31 c0 xor %eax,%eax _RTEMS_Lock_allocator(); _Heap_Get_information( the_heap, the_info ); _RTEMS_Unlock_allocator(); return true; } 10d8aa: 8d 65 f8 lea -0x8(%ebp),%esp 10d8ad: 5b pop %ebx 10d8ae: 5e pop %esi 10d8af: c9 leave 10d8b0: c3 ret =============================================================================== 00110c20 <_Protected_heap_Walk>: bool _Protected_heap_Walk( Heap_Control *the_heap, int source, bool do_dump ) { 110c20: 55 push %ebp 110c21: 89 e5 mov %esp,%ebp 110c23: 56 push %esi 110c24: 53 push %ebx 110c25: 83 ec 10 sub $0x10,%esp 110c28: 8b 5d 08 mov 0x8(%ebp),%ebx 110c2b: 8b 75 0c mov 0xc(%ebp),%esi 110c2e: 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 ) { 110c31: 8b 15 50 de 12 00 mov 0x12de50,%edx 110c37: 85 d2 test %edx,%edx 110c39: 74 19 je 110c54 <_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 ); 110c3b: 0f b6 c0 movzbl %al,%eax 110c3e: 89 45 10 mov %eax,0x10(%ebp) 110c41: 89 75 0c mov %esi,0xc(%ebp) 110c44: 89 5d 08 mov %ebx,0x8(%ebp) } return status; } 110c47: 8d 65 f8 lea -0x8(%ebp),%esp 110c4a: 5b pop %ebx 110c4b: 5e pop %esi 110c4c: 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 ); 110c4d: e9 1a f2 ff ff jmp 10fe6c <_Heap_Walk> 110c52: 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(); 110c54: 83 ec 0c sub $0xc,%esp 110c57: ff 35 3c df 12 00 pushl 0x12df3c 110c5d: 88 45 f4 mov %al,-0xc(%ebp) 110c60: e8 a7 e3 ff ff call 10f00c <_API_Mutex_Lock> status = _Heap_Walk( the_heap, source, do_dump ); 110c65: 83 c4 0c add $0xc,%esp 110c68: 8a 45 f4 mov -0xc(%ebp),%al 110c6b: 0f b6 c0 movzbl %al,%eax 110c6e: 50 push %eax 110c6f: 56 push %esi 110c70: 53 push %ebx 110c71: e8 f6 f1 ff ff call 10fe6c <_Heap_Walk> _RTEMS_Unlock_allocator(); 110c76: 5a pop %edx 110c77: ff 35 3c df 12 00 pushl 0x12df3c 110c7d: 88 45 f4 mov %al,-0xc(%ebp) 110c80: e8 cf e3 ff ff call 10f054 <_API_Mutex_Unlock> 110c85: 83 c4 10 add $0x10,%esp } else { status = _Heap_Walk( the_heap, source, do_dump ); } return status; } 110c88: 8a 45 f4 mov -0xc(%ebp),%al 110c8b: 8d 65 f8 lea -0x8(%ebp),%esp 110c8e: 5b pop %ebx 110c8f: 5e pop %esi 110c90: c9 leave 110c91: c3 ret =============================================================================== 00110e64 <_RTEMS_tasks_Create_extension>: bool _RTEMS_tasks_Create_extension( Thread_Control *executing, Thread_Control *created ) { 110e64: 55 push %ebp 110e65: 89 e5 mov %esp,%ebp 110e67: 53 push %ebx 110e68: 83 ec 10 sub $0x10,%esp 110e6b: 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 ); 110e6e: 80 3d 44 32 12 00 01 cmpb $0x1,0x123244 110e75: 19 c0 sbb %eax,%eax 110e77: 83 e0 c0 and $0xffffffc0,%eax 110e7a: 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 ); 110e7d: 50 push %eax 110e7e: e8 dd da ff ff call 10e960 <_Workspace_Allocate> if ( !api ) 110e83: 83 c4 10 add $0x10,%esp 110e86: 85 c0 test %eax,%eax 110e88: 74 6a je 110ef4 <_RTEMS_tasks_Create_extension+0x90> return false; created->API_Extensions[ THREAD_API_RTEMS ] = api; 110e8a: 89 83 e8 00 00 00 mov %eax,0xe8(%ebx) api->pending_events = EVENT_SETS_NONE_PENDING; 110e90: c7 00 00 00 00 00 movl $0x0,(%eax) api->event_condition = 0; 110e96: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) */ RTEMS_INLINE_ROUTINE void _ASR_Initialize ( ASR_Information *information ) { information->is_enabled = false; 110e9d: c6 40 08 00 movb $0x0,0x8(%eax) information->handler = NULL; 110ea1: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) information->mode_set = RTEMS_DEFAULT_MODES; 110ea8: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax) information->signals_posted = 0; 110eaf: c7 40 14 00 00 00 00 movl $0x0,0x14(%eax) information->signals_pending = 0; 110eb6: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) information->nest_level = 0; 110ebd: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax) _ASR_Initialize( &api->Signal ); created->task_variables = NULL; 110ec4: c7 83 f4 00 00 00 00 movl $0x0,0xf4(%ebx) 110ecb: 00 00 00 if ( rtems_configuration_get_notepads_enabled() ) { 110ece: 80 3d 44 32 12 00 00 cmpb $0x0,0x123244 110ed5: 74 13 je 110eea <_RTEMS_tasks_Create_extension+0x86> 110ed7: 31 d2 xor %edx,%edx 110ed9: 8d 76 00 lea 0x0(%esi),%esi for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++) api->Notepads[i] = 0; 110edc: c7 44 90 20 00 00 00 movl $0x0,0x20(%eax,%edx,4) 110ee3: 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++) 110ee4: 42 inc %edx 110ee5: 83 fa 10 cmp $0x10,%edx 110ee8: 75 f2 jne 110edc <_RTEMS_tasks_Create_extension+0x78> api->Notepads[i] = 0; } return true; 110eea: b0 01 mov $0x1,%al } 110eec: 8b 5d fc mov -0x4(%ebp),%ebx 110eef: c9 leave 110ef0: c3 ret 110ef1: 8d 76 00 lea 0x0(%esi),%esi to_allocate -= (RTEMS_NUMBER_NOTEPADS * sizeof(uint32_t)); api = _Workspace_Allocate( to_allocate ); if ( !api ) return false; 110ef4: 31 c0 xor %eax,%eax for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++) api->Notepads[i] = 0; } return true; } 110ef6: 8b 5d fc mov -0x4(%ebp),%ebx 110ef9: c9 leave 110efa: c3 ret =============================================================================== 00110e0c <_RTEMS_tasks_Delete_extension>: void _RTEMS_tasks_Delete_extension( Thread_Control *executing, Thread_Control *deleted ) { 110e0c: 55 push %ebp 110e0d: 89 e5 mov %esp,%ebp 110e0f: 56 push %esi 110e10: 53 push %ebx 110e11: 8b 5d 0c mov 0xc(%ebp),%ebx /* * Free per task variable memory */ tvp = deleted->task_variables; 110e14: 8b 83 f4 00 00 00 mov 0xf4(%ebx),%eax deleted->task_variables = NULL; 110e1a: c7 83 f4 00 00 00 00 movl $0x0,0xf4(%ebx) 110e21: 00 00 00 while (tvp) { 110e24: 85 c0 test %eax,%eax 110e26: 75 06 jne 110e2e <_RTEMS_tasks_Delete_extension+0x22> 110e28: eb 17 jmp 110e41 <_RTEMS_tasks_Delete_extension+0x35> 110e2a: 66 90 xchg %ax,%ax next = (rtems_task_variable_t *)tvp->next; _RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp ); tvp = next; 110e2c: 89 f0 mov %esi,%eax */ tvp = deleted->task_variables; deleted->task_variables = NULL; while (tvp) { next = (rtems_task_variable_t *)tvp->next; 110e2e: 8b 30 mov (%eax),%esi _RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp ); 110e30: 83 ec 08 sub $0x8,%esp 110e33: 50 push %eax 110e34: 53 push %ebx 110e35: e8 56 01 00 00 call 110f90 <_RTEMS_Tasks_Invoke_task_variable_dtor> * Free per task variable memory */ tvp = deleted->task_variables; deleted->task_variables = NULL; while (tvp) { 110e3a: 83 c4 10 add $0x10,%esp 110e3d: 85 f6 test %esi,%esi 110e3f: 75 eb jne 110e2c <_RTEMS_tasks_Delete_extension+0x20> /* * Free API specific memory */ (void) _Workspace_Free( deleted->API_Extensions[ THREAD_API_RTEMS ] ); 110e41: 83 ec 0c sub $0xc,%esp 110e44: ff b3 e8 00 00 00 pushl 0xe8(%ebx) 110e4a: e8 2d db ff ff call 10e97c <_Workspace_Free> deleted->API_Extensions[ THREAD_API_RTEMS ] = NULL; 110e4f: c7 83 e8 00 00 00 00 movl $0x0,0xe8(%ebx) 110e56: 00 00 00 110e59: 83 c4 10 add $0x10,%esp } 110e5c: 8d 65 f8 lea -0x8(%ebp),%esp 110e5f: 5b pop %ebx 110e60: 5e pop %esi 110e61: c9 leave 110e62: c3 ret =============================================================================== 00110d90 <_RTEMS_tasks_Initialize_user_tasks>: * * Output parameters: NONE */ void _RTEMS_tasks_Initialize_user_tasks( void ) { 110d90: 55 push %ebp 110d91: 89 e5 mov %esp,%ebp 110d93: 83 ec 08 sub $0x8,%esp if ( _RTEMS_tasks_Initialize_user_tasks_p ) 110d96: a1 c4 32 12 00 mov 0x1232c4,%eax 110d9b: 85 c0 test %eax,%eax 110d9d: 74 05 je 110da4 <_RTEMS_tasks_Initialize_user_tasks+0x14> (*_RTEMS_tasks_Initialize_user_tasks_p)(); } 110d9f: c9 leave */ void _RTEMS_tasks_Initialize_user_tasks( void ) { if ( _RTEMS_tasks_Initialize_user_tasks_p ) (*_RTEMS_tasks_Initialize_user_tasks_p)(); 110da0: ff e0 jmp *%eax 110da2: 66 90 xchg %ax,%ax } 110da4: c9 leave 110da5: 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 32 12 00 mov 0x12326c,%ebx maximum = Configuration_RTEMS_API.number_of_initialization_tasks; 10ba8f: 8b 3d 68 32 12 00 mov 0x123268,%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 06 0e 00 00 call 10c8f8 <_Internal_error_Occurred> =============================================================================== 00110d48 <_RTEMS_tasks_Switch_extension>: void _RTEMS_tasks_Switch_extension( Thread_Control *executing, Thread_Control *heir ) { 110d48: 55 push %ebp 110d49: 89 e5 mov %esp,%ebp /* * Per Task Variables */ tvp = executing->task_variables; 110d4b: 8b 45 08 mov 0x8(%ebp),%eax 110d4e: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax while (tvp) { 110d54: 85 c0 test %eax,%eax 110d56: 74 13 je 110d6b <_RTEMS_tasks_Switch_extension+0x23> tvp->tval = *tvp->ptr; 110d58: 8b 50 04 mov 0x4(%eax),%edx 110d5b: 8b 0a mov (%edx),%ecx 110d5d: 89 48 0c mov %ecx,0xc(%eax) *tvp->ptr = tvp->gval; 110d60: 8b 48 08 mov 0x8(%eax),%ecx 110d63: 89 0a mov %ecx,(%edx) tvp = (rtems_task_variable_t *)tvp->next; 110d65: 8b 00 mov (%eax),%eax /* * Per Task Variables */ tvp = executing->task_variables; while (tvp) { 110d67: 85 c0 test %eax,%eax 110d69: 75 ed jne 110d58 <_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; 110d6b: 8b 45 0c mov 0xc(%ebp),%eax 110d6e: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax while (tvp) { 110d74: 85 c0 test %eax,%eax 110d76: 74 13 je 110d8b <_RTEMS_tasks_Switch_extension+0x43> tvp->gval = *tvp->ptr; 110d78: 8b 50 04 mov 0x4(%eax),%edx 110d7b: 8b 0a mov (%edx),%ecx 110d7d: 89 48 08 mov %ecx,0x8(%eax) *tvp->ptr = tvp->tval; 110d80: 8b 48 0c mov 0xc(%eax),%ecx 110d83: 89 0a mov %ecx,(%edx) tvp = (rtems_task_variable_t *)tvp->next; 110d85: 8b 00 mov (%eax),%eax *tvp->ptr = tvp->gval; tvp = (rtems_task_variable_t *)tvp->next; } tvp = heir->task_variables; while (tvp) { 110d87: 85 c0 test %eax,%eax 110d89: 75 ed jne 110d78 <_RTEMS_tasks_Switch_extension+0x30><== NEVER TAKEN tvp->gval = *tvp->ptr; *tvp->ptr = tvp->tval; tvp = (rtems_task_variable_t *)tvp->next; } } 110d8b: c9 leave 110d8c: 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 9c 18 00 00 call 10dda4 <_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 b8 ae 12 00 cmp %esi,0x12aeb8 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 c8 a9 12 00 push $0x12a9c8 10c547: e8 cc 39 00 00 call 10ff18 <_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 c4 38 00 00 call 10fe1c <_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 e0 a7 12 00 push $0x12a7e0 10cabe: e8 79 1d 00 00 call 10e83c <_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 d0 a8 12 00 mov 0x12a8d0,%eax 10caf0: 48 dec %eax 10caf1: a3 d0 a8 12 00 mov %eax,0x12a8d0 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 dc a9 12 00 push $0x12a9dc 10cb1f: e8 d4 36 00 00 call 1101f8 <_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 33 24 00 00 call 10ef70 <_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 73 38 00 00 call 10fe1c <_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 3f 39 00 00 call 10fef4 <_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 fb 38 00 00 call 10fed0 <_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 24 38 00 00 call 10fe1c <_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 f0 38 00 00 call 10fef4 <_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 b8 38 00 00 call 10fed0 <_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> =============================================================================== 00111608 <_Scheduler_priority_Block>: void _Scheduler_priority_Block( Scheduler_Control *the_scheduler, Thread_Control *the_thread ) { 111608: 55 push %ebp 111609: 89 e5 mov %esp,%ebp 11160b: 53 push %ebx 11160c: 8b 45 0c mov 0xc(%ebp),%eax RTEMS_INLINE_ROUTINE void _Scheduler_priority_Ready_queue_extract( Thread_Control *the_thread ) { Chain_Control *ready = the_thread->scheduler.priority->ready_chain; 11160f: 8b 90 8c 00 00 00 mov 0x8c(%eax),%edx 111615: 8b 12 mov (%edx),%edx if ( _Chain_Has_only_one_node( ready ) ) { 111617: 8b 4a 08 mov 0x8(%edx),%ecx 11161a: 39 0a cmp %ecx,(%edx) 11161c: 74 6e je 11168c <_Scheduler_priority_Block+0x84> ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 11161e: 8b 08 mov (%eax),%ecx previous = the_node->previous; 111620: 8b 50 04 mov 0x4(%eax),%edx next->previous = previous; 111623: 89 51 04 mov %edx,0x4(%ecx) previous->next = next; 111626: 89 0a mov %ecx,(%edx) { _Scheduler_priority_Ready_queue_extract(the_thread); /* TODO: flash critical section */ if ( _Thread_Is_heir( the_thread ) ) 111628: 3b 05 5c 7b 12 00 cmp 0x127b5c,%eax 11162e: 74 18 je 111648 <_Scheduler_priority_Block+0x40> _Scheduler_priority_Schedule_body(the_scheduler); if ( _Thread_Is_executing( the_thread ) ) 111630: 3b 05 58 7b 12 00 cmp 0x127b58,%eax 111636: 74 04 je 11163c <_Scheduler_priority_Block+0x34> _Scheduler_priority_Block_body(the_scheduler, the_thread); } 111638: 5b pop %ebx 111639: c9 leave 11163a: c3 ret 11163b: 90 nop _Thread_Dispatch_necessary = true; 11163c: c6 05 64 7b 12 00 01 movb $0x1,0x127b64 111643: 5b pop %ebx 111644: c9 leave 111645: c3 ret 111646: 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 ); 111648: 66 8b 1d 80 7b 12 00 mov 0x127b80,%bx 11164f: 31 d2 xor %edx,%edx 111651: 89 d1 mov %edx,%ecx 111653: 66 0f bc cb bsf %bx,%cx _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor ); 111657: 0f b7 c9 movzwl %cx,%ecx 11165a: 66 8b 9c 09 a0 7b 12 mov 0x127ba0(%ecx,%ecx,1),%bx 111661: 00 111662: 66 0f bc d3 bsf %bx,%dx return (_Priority_Bits_index( major ) << 4) + 111666: c1 e1 04 shl $0x4,%ecx 111669: 0f b7 d2 movzwl %dx,%edx 11166c: 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 ] ) ) 11166f: 8d 14 52 lea (%edx,%edx,2),%edx 111672: c1 e2 02 shl $0x2,%edx 111675: 8b 4d 08 mov 0x8(%ebp),%ecx 111678: 03 11 add (%ecx),%edx 11167a: 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 ); 11167c: 83 c2 04 add $0x4,%edx 11167f: 39 d1 cmp %edx,%ecx 111681: 74 4d je 1116d0 <_Scheduler_priority_Block+0xc8><== NEVER TAKEN RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body( Scheduler_Control *the_scheduler ) { _Thread_Heir = _Scheduler_priority_Ready_queue_first( 111683: 89 0d 5c 7b 12 00 mov %ecx,0x127b5c 111689: eb a5 jmp 111630 <_Scheduler_priority_Block+0x28> 11168b: 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 ); 11168c: 8d 4a 04 lea 0x4(%edx),%ecx 11168f: 89 0a mov %ecx,(%edx) head->next = tail; head->previous = NULL; 111691: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) tail->previous = head; 111698: 89 52 08 mov %edx,0x8(%edx) { Chain_Control *ready = the_thread->scheduler.priority->ready_chain; if ( _Chain_Has_only_one_node( ready ) ) { _Chain_Initialize_empty( ready ); _Priority_bit_map_Remove( &the_thread->scheduler.priority->Priority_map ); 11169b: 8b 88 8c 00 00 00 mov 0x8c(%eax),%ecx RTEMS_INLINE_ROUTINE void _Priority_bit_map_Remove ( Priority_bit_map_Information *the_priority_map ) { *the_priority_map->minor &= the_priority_map->block_minor; 1116a1: 8b 59 04 mov 0x4(%ecx),%ebx 1116a4: 66 8b 13 mov (%ebx),%dx 1116a7: 66 23 51 0e and 0xe(%ecx),%dx 1116ab: 66 89 13 mov %dx,(%ebx) if ( *the_priority_map->minor == 0 ) 1116ae: 66 85 d2 test %dx,%dx 1116b1: 0f 85 71 ff ff ff jne 111628 <_Scheduler_priority_Block+0x20> _Priority_Major_bit_map &= the_priority_map->block_major; 1116b7: 66 8b 15 80 7b 12 00 mov 0x127b80,%dx 1116be: 23 51 0c and 0xc(%ecx),%edx 1116c1: 66 89 15 80 7b 12 00 mov %dx,0x127b80 1116c8: e9 5b ff ff ff jmp 111628 <_Scheduler_priority_Block+0x20> 1116cd: 8d 76 00 lea 0x0(%esi),%esi 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; 1116d0: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 1116d2: eb af jmp 111683 <_Scheduler_priority_Block+0x7b><== NOT EXECUTED =============================================================================== 0010d238 <_Scheduler_priority_Schedule>: */ void _Scheduler_priority_Schedule( Scheduler_Control *the_scheduler ) { 10d238: 55 push %ebp 10d239: 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 ); 10d23b: 66 8b 0d 80 7b 12 00 mov 0x127b80,%cx 10d242: 31 c0 xor %eax,%eax 10d244: 89 c2 mov %eax,%edx 10d246: 66 0f bc d1 bsf %cx,%dx _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor ); 10d24a: 0f b7 d2 movzwl %dx,%edx 10d24d: 66 8b 8c 12 a0 7b 12 mov 0x127ba0(%edx,%edx,1),%cx 10d254: 00 10d255: 66 0f bc c1 bsf %cx,%ax return (_Priority_Bits_index( major ) << 4) + 10d259: c1 e2 04 shl $0x4,%edx 10d25c: 0f b7 c0 movzwl %ax,%eax 10d25f: 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 ] ) ) 10d262: 8d 04 40 lea (%eax,%eax,2),%eax 10d265: c1 e0 02 shl $0x2,%eax 10d268: 8b 55 08 mov 0x8(%ebp),%edx 10d26b: 03 02 add (%edx),%eax _Scheduler_priority_Schedule_body( the_scheduler ); } 10d26d: 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 ); 10d26f: 83 c0 04 add $0x4,%eax 10d272: 39 c2 cmp %eax,%edx 10d274: 74 0a je 10d280 <_Scheduler_priority_Schedule+0x48><== NEVER TAKEN RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body( Scheduler_Control *the_scheduler ) { _Thread_Heir = _Scheduler_priority_Ready_queue_first( 10d276: 89 15 5c 7b 12 00 mov %edx,0x127b5c 10d27c: c9 leave 10d27d: c3 ret 10d27e: 66 90 xchg %ax,%ax 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; 10d280: 31 d2 xor %edx,%edx <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body( Scheduler_Control *the_scheduler ) { _Thread_Heir = _Scheduler_priority_Ready_queue_first( 10d282: 89 15 5c 7b 12 00 mov %edx,0x127b5c <== NOT EXECUTED 10d288: c9 leave <== NOT EXECUTED 10d289: c3 ret <== NOT EXECUTED =============================================================================== 0010d318 <_Scheduler_priority_Unblock>: void _Scheduler_priority_Unblock ( Scheduler_Control *the_scheduler, Thread_Control *the_thread ) { 10d318: 55 push %ebp 10d319: 89 e5 mov %esp,%ebp 10d31b: 53 push %ebx 10d31c: 8b 45 0c mov 0xc(%ebp),%eax RTEMS_INLINE_ROUTINE void _Scheduler_priority_Ready_queue_enqueue( Thread_Control *the_thread ) { _Priority_bit_map_Add( &the_thread->scheduler.priority->Priority_map ); 10d31f: 8b 90 8c 00 00 00 mov 0x8c(%eax),%edx RTEMS_INLINE_ROUTINE void _Priority_bit_map_Add ( Priority_bit_map_Information *the_priority_map ) { *the_priority_map->minor |= the_priority_map->ready_minor; 10d325: 8b 4a 04 mov 0x4(%edx),%ecx 10d328: 66 8b 5a 0a mov 0xa(%edx),%bx 10d32c: 66 09 19 or %bx,(%ecx) _Priority_Major_bit_map |= the_priority_map->ready_major; 10d32f: 66 8b 0d 80 7b 12 00 mov 0x127b80,%cx 10d336: 0b 4a 08 or 0x8(%edx),%ecx 10d339: 66 89 0d 80 7b 12 00 mov %cx,0x127b80 _Chain_Append_unprotected( the_thread->scheduler.priority->ready_chain, 10d340: 8b 12 mov (%edx),%edx Chain_Control *the_chain, Chain_Node *the_node ) { Chain_Node *tail = _Chain_Tail( the_chain ); Chain_Node *old_last = tail->previous; 10d342: 8b 4a 08 mov 0x8(%edx),%ecx RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected( Chain_Control *the_chain, Chain_Node *the_node ) { Chain_Node *tail = _Chain_Tail( the_chain ); 10d345: 8d 5a 04 lea 0x4(%edx),%ebx 10d348: 89 18 mov %ebx,(%eax) Chain_Node *old_last = tail->previous; the_node->next = tail; tail->previous = the_node; 10d34a: 89 42 08 mov %eax,0x8(%edx) old_last->next = the_node; 10d34d: 89 01 mov %eax,(%ecx) the_node->previous = old_last; 10d34f: 89 48 04 mov %ecx,0x4(%eax) * a context switch. * Pseudo-ISR case: * Even if the thread isn't preemptible, if the new heir is * a pseudo-ISR system task, we need to do a context switch. */ if ( the_thread->current_priority < _Thread_Heir->current_priority ) { 10d352: 8b 50 14 mov 0x14(%eax),%edx 10d355: 8b 0d 5c 7b 12 00 mov 0x127b5c,%ecx 10d35b: 3b 51 14 cmp 0x14(%ecx),%edx 10d35e: 73 17 jae 10d377 <_Scheduler_priority_Unblock+0x5f> _Thread_Heir = the_thread; 10d360: a3 5c 7b 12 00 mov %eax,0x127b5c if ( _Thread_Executing->is_preemptible || 10d365: a1 58 7b 12 00 mov 0x127b58,%eax 10d36a: 80 78 74 00 cmpb $0x0,0x74(%eax) 10d36e: 74 0c je 10d37c <_Scheduler_priority_Unblock+0x64> the_thread->current_priority == 0 ) _Thread_Dispatch_necessary = true; 10d370: c6 05 64 7b 12 00 01 movb $0x1,0x127b64 _Scheduler_priority_Unblock_body(the_scheduler, the_thread); } 10d377: 5b pop %ebx 10d378: c9 leave 10d379: c3 ret 10d37a: 66 90 xchg %ax,%ax * Even if the thread isn't preemptible, if the new heir is * a pseudo-ISR system task, we need to do a context switch. */ if ( the_thread->current_priority < _Thread_Heir->current_priority ) { _Thread_Heir = the_thread; if ( _Thread_Executing->is_preemptible || 10d37c: 85 d2 test %edx,%edx 10d37e: 75 f7 jne 10d377 <_Scheduler_priority_Unblock+0x5f> the_thread->current_priority == 0 ) _Thread_Dispatch_necessary = true; 10d380: c6 05 64 7b 12 00 01 movb $0x1,0x127b64 10d387: eb ee jmp 10d377 <_Scheduler_priority_Unblock+0x5f> =============================================================================== 0010d38c <_Scheduler_priority_Yield>: */ void _Scheduler_priority_Yield( Scheduler_Control *the_scheduler __attribute__((unused)) ) { 10d38c: 55 push %ebp 10d38d: 89 e5 mov %esp,%ebp 10d38f: 56 push %esi 10d390: 53 push %ebx ISR_Level level; Thread_Control *executing; Chain_Control *ready; executing = _Thread_Executing; 10d391: a1 58 7b 12 00 mov 0x127b58,%eax ready = executing->scheduler.priority->ready_chain; 10d396: 8b 90 8c 00 00 00 mov 0x8c(%eax),%edx 10d39c: 8b 12 mov (%edx),%edx _ISR_Disable( level ); 10d39e: 9c pushf 10d39f: fa cli 10d3a0: 59 pop %ecx if ( !_Chain_Has_only_one_node( ready ) ) { 10d3a1: 8b 5a 08 mov 0x8(%edx),%ebx 10d3a4: 39 1a cmp %ebx,(%edx) 10d3a6: 74 40 je 10d3e8 <_Scheduler_priority_Yield+0x5c> ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 10d3a8: 8b 30 mov (%eax),%esi previous = the_node->previous; 10d3aa: 8b 58 04 mov 0x4(%eax),%ebx next->previous = previous; 10d3ad: 89 5e 04 mov %ebx,0x4(%esi) previous->next = next; 10d3b0: 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; 10d3b2: 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 ); 10d3b5: 8d 72 04 lea 0x4(%edx),%esi 10d3b8: 89 30 mov %esi,(%eax) Chain_Node *old_last = tail->previous; the_node->next = tail; tail->previous = the_node; 10d3ba: 89 42 08 mov %eax,0x8(%edx) old_last->next = the_node; 10d3bd: 89 03 mov %eax,(%ebx) the_node->previous = old_last; 10d3bf: 89 58 04 mov %ebx,0x4(%eax) _Chain_Extract_unprotected( &executing->Object.Node ); _Chain_Append_unprotected( ready, &executing->Object.Node ); _ISR_Flash( level ); 10d3c2: 51 push %ecx 10d3c3: 9d popf 10d3c4: fa cli if ( _Thread_Is_heir( executing ) ) 10d3c5: 3b 05 5c 7b 12 00 cmp 0x127b5c,%eax 10d3cb: 74 0f je 10d3dc <_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; 10d3cd: c6 05 64 7b 12 00 01 movb $0x1,0x127b64 _ISR_Enable( level ); 10d3d4: 51 push %ecx 10d3d5: 9d popf } 10d3d6: 5b pop %ebx 10d3d7: 5e pop %esi 10d3d8: c9 leave 10d3d9: c3 ret 10d3da: 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 ); 10d3dc: 8b 02 mov (%edx),%eax 10d3de: a3 5c 7b 12 00 mov %eax,0x127b5c 10d3e3: eb e8 jmp 10d3cd <_Scheduler_priority_Yield+0x41> 10d3e5: 8d 76 00 lea 0x0(%esi),%esi _Thread_Dispatch_necessary = true; } else if ( !_Thread_Is_heir( executing ) ) 10d3e8: 3b 05 5c 7b 12 00 cmp 0x127b5c,%eax 10d3ee: 75 dd jne 10d3cd <_Scheduler_priority_Yield+0x41> 10d3f0: eb e2 jmp 10d3d4 <_Scheduler_priority_Yield+0x48> =============================================================================== 0010dae0 <_TOD_Set>: */ void _TOD_Set( const struct timespec *time ) { 10dae0: 55 push %ebp 10dae1: 89 e5 mov %esp,%ebp 10dae3: 53 push %ebx 10dae4: 83 ec 04 sub $0x4,%esp 10dae7: 8b 5d 08 mov 0x8(%ebp),%ebx 10daea: a1 70 23 13 00 mov 0x132370,%eax 10daef: 40 inc %eax 10daf0: a3 70 23 13 00 mov %eax,0x132370 long seconds; _Thread_Disable_dispatch(); _TOD_Deactivate(); seconds = _TOD_Seconds_since_epoch(); 10daf5: a1 44 24 13 00 mov 0x132444,%eax if ( time->tv_sec < seconds ) 10dafa: 8b 13 mov (%ebx),%edx 10dafc: 39 d0 cmp %edx,%eax 10dafe: 7f 34 jg 10db34 <_TOD_Set+0x54> Watchdog_Adjust_directions direction, Watchdog_Interval units ) { _Watchdog_Adjust( &_Watchdog_Seconds_chain, direction, units ); 10db00: 51 push %ecx _Watchdog_Adjust_seconds( WATCHDOG_BACKWARD, seconds - time->tv_sec ); else _Watchdog_Adjust_seconds( WATCHDOG_FORWARD, time->tv_sec - seconds ); 10db01: 29 c2 sub %eax,%edx 10db03: 52 push %edx 10db04: 6a 00 push $0x0 10db06: 68 70 24 13 00 push $0x132470 10db0b: e8 e8 24 00 00 call 10fff8 <_Watchdog_Adjust> 10db10: 83 c4 10 add $0x10,%esp /* POSIX format TOD (timespec) */ _Timestamp_Set( &_TOD_Now, time->tv_sec, time->tv_nsec ); 10db13: 8b 03 mov (%ebx),%eax 10db15: a3 44 24 13 00 mov %eax,0x132444 10db1a: 8b 43 04 mov 0x4(%ebx),%eax 10db1d: a3 48 24 13 00 mov %eax,0x132448 _TOD_Is_set = true; 10db22: c6 05 84 23 13 00 01 movb $0x1,0x132384 _TOD_Activate(); _Thread_Enable_dispatch(); } 10db29: 8b 5d fc mov -0x4(%ebp),%ebx 10db2c: c9 leave _Timestamp_Set( &_TOD_Now, time->tv_sec, time->tv_nsec ); _TOD_Is_set = true; _TOD_Activate(); _Thread_Enable_dispatch(); 10db2d: e9 42 15 00 00 jmp 10f074 <_Thread_Enable_dispatch> 10db32: 66 90 xchg %ax,%ax 10db34: 51 push %ecx _TOD_Deactivate(); seconds = _TOD_Seconds_since_epoch(); if ( time->tv_sec < seconds ) _Watchdog_Adjust_seconds( WATCHDOG_BACKWARD, seconds - time->tv_sec ); 10db35: 29 d0 sub %edx,%eax 10db37: 50 push %eax 10db38: 6a 01 push $0x1 10db3a: 68 70 24 13 00 push $0x132470 10db3f: e8 b4 24 00 00 call 10fff8 <_Watchdog_Adjust> 10db44: 83 c4 10 add $0x10,%esp 10db47: eb ca jmp 10db13 <_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 e0 3a 12 movzwl 0x123ae0(%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 14 3b 12 movzwl 0x123b14(%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 fa 3a 12 movzwl 0x123afa(%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 2c 62 12 00 mov 0x12622c,%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 54 3b 12 00 mov 0x123b54(,%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 20 3b 12 00 mov 0x123b20(,%eax,4),%eax 10c2e4: eb e8 jmp 10c2ce <_TOD_Validate+0x5a> =============================================================================== 0010d440 <_Thread_Change_priority>: void _Thread_Change_priority( Thread_Control *the_thread, Priority_Control new_priority, bool prepend_it ) { 10d440: 55 push %ebp 10d441: 89 e5 mov %esp,%ebp 10d443: 57 push %edi 10d444: 56 push %esi 10d445: 53 push %ebx 10d446: 83 ec 28 sub $0x28,%esp 10d449: 8b 5d 08 mov 0x8(%ebp),%ebx 10d44c: 8b 75 0c mov 0xc(%ebp),%esi 10d44f: 8a 45 10 mov 0x10(%ebp),%al 10d452: 88 45 e7 mov %al,-0x19(%ebp) */ /* * Save original state */ original_state = the_thread->current_state; 10d455: 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 ); 10d458: 53 push %ebx 10d459: e8 3a 0d 00 00 call 10e198 <_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 ) 10d45e: 83 c4 10 add $0x10,%esp 10d461: 39 73 14 cmp %esi,0x14(%ebx) 10d464: 74 0d je 10d473 <_Thread_Change_priority+0x33> _Thread_Set_priority( the_thread, new_priority ); 10d466: 83 ec 08 sub $0x8,%esp 10d469: 56 push %esi 10d46a: 53 push %ebx 10d46b: e8 c4 0c 00 00 call 10e134 <_Thread_Set_priority> 10d470: 83 c4 10 add $0x10,%esp _ISR_Disable( level ); 10d473: 9c pushf 10d474: fa cli 10d475: 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; 10d476: 8b 43 10 mov 0x10(%ebx),%eax if ( state != STATES_TRANSIENT ) { 10d479: 83 f8 04 cmp $0x4,%eax 10d47c: 74 26 je 10d4a4 <_Thread_Change_priority+0x64> /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) 10d47e: 83 e7 04 and $0x4,%edi 10d481: 74 15 je 10d498 <_Thread_Change_priority+0x58><== ALWAYS TAKEN the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); _ISR_Enable( level ); 10d483: 56 push %esi 10d484: 9d popf if ( _States_Is_waiting_on_thread_queue( state ) ) { 10d485: a9 e0 be 03 00 test $0x3bee0,%eax 10d48a: 0f 85 94 00 00 00 jne 10d524 <_Thread_Change_priority+0xe4> if ( !_Thread_Is_executing_also_the_heir() && _Thread_Executing->is_preemptible ) _Thread_Dispatch_necessary = true; _ISR_Enable( level ); } 10d490: 8d 65 f4 lea -0xc(%ebp),%esp 10d493: 5b pop %ebx 10d494: 5e pop %esi 10d495: 5f pop %edi 10d496: c9 leave 10d497: c3 ret RTEMS_INLINE_ROUTINE States_Control _States_Clear ( States_Control states_to_clear, States_Control current_state ) { return (current_state & ~states_to_clear); 10d498: 89 c2 mov %eax,%edx 10d49a: 83 e2 fb and $0xfffffffb,%edx 10d49d: 89 53 10 mov %edx,0x10(%ebx) 10d4a0: eb e1 jmp 10d483 <_Thread_Change_priority+0x43> 10d4a2: 66 90 xchg %ax,%ax } return; } /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) { 10d4a4: 83 e7 04 and $0x4,%edi 10d4a7: 75 40 jne 10d4e9 <_Thread_Change_priority+0xa9><== NEVER TAKEN * Ready Queue with interrupts off. * * FIXME: hard-coded for priority scheduling. Might be ok since this * function is specific to priority scheduling? */ the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); 10d4a9: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) if ( prepend_it ) 10d4b0: 80 7d e7 00 cmpb $0x0,-0x19(%ebp) 10d4b4: 0f 84 82 00 00 00 je 10d53c <_Thread_Change_priority+0xfc> RTEMS_INLINE_ROUTINE void _Scheduler_priority_Ready_queue_enqueue_first( Thread_Control *the_thread ) { _Priority_bit_map_Add( &the_thread->scheduler.priority->Priority_map ); 10d4ba: 8b 83 8c 00 00 00 mov 0x8c(%ebx),%eax RTEMS_INLINE_ROUTINE void _Priority_bit_map_Add ( Priority_bit_map_Information *the_priority_map ) { *the_priority_map->minor |= the_priority_map->ready_minor; 10d4c0: 8b 50 04 mov 0x4(%eax),%edx 10d4c3: 66 8b 48 0a mov 0xa(%eax),%cx 10d4c7: 66 09 0a or %cx,(%edx) _Priority_Major_bit_map |= the_priority_map->ready_major; 10d4ca: 66 8b 15 80 7b 12 00 mov 0x127b80,%dx 10d4d1: 0b 50 08 or 0x8(%eax),%edx 10d4d4: 66 89 15 80 7b 12 00 mov %dx,0x127b80 _Chain_Prepend_unprotected( the_thread->scheduler.priority->ready_chain, 10d4db: 8b 00 mov (%eax),%eax Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 10d4dd: 89 43 04 mov %eax,0x4(%ebx) before_node = after_node->next; 10d4e0: 8b 10 mov (%eax),%edx after_node->next = the_node; 10d4e2: 89 18 mov %ebx,(%eax) the_node->next = before_node; 10d4e4: 89 13 mov %edx,(%ebx) before_node->previous = the_node; 10d4e6: 89 5a 04 mov %ebx,0x4(%edx) _Scheduler_priority_Ready_queue_enqueue_first( the_thread ); else _Scheduler_priority_Ready_queue_enqueue( the_thread ); } _ISR_Flash( level ); 10d4e9: 56 push %esi 10d4ea: 9d popf 10d4eb: fa cli */ RTEMS_INLINE_ROUTINE void _Scheduler_Schedule( Scheduler_Control *the_scheduler ) { the_scheduler->Operations.schedule( the_scheduler ); 10d4ec: 83 ec 0c sub $0xc,%esp 10d4ef: 68 20 76 12 00 push $0x127620 10d4f4: ff 15 24 76 12 00 call *0x127624 * is also the heir thread, and false otherwise. */ RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void ) { return ( _Thread_Executing == _Thread_Heir ); 10d4fa: a1 58 7b 12 00 mov 0x127b58,%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(&_Scheduler); if ( !_Thread_Is_executing_also_the_heir() && 10d4ff: 83 c4 10 add $0x10,%esp 10d502: 3b 05 5c 7b 12 00 cmp 0x127b5c,%eax 10d508: 74 0d je 10d517 <_Thread_Change_priority+0xd7> 10d50a: 80 78 74 00 cmpb $0x0,0x74(%eax) 10d50e: 74 07 je 10d517 <_Thread_Change_priority+0xd7> _Thread_Executing->is_preemptible ) _Thread_Dispatch_necessary = true; 10d510: c6 05 64 7b 12 00 01 movb $0x1,0x127b64 _ISR_Enable( level ); 10d517: 56 push %esi 10d518: 9d popf } 10d519: 8d 65 f4 lea -0xc(%ebp),%esp 10d51c: 5b pop %ebx 10d51d: 5e pop %esi 10d51e: 5f pop %edi 10d51f: c9 leave 10d520: c3 ret 10d521: 8d 76 00 lea 0x0(%esi),%esi /* 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 ); 10d524: 89 5d 0c mov %ebx,0xc(%ebp) 10d527: 8b 43 44 mov 0x44(%ebx),%eax 10d52a: 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 ); } 10d52d: 8d 65 f4 lea -0xc(%ebp),%esp 10d530: 5b pop %ebx 10d531: 5e pop %esi 10d532: 5f pop %edi 10d533: 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 ); 10d534: e9 63 0b 00 00 jmp 10e09c <_Thread_queue_Requeue> 10d539: 8d 76 00 lea 0x0(%esi),%esi RTEMS_INLINE_ROUTINE void _Scheduler_priority_Ready_queue_enqueue( Thread_Control *the_thread ) { _Priority_bit_map_Add( &the_thread->scheduler.priority->Priority_map ); 10d53c: 8b 83 8c 00 00 00 mov 0x8c(%ebx),%eax RTEMS_INLINE_ROUTINE void _Priority_bit_map_Add ( Priority_bit_map_Information *the_priority_map ) { *the_priority_map->minor |= the_priority_map->ready_minor; 10d542: 8b 50 04 mov 0x4(%eax),%edx 10d545: 66 8b 48 0a mov 0xa(%eax),%cx 10d549: 66 09 0a or %cx,(%edx) _Priority_Major_bit_map |= the_priority_map->ready_major; 10d54c: 66 8b 15 80 7b 12 00 mov 0x127b80,%dx 10d553: 0b 50 08 or 0x8(%eax),%edx 10d556: 66 89 15 80 7b 12 00 mov %dx,0x127b80 _Chain_Append_unprotected( the_thread->scheduler.priority->ready_chain, 10d55d: 8b 00 mov (%eax),%eax Chain_Control *the_chain, Chain_Node *the_node ) { Chain_Node *tail = _Chain_Tail( the_chain ); Chain_Node *old_last = tail->previous; 10d55f: 8b 50 08 mov 0x8(%eax),%edx RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected( Chain_Control *the_chain, Chain_Node *the_node ) { Chain_Node *tail = _Chain_Tail( the_chain ); 10d562: 8d 48 04 lea 0x4(%eax),%ecx 10d565: 89 0b mov %ecx,(%ebx) Chain_Node *old_last = tail->previous; the_node->next = tail; tail->previous = the_node; 10d567: 89 58 08 mov %ebx,0x8(%eax) old_last->next = the_node; 10d56a: 89 1a mov %ebx,(%edx) the_node->previous = old_last; 10d56c: 89 53 04 mov %edx,0x4(%ebx) 10d56f: e9 75 ff ff ff jmp 10d4e9 <_Thread_Change_priority+0xa9> =============================================================================== 0010d574 <_Thread_Clear_state>: void _Thread_Clear_state( Thread_Control *the_thread, States_Control state ) { 10d574: 55 push %ebp 10d575: 89 e5 mov %esp,%ebp 10d577: 53 push %ebx 10d578: 83 ec 04 sub $0x4,%esp 10d57b: 8b 55 08 mov 0x8(%ebp),%edx 10d57e: 8b 45 0c mov 0xc(%ebp),%eax ISR_Level level; States_Control current_state; _ISR_Disable( level ); 10d581: 9c pushf 10d582: fa cli 10d583: 5b pop %ebx current_state = the_thread->current_state; 10d584: 8b 4a 10 mov 0x10(%edx),%ecx if ( current_state & state ) { 10d587: 85 c8 test %ecx,%eax 10d589: 74 0b je 10d596 <_Thread_Clear_state+0x22> 10d58b: f7 d0 not %eax 10d58d: 21 c8 and %ecx,%eax current_state = the_thread->current_state = _States_Clear( state, current_state ); 10d58f: 89 42 10 mov %eax,0x10(%edx) if ( _States_Is_ready( current_state ) ) { 10d592: 85 c0 test %eax,%eax 10d594: 74 0a je 10d5a0 <_Thread_Clear_state+0x2c> _Scheduler_Unblock( &_Scheduler, the_thread); } } _ISR_Enable( level ); 10d596: 53 push %ebx 10d597: 9d popf } 10d598: 8b 5d fc mov -0x4(%ebp),%ebx 10d59b: c9 leave 10d59c: c3 ret 10d59d: 8d 76 00 lea 0x0(%esi),%esi RTEMS_INLINE_ROUTINE void _Scheduler_Unblock( Scheduler_Control *the_scheduler, Thread_Control *the_thread ) { the_scheduler->Operations.unblock( the_scheduler, the_thread ); 10d5a0: 83 ec 08 sub $0x8,%esp 10d5a3: 52 push %edx 10d5a4: 68 20 76 12 00 push $0x127620 10d5a9: ff 15 30 76 12 00 call *0x127630 10d5af: 83 c4 10 add $0x10,%esp 10d5b2: eb e2 jmp 10d596 <_Thread_Clear_state+0x22> =============================================================================== 0010d740 <_Thread_Delay_ended>: void _Thread_Delay_ended( Objects_Id id, void *ignored __attribute__((unused)) ) { 10d740: 55 push %ebp 10d741: 89 e5 mov %esp,%ebp 10d743: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10d746: 8d 45 f4 lea -0xc(%ebp),%eax 10d749: 50 push %eax 10d74a: ff 75 08 pushl 0x8(%ebp) 10d74d: e8 c6 01 00 00 call 10d918 <_Thread_Get> switch ( location ) { 10d752: 83 c4 10 add $0x10,%esp 10d755: 8b 55 f4 mov -0xc(%ebp),%edx 10d758: 85 d2 test %edx,%edx 10d75a: 75 1c jne 10d778 <_Thread_Delay_ended+0x38><== NEVER TAKEN #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* impossible */ #endif break; case OBJECTS_LOCAL: _Thread_Clear_state( 10d75c: 83 ec 08 sub $0x8,%esp 10d75f: 68 18 00 00 10 push $0x10000018 10d764: 50 push %eax 10d765: e8 0a fe ff ff call 10d574 <_Thread_Clear_state> 10d76a: a1 70 75 12 00 mov 0x127570,%eax 10d76f: 48 dec %eax 10d770: a3 70 75 12 00 mov %eax,0x127570 10d775: 83 c4 10 add $0x10,%esp | STATES_INTERRUPTIBLE_BY_SIGNAL ); _Thread_Unnest_dispatch(); break; } } 10d778: c9 leave 10d779: c3 ret =============================================================================== 0010d77c <_Thread_Dispatch>: * dispatch thread * no dispatch thread */ void _Thread_Dispatch( void ) { 10d77c: 55 push %ebp 10d77d: 89 e5 mov %esp,%ebp 10d77f: 57 push %edi 10d780: 56 push %esi 10d781: 53 push %ebx 10d782: 83 ec 1c sub $0x1c,%esp Thread_Control *executing; Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; 10d785: 8b 1d 58 7b 12 00 mov 0x127b58,%ebx _ISR_Disable( level ); 10d78b: 9c pushf 10d78c: fa cli 10d78d: 58 pop %eax while ( _Thread_Dispatch_necessary == true ) { 10d78e: 8a 15 64 7b 12 00 mov 0x127b64,%dl 10d794: 84 d2 test %dl,%dl 10d796: 0f 84 3c 01 00 00 je 10d8d8 <_Thread_Dispatch+0x15c> heir = _Thread_Heir; 10d79c: 8b 35 5c 7b 12 00 mov 0x127b5c,%esi _Thread_Dispatch_disable_level = 1; 10d7a2: c7 05 70 75 12 00 01 movl $0x1,0x127570 10d7a9: 00 00 00 _Thread_Dispatch_necessary = false; 10d7ac: c6 05 64 7b 12 00 00 movb $0x0,0x127b64 _Thread_Executing = heir; 10d7b3: 89 35 58 7b 12 00 mov %esi,0x127b58 /* * 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 ) 10d7b9: 39 f3 cmp %esi,%ebx 10d7bb: 0f 84 17 01 00 00 je 10d8d8 <_Thread_Dispatch+0x15c> 10d7c1: 8d 7d d8 lea -0x28(%ebp),%edi 10d7c4: e9 f5 00 00 00 jmp 10d8be <_Thread_Dispatch+0x142> 10d7c9: 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 ); 10d7cc: 50 push %eax 10d7cd: 9d popf #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ { Timestamp_Control uptime, ran; _TOD_Get_uptime( &uptime ); 10d7ce: 83 ec 0c sub $0xc,%esp 10d7d1: 8d 45 e0 lea -0x20(%ebp),%eax 10d7d4: 50 push %eax 10d7d5: e8 b6 3a 00 00 call 111290 <_TOD_Get_uptime> _Timestamp_Subtract( 10d7da: 83 c4 0c add $0xc,%esp 10d7dd: 57 push %edi 10d7de: 8d 45 e0 lea -0x20(%ebp),%eax 10d7e1: 50 push %eax 10d7e2: 68 68 76 12 00 push $0x127668 10d7e7: e8 2c 0c 00 00 call 10e418 <_Timespec_Subtract> &_Thread_Time_of_last_context_switch, &uptime, &ran ); _Timestamp_Add_to( &executing->cpu_time_used, &ran ); 10d7ec: 58 pop %eax 10d7ed: 5a pop %edx 10d7ee: 57 push %edi 10d7ef: 8d 83 84 00 00 00 lea 0x84(%ebx),%eax 10d7f5: 50 push %eax 10d7f6: e8 e1 0b 00 00 call 10e3dc <_Timespec_Add_to> _Thread_Time_of_last_context_switch = uptime; 10d7fb: 8b 45 e0 mov -0x20(%ebp),%eax 10d7fe: 8b 55 e4 mov -0x1c(%ebp),%edx 10d801: a3 68 76 12 00 mov %eax,0x127668 10d806: 89 15 6c 76 12 00 mov %edx,0x12766c #endif /* * Switch libc's task specific data. */ if ( _Thread_libc_reent ) { 10d80c: a1 40 76 12 00 mov 0x127640,%eax 10d811: 83 c4 10 add $0x10,%esp 10d814: 85 c0 test %eax,%eax 10d816: 74 10 je 10d828 <_Thread_Dispatch+0xac> <== NEVER TAKEN executing->libc_reent = *_Thread_libc_reent; 10d818: 8b 10 mov (%eax),%edx 10d81a: 89 93 e4 00 00 00 mov %edx,0xe4(%ebx) *_Thread_libc_reent = heir->libc_reent; 10d820: 8b 96 e4 00 00 00 mov 0xe4(%esi),%edx 10d826: 89 10 mov %edx,(%eax) } _User_extensions_Thread_switch( executing, heir ); 10d828: 83 ec 08 sub $0x8,%esp 10d82b: 56 push %esi 10d82c: 53 push %ebx 10d82d: e8 86 0e 00 00 call 10e6b8 <_User_extensions_Thread_switch> if ( executing->fp_context != NULL ) _Context_Save_fp( &executing->fp_context ); #endif #endif _Context_Switch( &executing->Registers, &heir->Registers ); 10d832: 5a pop %edx 10d833: 59 pop %ecx 10d834: 81 c6 c8 00 00 00 add $0xc8,%esi 10d83a: 56 push %esi 10d83b: 8d 83 c8 00 00 00 lea 0xc8(%ebx),%eax 10d841: 50 push %eax 10d842: e8 79 11 00 00 call 10e9c0 <_CPU_Context_switch> #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE ) if ( (executing->fp_context != NULL) && 10d847: 83 c4 10 add $0x10,%esp 10d84a: 8b 83 e0 00 00 00 mov 0xe0(%ebx),%eax 10d850: 85 c0 test %eax,%eax 10d852: 74 36 je 10d88a <_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 ); 10d854: a1 00 76 12 00 mov 0x127600,%eax 10d859: 39 c3 cmp %eax,%ebx 10d85b: 74 2d je 10d88a <_Thread_Dispatch+0x10e> !_Thread_Is_allocated_fp( executing ) ) { if ( _Thread_Allocated_fp != NULL ) 10d85d: 85 c0 test %eax,%eax 10d85f: 74 11 je 10d872 <_Thread_Dispatch+0xf6> _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 10d861: 83 ec 0c sub $0xc,%esp 10d864: 05 e0 00 00 00 add $0xe0,%eax 10d869: 50 push %eax 10d86a: e8 85 11 00 00 call 10e9f4 <_CPU_Context_save_fp> 10d86f: 83 c4 10 add $0x10,%esp _Context_Restore_fp( &executing->fp_context ); 10d872: 83 ec 0c sub $0xc,%esp 10d875: 8d 83 e0 00 00 00 lea 0xe0(%ebx),%eax 10d87b: 50 push %eax 10d87c: e8 7d 11 00 00 call 10e9fe <_CPU_Context_restore_fp> _Thread_Allocated_fp = executing; 10d881: 89 1d 00 76 12 00 mov %ebx,0x127600 10d887: 83 c4 10 add $0x10,%esp if ( executing->fp_context != NULL ) _Context_Restore_fp( &executing->fp_context ); #endif #endif executing = _Thread_Executing; 10d88a: 8b 1d 58 7b 12 00 mov 0x127b58,%ebx _ISR_Disable( level ); 10d890: 9c pushf 10d891: fa cli 10d892: 58 pop %eax Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; _ISR_Disable( level ); while ( _Thread_Dispatch_necessary == true ) { 10d893: 8a 15 64 7b 12 00 mov 0x127b64,%dl 10d899: 84 d2 test %dl,%dl 10d89b: 74 3b je 10d8d8 <_Thread_Dispatch+0x15c> heir = _Thread_Heir; 10d89d: 8b 35 5c 7b 12 00 mov 0x127b5c,%esi _Thread_Dispatch_disable_level = 1; 10d8a3: c7 05 70 75 12 00 01 movl $0x1,0x127570 10d8aa: 00 00 00 _Thread_Dispatch_necessary = false; 10d8ad: c6 05 64 7b 12 00 00 movb $0x0,0x127b64 _Thread_Executing = heir; 10d8b4: 89 35 58 7b 12 00 mov %esi,0x127b58 /* * 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 ) 10d8ba: 39 de cmp %ebx,%esi 10d8bc: 74 1a je 10d8d8 <_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 ) 10d8be: 83 7e 7c 01 cmpl $0x1,0x7c(%esi) 10d8c2: 0f 85 04 ff ff ff jne 10d7cc <_Thread_Dispatch+0x50> heir->cpu_time_budget = _Thread_Ticks_per_timeslice; 10d8c8: 8b 15 40 75 12 00 mov 0x127540,%edx 10d8ce: 89 56 78 mov %edx,0x78(%esi) 10d8d1: e9 f6 fe ff ff jmp 10d7cc <_Thread_Dispatch+0x50> 10d8d6: 66 90 xchg %ax,%ax _ISR_Disable( level ); } post_switch: _Thread_Dispatch_disable_level = 0; 10d8d8: c7 05 70 75 12 00 00 movl $0x0,0x127570 10d8df: 00 00 00 _ISR_Enable( level ); 10d8e2: 50 push %eax 10d8e3: 9d popf _API_extensions_Run_postswitch(); 10d8e4: e8 eb e5 ff ff call 10bed4 <_API_extensions_Run_postswitch> } 10d8e9: 8d 65 f4 lea -0xc(%ebp),%esp 10d8ec: 5b pop %ebx 10d8ed: 5e pop %esi 10d8ee: 5f pop %edi 10d8ef: c9 leave 10d8f0: c3 ret =============================================================================== 0010d918 <_Thread_Get>: */ Thread_Control *_Thread_Get ( Objects_Id id, Objects_Locations *location ) { 10d918: 55 push %ebp 10d919: 89 e5 mov %esp,%ebp 10d91b: 53 push %ebx 10d91c: 83 ec 04 sub $0x4,%esp 10d91f: 8b 45 08 mov 0x8(%ebp),%eax 10d922: 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 ) ) { 10d925: 85 c0 test %eax,%eax 10d927: 74 47 je 10d970 <_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); 10d929: 89 c2 mov %eax,%edx 10d92b: c1 ea 18 shr $0x18,%edx 10d92e: 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 ) 10d931: 8d 5a ff lea -0x1(%edx),%ebx 10d934: 83 fb 02 cmp $0x2,%ebx 10d937: 77 27 ja 10d960 <_Thread_Get+0x48> */ RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class( Objects_Id id ) { return (uint32_t) 10d939: 89 c3 mov %eax,%ebx 10d93b: 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 :) */ 10d93e: 4b dec %ebx 10d93f: 75 1f jne 10d960 <_Thread_Get+0x48> *location = OBJECTS_ERROR; goto done; } #endif information = api_information[ the_class ]; 10d941: 8b 14 95 48 75 12 00 mov 0x127548(,%edx,4),%edx 10d948: 8b 52 04 mov 0x4(%edx),%edx if ( !information ) { 10d94b: 85 d2 test %edx,%edx 10d94d: 74 11 je 10d960 <_Thread_Get+0x48> *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 10d94f: 53 push %ebx 10d950: 51 push %ecx 10d951: 50 push %eax 10d952: 52 push %edx 10d953: e8 e8 f4 ff ff call 10ce40 <_Objects_Get> 10d958: 83 c4 10 add $0x10,%esp done: return tp; } 10d95b: 8b 5d fc mov -0x4(%ebp),%ebx 10d95e: c9 leave 10d95f: c3 ret } #endif information = api_information[ the_class ]; if ( !information ) { *location = OBJECTS_ERROR; 10d960: 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; 10d966: 31 c0 xor %eax,%eax tp = (Thread_Control *) _Objects_Get( information, id, location ); done: return tp; } 10d968: 8b 5d fc mov -0x4(%ebp),%ebx 10d96b: c9 leave 10d96c: c3 ret 10d96d: 8d 76 00 lea 0x0(%esi),%esi rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10d970: a1 70 75 12 00 mov 0x127570,%eax 10d975: 40 inc %eax 10d976: a3 70 75 12 00 mov %eax,0x127570 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; 10d97b: c7 01 00 00 00 00 movl $0x0,(%ecx) tp = _Thread_Executing; 10d981: a1 58 7b 12 00 mov 0x127b58,%eax tp = (Thread_Control *) _Objects_Get( information, id, location ); done: return tp; } 10d986: 8b 5d fc mov -0x4(%ebp),%ebx 10d989: c9 leave 10d98a: c3 ret =============================================================================== 0011314c <_Thread_Handler>: * * Output parameters: NONE */ void _Thread_Handler( void ) { 11314c: 55 push %ebp 11314d: 89 e5 mov %esp,%ebp 11314f: 53 push %ebx 113150: 83 ec 14 sub $0x14,%esp #if defined(EXECUTE_GLOBAL_CONSTRUCTORS) static char doneConstructors; char doneCons; #endif executing = _Thread_Executing; 113153: 8b 1d 58 7b 12 00 mov 0x127b58,%ebx /* * have to put level into a register for those cpu's that use * inline asm here */ level = executing->Start.isr_level; 113159: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax _ISR_Set_level(level); 11315f: 85 c0 test %eax,%eax 113161: 74 79 je 1131dc <_Thread_Handler+0x90> 113163: fa cli #if defined(EXECUTE_GLOBAL_CONSTRUCTORS) doneCons = doneConstructors; 113164: a0 ec 71 12 00 mov 0x1271ec,%al 113169: 88 45 f7 mov %al,-0x9(%ebp) doneConstructors = 1; 11316c: c6 05 ec 71 12 00 01 movb $0x1,0x1271ec #endif #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE ) if ( (executing->fp_context != NULL) && 113173: 8b 83 e0 00 00 00 mov 0xe0(%ebx),%eax 113179: 85 c0 test %eax,%eax 11317b: 74 24 je 1131a1 <_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 ); 11317d: a1 00 76 12 00 mov 0x127600,%eax 113182: 39 c3 cmp %eax,%ebx 113184: 74 1b je 1131a1 <_Thread_Handler+0x55> !_Thread_Is_allocated_fp( executing ) ) { if ( _Thread_Allocated_fp != NULL ) 113186: 85 c0 test %eax,%eax 113188: 74 11 je 11319b <_Thread_Handler+0x4f> _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 11318a: 83 ec 0c sub $0xc,%esp 11318d: 05 e0 00 00 00 add $0xe0,%eax 113192: 50 push %eax 113193: e8 5c b8 ff ff call 10e9f4 <_CPU_Context_save_fp> 113198: 83 c4 10 add $0x10,%esp _Thread_Allocated_fp = executing; 11319b: 89 1d 00 76 12 00 mov %ebx,0x127600 /* * 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 ); 1131a1: 83 ec 0c sub $0xc,%esp 1131a4: 53 push %ebx 1131a5: e8 72 b3 ff ff call 10e51c <_User_extensions_Thread_begin> /* * At this point, the dispatch disable level BETTER be 1. */ _Thread_Enable_dispatch(); 1131aa: e8 45 a7 ff ff call 10d8f4 <_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) */ { 1131af: 83 c4 10 add $0x10,%esp 1131b2: 80 7d f7 00 cmpb $0x0,-0x9(%ebp) 1131b6: 74 28 je 1131e0 <_Thread_Handler+0x94> INIT_NAME (); } #endif if ( executing->Start.prototype == THREAD_START_NUMERIC ) { 1131b8: 8b 83 94 00 00 00 mov 0x94(%ebx),%eax 1131be: 85 c0 test %eax,%eax 1131c0: 74 2d je 1131ef <_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 ) { 1131c2: 48 dec %eax 1131c3: 74 43 je 113208 <_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 ); 1131c5: 83 ec 0c sub $0xc,%esp 1131c8: 53 push %ebx 1131c9: e8 8a b3 ff ff call 10e558 <_User_extensions_Thread_exitted> _Internal_error_Occurred( 1131ce: 83 c4 0c add $0xc,%esp 1131d1: 6a 05 push $0x5 1131d3: 6a 01 push $0x1 1131d5: 6a 00 push $0x0 1131d7: e8 1c 97 ff ff call 10c8f8 <_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); 1131dc: fb sti 1131dd: eb 85 jmp 113164 <_Thread_Handler+0x18> 1131df: 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 (); 1131e0: e8 8b be 00 00 call 11f070 <__start_set_sysctl_set> } #endif if ( executing->Start.prototype == THREAD_START_NUMERIC ) { 1131e5: 8b 83 94 00 00 00 mov 0x94(%ebx),%eax 1131eb: 85 c0 test %eax,%eax 1131ed: 75 d3 jne 1131c2 <_Thread_Handler+0x76> executing->Wait.return_argument = (*(Thread_Entry_numeric) executing->Start.entry_point)( 1131ef: 83 ec 0c sub $0xc,%esp 1131f2: ff b3 9c 00 00 00 pushl 0x9c(%ebx) 1131f8: ff 93 90 00 00 00 call *0x90(%ebx) INIT_NAME (); } #endif if ( executing->Start.prototype == THREAD_START_NUMERIC ) { executing->Wait.return_argument = 1131fe: 89 43 28 mov %eax,0x28(%ebx) 113201: 83 c4 10 add $0x10,%esp 113204: eb bf jmp 1131c5 <_Thread_Handler+0x79> 113206: 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)( 113208: 83 ec 0c sub $0xc,%esp 11320b: ff b3 98 00 00 00 pushl 0x98(%ebx) 113211: 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 = 113217: 89 43 28 mov %eax,0x28(%ebx) 11321a: 83 c4 10 add $0x10,%esp 11321d: eb a6 jmp 1131c5 <_Thread_Handler+0x79> =============================================================================== 0010d98c <_Thread_Initialize>: Thread_CPU_budget_algorithms budget_algorithm, Thread_CPU_budget_algorithm_callout budget_callout, uint32_t isr_level, Objects_Name name ) { 10d98c: 55 push %ebp 10d98d: 89 e5 mov %esp,%ebp 10d98f: 57 push %edi 10d990: 56 push %esi 10d991: 53 push %ebx 10d992: 83 ec 1c sub $0x1c,%esp 10d995: 8b 5d 0c mov 0xc(%ebp),%ebx 10d998: 8b 4d 10 mov 0x10(%ebp),%ecx 10d99b: 8b 75 14 mov 0x14(%ebp),%esi 10d99e: 8a 55 18 mov 0x18(%ebp),%dl 10d9a1: 0f b6 7d 20 movzbl 0x20(%ebp),%edi /* * Zero out all the allocated memory fields */ for ( i=0 ; i <= THREAD_API_LAST ; i++ ) the_thread->API_Extensions[i] = NULL; 10d9a5: c7 83 e8 00 00 00 00 movl $0x0,0xe8(%ebx) 10d9ac: 00 00 00 10d9af: c7 83 ec 00 00 00 00 movl $0x0,0xec(%ebx) 10d9b6: 00 00 00 extensions_area = NULL; the_thread->libc_reent = NULL; 10d9b9: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx) 10d9c0: 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 ) { 10d9c3: 85 c9 test %ecx,%ecx 10d9c5: 0f 84 14 02 00 00 je 10dbdf <_Thread_Initialize+0x253> 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; 10d9cb: c6 83 b4 00 00 00 00 movb $0x0,0xb4(%ebx) 10d9d2: 89 f0 mov %esi,%eax Stack_Control *the_stack, void *starting_address, size_t size ) { the_stack->area = starting_address; 10d9d4: 89 8b bc 00 00 00 mov %ecx,0xbc(%ebx) the_stack->size = size; 10d9da: 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 ) { 10d9e0: 84 d2 test %dl,%dl 10d9e2: 0f 85 94 01 00 00 jne 10db7c <_Thread_Initialize+0x1f0> 10d9e8: 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; 10d9ea: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%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; 10d9f1: 89 83 e0 00 00 00 mov %eax,0xe0(%ebx) the_thread->Start.fp_context = fp_area; 10d9f7: 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; 10d9fd: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) the_watchdog->routine = routine; 10da04: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx) the_watchdog->id = id; 10da0b: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx) the_watchdog->user_data = user_data; 10da12: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) #endif /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 10da19: a1 4c 76 12 00 mov 0x12764c,%eax 10da1e: 85 c0 test %eax,%eax 10da20: 0f 85 7a 01 00 00 jne 10dba0 <_Thread_Initialize+0x214> (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) goto failed; } the_thread->extensions = (void **) extensions_area; 10da26: c7 83 f0 00 00 00 00 movl $0x0,0xf0(%ebx) 10da2d: 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; 10da30: 31 f6 xor %esi,%esi /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 10da32: 89 f8 mov %edi,%eax 10da34: 88 83 a0 00 00 00 mov %al,0xa0(%ebx) the_thread->Start.budget_algorithm = budget_algorithm; 10da3a: 8b 45 24 mov 0x24(%ebp),%eax 10da3d: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx) the_thread->Start.budget_callout = budget_callout; 10da43: 8b 45 28 mov 0x28(%ebp),%eax 10da46: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx) switch ( budget_algorithm ) { 10da4c: 83 7d 24 02 cmpl $0x2,0x24(%ebp) 10da50: 75 08 jne 10da5a <_Thread_Initialize+0xce> 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; 10da52: a1 40 75 12 00 mov 0x127540,%eax 10da57: 89 43 78 mov %eax,0x78(%ebx) case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: break; #endif } the_thread->Start.isr_level = isr_level; 10da5a: 8b 45 2c mov 0x2c(%ebp),%eax 10da5d: 89 83 ac 00 00 00 mov %eax,0xac(%ebx) the_thread->current_state = STATES_DORMANT; 10da63: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx) the_thread->Wait.queue = NULL; 10da6a: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) the_thread->resource_count = 0; 10da71: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx) the_thread->real_priority = priority; 10da78: 8b 45 1c mov 0x1c(%ebp),%eax 10da7b: 89 43 18 mov %eax,0x18(%ebx) the_thread->Start.initial_priority = priority; 10da7e: 89 83 b0 00 00 00 mov %eax,0xb0(%ebx) RTEMS_INLINE_ROUTINE void* _Scheduler_Thread_scheduler_allocate( Scheduler_Control *the_scheduler, Thread_Control *the_thread ) { return 10da84: 83 ec 08 sub $0x8,%esp 10da87: 53 push %ebx 10da88: 68 20 76 12 00 push $0x127620 10da8d: ff 15 34 76 12 00 call *0x127634 10da93: 89 c7 mov %eax,%edi sched =_Scheduler_Thread_scheduler_allocate( &_Scheduler, the_thread ); if ( !sched ) 10da95: 83 c4 10 add $0x10,%esp 10da98: 85 c0 test %eax,%eax 10da9a: 74 46 je 10dae2 <_Thread_Initialize+0x156> goto failed; _Thread_Set_priority( the_thread, priority ); 10da9c: 83 ec 08 sub $0x8,%esp 10da9f: ff 75 1c pushl 0x1c(%ebp) 10daa2: 53 push %ebx 10daa3: e8 8c 06 00 00 call 10e134 <_Thread_Set_priority> /* * Initialize the CPU usage statistics */ #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timestamp_Set_to_zero( &the_thread->cpu_time_used ); 10daa8: c7 83 84 00 00 00 00 movl $0x0,0x84(%ebx) 10daaf: 00 00 00 10dab2: c7 83 88 00 00 00 00 movl $0x0,0x88(%ebx) 10dab9: 00 00 00 _Thread_Stack_Free( the_thread ); return false; } 10dabc: 8b 45 08 mov 0x8(%ebp),%eax 10dabf: 8b 40 1c mov 0x1c(%eax),%eax Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 10dac2: 0f b7 53 08 movzwl 0x8(%ebx),%edx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10dac6: 89 1c 90 mov %ebx,(%eax,%edx,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 10dac9: 8b 45 30 mov 0x30(%ebp),%eax 10dacc: 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 ); 10dacf: 89 1c 24 mov %ebx,(%esp) 10dad2: e8 0d 0b 00 00 call 10e5e4 <_User_extensions_Thread_create> if ( extension_status ) 10dad7: 83 c4 10 add $0x10,%esp 10dada: 84 c0 test %al,%al 10dadc: 0f 85 8e 00 00 00 jne 10db70 <_Thread_Initialize+0x1e4> return true; failed: if ( the_thread->libc_reent ) 10dae2: 8b 83 e4 00 00 00 mov 0xe4(%ebx),%eax 10dae8: 85 c0 test %eax,%eax 10daea: 74 0c je 10daf8 <_Thread_Initialize+0x16c> _Workspace_Free( the_thread->libc_reent ); 10daec: 83 ec 0c sub $0xc,%esp 10daef: 50 push %eax 10daf0: e8 87 0e 00 00 call 10e97c <_Workspace_Free> 10daf5: 83 c4 10 add $0x10,%esp for ( i=0 ; i <= THREAD_API_LAST ; i++ ) if ( the_thread->API_Extensions[i] ) 10daf8: 8b 83 e8 00 00 00 mov 0xe8(%ebx),%eax 10dafe: 85 c0 test %eax,%eax 10db00: 74 0c je 10db0e <_Thread_Initialize+0x182> _Workspace_Free( the_thread->API_Extensions[i] ); 10db02: 83 ec 0c sub $0xc,%esp 10db05: 50 push %eax 10db06: e8 71 0e 00 00 call 10e97c <_Workspace_Free> 10db0b: 83 c4 10 add $0x10,%esp failed: if ( the_thread->libc_reent ) _Workspace_Free( the_thread->libc_reent ); for ( i=0 ; i <= THREAD_API_LAST ; i++ ) if ( the_thread->API_Extensions[i] ) 10db0e: 8b 83 ec 00 00 00 mov 0xec(%ebx),%eax 10db14: 85 c0 test %eax,%eax 10db16: 74 0c je 10db24 <_Thread_Initialize+0x198> _Workspace_Free( the_thread->API_Extensions[i] ); 10db18: 83 ec 0c sub $0xc,%esp 10db1b: 50 push %eax 10db1c: e8 5b 0e 00 00 call 10e97c <_Workspace_Free> 10db21: 83 c4 10 add $0x10,%esp if ( extensions_area ) 10db24: 85 f6 test %esi,%esi 10db26: 74 0c je 10db34 <_Thread_Initialize+0x1a8> (void) _Workspace_Free( extensions_area ); 10db28: 83 ec 0c sub $0xc,%esp 10db2b: 56 push %esi 10db2c: e8 4b 0e 00 00 call 10e97c <_Workspace_Free> 10db31: 83 c4 10 add $0x10,%esp #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( fp_area ) 10db34: 8b 45 e4 mov -0x1c(%ebp),%eax 10db37: 85 c0 test %eax,%eax 10db39: 74 0e je 10db49 <_Thread_Initialize+0x1bd> (void) _Workspace_Free( fp_area ); 10db3b: 83 ec 0c sub $0xc,%esp 10db3e: ff 75 e4 pushl -0x1c(%ebp) 10db41: e8 36 0e 00 00 call 10e97c <_Workspace_Free> 10db46: 83 c4 10 add $0x10,%esp #endif if ( sched ) 10db49: 85 ff test %edi,%edi 10db4b: 74 0c je 10db59 <_Thread_Initialize+0x1cd> (void) _Workspace_Free( sched ); 10db4d: 83 ec 0c sub $0xc,%esp 10db50: 57 push %edi 10db51: e8 26 0e 00 00 call 10e97c <_Workspace_Free> 10db56: 83 c4 10 add $0x10,%esp _Thread_Stack_Free( the_thread ); 10db59: 83 ec 0c sub $0xc,%esp 10db5c: 53 push %ebx 10db5d: e8 0a 07 00 00 call 10e26c <_Thread_Stack_Free> return false; 10db62: 83 c4 10 add $0x10,%esp 10db65: 31 c0 xor %eax,%eax } 10db67: 8d 65 f4 lea -0xc(%ebp),%esp 10db6a: 5b pop %ebx 10db6b: 5e pop %esi 10db6c: 5f pop %edi 10db6d: c9 leave 10db6e: c3 ret 10db6f: 90 nop * Mutex provides sufficient protection to let the user extensions * run safely. */ extension_status = _User_extensions_Thread_create( the_thread ); if ( extension_status ) return true; 10db70: b0 01 mov $0x1,%al _Thread_Stack_Free( the_thread ); return false; } 10db72: 8d 65 f4 lea -0xc(%ebp),%esp 10db75: 5b pop %ebx 10db76: 5e pop %esi 10db77: 5f pop %edi 10db78: c9 leave 10db79: c3 ret 10db7a: 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 ); 10db7c: 83 ec 0c sub $0xc,%esp 10db7f: 6a 6c push $0x6c 10db81: e8 da 0d 00 00 call 10e960 <_Workspace_Allocate> 10db86: 89 45 e4 mov %eax,-0x1c(%ebp) if ( !fp_area ) 10db89: 83 c4 10 add $0x10,%esp 10db8c: 85 c0 test %eax,%eax 10db8e: 0f 85 5d fe ff ff jne 10d9f1 <_Thread_Initialize+0x65> * Zero out all the allocated memory fields */ for ( i=0 ; i <= THREAD_API_LAST ; i++ ) the_thread->API_Extensions[i] = NULL; extensions_area = NULL; 10db94: 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; 10db96: 31 ff xor %edi,%edi 10db98: e9 45 ff ff ff jmp 10dae2 <_Thread_Initialize+0x156> 10db9d: 8d 76 00 lea 0x0(%esi),%esi /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { extensions_area = _Workspace_Allocate( 10dba0: 83 ec 0c sub $0xc,%esp 10dba3: 8d 04 85 04 00 00 00 lea 0x4(,%eax,4),%eax 10dbaa: 50 push %eax 10dbab: e8 b0 0d 00 00 call 10e960 <_Workspace_Allocate> 10dbb0: 89 c6 mov %eax,%esi (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) 10dbb2: 83 c4 10 add $0x10,%esp 10dbb5: 85 c0 test %eax,%eax 10dbb7: 74 5a je 10dc13 <_Thread_Initialize+0x287> goto failed; } the_thread->extensions = (void **) extensions_area; 10dbb9: 89 83 f0 00 00 00 mov %eax,0xf0(%ebx) 10dbbf: 8b 0d 4c 76 12 00 mov 0x12764c,%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++ ) 10dbc5: 31 d2 xor %edx,%edx (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) goto failed; } the_thread->extensions = (void **) extensions_area; 10dbc7: 31 c0 xor %eax,%eax 10dbc9: 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; 10dbcc: 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++ ) 10dbd3: 40 inc %eax 10dbd4: 89 c2 mov %eax,%edx 10dbd6: 39 c1 cmp %eax,%ecx 10dbd8: 73 f2 jae 10dbcc <_Thread_Initialize+0x240> 10dbda: e9 53 fe ff ff jmp 10da32 <_Thread_Initialize+0xa6> return false; /* stack allocation failed */ stack = the_thread->Start.stack; #else if ( !stack_area ) { actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size ); 10dbdf: 83 ec 08 sub $0x8,%esp 10dbe2: 56 push %esi 10dbe3: 53 push %ebx 10dbe4: 88 55 e0 mov %dl,-0x20(%ebp) 10dbe7: e8 1c 06 00 00 call 10e208 <_Thread_Stack_Allocate> if ( !actual_stack_size || actual_stack_size < stack_size ) 10dbec: 83 c4 10 add $0x10,%esp 10dbef: 85 c0 test %eax,%eax 10dbf1: 8a 55 e0 mov -0x20(%ebp),%dl 10dbf4: 74 16 je 10dc0c <_Thread_Initialize+0x280> 10dbf6: 39 c6 cmp %eax,%esi 10dbf8: 77 12 ja 10dc0c <_Thread_Initialize+0x280><== NEVER TAKEN return false; /* stack allocation failed */ stack = the_thread->Start.stack; 10dbfa: 8b 8b c4 00 00 00 mov 0xc4(%ebx),%ecx the_thread->Start.core_allocated_stack = true; 10dc00: c6 83 b4 00 00 00 01 movb $0x1,0xb4(%ebx) 10dc07: e9 c8 fd ff ff jmp 10d9d4 <_Thread_Initialize+0x48> 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 */ 10dc0c: 31 c0 xor %eax,%eax 10dc0e: e9 54 ff ff ff jmp 10db67 <_Thread_Initialize+0x1db> 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; 10dc13: 31 ff xor %edi,%edi 10dc15: e9 c8 fe ff ff jmp 10dae2 <_Thread_Initialize+0x156> =============================================================================== 00112610 <_Thread_Reset>: void _Thread_Reset( Thread_Control *the_thread, void *pointer_argument, Thread_Entry_numeric_type numeric_argument ) { 112610: 55 push %ebp 112611: 89 e5 mov %esp,%ebp 112613: 53 push %ebx 112614: 83 ec 10 sub $0x10,%esp 112617: 8b 5d 08 mov 0x8(%ebp),%ebx the_thread->resource_count = 0; 11261a: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx) the_thread->is_preemptible = the_thread->Start.is_preemptible; 112621: 8a 83 a0 00 00 00 mov 0xa0(%ebx),%al 112627: 88 43 74 mov %al,0x74(%ebx) the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 11262a: 8b 83 a4 00 00 00 mov 0xa4(%ebx),%eax 112630: 89 43 7c mov %eax,0x7c(%ebx) the_thread->budget_callout = the_thread->Start.budget_callout; 112633: 8b 83 a8 00 00 00 mov 0xa8(%ebx),%eax 112639: 89 83 80 00 00 00 mov %eax,0x80(%ebx) the_thread->Start.pointer_argument = pointer_argument; 11263f: 8b 45 0c mov 0xc(%ebp),%eax 112642: 89 83 98 00 00 00 mov %eax,0x98(%ebx) the_thread->Start.numeric_argument = numeric_argument; 112648: 8b 45 10 mov 0x10(%ebp),%eax 11264b: 89 83 9c 00 00 00 mov %eax,0x9c(%ebx) if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) { 112651: 53 push %ebx 112652: e8 c5 c4 ff ff call 10eb1c <_Thread_queue_Extract_with_proxy> 112657: 83 c4 10 add $0x10,%esp 11265a: 84 c0 test %al,%al 11265c: 75 06 jne 112664 <_Thread_Reset+0x54> if ( _Watchdog_Is_active( &the_thread->Timer ) ) 11265e: 83 7b 50 02 cmpl $0x2,0x50(%ebx) 112662: 74 28 je 11268c <_Thread_Reset+0x7c> (void) _Watchdog_Remove( &the_thread->Timer ); } if ( the_thread->current_priority != the_thread->Start.initial_priority ) { 112664: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax 11266a: 39 43 14 cmp %eax,0x14(%ebx) 11266d: 74 15 je 112684 <_Thread_Reset+0x74> the_thread->real_priority = the_thread->Start.initial_priority; 11266f: 89 43 18 mov %eax,0x18(%ebx) _Thread_Set_priority( the_thread, the_thread->Start.initial_priority ); 112672: 89 45 0c mov %eax,0xc(%ebp) 112675: 89 5d 08 mov %ebx,0x8(%ebp) } } 112678: 8b 5d fc mov -0x4(%ebp),%ebx 11267b: 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 ); 11267c: e9 77 c6 ff ff jmp 10ecf8 <_Thread_Set_priority> 112681: 8d 76 00 lea 0x0(%esi),%esi } } 112684: 8b 5d fc mov -0x4(%ebp),%ebx 112687: c9 leave 112688: c3 ret 112689: 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 ); 11268c: 83 ec 0c sub $0xc,%esp 11268f: 8d 43 48 lea 0x48(%ebx),%eax 112692: 50 push %eax 112693: e8 a4 cd ff ff call 10f43c <_Watchdog_Remove> 112698: 83 c4 10 add $0x10,%esp 11269b: eb c7 jmp 112664 <_Thread_Reset+0x54> =============================================================================== 0011146c <_Thread_Resume>: void _Thread_Resume( Thread_Control *the_thread, bool force ) { 11146c: 55 push %ebp 11146d: 89 e5 mov %esp,%ebp 11146f: 53 push %ebx 111470: 83 ec 04 sub $0x4,%esp 111473: 8b 45 08 mov 0x8(%ebp),%eax ISR_Level level; States_Control current_state; _ISR_Disable( level ); 111476: 9c pushf 111477: fa cli 111478: 5b pop %ebx current_state = the_thread->current_state; 111479: 8b 50 10 mov 0x10(%eax),%edx if ( current_state & STATES_SUSPENDED ) { 11147c: f6 c2 02 test $0x2,%dl 11147f: 74 0a je 11148b <_Thread_Resume+0x1f> <== NEVER TAKEN 111481: 83 e2 fd and $0xfffffffd,%edx current_state = the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state); 111484: 89 50 10 mov %edx,0x10(%eax) if ( _States_Is_ready( current_state ) ) { 111487: 85 d2 test %edx,%edx 111489: 74 09 je 111494 <_Thread_Resume+0x28> _Scheduler_Unblock( &_Scheduler, the_thread ); } } _ISR_Enable( level ); 11148b: 53 push %ebx 11148c: 9d popf } 11148d: 8b 5d fc mov -0x4(%ebp),%ebx 111490: c9 leave 111491: c3 ret 111492: 66 90 xchg %ax,%ax RTEMS_INLINE_ROUTINE void _Scheduler_Unblock( Scheduler_Control *the_scheduler, Thread_Control *the_thread ) { the_scheduler->Operations.unblock( the_scheduler, the_thread ); 111494: 83 ec 08 sub $0x8,%esp 111497: 50 push %eax 111498: 68 e0 af 12 00 push $0x12afe0 11149d: ff 15 f0 af 12 00 call *0x12aff0 1114a3: 83 c4 10 add $0x10,%esp 1114a6: eb e3 jmp 11148b <_Thread_Resume+0x1f> =============================================================================== 0010e208 <_Thread_Stack_Allocate>: size_t _Thread_Stack_Allocate( Thread_Control *the_thread, size_t stack_size ) { 10e208: 55 push %ebp 10e209: 89 e5 mov %esp,%ebp 10e20b: 53 push %ebx 10e20c: 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; 10e20f: a1 70 32 12 00 mov 0x123270,%eax 10e214: 8b 5d 0c mov 0xc(%ebp),%ebx 10e217: 39 c3 cmp %eax,%ebx 10e219: 73 02 jae 10e21d <_Thread_Stack_Allocate+0x15> 10e21b: 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 ) { 10e21d: a1 a4 32 12 00 mov 0x1232a4,%eax 10e222: 85 c0 test %eax,%eax 10e224: 74 32 je 10e258 <_Thread_Stack_Allocate+0x50> stack_addr = (*Configuration.stack_allocate_hook)( the_stack_size ); 10e226: 83 ec 0c sub $0xc,%esp 10e229: 53 push %ebx 10e22a: ff d0 call *%eax 10e22c: 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 ) 10e22f: 85 c0 test %eax,%eax 10e231: 74 11 je 10e244 <_Thread_Stack_Allocate+0x3c> the_stack_size = 0; the_thread->Start.stack = stack_addr; 10e233: 8b 55 08 mov 0x8(%ebp),%edx 10e236: 89 82 c4 00 00 00 mov %eax,0xc4(%edx) return the_stack_size; } 10e23c: 89 d8 mov %ebx,%eax 10e23e: 8b 5d fc mov -0x4(%ebp),%ebx 10e241: c9 leave 10e242: c3 ret 10e243: 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; 10e244: 31 db xor %ebx,%ebx the_thread->Start.stack = stack_addr; 10e246: 8b 55 08 mov 0x8(%ebp),%edx 10e249: 89 82 c4 00 00 00 mov %eax,0xc4(%edx) return the_stack_size; } 10e24f: 89 d8 mov %ebx,%eax 10e251: 8b 5d fc mov -0x4(%ebp),%ebx 10e254: c9 leave 10e255: c3 ret 10e256: 66 90 xchg %ax,%ax RTEMS_INLINE_ROUTINE uint32_t _Stack_Adjust_size ( size_t size ) { return size + CPU_STACK_ALIGNMENT; 10e258: 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 ); 10e25b: 83 ec 0c sub $0xc,%esp 10e25e: 53 push %ebx 10e25f: e8 fc 06 00 00 call 10e960 <_Workspace_Allocate> 10e264: 83 c4 10 add $0x10,%esp 10e267: eb c6 jmp 10e22f <_Thread_Stack_Allocate+0x27> =============================================================================== 0010e26c <_Thread_Stack_Free>: */ void _Thread_Stack_Free( Thread_Control *the_thread ) { 10e26c: 55 push %ebp 10e26d: 89 e5 mov %esp,%ebp 10e26f: 83 ec 08 sub $0x8,%esp 10e272: 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 ) 10e275: 80 b8 b4 00 00 00 00 cmpb $0x0,0xb4(%eax) 10e27c: 74 16 je 10e294 <_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 ) 10e27e: 8b 15 a8 32 12 00 mov 0x1232a8,%edx 10e284: 85 d2 test %edx,%edx 10e286: 74 10 je 10e298 <_Thread_Stack_Free+0x2c> (*Configuration.stack_free_hook)( the_thread->Start.Initial_stack.area ); 10e288: 8b 80 bc 00 00 00 mov 0xbc(%eax),%eax 10e28e: 89 45 08 mov %eax,0x8(%ebp) else _Workspace_Free( the_thread->Start.Initial_stack.area ); } 10e291: 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 ); 10e292: ff e2 jmp *%edx else _Workspace_Free( the_thread->Start.Initial_stack.area ); } 10e294: c9 leave 10e295: c3 ret 10e296: 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 ); 10e298: 8b 80 bc 00 00 00 mov 0xbc(%eax),%eax 10e29e: 89 45 08 mov %eax,0x8(%ebp) } 10e2a1: 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 ); 10e2a2: e9 d5 06 00 00 jmp 10e97c <_Workspace_Free> =============================================================================== 00111978 <_Thread_Suspend>: */ void _Thread_Suspend( Thread_Control *the_thread ) { 111978: 55 push %ebp 111979: 89 e5 mov %esp,%ebp 11197b: 53 push %ebx 11197c: 83 ec 04 sub $0x4,%esp 11197f: 8b 45 08 mov 0x8(%ebp),%eax ISR_Level level; _ISR_Disable( level ); 111982: 9c pushf 111983: fa cli 111984: 5b pop %ebx if ( !_States_Is_ready( the_thread->current_state ) ) { 111985: 8b 50 10 mov 0x10(%eax),%edx 111988: 85 d2 test %edx,%edx 11198a: 74 10 je 11199c <_Thread_Suspend+0x24> 11198c: 83 ca 02 or $0x2,%edx 11198f: 89 50 10 mov %edx,0x10(%eax) the_thread->current_state = _States_Set( STATES_SUSPENDED, the_thread->current_state ); _ISR_Enable( level ); 111992: 53 push %ebx 111993: 9d popf the_thread->current_state = STATES_SUSPENDED; _Scheduler_Block(&_Scheduler, the_thread); _ISR_Enable( level ); } 111994: 8b 5d fc mov -0x4(%ebp),%ebx 111997: c9 leave 111998: c3 ret 111999: 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; 11199c: c7 40 10 02 00 00 00 movl $0x2,0x10(%eax) RTEMS_INLINE_ROUTINE void _Scheduler_Block( Scheduler_Control *the_scheduler, Thread_Control *the_thread ) { the_scheduler->Operations.block( the_scheduler, the_thread ); 1119a3: 83 ec 08 sub $0x8,%esp 1119a6: 50 push %eax 1119a7: 68 20 76 12 00 push $0x127620 1119ac: ff 15 2c 76 12 00 call *0x12762c _Scheduler_Block(&_Scheduler, the_thread); _ISR_Enable( level ); 1119b2: 53 push %ebx 1119b3: 9d popf 1119b4: 83 c4 10 add $0x10,%esp } 1119b7: 8b 5d fc mov -0x4(%ebp),%ebx 1119ba: c9 leave 1119bb: c3 ret =============================================================================== 0010e364 <_Thread_Tickle_timeslice>: * * Output parameters: NONE */ void _Thread_Tickle_timeslice( void ) { 10e364: 55 push %ebp 10e365: 89 e5 mov %esp,%ebp 10e367: 53 push %ebx 10e368: 83 ec 04 sub $0x4,%esp Thread_Control *executing; executing = _Thread_Executing; 10e36b: 8b 1d 58 7b 12 00 mov 0x127b58,%ebx /* * If the thread is not preemptible or is not ready, then * just return. */ if ( !executing->is_preemptible ) 10e371: 80 7b 74 00 cmpb $0x0,0x74(%ebx) 10e375: 74 19 je 10e390 <_Thread_Tickle_timeslice+0x2c> return; if ( !_States_Is_ready( executing->current_state ) ) 10e377: 8b 43 10 mov 0x10(%ebx),%eax 10e37a: 85 c0 test %eax,%eax 10e37c: 75 12 jne 10e390 <_Thread_Tickle_timeslice+0x2c> /* * The cpu budget algorithm determines what happens next. */ switch ( executing->budget_algorithm ) { 10e37e: 8b 43 7c mov 0x7c(%ebx),%eax 10e381: 83 f8 01 cmp $0x1,%eax 10e384: 72 0a jb 10e390 <_Thread_Tickle_timeslice+0x2c> 10e386: 83 f8 02 cmp $0x2,%eax 10e389: 76 29 jbe 10e3b4 <_Thread_Tickle_timeslice+0x50> 10e38b: 83 f8 03 cmp $0x3,%eax 10e38e: 74 08 je 10e398 <_Thread_Tickle_timeslice+0x34><== ALWAYS TAKEN if ( --executing->cpu_time_budget == 0 ) (*executing->budget_callout)( executing ); break; #endif } } 10e390: 8b 5d fc mov -0x4(%ebp),%ebx 10e393: c9 leave 10e394: c3 ret 10e395: 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 ) 10e398: 8b 43 78 mov 0x78(%ebx),%eax 10e39b: 48 dec %eax 10e39c: 89 43 78 mov %eax,0x78(%ebx) 10e39f: 85 c0 test %eax,%eax 10e3a1: 75 ed jne 10e390 <_Thread_Tickle_timeslice+0x2c> (*executing->budget_callout)( executing ); 10e3a3: 83 ec 0c sub $0xc,%esp 10e3a6: 53 push %ebx 10e3a7: ff 93 80 00 00 00 call *0x80(%ebx) 10e3ad: 83 c4 10 add $0x10,%esp 10e3b0: eb de jmp 10e390 <_Thread_Tickle_timeslice+0x2c> 10e3b2: 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 ) { 10e3b4: 8b 43 78 mov 0x78(%ebx),%eax 10e3b7: 48 dec %eax 10e3b8: 89 43 78 mov %eax,0x78(%ebx) 10e3bb: 85 c0 test %eax,%eax 10e3bd: 7f d1 jg 10e390 <_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( &_Scheduler ); 10e3bf: 83 ec 0c sub $0xc,%esp 10e3c2: 68 20 76 12 00 push $0x127620 10e3c7: ff 15 28 76 12 00 call *0x127628 * 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; 10e3cd: a1 40 75 12 00 mov 0x127540,%eax 10e3d2: 89 43 78 mov %eax,0x78(%ebx) 10e3d5: 83 c4 10 add $0x10,%esp 10e3d8: eb b6 jmp 10e390 <_Thread_Tickle_timeslice+0x2c> =============================================================================== 0010dcf4 <_Thread_queue_Dequeue_priority>: */ Thread_Control *_Thread_queue_Dequeue_priority( Thread_queue_Control *the_thread_queue ) { 10dcf4: 55 push %ebp 10dcf5: 89 e5 mov %esp,%ebp 10dcf7: 57 push %edi 10dcf8: 56 push %esi 10dcf9: 53 push %ebx 10dcfa: 83 ec 2c sub $0x2c,%esp 10dcfd: 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 ); 10dd00: 9c pushf 10dd01: fa cli 10dd02: 58 pop %eax 10dd03: 89 f9 mov %edi,%ecx for( index=0 ; 10dd05: 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 ); } 10dd07: 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 ); 10dd09: 8d 34 52 lea (%edx,%edx,2),%esi 10dd0c: 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 ] ) ) { 10dd10: 39 f3 cmp %esi,%ebx 10dd12: 75 18 jne 10dd2c <_Thread_queue_Dequeue_priority+0x38> Chain_Node *previous_node; _ISR_Disable( level ); for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { 10dd14: 42 inc %edx 10dd15: 83 c1 0c add $0xc,%ecx Chain_Node *last_node; Chain_Node *next_node; Chain_Node *previous_node; _ISR_Disable( level ); for( index=0 ; 10dd18: 83 fa 04 cmp $0x4,%edx 10dd1b: 75 ea jne 10dd07 <_Thread_queue_Dequeue_priority+0x13> } /* * We did not find a thread to unblock. */ _ISR_Enable( level ); 10dd1d: 50 push %eax 10dd1e: 9d popf return NULL; 10dd1f: 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 ); } 10dd21: 89 f0 mov %esi,%eax 10dd23: 8d 65 f4 lea -0xc(%ebp),%esp 10dd26: 5b pop %ebx 10dd27: 5e pop %esi 10dd28: 5f pop %edi 10dd29: c9 leave 10dd2a: c3 ret 10dd2b: 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( 10dd2c: 89 de mov %ebx,%esi */ _ISR_Enable( level ); return NULL; dequeue: the_thread->Wait.queue = NULL; 10dd2e: 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 ); } 10dd35: 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; 10dd38: 8b 0b mov (%ebx),%ecx previous_node = the_thread->Object.Node.previous; 10dd3a: 8b 7b 04 mov 0x4(%ebx),%edi 10dd3d: 89 7d d4 mov %edi,-0x2c(%ebp) 10dd40: 8d 7b 3c lea 0x3c(%ebx),%edi if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 10dd43: 39 fa cmp %edi,%edx 10dd45: 74 7f je 10ddc6 <_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 ); } 10dd47: 8b 7b 40 mov 0x40(%ebx),%edi 10dd4a: 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; 10dd4d: 8b 3a mov (%edx),%edi 10dd4f: 89 7d e0 mov %edi,-0x20(%ebp) previous_node->next = new_first_node; 10dd52: 8b 7d d4 mov -0x2c(%ebp),%edi 10dd55: 89 17 mov %edx,(%edi) next_node->previous = new_first_node; 10dd57: 89 51 04 mov %edx,0x4(%ecx) new_first_node->next = next_node; 10dd5a: 89 0a mov %ecx,(%edx) new_first_node->previous = previous_node; 10dd5c: 89 7a 04 mov %edi,0x4(%edx) if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 10dd5f: 8b 4b 40 mov 0x40(%ebx),%ecx 10dd62: 39 4b 38 cmp %ecx,0x38(%ebx) 10dd65: 74 17 je 10dd7e <_Thread_queue_Dequeue_priority+0x8a> /* > two threads on 2-n */ head = _Chain_Head( &new_first_thread->Wait.Block2n ); 10dd67: 8d 4a 38 lea 0x38(%edx),%ecx 10dd6a: 8b 7d e0 mov -0x20(%ebp),%edi 10dd6d: 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; 10dd70: 89 7a 38 mov %edi,0x38(%edx) tail->previous = last_node; 10dd73: 8b 4d e4 mov -0x1c(%ebp),%ecx 10dd76: 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 ); 10dd79: 83 c2 3c add $0x3c,%edx 10dd7c: 89 11 mov %edx,(%ecx) } else { previous_node->next = next_node; next_node->previous = previous_node; } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 10dd7e: 83 7b 50 02 cmpl $0x2,0x50(%ebx) 10dd82: 74 18 je 10dd9c <_Thread_queue_Dequeue_priority+0xa8> _ISR_Enable( level ); 10dd84: 50 push %eax 10dd85: 9d popf RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 10dd86: 83 ec 08 sub $0x8,%esp 10dd89: 68 f8 ff 03 10 push $0x1003fff8 10dd8e: 53 push %ebx 10dd8f: e8 e0 f7 ff ff call 10d574 <_Thread_Clear_state> 10dd94: 83 c4 10 add $0x10,%esp 10dd97: eb 88 jmp 10dd21 <_Thread_queue_Dequeue_priority+0x2d> 10dd99: 8d 76 00 lea 0x0(%esi),%esi RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 10dd9c: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 10dda3: 50 push %eax 10dda4: 9d popf (void) _Watchdog_Remove( &the_thread->Timer ); 10dda5: 83 ec 0c sub $0xc,%esp 10dda8: 8d 43 48 lea 0x48(%ebx),%eax 10ddab: 50 push %eax 10ddac: e8 87 0a 00 00 call 10e838 <_Watchdog_Remove> 10ddb1: 58 pop %eax 10ddb2: 5a pop %edx 10ddb3: 68 f8 ff 03 10 push $0x1003fff8 10ddb8: 53 push %ebx 10ddb9: e8 b6 f7 ff ff call 10d574 <_Thread_Clear_state> 10ddbe: 83 c4 10 add $0x10,%esp 10ddc1: e9 5b ff ff ff jmp 10dd21 <_Thread_queue_Dequeue_priority+0x2d> head->next = new_second_node; tail->previous = last_node; last_node->next = tail; } } else { previous_node->next = next_node; 10ddc6: 8b 7d d4 mov -0x2c(%ebp),%edi 10ddc9: 89 0f mov %ecx,(%edi) next_node->previous = previous_node; 10ddcb: 89 79 04 mov %edi,0x4(%ecx) 10ddce: eb ae jmp 10dd7e <_Thread_queue_Dequeue_priority+0x8a> =============================================================================== 0010de68 <_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 ) { 10de68: 55 push %ebp 10de69: 89 e5 mov %esp,%ebp 10de6b: 57 push %edi 10de6c: 56 push %esi 10de6d: 53 push %ebx 10de6e: 83 ec 0c sub $0xc,%esp 10de71: 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 ); 10de74: 8d 47 3c lea 0x3c(%edi),%eax 10de77: 89 47 38 mov %eax,0x38(%edi) head->next = tail; head->previous = NULL; 10de7a: 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 ); 10de81: 8d 47 38 lea 0x38(%edi),%eax 10de84: 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; 10de87: 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); 10de8a: 89 d0 mov %edx,%eax 10de8c: 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; 10de8f: 8b 4d 08 mov 0x8(%ebp),%ecx 10de92: 8b 59 38 mov 0x38(%ecx),%ebx if ( _Thread_queue_Is_reverse_search( priority ) ) 10de95: f6 c2 20 test $0x20,%dl 10de98: 75 66 jne 10df00 <_Thread_queue_Enqueue_priority+0x98> * * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; } 10de9a: 8d 04 40 lea (%eax,%eax,2),%eax 10de9d: 8d 04 81 lea (%ecx,%eax,4),%eax 10dea0: 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)); 10dea3: 83 c0 04 add $0x4,%eax 10dea6: 89 7d e8 mov %edi,-0x18(%ebp) 10dea9: 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 ); 10deab: 9c pushf 10deac: fa cli 10dead: 5e pop %esi 10deae: 89 75 ec mov %esi,-0x14(%ebp) * * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; } 10deb1: 8b 4d f0 mov -0x10(%ebp),%ecx 10deb4: 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 ) ) { 10deb6: 39 f8 cmp %edi,%eax 10deb8: 75 18 jne 10ded2 <_Thread_queue_Enqueue_priority+0x6a> 10deba: e9 0e 01 00 00 jmp 10dfcd <_Thread_queue_Enqueue_priority+0x165> 10debf: 90 nop break; search_priority = search_thread->current_priority; if ( priority <= search_priority ) break; #endif _ISR_Flash( level ); 10dec0: 56 push %esi 10dec1: 9d popf 10dec2: fa cli if ( !_States_Are_set( search_thread->current_state, block_state) ) { 10dec3: 85 58 10 test %ebx,0x10(%eax) 10dec6: 0f 84 ac 00 00 00 je 10df78 <_Thread_queue_Enqueue_priority+0x110><== NEVER TAKEN _ISR_Enable( level ); goto restart_forward_search; } search_thread = (Thread_Control *)search_thread->Object.Node.next; 10decc: 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 ) ) { 10dece: 39 f8 cmp %edi,%eax 10ded0: 74 07 je 10ded9 <_Thread_queue_Enqueue_priority+0x71> search_priority = search_thread->current_priority; 10ded2: 8b 48 14 mov 0x14(%eax),%ecx if ( priority <= search_priority ) 10ded5: 39 ca cmp %ecx,%edx 10ded7: 77 e7 ja 10dec0 <_Thread_queue_Enqueue_priority+0x58> 10ded9: 8b 7d e8 mov -0x18(%ebp),%edi 10dedc: 89 75 f0 mov %esi,-0x10(%ebp) } search_thread = (Thread_Control *)search_thread->Object.Node.next; } if ( the_thread_queue->sync_state != 10dedf: 8b 75 08 mov 0x8(%ebp),%esi 10dee2: 8b 5e 30 mov 0x30(%esi),%ebx 10dee5: 83 fb 01 cmp $0x1,%ebx 10dee8: 0f 84 92 00 00 00 je 10df80 <_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; 10deee: 8b 45 10 mov 0x10(%ebp),%eax 10def1: 8b 55 ec mov -0x14(%ebp),%edx 10def4: 89 10 mov %edx,(%eax) return the_thread_queue->sync_state; } 10def6: 89 d8 mov %ebx,%eax 10def8: 83 c4 0c add $0xc,%esp 10defb: 5b pop %ebx 10defc: 5e pop %esi 10defd: 5f pop %edi 10defe: c9 leave 10deff: c3 ret 10df00: 8d 04 40 lea (%eax,%eax,2),%eax 10df03: 8b 4d 08 mov 0x8(%ebp),%ecx 10df06: 8d 34 81 lea (%ecx,%eax,4),%esi 10df09: 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; 10df0c: 0f b6 0d 74 32 12 00 movzbl 0x123274,%ecx 10df13: 41 inc %ecx _ISR_Disable( level ); 10df14: 9c pushf 10df15: fa cli 10df16: 5f pop %edi 10df17: 89 7d ec mov %edi,-0x14(%ebp) * * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; } 10df1a: 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 ) ) { 10df1d: 39 f0 cmp %esi,%eax 10df1f: 75 12 jne 10df33 <_Thread_queue_Enqueue_priority+0xcb> 10df21: eb 17 jmp 10df3a <_Thread_queue_Enqueue_priority+0xd2> 10df23: 90 nop break; search_priority = search_thread->current_priority; if ( priority >= search_priority ) break; #endif _ISR_Flash( level ); 10df24: 57 push %edi 10df25: 9d popf 10df26: fa cli if ( !_States_Are_set( search_thread->current_state, block_state) ) { 10df27: 85 58 10 test %ebx,0x10(%eax) 10df2a: 74 48 je 10df74 <_Thread_queue_Enqueue_priority+0x10c> _ISR_Enable( level ); goto restart_reverse_search; } search_thread = (Thread_Control *) search_thread->Object.Node.previous; 10df2c: 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 ) ) { 10df2f: 39 f0 cmp %esi,%eax 10df31: 74 07 je 10df3a <_Thread_queue_Enqueue_priority+0xd2> search_priority = search_thread->current_priority; 10df33: 8b 48 14 mov 0x14(%eax),%ecx if ( priority >= search_priority ) 10df36: 39 ca cmp %ecx,%edx 10df38: 72 ea jb 10df24 <_Thread_queue_Enqueue_priority+0xbc> 10df3a: 89 7d e8 mov %edi,-0x18(%ebp) 10df3d: 8b 7d f0 mov -0x10(%ebp),%edi } search_thread = (Thread_Control *) search_thread->Object.Node.previous; } if ( the_thread_queue->sync_state != 10df40: 8b 75 08 mov 0x8(%ebp),%esi 10df43: 8b 5e 30 mov 0x30(%esi),%ebx 10df46: 83 fb 01 cmp $0x1,%ebx 10df49: 75 a3 jne 10deee <_Thread_queue_Enqueue_priority+0x86> THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10df4b: c7 46 30 00 00 00 00 movl $0x0,0x30(%esi) if ( priority == search_priority ) 10df52: 39 ca cmp %ecx,%edx 10df54: 74 53 je 10dfa9 <_Thread_queue_Enqueue_priority+0x141> goto equal_priority; search_node = (Chain_Node *) search_thread; next_node = search_node->next; 10df56: 8b 10 mov (%eax),%edx the_node = (Chain_Node *) the_thread; the_node->next = next_node; 10df58: 89 17 mov %edx,(%edi) the_node->previous = search_node; 10df5a: 89 47 04 mov %eax,0x4(%edi) search_node->next = the_node; 10df5d: 89 38 mov %edi,(%eax) next_node->previous = the_node; 10df5f: 89 7a 04 mov %edi,0x4(%edx) the_thread->Wait.queue = the_thread_queue; 10df62: 89 77 44 mov %esi,0x44(%edi) _ISR_Enable( level ); 10df65: ff 75 e8 pushl -0x18(%ebp) 10df68: 9d popf * * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; } 10df69: 89 d8 mov %ebx,%eax 10df6b: 83 c4 0c add $0xc,%esp 10df6e: 5b pop %ebx 10df6f: 5e pop %esi 10df70: 5f pop %edi 10df71: c9 leave 10df72: c3 ret 10df73: 90 nop if ( priority >= search_priority ) break; #endif _ISR_Flash( level ); if ( !_States_Are_set( search_thread->current_state, block_state) ) { _ISR_Enable( level ); 10df74: 57 push %edi 10df75: 9d popf goto restart_reverse_search; 10df76: eb 94 jmp 10df0c <_Thread_queue_Enqueue_priority+0xa4> if ( priority <= search_priority ) break; #endif _ISR_Flash( level ); if ( !_States_Are_set( search_thread->current_state, block_state) ) { _ISR_Enable( level ); 10df78: 56 push %esi <== NOT EXECUTED 10df79: 9d popf <== NOT EXECUTED goto restart_forward_search; 10df7a: e9 2c ff ff ff jmp 10deab <_Thread_queue_Enqueue_priority+0x43><== NOT EXECUTED 10df7f: 90 nop <== NOT EXECUTED if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10df80: c7 46 30 00 00 00 00 movl $0x0,0x30(%esi) if ( priority == search_priority ) 10df87: 39 ca cmp %ecx,%edx 10df89: 74 1e je 10dfa9 <_Thread_queue_Enqueue_priority+0x141> goto equal_priority; search_node = (Chain_Node *) search_thread; previous_node = search_node->previous; 10df8b: 8b 50 04 mov 0x4(%eax),%edx the_node = (Chain_Node *) the_thread; the_node->next = search_node; 10df8e: 89 07 mov %eax,(%edi) the_node->previous = previous_node; 10df90: 89 57 04 mov %edx,0x4(%edi) previous_node->next = the_node; 10df93: 89 3a mov %edi,(%edx) search_node->previous = the_node; 10df95: 89 78 04 mov %edi,0x4(%eax) the_thread->Wait.queue = the_thread_queue; 10df98: 89 77 44 mov %esi,0x44(%edi) _ISR_Enable( level ); 10df9b: ff 75 f0 pushl -0x10(%ebp) 10df9e: 9d popf * * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; } 10df9f: 89 d8 mov %ebx,%eax 10dfa1: 83 c4 0c add $0xc,%esp 10dfa4: 5b pop %ebx 10dfa5: 5e pop %esi 10dfa6: 5f pop %edi 10dfa7: c9 leave 10dfa8: 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; 10dfa9: 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 ); 10dfac: 8d 48 3c lea 0x3c(%eax),%ecx 10dfaf: 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; 10dfb1: 89 57 04 mov %edx,0x4(%edi) previous_node->next = the_node; 10dfb4: 89 3a mov %edi,(%edx) search_node->previous = the_node; 10dfb6: 89 78 40 mov %edi,0x40(%eax) the_thread->Wait.queue = the_thread_queue; 10dfb9: 8b 45 08 mov 0x8(%ebp),%eax 10dfbc: 89 47 44 mov %eax,0x44(%edi) _ISR_Enable( level ); 10dfbf: ff 75 ec pushl -0x14(%ebp) 10dfc2: 9d popf return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 10dfc3: bb 01 00 00 00 mov $0x1,%ebx 10dfc8: e9 29 ff ff ff jmp 10def6 <_Thread_queue_Enqueue_priority+0x8e> 10dfcd: 8b 7d e8 mov -0x18(%ebp),%edi 10dfd0: 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; 10dfd3: b9 ff ff ff ff mov $0xffffffff,%ecx 10dfd8: e9 02 ff ff ff jmp 10dedf <_Thread_queue_Enqueue_priority+0x77> =============================================================================== 0011181c <_Thread_queue_Extract>: void _Thread_queue_Extract( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 11181c: 55 push %ebp 11181d: 89 e5 mov %esp,%ebp 11181f: 83 ec 08 sub $0x8,%esp 111822: 8b 45 08 mov 0x8(%ebp),%eax 111825: 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 ) 111828: 83 78 34 01 cmpl $0x1,0x34(%eax) 11182c: 74 0e je 11183c <_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 ); 11182e: 89 55 0c mov %edx,0xc(%ebp) 111831: 89 45 08 mov %eax,0x8(%ebp) } 111834: 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 ); 111835: e9 e6 19 00 00 jmp 113220 <_Thread_queue_Extract_fifo> 11183a: 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 ); 11183c: 51 push %ecx 11183d: 6a 00 push $0x0 11183f: 52 push %edx 111840: 50 push %eax 111841: e8 06 00 00 00 call 11184c <_Thread_queue_Extract_priority_helper> 111846: 83 c4 10 add $0x10,%esp else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ _Thread_queue_Extract_fifo( the_thread_queue, the_thread ); } 111849: c9 leave 11184a: c3 ret =============================================================================== 00113220 <_Thread_queue_Extract_fifo>: void _Thread_queue_Extract_fifo( Thread_queue_Control *the_thread_queue __attribute__((unused)), Thread_Control *the_thread ) { 113220: 55 push %ebp 113221: 89 e5 mov %esp,%ebp 113223: 53 push %ebx 113224: 83 ec 04 sub $0x4,%esp 113227: 8b 5d 0c mov 0xc(%ebp),%ebx ISR_Level level; _ISR_Disable( level ); 11322a: 9c pushf 11322b: fa cli 11322c: 58 pop %eax if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 11322d: f7 43 10 e0 be 03 00 testl $0x3bee0,0x10(%ebx) 113234: 74 2e je 113264 <_Thread_queue_Extract_fifo+0x44> ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 113236: 8b 0b mov (%ebx),%ecx previous = the_node->previous; 113238: 8b 53 04 mov 0x4(%ebx),%edx next->previous = previous; 11323b: 89 51 04 mov %edx,0x4(%ecx) previous->next = next; 11323e: 89 0a mov %ecx,(%edx) return; } _Chain_Extract_unprotected( &the_thread->Object.Node ); the_thread->Wait.queue = NULL; 113240: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 113247: 83 7b 50 02 cmpl $0x2,0x50(%ebx) 11324b: 74 1f je 11326c <_Thread_queue_Extract_fifo+0x4c> _ISR_Enable( level ); 11324d: 50 push %eax 11324e: 9d popf RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 11324f: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp) 113256: 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 } 113259: 8b 5d fc mov -0x4(%ebp),%ebx 11325c: c9 leave 11325d: e9 12 a3 ff ff jmp 10d574 <_Thread_Clear_state> 113262: 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 ); 113264: 50 push %eax 113265: 9d popf #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 113266: 8b 5d fc mov -0x4(%ebp),%ebx 113269: c9 leave 11326a: c3 ret 11326b: 90 nop 11326c: 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 ); 113273: 50 push %eax 113274: 9d popf (void) _Watchdog_Remove( &the_thread->Timer ); 113275: 83 ec 0c sub $0xc,%esp 113278: 8d 43 48 lea 0x48(%ebx),%eax 11327b: 50 push %eax 11327c: e8 b7 b5 ff ff call 10e838 <_Watchdog_Remove> 113281: 83 c4 10 add $0x10,%esp 113284: eb c9 jmp 11324f <_Thread_queue_Extract_fifo+0x2f> =============================================================================== 0011184c <_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 ) { 11184c: 55 push %ebp 11184d: 89 e5 mov %esp,%ebp 11184f: 57 push %edi 111850: 56 push %esi 111851: 53 push %ebx 111852: 83 ec 1c sub $0x1c,%esp 111855: 8b 5d 0c mov 0xc(%ebp),%ebx 111858: 8a 45 10 mov 0x10(%ebp),%al 11185b: 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 ); 11185e: 9c pushf 11185f: fa cli 111860: 8f 45 e4 popl -0x1c(%ebp) if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 111863: f7 43 10 e0 be 03 00 testl $0x3bee0,0x10(%ebx) 11186a: 74 6c je 1118d8 <_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; 11186c: 8b 13 mov (%ebx),%edx previous_node = the_node->previous; 11186e: 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 } 111871: 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 ); 111874: 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 ) ) { 111877: 39 f0 cmp %esi,%eax 111879: 74 69 je 1118e4 <_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 } 11187b: 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; 11187e: 8b 30 mov (%eax),%esi previous_node->next = new_first_node; 111880: 89 01 mov %eax,(%ecx) next_node->previous = new_first_node; 111882: 89 42 04 mov %eax,0x4(%edx) new_first_node->next = next_node; 111885: 89 10 mov %edx,(%eax) new_first_node->previous = previous_node; 111887: 89 48 04 mov %ecx,0x4(%eax) if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 11188a: 8b 53 40 mov 0x40(%ebx),%edx 11188d: 39 53 38 cmp %edx,0x38(%ebx) 111890: 74 11 je 1118a3 <_Thread_queue_Extract_priority_helper+0x57> /* > two threads on 2-n */ head = _Chain_Head( &new_first_thread->Wait.Block2n ); 111892: 8d 50 38 lea 0x38(%eax),%edx 111895: 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; 111898: 89 70 38 mov %esi,0x38(%eax) tail->previous = last_node; 11189b: 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 ); 11189e: 83 c0 3c add $0x3c,%eax 1118a1: 89 07 mov %eax,(%edi) /* * If we are not supposed to touch timers or the thread's state, return. */ if ( requeuing ) { 1118a3: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp) 1118a7: 75 23 jne 1118cc <_Thread_queue_Extract_priority_helper+0x80> _ISR_Enable( level ); return; } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 1118a9: 83 7b 50 02 cmpl $0x2,0x50(%ebx) 1118ad: 74 3d je 1118ec <_Thread_queue_Extract_priority_helper+0xa0> _ISR_Enable( level ); 1118af: ff 75 e4 pushl -0x1c(%ebp) 1118b2: 9d popf 1118b3: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp) 1118ba: 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 } 1118bd: 8d 65 f4 lea -0xc(%ebp),%esp 1118c0: 5b pop %ebx 1118c1: 5e pop %esi 1118c2: 5f pop %edi 1118c3: c9 leave 1118c4: e9 ab bc ff ff jmp 10d574 <_Thread_Clear_state> 1118c9: 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 ); 1118cc: ff 75 e4 pushl -0x1c(%ebp) 1118cf: 9d popf #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 1118d0: 8d 65 f4 lea -0xc(%ebp),%esp 1118d3: 5b pop %ebx 1118d4: 5e pop %esi 1118d5: 5f pop %edi 1118d6: c9 leave 1118d7: 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 ); 1118d8: ff 75 e4 pushl -0x1c(%ebp) 1118db: 9d popf #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 1118dc: 8d 65 f4 lea -0xc(%ebp),%esp 1118df: 5b pop %ebx 1118e0: 5e pop %esi 1118e1: 5f pop %edi 1118e2: c9 leave 1118e3: c3 ret head->next = new_second_node; tail->previous = last_node; last_node->next = tail; } } else { previous_node->next = next_node; 1118e4: 89 11 mov %edx,(%ecx) next_node->previous = previous_node; 1118e6: 89 4a 04 mov %ecx,0x4(%edx) 1118e9: eb b8 jmp 1118a3 <_Thread_queue_Extract_priority_helper+0x57> 1118eb: 90 nop 1118ec: 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 ); 1118f3: ff 75 e4 pushl -0x1c(%ebp) 1118f6: 9d popf (void) _Watchdog_Remove( &the_thread->Timer ); 1118f7: 83 ec 0c sub $0xc,%esp 1118fa: 8d 43 48 lea 0x48(%ebx),%eax 1118fd: 50 push %eax 1118fe: e8 35 cf ff ff call 10e838 <_Watchdog_Remove> 111903: 83 c4 10 add $0x10,%esp 111906: eb ab jmp 1118b3 <_Thread_queue_Extract_priority_helper+0x67> =============================================================================== 0010dfe0 <_Thread_queue_Extract_with_proxy>: */ bool _Thread_queue_Extract_with_proxy( Thread_Control *the_thread ) { 10dfe0: 55 push %ebp 10dfe1: 89 e5 mov %esp,%ebp 10dfe3: 83 ec 08 sub $0x8,%esp 10dfe6: 8b 45 08 mov 0x8(%ebp),%eax States_Control state; state = the_thread->current_state; if ( _States_Is_waiting_on_thread_queue( state ) ) { 10dfe9: f7 40 10 e0 be 03 00 testl $0x3bee0,0x10(%eax) 10dff0: 75 06 jne 10dff8 <_Thread_queue_Extract_with_proxy+0x18> #endif _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); return true; } return false; 10dff2: 31 c0 xor %eax,%eax } 10dff4: c9 leave 10dff5: c3 ret 10dff6: 66 90 xchg %ax,%ax if ( proxy_extract_callout ) (*proxy_extract_callout)( the_thread ); } #endif _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 10dff8: 83 ec 08 sub $0x8,%esp 10dffb: 50 push %eax 10dffc: ff 70 44 pushl 0x44(%eax) 10dfff: e8 18 38 00 00 call 11181c <_Thread_queue_Extract> return true; 10e004: 83 c4 10 add $0x10,%esp 10e007: b0 01 mov $0x1,%al } return false; } 10e009: c9 leave 10e00a: c3 ret =============================================================================== 0010fe38 <_Thread_queue_First>: */ Thread_Control *_Thread_queue_First( Thread_queue_Control *the_thread_queue ) { 10fe38: 55 push %ebp 10fe39: 89 e5 mov %esp,%ebp 10fe3b: 83 ec 08 sub $0x8,%esp 10fe3e: 8b 45 08 mov 0x8(%ebp),%eax Thread_Control * (*first_p)(Thread_queue_Control *); if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) 10fe41: 83 78 34 01 cmpl $0x1,0x34(%eax) 10fe45: 74 0d je 10fe54 <_Thread_queue_First+0x1c> first_p = _Thread_queue_First_priority; else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ first_p = _Thread_queue_First_fifo; 10fe47: ba b0 37 11 00 mov $0x1137b0,%edx return (*first_p)( the_thread_queue ); 10fe4c: 89 45 08 mov %eax,0x8(%ebp) } 10fe4f: 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 ); 10fe50: ff e2 jmp *%edx 10fe52: 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; 10fe54: ba 60 fe 10 00 mov $0x10fe60,%edx else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ first_p = _Thread_queue_First_fifo; return (*first_p)( the_thread_queue ); 10fe59: 89 45 08 mov %eax,0x8(%ebp) } 10fe5c: 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 ); 10fe5d: ff e2 jmp *%edx =============================================================================== 001137b0 <_Thread_queue_First_fifo>: */ Thread_Control *_Thread_queue_First_fifo( Thread_queue_Control *the_thread_queue ) { 1137b0: 55 push %ebp 1137b1: 89 e5 mov %esp,%ebp 1137b3: 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; } 1137b6: 8b 02 mov (%edx),%eax 1137b8: 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 ) ) 1137bb: 39 d0 cmp %edx,%eax 1137bd: 74 05 je 1137c4 <_Thread_queue_First_fifo+0x14> return (Thread_Control *) _Chain_First( &the_thread_queue->Queues.Fifo ); return NULL; } 1137bf: c9 leave 1137c0: c3 ret 1137c1: 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; 1137c4: 31 c0 xor %eax,%eax } 1137c6: c9 leave 1137c7: c3 ret =============================================================================== 0010e00c <_Thread_queue_Flush>: #else Thread_queue_Flush_callout remote_extract_callout __attribute__((unused)), #endif uint32_t status ) { 10e00c: 55 push %ebp 10e00d: 89 e5 mov %esp,%ebp 10e00f: 56 push %esi 10e010: 53 push %ebx 10e011: 8b 5d 08 mov 0x8(%ebp),%ebx 10e014: 8b 75 10 mov 0x10(%ebp),%esi Thread_Control *the_thread; while ( (the_thread = _Thread_queue_Dequeue( the_thread_queue )) ) { 10e017: eb 06 jmp 10e01f <_Thread_queue_Flush+0x13> 10e019: 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; 10e01c: 89 70 34 mov %esi,0x34(%eax) uint32_t status ) { Thread_Control *the_thread; while ( (the_thread = _Thread_queue_Dequeue( the_thread_queue )) ) { 10e01f: 83 ec 0c sub $0xc,%esp 10e022: 53 push %ebx 10e023: e8 80 fc ff ff call 10dca8 <_Thread_queue_Dequeue> 10e028: 83 c4 10 add $0x10,%esp 10e02b: 85 c0 test %eax,%eax 10e02d: 75 ed jne 10e01c <_Thread_queue_Flush+0x10> ( *remote_extract_callout )( the_thread ); else #endif the_thread->Wait.return_code = status; } } 10e02f: 8d 65 f8 lea -0x8(%ebp),%esp 10e032: 5b pop %ebx 10e033: 5e pop %esi 10e034: c9 leave 10e035: c3 ret =============================================================================== 0010e038 <_Thread_queue_Initialize>: Thread_queue_Control *the_thread_queue, Thread_queue_Disciplines the_discipline, States_Control state, uint32_t timeout_status ) { 10e038: 55 push %ebp 10e039: 89 e5 mov %esp,%ebp 10e03b: 56 push %esi 10e03c: 53 push %ebx 10e03d: 8b 45 08 mov 0x8(%ebp),%eax 10e040: 8b 55 0c mov 0xc(%ebp),%edx the_thread_queue->state = state; 10e043: 8b 4d 10 mov 0x10(%ebp),%ecx 10e046: 89 48 38 mov %ecx,0x38(%eax) the_thread_queue->discipline = the_discipline; 10e049: 89 50 34 mov %edx,0x34(%eax) the_thread_queue->timeout_status = timeout_status; 10e04c: 8b 4d 14 mov 0x14(%ebp),%ecx 10e04f: 89 48 3c mov %ecx,0x3c(%eax) the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10e052: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax) if ( the_discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) { 10e059: 83 fa 01 cmp $0x1,%edx 10e05c: 74 16 je 10e074 <_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 ); 10e05e: 8d 50 04 lea 0x4(%eax),%edx 10e061: 89 10 mov %edx,(%eax) head->next = tail; head->previous = NULL; 10e063: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) tail->previous = head; 10e06a: 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 ); } } 10e06d: 5b pop %ebx 10e06e: 5e pop %esi 10e06f: c9 leave 10e070: c3 ret 10e071: 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 ) { 10e074: 89 c1 mov %eax,%ecx 10e076: 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 ); 10e078: 8d 1c 52 lea (%edx,%edx,2),%ebx 10e07b: 8d 1c 98 lea (%eax,%ebx,4),%ebx 10e07e: 8d 73 04 lea 0x4(%ebx),%esi 10e081: 89 31 mov %esi,(%ecx) head->next = tail; head->previous = NULL; 10e083: 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 ); 10e08a: 89 59 08 mov %ebx,0x8(%ecx) uint32_t index; for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++) 10e08d: 42 inc %edx 10e08e: 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 ; 10e091: 83 fa 04 cmp $0x4,%edx 10e094: 75 e2 jne 10e078 <_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 ); } } 10e096: 5b pop %ebx 10e097: 5e pop %esi 10e098: c9 leave 10e099: c3 ret =============================================================================== 0010e09c <_Thread_queue_Requeue>: void _Thread_queue_Requeue( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 10e09c: 55 push %ebp 10e09d: 89 e5 mov %esp,%ebp 10e09f: 57 push %edi 10e0a0: 56 push %esi 10e0a1: 53 push %ebx 10e0a2: 83 ec 1c sub $0x1c,%esp 10e0a5: 8b 75 08 mov 0x8(%ebp),%esi 10e0a8: 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 ) 10e0ab: 85 f6 test %esi,%esi 10e0ad: 74 06 je 10e0b5 <_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 ) { 10e0af: 83 7e 34 01 cmpl $0x1,0x34(%esi) 10e0b3: 74 0b je 10e0c0 <_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 ); } } 10e0b5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e0b8: 5b pop %ebx <== NOT EXECUTED 10e0b9: 5e pop %esi <== NOT EXECUTED 10e0ba: 5f pop %edi <== NOT EXECUTED 10e0bb: c9 leave <== NOT EXECUTED 10e0bc: c3 ret <== NOT EXECUTED 10e0bd: 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 ); 10e0c0: 9c pushf 10e0c1: fa cli 10e0c2: 5b pop %ebx if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 10e0c3: f7 47 10 e0 be 03 00 testl $0x3bee0,0x10(%edi) 10e0ca: 75 0c jne 10e0d8 <_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 ); 10e0cc: 53 push %ebx 10e0cd: 9d popf } } 10e0ce: 8d 65 f4 lea -0xc(%ebp),%esp 10e0d1: 5b pop %ebx 10e0d2: 5e pop %esi 10e0d3: 5f pop %edi 10e0d4: c9 leave 10e0d5: c3 ret 10e0d6: 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; 10e0d8: 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 ); 10e0df: 50 push %eax 10e0e0: 6a 01 push $0x1 10e0e2: 57 push %edi 10e0e3: 56 push %esi 10e0e4: e8 63 37 00 00 call 11184c <_Thread_queue_Extract_priority_helper> (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored ); 10e0e9: 83 c4 0c add $0xc,%esp 10e0ec: 8d 45 e4 lea -0x1c(%ebp),%eax 10e0ef: 50 push %eax 10e0f0: 57 push %edi 10e0f1: 56 push %esi 10e0f2: e8 71 fd ff ff call 10de68 <_Thread_queue_Enqueue_priority> 10e0f7: 83 c4 10 add $0x10,%esp 10e0fa: eb d0 jmp 10e0cc <_Thread_queue_Requeue+0x30> =============================================================================== 0010e0fc <_Thread_queue_Timeout>: void _Thread_queue_Timeout( Objects_Id id, void *ignored __attribute__((unused)) ) { 10e0fc: 55 push %ebp 10e0fd: 89 e5 mov %esp,%ebp 10e0ff: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10e102: 8d 45 f4 lea -0xc(%ebp),%eax 10e105: 50 push %eax 10e106: ff 75 08 pushl 0x8(%ebp) 10e109: e8 0a f8 ff ff call 10d918 <_Thread_Get> switch ( location ) { 10e10e: 83 c4 10 add $0x10,%esp 10e111: 8b 55 f4 mov -0xc(%ebp),%edx 10e114: 85 d2 test %edx,%edx 10e116: 75 17 jne 10e12f <_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 ); 10e118: 83 ec 0c sub $0xc,%esp 10e11b: 50 push %eax 10e11c: e8 e7 37 00 00 call 111908 <_Thread_queue_Process_timeout> */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 10e121: a1 70 75 12 00 mov 0x127570,%eax 10e126: 48 dec %eax 10e127: a3 70 75 12 00 mov %eax,0x127570 10e12c: 83 c4 10 add $0x10,%esp _Thread_Unnest_dispatch(); break; } } 10e12f: c9 leave 10e130: c3 ret =============================================================================== 00118dc4 <_Timer_server_Body>: * @a arg points to the corresponding timer server control block. */ static rtems_task _Timer_server_Body( rtems_task_argument arg ) { 118dc4: 55 push %ebp 118dc5: 89 e5 mov %esp,%ebp 118dc7: 57 push %edi 118dc8: 56 push %esi 118dc9: 53 push %ebx 118dca: 83 ec 4c sub $0x4c,%esp 118dcd: 8b 5d 08 mov 0x8(%ebp),%ebx ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 118dd0: 8d 45 e0 lea -0x20(%ebp),%eax 118dd3: 89 45 b4 mov %eax,-0x4c(%ebp) 118dd6: 89 45 dc mov %eax,-0x24(%ebp) head->previous = NULL; 118dd9: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) tail->previous = head; 118de0: 8d 4d dc lea -0x24(%ebp),%ecx 118de3: 89 4d e4 mov %ecx,-0x1c(%ebp) ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 118de6: 8d 7d d0 lea -0x30(%ebp),%edi 118de9: 8d 45 d4 lea -0x2c(%ebp),%eax 118dec: 89 45 b0 mov %eax,-0x50(%ebp) 118def: 89 45 d0 mov %eax,-0x30(%ebp) head->previous = NULL; 118df2: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) tail->previous = head; 118df9: 89 7d d8 mov %edi,-0x28(%ebp) 118dfc: 8d 73 30 lea 0x30(%ebx),%esi 118dff: 8d 4b 68 lea 0x68(%ebx),%ecx 118e02: 89 4d c4 mov %ecx,-0x3c(%ebp) 118e05: 8d 43 08 lea 0x8(%ebx),%eax 118e08: 89 45 bc mov %eax,-0x44(%ebp) 118e0b: 8d 53 40 lea 0x40(%ebx),%edx 118e0e: 89 55 c0 mov %edx,-0x40(%ebp) 118e11: 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; 118e14: 8d 4d dc lea -0x24(%ebp),%ecx 118e17: 89 4b 78 mov %ecx,0x78(%ebx) 118e1a: 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; 118e1c: a1 84 23 14 00 mov 0x142384,%eax /* * We assume adequate unsigned arithmetic here. */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; 118e21: 8b 53 3c mov 0x3c(%ebx),%edx watchdogs->last_snapshot = snapshot; 118e24: 89 43 3c mov %eax,0x3c(%ebx) _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 118e27: 51 push %ecx 118e28: 57 push %edi Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot; /* * We assume adequate unsigned arithmetic here. */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; 118e29: 29 d0 sub %edx,%eax watchdogs->last_snapshot = snapshot; _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 118e2b: 50 push %eax 118e2c: 56 push %esi 118e2d: e8 72 3f 00 00 call 11cda4 <_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(); 118e32: a1 e4 22 14 00 mov 0x1422e4,%eax Watchdog_Interval last_snapshot = watchdogs->last_snapshot; 118e37: 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 ) { 118e3a: 83 c4 10 add $0x10,%esp 118e3d: 39 d0 cmp %edx,%eax 118e3f: 0f 87 af 00 00 00 ja 118ef4 <_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 ) { 118e45: 0f 82 c9 00 00 00 jb 118f14 <_Timer_server_Body+0x150> */ delta = last_snapshot - snapshot; _Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta ); } watchdogs->last_snapshot = snapshot; 118e4b: 89 43 74 mov %eax,0x74(%ebx) 118e4e: 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 ); 118e50: 8b 43 78 mov 0x78(%ebx),%eax 118e53: 83 ec 0c sub $0xc,%esp 118e56: 50 push %eax 118e57: e8 04 0a 00 00 call 119860 <_Chain_Get> if ( timer == NULL ) { 118e5c: 83 c4 10 add $0x10,%esp 118e5f: 85 c0 test %eax,%eax 118e61: 74 35 je 118e98 <_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 ) { 118e63: 8b 50 38 mov 0x38(%eax),%edx <== NOT EXECUTED 118e66: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED 118e69: 74 19 je 118e84 <_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 ) { 118e6b: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED 118e6e: 75 e0 jne 118e50 <_Timer_server_Body+0x8c><== NOT EXECUTED _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker ); 118e70: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 118e73: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 118e76: 50 push %eax <== NOT EXECUTED 118e77: ff 75 c4 pushl -0x3c(%ebp) <== NOT EXECUTED 118e7a: e8 b1 3f 00 00 call 11ce30 <_Watchdog_Insert> <== NOT EXECUTED 118e7f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 118e82: eb cc jmp 118e50 <_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 ); 118e84: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 118e87: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 118e8a: 50 push %eax <== NOT EXECUTED 118e8b: 56 push %esi <== NOT EXECUTED 118e8c: e8 9f 3f 00 00 call 11ce30 <_Watchdog_Insert> <== NOT EXECUTED 118e91: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 118e94: eb ba jmp 118e50 <_Timer_server_Body+0x8c><== NOT EXECUTED 118e96: 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 ); 118e98: 9c pushf 118e99: fa cli 118e9a: 58 pop %eax tmp = ts->insert_chain; 118e9b: 8b 53 78 mov 0x78(%ebx),%edx if ( _Chain_Is_empty( insert_chain ) ) { 118e9e: 8b 55 b4 mov -0x4c(%ebp),%edx 118ea1: 39 55 dc cmp %edx,-0x24(%ebp) 118ea4: 0f 84 86 00 00 00 je 118f30 <_Timer_server_Body+0x16c><== ALWAYS TAKEN 118eaa: b2 01 mov $0x1,%dl <== NOT EXECUTED ts->insert_chain = NULL; do_loop = false; } _ISR_Enable( level ); 118eac: 50 push %eax 118ead: 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 ) { 118eae: 84 d2 test %dl,%dl 118eb0: 0f 85 66 ff ff ff jne 118e1c <_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 ) ) { 118eb6: 8b 4d b0 mov -0x50(%ebp),%ecx 118eb9: 39 4d d0 cmp %ecx,-0x30(%ebp) 118ebc: 75 22 jne 118ee0 <_Timer_server_Body+0x11c> 118ebe: eb 7e jmp 118f3e <_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; 118ec0: 8b 10 mov (%eax),%edx head->next = new_first; 118ec2: 89 55 d0 mov %edx,-0x30(%ebp) new_first->previous = head; 118ec5: 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; 118ec8: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax) _ISR_Enable( level ); 118ecf: 51 push %ecx 118ed0: 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 ); 118ed1: 83 ec 08 sub $0x8,%esp 118ed4: ff 70 24 pushl 0x24(%eax) 118ed7: ff 70 20 pushl 0x20(%eax) 118eda: ff 50 1c call *0x1c(%eax) } 118edd: 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 ); 118ee0: 9c pushf 118ee1: fa cli 118ee2: 59 pop %ecx initialized = false; } #endif return status; } 118ee3: 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)) 118ee6: 3b 45 b0 cmp -0x50(%ebp),%eax 118ee9: 75 d5 jne 118ec0 <_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 ); 118eeb: 51 push %ecx 118eec: 9d popf 118eed: e9 22 ff ff ff jmp 118e14 <_Timer_server_Body+0x50> 118ef2: 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 ); 118ef4: 51 push %ecx 118ef5: 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; 118ef6: 89 c1 mov %eax,%ecx 118ef8: 29 d1 sub %edx,%ecx _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 118efa: 51 push %ecx 118efb: ff 75 c4 pushl -0x3c(%ebp) 118efe: 89 45 b8 mov %eax,-0x48(%ebp) 118f01: e8 9e 3e 00 00 call 11cda4 <_Watchdog_Adjust_to_chain> 118f06: 83 c4 10 add $0x10,%esp 118f09: 8b 45 b8 mov -0x48(%ebp),%eax 118f0c: e9 3a ff ff ff jmp 118e4b <_Timer_server_Body+0x87> 118f11: 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 ); 118f14: 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; 118f15: 29 c2 sub %eax,%edx _Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta ); 118f17: 52 push %edx 118f18: 6a 01 push $0x1 118f1a: ff 75 c4 pushl -0x3c(%ebp) 118f1d: 89 45 b8 mov %eax,-0x48(%ebp) 118f20: e8 07 3e 00 00 call 11cd2c <_Watchdog_Adjust> 118f25: 83 c4 10 add $0x10,%esp 118f28: 8b 45 b8 mov -0x48(%ebp),%eax 118f2b: e9 1b ff ff ff jmp 118e4b <_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; 118f30: c7 43 78 00 00 00 00 movl $0x0,0x78(%ebx) do_loop = false; 118f37: 31 d2 xor %edx,%edx 118f39: e9 6e ff ff ff jmp 118eac <_Timer_server_Body+0xe8> * the active flag of the timer server is true. */ (*watchdog->routine)( watchdog->id, watchdog->user_data ); } } else { ts->active = false; 118f3e: c6 43 7c 00 movb $0x0,0x7c(%ebx) 118f42: a1 10 22 14 00 mov 0x142210,%eax 118f47: 40 inc %eax 118f48: a3 10 22 14 00 mov %eax,0x142210 /* * Block until there is something to do. */ _Thread_Disable_dispatch(); _Thread_Set_state( ts->thread, STATES_DELAYING ); 118f4d: 83 ec 08 sub $0x8,%esp 118f50: 6a 08 push $0x8 118f52: ff 33 pushl (%ebx) 118f54: e8 67 37 00 00 call 11c6c0 <_Thread_Set_state> _Timer_server_Reset_interval_system_watchdog( ts ); 118f59: 89 d8 mov %ebx,%eax 118f5b: e8 c4 fd ff ff call 118d24 <_Timer_server_Reset_interval_system_watchdog> _Timer_server_Reset_tod_system_watchdog( ts ); 118f60: 89 d8 mov %ebx,%eax 118f62: e8 0d fe ff ff call 118d74 <_Timer_server_Reset_tod_system_watchdog> _Thread_Enable_dispatch(); 118f67: e8 2c 2e 00 00 call 11bd98 <_Thread_Enable_dispatch> ts->active = true; 118f6c: 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 ); 118f70: 5a pop %edx 118f71: ff 75 bc pushl -0x44(%ebp) 118f74: e8 f7 3f 00 00 call 11cf70 <_Watchdog_Remove> static void _Timer_server_Stop_tod_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog ); 118f79: 58 pop %eax 118f7a: ff 75 c0 pushl -0x40(%ebp) 118f7d: e8 ee 3f 00 00 call 11cf70 <_Watchdog_Remove> 118f82: 83 c4 10 add $0x10,%esp 118f85: e9 8a fe ff ff jmp 118e14 <_Timer_server_Body+0x50> =============================================================================== 00118f8c <_Timer_server_Schedule_operation_method>: static void _Timer_server_Schedule_operation_method( Timer_server_Control *ts, Timer_Control *timer ) { 118f8c: 55 push %ebp 118f8d: 89 e5 mov %esp,%ebp 118f8f: 57 push %edi 118f90: 56 push %esi 118f91: 53 push %ebx 118f92: 83 ec 2c sub $0x2c,%esp 118f95: 8b 5d 08 mov 0x8(%ebp),%ebx 118f98: 8b 45 0c mov 0xc(%ebp),%eax if ( ts->insert_chain == NULL ) { 118f9b: 8b 53 78 mov 0x78(%ebx),%edx 118f9e: 85 d2 test %edx,%edx 118fa0: 74 16 je 118fb8 <_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 ); 118fa2: 8b 53 78 mov 0x78(%ebx),%edx <== NOT EXECUTED 118fa5: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 118fa8: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } } 118fab: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 118fae: 5b pop %ebx <== NOT EXECUTED 118faf: 5e pop %esi <== NOT EXECUTED 118fb0: 5f pop %edi <== NOT EXECUTED 118fb1: 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 ); 118fb2: e9 6d 08 00 00 jmp 119824 <_Chain_Append> <== NOT EXECUTED 118fb7: 90 nop <== NOT EXECUTED 118fb8: 8b 15 10 22 14 00 mov 0x142210,%edx 118fbe: 42 inc %edx 118fbf: 89 15 10 22 14 00 mov %edx,0x142210 * being inserted. This could result in an integer overflow. */ _Thread_Disable_dispatch(); if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { 118fc5: 8b 50 38 mov 0x38(%eax),%edx 118fc8: 83 fa 01 cmp $0x1,%edx 118fcb: 74 7b je 119048 <_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 ) { 118fcd: 83 fa 03 cmp $0x3,%edx 118fd0: 74 0e je 118fe0 <_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 ); } } 118fd2: 8d 65 f4 lea -0xc(%ebp),%esp 118fd5: 5b pop %ebx 118fd6: 5e pop %esi 118fd7: 5f pop %edi 118fd8: c9 leave if ( !ts->active ) { _Timer_server_Reset_tod_system_watchdog( ts ); } } _Thread_Enable_dispatch(); 118fd9: e9 ba 2d 00 00 jmp 11bd98 <_Thread_Enable_dispatch> 118fde: 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 ); 118fe0: 9c pushf 118fe1: fa cli 118fe2: 8f 45 e4 popl -0x1c(%ebp) snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); 118fe5: 8b 0d e4 22 14 00 mov 0x1422e4,%ecx last_snapshot = ts->TOD_watchdogs.last_snapshot; 118feb: 8b 53 74 mov 0x74(%ebx),%edx 118fee: 89 55 d4 mov %edx,-0x2c(%ebp) initialized = false; } #endif return status; } 118ff1: 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 ); 118ff4: 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 ) ) { 118ff7: 39 fa cmp %edi,%edx 118ff9: 74 21 je 11901c <_Timer_server_Schedule_operation_method+0x90> first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain ); delta_interval = first_watchdog->delta_interval; 118ffb: 8b 7a 10 mov 0x10(%edx),%edi if ( snapshot > last_snapshot ) { 118ffe: 3b 4d d4 cmp -0x2c(%ebp),%ecx 119001: 0f 86 a1 00 00 00 jbe 1190a8 <_Timer_server_Schedule_operation_method+0x11c> /* * We advanced in time. */ delta = snapshot - last_snapshot; 119007: 89 ce mov %ecx,%esi 119009: 2b 75 d4 sub -0x2c(%ebp),%esi 11900c: 89 75 d4 mov %esi,-0x2c(%ebp) if (delta_interval > delta) { 11900f: 39 f7 cmp %esi,%edi 119011: 0f 86 9b 00 00 00 jbe 1190b2 <_Timer_server_Schedule_operation_method+0x126><== NEVER TAKEN delta_interval -= delta; 119017: 29 f7 sub %esi,%edi * Someone put us in the past. */ delta = last_snapshot - snapshot; delta_interval += delta; } first_watchdog->delta_interval = delta_interval; 119019: 89 7a 10 mov %edi,0x10(%edx) } ts->TOD_watchdogs.last_snapshot = snapshot; 11901c: 89 4b 74 mov %ecx,0x74(%ebx) _ISR_Enable( level ); 11901f: ff 75 e4 pushl -0x1c(%ebp) 119022: 9d popf _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker ); 119023: 83 ec 08 sub $0x8,%esp 119026: 83 c0 10 add $0x10,%eax 119029: 50 push %eax 11902a: 8d 43 68 lea 0x68(%ebx),%eax 11902d: 50 push %eax 11902e: e8 fd 3d 00 00 call 11ce30 <_Watchdog_Insert> if ( !ts->active ) { 119033: 8a 43 7c mov 0x7c(%ebx),%al 119036: 83 c4 10 add $0x10,%esp 119039: 84 c0 test %al,%al 11903b: 75 95 jne 118fd2 <_Timer_server_Schedule_operation_method+0x46> _Timer_server_Reset_tod_system_watchdog( ts ); 11903d: 89 d8 mov %ebx,%eax 11903f: e8 30 fd ff ff call 118d74 <_Timer_server_Reset_tod_system_watchdog> 119044: eb 8c jmp 118fd2 <_Timer_server_Schedule_operation_method+0x46> 119046: 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 ); 119048: 9c pushf 119049: fa cli 11904a: 8f 45 e4 popl -0x1c(%ebp) snapshot = _Watchdog_Ticks_since_boot; 11904d: 8b 0d 84 23 14 00 mov 0x142384,%ecx last_snapshot = ts->Interval_watchdogs.last_snapshot; 119053: 8b 7b 3c mov 0x3c(%ebx),%edi initialized = false; } #endif return status; } 119056: 8b 53 30 mov 0x30(%ebx),%edx 119059: 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 ) ) { 11905c: 39 f2 cmp %esi,%edx 11905e: 74 10 je 119070 <_Timer_server_Schedule_operation_method+0xe4> first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain ); /* * We assume adequate unsigned arithmetic here. */ delta = snapshot - last_snapshot; 119060: 89 ce mov %ecx,%esi 119062: 29 fe sub %edi,%esi delta_interval = first_watchdog->delta_interval; 119064: 8b 7a 10 mov 0x10(%edx),%edi if (delta_interval > delta) { 119067: 39 fe cmp %edi,%esi 119069: 73 39 jae 1190a4 <_Timer_server_Schedule_operation_method+0x118> delta_interval -= delta; 11906b: 29 f7 sub %esi,%edi } else { delta_interval = 0; } first_watchdog->delta_interval = delta_interval; 11906d: 89 7a 10 mov %edi,0x10(%edx) } ts->Interval_watchdogs.last_snapshot = snapshot; 119070: 89 4b 3c mov %ecx,0x3c(%ebx) _ISR_Enable( level ); 119073: ff 75 e4 pushl -0x1c(%ebp) 119076: 9d popf _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); 119077: 83 ec 08 sub $0x8,%esp 11907a: 83 c0 10 add $0x10,%eax 11907d: 50 push %eax 11907e: 8d 43 30 lea 0x30(%ebx),%eax 119081: 50 push %eax 119082: e8 a9 3d 00 00 call 11ce30 <_Watchdog_Insert> if ( !ts->active ) { 119087: 8a 43 7c mov 0x7c(%ebx),%al 11908a: 83 c4 10 add $0x10,%esp 11908d: 84 c0 test %al,%al 11908f: 0f 85 3d ff ff ff jne 118fd2 <_Timer_server_Schedule_operation_method+0x46> _Timer_server_Reset_interval_system_watchdog( ts ); 119095: 89 d8 mov %ebx,%eax 119097: e8 88 fc ff ff call 118d24 <_Timer_server_Reset_interval_system_watchdog> 11909c: e9 31 ff ff ff jmp 118fd2 <_Timer_server_Schedule_operation_method+0x46> 1190a1: 8d 76 00 lea 0x0(%esi),%esi delta_interval = first_watchdog->delta_interval; if (delta_interval > delta) { delta_interval -= delta; } else { delta_interval = 0; 1190a4: 31 ff xor %edi,%edi 1190a6: eb c5 jmp 11906d <_Timer_server_Schedule_operation_method+0xe1> } } else { /* * Someone put us in the past. */ delta = last_snapshot - snapshot; 1190a8: 03 7d d4 add -0x2c(%ebp),%edi delta_interval += delta; 1190ab: 29 cf sub %ecx,%edi 1190ad: e9 67 ff ff ff jmp 119019 <_Timer_server_Schedule_operation_method+0x8d> */ delta = snapshot - last_snapshot; if (delta_interval > delta) { delta_interval -= delta; } else { delta_interval = 0; 1190b2: 31 ff xor %edi,%edi <== NOT EXECUTED 1190b4: e9 60 ff ff ff jmp 119019 <_Timer_server_Schedule_operation_method+0x8d><== NOT EXECUTED =============================================================================== 0010fc18 <_Timespec_Divide>: const struct timespec *lhs, const struct timespec *rhs, uint32_t *ival_percentage, uint32_t *fval_percentage ) { 10fc18: 55 push %ebp 10fc19: 89 e5 mov %esp,%ebp 10fc1b: 57 push %edi 10fc1c: 56 push %esi 10fc1d: 53 push %ebx 10fc1e: 83 ec 2c sub $0x2c,%esp 10fc21: 8b 45 08 mov 0x8(%ebp),%eax 10fc24: 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; 10fc27: 8b 38 mov (%eax),%edi left += lhs->tv_nsec; 10fc29: 8b 70 04 mov 0x4(%eax),%esi right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 10fc2c: bb 00 ca 9a 3b mov $0x3b9aca00,%ebx 10fc31: 8b 01 mov (%ecx),%eax 10fc33: f7 eb imul %ebx 10fc35: 89 45 e0 mov %eax,-0x20(%ebp) 10fc38: 89 55 e4 mov %edx,-0x1c(%ebp) right += rhs->tv_nsec; 10fc3b: 8b 41 04 mov 0x4(%ecx),%eax 10fc3e: 99 cltd 10fc3f: 01 45 e0 add %eax,-0x20(%ebp) 10fc42: 11 55 e4 adc %edx,-0x1c(%ebp) if ( right == 0 ) { 10fc45: 8b 55 e4 mov -0x1c(%ebp),%edx 10fc48: 0b 55 e0 or -0x20(%ebp),%edx 10fc4b: 74 73 je 10fcc0 <_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; 10fc4d: 89 f8 mov %edi,%eax 10fc4f: f7 eb imul %ebx 10fc51: 89 45 d0 mov %eax,-0x30(%ebp) 10fc54: 89 55 d4 mov %edx,-0x2c(%ebp) left += lhs->tv_nsec; 10fc57: 89 f7 mov %esi,%edi 10fc59: c1 ff 1f sar $0x1f,%edi 10fc5c: 01 75 d0 add %esi,-0x30(%ebp) 10fc5f: 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; 10fc62: 69 4d d4 a0 86 01 00 imul $0x186a0,-0x2c(%ebp),%ecx 10fc69: bb a0 86 01 00 mov $0x186a0,%ebx 10fc6e: 8b 45 d0 mov -0x30(%ebp),%eax 10fc71: f7 e3 mul %ebx 10fc73: 8d 34 11 lea (%ecx,%edx,1),%esi 10fc76: ff 75 e4 pushl -0x1c(%ebp) 10fc79: ff 75 e0 pushl -0x20(%ebp) 10fc7c: 56 push %esi 10fc7d: 50 push %eax 10fc7e: e8 3d 0a 01 00 call 1206c0 <__udivdi3> 10fc83: 83 c4 10 add $0x10,%esp 10fc86: 89 c3 mov %eax,%ebx 10fc88: 89 d6 mov %edx,%esi *ival_percentage = answer / 1000; 10fc8a: 6a 00 push $0x0 10fc8c: 68 e8 03 00 00 push $0x3e8 10fc91: 52 push %edx 10fc92: 50 push %eax 10fc93: e8 28 0a 01 00 call 1206c0 <__udivdi3> 10fc98: 83 c4 10 add $0x10,%esp 10fc9b: 8b 55 10 mov 0x10(%ebp),%edx 10fc9e: 89 02 mov %eax,(%edx) *fval_percentage = answer % 1000; 10fca0: 6a 00 push $0x0 10fca2: 68 e8 03 00 00 push $0x3e8 10fca7: 56 push %esi 10fca8: 53 push %ebx 10fca9: e8 22 0b 01 00 call 1207d0 <__umoddi3> 10fcae: 83 c4 10 add $0x10,%esp 10fcb1: 8b 55 14 mov 0x14(%ebp),%edx 10fcb4: 89 02 mov %eax,(%edx) } 10fcb6: 8d 65 f4 lea -0xc(%ebp),%esp 10fcb9: 5b pop %ebx 10fcba: 5e pop %esi 10fcbb: 5f pop %edi 10fcbc: c9 leave 10fcbd: c3 ret 10fcbe: 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; 10fcc0: 8b 45 10 mov 0x10(%ebp),%eax 10fcc3: c7 00 00 00 00 00 movl $0x0,(%eax) *fval_percentage = 0; 10fcc9: 8b 55 14 mov 0x14(%ebp),%edx 10fccc: c7 02 00 00 00 00 movl $0x0,(%edx) answer = (left * 100000) / right; *ival_percentage = answer / 1000; *fval_percentage = answer % 1000; } 10fcd2: 8d 65 f4 lea -0xc(%ebp),%esp 10fcd5: 5b pop %ebx 10fcd6: 5e pop %esi 10fcd7: 5f pop %edi 10fcd8: c9 leave 10fcd9: c3 ret =============================================================================== 0011f794 <_Timespec_Is_valid>: #include bool _Timespec_Is_valid( const struct timespec *time ) { 11f794: 55 push %ebp 11f795: 89 e5 mov %esp,%ebp 11f797: 8b 45 08 mov 0x8(%ebp),%eax if ( !time ) 11f79a: 85 c0 test %eax,%eax 11f79c: 74 1a je 11f7b8 <_Timespec_Is_valid+0x24> return false; if ( time->tv_sec < 0 ) 11f79e: 8b 10 mov (%eax),%edx 11f7a0: 85 d2 test %edx,%edx 11f7a2: 78 14 js 11f7b8 <_Timespec_Is_valid+0x24> return false; if ( time->tv_nsec < 0 ) 11f7a4: 8b 40 04 mov 0x4(%eax),%eax 11f7a7: 85 c0 test %eax,%eax 11f7a9: 78 0d js 11f7b8 <_Timespec_Is_valid+0x24> #include #include #include bool _Timespec_Is_valid( 11f7ab: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax 11f7b0: 0f 96 c0 setbe %al if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) return false; return true; } 11f7b3: c9 leave 11f7b4: c3 ret 11f7b5: 8d 76 00 lea 0x0(%esi),%esi if ( time->tv_sec < 0 ) return false; if ( time->tv_nsec < 0 ) return false; 11f7b8: 31 c0 xor %eax,%eax if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) return false; return true; } 11f7ba: c9 leave 11f7bb: c3 ret =============================================================================== 001119bc <_Timespec_To_ticks>: */ uint32_t _Timespec_To_ticks( const struct timespec *time ) { 1119bc: 55 push %ebp 1119bd: 89 e5 mov %esp,%ebp 1119bf: 56 push %esi 1119c0: 53 push %ebx 1119c1: 8b 5d 08 mov 0x8(%ebp),%ebx uint32_t ticks; if ( (time->tv_sec == 0) && (time->tv_nsec == 0) ) 1119c4: 8b 33 mov (%ebx),%esi 1119c6: 85 f6 test %esi,%esi 1119c8: 75 07 jne 1119d1 <_Timespec_To_ticks+0x15> 1119ca: 8b 43 04 mov 0x4(%ebx),%eax 1119cd: 85 c0 test %eax,%eax 1119cf: 74 37 je 111a08 <_Timespec_To_ticks+0x4c> return 0; ticks = time->tv_sec * TOD_TICKS_PER_SECOND; 1119d1: e8 62 17 00 00 call 113138 1119d6: 89 c1 mov %eax,%ecx 1119d8: 0f af ce imul %esi,%ecx ticks += time->tv_nsec / rtems_configuration_get_nanoseconds_per_tick(); 1119db: a1 8c 32 12 00 mov 0x12328c,%eax 1119e0: 8d 04 80 lea (%eax,%eax,4),%eax 1119e3: 8d 04 80 lea (%eax,%eax,4),%eax 1119e6: 8d 34 80 lea (%eax,%eax,4),%esi 1119e9: c1 e6 03 shl $0x3,%esi 1119ec: 8b 43 04 mov 0x4(%ebx),%eax 1119ef: 31 d2 xor %edx,%edx 1119f1: f7 f6 div %esi if (ticks) 1119f3: 01 c8 add %ecx,%eax 1119f5: 74 05 je 1119fc <_Timespec_To_ticks+0x40> return ticks; return 1; } 1119f7: 5b pop %ebx 1119f8: 5e pop %esi 1119f9: c9 leave 1119fa: c3 ret 1119fb: 90 nop ticks += time->tv_nsec / rtems_configuration_get_nanoseconds_per_tick(); if (ticks) return ticks; return 1; 1119fc: b8 01 00 00 00 mov $0x1,%eax } 111a01: 5b pop %ebx 111a02: 5e pop %esi 111a03: c9 leave 111a04: c3 ret 111a05: 8d 76 00 lea 0x0(%esi),%esi ) { uint32_t ticks; if ( (time->tv_sec == 0) && (time->tv_nsec == 0) ) return 0; 111a08: 31 c0 xor %eax,%eax if (ticks) return ticks; return 1; } 111a0a: 5b pop %ebx 111a0b: 5e pop %esi 111a0c: c9 leave 111a0d: c3 ret =============================================================================== 0010e594 <_User_extensions_Fatal>: void _User_extensions_Fatal ( Internal_errors_Source the_source, bool is_internal, Internal_errors_t the_error ) { 10e594: 55 push %ebp 10e595: 89 e5 mov %esp,%ebp 10e597: 57 push %edi 10e598: 56 push %esi 10e599: 53 push %ebx 10e59a: 83 ec 1c sub $0x1c,%esp 10e59d: 8b 75 08 mov 0x8(%ebp),%esi 10e5a0: 8b 7d 10 mov 0x10(%ebp),%edi 10e5a3: 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 ); } } 10e5a6: 8b 1d d4 77 12 00 mov 0x1277d4,%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); 10e5ac: 81 fb cc 77 12 00 cmp $0x1277cc,%ebx 10e5b2: 74 25 je 10e5d9 <_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 ); 10e5b4: 0f b6 c0 movzbl %al,%eax 10e5b7: 89 45 e4 mov %eax,-0x1c(%ebp) 10e5ba: 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 ) 10e5bc: 8b 43 30 mov 0x30(%ebx),%eax 10e5bf: 85 c0 test %eax,%eax 10e5c1: 74 0b je 10e5ce <_User_extensions_Fatal+0x3a> (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); 10e5c3: 52 push %edx 10e5c4: 57 push %edi 10e5c5: ff 75 e4 pushl -0x1c(%ebp) 10e5c8: 56 push %esi 10e5c9: ff d0 call *%eax 10e5cb: 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 ) { 10e5ce: 8b 5b 04 mov 0x4(%ebx),%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); 10e5d1: 81 fb cc 77 12 00 cmp $0x1277cc,%ebx 10e5d7: 75 e3 jne 10e5bc <_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 ); } } 10e5d9: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e5dc: 5b pop %ebx <== NOT EXECUTED 10e5dd: 5e pop %esi <== NOT EXECUTED 10e5de: 5f pop %edi <== NOT EXECUTED 10e5df: c9 leave <== NOT EXECUTED 10e5e0: c3 ret <== NOT EXECUTED =============================================================================== 0010e458 <_User_extensions_Handler_initialization>: #include #include #include void _User_extensions_Handler_initialization(void) { 10e458: 55 push %ebp 10e459: 89 e5 mov %esp,%ebp 10e45b: 57 push %edi 10e45c: 56 push %esi 10e45d: 53 push %ebx 10e45e: 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; 10e461: a1 bc 32 12 00 mov 0x1232bc,%eax 10e466: 89 45 dc mov %eax,-0x24(%ebp) initial_extensions = Configuration.User_extension_table; 10e469: 8b 35 c0 32 12 00 mov 0x1232c0,%esi ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 10e46f: c7 05 cc 77 12 00 d0 movl $0x1277d0,0x1277cc 10e476: 77 12 00 head->previous = NULL; 10e479: c7 05 d0 77 12 00 00 movl $0x0,0x1277d0 10e480: 00 00 00 tail->previous = head; 10e483: c7 05 d4 77 12 00 cc movl $0x1277cc,0x1277d4 10e48a: 77 12 00 ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 10e48d: c7 05 74 75 12 00 78 movl $0x127578,0x127574 10e494: 75 12 00 head->previous = NULL; 10e497: c7 05 78 75 12 00 00 movl $0x0,0x127578 10e49e: 00 00 00 tail->previous = head; 10e4a1: c7 05 7c 75 12 00 74 movl $0x127574,0x12757c 10e4a8: 75 12 00 _Chain_Initialize_empty( &_User_extensions_List ); _Chain_Initialize_empty( &_User_extensions_Switches_list ); if ( initial_extensions ) { 10e4ab: 85 f6 test %esi,%esi 10e4ad: 74 64 je 10e513 <_User_extensions_Handler_initialization+0xbb><== NEVER TAKEN extension = (User_extensions_Control *) _Workspace_Allocate_or_fatal_error( 10e4af: 89 c2 mov %eax,%edx 10e4b1: 8d 04 40 lea (%eax,%eax,2),%eax 10e4b4: 8d 0c 82 lea (%edx,%eax,4),%ecx 10e4b7: c1 e1 02 shl $0x2,%ecx 10e4ba: 83 ec 0c sub $0xc,%esp 10e4bd: 51 push %ecx 10e4be: 89 4d d8 mov %ecx,-0x28(%ebp) 10e4c1: e8 ce 04 00 00 call 10e994 <_Workspace_Allocate_or_fatal_error> 10e4c6: 89 c3 mov %eax,%ebx number_of_extensions * sizeof( User_extensions_Control ) ); memset ( 10e4c8: 31 c0 xor %eax,%eax 10e4ca: 8b 4d d8 mov -0x28(%ebp),%ecx 10e4cd: 89 df mov %ebx,%edi 10e4cf: f3 aa rep stos %al,%es:(%edi) extension, 0, number_of_extensions * sizeof( User_extensions_Control ) ); for ( i = 0 ; i < number_of_extensions ; i++ ) { 10e4d1: 83 c4 10 add $0x10,%esp 10e4d4: 8b 45 dc mov -0x24(%ebp),%eax 10e4d7: 85 c0 test %eax,%eax 10e4d9: 74 38 je 10e513 <_User_extensions_Handler_initialization+0xbb><== NEVER TAKEN 10e4db: 89 75 e4 mov %esi,-0x1c(%ebp) 10e4de: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) 10e4e5: 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; 10e4e8: 8d 7b 14 lea 0x14(%ebx),%edi 10e4eb: 8b 75 e4 mov -0x1c(%ebp),%esi 10e4ee: b9 08 00 00 00 mov $0x8,%ecx 10e4f3: f3 a5 rep movsl %ds:(%esi),%es:(%edi) _User_extensions_Add_set( extension ); 10e4f5: 83 ec 0c sub $0xc,%esp 10e4f8: 53 push %ebx 10e4f9: e8 12 35 00 00 call 111a10 <_User_extensions_Add_set> _User_extensions_Add_set_with_table (extension, &initial_extensions[i]); extension++; 10e4fe: 83 c3 34 add $0x34,%ebx extension, 0, number_of_extensions * sizeof( User_extensions_Control ) ); for ( i = 0 ; i < number_of_extensions ; i++ ) { 10e501: ff 45 e0 incl -0x20(%ebp) 10e504: 83 45 e4 20 addl $0x20,-0x1c(%ebp) 10e508: 83 c4 10 add $0x10,%esp 10e50b: 8b 45 e0 mov -0x20(%ebp),%eax 10e50e: 39 45 dc cmp %eax,-0x24(%ebp) 10e511: 77 d5 ja 10e4e8 <_User_extensions_Handler_initialization+0x90> _User_extensions_Add_set_with_table (extension, &initial_extensions[i]); extension++; } } } 10e513: 8d 65 f4 lea -0xc(%ebp),%esp 10e516: 5b pop %ebx 10e517: 5e pop %esi 10e518: 5f pop %edi 10e519: c9 leave 10e51a: c3 ret =============================================================================== 0010f9e0 <_User_extensions_Remove_set>: #include void _User_extensions_Remove_set ( User_extensions_Control *the_extension ) { 10f9e0: 55 push %ebp 10f9e1: 89 e5 mov %esp,%ebp 10f9e3: 53 push %ebx 10f9e4: 83 ec 10 sub $0x10,%esp 10f9e7: 8b 5d 08 mov 0x8(%ebp),%ebx _Chain_Extract( &the_extension->Node ); 10f9ea: 53 push %ebx 10f9eb: e8 ac d9 ff ff call 10d39c <_Chain_Extract> /* * If a switch handler is present, remove it. */ if ( the_extension->Callouts.thread_switch != NULL ) 10f9f0: 83 c4 10 add $0x10,%esp 10f9f3: 8b 43 24 mov 0x24(%ebx),%eax 10f9f6: 85 c0 test %eax,%eax 10f9f8: 74 12 je 10fa0c <_User_extensions_Remove_set+0x2c> _Chain_Extract( &the_extension->Switch.Node ); 10f9fa: 83 c3 08 add $0x8,%ebx 10f9fd: 89 5d 08 mov %ebx,0x8(%ebp) } 10fa00: 8b 5d fc mov -0x4(%ebp),%ebx 10fa03: c9 leave /* * If a switch handler is present, remove it. */ if ( the_extension->Callouts.thread_switch != NULL ) _Chain_Extract( &the_extension->Switch.Node ); 10fa04: e9 93 d9 ff ff jmp 10d39c <_Chain_Extract> 10fa09: 8d 76 00 lea 0x0(%esi),%esi } 10fa0c: 8b 5d fc mov -0x4(%ebp),%ebx 10fa0f: c9 leave 10fa10: c3 ret =============================================================================== 0010e51c <_User_extensions_Thread_begin>: #include void _User_extensions_Thread_begin ( Thread_Control *executing ) { 10e51c: 55 push %ebp 10e51d: 89 e5 mov %esp,%ebp 10e51f: 56 push %esi 10e520: 53 push %ebx 10e521: 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 ); } } 10e524: 8b 1d cc 77 12 00 mov 0x1277cc,%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); 10e52a: 81 fb d0 77 12 00 cmp $0x1277d0,%ebx 10e530: 74 1c je 10e54e <_User_extensions_Thread_begin+0x32><== NEVER TAKEN 10e532: 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 ) 10e534: 8b 43 28 mov 0x28(%ebx),%eax 10e537: 85 c0 test %eax,%eax 10e539: 74 09 je 10e544 <_User_extensions_Thread_begin+0x28> (*the_extension->Callouts.thread_begin)( executing ); 10e53b: 83 ec 0c sub $0xc,%esp 10e53e: 56 push %esi 10e53f: ff d0 call *%eax 10e541: 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 ) { 10e544: 8b 1b mov (%ebx),%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); 10e546: 81 fb d0 77 12 00 cmp $0x1277d0,%ebx 10e54c: 75 e6 jne 10e534 <_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 ); } } 10e54e: 8d 65 f8 lea -0x8(%ebp),%esp 10e551: 5b pop %ebx 10e552: 5e pop %esi 10e553: c9 leave 10e554: c3 ret =============================================================================== 0010e5e4 <_User_extensions_Thread_create>: #include bool _User_extensions_Thread_create ( Thread_Control *the_thread ) { 10e5e4: 55 push %ebp 10e5e5: 89 e5 mov %esp,%ebp 10e5e7: 56 push %esi 10e5e8: 53 push %ebx 10e5e9: 8b 75 08 mov 0x8(%ebp),%esi return false; } } return true; } 10e5ec: 8b 1d cc 77 12 00 mov 0x1277cc,%ebx { Chain_Node *the_node; User_extensions_Control *the_extension; bool status; for ( the_node = _Chain_First( &_User_extensions_List ); 10e5f2: 81 fb d0 77 12 00 cmp $0x1277d0,%ebx 10e5f8: 74 26 je 10e620 <_User_extensions_Thread_create+0x3c><== NEVER TAKEN 10e5fa: 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 ) { 10e5fc: 8b 43 14 mov 0x14(%ebx),%eax 10e5ff: 85 c0 test %eax,%eax 10e601: 74 13 je 10e616 <_User_extensions_Thread_create+0x32> status = (*the_extension->Callouts.thread_create)( 10e603: 83 ec 08 sub $0x8,%esp 10e606: 56 push %esi 10e607: ff 35 58 7b 12 00 pushl 0x127b58 10e60d: ff d0 call *%eax _Thread_Executing, the_thread ); if ( !status ) 10e60f: 83 c4 10 add $0x10,%esp 10e612: 84 c0 test %al,%al 10e614: 74 16 je 10e62c <_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 ) { 10e616: 8b 1b mov (%ebx),%ebx { Chain_Node *the_node; User_extensions_Control *the_extension; bool status; for ( the_node = _Chain_First( &_User_extensions_List ); 10e618: 81 fb d0 77 12 00 cmp $0x1277d0,%ebx 10e61e: 75 dc jne 10e5fc <_User_extensions_Thread_create+0x18> if ( !status ) return false; } } return true; 10e620: b0 01 mov $0x1,%al } 10e622: 8d 65 f8 lea -0x8(%ebp),%esp 10e625: 5b pop %ebx 10e626: 5e pop %esi 10e627: c9 leave 10e628: c3 ret 10e629: 8d 76 00 lea 0x0(%esi),%esi status = (*the_extension->Callouts.thread_create)( _Thread_Executing, the_thread ); if ( !status ) return false; 10e62c: 31 c0 xor %eax,%eax } } return true; } 10e62e: 8d 65 f8 lea -0x8(%ebp),%esp 10e631: 5b pop %ebx 10e632: 5e pop %esi 10e633: c9 leave 10e634: c3 ret =============================================================================== 0010e638 <_User_extensions_Thread_delete>: #include void _User_extensions_Thread_delete ( Thread_Control *the_thread ) { 10e638: 55 push %ebp 10e639: 89 e5 mov %esp,%ebp 10e63b: 56 push %esi 10e63c: 53 push %ebx 10e63d: 8b 75 08 mov 0x8(%ebp),%esi (*the_extension->Callouts.thread_delete)( _Thread_Executing, the_thread ); } } 10e640: 8b 1d d4 77 12 00 mov 0x1277d4,%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); 10e646: 81 fb cc 77 12 00 cmp $0x1277cc,%ebx 10e64c: 74 23 je 10e671 <_User_extensions_Thread_delete+0x39><== NEVER TAKEN 10e64e: 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 ) 10e650: 8b 43 20 mov 0x20(%ebx),%eax 10e653: 85 c0 test %eax,%eax 10e655: 74 0f je 10e666 <_User_extensions_Thread_delete+0x2e> (*the_extension->Callouts.thread_delete)( 10e657: 83 ec 08 sub $0x8,%esp 10e65a: 56 push %esi 10e65b: ff 35 58 7b 12 00 pushl 0x127b58 10e661: ff d0 call *%eax 10e663: 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 ) { 10e666: 8b 5b 04 mov 0x4(%ebx),%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); 10e669: 81 fb cc 77 12 00 cmp $0x1277cc,%ebx 10e66f: 75 df jne 10e650 <_User_extensions_Thread_delete+0x18> (*the_extension->Callouts.thread_delete)( _Thread_Executing, the_thread ); } } 10e671: 8d 65 f8 lea -0x8(%ebp),%esp 10e674: 5b pop %ebx 10e675: 5e pop %esi 10e676: c9 leave 10e677: c3 ret =============================================================================== 0010e558 <_User_extensions_Thread_exitted>: void _User_extensions_Thread_exitted ( Thread_Control *executing ) { 10e558: 55 push %ebp 10e559: 89 e5 mov %esp,%ebp 10e55b: 56 push %esi 10e55c: 53 push %ebx 10e55d: 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 ); } } 10e560: 8b 1d d4 77 12 00 mov 0x1277d4,%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); 10e566: 81 fb cc 77 12 00 cmp $0x1277cc,%ebx 10e56c: 74 1d je 10e58b <_User_extensions_Thread_exitted+0x33><== NEVER TAKEN 10e56e: 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 ) 10e570: 8b 43 2c mov 0x2c(%ebx),%eax 10e573: 85 c0 test %eax,%eax 10e575: 74 09 je 10e580 <_User_extensions_Thread_exitted+0x28> (*the_extension->Callouts.thread_exitted)( executing ); 10e577: 83 ec 0c sub $0xc,%esp 10e57a: 56 push %esi 10e57b: ff d0 call *%eax 10e57d: 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 ) { 10e580: 8b 5b 04 mov 0x4(%ebx),%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); 10e583: 81 fb cc 77 12 00 cmp $0x1277cc,%ebx 10e589: 75 e5 jne 10e570 <_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 ); } } 10e58b: 8d 65 f8 lea -0x8(%ebp),%esp 10e58e: 5b pop %ebx 10e58f: 5e pop %esi 10e590: c9 leave 10e591: c3 ret =============================================================================== 0010f23c <_User_extensions_Thread_restart>: #include void _User_extensions_Thread_restart ( Thread_Control *the_thread ) { 10f23c: 55 push %ebp 10f23d: 89 e5 mov %esp,%ebp 10f23f: 56 push %esi 10f240: 53 push %ebx 10f241: 8b 75 08 mov 0x8(%ebp),%esi (*the_extension->Callouts.thread_restart)( _Thread_Executing, the_thread ); } } 10f244: 8b 1d cc 9a 12 00 mov 0x129acc,%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); 10f24a: 81 fb d0 9a 12 00 cmp $0x129ad0,%ebx 10f250: 74 22 je 10f274 <_User_extensions_Thread_restart+0x38><== NEVER TAKEN 10f252: 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 ) 10f254: 8b 43 1c mov 0x1c(%ebx),%eax 10f257: 85 c0 test %eax,%eax 10f259: 74 0f je 10f26a <_User_extensions_Thread_restart+0x2e> (*the_extension->Callouts.thread_restart)( 10f25b: 83 ec 08 sub $0x8,%esp 10f25e: 56 push %esi 10f25f: ff 35 58 9e 12 00 pushl 0x129e58 10f265: ff d0 call *%eax 10f267: 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 ) { 10f26a: 8b 1b mov (%ebx),%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); 10f26c: 81 fb d0 9a 12 00 cmp $0x129ad0,%ebx 10f272: 75 e0 jne 10f254 <_User_extensions_Thread_restart+0x18> (*the_extension->Callouts.thread_restart)( _Thread_Executing, the_thread ); } } 10f274: 8d 65 f8 lea -0x8(%ebp),%esp 10f277: 5b pop %ebx 10f278: 5e pop %esi 10f279: c9 leave 10f27a: c3 ret =============================================================================== 0010e678 <_User_extensions_Thread_start>: #include void _User_extensions_Thread_start ( Thread_Control *the_thread ) { 10e678: 55 push %ebp 10e679: 89 e5 mov %esp,%ebp 10e67b: 56 push %esi 10e67c: 53 push %ebx 10e67d: 8b 75 08 mov 0x8(%ebp),%esi (*the_extension->Callouts.thread_start)( _Thread_Executing, the_thread ); } } 10e680: 8b 1d cc 77 12 00 mov 0x1277cc,%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); 10e686: 81 fb d0 77 12 00 cmp $0x1277d0,%ebx 10e68c: 74 22 je 10e6b0 <_User_extensions_Thread_start+0x38><== NEVER TAKEN 10e68e: 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 ) 10e690: 8b 43 18 mov 0x18(%ebx),%eax 10e693: 85 c0 test %eax,%eax 10e695: 74 0f je 10e6a6 <_User_extensions_Thread_start+0x2e> (*the_extension->Callouts.thread_start)( 10e697: 83 ec 08 sub $0x8,%esp 10e69a: 56 push %esi 10e69b: ff 35 58 7b 12 00 pushl 0x127b58 10e6a1: ff d0 call *%eax 10e6a3: 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 ) { 10e6a6: 8b 1b mov (%ebx),%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); 10e6a8: 81 fb d0 77 12 00 cmp $0x1277d0,%ebx 10e6ae: 75 e0 jne 10e690 <_User_extensions_Thread_start+0x18> (*the_extension->Callouts.thread_start)( _Thread_Executing, the_thread ); } } 10e6b0: 8d 65 f8 lea -0x8(%ebp),%esp 10e6b3: 5b pop %ebx 10e6b4: 5e pop %esi 10e6b5: c9 leave 10e6b6: c3 ret =============================================================================== 0010e6b8 <_User_extensions_Thread_switch>: void _User_extensions_Thread_switch ( Thread_Control *executing, Thread_Control *heir ) { 10e6b8: 55 push %ebp 10e6b9: 89 e5 mov %esp,%ebp 10e6bb: 57 push %edi 10e6bc: 56 push %esi 10e6bd: 53 push %ebx 10e6be: 83 ec 0c sub $0xc,%esp 10e6c1: 8b 7d 08 mov 0x8(%ebp),%edi 10e6c4: 8b 75 0c mov 0xc(%ebp),%esi the_extension_switch = (User_extensions_Switch_control *) the_node; (*the_extension_switch->thread_switch)( executing, heir ); } } 10e6c7: 8b 1d 74 75 12 00 mov 0x127574,%ebx ) { Chain_Node *the_node; User_extensions_Switch_control *the_extension_switch; for ( the_node = _Chain_First( &_User_extensions_Switches_list ); 10e6cd: 81 fb 78 75 12 00 cmp $0x127578,%ebx 10e6d3: 74 18 je 10e6ed <_User_extensions_Thread_switch+0x35><== NEVER TAKEN 10e6d5: 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 ); 10e6d8: 83 ec 08 sub $0x8,%esp 10e6db: 56 push %esi 10e6dc: 57 push %edi 10e6dd: 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 ) { 10e6e0: 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 ); 10e6e2: 83 c4 10 add $0x10,%esp 10e6e5: 81 fb 78 75 12 00 cmp $0x127578,%ebx 10e6eb: 75 eb jne 10e6d8 <_User_extensions_Thread_switch+0x20> the_extension_switch = (User_extensions_Switch_control *) the_node; (*the_extension_switch->thread_switch)( executing, heir ); } } 10e6ed: 8d 65 f4 lea -0xc(%ebp),%esp 10e6f0: 5b pop %ebx 10e6f1: 5e pop %esi 10e6f2: 5f pop %edi 10e6f3: c9 leave 10e6f4: c3 ret =============================================================================== 0010fff8 <_Watchdog_Adjust>: void _Watchdog_Adjust( Chain_Control *header, Watchdog_Adjust_directions direction, Watchdog_Interval units ) { 10fff8: 55 push %ebp 10fff9: 89 e5 mov %esp,%ebp 10fffb: 57 push %edi 10fffc: 56 push %esi 10fffd: 53 push %ebx 10fffe: 83 ec 1c sub $0x1c,%esp 110001: 8b 75 08 mov 0x8(%ebp),%esi 110004: 8b 4d 0c mov 0xc(%ebp),%ecx 110007: 8b 5d 10 mov 0x10(%ebp),%ebx ISR_Level level; _ISR_Disable( level ); 11000a: 9c pushf 11000b: fa cli 11000c: 58 pop %eax } } _ISR_Enable( level ); } 11000d: 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 ); 11000f: 8d 7e 04 lea 0x4(%esi),%edi 110012: 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 ) ) { 110015: 39 fa cmp %edi,%edx 110017: 74 3d je 110056 <_Watchdog_Adjust+0x5e> switch ( direction ) { 110019: 85 c9 test %ecx,%ecx 11001b: 75 43 jne 110060 <_Watchdog_Adjust+0x68> case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; break; case WATCHDOG_FORWARD: while ( units ) { 11001d: 85 db test %ebx,%ebx 11001f: 74 35 je 110056 <_Watchdog_Adjust+0x5e> <== NEVER TAKEN if ( units < _Watchdog_First( header )->delta_interval ) { 110021: 8b 7a 10 mov 0x10(%edx),%edi 110024: 39 fb cmp %edi,%ebx 110026: 73 0f jae 110037 <_Watchdog_Adjust+0x3f> <== ALWAYS TAKEN 110028: eb 3e jmp 110068 <_Watchdog_Adjust+0x70> <== NOT EXECUTED 11002a: 66 90 xchg %ax,%ax <== NOT EXECUTED switch ( direction ) { case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; break; case WATCHDOG_FORWARD: while ( units ) { 11002c: 29 fb sub %edi,%ebx 11002e: 74 26 je 110056 <_Watchdog_Adjust+0x5e> <== NEVER TAKEN if ( units < _Watchdog_First( header )->delta_interval ) { 110030: 8b 7a 10 mov 0x10(%edx),%edi 110033: 39 df cmp %ebx,%edi 110035: 77 31 ja 110068 <_Watchdog_Adjust+0x70> _Watchdog_First( header )->delta_interval -= units; break; } else { units -= _Watchdog_First( header )->delta_interval; _Watchdog_First( header )->delta_interval = 1; 110037: c7 42 10 01 00 00 00 movl $0x1,0x10(%edx) _ISR_Enable( level ); 11003e: 50 push %eax 11003f: 9d popf _Watchdog_Tickle( header ); 110040: 83 ec 0c sub $0xc,%esp 110043: 56 push %esi 110044: e8 d3 01 00 00 call 11021c <_Watchdog_Tickle> _ISR_Disable( level ); 110049: 9c pushf 11004a: fa cli 11004b: 58 pop %eax } } _ISR_Enable( level ); } 11004c: 8b 16 mov (%esi),%edx _Watchdog_Tickle( header ); _ISR_Disable( level ); if ( _Chain_Is_empty( header ) ) 11004e: 83 c4 10 add $0x10,%esp 110051: 39 55 e4 cmp %edx,-0x1c(%ebp) 110054: 75 d6 jne 11002c <_Watchdog_Adjust+0x34> } break; } } _ISR_Enable( level ); 110056: 50 push %eax 110057: 9d popf } 110058: 8d 65 f4 lea -0xc(%ebp),%esp 11005b: 5b pop %ebx 11005c: 5e pop %esi 11005d: 5f pop %edi 11005e: c9 leave 11005f: c3 ret * unmodified across that call. * * Till Straumann, 7/2003 */ if ( !_Chain_Is_empty( header ) ) { switch ( direction ) { 110060: 49 dec %ecx 110061: 75 f3 jne 110056 <_Watchdog_Adjust+0x5e> <== NEVER TAKEN case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; 110063: 01 5a 10 add %ebx,0x10(%edx) break; 110066: eb ee jmp 110056 <_Watchdog_Adjust+0x5e> case WATCHDOG_FORWARD: while ( units ) { if ( units < _Watchdog_First( header )->delta_interval ) { _Watchdog_First( header )->delta_interval -= units; 110068: 29 df sub %ebx,%edi 11006a: 89 7a 10 mov %edi,0x10(%edx) break; 11006d: eb e7 jmp 110056 <_Watchdog_Adjust+0x5e> =============================================================================== 0010e6f8 <_Watchdog_Insert>: void _Watchdog_Insert( Chain_Control *header, Watchdog_Control *the_watchdog ) { 10e6f8: 55 push %ebp 10e6f9: 89 e5 mov %esp,%ebp 10e6fb: 57 push %edi 10e6fc: 56 push %esi 10e6fd: 53 push %ebx 10e6fe: 83 ec 04 sub $0x4,%esp 10e701: 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; 10e704: 8b 3d 54 7b 12 00 mov 0x127b54,%edi _ISR_Disable( level ); 10e70a: 9c pushf 10e70b: fa cli 10e70c: 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 ) { 10e70f: 8b 43 08 mov 0x8(%ebx),%eax 10e712: 85 c0 test %eax,%eax 10e714: 0f 85 9e 00 00 00 jne 10e7b8 <_Watchdog_Insert+0xc0> _ISR_Enable( level ); return; } the_watchdog->state = WATCHDOG_BEING_INSERTED; 10e71a: c7 43 08 01 00 00 00 movl $0x1,0x8(%ebx) _Watchdog_Sync_count++; 10e721: a1 e0 76 12 00 mov 0x1276e0,%eax 10e726: 40 inc %eax 10e727: a3 e0 76 12 00 mov %eax,0x1276e0 restart: delta_interval = the_watchdog->initial; 10e72c: 8b 43 0c mov 0xc(%ebx),%eax RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First( Chain_Control *header ) { return ( (Watchdog_Control *) _Chain_First( header ) ); 10e72f: 8b 4d 08 mov 0x8(%ebp),%ecx 10e732: 8b 11 mov (%ecx),%edx for ( after = _Watchdog_First( header ) ; ; after = _Watchdog_Next( after ) ) { if ( delta_interval == 0 || !_Watchdog_Next( after ) ) 10e734: 85 c0 test %eax,%eax 10e736: 74 5d je 10e795 <_Watchdog_Insert+0x9d> 10e738: 8b 32 mov (%edx),%esi 10e73a: 85 f6 test %esi,%esi 10e73c: 74 57 je 10e795 <_Watchdog_Insert+0x9d> break; if ( delta_interval < after->delta_interval ) { 10e73e: 8b 4a 10 mov 0x10(%edx),%ecx 10e741: 39 c8 cmp %ecx,%eax 10e743: 73 22 jae 10e767 <_Watchdog_Insert+0x6f> 10e745: eb 49 jmp 10e790 <_Watchdog_Insert+0x98> 10e747: 90 nop if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { goto exit_insert; } if ( _Watchdog_Sync_level > insert_isr_nest_level ) { 10e748: 8b 35 60 76 12 00 mov 0x127660,%esi 10e74e: 39 f7 cmp %esi,%edi 10e750: 72 72 jb 10e7c4 <_Watchdog_Insert+0xcc> if ( delta_interval < after->delta_interval ) { after->delta_interval -= delta_interval; break; } delta_interval -= after->delta_interval; 10e752: 29 c8 sub %ecx,%eax exit_insert: _Watchdog_Sync_level = insert_isr_nest_level; _Watchdog_Sync_count--; _ISR_Enable( level ); } 10e754: 8b 12 mov (%edx),%edx for ( after = _Watchdog_First( header ) ; ; after = _Watchdog_Next( after ) ) { if ( delta_interval == 0 || !_Watchdog_Next( after ) ) 10e756: 85 c0 test %eax,%eax 10e758: 74 3b je 10e795 <_Watchdog_Insert+0x9d> 10e75a: 8b 0a mov (%edx),%ecx 10e75c: 85 c9 test %ecx,%ecx 10e75e: 74 35 je 10e795 <_Watchdog_Insert+0x9d> break; if ( delta_interval < after->delta_interval ) { 10e760: 8b 4a 10 mov 0x10(%edx),%ecx 10e763: 39 c1 cmp %eax,%ecx 10e765: 77 29 ja 10e790 <_Watchdog_Insert+0x98> break; } delta_interval -= after->delta_interval; _ISR_Flash( level ); 10e767: ff 75 f0 pushl -0x10(%ebp) 10e76a: 9d popf 10e76b: fa cli if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { 10e76c: 83 7b 08 01 cmpl $0x1,0x8(%ebx) 10e770: 74 d6 je 10e748 <_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; 10e772: 89 3d 60 76 12 00 mov %edi,0x127660 _Watchdog_Sync_count--; 10e778: a1 e0 76 12 00 mov 0x1276e0,%eax 10e77d: 48 dec %eax 10e77e: a3 e0 76 12 00 mov %eax,0x1276e0 _ISR_Enable( level ); 10e783: ff 75 f0 pushl -0x10(%ebp) 10e786: 9d popf } 10e787: 58 pop %eax 10e788: 5b pop %ebx 10e789: 5e pop %esi 10e78a: 5f pop %edi 10e78b: c9 leave 10e78c: c3 ret 10e78d: 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; 10e790: 29 c1 sub %eax,%ecx 10e792: 89 4a 10 mov %ecx,0x10(%edx) RTEMS_INLINE_ROUTINE void _Watchdog_Activate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_ACTIVE; 10e795: c7 43 08 02 00 00 00 movl $0x2,0x8(%ebx) } } _Watchdog_Activate( the_watchdog ); the_watchdog->delta_interval = delta_interval; 10e79c: 89 43 10 mov %eax,0x10(%ebx) _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node ); 10e79f: 8b 42 04 mov 0x4(%edx),%eax Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 10e7a2: 89 43 04 mov %eax,0x4(%ebx) before_node = after_node->next; 10e7a5: 8b 10 mov (%eax),%edx after_node->next = the_node; 10e7a7: 89 18 mov %ebx,(%eax) the_node->next = before_node; 10e7a9: 89 13 mov %edx,(%ebx) before_node->previous = the_node; 10e7ab: 89 5a 04 mov %ebx,0x4(%edx) the_watchdog->start_time = _Watchdog_Ticks_since_boot; 10e7ae: a1 e4 76 12 00 mov 0x1276e4,%eax 10e7b3: 89 43 14 mov %eax,0x14(%ebx) 10e7b6: eb ba jmp 10e772 <_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 ); 10e7b8: ff 75 f0 pushl -0x10(%ebp) 10e7bb: 9d popf exit_insert: _Watchdog_Sync_level = insert_isr_nest_level; _Watchdog_Sync_count--; _ISR_Enable( level ); } 10e7bc: 58 pop %eax 10e7bd: 5b pop %ebx 10e7be: 5e pop %esi 10e7bf: 5f pop %edi 10e7c0: c9 leave 10e7c1: c3 ret 10e7c2: 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; 10e7c4: 89 3d 60 76 12 00 mov %edi,0x127660 goto restart; 10e7ca: e9 5d ff ff ff jmp 10e72c <_Watchdog_Insert+0x34> =============================================================================== 0010e838 <_Watchdog_Remove>: */ Watchdog_States _Watchdog_Remove( Watchdog_Control *the_watchdog ) { 10e838: 55 push %ebp 10e839: 89 e5 mov %esp,%ebp 10e83b: 56 push %esi 10e83c: 53 push %ebx 10e83d: 8b 55 08 mov 0x8(%ebp),%edx ISR_Level level; Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); 10e840: 9c pushf 10e841: fa cli 10e842: 59 pop %ecx previous_state = the_watchdog->state; 10e843: 8b 42 08 mov 0x8(%edx),%eax switch ( previous_state ) { 10e846: 83 f8 01 cmp $0x1,%eax 10e849: 74 4d je 10e898 <_Watchdog_Remove+0x60> 10e84b: 73 0f jae 10e85c <_Watchdog_Remove+0x24> _Watchdog_Sync_level = _ISR_Nest_level; _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 10e84d: 8b 1d e4 76 12 00 mov 0x1276e4,%ebx 10e853: 89 5a 18 mov %ebx,0x18(%edx) _ISR_Enable( level ); 10e856: 51 push %ecx 10e857: 9d popf return( previous_state ); } 10e858: 5b pop %ebx 10e859: 5e pop %esi 10e85a: c9 leave 10e85b: c3 ret Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); previous_state = the_watchdog->state; switch ( previous_state ) { 10e85c: 83 f8 03 cmp $0x3,%eax 10e85f: 77 ec ja 10e84d <_Watchdog_Remove+0x15> <== NEVER TAKEN break; case WATCHDOG_ACTIVE: case WATCHDOG_REMOVE_IT: the_watchdog->state = WATCHDOG_INACTIVE; 10e861: 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 ); } 10e868: 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) ) 10e86a: 8b 33 mov (%ebx),%esi 10e86c: 85 f6 test %esi,%esi 10e86e: 74 06 je 10e876 <_Watchdog_Remove+0x3e> next_watchdog->delta_interval += the_watchdog->delta_interval; 10e870: 8b 72 10 mov 0x10(%edx),%esi 10e873: 01 73 10 add %esi,0x10(%ebx) if ( _Watchdog_Sync_count ) 10e876: 8b 35 e0 76 12 00 mov 0x1276e0,%esi 10e87c: 85 f6 test %esi,%esi 10e87e: 74 0c je 10e88c <_Watchdog_Remove+0x54> _Watchdog_Sync_level = _ISR_Nest_level; 10e880: 8b 35 54 7b 12 00 mov 0x127b54,%esi 10e886: 89 35 60 76 12 00 mov %esi,0x127660 { Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; 10e88c: 8b 72 04 mov 0x4(%edx),%esi next->previous = previous; 10e88f: 89 73 04 mov %esi,0x4(%ebx) previous->next = next; 10e892: 89 1e mov %ebx,(%esi) 10e894: eb b7 jmp 10e84d <_Watchdog_Remove+0x15> 10e896: 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; 10e898: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx) break; 10e89f: eb ac jmp 10e84d <_Watchdog_Remove+0x15> =============================================================================== 0010fbec <_Watchdog_Report>: void _Watchdog_Report( const char *name, Watchdog_Control *watch ) { 10fbec: 55 push %ebp 10fbed: 89 e5 mov %esp,%ebp 10fbef: 57 push %edi 10fbf0: 56 push %esi 10fbf1: 53 push %ebx 10fbf2: 83 ec 2c sub $0x2c,%esp 10fbf5: 8b 55 08 mov 0x8(%ebp),%edx 10fbf8: 8b 45 0c mov 0xc(%ebp),%eax printk( 10fbfb: 8b 78 24 mov 0x24(%eax),%edi 10fbfe: 8b 70 20 mov 0x20(%eax),%esi 10fc01: 8b 58 1c mov 0x1c(%eax),%ebx 10fc04: 8b 48 0c mov 0xc(%eax),%ecx 10fc07: 89 4d d4 mov %ecx,-0x2c(%ebp) 10fc0a: 8b 48 10 mov 0x10(%eax),%ecx 10fc0d: 89 4d e4 mov %ecx,-0x1c(%ebp) 10fc10: 85 d2 test %edx,%edx 10fc12: 74 2c je 10fc40 <_Watchdog_Report+0x54> 10fc14: b9 a3 2c 12 00 mov $0x122ca3,%ecx 10fc19: 83 ec 0c sub $0xc,%esp 10fc1c: 57 push %edi 10fc1d: 56 push %esi 10fc1e: 53 push %ebx 10fc1f: 50 push %eax 10fc20: ff 75 d4 pushl -0x2c(%ebp) 10fc23: ff 75 e4 pushl -0x1c(%ebp) 10fc26: 51 push %ecx 10fc27: 52 push %edx 10fc28: 68 06 37 12 00 push $0x123706 10fc2d: e8 66 9e ff ff call 109a98 10fc32: 83 c4 30 add $0x30,%esp watch, watch->routine, watch->id, watch->user_data ); } 10fc35: 8d 65 f4 lea -0xc(%ebp),%esp 10fc38: 5b pop %ebx 10fc39: 5e pop %esi 10fc3a: 5f pop %edi 10fc3b: c9 leave 10fc3c: c3 ret 10fc3d: 8d 76 00 lea 0x0(%esi),%esi void _Watchdog_Report( const char *name, Watchdog_Control *watch ) { printk( 10fc40: b9 69 35 12 00 mov $0x123569,%ecx 10fc45: 89 ca mov %ecx,%edx 10fc47: eb d0 jmp 10fc19 <_Watchdog_Report+0x2d> =============================================================================== 0010fb7c <_Watchdog_Report_chain>: void _Watchdog_Report_chain( const char *name, Chain_Control *header ) { 10fb7c: 55 push %ebp 10fb7d: 89 e5 mov %esp,%ebp 10fb7f: 57 push %edi 10fb80: 56 push %esi 10fb81: 53 push %ebx 10fb82: 83 ec 20 sub $0x20,%esp 10fb85: 8b 7d 08 mov 0x8(%ebp),%edi 10fb88: 8b 75 0c mov 0xc(%ebp),%esi ISR_Level level; Chain_Node *node; _ISR_Disable( level ); 10fb8b: 9c pushf 10fb8c: fa cli 10fb8d: 8f 45 e4 popl -0x1c(%ebp) printk( "Watchdog Chain: %s %p\n", name, header ); 10fb90: 56 push %esi 10fb91: 57 push %edi 10fb92: 68 d0 36 12 00 push $0x1236d0 10fb97: e8 fc 9e ff ff call 109a98 printk( "== end of %s \n", name ); } else { printk( "Chain is empty\n" ); } _ISR_Enable( level ); } 10fb9c: 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 ); 10fb9e: 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 ) ) { 10fba1: 83 c4 10 add $0x10,%esp 10fba4: 39 f3 cmp %esi,%ebx 10fba6: 74 31 je 10fbd9 <_Watchdog_Report_chain+0x5d> node != _Chain_Tail(header) ; node = node->next ) { Watchdog_Control *watch = (Watchdog_Control *) node; _Watchdog_Report( NULL, watch ); 10fba8: 83 ec 08 sub $0x8,%esp 10fbab: 53 push %ebx 10fbac: 6a 00 push $0x0 10fbae: e8 39 00 00 00 call 10fbec <_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 ) 10fbb3: 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 ) ; 10fbb5: 83 c4 10 add $0x10,%esp 10fbb8: 39 f3 cmp %esi,%ebx 10fbba: 75 ec jne 10fba8 <_Watchdog_Report_chain+0x2c><== NEVER TAKEN { Watchdog_Control *watch = (Watchdog_Control *) node; _Watchdog_Report( NULL, watch ); } printk( "== end of %s \n", name ); 10fbbc: 83 ec 08 sub $0x8,%esp 10fbbf: 57 push %edi 10fbc0: 68 e7 36 12 00 push $0x1236e7 10fbc5: e8 ce 9e ff ff call 109a98 10fbca: 83 c4 10 add $0x10,%esp } else { printk( "Chain is empty\n" ); } _ISR_Enable( level ); 10fbcd: ff 75 e4 pushl -0x1c(%ebp) 10fbd0: 9d popf } 10fbd1: 8d 65 f4 lea -0xc(%ebp),%esp 10fbd4: 5b pop %ebx 10fbd5: 5e pop %esi 10fbd6: 5f pop %edi 10fbd7: c9 leave 10fbd8: c3 ret _Watchdog_Report( NULL, watch ); } printk( "== end of %s \n", name ); } else { printk( "Chain is empty\n" ); 10fbd9: 83 ec 0c sub $0xc,%esp 10fbdc: 68 f6 36 12 00 push $0x1236f6 10fbe1: e8 b2 9e ff ff call 109a98 10fbe6: 83 c4 10 add $0x10,%esp 10fbe9: eb e2 jmp 10fbcd <_Watchdog_Report_chain+0x51> =============================================================================== 0010e8a4 <_Watchdog_Tickle>: */ void _Watchdog_Tickle( Chain_Control *header ) { 10e8a4: 55 push %ebp 10e8a5: 89 e5 mov %esp,%ebp 10e8a7: 57 push %edi 10e8a8: 56 push %esi 10e8a9: 53 push %ebx 10e8aa: 83 ec 1c sub $0x1c,%esp 10e8ad: 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 ); 10e8b0: 9c pushf 10e8b1: fa cli 10e8b2: 5e pop %esi } while ( !_Chain_Is_empty( header ) && (the_watchdog->delta_interval == 0) ); leave: _ISR_Enable(level); } 10e8b3: 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 ); 10e8b5: 8d 47 04 lea 0x4(%edi),%eax 10e8b8: 89 45 e4 mov %eax,-0x1c(%ebp) * volatile data - till, 2003/7 */ _ISR_Disable( level ); if ( _Chain_Is_empty( header ) ) 10e8bb: 39 c3 cmp %eax,%ebx 10e8bd: 74 11 je 10e8d0 <_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) { 10e8bf: 8b 43 10 mov 0x10(%ebx),%eax 10e8c2: 85 c0 test %eax,%eax 10e8c4: 74 34 je 10e8fa <_Watchdog_Tickle+0x56> the_watchdog->delta_interval--; 10e8c6: 48 dec %eax 10e8c7: 89 43 10 mov %eax,0x10(%ebx) if ( the_watchdog->delta_interval != 0 ) 10e8ca: 85 c0 test %eax,%eax 10e8cc: 74 2c je 10e8fa <_Watchdog_Tickle+0x56> 10e8ce: 66 90 xchg %ax,%ax the_watchdog = _Watchdog_First( header ); } while ( !_Chain_Is_empty( header ) && (the_watchdog->delta_interval == 0) ); leave: _ISR_Enable(level); 10e8d0: 56 push %esi 10e8d1: 9d popf } 10e8d2: 8d 65 f4 lea -0xc(%ebp),%esp 10e8d5: 5b pop %ebx 10e8d6: 5e pop %esi 10e8d7: 5f pop %edi 10e8d8: c9 leave 10e8d9: c3 ret _ISR_Enable( level ); switch( watchdog_state ) { case WATCHDOG_ACTIVE: (*the_watchdog->routine)( 10e8da: 83 ec 08 sub $0x8,%esp 10e8dd: ff 73 24 pushl 0x24(%ebx) 10e8e0: ff 73 20 pushl 0x20(%ebx) 10e8e3: ff 53 1c call *0x1c(%ebx) the_watchdog->id, the_watchdog->user_data ); break; 10e8e6: 83 c4 10 add $0x10,%esp case WATCHDOG_REMOVE_IT: break; } _ISR_Disable( level ); 10e8e9: 9c pushf 10e8ea: fa cli 10e8eb: 5e pop %esi } while ( !_Chain_Is_empty( header ) && (the_watchdog->delta_interval == 0) ); leave: _ISR_Enable(level); } 10e8ec: 8b 1f mov (%edi),%ebx _ISR_Disable( level ); the_watchdog = _Watchdog_First( header ); } while ( !_Chain_Is_empty( header ) && (the_watchdog->delta_interval == 0) ); 10e8ee: 3b 5d e4 cmp -0x1c(%ebp),%ebx 10e8f1: 74 dd je 10e8d0 <_Watchdog_Tickle+0x2c> } _ISR_Disable( level ); the_watchdog = _Watchdog_First( header ); } while ( !_Chain_Is_empty( header ) && 10e8f3: 8b 43 10 mov 0x10(%ebx),%eax 10e8f6: 85 c0 test %eax,%eax 10e8f8: 75 d6 jne 10e8d0 <_Watchdog_Tickle+0x2c> if ( the_watchdog->delta_interval != 0 ) goto leave; } do { watchdog_state = _Watchdog_Remove( the_watchdog ); 10e8fa: 83 ec 0c sub $0xc,%esp 10e8fd: 53 push %ebx 10e8fe: e8 35 ff ff ff call 10e838 <_Watchdog_Remove> _ISR_Enable( level ); 10e903: 56 push %esi 10e904: 9d popf switch( watchdog_state ) { 10e905: 83 c4 10 add $0x10,%esp 10e908: 83 f8 02 cmp $0x2,%eax 10e90b: 75 dc jne 10e8e9 <_Watchdog_Tickle+0x45> <== NEVER TAKEN 10e90d: eb cb jmp 10e8da <_Watchdog_Tickle+0x36> =============================================================================== 0010e910 <_Workspace_Handler_initialization>: /* * _Workspace_Handler_initialization */ void _Workspace_Handler_initialization(void) { 10e910: 55 push %ebp 10e911: 89 e5 mov %esp,%ebp 10e913: 57 push %edi 10e914: 53 push %ebx uintptr_t memory_available = 0; void *starting_address = Configuration.work_space_start; 10e915: 8b 1d 80 32 12 00 mov 0x123280,%ebx uintptr_t size = Configuration.work_space_size; 10e91b: 8b 15 84 32 12 00 mov 0x123284,%edx if ( Configuration.do_zero_of_workspace ) 10e921: 80 3d ac 32 12 00 00 cmpb $0x0,0x1232ac 10e928: 75 1e jne 10e948 <_Workspace_Handler_initialization+0x38> memset( starting_address, 0, size ); memory_available = _Heap_Initialize( 10e92a: 6a 04 push $0x4 10e92c: 52 push %edx 10e92d: 53 push %ebx 10e92e: 68 a0 75 12 00 push $0x1275a0 10e933: e8 b8 dd ff ff call 10c6f0 <_Heap_Initialize> starting_address, size, CPU_HEAP_ALIGNMENT ); if ( memory_available == 0 ) 10e938: 83 c4 10 add $0x10,%esp 10e93b: 85 c0 test %eax,%eax 10e93d: 74 13 je 10e952 <_Workspace_Handler_initialization+0x42> _Internal_error_Occurred( INTERNAL_ERROR_CORE, true, INTERNAL_ERROR_TOO_LITTLE_WORKSPACE ); } 10e93f: 8d 65 f8 lea -0x8(%ebp),%esp 10e942: 5b pop %ebx 10e943: 5f pop %edi 10e944: c9 leave 10e945: c3 ret 10e946: 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 ); 10e948: 31 c0 xor %eax,%eax 10e94a: 89 df mov %ebx,%edi 10e94c: 89 d1 mov %edx,%ecx 10e94e: f3 aa rep stos %al,%es:(%edi) 10e950: eb d8 jmp 10e92a <_Workspace_Handler_initialization+0x1a> size, CPU_HEAP_ALIGNMENT ); if ( memory_available == 0 ) _Internal_error_Occurred( 10e952: 50 push %eax 10e953: 6a 02 push $0x2 10e955: 6a 01 push $0x1 10e957: 6a 00 push $0x0 10e959: e8 9a df ff ff call 10c8f8 <_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 76 a9 00 00 call 116f64 <__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 35 12 00 mov 0x1235ac,%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 78 7e 12 00 mov 0x127e78,%eax 10adc0: 05 84 00 00 00 add $0x84,%eax 10adc5: 50 push %eax 10adc6: e8 61 38 00 00 call 10e62c <_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 ff 87 00 00 call 1135f4 <__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 8c 47 12 00 cmp 0x12478c,%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 b0 8b 12 00 mov 0x128bb0,%eax 10b641: 40 inc %eax 10b642: a3 b0 8b 12 00 mov %eax,0x128bb0 * 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 89 17 00 00 call 10cddc <_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 ac 17 00 00 call 10ce64 <_TOD_Set> _Thread_Enable_dispatch(); 10b6b8: e8 ef 2b 00 00 call 10e2ac <_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 e7 86 00 00 call 113dc8 <__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 80 a1 12 00 push $0x12a180 10bd28: e8 73 11 00 00 call 10cea0 if (fcntl (fildes, F_GETFD) < 0) { 10bd2d: 5f pop %edi 10bd2e: 58 pop %eax 10bd2f: 6a 01 push $0x1 10bd31: 56 push %esi 10bd32: e8 91 6a 00 00 call 1127c8 10bd37: 83 c4 10 add $0x10,%esp 10bd3a: 85 c0 test %eax,%eax 10bd3c: 0f 88 73 01 00 00 js 10beb5 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 82 00 00 00 je 10bdcc 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 3c 01 00 00 jne 10be90 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: 52 push %edx 10bd55: 6a 00 push $0x0 10bd57: 57 push %edi 10bd58: 68 c8 a1 12 00 push $0x12a1c8 10bd5d: e8 76 03 00 00 call 10c0d8 if (r_chain == NULL) { 10bd62: 83 c4 10 add $0x10,%esp 10bd65: 85 c0 test %eax,%eax 10bd67: 74 0f je 10bd78 pthread_mutex_unlock (&r_chain->mutex); pthread_mutex_unlock (&aio_request_queue.mutex); return result; } } return AIO_ALLDONE; 10bd69: bb 02 00 00 00 mov $0x2,%ebx } 10bd6e: 89 d8 mov %ebx,%eax 10bd70: 8d 65 f4 lea -0xc(%ebp),%esp 10bd73: 5b pop %ebx 10bd74: 5e pop %esi 10bd75: 5f pop %edi 10bd76: c9 leave 10bd77: c3 ret 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)) { 10bd78: 81 3d d4 a1 12 00 d8 cmpl $0x12a1d8,0x12a1d4 10bd7f: a1 12 00 10bd82: 0f 84 98 00 00 00 je 10be20 <== NEVER TAKEN r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0); 10bd88: 50 push %eax 10bd89: 6a 00 push $0x0 10bd8b: 57 push %edi 10bd8c: 68 d4 a1 12 00 push $0x12a1d4 10bd91: e8 42 03 00 00 call 10c0d8 if (r_chain == NULL) { 10bd96: 83 c4 10 add $0x10,%esp 10bd99: 85 c0 test %eax,%eax 10bd9b: 0f 84 ef 00 00 00 je 10be90 rtems_set_errno_and_return_minus_one (EINVAL); } AIO_printf ("Request on [IQ]\n"); result = rtems_aio_remove_req (&r_chain->perfd, aiocbp); 10bda1: 83 ec 08 sub $0x8,%esp 10bda4: 53 push %ebx 10bda5: 83 c0 08 add $0x8,%eax 10bda8: 50 push %eax 10bda9: e8 ee 06 00 00 call 10c49c 10bdae: 89 c3 mov %eax,%ebx pthread_mutex_unlock (&aio_request_queue.mutex); 10bdb0: c7 04 24 80 a1 12 00 movl $0x12a180,(%esp) 10bdb7: e8 6c 11 00 00 call 10cf28 return result; 10bdbc: 83 c4 10 add $0x10,%esp pthread_mutex_unlock (&aio_request_queue.mutex); return result; } } return AIO_ALLDONE; } 10bdbf: 89 d8 mov %ebx,%eax 10bdc1: 8d 65 f4 lea -0xc(%ebp),%esp 10bdc4: 5b pop %ebx 10bdc5: 5e pop %esi 10bdc6: 5f pop %edi 10bdc7: c9 leave 10bdc8: c3 ret 10bdc9: 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); 10bdcc: 53 push %ebx 10bdcd: 6a 00 push $0x0 10bdcf: 56 push %esi 10bdd0: 68 c8 a1 12 00 push $0x12a1c8 10bdd5: e8 fe 02 00 00 call 10c0d8 10bdda: 89 c3 mov %eax,%ebx if (r_chain == NULL) { 10bddc: 83 c4 10 add $0x10,%esp 10bddf: 85 c0 test %eax,%eax 10bde1: 74 59 je 10be3c return AIO_ALLDONE; } AIO_printf ("Request chain on [WQ]\n"); pthread_mutex_lock (&r_chain->mutex); 10bde3: 8d 70 1c lea 0x1c(%eax),%esi 10bde6: 83 ec 0c sub $0xc,%esp 10bde9: 56 push %esi 10bdea: e8 b1 10 00 00 call 10cea0 */ RTEMS_INLINE_ROUTINE void rtems_chain_extract( rtems_chain_node *the_node ) { _Chain_Extract( the_node ); 10bdef: 89 1c 24 mov %ebx,(%esp) 10bdf2: e8 7d 2a 00 00 call 10e874 <_Chain_Extract> rtems_chain_extract (&r_chain->next_fd); rtems_aio_remove_fd (r_chain); 10bdf7: 89 1c 24 mov %ebx,(%esp) 10bdfa: e8 4d 06 00 00 call 10c44c pthread_mutex_unlock (&r_chain->mutex); 10bdff: 89 34 24 mov %esi,(%esp) 10be02: e8 21 11 00 00 call 10cf28 pthread_mutex_unlock (&aio_request_queue.mutex); 10be07: c7 04 24 80 a1 12 00 movl $0x12a180,(%esp) 10be0e: e8 15 11 00 00 call 10cf28 return AIO_CANCELED; 10be13: 83 c4 10 add $0x10,%esp 10be16: 31 db xor %ebx,%ebx 10be18: e9 51 ff ff ff jmp 10bd6e 10be1d: 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); 10be20: 83 ec 0c sub $0xc,%esp 10be23: 68 80 a1 12 00 push $0x12a180 <== NOT EXECUTED 10be28: e8 fb 10 00 00 call 10cf28 <== NOT EXECUTED return AIO_ALLDONE; 10be2d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10be30: bb 02 00 00 00 mov $0x2,%ebx <== NOT EXECUTED 10be35: e9 34 ff ff ff jmp 10bd6e <== NOT EXECUTED 10be3a: 66 90 xchg %ax,%ax <== NOT EXECUTED 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)) { 10be3c: 81 3d d4 a1 12 00 d8 cmpl $0x12a1d8,0x12a1d4 10be43: a1 12 00 10be46: 74 d8 je 10be20 <== NEVER TAKEN r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0); 10be48: 51 push %ecx 10be49: 6a 00 push $0x0 10be4b: 56 push %esi 10be4c: 68 d4 a1 12 00 push $0x12a1d4 10be51: e8 82 02 00 00 call 10c0d8 10be56: 89 c3 mov %eax,%ebx if (r_chain == NULL) { 10be58: 83 c4 10 add $0x10,%esp 10be5b: 85 c0 test %eax,%eax 10be5d: 74 7b je 10beda 10be5f: 83 ec 0c sub $0xc,%esp 10be62: 50 push %eax 10be63: e8 0c 2a 00 00 call 10e874 <_Chain_Extract> } AIO_printf ("Request chain on [IQ]\n"); rtems_chain_extract (&r_chain->next_fd); rtems_aio_remove_fd (r_chain); 10be68: 89 1c 24 mov %ebx,(%esp) 10be6b: e8 dc 05 00 00 call 10c44c pthread_mutex_destroy (&r_chain->mutex); 10be70: 8d 73 1c lea 0x1c(%ebx),%esi 10be73: 89 34 24 mov %esi,(%esp) 10be76: e8 b9 0d 00 00 call 10cc34 pthread_cond_destroy (&r_chain->mutex); 10be7b: 89 34 24 mov %esi,(%esp) 10be7e: e8 6d 0a 00 00 call 10c8f0 free (r_chain); 10be83: 89 1c 24 mov %ebx,(%esp) 10be86: e8 a9 cc ff ff call 108b34 10be8b: e9 77 ff ff ff jmp 10be07 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); 10be90: 83 ec 0c sub $0xc,%esp 10be93: 68 80 a1 12 00 push $0x12a180 10be98: e8 8b 10 00 00 call 10cf28 rtems_set_errno_and_return_minus_one (EINVAL); 10be9d: e8 5a 9d 00 00 call 115bfc <__errno> 10bea2: c7 00 16 00 00 00 movl $0x16,(%eax) 10bea8: 83 c4 10 add $0x10,%esp 10beab: bb ff ff ff ff mov $0xffffffff,%ebx 10beb0: e9 b9 fe ff ff jmp 10bd6e int result; pthread_mutex_lock (&aio_request_queue.mutex); if (fcntl (fildes, F_GETFD) < 0) { pthread_mutex_unlock(&aio_request_queue.mutex); 10beb5: 83 ec 0c sub $0xc,%esp 10beb8: 68 80 a1 12 00 push $0x12a180 10bebd: e8 66 10 00 00 call 10cf28 rtems_set_errno_and_return_minus_one (EBADF); 10bec2: e8 35 9d 00 00 call 115bfc <__errno> 10bec7: c7 00 09 00 00 00 movl $0x9,(%eax) 10becd: 83 c4 10 add $0x10,%esp 10bed0: bb ff ff ff ff mov $0xffffffff,%ebx 10bed5: e9 94 fe ff ff jmp 10bd6e 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); 10beda: 83 ec 0c sub $0xc,%esp 10bedd: 68 80 a1 12 00 push $0x12a180 10bee2: e8 41 10 00 00 call 10cf28 return AIO_ALLDONE; 10bee7: 83 c4 10 add $0x10,%esp 10beea: b3 02 mov $0x2,%bl 10beec: e9 7d fe ff ff jmp 10bd6e =============================================================================== 0010bf00 : int aio_fsync( int op, struct aiocb *aiocbp ) { 10bf00: 55 push %ebp 10bf01: 89 e5 mov %esp,%ebp 10bf03: 53 push %ebx 10bf04: 83 ec 04 sub $0x4,%esp 10bf07: 8b 5d 0c mov 0xc(%ebp),%ebx rtems_aio_request *req; int mode; if (op != O_SYNC) 10bf0a: 81 7d 08 00 20 00 00 cmpl $0x2000,0x8(%ebp) 10bf11: 75 41 jne 10bf54 rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); mode = fcntl (aiocbp->aio_fildes, F_GETFL); 10bf13: 83 ec 08 sub $0x8,%esp 10bf16: 6a 03 push $0x3 10bf18: ff 33 pushl (%ebx) 10bf1a: e8 a9 68 00 00 call 1127c8 if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR))) 10bf1f: 83 e0 03 and $0x3,%eax 10bf22: 48 dec %eax 10bf23: 83 c4 10 add $0x10,%esp 10bf26: 83 f8 01 cmp $0x1,%eax 10bf29: 77 4d ja 10bf78 rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); req = malloc (sizeof (rtems_aio_request)); 10bf2b: 83 ec 0c sub $0xc,%esp 10bf2e: 6a 18 push $0x18 10bf30: e8 13 d1 ff ff call 109048 if (req == NULL) 10bf35: 83 c4 10 add $0x10,%esp 10bf38: 85 c0 test %eax,%eax 10bf3a: 74 57 je 10bf93 <== NEVER TAKEN rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); req->aiocbp = aiocbp; 10bf3c: 89 58 14 mov %ebx,0x14(%eax) req->aiocbp->aio_lio_opcode = LIO_SYNC; 10bf3f: c7 43 2c 03 00 00 00 movl $0x3,0x2c(%ebx) return rtems_aio_enqueue (req); 10bf46: 89 45 08 mov %eax,0x8(%ebp) } 10bf49: 8b 5d fc mov -0x4(%ebp),%ebx 10bf4c: 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); 10bf4d: e9 ba 05 00 00 jmp 10c50c 10bf52: 66 90 xchg %ax,%ax { rtems_aio_request *req; int mode; if (op != O_SYNC) rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); 10bf54: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx) 10bf5b: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10bf62: e8 95 9c 00 00 call 115bfc <__errno> 10bf67: c7 00 16 00 00 00 movl $0x16,(%eax) req->aiocbp = aiocbp; req->aiocbp->aio_lio_opcode = LIO_SYNC; return rtems_aio_enqueue (req); } 10bf6d: b8 ff ff ff ff mov $0xffffffff,%eax 10bf72: 8b 5d fc mov -0x4(%ebp),%ebx 10bf75: c9 leave 10bf76: c3 ret 10bf77: 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); 10bf78: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx) 10bf7f: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10bf86: e8 71 9c 00 00 call 115bfc <__errno> 10bf8b: c7 00 09 00 00 00 movl $0x9,(%eax) 10bf91: eb da jmp 10bf6d req = malloc (sizeof (rtems_aio_request)); if (req == NULL) rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); 10bf93: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) 10bf9a: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED 10bfa1: e8 56 9c 00 00 call 115bfc <__errno> <== NOT EXECUTED 10bfa6: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10bfac: eb bf jmp 10bf6d <== NOT EXECUTED =============================================================================== 0010c714 : * 0 - otherwise */ int aio_read (struct aiocb *aiocbp) { 10c714: 55 push %ebp 10c715: 89 e5 mov %esp,%ebp 10c717: 53 push %ebx 10c718: 83 ec 0c sub $0xc,%esp 10c71b: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_aio_request *req; int mode; mode = fcntl (aiocbp->aio_fildes, F_GETFL); 10c71e: 6a 03 push $0x3 10c720: ff 33 pushl (%ebx) 10c722: e8 a1 60 00 00 call 1127c8 if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR))) 10c727: 83 c4 10 add $0x10,%esp 10c72a: 83 e0 03 and $0x3,%eax 10c72d: 74 05 je 10c734 <== NEVER TAKEN 10c72f: 83 f8 02 cmp $0x2,%eax 10c732: 75 38 jne 10c76c rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX) 10c734: 8b 53 14 mov 0x14(%ebx),%edx 10c737: 85 d2 test %edx,%edx 10c739: 75 55 jne 10c790 rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); if (aiocbp->aio_offset < 0) 10c73b: 8b 43 08 mov 0x8(%ebx),%eax 10c73e: 85 c0 test %eax,%eax 10c740: 78 4e js 10c790 rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); req = malloc (sizeof (rtems_aio_request)); 10c742: 83 ec 0c sub $0xc,%esp 10c745: 6a 18 push $0x18 10c747: e8 fc c8 ff ff call 109048 if (req == NULL) 10c74c: 83 c4 10 add $0x10,%esp 10c74f: 85 c0 test %eax,%eax 10c751: 74 58 je 10c7ab <== NEVER TAKEN rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); req->aiocbp = aiocbp; 10c753: 89 58 14 mov %ebx,0x14(%eax) req->aiocbp->aio_lio_opcode = LIO_READ; 10c756: c7 43 2c 01 00 00 00 movl $0x1,0x2c(%ebx) return rtems_aio_enqueue (req); 10c75d: 89 45 08 mov %eax,0x8(%ebp) } 10c760: 8b 5d fc mov -0x4(%ebp),%ebx 10c763: 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); 10c764: e9 a3 fd ff ff jmp 10c50c 10c769: 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); 10c76c: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx) 10c773: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10c77a: e8 7d 94 00 00 call 115bfc <__errno> 10c77f: c7 00 09 00 00 00 movl $0x9,(%eax) req->aiocbp = aiocbp; req->aiocbp->aio_lio_opcode = LIO_READ; return rtems_aio_enqueue (req); } 10c785: b8 ff ff ff ff mov $0xffffffff,%eax 10c78a: 8b 5d fc mov -0x4(%ebp),%ebx 10c78d: c9 leave 10c78e: c3 ret 10c78f: 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); 10c790: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx) 10c797: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10c79e: e8 59 94 00 00 call 115bfc <__errno> 10c7a3: c7 00 16 00 00 00 movl $0x16,(%eax) 10c7a9: eb da jmp 10c785 req = malloc (sizeof (rtems_aio_request)); if (req == NULL) rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); 10c7ab: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED 10c7b2: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED 10c7b9: e8 3e 94 00 00 call 115bfc <__errno> <== NOT EXECUTED 10c7be: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10c7c4: eb bf jmp 10c785 <== NOT EXECUTED =============================================================================== 0010c7d4 : * 0 - otherwise */ int aio_write (struct aiocb *aiocbp) { 10c7d4: 55 push %ebp 10c7d5: 89 e5 mov %esp,%ebp 10c7d7: 53 push %ebx 10c7d8: 83 ec 0c sub $0xc,%esp 10c7db: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_aio_request *req; int mode; mode = fcntl (aiocbp->aio_fildes, F_GETFL); 10c7de: 6a 03 push $0x3 10c7e0: ff 33 pushl (%ebx) 10c7e2: e8 e1 5f 00 00 call 1127c8 if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR))) 10c7e7: 83 e0 03 and $0x3,%eax 10c7ea: 48 dec %eax 10c7eb: 83 c4 10 add $0x10,%esp 10c7ee: 83 f8 01 cmp $0x1,%eax 10c7f1: 77 35 ja 10c828 rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX) 10c7f3: 8b 53 14 mov 0x14(%ebx),%edx 10c7f6: 85 d2 test %edx,%edx 10c7f8: 75 52 jne 10c84c rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); if (aiocbp->aio_offset < 0) 10c7fa: 8b 43 08 mov 0x8(%ebx),%eax 10c7fd: 85 c0 test %eax,%eax 10c7ff: 78 4b js 10c84c rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); req = malloc (sizeof (rtems_aio_request)); 10c801: 83 ec 0c sub $0xc,%esp 10c804: 6a 18 push $0x18 10c806: e8 3d c8 ff ff call 109048 if (req == NULL) 10c80b: 83 c4 10 add $0x10,%esp 10c80e: 85 c0 test %eax,%eax 10c810: 74 55 je 10c867 <== NEVER TAKEN rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); req->aiocbp = aiocbp; 10c812: 89 58 14 mov %ebx,0x14(%eax) req->aiocbp->aio_lio_opcode = LIO_WRITE; 10c815: c7 43 2c 02 00 00 00 movl $0x2,0x2c(%ebx) return rtems_aio_enqueue (req); 10c81c: 89 45 08 mov %eax,0x8(%ebp) } 10c81f: 8b 5d fc mov -0x4(%ebp),%ebx 10c822: 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); 10c823: e9 e4 fc ff ff jmp 10c50c 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); 10c828: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx) 10c82f: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10c836: e8 c1 93 00 00 call 115bfc <__errno> 10c83b: c7 00 09 00 00 00 movl $0x9,(%eax) req->aiocbp = aiocbp; req->aiocbp->aio_lio_opcode = LIO_WRITE; return rtems_aio_enqueue (req); } 10c841: b8 ff ff ff ff mov $0xffffffff,%eax 10c846: 8b 5d fc mov -0x4(%ebp),%ebx 10c849: c9 leave 10c84a: c3 ret 10c84b: 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); 10c84c: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx) 10c853: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10c85a: e8 9d 93 00 00 call 115bfc <__errno> 10c85f: c7 00 16 00 00 00 movl $0x16,(%eax) 10c865: eb da jmp 10c841 req = malloc (sizeof (rtems_aio_request)); if (req == NULL) rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); 10c867: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED 10c86e: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED 10c875: e8 82 93 00 00 call 115bfc <__errno> <== NOT EXECUTED 10c87a: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10c880: eb bf jmp 10c841 <== 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 6f bb 00 00 call 114e8c <__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 =============================================================================== 001106a8 : #include int chdir( const char *pathname ) { 1106a8: 55 push %ebp 1106a9: 89 e5 mov %esp,%ebp 1106ab: 57 push %edi 1106ac: 56 push %esi 1106ad: 83 ec 20 sub $0x20,%esp 1106b0: 8b 55 08 mov 0x8(%ebp),%edx rtems_filesystem_location_info_t loc; int result; if ( !pathname ) 1106b3: 85 d2 test %edx,%edx 1106b5: 74 75 je 11072c rtems_set_errno_and_return_minus_one( EFAULT ); /* * Get the node where we wish to go. */ result = rtems_filesystem_evaluate_path( 1106b7: 31 c0 xor %eax,%eax 1106b9: b9 ff ff ff ff mov $0xffffffff,%ecx 1106be: 89 d7 mov %edx,%edi 1106c0: f2 ae repnz scas %es:(%edi),%al 1106c2: f7 d1 not %ecx 1106c4: 49 dec %ecx 1106c5: 83 ec 0c sub $0xc,%esp 1106c8: 6a 01 push $0x1 1106ca: 8d 75 e4 lea -0x1c(%ebp),%esi 1106cd: 56 push %esi 1106ce: 6a 01 push $0x1 1106d0: 51 push %ecx 1106d1: 52 push %edx 1106d2: e8 31 7d ff ff call 108408 pathname, strlen( pathname ), RTEMS_LIBIO_PERMS_SEARCH, &loc, true ); if ( result != 0 ) 1106d7: 83 c4 20 add $0x20,%esp 1106da: 85 c0 test %eax,%eax 1106dc: 74 0e je 1106ec return -1; 1106de: b8 ff ff ff ff mov $0xffffffff,%eax rtems_filesystem_freenode( &rtems_filesystem_current ); rtems_filesystem_current = loc; return 0; } 1106e3: 8d 65 f8 lea -0x8(%ebp),%esp 1106e6: 5e pop %esi 1106e7: 5f pop %edi 1106e8: c9 leave 1106e9: c3 ret 1106ea: 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 ) { 1106ec: 83 ec 0c sub $0xc,%esp 1106ef: 56 push %esi 1106f0: 8b 45 f0 mov -0x10(%ebp),%eax 1106f3: ff 50 10 call *0x10(%eax) 1106f6: 83 c4 10 add $0x10,%esp 1106f9: 48 dec %eax 1106fa: 75 48 jne 110744 rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( ENOTDIR ); } rtems_filesystem_freenode( &rtems_filesystem_current ); 1106fc: 83 ec 0c sub $0xc,%esp 1106ff: a1 b0 5a 12 00 mov 0x125ab0,%eax 110704: 83 c0 04 add $0x4,%eax 110707: 50 push %eax 110708: e8 d3 7d ff ff call 1084e0 rtems_filesystem_current = loc; 11070d: 8b 3d b0 5a 12 00 mov 0x125ab0,%edi 110713: 83 c7 04 add $0x4,%edi 110716: b9 05 00 00 00 mov $0x5,%ecx 11071b: f3 a5 rep movsl %ds:(%esi),%es:(%edi) return 0; 11071d: 83 c4 10 add $0x10,%esp 110720: 31 c0 xor %eax,%eax } 110722: 8d 65 f8 lea -0x8(%ebp),%esp 110725: 5e pop %esi 110726: 5f pop %edi 110727: c9 leave 110728: c3 ret 110729: 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 ); 11072c: e8 8f 34 00 00 call 113bc0 <__errno> 110731: c7 00 0e 00 00 00 movl $0xe,(%eax) 110737: b8 ff ff ff ff mov $0xffffffff,%eax rtems_filesystem_freenode( &rtems_filesystem_current ); rtems_filesystem_current = loc; return 0; } 11073c: 8d 65 f8 lea -0x8(%ebp),%esp 11073f: 5e pop %esi 110740: 5f pop %edi 110741: c9 leave 110742: c3 ret 110743: 90 nop /* * Verify you can change directory into this node. */ if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) { rtems_filesystem_freenode( &loc ); 110744: 83 ec 0c sub $0xc,%esp 110747: 56 push %esi 110748: e8 93 7d ff ff call 1084e0 rtems_set_errno_and_return_minus_one( ENOTDIR ); 11074d: e8 6e 34 00 00 call 113bc0 <__errno> 110752: c7 00 14 00 00 00 movl $0x14,(%eax) 110758: 83 c4 10 add $0x10,%esp 11075b: b8 ff ff ff ff mov $0xffffffff,%eax 110760: eb 81 jmp 1106e3 =============================================================================== 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 b0 5a 12 00 60 cmpl $0x127d60,0x125ab0 10827f: 7d 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 19 84 00 00 call 1106a8 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 b6 19 12 00 push $0x1219b6 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 b0 5a 12 00 mov 0x125ab0,%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 b0 5a 12 00 mov 0x125ab0,%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 b0 5a 12 00 60 cmpl $0x127d60,0x125ab0 1082f0: 7d 12 00 1082f3: 75 8f jne 108284 rtems_set_errno_and_return_minus_one( ENOTSUP ); 1082f5: e8 c6 b8 00 00 call 113bc0 <__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 b3 b8 00 00 call 113bc0 <__errno> 10830d: 89 c6 mov %eax,%esi 10830f: e8 ac b8 00 00 call 113bc0 <__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 a3 8e 00 00 call 114320 <__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 8f 8e 00 00 call 114320 <__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 a3 1e 00 00 call 10d34c <_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 3f 1e 00 00 call 10d2f8 <_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 3c 8e 00 00 call 114320 <__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 90 85 12 00 mov 0x128590,%eax 10b501: 40 inc %eax 10b502: a3 90 85 12 00 mov %eax,0x128590 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 94 1e 00 00 call 10d3a4 <_TOD_Set> _Thread_Enable_dispatch(); 10b510: e8 d7 32 00 00 call 10e7ec <_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 ff 8d 00 00 call 114320 <__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 =============================================================================== 0010fc0c : #include int close( int fd ) { 10fc0c: 55 push %ebp 10fc0d: 89 e5 mov %esp,%ebp 10fc0f: 53 push %ebx 10fc10: 83 ec 14 sub $0x14,%esp 10fc13: 8b 45 08 mov 0x8(%ebp),%eax rtems_libio_t *iop; rtems_status_code rc; rtems_libio_check_fd(fd); 10fc16: 3b 05 ac 31 12 00 cmp 0x1231ac,%eax 10fc1c: 73 46 jae 10fc64 iop = rtems_libio_iop(fd); 10fc1e: c1 e0 03 shl $0x3,%eax 10fc21: 8d 1c c5 00 00 00 00 lea 0x0(,%eax,8),%ebx 10fc28: 29 c3 sub %eax,%ebx 10fc2a: 03 1d 00 74 12 00 add 0x127400,%ebx rtems_libio_check_is_open(iop); 10fc30: f6 43 15 01 testb $0x1,0x15(%ebx) 10fc34: 74 2e je 10fc64 rc = RTEMS_SUCCESSFUL; rc = (*iop->pathinfo.handlers->close_h)( iop ); 10fc36: 83 ec 0c sub $0xc,%esp 10fc39: 8b 43 20 mov 0x20(%ebx),%eax 10fc3c: 53 push %ebx 10fc3d: ff 50 04 call *0x4(%eax) rtems_filesystem_freenode( &iop->pathinfo ); 10fc40: 8d 53 18 lea 0x18(%ebx),%edx 10fc43: 89 14 24 mov %edx,(%esp) 10fc46: 89 45 f4 mov %eax,-0xc(%ebp) 10fc49: e8 52 84 ff ff call 1080a0 rtems_libio_free( iop ); 10fc4e: 89 1c 24 mov %ebx,(%esp) 10fc51: e8 26 02 00 00 call 10fe7c return rc; 10fc56: 83 c4 10 add $0x10,%esp 10fc59: 8b 45 f4 mov -0xc(%ebp),%eax } 10fc5c: 8b 5d fc mov -0x4(%ebp),%ebx 10fc5f: c9 leave 10fc60: c3 ret 10fc61: 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); 10fc64: e8 ab 36 00 00 call 113314 <__errno> 10fc69: c7 00 09 00 00 00 movl $0x9,(%eax) 10fc6f: b8 ff ff ff ff mov $0xffffffff,%eax 10fc74: eb e6 jmp 10fc5c =============================================================================== 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 6b d6 11 00 mov $0x11d66b,%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 6b d6 11 00 mov $0x11d66b,%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 =============================================================================== 0010ee58 : const char *pathname, size_t pathnamelen, int flags, rtems_filesystem_location_info_t *pathloc ) { 10ee58: 55 push %ebp 10ee59: 89 e5 mov %esp,%ebp 10ee5b: 57 push %edi 10ee5c: 56 push %esi 10ee5d: 53 push %ebx 10ee5e: 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 ) ) 10ee61: f7 45 10 f8 ff ff ff testl $0xfffffff8,0x10(%ebp) 10ee68: 0f 85 96 00 00 00 jne 10ef04 <== 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; 10ee6e: 8b 45 14 mov 0x14(%ebp),%eax 10ee71: 8b 00 mov (%eax),%eax 10ee73: 89 45 e4 mov %eax,-0x1c(%ebp) if (!device_name_table) 10ee76: 85 c0 test %eax,%eax 10ee78: 0f 84 98 00 00 00 je 10ef16 rtems_set_errno_and_return_minus_one( EFAULT ); for (i = 0; i < rtems_device_table_size; i++) { 10ee7e: 8b 15 d0 0c 12 00 mov 0x120cd0,%edx 10ee84: 89 55 e0 mov %edx,-0x20(%ebp) 10ee87: 85 d2 test %edx,%edx 10ee89: 74 38 je 10eec3 <== NEVER TAKEN 10ee8b: 31 c0 xor %eax,%eax 10ee8d: 31 db xor %ebx,%ebx if (!device_name_table[i].device_name) 10ee8f: 8d 04 80 lea (%eax,%eax,4),%eax 10ee92: 8b 55 e4 mov -0x1c(%ebp),%edx 10ee95: 8d 3c 82 lea (%edx,%eax,4),%edi 10ee98: 8b 37 mov (%edi),%esi 10ee9a: 85 f6 test %esi,%esi 10ee9c: 74 1d je 10eebb continue; if (strncmp(pathname, device_name_table[i].device_name, pathnamelen) != 0) 10ee9e: 50 push %eax 10ee9f: ff 75 0c pushl 0xc(%ebp) 10eea2: 56 push %esi 10eea3: ff 75 08 pushl 0x8(%ebp) 10eea6: e8 79 32 00 00 call 112124 10eeab: 83 c4 10 add $0x10,%esp 10eeae: 85 c0 test %eax,%eax 10eeb0: 75 09 jne 10eebb continue; if (device_name_table[i].device_name[pathnamelen] != '\0') 10eeb2: 8b 45 0c mov 0xc(%ebp),%eax 10eeb5: 80 3c 06 00 cmpb $0x0,(%esi,%eax,1) 10eeb9: 74 21 je 10eedc <== 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++) { 10eebb: 43 inc %ebx 10eebc: 89 d8 mov %ebx,%eax 10eebe: 39 5d e0 cmp %ebx,-0x20(%ebp) 10eec1: 77 cc ja 10ee8f pathloc->mt_entry = rtems_filesystem_root.mt_entry; return 0; } /* no such file or directory */ rtems_set_errno_and_return_minus_one( ENOENT ); 10eec3: e8 20 26 00 00 call 1114e8 <__errno> 10eec8: c7 00 02 00 00 00 movl $0x2,(%eax) 10eece: b8 ff ff ff ff mov $0xffffffff,%eax } 10eed3: 8d 65 f4 lea -0xc(%ebp),%esp 10eed6: 5b pop %ebx 10eed7: 5e pop %esi 10eed8: 5f pop %edi 10eed9: c9 leave 10eeda: c3 ret 10eedb: 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]; 10eedc: 8b 55 14 mov 0x14(%ebp),%edx 10eedf: 89 3a mov %edi,(%edx) pathloc->handlers = &devFS_file_handlers; 10eee1: c7 42 08 20 2c 12 00 movl $0x122c20,0x8(%edx) pathloc->ops = &devFS_ops; 10eee8: c7 42 0c c0 2b 12 00 movl $0x122bc0,0xc(%edx) pathloc->mt_entry = rtems_filesystem_root.mt_entry; 10eeef: a1 90 2d 12 00 mov 0x122d90,%eax 10eef4: 8b 40 28 mov 0x28(%eax),%eax 10eef7: 89 42 10 mov %eax,0x10(%edx) return 0; 10eefa: 31 c0 xor %eax,%eax } /* no such file or directory */ rtems_set_errno_and_return_minus_one( ENOENT ); } 10eefc: 8d 65 f4 lea -0xc(%ebp),%esp 10eeff: 5b pop %ebx 10ef00: 5e pop %esi 10ef01: 5f pop %edi 10ef02: c9 leave 10ef03: 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 ); 10ef04: e8 df 25 00 00 call 1114e8 <__errno> <== NOT EXECUTED 10ef09: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED 10ef0f: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10ef14: eb e6 jmp 10eefc <== 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 ); 10ef16: e8 cd 25 00 00 call 1114e8 <__errno> 10ef1b: c7 00 0e 00 00 00 movl $0xe,(%eax) 10ef21: 83 c8 ff or $0xffffffff,%eax 10ef24: eb d6 jmp 10eefc =============================================================================== 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 22 40 00 00 call 10bb2c 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 17 74 00 00 call 10ef38 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 d0 0c 12 00 mov 0x120cd0,%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 34 a7 00 00 call 1120cc 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 df 9a 00 00 call 1114e8 <__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 a5 9a 00 00 call 1114e8 <__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 93 9a 00 00 call 1114e8 <__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 83 9a 00 00 call 1114e8 <__errno> 107a65: c7 00 0e 00 00 00 movl $0xe,(%eax) 107a6b: 83 c8 ff or $0xffffffff,%eax 107a6e: eb 8c jmp 1079fc =============================================================================== 00112714 : int device_ioctl( rtems_libio_t *iop, uint32_t command, void *buffer ) { 112714: 55 push %ebp 112715: 89 e5 mov %esp,%ebp 112717: 83 ec 1c sub $0x1c,%esp 11271a: 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; 11271d: 89 45 e8 mov %eax,-0x18(%ebp) args.command = command; 112720: 8b 55 0c mov 0xc(%ebp),%edx 112723: 89 55 ec mov %edx,-0x14(%ebp) args.buffer = buffer; 112726: 8b 55 10 mov 0x10(%ebp),%edx 112729: 89 55 f0 mov %edx,-0x10(%ebp) the_jnode = iop->pathinfo.node_access; 11272c: 8b 40 18 mov 0x18(%eax),%eax status = rtems_io_control( the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args 11272f: 8d 55 e8 lea -0x18(%ebp),%edx args.command = command; args.buffer = buffer; the_jnode = iop->pathinfo.node_access; status = rtems_io_control( 112732: 52 push %edx 112733: ff 70 54 pushl 0x54(%eax) 112736: ff 70 50 pushl 0x50(%eax) 112739: e8 fa 08 00 00 call 113038 the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) 11273e: 83 c4 10 add $0x10,%esp 112741: 85 c0 test %eax,%eax 112743: 75 07 jne 11274c return rtems_deviceio_errno(status); return args.ioctl_return; 112745: 8b 45 f4 mov -0xc(%ebp),%eax } 112748: c9 leave 112749: c3 ret 11274a: 66 90 xchg %ax,%ax the_jnode->info.device.minor, (void *) &args ); if ( status ) return rtems_deviceio_errno(status); 11274c: 83 ec 0c sub $0xc,%esp 11274f: 50 push %eax 112750: e8 33 0b 00 00 call 113288 112755: 83 c4 10 add $0x10,%esp return args.ioctl_return; } 112758: c9 leave 112759: 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 ee 2c 00 00 call 10bd00 <== 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 b4 52 12 00 mov 0x1252b4,%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 e0 8a 12 00 mov 0x128ae0,%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 50 b3 00 00 call 1142cc 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 c8 8b 12 00 mov 0x128bc8,%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 a8 b4 00 00 call 1142cc 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 b4 52 12 00 mov 0x1252b4,%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 0c 12 00 push $0x120c06 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 b4 52 12 00 mov 0x1252b4,%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 0c 12 00 push $0x120c08 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 0c 12 00 push $0x120c06 <== 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 b4 52 12 00 mov 0x1252b4,%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 ec 45 12 00 cmp 0x1245ec,%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 40 88 12 00 add 0x128840,%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 f0 65 12 00 mov 0x1265f0,%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 24 12 00 push $0x1224d6 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 f0 65 12 00 mov 0x1265f0,%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 e7 b5 00 00 call 1141d4 <__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 f0 65 12 00 mov 0x1265f0,%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 b7 b5 00 00 call 1141d4 <__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 a3 b5 00 00 call 1141d4 <__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 ec 45 12 00 cmp 0x1245ec,%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 40 88 12 00 add 0x128840,%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 43 b5 00 00 call 1141d4 <__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 2f b5 00 00 call 1141d4 <__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 cc 4d 12 00 mov 0x124dcc,%ecx 108af8: 39 cb cmp %ecx,%ebx 108afa: 0f 83 5c 01 00 00 jae 108c5c iop = rtems_libio_iop( fd ); 108b00: a1 20 90 12 00 mov 0x129020,%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 43 b9 00 00 call 114474 <__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 d0 26 12 00 jmp *0x1226d0(,%edx,4) 108b43: 90 nop errno = ENOTSUP; ret = -1; break; case F_GETOWN: /* for sockets. */ errno = ENOTSUP; 108b44: e8 2b b9 00 00 call 114474 <__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 d3 b8 00 00 call 114474 <__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 13 b8 00 00 call 114474 <__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 20 90 12 00 mov 0x129020,%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 cc 4d 12 00 cmp 0x124dcc,%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 20 90 12 00 add 0x129020,%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 73 b7 00 00 call 114474 <__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 5f b7 00 00 call 114474 <__errno> 108d15: c7 00 16 00 00 00 movl $0x16,(%eax) 108d1b: eb ea jmp 108d07 =============================================================================== 00111a70 : */ int fifo_open( pipe_control_t **pipep, rtems_libio_t *iop ) { 111a70: 55 push %ebp 111a71: 89 e5 mov %esp,%ebp 111a73: 57 push %edi 111a74: 56 push %esi 111a75: 53 push %ebx 111a76: 83 ec 2c sub $0x2c,%esp 111a79: 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) { 111a7c: a1 ec 9b 12 00 mov 0x129bec,%eax 111a81: 85 c0 test %eax,%eax 111a83: 0f 84 8b 00 00 00 je 111b14 rtems_libio_unlock(); } if (sc == RTEMS_SUCCESSFUL) { sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 111a89: 53 push %ebx 111a8a: 6a 00 push $0x0 111a8c: 6a 00 push $0x0 111a8e: 50 push %eax 111a8f: e8 40 ba ff ff call 10d4d4 } if (sc == RTEMS_SUCCESSFUL) { 111a94: 83 c4 10 add $0x10,%esp 111a97: 85 c0 test %eax,%eax 111a99: 0f 85 4c 03 00 00 jne 111deb <== NEVER TAKEN err = pipe_lock(); if (err) return err; pipe = *pipep; 111a9f: 8b 1e mov (%esi),%ebx if (pipe == NULL) { 111aa1: 85 db test %ebx,%ebx 111aa3: 0f 84 df 01 00 00 je 111c88 err = pipe_alloc(&pipe); if (err) goto out; } if (! PIPE_LOCK(pipe)) 111aa9: 52 push %edx 111aaa: 6a 00 push $0x0 111aac: 6a 00 push $0x0 111aae: ff 73 28 pushl 0x28(%ebx) 111ab1: e8 1e ba ff ff call 10d4d4 111ab6: 83 c4 10 add $0x10,%esp 111ab9: 83 f8 01 cmp $0x1,%eax 111abc: 19 ff sbb %edi,%edi 111abe: f7 d7 not %edi 111ac0: 83 e7 fc and $0xfffffffc,%edi err = -EINTR; if (*pipep == NULL) { 111ac3: 8b 06 mov (%esi),%eax 111ac5: 85 c0 test %eax,%eax 111ac7: 0f 84 d7 02 00 00 je 111da4 else *pipep = pipe; } out: pipe_unlock(); 111acd: e8 aa fe ff ff call 11197c pipe_control_t *pipe; unsigned int prevCounter; int err; err = pipe_new(pipep); if (err) 111ad2: 85 ff test %edi,%edi 111ad4: 75 32 jne 111b08 <== NEVER TAKEN return err; pipe = *pipep; 111ad6: 8b 1e mov (%esi),%ebx switch (LIBIO_ACCMODE(iop)) { 111ad8: 8b 55 0c mov 0xc(%ebp),%edx 111adb: 8b 42 14 mov 0x14(%edx),%eax 111ade: 83 e0 06 and $0x6,%eax 111ae1: 83 f8 04 cmp $0x4,%eax 111ae4: 74 6a je 111b50 111ae6: 83 f8 06 cmp $0x6,%eax 111ae9: 0f 84 59 01 00 00 je 111c48 111aef: 83 f8 02 cmp $0x2,%eax 111af2: 0f 84 dc 00 00 00 je 111bd4 <== ALWAYS TAKEN if (pipe->Writers ++ == 0) PIPE_WAKEUPREADERS(pipe); break; } PIPE_UNLOCK(pipe); 111af8: 83 ec 0c sub $0xc,%esp 111afb: ff 73 28 pushl 0x28(%ebx) 111afe: e8 cd ba ff ff call 10d5d0 return 0; 111b03: 83 c4 10 add $0x10,%esp 111b06: 31 ff xor %edi,%edi out_error: pipe_release(pipep, iop); return err; } 111b08: 89 f8 mov %edi,%eax 111b0a: 8d 65 f4 lea -0xc(%ebp),%esp 111b0d: 5b pop %ebx 111b0e: 5e pop %esi 111b0f: 5f pop %edi 111b10: c9 leave 111b11: c3 ret 111b12: 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 ); 111b14: 50 push %eax 111b15: 6a 00 push $0x0 111b17: 6a 00 push $0x0 111b19: ff 35 08 9e 12 00 pushl 0x129e08 111b1f: e8 b0 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) { 111b24: 83 c4 10 add $0x10,%esp 111b27: 8b 3d ec 9b 12 00 mov 0x129bec,%edi 111b2d: 85 ff test %edi,%edi 111b2f: 0f 84 83 02 00 00 je 111db8 <== ALWAYS TAKEN } static inline void rtems_libio_unlock( void ) { rtems_semaphore_release( rtems_libio_semaphore ); 111b35: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111b38: ff 35 08 9e 12 00 pushl 0x129e08 <== NOT EXECUTED 111b3e: e8 8d ba ff ff call 10d5d0 <== NOT EXECUTED 111b43: a1 ec 9b 12 00 mov 0x129bec,%eax <== NOT EXECUTED 111b48: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111b4b: e9 39 ff ff ff jmp 111a89 <== NOT EXECUTED } while (prevCounter == pipe->writerCounter); } break; case LIBIO_FLAGS_WRITE: pipe->writerCounter ++; 111b50: ff 43 24 incl 0x24(%ebx) if (pipe->Writers ++ == 0) 111b53: 8b 43 14 mov 0x14(%ebx),%eax 111b56: 8d 50 01 lea 0x1(%eax),%edx 111b59: 89 53 14 mov %edx,0x14(%ebx) 111b5c: 85 c0 test %eax,%eax 111b5e: 0f 84 c4 02 00 00 je 111e28 <== ALWAYS TAKEN PIPE_WAKEUPREADERS(pipe); if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) { 111b64: 8b 4b 10 mov 0x10(%ebx),%ecx 111b67: 85 c9 test %ecx,%ecx 111b69: 75 8d jne 111af8 111b6b: 8b 55 0c mov 0xc(%ebp),%edx 111b6e: f6 42 14 01 testb $0x1,0x14(%edx) 111b72: 0f 85 04 03 00 00 jne 111e7c err = -ENXIO; goto out_error; } if (pipe->Readers == 0) { prevCounter = pipe->readerCounter; 111b78: 8b 7b 20 mov 0x20(%ebx),%edi 111b7b: eb 20 jmp 111b9d 111b7d: 8d 76 00 lea 0x0(%esi),%esi err = -EINTR; do { PIPE_UNLOCK(pipe); if (! PIPE_WRITEWAIT(pipe)) goto out_error; if (! PIPE_LOCK(pipe)) 111b80: 51 push %ecx 111b81: 6a 00 push $0x0 111b83: 6a 00 push $0x0 111b85: ff 73 28 pushl 0x28(%ebx) 111b88: e8 47 b9 ff ff call 10d4d4 111b8d: 83 c4 10 add $0x10,%esp 111b90: 85 c0 test %eax,%eax 111b92: 75 27 jne 111bbb <== NEVER TAKEN goto out_error; } while (prevCounter == pipe->readerCounter); 111b94: 39 7b 20 cmp %edi,0x20(%ebx) 111b97: 0f 85 5b ff ff ff jne 111af8 <== ALWAYS TAKEN if (pipe->Readers == 0) { prevCounter = pipe->readerCounter; err = -EINTR; do { PIPE_UNLOCK(pipe); 111b9d: 83 ec 0c sub $0xc,%esp 111ba0: ff 73 28 pushl 0x28(%ebx) 111ba3: e8 28 ba ff ff call 10d5d0 if (! PIPE_WRITEWAIT(pipe)) 111ba8: 58 pop %eax 111ba9: 5a pop %edx 111baa: 6a 00 push $0x0 111bac: ff 73 30 pushl 0x30(%ebx) 111baf: e8 b0 1c 00 00 call 113864 111bb4: 83 c4 10 add $0x10,%esp 111bb7: 85 c0 test %eax,%eax 111bb9: 74 c5 je 111b80 <== ALWAYS TAKEN goto out_error; } if (pipe->Readers == 0) { prevCounter = pipe->readerCounter; err = -EINTR; 111bbb: bf fc ff ff ff mov $0xfffffffc,%edi <== NOT EXECUTED PIPE_UNLOCK(pipe); return 0; out_error: pipe_release(pipep, iop); 111bc0: 83 ec 08 sub $0x8,%esp 111bc3: ff 75 0c pushl 0xc(%ebp) 111bc6: 56 push %esi 111bc7: e8 c8 fd ff ff call 111994 return err; 111bcc: 83 c4 10 add $0x10,%esp 111bcf: e9 34 ff ff ff jmp 111b08 return err; pipe = *pipep; switch (LIBIO_ACCMODE(iop)) { case LIBIO_FLAGS_READ: pipe->readerCounter ++; 111bd4: ff 43 20 incl 0x20(%ebx) if (pipe->Readers ++ == 0) 111bd7: 8b 43 10 mov 0x10(%ebx),%eax 111bda: 8d 50 01 lea 0x1(%eax),%edx 111bdd: 89 53 10 mov %edx,0x10(%ebx) 111be0: 85 c0 test %eax,%eax 111be2: 0f 84 10 02 00 00 je 111df8 <== ALWAYS TAKEN PIPE_WAKEUPWRITERS(pipe); if (pipe->Writers == 0) { 111be8: 8b 7b 14 mov 0x14(%ebx),%edi 111beb: 85 ff test %edi,%edi 111bed: 0f 85 05 ff ff ff jne 111af8 /* Not an error */ if (LIBIO_NODELAY(iop)) 111bf3: 8b 45 0c mov 0xc(%ebp),%eax 111bf6: f6 40 14 01 testb $0x1,0x14(%eax) 111bfa: 0f 85 f8 fe ff ff jne 111af8 break; prevCounter = pipe->writerCounter; 111c00: 8b 7b 24 mov 0x24(%ebx),%edi 111c03: eb 20 jmp 111c25 111c05: 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)) 111c08: 50 push %eax 111c09: 6a 00 push $0x0 111c0b: 6a 00 push $0x0 111c0d: ff 73 28 pushl 0x28(%ebx) 111c10: e8 bf b8 ff ff call 10d4d4 111c15: 83 c4 10 add $0x10,%esp 111c18: 85 c0 test %eax,%eax 111c1a: 75 9f jne 111bbb <== NEVER TAKEN goto out_error; } while (prevCounter == pipe->writerCounter); 111c1c: 39 7b 24 cmp %edi,0x24(%ebx) 111c1f: 0f 85 d3 fe ff ff jne 111af8 <== ALWAYS TAKEN prevCounter = pipe->writerCounter; err = -EINTR; /* Wait until a writer opens the pipe */ do { PIPE_UNLOCK(pipe); 111c25: 83 ec 0c sub $0xc,%esp 111c28: ff 73 28 pushl 0x28(%ebx) 111c2b: e8 a0 b9 ff ff call 10d5d0 if (! PIPE_READWAIT(pipe)) 111c30: 5a pop %edx 111c31: 59 pop %ecx 111c32: 6a 00 push $0x0 111c34: ff 73 2c pushl 0x2c(%ebx) 111c37: e8 28 1c 00 00 call 113864 111c3c: 83 c4 10 add $0x10,%esp 111c3f: 85 c0 test %eax,%eax 111c41: 74 c5 je 111c08 <== ALWAYS TAKEN 111c43: e9 73 ff ff ff jmp 111bbb <== NOT EXECUTED } while (prevCounter == pipe->readerCounter); } break; case LIBIO_FLAGS_READ_WRITE: pipe->readerCounter ++; 111c48: ff 43 20 incl 0x20(%ebx) if (pipe->Readers ++ == 0) 111c4b: 8b 43 10 mov 0x10(%ebx),%eax 111c4e: 8d 50 01 lea 0x1(%eax),%edx 111c51: 89 53 10 mov %edx,0x10(%ebx) 111c54: 85 c0 test %eax,%eax 111c56: 0f 84 b4 01 00 00 je 111e10 <== ALWAYS TAKEN PIPE_WAKEUPWRITERS(pipe); pipe->writerCounter ++; 111c5c: ff 43 24 incl 0x24(%ebx) if (pipe->Writers ++ == 0) 111c5f: 8b 43 14 mov 0x14(%ebx),%eax 111c62: 8d 50 01 lea 0x1(%eax),%edx 111c65: 89 53 14 mov %edx,0x14(%ebx) 111c68: 85 c0 test %eax,%eax 111c6a: 0f 85 88 fe ff ff jne 111af8 <== NEVER TAKEN PIPE_WAKEUPREADERS(pipe); 111c70: 83 ec 08 sub $0x8,%esp 111c73: 8d 45 e4 lea -0x1c(%ebp),%eax 111c76: 50 push %eax 111c77: ff 73 2c pushl 0x2c(%ebx) 111c7a: e8 81 1b 00 00 call 113800 111c7f: 83 c4 10 add $0x10,%esp 111c82: e9 71 fe ff ff jmp 111af8 111c87: 90 nop { static char c = 'a'; pipe_control_t *pipe; int err = -ENOMEM; pipe = malloc(sizeof(pipe_control_t)); 111c88: 83 ec 0c sub $0xc,%esp 111c8b: 6a 34 push $0x34 111c8d: e8 2e 84 ff ff call 10a0c0 111c92: 89 c3 mov %eax,%ebx 111c94: 89 45 d4 mov %eax,-0x2c(%ebp) if (pipe == NULL) 111c97: 83 c4 10 add $0x10,%esp 111c9a: 85 c0 test %eax,%eax 111c9c: 0f 84 32 02 00 00 je 111ed4 return err; memset(pipe, 0, sizeof(pipe_control_t)); 111ca2: b9 34 00 00 00 mov $0x34,%ecx 111ca7: 31 c0 xor %eax,%eax 111ca9: 89 df mov %ebx,%edi 111cab: f3 aa rep stos %al,%es:(%edi) pipe->Size = PIPE_BUF; 111cad: c7 43 04 00 02 00 00 movl $0x200,0x4(%ebx) pipe->Buffer = malloc(pipe->Size); 111cb4: 83 ec 0c sub $0xc,%esp 111cb7: 68 00 02 00 00 push $0x200 111cbc: e8 ff 83 ff ff call 10a0c0 111cc1: 89 03 mov %eax,(%ebx) if (! pipe->Buffer) 111cc3: 83 c4 10 add $0x10,%esp 111cc6: 85 c0 test %eax,%eax 111cc8: 0f 84 f8 01 00 00 je 111ec6 <== NEVER TAKEN goto err_buf; err = -ENOMEM; if (rtems_barrier_create( 111cce: 8d 43 2c lea 0x2c(%ebx),%eax 111cd1: 50 push %eax 111cd2: 6a 00 push $0x0 111cd4: 6a 00 push $0x0 rtems_build_name ('P', 'I', 'r', c), 111cd6: 0f be 05 b8 7b 12 00 movsbl 0x127bb8,%eax if (! pipe->Buffer) goto err_buf; err = -ENOMEM; if (rtems_barrier_create( 111cdd: 0d 00 72 49 50 or $0x50497200,%eax 111ce2: 50 push %eax 111ce3: e8 9c 19 00 00 call 113684 111ce8: 83 c4 10 add $0x10,%esp 111ceb: 85 c0 test %eax,%eax 111ced: 0f 85 c3 01 00 00 jne 111eb6 rtems_build_name ('P', 'I', 'r', c), RTEMS_BARRIER_MANUAL_RELEASE, 0, &pipe->readBarrier) != RTEMS_SUCCESSFUL) goto err_rbar; if (rtems_barrier_create( 111cf3: 8d 43 30 lea 0x30(%ebx),%eax 111cf6: 50 push %eax 111cf7: 6a 00 push $0x0 111cf9: 6a 00 push $0x0 rtems_build_name ('P', 'I', 'w', c), 111cfb: 0f be 05 b8 7b 12 00 movsbl 0x127bb8,%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( 111d02: 0d 00 77 49 50 or $0x50497700,%eax 111d07: 50 push %eax 111d08: e8 77 19 00 00 call 113684 111d0d: 83 c4 10 add $0x10,%esp 111d10: 85 c0 test %eax,%eax 111d12: 0f 85 8d 01 00 00 jne 111ea5 rtems_build_name ('P', 'I', 'w', c), RTEMS_BARRIER_MANUAL_RELEASE, 0, &pipe->writeBarrier) != RTEMS_SUCCESSFUL) goto err_wbar; if (rtems_semaphore_create( 111d18: 83 ec 0c sub $0xc,%esp 111d1b: 8d 43 28 lea 0x28(%ebx),%eax 111d1e: 50 push %eax 111d1f: 6a 00 push $0x0 111d21: 6a 10 push $0x10 111d23: 6a 01 push $0x1 rtems_build_name ('P', 'I', 's', c), 1, 111d25: 0f be 05 b8 7b 12 00 movsbl 0x127bb8,%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( 111d2c: 0d 00 73 49 50 or $0x50497300,%eax 111d31: 50 push %eax 111d32: e8 21 b5 ff ff call 10d258 111d37: 83 c4 20 add $0x20,%esp 111d3a: 85 c0 test %eax,%eax 111d3c: 0f 85 52 01 00 00 jne 111e94 Objects_Id id, Objects_Locations *location ) { return (Barrier_Control *) _Objects_Get( &_Barrier_Information, id, location ); 111d42: 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 111d43: 8d 7d e0 lea -0x20(%ebp),%edi 111d46: 57 push %edi 111d47: ff 73 2c pushl 0x2c(%ebx) 111d4a: 68 a0 a9 12 00 push $0x12a9a0 111d4f: e8 c8 ce ff ff call 10ec1c <_Objects_Get> |= STATES_INTERRUPTIBLE_BY_SIGNAL; 111d54: 81 48 4c 00 00 00 10 orl $0x10000000,0x4c(%eax) _Thread_Enable_dispatch(); 111d5b: e8 a0 d9 ff ff call 10f700 <_Thread_Enable_dispatch> 111d60: 83 c4 0c add $0xc,%esp 111d63: 57 push %edi 111d64: ff 73 30 pushl 0x30(%ebx) 111d67: 68 a0 a9 12 00 push $0x12a9a0 111d6c: e8 ab ce ff ff call 10ec1c <_Objects_Get> _Barrier_Get(pipe->writeBarrier, &location)->Barrier.Wait_queue.state |= STATES_INTERRUPTIBLE_BY_SIGNAL; 111d71: 81 48 4c 00 00 00 10 orl $0x10000000,0x4c(%eax) _Thread_Enable_dispatch(); 111d78: e8 83 d9 ff ff call 10f700 <_Thread_Enable_dispatch> #ifdef RTEMS_POSIX_API pipe_interruptible(pipe); #endif *pipep = pipe; if (c ++ == 'z') 111d7d: a0 b8 7b 12 00 mov 0x127bb8,%al 111d82: 8d 50 01 lea 0x1(%eax),%edx 111d85: 88 15 b8 7b 12 00 mov %dl,0x127bb8 111d8b: 83 c4 10 add $0x10,%esp 111d8e: 3c 7a cmp $0x7a,%al 111d90: 0f 85 13 fd ff ff jne 111aa9 c = 'a'; 111d96: c6 05 b8 7b 12 00 61 movb $0x61,0x127bb8 111d9d: e9 07 fd ff ff jmp 111aa9 111da2: 66 90 xchg %ax,%ax if (! PIPE_LOCK(pipe)) err = -EINTR; if (*pipep == NULL) { if (err) 111da4: 85 ff test %edi,%edi 111da6: 0f 85 94 00 00 00 jne 111e40 <== NEVER TAKEN pipe_free(pipe); else *pipep = pipe; 111dac: 89 1e mov %ebx,(%esi) } out: pipe_unlock(); 111dae: e8 c9 fb ff ff call 11197c 111db3: e9 1e fd ff ff jmp 111ad6 if (pipe_semaphore == RTEMS_ID_NONE) { rtems_libio_lock(); if (pipe_semaphore == RTEMS_ID_NONE) { sc = rtems_semaphore_create( 111db8: 83 ec 0c sub $0xc,%esp 111dbb: 68 ec 9b 12 00 push $0x129bec 111dc0: 6a 00 push $0x0 111dc2: 6a 54 push $0x54 111dc4: 6a 01 push $0x1 111dc6: 68 45 50 49 50 push $0x50495045 111dcb: e8 88 b4 ff ff call 10d258 111dd0: 89 c3 mov %eax,%ebx 111dd2: 83 c4 14 add $0x14,%esp 111dd5: ff 35 08 9e 12 00 pushl 0x129e08 111ddb: e8 f0 b7 ff ff call 10d5d0 } rtems_libio_unlock(); } if (sc == RTEMS_SUCCESSFUL) { 111de0: 83 c4 10 add $0x10,%esp 111de3: 85 db test %ebx,%ebx 111de5: 0f 84 f0 00 00 00 je 111edb ) { pipe_control_t *pipe; int err = 0; err = pipe_lock(); 111deb: bf f4 ff ff ff mov $0xfffffff4,%edi 111df0: e9 13 fd ff ff jmp 111b08 111df5: 8d 76 00 lea 0x0(%esi),%esi switch (LIBIO_ACCMODE(iop)) { case LIBIO_FLAGS_READ: pipe->readerCounter ++; if (pipe->Readers ++ == 0) PIPE_WAKEUPWRITERS(pipe); 111df8: 83 ec 08 sub $0x8,%esp 111dfb: 8d 45 e4 lea -0x1c(%ebp),%eax 111dfe: 50 push %eax 111dff: ff 73 30 pushl 0x30(%ebx) 111e02: e8 f9 19 00 00 call 113800 111e07: 83 c4 10 add $0x10,%esp 111e0a: e9 d9 fd ff ff jmp 111be8 111e0f: 90 nop break; case LIBIO_FLAGS_READ_WRITE: pipe->readerCounter ++; if (pipe->Readers ++ == 0) PIPE_WAKEUPWRITERS(pipe); 111e10: 83 ec 08 sub $0x8,%esp 111e13: 8d 45 e4 lea -0x1c(%ebp),%eax 111e16: 50 push %eax 111e17: ff 73 30 pushl 0x30(%ebx) 111e1a: e8 e1 19 00 00 call 113800 111e1f: 83 c4 10 add $0x10,%esp 111e22: e9 35 fe ff ff jmp 111c5c 111e27: 90 nop case LIBIO_FLAGS_WRITE: pipe->writerCounter ++; if (pipe->Writers ++ == 0) PIPE_WAKEUPREADERS(pipe); 111e28: 83 ec 08 sub $0x8,%esp 111e2b: 8d 45 e4 lea -0x1c(%ebp),%eax 111e2e: 50 push %eax 111e2f: ff 73 2c pushl 0x2c(%ebx) 111e32: e8 c9 19 00 00 call 113800 111e37: 83 c4 10 add $0x10,%esp 111e3a: e9 25 fd ff ff jmp 111b64 111e3f: 90 nop /* Called with pipe_semaphore held. */ static inline void pipe_free( pipe_control_t *pipe ) { rtems_barrier_delete(pipe->readBarrier); 111e40: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111e43: ff 73 2c pushl 0x2c(%ebx) <== NOT EXECUTED 111e46: e8 25 19 00 00 call 113770 <== NOT EXECUTED rtems_barrier_delete(pipe->writeBarrier); 111e4b: 59 pop %ecx <== NOT EXECUTED 111e4c: ff 73 30 pushl 0x30(%ebx) <== NOT EXECUTED 111e4f: e8 1c 19 00 00 call 113770 <== NOT EXECUTED rtems_semaphore_delete(pipe->Semaphore); 111e54: 5a pop %edx <== NOT EXECUTED 111e55: ff 73 28 pushl 0x28(%ebx) <== NOT EXECUTED 111e58: e8 d3 b5 ff ff call 10d430 <== NOT EXECUTED free(pipe->Buffer); 111e5d: 58 pop %eax <== NOT EXECUTED 111e5e: ff 33 pushl (%ebx) <== NOT EXECUTED 111e60: e8 6b 7b ff ff call 1099d0 <== NOT EXECUTED free(pipe); 111e65: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 111e68: e8 63 7b ff ff call 1099d0 <== NOT EXECUTED 111e6d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED else *pipep = pipe; } out: pipe_unlock(); 111e70: e8 07 fb ff ff call 11197c 111e75: e9 8e fc ff ff jmp 111b08 111e7a: 66 90 xchg %ax,%ax if (pipe->Writers ++ == 0) PIPE_WAKEUPREADERS(pipe); if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) { PIPE_UNLOCK(pipe); 111e7c: 83 ec 0c sub $0xc,%esp 111e7f: ff 73 28 pushl 0x28(%ebx) 111e82: e8 49 b7 ff ff call 10d5d0 err = -ENXIO; goto out_error; 111e87: 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; 111e8a: bf fa ff ff ff mov $0xfffffffa,%edi goto out_error; 111e8f: e9 2c fd ff ff jmp 111bc0 if (c ++ == 'z') c = 'a'; return 0; err_sem: rtems_barrier_delete(pipe->writeBarrier); 111e94: 83 ec 0c sub $0xc,%esp 111e97: 8b 45 d4 mov -0x2c(%ebp),%eax 111e9a: ff 70 30 pushl 0x30(%eax) 111e9d: e8 ce 18 00 00 call 113770 111ea2: 83 c4 10 add $0x10,%esp err_wbar: rtems_barrier_delete(pipe->readBarrier); 111ea5: 83 ec 0c sub $0xc,%esp 111ea8: 8b 55 d4 mov -0x2c(%ebp),%edx 111eab: ff 72 2c pushl 0x2c(%edx) 111eae: e8 bd 18 00 00 call 113770 111eb3: 83 c4 10 add $0x10,%esp err_rbar: free(pipe->Buffer); 111eb6: 83 ec 0c sub $0xc,%esp 111eb9: 8b 45 d4 mov -0x2c(%ebp),%eax 111ebc: ff 30 pushl (%eax) 111ebe: e8 0d 7b ff ff call 1099d0 111ec3: 83 c4 10 add $0x10,%esp err_buf: free(pipe); 111ec6: 83 ec 0c sub $0xc,%esp 111ec9: ff 75 d4 pushl -0x2c(%ebp) 111ecc: e8 ff 7a ff ff call 1099d0 111ed1: 83 c4 10 add $0x10,%esp ) { pipe_control_t *pipe; int err = 0; err = pipe_lock(); 111ed4: bf f4 ff ff ff mov $0xfffffff4,%edi 111ed9: eb 95 jmp 111e70 } rtems_libio_unlock(); } if (sc == RTEMS_SUCCESSFUL) { 111edb: a1 ec 9b 12 00 mov 0x129bec,%eax 111ee0: e9 a4 fb ff ff jmp 111a89 =============================================================================== 0010ff9c : const char *type; rtems_filesystem_fsmount_me_t mount_h; } find_arg; static bool find_handler(const rtems_filesystem_table_t *entry, void *arg) { 10ff9c: 55 push %ebp 10ff9d: 89 e5 mov %esp,%ebp 10ff9f: 56 push %esi 10ffa0: 53 push %ebx 10ffa1: 8b 75 08 mov 0x8(%ebp),%esi 10ffa4: 8b 5d 0c mov 0xc(%ebp),%ebx find_arg *fa = arg; if ( strcmp( entry->type, fa->type ) != 0 ) { 10ffa7: 83 ec 08 sub $0x8,%esp 10ffaa: ff 33 pushl (%ebx) 10ffac: ff 36 pushl (%esi) 10ffae: e8 d9 3f 00 00 call 113f8c 10ffb3: 83 c4 10 add $0x10,%esp 10ffb6: 85 c0 test %eax,%eax 10ffb8: 75 12 jne 10ffcc return false; } else { fa->mount_h = entry->mount_h; 10ffba: 8b 46 04 mov 0x4(%esi),%eax 10ffbd: 89 43 04 mov %eax,0x4(%ebx) return true; 10ffc0: b0 01 mov $0x1,%al } } 10ffc2: 8d 65 f8 lea -0x8(%ebp),%esp 10ffc5: 5b pop %ebx 10ffc6: 5e pop %esi 10ffc7: c9 leave 10ffc8: c3 ret 10ffc9: 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; 10ffcc: 31 c0 xor %eax,%eax } else { fa->mount_h = entry->mount_h; return true; } } 10ffce: 8d 65 f8 lea -0x8(%ebp),%esp 10ffd1: 5b pop %ebx 10ffd2: 5e pop %esi 10ffd3: c9 leave 10ffd4: 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 cc 4d 12 00 cmp 0x124dcc,%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 20 90 12 00 add 0x129020,%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 08 b7 00 00 call 114474 <__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 f8 26 12 00 jmp *0x1226f8(,%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 8b b6 00 00 call 114474 <__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 2c 74 12 00 incl 0x12742c 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 40 77 12 00 03 cmpl $0x3,0x127740 1080cf: 74 47 je 108118 <== ALWAYS TAKEN } /* * If configured, update the statistics */ if ( rtems_malloc_statistics_helpers ) 1080d1: a1 c8 57 12 00 mov 0x1257c8,%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 b8 31 12 00 pushl 0x1231b8 1080ee: e8 4d 50 00 00 call 10d140 <_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 b8 31 12 00 mov 0x1231b8,%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 0b 12 00 push $0x120b10 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 60 7d 12 00 cmp $0x127d60,%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 10958c: c3 ret <== NOT EXECUTED =============================================================================== 0011e7b0 : int fstat( int fd, struct stat *sbuf ) { 11e7b0: 55 push %ebp 11e7b1: 89 e5 mov %esp,%ebp 11e7b3: 57 push %edi 11e7b4: 53 push %ebx 11e7b5: 8b 45 08 mov 0x8(%ebp),%eax 11e7b8: 8b 5d 0c mov 0xc(%ebp),%ebx rtems_libio_t *iop; /* * Check to see if we were passed a valid pointer. */ if ( !sbuf ) 11e7bb: 85 db test %ebx,%ebx 11e7bd: 74 55 je 11e814 rtems_set_errno_and_return_minus_one( EFAULT ); /* * Now process the stat() request. */ iop = rtems_libio_iop( fd ); 11e7bf: 3b 05 ac 31 12 00 cmp 0x1231ac,%eax 11e7c5: 73 39 jae 11e800 11e7c7: c1 e0 03 shl $0x3,%eax 11e7ca: 8d 14 c5 00 00 00 00 lea 0x0(,%eax,8),%edx 11e7d1: 29 c2 sub %eax,%edx 11e7d3: 03 15 00 74 12 00 add 0x127400,%edx rtems_libio_check_fd( fd ); rtems_libio_check_is_open(iop); 11e7d9: f6 42 15 01 testb $0x1,0x15(%edx) 11e7dd: 74 21 je 11e800 /* * Zero out the stat structure so the various support * versions of stat don't have to. */ memset( sbuf, 0, sizeof(struct stat) ); 11e7df: b9 48 00 00 00 mov $0x48,%ecx 11e7e4: 31 c0 xor %eax,%eax 11e7e6: 89 df mov %ebx,%edi 11e7e8: f3 aa rep stos %al,%es:(%edi) return (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, sbuf ); 11e7ea: 8b 42 20 mov 0x20(%edx),%eax 11e7ed: 89 5d 0c mov %ebx,0xc(%ebp) 11e7f0: 83 c2 18 add $0x18,%edx 11e7f3: 89 55 08 mov %edx,0x8(%ebp) 11e7f6: 8b 40 18 mov 0x18(%eax),%eax } 11e7f9: 5b pop %ebx 11e7fa: 5f pop %edi 11e7fb: 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 ); 11e7fc: ff e0 jmp *%eax 11e7fe: 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); 11e800: e8 0f 4b ff ff call 113314 <__errno> 11e805: 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 ); } 11e80b: b8 ff ff ff ff mov $0xffffffff,%eax 11e810: 5b pop %ebx 11e811: 5f pop %edi 11e812: c9 leave 11e813: c3 ret /* * Check to see if we were passed a valid pointer. */ if ( !sbuf ) rtems_set_errno_and_return_minus_one( EFAULT ); 11e814: e8 fb 4a ff ff call 113314 <__errno> 11e819: c7 00 0e 00 00 00 movl $0xe,(%eax) 11e81f: eb ea jmp 11e80b =============================================================================== 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 cc 4d 12 00 cmp 0x124dcc,%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 20 90 12 00 add 0x129020,%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 1b b5 00 00 call 114474 <__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 07 b5 00 00 call 114474 <__errno> 108f6d: c7 00 16 00 00 00 movl $0x16,(%eax) 108f73: eb ea jmp 108f5f =============================================================================== 0010fc8c : int ftruncate( int fd, off_t length ) { 10fc8c: 55 push %ebp 10fc8d: 89 e5 mov %esp,%ebp 10fc8f: 57 push %edi 10fc90: 56 push %esi 10fc91: 53 push %ebx 10fc92: 83 ec 3c sub $0x3c,%esp 10fc95: 8b 45 08 mov 0x8(%ebp),%eax 10fc98: 8b 55 0c mov 0xc(%ebp),%edx 10fc9b: 8b 4d 10 mov 0x10(%ebp),%ecx 10fc9e: 89 55 c0 mov %edx,-0x40(%ebp) 10fca1: 89 4d c4 mov %ecx,-0x3c(%ebp) rtems_libio_t *iop; rtems_filesystem_location_info_t loc; rtems_libio_check_fd( fd ); 10fca4: 3b 05 ac 31 12 00 cmp 0x1231ac,%eax 10fcaa: 73 58 jae 10fd04 iop = rtems_libio_iop( fd ); 10fcac: c1 e0 03 shl $0x3,%eax 10fcaf: 8d 1c c5 00 00 00 00 lea 0x0(,%eax,8),%ebx 10fcb6: 29 c3 sub %eax,%ebx 10fcb8: 03 1d 00 74 12 00 add 0x127400,%ebx rtems_libio_check_is_open(iop); 10fcbe: f6 43 15 01 testb $0x1,0x15(%ebx) 10fcc2: 74 40 je 10fd04 /* * Make sure we are not working on a directory */ loc = iop->pathinfo; 10fcc4: 8d 7d d4 lea -0x2c(%ebp),%edi 10fcc7: 8d 73 18 lea 0x18(%ebx),%esi 10fcca: b9 05 00 00 00 mov $0x5,%ecx 10fccf: f3 a5 rep movsl %ds:(%esi),%es:(%edi) if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) 10fcd1: 83 ec 0c sub $0xc,%esp 10fcd4: 8d 45 d4 lea -0x2c(%ebp),%eax 10fcd7: 50 push %eax 10fcd8: 8b 45 e0 mov -0x20(%ebp),%eax 10fcdb: ff 50 10 call *0x10(%eax) 10fcde: 83 c4 10 add $0x10,%esp 10fce1: 48 dec %eax 10fce2: 74 46 je 10fd2a rtems_set_errno_and_return_minus_one( EISDIR ); rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 10fce4: f6 43 14 04 testb $0x4,0x14(%ebx) 10fce8: 74 2e je 10fd18 return (*iop->pathinfo.handlers->ftruncate_h)( iop, length ); 10fcea: 50 push %eax 10fceb: 8b 43 20 mov 0x20(%ebx),%eax 10fcee: ff 75 c4 pushl -0x3c(%ebp) 10fcf1: ff 75 c0 pushl -0x40(%ebp) 10fcf4: 53 push %ebx 10fcf5: ff 50 20 call *0x20(%eax) 10fcf8: 83 c4 10 add $0x10,%esp } 10fcfb: 8d 65 f4 lea -0xc(%ebp),%esp 10fcfe: 5b pop %ebx 10fcff: 5e pop %esi 10fd00: 5f pop %edi 10fd01: c9 leave 10fd02: c3 ret 10fd03: 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); 10fd04: e8 0b 36 00 00 call 113314 <__errno> 10fd09: c7 00 09 00 00 00 movl $0x9,(%eax) 10fd0f: b8 ff ff ff ff mov $0xffffffff,%eax 10fd14: eb e5 jmp 10fcfb 10fd16: 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 ); 10fd18: e8 f7 35 00 00 call 113314 <__errno> 10fd1d: c7 00 16 00 00 00 movl $0x16,(%eax) 10fd23: b8 ff ff ff ff mov $0xffffffff,%eax 10fd28: eb d1 jmp 10fcfb * 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 ); 10fd2a: e8 e5 35 00 00 call 113314 <__errno> 10fd2f: c7 00 15 00 00 00 movl $0x15,(%eax) 10fd35: b8 ff ff ff ff mov $0xffffffff,%eax 10fd3a: eb bf jmp 10fcfb =============================================================================== 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 6c 36 12 00 mov 0x12366c,%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 =============================================================================== 001201a4 : int getdents( int dd_fd, char *dd_buf, int dd_len ) { 1201a4: 55 push %ebp 1201a5: 89 e5 mov %esp,%ebp 1201a7: 57 push %edi 1201a8: 56 push %esi 1201a9: 53 push %ebx 1201aa: 83 ec 2c sub $0x2c,%esp 1201ad: 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 ); 1201b0: 3b 05 cc 5c 12 00 cmp 0x125ccc,%eax 1201b6: 73 4c jae 120204 <== NEVER TAKEN 1201b8: c1 e0 03 shl $0x3,%eax 1201bb: 8d 1c c5 00 00 00 00 lea 0x0(,%eax,8),%ebx 1201c2: 29 c3 sub %eax,%ebx 1201c4: 03 1d 40 a0 12 00 add 0x12a040,%ebx /* * Make sure we are working on a directory */ loc = iop->pathinfo; 1201ca: 8d 7d d4 lea -0x2c(%ebp),%edi 1201cd: 8d 73 18 lea 0x18(%ebx),%esi 1201d0: b9 05 00 00 00 mov $0x5,%ecx 1201d5: f3 a5 rep movsl %ds:(%esi),%es:(%edi) if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) 1201d7: 83 ec 0c sub $0xc,%esp 1201da: 8d 45 d4 lea -0x2c(%ebp),%eax 1201dd: 50 push %eax 1201de: 8b 45 e0 mov -0x20(%ebp),%eax 1201e1: ff 50 10 call *0x10(%eax) 1201e4: 83 c4 10 add $0x10,%esp 1201e7: 48 dec %eax 1201e8: 75 1e jne 120208 /* * 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 ); 1201ea: 50 push %eax 1201eb: 8b 43 20 mov 0x20(%ebx),%eax 1201ee: ff 75 10 pushl 0x10(%ebp) 1201f1: ff 75 0c pushl 0xc(%ebp) 1201f4: 53 push %ebx 1201f5: ff 50 08 call *0x8(%eax) 1201f8: 83 c4 10 add $0x10,%esp } 1201fb: 8d 65 f4 lea -0xc(%ebp),%esp 1201fe: 5b pop %ebx 1201ff: 5e pop %esi 120200: 5f pop %edi 120201: c9 leave 120202: c3 ret 120203: 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 ); 120204: 31 db xor %ebx,%ebx 120206: eb c2 jmp 1201ca <== 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 ); 120208: e8 57 41 ff ff call 114364 <__errno> 12020d: c7 00 14 00 00 00 movl $0x14,(%eax) 120213: b8 ff ff ff ff mov $0xffffffff,%eax 120218: eb e1 jmp 1201fb =============================================================================== 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 0f 12 00 push $0x120fd2 108b51: 68 b9 24 12 00 push $0x1224b9 108b56: e8 75 be 00 00 call 1149d0 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 d5 cc 00 00 call 11584c 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 0f b7 00 00 call 1142cc *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 f3 b6 00 00 call 1142cc rtems_set_errno_and_return_minus_one( EINVAL ); 108bd9: e8 96 b5 00 00 call 114174 <__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 7b b5 00 00 call 114174 <__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 00 8b 12 00 push $0x128b00 108e6c: 68 e4 8a 12 00 push $0x128ae4 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 e8 87 00 00 call 113a34 <__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 d3 87 00 00 call 113a34 <__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 bf 87 00 00 call 113a34 <__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 90 d3 00 00 call 1159cc 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 26 12 00 mov $0x122609,%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 0f 12 00 push $0x120fd2 108c21: 68 ad 24 12 00 push $0x1224ad 108c26: e8 a5 bd 00 00 call 1149d0 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 05 cc 00 00 call 11584c 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 3f b6 00 00 call 1142cc *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 23 b6 00 00 call 1142cc rtems_set_errno_and_return_minus_one( EINVAL ); 108ca9: e8 c6 b4 00 00 call 114174 <__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 ab b4 00 00 call 114174 <__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 00 8c 12 00 push $0x128c00 108d14: 68 cc 8b 12 00 push $0x128bcc 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 =============================================================================== 00112770 : rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode ) { 112770: 55 push %ebp 112771: 89 e5 mov %esp,%ebp 112773: 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 ) 112776: 8b 50 18 mov 0x18(%eax),%edx 112779: 83 7a 4c 01 cmpl $0x1,0x4c(%edx) 11277d: 74 09 je 112788 <== ALWAYS TAKEN return -1; /* It wasn't a directory --> return error */ 11277f: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED iop->offset = 0; return 0; } 112784: c9 leave <== NOT EXECUTED 112785: c3 ret <== NOT EXECUTED 112786: 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; 112788: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) 11278f: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax) return 0; 112796: 31 c0 xor %eax,%eax } 112798: c9 leave 112799: c3 ret =============================================================================== 0011279c : ssize_t imfs_dir_read( rtems_libio_t *iop, void *buffer, size_t count ) { 11279c: 55 push %ebp 11279d: 89 e5 mov %esp,%ebp 11279f: 57 push %edi 1127a0: 56 push %esi 1127a1: 53 push %ebx 1127a2: 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; 1127a8: 8b 55 08 mov 0x8(%ebp),%edx 1127ab: 8b 42 18 mov 0x18(%edx),%eax IMFS_create_orphan( the_jnode ); IMFS_check_node_remove( the_jnode ); return 0; } 1127ae: 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 ); 1127b1: 83 c0 54 add $0x54,%eax 1127b4: 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 ) ) 1127ba: 39 c3 cmp %eax,%ebx 1127bc: 0f 84 2a 01 00 00 je 1128ec /* Move to the first of the desired directory entries */ the_node = rtems_chain_first( the_chain ); bytes_transferred = 0; first_entry = iop->offset; 1127c2: 8b 42 0c mov 0xc(%edx),%eax 1127c5: 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); 1127cb: ba f1 f0 f0 f0 mov $0xf0f0f0f1,%edx 1127d0: 8b 45 10 mov 0x10(%ebp),%eax 1127d3: f7 e2 mul %edx 1127d5: c1 ea 08 shr $0x8,%edx 1127d8: 89 d0 mov %edx,%eax 1127da: c1 e0 04 shl $0x4,%eax 1127dd: c1 e2 08 shl $0x8,%edx 1127e0: 8d 14 10 lea (%eax,%edx,1),%edx 1127e3: 03 95 d4 fe ff ff add -0x12c(%ebp),%edx 1127e9: 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 ( 1127ef: 85 d2 test %edx,%edx 1127f1: 0f 8e f5 00 00 00 jle 1128ec <== NEVER TAKEN 1127f7: 31 d2 xor %edx,%edx 1127f9: c7 85 c8 fe ff ff 00 movl $0x0,-0x138(%ebp) 112800: 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 ); 112803: 8d 85 d8 fe ff ff lea -0x128(%ebp),%eax 112809: 89 85 b4 fe ff ff mov %eax,-0x14c(%ebp) 11280f: eb 23 jmp 112834 112811: 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; 112814: 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( 112816: 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 ( 11281c: 39 95 d0 fe ff ff cmp %edx,-0x130(%ebp) 112822: 0f 8e b4 00 00 00 jle 1128dc <== 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 ) ){ 112828: 3b 9d cc fe ff ff cmp -0x134(%ebp),%ebx 11282e: 0f 84 a8 00 00 00 je 1128dc /* entry in the read */ return bytes_transferred; /* Indicate that there are no more */ /* entries to return */ } if( current_entry >= first_entry ) { 112834: 39 95 d4 fe ff ff cmp %edx,-0x12c(%ebp) 11283a: 7f d8 jg 112814 /* Move the entry to the return buffer */ tmp_dirent.d_off = current_entry; 11283c: 89 95 dc fe ff ff mov %edx,-0x124(%ebp) 112842: 89 d0 mov %edx,%eax 112844: c1 f8 1f sar $0x1f,%eax 112847: 89 85 e0 fe ff ff mov %eax,-0x120(%ebp) tmp_dirent.d_reclen = sizeof( struct dirent ); 11284d: 66 c7 85 e4 fe ff ff movw $0x110,-0x11c(%ebp) 112854: 10 01 the_jnode = (IMFS_jnode_t *) the_node; tmp_dirent.d_ino = the_jnode->st_ino; 112856: 8b 43 38 mov 0x38(%ebx),%eax 112859: 89 85 d8 fe ff ff mov %eax,-0x128(%ebp) tmp_dirent.d_namlen = strlen( the_jnode->name ); 11285f: 8d 73 0c lea 0xc(%ebx),%esi 112862: 31 c0 xor %eax,%eax 112864: b9 ff ff ff ff mov $0xffffffff,%ecx 112869: 89 f7 mov %esi,%edi 11286b: f2 ae repnz scas %es:(%edi),%al 11286d: f7 d1 not %ecx 11286f: 49 dec %ecx 112870: 66 89 8d e6 fe ff ff mov %cx,-0x11a(%ebp) strcpy( tmp_dirent.d_name, the_jnode->name ); 112877: 83 ec 08 sub $0x8,%esp 11287a: 56 push %esi 11287b: 8d 85 e8 fe ff ff lea -0x118(%ebp),%eax 112881: 50 push %eax 112882: 89 95 c4 fe ff ff mov %edx,-0x13c(%ebp) 112888: e8 57 17 00 00 call 113fe4 memcpy( 11288d: 8b 45 0c mov 0xc(%ebp),%eax 112890: 03 85 c8 fe ff ff add -0x138(%ebp),%eax 112896: b9 44 00 00 00 mov $0x44,%ecx 11289b: 89 c7 mov %eax,%edi 11289d: 8b b5 b4 fe ff ff mov -0x14c(%ebp),%esi 1128a3: f3 a5 rep movsl %ds:(%esi),%es:(%edi) buffer + bytes_transferred, (void *)&tmp_dirent, sizeof( struct dirent ) ); iop->offset = iop->offset + sizeof(struct dirent); 1128a5: 8b 45 08 mov 0x8(%ebp),%eax 1128a8: 81 40 0c 10 01 00 00 addl $0x110,0xc(%eax) 1128af: 83 50 10 00 adcl $0x0,0x10(%eax) bytes_transferred = bytes_transferred + sizeof( struct dirent ); 1128b3: 81 85 c8 fe ff ff 10 addl $0x110,-0x138(%ebp) 1128ba: 01 00 00 1128bd: 83 c4 10 add $0x10,%esp 1128c0: 8b 95 c4 fe ff ff mov -0x13c(%ebp),%edx } the_node = the_node->next; 1128c6: 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( 1128c8: 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 ( 1128ce: 39 95 d0 fe ff ff cmp %edx,-0x130(%ebp) 1128d4: 0f 8f 4e ff ff ff jg 112828 <== NEVER TAKEN 1128da: 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 ) ){ 1128dc: 8b 85 c8 fe ff ff mov -0x138(%ebp),%eax the_node = the_node->next; } /* Success */ return bytes_transferred; } 1128e2: 8d 65 f4 lea -0xc(%ebp),%esp 1128e5: 5b pop %ebx 1128e6: 5e pop %esi 1128e7: 5f pop %edi 1128e8: c9 leave 1128e9: c3 ret 1128ea: 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; 1128ec: 31 c0 xor %eax,%eax the_node = the_node->next; } /* Success */ return bytes_transferred; } 1128ee: 8d 65 f4 lea -0xc(%ebp),%esp 1128f1: 5b pop %ebx 1128f2: 5e pop %esi 1128f3: 5f pop %edi 1128f4: c9 leave 1128f5: c3 ret =============================================================================== 00112a28 : int imfs_dir_rmnod( rtems_filesystem_location_info_t *parent_pathloc, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN */ ) { 112a28: 55 push %ebp 112a29: 89 e5 mov %esp,%ebp 112a2b: 53 push %ebx 112a2c: 83 ec 04 sub $0x4,%esp 112a2f: 8b 45 0c mov 0xc(%ebp),%eax IMFS_jnode_t *the_jnode; the_jnode = (IMFS_jnode_t *) pathloc->node_access; 112a32: 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 ); 112a34: 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 ) ) 112a37: 39 53 50 cmp %edx,0x50(%ebx) 112a3a: 75 44 jne 112a80 /* * You cannot remove the file system root node. */ if ( pathloc->mt_entry->mt_fs_root.node_access == pathloc->node_access ) 112a3c: 8b 40 10 mov 0x10(%eax),%eax 112a3f: 3b 58 1c cmp 0x1c(%eax),%ebx 112a42: 74 24 je 112a68 /* * You cannot remove a mountpoint. */ if ( the_jnode->info.directory.mt_fs != NULL ) 112a44: 8b 4b 5c mov 0x5c(%ebx),%ecx 112a47: 85 c9 test %ecx,%ecx 112a49: 75 1d jne 112a68 <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EBUSY ); IMFS_create_orphan( the_jnode ); 112a4b: 83 ec 0c sub $0xc,%esp 112a4e: 53 push %ebx 112a4f: e8 98 cf ff ff call 10f9ec IMFS_check_node_remove( the_jnode ); 112a54: 89 1c 24 mov %ebx,(%esp) 112a57: e8 d4 cf ff ff call 10fa30 return 0; 112a5c: 83 c4 10 add $0x10,%esp 112a5f: 31 c0 xor %eax,%eax } 112a61: 8b 5d fc mov -0x4(%ebp),%ebx 112a64: c9 leave 112a65: c3 ret 112a66: 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 ); 112a68: e8 a7 08 00 00 call 113314 <__errno> 112a6d: c7 00 10 00 00 00 movl $0x10,(%eax) 112a73: b8 ff ff ff ff mov $0xffffffff,%eax IMFS_create_orphan( the_jnode ); IMFS_check_node_remove( the_jnode ); return 0; } 112a78: 8b 5d fc mov -0x4(%ebp),%ebx 112a7b: c9 leave 112a7c: c3 ret 112a7d: 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 ); 112a80: e8 8f 08 00 00 call 113314 <__errno> 112a85: c7 00 5a 00 00 00 movl $0x5a,(%eax) 112a8b: b8 ff ff ff ff mov $0xffffffff,%eax 112a90: eb cf jmp 112a61 =============================================================================== 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 c8 8c 12 00 00 cmpb $0x0,0x128cc8 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 c8 8c 12 00 01 movb $0x1,0x128cc8 mkdir("/etc", 0777); 108a53: 83 ec 08 sub $0x8,%esp 108a56: 68 ff 01 00 00 push $0x1ff 108a5b: 68 a8 24 12 00 push $0x1224a8 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 0f 12 00 push $0x120fd2 108a6c: 68 ad 24 12 00 push $0x1224ad 108a71: e8 5a bf 00 00 call 1149d0 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 46 b8 00 00 call 1142cc 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 0f 12 00 push $0x120fd2 108a91: 68 b9 24 12 00 push $0x1224b9 108a96: e8 35 bf 00 00 call 1149d0 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 21 b8 00 00 call 1142cc 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 0e 12 00 push $0x120eb4 108abc: 68 b9 24 12 00 push $0x1224b9 108ac1: e8 0a bf 00 00 call 1149d0 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 25 12 00 push $0x12252c 108add: e8 c2 c6 00 00 call 1151a4 "rtems:x:1:rtems\n" "tty:x:2:tty\n" ); fclose(fp); 108ae2: 89 1c 24 mov %ebx,(%esp) 108ae5: e8 e2 b7 00 00 call 1142cc 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 0e 12 00 push $0x120eb4 108afc: 68 ad 24 12 00 push $0x1224ad 108b01: e8 ca be 00 00 call 1149d0 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 24 12 00 push $0x1224c4 108b1d: e8 82 c6 00 00 call 1151a4 "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 a2 b7 00 00 call 1142cc 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 b4 52 12 00 mov 0x1252b4,%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 a0 51 12 00 mov 0x1251a0,%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 =============================================================================== 001241b4 : int killinfo( pid_t pid, int sig, const union sigval *value ) { 1241b4: 55 push %ebp 1241b5: 89 e5 mov %esp,%ebp 1241b7: 57 push %edi 1241b8: 56 push %esi 1241b9: 53 push %ebx 1241ba: 83 ec 3c sub $0x3c,%esp 1241bd: 8b 75 0c mov 0xc(%ebp),%esi 1241c0: 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() ) 1241c3: e8 00 fd ff ff call 123ec8 1241c8: 3b 45 08 cmp 0x8(%ebp),%eax 1241cb: 0f 85 3f 02 00 00 jne 124410 rtems_set_errno_and_return_minus_one( ESRCH ); /* * Validate the signal passed. */ if ( !sig ) 1241d1: 85 f6 test %esi,%esi 1241d3: 0f 84 4c 02 00 00 je 124425 static inline bool is_valid_signo( int signo ) { return ((signo) >= 1 && (signo) <= 32 ); 1241d9: 8d 4e ff lea -0x1(%esi),%ecx rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 1241dc: 83 f9 1f cmp $0x1f,%ecx 1241df: 0f 87 40 02 00 00 ja 124425 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 ) 1241e5: 8d 04 76 lea (%esi,%esi,2),%eax 1241e8: 83 3c 85 28 e9 12 00 cmpl $0x1,0x12e928(,%eax,4) 1241ef: 01 1241f0: 0f 84 e6 01 00 00 je 1243dc /* * 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 ) ) 1241f6: 83 fe 08 cmp $0x8,%esi 1241f9: 0f 84 c9 00 00 00 je 1242c8 1241ff: 83 fe 04 cmp $0x4,%esi 124202: 0f 84 c0 00 00 00 je 1242c8 124208: 83 fe 0b cmp $0xb,%esi 12420b: 0f 84 b7 00 00 00 je 1242c8 static inline sigset_t signo_to_mask( uint32_t sig ) { return 1u << (sig - 1); 124211: bb 01 00 00 00 mov $0x1,%ebx 124216: d3 e3 shl %cl,%ebx /* * Build up a siginfo structure */ siginfo = &siginfo_struct; siginfo->si_signo = sig; 124218: 89 75 dc mov %esi,-0x24(%ebp) siginfo->si_code = SI_USER; 12421b: c7 45 e0 01 00 00 00 movl $0x1,-0x20(%ebp) if ( !value ) { 124222: 85 ff test %edi,%edi 124224: 0f 84 ba 01 00 00 je 1243e4 siginfo->si_value.sival_int = 0; } else { siginfo->si_value = *value; 12422a: 8b 07 mov (%edi),%eax 12422c: 89 45 e4 mov %eax,-0x1c(%ebp) 12422f: a1 d0 e2 12 00 mov 0x12e2d0,%eax 124234: 40 inc %eax 124235: a3 d0 e2 12 00 mov %eax,0x12e2d0 /* * 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; 12423a: 8b 0d b8 e8 12 00 mov 0x12e8b8,%ecx api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( _POSIX_signals_Is_interested( api, mask ) ) { 124240: 8b 81 ec 00 00 00 mov 0xec(%ecx),%eax 124246: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax 12424c: f7 d0 not %eax 12424e: 85 c3 test %eax,%ebx 124250: 75 34 jne 124286 } DEBUG_STEP("\n"); _Thread_Enable_dispatch(); return 0; } 124252: a1 c0 ea 12 00 mov 0x12eac0,%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 ); 124257: 3d c4 ea 12 00 cmp $0x12eac4,%eax 12425c: 75 1b jne 124279 12425e: e9 81 00 00 00 jmp 1242e4 124263: 90 nop /* * Is this thread is blocked waiting for another signal but has * not blocked this one? */ if (~api->signals_blocked & mask) 124264: 8b 92 d0 00 00 00 mov 0xd0(%edx),%edx 12426a: f7 d2 not %edx 12426c: 85 d3 test %edx,%ebx 12426e: 75 16 jne 124286 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 ) { 124270: 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 ); 124272: 3d c4 ea 12 00 cmp $0x12eac4,%eax 124277: 74 6b je 1242e4 <== ALWAYS TAKEN !_Chain_Is_tail( the_chain, the_node ) ; the_node = the_node->next ) { the_thread = (Thread_Control *)the_node; 124279: 89 c1 mov %eax,%ecx api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 12427b: 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) 124281: 85 58 30 test %ebx,0x30(%eax) 124284: 74 de je 124264 /* * 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 ) ) { 124286: 50 push %eax mask = signo_to_mask( sig ); /* * Build up a siginfo structure */ siginfo = &siginfo_struct; 124287: 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 ) ) { 12428a: 50 push %eax 12428b: 56 push %esi 12428c: 51 push %ecx 12428d: e8 d6 01 00 00 call 124468 <_POSIX_signals_Unblock_thread> 124292: 83 c4 10 add $0x10,%esp 124295: 84 c0 test %al,%al 124297: 75 1f jne 1242b8 /* * 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 ); 124299: 83 ec 0c sub $0xc,%esp 12429c: 53 push %ebx 12429d: e8 b2 01 00 00 call 124454 <_POSIX_signals_Set_process_signals> if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) { 1242a2: 8d 1c 76 lea (%esi,%esi,2),%ebx 1242a5: c1 e3 02 shl $0x2,%ebx 1242a8: 83 c4 10 add $0x10,%esp 1242ab: 83 bb 20 e9 12 00 02 cmpl $0x2,0x12e920(%ebx) 1242b2: 0f 84 e4 00 00 00 je 12439c _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); } DEBUG_STEP("\n"); _Thread_Enable_dispatch(); 1242b8: e8 5f e7 fe ff call 112a1c <_Thread_Enable_dispatch> return 0; 1242bd: 31 c0 xor %eax,%eax } 1242bf: 8d 65 f4 lea -0xc(%ebp),%esp 1242c2: 5b pop %ebx 1242c3: 5e pop %esi 1242c4: 5f pop %edi 1242c5: c9 leave 1242c6: c3 ret 1242c7: 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 ); 1242c8: e8 7b 03 00 00 call 124648 1242cd: 83 ec 08 sub $0x8,%esp 1242d0: 56 push %esi 1242d1: 50 push %eax 1242d2: e8 b1 02 00 00 call 124588 1242d7: 83 c4 10 add $0x10,%esp } DEBUG_STEP("\n"); _Thread_Enable_dispatch(); return 0; } 1242da: 8d 65 f4 lea -0xc(%ebp),%esp 1242dd: 5b pop %ebx 1242de: 5e pop %esi 1242df: 5f pop %edi 1242e0: c9 leave 1242e1: c3 ret 1242e2: 66 90 xchg %ax,%ax * NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL; interested_priority = PRIORITY_MAXIMUM + 1; 1242e4: 0f b6 05 54 9e 12 00 movzbl 0x129e54,%eax 1242eb: 40 inc %eax 1242ec: 89 45 d4 mov %eax,-0x2c(%ebp) * * NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL; 1242ef: 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++) { 1242f6: c7 45 cc 02 00 00 00 movl $0x2,-0x34(%ebp) 1242fd: 89 5d d0 mov %ebx,-0x30(%ebp) 124300: 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 ] ) 124303: 8b 55 cc mov -0x34(%ebp),%edx 124306: 8b 04 95 a8 e2 12 00 mov 0x12e2a8(,%edx,4),%eax 12430d: 85 c0 test %eax,%eax 12430f: 74 68 je 124379 <== NEVER TAKEN continue; the_info = _Objects_Information_table[ the_api ][ 1 ]; 124311: 8b 40 04 mov 0x4(%eax),%eax */ if ( !the_info ) continue; #endif maximum = the_info->maximum; 124314: 0f b7 70 10 movzwl 0x10(%eax),%esi object_table = the_info->local_table; 124318: 8b 78 1c mov 0x1c(%eax),%edi for ( index = 1 ; index <= maximum ; index++ ) { 12431b: 85 f6 test %esi,%esi 12431d: 74 5a je 124379 12431f: b8 01 00 00 00 mov $0x1,%eax the_thread = (Thread_Control *) object_table[ index ]; 124324: 8b 14 87 mov (%edi,%eax,4),%edx if ( !the_thread ) 124327: 85 d2 test %edx,%edx 124329: 74 49 je 124374 /* * If this thread is of lower priority than the interested thread, * go on to the next thread. */ if ( the_thread->current_priority > interested_priority ) 12432b: 8b 4a 14 mov 0x14(%edx),%ecx 12432e: 3b 4d d4 cmp -0x2c(%ebp),%ecx 124331: 77 41 ja 124374 #if defined(RTEMS_DEBUG) if ( !api ) continue; #endif if ( !_POSIX_signals_Is_interested( api, mask ) ) 124333: 8b 9a ec 00 00 00 mov 0xec(%edx),%ebx 124339: 8b 9b d0 00 00 00 mov 0xd0(%ebx),%ebx 12433f: f7 d3 not %ebx 124341: 85 5d d0 test %ebx,-0x30(%ebp) 124344: 74 2e je 124374 * * 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 ) { 124346: 3b 4d d4 cmp -0x2c(%ebp),%ecx 124349: 72 21 jb 12436c * and blocking interruptibutable by signal. * * If the interested thread is ready, don't think about changing. */ if ( interested && !_States_Is_ready( interested->current_state ) ) { 12434b: 8b 5d c8 mov -0x38(%ebp),%ebx 12434e: 85 db test %ebx,%ebx 124350: 74 22 je 124374 <== NEVER TAKEN 124352: 8b 5d c8 mov -0x38(%ebp),%ebx 124355: 8b 5b 10 mov 0x10(%ebx),%ebx 124358: 89 5d c4 mov %ebx,-0x3c(%ebp) 12435b: 85 db test %ebx,%ebx 12435d: 74 15 je 124374 <== NEVER TAKEN /* preferred ready over blocked */ DEBUG_STEP("5"); if ( _States_Is_ready( the_thread->current_state ) ) { 12435f: 8b 5a 10 mov 0x10(%edx),%ebx 124362: 85 db test %ebx,%ebx 124364: 0f 85 86 00 00 00 jne 1243f0 12436a: 66 90 xchg %ax,%ax 12436c: 89 4d d4 mov %ecx,-0x2c(%ebp) 12436f: 89 55 c8 mov %edx,-0x38(%ebp) 124372: 66 90 xchg %ax,%ax #endif maximum = the_info->maximum; object_table = the_info->local_table; for ( index = 1 ; index <= maximum ; index++ ) { 124374: 40 inc %eax 124375: 39 c6 cmp %eax,%esi 124377: 73 ab jae 124324 * + 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++) { 124379: ff 45 cc incl -0x34(%ebp) 12437c: 83 7d cc 04 cmpl $0x4,-0x34(%ebp) 124380: 75 81 jne 124303 124382: 8b 5d d0 mov -0x30(%ebp),%ebx 124385: 8b 75 c0 mov -0x40(%ebp),%esi } } } } if ( interested ) { 124388: 8b 55 c8 mov -0x38(%ebp),%edx 12438b: 85 d2 test %edx,%edx 12438d: 0f 84 06 ff ff ff je 124299 124393: 8b 4d c8 mov -0x38(%ebp),%ecx 124396: e9 eb fe ff ff jmp 124286 12439b: 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 ); 12439c: 83 ec 0c sub $0xc,%esp 12439f: 68 a0 ea 12 00 push $0x12eaa0 1243a4: e8 f7 cc fe ff call 1110a0 <_Chain_Get> if ( !psiginfo ) { 1243a9: 83 c4 10 add $0x10,%esp 1243ac: 85 c0 test %eax,%eax 1243ae: 0f 84 86 00 00 00 je 12443a _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EAGAIN ); } psiginfo->Info = *siginfo; 1243b4: 8d 78 08 lea 0x8(%eax),%edi 1243b7: 8d 75 dc lea -0x24(%ebp),%esi 1243ba: b9 03 00 00 00 mov $0x3,%ecx 1243bf: f3 a5 rep movsl %ds:(%esi),%es:(%edi) _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); 1243c1: 83 ec 08 sub $0x8,%esp 1243c4: 50 push %eax 1243c5: 81 c3 40 eb 12 00 add $0x12eb40,%ebx 1243cb: 53 push %ebx 1243cc: e8 93 cc fe ff call 111064 <_Chain_Append> 1243d1: 83 c4 10 add $0x10,%esp 1243d4: e9 df fe ff ff jmp 1242b8 1243d9: 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; 1243dc: 31 c0 xor %eax,%eax 1243de: e9 f7 fe ff ff jmp 1242da 1243e3: 90 nop */ siginfo = &siginfo_struct; siginfo->si_signo = sig; siginfo->si_code = SI_USER; if ( !value ) { siginfo->si_value.sival_int = 0; 1243e4: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) 1243eb: e9 3f fe ff ff jmp 12422f continue; } DEBUG_STEP("6"); /* prefer blocked/interruptible over blocked/not interruptible */ if ( !_States_Is_interruptible_by_signal(interested->current_state) ) { 1243f0: f7 45 c4 00 00 00 10 testl $0x10000000,-0x3c(%ebp) 1243f7: 0f 85 77 ff ff ff jne 124374 DEBUG_STEP("7"); if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) { 1243fd: 81 e3 00 00 00 10 and $0x10000000,%ebx 124403: 0f 84 6b ff ff ff je 124374 124409: e9 5e ff ff ff jmp 12436c 12440e: 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 ); 124410: e8 d7 40 ff ff call 1184ec <__errno> 124415: c7 00 03 00 00 00 movl $0x3,(%eax) 12441b: b8 ff ff ff ff mov $0xffffffff,%eax 124420: e9 b5 fe ff ff jmp 1242da */ if ( !sig ) rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) rtems_set_errno_and_return_minus_one( EINVAL ); 124425: e8 c2 40 ff ff call 1184ec <__errno> 12442a: c7 00 16 00 00 00 movl $0x16,(%eax) 124430: b8 ff ff ff ff mov $0xffffffff,%eax 124435: e9 a0 fe ff ff jmp 1242da 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(); 12443a: e8 dd e5 fe ff call 112a1c <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EAGAIN ); 12443f: e8 a8 40 ff ff call 1184ec <__errno> 124444: c7 00 0b 00 00 00 movl $0xb,(%eax) 12444a: 83 c8 ff or $0xffffffff,%eax 12444d: e9 88 fe ff ff jmp 1242da =============================================================================== 0011e978 : extern void _wrapup_reent(struct _reent *); extern void _reclaim_reent(struct _reent *); void libc_wrapup(void) { 11e978: 55 push %ebp 11e979: 89 e5 mov %esp,%ebp 11e97b: 53 push %ebx 11e97c: 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())) 11e97f: 83 3d 40 77 12 00 03 cmpl $0x3,0x127740 11e986: 74 08 je 11e990 <== ALWAYS TAKEN */ fclose (stdin); fclose (stdout); fclose (stderr); } 11e988: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 11e98b: c9 leave <== NOT EXECUTED 11e98c: c3 ret <== NOT EXECUTED 11e98d: 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) { 11e990: a1 c0 52 12 00 mov 0x1252c0,%eax 11e995: 8b 1d e0 16 12 00 mov 0x1216e0,%ebx 11e99b: 39 d8 cmp %ebx,%eax 11e99d: 74 14 je 11e9b3 _wrapup_reent(_global_impure_ptr); 11e99f: 83 ec 0c sub $0xc,%esp 11e9a2: 53 push %ebx 11e9a3: e8 f8 05 00 00 call 11efa0 <_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; 11e9a8: 89 1d c0 52 12 00 mov %ebx,0x1252c0 11e9ae: 83 c4 10 add $0x10,%esp 11e9b1: 89 d8 mov %ebx,%eax * * Should this be changed to do *all* file streams? * _fwalk (_REENT, fclose); */ fclose (stdin); 11e9b3: 83 ec 0c sub $0xc,%esp 11e9b6: ff 70 04 pushl 0x4(%eax) 11e9b9: e8 ae 4a ff ff call 11346c fclose (stdout); 11e9be: 5a pop %edx 11e9bf: a1 c0 52 12 00 mov 0x1252c0,%eax 11e9c4: ff 70 08 pushl 0x8(%eax) 11e9c7: e8 a0 4a ff ff call 11346c fclose (stderr); 11e9cc: 58 pop %eax 11e9cd: a1 c0 52 12 00 mov 0x1252c0,%eax 11e9d2: ff 70 0c pushl 0xc(%eax) 11e9d5: e8 92 4a ff ff call 11346c 11e9da: 83 c4 10 add $0x10,%esp } 11e9dd: 8b 5d fc mov -0x4(%ebp),%ebx 11e9e0: c9 leave 11e9e1: 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 36 b9 00 00 call 116f64 <__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 =============================================================================== 0011e850 : off_t lseek( int fd, off_t offset, int whence ) { 11e850: 55 push %ebp 11e851: 89 e5 mov %esp,%ebp 11e853: 57 push %edi 11e854: 56 push %esi 11e855: 53 push %ebx 11e856: 83 ec 1c sub $0x1c,%esp 11e859: 8b 5d 08 mov 0x8(%ebp),%ebx 11e85c: 8b 55 0c mov 0xc(%ebp),%edx 11e85f: 8b 4d 10 mov 0x10(%ebp),%ecx 11e862: 8b 45 14 mov 0x14(%ebp),%eax rtems_libio_t *iop; off_t old_offset; off_t status; rtems_libio_check_fd( fd ); 11e865: 3b 1d ac 31 12 00 cmp 0x1231ac,%ebx 11e86b: 0f 83 b3 00 00 00 jae 11e924 <== NEVER TAKEN iop = rtems_libio_iop( fd ); 11e871: 8d 34 dd 00 00 00 00 lea 0x0(,%ebx,8),%esi 11e878: 8d 1c f5 00 00 00 00 lea 0x0(,%esi,8),%ebx 11e87f: 29 f3 sub %esi,%ebx 11e881: 03 1d 00 74 12 00 add 0x127400,%ebx rtems_libio_check_is_open(iop); 11e887: f6 43 15 01 testb $0x1,0x15(%ebx) 11e88b: 0f 84 93 00 00 00 je 11e924 <== NEVER TAKEN /* * Now process the lseek(). */ old_offset = iop->offset; 11e891: 8b 73 0c mov 0xc(%ebx),%esi 11e894: 8b 7b 10 mov 0x10(%ebx),%edi 11e897: 89 75 e0 mov %esi,-0x20(%ebp) 11e89a: 89 7d e4 mov %edi,-0x1c(%ebp) switch ( whence ) { 11e89d: 83 f8 01 cmp $0x1,%eax 11e8a0: 74 6e je 11e910 11e8a2: 83 f8 02 cmp $0x2,%eax 11e8a5: 74 35 je 11e8dc 11e8a7: 85 c0 test %eax,%eax 11e8a9: 75 45 jne 11e8f0 case SEEK_SET: iop->offset = offset; 11e8ab: 89 53 0c mov %edx,0xc(%ebx) 11e8ae: 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 ); 11e8b1: 8b 73 20 mov 0x20(%ebx),%esi 11e8b4: 50 push %eax 11e8b5: 51 push %ecx 11e8b6: 52 push %edx 11e8b7: 53 push %ebx 11e8b8: ff 56 14 call *0x14(%esi) if ( status == (off_t) -1 ) 11e8bb: 83 c4 10 add $0x10,%esp 11e8be: 89 c1 mov %eax,%ecx 11e8c0: 21 d1 and %edx,%ecx 11e8c2: 41 inc %ecx 11e8c3: 75 0c jne 11e8d1 iop->offset = old_offset; 11e8c5: 8b 75 e0 mov -0x20(%ebp),%esi 11e8c8: 8b 7d e4 mov -0x1c(%ebp),%edi 11e8cb: 89 73 0c mov %esi,0xc(%ebx) 11e8ce: 89 7b 10 mov %edi,0x10(%ebx) /* * So if the operation failed, we have to restore iop->offset. */ return status; } 11e8d1: 8d 65 f4 lea -0xc(%ebp),%esp 11e8d4: 5b pop %ebx 11e8d5: 5e pop %esi 11e8d6: 5f pop %edi 11e8d7: c9 leave 11e8d8: c3 ret 11e8d9: 8d 76 00 lea 0x0(%esi),%esi case SEEK_CUR: iop->offset += offset; break; case SEEK_END: iop->offset = iop->size + offset; 11e8dc: 89 d6 mov %edx,%esi 11e8de: 89 cf mov %ecx,%edi 11e8e0: 03 73 04 add 0x4(%ebx),%esi 11e8e3: 13 7b 08 adc 0x8(%ebx),%edi 11e8e6: 89 73 0c mov %esi,0xc(%ebx) 11e8e9: 89 7b 10 mov %edi,0x10(%ebx) break; 11e8ec: eb c3 jmp 11e8b1 11e8ee: 66 90 xchg %ax,%ax default: rtems_set_errno_and_return_minus_one( EINVAL ); 11e8f0: e8 1f 4a ff ff call 113314 <__errno> 11e8f5: c7 00 16 00 00 00 movl $0x16,(%eax) 11e8fb: b8 ff ff ff ff mov $0xffffffff,%eax 11e900: ba ff ff ff ff mov $0xffffffff,%edx /* * So if the operation failed, we have to restore iop->offset. */ return status; } 11e905: 8d 65 f4 lea -0xc(%ebp),%esp 11e908: 5b pop %ebx 11e909: 5e pop %esi 11e90a: 5f pop %edi 11e90b: c9 leave 11e90c: c3 ret 11e90d: 8d 76 00 lea 0x0(%esi),%esi case SEEK_SET: iop->offset = offset; break; case SEEK_CUR: iop->offset += offset; 11e910: 8b 75 e0 mov -0x20(%ebp),%esi 11e913: 8b 7d e4 mov -0x1c(%ebp),%edi 11e916: 01 d6 add %edx,%esi 11e918: 11 cf adc %ecx,%edi 11e91a: 89 73 0c mov %esi,0xc(%ebx) 11e91d: 89 7b 10 mov %edi,0x10(%ebx) break; 11e920: eb 8f jmp 11e8b1 11e922: 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); 11e924: e8 eb 49 ff ff call 113314 <__errno> 11e929: c7 00 09 00 00 00 movl $0x9,(%eax) 11e92f: b8 ff ff ff ff mov $0xffffffff,%eax 11e934: ba ff ff ff ff mov $0xffffffff,%edx 11e939: eb 96 jmp 11e8d1 =============================================================================== 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 c3 b5 00 00 call 11550c <__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 24 74 12 00 incl 0x127424 /* * 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 40 77 12 00 03 cmpl $0x3,0x127740 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 b8 31 12 00 pushl 0x1231b8 1083b3: e8 50 4d 00 00 call 10d108 <_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 d0 57 12 00 mov 0x1257d0,%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 c8 57 12 00 mov 0x1257c8,%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 cc 57 12 00 mov 0x1257cc,%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 ec ae 00 00 call 113314 <__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 1c 76 12 00 pushl 0x12761c 108325: e8 7a 3c 00 00 call 10bfa4 <_API_Mutex_Lock> *stats = rtems_malloc_statistics; 10832a: be e0 73 12 00 mov $0x1273e0,%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 1c 76 12 00 pushl 0x12761c 10833f: e8 a8 3c 00 00 call 10bfec <_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 4c 7c 12 00 mov 0x127c4c,%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 58 38 12 00 pushl 0x123858 10876e: e8 59 4d 00 00 call 10d4cc <_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 20 7c 12 00 add %ebx,0x127c20 108780: 6a 00 push $0x0 108782: 6a 00 push $0x0 108784: 56 push %esi 108785: ff 35 58 38 12 00 pushl 0x123858 10878b: e8 04 4d 00 00 call 10d494 <_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 f3 b1 00 00 call 113998 <__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 =============================================================================== 00111ec8 : */ void memfile_free_blocks_in_table( block_p **block_table, int entries ) { 111ec8: 55 push %ebp 111ec9: 89 e5 mov %esp,%ebp 111ecb: 57 push %edi 111ecc: 56 push %esi 111ecd: 53 push %ebx 111ece: 83 ec 0c sub $0xc,%esp 111ed1: 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; 111ed4: 8b 45 08 mov 0x8(%ebp),%eax 111ed7: 8b 30 mov (%eax),%esi for ( i=0 ; i<== NEVER TAKEN 111edd: 31 db xor %ebx,%ebx 111edf: 90 nop if ( b[i] ) { 111ee0: 8b 04 9e mov (%esi,%ebx,4),%eax 111ee3: 85 c0 test %eax,%eax 111ee5: 74 13 je 111efa memfile_free_block( b[i] ); 111ee7: 83 ec 0c sub $0xc,%esp 111eea: 50 push %eax 111eeb: e8 bc ff ff ff call 111eac b[i] = 0; 111ef0: c7 04 9e 00 00 00 00 movl $0x0,(%esi,%ebx,4) 111ef7: 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 111eff: 8b 45 08 mov 0x8(%ebp),%eax 111f02: 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 ); 111f04: 83 ec 0c sub $0xc,%esp 111f07: 56 push %esi 111f08: e8 9f ff ff ff call 111eac *block_table = 0; 111f0d: 8b 45 08 mov 0x8(%ebp),%eax 111f10: c7 00 00 00 00 00 movl $0x0,(%eax) 111f16: 83 c4 10 add $0x10,%esp } 111f19: 8d 65 f4 lea -0xc(%ebp),%esp 111f1c: 5b pop %ebx 111f1d: 5e pop %esi 111f1e: 5f pop %edi 111f1f: c9 leave 111f20: c3 ret =============================================================================== 00112444 : */ int memfile_ftruncate( rtems_libio_t *iop, rtems_off64_t length ) { 112444: 55 push %ebp 112445: 89 e5 mov %esp,%ebp 112447: 53 push %ebx 112448: 83 ec 14 sub $0x14,%esp 11244b: 8b 4d 08 mov 0x8(%ebp),%ecx 11244e: 8b 45 0c mov 0xc(%ebp),%eax 112451: 8b 55 10 mov 0x10(%ebp),%edx IMFS_jnode_t *the_jnode; the_jnode = iop->pathinfo.node_access; 112454: 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 ) 112457: 39 53 54 cmp %edx,0x54(%ebx) 11245a: 7f 19 jg 112475 <== NEVER TAKEN 11245c: 7d 12 jge 112470 <== ALWAYS TAKEN return IMFS_memfile_extend( the_jnode, length ); 11245e: 51 push %ecx 11245f: 52 push %edx 112460: 50 push %eax 112461: 53 push %ebx 112462: e8 45 fc ff ff call 1120ac 112467: 83 c4 10 add $0x10,%esp iop->size = the_jnode->info.file.size; IMFS_update_atime( the_jnode ); return 0; } 11246a: 8b 5d fc mov -0x4(%ebp),%ebx 11246d: c9 leave 11246e: c3 ret 11246f: 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 ) 112470: 39 43 50 cmp %eax,0x50(%ebx) 112473: 72 e9 jb 11245e /* * 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; 112475: 89 43 50 mov %eax,0x50(%ebx) 112478: 89 53 54 mov %edx,0x54(%ebx) iop->size = the_jnode->info.file.size; 11247b: 89 41 04 mov %eax,0x4(%ecx) 11247e: 89 51 08 mov %edx,0x8(%ecx) IMFS_update_atime( the_jnode ); 112481: 83 ec 08 sub $0x8,%esp 112484: 6a 00 push $0x0 112486: 8d 45 f0 lea -0x10(%ebp),%eax 112489: 50 push %eax 11248a: e8 a1 5c ff ff call 108130 11248f: 8b 45 f0 mov -0x10(%ebp),%eax 112492: 89 43 40 mov %eax,0x40(%ebx) return 0; 112495: 83 c4 10 add $0x10,%esp 112498: 31 c0 xor %eax,%eax } 11249a: 8b 5d fc mov -0x4(%ebp),%ebx 11249d: c9 leave 11249e: c3 ret =============================================================================== 001124a0 : rtems_off64_t memfile_lseek( rtems_libio_t *iop, rtems_off64_t offset, int whence ) { 1124a0: 55 push %ebp 1124a1: 89 e5 mov %esp,%ebp 1124a3: 57 push %edi 1124a4: 56 push %esi 1124a5: 53 push %ebx 1124a6: 83 ec 0c sub $0xc,%esp 1124a9: 8b 5d 08 mov 0x8(%ebp),%ebx IMFS_jnode_t *the_jnode; the_jnode = iop->pathinfo.node_access; 1124ac: 8b 73 18 mov 0x18(%ebx),%esi if (the_jnode->type == IMFS_LINEAR_FILE) { 1124af: 83 7e 4c 06 cmpl $0x6,0x4c(%esi) 1124b3: 74 2f je 1124e4 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 )) 1124b5: 57 push %edi 1124b6: ff 73 10 pushl 0x10(%ebx) 1124b9: ff 73 0c pushl 0xc(%ebx) 1124bc: 56 push %esi 1124bd: e8 ea fb ff ff call 1120ac 1124c2: 83 c4 10 add $0x10,%esp 1124c5: 85 c0 test %eax,%eax 1124c7: 75 45 jne 11250e rtems_set_errno_and_return_minus_one( ENOSPC ); iop->size = the_jnode->info.file.size; 1124c9: 8b 46 50 mov 0x50(%esi),%eax 1124cc: 8b 56 54 mov 0x54(%esi),%edx 1124cf: 89 43 04 mov %eax,0x4(%ebx) 1124d2: 89 53 08 mov %edx,0x8(%ebx) 1124d5: 8b 43 0c mov 0xc(%ebx),%eax 1124d8: 8b 53 10 mov 0x10(%ebx),%edx } return iop->offset; } 1124db: 8d 65 f4 lea -0xc(%ebp),%esp 1124de: 5b pop %ebx 1124df: 5e pop %esi 1124e0: 5f pop %edi 1124e1: c9 leave 1124e2: c3 ret 1124e3: 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) 1124e4: 8b 43 0c mov 0xc(%ebx),%eax 1124e7: 8b 53 10 mov 0x10(%ebx),%edx 1124ea: 8b 7e 50 mov 0x50(%esi),%edi 1124ed: 8b 4e 54 mov 0x54(%esi),%ecx 1124f0: 39 ca cmp %ecx,%edx 1124f2: 7c e7 jl 1124db <== NEVER TAKEN 1124f4: 7e 12 jle 112508 <== ALWAYS TAKEN iop->offset = the_jnode->info.linearfile.size; 1124f6: 89 7b 0c mov %edi,0xc(%ebx) <== NOT EXECUTED 1124f9: 89 4b 10 mov %ecx,0x10(%ebx) <== NOT EXECUTED 1124fc: 89 f8 mov %edi,%eax <== NOT EXECUTED 1124fe: 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; } 112500: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 112503: 5b pop %ebx <== NOT EXECUTED 112504: 5e pop %esi <== NOT EXECUTED 112505: 5f pop %edi <== NOT EXECUTED 112506: c9 leave <== NOT EXECUTED 112507: 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) 112508: 39 f8 cmp %edi,%eax 11250a: 76 cf jbe 1124db <== ALWAYS TAKEN 11250c: eb e8 jmp 1124f6 <== 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 ); 11250e: e8 01 0e 00 00 call 113314 <__errno> 112513: c7 00 1c 00 00 00 movl $0x1c,(%eax) 112519: b8 ff ff ff ff mov $0xffffffff,%eax 11251e: ba ff ff ff ff mov $0xffffffff,%edx 112523: eb b6 jmp 1124db =============================================================================== 0011239c : rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode ) { 11239c: 55 push %ebp 11239d: 89 e5 mov %esp,%ebp 11239f: 56 push %esi 1123a0: 53 push %ebx 1123a1: 8b 5d 08 mov 0x8(%ebp),%ebx IMFS_jnode_t *the_jnode; the_jnode = iop->pathinfo.node_access; 1123a4: 8b 73 18 mov 0x18(%ebx),%esi /* * Perform 'copy on write' for linear files */ if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND)) 1123a7: 8b 43 14 mov 0x14(%ebx),%eax 1123aa: a9 04 02 00 00 test $0x204,%eax 1123af: 74 06 je 1123b7 && (the_jnode->type == IMFS_LINEAR_FILE)) { 1123b1: 83 7e 4c 06 cmpl $0x6,0x4c(%esi) 1123b5: 74 2d je 1123e4 <== 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)) 1123b7: 8b 56 50 mov 0x50(%esi),%edx 1123ba: 8b 4e 54 mov 0x54(%esi),%ecx return -1; } if (iop->flags & LIBIO_FLAGS_APPEND) 1123bd: f6 c4 02 test $0x2,%ah 1123c0: 75 12 jne 1123d4 iop->offset = the_jnode->info.file.size; iop->size = the_jnode->info.file.size; 1123c2: 89 53 04 mov %edx,0x4(%ebx) 1123c5: 89 4b 08 mov %ecx,0x8(%ebx) return 0; 1123c8: 31 c0 xor %eax,%eax } 1123ca: 8d 65 f8 lea -0x8(%ebp),%esp 1123cd: 5b pop %ebx 1123ce: 5e pop %esi 1123cf: c9 leave 1123d0: c3 ret 1123d1: 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; 1123d4: 89 53 0c mov %edx,0xc(%ebx) 1123d7: 89 4b 10 mov %ecx,0x10(%ebx) 1123da: 8b 56 50 mov 0x50(%esi),%edx 1123dd: 8b 4e 54 mov 0x54(%esi),%ecx 1123e0: eb e0 jmp 1123c2 1123e2: 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; 1123e4: 8b 46 50 mov 0x50(%esi),%eax <== NOT EXECUTED const unsigned char *buffer = the_jnode->info.linearfile.direct; 1123e7: 8b 56 58 mov 0x58(%esi),%edx <== NOT EXECUTED the_jnode->type = IMFS_MEMORY_FILE; 1123ea: c7 46 4c 05 00 00 00 movl $0x5,0x4c(%esi) <== NOT EXECUTED the_jnode->info.file.size = 0; 1123f1: c7 46 50 00 00 00 00 movl $0x0,0x50(%esi) <== NOT EXECUTED 1123f8: c7 46 54 00 00 00 00 movl $0x0,0x54(%esi) <== NOT EXECUTED the_jnode->info.file.indirect = 0; 1123ff: c7 46 58 00 00 00 00 movl $0x0,0x58(%esi) <== NOT EXECUTED the_jnode->info.file.doubly_indirect = 0; 112406: c7 46 5c 00 00 00 00 movl $0x0,0x5c(%esi) <== NOT EXECUTED the_jnode->info.file.triply_indirect = 0; 11240d: c7 46 60 00 00 00 00 movl $0x0,0x60(%esi) <== NOT EXECUTED if ((count != 0) 112414: 85 c0 test %eax,%eax <== NOT EXECUTED 112416: 75 09 jne 112421 <== NOT EXECUTED 112418: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 11241b: 31 d2 xor %edx,%edx <== NOT EXECUTED 11241d: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 11241f: eb 9c jmp 1123bd <== NOT EXECUTED && (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1)) 112421: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 112424: 50 push %eax <== NOT EXECUTED 112425: 52 push %edx <== NOT EXECUTED 112426: 6a 00 push $0x0 <== NOT EXECUTED 112428: 6a 00 push $0x0 <== NOT EXECUTED 11242a: 56 push %esi <== NOT EXECUTED 11242b: e8 94 fd ff ff call 1121c4 <== NOT EXECUTED 112430: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 112433: 40 inc %eax <== NOT EXECUTED 112434: 74 08 je 11243e <== NOT EXECUTED 112436: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 112439: e9 79 ff ff ff jmp 1123b7 <== NOT EXECUTED return -1; 11243e: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 112441: eb 87 jmp 1123ca <== 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 a9 ae 00 00 call 113314 <__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 e9 7a 00 00 call 11007c 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 0b 12 00 mov $0x120b60,%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 84 50 12 00 88 cmpl $0x125088,0x125084 108668: 50 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 08 74 12 00 pushl 0x127408 108693: e8 18 30 00 00 call 10b6b0 108698: 5a pop %edx 108699: 59 pop %ecx 10869a: 53 push %ebx 10869b: 68 84 50 12 00 push $0x125084 1086a0: e8 37 39 00 00 call 10bfdc <_Chain_Append> } static inline void rtems_libio_unlock( void ) { rtems_semaphore_release( rtems_libio_semaphore ); 1086a5: 58 pop %eax 1086a6: ff 35 08 74 12 00 pushl 0x127408 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 b0 51 12 00 mov 0x1251b0,%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 8f ab 00 00 call 113314 <__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 0b 12 00 movl $0x120b07,-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 4f ab 00 00 call 113314 <__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 37 ab 00 00 call 113314 <__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 eb aa 00 00 call 113314 <__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 db aa 00 00 call 113314 <__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 1a ae 00 00 call 113a08 <__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 b0 fa 12 00 mov 0x12fab0,%eax 10fb25: 40 inc %eax 10fb26: a3 b0 fa 12 00 mov %eax,0x12fab0 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 00 13 00 push $0x130020 10fb4a: e8 59 2c 00 00 call 1127a8 <_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 92 69 00 00 call 116500 <_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 fe 12 00 push $0x12fe80 10fb96: e8 c5 30 00 00 call 112c60 <_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 00 13 00 mov 0x13003c,%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 d8 3b 00 00 call 113794 <_Thread_Enable_dispatch> _Thread_Enable_dispatch(); 10fbbc: e8 d3 3b 00 00 call 113794 <_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 00 13 00 push $0x130020 10fbe2: e8 39 2f 00 00 call 112b20 <_Objects_Free> _POSIX_Message_queue_Free_fd( the_mq_fd ); _Thread_Enable_dispatch(); 10fbe7: e8 a8 3b 00 00 call 113794 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one_cast( status, mqd_t ); 10fbec: e8 c7 9c 00 00 call 1198b8 <__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 7f 3b 00 00 call 113794 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( ENFILE ); 10fc15: e8 9e 9c 00 00 call 1198b8 <__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 00 13 00 push $0x130020 10fc39: e8 e2 2e 00 00 call 112b20 <_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 51 3b 00 00 call 113794 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one_cast( EEXIST, mqd_t ); 10fc43: e8 70 9c 00 00 call 1198b8 <__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 fc 66 00 00 call 116378 <_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 00 13 00 mov 0x13003c,%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 f4 3a 00 00 call 113794 <_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 00 13 00 push $0x130020 10fcb1: e8 6a 2e 00 00 call 112b20 <_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 d9 3a 00 00 call 113794 <_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 =============================================================================== 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 40 76 12 00 mov 0x127640,%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 95 60 00 00 call 10e960 <_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 08 12 00 movl $0x12088a,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 16 12 00 mov 0x1216e0,%eax 108b15: a3 c0 52 12 00 mov %eax,0x1252c0 RTEMS_INLINE_ROUTINE void _Thread_Set_libc_reent ( struct _reent **libc_reent ) { _Thread_libc_reent = libc_reent; 108b1a: c7 05 40 76 12 00 c0 movl $0x1252c0,0x127640 108b21: 52 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 16 12 00 cmp 0x1216e0,%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 9d af 00 00 call 113afc <_fwalk> #if REENT_MALLOCED free(ptr); #else _Workspace_Free(ptr); 108b5f: 89 34 24 mov %esi,(%esp) 108b62: e8 15 5e 00 00 call 10e97c <_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 c0 52 12 00 00 movl $0x0,0x1252c0 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 c0 52 12 00 mov 0x1252c0,%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 8c ae 00 00 call 1136e8 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 ff ab 00 00 call 11346c <== 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 40 41 12 00 00 cmpb $0x0,0x124140 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 40 41 12 00 01 movb $0x1,0x124140 status = rtems_io_register_name( 107cf7: 50 push %eax 107cf8: 6a 00 push $0x0 107cfa: 53 push %ebx 107cfb: 68 1a d1 11 00 push $0x11d11a 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 80 44 12 00 mov %ebx,0x124480 } 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 ba 41 00 00 call 10bedc =============================================================================== 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 b3 71 00 00 call 10fdd8 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 ce 70 00 00 call 10fd5c 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 00 74 12 00 sub 0x127400,%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 16 a6 00 00 call 113314 <__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 5f 71 00 00 call 10fe7c 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 db a5 00 00 call 113314 <__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 c7 a5 00 00 call 113314 <__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 b6 a5 00 00 call 113314 <__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 00 74 12 00 sub 0x127400,%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 f3 6e 00 00 call 10fc8c 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 66 a5 00 00 call 113314 <__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 00 74 12 00 sub 0x127400,%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 27 6e 00 00 call 10fc0c 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 a2 a4 00 00 call 113314 <__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 b4 52 12 00 mov 0x1252b4,%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 0c 12 00 push $0x120c04 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 b4 52 12 00 mov 0x1252b4,%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 07 12 00 push $0x12079c 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 =============================================================================== 00110d5c : * Called by pipe() to create an anonymous pipe. */ int pipe_create( int filsdes[2] ) { 110d5c: 55 push %ebp 110d5d: 89 e5 mov %esp,%ebp 110d5f: 57 push %edi 110d60: 56 push %esi 110d61: 53 push %ebx 110d62: 83 ec 24 sub $0x24,%esp rtems_libio_t *iop; int err = 0; if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0) 110d65: 68 ff 01 00 00 push $0x1ff 110d6a: 68 6c 2d 12 00 push $0x122d6c 110d6f: e8 38 17 00 00 call 1124ac 110d74: 83 c4 10 add $0x10,%esp 110d77: 85 c0 test %eax,%eax 110d79: 74 0d je 110d88 <== ALWAYS TAKEN return -1; 110d7b: b8 ff ff ff ff mov $0xffffffff,%eax unlink(fifopath); } if(err != 0) rtems_set_errno_and_return_minus_one(err); return 0; } 110d80: 8d 65 f4 lea -0xc(%ebp),%esp 110d83: 5b pop %ebx 110d84: 5e pop %esi 110d85: 5f pop %edi 110d86: c9 leave 110d87: 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); 110d88: 8d 5d d9 lea -0x27(%ebp),%ebx 110d8b: be 71 2d 12 00 mov $0x122d71,%esi 110d90: b9 0a 00 00 00 mov $0xa,%ecx 110d95: 89 df mov %ebx,%edi 110d97: f3 a4 rep movsb %ds:(%esi),%es:(%edi) sprintf(fifopath + 10, "%04x", rtems_pipe_no ++); 110d99: 0f b7 05 4c 8e 12 00 movzwl 0x128e4c,%eax 110da0: 8d 50 01 lea 0x1(%eax),%edx 110da3: 66 89 15 4c 8e 12 00 mov %dx,0x128e4c 110daa: 51 push %ecx 110dab: 50 push %eax 110dac: 68 7c 2d 12 00 push $0x122d7c 110db1: 8d 45 e3 lea -0x1d(%ebp),%eax 110db4: 50 push %eax 110db5: e8 aa 4a 00 00 call 115864 /* Try creating FIFO file until find an available file name */ while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) { 110dba: 58 pop %eax 110dbb: 5a pop %edx 110dbc: 68 80 01 00 00 push $0x180 110dc1: 53 push %ebx 110dc2: e8 2d 14 00 00 call 1121f4 110dc7: 83 c4 10 add $0x10,%esp 110dca: 85 c0 test %eax,%eax 110dcc: 0f 85 a6 00 00 00 jne 110e78 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); 110dd2: 83 ec 08 sub $0x8,%esp 110dd5: 68 00 40 00 00 push $0x4000 110dda: 53 push %ebx 110ddb: e8 f0 90 ff ff call 109ed0 110de0: 8b 55 08 mov 0x8(%ebp),%edx 110de3: 89 02 mov %eax,(%edx) if (filsdes[0] < 0) { 110de5: 83 c4 10 add $0x10,%esp 110de8: 85 c0 test %eax,%eax 110dea: 78 58 js 110e44 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]); 110dec: 3b 05 ec 4d 12 00 cmp 0x124dec,%eax 110df2: 72 3c jb 110e30 <== ALWAYS TAKEN 110df4: 31 d2 xor %edx,%edx <== NOT EXECUTED iop->flags &= ~LIBIO_FLAGS_NO_DELAY; 110df6: 83 62 14 fe andl $0xfffffffe,0x14(%edx) filsdes[1] = open(fifopath, O_WRONLY); 110dfa: 83 ec 08 sub $0x8,%esp 110dfd: 6a 01 push $0x1 110dff: 53 push %ebx 110e00: e8 cb 90 ff ff call 109ed0 110e05: 8b 55 08 mov 0x8(%ebp),%edx 110e08: 89 42 04 mov %eax,0x4(%edx) if (filsdes[1] < 0) { 110e0b: 83 c4 10 add $0x10,%esp 110e0e: 85 c0 test %eax,%eax 110e10: 78 4a js 110e5c int pipe_create( int filsdes[2] ) { rtems_libio_t *iop; int err = 0; 110e12: 31 f6 xor %esi,%esi if (filsdes[1] < 0) { err = errno; close(filsdes[0]); } unlink(fifopath); 110e14: 83 ec 0c sub $0xc,%esp 110e17: 53 push %ebx 110e18: e8 ff b0 ff ff call 10bf1c 110e1d: 83 c4 10 add $0x10,%esp } if(err != 0) 110e20: 85 f6 test %esi,%esi 110e22: 75 63 jne 110e87 rtems_set_errno_and_return_minus_one(err); return 0; 110e24: 31 c0 xor %eax,%eax } 110e26: 8d 65 f4 lea -0xc(%ebp),%esp 110e29: 5b pop %ebx 110e2a: 5e pop %esi 110e2b: 5f pop %edi 110e2c: c9 leave 110e2d: c3 ret 110e2e: 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]); 110e30: c1 e0 03 shl $0x3,%eax 110e33: 8d 14 c5 00 00 00 00 lea 0x0(,%eax,8),%edx 110e3a: 29 c2 sub %eax,%edx 110e3c: 03 15 80 90 12 00 add 0x129080,%edx 110e42: eb b2 jmp 110df6 } /* Non-blocking open to avoid waiting for writers */ filsdes[0] = open(fifopath, O_RDONLY | O_NONBLOCK); if (filsdes[0] < 0) { err = errno; 110e44: e8 83 40 00 00 call 114ecc <__errno> 110e49: 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); 110e4b: 83 ec 0c sub $0xc,%esp 110e4e: 53 push %ebx 110e4f: e8 c8 b0 ff ff call 10bf1c 110e54: 83 c4 10 add $0x10,%esp 110e57: eb c7 jmp 110e20 110e59: 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; 110e5c: e8 6b 40 00 00 call 114ecc <__errno> 110e61: 8b 30 mov (%eax),%esi close(filsdes[0]); 110e63: 83 ec 0c sub $0xc,%esp 110e66: 8b 45 08 mov 0x8(%ebp),%eax 110e69: ff 30 pushl (%eax) 110e6b: e8 c8 80 ff ff call 108f38 110e70: 83 c4 10 add $0x10,%esp 110e73: eb 9f jmp 110e14 110e75: 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){ 110e78: e8 4f 40 00 00 call 114ecc <__errno> return -1; 110e7d: b8 ff ff ff ff mov $0xffffffff,%eax 110e82: e9 f9 fe ff ff jmp 110d80 close(filsdes[0]); } unlink(fifopath); } if(err != 0) rtems_set_errno_and_return_minus_one(err); 110e87: e8 40 40 00 00 call 114ecc <__errno> 110e8c: 89 30 mov %esi,(%eax) 110e8e: b8 ff ff ff ff mov $0xffffffff,%eax 110e93: e9 e8 fe ff ff jmp 110d80 =============================================================================== 001122a0 : pipe_control_t *pipe, uint32_t cmd, void *buffer, rtems_libio_t *iop ) { 1122a0: 55 push %ebp 1122a1: 89 e5 mov %esp,%ebp 1122a3: 56 push %esi 1122a4: 53 push %ebx 1122a5: 8b 75 08 mov 0x8(%ebp),%esi 1122a8: 8b 5d 10 mov 0x10(%ebp),%ebx if (cmd == FIONREAD) { 1122ab: 81 7d 0c 7f 66 04 40 cmpl $0x4004667f,0xc(%ebp) 1122b2: 74 0c je 1122c0 *(unsigned int *)buffer = pipe->Length; PIPE_UNLOCK(pipe); return 0; } return -EINVAL; 1122b4: b8 ea ff ff ff mov $0xffffffea,%eax } 1122b9: 8d 65 f8 lea -0x8(%ebp),%esp 1122bc: 5b pop %ebx 1122bd: 5e pop %esi 1122be: c9 leave 1122bf: c3 ret void *buffer, rtems_libio_t *iop ) { if (cmd == FIONREAD) { if (buffer == NULL) 1122c0: 85 db test %ebx,%ebx 1122c2: 75 07 jne 1122cb return -EFAULT; 1122c4: b8 f2 ff ff ff mov $0xfffffff2,%eax 1122c9: eb ee jmp 1122b9 if (! PIPE_LOCK(pipe)) 1122cb: 50 push %eax 1122cc: 6a 00 push $0x0 1122ce: 6a 00 push $0x0 1122d0: ff 76 28 pushl 0x28(%esi) 1122d3: e8 fc b1 ff ff call 10d4d4 1122d8: 83 c4 10 add $0x10,%esp 1122db: 85 c0 test %eax,%eax 1122dd: 74 07 je 1122e6 <== ALWAYS TAKEN return -EINTR; 1122df: b8 fc ff ff ff mov $0xfffffffc,%eax <== NOT EXECUTED 1122e4: eb d3 jmp 1122b9 <== NOT EXECUTED /* Return length of pipe */ *(unsigned int *)buffer = pipe->Length; 1122e6: 8b 46 0c mov 0xc(%esi),%eax 1122e9: 89 03 mov %eax,(%ebx) PIPE_UNLOCK(pipe); 1122eb: 83 ec 0c sub $0xc,%esp 1122ee: ff 76 28 pushl 0x28(%esi) 1122f1: e8 da b2 ff ff call 10d5d0 return 0; 1122f6: 83 c4 10 add $0x10,%esp 1122f9: 31 c0 xor %eax,%eax 1122fb: eb bc jmp 1122b9 =============================================================================== 00111ee8 : pipe_control_t *pipe, void *buffer, size_t count, rtems_libio_t *iop ) { 111ee8: 55 push %ebp 111ee9: 89 e5 mov %esp,%ebp 111eeb: 57 push %edi 111eec: 56 push %esi 111eed: 53 push %ebx 111eee: 83 ec 30 sub $0x30,%esp 111ef1: 8b 5d 08 mov 0x8(%ebp),%ebx int chunk, chunk1, read = 0, ret = 0; if (! PIPE_LOCK(pipe)) 111ef4: 6a 00 push $0x0 111ef6: 6a 00 push $0x0 111ef8: ff 73 28 pushl 0x28(%ebx) 111efb: e8 d4 b5 ff ff call 10d4d4 111f00: 83 c4 10 add $0x10,%esp 111f03: 85 c0 test %eax,%eax 111f05: 0f 85 ad 00 00 00 jne 111fb8 <== NEVER TAKEN return -EINTR; while (read < count) { 111f0b: 8b 55 10 mov 0x10(%ebp),%edx 111f0e: 85 d2 test %edx,%edx 111f10: 0f 84 7a 01 00 00 je 112090 <== NEVER TAKEN 111f16: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp) 111f1d: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) while (PIPE_EMPTY(pipe)) { 111f24: 8b 53 0c mov 0xc(%ebx),%edx 111f27: 85 d2 test %edx,%edx 111f29: 0f 85 99 00 00 00 jne 111fc8 /* Not an error */ if (pipe->Writers == 0) 111f2f: 8b 43 14 mov 0x14(%ebx),%eax 111f32: 85 c0 test %eax,%eax 111f34: 0f 84 fe 00 00 00 je 112038 goto out_locked; if (LIBIO_NODELAY(iop)) { 111f3a: 8b 45 14 mov 0x14(%ebp),%eax 111f3d: f6 40 14 01 testb $0x1,0x14(%eax) 111f41: 0f 85 f9 00 00 00 jne 112040 ret = -EAGAIN; goto out_locked; } /* Wait until pipe is no more empty or no writer exists */ pipe->waitingReaders ++; 111f47: ff 43 18 incl 0x18(%ebx) PIPE_UNLOCK(pipe); 111f4a: 83 ec 0c sub $0xc,%esp 111f4d: ff 73 28 pushl 0x28(%ebx) 111f50: e8 7b b6 ff ff call 10d5d0 if (! PIPE_READWAIT(pipe)) 111f55: 5e pop %esi 111f56: 5f pop %edi 111f57: 6a 00 push $0x0 111f59: ff 73 2c pushl 0x2c(%ebx) 111f5c: e8 03 19 00 00 call 113864 111f61: 83 c4 0c add $0xc,%esp 111f64: 83 f8 01 cmp $0x1,%eax 111f67: 19 f6 sbb %esi,%esi 111f69: f7 d6 not %esi 111f6b: 83 e6 fc and $0xfffffffc,%esi ret = -EINTR; if (! PIPE_LOCK(pipe)) { 111f6e: 6a 00 push $0x0 111f70: 6a 00 push $0x0 111f72: ff 73 28 pushl 0x28(%ebx) 111f75: e8 5a b5 ff ff call 10d4d4 111f7a: 83 c4 10 add $0x10,%esp 111f7d: 85 c0 test %eax,%eax 111f7f: 0f 85 c7 00 00 00 jne 11204c <== NEVER TAKEN /* WARN waitingReaders not restored! */ ret = -EINTR; goto out_nolock; } pipe->waitingReaders --; 111f85: ff 4b 18 decl 0x18(%ebx) if (ret != 0) 111f88: 85 f6 test %esi,%esi 111f8a: 74 98 je 111f24 <== ALWAYS TAKEN PIPE_WAKEUPWRITERS(pipe); read += chunk; } out_locked: PIPE_UNLOCK(pipe); 111f8c: 83 ec 0c sub $0xc,%esp 111f8f: ff 73 28 pushl 0x28(%ebx) 111f92: e8 39 b6 ff ff call 10d5d0 111f97: 83 c4 10 add $0x10,%esp out_nolock: if (read > 0) 111f9a: 8b 55 d4 mov -0x2c(%ebp),%edx 111f9d: 85 d2 test %edx,%edx 111f9f: 7e 0b jle 111fac 111fa1: 8b 45 d4 mov -0x2c(%ebp),%eax return read; return ret; } 111fa4: 8d 65 f4 lea -0xc(%ebp),%esp 111fa7: 5b pop %ebx 111fa8: 5e pop %esi 111fa9: 5f pop %edi 111faa: c9 leave 111fab: c3 ret PIPE_UNLOCK(pipe); out_nolock: if (read > 0) return read; return ret; 111fac: 89 f0 mov %esi,%eax } 111fae: 8d 65 f4 lea -0xc(%ebp),%esp 111fb1: 5b pop %ebx 111fb2: 5e pop %esi 111fb3: 5f pop %edi 111fb4: c9 leave 111fb5: c3 ret 111fb6: 66 90 xchg %ax,%ax ) { int chunk, chunk1, read = 0, ret = 0; if (! PIPE_LOCK(pipe)) return -EINTR; 111fb8: b8 fc ff ff ff mov $0xfffffffc,%eax <== NOT EXECUTED out_nolock: if (read > 0) return read; return ret; } 111fbd: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 111fc0: 5b pop %ebx <== NOT EXECUTED 111fc1: 5e pop %esi <== NOT EXECUTED 111fc2: 5f pop %edi <== NOT EXECUTED 111fc3: c9 leave <== NOT EXECUTED 111fc4: c3 ret <== NOT EXECUTED 111fc5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if (ret != 0) goto out_locked; } /* Read chunk bytes */ chunk = MIN(count - read, pipe->Length); 111fc8: 8b 45 10 mov 0x10(%ebp),%eax 111fcb: 2b 45 d0 sub -0x30(%ebp),%eax 111fce: 89 55 cc mov %edx,-0x34(%ebp) 111fd1: 39 c2 cmp %eax,%edx 111fd3: 76 03 jbe 111fd8 111fd5: 89 45 cc mov %eax,-0x34(%ebp) chunk1 = pipe->Size - pipe->Start; 111fd8: 8b 73 08 mov 0x8(%ebx),%esi 111fdb: 8b 43 04 mov 0x4(%ebx),%eax 111fde: 29 f0 sub %esi,%eax if (chunk > chunk1) { 111fe0: 39 45 cc cmp %eax,-0x34(%ebp) 111fe3: 7f 71 jg 112056 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); 111fe5: 8b 45 0c mov 0xc(%ebp),%eax 111fe8: 03 45 d0 add -0x30(%ebp),%eax 111feb: 03 33 add (%ebx),%esi 111fed: 89 c7 mov %eax,%edi 111fef: 8b 4d cc mov -0x34(%ebp),%ecx 111ff2: f3 a4 rep movsb %ds:(%esi),%es:(%edi) pipe->Start += chunk; 111ff4: 8b 45 cc mov -0x34(%ebp),%eax 111ff7: 03 43 08 add 0x8(%ebx),%eax pipe->Start %= pipe->Size; 111ffa: 31 d2 xor %edx,%edx 111ffc: f7 73 04 divl 0x4(%ebx) 111fff: 89 53 08 mov %edx,0x8(%ebx) pipe->Length -= chunk; 112002: 8b 43 0c mov 0xc(%ebx),%eax 112005: 2b 45 cc sub -0x34(%ebp),%eax 112008: 89 43 0c mov %eax,0xc(%ebx) /* For buffering optimization */ if (PIPE_EMPTY(pipe)) 11200b: 85 c0 test %eax,%eax 11200d: 75 07 jne 112016 pipe->Start = 0; 11200f: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) if (pipe->waitingWriters > 0) 112016: 8b 4b 1c mov 0x1c(%ebx),%ecx 112019: 85 c9 test %ecx,%ecx 11201b: 75 5f jne 11207c PIPE_WAKEUPWRITERS(pipe); read += chunk; 11201d: 8b 45 cc mov -0x34(%ebp),%eax 112020: 01 45 d4 add %eax,-0x2c(%ebp) int chunk, chunk1, read = 0, ret = 0; if (! PIPE_LOCK(pipe)) return -EINTR; while (read < count) { 112023: 8b 45 d4 mov -0x2c(%ebp),%eax 112026: 89 45 d0 mov %eax,-0x30(%ebp) 112029: 8b 45 10 mov 0x10(%ebp),%eax 11202c: 39 45 d4 cmp %eax,-0x2c(%ebp) 11202f: 0f 82 ef fe ff ff jb 111f24 <== NEVER TAKEN 112035: 8d 76 00 lea 0x0(%esi),%esi while (PIPE_EMPTY(pipe)) { /* Not an error */ if (pipe->Writers == 0) 112038: 31 f6 xor %esi,%esi 11203a: e9 4d ff ff ff jmp 111f8c 11203f: 90 nop goto out_locked; if (LIBIO_NODELAY(iop)) { ret = -EAGAIN; 112040: be f5 ff ff ff mov $0xfffffff5,%esi 112045: e9 42 ff ff ff jmp 111f8c 11204a: 66 90 xchg %ax,%ax PIPE_UNLOCK(pipe); if (! PIPE_READWAIT(pipe)) ret = -EINTR; if (! PIPE_LOCK(pipe)) { /* WARN waitingReaders not restored! */ ret = -EINTR; 11204c: be fc ff ff ff mov $0xfffffffc,%esi <== NOT EXECUTED 112051: e9 44 ff ff ff jmp 111f9a <== 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); 112056: 8b 55 0c mov 0xc(%ebp),%edx 112059: 03 55 d0 add -0x30(%ebp),%edx 11205c: 03 33 add (%ebx),%esi 11205e: 89 d7 mov %edx,%edi 112060: 89 c1 mov %eax,%ecx 112062: f3 a4 rep movsb %ds:(%esi),%es:(%edi) memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1); 112064: 8b 55 d0 mov -0x30(%ebp),%edx 112067: 01 c2 add %eax,%edx 112069: 03 55 0c add 0xc(%ebp),%edx 11206c: 8b 4d cc mov -0x34(%ebp),%ecx 11206f: 29 c1 sub %eax,%ecx 112071: 8b 33 mov (%ebx),%esi 112073: 89 d7 mov %edx,%edi 112075: f3 a4 rep movsb %ds:(%esi),%es:(%edi) 112077: e9 78 ff ff ff jmp 111ff4 /* For buffering optimization */ if (PIPE_EMPTY(pipe)) pipe->Start = 0; if (pipe->waitingWriters > 0) PIPE_WAKEUPWRITERS(pipe); 11207c: 83 ec 08 sub $0x8,%esp 11207f: 8d 45 e4 lea -0x1c(%ebp),%eax 112082: 50 push %eax 112083: ff 73 30 pushl 0x30(%ebx) 112086: e8 75 17 00 00 call 113800 11208b: 83 c4 10 add $0x10,%esp 11208e: eb 8d jmp 11201d int chunk, chunk1, read = 0, ret = 0; if (! PIPE_LOCK(pipe)) return -EINTR; while (read < count) { 112090: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) <== NOT EXECUTED 112097: 31 f6 xor %esi,%esi <== NOT EXECUTED 112099: e9 ee fe ff ff jmp 111f8c <== NOT EXECUTED =============================================================================== 00111994 : */ void pipe_release( pipe_control_t **pipep, rtems_libio_t *iop ) { 111994: 55 push %ebp 111995: 89 e5 mov %esp,%ebp 111997: 57 push %edi 111998: 56 push %esi 111999: 53 push %ebx 11199a: 83 ec 1c sub $0x1c,%esp 11199d: 8b 7d 08 mov 0x8(%ebp),%edi pipe_control_t *pipe = *pipep; 1119a0: 8b 1f mov (%edi),%ebx /* WARN pipe not released! */ if (!PIPE_LOCK(pipe)) rtems_fatal_error_occurred(0xdeadbeef); #endif mode = LIBIO_ACCMODE(iop); 1119a2: 8b 45 0c mov 0xc(%ebp),%eax 1119a5: 8b 40 14 mov 0x14(%eax),%eax 1119a8: 89 c6 mov %eax,%esi 1119aa: 83 e6 06 and $0x6,%esi if (mode & LIBIO_FLAGS_READ) 1119ad: a8 02 test $0x2,%al 1119af: 74 03 je 1119b4 pipe->Readers --; 1119b1: ff 4b 10 decl 0x10(%ebx) if (mode & LIBIO_FLAGS_WRITE) 1119b4: f7 c6 04 00 00 00 test $0x4,%esi 1119ba: 74 03 je 1119bf pipe->Writers --; 1119bc: ff 4b 14 decl 0x14(%ebx) PIPE_UNLOCK(pipe); 1119bf: 83 ec 0c sub $0xc,%esp 1119c2: ff 73 28 pushl 0x28(%ebx) 1119c5: e8 06 bc ff ff call 10d5d0 if (pipe->Readers == 0 && pipe->Writers == 0) { 1119ca: 83 c4 10 add $0x10,%esp 1119cd: 8b 53 10 mov 0x10(%ebx),%edx 1119d0: 85 d2 test %edx,%edx 1119d2: 74 2c je 111a00 *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) 1119d4: 8b 43 14 mov 0x14(%ebx),%eax 1119d7: 85 c0 test %eax,%eax 1119d9: 75 17 jne 1119f2 <== NEVER TAKEN 1119db: 83 fe 02 cmp $0x2,%esi 1119de: 74 12 je 1119f2 <== NEVER TAKEN PIPE_WAKEUPREADERS(pipe); 1119e0: 83 ec 08 sub $0x8,%esp 1119e3: 8d 45 e4 lea -0x1c(%ebp),%eax 1119e6: 50 push %eax 1119e7: ff 73 2c pushl 0x2c(%ebx) 1119ea: e8 11 1e 00 00 call 113800 1119ef: 83 c4 10 add $0x10,%esp pipe_unlock(); 1119f2: e8 85 ff ff ff call 11197c iop->flags &= ~LIBIO_FLAGS_OPEN; if(iop->pathinfo.ops->unlink_h(&iop->pathinfo)) return; #endif } 1119f7: 8d 65 f4 lea -0xc(%ebp),%esp 1119fa: 5b pop %ebx 1119fb: 5e pop %esi 1119fc: 5f pop %edi 1119fd: c9 leave 1119fe: c3 ret 1119ff: 90 nop if (mode & LIBIO_FLAGS_WRITE) pipe->Writers --; PIPE_UNLOCK(pipe); if (pipe->Readers == 0 && pipe->Writers == 0) { 111a00: 8b 43 14 mov 0x14(%ebx),%eax 111a03: 85 c0 test %eax,%eax 111a05: 74 25 je 111a2c delfile = TRUE; #endif pipe_free(pipe); *pipep = NULL; } else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE) 111a07: 83 fe 04 cmp $0x4,%esi 111a0a: 74 e6 je 1119f2 <== NEVER TAKEN /* Notify waiting Writers that all their partners left */ PIPE_WAKEUPWRITERS(pipe); 111a0c: 83 ec 08 sub $0x8,%esp 111a0f: 8d 45 e4 lea -0x1c(%ebp),%eax 111a12: 50 push %eax 111a13: ff 73 30 pushl 0x30(%ebx) 111a16: e8 e5 1d 00 00 call 113800 111a1b: 83 c4 10 add $0x10,%esp else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ) PIPE_WAKEUPREADERS(pipe); pipe_unlock(); 111a1e: e8 59 ff ff ff call 11197c iop->flags &= ~LIBIO_FLAGS_OPEN; if(iop->pathinfo.ops->unlink_h(&iop->pathinfo)) return; #endif } 111a23: 8d 65 f4 lea -0xc(%ebp),%esp 111a26: 5b pop %ebx 111a27: 5e pop %esi 111a28: 5f pop %edi 111a29: c9 leave 111a2a: c3 ret 111a2b: 90 nop /* Called with pipe_semaphore held. */ static inline void pipe_free( pipe_control_t *pipe ) { rtems_barrier_delete(pipe->readBarrier); 111a2c: 83 ec 0c sub $0xc,%esp 111a2f: ff 73 2c pushl 0x2c(%ebx) 111a32: e8 39 1d 00 00 call 113770 rtems_barrier_delete(pipe->writeBarrier); 111a37: 5e pop %esi 111a38: ff 73 30 pushl 0x30(%ebx) 111a3b: e8 30 1d 00 00 call 113770 rtems_semaphore_delete(pipe->Semaphore); 111a40: 59 pop %ecx 111a41: ff 73 28 pushl 0x28(%ebx) 111a44: e8 e7 b9 ff ff call 10d430 free(pipe->Buffer); 111a49: 5a pop %edx 111a4a: ff 33 pushl (%ebx) 111a4c: e8 7f 7f ff ff call 1099d0 free(pipe); 111a51: 89 1c 24 mov %ebx,(%esp) 111a54: e8 77 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; 111a59: c7 07 00 00 00 00 movl $0x0,(%edi) 111a5f: 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(); 111a62: e8 15 ff ff ff call 11197c iop->flags &= ~LIBIO_FLAGS_OPEN; if(iop->pathinfo.ops->unlink_h(&iop->pathinfo)) return; #endif } 111a67: 8d 65 f4 lea -0xc(%ebp),%esp 111a6a: 5b pop %ebx 111a6b: 5e pop %esi 111a6c: 5f pop %edi 111a6d: c9 leave 111a6e: c3 ret =============================================================================== 001120a0 : pipe_control_t *pipe, const void *buffer, size_t count, rtems_libio_t *iop ) { 1120a0: 55 push %ebp 1120a1: 89 e5 mov %esp,%ebp 1120a3: 57 push %edi 1120a4: 56 push %esi 1120a5: 53 push %ebx 1120a6: 83 ec 2c sub $0x2c,%esp 1120a9: 8b 5d 10 mov 0x10(%ebp),%ebx int chunk, chunk1, written = 0, ret = 0; /* Write nothing */ if (count == 0) 1120ac: 85 db test %ebx,%ebx 1120ae: 75 0c jne 1120bc <== ALWAYS TAKEN return 0; 1120b0: 31 c0 xor %eax,%eax #endif if (written > 0) return written; return ret; } 1120b2: 8d 65 f4 lea -0xc(%ebp),%esp 1120b5: 5b pop %ebx 1120b6: 5e pop %esi 1120b7: 5f pop %edi 1120b8: c9 leave 1120b9: c3 ret 1120ba: 66 90 xchg %ax,%ax /* Write nothing */ if (count == 0) return 0; if (! PIPE_LOCK(pipe)) 1120bc: 56 push %esi 1120bd: 6a 00 push $0x0 1120bf: 6a 00 push $0x0 1120c1: 8b 45 08 mov 0x8(%ebp),%eax 1120c4: ff 70 28 pushl 0x28(%eax) 1120c7: e8 08 b4 ff ff call 10d4d4 1120cc: 83 c4 10 add $0x10,%esp 1120cf: 85 c0 test %eax,%eax 1120d1: 0f 85 4a 01 00 00 jne 112221 <== NEVER TAKEN return -EINTR; if (pipe->Readers == 0) { 1120d7: 8b 45 08 mov 0x8(%ebp),%eax 1120da: 8b 48 10 mov 0x10(%eax),%ecx 1120dd: 85 c9 test %ecx,%ecx 1120df: 0f 84 57 01 00 00 je 11223c ret = -EPIPE; goto out_locked; } /* Write of PIPE_BUF bytes or less shall not be interleaved */ chunk = count <= pipe->Size ? count : 1; 1120e5: 8b 48 04 mov 0x4(%eax),%ecx 1120e8: 39 cb cmp %ecx,%ebx 1120ea: 0f 87 42 01 00 00 ja 112232 <== NEVER TAKEN 1120f0: 89 de mov %ebx,%esi 1120f2: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp) 1120f9: 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); 112100: 89 5d c8 mov %ebx,-0x38(%ebp) 112103: 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) { 112106: 8b 43 0c mov 0xc(%ebx),%eax 112109: 89 ca mov %ecx,%edx 11210b: 29 c2 sub %eax,%edx 11210d: 39 f2 cmp %esi,%edx 11210f: 73 6f jae 112180 if (LIBIO_NODELAY(iop)) { 112111: 8b 45 14 mov 0x14(%ebp),%eax 112114: f6 40 14 01 testb $0x1,0x14(%eax) 112118: 0f 85 48 01 00 00 jne 112266 ret = -EAGAIN; goto out_locked; } /* Wait until there is chunk bytes space or no reader exists */ pipe->waitingWriters ++; 11211e: ff 43 1c incl 0x1c(%ebx) PIPE_UNLOCK(pipe); 112121: 83 ec 0c sub $0xc,%esp 112124: ff 73 28 pushl 0x28(%ebx) 112127: e8 a4 b4 ff ff call 10d5d0 if (! PIPE_WRITEWAIT(pipe)) 11212c: 58 pop %eax 11212d: 5a pop %edx 11212e: 6a 00 push $0x0 112130: ff 73 30 pushl 0x30(%ebx) 112133: e8 2c 17 00 00 call 113864 112138: 83 c4 0c add $0xc,%esp 11213b: 83 f8 01 cmp $0x1,%eax 11213e: 19 ff sbb %edi,%edi 112140: f7 d7 not %edi 112142: 83 e7 fc and $0xfffffffc,%edi ret = -EINTR; if (! PIPE_LOCK(pipe)) { 112145: 6a 00 push $0x0 112147: 6a 00 push $0x0 112149: ff 73 28 pushl 0x28(%ebx) 11214c: e8 83 b3 ff ff call 10d4d4 112151: 83 c4 10 add $0x10,%esp 112154: 85 c0 test %eax,%eax 112156: 0f 85 03 01 00 00 jne 11225f <== NEVER TAKEN /* WARN waitingWriters not restored! */ ret = -EINTR; goto out_nolock; } pipe->waitingWriters --; 11215c: ff 4b 1c decl 0x1c(%ebx) if (ret != 0) 11215f: 85 ff test %edi,%edi 112161: 0f 85 95 00 00 00 jne 1121fc <== NEVER TAKEN goto out_locked; if (pipe->Readers == 0) { 112167: 8b 7b 10 mov 0x10(%ebx),%edi 11216a: 85 ff test %edi,%edi 11216c: 0f 84 85 00 00 00 je 1121f7 <== NEVER TAKEN 112172: 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) { 112175: 8b 43 0c mov 0xc(%ebx),%eax 112178: 89 ca mov %ecx,%edx 11217a: 29 c2 sub %eax,%edx 11217c: 39 f2 cmp %esi,%edx 11217e: 72 91 jb 112111 <== NEVER TAKEN ret = -EPIPE; goto out_locked; } } chunk = MIN(count - written, PIPE_SPACE(pipe)); 112180: 8b 75 c8 mov -0x38(%ebp),%esi 112183: 2b 75 d0 sub -0x30(%ebp),%esi 112186: 89 55 cc mov %edx,-0x34(%ebp) 112189: 39 f2 cmp %esi,%edx 11218b: 76 03 jbe 112190 11218d: 89 75 cc mov %esi,-0x34(%ebp) chunk1 = pipe->Size - PIPE_WSTART(pipe); 112190: 03 43 08 add 0x8(%ebx),%eax 112193: 31 d2 xor %edx,%edx 112195: f7 f1 div %ecx 112197: 89 c8 mov %ecx,%eax 112199: 29 d0 sub %edx,%eax if (chunk > chunk1) { 11219b: 39 45 cc cmp %eax,-0x34(%ebp) 11219e: 0f 8e c9 00 00 00 jle 11226d memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1); 1121a4: 03 13 add (%ebx),%edx 1121a6: 8b 75 0c mov 0xc(%ebp),%esi 1121a9: 03 75 d0 add -0x30(%ebp),%esi 1121ac: 89 d7 mov %edx,%edi 1121ae: 89 c1 mov %eax,%ecx 1121b0: f3 a4 rep movsb %ds:(%esi),%es:(%edi) memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1); 1121b2: 8b 13 mov (%ebx),%edx 1121b4: 8b 4d cc mov -0x34(%ebp),%ecx 1121b7: 29 c1 sub %eax,%ecx 1121b9: 03 45 d0 add -0x30(%ebp),%eax 1121bc: 8b 75 0c mov 0xc(%ebp),%esi 1121bf: 01 c6 add %eax,%esi 1121c1: 89 d7 mov %edx,%edi 1121c3: f3 a4 rep movsb %ds:(%esi),%es:(%edi) } else memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk); pipe->Length += chunk; 1121c5: 8b 45 cc mov -0x34(%ebp),%eax 1121c8: 01 43 0c add %eax,0xc(%ebx) if (pipe->waitingReaders > 0) 1121cb: 83 7b 18 00 cmpl $0x0,0x18(%ebx) 1121cf: 0f 85 ac 00 00 00 jne 112281 PIPE_WAKEUPREADERS(pipe); written += chunk; 1121d5: 8b 45 cc mov -0x34(%ebp),%eax 1121d8: 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) { 1121db: 8b 45 d4 mov -0x2c(%ebp),%eax 1121de: 89 45 d0 mov %eax,-0x30(%ebp) 1121e1: 39 45 c8 cmp %eax,-0x38(%ebp) 1121e4: 0f 86 ad 00 00 00 jbe 112297 <== ALWAYS TAKEN 1121ea: 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; 1121ed: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED 1121f2: e9 0f ff ff ff jmp 112106 <== NOT EXECUTED pipe->waitingWriters --; if (ret != 0) goto out_locked; if (pipe->Readers == 0) { ret = -EPIPE; 1121f7: 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); 1121fc: 83 ec 0c sub $0xc,%esp 1121ff: 8b 45 08 mov 0x8(%ebp),%eax 112202: ff 70 28 pushl 0x28(%eax) 112205: e8 c6 b3 ff ff call 10d5d0 11220a: 83 c4 10 add $0x10,%esp out_nolock: #ifdef RTEMS_POSIX_API /* Signal SIGPIPE */ if (ret == -EPIPE) 11220d: 83 ff e0 cmp $0xffffffe0,%edi 112210: 74 38 je 11224a kill(getpid(), SIGPIPE); #endif if (written > 0) 112212: 8b 4d d4 mov -0x2c(%ebp),%ecx 112215: 85 c9 test %ecx,%ecx 112217: 7e 12 jle 11222b 112219: 8b 45 d4 mov -0x2c(%ebp),%eax 11221c: e9 91 fe ff ff jmp 1120b2 /* Write nothing */ if (count == 0) return 0; if (! PIPE_LOCK(pipe)) return -EINTR; 112221: b8 fc ff ff ff mov $0xfffffffc,%eax <== NOT EXECUTED 112226: e9 87 fe ff ff jmp 1120b2 <== NOT EXECUTED /* Signal SIGPIPE */ if (ret == -EPIPE) kill(getpid(), SIGPIPE); #endif if (written > 0) 11222b: 89 f8 mov %edi,%eax 11222d: e9 80 fe ff ff jmp 1120b2 ret = -EPIPE; goto out_locked; } /* Write of PIPE_BUF bytes or less shall not be interleaved */ chunk = count <= pipe->Size ? count : 1; 112232: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED 112237: e9 b6 fe ff ff jmp 1120f2 <== NOT EXECUTED if (! PIPE_LOCK(pipe)) return -EINTR; if (pipe->Readers == 0) { ret = -EPIPE; 11223c: 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; 112241: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) 112248: eb b2 jmp 1121fc out_nolock: #ifdef RTEMS_POSIX_API /* Signal SIGPIPE */ if (ret == -EPIPE) kill(getpid(), SIGPIPE); 11224a: e8 21 08 00 00 call 112a70 11224f: 83 ec 08 sub $0x8,%esp 112252: 6a 0d push $0xd 112254: 50 push %eax 112255: e8 1a 0b 00 00 call 112d74 11225a: 83 c4 10 add $0x10,%esp 11225d: eb b3 jmp 112212 PIPE_UNLOCK(pipe); if (! PIPE_WRITEWAIT(pipe)) ret = -EINTR; if (! PIPE_LOCK(pipe)) { /* WARN waitingWriters not restored! */ ret = -EINTR; 11225f: bf fc ff ff ff mov $0xfffffffc,%edi <== NOT EXECUTED 112264: eb ac jmp 112212 <== NOT EXECUTED chunk = count <= pipe->Size ? count : 1; while (written < count) { while (PIPE_SPACE(pipe) < chunk) { if (LIBIO_NODELAY(iop)) { ret = -EAGAIN; 112266: bf f5 ff ff ff mov $0xfffffff5,%edi 11226b: eb 8f jmp 1121fc 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); 11226d: 03 13 add (%ebx),%edx 11226f: 8b 75 0c mov 0xc(%ebp),%esi 112272: 03 75 d0 add -0x30(%ebp),%esi 112275: 89 d7 mov %edx,%edi 112277: 8b 4d cc mov -0x34(%ebp),%ecx 11227a: f3 a4 rep movsb %ds:(%esi),%es:(%edi) 11227c: e9 44 ff ff ff jmp 1121c5 pipe->Length += chunk; if (pipe->waitingReaders > 0) PIPE_WAKEUPREADERS(pipe); 112281: 56 push %esi 112282: 56 push %esi 112283: 8d 45 e4 lea -0x1c(%ebp),%eax 112286: 50 push %eax 112287: ff 73 2c pushl 0x2c(%ebx) 11228a: e8 71 15 00 00 call 113800 11228f: 83 c4 10 add $0x10,%esp 112292: e9 3e ff ff ff jmp 1121d5 } /* Write of PIPE_BUF bytes or less shall not be interleaved */ chunk = count <= pipe->Size ? count : 1; while (written < count) { 112297: 31 ff xor %edi,%edi 112299: e9 5e ff ff ff jmp 1121fc =============================================================================== 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 08 dd 12 00 incl 0x12dd08 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 =============================================================================== 00111b5c : int pthread_attr_setinheritsched( pthread_attr_t *attr, int inheritsched ) { 111b5c: 55 push %ebp 111b5d: 89 e5 mov %esp,%ebp 111b5f: 8b 45 08 mov 0x8(%ebp),%eax 111b62: 8b 55 0c mov 0xc(%ebp),%edx if ( !attr || !attr->is_initialized ) 111b65: 85 c0 test %eax,%eax 111b67: 74 1f je 111b88 111b69: 8b 08 mov (%eax),%ecx 111b6b: 85 c9 test %ecx,%ecx 111b6d: 74 19 je 111b88 return EINVAL; switch ( inheritsched ) { 111b6f: 8d 4a ff lea -0x1(%edx),%ecx 111b72: 83 f9 01 cmp $0x1,%ecx 111b75: 76 09 jbe 111b80 case PTHREAD_EXPLICIT_SCHED: attr->inheritsched = inheritsched; return 0; default: return ENOTSUP; 111b77: b8 86 00 00 00 mov $0x86,%eax } } 111b7c: c9 leave 111b7d: c3 ret 111b7e: 66 90 xchg %ax,%ax return EINVAL; switch ( inheritsched ) { case PTHREAD_INHERIT_SCHED: case PTHREAD_EXPLICIT_SCHED: attr->inheritsched = inheritsched; 111b80: 89 50 10 mov %edx,0x10(%eax) return 0; 111b83: 31 c0 xor %eax,%eax default: return ENOTSUP; } } 111b85: c9 leave 111b86: c3 ret 111b87: 90 nop pthread_attr_t *attr, int inheritsched ) { if ( !attr || !attr->is_initialized ) return EINVAL; 111b88: b8 16 00 00 00 mov $0x16,%eax return 0; default: return ENOTSUP; } } 111b8d: c9 leave 111b8e: 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 f8 db 12 00 mov 0x12dbf8,%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 =============================================================================== 00111b90 : int pthread_attr_setstacksize( pthread_attr_t *attr, size_t stacksize ) { 111b90: 55 push %ebp 111b91: 89 e5 mov %esp,%ebp 111b93: 8b 45 08 mov 0x8(%ebp),%eax 111b96: 8b 55 0c mov 0xc(%ebp),%edx if ( !attr || !attr->is_initialized ) 111b99: 85 c0 test %eax,%eax 111b9b: 74 23 je 111bc0 111b9d: 8b 08 mov (%eax),%ecx 111b9f: 85 c9 test %ecx,%ecx 111ba1: 74 1d je 111bc0 return EINVAL; if (stacksize < PTHREAD_MINIMUM_STACK_SIZE) 111ba3: 8b 0d 78 45 12 00 mov 0x124578,%ecx 111ba9: d1 e1 shl %ecx 111bab: 39 d1 cmp %edx,%ecx 111bad: 77 09 ja 111bb8 attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE; else attr->stacksize = stacksize; 111baf: 89 50 08 mov %edx,0x8(%eax) return 0; 111bb2: 31 c0 xor %eax,%eax } 111bb4: c9 leave 111bb5: c3 ret 111bb6: 66 90 xchg %ax,%ax { if ( !attr || !attr->is_initialized ) return EINVAL; if (stacksize < PTHREAD_MINIMUM_STACK_SIZE) attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE; 111bb8: 89 48 08 mov %ecx,0x8(%eax) else attr->stacksize = stacksize; return 0; 111bbb: 31 c0 xor %eax,%eax } 111bbd: c9 leave 111bbe: c3 ret 111bbf: 90 nop pthread_attr_t *attr, size_t stacksize ) { if ( !attr || !attr->is_initialized ) return EINVAL; 111bc0: 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; } 111bc5: c9 leave 111bc6: 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 f0 8c 12 00 mov 0x128cf0,%eax 10b9de: 40 inc %eax 10b9df: a3 f0 8c 12 00 mov %eax,0x128cf0 * 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 40 91 12 00 push $0x129140 10b9ec: e8 fb 20 00 00 call 10daec <_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 dd 16 00 00 call 10d0e8 <_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 5c 91 12 00 mov 0x12915c,%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 2d 30 00 00 call 10ea58 <_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 0b 30 00 00 call 10ea58 <_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 40 91 12 00 push $0x129140 10ba81: e8 1e 25 00 00 call 10dfa4 <_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 77 16 00 00 call 10d11c <_CORE_barrier_Wait> the_barrier->Object.id, true, 0, NULL ); _Thread_Enable_dispatch(); 10baa5: 83 c4 20 add $0x20,%esp 10baa8: e8 ab 2f 00 00 call 10ea58 <_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 d8 92 12 00 mov 0x1292d8,%eax true, 0, NULL ); _Thread_Enable_dispatch(); return _POSIX_Barrier_Translate_core_barrier_return_code( 10bab5: ff 70 34 pushl 0x34(%eax) 10bab8: e8 e7 5b 00 00 call 1116a4 <_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 8e 12 00 mov 0x128e54,%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 8b 12 00 push $0x128b40 10b159: e8 2a 21 00 00 call 10d288 <_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 5b 55 00 00 call 1106dc <_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 5d 08 mov 0x8(%ebp),%ebx 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 58 7f 12 00 mov 0x127f58,%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 70 79 12 00 mov 0x127970,%edx 10afd1: 42 inc %edx 10afd2: 89 15 70 79 12 00 mov %edx,0x127970 * 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: 5e pop %esi 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: 56 push %esi 10affa: 9d popf 10affb: 8b 70 08 mov 0x8(%eax),%esi 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 3a 3a 00 00 call 10ea44 <_Workspace_Free> _Thread_Enable_dispatch(); 10b00a: e8 ad 29 00 00 call 10d9bc <_Thread_Enable_dispatch> if ( execute ) 10b00f: 83 c4 10 add $0x10,%esp 10b012: 85 db test %ebx,%ebx 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 f0 mov %esi,%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 87 29 00 00 call 10d9bc <_Thread_Enable_dispatch> _ISR_Enable( level ); 10b035: 56 push %esi 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 10 90 12 00 mov 0x129010,%eax 10b374: 40 inc %eax 10b375: a3 10 90 12 00 mov %eax,0x129010 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 00 42 00 00 call 10f584 <_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 f8 95 12 00 mov 0x1295f8,%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 c3 17 00 00 call 10cb70 <_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 cd 30 00 00 jmp 10e488 <_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 b9 3d 00 00 call 10fe38 <_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 95 36 00 00 call 10f720 <_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 c0 a1 12 00 push $0x12a1c0 10c0ad: e8 7e 27 00 00 call 10e830 <_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 c0 a1 12 00 push $0x12a1c0 10c0ba: e8 6d 2a 00 00 call 10eb2c <_Objects_Free> &_POSIX_Condition_variables_Information, &the_cond->Object ); _POSIX_Condition_variables_Free( the_cond ); _Thread_Enable_dispatch(); 10c0bf: e8 5c 36 00 00 call 10f720 <_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 d0 9c 12 00 mov 0x129cd0,%eax 10c14d: 40 inc %eax 10c14e: a3 d0 9c 12 00 mov %eax,0x129cd0 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 c0 a1 12 00 push $0x12a1c0 10c15b: e8 54 26 00 00 call 10e7b4 <_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 2b 3d 00 00 call 10feb4 <_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 dc a1 12 00 mov 0x12a1dc,%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 74 35 00 00 call 10f720 <_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 33 12 00 mov $0x12333c,%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 57 35 00 00 call 10f720 <_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 33 12 00 mov 0x12333c,%edx 10c004: 8b 0d 40 33 12 00 mov 0x123340,%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 78 45 12 00 mov 0x124578,%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 e0 1e 12 00 mov $0x121ee0,%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 8e 12 00 mov 0x128e38,%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 95 62 00 00 call 111a30 <_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 7c 45 12 00 movzbl 0x12457c,%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 89 62 00 00 call 111a4c <_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 3c 89 12 00 pushl 0x12893c 10b7d9: 89 45 a0 mov %eax,-0x60(%ebp) 10b7dc: e8 bf 17 00 00 call 10cfa0 <_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 8b 12 00 movl $0x128b20,(%esp) 10b7e8: e8 d7 21 00 00 call 10d9c4 <_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 78 45 12 00 mov 0x124578,%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 8b 12 00 push $0x128b20 10b840: 89 55 a0 mov %edx,-0x60(%ebp) 10b843: e8 80 31 00 00 call 10e9c8 <_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 8b 12 00 push $0x128b20 10b85d: e8 da 24 00 00 call 10dd3c <_Objects_Free> _POSIX_Threads_Free( the_thread ); _RTEMS_Unlock_allocator(); 10b862: 59 pop %ecx 10b863: ff 35 3c 89 12 00 pushl 0x12893c 10b869: e8 7a 17 00 00 call 10cfe8 <_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 66 3a 00 00 call 10f340 <_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 3c 89 12 00 pushl 0x12893c 10b8fa: 89 55 a0 mov %edx,-0x60(%ebp) 10b8fd: e8 e6 16 00 00 call 10cfe8 <_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 3c 89 12 00 pushl 0x12893c 10b916: e8 cd 16 00 00 call 10cfe8 <_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 a3 3b 00 00 call 10f4dc <_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 5c 89 12 00 push $0x12895c 10b951: e8 b6 3e 00 00 call 10f80c <_Watchdog_Insert> 10b956: 83 c4 10 add $0x10,%esp 10b959: 8b 55 a0 mov -0x60(%ebp),%edx 10b95c: eb 88 jmp 10b8e6 =============================================================================== 00112e78 : } void pthread_exit( void *value_ptr ) { 112e78: 55 push %ebp 112e79: 89 e5 mov %esp,%ebp 112e7b: 83 ec 10 sub $0x10,%esp _POSIX_Thread_Exit( _Thread_Executing, value_ptr ); 112e7e: ff 75 08 pushl 0x8(%ebp) 112e81: ff 35 58 7b 12 00 pushl 0x127b58 112e87: e8 88 ff ff ff call 112e14 <_POSIX_Thread_Exit> 112e8c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 112e8f: c9 leave <== NOT EXECUTED 112e90: 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 60 b8 12 00 push $0x12b860 10d8f4: e8 07 24 00 00 call 10fd00 <_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 5c 72 12 00 movzbl 0x12725c,%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 83 2e 00 00 call 1107b4 <_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 40 8a 12 00 push $0x128a40 10b6ca: e8 a5 25 00 00 call 10dc74 <_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 78 8b 12 00 mov 0x128b78,%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 2c 30 00 00 call 10e728 <_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 22 13 00 push $0x132240 11112e: e8 11 24 00 00 call 113544 <_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 25 13 00 mov 0x132558,%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 00 48 11 00 push $0x114800 111172: 6a 00 push $0x0 111174: 83 c2 44 add $0x44,%edx 111177: 52 push %edx 111178: e8 57 33 00 00 call 1144d4 <_Thread_queue_Enqueue_with_handler> _Thread_Enable_dispatch(); 11117d: e8 76 2e 00 00 call 113ff8 <_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 5b 2e 00 00 call 113ff8 <_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 4b 2e 00 00 call 113ff8 <_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 90 85 12 00 mov 0x128590,%eax 10b552: 40 inc %eax 10b553: a3 90 85 12 00 mov %eax,0x128590 * 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 40 8a 12 00 push $0x128a40 10b55d: e8 5a 22 00 00 call 10d7bc <_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 68 85 12 00 mov 0x128568(,%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 fd 42 00 00 call 10f89c <_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 5c 8a 12 00 mov 0x128a5c,%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 4f 31 00 00 call 10e728 <_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 3f 31 00 00 call 10e728 <_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 40 8a 12 00 push $0x128a40 10b609: e8 26 25 00 00 call 10db34 <_Objects_Free> _POSIX_Keys_Free( the_key ); _Thread_Enable_dispatch(); 10b60e: e8 15 31 00 00 call 10e728 <_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 40 8a 12 00 push $0x128a40 10b637: e8 38 26 00 00 call 10dc74 <_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 40 8a 12 00 push $0x128a40 10b651: e8 e2 21 00 00 call 10d838 <_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 40 8a 12 00 push $0x128a40 10b666: e8 c9 24 00 00 call 10db34 <_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 b8 30 00 00 call 10e728 <_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 =============================================================================== 00124588 : int pthread_kill( pthread_t thread, int sig ) { 124588: 55 push %ebp 124589: 89 e5 mov %esp,%ebp 12458b: 57 push %edi 12458c: 56 push %esi 12458d: 53 push %ebx 12458e: 83 ec 1c sub $0x1c,%esp 124591: 8b 5d 0c mov 0xc(%ebp),%ebx POSIX_API_Control *api; Thread_Control *the_thread; Objects_Locations location; if ( !sig ) 124594: 85 db test %ebx,%ebx 124596: 0f 84 84 00 00 00 je 124620 static inline bool is_valid_signo( int signo ) { return ((signo) >= 1 && (signo) <= 32 ); 12459c: 8d 7b ff lea -0x1(%ebx),%edi rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 12459f: 83 ff 1f cmp $0x1f,%edi 1245a2: 77 7c ja 124620 pthread_t id, Objects_Locations *location ) { return (Thread_Control *) _Objects_Get( &_POSIX_Threads_Information, (Objects_Id)id, location ); 1245a4: 56 push %esi rtems_set_errno_and_return_minus_one( EINVAL ); the_thread = _POSIX_Threads_Get( thread, &location ); 1245a5: 8d 45 e4 lea -0x1c(%ebp),%eax 1245a8: 50 push %eax 1245a9: ff 75 08 pushl 0x8(%ebp) 1245ac: 68 a0 e5 12 00 push $0x12e5a0 1245b1: e8 32 d9 fe ff call 111ee8 <_Objects_Get> 1245b6: 89 c6 mov %eax,%esi switch ( location ) { 1245b8: 83 c4 10 add $0x10,%esp 1245bb: 8b 4d e4 mov -0x1c(%ebp),%ecx 1245be: 85 c9 test %ecx,%ecx 1245c0: 75 72 jne 124634 case OBJECTS_LOCAL: /* * If sig == 0 then just validate arguments */ api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 1245c2: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx if ( sig ) { if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) { 1245c8: 8d 04 5b lea (%ebx,%ebx,2),%eax 1245cb: 83 3c 85 28 e9 12 00 cmpl $0x1,0x12e928(,%eax,4) 1245d2: 01 1245d3: 74 2d je 124602 static inline sigset_t signo_to_mask( uint32_t sig ) { return 1u << (sig - 1); 1245d5: b8 01 00 00 00 mov $0x1,%eax 1245da: 89 f9 mov %edi,%ecx 1245dc: d3 e0 shl %cl,%eax return 0; } /* XXX critical section */ api->signals_pending |= signo_to_mask( sig ); 1245de: 09 82 d4 00 00 00 or %eax,0xd4(%edx) (void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL ); 1245e4: 52 push %edx 1245e5: 6a 00 push $0x0 1245e7: 53 push %ebx 1245e8: 56 push %esi 1245e9: e8 7a fe ff ff call 124468 <_POSIX_signals_Unblock_thread> if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 1245ee: 83 c4 10 add $0x10,%esp 1245f1: a1 b4 e8 12 00 mov 0x12e8b4,%eax 1245f6: 85 c0 test %eax,%eax 1245f8: 74 08 je 124602 1245fa: 3b 35 b8 e8 12 00 cmp 0x12e8b8,%esi 124600: 74 12 je 124614 _Thread_Dispatch_necessary = true; } _Thread_Enable_dispatch(); 124602: e8 15 e4 fe ff call 112a1c <_Thread_Enable_dispatch> return 0; 124607: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( ESRCH ); } 124609: 8d 65 f4 lea -0xc(%ebp),%esp 12460c: 5b pop %ebx 12460d: 5e pop %esi 12460e: 5f pop %edi 12460f: c9 leave 124610: c3 ret 124611: 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; 124614: c6 05 c4 e8 12 00 01 movb $0x1,0x12e8c4 12461b: eb e5 jmp 124602 12461d: 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 ); 124620: e8 c7 3e ff ff call 1184ec <__errno> 124625: c7 00 16 00 00 00 movl $0x16,(%eax) 12462b: b8 ff ff ff ff mov $0xffffffff,%eax 124630: eb d7 jmp 124609 124632: 66 90 xchg %ax,%ax #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( ESRCH ); 124634: e8 b3 3e ff ff call 1184ec <__errno> 124639: c7 00 03 00 00 00 movl $0x3,(%eax) 12463f: b8 ff ff ff ff mov $0xffffffff,%eax 124644: eb c3 jmp 124609 =============================================================================== 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 5c 72 12 00 movzbl 0x12725c,%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 d3 35 00 00 call 1107b4 <_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 90 b5 12 00 mov 0x12b590,%eax 10d26e: 40 inc %eax 10d26f: a3 90 b5 12 00 mov %eax,0x12b590 * _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 a0 b9 12 00 push $0x12b9a0 10d27c: e8 c7 25 00 00 call 10f848 <_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 5c 72 12 00 movzbl 0x12725c,%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 0d 1d 00 00 call 10efd4 <_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 bc b9 12 00 mov 0x12b9bc,%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 d0 34 00 00 call 1107b4 <_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 20 ba 12 00 mov $0x12ba20,%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 87 34 00 00 call 1107b4 <_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 f4 0b 00 00 call 10c9cc 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 db 0b 00 00 call 10c9cc 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 b1 12 00 push $0x12b180 10c49a: e8 e1 2b 00 00 call 10f080 <_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 81 3e 00 00 call 110338 <_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 71 36 00 00 call 10fb34 <_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 b1 12 00 push $0x12b180 10c4e5: e8 5a 27 00 00 call 10ec44 <_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 b1 12 00 push $0x12b180 10c4f2: e8 49 2a 00 00 call 10ef40 <_Objects_Free> _POSIX_RWLock_Free( the_rwlock ); _Thread_Enable_dispatch(); 10c4f7: e8 38 36 00 00 call 10fb34 <_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 f0 ae 12 00 mov 0x12aef0,%eax 10c544: 40 inc %eax 10c545: a3 f0 ae 12 00 mov %eax,0x12aef0 * 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 b1 12 00 push $0x12b180 10c552: e8 71 26 00 00 call 10ebc8 <_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 3f 1e 00 00 call 10e3b0 <_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 b1 12 00 mov 0x12b19c,%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 a3 35 00 00 call 10fb34 <_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 8f 35 00 00 call 10fb34 <_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 ae 62 00 00 call 1128f4 <_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 b1 12 00 push $0x12b180 10c656: e8 25 2a 00 00 call 10f080 <_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 5f 1d 00 00 call 10e3e4 <_CORE_RWLock_Obtain_for_reading> do_wait, ticks, NULL ); _Thread_Enable_dispatch(); 10c685: 83 c4 20 add $0x20,%esp 10c688: e8 a7 34 00 00 call 10fb34 <_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 b4 12 00 mov 0x12b4d8,%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 b4 12 00 mov 0x12b4d8,%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 f6 61 00 00 call 1128f4 <_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 b1 12 00 push $0x12b180 10c70e: e8 6d 29 00 00 call 10f080 <_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 6f 1d 00 00 call 10e4ac <_CORE_RWLock_Obtain_for_writing> do_wait, ticks, NULL ); _Thread_Enable_dispatch(); 10c73d: 83 c4 20 add $0x20,%esp 10c740: e8 ef 33 00 00 call 10fb34 <_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 b4 12 00 mov 0x12b4d8,%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 b4 12 00 mov 0x12b4d8,%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 8e 12 00 mov 0x128e54,%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 8e 12 00 mov 0x128e58,%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 70 88 12 00 mov 0x128870,%ebx 10b25e: 43 inc %ebx 10b25f: 89 1d 70 88 12 00 mov %ebx,0x128870 _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 8e 12 00 pushl 0x128e58 10b27c: e8 5b 54 00 00 call 1106dc <_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 8e 12 00 mov 0x128e54,%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 8e 12 00 mov 0x128e58,%ecx 10b2ca: 8b 89 ec 00 00 00 mov 0xec(%ecx),%ecx 10b2d0: 8b 1d 70 88 12 00 mov 0x128870,%ebx 10b2d6: 43 inc %ebx 10b2d7: 89 1d 70 88 12 00 mov %ebx,0x128870 _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 8e 12 00 pushl 0x128e58 10b2f4: e8 e3 53 00 00 call 1106dc <_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 f7 5b 00 00 call 113930 <_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 60 b8 12 00 push $0x12b860 10dd59: e8 a2 1f 00 00 call 10fd00 <_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 60 b5 12 00 mov 0x12b560,%eax 10ddc0: 89 42 78 mov %eax,0x78(%edx) 10ddc3: 0f b6 05 5c 72 12 00 movzbl 0x12725c,%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 20 25 00 00 call 110300 <_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 cc 29 00 00 call 1107b4 <_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 10 3a 00 00 call 11184c <_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 eb 39 00 00 call 11184c <_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 =============================================================================== 00111cf4 : int pthread_sigmask( int how, const sigset_t *set, sigset_t *oset ) { 111cf4: 55 push %ebp 111cf5: 89 e5 mov %esp,%ebp 111cf7: 56 push %esi 111cf8: 53 push %ebx 111cf9: 8b 4d 08 mov 0x8(%ebp),%ecx 111cfc: 8b 55 0c mov 0xc(%ebp),%edx 111cff: 8b 5d 10 mov 0x10(%ebp),%ebx POSIX_API_Control *api; if ( !set && !oset ) 111d02: 85 d2 test %edx,%edx 111d04: 0f 84 8a 00 00 00 je 111d94 rtems_set_errno_and_return_minus_one( EINVAL ); api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 111d0a: a1 78 8b 12 00 mov 0x128b78,%eax 111d0f: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax if ( oset ) 111d15: 85 db test %ebx,%ebx 111d17: 74 0c je 111d25 *oset = api->signals_blocked; 111d19: 8b b0 d0 00 00 00 mov 0xd0(%eax),%esi 111d1f: 89 33 mov %esi,(%ebx) if ( !set ) 111d21: 85 d2 test %edx,%edx 111d23: 74 3b je 111d60 return 0; switch ( how ) { 111d25: 83 f9 01 cmp $0x1,%ecx 111d28: 74 5e je 111d88 111d2a: 83 f9 02 cmp $0x2,%ecx 111d2d: 74 39 je 111d68 111d2f: 85 c9 test %ecx,%ecx 111d31: 75 41 jne 111d74 break; case SIG_UNBLOCK: api->signals_blocked &= ~*set; break; case SIG_SETMASK: api->signals_blocked = *set; 111d33: 8b 12 mov (%edx),%edx 111d35: 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) ) { 111d3b: 8b 15 e8 8d 12 00 mov 0x128de8,%edx 111d41: 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 & 111d47: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax 111d4d: f7 d0 not %eax 111d4f: 85 c2 test %eax,%edx 111d51: 74 0d je 111d60 (api->signals_pending | _POSIX_signals_Pending) ) { _Thread_Dispatch(); 111d53: e8 1c c9 ff ff call 10e674 <_Thread_Dispatch> } return 0; 111d58: 31 c0 xor %eax,%eax } 111d5a: 5b pop %ebx 111d5b: 5e pop %esi 111d5c: c9 leave 111d5d: c3 ret 111d5e: 66 90 xchg %ax,%ax if ( ~api->signals_blocked & (api->signals_pending | _POSIX_signals_Pending) ) { _Thread_Dispatch(); } return 0; 111d60: 31 c0 xor %eax,%eax } 111d62: 5b pop %ebx 111d63: 5e pop %esi 111d64: c9 leave 111d65: c3 ret 111d66: 66 90 xchg %ax,%ax switch ( how ) { case SIG_BLOCK: api->signals_blocked |= *set; break; case SIG_UNBLOCK: api->signals_blocked &= ~*set; 111d68: 8b 12 mov (%edx),%edx 111d6a: f7 d2 not %edx 111d6c: 21 90 d0 00 00 00 and %edx,0xd0(%eax) break; 111d72: eb c7 jmp 111d3b case SIG_SETMASK: api->signals_blocked = *set; break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 111d74: e8 a7 25 00 00 call 114320 <__errno> 111d79: c7 00 16 00 00 00 movl $0x16,(%eax) 111d7f: b8 ff ff ff ff mov $0xffffffff,%eax (api->signals_pending | _POSIX_signals_Pending) ) { _Thread_Dispatch(); } return 0; } 111d84: 5b pop %ebx 111d85: 5e pop %esi 111d86: c9 leave 111d87: c3 ret if ( !set ) return 0; switch ( how ) { case SIG_BLOCK: api->signals_blocked |= *set; 111d88: 8b 12 mov (%edx),%edx 111d8a: 09 90 d0 00 00 00 or %edx,0xd0(%eax) break; 111d90: eb a9 jmp 111d3b 111d92: 66 90 xchg %ax,%ax sigset_t *oset ) { POSIX_API_Control *api; if ( !set && !oset ) 111d94: 85 db test %ebx,%ebx 111d96: 74 dc je 111d74 rtems_set_errno_and_return_minus_one( EINVAL ); api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 111d98: a1 78 8b 12 00 mov 0x128b78,%eax 111d9d: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax 111da3: e9 71 ff ff ff jmp 111d19 =============================================================================== 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 f4 95 12 00 mov 0x1295f4,%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 f8 95 12 00 mov 0x1295f8,%eax 10bb99: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax 10bb9f: 8b 15 10 90 12 00 mov 0x129010,%edx 10bba5: 42 inc %edx 10bba6: 89 15 10 90 12 00 mov %edx,0x129010 _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 c3 28 00 00 call 10e488 <_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 f8 95 12 00 pushl 0x1295f8 10bbd0: e8 53 5b 00 00 call 111728 <_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 a6 28 00 00 jmp 10e488 <_Thread_Enable_dispatch> =============================================================================== 0011ea00 : ssize_t read( int fd, void *buffer, size_t count ) { 11ea00: 55 push %ebp 11ea01: 89 e5 mov %esp,%ebp 11ea03: 53 push %ebx 11ea04: 83 ec 04 sub $0x4,%esp 11ea07: 8b 4d 08 mov 0x8(%ebp),%ecx 11ea0a: 8b 45 0c mov 0xc(%ebp),%eax 11ea0d: 8b 55 10 mov 0x10(%ebp),%edx ssize_t rc; rtems_libio_t *iop; rtems_libio_check_fd( fd ); 11ea10: 3b 0d ac 31 12 00 cmp 0x1231ac,%ecx 11ea16: 73 50 jae 11ea68 <== NEVER TAKEN iop = rtems_libio_iop( fd ); 11ea18: c1 e1 03 shl $0x3,%ecx 11ea1b: 8d 1c cd 00 00 00 00 lea 0x0(,%ecx,8),%ebx 11ea22: 29 cb sub %ecx,%ebx 11ea24: 03 1d 00 74 12 00 add 0x127400,%ebx rtems_libio_check_is_open( iop ); 11ea2a: 8b 4b 14 mov 0x14(%ebx),%ecx 11ea2d: f6 c5 01 test $0x1,%ch 11ea30: 74 36 je 11ea68 rtems_libio_check_buffer( buffer ); 11ea32: 85 c0 test %eax,%eax 11ea34: 74 46 je 11ea7c <== NEVER TAKEN rtems_libio_check_count( count ); 11ea36: 85 d2 test %edx,%edx 11ea38: 74 26 je 11ea60 rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ ); 11ea3a: 83 e1 02 and $0x2,%ecx 11ea3d: 74 3d je 11ea7c /* * Now process the read(). */ rc = (*iop->pathinfo.handlers->read_h)( iop, buffer, count ); 11ea3f: 51 push %ecx 11ea40: 8b 4b 20 mov 0x20(%ebx),%ecx 11ea43: 52 push %edx 11ea44: 50 push %eax 11ea45: 53 push %ebx 11ea46: ff 51 08 call *0x8(%ecx) if ( rc > 0 ) 11ea49: 83 c4 10 add $0x10,%esp 11ea4c: 85 c0 test %eax,%eax 11ea4e: 7e 0b jle 11ea5b iop->offset += rc; 11ea50: 89 c1 mov %eax,%ecx 11ea52: c1 f9 1f sar $0x1f,%ecx 11ea55: 01 43 0c add %eax,0xc(%ebx) 11ea58: 11 4b 10 adc %ecx,0x10(%ebx) return rc; } 11ea5b: 8b 5d fc mov -0x4(%ebp),%ebx 11ea5e: c9 leave 11ea5f: 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 ); 11ea60: 31 c0 xor %eax,%eax if ( rc > 0 ) iop->offset += rc; return rc; } 11ea62: 8b 5d fc mov -0x4(%ebp),%ebx 11ea65: c9 leave 11ea66: c3 ret 11ea67: 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 ); 11ea68: e8 a7 48 ff ff call 113314 <__errno> 11ea6d: c7 00 09 00 00 00 movl $0x9,(%eax) 11ea73: b8 ff ff ff ff mov $0xffffffff,%eax 11ea78: eb e1 jmp 11ea5b 11ea7a: 66 90 xchg %ax,%ax rtems_libio_check_buffer( buffer ); rtems_libio_check_count( count ); rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ ); 11ea7c: e8 93 48 ff ff call 113314 <__errno> 11ea81: c7 00 16 00 00 00 movl $0x16,(%eax) 11ea87: b8 ff ff ff ff mov $0xffffffff,%eax 11ea8c: eb cd jmp 11ea5b =============================================================================== 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 53 ad 00 00 call 115e40 <__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 32 ad 00 00 call 115e40 <__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 cc 47 12 00 cmp 0x1247cc,%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 20 8a 12 00 add 0x128a20,%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 9b a2 00 00 call 1140a4 <__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 69 a2 00 00 call 1140a4 <__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 =============================================================================== 0011eb1c : void *realloc( void *ptr, size_t size ) { 11eb1c: 55 push %ebp 11eb1d: 89 e5 mov %esp,%ebp 11eb1f: 57 push %edi 11eb20: 56 push %esi 11eb21: 53 push %ebx 11eb22: 83 ec 2c sub $0x2c,%esp 11eb25: 8b 5d 08 mov 0x8(%ebp),%ebx 11eb28: 8b 75 0c mov 0xc(%ebp),%esi uintptr_t old_size; char *new_area; MSBUMP(realloc_calls, 1); 11eb2b: ff 05 30 74 12 00 incl 0x127430 /* * Do not attempt to allocate memory if in a critical section or ISR. */ if (_System_state_Is_up(_System_state_Get())) { 11eb31: 83 3d 40 77 12 00 03 cmpl $0x3,0x127740 11eb38: 74 72 je 11ebac <== ALWAYS TAKEN } /* * Continue with realloc(). */ if ( !ptr ) 11eb3a: 85 db test %ebx,%ebx 11eb3c: 74 5e je 11eb9c return malloc( size ); if ( !size ) { 11eb3e: 85 f6 test %esi,%esi 11eb40: 74 3a je 11eb7c <== NEVER TAKEN free( ptr ); return (void *) 0; } if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) { 11eb42: 52 push %edx 11eb43: 8d 45 e4 lea -0x1c(%ebp),%eax 11eb46: 50 push %eax 11eb47: 53 push %ebx 11eb48: ff 35 b8 31 12 00 pushl 0x1231b8 11eb4e: e8 49 01 00 00 call 11ec9c <_Protected_heap_Get_block_size> 11eb53: 83 c4 10 add $0x10,%esp 11eb56: 84 c0 test %al,%al 11eb58: 74 32 je 11eb8c } /* * Now resize it. */ if ( _Protected_heap_Resize_block( RTEMS_Malloc_Heap, ptr, size ) ) { 11eb5a: 50 push %eax 11eb5b: 56 push %esi 11eb5c: 53 push %ebx 11eb5d: ff 35 b8 31 12 00 pushl 0x1231b8 11eb63: e8 6c 01 00 00 call 11ecd4 <_Protected_heap_Resize_block> 11eb68: 83 c4 10 add $0x10,%esp 11eb6b: 84 c0 test %al,%al 11eb6d: 74 5d je 11ebcc memcpy( new_area, ptr, (size < old_size) ? size : old_size ); free( ptr ); return new_area; } 11eb6f: 89 d8 mov %ebx,%eax 11eb71: 8d 65 f4 lea -0xc(%ebp),%esp 11eb74: 5b pop %ebx 11eb75: 5e pop %esi 11eb76: 5f pop %edi 11eb77: c9 leave 11eb78: c3 ret 11eb79: 8d 76 00 lea 0x0(%esi),%esi */ if ( !ptr ) return malloc( size ); if ( !size ) { free( ptr ); 11eb7c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11eb7f: 53 push %ebx <== NOT EXECUTED 11eb80: e8 2f 95 fe ff call 1080b4 <== NOT EXECUTED return (void *) 0; 11eb85: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11eb88: 31 db xor %ebx,%ebx <== NOT EXECUTED 11eb8a: eb e3 jmp 11eb6f <== NOT EXECUTED } if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) { errno = EINVAL; 11eb8c: e8 83 47 ff ff call 113314 <__errno> 11eb91: c7 00 16 00 00 00 movl $0x16,(%eax) return (void *) 0; 11eb97: 31 db xor %ebx,%ebx 11eb99: eb d4 jmp 11eb6f 11eb9b: 90 nop /* * Continue with realloc(). */ if ( !ptr ) return malloc( size ); 11eb9c: 83 ec 0c sub $0xc,%esp 11eb9f: 56 push %esi 11eba0: e8 e3 97 fe ff call 108388 11eba5: 89 c3 mov %eax,%ebx 11eba7: 83 c4 10 add $0x10,%esp 11ebaa: eb c3 jmp 11eb6f /* * 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) 11ebac: a1 70 75 12 00 mov 0x127570,%eax 11ebb1: 85 c0 test %eax,%eax 11ebb3: 74 04 je 11ebb9 <== ALWAYS TAKEN new_area = malloc( size ); MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */ if ( !new_area ) { return (void *) 0; 11ebb5: 31 db xor %ebx,%ebx 11ebb7: eb b6 jmp 11eb6f if (_System_state_Is_up(_System_state_Get())) { if (_Thread_Dispatch_disable_level > 0) return (void *) 0; if (_ISR_Nest_level > 0) 11ebb9: 8b 0d 54 7b 12 00 mov 0x127b54,%ecx 11ebbf: 85 c9 test %ecx,%ecx 11ebc1: 0f 84 73 ff ff ff je 11eb3a <== ALWAYS TAKEN new_area = malloc( size ); MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */ if ( !new_area ) { return (void *) 0; 11ebc7: 31 db xor %ebx,%ebx 11ebc9: eb a4 jmp 11eb6f <== NOT EXECUTED 11ebcb: 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 ); 11ebcc: 83 ec 0c sub $0xc,%esp 11ebcf: 56 push %esi 11ebd0: e8 b3 97 fe ff call 108388 MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */ 11ebd5: ff 0d 24 74 12 00 decl 0x127424 if ( !new_area ) { 11ebdb: 83 c4 10 add $0x10,%esp 11ebde: 85 c0 test %eax,%eax 11ebe0: 74 d3 je 11ebb5 return (void *) 0; } memcpy( new_area, ptr, (size < old_size) ? size : old_size ); 11ebe2: 8b 55 e4 mov -0x1c(%ebp),%edx 11ebe5: 89 f1 mov %esi,%ecx 11ebe7: 39 d6 cmp %edx,%esi 11ebe9: 76 02 jbe 11ebed <== NEVER TAKEN 11ebeb: 89 d1 mov %edx,%ecx 11ebed: 89 c7 mov %eax,%edi 11ebef: 89 de mov %ebx,%esi 11ebf1: f3 a4 rep movsb %ds:(%esi),%es:(%edi) free( ptr ); 11ebf3: 83 ec 0c sub $0xc,%esp 11ebf6: 53 push %ebx 11ebf7: 89 45 d4 mov %eax,-0x2c(%ebp) 11ebfa: e8 b5 94 fe ff call 1080b4 return new_area; 11ebff: 83 c4 10 add $0x10,%esp 11ec02: 8b 45 d4 mov -0x2c(%ebp),%eax 11ec05: 89 c3 mov %eax,%ebx 11ec07: e9 63 ff ff ff jmp 11eb6f =============================================================================== 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 8f a7 00 00 call 113bac <__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 =============================================================================== 0010c50c : * errno - otherwise */ int rtems_aio_enqueue (rtems_aio_request *req) { 10c50c: 55 push %ebp 10c50d: 89 e5 mov %esp,%ebp 10c50f: 57 push %edi 10c510: 56 push %esi 10c511: 53 push %ebx 10c512: 83 ec 58 sub $0x58,%esp 10c515: 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); 10c518: 68 80 a1 12 00 push $0x12a180 10c51d: e8 7e 09 00 00 call 10cea0 10c522: 89 c6 mov %eax,%esi if (result != 0) { 10c524: 83 c4 10 add $0x10,%esp 10c527: 85 c0 test %eax,%eax 10c529: 0f 85 c1 00 00 00 jne 10c5f0 <== 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); 10c52f: e8 1c 12 00 00 call 10d750 10c534: 51 push %ecx 10c535: 8d 55 c4 lea -0x3c(%ebp),%edx 10c538: 52 push %edx 10c539: 8d 55 e0 lea -0x20(%ebp),%edx 10c53c: 52 push %edx 10c53d: 50 push %eax 10c53e: e8 d9 0d 00 00 call 10d31c req->caller_thread = pthread_self (); 10c543: e8 08 12 00 00 call 10d750 10c548: 89 43 10 mov %eax,0x10(%ebx) req->priority = param.sched_priority - req->aiocbp->aio_reqprio; 10c54b: 8b 43 14 mov 0x14(%ebx),%eax 10c54e: 8b 55 c4 mov -0x3c(%ebp),%edx 10c551: 2b 50 14 sub 0x14(%eax),%edx 10c554: 89 53 0c mov %edx,0xc(%ebx) req->policy = policy; 10c557: 8b 55 e0 mov -0x20(%ebp),%edx 10c55a: 89 53 08 mov %edx,0x8(%ebx) req->aiocbp->error_code = EINPROGRESS; 10c55d: c7 40 30 77 00 00 00 movl $0x77,0x30(%eax) req->aiocbp->return_value = 0; 10c564: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax) if ((aio_request_queue.idle_threads == 0) && 10c56b: 83 c4 10 add $0x10,%esp 10c56e: 8b 15 e8 a1 12 00 mov 0x12a1e8,%edx 10c574: 85 d2 test %edx,%edx 10c576: 75 0d jne 10c585 10c578: 83 3d e4 a1 12 00 04 cmpl $0x4,0x12a1e4 10c57f: 0f 8e 83 00 00 00 jle 10c608 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, 10c585: 51 push %ecx 10c586: 6a 00 push $0x0 10c588: ff 30 pushl (%eax) 10c58a: 68 c8 a1 12 00 push $0x12a1c8 10c58f: e8 44 fb ff ff call 10c0d8 10c594: 89 c7 mov %eax,%edi req->aiocbp->aio_fildes, 0); if (r_chain != NULL) 10c596: 83 c4 10 add $0x10,%esp 10c599: 85 c0 test %eax,%eax 10c59b: 0f 84 df 00 00 00 je 10c680 { pthread_mutex_lock (&r_chain->mutex); 10c5a1: 8d 57 1c lea 0x1c(%edi),%edx 10c5a4: 83 ec 0c sub $0xc,%esp 10c5a7: 52 push %edx 10c5a8: 89 55 b4 mov %edx,-0x4c(%ebp) 10c5ab: e8 f0 08 00 00 call 10cea0 rtems_aio_insert_prio (&r_chain->perfd, req); 10c5b0: 58 pop %eax 10c5b1: 5a pop %edx 10c5b2: 53 push %ebx 10c5b3: 8d 47 08 lea 0x8(%edi),%eax 10c5b6: 50 push %eax 10c5b7: e8 48 fe ff ff call 10c404 pthread_cond_signal (&r_chain->cond); 10c5bc: 83 c7 20 add $0x20,%edi 10c5bf: 89 3c 24 mov %edi,(%esp) 10c5c2: e8 a9 04 00 00 call 10ca70 pthread_mutex_unlock (&r_chain->mutex); 10c5c7: 8b 55 b4 mov -0x4c(%ebp),%edx 10c5ca: 89 14 24 mov %edx,(%esp) 10c5cd: e8 56 09 00 00 call 10cf28 10c5d2: 83 c4 10 add $0x10,%esp /* just insert the request in the existing fd chain */ rtems_aio_insert_prio (&r_chain->perfd, req); } } pthread_mutex_unlock (&aio_request_queue.mutex); 10c5d5: 83 ec 0c sub $0xc,%esp 10c5d8: 68 80 a1 12 00 push $0x12a180 10c5dd: e8 46 09 00 00 call 10cf28 return 0; 10c5e2: 83 c4 10 add $0x10,%esp } 10c5e5: 89 f0 mov %esi,%eax 10c5e7: 8d 65 f4 lea -0xc(%ebp),%esp 10c5ea: 5b pop %ebx 10c5eb: 5e pop %esi 10c5ec: 5f pop %edi 10c5ed: c9 leave 10c5ee: c3 ret 10c5ef: 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); 10c5f0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c5f3: 53 push %ebx <== NOT EXECUTED 10c5f4: e8 3b c5 ff ff call 108b34 <== NOT EXECUTED return result; 10c5f9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } pthread_mutex_unlock (&aio_request_queue.mutex); return 0; } 10c5fc: 89 f0 mov %esi,%eax <== NOT EXECUTED 10c5fe: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c601: 5b pop %ebx <== NOT EXECUTED 10c602: 5e pop %esi <== NOT EXECUTED 10c603: 5f pop %edi <== NOT EXECUTED 10c604: c9 leave <== NOT EXECUTED 10c605: c3 ret <== NOT EXECUTED 10c606: 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); 10c608: 57 push %edi 10c609: 6a 01 push $0x1 10c60b: ff 30 pushl (%eax) 10c60d: 68 c8 a1 12 00 push $0x12a1c8 10c612: e8 c1 fa ff ff call 10c0d8 10c617: 89 c7 mov %eax,%edi if (r_chain->new_fd == 1) { 10c619: 83 c4 10 add $0x10,%esp 10c61c: 83 78 18 01 cmpl $0x1,0x18(%eax) 10c620: 0f 85 7b ff ff ff jne 10c5a1 RTEMS_INLINE_ROUTINE void _Chain_Prepend( Chain_Control *the_chain, Chain_Node *the_node ) { _Chain_Insert(_Chain_Head(the_chain), the_node); 10c626: 83 ec 08 sub $0x8,%esp 10c629: 53 push %ebx 10c62a: 8d 40 08 lea 0x8(%eax),%eax 10c62d: 50 push %eax 10c62e: e8 7d 22 00 00 call 10e8b0 <_Chain_Insert> rtems_chain_prepend (&r_chain->perfd, &req->next_prio); r_chain->new_fd = 0; 10c633: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi) pthread_mutex_init (&r_chain->mutex, NULL); 10c63a: 5a pop %edx 10c63b: 59 pop %ecx 10c63c: 6a 00 push $0x0 10c63e: 8d 47 1c lea 0x1c(%edi),%eax 10c641: 50 push %eax 10c642: e8 0d 07 00 00 call 10cd54 pthread_cond_init (&r_chain->cond, NULL); 10c647: 5b pop %ebx 10c648: 58 pop %eax 10c649: 6a 00 push $0x0 10c64b: 8d 47 20 lea 0x20(%edi),%eax 10c64e: 50 push %eax 10c64f: e8 68 03 00 00 call 10c9bc AIO_printf ("New thread \n"); result = pthread_create (&thid, &aio_request_queue.attr, 10c654: 57 push %edi 10c655: 68 98 c1 10 00 push $0x10c198 10c65a: 68 88 a1 12 00 push $0x12a188 10c65f: 8d 45 e4 lea -0x1c(%ebp),%eax 10c662: 50 push %eax 10c663: e8 2c 0a 00 00 call 10d094 10c668: 89 c3 mov %eax,%ebx rtems_aio_handle, (void *) r_chain); if (result != 0) { 10c66a: 83 c4 20 add $0x20,%esp 10c66d: 85 c0 test %eax,%eax 10c66f: 0f 85 87 00 00 00 jne 10c6fc <== NEVER TAKEN pthread_mutex_unlock (&aio_request_queue.mutex); return result; } ++aio_request_queue.active_threads; 10c675: ff 05 e4 a1 12 00 incl 0x12a1e4 10c67b: e9 55 ff ff ff jmp 10c5d5 } else { /* or to the idle chain */ chain = &aio_request_queue.idle_req; r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1); 10c680: 51 push %ecx 10c681: 6a 01 push $0x1 10c683: 8b 43 14 mov 0x14(%ebx),%eax 10c686: ff 30 pushl (%eax) 10c688: 68 d4 a1 12 00 push $0x12a1d4 10c68d: e8 46 fa ff ff call 10c0d8 10c692: 89 c7 mov %eax,%edi if (r_chain->new_fd == 1) { 10c694: 83 c4 10 add $0x10,%esp 10c697: 83 78 18 01 cmpl $0x1,0x18(%eax) 10c69b: 74 17 je 10c6b4 pthread_cond_init (&r_chain->cond, NULL); pthread_cond_signal (&aio_request_queue.new_req); ++aio_request_queue.idle_threads; } else /* just insert the request in the existing fd chain */ rtems_aio_insert_prio (&r_chain->perfd, req); 10c69d: 83 ec 08 sub $0x8,%esp 10c6a0: 53 push %ebx 10c6a1: 83 c7 08 add $0x8,%edi 10c6a4: 57 push %edi 10c6a5: e8 5a fd ff ff call 10c404 10c6aa: 83 c4 10 add $0x10,%esp 10c6ad: e9 23 ff ff ff jmp 10c5d5 10c6b2: 66 90 xchg %ax,%ax 10c6b4: 83 ec 08 sub $0x8,%esp 10c6b7: 53 push %ebx 10c6b8: 8d 40 08 lea 0x8(%eax),%eax 10c6bb: 50 push %eax 10c6bc: e8 ef 21 00 00 call 10e8b0 <_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; 10c6c1: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi) pthread_mutex_init (&r_chain->mutex, NULL); 10c6c8: 58 pop %eax 10c6c9: 5a pop %edx 10c6ca: 6a 00 push $0x0 10c6cc: 8d 47 1c lea 0x1c(%edi),%eax 10c6cf: 50 push %eax 10c6d0: e8 7f 06 00 00 call 10cd54 pthread_cond_init (&r_chain->cond, NULL); 10c6d5: 59 pop %ecx 10c6d6: 5b pop %ebx 10c6d7: 6a 00 push $0x0 10c6d9: 83 c7 20 add $0x20,%edi 10c6dc: 57 push %edi 10c6dd: e8 da 02 00 00 call 10c9bc pthread_cond_signal (&aio_request_queue.new_req); 10c6e2: c7 04 24 84 a1 12 00 movl $0x12a184,(%esp) 10c6e9: e8 82 03 00 00 call 10ca70 ++aio_request_queue.idle_threads; 10c6ee: ff 05 e8 a1 12 00 incl 0x12a1e8 10c6f4: 83 c4 10 add $0x10,%esp 10c6f7: e9 d9 fe ff ff jmp 10c5d5 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); 10c6fc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c6ff: 68 80 a1 12 00 push $0x12a180 <== NOT EXECUTED 10c704: e8 1f 08 00 00 call 10cf28 <== NOT EXECUTED return result; 10c709: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c70c: 89 de mov %ebx,%esi <== NOT EXECUTED 10c70e: e9 d2 fe ff ff jmp 10c5e5 <== NOT EXECUTED =============================================================================== 0010c198 : * NULL - if error */ static void * rtems_aio_handle (void *arg) { 10c198: 55 push %ebp <== NOT EXECUTED 10c199: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c19b: 57 push %edi <== NOT EXECUTED 10c19c: 56 push %esi <== NOT EXECUTED 10c19d: 53 push %ebx <== NOT EXECUTED 10c19e: 83 ec 4c sub $0x4c,%esp <== NOT EXECUTED rtems_aio_request_chain *r_chain = arg; 10c1a1: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10c1a4: 8d 43 1c lea 0x1c(%ebx),%eax <== NOT EXECUTED 10c1a7: 89 45 b4 mov %eax,-0x4c(%ebp) <== NOT EXECUTED 10c1aa: 66 90 xchg %ax,%ax <== NOT EXECUTED /* 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); 10c1ac: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c1af: ff 75 b4 pushl -0x4c(%ebp) <== NOT EXECUTED 10c1b2: e8 e9 0c 00 00 call 10cea0 <== NOT EXECUTED if (result != 0) 10c1b7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c1ba: 85 c0 test %eax,%eax <== NOT EXECUTED 10c1bc: 0f 85 92 01 00 00 jne 10c354 <== NOT EXECUTED } AIO_printf ("Thread finished\n"); return NULL; } 10c1c2: 8b 73 08 mov 0x8(%ebx),%esi <== NOT EXECUTED RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 10c1c5: 8d 43 0c lea 0xc(%ebx),%eax <== NOT EXECUTED /* 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)) { 10c1c8: 39 c6 cmp %eax,%esi <== NOT EXECUTED 10c1ca: 0f 84 d0 00 00 00 je 10c2a0 <== NOT EXECUTED 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); 10c1d0: e8 7b 15 00 00 call 10d750 <== NOT EXECUTED 10c1d5: 52 push %edx <== NOT EXECUTED 10c1d6: 8d 55 c0 lea -0x40(%ebp),%edx <== NOT EXECUTED 10c1d9: 52 push %edx <== NOT EXECUTED 10c1da: 8d 55 e4 lea -0x1c(%ebp),%edx <== NOT EXECUTED 10c1dd: 52 push %edx <== NOT EXECUTED 10c1de: 50 push %eax <== NOT EXECUTED 10c1df: e8 38 11 00 00 call 10d31c <== NOT EXECUTED param.sched_priority = req->priority; 10c1e4: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED 10c1e7: 89 45 c0 mov %eax,-0x40(%ebp) <== NOT EXECUTED pthread_setschedparam (pthread_self(), req->policy, ¶m); 10c1ea: 8b 7e 08 mov 0x8(%esi),%edi <== NOT EXECUTED 10c1ed: e8 5e 15 00 00 call 10d750 <== NOT EXECUTED 10c1f2: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10c1f5: 8d 55 c0 lea -0x40(%ebp),%edx <== NOT EXECUTED 10c1f8: 52 push %edx <== NOT EXECUTED 10c1f9: 57 push %edi <== NOT EXECUTED 10c1fa: 50 push %eax <== NOT EXECUTED 10c1fb: e8 60 15 00 00 call 10d760 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE void rtems_chain_extract( rtems_chain_node *the_node ) { _Chain_Extract( the_node ); 10c200: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10c203: e8 6c 26 00 00 call 10e874 <_Chain_Extract> <== NOT EXECUTED rtems_chain_extract (node); pthread_mutex_unlock (&r_chain->mutex); 10c208: 5f pop %edi <== NOT EXECUTED 10c209: ff 75 b4 pushl -0x4c(%ebp) <== NOT EXECUTED 10c20c: e8 17 0d 00 00 call 10cf28 <== NOT EXECUTED switch (req->aiocbp->aio_lio_opcode) { 10c211: 8b 7e 14 mov 0x14(%esi),%edi <== NOT EXECUTED 10c214: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c217: 8b 47 2c mov 0x2c(%edi),%eax <== NOT EXECUTED 10c21a: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10c21d: 74 21 je 10c240 <== NOT EXECUTED 10c21f: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10c222: 74 6c je 10c290 <== NOT EXECUTED 10c224: 48 dec %eax <== NOT EXECUTED 10c225: 74 4d je 10c274 <== NOT EXECUTED default: result = -1; } if (result == -1) { req->aiocbp->return_value = -1; 10c227: c7 47 34 ff ff ff ff movl $0xffffffff,0x34(%edi) <== NOT EXECUTED req->aiocbp->error_code = errno; 10c22e: e8 c9 99 00 00 call 115bfc <__errno> <== NOT EXECUTED 10c233: 8b 00 mov (%eax),%eax <== NOT EXECUTED 10c235: 89 47 30 mov %eax,0x30(%edi) <== NOT EXECUTED 10c238: e9 6f ff ff ff jmp 10c1ac <== NOT EXECUTED 10c23d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED (void *) req->aiocbp->aio_buf, req->aiocbp->aio_nbytes, req->aiocbp->aio_offset); break; case LIO_WRITE: result = pwrite (req->aiocbp->aio_fildes, 10c240: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c243: ff 77 08 pushl 0x8(%edi) <== NOT EXECUTED 10c246: ff 77 04 pushl 0x4(%edi) <== NOT EXECUTED 10c249: ff 77 10 pushl 0x10(%edi) <== NOT EXECUTED 10c24c: ff 77 0c pushl 0xc(%edi) <== NOT EXECUTED 10c24f: ff 37 pushl (%edi) <== NOT EXECUTED 10c251: e8 3e a4 00 00 call 116694 <== NOT EXECUTED (void *) req->aiocbp->aio_buf, req->aiocbp->aio_nbytes, req->aiocbp->aio_offset); break; 10c256: 83 c4 20 add $0x20,%esp <== NOT EXECUTED break; default: result = -1; } if (result == -1) { 10c259: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 10c25c: 0f 84 9a 01 00 00 je 10c3fc <== NOT EXECUTED req->aiocbp->return_value = -1; req->aiocbp->error_code = errno; } else { req->aiocbp->return_value = result; 10c262: 8b 56 14 mov 0x14(%esi),%edx <== NOT EXECUTED 10c265: 89 42 34 mov %eax,0x34(%edx) <== NOT EXECUTED req->aiocbp->error_code = 0; 10c268: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx) <== NOT EXECUTED 10c26f: e9 38 ff ff ff jmp 10c1ac <== NOT EXECUTED pthread_mutex_unlock (&r_chain->mutex); switch (req->aiocbp->aio_lio_opcode) { case LIO_READ: result = pread (req->aiocbp->aio_fildes, 10c274: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c277: ff 77 08 pushl 0x8(%edi) <== NOT EXECUTED 10c27a: ff 77 04 pushl 0x4(%edi) <== NOT EXECUTED 10c27d: ff 77 10 pushl 0x10(%edi) <== NOT EXECUTED 10c280: ff 77 0c pushl 0xc(%edi) <== NOT EXECUTED 10c283: ff 37 pushl (%edi) <== NOT EXECUTED 10c285: e8 56 a3 00 00 call 1165e0 <== NOT EXECUTED (void *) req->aiocbp->aio_buf, req->aiocbp->aio_nbytes, req->aiocbp->aio_offset); break; 10c28a: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10c28d: eb ca jmp 10c259 <== NOT EXECUTED 10c28f: 90 nop <== NOT EXECUTED (void *) req->aiocbp->aio_buf, req->aiocbp->aio_nbytes, req->aiocbp->aio_offset); break; case LIO_SYNC: result = fsync (req->aiocbp->aio_fildes); 10c290: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c293: ff 37 pushl (%edi) <== NOT EXECUTED 10c295: e8 0a 67 00 00 call 1129a4 <== NOT EXECUTED break; 10c29a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c29d: eb ba jmp 10c259 <== NOT EXECUTED 10c29f: 90 nop <== NOT EXECUTED wait for a signal on chain, this will unlock the queue. The fd chain is already unlocked */ struct timespec timeout; pthread_mutex_unlock (&r_chain->mutex); 10c2a0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c2a3: ff 75 b4 pushl -0x4c(%ebp) <== NOT EXECUTED 10c2a6: e8 7d 0c 00 00 call 10cf28 <== NOT EXECUTED pthread_mutex_lock (&aio_request_queue.mutex); 10c2ab: c7 04 24 80 a1 12 00 movl $0x12a180,(%esp) <== NOT EXECUTED 10c2b2: e8 e9 0b 00 00 call 10cea0 <== NOT EXECUTED if (rtems_chain_is_empty (chain)) 10c2b7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c2ba: 3b 73 08 cmp 0x8(%ebx),%esi <== NOT EXECUTED 10c2bd: 0f 85 e9 fe ff ff jne 10c1ac <== NOT EXECUTED { clock_gettime (CLOCK_REALTIME, &timeout); 10c2c3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10c2c6: 8d 45 dc lea -0x24(%ebp),%eax <== NOT EXECUTED 10c2c9: 50 push %eax <== NOT EXECUTED 10c2ca: 6a 01 push $0x1 <== NOT EXECUTED 10c2cc: e8 b3 05 00 00 call 10c884 <== NOT EXECUTED timeout.tv_sec += 3; 10c2d1: 83 45 dc 03 addl $0x3,-0x24(%ebp) <== NOT EXECUTED timeout.tv_nsec = 0; 10c2d5: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED result = pthread_cond_timedwait (&r_chain->cond, 10c2dc: 8d 73 20 lea 0x20(%ebx),%esi <== NOT EXECUTED 10c2df: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10c2e2: 8d 55 dc lea -0x24(%ebp),%edx <== NOT EXECUTED 10c2e5: 52 push %edx <== NOT EXECUTED 10c2e6: 68 80 a1 12 00 push $0x12a180 <== NOT EXECUTED 10c2eb: 56 push %esi <== NOT EXECUTED 10c2ec: e8 03 08 00 00 call 10caf4 <== NOT EXECUTED &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) { 10c2f1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c2f4: 83 f8 74 cmp $0x74,%eax <== NOT EXECUTED 10c2f7: 0f 85 af fe ff ff jne 10c1ac <== NOT EXECUTED 10c2fd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c300: 53 push %ebx <== NOT EXECUTED 10c301: e8 6e 25 00 00 call 10e874 <_Chain_Extract> <== NOT EXECUTED rtems_chain_extract (&r_chain->next_fd); pthread_mutex_destroy (&r_chain->mutex); 10c306: 59 pop %ecx <== NOT EXECUTED 10c307: ff 75 b4 pushl -0x4c(%ebp) <== NOT EXECUTED 10c30a: e8 25 09 00 00 call 10cc34 <== NOT EXECUTED pthread_cond_destroy (&r_chain->cond); 10c30f: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10c312: e8 d9 05 00 00 call 10c8f0 <== NOT EXECUTED free (r_chain); 10c317: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10c31a: e8 15 c8 ff ff call 108b34 <== NOT EXECUTED /* 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)) { 10c31f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c322: 81 3d d4 a1 12 00 d8 cmpl $0x12a1d8,0x12a1d4 <== NOT EXECUTED 10c329: a1 12 00 10c32c: 74 30 je 10c35e <== NOT EXECUTED r_chain->perfd = ((rtems_aio_request_chain *)node)->perfd; } else /* 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); 10c32e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c331: 68 80 a1 12 00 push $0x12a180 <== NOT EXECUTED 10c336: e8 ed 0b 00 00 call 10cf28 <== NOT EXECUTED 10c33b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c33e: e9 69 fe ff ff jmp 10c1ac <== NOT EXECUTED &timeout); /* If no new fd chain was added in the idle requests then this thread is finished */ if (result == ETIMEDOUT) { pthread_mutex_unlock (&aio_request_queue.mutex); 10c343: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c346: 68 80 a1 12 00 push $0x12a180 <== NOT EXECUTED 10c34b: e8 d8 0b 00 00 call 10cf28 <== NOT EXECUTED return NULL; 10c350: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c353: 90 nop <== NOT EXECUTED } AIO_printf ("Thread finished\n"); return NULL; } 10c354: 31 c0 xor %eax,%eax <== NOT EXECUTED 10c356: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c359: 5b pop %ebx <== NOT EXECUTED 10c35a: 5e pop %esi <== NOT EXECUTED 10c35b: 5f pop %edi <== NOT EXECUTED 10c35c: c9 leave <== NOT EXECUTED 10c35d: c3 ret <== NOT EXECUTED 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)) { ++aio_request_queue.idle_threads; 10c35e: ff 05 e8 a1 12 00 incl 0x12a1e8 <== NOT EXECUTED clock_gettime (CLOCK_REALTIME, &timeout); 10c364: 52 push %edx <== NOT EXECUTED 10c365: 52 push %edx <== NOT EXECUTED 10c366: 8d 45 dc lea -0x24(%ebp),%eax <== NOT EXECUTED 10c369: 50 push %eax <== NOT EXECUTED 10c36a: 6a 01 push $0x1 <== NOT EXECUTED 10c36c: e8 13 05 00 00 call 10c884 <== NOT EXECUTED timeout.tv_sec += 3; 10c371: 83 45 dc 03 addl $0x3,-0x24(%ebp) <== NOT EXECUTED timeout.tv_nsec = 0; 10c375: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED result = pthread_cond_timedwait (&aio_request_queue.new_req, 10c37c: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10c37f: 8d 55 dc lea -0x24(%ebp),%edx <== NOT EXECUTED 10c382: 52 push %edx <== NOT EXECUTED 10c383: 68 80 a1 12 00 push $0x12a180 <== NOT EXECUTED 10c388: 68 84 a1 12 00 push $0x12a184 <== NOT EXECUTED 10c38d: e8 62 07 00 00 call 10caf4 <== NOT EXECUTED &aio_request_queue.mutex, &timeout); /* If no new fd chain was added in the idle requests then this thread is finished */ if (result == ETIMEDOUT) { 10c392: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c395: 83 f8 74 cmp $0x74,%eax <== NOT EXECUTED 10c398: 74 a9 je 10c343 <== NOT EXECUTED return NULL; } /* Otherwise move this chain to the working chain and start the loop all over again */ --aio_request_queue.idle_threads; 10c39a: ff 0d e8 a1 12 00 decl 0x12a1e8 <== NOT EXECUTED } AIO_printf ("Thread finished\n"); return NULL; } 10c3a0: 8b 35 d4 a1 12 00 mov 0x12a1d4,%esi <== NOT EXECUTED 10c3a6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c3a9: 56 push %esi <== NOT EXECUTED 10c3aa: e8 c5 24 00 00 call 10e874 <_Chain_Extract> <== NOT EXECUTED /* Otherwise move this chain to the working chain and start the loop all over again */ --aio_request_queue.idle_threads; node = rtems_chain_first (&aio_request_queue.idle_req); rtems_chain_extract (node); r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, 10c3af: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10c3b2: 6a 01 push $0x1 <== NOT EXECUTED 10c3b4: ff 76 14 pushl 0x14(%esi) <== NOT EXECUTED 10c3b7: 68 c8 a1 12 00 push $0x12a1c8 <== NOT EXECUTED 10c3bc: e8 17 fd ff ff call 10c0d8 <== NOT EXECUTED 10c3c1: 89 c3 mov %eax,%ebx <== NOT EXECUTED ((rtems_aio_request_chain *)node)->fildes, 1); r_chain->new_fd = 0; 10c3c3: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) <== NOT EXECUTED pthread_mutex_init (&r_chain->mutex, NULL); 10c3ca: 5f pop %edi <== NOT EXECUTED 10c3cb: 58 pop %eax <== NOT EXECUTED 10c3cc: 6a 00 push $0x0 <== NOT EXECUTED 10c3ce: 8d 43 1c lea 0x1c(%ebx),%eax <== NOT EXECUTED 10c3d1: 89 45 b4 mov %eax,-0x4c(%ebp) <== NOT EXECUTED 10c3d4: 50 push %eax <== NOT EXECUTED 10c3d5: e8 7a 09 00 00 call 10cd54 <== NOT EXECUTED pthread_cond_init (&r_chain->cond, NULL); 10c3da: 5a pop %edx <== NOT EXECUTED 10c3db: 59 pop %ecx <== NOT EXECUTED 10c3dc: 6a 00 push $0x0 <== NOT EXECUTED 10c3de: 8d 43 20 lea 0x20(%ebx),%eax <== NOT EXECUTED 10c3e1: 50 push %eax <== NOT EXECUTED 10c3e2: e8 d5 05 00 00 call 10c9bc <== NOT EXECUTED r_chain->perfd = ((rtems_aio_request_chain *)node)->perfd; 10c3e7: 8d 7b 08 lea 0x8(%ebx),%edi <== NOT EXECUTED 10c3ea: 83 c6 08 add $0x8,%esi <== NOT EXECUTED 10c3ed: b9 03 00 00 00 mov $0x3,%ecx <== NOT EXECUTED 10c3f2: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 10c3f4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c3f7: e9 b0 fd ff ff jmp 10c1ac <== NOT EXECUTED break; default: result = -1; } if (result == -1) { 10c3fc: 8b 7e 14 mov 0x14(%esi),%edi <== NOT EXECUTED 10c3ff: e9 23 fe ff ff jmp 10c227 <== NOT EXECUTED =============================================================================== 0010bfb0 : * 0 - if initialization succeeded */ int rtems_aio_init (void) { 10bfb0: 55 push %ebp 10bfb1: 89 e5 mov %esp,%ebp 10bfb3: 53 push %ebx 10bfb4: 83 ec 10 sub $0x10,%esp int result = 0; result = pthread_attr_init (&aio_request_queue.attr); 10bfb7: 68 88 a1 12 00 push $0x12a188 10bfbc: e8 7f 10 00 00 call 10d040 10bfc1: 89 c3 mov %eax,%ebx if (result != 0) 10bfc3: 83 c4 10 add $0x10,%esp 10bfc6: 85 c0 test %eax,%eax 10bfc8: 74 0a je 10bfd4 <== ALWAYS TAKEN aio_request_queue.active_threads = 0; aio_request_queue.idle_threads = 0; aio_request_queue.initialized = AIO_QUEUE_INITIALIZED; return result; } 10bfca: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10bfcc: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10bfcf: c9 leave <== NOT EXECUTED 10bfd0: c3 ret <== NOT EXECUTED 10bfd1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED result = pthread_attr_init (&aio_request_queue.attr); if (result != 0) return result; result = 10bfd4: 83 ec 08 sub $0x8,%esp 10bfd7: 6a 00 push $0x0 10bfd9: 68 88 a1 12 00 push $0x12a188 10bfde: e8 89 10 00 00 call 10d06c pthread_attr_setdetachstate (&aio_request_queue.attr, PTHREAD_CREATE_DETACHED); if (result != 0) 10bfe3: 83 c4 10 add $0x10,%esp 10bfe6: 85 c0 test %eax,%eax 10bfe8: 0f 85 96 00 00 00 jne 10c084 <== NEVER TAKEN pthread_attr_destroy (&aio_request_queue.attr); result = pthread_mutex_init (&aio_request_queue.mutex, NULL); 10bfee: 83 ec 08 sub $0x8,%esp 10bff1: 6a 00 push $0x0 10bff3: 68 80 a1 12 00 push $0x12a180 10bff8: e8 57 0d 00 00 call 10cd54 if (result != 0) 10bffd: 83 c4 10 add $0x10,%esp 10c000: 85 c0 test %eax,%eax 10c002: 0f 85 b8 00 00 00 jne 10c0c0 <== NEVER TAKEN pthread_attr_destroy (&aio_request_queue.attr); result = pthread_cond_init (&aio_request_queue.new_req, NULL); 10c008: 83 ec 08 sub $0x8,%esp 10c00b: 6a 00 push $0x0 10c00d: 68 84 a1 12 00 push $0x12a184 10c012: e8 a5 09 00 00 call 10c9bc 10c017: 89 c3 mov %eax,%ebx if (result != 0) { 10c019: 83 c4 10 add $0x10,%esp 10c01c: 85 c0 test %eax,%eax 10c01e: 75 7c jne 10c09c <== NEVER TAKEN ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 10c020: c7 05 c8 a1 12 00 cc movl $0x12a1cc,0x12a1c8 10c027: a1 12 00 head->previous = NULL; 10c02a: c7 05 cc a1 12 00 00 movl $0x0,0x12a1cc 10c031: 00 00 00 tail->previous = head; 10c034: c7 05 d0 a1 12 00 c8 movl $0x12a1c8,0x12a1d0 10c03b: a1 12 00 ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 10c03e: c7 05 d4 a1 12 00 d8 movl $0x12a1d8,0x12a1d4 10c045: a1 12 00 head->previous = NULL; 10c048: c7 05 d8 a1 12 00 00 movl $0x0,0x12a1d8 10c04f: 00 00 00 tail->previous = head; 10c052: c7 05 dc a1 12 00 d4 movl $0x12a1d4,0x12a1dc 10c059: a1 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; 10c05c: c7 05 e4 a1 12 00 00 movl $0x0,0x12a1e4 10c063: 00 00 00 aio_request_queue.idle_threads = 0; 10c066: c7 05 e8 a1 12 00 00 movl $0x0,0x12a1e8 10c06d: 00 00 00 aio_request_queue.initialized = AIO_QUEUE_INITIALIZED; 10c070: c7 05 e0 a1 12 00 0b movl $0xb00b,0x12a1e0 10c077: b0 00 00 return result; } 10c07a: 89 d8 mov %ebx,%eax 10c07c: 8b 5d fc mov -0x4(%ebp),%ebx 10c07f: c9 leave 10c080: c3 ret 10c081: 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); 10c084: 83 ec 0c sub $0xc,%esp 10c087: 68 88 a1 12 00 push $0x12a188 <== NOT EXECUTED 10c08c: e8 8b 0f 00 00 call 10d01c <== NOT EXECUTED 10c091: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c094: e9 55 ff ff ff jmp 10bfee <== NOT EXECUTED 10c099: 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); 10c09c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c09f: 68 80 a1 12 00 push $0x12a180 <== NOT EXECUTED 10c0a4: e8 8b 0b 00 00 call 10cc34 <== NOT EXECUTED pthread_attr_destroy (&aio_request_queue.attr); 10c0a9: c7 04 24 88 a1 12 00 movl $0x12a188,(%esp) <== NOT EXECUTED 10c0b0: e8 67 0f 00 00 call 10d01c <== NOT EXECUTED 10c0b5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c0b8: e9 63 ff ff ff jmp 10c020 <== NOT EXECUTED 10c0bd: 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); 10c0c0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c0c3: 68 88 a1 12 00 push $0x12a188 <== NOT EXECUTED 10c0c8: e8 4f 0f 00 00 call 10d01c <== NOT EXECUTED 10c0cd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c0d0: e9 33 ff ff ff jmp 10c008 <== NOT EXECUTED =============================================================================== 0010c404 : * NONE */ void rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req) { 10c404: 55 push %ebp 10c405: 89 e5 mov %esp,%ebp 10c407: 56 push %esi 10c408: 53 push %ebx 10c409: 8b 55 08 mov 0x8(%ebp),%edx 10c40c: 8b 75 0c mov 0xc(%ebp),%esi } AIO_printf ("Thread finished\n"); return NULL; } 10c40f: 8b 02 mov (%edx),%eax 10c411: 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)) { 10c414: 39 c8 cmp %ecx,%eax 10c416: 74 27 je 10c43f <== 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 && 10c418: 8b 56 14 mov 0x14(%esi),%edx 10c41b: 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; 10c41e: 8b 50 14 mov 0x14(%eax),%edx while (req->aiocbp->aio_reqprio > prio && 10c421: 39 5a 14 cmp %ebx,0x14(%edx) 10c424: 7c 06 jl 10c42c <== NEVER TAKEN 10c426: eb 0e jmp 10c436 10c428: 39 c8 cmp %ecx,%eax <== NOT EXECUTED 10c42a: 74 1c je 10c448 <== NOT EXECUTED } AIO_printf ("Thread finished\n"); return NULL; } 10c42c: 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; 10c42e: 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 && 10c431: 39 5a 14 cmp %ebx,0x14(%edx) <== NOT EXECUTED 10c434: 7c f2 jl 10c428 <== 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 ); 10c436: 89 75 0c mov %esi,0xc(%ebp) 10c439: 8b 40 04 mov 0x4(%eax),%eax 10c43c: 89 45 08 mov %eax,0x8(%ebp) } rtems_chain_insert (node->previous, &req->next_prio); } } 10c43f: 5b pop %ebx 10c440: 5e pop %esi 10c441: c9 leave 10c442: e9 69 24 00 00 jmp 10e8b0 <_Chain_Insert> 10c447: 90 nop } AIO_printf ("Thread finished\n"); return NULL; } 10c448: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10c44a: eb ea jmp 10c436 <== NOT EXECUTED =============================================================================== 0010c44c : * Output parameters: * NONE */ void rtems_aio_remove_fd (rtems_aio_request_chain *r_chain) { 10c44c: 55 push %ebp 10c44d: 89 e5 mov %esp,%ebp 10c44f: 57 push %edi 10c450: 56 push %esi 10c451: 53 push %ebx 10c452: 83 ec 0c sub $0xc,%esp 10c455: 8b 7d 08 mov 0x8(%ebp),%edi } AIO_printf ("Thread finished\n"); return NULL; } 10c458: 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)); 10c45b: 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)) 10c45e: 39 fb cmp %edi,%ebx 10c460: 75 04 jne 10c466 <== ALWAYS TAKEN 10c462: eb 2d jmp 10c491 <== NOT EXECUTED { rtems_chain_extract (node); rtems_aio_request *req = (rtems_aio_request *) node; node = rtems_chain_next (node); 10c464: 89 f3 mov %esi,%ebx */ RTEMS_INLINE_ROUTINE void rtems_chain_extract( rtems_chain_node *the_node ) { _Chain_Extract( the_node ); 10c466: 83 ec 0c sub $0xc,%esp 10c469: 53 push %ebx 10c46a: e8 05 24 00 00 call 10e874 <_Chain_Extract> } AIO_printf ("Thread finished\n"); return NULL; } 10c46f: 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; 10c471: 8b 43 14 mov 0x14(%ebx),%eax 10c474: c7 40 30 8c 00 00 00 movl $0x8c,0x30(%eax) req->aiocbp->return_value = -1; 10c47b: c7 40 34 ff ff ff ff movl $0xffffffff,0x34(%eax) free (req); 10c482: 89 1c 24 mov %ebx,(%esp) 10c485: e8 aa 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)) 10c48a: 83 c4 10 add $0x10,%esp 10c48d: 39 fe cmp %edi,%esi 10c48f: 75 d3 jne 10c464 node = rtems_chain_next (node); req->aiocbp->error_code = ECANCELED; req->aiocbp->return_value = -1; free (req); } } 10c491: 8d 65 f4 lea -0xc(%ebp),%esp 10c494: 5b pop %ebx 10c495: 5e pop %esi 10c496: 5f pop %edi 10c497: c9 leave 10c498: c3 ret =============================================================================== 0010c49c : * 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) { 10c49c: 55 push %ebp 10c49d: 89 e5 mov %esp,%ebp 10c49f: 53 push %ebx 10c4a0: 83 ec 04 sub $0x4,%esp 10c4a3: 8b 55 08 mov 0x8(%ebp),%edx 10c4a6: 8b 4d 0c mov 0xc(%ebp),%ecx } AIO_printf ("Thread finished\n"); return NULL; } 10c4a9: 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 ); 10c4ab: 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)) 10c4ae: 39 d0 cmp %edx,%eax 10c4b0: 74 4e je 10c500 <== NEVER TAKEN return AIO_ALLDONE; rtems_chain_node *node = rtems_chain_first (chain); rtems_aio_request *current; current = (rtems_aio_request *) node; 10c4b2: 89 c3 mov %eax,%ebx while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) { 10c4b4: 39 48 14 cmp %ecx,0x14(%eax) 10c4b7: 75 0a jne 10c4c3 <== NEVER TAKEN 10c4b9: eb 19 jmp 10c4d4 10c4bb: 90 nop node = rtems_chain_next (node); current = (rtems_aio_request *) node; 10c4bc: 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) { 10c4be: 39 48 14 cmp %ecx,0x14(%eax) <== NOT EXECUTED 10c4c1: 74 11 je 10c4d4 <== NOT EXECUTED } AIO_printf ("Thread finished\n"); return NULL; } 10c4c3: 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) { 10c4c5: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10c4c7: 75 f3 jne 10c4bc <== NOT EXECUTED node = rtems_chain_next (node); current = (rtems_aio_request *) node; } if (rtems_chain_is_tail (chain, node)) return AIO_NOTCANCELED; 10c4c9: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED current->aiocbp->return_value = -1; free (current); } return AIO_CANCELED; } 10c4ce: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c4d1: c9 leave <== NOT EXECUTED 10c4d2: c3 ret <== NOT EXECUTED 10c4d3: 90 nop <== NOT EXECUTED 10c4d4: 83 ec 0c sub $0xc,%esp 10c4d7: 50 push %eax 10c4d8: e8 97 23 00 00 call 10e874 <_Chain_Extract> if (rtems_chain_is_tail (chain, node)) return AIO_NOTCANCELED; else { rtems_chain_extract (node); current->aiocbp->error_code = ECANCELED; 10c4dd: 8b 43 14 mov 0x14(%ebx),%eax 10c4e0: c7 40 30 8c 00 00 00 movl $0x8c,0x30(%eax) current->aiocbp->return_value = -1; 10c4e7: c7 40 34 ff ff ff ff movl $0xffffffff,0x34(%eax) free (current); 10c4ee: 89 1c 24 mov %ebx,(%esp) 10c4f1: e8 3e c6 ff ff call 108b34 } return AIO_CANCELED; 10c4f6: 83 c4 10 add $0x10,%esp 10c4f9: 31 c0 xor %eax,%eax } 10c4fb: 8b 5d fc mov -0x4(%ebp),%ebx 10c4fe: c9 leave 10c4ff: c3 ret */ int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp) { if (rtems_chain_is_empty (chain)) return AIO_ALLDONE; 10c500: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED current->aiocbp->return_value = -1; free (current); } return AIO_CANCELED; } 10c505: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c508: c9 leave <== NOT EXECUTED 10c509: c3 ret <== NOT EXECUTED =============================================================================== 0010c0d8 : * */ rtems_aio_request_chain * rtems_aio_search_fd (rtems_chain_control *chain, int fildes, int create) { 10c0d8: 55 push %ebp 10c0d9: 89 e5 mov %esp,%ebp 10c0db: 57 push %edi 10c0dc: 56 push %esi 10c0dd: 53 push %ebx 10c0de: 83 ec 1c sub $0x1c,%esp 10c0e1: 8b 75 08 mov 0x8(%ebp),%esi 10c0e4: 8b 5d 0c mov 0xc(%ebp),%ebx } AIO_printf ("Thread finished\n"); return NULL; } 10c0e7: 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)) { 10c0e9: 8b 50 14 mov 0x14(%eax),%edx 10c0ec: 39 d3 cmp %edx,%ebx 10c0ee: 7e 28 jle 10c118 RTEMS_INLINE_ROUTINE bool _Chain_Is_tail( Chain_Control *the_chain, const Chain_Node *the_node ) { return (the_node == _Chain_Tail(the_chain)); 10c0f0: 8d 4e 04 lea 0x4(%esi),%ecx 10c0f3: eb 0c jmp 10c101 10c0f5: 8d 76 00 lea 0x0(%esi),%esi } AIO_printf ("Thread finished\n"); return NULL; } 10c0f8: 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)) { 10c0fa: 8b 50 14 mov 0x14(%eax),%edx 10c0fd: 39 da cmp %ebx,%edx 10c0ff: 7d 17 jge 10c118 10c101: 39 c8 cmp %ecx,%eax 10c103: 75 f3 jne 10c0f8 10c105: 89 c7 mov %eax,%edi } if (r_chain->fildes == fildes) r_chain->new_fd = 0; else { if (create == 0) 10c107: 8b 45 10 mov 0x10(%ebp),%eax 10c10a: 85 c0 test %eax,%eax 10c10c: 75 1f jne 10c12d r_chain = NULL; 10c10e: 31 c0 xor %eax,%eax r_chain->new_fd = 1; r_chain->fildes = fildes; } } return r_chain; } 10c110: 8d 65 f4 lea -0xc(%ebp),%esp 10c113: 5b pop %ebx 10c114: 5e pop %esi 10c115: 5f pop %edi 10c116: c9 leave 10c117: c3 ret } AIO_printf ("Thread finished\n"); return NULL; } 10c118: 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) 10c11a: 39 d3 cmp %edx,%ebx 10c11c: 75 e9 jne 10c107 r_chain->new_fd = 0; 10c11e: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) r_chain->new_fd = 1; r_chain->fildes = fildes; } } return r_chain; } 10c125: 8d 65 f4 lea -0xc(%ebp),%esp 10c128: 5b pop %ebx 10c129: 5e pop %esi 10c12a: 5f pop %edi 10c12b: c9 leave 10c12c: c3 ret r_chain->new_fd = 0; else { if (create == 0) r_chain = NULL; else { r_chain = malloc (sizeof (rtems_aio_request_chain)); 10c12d: 83 ec 0c sub $0xc,%esp 10c130: 6a 24 push $0x24 10c132: e8 11 cf ff ff call 109048 10c137: 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 ); 10c139: 8d 4a 0c lea 0xc(%edx),%ecx 10c13c: 89 4a 08 mov %ecx,0x8(%edx) head->next = tail; head->previous = NULL; 10c13f: 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 ); 10c146: 8d 4a 08 lea 0x8(%edx),%ecx 10c149: 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 ); 10c14c: 8d 4e 04 lea 0x4(%esi),%ecx rtems_chain_initialize_empty (&r_chain->perfd); if (rtems_chain_is_empty (chain)) 10c14f: 83 c4 10 add $0x10,%esp 10c152: 39 0e cmp %ecx,(%esi) 10c154: 74 27 je 10c17d RTEMS_INLINE_ROUTINE void rtems_chain_insert( rtems_chain_node *after_node, rtems_chain_node *the_node ) { _Chain_Insert( after_node, the_node ); 10c156: 83 ec 08 sub $0x8,%esp 10c159: 52 push %edx 10c15a: ff 77 04 pushl 0x4(%edi) 10c15d: 89 45 e4 mov %eax,-0x1c(%ebp) 10c160: 89 55 e0 mov %edx,-0x20(%ebp) 10c163: e8 48 27 00 00 call 10e8b0 <_Chain_Insert> 10c168: 83 c4 10 add $0x10,%esp 10c16b: 8b 55 e0 mov -0x20(%ebp),%edx 10c16e: 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; 10c171: c7 42 18 01 00 00 00 movl $0x1,0x18(%edx) r_chain->fildes = fildes; 10c178: 89 5a 14 mov %ebx,0x14(%edx) 10c17b: eb a8 jmp 10c125 RTEMS_INLINE_ROUTINE void _Chain_Prepend( Chain_Control *the_chain, Chain_Node *the_node ) { _Chain_Insert(_Chain_Head(the_chain), the_node); 10c17d: 83 ec 08 sub $0x8,%esp 10c180: 52 push %edx 10c181: 56 push %esi 10c182: 89 45 e4 mov %eax,-0x1c(%ebp) 10c185: 89 55 e0 mov %edx,-0x20(%ebp) 10c188: e8 23 27 00 00 call 10e8b0 <_Chain_Insert> 10c18d: 83 c4 10 add $0x10,%esp 10c190: 8b 45 e4 mov -0x1c(%ebp),%eax 10c193: 8b 55 e0 mov -0x20(%ebp),%edx 10c196: eb d9 jmp 10c171 =============================================================================== 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 =============================================================================== 0010fb90 : uint32_t rtems_assoc_local_by_remote( const rtems_assoc_t *ap, uint32_t remote_value ) { 10fb90: 55 push %ebp 10fb91: 89 e5 mov %esp,%ebp 10fb93: 83 ec 10 sub $0x10,%esp const rtems_assoc_t *nap; nap = rtems_assoc_ptr_by_remote(ap, remote_value); 10fb96: ff 75 0c pushl 0xc(%ebp) 10fb99: ff 75 08 pushl 0x8(%ebp) 10fb9c: e8 13 00 00 00 call 10fbb4 if (nap) 10fba1: 83 c4 10 add $0x10,%esp 10fba4: 85 c0 test %eax,%eax 10fba6: 74 08 je 10fbb0 return nap->local_value; 10fba8: 8b 40 04 mov 0x4(%eax),%eax return 0; } 10fbab: c9 leave 10fbac: c3 ret 10fbad: 8d 76 00 lea 0x0(%esi),%esi nap = rtems_assoc_ptr_by_remote(ap, remote_value); if (nap) return nap->local_value; return 0; 10fbb0: 31 c0 xor %eax,%eax } 10fbb2: c9 leave 10fbb3: c3 ret =============================================================================== 00112b00 : uint32_t rtems_assoc_local_by_remote_bitfield( const rtems_assoc_t *ap, uint32_t remote_value ) { 112b00: 55 push %ebp 112b01: 89 e5 mov %esp,%ebp 112b03: 57 push %edi 112b04: 56 push %esi 112b05: 53 push %ebx 112b06: 83 ec 1c sub $0x1c,%esp 112b09: 8b 7d 0c mov 0xc(%ebp),%edi 112b0c: be 20 00 00 00 mov $0x20,%esi uint32_t b; uint32_t local_value = 0; 112b11: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) for (b = 1; b; b <<= 1) { 112b18: bb 01 00 00 00 mov $0x1,%ebx 112b1d: eb 06 jmp 112b25 112b1f: 90 nop 112b20: d1 e3 shl %ebx 112b22: 4e dec %esi 112b23: 74 1b je 112b40 if (b & remote_value) 112b25: 85 fb test %edi,%ebx 112b27: 74 f7 je 112b20 local_value |= rtems_assoc_local_by_remote(ap, b); 112b29: 83 ec 08 sub $0x8,%esp 112b2c: 53 push %ebx 112b2d: ff 75 08 pushl 0x8(%ebp) 112b30: e8 5b d0 ff ff call 10fb90 112b35: 09 45 e4 or %eax,-0x1c(%ebp) 112b38: 83 c4 10 add $0x10,%esp ) { uint32_t b; uint32_t local_value = 0; for (b = 1; b; b <<= 1) { 112b3b: d1 e3 shl %ebx 112b3d: 4e dec %esi 112b3e: 75 e5 jne 112b25 <== ALWAYS TAKEN if (b & remote_value) local_value |= rtems_assoc_local_by_remote(ap, b); } return local_value; } 112b40: 8b 45 e4 mov -0x1c(%ebp),%eax 112b43: 8d 65 f4 lea -0xc(%ebp),%esp 112b46: 5b pop %ebx 112b47: 5e pop %esi 112b48: 5f pop %edi 112b49: c9 leave 112b4a: c3 ret =============================================================================== 00114ce4 : const char *rtems_assoc_name_by_local( const rtems_assoc_t *ap, uint32_t local_value ) { 114ce4: 55 push %ebp 114ce5: 89 e5 mov %esp,%ebp 114ce7: 53 push %ebx 114ce8: 83 ec 0c sub $0xc,%esp 114ceb: 8b 5d 0c mov 0xc(%ebp),%ebx const rtems_assoc_t *nap; nap = rtems_assoc_ptr_by_local(ap, local_value); 114cee: 53 push %ebx 114cef: ff 75 08 pushl 0x8(%ebp) 114cf2: e8 1d 00 00 00 call 114d14 if (nap) 114cf7: 83 c4 10 add $0x10,%esp 114cfa: 85 c0 test %eax,%eax 114cfc: 74 0a je 114d08 return nap->name; 114cfe: 8b 00 mov (%eax),%eax return rtems_assoc_name_bad(local_value); } 114d00: 8b 5d fc mov -0x4(%ebp),%ebx 114d03: c9 leave 114d04: c3 ret 114d05: 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); 114d08: 89 5d 08 mov %ebx,0x8(%ebp) } 114d0b: 8b 5d fc mov -0x4(%ebp),%ebx 114d0e: c9 leave nap = rtems_assoc_ptr_by_local(ap, local_value); if (nap) return nap->name; return rtems_assoc_name_bad(local_value); 114d0f: e9 4c 31 00 00 jmp 117e60 =============================================================================== 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 c8 7e 00 00 jmp 110880 =============================================================================== 00114d14 : const rtems_assoc_t *rtems_assoc_ptr_by_local( const rtems_assoc_t *ap, uint32_t local_value ) { 114d14: 55 push %ebp 114d15: 89 e5 mov %esp,%ebp 114d17: 57 push %edi 114d18: 56 push %esi 114d19: 53 push %ebx 114d1a: 8b 45 08 mov 0x8(%ebp),%eax 114d1d: 8b 55 0c mov 0xc(%ebp),%edx const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) 114d20: 8b 30 mov (%eax),%esi 114d22: 85 f6 test %esi,%esi 114d24: 74 3e je 114d64 114d26: bf b8 74 12 00 mov $0x1274b8,%edi 114d2b: b9 0a 00 00 00 mov $0xa,%ecx 114d30: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) 114d32: 74 18 je 114d4c 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; 114d34: 31 c9 xor %ecx,%ecx 114d36: eb 09 jmp 114d41 if (rtems_assoc_is_default(ap)) default_ap = ap++; for ( ; ap->name; ap++) 114d38: 83 c0 0c add $0xc,%eax 114d3b: 8b 18 mov (%eax),%ebx 114d3d: 85 db test %ebx,%ebx 114d3f: 74 1b je 114d5c if (ap->local_value == local_value) 114d41: 39 50 04 cmp %edx,0x4(%eax) 114d44: 75 f2 jne 114d38 return ap; return default_ap; } 114d46: 5b pop %ebx 114d47: 5e pop %esi 114d48: 5f pop %edi 114d49: c9 leave 114d4a: c3 ret 114d4b: 90 nop ) { const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) default_ap = ap++; 114d4c: 8d 58 0c lea 0xc(%eax),%ebx for ( ; ap->name; ap++) 114d4f: 8b 70 0c mov 0xc(%eax),%esi 114d52: 85 f6 test %esi,%esi 114d54: 74 f0 je 114d46 <== NEVER TAKEN 114d56: 89 c1 mov %eax,%ecx 114d58: 89 d8 mov %ebx,%eax 114d5a: eb e5 jmp 114d41 114d5c: 89 c8 mov %ecx,%eax if (ap->local_value == local_value) return ap; return default_ap; } 114d5e: 5b pop %ebx 114d5f: 5e pop %esi 114d60: 5f pop %edi 114d61: c9 leave 114d62: c3 ret 114d63: 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; 114d64: 31 c0 xor %eax,%eax for ( ; ap->name; ap++) if (ap->local_value == local_value) return ap; return default_ap; } 114d66: 5b pop %ebx 114d67: 5e pop %esi 114d68: 5f pop %edi 114d69: c9 leave 114d6a: 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 5d 03 12 00 mov $0x12035d,%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 2f c1 00 00 call 114b7c 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 =============================================================================== 0010fbb4 : const rtems_assoc_t *rtems_assoc_ptr_by_remote( const rtems_assoc_t *ap, uint32_t remote_value ) { 10fbb4: 55 push %ebp 10fbb5: 89 e5 mov %esp,%ebp 10fbb7: 57 push %edi 10fbb8: 56 push %esi 10fbb9: 53 push %ebx 10fbba: 8b 45 08 mov 0x8(%ebp),%eax 10fbbd: 8b 55 0c mov 0xc(%ebp),%edx const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) 10fbc0: 8b 30 mov (%eax),%esi 10fbc2: 85 f6 test %esi,%esi 10fbc4: 74 3e je 10fc04 10fbc6: bf 18 11 12 00 mov $0x121118,%edi 10fbcb: b9 0a 00 00 00 mov $0xa,%ecx 10fbd0: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) 10fbd2: 74 18 je 10fbec 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; 10fbd4: 31 c9 xor %ecx,%ecx 10fbd6: eb 09 jmp 10fbe1 if (rtems_assoc_is_default(ap)) default_ap = ap++; for ( ; ap->name; ap++) 10fbd8: 83 c0 0c add $0xc,%eax 10fbdb: 8b 18 mov (%eax),%ebx 10fbdd: 85 db test %ebx,%ebx 10fbdf: 74 1b je 10fbfc if (ap->remote_value == remote_value) 10fbe1: 39 50 08 cmp %edx,0x8(%eax) 10fbe4: 75 f2 jne 10fbd8 return ap; return default_ap; } 10fbe6: 5b pop %ebx 10fbe7: 5e pop %esi 10fbe8: 5f pop %edi 10fbe9: c9 leave 10fbea: c3 ret 10fbeb: 90 nop ) { const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) default_ap = ap++; 10fbec: 8d 58 0c lea 0xc(%eax),%ebx for ( ; ap->name; ap++) 10fbef: 8b 70 0c mov 0xc(%eax),%esi 10fbf2: 85 f6 test %esi,%esi 10fbf4: 74 f0 je 10fbe6 <== NEVER TAKEN 10fbf6: 89 c1 mov %eax,%ecx 10fbf8: 89 d8 mov %ebx,%eax 10fbfa: eb e5 jmp 10fbe1 10fbfc: 89 c8 mov %ecx,%eax if (ap->remote_value == remote_value) return ap; return default_ap; } 10fbfe: 5b pop %ebx 10fbff: 5e pop %esi 10fc00: 5f pop %edi 10fc01: c9 leave 10fc02: c3 ret 10fc03: 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; 10fc04: 31 c0 xor %eax,%eax for ( ; ap->name; ap++) if (ap->remote_value == remote_value) return ap; return default_ap; } 10fc06: 5b pop %ebx 10fc07: 5e pop %esi 10fc08: 5f pop %edi 10fc09: c9 leave 10fc0a: 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 =============================================================================== 00113684 : rtems_name name, rtems_attribute attribute_set, uint32_t maximum_waiters, rtems_id *id ) { 113684: 55 push %ebp 113685: 89 e5 mov %esp,%ebp 113687: 57 push %edi 113688: 56 push %esi 113689: 53 push %ebx 11368a: 83 ec 2c sub $0x2c,%esp 11368d: 8b 5d 08 mov 0x8(%ebp),%ebx 113690: 8b 7d 0c mov 0xc(%ebp),%edi 113693: 8b 45 10 mov 0x10(%ebp),%eax 113696: 8b 75 14 mov 0x14(%ebp),%esi Barrier_Control *the_barrier; CORE_barrier_Attributes the_attributes; if ( !rtems_is_name_valid( name ) ) 113699: 85 db test %ebx,%ebx 11369b: 0f 84 87 00 00 00 je 113728 return RTEMS_INVALID_NAME; if ( !id ) 1136a1: 85 f6 test %esi,%esi 1136a3: 0f 84 bf 00 00 00 je 113768 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; /* Initialize core barrier attributes */ if ( _Attributes_Is_barrier_automatic( attribute_set ) ) { 1136a9: f7 c7 10 00 00 00 test $0x10,%edi 1136af: 0f 84 83 00 00 00 je 113738 the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; 1136b5: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) if ( maximum_waiters == 0 ) 1136bc: 85 c0 test %eax,%eax 1136be: 0f 84 80 00 00 00 je 113744 <== NEVER TAKEN return RTEMS_INVALID_NUMBER; } else the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE; the_attributes.maximum_count = maximum_waiters; 1136c4: 89 45 e4 mov %eax,-0x1c(%ebp) 1136c7: a1 70 9f 12 00 mov 0x129f70,%eax 1136cc: 40 inc %eax 1136cd: a3 70 9f 12 00 mov %eax,0x129f70 * 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 ); 1136d2: 83 ec 0c sub $0xc,%esp 1136d5: 68 a0 a9 12 00 push $0x12a9a0 1136da: e8 85 b0 ff ff call 10e764 <_Objects_Allocate> _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _Barrier_Allocate(); if ( !the_barrier ) { 1136df: 83 c4 10 add $0x10,%esp 1136e2: 85 c0 test %eax,%eax 1136e4: 74 6e je 113754 _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_barrier->attribute_set = attribute_set; 1136e6: 89 78 10 mov %edi,0x10(%eax) _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 1136e9: 83 ec 08 sub $0x8,%esp 1136ec: 8d 55 e0 lea -0x20(%ebp),%edx 1136ef: 52 push %edx 1136f0: 8d 50 14 lea 0x14(%eax),%edx 1136f3: 52 push %edx 1136f4: 89 45 d4 mov %eax,-0x2c(%ebp) 1136f7: e8 c0 07 00 00 call 113ebc <_CORE_barrier_Initialize> Objects_Name name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 1136fc: 8b 45 d4 mov -0x2c(%ebp),%eax 1136ff: 8b 50 08 mov 0x8(%eax),%edx Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 113702: 0f b7 fa movzwl %dx,%edi #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 113705: 8b 0d bc a9 12 00 mov 0x12a9bc,%ecx 11370b: 89 04 b9 mov %eax,(%ecx,%edi,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 11370e: 89 58 0c mov %ebx,0xc(%eax) &_Barrier_Information, &the_barrier->Object, (Objects_Name) name ); *id = the_barrier->Object.id; 113711: 89 16 mov %edx,(%esi) _Thread_Enable_dispatch(); 113713: e8 e8 bf ff ff call 10f700 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 113718: 83 c4 10 add $0x10,%esp 11371b: 31 c0 xor %eax,%eax } 11371d: 8d 65 f4 lea -0xc(%ebp),%esp 113720: 5b pop %ebx 113721: 5e pop %esi 113722: 5f pop %edi 113723: c9 leave 113724: c3 ret 113725: 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; 113728: b8 03 00 00 00 mov $0x3,%eax *id = the_barrier->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 11372d: 8d 65 f4 lea -0xc(%ebp),%esp 113730: 5b pop %ebx 113731: 5e pop %esi 113732: 5f pop %edi 113733: c9 leave 113734: c3 ret 113735: 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; 113738: c7 45 e0 01 00 00 00 movl $0x1,-0x20(%ebp) 11373f: eb 83 jmp 1136c4 113741: 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; 113744: b8 0a 00 00 00 mov $0xa,%eax *id = the_barrier->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 113749: 8d 65 f4 lea -0xc(%ebp),%esp 11374c: 5b pop %ebx 11374d: 5e pop %esi 11374e: 5f pop %edi 11374f: c9 leave 113750: c3 ret 113751: 8d 76 00 lea 0x0(%esi),%esi _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _Barrier_Allocate(); if ( !the_barrier ) { _Thread_Enable_dispatch(); 113754: e8 a7 bf ff ff call 10f700 <_Thread_Enable_dispatch> return RTEMS_TOO_MANY; 113759: b8 05 00 00 00 mov $0x5,%eax *id = the_barrier->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 11375e: 8d 65 f4 lea -0xc(%ebp),%esp 113761: 5b pop %ebx 113762: 5e pop %esi 113763: 5f pop %edi 113764: c9 leave 113765: c3 ret 113766: 66 90 xchg %ax,%ax if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !id ) return RTEMS_INVALID_ADDRESS; 113768: b8 09 00 00 00 mov $0x9,%eax 11376d: eb ae jmp 11371d =============================================================================== 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 f8 7c 12 00 mov 0x127cf8,%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 58 ce 00 00 call 114c4c 107df4: 83 c4 10 add $0x10,%esp /* printf( "raw: %p (%s)\n", p, p ); */ return p; } 107df7: c9 leave 107df8: c3 ret =============================================================================== 0010c14c : rtems_chain_control *chain, rtems_chain_node *node, rtems_id task, rtems_event_set events ) { 10c14c: 55 push %ebp 10c14d: 89 e5 mov %esp,%ebp 10c14f: 56 push %esi 10c150: 53 push %ebx 10c151: 8b 5d 10 mov 0x10(%ebp),%ebx 10c154: 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 ); 10c157: 83 ec 08 sub $0x8,%esp 10c15a: ff 75 0c pushl 0xc(%ebp) 10c15d: ff 75 08 pushl 0x8(%ebp) 10c160: e8 e3 04 00 00 call 10c648 <_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 ) { 10c165: 83 c4 10 add $0x10,%esp 10c168: 84 c0 test %al,%al 10c16a: 75 0c jne 10c178 <== ALWAYS TAKEN sc = rtems_event_send( task, events ); } return sc; } 10c16c: 31 c0 xor %eax,%eax 10c16e: 8d 65 f8 lea -0x8(%ebp),%esp 10c171: 5b pop %ebx 10c172: 5e pop %esi <== NOT EXECUTED 10c173: c9 leave <== NOT EXECUTED 10c174: c3 ret <== NOT EXECUTED 10c175: 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 ); 10c178: 89 75 0c mov %esi,0xc(%ebp) 10c17b: 89 5d 08 mov %ebx,0x8(%ebp) } return sc; } 10c17e: 8d 65 f8 lea -0x8(%ebp),%esp 10c181: 5b pop %ebx 10c182: 5e pop %esi 10c183: 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 ); 10c184: e9 a3 f5 ff ff jmp 10b72c =============================================================================== 0010c18c : rtems_chain_control *chain, rtems_id task, rtems_event_set events, rtems_chain_node **node ) { 10c18c: 55 push %ebp 10c18d: 89 e5 mov %esp,%ebp 10c18f: 56 push %esi 10c190: 53 push %ebx 10c191: 8b 5d 0c mov 0xc(%ebp),%ebx 10c194: 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 ); 10c197: 83 ec 08 sub $0x8,%esp 10c19a: ff 75 14 pushl 0x14(%ebp) 10c19d: ff 75 08 pushl 0x8(%ebp) 10c1a0: e8 0b 05 00 00 call 10c6b0 <_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 ) { 10c1a5: 83 c4 10 add $0x10,%esp 10c1a8: 84 c0 test %al,%al 10c1aa: 75 0c jne 10c1b8 sc = rtems_event_send( task, events ); } return sc; } 10c1ac: 31 c0 xor %eax,%eax 10c1ae: 8d 65 f8 lea -0x8(%ebp),%esp 10c1b1: 5b pop %ebx 10c1b2: 5e pop %esi 10c1b3: c9 leave 10c1b4: c3 ret 10c1b5: 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 ); 10c1b8: 89 75 0c mov %esi,0xc(%ebp) 10c1bb: 89 5d 08 mov %ebx,0x8(%ebp) } return sc; } 10c1be: 8d 65 f8 lea -0x8(%ebp),%esp 10c1c1: 5b pop %ebx 10c1c2: 5e pop %esi 10c1c3: 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 ); 10c1c4: e9 63 f5 ff ff jmp 10b72c =============================================================================== 0010c1cc : rtems_chain_control *chain, rtems_event_set events, rtems_interval timeout, rtems_chain_node **node_ptr ) { 10c1cc: 55 push %ebp 10c1cd: 89 e5 mov %esp,%ebp 10c1cf: 57 push %edi 10c1d0: 56 push %esi 10c1d1: 53 push %ebx 10c1d2: 83 ec 1c sub $0x1c,%esp 10c1d5: 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( 10c1d8: 8d 7d e4 lea -0x1c(%ebp),%edi 10c1db: 90 nop */ RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get( rtems_chain_control *the_chain ) { return _Chain_Get( the_chain ); 10c1dc: 83 ec 0c sub $0xc,%esp 10c1df: 56 push %esi 10c1e0: e8 07 05 00 00 call 10c6ec <_Chain_Get> 10c1e5: 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 10c1e7: 83 c4 10 add $0x10,%esp 10c1ea: 85 c0 test %eax,%eax 10c1ec: 75 22 jne 10c210 ) { rtems_event_set out; sc = rtems_event_receive( 10c1ee: 57 push %edi 10c1ef: ff 75 10 pushl 0x10(%ebp) 10c1f2: 6a 00 push $0x0 10c1f4: ff 75 0c pushl 0xc(%ebp) 10c1f7: e8 a8 f3 ff ff call 10b5a4 ) { rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_chain_node *node = NULL; while ( 10c1fc: 83 c4 10 add $0x10,%esp 10c1ff: 85 c0 test %eax,%eax 10c201: 74 d9 je 10c1dc <== NEVER TAKEN timeout, &out ); } *node_ptr = node; 10c203: 8b 55 14 mov 0x14(%ebp),%edx 10c206: 89 1a mov %ebx,(%edx) return sc; } 10c208: 8d 65 f4 lea -0xc(%ebp),%esp 10c20b: 5b pop %ebx 10c20c: 5e pop %esi 10c20d: 5f pop %edi 10c20e: c9 leave 10c20f: c3 ret rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_chain_node *node = NULL; while ( sc == RTEMS_SUCCESSFUL && (node = rtems_chain_get( chain )) == NULL 10c210: 31 c0 xor %eax,%eax timeout, &out ); } *node_ptr = node; 10c212: 8b 55 14 mov 0x14(%ebp),%edx 10c215: 89 1a mov %ebx,(%edx) return sc; } 10c217: 8d 65 f4 lea -0xc(%ebp),%esp 10c21a: 5b pop %ebx 10c21b: 5e pop %esi 10c21c: 5f pop %edi 10c21d: c9 leave 10c21e: c3 ret =============================================================================== 0010c220 : rtems_chain_control *chain, rtems_chain_node *node, rtems_id task, rtems_event_set events ) { 10c220: 55 push %ebp 10c221: 89 e5 mov %esp,%ebp 10c223: 56 push %esi 10c224: 53 push %ebx 10c225: 8b 5d 10 mov 0x10(%ebp),%ebx 10c228: 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 ); 10c22b: 83 ec 08 sub $0x8,%esp 10c22e: ff 75 0c pushl 0xc(%ebp) 10c231: ff 75 08 pushl 0x8(%ebp) 10c234: e8 f7 04 00 00 call 10c730 <_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) { 10c239: 83 c4 10 add $0x10,%esp 10c23c: 84 c0 test %al,%al 10c23e: 75 0c jne 10c24c <== ALWAYS TAKEN sc = rtems_event_send( task, events ); } return sc; } 10c240: 31 c0 xor %eax,%eax 10c242: 8d 65 f8 lea -0x8(%ebp),%esp 10c245: 5b pop %ebx 10c246: 5e pop %esi <== NOT EXECUTED 10c247: c9 leave <== NOT EXECUTED 10c248: c3 ret <== NOT EXECUTED 10c249: 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 ); 10c24c: 89 75 0c mov %esi,0xc(%ebp) 10c24f: 89 5d 08 mov %ebx,0x8(%ebp) } return sc; } 10c252: 8d 65 f8 lea -0x8(%ebp),%esp 10c255: 5b pop %ebx 10c256: 5e pop %esi 10c257: 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 ); 10c258: e9 cf 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 24 22 14 00 00 cmpb $0x0,0x142224 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 21 44 00 00 call 11a034 <_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 7a 16 00 00 call 10c864 <_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 2c 62 12 00 imul 0x12622c,%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 70 23 13 00 mov 0x132370,%eax 10c176: 40 inc %eax 10c177: a3 70 23 13 00 mov %eax,0x132370 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 59 19 00 00 call 10dae0 <_TOD_Set> _Thread_Enable_dispatch(); 10c187: e8 e8 2e 00 00 call 10f074 <_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 3d 15 00 00 call 10c518 <_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 7c 76 12 00 push $0x12767c 10afe3: e8 bc 38 00 00 call 10e8a4 <_Watchdog_Tickle> _Watchdog_Tickle_ticks(); _Thread_Tickle_timeslice(); 10afe8: e8 77 33 00 00 call 10e364 <_Thread_Tickle_timeslice> * otherwise. */ RTEMS_INLINE_ROUTINE bool _Thread_Is_context_switch_necessary( void ) { return ( _Thread_Dispatch_necessary ); 10afed: a0 64 7b 12 00 mov 0x127b64,%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 70 75 12 00 mov 0x127570,%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 6f 27 00 00 call 10d77c <_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 68 24 13 00 mov 0x132468,%eax 10841c: 8b 15 6c 24 13 00 mov 0x13246c,%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 24 56 00 00 call 10da58 <_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 00 2a 13 00 push $0x132a00 108444: e8 93 78 00 00 call 10fcdc <_Timespec_Subtract> } } } #endif (*print)( 108449: 5b pop %ebx 10844a: 5e pop %esi 10844b: 68 50 32 12 00 push $0x123250 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 48 23 13 00 mov 0x132348(,%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 7b 77 00 00 call 10fc18 <_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 c3 34 12 00 push $0x1234c3 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 b0 34 12 00 push $0x1234b0 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 98 29 13 00 mov 0x132998,%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 a0 77 00 00 call 10fcdc <_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 8e 76 00 00 call 10fbdc <_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 c4 33 12 00 push $0x1233c4 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 =============================================================================== 00113288 : [RTEMS_IO_ERROR] = EIO, [RTEMS_PROXY_BLOCKING] = EIO }; int rtems_deviceio_errno(rtems_status_code sc) { 113288: 55 push %ebp 113289: 89 e5 mov %esp,%ebp 11328b: 53 push %ebx 11328c: 83 ec 04 sub $0x4,%esp 11328f: 8b 45 08 mov 0x8(%ebp),%eax if (sc == RTEMS_SUCCESSFUL) { 113292: 85 c0 test %eax,%eax 113294: 75 06 jne 11329c return 0; 113296: 31 c0 xor %eax,%eax errno = eno; return -1; } } 113298: 5a pop %edx 113299: 5b pop %ebx 11329a: c9 leave 11329b: c3 ret if (sc == RTEMS_SUCCESSFUL) { return 0; } else { int eno = EINVAL; if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) { 11329c: 83 f8 1c cmp $0x1c,%eax 11329f: 77 17 ja 1132b8 <== NEVER TAKEN eno = status_code_to_errno [sc]; 1132a1: 8b 1c 85 c0 13 12 00 mov 0x1213c0(,%eax,4),%ebx } errno = eno; 1132a8: e8 67 00 00 00 call 113314 <__errno> 1132ad: 89 18 mov %ebx,(%eax) return -1; 1132af: b8 ff ff ff ff mov $0xffffffff,%eax 1132b4: eb e2 jmp 113298 1132b6: 66 90 xchg %ax,%ax int rtems_deviceio_errno(rtems_status_code sc) { if (sc == RTEMS_SUCCESSFUL) { return 0; } else { int eno = EINVAL; 1132b8: bb 16 00 00 00 mov $0x16,%ebx <== NOT EXECUTED 1132bd: eb e9 jmp 1132a8 <== 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 69 27 00 00 call 10d918 <_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 1d 27 00 00 call 10d8f4 <_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 =============================================================================== 0010d00c : #include rtems_status_code rtems_extension_delete( rtems_id id ) { 10d00c: 55 push %ebp 10d00d: 89 e5 mov %esp,%ebp 10d00f: 53 push %ebx 10d010: 83 ec 18 sub $0x18,%esp Extension_Control *the_extension; Objects_Locations location; the_extension = _Extension_Get( id, &location ); 10d013: 8d 45 f4 lea -0xc(%ebp),%eax Objects_Id id, Objects_Locations *location ) { return (Extension_Control *) _Objects_Get( &_Extension_Information, id, location ); 10d016: 50 push %eax 10d017: ff 75 08 pushl 0x8(%ebp) 10d01a: 68 00 26 13 00 push $0x132600 10d01f: e8 24 12 00 00 call 10e248 <_Objects_Get> 10d024: 89 c3 mov %eax,%ebx switch ( location ) { 10d026: 83 c4 10 add $0x10,%esp 10d029: 8b 55 f4 mov -0xc(%ebp),%edx 10d02c: 85 d2 test %edx,%edx 10d02e: 75 38 jne 10d068 case OBJECTS_LOCAL: _User_extensions_Remove_set( &the_extension->Extension ); 10d030: 83 ec 0c sub $0xc,%esp 10d033: 8d 40 10 lea 0x10(%eax),%eax 10d036: 50 push %eax 10d037: e8 a4 29 00 00 call 10f9e0 <_User_extensions_Remove_set> _Objects_Close( &_Extension_Information, &the_extension->Object ); 10d03c: 59 pop %ecx 10d03d: 58 pop %eax 10d03e: 53 push %ebx 10d03f: 68 00 26 13 00 push $0x132600 10d044: e8 c3 0d 00 00 call 10de0c <_Objects_Close> RTEMS_INLINE_ROUTINE void _Extension_Free ( Extension_Control *the_extension ) { _Objects_Free( &_Extension_Information, &the_extension->Object ); 10d049: 58 pop %eax 10d04a: 5a pop %edx 10d04b: 53 push %ebx 10d04c: 68 00 26 13 00 push $0x132600 10d051: e8 b2 10 00 00 call 10e108 <_Objects_Free> _Extension_Free( the_extension ); _Thread_Enable_dispatch(); 10d056: e8 a1 1c 00 00 call 10ecfc <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10d05b: 83 c4 10 add $0x10,%esp 10d05e: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10d060: 8b 5d fc mov -0x4(%ebp),%ebx 10d063: c9 leave 10d064: c3 ret 10d065: 8d 76 00 lea 0x0(%esi),%esi #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10d068: b8 04 00 00 00 mov $0x4,%eax } 10d06d: 8b 5d fc mov -0x4(%ebp),%ebx 10d070: c9 leave 10d071: 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 =============================================================================== 0011007c : rtems_filesystem_fsmount_me_t rtems_filesystem_get_mount_handler( const char *type ) { 11007c: 55 push %ebp 11007d: 89 e5 mov %esp,%ebp 11007f: 83 ec 18 sub $0x18,%esp 110082: 8b 45 08 mov 0x8(%ebp),%eax find_arg fa = { 110085: 89 45 f0 mov %eax,-0x10(%ebp) 110088: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) .type = type, .mount_h = NULL }; if ( type != NULL ) { 11008f: 85 c0 test %eax,%eax 110091: 74 19 je 1100ac <== NEVER TAKEN rtems_filesystem_iterate( find_handler, &fa ); 110093: 83 ec 08 sub $0x8,%esp 110096: 8d 45 f0 lea -0x10(%ebp),%eax 110099: 50 push %eax 11009a: 68 9c ff 10 00 push $0x10ff9c 11009f: e8 34 ff ff ff call 10ffd8 1100a4: 8b 45 f4 mov -0xc(%ebp),%eax 1100a7: 83 c4 10 add $0x10,%esp } return fa.mount_h; } 1100aa: c9 leave 1100ab: c3 ret find_arg fa = { .type = type, .mount_h = NULL }; if ( type != NULL ) { 1100ac: 31 c0 xor %eax,%eax rtems_filesystem_iterate( find_handler, &fa ); } return fa.mount_h; } 1100ae: c9 leave <== NOT EXECUTED 1100af: c3 ret <== NOT EXECUTED =============================================================================== 00110238 : #include "rtems/libio_.h" void rtems_filesystem_get_sym_start_loc(const char *path, int *index, rtems_filesystem_location_info_t *loc) { 110238: 55 push %ebp 110239: 89 e5 mov %esp,%ebp 11023b: 57 push %edi 11023c: 56 push %esi 11023d: 53 push %ebx 11023e: 83 ec 18 sub $0x18,%esp 110241: 8b 5d 0c mov 0xc(%ebp),%ebx if (rtems_filesystem_is_separator(path[0])) { 110244: 8b 45 08 mov 0x8(%ebp),%eax 110247: 0f be 00 movsbl (%eax),%eax 11024a: 50 push %eax 11024b: e8 c8 8c ff ff call 108f18 110250: 83 c4 10 add $0x10,%esp 110253: 85 c0 test %eax,%eax 110255: 75 11 jne 110268 *loc = rtems_filesystem_root; *index = 1; } else { *index = 0; 110257: c7 03 00 00 00 00 movl $0x0,(%ebx) } } 11025d: 8d 65 f4 lea -0xc(%ebp),%esp 110260: 5b pop %ebx 110261: 5e pop %esi 110262: 5f pop %edi 110263: c9 leave 110264: c3 ret 110265: 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; 110268: 8b 35 b0 51 12 00 mov 0x1251b0,%esi 11026e: 83 c6 18 add $0x18,%esi 110271: b9 05 00 00 00 mov $0x5,%ecx 110276: 8b 7d 10 mov 0x10(%ebp),%edi 110279: f3 a5 rep movsl %ds:(%esi),%es:(%edi) *index = 1; 11027b: c7 03 01 00 00 00 movl $0x1,(%ebx) } else { *index = 0; } } 110281: 8d 65 f4 lea -0xc(%ebp),%esp 110284: 5b pop %ebx 110285: 5e pop %esi 110286: 5f pop %edi 110287: c9 leave 110288: 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 b0 51 12 00 mov 0x1251b0,%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 f1 11 00 mov 0x11f120,%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 b4 31 12 00 mov 0x1231b4,%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 b0 51 12 00 mov 0x1251b0,%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 0b 12 00 push $0x120b07 107e9f: e8 24 01 00 00 call 107fc8 rtems_filesystem_root = loc; 107ea4: 8b 3d b0 51 12 00 mov 0x1251b0,%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 0b 12 00 push $0x120b07 107ec5: e8 fe 00 00 00 call 107fc8 rtems_filesystem_current = loc; 107eca: 8b 3d b0 51 12 00 mov 0x1251b0,%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 0b 12 00 push $0x120b09 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 f6 3d 00 00 call 10bd00 <== 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 e9 3d 00 00 call 10bd00 <== 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 dc 3d 00 00 call 10bd00 <== NOT EXECUTED =============================================================================== 0010ffd8 : bool rtems_filesystem_iterate( rtems_per_filesystem_routine routine, void *routine_arg ) { 10ffd8: 55 push %ebp 10ffd9: 89 e5 mov %esp,%ebp 10ffdb: 57 push %edi 10ffdc: 56 push %esi 10ffdd: 53 push %ebx 10ffde: 83 ec 1c sub $0x1c,%esp 10ffe1: 8b 75 08 mov 0x8(%ebp),%esi 10ffe4: 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 ) { 10ffe7: 8b 1d 00 f1 11 00 mov 0x11f100,%ebx 10ffed: 85 db test %ebx,%ebx 10ffef: 74 24 je 110015 <== NEVER TAKEN 10fff1: bb 00 f1 11 00 mov $0x11f100,%ebx 10fff6: eb 04 jmp 10fffc 10fff8: 84 c0 test %al,%al 10fffa: 75 70 jne 11006c stop = (*routine)( table_entry, routine_arg ); 10fffc: 83 ec 08 sub $0x8,%esp 10ffff: 57 push %edi 110000: 53 push %ebx 110001: ff d6 call *%esi 110003: 88 c2 mov %al,%dl ++table_entry; 110005: 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 ) { 110008: 83 c4 10 add $0x10,%esp 11000b: 8b 0b mov (%ebx),%ecx 11000d: 85 c9 test %ecx,%ecx 11000f: 75 e7 jne 10fff8 stop = (*routine)( table_entry, routine_arg ); ++table_entry; } if ( !stop ) { 110011: 84 c0 test %al,%al 110013: 75 57 jne 11006c 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 ); 110015: 50 push %eax 110016: 6a 00 push $0x0 110018: 6a 00 push $0x0 11001a: ff 35 08 74 12 00 pushl 0x127408 110020: e8 8b b6 ff ff call 10b6b0 } } rtems_libio_unlock(); rtems_set_errno_and_return_minus_one( ENOENT ); } 110025: 8b 1d d8 51 12 00 mov 0x1251d8,%ebx ++table_entry; } if ( !stop ) { rtems_libio_lock(); for ( 11002b: 83 c4 10 add $0x10,%esp 11002e: 81 fb dc 51 12 00 cmp $0x1251dc,%ebx 110034: 75 06 jne 11003c 110036: eb 3e jmp 110076 node = rtems_chain_first( &filesystem_chain ); !rtems_chain_is_tail( &filesystem_chain, node ) && !stop; 110038: 84 c0 test %al,%al 11003a: 75 19 jne 110055 <== NEVER TAKEN node = rtems_chain_next( node ) ) { const filesystem_node *fsn = (filesystem_node *) node; stop = (*routine)( &fsn->entry, routine_arg ); 11003c: 83 ec 08 sub $0x8,%esp 11003f: 57 push %edi 110040: 8d 43 08 lea 0x8(%ebx),%eax 110043: 50 push %eax 110044: ff d6 call *%esi 110046: 88 c2 mov %al,%dl } } rtems_libio_unlock(); rtems_set_errno_and_return_minus_one( ENOENT ); } 110048: 8b 1b mov (%ebx),%ebx ++table_entry; } if ( !stop ) { rtems_libio_lock(); for ( 11004a: 83 c4 10 add $0x10,%esp 11004d: 81 fb dc 51 12 00 cmp $0x1251dc,%ebx 110053: 75 e3 jne 110038 } static inline void rtems_libio_unlock( void ) { rtems_semaphore_release( rtems_libio_semaphore ); 110055: 83 ec 0c sub $0xc,%esp 110058: ff 35 08 74 12 00 pushl 0x127408 11005e: 88 55 e4 mov %dl,-0x1c(%ebp) 110061: e8 46 b7 ff ff call 10b7ac 110066: 83 c4 10 add $0x10,%esp 110069: 8a 55 e4 mov -0x1c(%ebp),%dl } rtems_libio_unlock(); } return stop; } 11006c: 88 d0 mov %dl,%al 11006e: 8d 65 f4 lea -0xc(%ebp),%esp 110071: 5b pop %ebx 110072: 5e pop %esi 110073: 5f pop %edi 110074: c9 leave 110075: c3 ret ++table_entry; } if ( !stop ) { rtems_libio_lock(); for ( 110076: 31 d2 xor %edx,%edx 110078: eb db jmp 110055 =============================================================================== 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 08 74 12 00 pushl 0x127408 10851d: e8 8e 31 00 00 call 10b6b0 stop = (*routine)( mt_entry, routine_arg ); } rtems_libio_unlock(); return stop; } 108522: 8b 1d 84 50 12 00 mov 0x125084,%ebx { rtems_chain_node *node = NULL; bool stop = false; rtems_libio_lock(); for ( 108528: 83 c4 10 add $0x10,%esp 10852b: 81 fb 88 50 12 00 cmp $0x125088,%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 88 50 12 00 cmp $0x125088,%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 08 74 12 00 pushl 0x127408 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 =============================================================================== 001100b0 : int rtems_filesystem_register( const char *type, rtems_filesystem_fsmount_me_t mount_h ) { 1100b0: 55 push %ebp 1100b1: 89 e5 mov %esp,%ebp 1100b3: 57 push %edi 1100b4: 56 push %esi 1100b5: 53 push %ebx 1100b6: 83 ec 28 sub $0x28,%esp size_t type_size = strlen(type) + 1; 1100b9: 31 c0 xor %eax,%eax 1100bb: b9 ff ff ff ff mov $0xffffffff,%ecx 1100c0: 8b 7d 08 mov 0x8(%ebp),%edi 1100c3: f2 ae repnz scas %es:(%edi),%al 1100c5: f7 d1 not %ecx size_t fsn_size = sizeof( filesystem_node ) + type_size; 1100c7: 8d 41 10 lea 0x10(%ecx),%eax filesystem_node *fsn = malloc( fsn_size ); 1100ca: 50 push %eax 1100cb: 89 4d e4 mov %ecx,-0x1c(%ebp) 1100ce: e8 b5 82 ff ff call 108388 1100d3: 89 c3 mov %eax,%ebx char *type_storage = (char *) fsn + sizeof( *fsn ); if ( fsn == NULL ) 1100d5: 83 c4 10 add $0x10,%esp 1100d8: 85 c0 test %eax,%eax 1100da: 8b 4d e4 mov -0x1c(%ebp),%ecx 1100dd: 0f 84 8e 00 00 00 je 110171 ) { 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 ); 1100e3: 8d 40 10 lea 0x10(%eax),%eax if ( fsn == NULL ) rtems_set_errno_and_return_minus_one( ENOMEM ); memcpy(type_storage, type, type_size); 1100e6: 89 c7 mov %eax,%edi 1100e8: 8b 75 08 mov 0x8(%ebp),%esi 1100eb: f3 a4 rep movsb %ds:(%esi),%es:(%edi) fsn->entry.type = type_storage; 1100ed: 89 43 08 mov %eax,0x8(%ebx) fsn->entry.mount_h = mount_h; 1100f0: 8b 45 0c mov 0xc(%ebp),%eax 1100f3: 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 ); 1100f6: 50 push %eax 1100f7: 6a 00 push $0x0 1100f9: 6a 00 push $0x0 1100fb: ff 35 08 74 12 00 pushl 0x127408 110101: e8 aa b5 ff ff call 10b6b0 rtems_libio_lock(); if ( rtems_filesystem_get_mount_handler( type ) == NULL ) { 110106: 5f pop %edi 110107: ff 75 08 pushl 0x8(%ebp) 11010a: e8 6d ff ff ff call 11007c 11010f: 83 c4 10 add $0x10,%esp 110112: 85 c0 test %eax,%eax 110114: 75 2a jne 110140 110116: 83 ec 08 sub $0x8,%esp 110119: 53 push %ebx 11011a: 68 d8 51 12 00 push $0x1251d8 11011f: e8 b8 be ff ff call 10bfdc <_Chain_Append> } static inline void rtems_libio_unlock( void ) { rtems_semaphore_release( rtems_libio_semaphore ); 110124: 5e pop %esi 110125: ff 35 08 74 12 00 pushl 0x127408 11012b: e8 7c b6 ff ff call 10b7ac 110130: 83 c4 10 add $0x10,%esp rtems_set_errno_and_return_minus_one( EINVAL ); } rtems_libio_unlock(); return 0; 110133: 31 c0 xor %eax,%eax } 110135: 8d 65 f4 lea -0xc(%ebp),%esp 110138: 5b pop %ebx 110139: 5e pop %esi 11013a: 5f pop %edi 11013b: c9 leave 11013c: c3 ret 11013d: 8d 76 00 lea 0x0(%esi),%esi 110140: 83 ec 0c sub $0xc,%esp 110143: ff 35 08 74 12 00 pushl 0x127408 110149: e8 5e 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 ); 11014e: 89 1c 24 mov %ebx,(%esp) 110151: e8 5e 7f ff ff call 1080b4 rtems_set_errno_and_return_minus_one( EINVAL ); 110156: e8 b9 31 00 00 call 113314 <__errno> 11015b: c7 00 16 00 00 00 movl $0x16,(%eax) 110161: 83 c4 10 add $0x10,%esp 110164: b8 ff ff ff ff mov $0xffffffff,%eax } rtems_libio_unlock(); return 0; } 110169: 8d 65 f4 lea -0xc(%ebp),%esp 11016c: 5b pop %ebx 11016d: 5e pop %esi 11016e: 5f pop %edi 11016f: c9 leave 110170: 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 ); 110171: e8 9e 31 00 00 call 113314 <__errno> 110176: c7 00 0c 00 00 00 movl $0xc,(%eax) 11017c: b8 ff ff ff ff mov $0xffffffff,%eax 110181: eb b2 jmp 110135 =============================================================================== 00110184 : int rtems_filesystem_unregister( const char *type ) { 110184: 55 push %ebp 110185: 89 e5 mov %esp,%ebp 110187: 56 push %esi 110188: 53 push %ebx 110189: 8b 75 08 mov 0x8(%ebp),%esi rtems_chain_node *node = NULL; if ( type == NULL ) { 11018c: 85 f6 test %esi,%esi 11018e: 0f 84 94 00 00 00 je 110228 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 ); 110194: 51 push %ecx 110195: 6a 00 push $0x0 110197: 6a 00 push $0x0 110199: ff 35 08 74 12 00 pushl 0x127408 11019f: e8 0c b5 ff ff call 10b6b0 } } rtems_libio_unlock(); rtems_set_errno_and_return_minus_one( ENOENT ); } 1101a4: 8b 1d d8 51 12 00 mov 0x1251d8,%ebx if ( type == NULL ) { rtems_set_errno_and_return_minus_one( EINVAL ); } rtems_libio_lock(); for ( 1101aa: 83 c4 10 add $0x10,%esp 1101ad: 81 fb dc 51 12 00 cmp $0x1251dc,%ebx 1101b3: 75 0d jne 1101c2 1101b5: eb 49 jmp 110200 1101b7: 90 nop } } rtems_libio_unlock(); rtems_set_errno_and_return_minus_one( ENOENT ); } 1101b8: 8b 1b mov (%ebx),%ebx if ( type == NULL ) { rtems_set_errno_and_return_minus_one( EINVAL ); } rtems_libio_lock(); for ( 1101ba: 81 fb dc 51 12 00 cmp $0x1251dc,%ebx 1101c0: 74 3e je 110200 <== 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 ) { 1101c2: 83 ec 08 sub $0x8,%esp 1101c5: 56 push %esi 1101c6: ff 73 08 pushl 0x8(%ebx) 1101c9: e8 be 3d 00 00 call 113f8c 1101ce: 83 c4 10 add $0x10,%esp 1101d1: 85 c0 test %eax,%eax 1101d3: 75 e3 jne 1101b8 */ RTEMS_INLINE_ROUTINE void rtems_chain_extract( rtems_chain_node *the_node ) { _Chain_Extract( the_node ); 1101d5: 83 ec 0c sub $0xc,%esp 1101d8: 53 push %ebx 1101d9: e8 22 be ff ff call 10c000 <_Chain_Extract> rtems_chain_extract( node ); free( fsn ); 1101de: 89 1c 24 mov %ebx,(%esp) 1101e1: e8 ce 7e ff ff call 1080b4 } static inline void rtems_libio_unlock( void ) { rtems_semaphore_release( rtems_libio_semaphore ); 1101e6: 5a pop %edx 1101e7: ff 35 08 74 12 00 pushl 0x127408 1101ed: e8 ba b5 ff ff call 10b7ac 1101f2: 83 c4 10 add $0x10,%esp rtems_libio_unlock(); return 0; 1101f5: 31 c0 xor %eax,%eax } } rtems_libio_unlock(); rtems_set_errno_and_return_minus_one( ENOENT ); } 1101f7: 8d 65 f8 lea -0x8(%ebp),%esp 1101fa: 5b pop %ebx 1101fb: 5e pop %esi 1101fc: c9 leave 1101fd: c3 ret 1101fe: 66 90 xchg %ax,%ax 110200: 83 ec 0c sub $0xc,%esp 110203: ff 35 08 74 12 00 pushl 0x127408 110209: e8 9e b5 ff ff call 10b7ac return 0; } } rtems_libio_unlock(); rtems_set_errno_and_return_minus_one( ENOENT ); 11020e: e8 01 31 00 00 call 113314 <__errno> 110213: c7 00 02 00 00 00 movl $0x2,(%eax) 110219: 83 c4 10 add $0x10,%esp 11021c: b8 ff ff ff ff mov $0xffffffff,%eax } 110221: 8d 65 f8 lea -0x8(%ebp),%esp 110224: 5b pop %ebx 110225: 5e pop %esi 110226: c9 leave 110227: c3 ret ) { rtems_chain_node *node = NULL; if ( type == NULL ) { rtems_set_errno_and_return_minus_one( EINVAL ); 110228: e8 e7 30 00 00 call 113314 <__errno> 11022d: c7 00 16 00 00 00 movl $0x16,(%eax) 110233: 83 c8 ff or $0xffffffff,%eax 110236: eb e9 jmp 110221 =============================================================================== 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 20 e0 12 00 03 cmpl $0x3,0x12e020 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 58 91 12 00 pushl 0x129158 10bc5b: e8 0c 4e 00 00 call 110a6c <_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 =============================================================================== 00112ff8 : rtems_status_code rtems_io_close( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 112ff8: 55 push %ebp 112ff9: 89 e5 mov %esp,%ebp 112ffb: 53 push %ebx 112ffc: 83 ec 04 sub $0x4,%esp 112fff: 8b 45 08 mov 0x8(%ebp),%eax rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 113002: 39 05 20 80 12 00 cmp %eax,0x128020 113008: 76 1a jbe 113024 return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].close_entry; 11300a: 8d 14 40 lea (%eax,%eax,2),%edx 11300d: c1 e2 03 shl $0x3,%edx 113010: 03 15 24 80 12 00 add 0x128024,%edx 113016: 8b 52 08 mov 0x8(%edx),%edx return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 113019: 85 d2 test %edx,%edx 11301b: 74 13 je 113030 } 11301d: 59 pop %ecx 11301e: 5b pop %ebx 11301f: 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; 113020: ff e2 jmp *%edx 113022: 66 90 xchg %ax,%ax ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; 113024: b8 0a 00 00 00 mov $0xa,%eax callout = _IO_Driver_address_table[major].close_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; } 113029: 5a pop %edx 11302a: 5b pop %ebx 11302b: c9 leave 11302c: c3 ret 11302d: 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; 113030: 31 c0 xor %eax,%eax } 113032: 5a pop %edx 113033: 5b pop %ebx 113034: c9 leave 113035: c3 ret =============================================================================== 00113038 : rtems_status_code rtems_io_control( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 113038: 55 push %ebp 113039: 89 e5 mov %esp,%ebp 11303b: 53 push %ebx 11303c: 83 ec 04 sub $0x4,%esp 11303f: 8b 45 08 mov 0x8(%ebp),%eax rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 113042: 39 05 20 80 12 00 cmp %eax,0x128020 113048: 76 1a jbe 113064 return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].control_entry; 11304a: 8d 14 40 lea (%eax,%eax,2),%edx 11304d: c1 e2 03 shl $0x3,%edx 113050: 03 15 24 80 12 00 add 0x128024,%edx 113056: 8b 52 14 mov 0x14(%edx),%edx return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 113059: 85 d2 test %edx,%edx 11305b: 74 13 je 113070 } 11305d: 59 pop %ecx 11305e: 5b pop %ebx 11305f: 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; 113060: ff e2 jmp *%edx 113062: 66 90 xchg %ax,%ax ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; 113064: b8 0a 00 00 00 mov $0xa,%eax callout = _IO_Driver_address_table[major].control_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; } 113069: 5a pop %edx 11306a: 5b pop %ebx 11306b: c9 leave 11306c: c3 ret 11306d: 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; 113070: 31 c0 xor %eax,%eax } 113072: 5a pop %edx 113073: 5b pop %ebx 113074: c9 leave 113075: c3 ret =============================================================================== 00111014 : rtems_status_code rtems_io_initialize( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 111014: 55 push %ebp 111015: 89 e5 mov %esp,%ebp 111017: 53 push %ebx 111018: 83 ec 04 sub $0x4,%esp 11101b: 8b 45 08 mov 0x8(%ebp),%eax rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 11101e: 39 05 20 80 12 00 cmp %eax,0x128020 111024: 76 1a jbe 111040 return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].initialization_entry; 111026: 8d 14 40 lea (%eax,%eax,2),%edx 111029: c1 e2 03 shl $0x3,%edx 11102c: 03 15 24 80 12 00 add 0x128024,%edx 111032: 8b 12 mov (%edx),%edx return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 111034: 85 d2 test %edx,%edx 111036: 74 14 je 11104c } 111038: 59 pop %ecx 111039: 5b pop %ebx 11103a: 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; 11103b: ff e2 jmp *%edx 11103d: 8d 76 00 lea 0x0(%esi),%esi ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; 111040: b8 0a 00 00 00 mov $0xa,%eax callout = _IO_Driver_address_table[major].initialization_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; } 111045: 5a pop %edx 111046: 5b pop %ebx 111047: c9 leave 111048: c3 ret 111049: 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; 11104c: 31 c0 xor %eax,%eax } 11104e: 5a pop %edx 11104f: 5b pop %ebx 111050: c9 leave 111051: 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 =============================================================================== 00113078 : rtems_status_code rtems_io_open( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 113078: 55 push %ebp 113079: 89 e5 mov %esp,%ebp 11307b: 53 push %ebx 11307c: 83 ec 04 sub $0x4,%esp 11307f: 8b 45 08 mov 0x8(%ebp),%eax rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 113082: 39 05 20 80 12 00 cmp %eax,0x128020 113088: 76 1a jbe 1130a4 return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].open_entry; 11308a: 8d 14 40 lea (%eax,%eax,2),%edx 11308d: c1 e2 03 shl $0x3,%edx 113090: 03 15 24 80 12 00 add 0x128024,%edx 113096: 8b 52 04 mov 0x4(%edx),%edx return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 113099: 85 d2 test %edx,%edx 11309b: 74 13 je 1130b0 } 11309d: 59 pop %ecx 11309e: 5b pop %ebx 11309f: 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; 1130a0: ff e2 jmp *%edx 1130a2: 66 90 xchg %ax,%ax ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; 1130a4: b8 0a 00 00 00 mov $0xa,%eax callout = _IO_Driver_address_table[major].open_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; } 1130a9: 5a pop %edx 1130aa: 5b pop %ebx 1130ab: c9 leave 1130ac: c3 ret 1130ad: 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; 1130b0: 31 c0 xor %eax,%eax } 1130b2: 5a pop %edx 1130b3: 5b pop %ebx 1130b4: c9 leave 1130b5: c3 ret =============================================================================== 001130b8 : rtems_status_code rtems_io_read( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 1130b8: 55 push %ebp 1130b9: 89 e5 mov %esp,%ebp 1130bb: 53 push %ebx 1130bc: 83 ec 04 sub $0x4,%esp 1130bf: 8b 45 08 mov 0x8(%ebp),%eax rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 1130c2: 39 05 20 80 12 00 cmp %eax,0x128020 1130c8: 76 1a jbe 1130e4 return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].read_entry; 1130ca: 8d 14 40 lea (%eax,%eax,2),%edx 1130cd: c1 e2 03 shl $0x3,%edx 1130d0: 03 15 24 80 12 00 add 0x128024,%edx 1130d6: 8b 52 0c mov 0xc(%edx),%edx return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 1130d9: 85 d2 test %edx,%edx 1130db: 74 13 je 1130f0 } 1130dd: 59 pop %ecx 1130de: 5b pop %ebx 1130df: 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; 1130e0: ff e2 jmp *%edx 1130e2: 66 90 xchg %ax,%ax ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; 1130e4: b8 0a 00 00 00 mov $0xa,%eax callout = _IO_Driver_address_table[major].read_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; } 1130e9: 5a pop %edx 1130ea: 5b pop %ebx 1130eb: c9 leave 1130ec: c3 ret 1130ed: 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; 1130f0: 31 c0 xor %eax,%eax } 1130f2: 5a pop %edx 1130f3: 5b pop %ebx 1130f4: c9 leave 1130f5: c3 ret =============================================================================== 0010cecc : 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 ) { 10cecc: 55 push %ebp 10cecd: 89 e5 mov %esp,%ebp 10cecf: 57 push %edi 10ced0: 56 push %esi 10ced1: 53 push %ebx 10ced2: 83 ec 0c sub $0xc,%esp 10ced5: 8b 5d 08 mov 0x8(%ebp),%ebx 10ced8: 8b 75 0c mov 0xc(%ebp),%esi 10cedb: 8b 55 10 mov 0x10(%ebp),%edx rtems_device_major_number major_limit = _IO_Number_of_drivers; 10cede: a1 00 bd 12 00 mov 0x12bd00,%eax if ( rtems_interrupt_is_in_progress() ) 10cee3: 8b 0d 34 b8 12 00 mov 0x12b834,%ecx 10cee9: 85 c9 test %ecx,%ecx 10ceeb: 0f 85 ab 00 00 00 jne 10cf9c return RTEMS_CALLED_FROM_ISR; if ( registered_major == NULL ) 10cef1: 85 d2 test %edx,%edx 10cef3: 0f 84 e7 00 00 00 je 10cfe0 return RTEMS_INVALID_ADDRESS; /* Set it to an invalid value */ *registered_major = major_limit; 10cef9: 89 02 mov %eax,(%edx) if ( driver_table == NULL ) 10cefb: 85 f6 test %esi,%esi 10cefd: 0f 84 dd 00 00 00 je 10cfe0 static inline bool rtems_io_is_empty_table( const rtems_driver_address_table *table ) { return table->initialization_entry == NULL && table->open_entry == NULL; 10cf03: 8b 3e mov (%esi),%edi 10cf05: 85 ff test %edi,%edi 10cf07: 0f 84 c7 00 00 00 je 10cfd4 return RTEMS_INVALID_ADDRESS; if ( rtems_io_is_empty_table( driver_table ) ) return RTEMS_INVALID_ADDRESS; if ( major >= major_limit ) 10cf0d: 39 d8 cmp %ebx,%eax 10cf0f: 76 7b jbe 10cf8c rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10cf11: a1 50 b2 12 00 mov 0x12b250,%eax 10cf16: 40 inc %eax 10cf17: a3 50 b2 12 00 mov %eax,0x12b250 return RTEMS_INVALID_NUMBER; _Thread_Disable_dispatch(); if ( major == 0 ) { 10cf1c: 85 db test %ebx,%ebx 10cf1e: 0f 85 88 00 00 00 jne 10cfac static rtems_status_code rtems_io_obtain_major_number( rtems_device_major_number *major ) { rtems_device_major_number n = _IO_Number_of_drivers; 10cf24: 8b 0d 00 bd 12 00 mov 0x12bd00,%ecx rtems_device_major_number m = 0; /* major is error checked by caller */ for ( m = 0; m < n; ++m ) { 10cf2a: 85 c9 test %ecx,%ecx 10cf2c: 0f 84 bb 00 00 00 je 10cfed <== NEVER TAKEN 10cf32: 8b 3d 04 bd 12 00 mov 0x12bd04,%edi 10cf38: 89 f8 mov %edi,%eax 10cf3a: eb 08 jmp 10cf44 10cf3c: 43 inc %ebx 10cf3d: 83 c0 18 add $0x18,%eax 10cf40: 39 d9 cmp %ebx,%ecx 10cf42: 76 0b jbe 10cf4f static inline bool rtems_io_is_empty_table( const rtems_driver_address_table *table ) { return table->initialization_entry == NULL && table->open_entry == NULL; 10cf44: 83 38 00 cmpl $0x0,(%eax) 10cf47: 75 f3 jne 10cf3c 10cf49: 83 78 04 00 cmpl $0x0,0x4(%eax) 10cf4d: 75 ed jne 10cf3c if ( rtems_io_is_empty_table( table ) ) break; } /* Assigns invalid value in case of failure */ *major = m; 10cf4f: 89 1a mov %ebx,(%edx) if ( m != n ) 10cf51: 39 d9 cmp %ebx,%ecx 10cf53: 0f 84 9b 00 00 00 je 10cff4 10cf59: 8d 04 5b lea (%ebx,%ebx,2),%eax 10cf5c: c1 e0 03 shl $0x3,%eax } *registered_major = major; } _IO_Driver_address_table [major] = *driver_table; 10cf5f: 01 c7 add %eax,%edi 10cf61: b9 06 00 00 00 mov $0x6,%ecx 10cf66: f3 a5 rep movsl %ds:(%esi),%es:(%edi) _Thread_Enable_dispatch(); 10cf68: e8 a3 1c 00 00 call 10ec10 <_Thread_Enable_dispatch> return rtems_io_initialize( major, 0, NULL ); 10cf6d: c7 45 10 00 00 00 00 movl $0x0,0x10(%ebp) 10cf74: c7 45 0c 00 00 00 00 movl $0x0,0xc(%ebp) 10cf7b: 89 5d 08 mov %ebx,0x8(%ebp) } 10cf7e: 83 c4 0c add $0xc,%esp 10cf81: 5b pop %ebx 10cf82: 5e pop %esi 10cf83: 5f pop %edi 10cf84: c9 leave _IO_Driver_address_table [major] = *driver_table; _Thread_Enable_dispatch(); return rtems_io_initialize( major, 0, NULL ); 10cf85: e9 36 7e 00 00 jmp 114dc0 10cf8a: 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; 10cf8c: 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 ); } 10cf91: 83 c4 0c add $0xc,%esp 10cf94: 5b pop %ebx 10cf95: 5e pop %esi 10cf96: 5f pop %edi 10cf97: c9 leave 10cf98: c3 ret 10cf99: 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; 10cf9c: 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 ); } 10cfa1: 83 c4 0c add $0xc,%esp 10cfa4: 5b pop %ebx 10cfa5: 5e pop %esi 10cfa6: 5f pop %edi 10cfa7: c9 leave 10cfa8: c3 ret 10cfa9: 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; 10cfac: 8d 04 5b lea (%ebx,%ebx,2),%eax 10cfaf: c1 e0 03 shl $0x3,%eax 10cfb2: 8b 0d 04 bd 12 00 mov 0x12bd04,%ecx 10cfb8: 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; 10cfba: 8b 39 mov (%ecx),%edi 10cfbc: 85 ff test %edi,%edi 10cfbe: 74 40 je 10d000 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(); 10cfc0: e8 4b 1c 00 00 call 10ec10 <_Thread_Enable_dispatch> return RTEMS_RESOURCE_IN_USE; 10cfc5: 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 ); } 10cfca: 83 c4 0c add $0xc,%esp 10cfcd: 5b pop %ebx 10cfce: 5e pop %esi 10cfcf: 5f pop %edi 10cfd0: c9 leave 10cfd1: c3 ret 10cfd2: 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; 10cfd4: 8b 4e 04 mov 0x4(%esi),%ecx 10cfd7: 85 c9 test %ecx,%ecx 10cfd9: 0f 85 2e ff ff ff jne 10cf0d 10cfdf: 90 nop if ( driver_table == NULL ) return RTEMS_INVALID_ADDRESS; if ( rtems_io_is_empty_table( driver_table ) ) return RTEMS_INVALID_ADDRESS; 10cfe0: 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 ); } 10cfe5: 83 c4 0c add $0xc,%esp 10cfe8: 5b pop %ebx 10cfe9: 5e pop %esi 10cfea: 5f pop %edi 10cfeb: c9 leave 10cfec: c3 ret if ( rtems_io_is_empty_table( table ) ) break; } /* Assigns invalid value in case of failure */ *major = m; 10cfed: c7 02 00 00 00 00 movl $0x0,(%edx) 10cff3: 90 nop if ( major == 0 ) { rtems_status_code sc = rtems_io_obtain_major_number( registered_major ); if ( sc != RTEMS_SUCCESSFUL ) { _Thread_Enable_dispatch(); 10cff4: e8 17 1c 00 00 call 10ec10 <_Thread_Enable_dispatch> *major = m; if ( m != n ) return RTEMS_SUCCESSFUL; return RTEMS_TOO_MANY; 10cff9: 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; 10cffe: eb 91 jmp 10cf91 static inline bool rtems_io_is_empty_table( const rtems_driver_address_table *table ) { return table->initialization_entry == NULL && table->open_entry == NULL; 10d000: 8b 49 04 mov 0x4(%ecx),%ecx 10d003: 85 c9 test %ecx,%ecx 10d005: 75 b9 jne 10cfc0 if ( !rtems_io_is_empty_table( table ) ) { _Thread_Enable_dispatch(); return RTEMS_RESOURCE_IN_USE; } *registered_major = major; 10d007: 89 1a mov %ebx,(%edx) 10d009: 8b 3d 04 bd 12 00 mov 0x12bd04,%edi 10d00f: e9 4b ff ff ff jmp 10cf5f =============================================================================== 0010d014 : */ rtems_status_code rtems_io_unregister_driver( rtems_device_major_number major ) { 10d014: 55 push %ebp 10d015: 89 e5 mov %esp,%ebp 10d017: 57 push %edi 10d018: 83 ec 04 sub $0x4,%esp 10d01b: 8b 45 08 mov 0x8(%ebp),%eax if ( rtems_interrupt_is_in_progress() ) 10d01e: 8b 0d 34 b8 12 00 mov 0x12b834,%ecx 10d024: 85 c9 test %ecx,%ecx 10d026: 75 44 jne 10d06c return RTEMS_CALLED_FROM_ISR; if ( major < _IO_Number_of_drivers ) { 10d028: 39 05 00 bd 12 00 cmp %eax,0x12bd00 10d02e: 77 0c ja 10d03c _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_UNSATISFIED; 10d030: b8 0d 00 00 00 mov $0xd,%eax } 10d035: 5a pop %edx 10d036: 5f pop %edi 10d037: c9 leave 10d038: c3 ret 10d039: 8d 76 00 lea 0x0(%esi),%esi 10d03c: 8b 15 50 b2 12 00 mov 0x12b250,%edx 10d042: 42 inc %edx 10d043: 89 15 50 b2 12 00 mov %edx,0x12b250 return RTEMS_CALLED_FROM_ISR; if ( major < _IO_Number_of_drivers ) { _Thread_Disable_dispatch(); memset( &_IO_Driver_address_table[major], 10d049: 8d 14 40 lea (%eax,%eax,2),%edx 10d04c: 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( 10d04f: 03 15 04 bd 12 00 add 0x12bd04,%edx 10d055: b9 18 00 00 00 mov $0x18,%ecx 10d05a: 31 c0 xor %eax,%eax 10d05c: 89 d7 mov %edx,%edi 10d05e: f3 aa rep stos %al,%es:(%edi) &_IO_Driver_address_table[major], 0, sizeof( rtems_driver_address_table ) ); _Thread_Enable_dispatch(); 10d060: e8 ab 1b 00 00 call 10ec10 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10d065: 31 c0 xor %eax,%eax } return RTEMS_UNSATISFIED; } 10d067: 5a pop %edx 10d068: 5f pop %edi 10d069: c9 leave 10d06a: c3 ret 10d06b: 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; 10d06c: b8 12 00 00 00 mov $0x12,%eax return RTEMS_SUCCESSFUL; } return RTEMS_UNSATISFIED; } 10d071: 5a pop %edx 10d072: 5f pop %edi 10d073: c9 leave 10d074: c3 ret =============================================================================== 001130f8 : rtems_status_code rtems_io_write( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 1130f8: 55 push %ebp 1130f9: 89 e5 mov %esp,%ebp 1130fb: 53 push %ebx 1130fc: 83 ec 04 sub $0x4,%esp 1130ff: 8b 45 08 mov 0x8(%ebp),%eax rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 113102: 39 05 20 80 12 00 cmp %eax,0x128020 113108: 76 1a jbe 113124 return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].write_entry; 11310a: 8d 14 40 lea (%eax,%eax,2),%edx 11310d: c1 e2 03 shl $0x3,%edx 113110: 03 15 24 80 12 00 add 0x128024,%edx 113116: 8b 52 10 mov 0x10(%edx),%edx return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 113119: 85 d2 test %edx,%edx 11311b: 74 13 je 113130 } 11311d: 59 pop %ecx 11311e: 5b pop %ebx 11311f: 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; 113120: ff e2 jmp *%edx 113122: 66 90 xchg %ax,%ax ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; 113124: b8 0a 00 00 00 mov $0xa,%eax callout = _IO_Driver_address_table[major].write_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; } 113129: 5a pop %edx 11312a: 5b pop %ebx 11312b: c9 leave 11312c: c3 ret 11312d: 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; 113130: 31 c0 xor %eax,%eax } 113132: 5a pop %edx 113133: 5b pop %ebx 113134: c9 leave 113135: c3 ret =============================================================================== 0010dfbc : #include #include void rtems_iterate_over_all_threads(rtems_per_thread_routine routine) { 10dfbc: 55 push %ebp 10dfbd: 89 e5 mov %esp,%ebp 10dfbf: 57 push %edi 10dfc0: 56 push %esi 10dfc1: 53 push %ebx 10dfc2: 83 ec 1c sub $0x1c,%esp 10dfc5: 8b 7d 08 mov 0x8(%ebp),%edi uint32_t i; uint32_t api_index; Thread_Control *the_thread; Objects_Information *information; if ( !routine ) 10dfc8: 85 ff test %edi,%edi 10dfca: 74 49 je 10e015 <== NEVER TAKEN 10dfcc: 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 ]; 10dfd3: 8b 55 e4 mov -0x1c(%ebp),%edx 10dfd6: 8b 04 95 48 23 13 00 mov 0x132348(,%edx,4),%eax 10dfdd: 8b 70 04 mov 0x4(%eax),%esi if ( !information ) 10dfe0: 85 f6 test %esi,%esi 10dfe2: 74 28 je 10e00c continue; for ( i=1 ; i <= information->maximum ; i++ ) { 10dfe4: 66 83 7e 10 00 cmpw $0x0,0x10(%esi) 10dfe9: 74 21 je 10e00c 10dfeb: bb 01 00 00 00 mov $0x1,%ebx the_thread = (Thread_Control *)information->local_table[ i ]; 10dff0: 8b 46 1c mov 0x1c(%esi),%eax 10dff3: 8b 04 98 mov (%eax,%ebx,4),%eax if ( !the_thread ) 10dff6: 85 c0 test %eax,%eax 10dff8: 74 09 je 10e003 <== NEVER TAKEN continue; (*routine)(the_thread); 10dffa: 83 ec 0c sub $0xc,%esp 10dffd: 50 push %eax 10dffe: ff d7 call *%edi 10e000: 83 c4 10 add $0x10,%esp information = _Objects_Information_table[ api_index ][ 1 ]; if ( !information ) continue; for ( i=1 ; i <= information->maximum ; i++ ) { 10e003: 43 inc %ebx 10e004: 0f b7 46 10 movzwl 0x10(%esi),%eax 10e008: 39 d8 cmp %ebx,%eax 10e00a: 73 e4 jae 10dff0 Objects_Information *information; if ( !routine ) return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { 10e00c: ff 45 e4 incl -0x1c(%ebp) 10e00f: 83 7d e4 04 cmpl $0x4,-0x1c(%ebp) 10e013: 75 be jne 10dfd3 (*routine)(the_thread); } } } 10e015: 8d 65 f4 lea -0xc(%ebp),%esp 10e018: 5b pop %ebx 10e019: 5e pop %esi 10e01a: 5f pop %edi 10e01b: c9 leave 10e01c: c3 ret =============================================================================== 0010fe7c : */ void rtems_libio_free( rtems_libio_t *iop ) { 10fe7c: 55 push %ebp 10fe7d: 89 e5 mov %esp,%ebp 10fe7f: 53 push %ebx 10fe80: 83 ec 08 sub $0x8,%esp 10fe83: 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 ); 10fe86: 6a 00 push $0x0 10fe88: 6a 00 push $0x0 10fe8a: ff 35 08 74 12 00 pushl 0x127408 10fe90: e8 1b b8 ff ff call 10b6b0 rtems_libio_lock(); if (iop->sem) 10fe95: 8b 43 2c mov 0x2c(%ebx),%eax 10fe98: 83 c4 10 add $0x10,%esp 10fe9b: 85 c0 test %eax,%eax 10fe9d: 74 0c je 10feab <== NEVER TAKEN rtems_semaphore_delete(iop->sem); 10fe9f: 83 ec 0c sub $0xc,%esp 10fea2: 50 push %eax 10fea3: e8 64 b7 ff ff call 10b60c 10fea8: 83 c4 10 add $0x10,%esp iop->flags &= ~LIBIO_FLAGS_OPEN; 10feab: 81 63 14 ff fe ff ff andl $0xfffffeff,0x14(%ebx) iop->data1 = rtems_libio_iop_freelist; 10feb2: a1 04 74 12 00 mov 0x127404,%eax 10feb7: 89 43 34 mov %eax,0x34(%ebx) rtems_libio_iop_freelist = iop; 10feba: 89 1d 04 74 12 00 mov %ebx,0x127404 } static inline void rtems_libio_unlock( void ) { rtems_semaphore_release( rtems_libio_semaphore ); 10fec0: a1 08 74 12 00 mov 0x127408,%eax 10fec5: 89 45 08 mov %eax,0x8(%ebp) rtems_libio_unlock(); } 10fec8: 8b 5d fc mov -0x4(%ebp),%ebx 10fecb: c9 leave 10fecc: e9 db 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 ac 31 12 00 mov 0x1231ac,%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 00 74 12 00 mov %eax,0x127400 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 04 74 12 00 mov %eax,0x127404 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 08 74 12 00 push $0x127408 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 a8 31 12 00 mov 0x1231a8,%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 b2 3a 00 00 call 10bd00 <== 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 a8 3a 00 00 call 10bd00 =============================================================================== 0010ff38 : */ int rtems_libio_is_file_open( void *node_access ) { 10ff38: 55 push %ebp 10ff39: 89 e5 mov %esp,%ebp 10ff3b: 53 push %ebx 10ff3c: 83 ec 08 sub $0x8,%esp 10ff3f: 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 ); 10ff42: 6a 00 push $0x0 10ff44: 6a 00 push $0x0 10ff46: ff 35 08 74 12 00 pushl 0x127408 10ff4c: e8 5f 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++){ 10ff51: a1 00 74 12 00 mov 0x127400,%eax 10ff56: 8b 0d ac 31 12 00 mov 0x1231ac,%ecx 10ff5c: 83 c4 10 add $0x10,%esp 10ff5f: 85 c9 test %ecx,%ecx 10ff61: 74 18 je 10ff7b <== NEVER TAKEN 10ff63: 31 d2 xor %edx,%edx 10ff65: eb 04 jmp 10ff6b 10ff67: 90 nop 10ff68: 83 c0 38 add $0x38,%eax if ((iop->flags & LIBIO_FLAGS_OPEN) != 0) { 10ff6b: f6 40 15 01 testb $0x1,0x15(%eax) 10ff6f: 74 05 je 10ff76 /* * Check if this node is under the file system that we * are trying to dismount. */ if ( iop->pathinfo.node_access == node_access ) { 10ff71: 39 58 18 cmp %ebx,0x18(%eax) 10ff74: 74 1e je 10ff94 /* * Look for any active file descriptor entry. */ for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){ 10ff76: 42 inc %edx 10ff77: 39 ca cmp %ecx,%edx 10ff79: 72 ed jb 10ff68 int rtems_libio_is_file_open( void *node_access ) { rtems_libio_t *iop; int result=0; 10ff7b: 31 db xor %ebx,%ebx } static inline void rtems_libio_unlock( void ) { rtems_semaphore_release( rtems_libio_semaphore ); 10ff7d: 83 ec 0c sub $0xc,%esp 10ff80: ff 35 08 74 12 00 pushl 0x127408 10ff86: e8 21 b8 ff ff call 10b7ac } rtems_libio_unlock(); return result; } 10ff8b: 89 d8 mov %ebx,%eax 10ff8d: 8b 5d fc mov -0x4(%ebp),%ebx 10ff90: c9 leave 10ff91: c3 ret 10ff92: 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; 10ff94: bb 01 00 00 00 mov $0x1,%ebx 10ff99: eb e2 jmp 10ff7d =============================================================================== 0010fed4 : */ int rtems_libio_is_open_files_in_fs( rtems_filesystem_mount_table_entry_t * fs_mt_entry ) { 10fed4: 55 push %ebp 10fed5: 89 e5 mov %esp,%ebp 10fed7: 53 push %ebx 10fed8: 83 ec 08 sub $0x8,%esp 10fedb: 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 ); 10fede: 6a 00 push $0x0 10fee0: 6a 00 push $0x0 10fee2: ff 35 08 74 12 00 pushl 0x127408 10fee8: e8 c3 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++){ 10feed: a1 00 74 12 00 mov 0x127400,%eax 10fef2: 8b 0d ac 31 12 00 mov 0x1231ac,%ecx 10fef8: 83 c4 10 add $0x10,%esp 10fefb: 85 c9 test %ecx,%ecx 10fefd: 74 18 je 10ff17 <== NEVER TAKEN 10feff: 31 d2 xor %edx,%edx 10ff01: eb 04 jmp 10ff07 10ff03: 90 nop 10ff04: 83 c0 38 add $0x38,%eax if ((iop->flags & LIBIO_FLAGS_OPEN) != 0) { 10ff07: f6 40 15 01 testb $0x1,0x15(%eax) 10ff0b: 74 05 je 10ff12 /* * Check if this node is under the file system that we * are trying to dismount. */ if ( iop->pathinfo.mt_entry == fs_mt_entry ) { 10ff0d: 39 58 28 cmp %ebx,0x28(%eax) 10ff10: 74 1e je 10ff30 /* * Look for any active file descriptor entry. */ for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){ 10ff12: 42 inc %edx 10ff13: 39 ca cmp %ecx,%edx 10ff15: 72 ed jb 10ff04 int rtems_libio_is_open_files_in_fs( rtems_filesystem_mount_table_entry_t * fs_mt_entry ) { rtems_libio_t *iop; int result = 0; 10ff17: 31 db xor %ebx,%ebx } static inline void rtems_libio_unlock( void ) { rtems_semaphore_release( rtems_libio_semaphore ); 10ff19: 83 ec 0c sub $0xc,%esp 10ff1c: ff 35 08 74 12 00 pushl 0x127408 10ff22: e8 85 b8 ff ff call 10b7ac } rtems_libio_unlock(); return result; } 10ff27: 89 d8 mov %ebx,%eax 10ff29: 8b 5d fc mov -0x4(%ebp),%ebx 10ff2c: c9 leave 10ff2d: c3 ret 10ff2e: 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; 10ff30: bb 01 00 00 00 mov $0x1,%ebx 10ff35: eb e2 jmp 10ff19 =============================================================================== 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 27 14 12 00 push $0x121427 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 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 27 14 12 00 push $0x121427 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 b0 5a 12 00 mov 0x125ab0,%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 60 7d 12 00 cmp $0x127d60,%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 b0 5a 12 00 push $0x125ab0 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 b0 5a 12 00 mov %edx,0x125ab0 } /* Inherit the global values */ *rtems_current_user_env = rtems_global_user_env; 109640: be 60 7d 12 00 mov $0x127d60,%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 b0 5a 12 00 push $0x125ab0 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 b0 5a 12 00 mov 0x125ab0,%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 b0 5a 12 00 mov %edx,0x125ab0 #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 =============================================================================== 0010fd94 : */ uint32_t rtems_libio_to_fcntl_flags( uint32_t flags ) { 10fd94: 55 push %ebp 10fd95: 89 e5 mov %esp,%ebp 10fd97: 8b 55 08 mov 0x8(%ebp),%edx uint32_t fcntl_flags = 0; if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) { 10fd9a: 89 d0 mov %edx,%eax 10fd9c: 83 e0 06 and $0x6,%eax 10fd9f: 83 f8 06 cmp $0x6,%eax 10fda2: 74 2c je 10fdd0 fcntl_flags |= O_RDWR; } else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) { 10fda4: f6 c2 02 test $0x2,%dl 10fda7: 75 23 jne 10fdcc <== ALWAYS TAKEN ) { uint32_t fcntl_flags = 0; if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) { fcntl_flags |= O_RDWR; 10fda9: 31 c0 xor %eax,%eax 10fdab: f6 c2 04 test $0x4,%dl <== NOT EXECUTED 10fdae: 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 ) { 10fdb1: f6 c2 01 test $0x1,%dl 10fdb4: 74 03 je 10fdb9 fcntl_flags |= O_NONBLOCK; 10fdb6: 80 cc 40 or $0x40,%ah } if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) { 10fdb9: f6 c6 02 test $0x2,%dh 10fdbc: 74 03 je 10fdc1 fcntl_flags |= O_APPEND; 10fdbe: 83 c8 08 or $0x8,%eax } if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) { 10fdc1: 80 e6 04 and $0x4,%dh 10fdc4: 74 03 je 10fdc9 fcntl_flags |= O_CREAT; 10fdc6: 80 cc 02 or $0x2,%ah } return fcntl_flags; } 10fdc9: c9 leave 10fdca: c3 ret 10fdcb: 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; 10fdcc: 31 c0 xor %eax,%eax 10fdce: eb e1 jmp 10fdb1 ) { uint32_t fcntl_flags = 0; if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) { fcntl_flags |= O_RDWR; 10fdd0: b8 02 00 00 00 mov $0x2,%eax 10fdd5: eb da jmp 10fdb1 =============================================================================== 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 58 91 12 00 pushl 0x129158 10af23: e8 ec 5b 00 00 call 110b14 <_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 24 dd 12 00 add %eax,0x12dd24 10af3a: 11 15 28 dd 12 00 adc %edx,0x12dd28 } } 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 58 91 12 00 pushl 0x129158 10af64: e8 ab 5b 00 00 call 110b14 <_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 1c dd 12 00 add 0x12dd1c,%eax 10af74: 13 15 20 dd 12 00 adc 0x12dd20,%edx 10af7a: a3 1c dd 12 00 mov %eax,0x12dd1c 10af7f: 89 15 20 dd 12 00 mov %edx,0x12dd20 current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed); 10af85: 2b 05 24 dd 12 00 sub 0x12dd24,%eax if (current_depth > s->max_depth) 10af8b: 83 c4 10 add $0x10,%esp 10af8e: 3b 05 18 dd 12 00 cmp 0x12dd18,%eax 10af94: 76 05 jbe 10af9b s->max_depth = current_depth; 10af96: a3 18 dd 12 00 mov %eax,0x12dd18 } 10af9b: c9 leave 10af9c: c3 ret =============================================================================== 00113d98 : int rtems_memalign( void **pointer, size_t alignment, size_t size ) { 113d98: 55 push %ebp 113d99: 89 e5 mov %esp,%ebp 113d9b: 53 push %ebx 113d9c: 83 ec 14 sub $0x14,%esp 113d9f: 8b 5d 08 mov 0x8(%ebp),%ebx void *return_this; /* * Parameter error checks */ if ( !pointer ) 113da2: 85 db test %ebx,%ebx 113da4: 74 5b je 113e01 return EINVAL; *pointer = NULL; 113da6: 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()) && 113dac: 83 3d 20 b4 12 00 03 cmpl $0x3,0x12b420 113db3: 74 43 je 113df8 <== ALWAYS TAKEN return EINVAL; /* * If some free's have been deferred, then do them now. */ malloc_deferred_frees_process(); 113db5: e8 a6 53 ff ff call 109160 Heap_Control *heap, uintptr_t size, uintptr_t alignment ) { return 113dba: 6a 00 push $0x0 113dbc: ff 75 0c pushl 0xc(%ebp) 113dbf: ff 75 10 pushl 0x10(%ebp) 113dc2: ff 35 f8 6d 12 00 pushl 0x126df8 113dc8: e8 d7 a5 ff ff call 10e3a4 <_Protected_heap_Allocate_aligned_with_boundary> return_this = _Protected_heap_Allocate_aligned( RTEMS_Malloc_Heap, size, alignment ); if ( !return_this ) 113dcd: 83 c4 10 add $0x10,%esp 113dd0: 85 c0 test %eax,%eax 113dd2: 74 38 je 113e0c return ENOMEM; /* * If configured, update the more involved statistics */ if ( rtems_malloc_statistics_helpers ) 113dd4: 8b 15 08 94 12 00 mov 0x129408,%edx 113dda: 85 d2 test %edx,%edx 113ddc: 74 10 je 113dee (*rtems_malloc_statistics_helpers->at_malloc)(pointer); 113dde: 83 ec 0c sub $0xc,%esp 113de1: 53 push %ebx 113de2: 89 45 f4 mov %eax,-0xc(%ebp) 113de5: ff 52 04 call *0x4(%edx) 113de8: 83 c4 10 add $0x10,%esp 113deb: 8b 45 f4 mov -0xc(%ebp),%eax *pointer = return_this; 113dee: 89 03 mov %eax,(%ebx) return 0; 113df0: 31 c0 xor %eax,%eax } 113df2: 8b 5d fc mov -0x4(%ebp),%ebx 113df5: c9 leave 113df6: c3 ret 113df7: 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() ) 113df8: e8 23 53 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()) && 113dfd: 84 c0 test %al,%al 113dff: 75 b4 jne 113db5 <== ALWAYS TAKEN !malloc_is_system_state_OK() ) return EINVAL; 113e01: 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; } 113e06: 8b 5d fc mov -0x4(%ebp),%ebx 113e09: c9 leave 113e0a: c3 ret 113e0b: 90 nop RTEMS_Malloc_Heap, size, alignment ); if ( !return_this ) return ENOMEM; 113e0c: b8 0c 00 00 00 mov $0xc,%eax 113e11: eb df jmp 113df2 =============================================================================== 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 40 2c 14 00 push $0x142c40 1163e1: e8 fe 4e 00 00 call 11b2e4 <_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 cc 34 00 00 call 1198e0 <_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 7a 59 00 00 call 11bd98 <_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 f0 0b 13 00 mov 0x130bf0,%eax 1138b5: 40 inc %eax 1138b6: a3 f0 0b 13 00 mov %eax,0x130bf0 #endif #endif _Thread_Disable_dispatch(); /* protects object pointer */ the_message_queue = _Message_queue_Allocate(); 1138bb: 89 4d d4 mov %ecx,-0x2c(%ebp) 1138be: e8 d9 5f 00 00 call 11989c <_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 31 11 00 00 call 114a20 <_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 16 13 00 push $0x131620 113902: e8 b9 1f 00 00 call 1158c0 <_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 28 2c 00 00 call 116534 <_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 16 13 00 mov 0x13163c,%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 f3 2b 00 00 call 116534 <_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 e7 2b 00 00 call 116534 <_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 40 2c 14 00 push $0x142c40 116557: e8 88 4d 00 00 call 11b2e4 <_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 40 2c 14 00 push $0x142c40 116571: e8 f6 48 00 00 call 11ae6c <_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 de 33 00 00 call 119964 <_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 40 2c 14 00 push $0x142c40 11658e: e8 d5 4b 00 00 call 11b168 <_Objects_Free> 0, /* Not used */ 0 ); } #endif _Thread_Enable_dispatch(); 116593: e8 00 58 00 00 call 11bd98 <_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 40 2c 14 00 push $0x142c40 1165cb: e8 14 4d 00 00 call 11b2e4 <_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 b0 33 00 00 call 1199a0 <_CORE_message_queue_Flush> 1165f0: 89 03 mov %eax,(%ebx) _Thread_Enable_dispatch(); 1165f2: e8 a1 57 00 00 call 11bd98 <_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 40 2c 14 00 push $0x142c40 11662b: e8 b4 4c 00 00 call 11b2e4 <_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 4a 57 00 00 call 11bd98 <_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 16 13 00 push $0x131620 11399f: e8 5c 20 00 00 call 115a00 <_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 04 11 00 00 call 114ad0 <_CORE_message_queue_Seize> buffer, size, wait, timeout ); _Thread_Enable_dispatch(); 1139cc: 83 c4 20 add $0x20,%esp 1139cf: e8 60 2b 00 00 call 116534 <_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 11 13 00 mov 0x1311d8,%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 a0 7f 12 00 push $0x127fa0 10b3c5: e8 76 1a 00 00 call 10ce40 <_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 43 0c 00 00 call 10c03c <_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 f1 24 00 00 call 10d8f4 <_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 40 2c 14 00 push $0x142c40 1167bd: e8 22 4b 00 00 call 11b2e4 <_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 ef 33 00 00 call 119be0 <_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 9d 55 00 00 call 11bd98 <_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 =============================================================================== 001124ac : return (retval); } int rtems_mkdir(const char *path, mode_t mode) { 1124ac: 55 push %ebp 1124ad: 89 e5 mov %esp,%ebp 1124af: 57 push %edi 1124b0: 56 push %esi 1124b1: 53 push %ebx 1124b2: 83 ec 78 sub $0x78,%esp int success = 0; char *dup_path = strdup(path); 1124b5: ff 75 08 pushl 0x8(%ebp) 1124b8: e8 97 36 00 00 call 115b54 1124bd: 89 c7 mov %eax,%edi if (dup_path != NULL) { 1124bf: 83 c4 10 add $0x10,%esp 1124c2: 85 c0 test %eax,%eax 1124c4: 0f 84 0a 01 00 00 je 1125d4 <== NEVER TAKEN char *p; p = path; oumask = 0; retval = 1; if (p[0] == '/') /* Skip leading '/'. */ 1124ca: 8a 10 mov (%eax),%dl 1124cc: 80 fa 2f cmp $0x2f,%dl 1124cf: 0f 84 0f 01 00 00 je 1125e4 1124d5: 89 c3 mov %eax,%ebx 1124d7: c7 45 94 00 00 00 00 movl $0x0,-0x6c(%ebp) 1124de: b8 01 00 00 00 mov $0x1,%eax ++p; for (first = 1, last = 0; !last ; ++p) { if (p[0] == '\0') 1124e3: 84 d2 test %dl,%dl 1124e5: 74 11 je 1124f8 <== NEVER TAKEN 1124e7: 90 nop last = 1; else if (p[0] != '/') 1124e8: 80 fa 2f cmp $0x2f,%dl 1124eb: 0f 84 83 00 00 00 je 112574 p = path; oumask = 0; retval = 1; if (p[0] == '/') /* Skip leading '/'. */ ++p; for (first = 1, last = 0; !last ; ++p) { 1124f1: 43 inc %ebx 1124f2: 8a 13 mov (%ebx),%dl if (p[0] == '\0') 1124f4: 84 d2 test %dl,%dl 1124f6: 75 f0 jne 1124e8 last = 1; else if (p[0] != '/') continue; *p = '\0'; 1124f8: c6 03 00 movb $0x0,(%ebx) 1124fb: be 01 00 00 00 mov $0x1,%esi if (!last && p[1] == '\0') last = 1; if (first) { 112500: 85 c0 test %eax,%eax 112502: 75 54 jne 112558 oumask = umask(0); numask = oumask & ~(S_IWUSR | S_IXUSR); (void)umask(numask); first = 0; } if (last) 112504: 85 f6 test %esi,%esi 112506: 75 3c jne 112544 (void)umask(oumask); if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) { 112508: b8 ff 01 00 00 mov $0x1ff,%eax 11250d: 83 ec 08 sub $0x8,%esp 112510: 50 push %eax 112511: 57 push %edi 112512: e8 ed 71 ff ff call 109704 112517: 83 c4 10 add $0x10,%esp 11251a: 85 c0 test %eax,%eax 11251c: 78 6a js 112588 } else { retval = 0; break; } } if (!last) 11251e: 85 f6 test %esi,%esi 112520: 75 0a jne 11252c *p = '/'; 112522: c6 03 2f movb $0x2f,(%ebx) 112525: 31 c0 xor %eax,%eax 112527: eb c8 jmp 1124f1 112529: 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); 11252c: 83 ec 0c sub $0xc,%esp 11252f: 57 push %edi 112530: e8 d7 6b ff ff call 10910c 112535: 83 c4 10 add $0x10,%esp } return success != 0 ? 0 : -1; 112538: 31 c0 xor %eax,%eax } 11253a: 8d 65 f4 lea -0xc(%ebp),%esp 11253d: 5b pop %ebx 11253e: 5e pop %esi 11253f: 5f pop %edi 112540: c9 leave 112541: c3 ret 112542: 66 90 xchg %ax,%ax numask = oumask & ~(S_IWUSR | S_IXUSR); (void)umask(numask); first = 0; } if (last) (void)umask(oumask); 112544: 83 ec 0c sub $0xc,%esp 112547: ff 75 94 pushl -0x6c(%ebp) 11254a: e8 81 01 00 00 call 1126d0 11254f: 83 c4 10 add $0x10,%esp if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) { 112552: 8b 45 0c mov 0xc(%ebp),%eax 112555: eb b6 jmp 11250d 112557: 90 nop * mkdir [-m mode] dir * * We change the user's umask and then restore it, * instead of doing chmod's. */ oumask = umask(0); 112558: 83 ec 0c sub $0xc,%esp 11255b: 6a 00 push $0x0 11255d: e8 6e 01 00 00 call 1126d0 112562: 89 45 94 mov %eax,-0x6c(%ebp) numask = oumask & ~(S_IWUSR | S_IXUSR); 112565: 24 3f and $0x3f,%al (void)umask(numask); 112567: 89 04 24 mov %eax,(%esp) 11256a: e8 61 01 00 00 call 1126d0 11256f: 83 c4 10 add $0x10,%esp 112572: eb 90 jmp 112504 for (first = 1, last = 0; !last ; ++p) { if (p[0] == '\0') last = 1; else if (p[0] != '/') continue; *p = '\0'; 112574: c6 03 00 movb $0x0,(%ebx) if (!last && p[1] == '\0') 112577: 31 d2 xor %edx,%edx 112579: 80 7b 01 00 cmpb $0x0,0x1(%ebx) 11257d: 0f 94 c2 sete %dl 112580: 89 d6 mov %edx,%esi 112582: e9 79 ff ff ff jmp 112500 112587: 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) { 112588: e8 3f 29 00 00 call 114ecc <__errno> 11258d: 83 38 11 cmpl $0x11,(%eax) 112590: 74 0a je 11259c 112592: e8 35 29 00 00 call 114ecc <__errno> 112597: 83 38 15 cmpl $0x15,(%eax) 11259a: 75 53 jne 1125ef <== ALWAYS TAKEN if (stat(path, &sb) < 0) { 11259c: 83 ec 08 sub $0x8,%esp 11259f: 8d 45 a0 lea -0x60(%ebp),%eax 1125a2: 50 push %eax 1125a3: 57 push %edi 1125a4: e8 7f 00 00 00 call 112628 1125a9: 83 c4 10 add $0x10,%esp 1125ac: 85 c0 test %eax,%eax 1125ae: 78 3f js 1125ef <== NEVER TAKEN retval = 0; break; } else if (!S_ISDIR(sb.st_mode)) { 1125b0: 8b 45 ac mov -0x54(%ebp),%eax 1125b3: 25 00 f0 00 00 and $0xf000,%eax 1125b8: 3d 00 40 00 00 cmp $0x4000,%eax 1125bd: 0f 84 5b ff ff ff je 11251e if (last) 1125c3: 85 f6 test %esi,%esi 1125c5: 74 53 je 11261a errno = EEXIST; 1125c7: e8 00 29 00 00 call 114ecc <__errno> 1125cc: c7 00 11 00 00 00 movl $0x11,(%eax) 1125d2: eb 2d jmp 112601 if (dup_path != NULL) { success = build(dup_path, mode); free(dup_path); } return success != 0 ? 0 : -1; 1125d4: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED } 1125d9: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1125dc: 5b pop %ebx <== NOT EXECUTED 1125dd: 5e pop %esi <== NOT EXECUTED 1125de: 5f pop %edi <== NOT EXECUTED 1125df: c9 leave <== NOT EXECUTED 1125e0: c3 ret <== NOT EXECUTED 1125e1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED p = path; oumask = 0; retval = 1; if (p[0] == '/') /* Skip leading '/'. */ ++p; 1125e4: 8d 58 01 lea 0x1(%eax),%ebx 1125e7: 8a 50 01 mov 0x1(%eax),%dl 1125ea: e9 e8 fe ff ff jmp 1124d7 } } if (!last) *p = '/'; } if (!first && !last) 1125ef: 85 f6 test %esi,%esi 1125f1: 75 0e jne 112601 <== ALWAYS TAKEN (void)umask(oumask); 1125f3: 83 ec 0c sub $0xc,%esp 1125f6: ff 75 94 pushl -0x6c(%ebp) 1125f9: e8 d2 00 00 00 call 1126d0 1125fe: 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); 112601: 83 ec 0c sub $0xc,%esp 112604: 57 push %edi 112605: e8 02 6b ff ff call 10910c 11260a: 83 c4 10 add $0x10,%esp } return success != 0 ? 0 : -1; 11260d: b8 ff ff ff ff mov $0xffffffff,%eax } 112612: 8d 65 f4 lea -0xc(%ebp),%esp 112615: 5b pop %ebx 112616: 5e pop %esi 112617: 5f pop %edi 112618: c9 leave 112619: c3 ret break; } else if (!S_ISDIR(sb.st_mode)) { if (last) errno = EEXIST; else errno = ENOTDIR; 11261a: e8 ad 28 00 00 call 114ecc <__errno> 11261f: c7 00 14 00 00 00 movl $0x14,(%eax) 112625: eb cc jmp 1125f3 =============================================================================== 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 60 74 12 00 push $0x127460 10b986: e8 b9 49 00 00 call 110344 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 43 24 12 00 mov $0x122443,%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 54 1b 00 00 call 10ead4 <_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 <== NOT EXECUTED 10cfe9: eb d7 jmp 10cfc2 <== NOT EXECUTED =============================================================================== 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 af 1b 00 00 call 10e0ec <_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 2c 30 12 00 mov 0x12302c(,%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 2c 19 00 00 call 10d2f8 <_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 cf 1a 00 00 call 10d4b0 <_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 18 9e 12 00 mov 0x129e18,%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 9f 1c 00 00 call 10d6ac <_Objects_Set_name> _Thread_Enable_dispatch(); 10ba0d: e8 36 26 00 00 call 10e048 <_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 10 22 14 00 mov 0x142210,%eax 116891: 40 inc %eax 116892: a3 10 22 14 00 mov %eax,0x142210 * 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 a0 20 14 00 push $0x1420a0 11689f: 89 55 e0 mov %edx,-0x20(%ebp) 1168a2: e8 49 45 00 00 call 11adf0 <_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 a2 2f 00 00 call 119884 <_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 bc 20 14 00 mov 0x1420bc,%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 97 54 00 00 call 11bd98 <_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 87 54 00 00 call 11bd98 <_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 a0 20 14 00 push $0x1420a0 1169a4: e8 3b 49 00 00 call 11b2e4 <_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 9f 2e 00 00 call 119860 <_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 c5 53 00 00 call 11bd98 <_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 97 53 00 00 call 11bd98 <_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 a0 20 14 00 push $0x1420a0 116a43: e8 9c 48 00 00 call 11b2e4 <_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 97 2d 00 00 call 119824 <_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 03 53 00 00 call 11bd98 <_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 ef 52 00 00 call 11bd98 <_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 10 22 14 00 mov 0x142210,%eax 115e99: 40 inc %eax 115e9a: a3 10 22 14 00 mov %eax,0x142210 */ 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 60 20 14 00 push $0x142060 115ea7: 89 55 e4 mov %edx,-0x1c(%ebp) 115eaa: e8 41 4f 00 00 call 11adf0 <_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 7c 20 14 00 mov 0x14207c,%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 b9 5e 00 00 call 11bd98 <_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 a7 5e 00 00 call 11bd98 <_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 60 20 14 00 push $0x142060 115f0a: e8 d5 53 00 00 call 11b2e4 <_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 60 20 14 00 push $0x142060 115f22: 89 45 e4 mov %eax,-0x1c(%ebp) 115f25: e8 42 4f 00 00 call 11ae6c <_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 60 20 14 00 push $0x142060 115f35: e8 2e 52 00 00 call 11b168 <_Objects_Free> _Dual_ported_memory_Free( the_port ); _Thread_Enable_dispatch(); 115f3a: e8 59 5e 00 00 call 11bd98 <_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 60 20 14 00 push $0x142060 115f6f: e8 70 53 00 00 call 11b2e4 <_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 f8 5d 00 00 call 11bd98 <_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 60 20 14 00 push $0x142060 115fff: e8 e0 52 00 00 call 11b2e4 <_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 68 5d 00 00 call 11bd98 <_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 0b 12 00 push $0x120bdb 1078ef: 53 push %ebx 1078f0: e8 17 c6 00 00 call 113f0c 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 0b 12 00 push $0x120bd3 107983: 53 push %ebx 107984: e8 83 c5 00 00 call 113f0c 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 34 54 12 00 mov 0x125434,%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 0b 12 00 push $0x120bdb 107a0f: 53 push %ebx 107a10: e8 f7 c4 00 00 call 113f0c 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 e0 20 14 00 push $0x1420e0 116acb: e8 14 48 00 00 call 11b2e4 <_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 f8 27 14 00 mov 0x1427f8,%eax 116aed: 39 43 40 cmp %eax,0x40(%ebx) 116af0: 74 12 je 116b04 _Thread_Enable_dispatch(); 116af2: e8 a1 52 00 00 call 11bd98 <_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 60 64 00 00 call 11cf70 <_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 7c 52 00 00 call 11bd98 <_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 d0 a8 12 00 mov 0x12a8d0,%eax 10c364: 40 inc %eax 10c365: a3 d0 a8 12 00 mov %eax,0x12a8d0 * 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 e0 a7 12 00 push $0x12a7e0 10c372: e8 25 1f 00 00 call 10e29c <_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 b8 ae 12 00 mov 0x12aeb8,%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 fc a7 12 00 mov 0x12a7fc,%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 fa 2e 00 00 call 10f2f0 <_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 db 2e 00 00 call 10f2f0 <_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 =============================================================================== 001128d0 : rtems_status_code rtems_rate_monotonic_get_status( rtems_id id, rtems_rate_monotonic_period_status *status ) { 1128d0: 55 push %ebp 1128d1: 89 e5 mov %esp,%ebp 1128d3: 53 push %ebx 1128d4: 83 ec 24 sub $0x24,%esp 1128d7: 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 ) 1128da: 85 db test %ebx,%ebx 1128dc: 0f 84 92 00 00 00 je 112974 1128e2: 50 push %eax return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); 1128e3: 8d 45 f4 lea -0xc(%ebp),%eax 1128e6: 50 push %eax 1128e7: ff 75 08 pushl 0x8(%ebp) 1128ea: 68 e0 a7 12 00 push $0x12a7e0 1128ef: e8 48 bf ff ff call 10e83c <_Objects_Get> switch ( location ) { 1128f4: 83 c4 10 add $0x10,%esp 1128f7: 8b 4d f4 mov -0xc(%ebp),%ecx 1128fa: 85 c9 test %ecx,%ecx 1128fc: 74 0a je 112908 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 1128fe: b8 04 00 00 00 mov $0x4,%eax } 112903: 8b 5d fc mov -0x4(%ebp),%ebx 112906: c9 leave 112907: c3 ret the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: status->owner = the_period->owner->Object.id; 112908: 8b 50 40 mov 0x40(%eax),%edx 11290b: 8b 52 08 mov 0x8(%edx),%edx 11290e: 89 13 mov %edx,(%ebx) status->state = the_period->state; 112910: 8b 50 38 mov 0x38(%eax),%edx 112913: 89 53 04 mov %edx,0x4(%ebx) /* * If the period is inactive, there is no information. */ if ( status->state == RATE_MONOTONIC_INACTIVE ) { 112916: 85 d2 test %edx,%edx 112918: 75 2a jne 112944 #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timespec_Set_to_zero( &status->since_last_period ); 11291a: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) 112921: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) _Timespec_Set_to_zero( &status->executed_since_last_period ); 112928: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) 11292f: 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(); 112936: e8 b5 c9 ff ff call 10f2f0 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 11293b: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11293d: 8b 5d fc mov -0x4(%ebp),%ebx 112940: c9 leave 112941: c3 ret 112942: 66 90 xchg %ax,%ax } else { /* * Grab the current status. */ valid_status = 112944: 52 push %edx _Rate_monotonic_Get_status( 112945: 8d 55 ec lea -0x14(%ebp),%edx } else { /* * Grab the current status. */ valid_status = 112948: 52 push %edx _Rate_monotonic_Get_status( 112949: 8d 55 e4 lea -0x1c(%ebp),%edx } else { /* * Grab the current status. */ valid_status = 11294c: 52 push %edx 11294d: 50 push %eax 11294e: e8 05 9b ff ff call 10c458 <_Rate_monotonic_Get_status> _Rate_monotonic_Get_status( the_period, &since_last_period, &executed ); if (!valid_status) { 112953: 83 c4 10 add $0x10,%esp 112956: 84 c0 test %al,%al 112958: 74 26 je 112980 _Thread_Enable_dispatch(); return RTEMS_NOT_DEFINED; } #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timestamp_To_timespec( 11295a: 8b 45 e4 mov -0x1c(%ebp),%eax 11295d: 8b 55 e8 mov -0x18(%ebp),%edx 112960: 89 43 08 mov %eax,0x8(%ebx) 112963: 89 53 0c mov %edx,0xc(%ebx) &since_last_period, &status->since_last_period ); _Timestamp_To_timespec( 112966: 8b 45 ec mov -0x14(%ebp),%eax 112969: 8b 55 f0 mov -0x10(%ebp),%edx 11296c: 89 43 10 mov %eax,0x10(%ebx) 11296f: 89 53 14 mov %edx,0x14(%ebx) 112972: eb c2 jmp 112936 Rate_monotonic_Period_time_t since_last_period; Rate_monotonic_Control *the_period; bool valid_status; if ( !status ) return RTEMS_INVALID_ADDRESS; 112974: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112979: 8b 5d fc mov -0x4(%ebp),%ebx 11297c: c9 leave 11297d: c3 ret 11297e: 66 90 xchg %ax,%ax valid_status = _Rate_monotonic_Get_status( the_period, &since_last_period, &executed ); if (!valid_status) { _Thread_Enable_dispatch(); 112980: e8 6b c9 ff ff call 10f2f0 <_Thread_Enable_dispatch> return RTEMS_NOT_DEFINED; 112985: b8 0b 00 00 00 mov $0xb,%eax 11298a: e9 74 ff ff ff jmp 112903 =============================================================================== 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 e0 a7 12 00 push $0x12a7e0 10c66d: e8 ca 21 00 00 call 10e83c <_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 b8 ae 12 00 mov 0x12aeb8,%edx 10c692: 39 50 40 cmp %edx,0x40(%eax) 10c695: 74 15 je 10c6ac _Thread_Enable_dispatch(); 10c697: e8 54 2c 00 00 call 10f2f0 <_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 dc 34 12 00 mov 0x1234dc(,%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 29 2c 00 00 call 10f2f0 <_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 dc a9 12 00 push $0x12a9dc 10c70d: e8 e6 3a 00 00 call 1101f8 <_Watchdog_Insert> _Thread_Enable_dispatch(); 10c712: e8 d9 2b 00 00 call 10f2f0 <_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 dc a9 12 00 push $0x12a9dc 10c769: e8 8a 3a 00 00 call 1101f8 <_Watchdog_Insert> _Thread_Enable_dispatch(); 10c76e: e8 7d 2b 00 00 call 10f2f0 <_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 b8 ae 12 00 mov 0x12aeb8,%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 a0 33 00 00 call 10fb54 <_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 1d 2b 00 00 call 10f2f0 <_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 b8 ae 12 00 pushl 0x12aeb8 10c7e7: e8 84 27 00 00 call 10ef70 <_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 f0 34 12 00 push $0x1234f0 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 28 35 12 00 push $0x123528 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 4c 35 12 00 push $0x12354c 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 70 35 12 00 push $0x123570 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 bc 35 12 00 push $0x1235bc 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 e8 a7 12 00 mov 0x12a7e8,%ebx 10c84c: 83 c4 10 add $0x10,%esp 10c84f: 3b 1d ec a7 12 00 cmp 0x12a7ec,%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 ec a7 12 00 cmp %ebx,0x12a7ec 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 b5 5f 00 00 call 112824 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 4d 60 00 00 call 1128d0 #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 0e 35 12 00 push $0x12350e 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 f9 15 12 00 push $0x1215f9 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 ec a7 12 00 cmp %ebx,0x12a7ec 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 75 35 00 00 call 10fe58 <_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 08 36 12 00 push $0x123608 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 eb 34 00 00 call 10fe58 <_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 28 36 12 00 push $0x123628 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 d0 a8 12 00 mov 0x12a8d0,%eax 10ca0c: 40 inc %eax 10ca0d: a3 d0 a8 12 00 mov %eax,0x12a8d0 /* * 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 e8 a7 12 00 mov 0x12a7e8,%ebx 10ca18: 3b 1d ec a7 12 00 cmp 0x12a7ec,%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 ec a7 12 00 cmp %ebx,0x12a7ec 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 b2 28 00 00 jmp 10f2f0 <_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 e0 a7 12 00 push $0x12a7e0 10ca54: e8 e3 1d 00 00 call 10e83c <_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 5c 28 00 00 call 10f2f0 <_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 fc 22 14 00 pushl 0x1422fc 11727f: e8 28 25 00 00 call 1197ac <_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 20 21 14 00 movl $0x142120,(%esp) 11728b: e8 60 3b 00 00 call 11adf0 <_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 4f 37 00 00 call 11a9fc <_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 f3 51 00 00 call 11c4dc <_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 3c 21 14 00 mov 0x14213c,%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 fc 22 14 00 pushl 0x1422fc 11730e: 89 45 e4 mov %eax,-0x1c(%ebp) 117311: e8 de 24 00 00 call 1197f4 <_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 20 21 14 00 push $0x142120 11733d: e8 26 3e 00 00 call 11b168 <_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 fc 22 14 00 pushl 0x1422fc 117371: e8 36 24 00 00 call 1197ac <_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 20 21 14 00 push $0x142120 117385: e8 1e 3f 00 00 call 11b2a8 <_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 fc 22 14 00 pushl 0x1422fc 1173a2: e8 4d 24 00 00 call 1197f4 <_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 20 21 14 00 push $0x142120 1173c9: 89 45 e4 mov %eax,-0x1c(%ebp) 1173cc: e8 9b 3a 00 00 call 11ae6c <_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 20 21 14 00 push $0x142120 1173dc: e8 87 3d 00 00 call 11b168 <_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 fc 22 14 00 pushl 0x1422fc 117400: e8 a7 23 00 00 call 1197ac <_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 20 21 14 00 push $0x142120 117414: e8 8f 3e 00 00 call 11b2a8 <_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 fc 22 14 00 pushl 0x1422fc 117433: e8 bc 23 00 00 call 1197f4 <_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 9b 2f 00 00 call 11a3f0 <_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 fc 22 14 00 pushl 0x1422fc 11749b: e8 0c 23 00 00 call 1197ac <_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 20 21 14 00 push $0x142120 1174af: e8 f4 3d 00 00 call 11b2a8 <_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 fc 22 14 00 pushl 0x1422fc 1174cc: e8 23 23 00 00 call 1197f4 <_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 da 32 00 00 call 11a7d8 <_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 fc 22 14 00 pushl 0x1422fc 1175c5: e8 e2 21 00 00 call 1197ac <_API_Mutex_Lock> executing = _Thread_Executing; 1175ca: a1 f8 27 14 00 mov 0x1427f8,%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 20 21 14 00 push $0x142120 1175e1: e8 c2 3c 00 00 call 11b2a8 <_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 fc 22 14 00 pushl 0x1422fc 117605: 89 45 d0 mov %eax,-0x30(%ebp) 117608: e8 e7 21 00 00 call 1197f4 <_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 ea 2b 00 00 call 11a21c <_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 10 22 14 00 mov 0x142210,%eax 117662: 40 inc %eax 117663: a3 10 22 14 00 mov %eax,0x142210 * 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 fc 22 14 00 pushl 0x1422fc 117671: e8 7e 21 00 00 call 1197f4 <_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 a0 c5 11 00 push $0x11c5a0 11769a: ff 75 14 pushl 0x14(%ebp) 11769d: 50 push %eax 11769e: e8 d1 4b 00 00 call 11c274 <_Thread_queue_Enqueue_with_handler> _Thread_Enable_dispatch(); 1176a3: e8 f0 46 00 00 call 11bd98 <_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 fc 22 14 00 pushl 0x1422fc 117788: e8 1f 20 00 00 call 1197ac <_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 20 21 14 00 push $0x142120 11779c: e8 07 3b 00 00 call 11b2a8 <_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 fc 22 14 00 pushl 0x1422fc 1177b6: e8 39 20 00 00 call 1197f4 <_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 1e 34 00 00 call 11ac04 <_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 b5 7c 00 00 call 11f4b0 <_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 fc 22 14 00 pushl 0x1422fc 11781d: 89 45 e4 mov %eax,-0x1c(%ebp) 117820: e8 cf 1f 00 00 call 1197f4 <_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 fc 22 14 00 pushl 0x1422fc 11784d: e8 5a 1f 00 00 call 1197ac <_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 20 21 14 00 push $0x142120 117861: e8 42 3a 00 00 call 11b2a8 <_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 07 2e 00 00 call 11a688 <_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 fc 22 14 00 pushl 0x1422fc 11789e: e8 51 1f 00 00 call 1197f4 <_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 f4 7b 00 00 call 11f4b0 <_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 70 75 12 00 mov 0x127570,%eax 10b4b0: 40 inc %eax 10b4b1: a3 70 75 12 00 mov %eax,0x127570 * 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 c0 74 12 00 push $0x1274c0 10b4be: 89 4d c4 mov %ecx,-0x3c(%ebp) 10b4c1: e8 c2 14 00 00 call 10c988 <_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 69 0c 00 00 call 10c180 <_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 dc 74 12 00 mov 0x1274dc,%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 b5 23 00 00 call 10d8f4 <_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 88 0e 00 00 call 10c410 <_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 5f 23 00 00 call 10d8f4 <_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 c0 74 12 00 push $0x1274c0 10b5d8: e8 23 17 00 00 call 10cd00 <_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 12 23 00 00 call 10d8f4 <_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 c0 74 12 00 push $0x1274c0 10b61f: e8 1c 18 00 00 call 10ce40 <_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 9f 22 00 00 call 10d8f4 <_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 06 0b 00 00 call 10c174 <_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 c0 74 12 00 push $0x1274c0 10b67a: e8 85 13 00 00 call 10ca04 <_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 c0 74 12 00 push $0x1274c0 10b687: e8 74 16 00 00 call 10cd00 <_Objects_Free> 0, /* Not used */ 0 /* Not used */ ); } #endif _Thread_Enable_dispatch(); 10b68c: e8 63 22 00 00 call 10d8f4 <_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 5a 0d 00 00 call 10c404 <_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 c0 74 12 00 push $0x1274c0 10b6d0: e8 13 17 00 00 call 10cde8 <_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 6e 0b 00 00 call 10c278 <_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 58 7b 12 00 mov 0x127b58,%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 58 7b 12 00 mov 0x127b58,%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 58 7b 12 00 mov 0x127b58,%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 70 75 12 00 mov 0x127570,%ecx 10b77a: 41 inc %ecx 10b77b: 89 0d 70 75 12 00 mov %ecx,0x127570 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 fc e0 10 00 push $0x10e0fc 10b79b: 57 push %edi 10b79c: 50 push %eax 10b79d: e8 2e 26 00 00 call 10ddd0 <_Thread_queue_Enqueue_with_handler> _Thread_Enable_dispatch(); 10b7a2: e8 4d 21 00 00 call 10d8f4 <_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 c0 74 12 00 push $0x1274c0 10b7c0: e8 7b 16 00 00 call 10ce40 <_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 61 0c 00 00 call 10c450 <_CORE_semaphore_Surrender> 10b7ef: 89 c3 mov %eax,%ebx &the_semaphore->Core_control.semaphore, id, MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); 10b7f1: e8 fe 20 00 00 call 10d8f4 <_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 03 0b 00 00 call 10c318 <_CORE_mutex_Surrender> 10b815: 89 c3 mov %eax,%ebx &the_semaphore->Core_control.mutex, id, MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); 10b817: e8 d8 20 00 00 call 10d8f4 <_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 35 40 00 00 call 11bdbc <_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 f4 27 14 00 mov 0x1427f4,%edx 117dbd: 85 d2 test %edx,%edx 117dbf: 74 1b je 117ddc 117dc1: 3b 05 f8 27 14 00 cmp 0x1427f8,%eax 117dc7: 75 13 jne 117ddc <== NEVER TAKEN _Thread_Dispatch_necessary = true; 117dc9: c6 05 04 28 14 00 01 movb $0x1,0x142804 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 b7 3f 00 00 call 11bd98 <_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 ab 3f 00 00 call 11bd98 <_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 a0 a0 12 00 mov $0x12a0a0,%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 98 a8 12 00 mov 0x12a898,%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 48 9d 12 00 mov 0x129d48,%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 a0 a0 12 00 mov $0x12a0a0,%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 48 9d 12 00 mov 0x129d48,%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 98 a8 12 00 pushl 0x12a898 <== 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 40 9d 12 00 mov %esi,0x129d40 <== NOT EXECUTED print_handler = print; 1081b5: 89 1d 44 9d 12 00 mov %ebx,0x129d44 <== NOT EXECUTED (*print)( context, "Stack usage by thread\n"); 1081bb: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1081be: 68 c8 35 12 00 push $0x1235c8 <== 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 4c 36 12 00 push $0x12364c <== 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 64 70 00 00 call 10f240 <== 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 40 9d 12 00 00 movl $0x0,0x129d40 <== NOT EXECUTED 1081ef: 00 00 00 print_handler = NULL; 1081f2: c7 05 44 9d 12 00 00 movl $0x0,0x129d44 <== 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 a0 a0 12 00 mov $0x12a0a0,%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 a0 a0 12 00 mov $0x12a0a0,%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 =============================================================================== 00110b40 : #if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER) , int base #endif ) { 110b40: 55 push %ebp 110b41: 89 e5 mov %esp,%ebp 110b43: 57 push %edi 110b44: 56 push %esi 110b45: 53 push %ebx 110b46: 83 ec 2c sub $0x2c,%esp 110b49: 8b 75 08 mov 0x8(%ebp),%esi 110b4c: 8b 5d 0c mov 0xc(%ebp),%ebx 110b4f: 8b 7d 10 mov 0x10(%ebp),%edi STRING_TO_INPUT_TYPE result; char *end; if ( !n ) 110b52: 85 db test %ebx,%ebx 110b54: 74 72 je 110bc8 return RTEMS_INVALID_ADDRESS; errno = 0; 110b56: e8 f9 2e 00 00 call 113a54 <__errno> 110b5b: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 110b61: c7 03 00 00 00 00 movl $0x0,(%ebx) 110b67: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) #ifdef STRING_TO_FLOAT result = STRING_TO_METHOD( s, &end ); 110b6e: 83 ec 08 sub $0x8,%esp 110b71: 8d 45 e4 lea -0x1c(%ebp),%eax 110b74: 50 push %eax 110b75: 56 push %esi 110b76: e8 dd 58 00 00 call 116458 #elif defined(STRING_TO_INTEGER) result = STRING_TO_METHOD( s, &end, base ); #endif /* If the user wants the end pointer back, then return it. */ if ( endptr ) 110b7b: 83 c4 10 add $0x10,%esp 110b7e: 85 ff test %edi,%edi 110b80: 74 56 je 110bd8 *endptr = end; 110b82: 8b 45 e4 mov -0x1c(%ebp),%eax 110b85: 89 07 mov %eax,(%edi) /* nothing was converted */ if ( end == s ) 110b87: 39 c6 cmp %eax,%esi 110b89: 74 55 je 110be0 return RTEMS_INVALID_NUMBER; #endif #ifdef STRING_TO_MAX /* there was an overflow */ if ( (result == STRING_TO_MAX) && (errno == ERANGE)) 110b8b: dd 05 30 58 12 00 fldl 0x125830 110b91: d9 c9 fxch %st(1) 110b93: dd e1 fucom %st(1) 110b95: df e0 fnstsw %ax 110b97: dd d9 fstp %st(1) 110b99: f6 c4 45 test $0x45,%ah 110b9c: 74 0e je 110bac #endif #if defined(STRING_TO_POINTER) *n = (STRING_TO_TYPE) (uintptr_t)result; #else *n = (STRING_TO_TYPE) result; 110b9e: dd 1b fstpl (%ebx) #endif return RTEMS_SUCCESSFUL; 110ba0: 31 c0 xor %eax,%eax } 110ba2: 8d 65 f4 lea -0xc(%ebp),%esp 110ba5: 5b pop %ebx 110ba6: 5e pop %esi 110ba7: 5f pop %edi 110ba8: c9 leave 110ba9: c3 ret 110baa: 66 90 xchg %ax,%ax return RTEMS_INVALID_NUMBER; #endif #ifdef STRING_TO_MAX /* there was an overflow */ if ( (result == STRING_TO_MAX) && (errno == ERANGE)) 110bac: dd 5d c8 fstpl -0x38(%ebp) 110baf: e8 a0 2e 00 00 call 113a54 <__errno> 110bb4: 83 38 22 cmpl $0x22,(%eax) 110bb7: dd 45 c8 fldl -0x38(%ebp) 110bba: 75 e2 jne 110b9e <== NEVER TAKEN 110bbc: dd d8 fstp %st(0) return RTEMS_INVALID_NUMBER; 110bbe: b8 0a 00 00 00 mov $0xa,%eax 110bc3: eb dd jmp 110ba2 110bc5: 8d 76 00 lea 0x0(%esi),%esi { STRING_TO_INPUT_TYPE result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 110bc8: b8 09 00 00 00 mov $0x9,%eax *n = (STRING_TO_TYPE) (uintptr_t)result; #else *n = (STRING_TO_TYPE) result; #endif return RTEMS_SUCCESSFUL; } 110bcd: 8d 65 f4 lea -0xc(%ebp),%esp 110bd0: 5b pop %ebx 110bd1: 5e pop %esi 110bd2: 5f pop %edi 110bd3: c9 leave 110bd4: c3 ret 110bd5: 8d 76 00 lea 0x0(%esi),%esi #elif defined(STRING_TO_INTEGER) result = STRING_TO_METHOD( s, &end, base ); #endif /* If the user wants the end pointer back, then return it. */ if ( endptr ) 110bd8: 8b 45 e4 mov -0x1c(%ebp),%eax 110bdb: eb aa jmp 110b87 110bdd: 8d 76 00 lea 0x0(%esi),%esi 110be0: dd d8 fstp %st(0) *endptr = end; /* nothing was converted */ if ( end == s ) return RTEMS_NOT_DEFINED; 110be2: b8 0b 00 00 00 mov $0xb,%eax 110be7: eb b9 jmp 110ba2 =============================================================================== 00110bec : #if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER) , int base #endif ) { 110bec: 55 push %ebp 110bed: 89 e5 mov %esp,%ebp 110bef: 57 push %edi 110bf0: 56 push %esi 110bf1: 53 push %ebx 110bf2: 83 ec 2c sub $0x2c,%esp 110bf5: 8b 75 08 mov 0x8(%ebp),%esi 110bf8: 8b 5d 0c mov 0xc(%ebp),%ebx 110bfb: 8b 7d 10 mov 0x10(%ebp),%edi STRING_TO_INPUT_TYPE result; char *end; if ( !n ) 110bfe: 85 db test %ebx,%ebx 110c00: 74 6a je 110c6c return RTEMS_INVALID_ADDRESS; errno = 0; 110c02: e8 4d 2e 00 00 call 113a54 <__errno> 110c07: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 110c0d: c7 03 00 00 00 00 movl $0x0,(%ebx) #ifdef STRING_TO_FLOAT result = STRING_TO_METHOD( s, &end ); 110c13: 83 ec 08 sub $0x8,%esp 110c16: 8d 45 e4 lea -0x1c(%ebp),%eax 110c19: 50 push %eax 110c1a: 56 push %esi 110c1b: e8 54 58 00 00 call 116474 #elif defined(STRING_TO_INTEGER) result = STRING_TO_METHOD( s, &end, base ); #endif /* If the user wants the end pointer back, then return it. */ if ( endptr ) 110c20: 83 c4 10 add $0x10,%esp 110c23: 85 ff test %edi,%edi 110c25: 74 55 je 110c7c *endptr = end; 110c27: 8b 45 e4 mov -0x1c(%ebp),%eax 110c2a: 89 07 mov %eax,(%edi) /* nothing was converted */ if ( end == s ) 110c2c: 39 c6 cmp %eax,%esi 110c2e: 74 54 je 110c84 return RTEMS_INVALID_NUMBER; #endif #ifdef STRING_TO_MAX /* there was an overflow */ if ( (result == STRING_TO_MAX) && (errno == ERANGE)) 110c30: d9 05 38 58 12 00 flds 0x125838 110c36: d9 c9 fxch %st(1) 110c38: dd e1 fucom %st(1) 110c3a: df e0 fnstsw %ax 110c3c: dd d9 fstp %st(1) 110c3e: f6 c4 45 test $0x45,%ah 110c41: 74 0d je 110c50 #endif #if defined(STRING_TO_POINTER) *n = (STRING_TO_TYPE) (uintptr_t)result; #else *n = (STRING_TO_TYPE) result; 110c43: d9 1b fstps (%ebx) #endif return RTEMS_SUCCESSFUL; 110c45: 31 c0 xor %eax,%eax } 110c47: 8d 65 f4 lea -0xc(%ebp),%esp 110c4a: 5b pop %ebx 110c4b: 5e pop %esi 110c4c: 5f pop %edi 110c4d: c9 leave 110c4e: c3 ret 110c4f: 90 nop return RTEMS_INVALID_NUMBER; #endif #ifdef STRING_TO_MAX /* there was an overflow */ if ( (result == STRING_TO_MAX) && (errno == ERANGE)) 110c50: d9 5d c8 fstps -0x38(%ebp) 110c53: e8 fc 2d 00 00 call 113a54 <__errno> 110c58: 83 38 22 cmpl $0x22,(%eax) 110c5b: d9 45 c8 flds -0x38(%ebp) 110c5e: 75 e3 jne 110c43 <== NEVER TAKEN 110c60: dd d8 fstp %st(0) return RTEMS_INVALID_NUMBER; 110c62: b8 0a 00 00 00 mov $0xa,%eax 110c67: eb de jmp 110c47 110c69: 8d 76 00 lea 0x0(%esi),%esi { STRING_TO_INPUT_TYPE result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 110c6c: b8 09 00 00 00 mov $0x9,%eax *n = (STRING_TO_TYPE) (uintptr_t)result; #else *n = (STRING_TO_TYPE) result; #endif return RTEMS_SUCCESSFUL; } 110c71: 8d 65 f4 lea -0xc(%ebp),%esp 110c74: 5b pop %ebx 110c75: 5e pop %esi 110c76: 5f pop %edi 110c77: c9 leave 110c78: c3 ret 110c79: 8d 76 00 lea 0x0(%esi),%esi #elif defined(STRING_TO_INTEGER) result = STRING_TO_METHOD( s, &end, base ); #endif /* If the user wants the end pointer back, then return it. */ if ( endptr ) 110c7c: 8b 45 e4 mov -0x1c(%ebp),%eax 110c7f: eb ab jmp 110c2c 110c81: 8d 76 00 lea 0x0(%esi),%esi 110c84: dd d8 fstp %st(0) *endptr = end; /* nothing was converted */ if ( end == s ) return RTEMS_NOT_DEFINED; 110c86: b8 0b 00 00 00 mov $0xb,%eax 110c8b: eb ba jmp 110c47 =============================================================================== 00110c90 : #if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER) , int base #endif ) { 110c90: 55 push %ebp 110c91: 89 e5 mov %esp,%ebp 110c93: 57 push %edi 110c94: 56 push %esi 110c95: 53 push %ebx 110c96: 83 ec 2c sub $0x2c,%esp 110c99: 8b 75 08 mov 0x8(%ebp),%esi 110c9c: 8b 5d 0c mov 0xc(%ebp),%ebx 110c9f: 8b 7d 10 mov 0x10(%ebp),%edi STRING_TO_INPUT_TYPE result; char *end; if ( !n ) 110ca2: 85 db test %ebx,%ebx 110ca4: 74 5e je 110d04 return RTEMS_INVALID_ADDRESS; errno = 0; 110ca6: e8 a9 2d 00 00 call 113a54 <__errno> 110cab: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 110cb1: c7 03 00 00 00 00 movl $0x0,(%ebx) #ifdef STRING_TO_FLOAT result = STRING_TO_METHOD( s, &end ); #elif defined(STRING_TO_POINTER) result = STRING_TO_METHOD( s, &end, 16 ); #elif defined(STRING_TO_INTEGER) result = STRING_TO_METHOD( s, &end, base ); 110cb7: 50 push %eax 110cb8: ff 75 14 pushl 0x14(%ebp) 110cbb: 8d 45 e4 lea -0x1c(%ebp),%eax 110cbe: 50 push %eax 110cbf: 56 push %esi 110cc0: e8 6f 59 00 00 call 116634 110cc5: 89 c2 mov %eax,%edx #endif /* If the user wants the end pointer back, then return it. */ if ( endptr ) 110cc7: 83 c4 10 add $0x10,%esp 110cca: 85 ff test %edi,%edi 110ccc: 74 46 je 110d14 *endptr = end; 110cce: 8b 45 e4 mov -0x1c(%ebp),%eax 110cd1: 89 07 mov %eax,(%edi) /* nothing was converted */ if ( end == s ) 110cd3: 39 c6 cmp %eax,%esi 110cd5: 74 45 je 110d1c return RTEMS_INVALID_NUMBER; #endif #ifdef STRING_TO_MAX /* there was an overflow */ if ( (result == STRING_TO_MAX) && (errno == ERANGE)) 110cd7: 81 fa ff ff ff 7f cmp $0x7fffffff,%edx 110cdd: 74 0d je 110cec #endif #if defined(STRING_TO_POINTER) *n = (STRING_TO_TYPE) (uintptr_t)result; #else *n = (STRING_TO_TYPE) result; 110cdf: 89 13 mov %edx,(%ebx) #endif return RTEMS_SUCCESSFUL; 110ce1: 31 c0 xor %eax,%eax } 110ce3: 8d 65 f4 lea -0xc(%ebp),%esp 110ce6: 5b pop %ebx 110ce7: 5e pop %esi 110ce8: 5f pop %edi 110ce9: c9 leave 110cea: c3 ret 110ceb: 90 nop return RTEMS_INVALID_NUMBER; #endif #ifdef STRING_TO_MAX /* there was an overflow */ if ( (result == STRING_TO_MAX) && (errno == ERANGE)) 110cec: 89 55 d4 mov %edx,-0x2c(%ebp) 110cef: e8 60 2d 00 00 call 113a54 <__errno> 110cf4: 83 38 22 cmpl $0x22,(%eax) 110cf7: 8b 55 d4 mov -0x2c(%ebp),%edx 110cfa: 75 e3 jne 110cdf return RTEMS_INVALID_NUMBER; 110cfc: b8 0a 00 00 00 mov $0xa,%eax 110d01: eb e0 jmp 110ce3 110d03: 90 nop { STRING_TO_INPUT_TYPE result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 110d04: b8 09 00 00 00 mov $0x9,%eax *n = (STRING_TO_TYPE) (uintptr_t)result; #else *n = (STRING_TO_TYPE) result; #endif return RTEMS_SUCCESSFUL; } 110d09: 8d 65 f4 lea -0xc(%ebp),%esp 110d0c: 5b pop %ebx 110d0d: 5e pop %esi 110d0e: 5f pop %edi 110d0f: c9 leave 110d10: c3 ret 110d11: 8d 76 00 lea 0x0(%esi),%esi #elif defined(STRING_TO_INTEGER) result = STRING_TO_METHOD( s, &end, base ); #endif /* If the user wants the end pointer back, then return it. */ if ( endptr ) 110d14: 8b 45 e4 mov -0x1c(%ebp),%eax 110d17: eb ba jmp 110cd3 110d19: 8d 76 00 lea 0x0(%esi),%esi *endptr = end; /* nothing was converted */ if ( end == s ) return RTEMS_NOT_DEFINED; 110d1c: b8 0b 00 00 00 mov $0xb,%eax 110d21: eb c0 jmp 110ce3 =============================================================================== 00110dd4 : #if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER) , int base #endif ) { 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 1c sub $0x1c,%esp 110ddd: 8b 7d 08 mov 0x8(%ebp),%edi 110de0: 8b 5d 0c mov 0xc(%ebp),%ebx STRING_TO_INPUT_TYPE result; char *end; if ( !n ) 110de3: 85 db test %ebx,%ebx 110de5: 74 69 je 110e50 return RTEMS_INVALID_ADDRESS; errno = 0; 110de7: e8 68 2c 00 00 call 113a54 <__errno> 110dec: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 110df2: c7 03 00 00 00 00 movl $0x0,(%ebx) #ifdef STRING_TO_FLOAT result = STRING_TO_METHOD( s, &end ); #elif defined(STRING_TO_POINTER) result = STRING_TO_METHOD( s, &end, 16 ); #elif defined(STRING_TO_INTEGER) result = STRING_TO_METHOD( s, &end, base ); 110df8: 52 push %edx 110df9: ff 75 14 pushl 0x14(%ebp) 110dfc: 8d 45 e4 lea -0x1c(%ebp),%eax 110dff: 50 push %eax 110e00: 57 push %edi 110e01: e8 2e 58 00 00 call 116634 110e06: 89 c6 mov %eax,%esi #endif /* If the user wants the end pointer back, then return it. */ if ( endptr ) 110e08: 83 c4 10 add $0x10,%esp 110e0b: 8b 45 10 mov 0x10(%ebp),%eax 110e0e: 85 c0 test %eax,%eax 110e10: 74 4e je 110e60 *endptr = end; 110e12: 8b 45 e4 mov -0x1c(%ebp),%eax 110e15: 8b 55 10 mov 0x10(%ebp),%edx 110e18: 89 02 mov %eax,(%edx) /* nothing was converted */ if ( end == s ) 110e1a: 39 c7 cmp %eax,%edi 110e1c: 74 4a je 110e68 return RTEMS_INVALID_NUMBER; #endif #ifdef STRING_TO_MAX /* there was an overflow */ if ( (result == STRING_TO_MAX) && (errno == ERANGE)) 110e1e: 81 fe ff ff ff 7f cmp $0x7fffffff,%esi 110e24: 74 16 je 110e3c return RTEMS_INVALID_NUMBER; #endif #ifdef STRING_TO_MIN /* there was an underflow */ if ( (result == STRING_TO_MIN) && (errno == ERANGE)) 110e26: 81 fe 00 00 00 80 cmp $0x80000000,%esi 110e2c: 74 0e je 110e3c #endif #if defined(STRING_TO_POINTER) *n = (STRING_TO_TYPE) (uintptr_t)result; #else *n = (STRING_TO_TYPE) result; 110e2e: 89 33 mov %esi,(%ebx) #endif return RTEMS_SUCCESSFUL; 110e30: 31 c0 xor %eax,%eax } 110e32: 8d 65 f4 lea -0xc(%ebp),%esp 110e35: 5b pop %ebx 110e36: 5e pop %esi 110e37: 5f pop %edi 110e38: c9 leave 110e39: c3 ret 110e3a: 66 90 xchg %ax,%ax return RTEMS_INVALID_NUMBER; #endif #ifdef STRING_TO_MIN /* there was an underflow */ if ( (result == STRING_TO_MIN) && (errno == ERANGE)) 110e3c: e8 13 2c 00 00 call 113a54 <__errno> 110e41: 83 38 22 cmpl $0x22,(%eax) 110e44: 75 e8 jne 110e2e return RTEMS_INVALID_NUMBER; 110e46: b8 0a 00 00 00 mov $0xa,%eax 110e4b: eb e5 jmp 110e32 110e4d: 8d 76 00 lea 0x0(%esi),%esi { STRING_TO_INPUT_TYPE result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 110e50: b8 09 00 00 00 mov $0x9,%eax *n = (STRING_TO_TYPE) (uintptr_t)result; #else *n = (STRING_TO_TYPE) result; #endif return RTEMS_SUCCESSFUL; } 110e55: 8d 65 f4 lea -0xc(%ebp),%esp 110e58: 5b pop %ebx 110e59: 5e pop %esi 110e5a: 5f pop %edi 110e5b: c9 leave 110e5c: c3 ret 110e5d: 8d 76 00 lea 0x0(%esi),%esi #elif defined(STRING_TO_INTEGER) result = STRING_TO_METHOD( s, &end, base ); #endif /* If the user wants the end pointer back, then return it. */ if ( endptr ) 110e60: 8b 45 e4 mov -0x1c(%ebp),%eax 110e63: eb b5 jmp 110e1a 110e65: 8d 76 00 lea 0x0(%esi),%esi *endptr = end; /* nothing was converted */ if ( end == s ) return RTEMS_NOT_DEFINED; 110e68: b8 0b 00 00 00 mov $0xb,%eax 110e6d: eb c3 jmp 110e32 =============================================================================== 00110d24 : #if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER) , int base #endif ) { 110d24: 55 push %ebp 110d25: 89 e5 mov %esp,%ebp 110d27: 57 push %edi 110d28: 56 push %esi 110d29: 53 push %ebx 110d2a: 83 ec 2c sub $0x2c,%esp 110d2d: 8b 5d 0c mov 0xc(%ebp),%ebx 110d30: 8b 7d 10 mov 0x10(%ebp),%edi STRING_TO_INPUT_TYPE result; char *end; if ( !n ) 110d33: 85 db test %ebx,%ebx 110d35: 74 7d je 110db4 return RTEMS_INVALID_ADDRESS; errno = 0; 110d37: e8 18 2d 00 00 call 113a54 <__errno> 110d3c: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 110d42: c7 03 00 00 00 00 movl $0x0,(%ebx) 110d48: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) #ifdef STRING_TO_FLOAT result = STRING_TO_METHOD( s, &end ); #elif defined(STRING_TO_POINTER) result = STRING_TO_METHOD( s, &end, 16 ); #elif defined(STRING_TO_INTEGER) result = STRING_TO_METHOD( s, &end, base ); 110d4f: 50 push %eax 110d50: ff 75 14 pushl 0x14(%ebp) 110d53: 8d 45 e4 lea -0x1c(%ebp),%eax 110d56: 50 push %eax 110d57: ff 75 08 pushl 0x8(%ebp) 110d5a: e8 f1 58 00 00 call 116650 110d5f: 89 c6 mov %eax,%esi #endif /* If the user wants the end pointer back, then return it. */ if ( endptr ) 110d61: 83 c4 10 add $0x10,%esp 110d64: 85 ff test %edi,%edi 110d66: 74 5c je 110dc4 *endptr = end; 110d68: 8b 45 e4 mov -0x1c(%ebp),%eax 110d6b: 89 07 mov %eax,(%edi) /* nothing was converted */ if ( end == s ) 110d6d: 39 45 08 cmp %eax,0x8(%ebp) 110d70: 74 5a je 110dcc return RTEMS_INVALID_NUMBER; #endif #ifdef STRING_TO_MAX /* there was an overflow */ if ( (result == STRING_TO_MAX) && (errno == ERANGE)) 110d72: 89 d1 mov %edx,%ecx 110d74: 81 f1 ff ff ff 7f xor $0x7fffffff,%ecx 110d7a: 89 f0 mov %esi,%eax 110d7c: f7 d0 not %eax 110d7e: 09 c1 or %eax,%ecx 110d80: 74 1a je 110d9c return RTEMS_INVALID_NUMBER; #endif #ifdef STRING_TO_MIN /* there was an underflow */ if ( (result == STRING_TO_MIN) && (errno == ERANGE)) 110d82: 8d 82 00 00 00 80 lea -0x80000000(%edx),%eax 110d88: 09 f0 or %esi,%eax 110d8a: 74 10 je 110d9c #endif #if defined(STRING_TO_POINTER) *n = (STRING_TO_TYPE) (uintptr_t)result; #else *n = (STRING_TO_TYPE) result; 110d8c: 89 33 mov %esi,(%ebx) 110d8e: 89 53 04 mov %edx,0x4(%ebx) #endif return RTEMS_SUCCESSFUL; 110d91: 31 c0 xor %eax,%eax } 110d93: 8d 65 f4 lea -0xc(%ebp),%esp 110d96: 5b pop %ebx 110d97: 5e pop %esi 110d98: 5f pop %edi 110d99: c9 leave 110d9a: c3 ret 110d9b: 90 nop return RTEMS_INVALID_NUMBER; #endif #ifdef STRING_TO_MIN /* there was an underflow */ if ( (result == STRING_TO_MIN) && (errno == ERANGE)) 110d9c: 89 55 d4 mov %edx,-0x2c(%ebp) 110d9f: e8 b0 2c 00 00 call 113a54 <__errno> 110da4: 83 38 22 cmpl $0x22,(%eax) 110da7: 8b 55 d4 mov -0x2c(%ebp),%edx 110daa: 75 e0 jne 110d8c return RTEMS_INVALID_NUMBER; 110dac: b8 0a 00 00 00 mov $0xa,%eax 110db1: eb e0 jmp 110d93 110db3: 90 nop { STRING_TO_INPUT_TYPE result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 110db4: b8 09 00 00 00 mov $0x9,%eax *n = (STRING_TO_TYPE) (uintptr_t)result; #else *n = (STRING_TO_TYPE) result; #endif return RTEMS_SUCCESSFUL; } 110db9: 8d 65 f4 lea -0xc(%ebp),%esp 110dbc: 5b pop %ebx 110dbd: 5e pop %esi 110dbe: 5f pop %edi 110dbf: c9 leave 110dc0: c3 ret 110dc1: 8d 76 00 lea 0x0(%esi),%esi #elif defined(STRING_TO_INTEGER) result = STRING_TO_METHOD( s, &end, base ); #endif /* If the user wants the end pointer back, then return it. */ if ( endptr ) 110dc4: 8b 45 e4 mov -0x1c(%ebp),%eax 110dc7: eb a4 jmp 110d6d 110dc9: 8d 76 00 lea 0x0(%esi),%esi *endptr = end; /* nothing was converted */ if ( end == s ) return RTEMS_NOT_DEFINED; 110dcc: b8 0b 00 00 00 mov $0xb,%eax 110dd1: eb c0 jmp 110d93 =============================================================================== 00110e70 : #if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER) , int base #endif ) { 110e70: 55 push %ebp 110e71: 89 e5 mov %esp,%ebp 110e73: 57 push %edi 110e74: 56 push %esi 110e75: 53 push %ebx 110e76: 83 ec 2c sub $0x2c,%esp 110e79: 8b 75 08 mov 0x8(%ebp),%esi 110e7c: 8b 5d 0c mov 0xc(%ebp),%ebx 110e7f: 8b 7d 10 mov 0x10(%ebp),%edi STRING_TO_INPUT_TYPE result; char *end; if ( !n ) 110e82: 85 db test %ebx,%ebx 110e84: 74 5a je 110ee0 return RTEMS_INVALID_ADDRESS; errno = 0; 110e86: e8 c9 2b 00 00 call 113a54 <__errno> 110e8b: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 110e91: c7 03 00 00 00 00 movl $0x0,(%ebx) #ifdef STRING_TO_FLOAT result = STRING_TO_METHOD( s, &end ); #elif defined(STRING_TO_POINTER) result = STRING_TO_METHOD( s, &end, 16 ); 110e97: 50 push %eax 110e98: 6a 10 push $0x10 110e9a: 8d 45 e4 lea -0x1c(%ebp),%eax 110e9d: 50 push %eax 110e9e: 56 push %esi 110e9f: e8 4c 5c 00 00 call 116af0 110ea4: 89 c2 mov %eax,%edx #elif defined(STRING_TO_INTEGER) result = STRING_TO_METHOD( s, &end, base ); #endif /* If the user wants the end pointer back, then return it. */ if ( endptr ) 110ea6: 83 c4 10 add $0x10,%esp 110ea9: 85 ff test %edi,%edi 110eab: 74 43 je 110ef0 *endptr = end; 110ead: 8b 45 e4 mov -0x1c(%ebp),%eax 110eb0: 89 07 mov %eax,(%edi) /* nothing was converted */ if ( end == s ) 110eb2: 39 c6 cmp %eax,%esi 110eb4: 74 42 je 110ef8 return RTEMS_INVALID_NUMBER; #endif #ifdef STRING_TO_MAX /* there was an overflow */ if ( (result == STRING_TO_MAX) && (errno == ERANGE)) 110eb6: 83 fa ff cmp $0xffffffff,%edx 110eb9: 74 0d je 110ec8 <== NEVER TAKEN if ( (result == STRING_TO_MIN) && (errno == ERANGE)) return RTEMS_INVALID_NUMBER; #endif #if defined(STRING_TO_POINTER) *n = (STRING_TO_TYPE) (uintptr_t)result; 110ebb: 89 13 mov %edx,(%ebx) #else *n = (STRING_TO_TYPE) result; #endif return RTEMS_SUCCESSFUL; 110ebd: 31 c0 xor %eax,%eax } 110ebf: 8d 65 f4 lea -0xc(%ebp),%esp 110ec2: 5b pop %ebx 110ec3: 5e pop %esi 110ec4: 5f pop %edi 110ec5: c9 leave 110ec6: c3 ret 110ec7: 90 nop return RTEMS_INVALID_NUMBER; #endif #ifdef STRING_TO_MAX /* there was an overflow */ if ( (result == STRING_TO_MAX) && (errno == ERANGE)) 110ec8: 89 55 d4 mov %edx,-0x2c(%ebp) <== NOT EXECUTED 110ecb: e8 84 2b 00 00 call 113a54 <__errno> <== NOT EXECUTED 110ed0: 83 38 22 cmpl $0x22,(%eax) <== NOT EXECUTED 110ed3: 8b 55 d4 mov -0x2c(%ebp),%edx <== NOT EXECUTED 110ed6: 75 e3 jne 110ebb <== NOT EXECUTED return RTEMS_INVALID_NUMBER; 110ed8: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 110edd: eb e0 jmp 110ebf <== NOT EXECUTED 110edf: 90 nop <== NOT EXECUTED { STRING_TO_INPUT_TYPE result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 110ee0: b8 09 00 00 00 mov $0x9,%eax *n = (STRING_TO_TYPE) (uintptr_t)result; #else *n = (STRING_TO_TYPE) result; #endif return RTEMS_SUCCESSFUL; } 110ee5: 8d 65 f4 lea -0xc(%ebp),%esp 110ee8: 5b pop %ebx 110ee9: 5e pop %esi 110eea: 5f pop %edi 110eeb: c9 leave 110eec: c3 ret 110eed: 8d 76 00 lea 0x0(%esi),%esi #elif defined(STRING_TO_INTEGER) result = STRING_TO_METHOD( s, &end, base ); #endif /* If the user wants the end pointer back, then return it. */ if ( endptr ) 110ef0: 8b 45 e4 mov -0x1c(%ebp),%eax 110ef3: eb bd jmp 110eb2 110ef5: 8d 76 00 lea 0x0(%esi),%esi *endptr = end; /* nothing was converted */ if ( end == s ) return RTEMS_NOT_DEFINED; 110ef8: b8 0b 00 00 00 mov $0xb,%eax 110efd: eb c0 jmp 110ebf =============================================================================== 00110f00 : #if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER) , int base #endif ) { 110f00: 55 push %ebp 110f01: 89 e5 mov %esp,%ebp 110f03: 57 push %edi 110f04: 56 push %esi 110f05: 53 push %ebx 110f06: 83 ec 1c sub $0x1c,%esp 110f09: 8b 75 08 mov 0x8(%ebp),%esi 110f0c: 8b 5d 0c mov 0xc(%ebp),%ebx 110f0f: 8b 7d 10 mov 0x10(%ebp),%edi STRING_TO_INPUT_TYPE result; char *end; if ( !n ) 110f12: 85 db test %ebx,%ebx 110f14: 74 3a je 110f50 return RTEMS_INVALID_ADDRESS; errno = 0; 110f16: e8 39 2b 00 00 call 113a54 <__errno> 110f1b: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 110f21: c6 03 00 movb $0x0,(%ebx) #ifdef STRING_TO_FLOAT result = STRING_TO_METHOD( s, &end ); #elif defined(STRING_TO_POINTER) result = STRING_TO_METHOD( s, &end, 16 ); #elif defined(STRING_TO_INTEGER) result = STRING_TO_METHOD( s, &end, base ); 110f24: 50 push %eax 110f25: ff 75 14 pushl 0x14(%ebp) 110f28: 8d 45 e4 lea -0x1c(%ebp),%eax 110f2b: 50 push %eax 110f2c: 56 push %esi 110f2d: e8 be 5b 00 00 call 116af0 #endif /* If the user wants the end pointer back, then return it. */ if ( endptr ) 110f32: 83 c4 10 add $0x10,%esp 110f35: 85 ff test %edi,%edi 110f37: 74 27 je 110f60 *endptr = end; 110f39: 8b 55 e4 mov -0x1c(%ebp),%edx 110f3c: 89 17 mov %edx,(%edi) /* nothing was converted */ if ( end == s ) 110f3e: 39 d6 cmp %edx,%esi 110f40: 74 26 je 110f68 #ifdef STRING_TO_FLOAT result = STRING_TO_METHOD( s, &end ); #elif defined(STRING_TO_POINTER) result = STRING_TO_METHOD( s, &end, 16 ); #elif defined(STRING_TO_INTEGER) result = STRING_TO_METHOD( s, &end, base ); 110f42: 88 03 mov %al,(%ebx) #if defined(STRING_TO_POINTER) *n = (STRING_TO_TYPE) (uintptr_t)result; #else *n = (STRING_TO_TYPE) result; #endif return RTEMS_SUCCESSFUL; 110f44: 31 c0 xor %eax,%eax } 110f46: 8d 65 f4 lea -0xc(%ebp),%esp 110f49: 5b pop %ebx 110f4a: 5e pop %esi 110f4b: 5f pop %edi 110f4c: c9 leave 110f4d: c3 ret 110f4e: 66 90 xchg %ax,%ax { STRING_TO_INPUT_TYPE result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 110f50: b8 09 00 00 00 mov $0x9,%eax *n = (STRING_TO_TYPE) (uintptr_t)result; #else *n = (STRING_TO_TYPE) result; #endif return RTEMS_SUCCESSFUL; } 110f55: 8d 65 f4 lea -0xc(%ebp),%esp 110f58: 5b pop %ebx 110f59: 5e pop %esi 110f5a: 5f pop %edi 110f5b: c9 leave 110f5c: c3 ret 110f5d: 8d 76 00 lea 0x0(%esi),%esi #elif defined(STRING_TO_INTEGER) result = STRING_TO_METHOD( s, &end, base ); #endif /* If the user wants the end pointer back, then return it. */ if ( endptr ) 110f60: 8b 55 e4 mov -0x1c(%ebp),%edx 110f63: eb d9 jmp 110f3e 110f65: 8d 76 00 lea 0x0(%esi),%esi *endptr = end; /* nothing was converted */ if ( end == s ) return RTEMS_NOT_DEFINED; 110f68: b8 0b 00 00 00 mov $0xb,%eax 110f6d: eb d7 jmp 110f46 =============================================================================== 00110f70 : #if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER) , int base #endif ) { 110f70: 55 push %ebp 110f71: 89 e5 mov %esp,%ebp 110f73: 57 push %edi 110f74: 56 push %esi 110f75: 53 push %ebx 110f76: 83 ec 2c sub $0x2c,%esp 110f79: 8b 75 08 mov 0x8(%ebp),%esi 110f7c: 8b 5d 0c mov 0xc(%ebp),%ebx 110f7f: 8b 7d 10 mov 0x10(%ebp),%edi STRING_TO_INPUT_TYPE result; char *end; if ( !n ) 110f82: 85 db test %ebx,%ebx 110f84: 74 5a je 110fe0 return RTEMS_INVALID_ADDRESS; errno = 0; 110f86: e8 c9 2a 00 00 call 113a54 <__errno> 110f8b: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 110f91: c7 03 00 00 00 00 movl $0x0,(%ebx) #ifdef STRING_TO_FLOAT result = STRING_TO_METHOD( s, &end ); #elif defined(STRING_TO_POINTER) result = STRING_TO_METHOD( s, &end, 16 ); #elif defined(STRING_TO_INTEGER) result = STRING_TO_METHOD( s, &end, base ); 110f97: 50 push %eax 110f98: ff 75 14 pushl 0x14(%ebp) 110f9b: 8d 45 e4 lea -0x1c(%ebp),%eax 110f9e: 50 push %eax 110f9f: 56 push %esi 110fa0: e8 4b 5b 00 00 call 116af0 110fa5: 89 c2 mov %eax,%edx #endif /* If the user wants the end pointer back, then return it. */ if ( endptr ) 110fa7: 83 c4 10 add $0x10,%esp 110faa: 85 ff test %edi,%edi 110fac: 74 42 je 110ff0 *endptr = end; 110fae: 8b 45 e4 mov -0x1c(%ebp),%eax 110fb1: 89 07 mov %eax,(%edi) /* nothing was converted */ if ( end == s ) 110fb3: 39 c6 cmp %eax,%esi 110fb5: 74 41 je 110ff8 return RTEMS_INVALID_NUMBER; #endif #ifdef STRING_TO_MAX /* there was an overflow */ if ( (result == STRING_TO_MAX) && (errno == ERANGE)) 110fb7: 83 fa ff cmp $0xffffffff,%edx 110fba: 74 0c je 110fc8 #endif #if defined(STRING_TO_POINTER) *n = (STRING_TO_TYPE) (uintptr_t)result; #else *n = (STRING_TO_TYPE) result; 110fbc: 89 13 mov %edx,(%ebx) #endif return RTEMS_SUCCESSFUL; 110fbe: 31 c0 xor %eax,%eax } 110fc0: 8d 65 f4 lea -0xc(%ebp),%esp 110fc3: 5b pop %ebx 110fc4: 5e pop %esi 110fc5: 5f pop %edi 110fc6: c9 leave 110fc7: c3 ret return RTEMS_INVALID_NUMBER; #endif #ifdef STRING_TO_MAX /* there was an overflow */ if ( (result == STRING_TO_MAX) && (errno == ERANGE)) 110fc8: 89 55 d4 mov %edx,-0x2c(%ebp) 110fcb: e8 84 2a 00 00 call 113a54 <__errno> 110fd0: 83 38 22 cmpl $0x22,(%eax) 110fd3: 8b 55 d4 mov -0x2c(%ebp),%edx 110fd6: 75 e4 jne 110fbc <== NEVER TAKEN return RTEMS_INVALID_NUMBER; 110fd8: b8 0a 00 00 00 mov $0xa,%eax 110fdd: eb e1 jmp 110fc0 110fdf: 90 nop { STRING_TO_INPUT_TYPE result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 110fe0: b8 09 00 00 00 mov $0x9,%eax *n = (STRING_TO_TYPE) (uintptr_t)result; #else *n = (STRING_TO_TYPE) result; #endif return RTEMS_SUCCESSFUL; } 110fe5: 8d 65 f4 lea -0xc(%ebp),%esp 110fe8: 5b pop %ebx 110fe9: 5e pop %esi 110fea: 5f pop %edi 110feb: c9 leave 110fec: c3 ret 110fed: 8d 76 00 lea 0x0(%esi),%esi #elif defined(STRING_TO_INTEGER) result = STRING_TO_METHOD( s, &end, base ); #endif /* If the user wants the end pointer back, then return it. */ if ( endptr ) 110ff0: 8b 45 e4 mov -0x1c(%ebp),%eax 110ff3: eb be jmp 110fb3 110ff5: 8d 76 00 lea 0x0(%esi),%esi *endptr = end; /* nothing was converted */ if ( end == s ) return RTEMS_NOT_DEFINED; 110ff8: b8 0b 00 00 00 mov $0xb,%eax 110ffd: eb c1 jmp 110fc0 =============================================================================== 0011109c : #if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER) , int base #endif ) { 11109c: 55 push %ebp 11109d: 89 e5 mov %esp,%ebp 11109f: 57 push %edi 1110a0: 56 push %esi 1110a1: 53 push %ebx 1110a2: 83 ec 2c sub $0x2c,%esp 1110a5: 8b 75 08 mov 0x8(%ebp),%esi 1110a8: 8b 5d 0c mov 0xc(%ebp),%ebx 1110ab: 8b 7d 10 mov 0x10(%ebp),%edi STRING_TO_INPUT_TYPE result; char *end; if ( !n ) 1110ae: 85 db test %ebx,%ebx 1110b0: 74 5a je 11110c return RTEMS_INVALID_ADDRESS; errno = 0; 1110b2: e8 9d 29 00 00 call 113a54 <__errno> 1110b7: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 1110bd: c7 03 00 00 00 00 movl $0x0,(%ebx) #ifdef STRING_TO_FLOAT result = STRING_TO_METHOD( s, &end ); #elif defined(STRING_TO_POINTER) result = STRING_TO_METHOD( s, &end, 16 ); #elif defined(STRING_TO_INTEGER) result = STRING_TO_METHOD( s, &end, base ); 1110c3: 50 push %eax 1110c4: ff 75 14 pushl 0x14(%ebp) 1110c7: 8d 45 e4 lea -0x1c(%ebp),%eax 1110ca: 50 push %eax 1110cb: 56 push %esi 1110cc: e8 1f 5a 00 00 call 116af0 1110d1: 89 c2 mov %eax,%edx #endif /* If the user wants the end pointer back, then return it. */ if ( endptr ) 1110d3: 83 c4 10 add $0x10,%esp 1110d6: 85 ff test %edi,%edi 1110d8: 74 42 je 11111c *endptr = end; 1110da: 8b 45 e4 mov -0x1c(%ebp),%eax 1110dd: 89 07 mov %eax,(%edi) /* nothing was converted */ if ( end == s ) 1110df: 39 c6 cmp %eax,%esi 1110e1: 74 41 je 111124 return RTEMS_INVALID_NUMBER; #endif #ifdef STRING_TO_MAX /* there was an overflow */ if ( (result == STRING_TO_MAX) && (errno == ERANGE)) 1110e3: 83 fa ff cmp $0xffffffff,%edx 1110e6: 74 0c je 1110f4 #endif #if defined(STRING_TO_POINTER) *n = (STRING_TO_TYPE) (uintptr_t)result; #else *n = (STRING_TO_TYPE) result; 1110e8: 89 13 mov %edx,(%ebx) #endif return RTEMS_SUCCESSFUL; 1110ea: 31 c0 xor %eax,%eax } 1110ec: 8d 65 f4 lea -0xc(%ebp),%esp 1110ef: 5b pop %ebx 1110f0: 5e pop %esi 1110f1: 5f pop %edi 1110f2: c9 leave 1110f3: c3 ret return RTEMS_INVALID_NUMBER; #endif #ifdef STRING_TO_MAX /* there was an overflow */ if ( (result == STRING_TO_MAX) && (errno == ERANGE)) 1110f4: 89 55 d4 mov %edx,-0x2c(%ebp) 1110f7: e8 58 29 00 00 call 113a54 <__errno> 1110fc: 83 38 22 cmpl $0x22,(%eax) 1110ff: 8b 55 d4 mov -0x2c(%ebp),%edx 111102: 75 e4 jne 1110e8 <== NEVER TAKEN return RTEMS_INVALID_NUMBER; 111104: b8 0a 00 00 00 mov $0xa,%eax 111109: eb e1 jmp 1110ec 11110b: 90 nop { STRING_TO_INPUT_TYPE result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 11110c: b8 09 00 00 00 mov $0x9,%eax *n = (STRING_TO_TYPE) (uintptr_t)result; #else *n = (STRING_TO_TYPE) result; #endif return RTEMS_SUCCESSFUL; } 111111: 8d 65 f4 lea -0xc(%ebp),%esp 111114: 5b pop %ebx 111115: 5e pop %esi 111116: 5f pop %edi 111117: c9 leave 111118: c3 ret 111119: 8d 76 00 lea 0x0(%esi),%esi #elif defined(STRING_TO_INTEGER) result = STRING_TO_METHOD( s, &end, base ); #endif /* If the user wants the end pointer back, then return it. */ if ( endptr ) 11111c: 8b 45 e4 mov -0x1c(%ebp),%eax 11111f: eb be jmp 1110df 111121: 8d 76 00 lea 0x0(%esi),%esi *endptr = end; /* nothing was converted */ if ( end == s ) return RTEMS_NOT_DEFINED; 111124: b8 0b 00 00 00 mov $0xb,%eax 111129: eb c1 jmp 1110ec =============================================================================== 00111000 : #if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER) , int base #endif ) { 111000: 55 push %ebp 111001: 89 e5 mov %esp,%ebp 111003: 57 push %edi 111004: 56 push %esi 111005: 53 push %ebx 111006: 83 ec 2c sub $0x2c,%esp 111009: 8b 5d 0c mov 0xc(%ebp),%ebx 11100c: 8b 7d 10 mov 0x10(%ebp),%edi STRING_TO_INPUT_TYPE result; char *end; if ( !n ) 11100f: 85 db test %ebx,%ebx 111011: 74 69 je 11107c return RTEMS_INVALID_ADDRESS; errno = 0; 111013: e8 3c 2a 00 00 call 113a54 <__errno> 111018: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 11101e: c7 03 00 00 00 00 movl $0x0,(%ebx) 111024: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) #ifdef STRING_TO_FLOAT result = STRING_TO_METHOD( s, &end ); #elif defined(STRING_TO_POINTER) result = STRING_TO_METHOD( s, &end, 16 ); #elif defined(STRING_TO_INTEGER) result = STRING_TO_METHOD( s, &end, base ); 11102b: 50 push %eax 11102c: ff 75 14 pushl 0x14(%ebp) 11102f: 8d 45 e4 lea -0x1c(%ebp),%eax 111032: 50 push %eax 111033: ff 75 08 pushl 0x8(%ebp) 111036: e8 d1 5a 00 00 call 116b0c 11103b: 89 c6 mov %eax,%esi #endif /* If the user wants the end pointer back, then return it. */ if ( endptr ) 11103d: 83 c4 10 add $0x10,%esp 111040: 85 ff test %edi,%edi 111042: 74 48 je 11108c *endptr = end; 111044: 8b 45 e4 mov -0x1c(%ebp),%eax 111047: 89 07 mov %eax,(%edi) /* nothing was converted */ if ( end == s ) 111049: 39 45 08 cmp %eax,0x8(%ebp) 11104c: 74 46 je 111094 return RTEMS_INVALID_NUMBER; #endif #ifdef STRING_TO_MAX /* there was an overflow */ if ( (result == STRING_TO_MAX) && (errno == ERANGE)) 11104e: 89 f0 mov %esi,%eax 111050: 21 d0 and %edx,%eax 111052: 40 inc %eax 111053: 74 0f je 111064 #endif #if defined(STRING_TO_POINTER) *n = (STRING_TO_TYPE) (uintptr_t)result; #else *n = (STRING_TO_TYPE) result; 111055: 89 33 mov %esi,(%ebx) 111057: 89 53 04 mov %edx,0x4(%ebx) #endif return RTEMS_SUCCESSFUL; 11105a: 31 c0 xor %eax,%eax } 11105c: 8d 65 f4 lea -0xc(%ebp),%esp 11105f: 5b pop %ebx 111060: 5e pop %esi 111061: 5f pop %edi 111062: c9 leave 111063: c3 ret return RTEMS_INVALID_NUMBER; #endif #ifdef STRING_TO_MAX /* there was an overflow */ if ( (result == STRING_TO_MAX) && (errno == ERANGE)) 111064: 89 55 d4 mov %edx,-0x2c(%ebp) 111067: e8 e8 29 00 00 call 113a54 <__errno> 11106c: 83 38 22 cmpl $0x22,(%eax) 11106f: 8b 55 d4 mov -0x2c(%ebp),%edx 111072: 75 e1 jne 111055 <== NEVER TAKEN return RTEMS_INVALID_NUMBER; 111074: b8 0a 00 00 00 mov $0xa,%eax 111079: eb e1 jmp 11105c 11107b: 90 nop { STRING_TO_INPUT_TYPE result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 11107c: b8 09 00 00 00 mov $0x9,%eax *n = (STRING_TO_TYPE) (uintptr_t)result; #else *n = (STRING_TO_TYPE) result; #endif return RTEMS_SUCCESSFUL; } 111081: 8d 65 f4 lea -0xc(%ebp),%esp 111084: 5b pop %ebx 111085: 5e pop %esi 111086: 5f pop %edi 111087: c9 leave 111088: c3 ret 111089: 8d 76 00 lea 0x0(%esi),%esi #elif defined(STRING_TO_INTEGER) result = STRING_TO_METHOD( s, &end, base ); #endif /* If the user wants the end pointer back, then return it. */ if ( endptr ) 11108c: 8b 45 e4 mov -0x1c(%ebp),%eax 11108f: eb b8 jmp 111049 111091: 8d 76 00 lea 0x0(%esi),%esi *endptr = end; /* nothing was converted */ if ( end == s ) return RTEMS_NOT_DEFINED; 111094: b8 0b 00 00 00 mov $0xb,%eax 111099: eb c1 jmp 11105c =============================================================================== 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 65 12 00 cmp $0x126580,%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 65 12 00 mov $0x1265c8,%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 57 fe 00 00 call 117d3c 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 5e 7c 00 00 call 10fb60 <_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 4b 7c 00 00 call 10fb60 <_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 35 7c 00 00 call 10fb60 <_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 ff 80 00 00 call 110034 <_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 75 fa 00 00 call 1179d4 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 82 f8 00 00 call 117820 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 70 12 00 cmp $0x127000,%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 0c 88 00 00 call 110814 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 ce 81 00 00 call 11021c &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 32 12 00 movzbl 0x123274,%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 5c 76 12 00 pushl 0x12765c 10b897: e8 c8 06 00 00 call 10bf64 <_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 00 75 12 00 movl $0x127500,(%esp) 10b8a3: e8 e0 10 00 00 call 10c988 <_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 00 75 12 00 push $0x127500 10b8ed: 89 55 e4 mov %edx,-0x1c(%ebp) 10b8f0: e8 97 20 00 00 call 10d98c <_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 5c 76 12 00 pushl 0x12765c 10b91e: e8 89 06 00 00 call 10bfac <_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 15 14 00 00 call 10cd70 <_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 99 13 00 00 call 10cd00 <_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 5c 76 12 00 pushl 0x12765c 10b96e: e8 39 06 00 00 call 10bfac <_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 5c 76 12 00 pushl 0x12765c 10b98d: e8 1a 06 00 00 call 10bfac <_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 5c 76 12 00 pushl 0x12765c 10b9b9: e8 a6 05 00 00 call 10bf64 <_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 4c 1f 00 00 call 10d918 <_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 8d 13 00 00 call 10cd70 <_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 c8 1b 00 00 call 10d5b4 <_Thread_Close> 10b9ec: 58 pop %eax 10b9ed: ff 73 08 pushl 0x8(%ebx) 10b9f0: e8 7b 13 00 00 call 10cd70 <_Objects_Get_information_id> 10b9f5: 5a pop %edx 10b9f6: 59 pop %ecx 10b9f7: 53 push %ebx 10b9f8: 50 push %eax 10b9f9: e8 02 13 00 00 call 10cd00 <_Objects_Free> _RTEMS_tasks_Free( the_thread ); _RTEMS_Unlock_allocator(); 10b9fe: 58 pop %eax 10b9ff: ff 35 5c 76 12 00 pushl 0x12765c 10ba05: e8 a2 05 00 00 call 10bfac <_API_Mutex_Unlock> _Thread_Enable_dispatch(); 10ba0a: e8 e5 1e 00 00 call 10d8f4 <_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 5c 76 12 00 pushl 0x12765c 10ba25: e8 82 05 00 00 call 10bfac <_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 e4 61 12 00 00 cmpb $0x0,0x1261e4 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 18 ae 12 00 mov 0x12ae18,%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 3d 22 00 00 call 10f760 <_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 fe 21 00 00 call 10f73c <_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 18 ae 12 00 mov 0x12ae18,%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 66 3c 00 00 call 11bdbc <_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 25 3c 00 00 call 11bd98 <_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 17 3c 00 00 call 11bd98 <_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 =============================================================================== 00112e94 : rtems_status_code rtems_task_mode( rtems_mode mode_set, rtems_mode mask, rtems_mode *previous_mode_set ) { 112e94: 55 push %ebp 112e95: 89 e5 mov %esp,%ebp 112e97: 57 push %edi 112e98: 56 push %esi 112e99: 53 push %ebx 112e9a: 83 ec 1c sub $0x1c,%esp 112e9d: 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 ) 112ea0: 85 c9 test %ecx,%ecx 112ea2: 0f 84 40 01 00 00 je 112fe8 return RTEMS_INVALID_ADDRESS; executing = _Thread_Executing; 112ea8: 8b 1d 58 7b 12 00 mov 0x127b58,%ebx api = executing->API_Extensions[ THREAD_API_RTEMS ]; 112eae: 8b bb e8 00 00 00 mov 0xe8(%ebx),%edi asr = &api->Signal; old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT; 112eb4: 80 7b 74 01 cmpb $0x1,0x74(%ebx) 112eb8: 19 f6 sbb %esi,%esi 112eba: 81 e6 00 01 00 00 and $0x100,%esi if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) 112ec0: 8b 53 7c mov 0x7c(%ebx),%edx 112ec3: 85 d2 test %edx,%edx 112ec5: 0f 85 f1 00 00 00 jne 112fbc old_mode |= RTEMS_NO_TIMESLICE; else old_mode |= RTEMS_TIMESLICE; old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR; 112ecb: 80 7f 08 01 cmpb $0x1,0x8(%edi) 112ecf: 19 d2 sbb %edx,%edx 112ed1: 81 e2 00 04 00 00 and $0x400,%edx old_mode |= _ISR_Get_level(); 112ed7: 89 55 e4 mov %edx,-0x1c(%ebp) 112eda: 89 4d e0 mov %ecx,-0x20(%ebp) 112edd: e8 7a be ff ff call 10ed5c <_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; 112ee2: 8b 55 e4 mov -0x1c(%ebp),%edx 112ee5: 09 d0 or %edx,%eax old_mode |= _ISR_Get_level(); 112ee7: 09 f0 or %esi,%eax 112ee9: 8b 4d e0 mov -0x20(%ebp),%ecx 112eec: 89 01 mov %eax,(%ecx) *previous_mode_set = old_mode; /* * These are generic thread scheduling characteristics. */ if ( mask & RTEMS_PREEMPT_MASK ) 112eee: f7 45 0c 00 01 00 00 testl $0x100,0xc(%ebp) 112ef5: 74 0b je 112f02 executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false; 112ef7: f7 45 08 00 01 00 00 testl $0x100,0x8(%ebp) 112efe: 0f 94 43 74 sete 0x74(%ebx) if ( mask & RTEMS_TIMESLICE_MASK ) { 112f02: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp) 112f09: 74 1c je 112f27 if ( _Modes_Is_timeslice(mode_set) ) { 112f0b: f7 45 08 00 02 00 00 testl $0x200,0x8(%ebp) 112f12: 0f 84 b8 00 00 00 je 112fd0 executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; 112f18: c7 43 7c 01 00 00 00 movl $0x1,0x7c(%ebx) executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 112f1f: a1 40 75 12 00 mov 0x127540,%eax 112f24: 89 43 78 mov %eax,0x78(%ebx) } /* * Set the new interrupt level */ if ( mask & RTEMS_INTERRUPT_MASK ) 112f27: f6 45 0c 01 testb $0x1,0xc(%ebp) 112f2b: 74 0b je 112f38 */ RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level ( Modes_Control mode_set ) { _ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) ); 112f2d: f6 45 08 01 testb $0x1,0x8(%ebp) 112f31: 0f 84 91 00 00 00 je 112fc8 112f37: fa cli * This is specific to the RTEMS API */ is_asr_enabled = false; needs_asr_dispatching = false; if ( mask & RTEMS_ASR_MASK ) { 112f38: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp) 112f3f: 74 3f je 112f80 * Output: * *previous_mode_set - previous mode set * always return RTEMS_SUCCESSFUL; */ rtems_status_code rtems_task_mode( 112f41: f7 45 08 00 04 00 00 testl $0x400,0x8(%ebp) 112f48: 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 ) { 112f4b: 38 47 08 cmp %al,0x8(%edi) 112f4e: 74 30 je 112f80 asr->is_enabled = is_asr_enabled; 112f50: 88 47 08 mov %al,0x8(%edi) ) { rtems_signal_set _signals; ISR_Level _level; _ISR_Disable( _level ); 112f53: 9c pushf 112f54: fa cli 112f55: 58 pop %eax _signals = information->signals_pending; 112f56: 8b 57 18 mov 0x18(%edi),%edx information->signals_pending = information->signals_posted; 112f59: 8b 4f 14 mov 0x14(%edi),%ecx 112f5c: 89 4f 18 mov %ecx,0x18(%edi) information->signals_posted = _signals; 112f5f: 89 57 14 mov %edx,0x14(%edi) _ISR_Enable( _level ); 112f62: 50 push %eax 112f63: 9d popf /* * This is specific to the RTEMS API */ is_asr_enabled = false; needs_asr_dispatching = false; 112f64: 8b 47 14 mov 0x14(%edi),%eax 112f67: 85 c0 test %eax,%eax 112f69: 0f 95 c0 setne %al needs_asr_dispatching = true; } } } if ( _System_state_Is_up( _System_state_Get() ) ) { 112f6c: 83 3d 40 77 12 00 03 cmpl $0x3,0x127740 112f73: 74 16 je 112f8b <== ALWAYS TAKEN if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) ) _Thread_Dispatch(); } return RTEMS_SUCCESSFUL; 112f75: 31 c0 xor %eax,%eax } 112f77: 83 c4 1c add $0x1c,%esp 112f7a: 5b pop %ebx 112f7b: 5e pop %esi 112f7c: 5f pop %edi 112f7d: c9 leave 112f7e: c3 ret 112f7f: 90 nop /* * This is specific to the RTEMS API */ is_asr_enabled = false; needs_asr_dispatching = false; 112f80: 31 c0 xor %eax,%eax needs_asr_dispatching = true; } } } if ( _System_state_Is_up( _System_state_Get() ) ) { 112f82: 83 3d 40 77 12 00 03 cmpl $0x3,0x127740 112f89: 75 ea jne 112f75 <== NEVER TAKEN bool are_signals_pending ) { Thread_Control *executing; executing = _Thread_Executing; 112f8b: 8b 15 58 7b 12 00 mov 0x127b58,%edx if ( are_signals_pending || 112f91: 84 c0 test %al,%al 112f93: 75 0e jne 112fa3 112f95: 3b 15 5c 7b 12 00 cmp 0x127b5c,%edx 112f9b: 74 d8 je 112f75 (!_Thread_Is_heir( executing ) && executing->is_preemptible) ) { 112f9d: 80 7a 74 00 cmpb $0x0,0x74(%edx) 112fa1: 74 d2 je 112f75 <== NEVER TAKEN _Thread_Dispatch_necessary = true; 112fa3: c6 05 64 7b 12 00 01 movb $0x1,0x127b64 if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) ) _Thread_Dispatch(); 112faa: e8 cd a7 ff ff call 10d77c <_Thread_Dispatch> } return RTEMS_SUCCESSFUL; 112faf: 31 c0 xor %eax,%eax } 112fb1: 83 c4 1c add $0x1c,%esp 112fb4: 5b pop %ebx 112fb5: 5e pop %esi 112fb6: 5f pop %edi 112fb7: c9 leave 112fb8: c3 ret 112fb9: 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; 112fbc: 81 ce 00 02 00 00 or $0x200,%esi 112fc2: e9 04 ff ff ff jmp 112ecb 112fc7: 90 nop 112fc8: fb sti 112fc9: e9 6a ff ff ff jmp 112f38 112fce: 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; 112fd0: c7 43 7c 00 00 00 00 movl $0x0,0x7c(%ebx) } /* * Set the new interrupt level */ if ( mask & RTEMS_INTERRUPT_MASK ) 112fd7: f6 45 0c 01 testb $0x1,0xc(%ebp) 112fdb: 0f 84 57 ff ff ff je 112f38 112fe1: e9 47 ff ff ff jmp 112f2d 112fe6: 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; 112fe8: b8 09 00 00 00 mov $0x9,%eax if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) ) _Thread_Dispatch(); } return RTEMS_SUCCESSFUL; } 112fed: 83 c4 1c add $0x1c,%esp 112ff0: 5b pop %ebx 112ff1: 5e pop %esi 112ff2: 5f pop %edi 112ff3: c9 leave 112ff4: 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 62 1f 00 00 call 110c50 <_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 21 1f 00 00 call 110c2c <_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 4d 27 00 00 call 11146c <_Thread_Resume> _Thread_Enable_dispatch(); 10ed1f: e8 08 1f 00 00 call 110c2c <_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 e4 61 12 00 00 cmpb $0x0,0x1261e4 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 18 ae 12 00 mov 0x12ae18,%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 c9 20 00 00 call 10f760 <_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 8c 20 00 00 call 10f73c <_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 18 ae 12 00 mov 0x12ae18,%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 72 12 00 movzbl 0x127234,%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 c0 20 00 00 call 111a90 <_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 bc 1b 00 00 call 1115b8 <_Thread_Change_priority> 10f9fc: 83 c4 10 add $0x10,%esp } _Thread_Enable_dispatch(); 10f9ff: e8 68 20 00 00 call 111a6c <_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 07 1e 00 00 call 10d918 <_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 d8 27 00 00 call 10e304 <_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 bc 1d 00 00 call 10d8f4 <_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 93 1d 00 00 call 10d8f4 <_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 =============================================================================== 00110f40 : */ rtems_status_code rtems_task_suspend( rtems_id id ) { 110f40: 55 push %ebp 110f41: 89 e5 mov %esp,%ebp 110f43: 83 ec 20 sub $0x20,%esp register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 110f46: 8d 45 f4 lea -0xc(%ebp),%eax 110f49: 50 push %eax 110f4a: ff 75 08 pushl 0x8(%ebp) 110f4d: e8 c6 c9 ff ff call 10d918 <_Thread_Get> switch ( location ) { 110f52: 83 c4 10 add $0x10,%esp 110f55: 8b 55 f4 mov -0xc(%ebp),%edx 110f58: 85 d2 test %edx,%edx 110f5a: 74 08 je 110f64 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 110f5c: b8 04 00 00 00 mov $0x4,%eax } 110f61: c9 leave 110f62: c3 ret 110f63: 90 nop the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { 110f64: f6 40 10 02 testb $0x2,0x10(%eax) 110f68: 74 0e je 110f78 _Thread_Suspend( the_thread ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 110f6a: e8 85 c9 ff ff call 10d8f4 <_Thread_Enable_dispatch> return RTEMS_ALREADY_SUSPENDED; 110f6f: b8 0f 00 00 00 mov $0xf,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 110f74: c9 leave 110f75: c3 ret 110f76: 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 ); 110f78: 83 ec 0c sub $0xc,%esp 110f7b: 50 push %eax 110f7c: e8 f7 09 00 00 call 111978 <_Thread_Suspend> _Thread_Enable_dispatch(); 110f81: e8 6e c9 ff ff call 10d8f4 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 110f86: 83 c4 10 add $0x10,%esp 110f89: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 110f8b: c9 leave 110f8c: 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 b2 1f 00 00 call 10e628 <_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 ca 2f 00 00 call 10f670 <_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 39 1f 00 00 call 10e604 <_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 19 1f 00 00 call 10e604 <_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 07 1f 00 00 call 10e604 <_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 f7 1e 00 00 call 10e628 <_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 96 1e 00 00 call 10e604 <_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 79 1e 00 00 call 10e604 <_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 53 1e 00 00 call 10e628 <_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 03 1e 00 00 call 10e604 <_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 db 1d 00 00 call 10e604 <_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 =============================================================================== 0010c9cc : */ rtems_status_code rtems_task_wake_when( rtems_time_of_day *time_buffer ) { 10c9cc: 55 push %ebp 10c9cd: 89 e5 mov %esp,%ebp 10c9cf: 53 push %ebx 10c9d0: 83 ec 14 sub $0x14,%esp 10c9d3: 8b 5d 08 mov 0x8(%ebp),%ebx Watchdog_Interval seconds; if ( !_TOD_Is_set ) 10c9d6: 80 3d 84 a2 12 00 00 cmpb $0x0,0x12a284 10c9dd: 0f 84 a9 00 00 00 je 10ca8c return RTEMS_NOT_DEFINED; if ( !time_buffer ) 10c9e3: 85 db test %ebx,%ebx 10c9e5: 0f 84 ad 00 00 00 je 10ca98 return RTEMS_INVALID_ADDRESS; time_buffer->ticks = 0; 10c9eb: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) if ( !_TOD_Validate( time_buffer ) ) 10c9f2: 83 ec 0c sub $0xc,%esp 10c9f5: 53 push %ebx 10c9f6: e8 c5 f3 ff ff call 10bdc0 <_TOD_Validate> 10c9fb: 83 c4 10 add $0x10,%esp 10c9fe: 84 c0 test %al,%al 10ca00: 75 0a jne 10ca0c return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( time_buffer ); if ( seconds <= _TOD_Seconds_since_epoch() ) return RTEMS_INVALID_CLOCK; 10ca02: b8 14 00 00 00 mov $0x14,%eax &_Thread_Executing->Timer, seconds - _TOD_Seconds_since_epoch() ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10ca07: 8b 5d fc mov -0x4(%ebp),%ebx 10ca0a: c9 leave 10ca0b: c3 ret time_buffer->ticks = 0; if ( !_TOD_Validate( time_buffer ) ) return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( time_buffer ); 10ca0c: 83 ec 0c sub $0xc,%esp 10ca0f: 53 push %ebx 10ca10: e8 1f f3 ff ff call 10bd34 <_TOD_To_seconds> if ( seconds <= _TOD_Seconds_since_epoch() ) 10ca15: 83 c4 10 add $0x10,%esp 10ca18: 3b 05 44 a3 12 00 cmp 0x12a344,%eax 10ca1e: 76 e2 jbe 10ca02 10ca20: 8b 15 70 a2 12 00 mov 0x12a270,%edx 10ca26: 42 inc %edx 10ca27: 89 15 70 a2 12 00 mov %edx,0x12a270 return RTEMS_INVALID_CLOCK; _Thread_Disable_dispatch(); _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME ); 10ca2d: 83 ec 08 sub $0x8,%esp 10ca30: 6a 10 push $0x10 10ca32: ff 35 58 a8 12 00 pushl 0x12a858 10ca38: 89 45 f4 mov %eax,-0xc(%ebp) 10ca3b: e8 68 26 00 00 call 10f0a8 <_Thread_Set_state> _Watchdog_Initialize( &_Thread_Executing->Timer, _Thread_Delay_ended, _Thread_Executing->Object.id, 10ca40: 8b 15 58 a8 12 00 mov 0x12a858,%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( 10ca46: 8b 4a 08 mov 0x8(%edx),%ecx Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 10ca49: c7 42 50 00 00 00 00 movl $0x0,0x50(%edx) the_watchdog->routine = routine; 10ca50: c7 42 64 90 e6 10 00 movl $0x10e690,0x64(%edx) the_watchdog->id = id; 10ca57: 89 4a 68 mov %ecx,0x68(%edx) the_watchdog->user_data = user_data; 10ca5a: 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( 10ca61: 8b 45 f4 mov -0xc(%ebp),%eax 10ca64: 2b 05 44 a3 12 00 sub 0x12a344,%eax 10ca6a: 89 42 54 mov %eax,0x54(%edx) ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 10ca6d: 58 pop %eax 10ca6e: 59 pop %ecx 10ca6f: 83 c2 48 add $0x48,%edx 10ca72: 52 push %edx 10ca73: 68 70 a3 12 00 push $0x12a370 10ca78: e8 43 2c 00 00 call 10f6c0 <_Watchdog_Insert> &_Thread_Executing->Timer, seconds - _TOD_Seconds_since_epoch() ); _Thread_Enable_dispatch(); 10ca7d: e8 c2 1d 00 00 call 10e844 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10ca82: 83 c4 10 add $0x10,%esp 10ca85: 31 c0 xor %eax,%eax 10ca87: e9 7b ff ff ff jmp 10ca07 ) { Watchdog_Interval seconds; if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; 10ca8c: b8 0b 00 00 00 mov $0xb,%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 10ca96: 66 90 xchg %ax,%ax if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; if ( !time_buffer ) return RTEMS_INVALID_ADDRESS; 10ca98: b8 09 00 00 00 mov $0x9,%eax &_Thread_Executing->Timer, seconds - _TOD_Seconds_since_epoch() ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10ca9d: 8b 5d fc mov -0x4(%ebp),%ebx 10caa0: c9 leave 10caa1: 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 a0 50 12 00 push $0x1250a0 108f48: e8 43 6c 00 00 call 10fb90 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 4c 74 12 00 pushl 0x12744c 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 e4 70 12 00 mov 0x1270e4(%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 4c 74 12 00 pushl 0x12744c 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 54 74 12 00 mov %eax,0x127454 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 50 74 12 00 mov %edx,0x127450 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 79 26 00 00 call 10bd00 <== 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 94 71 12 00 mov 0x127194,%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 34 11 00 00 call 10bd00 <== 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 f0 70 12 00 mov 0x1270f0(%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 f0 70 12 00 mov 0x1270f0(%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 4c 74 12 00 mov 0x12744c,%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 4c 74 12 00 push $0x12744c 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 5c 2d 00 00 call 10bd00 =============================================================================== 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 f8 70 12 00 mov 0x1270f8(%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 <== ALWAYS TAKEN !(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 <== NOT EXECUTED 1097bc: 25 ef fd ff ff and $0xfffffdef,%eax <== NOT EXECUTED 1097c1: 89 82 b8 00 00 00 mov %eax,0xb8(%edx) <== NOT EXECUTED /* 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 <== NOT EXECUTED 1097cd: a8 20 test $0x20,%al <== NOT EXECUTED 1097cf: 74 23 je 1097f4 <== NOT EXECUTED /* 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 <== ALWAYS TAKEN /* clear related flags in flow_ctrl */ tty->flow_ctrl &= ~(FL_MDXOF); 109808: 8b 81 b8 00 00 00 mov 0xb8(%ecx),%eax <== NOT EXECUTED 10980e: 80 e4 fb and $0xfb,%ah <== NOT EXECUTED 109811: 89 81 b8 00 00 00 mov %eax,0xb8(%ecx) <== NOT EXECUTED /* 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 <== NOT EXECUTED 10981d: 83 e0 fd and $0xfffffffd,%eax <== NOT EXECUTED 109820: 89 81 b8 00 00 00 mov %eax,0xb8(%ecx) <== NOT EXECUTED } /* 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 e4 70 12 00 mov 0x1270e4(%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 e0 70 12 00 mov 0x1270e0(%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 60 89 12 00 push $0x128960 10aa94: e8 f7 6e 00 00 call 111990 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 4c 74 12 00 pushl 0x12744c 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 54 74 12 00 mov 0x127454,%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 4c 74 12 00 pushl 0x12744c 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 a4 51 12 00 mov 0x1251a4,%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 a8 51 12 00 mov 0x1251a8,%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 a0 51 12 00 pushl 0x1251a0 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 54 74 12 00 mov %eax,0x127454 if (rtems_termios_ttyTail == NULL) 1091f2: 8b 0d 50 74 12 00 mov 0x127450,%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 ac 51 12 00 movsbl 0x1251ac,%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 ac 51 12 00 movsbl 0x1251ac,%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 ac 51 12 00 movsbl 0x1251ac,%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 ac 51 12 00 mov 0x1251ac,%al 109371: 8d 48 01 lea 0x1(%eax),%ecx 109374: 88 0d ac 51 12 00 mov %cl,0x1251ac 10937a: 3c 7a cmp $0x7a,%al 10937c: 0f 85 e6 fc ff ff jne 109068 c = 'a'; 109382: c6 05 ac 51 12 00 61 movb $0x61,0x1251ac 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 4c 74 12 00 pushl 0x12744c 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 4c 74 12 00 pushl 0x12744c 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 ac 51 12 00 movsbl 0x1251ac,%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 e4 28 00 00 call 10bd00 /* * 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 ac 51 12 00 movsbl 0x1251ac,%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 ac 51 12 00 movsbl 0x1251ac,%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 50 74 12 00 mov %eax,0x127450 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 <== NOT EXECUTED 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 109bfa: 50 push %eax <== NOT EXECUTED 109bfb: e8 00 21 00 00 call 10bd00 <== 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 e8 70 12 00 mov 0x1270e8(%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 a0 51 12 00 mov 0x1251a0,%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 a0 51 12 00 mov 0x1251a0,%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 f4 70 12 00 mov 0x1270f4(%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 <== NOT EXECUTED 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 ec 70 12 00 mov 0x1270ec(%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 =============================================================================== 001186e0 : */ rtems_status_code rtems_timer_cancel( rtems_id id ) { 1186e0: 55 push %ebp 1186e1: 89 e5 mov %esp,%ebp 1186e3: 83 ec 1c sub $0x1c,%esp Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); 1186e6: 8d 45 f4 lea -0xc(%ebp),%eax Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) _Objects_Get( &_Timer_Information, id, location ); 1186e9: 50 push %eax 1186ea: ff 75 08 pushl 0x8(%ebp) 1186ed: 68 80 2c 14 00 push $0x142c80 1186f2: e8 ed 2b 00 00 call 11b2e4 <_Objects_Get> switch ( location ) { 1186f7: 83 c4 10 add $0x10,%esp 1186fa: 8b 55 f4 mov -0xc(%ebp),%edx 1186fd: 85 d2 test %edx,%edx 1186ff: 74 07 je 118708 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 118701: b8 04 00 00 00 mov $0x4,%eax } 118706: c9 leave 118707: c3 ret the_timer = _Timer_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Timer_Is_dormant_class( the_timer->the_class ) ) 118708: 83 78 38 04 cmpl $0x4,0x38(%eax) 11870c: 74 0f je 11871d <== NEVER TAKEN (void) _Watchdog_Remove( &the_timer->Ticker ); 11870e: 83 ec 0c sub $0xc,%esp 118711: 83 c0 10 add $0x10,%eax 118714: 50 push %eax 118715: e8 56 48 00 00 call 11cf70 <_Watchdog_Remove> 11871a: 83 c4 10 add $0x10,%esp _Thread_Enable_dispatch(); 11871d: e8 76 36 00 00 call 11bd98 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 118722: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 118724: c9 leave 118725: c3 ret =============================================================================== 0010bffc : rtems_status_code rtems_timer_create( rtems_name name, rtems_id *id ) { 10bffc: 55 push %ebp 10bffd: 89 e5 mov %esp,%ebp 10bfff: 57 push %edi 10c000: 56 push %esi 10c001: 53 push %ebx 10c002: 83 ec 0c sub $0xc,%esp 10c005: 8b 5d 08 mov 0x8(%ebp),%ebx 10c008: 8b 75 0c mov 0xc(%ebp),%esi Timer_Control *the_timer; if ( !rtems_is_name_valid( name ) ) 10c00b: 85 db test %ebx,%ebx 10c00d: 74 6d je 10c07c return RTEMS_INVALID_NAME; if ( !id ) 10c00f: 85 f6 test %esi,%esi 10c011: 0f 84 89 00 00 00 je 10c0a0 10c017: a1 d0 8f 12 00 mov 0x128fd0,%eax 10c01c: 40 inc %eax 10c01d: a3 d0 8f 12 00 mov %eax,0x128fd0 * 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 ); 10c022: 83 ec 0c sub $0xc,%esp 10c025: 68 40 9a 12 00 push $0x129a40 10c02a: e8 29 0f 00 00 call 10cf58 <_Objects_Allocate> _Thread_Disable_dispatch(); /* to prevent deletion */ the_timer = _Timer_Allocate(); if ( !the_timer ) { 10c02f: 83 c4 10 add $0x10,%esp 10c032: 85 c0 test %eax,%eax 10c034: 74 56 je 10c08c _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_timer->the_class = TIMER_DORMANT; 10c036: 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; 10c03d: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) the_watchdog->routine = routine; 10c044: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax) the_watchdog->id = id; 10c04b: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax) the_watchdog->user_data = user_data; 10c052: 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 ), 10c059: 8b 50 08 mov 0x8(%eax),%edx Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 10c05c: 0f b7 fa movzwl %dx,%edi #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10c05f: 8b 0d 5c 9a 12 00 mov 0x129a5c,%ecx 10c065: 89 04 b9 mov %eax,(%ecx,%edi,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 10c068: 89 58 0c mov %ebx,0xc(%eax) &_Timer_Information, &the_timer->Object, (Objects_Name) name ); *id = the_timer->Object.id; 10c06b: 89 16 mov %edx,(%esi) _Thread_Enable_dispatch(); 10c06d: e8 52 1e 00 00 call 10dec4 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10c072: 31 c0 xor %eax,%eax } 10c074: 8d 65 f4 lea -0xc(%ebp),%esp 10c077: 5b pop %ebx 10c078: 5e pop %esi 10c079: 5f pop %edi 10c07a: c9 leave 10c07b: c3 ret ) { Timer_Control *the_timer; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 10c07c: b8 03 00 00 00 mov $0x3,%eax ); *id = the_timer->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10c081: 8d 65 f4 lea -0xc(%ebp),%esp 10c084: 5b pop %ebx 10c085: 5e pop %esi 10c086: 5f pop %edi 10c087: c9 leave 10c088: c3 ret 10c089: 8d 76 00 lea 0x0(%esi),%esi _Thread_Disable_dispatch(); /* to prevent deletion */ the_timer = _Timer_Allocate(); if ( !the_timer ) { _Thread_Enable_dispatch(); 10c08c: e8 33 1e 00 00 call 10dec4 <_Thread_Enable_dispatch> return RTEMS_TOO_MANY; 10c091: b8 05 00 00 00 mov $0x5,%eax ); *id = the_timer->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10c096: 8d 65 f4 lea -0xc(%ebp),%esp 10c099: 5b pop %ebx 10c09a: 5e pop %esi 10c09b: 5f pop %edi 10c09c: c9 leave 10c09d: c3 ret 10c09e: 66 90 xchg %ax,%ax if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !id ) return RTEMS_INVALID_ADDRESS; 10c0a0: b8 09 00 00 00 mov $0x9,%eax ); *id = the_timer->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10c0a5: 8d 65 f4 lea -0xc(%ebp),%esp 10c0a8: 5b pop %ebx 10c0a9: 5e pop %esi 10c0aa: 5f pop %edi 10c0ab: c9 leave 10c0ac: c3 ret =============================================================================== 001187dc : */ rtems_status_code rtems_timer_delete( rtems_id id ) { 1187dc: 55 push %ebp 1187dd: 89 e5 mov %esp,%ebp 1187df: 53 push %ebx 1187e0: 83 ec 18 sub $0x18,%esp Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); 1187e3: 8d 45 f4 lea -0xc(%ebp),%eax Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) _Objects_Get( &_Timer_Information, id, location ); 1187e6: 50 push %eax 1187e7: ff 75 08 pushl 0x8(%ebp) 1187ea: 68 80 2c 14 00 push $0x142c80 1187ef: e8 f0 2a 00 00 call 11b2e4 <_Objects_Get> 1187f4: 89 c3 mov %eax,%ebx switch ( location ) { 1187f6: 83 c4 10 add $0x10,%esp 1187f9: 8b 4d f4 mov -0xc(%ebp),%ecx 1187fc: 85 c9 test %ecx,%ecx 1187fe: 75 38 jne 118838 case OBJECTS_LOCAL: _Objects_Close( &_Timer_Information, &the_timer->Object ); 118800: 83 ec 08 sub $0x8,%esp 118803: 50 push %eax 118804: 68 80 2c 14 00 push $0x142c80 118809: e8 5e 26 00 00 call 11ae6c <_Objects_Close> (void) _Watchdog_Remove( &the_timer->Ticker ); 11880e: 8d 43 10 lea 0x10(%ebx),%eax 118811: 89 04 24 mov %eax,(%esp) 118814: e8 57 47 00 00 call 11cf70 <_Watchdog_Remove> */ RTEMS_INLINE_ROUTINE void _Timer_Free ( Timer_Control *the_timer ) { _Objects_Free( &_Timer_Information, &the_timer->Object ); 118819: 58 pop %eax 11881a: 5a pop %edx 11881b: 53 push %ebx 11881c: 68 80 2c 14 00 push $0x142c80 118821: e8 42 29 00 00 call 11b168 <_Objects_Free> _Timer_Free( the_timer ); _Thread_Enable_dispatch(); 118826: e8 6d 35 00 00 call 11bd98 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 11882b: 83 c4 10 add $0x10,%esp 11882e: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 118830: 8b 5d fc mov -0x4(%ebp),%ebx 118833: c9 leave 118834: c3 ret 118835: 8d 76 00 lea 0x0(%esi),%esi #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 118838: b8 04 00 00 00 mov $0x4,%eax } 11883d: 8b 5d fc mov -0x4(%ebp),%ebx 118840: c9 leave 118841: c3 ret =============================================================================== 0010c0b0 : rtems_id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 10c0b0: 55 push %ebp 10c0b1: 89 e5 mov %esp,%ebp 10c0b3: 57 push %edi 10c0b4: 56 push %esi 10c0b5: 53 push %ebx 10c0b6: 83 ec 2c sub $0x2c,%esp 10c0b9: 8b 5d 0c mov 0xc(%ebp),%ebx 10c0bc: 8b 75 10 mov 0x10(%ebp),%esi Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( ticks == 0 ) 10c0bf: 85 db test %ebx,%ebx 10c0c1: 0f 84 99 00 00 00 je 10c160 return RTEMS_INVALID_NUMBER; if ( !routine ) 10c0c7: 85 f6 test %esi,%esi 10c0c9: 0f 84 b1 00 00 00 je 10c180 Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) _Objects_Get( &_Timer_Information, id, location ); 10c0cf: 57 push %edi return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); 10c0d0: 8d 45 e4 lea -0x1c(%ebp),%eax 10c0d3: 50 push %eax 10c0d4: ff 75 08 pushl 0x8(%ebp) 10c0d7: 68 40 9a 12 00 push $0x129a40 10c0dc: e8 2f 13 00 00 call 10d410 <_Objects_Get> 10c0e1: 89 c7 mov %eax,%edi switch ( location ) { 10c0e3: 83 c4 10 add $0x10,%esp 10c0e6: 8b 4d e4 mov -0x1c(%ebp),%ecx 10c0e9: 85 c9 test %ecx,%ecx 10c0eb: 74 0f je 10c0fc #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10c0ed: b8 04 00 00 00 mov $0x4,%eax } 10c0f2: 8d 65 f4 lea -0xc(%ebp),%esp 10c0f5: 5b pop %ebx 10c0f6: 5e pop %esi 10c0f7: 5f pop %edi 10c0f8: c9 leave 10c0f9: c3 ret 10c0fa: 66 90 xchg %ax,%ax the_timer = _Timer_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 10c0fc: 8d 50 10 lea 0x10(%eax),%edx 10c0ff: 83 ec 0c sub $0xc,%esp 10c102: 52 push %edx 10c103: 89 55 d4 mov %edx,-0x2c(%ebp) 10c106: e8 fd 2c 00 00 call 10ee08 <_Watchdog_Remove> _ISR_Disable( level ); 10c10b: 9c pushf 10c10c: fa cli 10c10d: 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 ) { 10c10e: 83 c4 10 add $0x10,%esp 10c111: 8b 57 18 mov 0x18(%edi),%edx 10c114: 85 d2 test %edx,%edx 10c116: 8b 55 d4 mov -0x2c(%ebp),%edx 10c119: 75 55 jne 10c170 /* * 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; 10c11b: 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; 10c122: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi) the_watchdog->routine = routine; 10c129: 89 77 2c mov %esi,0x2c(%edi) the_watchdog->id = id; 10c12c: 8b 4d 08 mov 0x8(%ebp),%ecx 10c12f: 89 4f 30 mov %ecx,0x30(%edi) the_watchdog->user_data = user_data; 10c132: 8b 4d 14 mov 0x14(%ebp),%ecx 10c135: 89 4f 34 mov %ecx,0x34(%edi) _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); _ISR_Enable( level ); 10c138: 50 push %eax 10c139: 9d popf Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10c13a: 89 5f 1c mov %ebx,0x1c(%edi) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10c13d: 83 ec 08 sub $0x8,%esp 10c140: 52 push %edx 10c141: 68 dc 90 12 00 push $0x1290dc 10c146: e8 7d 2b 00 00 call 10ecc8 <_Watchdog_Insert> _Watchdog_Insert_ticks( &the_timer->Ticker, ticks ); _Thread_Enable_dispatch(); 10c14b: e8 74 1d 00 00 call 10dec4 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10c150: 83 c4 10 add $0x10,%esp 10c153: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10c155: 8d 65 f4 lea -0xc(%ebp),%esp 10c158: 5b pop %ebx 10c159: 5e pop %esi 10c15a: 5f pop %edi 10c15b: c9 leave 10c15c: c3 ret 10c15d: 8d 76 00 lea 0x0(%esi),%esi Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( ticks == 0 ) return RTEMS_INVALID_NUMBER; 10c160: b8 0a 00 00 00 mov $0xa,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10c165: 8d 65 f4 lea -0xc(%ebp),%esp 10c168: 5b pop %ebx 10c169: 5e pop %esi 10c16a: 5f pop %edi 10c16b: c9 leave 10c16c: c3 ret 10c16d: 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 ); 10c170: 50 push %eax 10c171: 9d popf _Thread_Enable_dispatch(); 10c172: e8 4d 1d 00 00 call 10dec4 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10c177: 31 c0 xor %eax,%eax 10c179: e9 74 ff ff ff jmp 10c0f2 10c17e: 66 90 xchg %ax,%ax if ( ticks == 0 ) return RTEMS_INVALID_NUMBER; if ( !routine ) return RTEMS_INVALID_ADDRESS; 10c180: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10c185: 8d 65 f4 lea -0xc(%ebp),%esp 10c188: 5b pop %ebx 10c189: 5e pop %esi 10c18a: 5f pop %edi 10c18b: c9 leave 10c18c: c3 ret =============================================================================== 00118924 : rtems_id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 118924: 55 push %ebp 118925: 89 e5 mov %esp,%ebp 118927: 57 push %edi 118928: 56 push %esi 118929: 53 push %ebx 11892a: 83 ec 2c sub $0x2c,%esp 11892d: 8b 75 08 mov 0x8(%ebp),%esi 118930: 8b 7d 0c mov 0xc(%ebp),%edi 118933: 8b 5d 10 mov 0x10(%ebp),%ebx Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; if ( !_TOD_Is_set ) 118936: 80 3d 24 22 14 00 00 cmpb $0x0,0x142224 11893d: 75 0d jne 11894c return RTEMS_NOT_DEFINED; 11893f: b8 0b 00 00 00 mov $0xb,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 118944: 8d 65 f4 lea -0xc(%ebp),%esp 118947: 5b pop %ebx 118948: 5e pop %esi 118949: 5f pop %edi 11894a: c9 leave 11894b: c3 ret rtems_interval seconds; if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; if ( !_TOD_Validate( wall_time ) ) 11894c: 83 ec 0c sub $0xc,%esp 11894f: 57 push %edi 118950: e8 87 d4 ff ff call 115ddc <_TOD_Validate> 118955: 83 c4 10 add $0x10,%esp 118958: 84 c0 test %al,%al 11895a: 74 1e je 11897a return RTEMS_INVALID_CLOCK; if ( !routine ) 11895c: 85 db test %ebx,%ebx 11895e: 0f 84 a4 00 00 00 je 118a08 return RTEMS_INVALID_ADDRESS; seconds = _TOD_To_seconds( wall_time ); 118964: 83 ec 0c sub $0xc,%esp 118967: 57 push %edi 118968: e8 e3 d3 ff ff call 115d50 <_TOD_To_seconds> 11896d: 89 c7 mov %eax,%edi if ( seconds <= _TOD_Seconds_since_epoch() ) 11896f: 83 c4 10 add $0x10,%esp 118972: 3b 05 e4 22 14 00 cmp 0x1422e4,%eax 118978: 77 0e ja 118988 return RTEMS_INVALID_CLOCK; 11897a: b8 14 00 00 00 mov $0x14,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11897f: 8d 65 f4 lea -0xc(%ebp),%esp 118982: 5b pop %ebx 118983: 5e pop %esi 118984: 5f pop %edi 118985: c9 leave 118986: c3 ret 118987: 90 nop 118988: 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 ); 118989: 8d 45 e4 lea -0x1c(%ebp),%eax 11898c: 50 push %eax 11898d: 56 push %esi 11898e: 68 80 2c 14 00 push $0x142c80 118993: e8 4c 29 00 00 call 11b2e4 <_Objects_Get> switch ( location ) { 118998: 83 c4 10 add $0x10,%esp 11899b: 8b 4d e4 mov -0x1c(%ebp),%ecx 11899e: 85 c9 test %ecx,%ecx 1189a0: 75 5a jne 1189fc case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 1189a2: 8d 48 10 lea 0x10(%eax),%ecx 1189a5: 83 ec 0c sub $0xc,%esp 1189a8: 51 push %ecx 1189a9: 89 45 d0 mov %eax,-0x30(%ebp) 1189ac: 89 4d d4 mov %ecx,-0x2c(%ebp) 1189af: e8 bc 45 00 00 call 11cf70 <_Watchdog_Remove> the_timer->the_class = TIMER_TIME_OF_DAY; 1189b4: 8b 55 d0 mov -0x30(%ebp),%edx 1189b7: 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; 1189be: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx) the_watchdog->routine = routine; 1189c5: 89 5a 2c mov %ebx,0x2c(%edx) the_watchdog->id = id; 1189c8: 89 72 30 mov %esi,0x30(%edx) the_watchdog->user_data = user_data; 1189cb: 8b 45 14 mov 0x14(%ebp),%eax 1189ce: 89 42 34 mov %eax,0x34(%edx) _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); _Watchdog_Insert_seconds( 1189d1: 2b 3d e4 22 14 00 sub 0x1422e4,%edi 1189d7: 89 7a 1c mov %edi,0x1c(%edx) ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 1189da: 58 pop %eax 1189db: 5a pop %edx 1189dc: 8b 4d d4 mov -0x2c(%ebp),%ecx 1189df: 51 push %ecx 1189e0: 68 10 23 14 00 push $0x142310 1189e5: e8 46 44 00 00 call 11ce30 <_Watchdog_Insert> &the_timer->Ticker, seconds - _TOD_Seconds_since_epoch() ); _Thread_Enable_dispatch(); 1189ea: e8 a9 33 00 00 call 11bd98 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 1189ef: 83 c4 10 add $0x10,%esp 1189f2: 31 c0 xor %eax,%eax 1189f4: e9 4b ff ff ff jmp 118944 1189f9: 8d 76 00 lea 0x0(%esi),%esi #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 1189fc: b8 04 00 00 00 mov $0x4,%eax 118a01: e9 3e ff ff ff jmp 118944 118a06: 66 90 xchg %ax,%ax if ( !_TOD_Validate( wall_time ) ) return RTEMS_INVALID_CLOCK; if ( !routine ) return RTEMS_INVALID_ADDRESS; 118a08: b8 09 00 00 00 mov $0x9,%eax 118a0d: e9 32 ff ff ff jmp 118944 =============================================================================== 001190bc : rtems_status_code rtems_timer_initiate_server( uint32_t priority, uint32_t stack_size, rtems_attribute attribute_set ) { 1190bc: 55 push %ebp 1190bd: 89 e5 mov %esp,%ebp 1190bf: 56 push %esi 1190c0: 53 push %ebx 1190c1: 83 ec 10 sub $0x10,%esp 1190c4: 8b 45 08 mov 0x8(%ebp),%eax 1190c7: 85 c0 test %eax,%eax 1190c9: 74 41 je 11910c ( the_priority <= RTEMS_MAXIMUM_PRIORITY ) ); 1190cb: 0f b6 15 d4 9a 13 00 movzbl 0x139ad4,%edx */ RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid ( rtems_task_priority the_priority ) { return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) && 1190d2: 39 d0 cmp %edx,%eax 1190d4: 76 42 jbe 119118 * 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 ) 1190d6: 40 inc %eax 1190d7: 75 33 jne 11910c return RTEMS_INVALID_PRIORITY; _priority = 0; 1190d9: 31 f6 xor %esi,%esi 1190db: 8b 15 10 22 14 00 mov 0x142210,%edx 1190e1: 42 inc %edx 1190e2: 89 15 10 22 14 00 mov %edx,0x142210 /* * Just to make sure this is only called once. */ _Thread_Disable_dispatch(); tmpInitialized = initialized; 1190e8: 8a 1d 40 db 13 00 mov 0x13db40,%bl initialized = true; 1190ee: c6 05 40 db 13 00 01 movb $0x1,0x13db40 _Thread_Enable_dispatch(); 1190f5: e8 9e 2c 00 00 call 11bd98 <_Thread_Enable_dispatch> if ( tmpInitialized ) 1190fa: 84 db test %bl,%bl 1190fc: 74 1e je 11911c return RTEMS_INCORRECT_STATE; 1190fe: b8 0e 00 00 00 mov $0xe,%eax initialized = false; } #endif return status; } 119103: 8d 65 f8 lea -0x8(%ebp),%esp 119106: 5b pop %ebx 119107: 5e pop %esi 119108: c9 leave 119109: c3 ret 11910a: 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; 11910c: b8 13 00 00 00 mov $0x13,%eax initialized = false; } #endif return status; } 119111: 8d 65 f8 lea -0x8(%ebp),%esp 119114: 5b pop %ebx 119115: 5e pop %esi 119116: c9 leave 119117: c3 ret 119118: 89 c6 mov %eax,%esi 11911a: eb bf jmp 1190db * 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( 11911c: 83 ec 08 sub $0x8,%esp 11911f: 8d 45 f4 lea -0xc(%ebp),%eax 119122: 50 push %eax 119123: 8b 45 10 mov 0x10(%ebp),%eax 119126: 80 cc 80 or $0x80,%ah 119129: 50 push %eax 11912a: 68 00 01 00 00 push $0x100 11912f: ff 75 0c pushl 0xc(%ebp) 119132: 56 push %esi 119133: 68 45 4d 49 54 push $0x54494d45 119138: e8 bb 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) { 11913d: 83 c4 20 add $0x20,%esp 119140: 85 c0 test %eax,%eax 119142: 74 10 je 119154 initialized = false; 119144: c6 05 40 db 13 00 00 movb $0x0,0x13db40 initialized = false; } #endif return status; } 11914b: 8d 65 f8 lea -0x8(%ebp),%esp 11914e: 5b pop %ebx 11914f: 5e pop %esi 119150: c9 leave 119151: c3 ret 119152: 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) 119154: 8b 45 f4 mov -0xc(%ebp),%eax */ #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return NULL; #endif return information->local_table[ index ]; 119157: 0f b7 c8 movzwl %ax,%ecx 11915a: 8b 15 bc 21 14 00 mov 0x1421bc,%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( 119160: 8b 14 8a mov (%edx,%ecx,4),%edx 119163: 89 15 c0 da 13 00 mov %edx,0x13dac0 ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 119169: c7 05 f0 da 13 00 f4 movl $0x13daf4,0x13daf0 119170: da 13 00 head->previous = NULL; 119173: c7 05 f4 da 13 00 00 movl $0x0,0x13daf4 11917a: 00 00 00 tail->previous = head; 11917d: c7 05 f8 da 13 00 f0 movl $0x13daf0,0x13daf8 119184: da 13 00 ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 119187: c7 05 28 db 13 00 2c movl $0x13db2c,0x13db28 11918e: db 13 00 head->previous = NULL; 119191: c7 05 2c db 13 00 00 movl $0x0,0x13db2c 119198: 00 00 00 tail->previous = head; 11919b: c7 05 30 db 13 00 28 movl $0x13db28,0x13db30 1191a2: db 13 00 Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 1191a5: c7 05 d0 da 13 00 00 movl $0x0,0x13dad0 1191ac: 00 00 00 the_watchdog->routine = routine; 1191af: c7 05 e4 da 13 00 e4 movl $0x11bbe4,0x13dae4 1191b6: bb 11 00 the_watchdog->id = id; 1191b9: a3 e8 da 13 00 mov %eax,0x13dae8 the_watchdog->user_data = user_data; 1191be: c7 05 ec da 13 00 00 movl $0x0,0x13daec 1191c5: 00 00 00 Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 1191c8: c7 05 08 db 13 00 00 movl $0x0,0x13db08 1191cf: 00 00 00 the_watchdog->routine = routine; 1191d2: c7 05 1c db 13 00 e4 movl $0x11bbe4,0x13db1c 1191d9: bb 11 00 the_watchdog->id = id; 1191dc: a3 20 db 13 00 mov %eax,0x13db20 the_watchdog->user_data = user_data; 1191e1: c7 05 24 db 13 00 00 movl $0x0,0x13db24 1191e8: 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; 1191eb: c7 05 c4 da 13 00 8c movl $0x118f8c,0x13dac4 1191f2: 8f 11 00 ts->Interval_watchdogs.last_snapshot = _Watchdog_Ticks_since_boot; 1191f5: 8b 15 84 23 14 00 mov 0x142384,%edx 1191fb: 89 15 fc da 13 00 mov %edx,0x13dafc ts->TOD_watchdogs.last_snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); 119201: 8b 15 e4 22 14 00 mov 0x1422e4,%edx 119207: 89 15 34 db 13 00 mov %edx,0x13db34 ts->insert_chain = NULL; 11920d: c7 05 38 db 13 00 00 movl $0x0,0x13db38 119214: 00 00 00 ts->active = false; 119217: c6 05 3c db 13 00 00 movb $0x0,0x13db3c /* * The default timer server is now available. */ _Timer_server = ts; 11921e: c7 05 c0 2c 14 00 c0 movl $0x13dac0,0x142cc0 119225: da 13 00 /* * Start the timer server */ status = rtems_task_start( 119228: 53 push %ebx 119229: 68 c0 da 13 00 push $0x13dac0 11922e: 68 c4 8d 11 00 push $0x118dc4 119233: 50 push %eax 119234: e8 7f f2 ff ff call 1184b8 if (status) { initialized = false; } #endif return status; 119239: 83 c4 10 add $0x10,%esp 11923c: e9 d0 fe ff ff jmp 119111 =============================================================================== 00118a9c : */ rtems_status_code rtems_timer_reset( rtems_id id ) { 118a9c: 55 push %ebp 118a9d: 89 e5 mov %esp,%ebp 118a9f: 56 push %esi 118aa0: 53 push %ebx 118aa1: 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 ); 118aa4: 8d 45 f4 lea -0xc(%ebp),%eax 118aa7: 50 push %eax 118aa8: ff 75 08 pushl 0x8(%ebp) 118aab: 68 80 2c 14 00 push $0x142c80 118ab0: e8 2f 28 00 00 call 11b2e4 <_Objects_Get> 118ab5: 89 c3 mov %eax,%ebx switch ( location ) { 118ab7: 83 c4 10 add $0x10,%esp 118aba: 8b 45 f4 mov -0xc(%ebp),%eax 118abd: 85 c0 test %eax,%eax 118abf: 74 0f je 118ad0 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 118ac1: b8 04 00 00 00 mov $0x4,%eax } 118ac6: 8d 65 f8 lea -0x8(%ebp),%esp 118ac9: 5b pop %ebx 118aca: 5e pop %esi 118acb: c9 leave 118acc: c3 ret 118acd: 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 ) { 118ad0: 8b 43 38 mov 0x38(%ebx),%eax 118ad3: 85 c0 test %eax,%eax 118ad5: 74 1d je 118af4 _Watchdog_Remove( &the_timer->Ticker ); _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker ); } else if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) { 118ad7: 48 dec %eax 118ad8: 74 3a je 118b14 /* * 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; 118ada: b8 0b 00 00 00 mov $0xb,%eax } _Thread_Enable_dispatch(); 118adf: 89 45 e4 mov %eax,-0x1c(%ebp) 118ae2: e8 b1 32 00 00 call 11bd98 <_Thread_Enable_dispatch> return status; 118ae7: 8b 45 e4 mov -0x1c(%ebp),%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 118aea: 8d 65 f8 lea -0x8(%ebp),%esp 118aed: 5b pop %ebx 118aee: 5e pop %esi 118aef: c9 leave 118af0: c3 ret 118af1: 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 ); 118af4: 83 c3 10 add $0x10,%ebx 118af7: 83 ec 0c sub $0xc,%esp 118afa: 53 push %ebx 118afb: e8 70 44 00 00 call 11cf70 <_Watchdog_Remove> _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker ); 118b00: 59 pop %ecx 118b01: 5e pop %esi 118b02: 53 push %ebx 118b03: 68 1c 23 14 00 push $0x14231c 118b08: e8 23 43 00 00 call 11ce30 <_Watchdog_Insert> 118b0d: 83 c4 10 add $0x10,%esp rtems_id id ) { Timer_Control *the_timer; Objects_Locations location; rtems_status_code status = RTEMS_SUCCESSFUL; 118b10: 31 c0 xor %eax,%eax 118b12: eb cb jmp 118adf 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; 118b14: 8b 35 c0 2c 14 00 mov 0x142cc0,%esi if ( !timer_server ) { _Thread_Enable_dispatch(); return RTEMS_INCORRECT_STATE; } #endif _Watchdog_Remove( &the_timer->Ticker ); 118b1a: 83 ec 0c sub $0xc,%esp 118b1d: 8d 43 10 lea 0x10(%ebx),%eax 118b20: 50 push %eax 118b21: e8 4a 44 00 00 call 11cf70 <_Watchdog_Remove> (*timer_server->schedule_operation)( timer_server, the_timer ); 118b26: 58 pop %eax 118b27: 5a pop %edx 118b28: 53 push %ebx 118b29: 56 push %esi 118b2a: ff 56 04 call *0x4(%esi) 118b2d: 83 c4 10 add $0x10,%esp rtems_id id ) { Timer_Control *the_timer; Objects_Locations location; rtems_status_code status = RTEMS_SUCCESSFUL; 118b30: 31 c0 xor %eax,%eax 118b32: eb ab jmp 118adf =============================================================================== 00118b34 : rtems_id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 118b34: 55 push %ebp 118b35: 89 e5 mov %esp,%ebp 118b37: 57 push %edi 118b38: 56 push %esi 118b39: 53 push %ebx 118b3a: 83 ec 2c sub $0x2c,%esp 118b3d: 8b 7d 0c mov 0xc(%ebp),%edi 118b40: 8b 75 10 mov 0x10(%ebp),%esi Timer_Control *the_timer; Objects_Locations location; ISR_Level level; Timer_server_Control *timer_server = _Timer_server; 118b43: 8b 1d c0 2c 14 00 mov 0x142cc0,%ebx if ( !timer_server ) 118b49: 85 db test %ebx,%ebx 118b4b: 0f 84 9f 00 00 00 je 118bf0 return RTEMS_INCORRECT_STATE; if ( !routine ) 118b51: 85 f6 test %esi,%esi 118b53: 0f 84 a3 00 00 00 je 118bfc return RTEMS_INVALID_ADDRESS; if ( ticks == 0 ) 118b59: 85 ff test %edi,%edi 118b5b: 75 0f jne 118b6c return RTEMS_INVALID_NUMBER; 118b5d: b8 0a 00 00 00 mov $0xa,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 118b62: 8d 65 f4 lea -0xc(%ebp),%esp 118b65: 5b pop %ebx 118b66: 5e pop %esi 118b67: 5f pop %edi 118b68: c9 leave 118b69: c3 ret 118b6a: 66 90 xchg %ax,%ax 118b6c: 52 push %edx return RTEMS_INVALID_ADDRESS; if ( ticks == 0 ) return RTEMS_INVALID_NUMBER; the_timer = _Timer_Get( id, &location ); 118b6d: 8d 45 e4 lea -0x1c(%ebp),%eax 118b70: 50 push %eax 118b71: ff 75 08 pushl 0x8(%ebp) 118b74: 68 80 2c 14 00 push $0x142c80 118b79: e8 66 27 00 00 call 11b2e4 <_Objects_Get> 118b7e: 89 c2 mov %eax,%edx switch ( location ) { 118b80: 83 c4 10 add $0x10,%esp 118b83: 8b 45 e4 mov -0x1c(%ebp),%eax 118b86: 85 c0 test %eax,%eax 118b88: 75 56 jne 118be0 case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 118b8a: 83 ec 0c sub $0xc,%esp 118b8d: 8d 42 10 lea 0x10(%edx),%eax 118b90: 50 push %eax 118b91: 89 55 d4 mov %edx,-0x2c(%ebp) 118b94: e8 d7 43 00 00 call 11cf70 <_Watchdog_Remove> _ISR_Disable( level ); 118b99: 9c pushf 118b9a: fa cli 118b9b: 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 ) { 118b9c: 83 c4 10 add $0x10,%esp 118b9f: 8b 55 d4 mov -0x2c(%ebp),%edx 118ba2: 8b 4a 18 mov 0x18(%edx),%ecx 118ba5: 85 c9 test %ecx,%ecx 118ba7: 75 5f jne 118c08 /* * 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; 118ba9: 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; 118bb0: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx) the_watchdog->routine = routine; 118bb7: 89 72 2c mov %esi,0x2c(%edx) the_watchdog->id = id; 118bba: 8b 4d 08 mov 0x8(%ebp),%ecx 118bbd: 89 4a 30 mov %ecx,0x30(%edx) the_watchdog->user_data = user_data; 118bc0: 8b 4d 14 mov 0x14(%ebp),%ecx 118bc3: 89 4a 34 mov %ecx,0x34(%edx) _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); the_timer->Ticker.initial = ticks; 118bc6: 89 7a 1c mov %edi,0x1c(%edx) _ISR_Enable( level ); 118bc9: 50 push %eax 118bca: 9d popf (*timer_server->schedule_operation)( timer_server, the_timer ); 118bcb: 83 ec 08 sub $0x8,%esp 118bce: 52 push %edx 118bcf: 53 push %ebx 118bd0: ff 53 04 call *0x4(%ebx) _Thread_Enable_dispatch(); 118bd3: e8 c0 31 00 00 call 11bd98 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 118bd8: 83 c4 10 add $0x10,%esp 118bdb: 31 c0 xor %eax,%eax 118bdd: eb 83 jmp 118b62 118bdf: 90 nop #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 118be0: b8 04 00 00 00 mov $0x4,%eax } 118be5: 8d 65 f4 lea -0xc(%ebp),%esp 118be8: 5b pop %ebx 118be9: 5e pop %esi 118bea: 5f pop %edi 118beb: c9 leave 118bec: c3 ret 118bed: 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; 118bf0: b8 0e 00 00 00 mov $0xe,%eax 118bf5: e9 68 ff ff ff jmp 118b62 118bfa: 66 90 xchg %ax,%ax if ( !routine ) return RTEMS_INVALID_ADDRESS; 118bfc: b8 09 00 00 00 mov $0x9,%eax 118c01: e9 5c ff ff ff jmp 118b62 118c06: 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 ); 118c08: 50 push %eax 118c09: 9d popf _Thread_Enable_dispatch(); 118c0a: e8 89 31 00 00 call 11bd98 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 118c0f: 31 c0 xor %eax,%eax 118c11: e9 4c ff ff ff jmp 118b62 =============================================================================== 00118c18 : rtems_id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 118c18: 55 push %ebp 118c19: 89 e5 mov %esp,%ebp 118c1b: 57 push %edi 118c1c: 56 push %esi 118c1d: 53 push %ebx 118c1e: 83 ec 2c sub $0x2c,%esp 118c21: 8b 7d 0c mov 0xc(%ebp),%edi 118c24: 8b 75 10 mov 0x10(%ebp),%esi Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server; 118c27: 8b 1d c0 2c 14 00 mov 0x142cc0,%ebx if ( !timer_server ) 118c2d: 85 db test %ebx,%ebx 118c2f: 0f 84 d7 00 00 00 je 118d0c return RTEMS_INCORRECT_STATE; if ( !_TOD_Is_set ) 118c35: 80 3d 24 22 14 00 00 cmpb $0x0,0x142224 118c3c: 0f 84 aa 00 00 00 je 118cec <== NEVER TAKEN return RTEMS_NOT_DEFINED; if ( !routine ) 118c42: 85 f6 test %esi,%esi 118c44: 0f 84 b2 00 00 00 je 118cfc return RTEMS_INVALID_ADDRESS; if ( !_TOD_Validate( wall_time ) ) 118c4a: 83 ec 0c sub $0xc,%esp 118c4d: 57 push %edi 118c4e: e8 89 d1 ff ff call 115ddc <_TOD_Validate> 118c53: 83 c4 10 add $0x10,%esp 118c56: 84 c0 test %al,%al 118c58: 75 0e jne 118c68 return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( wall_time ); if ( seconds <= _TOD_Seconds_since_epoch() ) return RTEMS_INVALID_CLOCK; 118c5a: b8 14 00 00 00 mov $0x14,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 118c5f: 8d 65 f4 lea -0xc(%ebp),%esp 118c62: 5b pop %ebx 118c63: 5e pop %esi 118c64: 5f pop %edi 118c65: c9 leave 118c66: c3 ret 118c67: 90 nop return RTEMS_INVALID_ADDRESS; if ( !_TOD_Validate( wall_time ) ) return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( wall_time ); 118c68: 83 ec 0c sub $0xc,%esp 118c6b: 57 push %edi 118c6c: e8 df d0 ff ff call 115d50 <_TOD_To_seconds> 118c71: 89 c7 mov %eax,%edi if ( seconds <= _TOD_Seconds_since_epoch() ) 118c73: 83 c4 10 add $0x10,%esp 118c76: 3b 05 e4 22 14 00 cmp 0x1422e4,%eax 118c7c: 76 dc jbe 118c5a 118c7e: 52 push %edx return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); 118c7f: 8d 45 e4 lea -0x1c(%ebp),%eax 118c82: 50 push %eax 118c83: ff 75 08 pushl 0x8(%ebp) 118c86: 68 80 2c 14 00 push $0x142c80 118c8b: e8 54 26 00 00 call 11b2e4 <_Objects_Get> 118c90: 89 c2 mov %eax,%edx switch ( location ) { 118c92: 83 c4 10 add $0x10,%esp 118c95: 8b 45 e4 mov -0x1c(%ebp),%eax 118c98: 85 c0 test %eax,%eax 118c9a: 75 7c jne 118d18 case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 118c9c: 83 ec 0c sub $0xc,%esp 118c9f: 8d 42 10 lea 0x10(%edx),%eax 118ca2: 50 push %eax 118ca3: 89 55 d4 mov %edx,-0x2c(%ebp) 118ca6: e8 c5 42 00 00 call 11cf70 <_Watchdog_Remove> the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK; 118cab: 8b 55 d4 mov -0x2c(%ebp),%edx 118cae: 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; 118cb5: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx) the_watchdog->routine = routine; 118cbc: 89 72 2c mov %esi,0x2c(%edx) the_watchdog->id = id; 118cbf: 8b 45 08 mov 0x8(%ebp),%eax 118cc2: 89 42 30 mov %eax,0x30(%edx) the_watchdog->user_data = user_data; 118cc5: 8b 45 14 mov 0x14(%ebp),%eax 118cc8: 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(); 118ccb: 2b 3d e4 22 14 00 sub 0x1422e4,%edi 118cd1: 89 7a 1c mov %edi,0x1c(%edx) (*timer_server->schedule_operation)( timer_server, the_timer ); 118cd4: 58 pop %eax 118cd5: 59 pop %ecx 118cd6: 52 push %edx 118cd7: 53 push %ebx 118cd8: ff 53 04 call *0x4(%ebx) _Thread_Enable_dispatch(); 118cdb: e8 b8 30 00 00 call 11bd98 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 118ce0: 83 c4 10 add $0x10,%esp 118ce3: 31 c0 xor %eax,%eax 118ce5: e9 75 ff ff ff jmp 118c5f 118cea: 66 90 xchg %ax,%ax if ( !timer_server ) return RTEMS_INCORRECT_STATE; if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; 118cec: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 118cf1: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 118cf4: 5b pop %ebx <== NOT EXECUTED 118cf5: 5e pop %esi <== NOT EXECUTED 118cf6: 5f pop %edi <== NOT EXECUTED 118cf7: c9 leave <== NOT EXECUTED 118cf8: c3 ret <== NOT EXECUTED 118cf9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; if ( !routine ) return RTEMS_INVALID_ADDRESS; 118cfc: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 118d01: 8d 65 f4 lea -0xc(%ebp),%esp 118d04: 5b pop %ebx 118d05: 5e pop %esi 118d06: 5f pop %edi 118d07: c9 leave 118d08: c3 ret 118d09: 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; 118d0c: b8 0e 00 00 00 mov $0xe,%eax 118d11: e9 49 ff ff ff jmp 118c5f 118d16: 66 90 xchg %ax,%ax #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 118d18: b8 04 00 00 00 mov $0x4,%eax 118d1d: e9 3d ff ff ff jmp 118c5f =============================================================================== 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 60 e1 12 00 mov 0x12e160,%edx 10c71c: 8d 42 01 lea 0x1(%edx),%eax 10c71f: a3 60 e1 12 00 mov %eax,0x12e160 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 d0 e2 12 00 mov 0x12e2d0,%eax <== NOT EXECUTED 10c72d: 40 inc %eax <== NOT EXECUTED 10c72e: a3 d0 e2 12 00 mov %eax,0x12e2d0 <== NOT EXECUTED RTEMS_COMPILER_MEMORY_BARRIER(); 10c733: a1 60 e1 12 00 mov 0x12e160,%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 bf 12 00 mov 0x12bf20,%eax 10c749: ff 70 08 pushl 0x8(%eax) 10c74c: e8 33 c1 00 00 call 118884 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 bf 12 00 mov 0x12bf20,%eax 10c774: ff 70 0c pushl 0xc(%eax) 10c777: e8 88 1e 01 00 call 11e604 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 34 cd 00 00 call 1194cc 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 6a 12 00 push $0x126a69 10c7ab: a1 20 bf 12 00 mov 0x12bf20,%eax 10c7b0: ff 70 0c pushl 0xc(%eax) 10c7b3: e8 c0 c4 00 00 call 118c78 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 5d 12 00 push $0x125d22 10c7c5: a1 20 bf 12 00 mov 0x12bf20,%eax 10c7ca: ff 70 0c pushl 0xc(%eax) 10c7cd: e8 a6 c4 00 00 call 118c78 10c7d2: 8d 34 30 lea (%eax,%esi,1),%esi (void) fflush(stderr); 10c7d5: 58 pop %eax 10c7d6: a1 20 bf 12 00 mov 0x12bf20,%eax 10c7db: ff 70 0c pushl 0xc(%eax) 10c7de: e8 a1 c0 00 00 call 118884 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 6a 12 00 push $0x126a4e 10c810: a1 20 bf 12 00 mov 0x12bf20,%eax 10c815: ff 70 0c pushl 0xc(%eax) 10c818: e8 5b c4 00 00 call 118c78 #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 bf bc 00 00 call 1184ec <__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 8f cc 00 00 call 1194cc 10c83d: 83 c4 0c add $0xc,%esp 10c840: 50 push %eax 10c841: 68 5c 6a 12 00 push $0x126a5c 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 b4 6c 12 00 mov 0x126cb4,%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 c0 6c 12 00 pushl 0x126cc0 <== NOT EXECUTED 108734: e8 17 ce 00 00 call 115550 <__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 c0 6c 12 00 pushl 0x126cc0 1087dd: e8 6e cd 00 00 call 115550 <__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 d4 81 00 00 call 114024 <__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 7c 45 12 00 movzbl 0x12457c,%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 9c 81 00 00 call 114024 <__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 20 88 12 00 pushl 0x128820 10bebd: e8 92 35 00 00 call 10f454 <_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 46 81 00 00 call 114024 <__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 34 81 00 00 call 114024 <__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 40 d6 12 00 push $0x12d640 10e618: e8 c7 21 00 00 call 1107e4 <_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 30 90 00 00 call 11765c <__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 1c 64 00 00 call 114a64 <_POSIX_Semaphore_Delete> _Thread_Enable_dispatch(); 10e648: e8 cb 2c 00 00 call 111318 <_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 40 d6 12 00 push $0x12d640 10e668: e8 77 21 00 00 call 1107e4 <_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 e0 8f 00 00 call 11765c <__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 c9 63 00 00 call 114a64 <_POSIX_Semaphore_Delete> _Thread_Enable_dispatch(); 10e69b: e8 78 2c 00 00 call 111318 <_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 6b 2c 00 00 call 111318 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EINVAL ); 10e6ad: e8 aa 8f 00 00 call 11765c <__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 40 d6 12 00 push $0x12d640 10e6d4: e8 0b 21 00 00 call 1107e4 <_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 74 8f 00 00 call 11765c <__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 13 2c 00 00 call 111318 <_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 f0 d2 12 00 mov 0x12d2f0,%eax 10e765: 40 inc %eax 10e766: a3 f0 d2 12 00 mov %eax,0x12d2f0 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 26 63 00 00 call 114ab4 <_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 73 2b 00 00 call 111318 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one_cast( status, sem_t * ); 10e7a5: e8 b2 8e 00 00 call 11765c <__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 40 d6 12 00 push $0x12d640 10e7d8: e8 07 20 00 00 call 1107e4 <_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 30 2b 00 00 call 111318 <_Thread_Enable_dispatch> _Thread_Enable_dispatch(); 10e7e8: e8 2b 2b 00 00 call 111318 <_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 3d 61 00 00 call 114958 <_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 f6 2a 00 00 call 111318 <_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 e3 2a 00 00 call 111318 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * ); 10e835: e8 22 8e 00 00 call 11765c <__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 40 d6 12 00 push $0x12d640 10e85c: e8 83 1f 00 00 call 1107e4 <_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 ec 8d 00 00 call 11765c <__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 65 15 00 00 call 10fdf4 <_CORE_semaphore_Surrender> NULL /* XXX need to define a routine to handle this case */ #else NULL #endif ); _Thread_Enable_dispatch(); 10e88f: e8 84 2a 00 00 call 111318 <_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 36 55 00 00 call 113de8 <_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 5a 62 00 00 call 114b20 <_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 44 62 00 00 call 114b20 <_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 21 87 00 00 call 113a34 <__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 0f 87 00 00 call 113a34 <__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 fb 86 00 00 call 113a34 <__errno> 10b339: c7 00 0e 00 00 00 movl $0xe,(%eax) 10b33f: eb d8 jmp 10b319 =============================================================================== 0010bd50 : int sigaction( int sig, const struct sigaction *act, struct sigaction *oact ) { 10bd50: 55 push %ebp 10bd51: 89 e5 mov %esp,%ebp 10bd53: 57 push %edi 10bd54: 56 push %esi 10bd55: 53 push %ebx 10bd56: 83 ec 1c sub $0x1c,%esp 10bd59: 8b 5d 08 mov 0x8(%ebp),%ebx 10bd5c: 8b 45 0c mov 0xc(%ebp),%eax 10bd5f: 8b 55 10 mov 0x10(%ebp),%edx ISR_Level level; if ( oact ) 10bd62: 85 d2 test %edx,%edx 10bd64: 74 13 je 10bd79 *oact = _POSIX_signals_Vectors[ sig ]; 10bd66: 8d 0c 5b lea (%ebx,%ebx,2),%ecx 10bd69: 8d 34 8d e0 8b 12 00 lea 0x128be0(,%ecx,4),%esi 10bd70: b9 03 00 00 00 mov $0x3,%ecx 10bd75: 89 d7 mov %edx,%edi 10bd77: f3 a5 rep movsl %ds:(%esi),%es:(%edi) if ( !sig ) 10bd79: 85 db test %ebx,%ebx 10bd7b: 74 77 je 10bdf4 static inline bool is_valid_signo( int signo ) { return ((signo) >= 1 && (signo) <= 32 ); 10bd7d: 8d 53 ff lea -0x1(%ebx),%edx rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 10bd80: 83 fa 1f cmp $0x1f,%edx 10bd83: 77 6f ja 10bdf4 * * NOTE: Solaris documentation claims to "silently enforce" this which * contradicts the POSIX specification. */ if ( sig == SIGKILL ) 10bd85: 83 fb 09 cmp $0x9,%ebx 10bd88: 74 6a je 10bdf4 /* * Evaluate the new action structure and set the global signal vector * appropriately. */ if ( act ) { 10bd8a: 85 c0 test %eax,%eax 10bd8c: 74 62 je 10bdf0 <== 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 ); 10bd8e: 9c pushf 10bd8f: fa cli 10bd90: 8f 45 e4 popl -0x1c(%ebp) if ( act->sa_handler == SIG_DFL ) { 10bd93: 8b 50 08 mov 0x8(%eax),%edx 10bd96: 85 d2 test %edx,%edx 10bd98: 74 36 je 10bdd0 _POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ]; } else { _POSIX_signals_Clear_process_signals( sig ); 10bd9a: 83 ec 0c sub $0xc,%esp 10bd9d: 53 push %ebx 10bd9e: 89 45 e0 mov %eax,-0x20(%ebp) 10bda1: e8 96 57 00 00 call 11153c <_POSIX_signals_Clear_process_signals> _POSIX_signals_Vectors[ sig ] = *act; 10bda6: 8d 14 5b lea (%ebx,%ebx,2),%edx 10bda9: 8d 14 95 e0 8b 12 00 lea 0x128be0(,%edx,4),%edx 10bdb0: b9 03 00 00 00 mov $0x3,%ecx 10bdb5: 8b 45 e0 mov -0x20(%ebp),%eax 10bdb8: 89 d7 mov %edx,%edi 10bdba: 89 c6 mov %eax,%esi 10bdbc: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 10bdbe: 83 c4 10 add $0x10,%esp } _ISR_Enable( level ); 10bdc1: ff 75 e4 pushl -0x1c(%ebp) 10bdc4: 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; 10bdc5: 31 c0 xor %eax,%eax } 10bdc7: 8d 65 f4 lea -0xc(%ebp),%esp 10bdca: 5b pop %ebx 10bdcb: 5e pop %esi 10bdcc: 5f pop %edi 10bdcd: c9 leave 10bdce: c3 ret 10bdcf: 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 ]; 10bdd0: 8d 34 5b lea (%ebx,%ebx,2),%esi 10bdd3: c1 e6 02 shl $0x2,%esi 10bdd6: 8d 86 e0 8b 12 00 lea 0x128be0(%esi),%eax 10bddc: 81 c6 20 30 12 00 add $0x123020,%esi 10bde2: b9 03 00 00 00 mov $0x3,%ecx 10bde7: 89 c7 mov %eax,%edi 10bde9: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 10bdeb: eb d4 jmp 10bdc1 10bded: 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; 10bdf0: 31 c0 xor %eax,%eax 10bdf2: eb d3 jmp 10bdc7 <== 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 ); 10bdf4: e8 27 85 00 00 call 114320 <__errno> 10bdf9: c7 00 16 00 00 00 movl $0x16,(%eax) 10bdff: b8 ff ff ff ff mov $0xffffffff,%eax 10be04: eb c1 jmp 10bdc7 =============================================================================== 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 19 36 00 00 call 10f764 <_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 6d 36 00 00 call 10f7cc <_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 38 a2 12 00 mov 0x12a238,%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 a8 a4 12 00 mov 0x12a4a8,%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 50 9c 12 00 mov 0x129c50,%esi 10c1b2: 46 inc %esi 10c1b3: 89 35 50 9c 12 00 mov %esi,0x129c50 _Thread_Disable_dispatch(); the_thread->Wait.queue = &_POSIX_signals_Wait_queue; 10c1b9: c7 41 44 40 a4 12 00 movl $0x12a440,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 70 a4 12 00 01 movl $0x1,0x12a470 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 48 f4 10 00 push $0x10f448 10c1e3: 50 push %eax 10c1e4: 68 40 a4 12 00 push $0x12a440 10c1e9: 89 55 cc mov %edx,-0x34(%ebp) 10c1ec: e8 2b 2f 00 00 call 10f11c <_Thread_queue_Enqueue_with_handler> _Thread_Enable_dispatch(); 10c1f1: e8 4a 2a 00 00 call 10ec40 <_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 1d 5a 00 00 call 111c28 <_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 38 a2 12 00 mov 0x12a238,%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 <== NEVER TAKEN 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 ca 59 00 00 call 111c28 <_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 72 59 00 00 call 111c28 <_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 87 86 00 00 call 114964 <__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 6f 86 00 00 call 114964 <__errno> 10c2f5: 8b 15 38 a2 12 00 mov 0x12a238,%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 5b 81 00 00 call 116124 <__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 ff 87 00 00 call 111748 <__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 <== NOT EXECUTED 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 97 12 00 mov 0x129778,%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 9b b1 00 00 call 11539c <_fwalk> _Thread_Executing->libc_reent = current_reent; 10a201: a1 78 97 12 00 mov 0x129778,%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 fe a5 00 00 call 114e8c <__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 d9 71 00 00 call 111a84 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 ba 71 00 00 jmp 111a84 =============================================================================== 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 90 98 12 00 mov 0x129890,%eax 10b547: 40 inc %eax 10b548: a3 90 98 12 00 mov %eax,0x129890 * 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 9c 12 00 push $0x129c20 10b555: e8 9e 1e 00 00 call 10d3f8 <_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 9e 12 00 mov 0x129e78,%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 9c 12 00 mov 0x129c3c,%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 7e 2d 00 00 call 10e364 <_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 d3 8a 00 00 call 1140c8 <__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 58 2d 00 00 call 10e364 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EAGAIN ); 10b60c: e8 b7 8a 00 00 call 1140c8 <__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 9b 12 00 push $0x129b00 10ba57: e8 a4 21 00 00 call 10dc00 <_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 6b 8d 00 00 call 1147d8 <__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 9b 12 00 push $0x129b00 10ba89: e8 36 1d 00 00 call 10d7c4 <_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 43 3c 00 00 call 10f6e0 <_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 9b 12 00 push $0x129b00 10baa5: e8 16 20 00 00 call 10dac0 <_Objects_Free> _POSIX_Timer_Free( ptimer ); _Thread_Enable_dispatch(); 10baaa: e8 05 2c 00 00 call 10e6b4 <_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 c0 b1 12 00 push $0x12b1c0 10c913: e8 2c 21 00 00 call 10ea44 <_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 31 89 00 00 call 115258 <__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 ad 2b 00 00 call 10f4f8 <_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 01 17 00 00 call 10e070 <_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 c0 b1 12 00 push $0x12b1c0 10c97e: e8 c1 20 00 00 call 10ea44 <_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 a4 af 12 00 mov 0x12afa4,%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 73 36 00 00 call 11001c <_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 3f 2b 00 00 call 10f4f8 <_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 8b 88 00 00 call 115258 <__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 6c 38 00 00 call 10eeac <_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 58 38 00 00 call 10eeac <_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 9c 12 00 push $0x129c20 10b692: e8 19 22 00 00 call 10d8b0 <_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 4f 38 00 00 call 10ef14 <_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 3e 38 00 00 call 10ef14 <_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 3e 61 00 00 call 11182c <_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 ce 17 00 00 call 10cf00 <_TOD_Get> _Thread_Enable_dispatch(); 10b732: e8 2d 2c 00 00 call 10e364 <_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 a1 17 00 00 call 10cf00 <_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 1d 37 00 00 call 10ee88 <_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 59 37 00 00 call 10eed4 <_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 3f 89 00 00 call 1140c8 <__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 a1 3b 00 00 call 10f348 <_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 8c 2b 00 00 call 10e364 <_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 7b 2b 00 00 call 10e364 <_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 9c 8f 12 00 mov 0x128f9c,%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 80 8f 12 00 push $0x128f80 10b431: e8 72 3a 00 00 call 10eea8 <_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 70 35 00 00 call 10e9fc <_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 68 35 00 00 call 10e9fc <_Timespec_To_ticks> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10b494: a3 8c 8f 12 00 mov %eax,0x128f8c _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10b499: 58 pop %eax 10b49a: 5a pop %edx 10b49b: 68 80 8f 12 00 push $0x128f80 10b4a0: 68 9c 86 12 00 push $0x12869c 10b4a5: e8 be 38 00 00 call 10ed68 <_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 88 8f 12 00 00 movl $0x0,0x128f88 10b4bf: 00 00 00 the_watchdog->routine = routine; 10b4c2: c7 05 9c 8f 12 00 d4 movl $0x10b3d4,0x128f9c 10b4c9: b3 10 00 the_watchdog->id = id; 10b4cc: c7 05 a0 8f 12 00 00 movl $0x0,0x128fa0 10b4d3: 00 00 00 the_watchdog->user_data = user_data; 10b4d6: c7 05 a4 8f 12 00 00 movl $0x0,0x128fa4 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 94 8f 12 00 mov 0x128f94,%eax 10b4ed: 03 05 8c 8f 12 00 add 0x128f8c,%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 98 8f 12 00 sub 0x128f98,%eax /* remaining is now in ticks */ _Timespec_From_ticks( ticks, &tp ); 10b500: 50 push %eax 10b501: e8 6e 34 00 00 call 10e974 <_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 0f b4 00 00 call 1170d8 <__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 7d 12 00 mov 0x127d50,%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 48 a0 12 00 pushl 0x12a048 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 77 14 00 00 call 10d2b0 <_Chain_Extract> } static inline void rtems_libio_unlock( void ) { rtems_semaphore_release( rtems_libio_semaphore ); 10be39: 58 pop %eax 10be3a: ff 35 48 a0 12 00 pushl 0x12a048 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 ee 84 00 00 call 114364 <__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 d3 84 00 00 call 114364 <__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 ed 10 00 00 call 10cfb0 <== 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 7a c9 00 00 call 118900